@dlovans/tenet-core 0.2.0 → 0.3.0

package/README.md

@@ -2,6 +2,8 @@
 
 Declarative logic VM for JSON schemas. Reactive validation, temporal routing, and computed state.
 
+**Pure TypeScript** — No WASM, no native dependencies. Works in browsers, Node.js, Deno, Bun.
+
 ## Installation
 
 ```bash
@@ -13,11 +15,8 @@ npm install @dlovans/tenet-core
 ### Browser
 
 ```html
-<script src="https://unpkg.com/@dlovans/tenet-core/wasm/wasm_exec.js"></script>
 <script type="module">
-import { init, run } from '@dlovans/tenet-core';
-
-await init('/path/to/tenet.wasm');
+import { run } from '@dlovans/tenet-core';
 
 const schema = {
   definitions: {
@@ -33,26 +32,23 @@ const schema = {
 };
 
 const result = run(schema);
-console.log(result);
+console.log(result.result.status); // 'READY'
 </script>
 ```
 
 ### Node.js
 
 ```javascript
-import { init, run, verify } from '@dlovans/tenet-core';
-
-// Initialize WASM
-await init('./node_modules/@dlovans/tenet-core/wasm/tenet.wasm');
+import { run, verify } from '@dlovans/tenet-core';
 
-// Run schema logic
+// Run schema logic - no initialization needed
 const result = run(schema, new Date());
 
 if (result.error) {
   console.error(result.error);
 } else {
   console.log(result.result.status); // 'READY', 'INCOMPLETE', or 'INVALID'
-  console.log(result.result.errors); // Validation errors
+  console.log(result.result.errors); // Validation errors (if any)
 }
 
 // Verify transformation
@@ -62,51 +58,57 @@ console.log(verification.valid);
 
 ## API
 
-### `init(wasmPath?: string): Promise<void>`
-Initialize the WASM module. Must be called before `run()` or `verify()`.
-
 ### `run(schema, date?): TenetResult`
 Execute the schema logic for the given effective date.
 
+- `schema` — TenetSchema object or JSON string
+- `date` — Effective date for temporal routing (default: now)
+
+Returns `{ result: TenetSchema }` or `{ error: string }`.
+
 ### `verify(newSchema, oldSchema): TenetVerifyResult`
 Verify that a transformation is legal by replaying the logic.
 
-### `lint(schema): LintResult` *(No WASM required)*
-Static analysis - find issues without executing the schema.
+Returns `{ valid: boolean, error?: string }`.
 
-```javascript
-import { lint } from '@dlovans/tenet-core';
+### `isReady(): boolean`
+Always returns `true`. Kept for backwards compatibility.
 
-const result = lint(schema);
-// No init() needed - pure TypeScript!
+### `init(): Promise<void>` *(deprecated)*
+No-op. Kept for backwards compatibility with v0.1.x.
 
-if (!result.valid) {
-  for (const issue of result.issues) {
-    console.log(`${issue.severity}: ${issue.message}`);
-  }
-}
-```
+## Runtime Validation
 
-### `isTenetSchema(obj): boolean`
-Check if an object is a Tenet schema.
+The VM automatically detects and reports:
 
-### `isReady(): boolean`
-Check if WASM is initialized.
+- **Undefined variables** — `{"var": "unknown_field"}`
+- **Unknown operators** — `{"invalid_op": [...]}`
+- **Temporal conflicts** — Overlapping date ranges, same start/end dates
 
-## JSON Schema (IDE Support)
+All errors are returned in `result.errors` without failing execution.
 
-Add to your schema files for autocompletion:
+## TypeScript
 
-```json
-{
-  "$schema": "https://tenet.dev/schema/v1.json",
-  "definitions": { ... }
-}
+Full type definitions included:
+
+```typescript
+import type { TenetSchema, TenetResult, Definition, Rule } from '@dlovans/tenet-core';
 ```
 
-## TypeScript
+## Migration from v0.1.x
 
-Full type definitions are included. See `TenetSchema`, `Definition`, `Rule`, `LintResult`, etc.
+```javascript
+// Before (v0.1.x with WASM)
+import { init, run, lint } from '@dlovans/tenet-core';
+await init('./tenet.wasm');
+const result = run(schema);
+const issues = lint(schema);
+
+// After (v0.2.x pure TypeScript)
+import { run } from '@dlovans/tenet-core';
+const result = run(schema);
+// Validation errors are now in result.result.errors
+```
 
 ## License
 

package/dist/core/engine.d.ts

@@ -15,9 +15,12 @@ export declare function run(schema: TenetSchema | string, effectiveDate?: Date |
  * Verify that a completed document was correctly derived from a base schema.
  * Simulates the user's journey by iteratively copying visible field values and re-running.
  *
+ * Returns a structured result with all issues found (not just the first).
+ * Crash-safe: catches any unexpected error and returns it as an internal_error issue.
+ *
  * @param newSchema - The completed/submitted schema
  * @param oldSchema - The original base schema
  * @param maxIterations - Maximum replay iterations (default: 100)
- * @returns Whether the transformation was valid
+ * @returns Structured verification result
  */
 export declare function verify(newSchema: TenetSchema | string, oldSchema: TenetSchema | string, maxIterations?: number): TenetVerifyResult;

package/dist/core/engine.js

@@ -80,7 +80,7 @@ function setDefinitionValue(state, key, value, ruleId) {
     // Cycle detection
     const prevRule = state.fieldsSet.get(key);
     if (prevRule && prevRule !== ruleId) {
-        addError(state, key, ruleId, `Potential cycle: field '${key}' set by rule '${prevRule}' and again by rule '${ruleId}'`);
+        addError(state, key, ruleId, 'cycle_detected', `Potential cycle: field '${key}' set by rule '${prevRule}' and again by rule '${ruleId}'`);
     }
     state.fieldsSet.set(key, ruleId);
     const def = state.schema.definitions[key];
@@ -118,7 +118,7 @@ function applyAction(state, action, ruleId, lawRef) {
     }
     // Emit error if specified
     if (action.error_msg) {
-        addError(state, '', ruleId, action.error_msg, lawRef);
+        addError(state, '', ruleId, 'runtime_warning', action.error_msg, lawRef);
     }
 }
 /**
@@ -152,13 +152,23 @@ function computeDerived(state) {
         }
         // Evaluate the expression
         const value = resolve(derivedDef.eval, state);
-        // Store the computed value as a definition (readonly)
-        state.schema.definitions[name] = {
-            type: inferType(value),
-            value,
-            readonly: true,
-            visible: true,
-        };
+        // Preserve existing definition metadata if present
+        const existing = state.schema.definitions[name];
+        if (existing) {
+            existing.value = value;
+            existing.readonly = true;
+            if (existing.visible === undefined) {
+                existing.visible = true;
+            }
+        }
+        else {
+            state.schema.definitions[name] = {
+                type: inferType(value),
+                value,
+                readonly: true,
+                visible: true,
+            };
+        }
     }
 }
 /**
@@ -190,20 +200,23 @@ export function run(schema, effectiveDate = new Date()) {
             effectiveDate: date,
             fieldsSet: new Map(),
             errors: [],
+            derivedInProgress: new Set(),
         };
         // 1. Select temporal branch and prune inactive rules
         applyTemporalRouting(state);
-        // 2. Evaluate logic tree
+        // 2. Compute derived state (so logic tree can use derived values)
+        computeDerived(state);
+        // 3. Evaluate logic tree
         evaluateLogicTree(state);
-        // 3. Compute derived state
+        // 4. Re-compute derived state (in case logic modified inputs)
         computeDerived(state);
-        // 4. Validate definitions
+        // 5. Validate definitions
         validateDefinitions(state);
-        // 5. Check attestations
+        // 6. Check attestations
         checkAttestations(state, (action, ruleId, lawRef) => {
             applyAction(state, action, ruleId, lawRef);
         });
-        // 6. Determine status and attach errors
+        // 7. Determine status and attach errors
         state.schema.errors = state.errors.length > 0 ? state.errors : undefined;
         state.schema.status = determineStatus(state);
         return { result: state.schema };
@@ -225,25 +238,29 @@ function getVisibleEditableFields(schema) {
     return result;
 }
 /**
- * Count visible fields in a schema.
+ * Get a sorted, comma-joined string of visible field IDs for convergence detection.
  */
-function countVisibleFields(schema) {
-    let count = 0;
-    for (const def of Object.values(schema.definitions)) {
-        if (def?.visible) {
-            count++;
-        }
-    }
-    return count;
+function getVisibleFieldIds(schema) {
+    return Object.entries(schema.definitions)
+        .filter(([, def]) => def?.visible)
+        .map(([id]) => id)
+        .sort()
+        .join(',');
 }
 /**
  * Validate that the final state matches expected values.
+ * Collects ALL issues instead of bailing on the first — the UI needs the complete picture.
  */
 function validateFinalState(newSchema, resultSchema) {
+    const issues = [];
     // Check for unknown/injected fields in newSchema that don't exist in result
     for (const id of Object.keys(newSchema.definitions)) {
         if (!(id in resultSchema.definitions)) {
-            return [false, `Unknown field '${id}' not in schema`];
+            issues.push({
+                code: 'unknown_field',
+                field_id: id,
+                message: `Field '${id}' does not exist in the schema`,
+            });
         }
     }
     // Compare computed (readonly) values
@@ -253,49 +270,85 @@ function validateFinalState(newSchema, resultSchema) {
         }
         const newDef = newSchema.definitions[id];
         if (!newDef) {
-            return [false, `Computed field '${id}' missing in submitted document`];
+            issues.push({
+                code: 'computed_mismatch',
+                field_id: id,
+                message: `Computed field '${id}' is missing from the submitted document`,
+                expected: resultDef.value,
+            });
+            continue;
         }
         if (!compareEqual(newDef.value, resultDef.value)) {
-            return [false, `Computed field '${id}' mismatch: claimed ${JSON.stringify(newDef.value)}, expected ${JSON.stringify(resultDef.value)}`];
+            issues.push({
+                code: 'computed_mismatch',
+                field_id: id,
+                message: `Computed field '${id}' was modified`,
+                expected: resultDef.value,
+                claimed: newDef.value,
+            });
         }
     }
     // Verify attestations are fulfilled
     if (resultSchema.attestations) {
         for (const [id, resultAtt] of Object.entries(resultSchema.attestations)) {
-            if (!resultAtt) {
+            if (!resultAtt?.required) {
                 continue;
             }
             const newAtt = newSchema.attestations?.[id];
             if (!newAtt) {
                 continue;
             }
-            if (resultAtt.required) {
-                if (!newAtt.signed) {
-                    return [false, `Required attestation '${id}' not signed`];
-                }
-                if (!newAtt.evidence?.provider_audit_id) {
-                    return [false, `Attestation '${id}' missing evidence`];
-                }
-                if (!newAtt.evidence?.timestamp) {
-                    return [false, `Attestation '${id}' missing timestamp`];
-                }
+            if (!newAtt.signed) {
+                issues.push({
+                    code: 'attestation_unsigned',
+                    field_id: id,
+                    message: `Required attestation '${id}' has not been signed`,
+                });
+                continue; // No point checking evidence if unsigned
+            }
+            if (!newAtt.evidence?.provider_audit_id) {
+                issues.push({
+                    code: 'attestation_no_evidence',
+                    field_id: id,
+                    message: `Attestation '${id}' is signed but missing proof of signing`,
+                });
+            }
+            if (!newAtt.evidence?.timestamp) {
+                issues.push({
+                    code: 'attestation_no_timestamp',
+                    field_id: id,
+                    message: `Attestation '${id}' is signed but missing a timestamp`,
+                });
             }
         }
     }
     // Verify status matches
     if (newSchema.status !== resultSchema.status) {
-        return [false, `Status mismatch: claimed ${newSchema.status}, expected ${resultSchema.status}`];
+        issues.push({
+            code: 'status_mismatch',
+            message: 'The document status does not match what was computed',
+            expected: resultSchema.status,
+            claimed: newSchema.status,
+        });
     }
-    return [true, undefined];
+    return {
+        valid: issues.length === 0,
+        status: resultSchema.status,
+        issues: issues.length > 0 ? issues : undefined,
+        schema: resultSchema,
+    };
 }
 /**
  * Verify that a completed document was correctly derived from a base schema.
  * Simulates the user's journey by iteratively copying visible field values and re-running.
  *
+ * Returns a structured result with all issues found (not just the first).
+ * Crash-safe: catches any unexpected error and returns it as an internal_error issue.
+ *
  * @param newSchema - The completed/submitted schema
  * @param oldSchema - The original base schema
  * @param maxIterations - Maximum replay iterations (default: 100)
- * @returns Whether the transformation was valid
+ * @returns Structured verification result
  */
 export function verify(newSchema, oldSchema, maxIterations = 100) {
     try {
@@ -316,7 +369,7 @@ export function verify(newSchema, oldSchema, maxIterations = 100) {
         }
         // Start with base schema
         let currentSchema = parsedOldSchema;
-        let previousVisibleCount = -1;
+        let previousVisibleIds = '';
         for (let iteration = 0; iteration < maxIterations; iteration++) {
             // Count visible editable fields before copying
             const visibleEditable = getVisibleEditableFields(currentSchema);
@@ -343,23 +396,42 @@ export function verify(newSchema, oldSchema, maxIterations = 100) {
             // Run the schema
             const runResult = run(currentSchema, effectiveDate);
             if (runResult.error) {
-                return { valid: false, error: `Run failed (iteration ${iteration}): ${runResult.error}` };
+                return {
+                    valid: false,
+                    issues: [{
+                            code: 'internal_error',
+                            message: `VM run failed at iteration ${iteration}`,
+                        }],
+                    error: `Run failed (iteration ${iteration}): ${runResult.error}`,
+                };
             }
             const resultSchema = runResult.result;
-            // Count visible fields after run
-            const currentVisibleCount = countVisibleFields(resultSchema);
-            // Check for convergence
-            if (currentVisibleCount === previousVisibleCount) {
-                // Converged - now validate the final state
-                const [valid, error] = validateFinalState(parsedNewSchema, resultSchema);
-                return { valid, error };
+            // Get visible field IDs after run
+            const currentVisibleIds = getVisibleFieldIds(resultSchema);
+            // Check for convergence using set comparison
+            if (currentVisibleIds === previousVisibleIds) {
+                // Converged - now validate the final state and return full result
+                return validateFinalState(parsedNewSchema, resultSchema);
             }
-            previousVisibleCount = currentVisibleCount;
+            previousVisibleIds = currentVisibleIds;
             currentSchema = resultSchema;
         }
-        return { valid: false, error: `Verification did not converge after ${maxIterations} iterations` };
+        return {
+            valid: false,
+            issues: [{
+                    code: 'convergence_failed',
+                    message: `Document did not converge after ${maxIterations} iterations`,
+                }],
+        };
     }
     catch (error) {
-        return { valid: false, error: String(error) };
+        return {
+            valid: false,
+            issues: [{
+                    code: 'internal_error',
+                    message: `Unexpected error during verification`,
+                }],
+            error: String(error),
+        };
     }
 }

package/dist/core/operators.js

@@ -2,6 +2,7 @@
  * JSON-logic operators for the Tenet VM.
  * All operators are nil-safe: operations on nil/undefined return appropriate defaults.
  */
+import { addError } from './validate.js';
 /**
  * Convert a value to a number if possible.
  */
@@ -99,17 +100,56 @@ function resolveArgs(args, expected, resolve, state) {
     }
     return result;
 }
+/**
+ * Check if a variable name is defined in the schema.
+ */
+function isVariableDefined(name, state) {
+    // Check definitions
+    if (state.schema.definitions[name]) {
+        return true;
+    }
+    // Check derived state
+    if (state.schema.state_model?.derived?.[name]) {
+        return true;
+    }
+    return false;
+}
 /**
  * Get variable value from schema definitions or current element context.
+ * Now accepts an optional resolve function to evaluate derived expressions on-demand.
  */
-function getVar(path, state) {
+function getVar(path, state, resolve) {
     // Empty path returns current element context (for some/all/none)
     if (path === '') {
         return state.currentElement;
     }
     const parts = path.split('.');
-    // Check definitions first
-    const def = state.schema.definitions[parts[0]];
+    const rootVar = parts[0];
+    // Check if variable is defined (only for root-level vars, not nested access)
+    if (!isVariableDefined(rootVar, state) && state.currentElement === undefined) {
+        addError(state, '', '', 'runtime_warning', `Undefined variable '${rootVar}' in logic expression`);
+        return null;
+    }
+    // First, check derived state (derived values take precedence)
+    if (state.schema.state_model?.derived && resolve) {
+        const derived = state.schema.state_model.derived[rootVar];
+        if (derived?.eval) {
+            // Cycle detection for derived fields
+            if (state.derivedInProgress.has(rootVar)) {
+                addError(state, '', '', 'cycle_detected', `Circular dependency detected in derived field '${rootVar}'`);
+                return null;
+            }
+            state.derivedInProgress.add(rootVar);
+            const result = resolve(derived.eval, state);
+            state.derivedInProgress.delete(rootVar);
+            if (parts.length === 1) {
+                return result;
+            }
+            return accessPath(result, parts.slice(1));
+        }
+    }
+    // Then, check definitions
+    const def = state.schema.definitions[rootVar];
     if (def) {
         if (parts.length === 1) {
             return def.value;
@@ -117,15 +157,6 @@ function getVar(path, state) {
         // Nested access into the value
         return accessPath(def.value, parts.slice(1));
     }
-    // Check derived state
-    if (state.schema.state_model?.derived) {
-        const derived = state.schema.state_model.derived[parts[0]];
-        if (derived) {
-            // Note: derived values should already be computed by this point
-            // This is a fallback for direct access
-            return undefined;
-        }
-    }
     return undefined;
 }
 /**
@@ -147,9 +178,9 @@ function accessPath(value, parts) {
 // ============================================================
 const operators = {
     // === Variable Access ===
-    'var': (args, state) => {
+    'var': (args, state, resolve) => {
         const path = typeof args === 'string' ? args : '';
-        return getVar(path, state);
+        return getVar(path, state, resolve);
     },
     // === Comparison Operators ===
     '==': (args, state, resolve) => {
@@ -417,7 +448,7 @@ const operators = {
 export function applyOperator(op, args, state, resolve) {
     const fn = operators[op];
     if (!fn) {
-        // Unknown operator - return null
+        addError(state, '', '', 'runtime_warning', `Unknown operator '${op}' in logic expression`);
         return null;
     }
     return fn(args, state, resolve);

package/dist/core/temporal.js

@@ -2,6 +2,44 @@
  * Temporal branch selection and rule pruning.
  * Routes logic based on effective dates for bitemporal support.
  */
+import { addError } from './validate.js';
+/**
+ * Validate temporal_map for configuration errors.
+ * Checks for same start/end dates and overlapping ranges.
+ */
+function validateTemporalMap(state) {
+    const { schema } = state;
+    if (!schema.temporal_map || schema.temporal_map.length === 0) {
+        return;
+    }
+    for (let i = 0; i < schema.temporal_map.length; i++) {
+        const branch = schema.temporal_map[i];
+        if (!branch) {
+            continue;
+        }
+        const start = branch.valid_range[0];
+        const end = branch.valid_range[1];
+        // Check for same start/end date (invalid zero-length range)
+        if (start && end && start === end) {
+            addError(state, '', '', 'runtime_warning', `Temporal branch ${i} has same start and end date '${start}' (invalid range)`);
+        }
+        // Check for overlapping with previous branch
+        if (i > 0) {
+            const prev = schema.temporal_map[i - 1];
+            if (prev) {
+                const prevEnd = prev.valid_range[1]
+                    ? new Date(prev.valid_range[1]).getTime()
+                    : Infinity;
+                const currStart = start
+                    ? new Date(start).getTime()
+                    : -Infinity;
+                if (currStart <= prevEnd) {
+                    addError(state, '', '', 'runtime_warning', `Temporal branch ${i} overlaps with branch ${i - 1} (ranges must not overlap)`);
+                }
+            }
+        }
+    }
+}
 /**
  * Find the active temporal branch for a given effective date.
  * Returns undefined if no branch matches (uses default/unversioned logic).
@@ -62,6 +100,8 @@ export function pruneRules(state, activeBranch) {
  * Call this at the start of Run().
  */
 export function applyTemporalRouting(state) {
+    // Validate temporal_map configuration
+    validateTemporalMap(state);
     const branch = selectBranch(state);
     if (branch) {
         pruneRules(state, branch);