@dlovans/tenet-core 0.2.0 → 0.2.1

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.js

@@ -193,17 +193,19 @@ export function run(schema, effectiveDate = new Date()) {
         };
         // 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 };

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,50 @@ 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, '', '', `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) {
+            // Evaluate the derived expression on-demand
+            const result = resolve(derived.eval, state);
+            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 +151,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 +172,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 +442,7 @@ const operators = {
 export function applyOperator(op, args, state, resolve) {
     const fn = operators[op];
     if (!fn) {
-        // Unknown operator - return null
+        addError(state, '', '', `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, '', '', `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, '', '', `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);

package/dist/core/validate.js

@@ -120,8 +120,14 @@ export function validateDefinitions(state) {
             continue;
         }
         // Check required fields
-        if (def.required && (def.value === undefined || def.value === null)) {
-            addError(state, id, '', `Required field '${id}' is missing`);
+        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) {

package/dist/index.d.ts

@@ -4,8 +4,6 @@
  * 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;

package/dist/index.js

@@ -4,8 +4,6 @@
  * 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)
-export { lint, isTenetSchema, SCHEMA_URL } from './lint.js';
 // Import core engine functions
 import { run as coreRun, verify as coreVerify } from './core/engine.js';
 /**

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 {};

package/dist/validation-fixes.test.js

@@ -0,0 +1,399 @@
+/**
+ * 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
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { run } from './index.js';
+// ===========================================================================
+// Issue 1: Empty String Required Validation
+// ===========================================================================
+describe('Issue 1: Empty String Required Validation', () => {
+    it('should treat empty string as missing for required string fields', () => {
+        const schema = {
+            protocol: 'Test_v1',
+            schema_id: 'test',
+            definitions: {
+                name: { type: 'string', value: '', required: true },
+            },
+        };
+        const result = run(schema);
+        assert.ok(!result.error, `Run failed: ${result.error}`);
+        assert.ok(result.result);
+        // Status should be INCOMPLETE because empty string is "missing"
+        assert.strictEqual(result.result.status, 'INCOMPLETE', `Expected status INCOMPLETE for empty required string, got ${result.result.status}`);
+        // Should have an error for the missing field
+        assert.ok(result.result.errors && result.result.errors.length > 0, 'Expected error for empty required string');
+    });
+    it('should accept empty string for non-required fields', () => {
+        const schema = {
+            protocol: 'Test_v1',
+            schema_id: 'test',
+            definitions: {
+                notes: { type: 'string', value: '', required: false },
+            },
+        };
+        const result = run(schema);
+        assert.ok(!result.error);
+        assert.ok(result.result);
+        // Status should be READY because field is not required
+        assert.strictEqual(result.result.status, 'READY');
+    });
+    it('should accept zero for required number fields', () => {
+        const schema = {
+            protocol: 'Test_v1',
+            schema_id: 'test',
+            definitions: {
+                quantity: { type: 'number', value: 0, required: true },
+            },
+        };
+        const result = run(schema);
+        assert.ok(!result.error);
+        assert.ok(result.result);
+        // Status should be READY (0 is a valid value for required number)
+        assert.strictEqual(result.result.status, 'READY');
+    });
+    it('should catch empty allergy_note in survey schema', () => {
+        const schema = {
+            protocol: 'CoffeePreferenceSurvey_v1',
+            schema_id: 'coffee-pref-001',
+            definitions: {
+                respondent_name: {
+                    type: 'string',
+                    label: 'Your Name',
+                    required: true,
+                    value: 'Jane Doe',
+                },
+                allergy_note: {
+                    type: 'string',
+                    label: 'Please describe your allergy',
+                    required: true,
+                    visible: true,
+                    value: '',
+                },
+            },
+        };
+        const result = run(schema);
+        assert.ok(!result.error);
+        assert.ok(result.result);
+        // Should be INCOMPLETE because allergy_note is required but empty
+        assert.strictEqual(result.result.status, 'INCOMPLETE');
+    });
+});
+// ===========================================================================
+// Issue 2: Derived Fields Shadowing
+// ===========================================================================
+describe('Issue 2: Derived Fields Take Precedence', () => {
+    it('should compute derived value even when field exists in definitions', () => {
+        const schema = {
+            protocol: 'Test_v1',
+            schema_id: 'test',
+            definitions: {
+                gross: { type: 'number', value: 100 },
+                tax: { type: 'number', value: null, readonly: true },
+            },
+            state_model: {
+                inputs: ['gross'],
+                derived: {
+                    tax: { eval: { '*': [{ var: 'gross' }, 0.1] } },
+                },
+            },
+        };
+        const result = run(schema);
+        assert.ok(!result.error);
+        assert.ok(result.result);
+        // Tax should be computed as 10 (100 * 0.1)
+        const taxDef = result.result.definitions.tax;
+        assert.ok(taxDef, 'Expected tax definition to exist');
+        assert.strictEqual(taxDef.value, 10, `Expected tax = 10, got ${taxDef.value}`);
+    });
+    it('should allow logic tree to use derived values', () => {
+        const schema = {
+            protocol: 'Test_v1',
+            schema_id: 'test',
+            definitions: {
+                gross: { type: 'number', value: 100 },
+            },
+            state_model: {
+                inputs: ['gross'],
+                derived: {
+                    tax: { eval: { '*': [{ var: 'gross' }, 0.1] } },
+                },
+            },
+            logic_tree: [
+                {
+                    id: 'check_tax',
+                    when: { '>': [{ var: 'tax' }, 5] },
+                    then: { set: { high_tax: true } },
+                },
+            ],
+        };
+        const result = run(schema);
+        assert.ok(!result.error);
+        assert.ok(result.result);
+        // high_tax should be set because tax (10) > 5
+        const highTaxDef = result.result.definitions.high_tax;
+        assert.ok(highTaxDef, 'Expected high_tax definition to be created');
+        assert.strictEqual(highTaxDef.value, true, `Expected high_tax = true, got ${highTaxDef.value}`);
+    });
+});
+// ===========================================================================
+// Issue 3: Execution Order (Logic Before Derived)
+// ===========================================================================
+describe('Issue 3: Logic Can Use Derived Values', () => {
+    it('should compute derived values before logic tree evaluation', () => {
+        const schema = {
+            protocol: 'Test_v1',
+            schema_id: 'test',
+            definitions: {
+                income: { type: 'number', value: 50000 },
+                deductions: { type: 'number', value: 10000 },
+            },
+            state_model: {
+                inputs: ['income', 'deductions'],
+                derived: {
+                    taxable_income: { eval: { '-': [{ var: 'income' }, { var: 'deductions' }] } },
+                },
+            },
+            logic_tree: [
+                {
+                    id: 'high_income_bracket',
+                    when: { '>': [{ var: 'taxable_income' }, 30000] },
+                    then: { set: { tax_bracket: 'high' } },
+                },
+            ],
+        };
+        const result = run(schema);
+        assert.ok(!result.error);
+        assert.ok(result.result);
+        // taxable_income should be 40000 (50000 - 10000)
+        const taxableIncomeDef = result.result.definitions.taxable_income;
+        assert.ok(taxableIncomeDef, 'Expected taxable_income definition');
+        assert.strictEqual(taxableIncomeDef.value, 40000);
+        // tax_bracket should be "high" because taxable_income (40000) > 30000
+        const taxBracketDef = result.result.definitions.tax_bracket;
+        assert.ok(taxBracketDef, 'Expected tax_bracket to be set by logic rule');
+        assert.strictEqual(taxBracketDef.value, 'high');
+    });
+    it('should calculate effective tax rate in tax calculator schema', () => {
+        const schema = {
+            protocol: 'IncomeTaxCalculator_v1',
+            schema_id: 'tax-calc-001',
+            definitions: {
+                gross_annual_income: { type: 'currency', value: 85000 },
+                filing_status: {
+                    type: 'select',
+                    options: ['single', 'married_joint', 'married_separate'],
+                    value: 'single',
+                },
+                standard_deduction: { type: 'currency', readonly: true, value: null },
+                taxable_income: { type: 'currency', readonly: true, value: null },
+                effective_tax_rate: { type: 'number', readonly: true, value: null },
+            },
+            state_model: {
+                inputs: ['gross_annual_income', 'filing_status'],
+                derived: {
+                    standard_deduction: {
+                        eval: {
+                            if: [
+                                { '==': [{ var: 'filing_status' }, 'single'] },
+                                14600,
+                                { '==': [{ var: 'filing_status' }, 'married_joint'] },
+                                29200,
+                                21900,
+                            ],
+                        },
+                    },
+                    taxable_income: {
+                        eval: {
+                            '-': [{ var: 'gross_annual_income' }, { var: 'standard_deduction' }],
+                        },
+                    },
+                },
+            },
+            logic_tree: [
+                {
+                    id: 'calc_effective_rate',
+                    when: { '>': [{ var: 'taxable_income' }, 0] },
+                    then: {
+                        set: {
+                            effective_tax_rate: {
+                                '/': [
+                                    { '*': [{ var: 'taxable_income' }, 0.22] },
+                                    { var: 'gross_annual_income' },
+                                ],
+                            },
+                        },
+                    },
+                },
+            ],
+        };
+        const result = run(schema);
+        assert.ok(!result.error);
+        assert.ok(result.result);
+        // Check standard_deduction is 14600 for single
+        const stdDedDef = result.result.definitions.standard_deduction;
+        assert.ok(stdDedDef, 'Expected standard_deduction definition');
+        assert.strictEqual(stdDedDef.value, 14600);
+        // Check taxable_income is 70400 (85000 - 14600)
+        const taxableIncomeDef = result.result.definitions.taxable_income;
+        assert.ok(taxableIncomeDef, 'Expected taxable_income definition');
+        assert.strictEqual(taxableIncomeDef.value, 70400);
+        // Check effective_tax_rate is calculated (70400 * 0.22 / 85000 = ~0.182)
+        const effectiveRateDef = result.result.definitions.effective_tax_rate;
+        assert.ok(effectiveRateDef, 'Expected effective_tax_rate to be calculated');
+        const effectiveVal = effectiveRateDef.value;
+        assert.ok(effectiveVal > 0.18 && effectiveVal < 0.19, `Expected effective_tax_rate around 0.182, got ${effectiveVal}`);
+    });
+});
+// ===========================================================================
+// Edge Cases & Complex Scenarios
+// ===========================================================================
+describe('Edge Cases', () => {
+    it('should handle chained derived fields', () => {
+        const schema = {
+            protocol: 'Test_v1',
+            schema_id: 'test',
+            definitions: {
+                base: { type: 'number', value: 100 },
+            },
+            state_model: {
+                inputs: ['base'],
+                derived: {
+                    level1: { eval: { '*': [{ var: 'base' }, 2] } },
+                    level2: { eval: { '*': [{ var: 'level1' }, 3] } },
+                },
+            },
+        };
+        const result = run(schema);
+        assert.ok(!result.error);
+        assert.ok(result.result);
+        // level1 = 100 * 2 = 200
+        const level1Def = result.result.definitions.level1;
+        assert.ok(level1Def);
+        assert.strictEqual(level1Def.value, 200);
+        // level2 = 200 * 3 = 600
+        const level2Def = result.result.definitions.level2;
+        assert.ok(level2Def);
+        assert.strictEqual(level2Def.value, 600);
+    });
+    it('should re-compute derived after logic modifies inputs', () => {
+        const schema = {
+            protocol: 'Test_v1',
+            schema_id: 'test',
+            definitions: {
+                discount_eligible: { type: 'boolean', value: false },
+                base_price: { type: 'number', value: 100 },
+            },
+            state_model: {
+                inputs: ['discount_eligible', 'base_price'],
+                derived: {
+                    final_price: {
+                        eval: {
+                            if: [
+                                { var: 'discount_eligible' },
+                                { '*': [{ var: 'base_price' }, 0.9] },
+                                { var: 'base_price' },
+                            ],
+                        },
+                    },
+                },
+            },
+            logic_tree: [
+                {
+                    id: 'apply_discount',
+                    when: { '>': [{ var: 'base_price' }, 50] },
+                    then: { set: { discount_eligible: true } },
+                },
+            ],
+        };
+        const result = run(schema);
+        assert.ok(!result.error);
+        assert.ok(result.result);
+        // discount_eligible should be true
+        const discountDef = result.result.definitions.discount_eligible;
+        assert.ok(discountDef);
+        assert.strictEqual(discountDef.value, true);
+        // final_price should be 90 (100 * 0.9) because discount_eligible was set by logic
+        const finalPriceDef = result.result.definitions.final_price;
+        assert.ok(finalPriceDef);
+        assert.strictEqual(finalPriceDef.value, 90);
+    });
+    it('should catch multiple required empty strings', () => {
+        const schema = {
+            protocol: 'Test_v1',
+            schema_id: 'test',
+            definitions: {
+                first_name: { type: 'string', value: '', required: true },
+                last_name: { type: 'string', value: '', required: true },
+                nickname: { type: 'string', value: '', required: false },
+            },
+        };
+        const result = run(schema);
+        assert.ok(!result.error);
+        assert.ok(result.result);
+        // Status should be INCOMPLETE
+        assert.strictEqual(result.result.status, 'INCOMPLETE');
+        // Should have errors for both first_name and last_name
+        assert.ok(result.result.errors && result.result.errors.length >= 2, 'Expected at least 2 errors');
+    });
+    it('should use derived value when definition has null value', () => {
+        const schema = {
+            protocol: 'Test_v1',
+            schema_id: 'test',
+            definitions: {
+                input_a: { type: 'number', value: 10 },
+                input_b: { type: 'number', value: 20 },
+                result: { type: 'number', value: null, readonly: true },
+            },
+            state_model: {
+                inputs: ['input_a', 'input_b'],
+                derived: {
+                    result: { eval: { '+': [{ var: 'input_a' }, { var: 'input_b' }] } },
+                },
+            },
+        };
+        const result = run(schema);
+        assert.ok(!result.error);
+        assert.ok(result.result);
+        // result should be 30 (10 + 20), not null
+        const resultDef = result.result.definitions.result;
+        assert.ok(resultDef);
+        assert.strictEqual(resultDef.value, 30);
+    });
+    it('should compare two derived values in logic', () => {
+        const schema = {
+            protocol: 'Test_v1',
+            schema_id: 'test',
+            definitions: {
+                price_a: { type: 'number', value: 100 },
+                price_b: { type: 'number', value: 80 },
+            },
+            state_model: {
+                inputs: ['price_a', 'price_b'],
+                derived: {
+                    discounted_a: { eval: { '*': [{ var: 'price_a' }, 0.8] } },
+                    discounted_b: { eval: { '*': [{ var: 'price_b' }, 0.9] } },
+                },
+            },
+            logic_tree: [
+                {
+                    id: 'compare_prices',
+                    when: { '>': [{ var: 'discounted_a' }, { var: 'discounted_b' }] },
+                    then: { set: { best_deal: 'B' } },
+                },
+            ],
+        };
+        const result = run(schema);
+        assert.ok(!result.error);
+        assert.ok(result.result);
+        // discounted_a = 100 * 0.8 = 80
+        // discounted_b = 80 * 0.9 = 72
+        // 80 > 72, so best_deal = "B"
+        const bestDealDef = result.result.definitions.best_deal;
+        assert.ok(bestDealDef, 'Expected best_deal to be set');
+        assert.strictEqual(bestDealDef.value, 'B');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dlovans/tenet-core",
-    "version": "0.2.0",
+    "version": "0.2.1",
     "type": "module",
     "description": "Declarative logic VM for JSON schemas - reactive validation, temporal routing, and computed state",
     "main": "dist/index.js",
@@ -9,10 +9,6 @@
         ".": {
             "import": "./dist/index.js",
             "types": "./dist/index.d.ts"
-        },
-        "./lint": {
-            "import": "./dist/lint.js",
-            "types": "./dist/lint.d.ts"
         }
     },
     "files": [
@@ -30,8 +26,7 @@
         "schema",
         "form",
         "compliance",
-        "temporal",
-        "linter"
+        "temporal"
     ],
     "author": "Dlovan Sharif",
     "license": "MIT",

package/dist/lint.d.ts

@@ -1,31 +0,0 @@
-/**
- * Tenet Linter - Static Analysis for Tenet Schemas
- *
- * Pure TypeScript implementation - no WASM required.
- * Can be used in browsers, Node.js, and edge runtimes.
- */
-import type { TenetSchema } from './index';
-export declare const SCHEMA_URL = "https://tenet.dev/schema/v1.json";
-export interface LintIssue {
-    severity: 'error' | 'warning' | 'info';
-    field?: string;
-    rule?: string;
-    message: string;
-}
-export interface LintResult {
-    valid: boolean;
-    issues: LintIssue[];
-}
-/**
- * Perform static analysis on a Tenet schema without executing it.
- * Detects potential issues like undefined variables, cycles, and missing fields.
- *
- * @param schema - The schema object or JSON string
- * @returns Lint result with issues found
- */
-export declare function lint(schema: TenetSchema | string): LintResult;
-/**
- * Check if a schema is a valid Tenet schema (basic detection).
- * Useful for IDE integration to detect Tenet files.
- */
-export declare function isTenetSchema(schema: unknown): schema is TenetSchema;

package/dist/lint.js

@@ -1,160 +0,0 @@
-/**
- * Tenet Linter - Static Analysis for Tenet Schemas
- *
- * Pure TypeScript implementation - no WASM required.
- * Can be used in browsers, Node.js, and edge runtimes.
- */
-// JSON Schema URL for IDE integration
-export const SCHEMA_URL = 'https://tenet.dev/schema/v1.json';
-/**
- * Perform static analysis on a Tenet schema without executing it.
- * Detects potential issues like undefined variables, cycles, and missing fields.
- *
- * @param schema - The schema object or JSON string
- * @returns Lint result with issues found
- */
-export function lint(schema) {
-    let parsed;
-    try {
-        parsed = typeof schema === 'string' ? JSON.parse(schema) : schema;
-    }
-    catch (e) {
-        return {
-            valid: false,
-            issues: [{ severity: 'error', message: `Parse error: ${e}` }]
-        };
-    }
-    const result = {
-        valid: true,
-        issues: []
-    };
-    // Collect all defined field names
-    const definedFields = new Set();
-    if (parsed.definitions) {
-        for (const name of Object.keys(parsed.definitions)) {
-            definedFields.add(name);
-        }
-    }
-    // Add derived fields
-    if (parsed.state_model?.derived) {
-        for (const name of Object.keys(parsed.state_model.derived)) {
-            definedFields.add(name);
-        }
-    }
-    // Check 1: Schema identification
-    if (!parsed.protocol && !parsed['$schema']) {
-        result.issues.push({
-            severity: 'info',
-            message: `Consider adding "protocol": "Tenet_v1.0" or "$schema": "${SCHEMA_URL}" for IDE support`
-        });
-    }
-    // Check 2: Undefined variables in logic tree
-    if (parsed.logic_tree) {
-        for (const rule of parsed.logic_tree) {
-            if (!rule)
-                continue;
-            const varsInWhen = extractVars(rule.when);
-            for (const v of varsInWhen) {
-                if (!definedFields.has(v)) {
-                    addError(result, v, rule.id, `Undefined variable '${v}' in rule condition`);
-                }
-            }
-        }
-    }
-    // Check 3: Potential cycles (fields set by multiple rules)
-    const fieldSetBy = new Map();
-    if (parsed.logic_tree) {
-        for (const rule of parsed.logic_tree) {
-            if (!rule?.then?.set)
-                continue;
-            for (const field of Object.keys(rule.then.set)) {
-                const rules = fieldSetBy.get(field) || [];
-                rules.push(rule.id);
-                fieldSetBy.set(field, rules);
-            }
-        }
-    }
-    for (const [field, rules] of fieldSetBy) {
-        if (rules.length > 1) {
-            addWarning(result, field, '', `Field '${field}' may be set by multiple rules: [${rules.sort().join(', ')}] (potential cycle)`);
-        }
-    }
-    // Check 4: Temporal map validation
-    if (parsed.temporal_map) {
-        for (let i = 0; i < parsed.temporal_map.length; i++) {
-            const branch = parsed.temporal_map[i];
-            if (!branch)
-                continue;
-            if (!branch.logic_version) {
-                addWarning(result, '', '', `Temporal branch ${i} has no logic_version`);
-            }
-        }
-    }
-    // Check 5: Empty type in definitions
-    if (parsed.definitions) {
-        for (const [name, def] of Object.entries(parsed.definitions)) {
-            if (!def)
-                continue;
-            if (!def.type) {
-                addWarning(result, name, '', `Definition '${name}' has no type specified`);
-            }
-        }
-    }
-    return result;
-}
-/**
- * Check if a schema is a valid Tenet schema (basic detection).
- * Useful for IDE integration to detect Tenet files.
- */
-export function isTenetSchema(schema) {
-    if (typeof schema !== 'object' || schema === null)
-        return false;
-    const obj = schema;
-    // Check for $schema URL
-    if (obj['$schema'] === SCHEMA_URL)
-        return true;
-    // Check for protocol field
-    if (typeof obj.protocol === 'string' && obj.protocol.startsWith('Tenet'))
-        return true;
-    // Check for definitions + logic_tree structure
-    if (obj.definitions && typeof obj.definitions === 'object')
-        return true;
-    return false;
-}
-// Helper functions
-function addError(result, field, rule, message) {
-    result.valid = false;
-    result.issues.push({ severity: 'error', field, rule, message });
-}
-function addWarning(result, field, rule, message) {
-    result.issues.push({ severity: 'warning', field, rule, message });
-}
-/**
- * Extract all variable references from a JSON-logic expression.
- */
-function extractVars(node) {
-    if (node === null || node === undefined)
-        return [];
-    const vars = [];
-    if (typeof node === 'object') {
-        if (Array.isArray(node)) {
-            for (const elem of node) {
-                vars.push(...extractVars(elem));
-            }
-        }
-        else {
-            const obj = node;
-            // Check if this is a var reference
-            if ('var' in obj && typeof obj.var === 'string') {
-                // Get root variable name (before any dot notation)
-                const varName = obj.var.split('.')[0];
-                vars.push(varName);
-            }
-            // Recurse into all values
-            for (const val of Object.values(obj)) {
-                vars.push(...extractVars(val));
-            }
-        }
-    }
-    return vars;
-}