@dlovans/tenet-core 0.2.1 → 0.4.0

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,10 @@
  * 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';
+export type { LintResult, LintIssue, LintSeverity } from './core/lint.js';
+import type { TenetSchema, TenetResult, TenetVerifyResult } from './core/types.js';
+import type { LintResult } from './core/lint.js';
 /**
  * Initialize the Tenet VM.
  * This is a no-op in the pure TypeScript implementation (kept for backwards compatibility).
@@ -113,6 +32,14 @@ export declare function run(schema: TenetSchema | string, date?: Date | string):
  * @returns Whether the transformation is valid
  */
 export declare function verify(newSchema: TenetSchema | string, oldSchema: TenetSchema | string): TenetVerifyResult;
+/**
+ * Lint a schema for structural errors and type mismatches.
+ * Returns issues without executing the schema — pure static analysis.
+ *
+ * @param schema - The schema object or JSON string
+ * @returns Lint result with validity flag and issue list
+ */
+export declare function lint(schema: TenetSchema | string): LintResult;
 /**
  * Check if the VM is ready.
  * Always returns true in the pure TypeScript implementation.

package/dist/index.js

@@ -4,8 +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.
  */
-// Import core engine functions
 import { run as coreRun, verify as coreVerify } from './core/engine.js';
+import { lint as coreLint } from './core/lint.js';
 /**
  * Initialize the Tenet VM.
  * This is a no-op in the pure TypeScript implementation (kept for backwards compatibility).
@@ -37,6 +37,16 @@ export function run(schema, date = new Date()) {
 export function verify(newSchema, oldSchema) {
     return coreVerify(newSchema, oldSchema);
 }
+/**
+ * Lint a schema for structural errors and type mismatches.
+ * Returns issues without executing the schema — pure static analysis.
+ *
+ * @param schema - The schema object or JSON string
+ * @returns Lint result with validity flag and issue list
+ */
+export function lint(schema) {
+    return coreLint(schema);
+}
 /**
  * Check if the VM is ready.
  * Always returns true in the pure TypeScript implementation.

package/dist/lint.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for the lint() static schema analyzer.
+ * Organized into: Errors, Warnings, Valid schemas, Edge cases.
+ */
+export {};