aisp-validator 0.2.2 → 0.3.0

package/README.md

@@ -1,52 +1,36 @@
 # AISP Validator
 
 [![npm version](https://img.shields.io/npm/v/aisp-validator.svg)](https://www.npmjs.com/package/aisp-validator)
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
-**Validate AI Symbolic Protocol (AISP) 5.1 documents** with <2% ambiguity using a lightweight <10KB WASM kernel.
+**Validate AISP 5.1 documents** — AI Symbolic Protocol with <2% ambiguity.
 
-AISP is a formal specification language designed for AI-to-AI communication, providing precise, unambiguous specifications that eliminate interpretation errors.
-
-## Installation
+## Install
 
 ```bash
 npm install aisp-validator
 ```
 
-Or run directly with npx:
-
-```bash
-npx aisp-validator validate your-spec.aisp
-```
-
-## Quick Start
-
-### CLI Usage
+## CLI Usage
 
 ```bash
 # Validate a document
 npx aisp-validator validate spec.aisp
 
-# Get quality tier (◊⁺⁺, ◊⁺, ◊, ◊⁻, ⊘)
-npx aisp-validator tier spec.aisp
-
-# Get density score
-npx aisp-validator density spec.aisp
-
-# Debug - detailed density breakdown
-npx aisp-validator debug spec.aisp
+# Detailed output with JSON
+npx aisp-validator validate spec.aisp --long
+npx aisp-validator validate spec.aisp --json
 ```
 
-**Example output:**
+**Output:**
 ```
 ✓ VALID
   Tier: ◊⁺⁺ Platinum
   Semantic (δ): 1.000
   Pure (ρ):     1.857
-  Ambiguity:    0.010
 ```
 
-### Node.js
+## Node.js Usage
 
 ```javascript
 import AISP from 'aisp-validator';
@@ -54,193 +38,100 @@ import AISP from 'aisp-validator';
 await AISP.init();
 
 const result = AISP.validate(`
-𝔸1.0.example@2026-01-15
+𝔸1.0.example@2026-01-16
 γ≔test
 
 ⟦Ω:Meta⟧{ ∀D:Ambig(D)<0.02 }
 ⟦Σ:Types⟧{ T≜ℕ }
 ⟦Γ:Rules⟧{ ∀x:T:x≥0 }
 ⟦Λ:Funcs⟧{ f≜λx.x }
-⟦Ε⟧⟨δ≜0.75;φ≜100;τ≜◊⁺⁺⟩
+⟦Ε⟧⟨δ≜0.75;τ≜◊⁺⁺⟩
 `);
 
-console.log(result);
-// {
-//   valid: true,
-//   tier: '◊⁺⁺',
-//   tierName: 'Platinum',
-//   delta: 0.82,
-//   pureDensity: 1.85,
-//   ambiguity: 0.01
-// }
+console.log(result.valid);    // true
+console.log(result.tier);     // '◊⁺⁺'
+console.log(result.tierName); // 'Platinum'
+console.log(result.delta);    // 0.82
 ```
 
-### Browser
+## Browser Usage
 
 ```html
 <script type="module">
 import AISP from 'aisp-validator/browser';
 
 await AISP.init('/path/to/aisp.wasm');
-
-const result = AISP.validate(documentSource);
-console.log(result.tier);  // '◊⁺⁺'
+const result = AISP.validate(source);
 </script>
 ```
 
-## API Reference
-
-### `AISP.init(wasmPath?)`
-Initialize the WASM kernel. Must be called once before validation.
-
-### `AISP.validate(source)`
-Validate an AISP document. Returns:
-```javascript
-{
-  valid: boolean,       // true if document passes validation
-  tier: string,         // '⊘' | '◊⁻' | '◊' | '◊⁺' | '◊⁺⁺'
-  tierName: string,     // 'Reject' | 'Bronze' | 'Silver' | 'Gold' | 'Platinum'
-  tierValue: number,    // 0-4 (numeric tier)
-  delta: number,        // Semantic density δ [0, 1]
-  pureDensity: number,  // Pure density ρ (symbols/tokens)
-  ambiguity: number,    // [0, 1], must be <0.02
-  errorCode: number     // 0 = success
-}
-```
-
-### `AISP.debug(source)`
-Get detailed density breakdown for debugging.
-
-### `AISP.isValid(source)`
-Quick check: returns `true` if valid.
-
-### `AISP.getTier(source)`
-Returns tier symbol: `'◊⁺⁺'`, `'◊⁺'`, `'◊'`, `'◊⁻'`, or `'⊘'`
-
-### `AISP.getDensity(source)`
-Returns semantic density score (δ) between 0 and 1.
-
-### `AISP.validateFile(path)` (Node.js only)
-Validate a file by path.
-
-### `AISP.debugFile(path)` (Node.js only)
-Debug a file by path.
-
 ## Quality Tiers
 
-| Tier | Symbol | Threshold | Use Case |
-|------|--------|-----------|----------|
-| **Platinum** | ◊⁺⁺ | δ ≥ 0.75 | Production deployment |
-| **Gold** | ◊⁺ | δ ≥ 0.60 | Staging/pre-production |
-| **Silver** | ◊ | δ ≥ 0.40 | Development/testing |
-| **Bronze** | ◊⁻ | δ ≥ 0.20 | Draft/review |
-| **Reject** | ⊘ | δ < 0.20 | Insufficient quality |
+| Tier | Symbol | δ Threshold | Description |
+|------|--------|-------------|-------------|
+| Platinum | ◊⁺⁺ | ≥ 0.75 | Production ready |
+| Gold | ◊⁺ | ≥ 0.60 | Pre-production |
+| Silver | ◊ | ≥ 0.40 | Development |
+| Bronze | ◊⁻ | ≥ 0.20 | Draft |
+| Reject | ⊘ | < 0.20 | Invalid |
 
-## Density Metrics
+## Required Blocks
 
-### Semantic Density (δ)
-Measures specification completeness:
-```
-δ = (blockScore × 0.4) + (bindingScore × 0.6)
-```
-- **blockScore**: Required blocks present (⟦Ω⟧, ⟦Σ⟧, ⟦Γ⟧, ⟦Λ⟧, ⟦Ε⟧)
-- **bindingScore**: Semantic operators (≜, ≔, ∀, ∃, λ, ⇒, ∈, etc.)
+Every AISP document needs 5 blocks:
 
-### Pure Density (ρ)
-Measures symbol concentration:
-```
-ρ = |AISP_symbols| ÷ |non_ws_tokens|
-```
-
-## Required AISP Blocks
-
-Every valid AISP document must include these 5 blocks:
-
-| Block | Name | Purpose |
-|-------|------|---------|
-| `⟦Ω⟧` | Meta | Metadata and constraints |
-| `⟦Σ⟧` | Types | Type definitions |
-| `⟦Γ⟧` | Rules | Inference rules |
-| `⟦Λ⟧` | Funcs | Function definitions |
-| `⟦Ε⟧` | Evidence | Quality metrics |
-
-## Example AISP Document
-
-```aisp
-𝔸5.1.tic-tac-toe@2026-01-15
-γ≔game-spec
+| Block | Purpose |
+|-------|---------|
+| `⟦Ω⟧` | Meta/Foundation |
+| `⟦Σ⟧` | Types/Glossary |
+| `⟦Γ⟧` | Rules/Inference |
+| `⟦Λ⟧` | Functions |
+| `⟦Ε⟧` | Evidence |
 
-⟦Ω:Meta⟧{
-  ∀D∈AISP:Ambig(D)<0.02
-  Target≜AI-Agents
-}
+## API
 
-⟦Σ:Types⟧{
-  Player≜{X,O}
-  Cell≜{Empty,X,O}
-  Board≜Cell[9]
-}
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `AISP.init()` | Promise | Initialize WASM (call once) |
+| `AISP.validate(src)` | Object | Full validation result |
+| `AISP.isValid(src)` | boolean | Quick valid check |
+| `AISP.getTier(src)` | string | Tier symbol only |
+| `AISP.getDensity(src)` | number | Semantic density δ |
+| `AISP.validateFile(path)` | Object | Validate file (Node.js) |
 
-⟦Γ:Rules⟧{
-  ∀move:ValidMove(board,pos)⇔board[pos]=Empty
-  ∀win:WinCondition⇔∃line∈Lines:∀c∈line:c=player
-}
+### Validation Result
 
-⟦Λ:Funcs⟧{
-  makeMove≜λ(board,pos,player).board[pos]←player
-  checkWin≜λboard.∃p∈Player:WinCondition(board,p)
+```javascript
+{
+  valid: true,          // Document passes validation
+  tier: '◊⁺⁺',          // Quality tier symbol
+  tierName: 'Platinum', // Tier name
+  tierValue: 4,         // Numeric (0-4)
+  delta: 0.82,          // Semantic density [0,1]
+  pureDensity: 1.85,    // Symbol concentration
+  ambiguity: 0.01,      // Must be <0.02
+  errorCode: 0          // 0 = success
 }
-
-⟦Ε⟧⟨δ≜0.75;φ≜100;τ≜◊⁺⁺⟩
 ```
 
-## Building from Source
-
-The validator includes full Rust source code:
-
-```bash
-# Prerequisites
-rustup target add wasm32-unknown-unknown
-cargo install wasm-opt  # or: npm install -g binaryen
-
-# Build WASM kernel
-cd wasm
-./build.sh
-
-# Output: aisp.wasm (<10KB)
-```
-
-## Architecture
-
-- **WASM Kernel**: Zero-allocation Rust core (<10KB)
-- **Type System**: Based on dependent type theory
-- **Symbol Table**: AISP Σ_512 glossary (50+ formal symbols)
-- **Validation**: Structural + semantic analysis
-
 ## What is AISP?
 
-**AI Symbolic Protocol (AISP)** is a formal specification language designed for precise AI-to-AI communication. Key benefits:
+**AI Symbolic Protocol** is a formal specification language for AI-to-AI communication:
 
-- **<2% Ambiguity**: Eliminates interpretation errors
-- **Formal Semantics**: Based on type theory and logic
-- **Machine-Readable**: Designed for AI agents
-- **Human-Auditable**: Clear structure for review
-
-Learn more:
-- [AI Guide](https://github.com/bar181/aisp-open-core/blob/main/AI_GUIDE.md) - Complete AISP specification
-- [Human Guide](https://github.com/bar181/aisp-open-core/blob/main/HUMAN_GUIDE.md) - Human-readable introduction
-- [Reference (Rosetta Stone)](https://github.com/bar181/aisp-open-core/blob/main/reference.md) - Symbol glossary
+- **<2% Ambiguity** — Eliminates interpretation errors
+- **Formal Semantics** — Based on type theory
+- **Machine-Readable** — Designed for AI agents
+- **Human-Auditable** — Clear structure for review
 
 ## Links
 
-- **GitHub**: [github.com/bar181/aisp-open-core](https://github.com/bar181/aisp-open-core)
-- **npm**: [npmjs.com/package/aisp-validator](https://www.npmjs.com/package/aisp-validator)
-- **Issues**: [Report bugs](https://github.com/bar181/aisp-open-core/issues)
+- [AI Guide](https://github.com/bar181/aisp-open-core/blob/main/AI_GUIDE.md) — Full AISP 5.1 spec
+- [Human Guide](https://github.com/bar181/aisp-open-core/blob/main/HUMAN_GUIDE.md) — Introduction
+- [GitHub](https://github.com/bar181/aisp-open-core)
 
-## License
+## Author
 
-MIT License - see [LICENSE](https://github.com/bar181/aisp-open-core/blob/main/validator/LICENSE)
+Bradley Ross — [GitHub @bar181](https://github.com/bar181)
 
----
+## License
 
-**Made for AI agents, auditable by humans.**
+MIT

package/bin/cli.js

@@ -1,18 +1,21 @@
 #!/usr/bin/env node
 /**
  * AISP Validator CLI
- * Usage: aisp-validator <command> [file]
+ * Usage: aisp-validator <command> [file] [options]
  */
 
-import AISP from '../src/index.js';
-import { readFile } from 'fs/promises';
+import AISP, { SUPPORTED_EXTENSIONS, SIZE_LIMITS } from '../src/index.js';
+import { readFile, stat } from 'fs/promises';
 import { existsSync } from 'fs';
+import { extname, basename } from 'path';
+
+const VERSION = '0.3.0';
 
 const HELP = `
-AISP Validator v0.2.2 - Validate AISP 5.1 documents
+AISP Validator v${VERSION} - Validate AISP 5.1 documents
 
 Usage:
-  aisp-validator <command> [file]
+  aisp-validator <command> [file] [options]
   aisp-validator [file]              Shorthand for validate
 
 Commands:
@@ -20,8 +23,18 @@ Commands:
   tier <file>       Get quality tier (⊘ to ◊⁺⁺)
   density <file>    Get density score (δ)
   debug <file>      Show detailed density breakdown
+  long <file>       Long-format output with full details
   help              Show this help message
 
+Options:
+  --long, -l        Long-format output (detailed)
+  --json, -j        JSON output
+  --max-size <n>    Maximum document size in KB (default: 64)
+  --strict          Force WASM validation (max 1KB)
+
+Supported File Types:
+  ${SUPPORTED_EXTENSIONS.join(', ')}
+
 Quality Tiers:
   ◊⁺⁺  Platinum   δ ≥ 0.75
   ◊⁺   Gold       δ ≥ 0.60
@@ -41,8 +54,108 @@ Examples:
   npx aisp-validator validate spec.aisp
   npx aisp-validator tier spec.aisp
   npx aisp-validator debug spec.aisp
+  npx aisp-validator long spec.md --max-size 128
+  npx aisp-validator validate spec.aisp --json
 `;
 
+/**
+ * Parse CLI arguments
+ */
+function parseArgs(args) {
+    const result = {
+        command: 'validate',
+        file: null,
+        options: {
+            long: false,
+            json: false,
+            strict: false,
+            maxSize: SIZE_LIMITS.DEFAULT_MAX / 1024
+        }
+    };
+
+    const commands = ['validate', 'tier', 'density', 'debug', 'long', 'help'];
+    let i = 0;
+
+    while (i < args.length) {
+        const arg = args[i];
+
+        if (arg === '--long' || arg === '-l') {
+            result.options.long = true;
+        } else if (arg === '--json' || arg === '-j') {
+            result.options.json = true;
+        } else if (arg === '--strict') {
+            result.options.strict = true;
+        } else if (arg === '--max-size' && args[i + 1]) {
+            result.options.maxSize = parseInt(args[++i], 10) || 64;
+        } else if (commands.includes(arg)) {
+            result.command = arg;
+        } else if (!arg.startsWith('-') && !result.file) {
+            result.file = arg;
+        }
+        i++;
+    }
+
+    // 'long' command implies long format
+    if (result.command === 'long') {
+        result.options.long = true;
+        result.command = 'validate';
+    }
+
+    return result;
+}
+
+/**
+ * Check if file extension is supported
+ */
+function isExtensionSupported(file) {
+    const ext = extname(file).toLowerCase();
+    // Also allow files without extension (assume AISP)
+    return ext === '' || SUPPORTED_EXTENSIONS.includes(ext);
+}
+
+/**
+ * Format long output
+ */
+function formatLong(file, result, debug, fileSize) {
+    const lines = [];
+    lines.push(`\n${'═'.repeat(60)}`);
+    lines.push(`AISP Document Validation Report`);
+    lines.push(`${'═'.repeat(60)}`);
+    lines.push(`\nFile: ${basename(file)}`);
+    lines.push(`Size: ${(fileSize / 1024).toFixed(2)} KB`);
+    lines.push(`Mode: ${result.mode || 'wasm'}`);
+    lines.push(`\n${'─'.repeat(40)}`);
+    lines.push(`RESULT: ${result.valid ? '✓ VALID' : '✗ INVALID'}`);
+    lines.push(`${'─'.repeat(40)}`);
+    lines.push(`\nQuality Tier: ${result.tier} ${result.tierName}`);
+    lines.push(`\nMetrics:`);
+    lines.push(`  Semantic Density (δ): ${result.delta.toFixed(4)}`);
+    lines.push(`  Pure Density (ρ):     ${result.pureDensity.toFixed(4)}`);
+    lines.push(`  Ambiguity:            ${result.ambiguity.toFixed(4)}`);
+
+    if (debug) {
+        lines.push(`\n${'─'.repeat(40)}`);
+        lines.push(`Semantic Score Breakdown:`);
+        lines.push(`  Block Score:   ${(debug.blockScore * 100).toFixed(1)}% (weight: 40%)`);
+        lines.push(`  Binding Score: ${(debug.bindingScore * 100).toFixed(1)}% (weight: 60%)`);
+        lines.push(`\nBlocks Found: ${debug.breakdown.blocksFound}/${debug.breakdown.blocksRequired}`);
+        lines.push(`  Required: ⟦Ω⟧, ⟦Σ⟧, ⟦Γ⟧, ⟦Λ⟧, ⟦Ε⟧`);
+        lines.push(`\nSemantic Operators: ${debug.breakdown.totalBindings}`);
+        lines.push(`  ≜ definitions:   ${debug.breakdown.definitions}`);
+        lines.push(`  ≔ assignments:   ${debug.breakdown.assignments}`);
+        lines.push(`  ∀∃ quantifiers:  ${debug.breakdown.quantifiers}`);
+        lines.push(`  λ lambdas:       ${debug.breakdown.lambdas}`);
+        lines.push(`  ⇒⇔ implications: ${debug.breakdown.implications}`);
+        lines.push(`  ∈⊆∩∪ set ops:    ${debug.breakdown.setOps}`);
+        lines.push(`\nPure Density:`);
+        lines.push(`  AISP Symbols: ${debug.breakdown.symbolCount}`);
+        lines.push(`  Total Tokens: ${debug.breakdown.tokenCount}`);
+    }
+
+    lines.push(`\n${'═'.repeat(60)}`);
+    return lines.join('\n');
+}
+
 async function main() {
     const args = process.argv.slice(2);
 
@@ -52,22 +165,15 @@ async function main() {
     }
 
     if (args[0] === '--version' || args[0] === '-v') {
-        console.log('aisp-validator v0.2.2');
+        console.log(`aisp-validator v${VERSION}`);
         process.exit(0);
     }
 
-    let command = args[0];
-    let file = args[1];
-
-    // If first arg is a file (no command), default to validate
-    if (command && !['validate', 'tier', 'density', 'debug'].includes(command)) {
-        file = command;
-        command = 'validate';
-    }
+    const { command, file, options } = parseArgs(args);
 
     if (!file) {
         console.error('Error: No file specified');
-        console.log('Usage: aisp-validator <command> <file>');
+        console.log('Usage: aisp-validator <command> <file> [options]');
         process.exit(1);
     }
 
@@ -76,19 +182,51 @@ async function main() {
         process.exit(1);
     }
 
+    // Check file extension
+    if (!isExtensionSupported(file)) {
+        console.warn(`Warning: File extension not in supported list: ${SUPPORTED_EXTENSIONS.join(', ')}`);
+        console.warn('Continuing with validation...\n');
+    }
+
     try {
-        await AISP.init();
+        // Initialize with max size option
+        await AISP.init({ maxDocSize: options.maxSize * 1024 });
+
         const content = await readFile(file, 'utf-8');
+        const fileStats = await stat(file);
+        const fileSize = fileStats.size;
 
         switch (command) {
             case 'validate': {
-                const result = AISP.validate(content);
+                const result = AISP.validate(content, { strict: options.strict });
+                const debug = options.long ? AISP.debug(content) : null;
+
+                // JSON output
+                if (options.json) {
+                    const output = {
+                        file: basename(file),
+                        fileSize,
+                        ...result,
+                        ...(debug ? { breakdown: debug.breakdown } : {})
+                    };
+                    console.log(JSON.stringify(output, null, 2));
+                    process.exit(result.valid ? 0 : 1);
+                }
+
+                // Long format output
+                if (options.long) {
+                    console.log(formatLong(file, result, debug, fileSize));
+                    process.exit(result.valid ? 0 : 1);
+                }
+
+                // Standard output
                 if (result.valid) {
                     console.log(`✓ VALID`);
                     console.log(`  Tier: ${result.tier} ${result.tierName}`);
                     console.log(`  Semantic (δ): ${result.delta.toFixed(3)}`);
                     console.log(`  Pure (ρ):     ${result.pureDensity.toFixed(3)}`);
                     console.log(`  Ambiguity:    ${result.ambiguity.toFixed(3)}`);
+                    if (result.mode) console.log(`  Mode:         ${result.mode}`);
                     process.exit(0);
                 } else {
                     console.log(`✗ INVALID`);
@@ -105,20 +243,36 @@ async function main() {
 
             case 'tier': {
                 const result = AISP.validate(content);
-                console.log(`${result.tier} ${result.tierName}`);
+                if (options.json) {
+                    console.log(JSON.stringify({ tier: result.tier, tierName: result.tierName, tierValue: result.tierValue }));
+                } else {
+                    console.log(`${result.tier} ${result.tierName}`);
+                }
                 break;
             }
 
             case 'density': {
                 const result = AISP.validate(content);
-                console.log(result.delta.toFixed(4));
+                if (options.json) {
+                    console.log(JSON.stringify({ delta: result.delta, pureDensity: result.pureDensity }));
+                } else {
+                    console.log(result.delta.toFixed(4));
+                }
                 break;
             }
 
             case 'debug': {
                 const debug = AISP.debug(content);
+
+                if (options.json) {
+                    console.log(JSON.stringify(debug, null, 2));
+                    break;
+                }
+
                 console.log(`\nAISP Density Debug`);
                 console.log(`==================`);
+                console.log(`\nFile: ${basename(file)}`);
+                console.log(`Size: ${(fileSize / 1024).toFixed(2)} KB`);
                 console.log(`\nTier: ${debug.tier} ${debug.tierName}`);
                 console.log(`Semantic (δ): ${debug.delta.toFixed(3)}`);
                 console.log(`Pure (ρ):     ${debug.pureDensity.toFixed(3)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aisp-validator",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "AISP 5.1 document validator - validates AI Symbolic Protocol specifications with <2% ambiguity",
   "main": "src/index.js",
   "bin": {

package/src/index.js

@@ -131,20 +131,48 @@ function getTierFromDelta(delta) {
     return { tier: '⊘', tierValue: 0, tierName: 'Reject' };
 }
 
+/**
+ * Supported file extensions for AISP documents
+ */
+const SUPPORTED_EXTENSIONS = ['.aisp', '.md', '.txt', '.spec', '.aisp5'];
+
+/**
+ * Default and max document size limits
+ */
+const SIZE_LIMITS = {
+    DEFAULT_MAX: 64 * 1024,  // 64KB default
+    ABSOLUTE_MAX: 1024 * 1024, // 1MB absolute max
+    WASM_MAX: 1024  // WASM kernel limit
+};
+
 const AISP = {
     _instance: null,
     _memory: null,
     _allocPtr: 0x1000,
     _initialized: false,
+    _maxDocSize: SIZE_LIMITS.DEFAULT_MAX,
 
     /**
      * Initialize AISP kernel
-     * @param {string} [wasmPath] - Optional path to aisp.wasm
+     * @param {string|object} [options] - Path to aisp.wasm or options object
+     * @param {string} [options.wasmPath] - Path to aisp.wasm
+     * @param {number} [options.maxDocSize] - Maximum document size in bytes (default: 64KB)
      * @returns {Promise<number>} 0 on success
      */
-    async init(wasmPath) {
+    async init(options) {
         if (this._initialized) return 0;
 
+        // Handle both string (legacy) and object (new) options
+        let wasmPath;
+        if (typeof options === 'string') {
+            wasmPath = options;
+        } else if (options && typeof options === 'object') {
+            wasmPath = options.wasmPath;
+            if (options.maxDocSize) {
+                this._maxDocSize = Math.min(options.maxDocSize, SIZE_LIMITS.ABSOLUTE_MAX);
+            }
+        }
+
         const path = wasmPath || join(__dirname, '..', 'wasm', 'aisp.wasm');
         const bytes = await readFile(path);
 
@@ -165,12 +193,22 @@ const AISP = {
         return this._instance.aisp_init();
     },
 
+    /**
+     * Set maximum document size
+     * @param {number} size - Maximum size in bytes
+     */
+    setMaxDocSize(size) {
+        this._maxDocSize = Math.min(size, SIZE_LIMITS.ABSOLUTE_MAX);
+    },
+
     /**
      * Validate AISP document
      * @param {string} source - AISP source code
+     * @param {object} [options] - Validation options
+     * @param {boolean} [options.strict] - Use strict WASM validation (limited to 1KB)
      * @returns {object} Validation result
      */
-    validate(source) {
+    validate(source, options = {}) {
         if (!this._instance) {
             throw new Error('AISP not initialized. Call init() first.');
         }
@@ -178,41 +216,100 @@ const AISP = {
         const encoder = new TextEncoder();
         const bytes = encoder.encode(source);
 
-        const ptr = 0x1000;
-        if (bytes.length > 1024) {
-            return { valid: false, error: 'Document too large (max 1KB)' };
-        }
-
-        this._memory = new Uint8Array(this._instance.memory.buffer);
-        this._memory.set(bytes, ptr);
-
-        const docId = this._instance.aisp_parse(ptr, bytes.length);
-        if (docId < 0) {
+        // Check size against configurable limit
+        if (bytes.length > this._maxDocSize) {
             return {
                 valid: false,
-                error: `Parse error at offset ${this._instance.aisp_error_offset()}`,
-                errorCode: this._instance.aisp_error_code()
+                error: `Document too large (${bytes.length} bytes, max ${this._maxDocSize} bytes)`,
+                errorCode: -4
             };
         }
 
-        const parseResult = this._instance.aisp_validate(docId);
-
-        // Use semantic density calculation instead of WASM density
+        // Use semantic density calculation (works for all sizes)
         const densityResult = calculateSemanticDensity(source);
         const tierResult = getTierFromDelta(densityResult.delta);
 
+        // For documents within WASM limit, use WASM validation
+        if (bytes.length <= SIZE_LIMITS.WASM_MAX && options.strict !== false) {
+            const ptr = 0x1000;
+            this._memory = new Uint8Array(this._instance.memory.buffer);
+            this._memory.set(bytes, ptr);
+
+            const docId = this._instance.aisp_parse(ptr, bytes.length);
+            if (docId < 0) {
+                return {
+                    valid: false,
+                    error: `Parse error at offset ${this._instance.aisp_error_offset()}`,
+                    errorCode: this._instance.aisp_error_code(),
+                    tier: tierResult.tier,
+                    tierValue: tierResult.tierValue,
+                    tierName: tierResult.tierName,
+                    delta: densityResult.delta,
+                    pureDensity: densityResult.pureDensity
+                };
+            }
+
+            const parseResult = this._instance.aisp_validate(docId);
+
+            return {
+                valid: parseResult === 0,
+                tier: tierResult.tier,
+                tierValue: tierResult.tierValue,
+                tierName: tierResult.tierName,
+                delta: densityResult.delta,
+                pureDensity: densityResult.pureDensity,
+                ambiguity: this._instance.aisp_ambig(docId),
+                errorCode: parseResult,
+                mode: 'wasm'
+            };
+        }
+
+        // For larger documents, use pure JS validation
+        const jsValidation = this._validatePureJS(source, densityResult);
+
         return {
-            valid: parseResult === 0,
+            valid: jsValidation.valid,
             tier: tierResult.tier,
             tierValue: tierResult.tierValue,
             tierName: tierResult.tierName,
             delta: densityResult.delta,
             pureDensity: densityResult.pureDensity,
-            ambiguity: this._instance.aisp_ambig(docId),
-            errorCode: parseResult
+            ambiguity: jsValidation.ambiguity,
+            errorCode: jsValidation.valid ? 0 : -3,
+            mode: 'js',
+            docSize: bytes.length
         };
     },
 
+    /**
+     * Pure JavaScript validation for larger documents
+     * @private
+     */
+    _validatePureJS(source, densityResult) {
+        // Check for AISP header
+        if (!source.trim().startsWith('𝔸')) {
+            return { valid: false, ambiguity: 1.0, error: 'Missing AISP header (𝔸)' };
+        }
+
+        // Check for required blocks
+        const requiredBlocks = ['⟦Ω', '⟦Σ', '⟦Γ', '⟦Λ', '⟦Ε'];
+        const missingBlocks = requiredBlocks.filter(b => !source.includes(b));
+
+        if (missingBlocks.length > 0) {
+            return {
+                valid: false,
+                ambiguity: 0.5,
+                error: `Missing required blocks: ${missingBlocks.join(', ')}`
+            };
+        }
+
+        // Valid if all required blocks present and density >= 0.20 (Bronze tier minimum)
+        const valid = densityResult.delta >= 0.20;
+        const ambiguity = valid ? 0.01 : 0.5;
+
+        return { valid, ambiguity };
+    },
+
     /**
      * Get detailed density breakdown for debugging
      * @param {string} source - AISP source
@@ -290,5 +387,5 @@ const AISP = {
 };
 
 export default AISP;
-export const { init, validate, isValid, getDensity, getTier, validateFile, debug, debugFile } = AISP;
-export { calculateSemanticDensity, calculatePureDensity, getTierFromDelta, AISP_SYMBOLS };
+export const { init, validate, isValid, getDensity, getTier, validateFile, debug, debugFile, setMaxDocSize } = AISP;
+export { calculateSemanticDensity, calculatePureDensity, getTierFromDelta, AISP_SYMBOLS, SUPPORTED_EXTENSIONS, SIZE_LIMITS };