@dlovans/tenet-core 0.2.1 → 0.3.0

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,6 +200,7 @@ 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);
@@ -227,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
@@ -255,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 {
@@ -318,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);
@@ -345,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

@@ -127,15 +127,21 @@ function getVar(path, state, resolve) {
     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`);
+        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) {
-            // Evaluate the derived expression on-demand
+            // 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;
             }
@@ -442,7 +448,7 @@ const operators = {
 export function applyOperator(op, args, state, resolve) {
     const fn = operators[op];
     if (!fn) {
-        addError(state, '', '', `Unknown operator '${op}' in logic expression`);
+        addError(state, '', '', 'runtime_warning', `Unknown operator '${op}' in logic expression`);
         return null;
     }
     return fn(args, state, resolve);

package/dist/core/temporal.js

@@ -21,7 +21,7 @@ function validateTemporalMap(state) {
         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)`);
+            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) {
@@ -34,7 +34,7 @@ function validateTemporalMap(state) {
                     ? new Date(start).getTime()
                     : -Infinity;
                 if (currStart <= prevEnd) {
-                    addError(state, '', '', `Temporal branch ${i} overlaps with branch ${i - 1} (ranges must not overlap)`);
+                    addError(state, '', '', 'runtime_warning', `Temporal branch ${i} overlaps with branch ${i - 1} (ranges must not overlap)`);
                 }
             }
         }

package/dist/core/types.d.ts

@@ -1,8 +1,112 @@
 /**
- * Internal types for the Tenet VM core.
- * Public types are re-exported from index.ts
+ * All type definitions for the Tenet VM.
+ * This is the single source of truth — other modules re-export from here.
  */
-export type { TenetSchema, TenetResult, TenetVerifyResult, Definition, Rule, Action, TemporalBranch, StateModel, DerivedDef, ValidationError, Attestation, Evidence, } from '../index.js';
+export interface TenetResult {
+    result?: TenetSchema;
+    error?: string;
+}
+/**
+ * Machine-parseable codes for verification issues.
+ * UI layers map these to customer-friendly messages; the VM never decides presentation.
+ */
+export type VerifyIssueCode = 'unknown_field' | 'computed_mismatch' | 'attestation_unsigned' | 'attestation_no_evidence' | 'attestation_no_timestamp' | 'status_mismatch' | 'convergence_failed' | 'internal_error';
+/**
+ * A single structured problem found during verification.
+ */
+export interface VerifyIssue {
+    code: VerifyIssueCode;
+    field_id?: string;
+    message: string;
+    expected?: unknown;
+    claimed?: unknown;
+}
+export interface TenetVerifyResult {
+    valid: boolean;
+    status?: string;
+    issues?: VerifyIssue[];
+    schema?: TenetSchema;
+    error?: string;
+}
+export interface Evidence {
+    provider_audit_id?: string;
+    timestamp?: string;
+    signer_id?: string;
+    logic_version?: string;
+}
+export interface Attestation {
+    statement: string;
+    law_ref?: string;
+    required_role?: string;
+    provider?: string;
+    required?: boolean;
+    signed?: boolean;
+    evidence?: Evidence;
+    on_sign?: Action;
+}
+export interface TenetSchema {
+    protocol?: string;
+    schema_id?: string;
+    version?: string;
+    valid_from?: string;
+    definitions: Record<string, Definition>;
+    logic_tree?: Rule[];
+    temporal_map?: TemporalBranch[];
+    state_model?: StateModel;
+    errors?: ValidationError[];
+    status?: 'READY' | 'INCOMPLETE' | 'INVALID';
+    attestations?: Record<string, Attestation>;
+}
+export interface Definition {
+    type: 'string' | 'number' | 'boolean' | 'select' | 'date' | 'attestation' | 'currency';
+    value?: unknown;
+    options?: string[];
+    label?: string;
+    required?: boolean;
+    readonly?: boolean;
+    visible?: boolean;
+    min?: number;
+    max?: number;
+    step?: number;
+    min_length?: number;
+    max_length?: number;
+    pattern?: string;
+    ui_class?: string;
+    ui_message?: string;
+}
+export interface Rule {
+    id: string;
+    law_ref?: string;
+    logic_version?: string;
+    when: Record<string, unknown>;
+    then: Action;
+    disabled?: boolean;
+}
+export interface Action {
+    set?: Record<string, unknown>;
+    ui_modify?: Record<string, unknown>;
+    error_msg?: string;
+}
+export interface TemporalBranch {
+    valid_range: [string | null, string | null];
+    logic_version: string;
+    status: 'ACTIVE' | 'ARCHIVED';
+}
+export interface StateModel {
+    inputs: string[];
+    derived: Record<string, DerivedDef>;
+}
+export interface DerivedDef {
+    eval: Record<string, unknown>;
+}
+export type ErrorKind = 'type_mismatch' | 'missing_required' | 'constraint_violation' | 'attestation_incomplete' | 'runtime_warning' | 'cycle_detected';
+export interface ValidationError {
+    field_id?: string;
+    rule_id?: string;
+    kind: ErrorKind;
+    message: string;
+    law_ref?: string;
+}
 /**
  * Evaluation context for collection operators (some/all/none).
  * When iterating over an array, provides access to the current element.
@@ -17,7 +121,7 @@ export interface EvalContext {
  */
 export interface EvalState {
     /** The schema being evaluated (mutable copy) */
-    schema: import('../index.js').TenetSchema;
+    schema: TenetSchema;
     /** Effective date for temporal routing */
     effectiveDate: Date;
     /** Tracks which fields were set by which rule (cycle detection) */
@@ -25,7 +129,9 @@ export interface EvalState {
     /** Current element context for some/all/none operators */
     currentElement?: unknown;
     /** Accumulated validation errors */
-    errors: import('../index.js').ValidationError[];
+    errors: ValidationError[];
+    /** Cycle detection for derived fields */
+    derivedInProgress: Set<string>;
 }
 /**
  * Document status values

package/dist/core/types.js

@@ -1,5 +1,5 @@
 /**
- * Internal types for the Tenet VM core.
- * Public types are re-exported from index.ts
+ * All type definitions for the Tenet VM.
+ * This is the single source of truth — other modules re-export from here.
  */
 export {};

package/dist/core/validate.d.ts

@@ -2,11 +2,11 @@
  * Definition validation and status determination.
  * Validates types, constraints, and required fields.
  */
-import type { EvalState, DocStatus } from './types.js';
+import type { EvalState, ErrorKind, DocStatus, Action } 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;
+export declare function addError(state: EvalState, fieldId: string, ruleId: string, kind: ErrorKind, message: string, lawRef?: string): void;
 /**
  * Validate all definitions for type correctness and required fields.
  */
@@ -14,8 +14,8 @@ 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;
+export declare function checkAttestations(state: EvalState, applyAction: (action: Action, ruleId: string, lawRef: string) => void): void;
 /**
- * Determine document status based on validation errors.
+ * Determine document status based on ErrorKind.
  */
 export declare function determineStatus(state: EvalState): DocStatus;

package/dist/core/validate.js

@@ -6,10 +6,11 @@ import { toFloat, parseDate } from './operators.js';
 /**
  * Add an error to the state's error list.
  */
-export function addError(state, fieldId, ruleId, message, lawRef) {
+export function addError(state, fieldId, ruleId, kind, message, lawRef) {
     state.errors.push({
         field_id: fieldId || undefined,
         rule_id: ruleId || undefined,
+        kind,
         message,
         law_ref: lawRef || undefined,
     });
@@ -28,10 +29,10 @@ function isValidOption(value, options) {
  */
 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)}`);
+        addError(state, id, '', 'constraint_violation', `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)}`);
+        addError(state, id, '', 'constraint_violation', `Field '${id}' value ${value.toFixed(2)} exceeds maximum ${def.max.toFixed(2)}`);
     }
 }
 /**
@@ -39,16 +40,16 @@ function validateNumericConstraints(state, id, value, def) {
  */
 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)`);
+        addError(state, id, '', 'constraint_violation', `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)`);
+        addError(state, id, '', 'constraint_violation', `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`);
+                addError(state, id, '', 'constraint_violation', `Field '${id}' does not match required pattern`);
             }
         }
         catch {
@@ -58,13 +59,19 @@ function validateStringConstraints(state, id, value, def) {
 }
 /**
  * Validate a single definition's type and constraints.
+ * Array values are allowed — the declared type describes the element type,
+ * used by collection operators (some/all/none). Scalar validation is skipped for arrays.
  */
 function validateType(state, id, def) {
     const value = def.value;
+    // Skip scalar validation for array values (used with some/all/none operators)
+    if (Array.isArray(value)) {
+        return;
+    }
     switch (def.type) {
         case 'string': {
             if (typeof value !== 'string') {
-                addError(state, id, '', `Field '${id}' must be a string`);
+                addError(state, id, '', 'type_mismatch', `Field '${id}' must be a string`);
                 return;
             }
             validateStringConstraints(state, id, value, def);
@@ -74,7 +81,7 @@ function validateType(state, id, def) {
         case 'currency': {
             const [numVal, ok] = toFloat(value);
             if (!ok) {
-                addError(state, id, '', `Field '${id}' must be a number`);
+                addError(state, id, '', 'type_mismatch', `Field '${id}' must be a number`);
                 return;
             }
             validateNumericConstraints(state, id, numVal, def);
@@ -82,30 +89,30 @@ function validateType(state, id, def) {
         }
         case 'boolean': {
             if (typeof value !== 'boolean') {
-                addError(state, id, '', `Field '${id}' must be a boolean`);
+                addError(state, id, '', 'type_mismatch', `Field '${id}' must be a boolean`);
             }
             break;
         }
         case 'select': {
             if (typeof value !== 'string') {
-                addError(state, id, '', `Field '${id}' must be a string`);
+                addError(state, id, '', 'type_mismatch', `Field '${id}' must be a string`);
                 return;
             }
             if (!isValidOption(value, def.options)) {
-                addError(state, id, '', `Field '${id}' value '${value}' is not a valid option`);
+                addError(state, id, '', 'constraint_violation', `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`);
+                addError(state, id, '', 'type_mismatch', `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`);
+                addError(state, id, '', 'type_mismatch', `Field '${id}' must be a valid date`);
             }
             break;
         }
@@ -122,11 +129,11 @@ export function validateDefinitions(state) {
         // Check required fields
         if (def.required) {
             if (def.value === undefined || def.value === null) {
-                addError(state, id, '', `Required field '${id}' is missing`);
+                addError(state, id, '', 'missing_required', `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`);
+                addError(state, id, '', 'missing_required', `Required field '${id}' is missing`);
             }
         }
         // Validate type if value is present
@@ -145,7 +152,7 @@ export function checkAttestations(state, applyAction) {
             continue;
         }
         if (def.required && def.value !== true) {
-            addError(state, id, '', `Required attestation '${id}' not confirmed`);
+            addError(state, id, '', 'attestation_incomplete', `Required attestation '${id}' not confirmed`);
         }
     }
     // Check rich attestations
@@ -163,38 +170,30 @@ export function checkAttestations(state, applyAction) {
         // Validate required attestations
         if (att.required) {
             if (!att.signed) {
-                addError(state, id, '', `Required attestation '${id}' not signed`, att.law_ref);
+                addError(state, id, '', 'attestation_incomplete', `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);
+                addError(state, id, '', 'attestation_incomplete', `Attestation '${id}' signed but missing evidence`, att.law_ref);
             }
         }
     }
 }
 /**
- * Determine document status based on validation errors.
+ * Determine document status based on ErrorKind.
  */
 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 (err.kind === 'type_mismatch')
+            return 'INVALID';
     }
-    if (hasTypeErrors) {
-        return 'INVALID';
+    for (const err of state.errors) {
+        if (err.kind === 'missing_required' || err.kind === 'attestation_incomplete') {
+            return 'INCOMPLETE';
+        }
     }
-    if (hasMissingRequired || hasMissingAttestations) {
-        return 'INCOMPLETE';
+    for (const err of state.errors) {
+        if (err.kind === 'constraint_violation')
+            return 'INVALID';
     }
     return 'READY';
 }

package/dist/index.d.ts

@@ -4,91 +4,8 @@
  * This module provides a pure TypeScript implementation of the Tenet VM.
  * Works in both browser and Node.js environments with no WASM dependencies.
  */
-export interface TenetResult {
-    result?: TenetSchema;
-    error?: string;
-}
-export interface TenetVerifyResult {
-    valid: boolean;
-    error?: string;
-}
-export interface Evidence {
-    provider_audit_id?: string;
-    timestamp?: string;
-    signer_id?: string;
-    logic_version?: string;
-}
-export interface Attestation {
-    statement: string;
-    law_ref?: string;
-    required_role?: string;
-    provider?: string;
-    required?: boolean;
-    signed?: boolean;
-    evidence?: Evidence;
-    on_sign?: Action;
-}
-export interface TenetSchema {
-    protocol?: string;
-    schema_id?: string;
-    version?: string;
-    valid_from?: string;
-    definitions: Record<string, Definition>;
-    logic_tree?: Rule[];
-    temporal_map?: TemporalBranch[];
-    state_model?: StateModel;
-    errors?: ValidationError[];
-    status?: 'READY' | 'INCOMPLETE' | 'INVALID';
-    attestations?: Record<string, Attestation>;
-}
-export interface Definition {
-    type: 'string' | 'number' | 'boolean' | 'select' | 'date' | 'attestation' | 'currency';
-    value?: unknown;
-    options?: string[];
-    label?: string;
-    required?: boolean;
-    readonly?: boolean;
-    visible?: boolean;
-    min?: number;
-    max?: number;
-    step?: number;
-    min_length?: number;
-    max_length?: number;
-    pattern?: string;
-    ui_class?: string;
-    ui_message?: string;
-}
-export interface Rule {
-    id: string;
-    law_ref?: string;
-    logic_version?: string;
-    when: Record<string, unknown>;
-    then: Action;
-    disabled?: boolean;
-}
-export interface Action {
-    set?: Record<string, unknown>;
-    ui_modify?: Record<string, unknown>;
-    error_msg?: string;
-}
-export interface TemporalBranch {
-    valid_range: [string | null, string | null];
-    logic_version: string;
-    status: 'ACTIVE' | 'ARCHIVED';
-}
-export interface StateModel {
-    inputs: string[];
-    derived: Record<string, DerivedDef>;
-}
-export interface DerivedDef {
-    eval: Record<string, unknown>;
-}
-export interface ValidationError {
-    field_id?: string;
-    rule_id?: string;
-    message: string;
-    law_ref?: string;
-}
+export type { TenetSchema, TenetResult, TenetVerifyResult, VerifyIssue, VerifyIssueCode, Definition, Rule, Action, TemporalBranch, StateModel, DerivedDef, ValidationError, Evidence, Attestation, ErrorKind, } from './core/types.js';
+import type { TenetSchema, TenetResult, TenetVerifyResult } from './core/types.js';
 /**
  * Initialize the Tenet VM.
  * This is a no-op in the pure TypeScript implementation (kept for backwards compatibility).

package/dist/index.js

@@ -4,7 +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.
  */
-// Import core engine functions
 import { run as coreRun, verify as coreVerify } from './core/engine.js';
 /**
  * Initialize the Tenet VM.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@dlovans/tenet-core",
-    "version": "0.2.1",
+    "version": "0.3.0",
     "type": "module",
     "description": "Declarative logic VM for JSON schemas - reactive validation, temporal routing, and computed state",
     "main": "dist/index.js",