mcard-js 2.1.49 → 2.1.51

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { S as StorageEngine, M as MCard, D as DOTSMetadata } from './AbstractSqlEngine-DKka6XjT.js';
 export { P as Page } from './AbstractSqlEngine-DKka6XjT.js';
-import { CardCollection, Either, IO, Maybe } from './index.browser.js';
-export { ALGORITHM_HIERARCHY, ContentHandle, ContentTypeInterpreter, EVENT_CONSTANTS, ErrorCodes, ExecutionResult, FaroSidecar, FaroSidecarConfig, GTime, HandleValidationError, HashValidator, IndexedDBEngine, JsonRpcRequest, JsonRpcResponse, LensProtocol, LivenessMetric, MCardStore, PolynomialTerm, PostconditionViolation, PreconditionViolation, PrimeHash, Reader, SafetyViolation, ServiceWorkerPTR, State, ValidationRegistry, VerificationStatus, Writer, computeHash, validateHandle, validationRegistry } from './index.browser.js';
+import { CardCollection, Either, IO, Maybe, SafetyViolation, LivenessMetric } from './index.browser.js';
+export { ALGORITHM_HIERARCHY, ContentHandle, ContentTypeInterpreter, EVENT_CONSTANTS, ErrorCodes, ExecutionResult, FaroSidecar, FaroSidecarConfig, GTime, HandleValidationError, HashValidator, IndexedDBEngine, JsonRpcRequest, JsonRpcResponse, LensProtocol, MCardStore, PolynomialTerm, PostconditionViolation, PreconditionViolation, PrimeHash, Reader, ServiceWorkerPTR, State, ValidationRegistry, VerificationStatus, Writer, computeHash, validateHandle, validationRegistry } from './index.browser.js';
 export { SqliteWasmEngine } from './storage/SqliteWasmEngine.js';
 export { SqliteNodeEngine } from './storage/SqliteNodeEngine.js';
 import '@grafana/faro-web-sdk';
@@ -222,15 +222,21 @@ declare function processFileContent(filePath: string, options?: {
     allowPathological?: boolean;
     maxBytes?: number;
 }): Promise<FileProcessingResult$1>;
+/**
+ * Recursively hash the files in a directory to compute topological source hashes.
+ * Ignores problematic files.
+ */
+declare function getTreeHashes(dirPath: string): Promise<Record<string, string>>;
 
 type FileIO_NormalizedReadResult = NormalizedReadResult;
+declare const FileIO_getTreeHashes: typeof getTreeHashes;
 declare const FileIO_isProblematicFile: typeof isProblematicFile;
 declare const FileIO_listFiles: typeof listFiles;
 declare const FileIO_processFileContent: typeof processFileContent;
 declare const FileIO_readFileSafely: typeof readFileSafely;
 declare const FileIO_streamReadNormalizedText: typeof streamReadNormalizedText;
 declare namespace FileIO {
-  export { type FileProcessingResult$1 as FileProcessingResult, type FileIO_NormalizedReadResult as NormalizedReadResult, FileIO_isProblematicFile as isProblematicFile, FileIO_listFiles as listFiles, FileIO_processFileContent as processFileContent, FileIO_readFileSafely as readFileSafely, FileIO_streamReadNormalizedText as streamReadNormalizedText };
+  export { type FileProcessingResult$1 as FileProcessingResult, type FileIO_NormalizedReadResult as NormalizedReadResult, FileIO_getTreeHashes as getTreeHashes, FileIO_isProblematicFile as isProblematicFile, FileIO_listFiles as listFiles, FileIO_processFileContent as processFileContent, FileIO_readFileSafely as readFileSafely, FileIO_streamReadNormalizedText as streamReadNormalizedText };
 }
 
 interface FileProcessingResult {
@@ -265,14 +271,38 @@ declare function loadFileToCollection(targetPath: string, collection: CardCollec
     maxBytesOnProblem?: number;
     metadataOnly?: boolean;
 }): Promise<LoaderResponse>;
+/**
+ * AsyncGenerator for unblocking massive file ingest streams using backpressure semantics
+ * instead of buffering all results symmetrically into JS memory.
+ */
+declare function loadFileToCollectionStream(targetPath: string, collection: CardCollection, options?: {
+    recursive?: boolean;
+    includeProblematic?: boolean;
+    maxBytesOnProblem?: number;
+    metadataOnly?: boolean;
+}): AsyncGenerator<{
+    progress: number;
+    total: number;
+    result: FileProcessingResult;
+}, LoaderMetrics, unknown>;
+/**
+ * Dump the entire SQLite collection out to standard filesystem topography based on registered handles.
+ * Serves as the key PCard Transition for isomorphism checking.
+ */
+declare function exportCollectionToDirectory(collection: CardCollection, targetDir: string): Promise<{
+    exportedCount: number;
+    bytesWritten: number;
+}>;
 
 type Loader_FileProcessingResult = FileProcessingResult;
 type Loader_LoaderMetrics = LoaderMetrics;
 type Loader_LoaderResponse = LoaderResponse;
+declare const Loader_exportCollectionToDirectory: typeof exportCollectionToDirectory;
 declare const Loader_loadFileToCollection: typeof loadFileToCollection;
+declare const Loader_loadFileToCollectionStream: typeof loadFileToCollectionStream;
 declare const Loader_processAndStoreFile: typeof processAndStoreFile;
 declare namespace Loader {
-  export { type Loader_FileProcessingResult as FileProcessingResult, type Loader_LoaderMetrics as LoaderMetrics, type Loader_LoaderResponse as LoaderResponse, Loader_loadFileToCollection as loadFileToCollection, Loader_processAndStoreFile as processAndStoreFile };
+  export { type Loader_FileProcessingResult as FileProcessingResult, type Loader_LoaderMetrics as LoaderMetrics, type Loader_LoaderResponse as LoaderResponse, Loader_exportCollectionToDirectory as exportCollectionToDirectory, Loader_loadFileToCollection as loadFileToCollection, Loader_loadFileToCollectionStream as loadFileToCollectionStream, Loader_processAndStoreFile as processAndStoreFile };
 }
 
 type RuntimeConfig$1 = Record<string, unknown>;
@@ -899,978 +929,1106 @@ declare namespace index {
 }
 
 /**
- * PCard Model (Control Plane) - Petri Net TRANSITION
+ * VCard Model (Application Plane) - Petri Net TOKEN / PRE-CONDITION CARRIER
  *
- * This module defines PCard, the execution unit in the MVP Cards architecture.
- * PCards are MCards containing a valid CLM (Cubical Logic Model) specification.
+ * This module defines VCard, the sovereign decision layer in the MVP Cards architecture.
+ * VCard is the Applicative that manages all side effects and authorization.
  *
- * ## Categorical Foundation: STRONG PROFUNCTOR
+ * ## Category Theory Role: APPLICATIVE
  *
- * PCard implements the Strong Profunctor pattern from category theory:
+ * VCard is the **Applicative** in the MVP Cards categorical hierarchy:
+ * - **MCard (Monad)**: Data container with unit and bind
+ * - **PCard (Functor)**: Pure transformation
+ * - **VCard (Applicative)**: Context-aware application `<*> :: F (a -> b) -> F a -> F b`
  *
- *     P: A^op × B → Set
+ * The Applicative nature means VCard can encode **static pre-conditions**:
+ * the authorization graph is known ahead of time, while actual execution
+ * depends on runtime results.
  *
- * Where:
- *   - A^op denotes contravariance in input types (accepts MORE general)
- *   - B denotes covariance in output types (produces MORE specific)
- *   - Set is the category of sets (our value space)
+ * ## Petri Net Role: TOKEN + PRE-CONDITION
  *
- * The "Strong" property means PCard supports:
- *   - first:  P(A, B) → P(C × A, C × B)  (threading context through)
- *   - second: P(A, B) → P(A × C, B × C)  (preserving additional structure)
+ * In the Categorical Petri Net model, VCard serves dual roles:
  *
- * ## Composition via Coend
+ * ### As Token
+ * - VCard is the **Token** that resides in Places (Handles)
+ * - Tokens enable Transitions (PCards) to fire
+ * - Token movement represents verification cascade
  *
- * Two PCards compose via the Coend (categorical integral):
+ * ### As Pre-Condition (Firing Guard)
+ * A Petri Net transition fires when all input VCards exist:
  *
- *     (P ⨾ Q)(A, C) = ∫ᴮ P(A, B) × Q(B, C)
+ * ```
+ * M' = M - •t + t•
+ * ```
  *
- * Where:
- *   - ∫ᴮ is the Coend over the intermediate type B
- *   - P(A, B) is the first PCard (input A, output B)
- *   - Q(B, C) is the second PCard (input B, output C)
- *   - Result is a new PCard from A to C
+ * VCard as Input Arc encodes:
+ * - **Input Place**: Handle pointing to required VCard
+ * - **Token in Place**: VCard content in `card` table
+ * - **Arc Guard**: VCard's Applicative authorization check
+ * - **Token "Consumption"**: Recording `previous_hash` in new VCard
  *
- * The `andThen()` method implements this Coend composition.
+ * ### Hash as Token AND Certificate (Dual Role)
  *
- * ## SMC Structure (Symmetric Monoidal Category)
+ * | Role | Function | Implementation |
+ * |------|----------|----------------|
+ * | **Token** | Triggers firing (enables transitions) | `handle_registry.current_hash IS NOT NULL` |
+ * | **Certificate** | Proves correctness after verification | VCard content witnesses Hoare Triple |
  *
- * PCard composition forms a Symmetric Monoidal Category:
- *   - **Identity**: The "pass-through" PCard
- *   - **Composition**: Sequential chaining via `andThen()` (;)
- *   - **Tensor Product**: Parallel composition via `andAlso()` (⊗)
- *   - **Symmetry**: Port swapping via `swap()` (σ)
+ * ```
+ * {h_pre} PCard {h_post}
+ * ```
  *
- * ## Functor Role in MVP Cards Hierarchy
+ * Where:
+ * - h_pre = hash of input VCard (precondition satisfied)
+ * - PCard = CLM specification (transformation logic)
+ * - h_post = hash of output VCard (postcondition witnessed)
  *
- * PCard is the **Functor** in the categorical hierarchy:
- *   - **MCard (Monad)**: Data container
- *   - **PCard (Functor)**: Pure transformation `fmap :: (a -> b) -> F a -> F b`
- *   - **VCard (Applicative)**: Context-aware application
+ * ## Cascade Pattern: Propagating Verification
  *
- * ## Petri Net Role: TRANSITION
+ * VCards enable **verification cascades** across the network:
  *
- * In the Categorical Petri Net model, PCard is the **Transition**:
- *   - Consumes input VCards (Tokens) from input Places
- *   - Executes CLM logic (Abstract → Concrete transformation)
- *   - Produces output VCards (Tokens) for output Places
+ * ```
+ * T1 → V1 → T2 → V2 → T3 → ... → Vn
+ * ```
  *
- * ### The Firing Rule
+ * Each VerificationVCard (Vi) serves as:
+ * 1. **Post-condition** of transition Ti (what it produces)
+ * 2. **Pre-condition** of transition Ti+1 (what enables next step)
  *
- *     M' = M - •t + t•
+ * ## DOTS Vocabulary Role: ARENA + ACTION
  *
- * Where:
- *   - M = Current marking (token distribution)
- *   - •t = Pre-set (input VCards required)
- *   - t• = Post-set (output VCards produced)
+ * VCard is both:
+ * - **Arena**: Interface type defining what can interact (subject_did, capabilities, external_refs)
+ * - **Action**: Morphism where interactions (PCards) act on systems (MCards)
  *
- * ## CLM Triad: Abstract, Concrete, Balanced
+ * ## The Four Roles:
+ * 1. Identity & Credential Container (The "Who")
+ * 2. Verification Hub (The "Rules")
+ * 3. Side Effect Manager (The "Bridge")
+ * 4. Input/Output Gatekeeper (The "Gate")
  *
- * PCard content encodes the three dimensions:
- *   - **Abstract (A)**: WHY - Specification, intent, type signature
- *   - **Concrete (C)**: HOW - Implementation, runtime logic
- *   - **Balanced (B)**: WHAT - Tests, verification expectations
+ * ## VCard as Egress Gate: The Sovereign Boundary
  *
- * ## DOTS Vocabulary Role: LENS + CHART
+ * When a VerificationVCard is produced, it may also serve as **egress authorization**:
  *
- *   - **Lens**: Tight morphism (Abstract ↔ Concrete coherence)
- *   - **Chart**: Loose morphism (Balanced expectations wiring)
+ * | Egress Role | VCard Content | Enables |
+ * |-------------|--------------|---------|
+ * | Export Authorization | `egress_capability: { destination_did, scope }` | Sharing to specific PKCs |
+ * | Cross-PKC Transition | `transferable: true` | Token moves to destination's Petri Net |
+ * | Federation Trigger | Signed VCard bundle | Downstream PKC's transitions enabled |
  *
- * @see docs/PCard_Impl.md for full implementation specification
+ * @see docs/VCard_Impl.md for full implementation specification
  */
 
-type ClmObject = Record<string, unknown>;
 /**
- * Input VCard reference for Petri Net pre-condition
+ * Scope of a capability token.
  */
-interface InputVCardRef {
-    /** Handle name (Place) where precondition VCard must exist */
-    handle: string;
-    /** Expected VCard hash (optional, for strict matching) */
-    expectedHash?: string;
-    /** Purpose of this precondition (e.g., 'authenticate', 'authorize') */
-    purpose?: string;
+declare enum CapabilityScope {
+    READ = "read",
+    WRITE = "write",
+    EXECUTE = "execute",
+    ADMIN = "admin",
+    DELEGATE = "delegate"
 }
 /**
- * Output VCard specification for Petri Net post-condition
+ * Direction of gatekeeper authorization.
  */
-interface OutputVCardSpec {
-    /** Handle name (Place) where output VCard will be deposited */
-    handle: string;
-    /** Type of VCard to generate */
-    type: 'verification' | 'authorization' | 'audit' | 'result';
-    /** Additional metadata to include in the VCard */
-    metadata?: Record<string, unknown>;
+declare enum GatekeeperDirection {
+    INGRESS = "ingress",
+    EGRESS = "egress"
 }
 /**
- * PCard - The Control Plane unit (Petri Net Transition)
+ * A capability token defining authorized actions.
+ */
+interface Capability {
+    capabilityId: string;
+    actorDid: string;
+    scope: CapabilityScope;
+    resourcePattern: string;
+    expiresAt?: Date;
+    constraints?: Record<string, unknown>;
+    transferable: boolean;
+}
+/**
+ * A verified external reference managed by VCard.
+ */
+interface ExternalRef {
+    uri: string;
+    contentHash: string;
+    status: 'verified' | 'pending' | 'stale' | 'invalid';
+    signature?: string;
+    lastVerified?: Date;
+    qosMetrics?: Record<string, unknown>;
+}
+type ParsedVCardContent = Record<string, unknown>;
+type SimulationLogEntry = {
+    timestamp: Date;
+    effectType: string;
+    details: unknown;
+    simulated: true;
+};
+/**
+ * An ingress or egress gatekeeper event.
+ */
+interface GatekeeperEvent {
+    direction: GatekeeperDirection;
+    timestamp: Date;
+    sourceDid?: string;
+    destinationDid?: string;
+    contentHash: string;
+    authorized: boolean;
+    capabilityUsed?: string;
+    signature?: string;
+}
+/**
+ * VCard - The Application Plane unit (Petri Net Token)
  *
- * A PCard is an MCard whose content is a valid CLM specification.
- * It represents a transformation (Lens) with a specific interaction pattern (Chart).
+ * Implements the Empty Schema Principle: VCard IS an MCard.
+ * This class provides a view and runtime state management over the immutable content.
+ *
+ * In Petri Net terms:
+ * - VCard is a **Token** that resides in a **Place** (Handle)
+ * - VCard enables **Transitions** (PCards) to fire when present
+ * - VCard serves as both **Pre-condition** (what enables) and **Post-condition** (what is produced)
  */
-declare class PCard extends MCard {
-    private readonly parsedClm;
-    private readonly isLens;
-    protected constructor(content: Uint8Array, hash: string, g_time: string, contentType: string, hashFunction: string, parsedClm: ClmObject, isLens: boolean);
+declare class VCard extends MCard {
+    private _subjectDid;
+    private _controllerPubkeys;
+    private _capabilities;
+    private _externalRefs;
+    private _exportManifest;
+    private _gatekeeperLog;
+    private _pcardRefsHashes;
+    private _managedEventTypes;
+    private _wrappedPcardHash?;
+    protected constructor(content: Uint8Array, hash: string, g_time: string, contentType: string, hashFunction: string, initialData: ParsedVCardContent);
+    private _initializeMutableState;
     /**
-     * Create a new PCard from CLM content
-     *
-     * @param content - The CLM YAML string or bytes
-     * @param hashAlgorithm - Hash algorithm to use
-     * @param isLens - Whether this acts primarily as a Lens (default true)
+     * Create a new VCard from parameters.
+     * Follows strict UPTV structure { vcard: { ... } }.
      */
-    static create(content: string | Uint8Array, hashAlgorithm?: string, isLens?: boolean): Promise<PCard>;
+    static createVCard(subjectDid: string, controllerPubkeys: string[], capabilities?: Capability[], externalRefs?: ExternalRef[], managedEventTypes?: string[], wrappedPcardHash?: string, hashAlgorithm?: string, extraFields?: Record<string, any>): Promise<VCard>;
     /**
-     * Get DOTS vocabulary metadata for this PCard
-     *
-     * Automatically extracts dependencies from the CLM structure if available.
+     * Create a VCard wrapper from an existing MCard.
      */
+    static fromMCard(card: MCard): Promise<VCard>;
     getDOTSMetadata(): DOTSMetadata;
+    get subjectDid(): string;
+    get controllerPubkeys(): string[];
+    get capabilities(): Capability[];
+    get externalRefs(): ExternalRef[];
+    addCapability(capability: Capability): void;
+    getValidCapabilities(): Capability[];
+    hasCapability(scope: CapabilityScope, resourceHash: string): boolean;
+    addPCardReference(pcardHash: string): void;
+    getPCardReferences(): string[];
+    addExternalRef(ref: ExternalRef): void;
+    getExternalRefsByStatus(status: ExternalRef['status']): ExternalRef[];
+    verifyExternalRef(uri: string, newHash: string): boolean;
+    authorizeIngress(sourceDid: string, contentHash: string, capabilityId?: string): boolean;
+    getManagedEventTypes(): string[];
+    getWrappedPcardHash(): string | undefined;
+    registerForEgress(contentHash: string): boolean;
+    authorizeEgress(destinationDid: string, contentHash: string, capabilityId?: string): boolean;
+    private _logEgress;
+    getGatekeeperLog(direction?: GatekeeperDirection): GatekeeperEvent[];
+    logGatekeeperEvent(event: GatekeeperEvent): void;
+    getExportManifest(): string[];
+    simulateMode(): VCardSimulation;
     /**
-     * Get the parsed CLM object
-     */
-    get clm(): ClmObject;
-    private getSection;
-    /**
-     * Get the Abstract Specification section (UPTV Role: Abstract)
-     */
-    get abstract(): unknown;
-    /**
-     * Get the Concrete Implementation section (UPTV Role: Concrete)
-     */
-    get concrete(): unknown;
-    /**
-     * Get the Balanced Expectations (tests) section (UPTV Role: Balanced)
-     */
-    get balanced(): unknown;
-    /**
-     * Get the Abstract Specification section (Legacy)
-     */
-    get abstractSpec(): unknown;
-    /**
-     * Get the Concrete Implementation section (Legacy)
+     * Get the handle where this VCard token currently resides
+     *
+     * In Petri Net terms, this is the "Place" where the token is located.
+     *
+     * @returns Handle string if available in content, or hash-based handle
      */
-    get concreteImpl(): unknown;
+    getTokenHandle(): string;
     /**
-     * Get the Balanced Expectations (tests) section (Legacy)
+     * Check if this VCard is a VerificationVCard (result of PCard execution)
+     *
+     * VerificationVCards are produced by PCard transitions and contain
+     * execution results with provenance chain.
+     *
+     * @returns True if this is a verification token
      */
-    get balancedExpectations(): unknown;
+    isVerificationVCard(): boolean;
     /**
-     * Sequential Composition via Coend (P ⨾ Q)
-     *
-     * Implements profunctor composition using the Coend formula:
+     * Get the previous hash in the provenance chain
      *
-     *     (P ⨾ Q)(A, C) = ∫ᴮ P(A, B) × Q(B, C)
+     * In Petri Net terms, this links to the input VCard that was "consumed"
+     * when the transition fired to produce this VCard.
      *
-     * Where:
-     *   - this is P: A → B
-     *   - otherPCard is Q: B → C
-     *   - Result is P ⨾ Q: A → C
+     * @returns Previous VCard hash if this is part of a verification cascade
+     */
+    getPreviousHash(): string | undefined;
+    /**
+     * Get the PCard hash that produced this VCard (if verification)
      *
-     * The Coend (∫ᴮ) "integrates out" the intermediate type B by:
-     * 1. Matching P's output type with Q's input type
-     * 2. Creating a chain where P's result feeds into Q
-     * 3. The composition is associative: (P ⨾ Q) ⨾ R = P ⨾ (Q ⨾ R)
+     * This links the output token to the transition that created it.
      *
-     * In PTR execution:
-     *   - P is executed first (prep → exec → post)
-     *   - P's output VCard becomes Q's input VCard
-     *   - Q is executed second
-     *   - Final result is Q's output VCard
+     * @returns PCard hash that produced this VCard
+     */
+    getSourcePCardHash(): string | undefined;
+    /**
+     * Create a VerificationVCard from PCard execution result
      *
-     * Note: Named 'andThen' to avoid conflict with Promise.then (Thenable).
+     * This is the factory method for producing output tokens in the Petri Net.
      *
-     * @param otherPCard - The PCard to execute after this one (Q in P ⨾ Q)
-     * @returns A new PCard representing the composed profunctor (P ⨾ Q)
+     * @param pcard - The PCard (Transition) that executed
+     * @param result - Execution result
+     * @param previousVCard - Input VCard (pre-condition) if any
+     * @param success - Whether execution succeeded
+     * @returns New VerificationVCard
      */
-    andThen(otherPCard: PCard): Promise<PCard>;
+    static createVerificationVCard(pcard: {
+        hash: string;
+        getTransitionHandle?: () => string;
+        getBalancedHandle?: () => string;
+    }, result: unknown, previousVCard?: VCard, success?: boolean, hashAlgorithm?: string, executionTelemetry?: Record<string, unknown>): Promise<VCard>;
     /**
-     * Tensor Product ($A \otimes B$)
+     * Check if this VCard enables a specific PCard to fire
      *
-     * Runs this PCard and otherPCard in parallel.
+     * @param requiredHandle - The handle where a precondition VCard must exist
+     * @returns True if this VCard satisfies that precondition
      */
-    andAlso(otherPCard: PCard): Promise<PCard>;
+    enablesTransition(requiredHandle: string): boolean;
+}
+/**
+ * Simulation context for VCard (EOS Compliance).
+ */
+declare class VCardSimulation {
+    private vcard;
+    private log;
+    constructor(vcard: VCard);
+    logEffect(effectType: string, details: unknown): void;
+    getSimulationLog(): SimulationLogEntry[];
+}
+
+/**
+ * Type definitions for CLM (Cubical Logic Model) execution.
+ */
+/**
+ * CLM specification structure (parsed from YAML).
+ */
+interface CLMSpec {
+    version: string;
+    chapter: {
+        id: number;
+        title: string;
+        mvp_card?: string;
+        pkc_task?: string;
+    };
+    clm: {
+        abstract?: {
+            concept?: string;
+            purpose?: string;
+            description?: string;
+            goal?: string;
+            context?: string;
+            success_criteria?: string;
+            [key: string]: unknown;
+        };
+        abstract_spec?: CLMSpec['clm']['abstract'];
+        concrete?: {
+            manifestation?: string;
+            description?: string;
+            logic_source?: string;
+            runtime?: string;
+            builtin?: boolean;
+            code_file?: string;
+            entry_point?: string;
+            inputs?: string[];
+            process?: string;
+            outputs?: string[];
+            action?: string;
+            boundary?: 'intrinsic' | 'extrinsic';
+            runtimes_config?: RuntimeConfig[];
+            [key: string]: unknown;
+        };
+        concrete_impl?: CLMSpec['clm']['concrete'];
+        balanced?: {
+            expectation?: string;
+            description?: string;
+            test_cases?: unknown[];
+            examples?: unknown[];
+            [key: string]: unknown;
+        };
+        balanced_exp?: CLMSpec['clm']['balanced'];
+    };
+    examples?: CLMExample[];
+}
+/**
+ * Runtime configuration for multi-runtime CLMs.
+ */
+interface RuntimeConfig {
+    name: string;
+    file?: string;
+    binary?: string;
+    module?: string;
+    entry?: string;
+}
+/**
+ * CLM example definition.
+ */
+interface CLMExample {
+    name: string;
+    input?: unknown;
+    assumption?: unknown;
+    expected_output?: unknown;
+    confirmation?: unknown;
+    result_contains?: string;
+    [key: string]: unknown;
+}
+/**
+ * Result of executing a single CLM.
+ */
+interface ExecutionResult {
+    success: boolean;
+    result?: unknown;
+    error?: string;
+    executionTime: number;
+    clm: {
+        chapter: string;
+        concept: string;
+        manifestation: string;
+        boundary?: string;
+    };
+}
+/**
+ * Result of executing on a single runtime (for multi-runtime).
+ */
+interface RuntimeResult {
+    runtime: string;
+    success: boolean;
+    result?: unknown;
+    error?: string;
+    executionTime: number;
+}
+/**
+ * Result of multi-runtime consensus execution.
+ */
+interface MultiRuntimeResult {
+    success: boolean;
+    consensus: boolean;
+    results: RuntimeResult[];
+    consensusValue?: unknown;
+    error?: string;
+    executionTime: number;
+    clm: {
+        chapter: string;
+        concept: string;
+        manifestation: string;
+        boundary?: string;
+    };
+}
+/**
+ * Summary of running all examples in a CLM.
+ */
+interface RunExamplesSummary {
+    total: number;
+    passed: number;
+    results: ExampleRunResult[];
+}
+/**
+ * Result of running a single example.
+ */
+interface ExampleRunResult {
+    case: number;
+    name: string;
+    input: unknown;
+    result: unknown;
+    error?: string;
+    expected: unknown;
+    match: boolean;
+}
+/**
+ * Execution report for external reporting.
+ */
+interface ExecutionReport {
+    status: 'success' | 'failure';
+    result?: unknown;
+    error?: string;
+    chapter_id: number;
+    chapter_title: string;
+}
+/**
+ * Summary report for external reporting.
+ */
+interface SummaryReport {
+    status: 'success' | 'failure';
+    result: {
+        success: boolean;
+        total: number;
+        results: Array<{
+            case: number;
+            name: string;
+            result: unknown;
+            error?: string;
+        }>;
+    };
+    chapter_id: number;
+    chapter_title: string;
+}
+/**
+ * CLM banner lines for display.
+ */
+interface CLMBannerLines {
+    header: string[];
+}
+
+/**
+ * CLMRunner - Execute JavaScript logic from CLM specifications
+ *
+ * Node.js PTR runtime for interpreting Cubical Logic Models.
+ *
+ * Refactored to use modular components from ./clm/
+ */
+
+declare class CLMRunner {
+    private loader;
+    private timeout;
+    private collection?;
+    private privateCollection?;
+    constructor(basePath?: string, timeout?: number, collection?: CardCollection, privateCollection?: CardCollection);
     /**
-     * Symmetry ($\sigma$)
-     *
-     * Swaps the input/output ports of a tensor product.
+     * Run a CLM directly from a file path.
      */
-    swap(): Promise<PCard>;
+    runFile(clmPath: string, input?: unknown): Promise<ExecutionResult>;
     /**
-     * Run the Balanced Expectations (Proof)
+     * Execute a CLM specification with given input.
+     *
+     * Implements Petri Net Transition Semantics:
+     * 1. Constructs PCard (Transition)
+     * 2. Checks Pre-conditions (Firing Rule)
+     * 3. Executes Logic
+     * 4. Produces VerificationVCard (Token)
+     * 5. Persists to Collection (Place)
      */
-    verify(): Record<string, unknown>;
+    executeCLM(clm: CLMSpec, chapterDir: string, input: unknown): Promise<ExecutionResult>;
     /**
-     * Run with instrumentation (eBPF/Tracing)
+     * Execute a CLM across multiple runtimes and verify consensus.
      */
-    profile(): Record<string, unknown>;
+    executeMultiRuntime(clm: CLMSpec, chapterDir: string, input: unknown): Promise<MultiRuntimeResult>;
     /**
-     * Run in Operative mode (Step-by-step)
+     * Check if a CLM is a multi-runtime CLM.
      */
-    debug(): Record<string, unknown>;
+    isMultiRuntime(clm: CLMSpec): boolean;
     /**
-     * Return documentation/explanation
+     * Build CLM banner for display.
      */
-    explain(): Record<string, unknown>;
+    buildCLMBanner(clm: CLMSpec): CLMBannerLines;
     /**
-     * Get input VCard references (Pre-set: •t)
-     *
-     * These represent the preconditions that must be satisfied before
-     * this PCard (Transition) can fire.
-     *
-     * @returns Array of input VCard references from CLM specification
+     * Build execution report.
      */
-    getInputVCardRefs(): InputVCardRef[];
+    buildExecutionReport(clm: CLMSpec, execution: ExecutionResult): ExecutionReport;
     /**
-     * Get output VCard specifications (Post-set: t•)
-     *
-     * These define what VCards (Tokens) this PCard produces when fired.
-     *
-     * @returns Array of output VCard specifications
+     * Build summary report.
      */
-    getOutputVCardSpecs(): OutputVCardSpec[];
+    buildSummaryReport(clm: CLMSpec, summary: RunExamplesSummary): SummaryReport;
+    private executeLoader;
+    private executeNetwork;
+    private executeStandard;
+    private executeRecursive;
+    private resolveCodeOrPath;
+    private buildNetworkContext;
+    private buildJavaScriptContext;
+    private buildRunCLM;
+}
+
+type PreCheck$1 = (input: MCard) => boolean;
+type PostCheck$1 = (output: unknown) => boolean;
+/**
+ * Composition object handling the REPL paradigm logic for the PTREngine.
+ * prep → exec → post → await
+ */
+declare class REPLCycle {
+    private engine;
+    constructor(engine: PTREngine);
     /**
-     * Get the canonical handle for this PCard (Transition)
-     *
-     * @returns Handle string in form `clm://{module}/{function}/spec`
+     * The Arrow execution primitive orchestrated as a REPL cycle.
      */
-    getTransitionHandle(): string;
+    runWithSandwich(pcardHash: string, inputHash: string, preCheck?: PreCheck$1, postCheck?: PostCheck$1, context?: Record<string, any>): Promise<[unknown, VCard, number]>;
     /**
-     * Get the balanced expectations handle for this PCard
-     *
-     * This is where verification history is tracked in handle_history.
-     *
-     * @returns Handle string for balanced expectations
+     * PHASE 1: PREP (Read & Validate)
      */
-    getBalancedHandle(): string;
+    private prep;
     /**
-     * Check if this PCard (Transition) can fire given the available VCards
-     *
-     * A transition can fire when all input VCards (preconditions) are present.
-     *
-     * @param availableVCards - Map of handle → VCard hash
-     * @returns Object with canFire boolean and missing preconditions
+     * PHASE 2: EXEC (Evaluate)
      */
-    canFire(availableVCards: Map<string, string>): {
-        canFire: boolean;
-        missing: string[];
-    };
+    private exec;
     /**
-     * Get the runtime required for this PCard
-     *
-     * @returns Runtime name (e.g., 'javascript', 'python', 'lean')
+     * PHASE 3: POST (Print/Bind)
      */
-    getRuntime(): string;
+    private post;
     /**
-     * Check if this is a multi-runtime PCard
-     *
-     * @returns True if this PCard supports multiple runtimes
+     * PHASE 4: AWAIT (Loop/Record)
      */
-    isMultiRuntime(): boolean;
+    private awaitRecord;
     /**
-     * Get precondition specification for VCard Sandwich evaluation.
-     *
-     * Extracts the precondition spec from abstract.preconditions,
-     * classifying each condition by type.
-     *
-     * @returns Object with conditions array and classified conditions
+     * Internal retry wrapper
      */
-    getPreVCardSpec(): {
-        conditions: unknown[];
-        classified: {
-            type: string;
-            condition: unknown;
-        }[];
-    };
+    private _executeWithRetry;
+}
+
+declare class BatchProcessor {
+    private engine;
+    constructor(engine: PTREngine);
     /**
-     * Get postcondition specification for VCard Sandwich evaluation.
+     * Execute a PCard against multiple targets sequentially.
      *
-     * Extracts the postcondition spec from abstract.postconditions,
-     * classifying each condition by type.
+     * Task 8: Batch Processing
      *
-     * @returns Object with conditions array and classified conditions
+     * @param pcardHash - Hash of the PCard to execute
+     * @param targetHashes - List of target MCard/VCard hashes
+     * @param context - Execution context parameters
+     * @param failFast - If true, stop on first failure; if false, continue and report all
      */
-    getPostVCardSpec(): {
-        conditions: unknown[];
-        classified: {
-            type: string;
-            condition: unknown;
-        }[];
-    };
+    executeBatch(pcardHash: string, targetHashes: string[], context?: Record<string, any>, failFast?: boolean): Promise<Array<{
+        success: boolean;
+        output: any;
+        error?: string;
+        targetHash: string;
+    }>>;
     /**
-     * Classify a condition by its type (function, schema, capability, declarative).
+     * Execute a PCard against multiple targets in parallel.
      *
-     * @param condition - The condition to classify
-     * @returns Object with type and the original condition
+     * Task 8: Batch Processing Parallel
+     *
+     * @param pcardHash - Hash of the PCard to execute
+     * @param targetHashes - List of target MCard/VCard hashes
+     * @param context - Execution context parameters
+     * @param maxConcurrency - Maximum number of concurrent executions
      */
-    private classifyCondition;
+    executeBatchParallel(pcardHash: string, targetHashes: string[], context?: Record<string, any>, maxConcurrency?: number): Promise<Array<{
+        success: boolean;
+        output: any;
+        error?: string;
+        targetHash: string;
+    }>>;
 }
 
 /**
- * VCard Model (Application Plane) - Petri Net TOKEN / PRE-CONDITION CARRIER
- *
- * This module defines VCard, the sovereign decision layer in the MVP Cards architecture.
- * VCard is the Applicative that manages all side effects and authorization.
- *
- * ## Category Theory Role: APPLICATIVE
- *
- * VCard is the **Applicative** in the MVP Cards categorical hierarchy:
- * - **MCard (Monad)**: Data container with unit and bind
- * - **PCard (Functor)**: Pure transformation
- * - **VCard (Applicative)**: Context-aware application `<*> :: F (a -> b) -> F a -> F b`
- *
- * The Applicative nature means VCard can encode **static pre-conditions**:
- * the authorization graph is known ahead of time, while actual execution
- * depends on runtime results.
+ * PCard Model (Control Plane) - Petri Net TRANSITION
  *
- * ## Petri Net Role: TOKEN + PRE-CONDITION
+ * This module defines PCard, the execution unit in the MVP Cards architecture.
+ * PCards are MCards containing a valid CLM (Cubical Logic Model) specification.
  *
- * In the Categorical Petri Net model, VCard serves dual roles:
+ * ## Categorical Foundation: STRONG PROFUNCTOR
  *
- * ### As Token
- * - VCard is the **Token** that resides in Places (Handles)
- * - Tokens enable Transitions (PCards) to fire
- * - Token movement represents verification cascade
+ * PCard implements the Strong Profunctor pattern from category theory:
  *
- * ### As Pre-Condition (Firing Guard)
- * A Petri Net transition fires when all input VCards exist:
+ *     P: A^op × B → Set
  *
- * ```
- * M' = M - •t + t•
- * ```
+ * Where:
+ *   - A^op denotes contravariance in input types (accepts MORE general)
+ *   - B denotes covariance in output types (produces MORE specific)
+ *   - Set is the category of sets (our value space)
  *
- * VCard as Input Arc encodes:
- * - **Input Place**: Handle pointing to required VCard
- * - **Token in Place**: VCard content in `card` table
- * - **Arc Guard**: VCard's Applicative authorization check
- * - **Token "Consumption"**: Recording `previous_hash` in new VCard
+ * The "Strong" property means PCard supports:
+ *   - first:  P(A, B) → P(C × A, C × B)  (threading context through)
+ *   - second: P(A, B) → P(A × C, B × C)  (preserving additional structure)
  *
- * ### Hash as Token AND Certificate (Dual Role)
+ * ## Composition via Coend
  *
- * | Role | Function | Implementation |
- * |------|----------|----------------|
- * | **Token** | Triggers firing (enables transitions) | `handle_registry.current_hash IS NOT NULL` |
- * | **Certificate** | Proves correctness after verification | VCard content witnesses Hoare Triple |
+ * Two PCards compose via the Coend (categorical integral):
  *
- * ```
- * {h_pre} PCard {h_post}
- * ```
+ *     (P ⨾ Q)(A, C) = ∫ᴮ P(A, B) × Q(B, C)
  *
  * Where:
- * - h_pre = hash of input VCard (precondition satisfied)
- * - PCard = CLM specification (transformation logic)
- * - h_post = hash of output VCard (postcondition witnessed)
+ *   - ∫ᴮ is the Coend over the intermediate type B
+ *   - P(A, B) is the first PCard (input A, output B)
+ *   - Q(B, C) is the second PCard (input B, output C)
+ *   - Result is a new PCard from A to C
  *
- * ## Cascade Pattern: Propagating Verification
+ * The `andThen()` method implements this Coend composition.
  *
- * VCards enable **verification cascades** across the network:
+ * ## SMC Structure (Symmetric Monoidal Category)
  *
- * ```
- * T1 → V1 → T2 → V2 → T3 → ... → Vn
- * ```
+ * PCard composition forms a Symmetric Monoidal Category:
+ *   - **Identity**: The "pass-through" PCard
+ *   - **Composition**: Sequential chaining via `andThen()` (;)
+ *   - **Tensor Product**: Parallel composition via `andAlso()` (⊗)
+ *   - **Symmetry**: Port swapping via `swap()` (σ)
  *
- * Each VerificationVCard (Vi) serves as:
- * 1. **Post-condition** of transition Ti (what it produces)
- * 2. **Pre-condition** of transition Ti+1 (what enables next step)
+ * ## Functor Role in MVP Cards Hierarchy
  *
- * ## DOTS Vocabulary Role: ARENA + ACTION
+ * PCard is the **Functor** in the categorical hierarchy:
+ *   - **MCard (Monad)**: Data container
+ *   - **PCard (Functor)**: Pure transformation `fmap :: (a -> b) -> F a -> F b`
+ *   - **VCard (Applicative)**: Context-aware application
  *
- * VCard is both:
- * - **Arena**: Interface type defining what can interact (subject_did, capabilities, external_refs)
- * - **Action**: Morphism where interactions (PCards) act on systems (MCards)
+ * ## Petri Net Role: TRANSITION
  *
- * ## The Four Roles:
- * 1. Identity & Credential Container (The "Who")
- * 2. Verification Hub (The "Rules")
- * 3. Side Effect Manager (The "Bridge")
- * 4. Input/Output Gatekeeper (The "Gate")
+ * In the Categorical Petri Net model, PCard is the **Transition**:
+ *   - Consumes input VCards (Tokens) from input Places
+ *   - Executes CLM logic (Abstract → Concrete transformation)
+ *   - Produces output VCards (Tokens) for output Places
  *
- * ## VCard as Egress Gate: The Sovereign Boundary
+ * ### The Firing Rule
  *
- * When a VerificationVCard is produced, it may also serve as **egress authorization**:
+ *     M' = M - •t + t•
  *
- * | Egress Role | VCard Content | Enables |
- * |-------------|--------------|---------|
- * | Export Authorization | `egress_capability: { destination_did, scope }` | Sharing to specific PKCs |
- * | Cross-PKC Transition | `transferable: true` | Token moves to destination's Petri Net |
- * | Federation Trigger | Signed VCard bundle | Downstream PKC's transitions enabled |
+ * Where:
+ *   - M = Current marking (token distribution)
+ *   - •t = Pre-set (input VCards required)
+ *   - t• = Post-set (output VCards produced)
  *
- * @see docs/VCard_Impl.md for full implementation specification
+ * ## CLM Triad: Abstract, Concrete, Balanced
+ *
+ * PCard content encodes the three dimensions:
+ *   - **Abstract (A)**: WHY - Specification, intent, type signature
+ *   - **Concrete (C)**: HOW - Implementation, runtime logic
+ *   - **Balanced (B)**: WHAT - Tests, verification expectations
+ *
+ * ## DOTS Vocabulary Role: LENS + CHART
+ *
+ *   - **Lens**: Tight morphism (Abstract ↔ Concrete coherence)
+ *   - **Chart**: Loose morphism (Balanced expectations wiring)
+ *
+ * @see docs/PCard_Impl.md for full implementation specification
  */
 
+type ClmObject = Record<string, unknown>;
 /**
- * Scope of a capability token.
- */
-declare enum CapabilityScope {
-    READ = "read",
-    WRITE = "write",
-    EXECUTE = "execute",
-    ADMIN = "admin",
-    DELEGATE = "delegate"
-}
-/**
- * Direction of gatekeeper authorization.
- */
-declare enum GatekeeperDirection {
-    INGRESS = "ingress",
-    EGRESS = "egress"
-}
-/**
- * A capability token defining authorized actions.
- */
-interface Capability {
-    capabilityId: string;
-    actorDid: string;
-    scope: CapabilityScope;
-    resourcePattern: string;
-    expiresAt?: Date;
-    constraints?: Record<string, unknown>;
-    transferable: boolean;
-}
-/**
- * A verified external reference managed by VCard.
+ * Input VCard reference for Petri Net pre-condition
  */
-interface ExternalRef {
-    uri: string;
-    contentHash: string;
-    status: 'verified' | 'pending' | 'stale' | 'invalid';
-    signature?: string;
-    lastVerified?: Date;
-    qosMetrics?: Record<string, unknown>;
+interface InputVCardRef {
+    /** Handle name (Place) where precondition VCard must exist */
+    handle: string;
+    /** Expected VCard hash (optional, for strict matching) */
+    expectedHash?: string;
+    /** Purpose of this precondition (e.g., 'authenticate', 'authorize') */
+    purpose?: string;
 }
-type ParsedVCardContent = Record<string, unknown>;
-type SimulationLogEntry = {
-    timestamp: Date;
-    effectType: string;
-    details: unknown;
-    simulated: true;
-};
 /**
- * An ingress or egress gatekeeper event.
+ * Output VCard specification for Petri Net post-condition
  */
-interface GatekeeperEvent {
-    direction: GatekeeperDirection;
-    timestamp: Date;
-    sourceDid?: string;
-    destinationDid?: string;
-    contentHash: string;
-    authorized: boolean;
-    capabilityUsed?: string;
-    signature?: string;
+interface OutputVCardSpec {
+    /** Handle name (Place) where output VCard will be deposited */
+    handle: string;
+    /** Type of VCard to generate */
+    type: 'verification' | 'authorization' | 'audit' | 'result';
+    /** Additional metadata to include in the VCard */
+    metadata?: Record<string, unknown>;
 }
 /**
- * VCard - The Application Plane unit (Petri Net Token)
- *
- * Implements the Empty Schema Principle: VCard IS an MCard.
- * This class provides a view and runtime state management over the immutable content.
+ * PCard - The Control Plane unit (Petri Net Transition)
  *
- * In Petri Net terms:
- * - VCard is a **Token** that resides in a **Place** (Handle)
- * - VCard enables **Transitions** (PCards) to fire when present
- * - VCard serves as both **Pre-condition** (what enables) and **Post-condition** (what is produced)
+ * A PCard is an MCard whose content is a valid CLM specification.
+ * It represents a transformation (Lens) with a specific interaction pattern (Chart).
  */
-declare class VCard extends MCard {
-    private _subjectDid;
-    private _controllerPubkeys;
-    private _capabilities;
-    private _externalRefs;
-    private _exportManifest;
-    private _gatekeeperLog;
-    private _pcardRefsHashes;
-    protected constructor(content: Uint8Array, hash: string, g_time: string, contentType: string, hashFunction: string, initialData: ParsedVCardContent);
-    private _initializeMutableState;
+declare class PCard extends MCard {
+    private readonly parsedClm;
+    private readonly isLens;
+    protected constructor(content: Uint8Array, hash: string, g_time: string, contentType: string, hashFunction: string, parsedClm: ClmObject, isLens: boolean);
     /**
-     * Create a new VCard from parameters.
-     * Follows strict UPTV structure { vcard: { ... } }.
+     * Create a new PCard from CLM content
+     *
+     * @param content - The CLM YAML string or bytes
+     * @param hashAlgorithm - Hash algorithm to use
+     * @param isLens - Whether this acts primarily as a Lens (default true)
      */
-    static createVCard(subjectDid: string, controllerPubkeys: string[], capabilities?: Capability[], externalRefs?: ExternalRef[], hashAlgorithm?: string): Promise<VCard>;
+    static create(content: string | Uint8Array, hashAlgorithm?: string, isLens?: boolean): Promise<PCard>;
     /**
-     * Create a VCard wrapper from an existing MCard.
+     * Get DOTS vocabulary metadata for this PCard
+     *
+     * Automatically extracts dependencies from the CLM structure if available.
      */
-    static fromMCard(card: MCard): Promise<VCard>;
     getDOTSMetadata(): DOTSMetadata;
-    get subjectDid(): string;
-    get controllerPubkeys(): string[];
-    get capabilities(): Capability[];
-    get externalRefs(): ExternalRef[];
-    addCapability(capability: Capability): void;
-    getValidCapabilities(): Capability[];
-    hasCapability(scope: CapabilityScope, resourceHash: string): boolean;
-    addPCardReference(pcardHash: string): void;
-    getPCardReferences(): string[];
-    addExternalRef(ref: ExternalRef): void;
-    getExternalRefsByStatus(status: ExternalRef['status']): ExternalRef[];
-    verifyExternalRef(uri: string, newHash: string): boolean;
-    authorizeIngress(sourceDid: string, contentHash: string, capabilityId?: string): boolean;
-    registerForEgress(contentHash: string): boolean;
-    authorizeEgress(destinationDid: string, contentHash: string, capabilityId?: string): boolean;
-    private _logEgress;
-    getGatekeeperLog(direction?: GatekeeperDirection): GatekeeperEvent[];
-    getExportManifest(): string[];
-    simulateMode(): VCardSimulation;
     /**
-     * Get the handle where this VCard token currently resides
-     *
-     * In Petri Net terms, this is the "Place" where the token is located.
-     *
-     * @returns Handle string if available in content, or hash-based handle
+     * Get the parsed CLM object
      */
-    getTokenHandle(): string;
+    get clm(): ClmObject;
+    private getSection;
     /**
-     * Check if this VCard is a VerificationVCard (result of PCard execution)
-     *
-     * VerificationVCards are produced by PCard transitions and contain
-     * execution results with provenance chain.
-     *
-     * @returns True if this is a verification token
+     * Get the Abstract Specification section (UPTV Role: Abstract)
      */
-    isVerificationVCard(): boolean;
+    get abstract(): unknown;
     /**
-     * Get the previous hash in the provenance chain
-     *
-     * In Petri Net terms, this links to the input VCard that was "consumed"
-     * when the transition fired to produce this VCard.
-     *
-     * @returns Previous VCard hash if this is part of a verification cascade
+     * Get the Concrete Implementation section (UPTV Role: Concrete)
      */
-    getPreviousHash(): string | undefined;
+    get concrete(): unknown;
     /**
-     * Get the PCard hash that produced this VCard (if verification)
+     * Get the Balanced Expectations (tests) section (UPTV Role: Balanced)
+     */
+    get balanced(): unknown;
+    /**
+     * Get the Abstract Specification section (Legacy)
+     */
+    get abstractSpec(): unknown;
+    /**
+     * Get the Concrete Implementation section (Legacy)
+     */
+    get concreteImpl(): unknown;
+    /**
+     * Get the Balanced Expectations (tests) section (Legacy)
+     */
+    get balancedExpectations(): unknown;
+    /**
+     * Sequential Composition via Coend (P ⨾ Q)
+     *
+     * Implements profunctor composition using the Coend formula:
+     *
+     *     (P ⨾ Q)(A, C) = ∫ᴮ P(A, B) × Q(B, C)
      *
-     * This links the output token to the transition that created it.
+     * Where:
+     *   - this is P: A → B
+     *   - otherPCard is Q: B → C
+     *   - Result is P ⨾ Q: A → C
      *
-     * @returns PCard hash that produced this VCard
-     */
-    getSourcePCardHash(): string | undefined;
-    /**
-     * Create a VerificationVCard from PCard execution result
+     * The Coend (∫ᴮ) "integrates out" the intermediate type B by:
+     * 1. Matching P's output type with Q's input type
+     * 2. Creating a chain where P's result feeds into Q
+     * 3. The composition is associative: (P ⨾ Q) ⨾ R = P ⨾ (Q ⨾ R)
      *
-     * This is the factory method for producing output tokens in the Petri Net.
+     * In PTR execution:
+     *   - P is executed first (prep → exec → post)
+     *   - P's output VCard becomes Q's input VCard
+     *   - Q is executed second
+     *   - Final result is Q's output VCard
      *
-     * @param pcard - The PCard (Transition) that executed
-     * @param result - Execution result
-     * @param previousVCard - Input VCard (pre-condition) if any
-     * @param success - Whether execution succeeded
-     * @returns New VerificationVCard
+     * Note: Named 'andThen' to avoid conflict with Promise.then (Thenable).
+     *
+     * @param otherPCard - The PCard to execute after this one (Q in P ⨾ Q)
+     * @returns A new PCard representing the composed profunctor (P ⨾ Q)
      */
-    static createVerificationVCard(pcard: {
-        hash: string;
-        getTransitionHandle?: () => string;
-        getBalancedHandle?: () => string;
-    }, result: unknown, previousVCard?: VCard, success?: boolean, hashAlgorithm?: string): Promise<VCard>;
+    andThen(otherPCard: PCard): Promise<PCard>;
     /**
-     * Check if this VCard enables a specific PCard to fire
+     * Tensor Product ($A \otimes B$)
      *
-     * @param requiredHandle - The handle where a precondition VCard must exist
-     * @returns True if this VCard satisfies that precondition
+     * Runs this PCard and otherPCard in parallel.
      */
-    enablesTransition(requiredHandle: string): boolean;
+    andAlso(otherPCard: PCard): Promise<PCard>;
     /**
-     * Witness Precondition (V_pre) — creates a VCard that witnesses
-     * the input was accepted for evaluation.
+     * Symmetry ($\sigma$)
      *
-     * @param inputMCard - The input MCard being evaluated
-     * @param hashAlgorithm - Hash algorithm to use
-     * @returns VCard with type "precondition-witness"
+     * Swaps the input/output ports of a tensor product.
      */
-    static witnessPrecondition(inputMCard: MCard, hashAlgorithm?: string): Promise<VCard>;
+    swap(): Promise<PCard>;
     /**
-     * Witness Postcondition (V_post) — creates a VCard that witnesses
-     * the output was produced by a PCard evaluation.
-     *
-     * @param output - The execution output
-     * @param pcardHash - Hash of the PCard that produced the output
-     * @param hashAlgorithm - Hash algorithm to use
-     * @returns VCard with type "postcondition-witness"
+     * Run the Balanced Expectations (Proof)
      */
-    static witnessPostcondition(output: unknown, pcardHash?: string, hashAlgorithm?: string): Promise<VCard>;
+    verify(): Record<string, unknown>;
     /**
-     * Create a Sandwich Proof — combines V_pre and V_post into a
-     * composite verification proof.
-     *
-     * @param vPre - Precondition witness VCard
-     * @param vPost - Postcondition witness VCard
-     * @param pcardHash - Hash of the PCard that was evaluated
-     * @param hashAlgorithm - Hash algorithm to use
-     * @returns VCard with type "verification-sandwich"
+     * Run with instrumentation (eBPF/Tracing)
      */
-    static sandwich(vPre: VCard, vPost: VCard, pcardHash?: string, hashAlgorithm?: string): Promise<VCard>;
-}
-/**
- * Simulation context for VCard (EOS Compliance).
- */
-declare class VCardSimulation {
-    private vcard;
-    private log;
-    constructor(vcard: VCard);
-    logEffect(effectType: string, details: unknown): void;
-    getSimulationLog(): SimulationLogEntry[];
-}
-
-/**
- * PTREngine — The Polynomial Type Runtime Engine (Arrow Interface)
- *
- * This is the canonical execution primitive for the MVP Cards architecture.
- * It implements the formal Arrow interface mandated by the design documents:
- *
- *   - arr:     Lift a pure function into a PTR-managed Arrow (PCard)
- *   - compose: Sequential composition (>>>)
- *   - first:   Operate on first element of a product, preserving second
- *
- * The `runWithSandwich()` method is the core Arrow evaluation function,
- * implementing the VCard Sandwich lifecycle:
- *
- *     V_pre → PCard(Evaluation Map) → V_post → Sandwich(V_pre, V_post)
- *
- * Mirrors Python: mcard.ptr.core.engine.PTREngine
- *
- * Usage:
- *     import { PTREngine } from './PTREngine.js';
- *     const engine = new PTREngine(collection);
- *     const [output, sandwich] = await engine.runWithSandwich(pcardHash, inputHash);
- *
- * @module PTREngine
- */
-
-type PreCheck = (input: MCard) => boolean;
-type PostCheck = (output: unknown) => boolean;
-/**
- * PTREngine — The formal Arrow execution engine.
- *
- * Replaces ad-hoc CLMRunner execution paths with a formal
- * VCard Sandwich lifecycle. Every PCard execution generates
- * (V_pre, V_post) boundary proofs.
- */
-declare class PTREngine {
-    private collection;
-    private executionLog;
-    private runner;
+    profile(): Record<string, unknown>;
     /**
-     * Initialize PTREngine.
-     *
-     * @param storageCollection - MCard collection for long-term knowledge (mcard_collection.db)
-     * @param executionLogCollection - MCard collection for execution traces (execution_log.db).
-     *   If not provided, traces are written to storageCollection.
-     * @param options - Additional configuration
+     * Run in Operative mode (Step-by-step)
      */
-    constructor(storageCollection?: CardCollection, executionLogCollection?: CardCollection, options?: {
-        basePath?: string;
-        timeout?: number;
-    });
+    debug(): Record<string, unknown>;
     /**
-     * The Arrow execution primitive — the entire PTR in one method.
-     *
-     * Implements the VCard Sandwich lifecycle:
-     *     V_pre → PCard(Evaluation Map) → V_post
-     *
-     * @param pcardHash - Hash of the PCard to execute
-     * @param inputHash - Hash of the input MCard
-     * @param preCheck - Optional callable to validate preconditions on input
-     * @param postCheck - Optional callable to validate postconditions on output
-     * @returns Tuple of [execution_output, vcard_sandwich]
-     * @throws PreconditionViolation if preCheck returns false
-     * @throws PostconditionViolation if postCheck returns false
+     * Return documentation/explanation
      */
-    runWithSandwich(pcardHash: string, inputHash: string, preCheck?: PreCheck, postCheck?: PostCheck): Promise<[unknown, VCard]>;
+    explain(): Record<string, unknown>;
     /**
-     * Execute a CLM specification from a YAML file.
+     * Get input VCard references (Pre-set: •t)
      *
-     * Absorbs CLMRunner.runFile(), routing all file-based execution
-     * through the formal PTREngine lifecycle with VCard Sandwich generation.
+     * These represent the preconditions that must be satisfied before
+     * this PCard (Transition) can fire.
      *
-     * @param filePath - Path to the YAML file
-     * @param context - Execution context (inputs)
-     * @returns Execution report with VCard Sandwich proof hashes
+     * @returns Array of input VCard references from CLM specification
      */
-    runFile(filePath: string, context?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    getInputVCardRefs(): InputVCardRef[];
     /**
-     * Arrow `arr` — lift a pure function into a PCard.
+     * Get output VCard specifications (Post-set: t•)
      *
-     * Creates a PCard whose Concrete implementation is the given function.
+     * These define what VCards (Tokens) this PCard produces when fired.
      *
-     * @param func - A pure function from string to string
-     * @param name - Human-readable name for the PCard
-     * @returns The created PCard (stored in collection)
+     * @returns Array of output VCard specifications
      */
-    arr(func: (input: string) => string, name?: string): Promise<PCard>;
+    getOutputVCardSpecs(): OutputVCardSpec[];
     /**
-     * Arrow `>>>` — sequential composition of two PCards.
-     *
-     * Creates a new PCard representing pcardA >>> pcardB,
-     * where the output of A feeds into the input of B.
+     * Get the canonical handle for this PCard (Transition)
      *
-     * @param pcardAHash - Hash of the first PCard (executed first)
-     * @param pcardBHash - Hash of the second PCard (executed second)
-     * @returns The composed PCard (stored in collection)
+     * @returns Handle string in form `{module}/{function}/spec`
      */
-    compose(pcardAHash: string, pcardBHash: string): Promise<PCard>;
+    getTransitionHandle(): string;
     /**
-     * Arrow `first` — operate on first element of a product.
-     *
-     * Creates a new PCard that applies the original PCard to the
-     * first element of a (A, C) pair while preserving C.
+     * Get the balanced expectations handle for this PCard
      *
-     * @param pcardHash - Hash of the PCard to lift
-     * @returns The first-lifted PCard (stored in collection)
-     */
-    first(pcardHash: string): Promise<PCard>;
-    private recordToExecutionLog;
-}
-
-/**
- * Type definitions for CLM (Cubical Logic Model) execution.
- */
-/**
- * CLM specification structure (parsed from YAML).
- */
-interface CLMSpec {
-    version: string;
-    chapter: {
-        id: number;
-        title: string;
-        mvp_card?: string;
-        pkc_task?: string;
-    };
-    clm: {
-        abstract?: {
-            concept?: string;
-            purpose?: string;
-            description?: string;
-            goal?: string;
-            context?: string;
-            success_criteria?: string;
-            [key: string]: unknown;
-        };
-        abstract_spec?: CLMSpec['clm']['abstract'];
-        concrete?: {
-            manifestation?: string;
-            description?: string;
-            logic_source?: string;
-            runtime?: string;
-            builtin?: boolean;
-            code_file?: string;
-            entry_point?: string;
-            inputs?: string[];
-            process?: string;
-            outputs?: string[];
-            action?: string;
-            boundary?: 'intrinsic' | 'extrinsic';
-            runtimes_config?: RuntimeConfig[];
-            [key: string]: unknown;
-        };
-        concrete_impl?: CLMSpec['clm']['concrete'];
-        balanced?: {
-            expectation?: string;
-            description?: string;
-            test_cases?: unknown[];
-            examples?: unknown[];
-            [key: string]: unknown;
-        };
-        balanced_exp?: CLMSpec['clm']['balanced'];
-    };
-    examples?: CLMExample[];
-}
-/**
- * Runtime configuration for multi-runtime CLMs.
- */
-interface RuntimeConfig {
-    name: string;
-    file?: string;
-    binary?: string;
-    module?: string;
-    entry?: string;
-}
-/**
- * CLM example definition.
- */
-interface CLMExample {
-    name: string;
-    input?: unknown;
-    expected_output?: unknown;
-    result_contains?: string;
-    [key: string]: unknown;
-}
-/**
- * Result of executing a single CLM.
- */
-interface ExecutionResult {
-    success: boolean;
-    result?: unknown;
-    error?: string;
-    executionTime: number;
-    clm: {
-        chapter: string;
-        concept: string;
-        manifestation: string;
-        boundary?: string;
-    };
-}
-/**
- * Result of executing on a single runtime (for multi-runtime).
- */
-interface RuntimeResult {
-    runtime: string;
-    success: boolean;
-    result?: unknown;
-    error?: string;
-    executionTime: number;
-}
-/**
- * Result of multi-runtime consensus execution.
- */
-interface MultiRuntimeResult {
-    success: boolean;
-    consensus: boolean;
-    results: RuntimeResult[];
-    consensusValue?: unknown;
-    error?: string;
-    executionTime: number;
-    clm: {
-        chapter: string;
-        concept: string;
-        manifestation: string;
-        boundary?: string;
+     * This is where verification history is tracked in handle_history.
+     *
+     * @returns Handle string for balanced expectations
+     */
+    getBalancedHandle(): string;
+    /**
+     * Check if this PCard (Transition) can fire given the available VCards
+     *
+     * A transition can fire when all input VCards (preconditions) are present.
+     *
+     * @param availableVCards - Map of handle → VCard hash
+     * @returns Object with canFire boolean and missing preconditions
+     */
+    canFire(availableVCards: Map<string, string>): {
+        canFire: boolean;
+        missing: string[];
     };
-}
-/**
- * Verification result (comparing actual vs expected).
- */
-interface VerificationResult {
-    verified: boolean;
-    expected: unknown;
-    actual: unknown;
-    executionResult: ExecutionResult;
-}
-/**
- * Summary of running all examples in a CLM.
- */
-interface RunExamplesSummary {
-    total: number;
-    passed: number;
-    results: ExampleRunResult[];
-}
-/**
- * Result of running a single example.
- */
-interface ExampleRunResult {
-    case: number;
-    name: string;
-    input: unknown;
-    result: unknown;
-    error?: string;
-    expected: unknown;
-    match: boolean;
-}
-/**
- * Execution report for external reporting.
- */
-interface ExecutionReport {
-    status: 'success' | 'failure';
-    result?: unknown;
-    error?: string;
-    chapter_id: number;
-    chapter_title: string;
-}
-/**
- * Summary report for external reporting.
- */
-interface SummaryReport {
-    status: 'success' | 'failure';
-    result: {
-        success: boolean;
-        total: number;
-        results: Array<{
-            case: number;
-            name: string;
-            result: unknown;
-            error?: string;
-        }>;
+    /**
+     * Get the runtime required for this PCard
+     *
+     * @returns Runtime name (e.g., 'javascript', 'python', 'lean')
+     */
+    getRuntime(): string;
+    /**
+     * Check if this is a multi-runtime PCard
+     *
+     * @returns True if this PCard supports multiple runtimes
+     */
+    isMultiRuntime(): boolean;
+    /**
+     * Get precondition specification for VCard Sandwich evaluation.
+     *
+     * Extracts the precondition spec from abstract.preconditions,
+     * classifying each condition by type.
+     *
+     * @returns Object with conditions array and classified conditions
+     */
+    getPreVCardSpec(): {
+        conditions: unknown[];
+        classified: {
+            type: string;
+            condition: unknown;
+        }[];
     };
-    chapter_id: number;
-    chapter_title: string;
+    /**
+     * Get postcondition specification for VCard Sandwich evaluation.
+     *
+     * Extracts the postcondition spec from abstract.postconditions,
+     * classifying each condition by type.
+     *
+     * @returns Object with conditions array and classified conditions
+     */
+    getPostVCardSpec(): {
+        conditions: unknown[];
+        classified: {
+            type: string;
+            condition: unknown;
+        }[];
+    };
+    /**
+     * Classify a condition by its type (function, schema, capability, declarative).
+     *
+     * @param condition - The condition to classify
+     * @returns Object with type and the original condition
+     */
+    private classifyCondition;
+    /**
+     * Instantiate a VCard explicitly wrapping this PCard.
+     *
+     * This establishes the PCard as the literal factory for its VCards,
+     * ensuring that the `wrappedPcardHash` is permanently embedded into
+     * the generated VCard's content structure.
+     */
+    createVCard(vcardClass?: any, subjectDid?: string, controllerPubkeys?: string[], capabilities?: any[], externalRefs?: any[], managedEventTypes?: string[], ...args: any[]): Promise<any>;
 }
+
 /**
- * CLM banner lines for display.
+ * Sandbox Executor
+ *
+ * Executes PCard logic in a sandboxed environment with multi-language support.
+ * Wraps the execution pipeline inside a monadic boundary.
  */
-interface CLMBannerLines {
-    header: string[];
+
+declare class SandboxExecutor {
+    private collection;
+    constructor(collection: CardCollection);
+    /**
+     * Executes PCard logic via the underlying CLMRunner.
+     */
+    executeMonad(pcardObj: PCard, inputMCard: MCard, context: Record<string, any>, runner: CLMRunner): Promise<{
+        result: unknown;
+        error?: string;
+    }>;
 }
 
 /**
- * CLMRunner - Execute JavaScript logic from CLM specifications
- *
- * Node.js PTR runtime for interpreting Cubical Logic Models.
+ * Certificate Generator
  *
- * Refactored to use modular components from ./clm/
+ * Handles the generation of computable certificates (VCards) for
+ * the execution phases. Acts as an isolating wrapper around VCardSandwich
+ * and VCard factory boundaries.
  */
 
-declare class CLMRunner {
-    private loader;
-    private timeout;
-    private collection?;
-    private privateCollection?;
-    constructor(basePath?: string, timeout?: number, collection?: CardCollection, privateCollection?: CardCollection);
+declare class CertificateGenerator {
+    private collection;
+    constructor(collection: CardCollection);
     /**
-     * Run a CLM directly from a file path.
+     * Generate V_pre (Precondition Witness)
      */
-    runFile(clmPath: string, input?: unknown): Promise<ExecutionResult>;
+    generateVCardPre(inputMCard: MCard): Promise<VCard>;
     /**
-     * Execute a CLM specification with given input.
+     * Generate V_post (Postcondition Witness)
      *
-     * Implements Petri Net Transition Semantics:
-     * 1. Constructs PCard (Transition)
-     * 2. Checks Pre-conditions (Firing Rule)
-     * 3. Executes Logic
-     * 4. Produces VerificationVCard (Token)
-     * 5. Persists to Collection (Place)
+     * Optionally embeds governance telemetry (Token Arithmetics: M, N, E, Pi)
+     * as structured metadata within the VCard postcondition.
      */
-    executeCLM(clm: CLMSpec, chapterDir: string, input: unknown): Promise<ExecutionResult>;
+    generateVCardPost(executionOutput: unknown, pcardHash: string, governanceTelemetry?: Record<string, number>): Promise<VCard>;
     /**
-     * Execute a CLM across multiple runtimes and verify consensus.
+     * Generate Sandwich (Verification Integration)
      */
-    executeMultiRuntime(clm: CLMSpec, chapterDir: string, input: unknown): Promise<MultiRuntimeResult>;
+    generateVerificationSandwich(vPre: VCard, vPost: VCard, pcardHash: string): Promise<VCard>;
+}
+
+/**
+ * Correctness tracking and mathematical verification.
+ */
+
+declare class CorrectnessTracker {
+    enableAlignmentScoring: boolean;
+    private safetyViolations;
+    private livenessMetrics;
+    constructor(enableAlignmentScoring?: boolean);
     /**
-     * Check if a CLM is a multi-runtime CLM.
+     * Record a safety property violation.
      */
-    isMultiRuntime(clm: CLMSpec): boolean;
+    recordSafetyViolation(propertyName: string, violationType: string, details: string): void;
     /**
-     * Verify CLM output against expected result.
+     * Record progress toward liveness goals.
      */
-    verifyCLM(clm: CLMSpec, chapterDir: string, input: unknown, expected: unknown): Promise<VerificationResult>;
+    recordLivenessMetric(goal: string, progress: number): void;
     /**
-     * Run all examples from a CLM specification.
+     * Calculate directional alignment using cosine similarity.
+     *
+     * Implements: cos(θ) = (v_actual · v_spec) / (||v_actual|| ||v_spec||)
      */
-    runExamples(clm: CLMSpec, chapterDir: string): Promise<Array<{
-        name: string;
-        result: ExecutionResult;
-    }>>;
+    calculateAlignment(output: unknown, specEmbedding?: number[]): number | undefined;
     /**
-     * Summarize example runs.
+     * Verify that transformation preserves invariants (Jacobian check).
+     *
+     * Implements: |J| != 0 => transformation is reversible
      */
-    summarizeExampleRuns(clm: CLMSpec, results: Array<{
-        name: string;
-        result: ExecutionResult;
-    }>): RunExamplesSummary;
+    verifyInvariantPreservation(pcard: MCard, target: MCard, output: unknown): boolean;
+    getSafetyViolations(): SafetyViolation[];
+    getLivenessMetrics(): LivenessMetric[];
+    clear(): void;
+}
+
+/**
+ * OpenTelemetry Sidecar & Observability Manager
+ *
+ * Implements the telemetry tracing logic from Python's ObservabilityManager.
+ */
+declare class OpenTelemetrySidecar {
+    private static instance;
+    private constructor();
+    static getInstance(): OpenTelemetrySidecar;
     /**
-     * Build CLM banner for display.
+     * Captures execution context, including LLM logs and warnings into observability payload.
      */
-    buildCLMBanner(clm: CLMSpec): CLMBannerLines;
+    captureTelemetry(executionData: any): Record<string, unknown>;
+}
+
+/**
+ * PTREngine — The Polynomial Type Runtime Engine (Arrow Interface)
+ *
+ * This is the canonical execution primitive for the MVP Cards architecture.
+ * It implements the formal Arrow interface mandated by the design documents:
+ *
+ *   - arr:     Lift a pure function into a PTR-managed Arrow (PCard)
+ *   - compose: Sequential composition (>>>)
+ *   - first:   Operate on first element of a product, preserving second
+ *
+ * The `runWithSandwich()` method is the core Arrow evaluation function,
+ * implementing the VCard Sandwich lifecycle:
+ *
+ *     V_pre → PCard(Evaluation Map) → V_post → Sandwich(V_pre, V_post)
+ *
+ * Mirrors Python: mcard.ptr.core.engine.PTREngine
+ *
+ * Usage:
+ *     import { PTREngine } from './PTREngine.js';
+ *     const engine = new PTREngine(collection);
+ *     const [output, sandwich] = await engine.runWithSandwich(pcardHash, inputHash);
+ *
+ * @module PTREngine
+ */
+
+type PreCheck = (input: MCard) => boolean;
+type PostCheck = (output: unknown) => boolean;
+/**
+ * PTREngine — The formal Arrow execution engine.
+ *
+ * Replaces ad-hoc CLMRunner execution paths with a formal
+ * VCard Sandwich lifecycle. Every PCard execution generates
+ * (V_pre, V_post) boundary proofs.
+ */
+declare class PTREngine {
+    private collection;
+    private executionLog;
+    private identitySpace;
+    private runner;
+    repl: REPLCycle;
+    batch: BatchProcessor;
+    sandbox: SandboxExecutor;
+    certifier: CertificateGenerator;
+    correctnessTracker: CorrectnessTracker;
+    observability: OpenTelemetrySidecar;
     /**
-     * Build execution report.
+     * Async Factory for PTREngine to support automatic Tri-Database Isolation.
      */
-    buildExecutionReport(clm: CLMSpec, execution: ExecutionResult): ExecutionReport;
+    static create(storageCollection?: CardCollection, executionLogCollection?: CardCollection, identitySpaceCollection?: CardCollection, options?: {
+        basePath?: string;
+        timeout?: number;
+    }): Promise<PTREngine>;
     /**
-     * Build summary report.
+     * Initialize PTREngine. (Consider using PTREngine.create() for automatic database isolation)
+     *
+     * @param storageCollection - MCard collection for long-term knowledge (mcard_collection.db)
+     * @param executionLogCollection - MCard collection for execution traces (execution_log.db).
+     * @param identitySpaceCollection - MCard collection for isolated Zero-Trust checks.
+     * @param options - Additional configuration
      */
-    buildSummaryReport(clm: CLMSpec, summary: RunExamplesSummary): SummaryReport;
-    private executeLoader;
-    private executeNetwork;
-    private executeStandard;
-    private executeRecursive;
-    private resolveCodeOrPath;
-    private buildNetworkContext;
-    private buildJavaScriptContext;
-    private buildRunCLM;
+    constructor(storageCollection?: CardCollection, executionLogCollection?: CardCollection, identitySpaceCollection?: CardCollection, options?: {
+        basePath?: string;
+        timeout?: number;
+    });
+    getCollection(): CardCollection;
+    getExecutionLog(): CardCollection;
+    getIdentitySpace(): CardCollection;
+    getRunner(): CLMRunner;
+    /**
+     * The Arrow execution primitive — the entire PTR in one method.
+     *
+     * Implements the VCard Sandwich lifecycle:
+     *     V_pre → PCard(Evaluation Map) → V_post
+     *
+     * @param pcardHash - Hash of the PCard to execute
+     * @param inputHash - Hash of the input MCard
+     * @param preCheck - Optional callable to validate preconditions on input
+     * @param postCheck - Optional callable to validate postconditions on output
+     * @returns Tuple of [execution_output, vcard_sandwich, retry_count]
+     * @throws PreconditionViolation if preCheck returns false
+     * @throws PostconditionViolation if postCheck returns false
+     */
+    runWithSandwich(pcardHash: string, inputHash: string, preCheck?: PreCheck, postCheck?: PostCheck, context?: Record<string, any>): Promise<[unknown, VCard, number]>;
+}
+
+/**
+ * AuditVerifier handles the Pure Functional Software Deployment (PFSD) auditing phase.
+ * It reads Verification Sandwich MCards and walks the execution log references
+ * to assert Hoare-triples and mathematical state integrity.
+ */
+declare class AuditVerifier {
+    private collection;
+    constructor(collection: CardCollection);
+    /**
+     * Takes a Sandwich hash, loads it from the collection, and verifies the
+     * structural integrity of the corresponding VCard_Pre and VCard_Post.
+     */
+    verifyPfsdCertificate(sandwichHash: string): Promise<boolean>;
+}
+
+declare function verifyIsomorphism(sourceHashes: Record<string, string>, destHashes: Record<string, string>): {
+    isomorphic: boolean;
+    missingInDest: string[];
+    missingInSource: string[];
+    hashMismatches: string[];
+};
+
+declare const isomorphism_verifyIsomorphism: typeof verifyIsomorphism;
+declare namespace isomorphism {
+  export { isomorphism_verifyIsomorphism as verifyIsomorphism };
 }
 
-export { CLMRunner, CardCollection, type CreateEngineOptions, ENGINE_INFO, Either, type EngineEnvironment, type EngineInfo, EngineType, FileIO, IO, LLMConfig, LLMRuntime, index as Lambda, LambdaRuntime, Loader, MCard, Maybe, PTREngine, SandboxWorker, StorageEngine, chatMonad, createEngine, getAvailableEngines, getEngineInfo, getEnginesByEnvironment, promptMonad };
+export { AuditVerifier, CLMRunner, CardCollection, type CreateEngineOptions, ENGINE_INFO, Either, type EngineEnvironment, type EngineInfo, EngineType, FileIO, IO, isomorphism as IsomorphismValidator, LLMConfig, LLMRuntime, index as Lambda, LambdaRuntime, LivenessMetric, Loader, MCard, Maybe, PTREngine, SafetyViolation, SandboxWorker, StorageEngine, chatMonad, createEngine, getAvailableEngines, getEngineInfo, getEnginesByEnvironment, promptMonad };