fix lexicon intellisense build

deno.json

···
     "dev:cli": "deno run --allow-all packages/cli/src/mod.ts",
     "build:cli": "cd packages/cli && deno compile --allow-all --output bin/slices src/mod.ts",
     "build:lexicon": "cd packages/lexicon && deno task build",
+    "build:lexicon-intellisense": "cd ./packages/lexicon-rs && wasm-pack build --target web --features wasm && cp pkg/* ../lexicon-intellisense/wasm/",
     "codegen:cli": "deno task dev:cli codegen --lexicons ./lexicons --slice at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z --output ./packages/cli/src/generated_client.ts --include-slices",
     "codegen:frontend": "deno task dev:cli codegen --lexicons ./lexicons --slice at://did:plc:bcgltzqazw5tb6k2g3ttenbj/network.slices.slice/3lymhd4jhrd2z --output ./frontend/src/client.ts --include-slices",
     "dev:frontend": "cd frontend && deno task dev",
-    "build:lexicon-intellisense-wasm": "cd ./packages/lexicon-rs && wasm-pack build --target web --features wasm && cp pkg/* ../lexicon-intellisense/wasm/",
-    "build:lexicon-intellisense-lexicon": "deno bundle ./packages/lexicon/mod.ts -o ./packages/lexicon-intellisense/src/slices_lexicon.js",
     "test": "deno test --allow-all packages/*/tests/ packages/*/src/ frontend/src/",
     "check": "deno check packages/*/src/ packages/*/mod.ts packages/*/src/mod.ts frontend/src/**/*.ts frontend/src/**/*.tsx",
     "fmt": "deno fmt packages/ frontend/",

packages/lexicon-intellisense/package.json

···
 {
   "name": "lexicon-intellisense",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "VS Code IntelliSense support for AT Protocol lexicon JSON files",
   "main": "./out/extension.js",
   "license": "MIT",
···
     }
   },
   "scripts": {
-    "compile": "tsc -p ./",
+    "compile": "rm -rf ./out && tsc -p ./",
     "watch": "tsc -watch -p ./"
   },
   "devDependencies": {

packages/lexicon-intellisense/src/language-server.ts

···
   ServerOptions,
   TransportKind,
 } from "vscode-languageclient/node";
-// @ts-ignore - No declaration file for bundled module
 import {
   LexiconValidator,
   ValidationError,
   validate,
   validateWithDetails,
-// @ts-ignore
-} from "./slices_lexicon.js";
-
-// Type definitions for lexicon documents
-interface LexiconDoc {
-  id: string;
-  defs: Record<string, unknown>;
-  lexicon?: number;
-}
+  type LexiconDoc,
+} from "./lexicon";
 
 export class LexiconLanguageServer {
   private client: LanguageClient | undefined;
···
         const lexicon = JSON.parse(content);
         console.log(lexicon.id, "loaded from", filePath);
         if (lexicon.id && lexicon.defs) {
-          lexicons.push(lexicon as LexiconDoc);
+          lexicons.push(lexicon);
           idToFileMap.set(lexicon.id, filePath);
         }
       } catch (error) {
···
         // Attribute errors to specific files
         if (errorsByLexiconId) {
           for (const [lexiconId, errors] of Object.entries(errorsByLexiconId)) {
-          const filePath = idToFileMap.get(lexiconId);
-          if (filePath) {
-            const uri = vscode.Uri.file(filePath);
-            const existingDiagnostics =
-              this.diagnosticCollection.get(uri) || [];
-            const diagnostics = [...existingDiagnostics];
+            const filePath = idToFileMap.get(lexiconId);
+            if (filePath) {
+              const uri = vscode.Uri.file(filePath);
+              const existingDiagnostics =
+                this.diagnosticCollection.get(uri) || [];
+              const diagnostics = [...existingDiagnostics];
 
-            // Add each error as a diagnostic
-            for (const error of errors as string[]) {
-              diagnostics.push(
-                this.createDiagnostic(
-                  new vscode.Range(0, 0, 0, 0),
-                  error,
-                  vscode.DiagnosticSeverity.Error
-                )
-              );
+              // Add each error as a diagnostic
+              for (const error of errors as string[]) {
+                diagnostics.push(
+                  this.createDiagnostic(
+                    new vscode.Range(0, 0, 0, 0),
+                    error,
+                    vscode.DiagnosticSeverity.Error
+                  )
+                );
+              }
+
+              this.diagnosticCollection.set(uri, diagnostics);
             }
-
-            this.diagnosticCollection.set(uri, diagnostics);
-          }
           }
         }
 
-        const totalErrors = errorsByLexiconId ? Object.values(errorsByLexiconId).reduce(
-          (sum: number, errors) => sum + (errors as string[]).length,
-          0
-        ) : 0;
+        const totalErrors = errorsByLexiconId
+          ? Object.values(errorsByLexiconId).reduce(
+              (sum: number, errors) => sum + (errors as string[]).length,
+              0
+            )
+          : 0;
         if (totalErrors === 0) {
           console.log(
             `Successfully validated ${lexicons.length} lexicon files`
           );
         } else {
+          const errorCount = errorsByLexiconId ? Object.keys(errorsByLexiconId).length : 0;
           console.log(
-            `Validation found ${totalErrors} errors across ${errorsByLexiconId.size} lexicons`
+            `Validation found ${totalErrors} errors across ${errorCount} lexicons`
           );
         }
       } catch (error) {

packages/lexicon-intellisense/src/lexicon.ts

···
+/**
+ * AT Protocol Lexicon Validation Library
+ *
+ * Core implementation for comprehensive validation of AT Protocol lexicon documents and data records.
+ * Built on WebAssembly for high performance validation with full AT Protocol compliance.
+ */
+
+import init, {
+  WasmLexiconValidator,
+  validate_string_format,
+  is_valid_nsid,
+  validate_lexicons_and_get_errors,
+} from "../wasm/slices_lexicon.js";
+
+// ============================================================================
+// Module Initialization
+// ============================================================================
+
+/** Global WASM initialization state */
+let wasmInitialized = false;
+let wasmInitPromise: Promise<void> | null = null;
+
+/**
+ * Ensures the WebAssembly module is properly initialized before use.
+ * This is called automatically by all public methods.
+ *
+ * @internal
+ */
+export async function ensureWasmInit(): Promise<void> {
+  if (!wasmInitialized) {
+    if (!wasmInitPromise) {
+      wasmInitPromise = (async () => {
+        // Try to load WASM file - works in both Node.js and browser contexts
+        try {
+          // In Node.js (VS Code extension), use fs to load the file
+          if (typeof process !== 'undefined' && process.versions && process.versions.node) {
+            const fs = require('fs');
+            const path = require('path');
+
+            // Use __dirname which is available in CommonJS
+            const wasmPath = path.join(__dirname, '../wasm/slices_lexicon_bg.wasm');
+            const wasmBuffer = fs.readFileSync(wasmPath);
+            await init({ module_or_path: wasmBuffer });
+          } else {
+            // In browser, fetch the WASM file
+            const wasmPath = '../wasm/slices_lexicon_bg.wasm';
+            const response = await fetch(wasmPath);
+            const wasmBuffer = await response.arrayBuffer();
+            await init({ module_or_path: wasmBuffer });
+          }
+          wasmInitialized = true;
+        } catch (error) {
+          wasmInitPromise = null; // Reset so we can retry
+          throw error;
+        }
+      })();
+    }
+    await wasmInitPromise;
+  }
+}
+
+// ============================================================================
+// Types and Interfaces
+// ============================================================================
+
+/**
+ * Custom error class for lexicon validation failures.
+ * Extends the native Error class with validation-specific context.
+ */
+export class ValidationError extends Error {
+  /**
+   * Creates a new ValidationError instance.
+   *
+   * @param message - Human-readable error description
+   */
+  constructor(message: string) {
+    super(message);
+    this.name = "ValidationError";
+  }
+}
+
+/**
+ * Represents a complete AT Protocol lexicon document.
+ * Contains schema definitions and metadata for a specific collection or service.
+ */
+export interface LexiconDoc {
+  /** Unique namespace identifier (NSID) for this lexicon */
+  id: string;
+
+  /** Schema definitions mapping definition names to their schemas */
+  defs: Record<string, LexiconDefinition>;
+
+  /** Lexicon format version (currently 1) */
+  lexicon?: number;
+}
+
+/**
+ * Base lexicon definition interface
+ */
+export interface LexiconDefinition {
+  type: string;
+  description?: string;
+  [key: string]: unknown; // Allow additional properties
+}
+
+/**
+ * String format types supported by AT Protocol
+ */
+export type StringFormat =
+  | "datetime"
+  | "uri"
+  | "at-uri"
+  | "did"
+  | "handle"
+  | "at-identifier"
+  | "nsid"
+  | "cid"
+  | "language"
+  | "tid"
+  | "record-key";
+
+/**
+ * Type alias for validation error results
+ */
+export type ValidationErrors = Record<string, string[]> | null;
+
+/**
+ * Comprehensive validation result with error details and statistics.
+ */
+export interface ValidationResult {
+  /** Whether all lexicons passed validation */
+  valid: boolean;
+
+  /** Map of lexicon IDs to their error messages */
+  errors: Record<string, string[]>;
+
+  /** Total count of all validation errors across all lexicons */
+  totalErrors: number;
+
+  /** Number of lexicons that have validation errors */
+  lexiconsWithErrors: number;
+}
+
+/**
+ * Detailed error context information for debugging validation failures.
+ */
+export interface ErrorContext {
+  /** Current path in the schema being validated */
+  path: string;
+
+  /** ID of the lexicon currently being validated */
+  current_lexicon: string | null;
+
+  /** Whether a circular reference was detected */
+  has_circular_reference: boolean;
+
+  /** Stack of references being resolved (for circular detection) */
+  reference_stack: string[];
+}
+
+// ============================================================================
+// Core Validator Class
+// ============================================================================
+
+/**
+ * High-performance AT Protocol lexicon validator with resource management.
+ *
+ * Provides comprehensive validation capabilities including:
+ * - Schema structure validation
+ * - Cross-reference resolution
+ * - Data format validation
+ * - Circular dependency detection
+ *
+ * Implements Disposable for automatic resource cleanup.
+ */
+export class LexiconValidator implements Disposable {
+  private wasmValidator: WasmLexiconValidator;
+
+  /**
+   * Creates a new validator instance with the provided lexicon documents.
+   *
+   * Note: Prefer using the static `create()` method for async initialization.
+   *
+   * @param lexicons - Array of lexicon documents to validate
+   */
+  constructor(lexicons: LexiconDoc[]) {
+    const lexiconsJson = JSON.stringify(lexicons);
+    this.wasmValidator = new WasmLexiconValidator(lexiconsJson);
+  }
+
+  /**
+   * Creates a new validator instance with proper async initialization.
+   * Ensures WASM module is loaded before creating the validator.
+   *
+   * @param lexicons - Array of lexicon documents to validate
+   * @returns Promise resolving to a new validator instance
+   *
+   * @example
+   * ```typescript
+   * const lexicons = [{ id: "com.example.post", defs: {...} }];
+   * const validator = await LexiconValidator.create(lexicons);
+   * ```
+   */
+  static async create(lexicons: LexiconDoc[]): Promise<LexiconValidator> {
+    await ensureWasmInit();
+    return new LexiconValidator(lexicons);
+  }
+
+  /**
+   * Validates a data record against its collection's lexicon schema.
+   *
+   * Performs comprehensive validation including:
+   * - Type checking
+   * - Constraint validation
+   * - Format validation
+   * - Required field checking
+   *
+   * @param collection - NSID of the collection (lexicon) to validate against
+   * @param record - Data record to validate
+   * @throws {ValidationError} If validation fails
+   *
+   * @example
+   * ```typescript
+   * validator.validateRecord("com.example.post", {
+   *   text: "Hello world!",
+   *   createdAt: "2024-01-01T12:00:00Z"
+   * });
+   * ```
+   */
+  validateRecord(collection: string, record: Record<string, unknown>): void {
+    try {
+      const recordJson = JSON.stringify(record);
+      this.wasmValidator.validate_record(collection, recordJson);
+    } catch (error) {
+      throw new ValidationError(
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+
+  /**
+   * Validates all lexicon documents and returns comprehensive error information.
+   *
+   * Uses the enhanced validation system that collects ALL errors for each lexicon,
+   * not just the first error encountered.
+   *
+   * @returns Null if validation passes, or error map if validation fails
+   *
+   * @example
+   * ```typescript
+   * const errors = validator.validateLexicons();
+   * if (errors) {
+   *   console.log(`Found errors in ${Object.keys(errors).length} lexicons`);
+   * }
+   * ```
+   */
+  validateLexicons(): Record<string, string[]> | null {
+    try {
+      const result = this.wasmValidator.validate_lexicons();
+      const errorMap = JSON.parse(result);
+
+      // Return null for success case (no errors)
+      if (Object.keys(errorMap).length === 0) {
+        return null;
+      }
+
+      return errorMap;
+    } catch (error) {
+      throw new ValidationError(
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+
+  /**
+   * Checks for unresolved references across the lexicon set.
+   *
+   * Identifies references (like "$ref": "com.example.collection#definition")
+   * that point to non-existent lexicons or definitions.
+   *
+   * @returns Array of unresolved reference strings
+   *
+   * @example
+   * ```typescript
+   * const unresolved = validator.checkReferences();
+   * if (unresolved.length > 0) {
+   *   console.log("Unresolved references:", unresolved);
+   * }
+   * ```
+   */
+  checkReferences(): string[] {
+    try {
+      const result = this.wasmValidator.check_references();
+      return JSON.parse(result);
+    } catch (error) {
+      throw new ValidationError(
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+
+  /**
+   * Retrieves detailed error context for debugging validation failures.
+   *
+   * Provides path information, current lexicon context, and circular
+   * reference detection state for enhanced debugging.
+   *
+   * @param path - Schema path to get context for
+   * @returns Detailed error context information
+   *
+   * @example
+   * ```typescript
+   * const context = validator.getErrorContext("com.example.post#main");
+   * console.log(`Validating at path: ${context.path}`);
+   * ```
+   */
+  getErrorContext(path: string): ErrorContext {
+    try {
+      const result = this.wasmValidator.get_error_context(path);
+      return JSON.parse(result);
+    } catch (error) {
+      throw new ValidationError(
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+
+  /**
+   * Manually releases WASM resources.
+   *
+   * Call this when done with the validator to free memory.
+   * Automatically called by dispose methods when using `using` syntax.
+   */
+  free(): void {
+    this.wasmValidator.free();
+  }
+
+  /**
+   * Synchronous dispose method for automatic resource cleanup.
+   * Called automatically when using `using` keyword.
+   *
+   * @example
+   * ```typescript
+   * using validator = await LexiconValidator.create(lexicons);
+   * // Automatically cleaned up at end of scope
+   * ```
+   */
+  [Symbol.dispose](): void {
+    this.free();
+  }
+
+  /**
+   * Asynchronous dispose method for automatic resource cleanup.
+   * Called automatically when using `await using` keyword.
+   */
+  async [Symbol.asyncDispose](): Promise<void> {
+    await Promise.resolve(this.free());
+  }
+}
+
+// ============================================================================
+// Standalone Validation Functions
+// ============================================================================
+
+/**
+ * Validates lexicon documents using the enhanced validation system.
+ *
+ * This is the primary validation function that collects ALL validation errors
+ * for each lexicon, enabling comprehensive error reporting.
+ *
+ * @param lexicons - Array of lexicon documents to validate
+ * @returns Null if validation succeeds, or error map if validation fails
+ *
+ * @example
+ * ```typescript
+ * const errors = await validate([
+ *   { id: "com.example.post", defs: {...} },
+ *   { id: "com.example.user", defs: {...} }
+ * ]);
+ *
+ * if (errors) {
+ *   for (const [lexiconId, errorList] of Object.entries(errors)) {
+ *     console.log(`${lexiconId}: ${errorList.length} errors`);
+ *   }
+ * }
+ * ```
+ */
+export async function validate(
+  lexicons: LexiconDoc[]
+): Promise<Record<string, string[]> | null> {
+  await ensureWasmInit();
+
+  const lexiconsJson = JSON.stringify(lexicons);
+  const result = validate_lexicons_and_get_errors(lexiconsJson);
+  const errorMap = JSON.parse(result);
+
+  // Success case: no errors found
+  if (Object.keys(errorMap).length === 0) {
+    return null;
+  }
+
+  // Return complete error map with all errors for each lexicon
+  return errorMap;
+}
+
+/**
+ * Enhanced validation function with comprehensive result statistics.
+ *
+ * Provides detailed validation results including error counts and statistics
+ * for better reporting and debugging.
+ *
+ * @param lexicons - Array of lexicon documents to validate
+ * @returns Detailed validation result with statistics
+ *
+ * @example
+ * ```typescript
+ * const result = await validateWithDetails(lexicons);
+ * console.log(`Validation ${result.valid ? 'passed' : 'failed'}`);
+ * console.log(`Total errors: ${result.totalErrors}`);
+ * console.log(`Lexicons with errors: ${result.lexiconsWithErrors}`);
+ * ```
+ */
+export async function validateWithDetails(
+  lexicons: LexiconDoc[]
+): Promise<ValidationResult> {
+  const errors = await validate(lexicons);
+
+  if (errors === null) {
+    return {
+      valid: true,
+      errors: {},
+      totalErrors: 0,
+      lexiconsWithErrors: 0,
+    };
+  }
+
+  const totalErrors = Object.values(errors).reduce(
+    (sum, errorArray) => sum + errorArray.length,
+    0
+  );
+
+  return {
+    valid: false,
+    errors,
+    totalErrors,
+    lexiconsWithErrors: Object.keys(errors).length,
+  };
+}
+
+/**
+ * Validates a single data record against lexicon schemas.
+ *
+ * Convenience function that creates a temporary validator instance
+ * and automatically manages resources.
+ *
+ * @param lexicons - Array of lexicon documents containing the target schema
+ * @param collection - NSID of the collection to validate against
+ * @param record - Data record to validate
+ * @throws {ValidationError} If validation fails
+ *
+ * @example
+ * ```typescript
+ * await validateRecord(lexicons, "com.example.post", {
+ *   text: "Hello world!",
+ *   createdAt: "2024-01-01T12:00:00Z"
+ * });
+ * ```
+ */
+export async function validateRecord(
+  lexicons: LexiconDoc[],
+  collection: string,
+  record: Record<string, unknown>
+): Promise<void> {
+  return await withValidator(lexicons, (validator) => {
+    validator.validateRecord(collection, record);
+  });
+}
+
+// ============================================================================
+// Format and Utility Functions
+// ============================================================================
+
+/**
+ * Validates a string value against a specific AT Protocol format.
+ *
+ * Supports all AT Protocol string formats including:
+ * - datetime (RFC 3339)
+ * - uri, at-uri
+ * - did, handle
+ * - cid, tid
+ * - language (BCP 47)
+ *
+ * @param value - String value to validate
+ * @param format - AT Protocol format name
+ * @throws {ValidationError} If format validation fails
+ *
+ * @example
+ * ```typescript
+ * await validateStringFormat("2024-01-01T12:00:00Z", "datetime");
+ * await validateStringFormat("did:plc:example123", "did");
+ * ```
+ */
+export async function validateStringFormat(
+  value: string,
+  format: string
+): Promise<void> {
+  await ensureWasmInit();
+  try {
+    validate_string_format(value, format);
+  } catch (error) {
+    throw new ValidationError(
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+
+/**
+ * Checks if a string is a valid NSID (Namespaced Identifier).
+ *
+ * NSIDs are used throughout AT Protocol to identify lexicons, collections,
+ * and procedures. They follow reverse-domain-name format with at least
+ * 3 segments (e.g., "com.example.collection").
+ *
+ * @param nsid - String to validate as NSID
+ * @returns True if valid NSID, false otherwise
+ *
+ * @example
+ * ```typescript
+ * console.log(await isValidNsid("com.example.post")); // true
+ * console.log(await isValidNsid("invalid-nsid"));     // false
+ * ```
+ */
+export async function isValidNsid(nsid: string): Promise<boolean> {
+  await ensureWasmInit();
+  return is_valid_nsid(nsid);
+}
+
+// ============================================================================
+// Resource Management Utilities
+// ============================================================================
+
+/**
+ * Utility function for automatic validator lifecycle management.
+ *
+ * Uses the callback pattern to ensure WASM resources are properly
+ * cleaned up, even if an exception occurs during validation.
+ *
+ * @param lexicons - Array of lexicon documents
+ * @param callback - Function to execute with the validator
+ * @returns Promise resolving to the callback's return value
+ *
+ * @example
+ * ```typescript
+ * const result = await withValidator(lexicons, (validator) => {
+ *   validator.validateRecord("com.example.post", record);
+ *   return "validation passed";
+ * });
+ * ```
+ */
+export async function withValidator<T>(
+  lexicons: LexiconDoc[],
+  callback: (validator: LexiconValidator) => T | Promise<T>
+): Promise<T> {
+  const validator = await LexiconValidator.create(lexicons);
+  try {
+    return await callback(validator);
+  } finally {
+    validator.free();
+  }
+}

packages/lexicon-intellisense/src/slices_lexicon.js

···
-// packages/lexicon/wasm/slices_lexicon.js
-var wasm;
-var cachedUint8ArrayMemory0 = null;
-function getUint8ArrayMemory0() {
-  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-  }
-  return cachedUint8ArrayMemory0;
-}
-var cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", {
-  ignoreBOM: true,
-  fatal: true
-}) : {
-  decode: () => {
-    throw Error("TextDecoder not available");
-  }
-};
-if (typeof TextDecoder !== "undefined") {
-  cachedTextDecoder.decode();
-}
-var MAX_SAFARI_DECODE_BYTES = 2146435072;
-var numBytesDecoded = 0;
-function decodeText(ptr, len) {
-  numBytesDecoded += len;
-  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-    cachedTextDecoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf-8", {
-      ignoreBOM: true,
-      fatal: true
-    }) : {
-      decode: () => {
-        throw Error("TextDecoder not available");
-      }
-    };
-    cachedTextDecoder.decode();
-    numBytesDecoded = len;
-  }
-  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
-}
-function getStringFromWasm0(ptr, len) {
-  ptr = ptr >>> 0;
-  return decodeText(ptr, len);
-}
-var WASM_VECTOR_LEN = 0;
-var cachedTextEncoder = typeof TextEncoder !== "undefined" ? new TextEncoder("utf-8") : {
-  encode: () => {
-    throw Error("TextEncoder not available");
-  }
-};
-var encodeString = typeof cachedTextEncoder.encodeInto === "function" ? function(arg, view) {
-  return cachedTextEncoder.encodeInto(arg, view);
-} : function(arg, view) {
-  const buf = cachedTextEncoder.encode(arg);
-  view.set(buf);
-  return {
-    read: arg.length,
-    written: buf.length
-  };
-};
-function passStringToWasm0(arg, malloc, realloc) {
-  if (realloc === void 0) {
-    const buf = cachedTextEncoder.encode(arg);
-    const ptr2 = malloc(buf.length, 1) >>> 0;
-    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
-    WASM_VECTOR_LEN = buf.length;
-    return ptr2;
-  }
-  let len = arg.length;
-  let ptr = malloc(len, 1) >>> 0;
-  const mem = getUint8ArrayMemory0();
-  let offset = 0;
-  for (; offset < len; offset++) {
-    const code = arg.charCodeAt(offset);
-    if (code > 127) break;
-    mem[ptr + offset] = code;
-  }
-  if (offset !== len) {
-    if (offset !== 0) {
-      arg = arg.slice(offset);
-    }
-    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-    const ret = encodeString(arg, view);
-    offset += ret.written;
-    ptr = realloc(ptr, len, offset, 1) >>> 0;
-  }
-  WASM_VECTOR_LEN = offset;
-  return ptr;
-}
-var cachedDataViewMemory0 = null;
-function getDataViewMemory0() {
-  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
-    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-  }
-  return cachedDataViewMemory0;
-}
-function takeFromExternrefTable0(idx) {
-  const value = wasm.__wbindgen_export_3.get(idx);
-  wasm.__externref_table_dealloc(idx);
-  return value;
-}
-function validate_lexicons_and_get_errors(lexicons_json) {
-  let deferred2_0;
-  let deferred2_1;
-  try {
-    const ptr0 = passStringToWasm0(lexicons_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.validate_lexicons_and_get_errors(ptr0, len0);
-    deferred2_0 = ret[0];
-    deferred2_1 = ret[1];
-    return getStringFromWasm0(ret[0], ret[1]);
-  } finally {
-    wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
-  }
-}
-function validate_string_format(value, format) {
-  const ptr0 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-  const len0 = WASM_VECTOR_LEN;
-  const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-  const len1 = WASM_VECTOR_LEN;
-  const ret = wasm.validate_string_format(ptr0, len0, ptr1, len1);
-  if (ret[1]) {
-    throw takeFromExternrefTable0(ret[0]);
-  }
-}
-function is_valid_nsid(nsid) {
-  const ptr0 = passStringToWasm0(nsid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-  const len0 = WASM_VECTOR_LEN;
-  const ret = wasm.is_valid_nsid(ptr0, len0);
-  return ret !== 0;
-}
-var WasmLexiconValidatorFinalization = typeof FinalizationRegistry === "undefined" ? {
-  register: () => {
-  },
-  unregister: () => {
-  }
-} : new FinalizationRegistry((ptr) => wasm.__wbg_wasmlexiconvalidator_free(ptr >>> 0, 1));
-var WasmLexiconValidator = class {
-  __destroy_into_raw() {
-    const ptr = this.__wbg_ptr;
-    this.__wbg_ptr = 0;
-    WasmLexiconValidatorFinalization.unregister(this);
-    return ptr;
-  }
-  free() {
-    const ptr = this.__destroy_into_raw();
-    wasm.__wbg_wasmlexiconvalidator_free(ptr, 0);
-  }
-  /**
-     * Create a new validator with the given lexicon documents
-     * Takes a JSON string containing an array of lexicon documents
-     * @param {string} lexicons_json
-     */
-  constructor(lexicons_json) {
-    const ptr0 = passStringToWasm0(lexicons_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.wasmlexiconvalidator_new(ptr0, len0);
-    if (ret[2]) {
-      throw takeFromExternrefTable0(ret[1]);
-    }
-    this.__wbg_ptr = ret[0] >>> 0;
-    WasmLexiconValidatorFinalization.register(this, this.__wbg_ptr, this);
-    return this;
-  }
-  /**
-     * Validate a record against its collection's lexicon
-     * Takes collection name and record as JSON strings
-     * @param {string} collection
-     * @param {string} record_json
-     */
-  validate_record(collection, record_json) {
-    const ptr0 = passStringToWasm0(collection, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(record_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.wasmlexiconvalidator_validate_record(this.__wbg_ptr, ptr0, len0, ptr1, len1);
-    if (ret[1]) {
-      throw takeFromExternrefTable0(ret[0]);
-    }
-  }
-  /**
-     * Validate lexicon documents and return detailed validation results
-     * Returns a JSON string containing validation results with enhanced error context
-     * @returns {string}
-     */
-  validate_lexicons() {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-      const ret = wasm.wasmlexiconvalidator_validate_lexicons(this.__wbg_ptr);
-      deferred1_0 = ret[0];
-      deferred1_1 = ret[1];
-      return getStringFromWasm0(ret[0], ret[1]);
-    } finally {
-      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-    }
-  }
-  /**
-     * Check if all references in the lexicon set can be resolved
-     * Returns a JSON string with any unresolved references
-     * @returns {string}
-     */
-  check_references() {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-      const ret = wasm.wasmlexiconvalidator_check_references(this.__wbg_ptr);
-      deferred1_0 = ret[0];
-      deferred1_1 = ret[1];
-      return getStringFromWasm0(ret[0], ret[1]);
-    } finally {
-      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-    }
-  }
-  /**
-     * Get detailed error context for validation failures
-     * Returns enhanced error information with path context
-     * @param {string} path
-     * @returns {string}
-     */
-  get_error_context(path) {
-    let deferred2_0;
-    let deferred2_1;
-    try {
-      const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-      const len0 = WASM_VECTOR_LEN;
-      const ret = wasm.wasmlexiconvalidator_get_error_context(this.__wbg_ptr, ptr0, len0);
-      deferred2_0 = ret[0];
-      deferred2_1 = ret[1];
-      return getStringFromWasm0(ret[0], ret[1]);
-    } finally {
-      wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
-    }
-  }
-};
-var EXPECTED_RESPONSE_TYPES = /* @__PURE__ */ new Set([
-  "basic",
-  "cors",
-  "default"
-]);
-async function __wbg_load(module, imports) {
-  if (typeof Response === "function" && module instanceof Response) {
-    if (typeof WebAssembly.instantiateStreaming === "function") {
-      try {
-        return await WebAssembly.instantiateStreaming(module, imports);
-      } catch (e) {
-        const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
-        if (validResponse && module.headers.get("Content-Type") !== "application/wasm") {
-          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
-        } else {
-          throw e;
-        }
-      }
-    }
-    const bytes = await module.arrayBuffer();
-    return await WebAssembly.instantiate(bytes, imports);
-  } else {
-    const instance = await WebAssembly.instantiate(module, imports);
-    if (instance instanceof WebAssembly.Instance) {
-      return {
-        instance,
-        module
-      };
-    } else {
-      return instance;
-    }
-  }
-}
-function __wbg_get_imports() {
-  const imports = {};
-  imports.wbg = {};
-  imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
-    let deferred0_0;
-    let deferred0_1;
-    try {
-      deferred0_0 = arg0;
-      deferred0_1 = arg1;
-      console.error(getStringFromWasm0(arg0, arg1));
-    } finally {
-      wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-    }
-  };
-  imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
-    const ret = new Error();
-    return ret;
-  };
-  imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
-    const ret = arg1.stack;
-    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-  };
-  imports.wbg.__wbg_wbindgenthrow_4c11a24fca429ccf = function(arg0, arg1) {
-    throw new Error(getStringFromWasm0(arg0, arg1));
-  };
-  imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
-    const ret = getStringFromWasm0(arg0, arg1);
-    return ret;
-  };
-  imports.wbg.__wbindgen_init_externref_table = function() {
-    const table = wasm.__wbindgen_export_3;
-    const offset = table.grow(4);
-    table.set(0, void 0);
-    table.set(offset + 0, void 0);
-    table.set(offset + 1, null);
-    table.set(offset + 2, true);
-    table.set(offset + 3, false);
-    ;
-  };
-  return imports;
-}
-function __wbg_init_memory(imports, memory) {
-}
-function __wbg_finalize_init(instance, module) {
-  wasm = instance.exports;
-  __wbg_init.__wbindgen_wasm_module = module;
-  cachedDataViewMemory0 = null;
-  cachedUint8ArrayMemory0 = null;
-  wasm.__wbindgen_start();
-  return wasm;
-}
-async function __wbg_init(module_or_path) {
-  if (wasm !== void 0) return wasm;
-  if (typeof module_or_path !== "undefined") {
-    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
-      ({ module_or_path } = module_or_path);
-    } else {
-      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
-    }
-  }
-  if (typeof module_or_path === "undefined") {
-    module_or_path = new URL("slices_lexicon_bg.wasm", import.meta.url);
-  }
-  const imports = __wbg_get_imports();
-  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
-    module_or_path = fetch(module_or_path);
-  }
-  __wbg_init_memory(imports);
-  const { instance, module } = await __wbg_load(await module_or_path, imports);
-  return __wbg_finalize_init(instance, module);
-}
-var slices_lexicon_default = __wbg_init;
-
-// packages/lexicon/lexicon.ts
-var _computedKey;
-var _computedKey1;
-var wasmInitialized = false;
-async function ensureWasmInit() {
-  if (!wasmInitialized) {
-    const wasmUrl = new URL("./wasm/slices_lexicon_bg.wasm", import.meta.url);
-    await slices_lexicon_default({
-      module_or_path: wasmUrl
-    });
-    wasmInitialized = true;
-  }
-}
-var ValidationError = class extends Error {
-  /**
-   * Creates a new ValidationError instance.
-   *
-   * @param message - Human-readable error description
-   */
-  constructor(message) {
-    super(message);
-    this.name = "ValidationError";
-  }
-};
-_computedKey = Symbol.dispose, _computedKey1 = Symbol.asyncDispose;
-var LexiconValidator = class _LexiconValidator {
-  wasmValidator;
-  /**
-   * Creates a new validator instance with the provided lexicon documents.
-   *
-   * Note: Prefer using the static `create()` method for async initialization.
-   *
-   * @param lexicons - Array of lexicon documents to validate
-   */
-  constructor(lexicons) {
-    const lexiconsJson = JSON.stringify(lexicons);
-    this.wasmValidator = new WasmLexiconValidator(lexiconsJson);
-  }
-  /**
-   * Creates a new validator instance with proper async initialization.
-   * Ensures WASM module is loaded before creating the validator.
-   *
-   * @param lexicons - Array of lexicon documents to validate
-   * @returns Promise resolving to a new validator instance
-   *
-   * @example
-   * ```typescript
-   * const lexicons = [{ id: "com.example.post", defs: {...} }];
-   * const validator = await LexiconValidator.create(lexicons);
-   * ```
-   */
-  static async create(lexicons) {
-    await ensureWasmInit();
-    return new _LexiconValidator(lexicons);
-  }
-  /**
-   * Validates a data record against its collection's lexicon schema.
-   *
-   * Performs comprehensive validation including:
-   * - Type checking
-   * - Constraint validation
-   * - Format validation
-   * - Required field checking
-   *
-   * @param collection - NSID of the collection (lexicon) to validate against
-   * @param record - Data record to validate
-   * @throws {ValidationError} If validation fails
-   *
-   * @example
-   * ```typescript
-   * validator.validateRecord("com.example.post", {
-   *   text: "Hello world!",
-   *   createdAt: "2024-01-01T12:00:00Z"
-   * });
-   * ```
-   */
-  validateRecord(collection, record) {
-    try {
-      const recordJson = JSON.stringify(record);
-      this.wasmValidator.validate_record(collection, recordJson);
-    } catch (error) {
-      throw new ValidationError(error instanceof Error ? error.message : String(error));
-    }
-  }
-  /**
-   * Validates all lexicon documents and returns comprehensive error information.
-   *
-   * Uses the enhanced validation system that collects ALL errors for each lexicon,
-   * not just the first error encountered.
-   *
-   * @returns Null if validation passes, or error map if validation fails
-   *
-   * @example
-   * ```typescript
-   * const errors = validator.validateLexicons();
-   * if (errors) {
-   *   console.log(`Found errors in ${Object.keys(errors).length} lexicons`);
-   * }
-   * ```
-   */
-  validateLexicons() {
-    try {
-      const result = this.wasmValidator.validate_lexicons();
-      const errorMap = JSON.parse(result);
-      if (Object.keys(errorMap).length === 0) {
-        return null;
-      }
-      return errorMap;
-    } catch (error) {
-      throw new ValidationError(error instanceof Error ? error.message : String(error));
-    }
-  }
-  /**
-   * Checks for unresolved references across the lexicon set.
-   *
-   * Identifies references (like "$ref": "com.example.collection#definition")
-   * that point to non-existent lexicons or definitions.
-   *
-   * @returns Array of unresolved reference strings
-   *
-   * @example
-   * ```typescript
-   * const unresolved = validator.checkReferences();
-   * if (unresolved.length > 0) {
-   *   console.log("Unresolved references:", unresolved);
-   * }
-   * ```
-   */
-  checkReferences() {
-    try {
-      const result = this.wasmValidator.check_references();
-      return JSON.parse(result);
-    } catch (error) {
-      throw new ValidationError(error instanceof Error ? error.message : String(error));
-    }
-  }
-  /**
-   * Retrieves detailed error context for debugging validation failures.
-   *
-   * Provides path information, current lexicon context, and circular
-   * reference detection state for enhanced debugging.
-   *
-   * @param path - Schema path to get context for
-   * @returns Detailed error context information
-   *
-   * @example
-   * ```typescript
-   * const context = validator.getErrorContext("com.example.post#main");
-   * console.log(`Validating at path: ${context.path}`);
-   * ```
-   */
-  getErrorContext(path) {
-    try {
-      const result = this.wasmValidator.get_error_context(path);
-      return JSON.parse(result);
-    } catch (error) {
-      throw new ValidationError(error instanceof Error ? error.message : String(error));
-    }
-  }
-  /**
-   * Manually releases WASM resources.
-   *
-   * Call this when done with the validator to free memory.
-   * Automatically called by dispose methods when using `using` syntax.
-   */
-  free() {
-    this.wasmValidator.free();
-  }
-  /**
-   * Synchronous dispose method for automatic resource cleanup.
-   * Called automatically when using `using` keyword.
-   *
-   * @example
-   * ```typescript
-   * using validator = await LexiconValidator.create(lexicons);
-   * // Automatically cleaned up at end of scope
-   * ```
-   */
-  [_computedKey]() {
-    this.free();
-  }
-  /**
-   * Asynchronous dispose method for automatic resource cleanup.
-   * Called automatically when using `await using` keyword.
-   */
-  async [_computedKey1]() {
-    await Promise.resolve(this.free());
-  }
-};
-async function validate(lexicons) {
-  await ensureWasmInit();
-  const lexiconsJson = JSON.stringify(lexicons);
-  const result = validate_lexicons_and_get_errors(lexiconsJson);
-  const errorMap = JSON.parse(result);
-  if (Object.keys(errorMap).length === 0) {
-    return null;
-  }
-  return errorMap;
-}
-async function validateWithDetails(lexicons) {
-  const errors = await validate(lexicons);
-  if (errors === null) {
-    return {
-      valid: true,
-      errors: {},
-      totalErrors: 0,
-      lexiconsWithErrors: 0
-    };
-  }
-  const totalErrors = Object.values(errors).reduce((sum, errorArray) => sum + errorArray.length, 0);
-  return {
-    valid: false,
-    errors,
-    totalErrors,
-    lexiconsWithErrors: Object.keys(errors).length
-  };
-}
-async function validateRecord(lexicons, collection, record) {
-  return await withValidator(lexicons, (validator) => {
-    validator.validateRecord(collection, record);
-  });
-}
-async function validateStringFormat(value, format) {
-  await ensureWasmInit();
-  try {
-    validate_string_format(value, format);
-  } catch (error) {
-    throw new ValidationError(error instanceof Error ? error.message : String(error));
-  }
-}
-async function isValidNsid(nsid) {
-  await ensureWasmInit();
-  return is_valid_nsid(nsid);
-}
-async function withValidator(lexicons, callback) {
-  const validator = await LexiconValidator.create(lexicons);
-  try {
-    return await callback(validator);
-  } finally {
-    validator.free();
-  }
-}
-export {
-  LexiconValidator,
-  ValidationError,
-  isValidNsid,
-  validate,
-  validateRecord,
-  validateStringFormat,
-  validateWithDetails,
-  withValidator
-};