@dlovans/tenet-core 0.1.3 → 0.2.0

package/dist/core/operators.js

@@ -0,0 +1,424 @@
+/**
+ * JSON-logic operators for the Tenet VM.
+ * All operators are nil-safe: operations on nil/undefined return appropriate defaults.
+ */
+/**
+ * Convert a value to a number if possible.
+ */
+export function toFloat(v) {
+    if (v === null || v === undefined) {
+        return [0, false];
+    }
+    if (typeof v === 'number') {
+        return [v, true];
+    }
+    if (typeof v === 'string') {
+        // Don't auto-convert strings to numbers
+        return [0, false];
+    }
+    return [0, false];
+}
+/**
+ * Parse a date value (string or Date).
+ * Supports ISO 8601 formats.
+ */
+export function parseDate(v) {
+    if (v === null || v === undefined) {
+        return [new Date(0), false];
+    }
+    if (v instanceof Date) {
+        return [v, true];
+    }
+    if (typeof v === 'string') {
+        const d = new Date(v);
+        if (!isNaN(d.getTime())) {
+            return [d, true];
+        }
+    }
+    return [new Date(0), false];
+}
+/**
+ * Determine if a value is "truthy" in JSON-logic terms.
+ * nil, false, 0, and "" are falsy. Everything else is truthy.
+ */
+export function isTruthy(value) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return value !== 0;
+    }
+    if (typeof value === 'string') {
+        return value !== '';
+    }
+    if (Array.isArray(value)) {
+        return value.length > 0;
+    }
+    if (typeof value === 'object') {
+        return Object.keys(value).length > 0;
+    }
+    return true;
+}
+/**
+ * Compare two values for equality with type coercion.
+ * nil == nil is true, nil == anything_else is false.
+ */
+export function compareEqual(a, b) {
+    if (a === null || a === undefined) {
+        return b === null || b === undefined;
+    }
+    if (b === null || b === undefined) {
+        return false;
+    }
+    // Try numeric comparison if both can be numbers
+    const [aNum, aOk] = toFloat(a);
+    const [bNum, bOk] = toFloat(b);
+    if (aOk && bOk) {
+        return aNum === bNum;
+    }
+    // String comparison
+    return String(a) === String(b);
+}
+/**
+ * Resolve arguments array, handling single values and missing args.
+ */
+function resolveArgs(args, expected, resolve, state) {
+    const result = new Array(expected).fill(null);
+    if (!Array.isArray(args)) {
+        // Single value case (e.g., {"not": true})
+        if (expected > 0) {
+            result[0] = resolve(args, state);
+        }
+        return result;
+    }
+    for (let i = 0; i < expected && i < args.length; i++) {
+        result[i] = resolve(args[i], state);
+    }
+    return result;
+}
+/**
+ * Get variable value from schema definitions or current element context.
+ */
+function getVar(path, state) {
+    // 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]];
+    if (def) {
+        if (parts.length === 1) {
+            return def.value;
+        }
+        // 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;
+}
+/**
+ * Access nested path in an object.
+ */
+function accessPath(value, parts) {
+    if (parts.length === 0 || value === null || value === undefined) {
+        return value;
+    }
+    if (typeof value === 'object' && !Array.isArray(value)) {
+        const obj = value;
+        const next = obj[parts[0]];
+        return accessPath(next, parts.slice(1));
+    }
+    return undefined;
+}
+// ============================================================
+// Operator implementations
+// ============================================================
+const operators = {
+    // === Variable Access ===
+    'var': (args, state) => {
+        const path = typeof args === 'string' ? args : '';
+        return getVar(path, state);
+    },
+    // === Comparison Operators ===
+    '==': (args, state, resolve) => {
+        const a = resolveArgs(args, 2, resolve, state);
+        return compareEqual(a[0], a[1]);
+    },
+    '!=': (args, state, resolve) => {
+        const a = resolveArgs(args, 2, resolve, state);
+        return !compareEqual(a[0], a[1]);
+    },
+    '>': (args, state, resolve) => {
+        const a = resolveArgs(args, 2, resolve, state);
+        if (a[0] === null || a[0] === undefined || a[1] === null || a[1] === undefined) {
+            return false;
+        }
+        const [aNum, aOk] = toFloat(a[0]);
+        const [bNum, bOk] = toFloat(a[1]);
+        return aOk && bOk && aNum > bNum;
+    },
+    '<': (args, state, resolve) => {
+        const a = resolveArgs(args, 2, resolve, state);
+        if (a[0] === null || a[0] === undefined || a[1] === null || a[1] === undefined) {
+            return false;
+        }
+        const [aNum, aOk] = toFloat(a[0]);
+        const [bNum, bOk] = toFloat(a[1]);
+        return aOk && bOk && aNum < bNum;
+    },
+    '>=': (args, state, resolve) => {
+        const a = resolveArgs(args, 2, resolve, state);
+        if (a[0] === null || a[0] === undefined || a[1] === null || a[1] === undefined) {
+            return false;
+        }
+        const [aNum, aOk] = toFloat(a[0]);
+        const [bNum, bOk] = toFloat(a[1]);
+        return aOk && bOk && aNum >= bNum;
+    },
+    '<=': (args, state, resolve) => {
+        const a = resolveArgs(args, 2, resolve, state);
+        if (a[0] === null || a[0] === undefined || a[1] === null || a[1] === undefined) {
+            return false;
+        }
+        const [aNum, aOk] = toFloat(a[0]);
+        const [bNum, bOk] = toFloat(a[1]);
+        return aOk && bOk && aNum <= bNum;
+    },
+    // === Logical Operators ===
+    'and': (args, state, resolve) => {
+        if (!Array.isArray(args)) {
+            return isTruthy(resolve(args, state));
+        }
+        for (const arg of args) {
+            if (!isTruthy(resolve(arg, state))) {
+                return false;
+            }
+        }
+        return true;
+    },
+    'or': (args, state, resolve) => {
+        if (!Array.isArray(args)) {
+            return isTruthy(resolve(args, state));
+        }
+        for (const arg of args) {
+            if (isTruthy(resolve(arg, state))) {
+                return true;
+            }
+        }
+        return false;
+    },
+    'not': (args, state, resolve) => {
+        const a = resolveArgs(args, 1, resolve, state);
+        return !isTruthy(a[0]);
+    },
+    '!': (args, state, resolve) => {
+        const a = resolveArgs(args, 1, resolve, state);
+        return !isTruthy(a[0]);
+    },
+    'if': (args, state, resolve) => {
+        if (!Array.isArray(args) || args.length < 2) {
+            return null;
+        }
+        // Process condition-then pairs
+        for (let i = 0; i + 1 < args.length; i += 2) {
+            const condition = resolve(args[i], state);
+            if (isTruthy(condition)) {
+                return resolve(args[i + 1], state);
+            }
+        }
+        // Else clause (odd number of elements = has else)
+        if (args.length % 2 === 1) {
+            return resolve(args[args.length - 1], state);
+        }
+        return null;
+    },
+    // === Arithmetic Operators ===
+    '+': (args, state, resolve) => {
+        const a = resolveArgs(args, 2, resolve, state);
+        if (a[0] === null || a[0] === undefined || a[1] === null || a[1] === undefined) {
+            return null;
+        }
+        const [aNum, aOk] = toFloat(a[0]);
+        const [bNum, bOk] = toFloat(a[1]);
+        if (!aOk || !bOk) {
+            return null;
+        }
+        return aNum + bNum;
+    },
+    '-': (args, state, resolve) => {
+        const a = resolveArgs(args, 2, resolve, state);
+        if (a[0] === null || a[0] === undefined || a[1] === null || a[1] === undefined) {
+            return null;
+        }
+        const [aNum, aOk] = toFloat(a[0]);
+        const [bNum, bOk] = toFloat(a[1]);
+        if (!aOk || !bOk) {
+            return null;
+        }
+        return aNum - bNum;
+    },
+    '*': (args, state, resolve) => {
+        const a = resolveArgs(args, 2, resolve, state);
+        if (a[0] === null || a[0] === undefined || a[1] === null || a[1] === undefined) {
+            return null;
+        }
+        const [aNum, aOk] = toFloat(a[0]);
+        const [bNum, bOk] = toFloat(a[1]);
+        if (!aOk || !bOk) {
+            return null;
+        }
+        return aNum * bNum;
+    },
+    '/': (args, state, resolve) => {
+        const a = resolveArgs(args, 2, resolve, state);
+        if (a[0] === null || a[0] === undefined || a[1] === null || a[1] === undefined) {
+            return null;
+        }
+        const [aNum, aOk] = toFloat(a[0]);
+        const [bNum, bOk] = toFloat(a[1]);
+        if (!aOk || !bOk || bNum === 0) {
+            return null;
+        }
+        return aNum / bNum;
+    },
+    // === Date Operators ===
+    'before': (args, state, resolve) => {
+        const a = resolveArgs(args, 2, resolve, state);
+        const [aDate, aOk] = parseDate(a[0]);
+        const [bDate, bOk] = parseDate(a[1]);
+        if (!aOk || !bOk) {
+            return false;
+        }
+        return aDate.getTime() < bDate.getTime();
+    },
+    'after': (args, state, resolve) => {
+        const a = resolveArgs(args, 2, resolve, state);
+        const [aDate, aOk] = parseDate(a[0]);
+        const [bDate, bOk] = parseDate(a[1]);
+        if (!aOk || !bOk) {
+            return false;
+        }
+        return aDate.getTime() > bDate.getTime();
+    },
+    // === Collection Operators ===
+    'in': (args, state, resolve) => {
+        const a = resolveArgs(args, 2, resolve, state);
+        const needle = a[0];
+        const haystack = a[1];
+        if (needle === null || needle === undefined || haystack === null || haystack === undefined) {
+            return false;
+        }
+        if (Array.isArray(haystack)) {
+            for (const item of haystack) {
+                if (compareEqual(needle, item)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if (typeof haystack === 'string' && typeof needle === 'string') {
+            return haystack.includes(needle);
+        }
+        return false;
+    },
+    'some': (args, state, resolve) => {
+        if (!Array.isArray(args) || args.length < 2) {
+            return false;
+        }
+        // First arg is the array (resolve it)
+        const collection = resolve(args[0], state);
+        if (!Array.isArray(collection) || collection.length === 0) {
+            return false;
+        }
+        // Second arg is the condition
+        const condition = args[1];
+        // Check if any element satisfies the condition
+        for (const item of collection) {
+            const oldContext = state.currentElement;
+            state.currentElement = item;
+            const result = isTruthy(resolve(condition, state));
+            state.currentElement = oldContext;
+            if (result) {
+                return true;
+            }
+        }
+        return false;
+    },
+    'all': (args, state, resolve) => {
+        if (!Array.isArray(args) || args.length < 2) {
+            return false;
+        }
+        // First arg is the array (resolve it)
+        const collection = resolve(args[0], state);
+        if (!Array.isArray(collection)) {
+            return false;
+        }
+        // Empty array returns true for "all" (vacuous truth)
+        if (collection.length === 0) {
+            return true;
+        }
+        // Second arg is the condition
+        const condition = args[1];
+        // Check if all elements satisfy the condition
+        for (const item of collection) {
+            const oldContext = state.currentElement;
+            state.currentElement = item;
+            const result = isTruthy(resolve(condition, state));
+            state.currentElement = oldContext;
+            if (!result) {
+                return false;
+            }
+        }
+        return true;
+    },
+    'none': (args, state, resolve) => {
+        if (!Array.isArray(args) || args.length < 2) {
+            return false;
+        }
+        // First arg is the array (resolve it)
+        const collection = resolve(args[0], state);
+        if (!Array.isArray(collection)) {
+            return false;
+        }
+        // Empty array returns true for "none"
+        if (collection.length === 0) {
+            return true;
+        }
+        // Second arg is the condition
+        const condition = args[1];
+        // Check that no element satisfies the condition
+        for (const item of collection) {
+            const oldContext = state.currentElement;
+            state.currentElement = item;
+            const result = isTruthy(resolve(condition, state));
+            state.currentElement = oldContext;
+            if (result) {
+                return false;
+            }
+        }
+        return true;
+    },
+};
+/**
+ * Apply an operator to its arguments.
+ */
+export function applyOperator(op, args, state, resolve) {
+    const fn = operators[op];
+    if (!fn) {
+        // Unknown operator - return null
+        return null;
+    }
+    return fn(args, state, resolve);
+}

package/dist/core/resolver.d.ts

@@ -0,0 +1,11 @@
+/**
+ * JSON-logic expression resolver.
+ * Recursively evaluates JSON-logic expressions and returns their values.
+ */
+import type { EvalState } from './types.js';
+/**
+ * Resolve any JSON-logic node and return its value.
+ * This is the recursive core of the VM.
+ * It is nil-safe: operations on nil values return appropriate defaults.
+ */
+export declare function resolve(node: unknown, state: EvalState): unknown;

package/dist/core/resolver.js

@@ -0,0 +1,34 @@
+/**
+ * JSON-logic expression resolver.
+ * Recursively evaluates JSON-logic expressions and returns their values.
+ */
+import { applyOperator } from './operators.js';
+/**
+ * Resolve any JSON-logic node and return its value.
+ * This is the recursive core of the VM.
+ * It is nil-safe: operations on nil values return appropriate defaults.
+ */
+export function resolve(node, state) {
+    if (node === null || node === undefined) {
+        return null;
+    }
+    // Object - could be an operator or a literal map
+    if (typeof node === 'object' && !Array.isArray(node)) {
+        const obj = node;
+        const keys = Object.keys(obj);
+        // Single key = operator: {"==": [a, b]} or {"var": "field_name"}
+        if (keys.length === 1) {
+            const op = keys[0];
+            const args = obj[op];
+            return applyOperator(op, args, state, resolve);
+        }
+        // Multi-key object is treated as a literal (return as-is)
+        return node;
+    }
+    // Array literal - resolve each element
+    if (Array.isArray(node)) {
+        return node.map(elem => resolve(elem, state));
+    }
+    // Primitives (string, number, boolean) - return as-is
+    return node;
+}

package/dist/core/temporal.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Temporal branch selection and rule pruning.
+ * Routes logic based on effective dates for bitemporal support.
+ */
+import type { EvalState, TemporalBranch } from './types.js';
+/**
+ * Find the active temporal branch for a given effective date.
+ * Returns undefined if no branch matches (uses default/unversioned logic).
+ */
+export declare function selectBranch(state: EvalState): TemporalBranch | undefined;
+/**
+ * Mark rules as disabled if they don't belong to the active branch.
+ * Rules without a logic_version are always active (unversioned rules).
+ */
+export declare function pruneRules(state: EvalState, activeBranch: TemporalBranch | undefined): void;
+/**
+ * Select temporal branch and prune inactive rules.
+ * Call this at the start of Run().
+ */
+export declare function applyTemporalRouting(state: EvalState): void;

package/dist/core/temporal.js

@@ -0,0 +1,69 @@
+/**
+ * Temporal branch selection and rule pruning.
+ * Routes logic based on effective dates for bitemporal support.
+ */
+/**
+ * Find the active temporal branch for a given effective date.
+ * Returns undefined if no branch matches (uses default/unversioned logic).
+ */
+export function selectBranch(state) {
+    const { schema, effectiveDate } = state;
+    if (!schema.temporal_map || schema.temporal_map.length === 0) {
+        return undefined;
+    }
+    for (const branch of schema.temporal_map) {
+        if (!branch || !branch.valid_range[0]) {
+            continue;
+        }
+        const start = new Date(branch.valid_range[0]);
+        if (isNaN(start.getTime())) {
+            continue;
+        }
+        // Check if effectiveDate is at or after start
+        if (effectiveDate < start) {
+            continue;
+        }
+        // Check end date (null = open-ended)
+        if (branch.valid_range[1]) {
+            const end = new Date(branch.valid_range[1]);
+            if (!isNaN(end.getTime()) && effectiveDate > end) {
+                continue;
+            }
+        }
+        return branch;
+    }
+    return undefined;
+}
+/**
+ * Mark rules as disabled if they don't belong to the active branch.
+ * Rules without a logic_version are always active (unversioned rules).
+ */
+export function pruneRules(state, activeBranch) {
+    if (!activeBranch || !state.schema.logic_tree) {
+        return;
+    }
+    const activeVersion = activeBranch.logic_version;
+    for (const rule of state.schema.logic_tree) {
+        if (!rule) {
+            continue;
+        }
+        // Rules without a version are always active
+        if (!rule.logic_version) {
+            continue;
+        }
+        // Disable rules that don't match the active version
+        if (rule.logic_version !== activeVersion) {
+            rule.disabled = true;
+        }
+    }
+}
+/**
+ * Select temporal branch and prune inactive rules.
+ * Call this at the start of Run().
+ */
+export function applyTemporalRouting(state) {
+    const branch = selectBranch(state);
+    if (branch) {
+        pruneRules(state, branch);
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Internal types for the Tenet VM core.
+ * Public types are re-exported from index.ts
+ */
+export type { TenetSchema, TenetResult, TenetVerifyResult, Definition, Rule, Action, TemporalBranch, StateModel, DerivedDef, ValidationError, Attestation, Evidence, } from '../index.js';
+/**
+ * Evaluation context for collection operators (some/all/none).
+ * When iterating over an array, provides access to the current element.
+ */
+export interface EvalContext {
+    /** Current element being evaluated */
+    item: unknown;
+}
+/**
+ * Internal state during rule evaluation.
+ * Passed through the resolver and operators.
+ */
+export interface EvalState {
+    /** The schema being evaluated (mutable copy) */
+    schema: import('../index.js').TenetSchema;
+    /** Effective date for temporal routing */
+    effectiveDate: Date;
+    /** Tracks which fields were set by which rule (cycle detection) */
+    fieldsSet: Map<string, string>;
+    /** Current element context for some/all/none operators */
+    currentElement?: unknown;
+    /** Accumulated validation errors */
+    errors: import('../index.js').ValidationError[];
+}
+/**
+ * Document status values
+ */
+export type DocStatus = 'READY' | 'INCOMPLETE' | 'INVALID';

package/dist/core/types.js

@@ -0,0 +1,5 @@
+/**
+ * Internal types for the Tenet VM core.
+ * Public types are re-exported from index.ts
+ */
+export {};

package/dist/core/validate.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Definition validation and status determination.
+ * Validates types, constraints, and required fields.
+ */
+import type { EvalState, DocStatus } from './types.js';
+/**
+ * Add an error to the state's error list.
+ */
+export declare function addError(state: EvalState, fieldId: string, ruleId: string, message: string, lawRef?: string): void;
+/**
+ * Validate all definitions for type correctness and required fields.
+ */
+export declare function validateDefinitions(state: EvalState): void;
+/**
+ * Check attestations for required signatures.
+ */
+export declare function checkAttestations(state: EvalState, applyAction: (action: any, ruleId: string, lawRef: string) => void): void;
+/**
+ * Determine document status based on validation errors.
+ */
+export declare function determineStatus(state: EvalState): DocStatus;