@dlovans/tenet-core 0.1.3 → 0.2.0

package/dist/core/validate.js

@@ -0,0 +1,194 @@
+/**
+ * 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 && (def.value === undefined || def.value === null)) {
+            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,8 +1,8 @@
 /**
  * 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';
@@ -49,6 +49,7 @@ export interface Definition {
     options?: string[];
     label?: string;
     required?: boolean;
+    readonly?: boolean;
     visible?: boolean;
     min?: number;
     max?: number;
@@ -90,22 +91,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 +116,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,59 +1,22 @@
 /**
  * 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)
+// Re-export lint functions (pure TypeScript)
 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
-        const go = new Go();
-        const result = await WebAssembly.instantiateStreaming(fetch(wasmPath), 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.
@@ -63,12 +26,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.
@@ -79,16 +37,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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dlovans/tenet-core",
-    "version": "0.1.3",
+    "version": "0.2.0",
     "type": "module",
     "description": "Declarative logic VM for JSON schemas - reactive validation, temporal routing, and computed state",
     "main": "dist/index.js",
@@ -16,13 +16,10 @@
         }
     },
     "files": [
-        "dist",
-        "wasm"
+        "dist"
     ],
     "scripts": {
-        "build:wasm": "cd .. && GOOS=js GOARCH=wasm go build -o js/wasm/tenet.wasm ./cmd/wasm",
-        "build:js": "tsc",
-        "build": "npm run build:wasm && npm run build:js",
+        "build": "tsc",
         "test": "node --test dist/*.test.js",
         "prepublishOnly": "npm run build"
     },
@@ -32,7 +29,6 @@
         "reactive",
         "schema",
         "form",
-        "wasm",
         "compliance",
         "temporal",
         "linter"
@@ -54,4 +50,4 @@
         "@types/node": "^25.0.9",
         "typescript": "^5.0.0"
     }
-}
+}