@dlovans/tenet-core 0.1.4 → 0.2.1

package/dist/core/validate.js

@@ -0,0 +1,200 @@
+/**
+ * Definition validation and status determination.
+ * Validates types, constraints, and required fields.
+ */
+import { toFloat, parseDate } from './operators.js';
+/**
+ * Add an error to the state's error list.
+ */
+export function addError(state, fieldId, ruleId, message, lawRef) {
+    state.errors.push({
+        field_id: fieldId || undefined,
+        rule_id: ruleId || undefined,
+        message,
+        law_ref: lawRef || undefined,
+    });
+}
+/**
+ * Check if a value is one of the allowed options.
+ */
+function isValidOption(value, options) {
+    if (!options) {
+        return true; // No restrictions
+    }
+    return options.includes(value);
+}
+/**
+ * Validate numeric constraints (min/max).
+ */
+function validateNumericConstraints(state, id, value, def) {
+    if (def.min !== undefined && value < def.min) {
+        addError(state, id, '', `Field '${id}' value ${value.toFixed(2)} is below minimum ${def.min.toFixed(2)}`);
+    }
+    if (def.max !== undefined && value > def.max) {
+        addError(state, id, '', `Field '${id}' value ${value.toFixed(2)} exceeds maximum ${def.max.toFixed(2)}`);
+    }
+}
+/**
+ * Validate string constraints (length, pattern).
+ */
+function validateStringConstraints(state, id, value, def) {
+    if (def.min_length !== undefined && value.length < def.min_length) {
+        addError(state, id, '', `Field '${id}' is too short (minimum ${def.min_length} characters)`);
+    }
+    if (def.max_length !== undefined && value.length > def.max_length) {
+        addError(state, id, '', `Field '${id}' is too long (maximum ${def.max_length} characters)`);
+    }
+    if (def.pattern) {
+        try {
+            const regex = new RegExp(def.pattern);
+            if (!regex.test(value)) {
+                addError(state, id, '', `Field '${id}' does not match required pattern`);
+            }
+        }
+        catch {
+            // Invalid regex pattern, skip validation
+        }
+    }
+}
+/**
+ * Validate a single definition's type and constraints.
+ */
+function validateType(state, id, def) {
+    const value = def.value;
+    switch (def.type) {
+        case 'string': {
+            if (typeof value !== 'string') {
+                addError(state, id, '', `Field '${id}' must be a string`);
+                return;
+            }
+            validateStringConstraints(state, id, value, def);
+            break;
+        }
+        case 'number':
+        case 'currency': {
+            const [numVal, ok] = toFloat(value);
+            if (!ok) {
+                addError(state, id, '', `Field '${id}' must be a number`);
+                return;
+            }
+            validateNumericConstraints(state, id, numVal, def);
+            break;
+        }
+        case 'boolean': {
+            if (typeof value !== 'boolean') {
+                addError(state, id, '', `Field '${id}' must be a boolean`);
+            }
+            break;
+        }
+        case 'select': {
+            if (typeof value !== 'string') {
+                addError(state, id, '', `Field '${id}' must be a string`);
+                return;
+            }
+            if (!isValidOption(value, def.options)) {
+                addError(state, id, '', `Field '${id}' value '${value}' is not a valid option`);
+            }
+            break;
+        }
+        case 'attestation': {
+            if (typeof value !== 'boolean') {
+                addError(state, id, '', `Attestation '${id}' must be a boolean`);
+            }
+            break;
+        }
+        case 'date': {
+            const [, ok] = parseDate(value);
+            if (!ok) {
+                addError(state, id, '', `Field '${id}' must be a valid date`);
+            }
+            break;
+        }
+    }
+}
+/**
+ * Validate all definitions for type correctness and required fields.
+ */
+export function validateDefinitions(state) {
+    for (const [id, def] of Object.entries(state.schema.definitions)) {
+        if (!def) {
+            continue;
+        }
+        // Check required fields
+        if (def.required) {
+            if (def.value === undefined || def.value === null) {
+                addError(state, id, '', `Required field '${id}' is missing`);
+            }
+            else if ((def.type === 'string' || def.type === 'select') && def.value === '') {
+                // Empty string is also considered "missing" for required string/select fields
+                addError(state, id, '', `Required field '${id}' is missing`);
+            }
+        }
+        // Validate type if value is present
+        if (def.value !== undefined && def.value !== null) {
+            validateType(state, id, def);
+        }
+    }
+}
+/**
+ * Check attestations for required signatures.
+ */
+export function checkAttestations(state, applyAction) {
+    // Check legacy attestations in definitions (simple type: attestation)
+    for (const [id, def] of Object.entries(state.schema.definitions)) {
+        if (!def || def.type !== 'attestation') {
+            continue;
+        }
+        if (def.required && def.value !== true) {
+            addError(state, id, '', `Required attestation '${id}' not confirmed`);
+        }
+    }
+    // Check rich attestations
+    if (!state.schema.attestations) {
+        return;
+    }
+    for (const [id, att] of Object.entries(state.schema.attestations)) {
+        if (!att) {
+            continue;
+        }
+        // Process on_sign if signed is true
+        if (att.signed && att.on_sign) {
+            applyAction(att.on_sign, `attestation_${id}`, att.law_ref || '');
+        }
+        // Validate required attestations
+        if (att.required) {
+            if (!att.signed) {
+                addError(state, id, '', `Required attestation '${id}' not signed`, att.law_ref);
+            }
+            else if (!att.evidence || !att.evidence.provider_audit_id) {
+                addError(state, id, '', `Attestation '${id}' signed but missing evidence`, att.law_ref);
+            }
+        }
+    }
+}
+/**
+ * Determine document status based on validation errors.
+ */
+export function determineStatus(state) {
+    let hasTypeErrors = false;
+    let hasMissingRequired = false;
+    let hasMissingAttestations = false;
+    for (const err of state.errors) {
+        const msg = err.message;
+        if (msg.includes('must be a')) {
+            hasTypeErrors = true;
+        }
+        else if (msg.includes('missing') || msg.includes('Required field')) {
+            hasMissingRequired = true;
+        }
+        else if (msg.includes('attestation')) {
+            hasMissingAttestations = true;
+        }
+    }
+    if (hasTypeErrors) {
+        return 'INVALID';
+    }
+    if (hasMissingRequired || hasMissingAttestations) {
+        return 'INCOMPLETE';
+    }
+    return 'READY';
+}

package/dist/index.d.ts

@@ -1,11 +1,9 @@
 /**
  * Tenet - Declarative Logic VM for JSON Schemas
  *
- * This module provides a JavaScript/TypeScript wrapper around the Tenet WASM binary.
- * Works in both browser and Node.js environments.
+ * This module provides a pure TypeScript implementation of the Tenet VM.
+ * Works in both browser and Node.js environments with no WASM dependencies.
  */
-export { lint, isTenetSchema, SCHEMA_URL } from './lint.js';
-export type { LintIssue, LintResult } from './lint.js';
 export interface TenetResult {
     result?: TenetSchema;
     error?: string;
@@ -49,6 +47,7 @@ export interface Definition {
     options?: string[];
     label?: string;
     required?: boolean;
+    readonly?: boolean;
     visible?: boolean;
     min?: number;
     max?: number;
@@ -90,22 +89,13 @@ export interface ValidationError {
     message: string;
     law_ref?: string;
 }
-declare global {
-    var TenetRun: (json: string, date: string) => TenetResult;
-    var TenetVerify: (newJson: string, oldJson: string) => TenetVerifyResult;
-    var Go: new () => GoInstance;
-}
-interface GoInstance {
-    importObject: WebAssembly.Imports;
-    run(instance: WebAssembly.Instance): Promise<void>;
-}
 /**
- * Initialize the Tenet WASM module.
- * Must be called before using run() or verify().
+ * Initialize the Tenet VM.
+ * This is a no-op in the pure TypeScript implementation (kept for backwards compatibility).
  *
- * @param wasmPath - Path or URL to tenet.wasm file
+ * @deprecated No longer needed - the VM is ready immediately after import.
  */
-export declare function init(wasmPath?: string): Promise<void>;
+export declare function init(_wasmPath?: string): Promise<void>;
 /**
  * Run the Tenet VM on a schema.
  *
@@ -124,6 +114,7 @@ export declare function run(schema: TenetSchema | string, date?: Date | string):
  */
 export declare function verify(newSchema: TenetSchema | string, oldSchema: TenetSchema | string): TenetVerifyResult;
 /**
- * Check if the WASM module is ready.
+ * Check if the VM is ready.
+ * Always returns true in the pure TypeScript implementation.
  */
 export declare function isReady(): boolean;

package/dist/index.js

@@ -1,76 +1,20 @@
 /**
  * Tenet - Declarative Logic VM for JSON Schemas
  *
- * This module provides a JavaScript/TypeScript wrapper around the Tenet WASM binary.
- * Works in both browser and Node.js environments.
+ * This module provides a pure TypeScript implementation of the Tenet VM.
+ * Works in both browser and Node.js environments with no WASM dependencies.
  */
-// Re-export lint functions (pure TypeScript, no WASM needed)
-export { lint, isTenetSchema, SCHEMA_URL } from './lint.js';
-let wasmReady = false;
-let wasmReadyPromise = null;
+// Import core engine functions
+import { run as coreRun, verify as coreVerify } from './core/engine.js';
 /**
- * Initialize the Tenet WASM module.
- * Must be called before using run() or verify().
+ * Initialize the Tenet VM.
+ * This is a no-op in the pure TypeScript implementation (kept for backwards compatibility).
  *
- * @param wasmPath - Path or URL to tenet.wasm file
+ * @deprecated No longer needed - the VM is ready immediately after import.
  */
-export async function init(wasmPath = './tenet.wasm') {
-    if (wasmReady)
-        return;
-    if (wasmReadyPromise)
-        return wasmReadyPromise;
-    wasmReadyPromise = loadWasm(wasmPath);
-    await wasmReadyPromise;
-    wasmReady = true;
-}
-async function loadWasm(wasmPath) {
-    // Detect environment
-    const isBrowser = typeof window !== 'undefined';
-    const isNode = typeof process !== 'undefined' && process.versions?.node;
-    if (isBrowser) {
-        // Browser environment
-        // Resolve paths relative to this module
-        const moduleUrl = new URL(import.meta.url);
-        const baseUrl = moduleUrl.href.substring(0, moduleUrl.href.lastIndexOf('/'));
-        // Load wasm_exec.js if Go is not defined
-        if (typeof Go === 'undefined') {
-            await new Promise((resolve, reject) => {
-                const script = document.createElement('script');
-                script.src = `${baseUrl}/../wasm/wasm_exec.js`;
-                script.onload = () => resolve();
-                script.onerror = () => reject(new Error('Failed to load wasm_exec.js'));
-                document.head.appendChild(script);
-            });
-        }
-        // Auto-resolve WASM path if default
-        const resolvedWasmPath = wasmPath === './tenet.wasm'
-            ? `${baseUrl}/../wasm/tenet.wasm`
-            : wasmPath;
-        const go = new Go();
-        const result = await WebAssembly.instantiateStreaming(fetch(resolvedWasmPath), go.importObject);
-        go.run(result.instance);
-    }
-    else if (isNode) {
-        // Node.js environment
-        const fs = await import('fs');
-        const path = await import('path');
-        const { fileURLToPath } = await import('url');
-        const { createRequire } = await import('module');
-        // ESM-compatible __dirname and require
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = path.dirname(__filename);
-        const require = createRequire(import.meta.url);
-        // Load wasm_exec.js (Go's JS runtime)
-        const wasmExecPath = path.resolve(__dirname, '../wasm/wasm_exec.js');
-        require(wasmExecPath);
-        const go = new Go();
-        const wasmBuffer = fs.readFileSync(wasmPath);
-        const result = await WebAssembly.instantiate(wasmBuffer, go.importObject);
-        go.run(result.instance);
-    }
-    else {
-        throw new Error('Unsupported environment');
-    }
+export async function init(_wasmPath) {
+    // No-op: pure TypeScript implementation doesn't need initialization
+    return Promise.resolve();
 }
 /**
  * Run the Tenet VM on a schema.
@@ -80,12 +24,7 @@ async function loadWasm(wasmPath) {
  * @returns The transformed schema with computed state, errors, and status
  */
 export function run(schema, date = new Date()) {
-    if (!wasmReady) {
-        throw new Error('Tenet not initialized. Call init() first.');
-    }
-    const jsonStr = typeof schema === 'string' ? schema : JSON.stringify(schema);
-    const dateStr = date instanceof Date ? date.toISOString() : date;
-    return globalThis.TenetRun(jsonStr, dateStr);
+    return coreRun(schema, date);
 }
 /**
  * Verify that a schema transformation is legal.
@@ -96,16 +35,12 @@ export function run(schema, date = new Date()) {
  * @returns Whether the transformation is valid
  */
 export function verify(newSchema, oldSchema) {
-    if (!wasmReady) {
-        throw new Error('Tenet not initialized. Call init() first.');
-    }
-    const newJson = typeof newSchema === 'string' ? newSchema : JSON.stringify(newSchema);
-    const oldJson = typeof oldSchema === 'string' ? oldSchema : JSON.stringify(oldSchema);
-    return globalThis.TenetVerify(newJson, oldJson);
+    return coreVerify(newSchema, oldSchema);
 }
 /**
- * Check if the WASM module is ready.
+ * Check if the VM is ready.
+ * Always returns true in the pure TypeScript implementation.
  */
 export function isReady() {
-    return wasmReady;
+    return true;
 }

package/dist/validation-fixes.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tests for validation fixes:
+ * - Issue 1: Empty string passes required validation
+ * - Issue 2: Derived fields shadowed by definitions
+ * - Issue 3: Execution order - logic before derived
+ */
+export {};