aisp-validator 0.2.1 → 0.3.0

package/README.md

@@ -1,23 +1,36 @@
 # AISP Validator
 
-Validate [AISP 5.1](../AI_GUIDE.md) documents with <2% ambiguity using a <10KB WASM kernel.
+[![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)](LICENSE)
 
-## Quick Start
+**Validate AISP 5.1 documents** — AI Symbolic Protocol with <2% ambiguity.
 
-### CLI
+## Install
 
 ```bash
-# Validate a file
+npm install aisp-validator
+```
+
+## CLI Usage
+
+```bash
+# Validate a document
 npx aisp-validator validate spec.aisp
 
-# Get quality tier
-npx aisp-validator tier spec.aisp
+# Detailed output with JSON
+npx aisp-validator validate spec.aisp --long
+npx aisp-validator validate spec.aisp --json
+```
 
-# Get density score
-npx aisp-validator density spec.aisp
+**Output:**
+```
+✓ VALID
+  Tier: ◊⁺⁺ Platinum
+  Semantic (δ): 1.000
+  Pure (ρ):     1.857
 ```
 
-### Node.js
+## Node.js Usage
 
 ```javascript
 import AISP from 'aisp-validator';
@@ -25,112 +38,100 @@ import AISP from 'aisp-validator';
 await AISP.init();
 
 const result = AISP.validate(`
-𝔸1.0.example@2026-01-14
+𝔸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: '◊⁺⁺', delta: 0.78, 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 './browser/loader.js';
-
-await AISP.init('/wasm/aisp.wasm');
+import AISP from 'aisp-validator/browser';
 
-const result = AISP.validate(document);
-console.log(result.tier);  // '◊⁺⁺'
+await AISP.init('/path/to/aisp.wasm');
+const result = AISP.validate(source);
 </script>
 ```
 
-## API
-
-### `AISP.init(wasmPath?)`
-Initialize the WASM kernel. Call once before validation.
-
-### `AISP.validate(source)`
-Validate an AISP document. Returns:
-```javascript
-{
-  valid: boolean,      // true if valid
-  tier: string,        // '⊘' | '◊⁻' | '◊' | '◊⁺' | '◊⁺⁺'
-  tierValue: number,   // 0-4
-  delta: number,       // density δ [0, 1]
-  ambiguity: number,   // [0, 1], must be <0.02
-  errorCode: number    // 0 = success
-}
-```
-
-### `AISP.isValid(source)`
-Quick check: returns `true` if valid.
+## Quality Tiers
 
-### `AISP.getTier(source)`
-Returns tier symbol: `'◊⁺⁺'`, `'◊⁺'`, `'◊'`, `'◊⁻'`, or `'⊘'`
+| 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 |
 
-### `AISP.getDensity(source)`
-Returns density score (δ) between 0 and 1.
+## Required Blocks
 
-### `AISP.validateFile(path)` (Node.js only)
-Validate a file by path.
+Every AISP document needs 5 blocks:
 
-## Quality Tiers
+| Block | Purpose |
+|-------|---------|
+| `⟦Ω⟧` | Meta/Foundation |
+| `⟦Σ⟧` | Types/Glossary |
+| `⟦Γ⟧` | Rules/Inference |
+| `⟦Λ⟧` | Functions |
+| `⟦Ε⟧` | Evidence |
 
-| Tier | Symbol | Threshold | Meaning |
-|------|--------|-----------|---------|
-| Platinum | ◊⁺⁺ | δ ≥ 0.75 | Production-ready |
-| Gold | ◊⁺ | δ ≥ 0.60 | High quality |
-| Silver | ◊ | δ ≥ 0.40 | Acceptable |
-| Bronze | ◊⁻ | δ ≥ 0.20 | Needs improvement |
-| Reject | ⊘ | δ < 0.20 | Insufficient AISP |
+## API
 
-## Required AISP Blocks
+| 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) |
 
-Every valid AISP document must include:
+### Validation Result
 
-- `⟦Ω⟧` - Meta/foundation
-- `⟦Σ⟧` - Type definitions
-- `⟦Γ⟧` - Inference rules
-- `⟦Λ⟧` - Functions
-- `⟦Ε⟧` - Evidence
+```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
+}
+```
 
-## Building from Source
+## What is AISP?
 
-```bash
-# Prerequisites
-rustup target add wasm32-unknown-unknown
-npm install -g binaryen
+**AI Symbolic Protocol** is a formal specification language for AI-to-AI communication:
 
-# Build
-cd wasm
-./build.sh
+- **<2% Ambiguity** — Eliminates interpretation errors
+- **Formal Semantics** — Based on type theory
+- **Machine-Readable** — Designed for AI agents
+- **Human-Auditable** — Clear structure for review
 
-# Output: aisp.wasm (<10KB)
-```
+## Links
 
-## Architecture
+- [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)
 
-The validator uses a Rust WASM kernel based on dependent type theory:
+## Author
 
-- **Zero-allocation**: Arena-based memory, no heap
-- **Type checking**: Based on lean-agentic
-- **Symbol table**: AISP Σ_512 glossary
-- **Density computation**: AISP symbol ratio
+Bradley Ross — [GitHub @bar181](https://github.com/bar181)
 
 ## License
 
-MIT License - see [LICENSE](./LICENSE)
-
-## Links
-
-- [AISP 5.1 Specification](../AI_GUIDE.md)
-- [Reference (Rosetta Stone)](../reference.md)
-- [Repository](https://github.com/bar181/aisp-open-core)
+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.1 - 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.1');
+        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.1",
+  "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 };