add lexicon intellisense package for working with .json files in vscode

packages/lexicon-intellisense/.gitignore

···
+out
+node_modules
+*.vsix

packages/lexicon-intellisense/.vscode/launch.json

···
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Run Extension",
+      "type": "extensionHost",
+      "request": "launch",
+      "args": [
+        "--extensionDevelopmentPath=${workspaceFolder}"
+      ],
+      "outFiles": [
+        "${workspaceFolder}/out/**/*.js"
+      ],
+    }
+  ]
+}

packages/lexicon-intellisense/.vscode/tasks.json

···
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "npm",
+      "script": "compile",
+      "group": "build",
+      "presentation": {
+        "panel": "dedicated",
+        "reveal": "never"
+      },
+      "problemMatcher": [
+        "$tsc"
+      ]
+    },
+    {
+      "type": "npm",
+      "script": "watch",
+      "group": "build",
+      "presentation": {
+        "panel": "dedicated",
+        "reveal": "never"
+      },
+      "problemMatcher": [
+        "$tsc-watch"
+      ],
+      "isBackground": true
+    }
+  ]
+}

packages/lexicon-intellisense/.vscodeignore

···
+.vscode/**
+.vscode-test/**
+src/**
+.gitignore
+**/tsconfig.json
+**/*.map
+**/*.ts
+**/*.vsix
+node_modules/**/test/**
+node_modules/**/tests/**
+node_modules/**/*.md
+node_modules/**/*.txt
+node_modules/**/LICENSE*
+node_modules/**/README*
+node_modules/**/.npmignore
+node_modules/**/.*

packages/lexicon-intellisense/LICENSE

···
+MIT License
+
+Copyright (c) 2025 Slices Network
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/lexicon-intellisense/README.md

···
+# Lexicon IntelliSense
+
+VS Code extension providing IntelliSense support for AT Protocol lexicon JSON files using the `@slices/lexicon` validation library.
+
+## Features
+
+- **Real-time validation**: Validates lexicon files as you type using the WASM-based `@slices/lexicon` validator
+- **JSON Schema support**: Provides autocomplete and validation using comprehensive JSON schemas
+- **Cross-lexicon validation**: Validates references between lexicon files in your workspace
+- **Error diagnostics**: Shows validation errors directly in the editor with precise location information
+- **Workspace validation**: Command to validate all lexicon files in your workspace
+
+## Installation
+
+1. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+2. Compile the extension:
+   ```bash
+   npm run compile
+   ```
+
+3. Install in VS Code:
+   - Open VS Code
+   - Press F5 to launch a new Extension Development Host window
+   - Open a workspace containing lexicon files
+
+## Configuration
+
+The extension can be configured in VS Code settings:
+
+- `lexiconIntelliSense.enableValidation`: Enable/disable lexicon validation (default: true)
+- `lexiconIntelliSense.lexiconDirectory`: Directory containing lexicon files relative to workspace root (default: "lexicons")
+
+## Usage
+
+### Automatic Validation
+
+The extension automatically validates:
+- JSON files in directories containing "lexicons" in the path
+- JSON files that contain lexicon-like structure (have `id` and `defs` fields)
+
+### Manual Validation
+
+Use the command palette (Ctrl+Shift+P / Cmd+Shift+P):
+- `Lexicon: Validate Current File` - Validates the currently open lexicon file
+- `Lexicon: Validate Workspace` - Validates all lexicon files in the workspace
+
+### Features in Action
+
+1. **Structure validation**: Ensures lexicon files have required `id` and `defs` fields
+2. **Type checking**: Validates that definition types are correct
+3. **Reference validation**: Checks that references to other lexicons can be resolved
+4. **Format validation**: Validates string formats like datetime, uri, nsid, etc.
+
+## File Structure
+
+```
+packages/lexicon-intellisense/
+├── package.json              # Extension manifest
+├── src/
+│   ├── extension.ts          # Main extension entry point
+│   ├── language-server.ts    # Language server implementation
+│   └── lexicon-validator.ts  # WASM validator wrapper
+├── schemas/
+│   └── lexicon-schema.json   # JSON schema for lexicon files
+├── wasm/                     # WASM files from lexicon-rs
+└── language-configuration.json
+```
+
+## Development
+
+### Building
+
+```bash
+npm run compile
+```
+
+### Testing
+
+1. Open the project in VS Code
+2. Press F5 to launch the Extension Development Host
+3. Open a workspace with lexicon files
+4. Test validation and IntelliSense features
+
+### WASM Integration
+
+The extension uses WASM files compiled from the Rust-based `lexicon-rs` package for validation. These files are copied during build and provide the same validation logic used by the CLI tools.
+
+## Commands
+
+- `lexiconIntelliSense.validateFile`: Validate the current lexicon file
+- `lexiconIntelliSense.validateWorkspace`: Validate all lexicon files in workspace
+
+## License
+
+MIT

packages/lexicon-intellisense/images/logo.svg

···
+<svg viewBox="0 0 60 60" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient id="board1" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#FF6347;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#FF4500;stop-opacity:1" />
+    </linearGradient>
+    <linearGradient id="board2" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#00CED1;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#4682B4;stop-opacity:1" />
+    </linearGradient>
+  </defs>
+  
+  <!-- Surfboard/skateboard deck shapes stacked -->
+  <g transform="translate(30, 30)">
+    <!-- Top board slice -->
+    <ellipse cx="0" cy="-8" rx="15" ry="6" fill="url(#board1)"/>
+    
+    <!-- Middle board slice -->
+    <ellipse cx="0" cy="0" rx="18" ry="6" fill="url(#board2)"/>
+    
+    <!-- Bottom board slice -->
+    <ellipse cx="0" cy="8" rx="12" ry="6" fill="#32CD32"/>
+  </g>
+</svg>

packages/lexicon-intellisense/package-lock.json

···
+{
+  "name": "@slices/lexicon-intellisense",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@slices/lexicon-intellisense",
+      "version": "0.1.0",
+      "license": "MIT",
+      "dependencies": {
+        "vscode-languageclient": "^9.0.0",
+        "vscode-languageserver": "^9.0.0",
+        "vscode-languageserver-textdocument": "^1.0.11"
+      },
+      "devDependencies": {
+        "@types/node": "^20.0.0",
+        "@types/vscode": "^1.80.0",
+        "typescript": "^5.0.0"
+      },
+      "engines": {
+        "vscode": "^1.80.0"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "20.19.17",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.17.tgz",
+      "integrity": "sha512-gfehUI8N1z92kygssiuWvLiwcbOB3IRktR6hTDgJlXMYh5OvkPSRmgfoBUmfZt+vhwJtX7v1Yw4KvvAf7c5QKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@types/vscode": {
+      "version": "1.104.0",
+      "resolved": "https://registry.npmjs.org/@types/vscode/-/vscode-1.104.0.tgz",
+      "integrity": "sha512-0KwoU2rZ2ecsTGFxo4K1+f+AErRsYW0fsp6A0zufzGuhyczc2IoKqYqcwXidKXmy2u8YB2GsYsOtiI9Izx3Tig==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "license": "MIT"
+    },
+    "node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "5.1.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
+      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/semver": {
+      "version": "7.7.2",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz",
+      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.2.tgz",
+      "integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/vscode-jsonrpc": {
+      "version": "8.2.0",
+      "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.2.0.tgz",
+      "integrity": "sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/vscode-languageclient": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/vscode-languageclient/-/vscode-languageclient-9.0.1.tgz",
+      "integrity": "sha512-JZiimVdvimEuHh5olxhxkht09m3JzUGwggb5eRUkzzJhZ2KjCN0nh55VfiED9oez9DyF8/fz1g1iBV3h+0Z2EA==",
+      "license": "MIT",
+      "dependencies": {
+        "minimatch": "^5.1.0",
+        "semver": "^7.3.7",
+        "vscode-languageserver-protocol": "3.17.5"
+      },
+      "engines": {
+        "vscode": "^1.82.0"
+      }
+    },
+    "node_modules/vscode-languageserver": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver/-/vscode-languageserver-9.0.1.tgz",
+      "integrity": "sha512-woByF3PDpkHFUreUa7Hos7+pUWdeWMXRd26+ZX2A8cFx6v/JPTtd4/uN0/jB6XQHYaOlHbio03NTHCqrgG5n7g==",
+      "license": "MIT",
+      "dependencies": {
+        "vscode-languageserver-protocol": "3.17.5"
+      },
+      "bin": {
+        "installServerIntoExtension": "bin/installServerIntoExtension"
+      }
+    },
+    "node_modules/vscode-languageserver-protocol": {
+      "version": "3.17.5",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.17.5.tgz",
+      "integrity": "sha512-mb1bvRJN8SVznADSGWM9u/b07H7Ecg0I3OgXDuLdn307rl/J3A9YD6/eYOssqhecL27hK1IPZAsaqh00i/Jljg==",
+      "license": "MIT",
+      "dependencies": {
+        "vscode-jsonrpc": "8.2.0",
+        "vscode-languageserver-types": "3.17.5"
+      }
+    },
+    "node_modules/vscode-languageserver-textdocument": {
+      "version": "1.0.12",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.12.tgz",
+      "integrity": "sha512-cxWNPesCnQCcMPeenjKKsOCKQZ/L6Tv19DTRIGuLWe32lyzWhihGVJ/rcckZXJxfdKCFvRLS3fpBIsV/ZGX4zA==",
+      "license": "MIT"
+    },
+    "node_modules/vscode-languageserver-types": {
+      "version": "3.17.5",
+      "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.17.5.tgz",
+      "integrity": "sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg==",
+      "license": "MIT"
+    }
+  }
+}

packages/lexicon-intellisense/package.json

···
+{
+  "name": "lexicon-intellisense",
+  "version": "0.1.0",
+  "description": "VS Code IntelliSense support for AT Protocol lexicon JSON files",
+  "main": "./out/extension.js",
+  "license": "MIT",
+  "icon": "images/logo.png",
+  "publisher": "SlicesNetwork",
+  "keywords": [
+    "lexicon",
+    "atproto",
+    "at-protocol",
+    "json",
+    "validation"
+  ],
+  "engines": {
+    "vscode": "^1.80.0"
+  },
+  "categories": [
+    "Programming Languages",
+    "Linters"
+  ],
+  "activationEvents": [
+    "onLanguage:json"
+  ],
+  "contributes": {
+    "commands": [
+      {
+        "command": "lexiconIntelliSense.validateFile",
+        "title": "Validate Current File",
+        "category": "Lexicon"
+      },
+      {
+        "command": "lexiconIntelliSense.validateWorkspace",
+        "title": "Validate Workspace",
+        "category": "Lexicon"
+      }
+    ],
+    "jsonValidation": [
+      {
+        "fileMatch": "**/lexicons/**/*.json",
+        "url": "./schemas/lexicon-schema.json"
+      }
+    ],
+    "configuration": {
+      "title": "Lexicon IntelliSense",
+      "properties": {
+        "lexiconIntelliSense.enableValidation": {
+          "type": "boolean",
+          "default": true,
+          "description": "Enable lexicon validation using @slices/lexicon"
+        },
+        "lexiconIntelliSense.lexiconDirectory": {
+          "type": "string",
+          "default": "lexicons",
+          "description": "Directory containing lexicon files (relative to workspace root)"
+        }
+      }
+    }
+  },
+  "scripts": {
+    "vscode:prepublish": "npm run build",
+    "compile": "tsc -p ./",
+    "watch": "tsc -watch -p ./",
+    "build": "npm run copy:wasm && npm run compile",
+    "copy:wasm": "mkdir -p wasm && cp ../lexicon-rs/pkg/* wasm/"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.80.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "vscode-languageclient": "^9.0.0",
+    "vscode-languageserver": "^9.0.0",
+    "vscode-languageserver-textdocument": "^1.0.11"
+  }
+}

packages/lexicon-intellisense/schemas/lexicon-schema.json

···
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "AT Protocol Lexicon",
+  "type": "object",
+  "required": ["id", "defs"],
+  "properties": {
+    "lexicon": {
+      "type": "integer",
+      "description": "Lexicon version",
+      "default": 1
+    },
+    "id": {
+      "type": "string",
+      "description": "Unique identifier for the lexicon",
+      "pattern": "^[a-zA-Z0-9-]+\\.[a-zA-Z0-9.-]+$"
+    },
+    "description": {
+      "type": "string",
+      "description": "Description of the lexicon"
+    },
+    "defs": {
+      "type": "object",
+      "description": "Lexicon definitions",
+      "patternProperties": {
+        "^[a-zA-Z_][a-zA-Z0-9_]*$": {
+          "$ref": "#/$defs/definition"
+        }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false,
+  "$defs": {
+    "definition": {
+      "type": "object",
+      "required": ["type"],
+      "properties": {
+        "type": {
+          "type": "string",
+          "enum": ["record", "object", "string", "integer", "boolean", "array", "ref", "union", "blob", "bytes", "cid-link", "unknown"]
+        },
+        "description": {
+          "type": "string"
+        }
+      },
+      "allOf": [
+        {
+          "if": {
+            "properties": { "type": { "const": "record" } }
+          },
+          "then": {
+            "properties": {
+              "key": {
+                "type": "string",
+                "enum": ["literal:self", "tid", "any"]
+              },
+              "record": {
+                "$ref": "#/$defs/objectDef"
+              }
+            },
+            "required": ["record"]
+          }
+        },
+        {
+          "if": {
+            "properties": { "type": { "const": "object" } }
+          },
+          "then": {
+            "$ref": "#/$defs/objectDef"
+          }
+        },
+        {
+          "if": {
+            "properties": { "type": { "const": "string" } }
+          },
+          "then": {
+            "properties": {
+              "format": {
+                "type": "string",
+                "enum": ["datetime", "uri", "at-uri", "did", "handle", "at-identifier", "nsid", "cid", "language", "tid", "record-key"]
+              },
+              "maxLength": { "type": "integer", "minimum": 0 },
+              "minLength": { "type": "integer", "minimum": 0 },
+              "maxGraphemes": { "type": "integer", "minimum": 0 },
+              "minGraphemes": { "type": "integer", "minimum": 0 },
+              "enum": {
+                "type": "array",
+                "items": { "type": "string" }
+              },
+              "const": { "type": "string" },
+              "default": { "type": "string" }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": { "type": { "const": "integer" } }
+          },
+          "then": {
+            "properties": {
+              "minimum": { "type": "integer" },
+              "maximum": { "type": "integer" },
+              "enum": {
+                "type": "array",
+                "items": { "type": "integer" }
+              },
+              "const": { "type": "integer" },
+              "default": { "type": "integer" }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": { "type": { "const": "boolean" } }
+          },
+          "then": {
+            "properties": {
+              "const": { "type": "boolean" },
+              "default": { "type": "boolean" }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": { "type": { "const": "array" } }
+          },
+          "then": {
+            "properties": {
+              "items": {
+                "$ref": "#/$defs/definition"
+              },
+              "maxLength": { "type": "integer", "minimum": 0 },
+              "minLength": { "type": "integer", "minimum": 0 }
+            },
+            "required": ["items"]
+          }
+        },
+        {
+          "if": {
+            "properties": { "type": { "const": "ref" } }
+          },
+          "then": {
+            "properties": {
+              "ref": {
+                "type": "string",
+                "description": "Reference to another definition"
+              }
+            },
+            "required": ["ref"]
+          }
+        },
+        {
+          "if": {
+            "properties": { "type": { "const": "union" } }
+          },
+          "then": {
+            "properties": {
+              "refs": {
+                "type": "array",
+                "items": { "type": "string" },
+                "minItems": 1
+              },
+              "closed": { "type": "boolean" }
+            },
+            "required": ["refs"]
+          }
+        },
+        {
+          "if": {
+            "properties": { "type": { "const": "blob" } }
+          },
+          "then": {
+            "properties": {
+              "accept": {
+                "type": "array",
+                "items": { "type": "string" }
+              },
+              "maxSize": { "type": "integer", "minimum": 0 }
+            }
+          }
+        },
+        {
+          "if": {
+            "properties": { "type": { "const": "bytes" } }
+          },
+          "then": {
+            "properties": {
+              "maxLength": { "type": "integer", "minimum": 0 },
+              "minLength": { "type": "integer", "minimum": 0 }
+            }
+          }
+        }
+      ]
+    },
+    "objectDef": {
+      "type": "object",
+      "properties": {
+        "type": { "const": "object" },
+        "description": { "type": "string" },
+        "properties": {
+          "type": "object",
+          "patternProperties": {
+            "^[a-zA-Z_][a-zA-Z0-9_]*$": {
+              "$ref": "#/$defs/definition"
+            }
+          },
+          "additionalProperties": false
+        },
+        "required": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "nullable": {
+          "type": "array",
+          "items": { "type": "string" }
+        }
+      }
+    }
+  }
+}

packages/lexicon-intellisense/src/extension.ts

···
+import * as vscode from 'vscode';
+import * as path from 'path';
+import { LexiconLanguageServer } from './language-server';
+
+let languageServer: LexiconLanguageServer | undefined;
+
+export function activate(context: vscode.ExtensionContext) {
+  // Create the language server
+  languageServer = new LexiconLanguageServer(context);
+
+  // Start the language server
+  languageServer.start();
+
+  // Register commands
+  const validateCommand = vscode.commands.registerCommand('lexiconIntelliSense.validateFile', async () => {
+    const activeEditor = vscode.window.activeTextEditor;
+    if (!activeEditor) {
+      vscode.window.showErrorMessage('No active editor found');
+      return;
+    }
+
+    const document = activeEditor.document;
+    if (!isLexiconFile(document)) {
+      vscode.window.showErrorMessage('Current file is not a lexicon JSON file');
+      return;
+    }
+
+    try {
+      await languageServer?.validateDocument(document);
+      vscode.window.showInformationMessage('Lexicon validation completed');
+    } catch (error) {
+      vscode.window.showErrorMessage(`Validation failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+
+  const validateWorkspaceCommand = vscode.commands.registerCommand('lexiconIntelliSense.validateWorkspace', async () => {
+    if (!languageServer) {
+      vscode.window.showErrorMessage('Language server not initialized');
+      return;
+    }
+
+    try {
+      const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+      if (!workspaceFolder) {
+        vscode.window.showErrorMessage('No workspace folder found');
+        return;
+      }
+
+      await languageServer.validateWorkspace(workspaceFolder.uri);
+      vscode.window.showInformationMessage('Workspace lexicon validation completed');
+    } catch (error) {
+      vscode.window.showErrorMessage(`Workspace validation failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  });
+
+  context.subscriptions.push(validateCommand, validateWorkspaceCommand);
+
+  // Watch for configuration changes
+  const configWatcher = vscode.workspace.onDidChangeConfiguration((event) => {
+    if (event.affectsConfiguration('lexiconIntelliSense')) {
+      languageServer?.updateConfiguration();
+    }
+  });
+
+  context.subscriptions.push(configWatcher);
+}
+
+export function deactivate() {
+  if (languageServer) {
+    languageServer.stop();
+    languageServer = undefined;
+  }
+}
+
+function isLexiconFile(document: vscode.TextDocument): boolean {
+  // Check if file is in lexicons directory or has lexicon-like content
+  const filePath = document.uri.fsPath;
+  const isInLexiconsDir = filePath.includes('/lexicons/') || filePath.includes('\\lexicons\\');
+
+  if (isInLexiconsDir && document.languageId === 'json') {
+    return true;
+  }
+
+  // Check if JSON content looks like a lexicon
+  try {
+    const content = JSON.parse(document.getText());
+    return content && typeof content === 'object' &&
+           typeof content.id === 'string' &&
+           content.defs;
+  } catch {
+    return false;
+  }
+}

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

···
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as fs from 'fs';
+import {
+  LanguageClient,
+  LanguageClientOptions,
+  ServerOptions,
+  TransportKind
+} from 'vscode-languageclient/node';
+import { LexiconValidator, LexiconDoc, ValidationError } from './lexicon-validator';
+
+export class LexiconLanguageServer {
+  private client: LanguageClient | undefined;
+  private context: vscode.ExtensionContext;
+  private diagnosticCollection: vscode.DiagnosticCollection;
+
+  constructor(context: vscode.ExtensionContext) {
+    this.context = context;
+    this.diagnosticCollection = vscode.languages.createDiagnosticCollection('lexicon');
+    context.subscriptions.push(this.diagnosticCollection);
+  }
+
+  async start() {
+    // Set up document change listeners for real-time validation
+    const documentSelector = [
+      { scheme: 'file', language: 'json', pattern: '**/lexicons/**/*.json' }
+    ];
+
+    // Listen for document changes
+    const changeListener = vscode.workspace.onDidChangeTextDocument(async (event) => {
+      if (this.isLexiconDocument(event.document)) {
+        await this.validateDocument(event.document);
+      }
+    });
+
+    // Listen for document opens
+    const openListener = vscode.workspace.onDidOpenTextDocument(async (document) => {
+      if (this.isLexiconDocument(document)) {
+        await this.validateDocument(document);
+      }
+    });
+
+    // Listen for document saves
+    const saveListener = vscode.workspace.onDidSaveTextDocument(async (document) => {
+      if (this.isLexiconDocument(document)) {
+        await this.validateDocument(document);
+      }
+    });
+
+    this.context.subscriptions.push(changeListener, openListener, saveListener);
+
+    // Validate all open lexicon documents
+    for (const document of vscode.workspace.textDocuments) {
+      if (this.isLexiconDocument(document)) {
+        await this.validateDocument(document);
+      }
+    }
+  }
+
+  stop() {
+    if (this.client) {
+      this.client.stop();
+      this.client = undefined;
+    }
+  }
+
+  updateConfiguration() {
+    // Revalidate all open documents when configuration changes
+    for (const document of vscode.workspace.textDocuments) {
+      if (this.isLexiconDocument(document)) {
+        this.validateDocument(document);
+      }
+    }
+  }
+
+  async validateDocument(document: vscode.TextDocument) {
+    console.log('validateDocument called for:', document.uri.fsPath);
+
+    const config = vscode.workspace.getConfiguration('lexiconIntelliSense');
+    if (!config.get<boolean>('enableValidation', true)) {
+      console.log('Validation disabled in config');
+      return;
+    }
+
+    const diagnostics: vscode.Diagnostic[] = [];
+    console.log('Starting validation...');
+
+    try {
+      const content = document.getText();
+      const lexicon = JSON.parse(content);
+
+      // Basic structure validation
+      if (!lexicon || typeof lexicon !== 'object') {
+        diagnostics.push(this.createDiagnostic(
+          new vscode.Range(0, 0, 0, 0),
+          'Lexicon must be an object',
+          vscode.DiagnosticSeverity.Error
+        ));
+      } else {
+        // Validate required fields
+        if (!lexicon.id || typeof lexicon.id !== 'string') {
+          const range = this.findFieldRange(document, 'id') || this.findLineWithText(document, '"id"') || new vscode.Range(0, 0, 0, 0);
+          diagnostics.push(this.createDiagnostic(
+            range,
+            'Lexicon must have a valid "id" field',
+            vscode.DiagnosticSeverity.Error
+          ));
+        }
+
+        if (!lexicon.defs || typeof lexicon.defs !== 'object') {
+          const range = this.findFieldRange(document, 'defs') || this.findLineWithText(document, '"defs"') || new vscode.Range(0, 0, 0, 0);
+          diagnostics.push(this.createDiagnostic(
+            range,
+            'Lexicon must have a "defs" object',
+            vscode.DiagnosticSeverity.Error
+          ));
+        }
+
+        // Use WASM validator for deep validation
+        if (lexicon.id && lexicon.defs) {
+          console.log('Running WASM validation for lexicon:', lexicon.id);
+          try {
+            const validator = await LexiconValidator.create([lexicon as LexiconDoc]);
+            try {
+              validator.validateLexiconSetCompleteness();
+              console.log('WASM validation passed');
+            } catch (validationError) {
+              console.log('WASM validation failed:', validationError);
+              const errorMessage = validationError instanceof Error ? validationError.message : String(validationError);
+              const range = this.parseErrorLocationFromMessage(document, errorMessage) || this.findFieldRange(document, 'defs') || new vscode.Range(0, 0, 0, 0);
+              diagnostics.push(this.createDiagnostic(
+                range,
+                `Lexicon validation error: ${errorMessage}`,
+                vscode.DiagnosticSeverity.Error
+              ));
+            } finally {
+              validator.free();
+            }
+          } catch (error) {
+            console.log('WASM validator creation failed:', error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.log('Parsing error location for:', errorMessage);
+            const range = this.parseErrorLocationFromMessage(document, errorMessage) || this.findFieldRange(document, 'id') || new vscode.Range(0, 0, 0, 0);
+            console.log('Error range found:', range);
+            diagnostics.push(this.createDiagnostic(
+              range,
+              `Lexicon validation failed: ${errorMessage}`,
+              vscode.DiagnosticSeverity.Error
+            ));
+          }
+        } else {
+          console.log('Skipping WASM validation - missing id or defs');
+        }
+      }
+    } catch (parseError) {
+      diagnostics.push(this.createDiagnostic(
+        new vscode.Range(0, 0, 0, 0),
+        `Invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`,
+        vscode.DiagnosticSeverity.Error
+      ));
+    }
+
+    console.log('Setting diagnostics:', diagnostics.length, 'errors found');
+    this.diagnosticCollection.set(document.uri, diagnostics);
+  }
+
+  async validateWorkspace(workspaceUri: vscode.Uri) {
+    const config = vscode.workspace.getConfiguration('lexiconIntelliSense');
+    const lexiconDir = config.get<string>('lexiconDirectory', 'lexicons');
+
+    const lexiconPath = path.join(workspaceUri.fsPath, lexiconDir);
+    if (!fs.existsSync(lexiconPath)) {
+      vscode.window.showWarningMessage(`Lexicon directory not found: ${lexiconPath}`);
+      return;
+    }
+
+    const lexiconFiles = await this.findLexiconFiles(lexiconPath);
+    const lexicons: LexiconDoc[] = [];
+
+    // Load all lexicons
+    for (const filePath of lexiconFiles) {
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const lexicon = JSON.parse(content);
+        if (lexicon.id && lexicon.defs) {
+          lexicons.push(lexicon as LexiconDoc);
+        }
+      } catch (error) {
+        console.warn(`Failed to load lexicon ${filePath}:`, error);
+      }
+    }
+
+    // Validate the complete set
+    if (lexicons.length > 0) {
+      try {
+        const validator = await LexiconValidator.create(lexicons);
+        try {
+          validator.validateLexiconSetCompleteness();
+          vscode.window.showInformationMessage(`Successfully validated ${lexicons.length} lexicon files`);
+        } catch (validationError) {
+          vscode.window.showErrorMessage(`Set validation failed: ${validationError instanceof Error ? validationError.message : String(validationError)}`);
+        } finally {
+          validator.free();
+        }
+      } catch (error) {
+        vscode.window.showErrorMessage(`WASM validation failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+
+  private async findLexiconFiles(directory: string): Promise<string[]> {
+    const files: string[] = [];
+
+    const readDir = async (dir: string) => {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await readDir(fullPath);
+        } else if (entry.name.endsWith('.json')) {
+          files.push(fullPath);
+        }
+      }
+    };
+
+    await readDir(directory);
+    return files;
+  }
+
+  private isLexiconDocument(document: vscode.TextDocument): boolean {
+    const filePath = document.uri.fsPath;
+    const isInLexiconsDir = filePath.includes('/lexicons/') || filePath.includes('\\lexicons\\');
+
+    if (isInLexiconsDir && document.languageId === 'json') {
+      return true;
+    }
+
+    // Check if JSON content looks like a lexicon
+    try {
+      const content = JSON.parse(document.getText());
+      return content && typeof content === 'object' &&
+             typeof content.id === 'string' &&
+             content.defs;
+    } catch {
+      return false;
+    }
+  }
+
+  private findFieldRange(document: vscode.TextDocument, fieldName: string): vscode.Range | null {
+    const text = document.getText();
+    const regex = new RegExp(`"${fieldName}"\\s*:`, 'g');
+    let match;
+    const matches = [];
+
+    // Find all matches
+    while ((match = regex.exec(text)) !== null) {
+      matches.push(match);
+    }
+
+    if (matches.length === 0) return null;
+
+    // If only one match, use it
+    if (matches.length === 1) {
+      const startPos = document.positionAt(matches[0].index);
+      const endPos = document.positionAt(matches[0].index + matches[0][0].length);
+      return new vscode.Range(startPos, endPos);
+    }
+
+    // If multiple matches, try to find the one in properties context
+    for (const match of matches) {
+      const beforeMatch = text.substring(0, match.index);
+      // Look for "properties" keyword before this match
+      if (beforeMatch.includes('"properties"')) {
+        const startPos = document.positionAt(match.index);
+        const endPos = document.positionAt(match.index + match[0].length);
+        return new vscode.Range(startPos, endPos);
+      }
+    }
+
+    // Fallback to first match
+    const startPos = document.positionAt(matches[0].index);
+    const endPos = document.positionAt(matches[0].index + matches[0][0].length);
+    return new vscode.Range(startPos, endPos);
+  }
+
+  private findLineWithText(document: vscode.TextDocument, searchText: string): vscode.Range | null {
+    const text = document.getText();
+    const lines = text.split('\n');
+
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes(searchText)) {
+        const start = new vscode.Position(i, 0);
+        const end = new vscode.Position(i, lines[i].length);
+        return new vscode.Range(start, end);
+      }
+    }
+
+    return null;
+  }
+
+  private parseErrorLocationFromMessage(document: vscode.TextDocument, errorMessage: string): vscode.Range | null {
+    // Try to extract field names from error messages
+    // Common patterns: 'Property "main.title"', "'fieldName'", "at path 'defs.main.type'"
+
+    // Look for Property paths like "main.title" and map them to actual JSON structure
+    const propertyMatch = errorMessage.match(/Property '([^']+)'/);
+    if (propertyMatch) {
+      console.log('Found Property match:', propertyMatch[1]);
+      const propertyPath = propertyMatch[1];
+
+      // For "main.title" -> just look for "title" in the properties section
+      if (propertyPath.includes('.')) {
+        const parts = propertyPath.split('.');
+        const propertyName = parts[parts.length - 1]; // Get the last part (e.g., "title")
+        console.log('Looking for property name:', propertyName);
+
+        const range = this.findPropertyInContext(document, propertyName);
+        if (range) return range;
+      }
+
+      // Fallback to original mapping
+      const mappedPath = this.mapPropertyPathToJsonPath(propertyPath);
+      for (const fieldName of mappedPath) {
+        const range = this.findFieldRange(document, fieldName) || this.findLineWithText(document, `"${fieldName}"`);
+        if (range) return range;
+      }
+    }
+
+    // Look for string property definition errors like "String property definition 'main.releaseDate'"
+    const stringPropertyMatch = errorMessage.match(/String property definition '([^']+)'/);
+    if (stringPropertyMatch) {
+      console.log('Found String property definition match:', stringPropertyMatch[1]);
+      const propertyPath = stringPropertyMatch[1];
+
+      if (propertyPath.includes('.')) {
+        const parts = propertyPath.split('.');
+        const propertyName = parts[parts.length - 1]; // Get the last part (e.g., "releaseDate")
+        console.log('Looking for string property name:', propertyName);
+
+        const range = this.findPropertyInContext(document, propertyName);
+        if (range) return range;
+      }
+    }
+
+    // Look for quoted field names
+    const quotedFieldMatch = errorMessage.match(/'([^']+)'/);
+    if (quotedFieldMatch) {
+      const fieldPath = quotedFieldMatch[1];
+
+      // Try to find this field in the document
+      const range = this.findFieldRange(document, fieldPath) ||
+                   this.findLineWithText(document, `"${fieldPath}"`);
+      if (range) return range;
+    }
+
+    // Look for "type" errors - often in definitions
+    if (errorMessage.toLowerCase().includes('type')) {
+      const typeRange = this.findLineWithText(document, '"type"');
+      if (typeRange) return typeRange;
+    }
+
+    // Look for "defs" errors
+    if (errorMessage.toLowerCase().includes('defs') || errorMessage.toLowerCase().includes('definition')) {
+      const defsRange = this.findFieldRange(document, 'defs');
+      if (defsRange) return defsRange;
+    }
+
+    return null;
+  }
+
+  private mapPropertyPathToJsonPath(propertyPath: string): string[] {
+    // Map paths like "main.{property}" to actual JSON structure "defs.main.record.properties.{property}"
+    // This helps find the actual field in the JSON structure
+
+    const parts = propertyPath.split('.');
+
+    if (parts.length === 2) {
+      // "main.title" -> this is actually "defs.main.record.properties.title" in the JSON
+      const [defName, propertyName] = parts;
+
+      // Try to find the specific property first, then fallback to broader locations
+      return [
+        propertyName,           // Look for "title" directly
+        'properties',           // Look for "properties" section
+        'record',              // Look for "record" section
+        defName,               // Look for "main"
+        'defs'                 // Look for "defs"
+      ];
+    } else if (parts.length === 1) {
+      // "main" -> look for "main", then "defs"
+      return [parts[0], 'defs'];
+    }
+
+    // For longer paths, try each part in reverse order (most specific first)
+    return [...parts.reverse(), 'properties', 'record', 'defs'];
+  }
+
+  private findPropertyInContext(document: vscode.TextDocument, propertyName: string): vscode.Range | null {
+    console.log('Looking for property:', propertyName);
+    const text = document.getText();
+
+    // Find "properties" section first
+    const propertiesMatch = text.match(/"properties"\s*:\s*{/);
+    if (!propertiesMatch) {
+      console.log('No properties section found');
+      return null;
+    }
+
+    const propertiesStart = propertiesMatch.index! + propertiesMatch[0].length;
+    console.log('Properties section starts at:', propertiesStart);
+
+    // Find the property within the properties section
+    const propertiesSection = text.substring(propertiesStart);
+    const propertyRegex = new RegExp(`"${propertyName}"\\s*:`);
+    const propertyMatch = propertyRegex.exec(propertiesSection);
+
+    if (propertyMatch) {
+      const absoluteIndex = propertiesStart + propertyMatch.index;
+      const startPos = document.positionAt(absoluteIndex);
+      const endPos = document.positionAt(absoluteIndex + propertyMatch[0].length);
+      console.log('Found property at line:', startPos.line + 1);
+      return new vscode.Range(startPos, endPos);
+    }
+
+    console.log('Property not found in properties section');
+    return null;
+  }
+
+  private createDiagnostic(range: vscode.Range, message: string, severity: vscode.DiagnosticSeverity): vscode.Diagnostic {
+    const diagnostic = new vscode.Diagnostic(range, message, severity);
+    diagnostic.source = 'lexicon-intellisense';
+    return diagnostic;
+  }
+}

packages/lexicon-intellisense/src/lexicon-validator.ts

···
+/**
+ * Lexicon validator wrapper for Node.js environment
+ * Uses the WASM module from lexicon-rs
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Import WASM module - these files are copied from lexicon-rs/pkg
+const wasmModule = require('../wasm/slices_lexicon.js');
+
+let wasmInitialized = false;
+
+async function ensureWasmInit() {
+  if (!wasmInitialized) {
+    const wasmPath = path.join(__dirname, '../wasm/slices_lexicon_bg.wasm');
+    const wasmBytes = fs.readFileSync(wasmPath);
+    await wasmModule.default(wasmBytes);
+    wasmInitialized = true;
+  }
+}
+
+/**
+ * Lexicon document interface
+ */
+export interface LexiconDoc {
+  id: string;
+  defs: Record<string, unknown>;
+  lexicon?: number;
+}
+
+/**
+ * Lexicon validation error
+ */
+export class ValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ValidationError";
+  }
+}
+
+/**
+ * AT Protocol lexicon validator for Node.js
+ */
+export class LexiconValidator {
+  private wasmValidator: any;
+
+  constructor(lexicons: LexiconDoc[]) {
+    const lexiconsJson = JSON.stringify(lexicons);
+    this.wasmValidator = new wasmModule.WasmLexiconValidator(lexiconsJson);
+  }
+
+  /**
+   * Create a new validator with lexicon documents
+   * Ensures WASM is initialized first
+   */
+  static async create(lexicons: LexiconDoc[]): Promise<LexiconValidator> {
+    await ensureWasmInit();
+    return new LexiconValidator(lexicons);
+  }
+
+  /**
+   * Validate a record against its collection's lexicon
+   */
+  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));
+    }
+  }
+
+  /**
+   * Validate that all cross-lexicon references can be resolved
+   */
+  validateLexiconSetCompleteness(): void {
+    try {
+      this.wasmValidator.validate_lexicon_set_completeness();
+    } catch (error) {
+      throw new ValidationError(error instanceof Error ? error.message : String(error));
+    }
+  }
+
+  /**
+   * Clean up WASM resources
+   */
+  free(): void {
+    if (this.wasmValidator) {
+      this.wasmValidator.free();
+    }
+  }
+}
+
+/**
+ * Validate a string against a specific format
+ */
+export async function validateStringFormat(value: string, format: string): Promise<void> {
+  await ensureWasmInit();
+  try {
+    wasmModule.validate_string_format(value, format);
+  } catch (error) {
+    throw new ValidationError(error instanceof Error ? error.message : String(error));
+  }
+}
+
+/**
+ * Check if a string is a valid NSID (Name Spaced Identifier)
+ */
+export async function isValidNsid(nsid: string): Promise<boolean> {
+  await ensureWasmInit();
+  return wasmModule.is_valid_nsid(nsid);
+}

packages/lexicon-intellisense/tsconfig.json

···
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["ES2020"],
+    "module": "commonjs",
+    "outDir": "./out",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "sourceMap": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "out",
+    "**/*.test.ts"
+  ]
+}

packages/lexicon-intellisense/wasm/LICENSE

···
+MIT License
+
+Copyright (c) 2025 Slices Network
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/lexicon-intellisense/wasm/README.md

···
+# slices-lexicon
+
+AT Protocol lexicon validation library for Rust, compiled to WebAssembly.
+
+## Features
+
+- 🚀 Fast lexicon validation written in Rust
+- 🌐 WebAssembly support for browser and Node.js environments
+- 📦 Zero JavaScript dependencies
+- 🔒 Type-safe validation with comprehensive error messages
+- ✅ Full AT Protocol lexicon specification support
+
+## Installation
+
+```toml
+[dependencies]
+slices-lexicon = "0.1"
+```
+
+## Usage
+
+### In Rust
+
+```rust
+use slices_lexicon::{LexiconValidator, ValidationError};
+use serde_json::json;
+
+let lexicons = vec![
+    json!({
+        "id": "com.example.post",
+        "defs": {
+            "main": {
+                "type": "record",
+                "record": {
+                    "type": "object",
+                    "properties": {
+                        "text": { "type": "string" }
+                    }
+                }
+            }
+        }
+    })
+];
+
+let validator = LexiconValidator::new(lexicons)?;
+let record = json!({ "text": "Hello, world!" });
+
+validator.validate_record("com.example.post", &record)?;
+```
+
+### As WebAssembly
+
+Build with wasm-pack:
+
+```bash
+wasm-pack build --target web
+```
+
+Then use in JavaScript/TypeScript:
+
+```javascript
+import init, { WasmLexiconValidator } from './pkg/slices_lexicon.js';
+
+await init();
+
+const validator = new WasmLexiconValidator(JSON.stringify(lexicons));
+validator.validate_record("com.example.post", JSON.stringify(record));
+```
+
+## Supported Types
+
+- Objects with required/optional fields
+- Arrays with min/max length constraints
+- Strings with format validation (datetime, URI, DID, handle, etc.)
+- Integers with range constraints
+- Booleans with const values
+- Bytes (base64 encoded)
+- Unions (open and closed)
+- References (local and cross-lexicon)
+- CID links
+- Tokens (unit types for type discrimination)
+- Unknown types
+
+## String Formats
+
+- `datetime` - RFC3339/ISO8601 datetime
+- `uri` - Generic URI
+- `at-uri` - AT Protocol URI
+- `did` - Decentralized Identifier
+- `handle` - AT Protocol handle
+- `at-identifier` - DID or handle
+- `nsid` - Name Spaced Identifier
+- `cid` - Content Identifier
+- `language` - BCP47 language tag
+- `tid` - Timestamp-based Identifier
+- `record-key` - Record key format
+
+## License
+
+MIT

packages/lexicon-intellisense/wasm/lexicon_validator.d.ts

···
+/* tslint:disable */
+/* eslint-disable */
+export function main(): void;
+export function validate_string_format(value: string, format: string): void;
+export function is_valid_nsid(nsid: string): boolean;
+export class WasmLexiconValidator {
+  free(): void;
+  /**
+   * Create a new validator with the given lexicon documents
+   * Takes a JSON string containing an array of lexicon documents
+   */
+  constructor(lexicons_json: string);
+  /**
+   * Validate a record against its collection's lexicon
+   * Takes collection name and record as JSON strings
+   */
+  validate_record(collection: string, record_json: string): void;
+  /**
+   * Validate that all cross-lexicon references can be resolved
+   */
+  validate_lexicon_set_completeness(): void;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly main: () => void;
+  readonly __wbg_wasmlexiconvalidator_free: (a: number, b: number) => void;
+  readonly wasmlexiconvalidator_new: (a: number, b: number) => [number, number, number];
+  readonly wasmlexiconvalidator_validate_record: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+  readonly wasmlexiconvalidator_validate_lexicon_set_completeness: (a: number) => [number, number];
+  readonly validate_string_format: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly is_valid_nsid: (a: number, b: number) => number;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_export_3: WebAssembly.Table;
+  readonly __externref_table_dealloc: (a: number) => void;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

packages/lexicon-intellisense/wasm/lexicon_validator.js

···
+let wasm;
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let 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);
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const 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 === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    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 > 0x7F) 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;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+export function main() {
+    wasm.main();
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_3.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+/**
+ * @param {string} value
+ * @param {string} format
+ */
+export 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]);
+    }
+}
+
+/**
+ * @param {string} nsid
+ * @returns {boolean}
+ */
+export 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;
+}
+
+const WasmLexiconValidatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmlexiconvalidator_free(ptr >>> 0, 1));
+
+export class WasmLexiconValidator {
+
+    __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 that all cross-lexicon references can be resolved
+     */
+    validate_lexicon_set_completeness() {
+        const ret = wasm.wasmlexiconvalidator_validate_lexicon_set_completeness(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+
+const EXPECTED_RESPONSE_TYPES = 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) {
+        // Cast intrinsic for `Ref(String) -> Externref`.
+        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, undefined);
+        table.set(offset + 0, undefined);
+        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;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module !== 'undefined') {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+
+    __wbg_init_memory(imports);
+
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+
+    const instance = new WebAssembly.Instance(module, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) 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('lexicon_validator_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);
+}
+
+export { initSync };
+export default __wbg_init;

packages/lexicon-intellisense/wasm/lexicon_validator_bg.wasm.d.ts

···
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const main: () => void;
+export const __wbg_wasmlexiconvalidator_free: (a: number, b: number) => void;
+export const wasmlexiconvalidator_new: (a: number, b: number) => [number, number, number];
+export const wasmlexiconvalidator_validate_record: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const wasmlexiconvalidator_validate_lexicon_set_completeness: (a: number) => [number, number];
+export const validate_string_format: (a: number, b: number, c: number, d: number) => [number, number];
+export const is_valid_nsid: (a: number, b: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export_3: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

packages/lexicon-intellisense/wasm/package.json

···
+{
+  "name": "slices-lexicon",
+  "type": "module",
+  "description": "AT Protocol lexicon validation library for Slices",
+  "version": "0.1.4",
+  "license": "MIT",
+  "files": [
+    "slices_lexicon_bg.wasm",
+    "slices_lexicon.js",
+    "slices_lexicon.d.ts"
+  ],
+  "main": "slices_lexicon.js",
+  "types": "slices_lexicon.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ],
+  "keywords": [
+    "atproto",
+    "lexicon",
+    "validation",
+    "wasm",
+    "bluesky"
+  ]
+}

packages/lexicon-intellisense/wasm/slices_lexicon.d.ts

···
+/* tslint:disable */
+/* eslint-disable */
+export function main(): void;
+export function validate_string_format(value: string, format: string): void;
+export function is_valid_nsid(nsid: string): boolean;
+export class WasmLexiconValidator {
+  free(): void;
+  /**
+   * Create a new validator with the given lexicon documents
+   * Takes a JSON string containing an array of lexicon documents
+   */
+  constructor(lexicons_json: string);
+  /**
+   * Validate a record against its collection's lexicon
+   * Takes collection name and record as JSON strings
+   */
+  validate_record(collection: string, record_json: string): void;
+  /**
+   * Validate that all cross-lexicon references can be resolved
+   */
+  validate_lexicon_set_completeness(): void;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
+  readonly __wbg_wasmlexiconvalidator_free: (a: number, b: number) => void;
+  readonly wasmlexiconvalidator_new: (a: number, b: number) => [number, number, number];
+  readonly wasmlexiconvalidator_validate_record: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+  readonly wasmlexiconvalidator_validate_lexicon_set_completeness: (a: number) => [number, number];
+  readonly validate_string_format: (a: number, b: number, c: number, d: number) => [number, number];
+  readonly is_valid_nsid: (a: number, b: number) => number;
+  readonly main: () => void;
+  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_export_3: WebAssembly.Table;
+  readonly __externref_table_dealloc: (a: number) => void;
+  readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

packages/lexicon-intellisense/wasm/slices_lexicon.js

···
+let wasm;
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let 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);
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const 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 === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    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 > 0x7F) 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;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+export function main() {
+    wasm.main();
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_3.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+/**
+ * @param {string} value
+ * @param {string} format
+ */
+export 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]);
+    }
+}
+
+/**
+ * @param {string} nsid
+ * @returns {boolean}
+ */
+export 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;
+}
+
+const WasmLexiconValidatorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmlexiconvalidator_free(ptr >>> 0, 1));
+
+export class WasmLexiconValidator {
+
+    __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 that all cross-lexicon references can be resolved
+     */
+    validate_lexicon_set_completeness() {
+        const ret = wasm.wasmlexiconvalidator_validate_lexicon_set_completeness(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+}
+
+const EXPECTED_RESPONSE_TYPES = 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) {
+        // Cast intrinsic for `Ref(String) -> Externref`.
+        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, undefined);
+        table.set(offset + 0, undefined);
+        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;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module !== 'undefined') {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+
+    __wbg_init_memory(imports);
+
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+
+    const instance = new WebAssembly.Instance(module, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) 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);
+}
+
+export { initSync };
+export default __wbg_init;

packages/lexicon-intellisense/wasm/slices_lexicon_bg.wasm.d.ts

···
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_wasmlexiconvalidator_free: (a: number, b: number) => void;
+export const wasmlexiconvalidator_new: (a: number, b: number) => [number, number, number];
+export const wasmlexiconvalidator_validate_record: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+export const wasmlexiconvalidator_validate_lexicon_set_completeness: (a: number) => [number, number];
+export const validate_string_format: (a: number, b: number, c: number, d: number) => [number, number];
+export const is_valid_nsid: (a: number, b: number) => number;
+export const main: () => void;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export_3: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;