@manifesto-ai/core 2.8.0 → 2.9.0

package/dist/schema/flow.d.ts

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { type ExprNode } from "./expr.js";
+/**
+ * FlowNode - Declarative state transition programs
+ * Flows do NOT execute; they describe.
+ * Flows do NOT return values; they modify Snapshot.
+ * Flows are NOT Turing-complete; they always terminate.
+ */
+export type FlowNode = SeqFlow | IfFlow | PatchFlow | EffectFlow | CallFlow | HaltFlow | FailFlow;
+/**
+ * Patch operations
+ */
+export declare const PatchOp: z.ZodEnum<{
+    set: "set";
+    unset: "unset";
+    merge: "merge";
+}>;
+export type PatchOp = z.infer<typeof PatchOp>;
+/**
+ * seq - Execute steps in order
+ */
+export declare const SeqFlow: z.ZodType<{
+    kind: "seq";
+    steps: FlowNode[];
+}>;
+export type SeqFlow = z.infer<typeof SeqFlow>;
+/**
+ * if - Conditional execution
+ */
+export declare const IfFlow: z.ZodType<{
+    kind: "if";
+    cond: ExprNode;
+    then: FlowNode;
+    else?: FlowNode;
+}>;
+export type IfFlow = z.infer<typeof IfFlow>;
+/**
+ * patch - State mutation declaration
+ */
+export declare const PatchFlow: z.ZodObject<{
+    kind: z.ZodLiteral<"patch">;
+    op: z.ZodEnum<{
+        set: "set";
+        unset: "unset";
+        merge: "merge";
+    }>;
+    path: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"prop">;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"index">;
+        index: z.ZodNumber;
+    }, z.core.$strip>], "kind">>;
+    value: z.ZodOptional<z.ZodType<ExprNode, unknown, z.core.$ZodTypeInternals<ExprNode, unknown>>>;
+}, z.core.$strip>;
+export type PatchFlow = z.infer<typeof PatchFlow>;
+/**
+ * effect - External operation requirement declaration
+ * Effects are NOT executed by Core. They are declarations recorded in Snapshot.
+ */
+export declare const EffectFlow: z.ZodObject<{
+    kind: z.ZodLiteral<"effect">;
+    type: z.ZodString;
+    params: z.ZodRecord<z.ZodString, z.ZodType<ExprNode, unknown, z.core.$ZodTypeInternals<ExprNode, unknown>>>;
+}, z.core.$strip>;
+export type EffectFlow = z.infer<typeof EffectFlow>;
+/**
+ * call - Invoke another flow by name
+ * Does NOT pass arguments or return values.
+ * The called Flow reads from the same Snapshot.
+ */
+export declare const CallFlow: z.ZodObject<{
+    kind: z.ZodLiteral<"call">;
+    flow: z.ZodString;
+}, z.core.$strip>;
+export type CallFlow = z.infer<typeof CallFlow>;
+/**
+ * halt - Stop flow execution normally (not an error)
+ */
+export declare const HaltFlow: z.ZodObject<{
+    kind: z.ZodLiteral<"halt">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HaltFlow = z.infer<typeof HaltFlow>;
+/**
+ * fail - Stop flow execution with an error
+ * The error is recorded in Snapshot.
+ */
+export declare const FailFlow: z.ZodObject<{
+    kind: z.ZodLiteral<"fail">;
+    code: z.ZodString;
+    message: z.ZodOptional<z.ZodType<ExprNode, unknown, z.core.$ZodTypeInternals<ExprNode, unknown>>>;
+}, z.core.$strip>;
+export type FailFlow = z.infer<typeof FailFlow>;
+export declare const FlowNodeSchema: z.ZodType<FlowNode>;
+/**
+ * Flow node kinds enum
+ */
+export declare const FlowKind: z.ZodEnum<{
+    if: "if";
+    patch: "patch";
+    effect: "effect";
+    call: "call";
+    halt: "halt";
+    fail: "fail";
+    seq: "seq";
+}>;
+export type FlowKind = z.infer<typeof FlowKind>;

package/dist/schema/host-context.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+/**
+ * HostContext - Explicit host-provided inputs for determinism
+ */
+export declare const HostContext: z.ZodObject<{
+    now: z.ZodNumber;
+    randomSeed: z.ZodString;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type HostContext = z.infer<typeof HostContext>;

package/dist/schema/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./common.js";
+export * from "./field.js";
+export * from "./expr.js";
+export * from "./flow.js";
+export * from "./computed.js";
+export * from "./action.js";
+export * from "./domain.js";
+export * from "./type-spec.js";
+export * from "./snapshot.js";
+export * from "./defaults.js";
+export * from "./patch.js";
+export * from "./host-context.js";
+export * from "./trace.js";
+export * from "./result.js";

package/dist/schema/patch.d.ts

@@ -0,0 +1,105 @@
+import { z } from "zod";
+/**
+ * PatchSegment - A single segment in a patch path.
+ */
+export declare const PatchSegment: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"prop">;
+    name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"index">;
+    index: z.ZodNumber;
+}, z.core.$strip>], "kind">;
+export type PatchSegment = z.infer<typeof PatchSegment>;
+/**
+ * PatchPath - Path segments rooted at snapshot.data.
+ */
+export declare const PatchPath: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"prop">;
+    name: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"index">;
+    index: z.ZodNumber;
+}, z.core.$strip>], "kind">>;
+export type PatchPath = z.infer<typeof PatchPath>;
+/**
+ * Patch - A single state modification operation.
+ * Only three operations: set, unset, merge.
+ */
+export declare const Patch: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"set">;
+    path: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"prop">;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"index">;
+        index: z.ZodNumber;
+    }, z.core.$strip>], "kind">>;
+    value: z.ZodUnknown;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"unset">;
+    path: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"prop">;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"index">;
+        index: z.ZodNumber;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"merge">;
+    path: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"prop">;
+        name: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"index">;
+        index: z.ZodNumber;
+    }, z.core.$strip>], "kind">>;
+    value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>], "op">;
+export type Patch = z.infer<typeof Patch>;
+/**
+ * SetPatch - Set value at path
+ */
+export type SetPatch = Extract<Patch, {
+    op: "set";
+}>;
+/**
+ * UnsetPatch - Remove value at path
+ */
+export type UnsetPatch = Extract<Patch, {
+    op: "unset";
+}>;
+/**
+ * MergePatch - Shallow merge object at path
+ */
+export type MergePatch = Extract<Patch, {
+    op: "merge";
+}>;
+/**
+ * Intent - A request to perform an action
+ */
+export declare const Intent: z.ZodObject<{
+    type: z.ZodString;
+    input: z.ZodOptional<z.ZodUnknown>;
+    intentId: z.ZodString;
+}, z.core.$strip>;
+export type Intent = z.infer<typeof Intent>;
+/**
+ * Helper to create a prop segment
+ */
+export declare function propSegment(name: string): PatchSegment;
+/**
+ * Helper to create an index segment
+ */
+export declare function indexSegment(index: number): PatchSegment;
+/**
+ * Helper to create a set patch
+ */
+export declare function setPatch(path: PatchPath, value: unknown): SetPatch;
+/**
+ * Helper to create an unset patch
+ */
+export declare function unsetPatch(path: PatchPath): UnsetPatch;
+/**
+ * Helper to create a merge patch
+ */
+export declare function mergePatch(path: PatchPath, value: Record<string, unknown>): MergePatch;

package/dist/schema/result.d.ts

@@ -0,0 +1,175 @@
+import { z } from "zod";
+import { TraceNode } from "./trace.js";
+/**
+ * ComputeStatus - Result of a compute() call
+ */
+export declare const ComputeStatus: z.ZodEnum<{
+    error: "error";
+    pending: "pending";
+    complete: "complete";
+    halted: "halted";
+}>;
+export type ComputeStatus = z.infer<typeof ComputeStatus>;
+/**
+ * SystemDelta - Declarative system transition emitted by compute().
+ */
+export declare const SystemDelta: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        idle: "idle";
+        computing: "computing";
+        pending: "pending";
+    }>>;
+    currentAction: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastError: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        source: z.ZodObject<{
+            actionId: z.ZodString;
+            nodePath: z.ZodString;
+        }, z.core.$strip>;
+        timestamp: z.ZodNumber;
+        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    addRequirements: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        actionId: z.ZodString;
+        flowPosition: z.ZodObject<{
+            nodePath: z.ZodString;
+            snapshotVersion: z.ZodNumber;
+        }, z.core.$strip>;
+        createdAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    removeRequirementIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type SystemDelta = z.infer<typeof SystemDelta>;
+/**
+ * ComputeResult - Result of compute() call
+ */
+export declare const ComputeResult: z.ZodObject<{
+    patches: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        op: z.ZodLiteral<"set">;
+        path: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"prop">;
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"index">;
+            index: z.ZodNumber;
+        }, z.core.$strip>], "kind">>;
+        value: z.ZodUnknown;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"unset">;
+        path: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"prop">;
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"index">;
+            index: z.ZodNumber;
+        }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>, z.ZodObject<{
+        op: z.ZodLiteral<"merge">;
+        path: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"prop">;
+            name: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"index">;
+            index: z.ZodNumber;
+        }, z.core.$strip>], "kind">>;
+        value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>], "op">>;
+    systemDelta: z.ZodObject<{
+        status: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            idle: "idle";
+            computing: "computing";
+            pending: "pending";
+        }>>;
+        currentAction: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        lastError: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            source: z.ZodObject<{
+                actionId: z.ZodString;
+                nodePath: z.ZodString;
+            }, z.core.$strip>;
+            timestamp: z.ZodNumber;
+            context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+        addRequirements: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            actionId: z.ZodString;
+            flowPosition: z.ZodObject<{
+                nodePath: z.ZodString;
+                snapshotVersion: z.ZodNumber;
+            }, z.core.$strip>;
+            createdAt: z.ZodNumber;
+        }, z.core.$strip>>;
+        removeRequirementIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    trace: z.ZodObject<{
+        root: z.ZodType<TraceNode, unknown, z.core.$ZodTypeInternals<TraceNode, unknown>>;
+        nodes: z.ZodRecord<z.ZodString, z.ZodType<TraceNode, unknown, z.core.$ZodTypeInternals<TraceNode, unknown>>>;
+        intent: z.ZodObject<{
+            type: z.ZodString;
+            input: z.ZodUnknown;
+        }, z.core.$strip>;
+        baseVersion: z.ZodNumber;
+        resultVersion: z.ZodNumber;
+        duration: z.ZodNumber;
+        terminatedBy: z.ZodEnum<{
+            error: "error";
+            effect: "effect";
+            halt: "halt";
+            complete: "complete";
+        }>;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        error: "error";
+        pending: "pending";
+        complete: "complete";
+        halted: "halted";
+    }>;
+}, z.core.$strip>;
+export type ComputeResult = z.infer<typeof ComputeResult>;
+/**
+ * ValidationError - Single validation error
+ */
+export declare const ValidationError: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ValidationError = z.infer<typeof ValidationError>;
+/**
+ * ValidationResult - Result of validate() call
+ */
+export declare const ValidationResult: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ValidationResult = z.infer<typeof ValidationResult>;
+/**
+ * ExplainResult - Result of explain() call
+ */
+export declare const ExplainResult: z.ZodObject<{
+    value: z.ZodUnknown;
+    trace: z.ZodType<TraceNode, unknown, z.core.$ZodTypeInternals<TraceNode, unknown>>;
+    deps: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ExplainResult = z.infer<typeof ExplainResult>;
+/**
+ * Create a successful validation result
+ */
+export declare function validResult(): ValidationResult;
+/**
+ * Create a failed validation result
+ */
+export declare function invalidResult(errors: ValidationError[]): ValidationResult;

package/dist/schema/snapshot.d.ts

@@ -0,0 +1,132 @@
+import { z } from "zod";
+/**
+ * ErrorValue - Errors are values in Snapshot, not exceptions.
+ */
+export declare const ErrorValue: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    source: z.ZodObject<{
+        actionId: z.ZodString;
+        nodePath: z.ZodString;
+    }, z.core.$strip>;
+    timestamp: z.ZodNumber;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type ErrorValue = z.infer<typeof ErrorValue>;
+/**
+ * FlowPosition - Position in the flow where effect was encountered
+ */
+export declare const FlowPosition: z.ZodObject<{
+    nodePath: z.ZodString;
+    snapshotVersion: z.ZodNumber;
+}, z.core.$strip>;
+export type FlowPosition = z.infer<typeof FlowPosition>;
+/**
+ * Requirement - A recorded effect declaration waiting for Host fulfillment
+ */
+export declare const Requirement: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    actionId: z.ZodString;
+    flowPosition: z.ZodObject<{
+        nodePath: z.ZodString;
+        snapshotVersion: z.ZodNumber;
+    }, z.core.$strip>;
+    createdAt: z.ZodNumber;
+}, z.core.$strip>;
+export type Requirement = z.infer<typeof Requirement>;
+/**
+ * SystemState - Internal system state
+ */
+export declare const SystemState: z.ZodObject<{
+    status: z.ZodEnum<{
+        error: "error";
+        idle: "idle";
+        computing: "computing";
+        pending: "pending";
+    }>;
+    lastError: z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        source: z.ZodObject<{
+            actionId: z.ZodString;
+            nodePath: z.ZodString;
+        }, z.core.$strip>;
+        timestamp: z.ZodNumber;
+        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    pendingRequirements: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        actionId: z.ZodString;
+        flowPosition: z.ZodObject<{
+            nodePath: z.ZodString;
+            snapshotVersion: z.ZodNumber;
+        }, z.core.$strip>;
+        createdAt: z.ZodNumber;
+    }, z.core.$strip>>;
+    currentAction: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type SystemState = z.infer<typeof SystemState>;
+/**
+ * SnapshotMeta - Snapshot metadata
+ */
+export declare const SnapshotMeta: z.ZodObject<{
+    version: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    randomSeed: z.ZodString;
+    schemaHash: z.ZodString;
+}, z.core.$strip>;
+export type SnapshotMeta = z.infer<typeof SnapshotMeta>;
+/**
+ * Snapshot - Immutable, point-in-time representation of world state.
+ * This is the ONLY medium of communication between Core and Host.
+ */
+export declare const Snapshot: z.ZodObject<{
+    data: z.ZodUnknown;
+    computed: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    system: z.ZodObject<{
+        status: z.ZodEnum<{
+            error: "error";
+            idle: "idle";
+            computing: "computing";
+            pending: "pending";
+        }>;
+        lastError: z.ZodNullable<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+            source: z.ZodObject<{
+                actionId: z.ZodString;
+                nodePath: z.ZodString;
+            }, z.core.$strip>;
+            timestamp: z.ZodNumber;
+            context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        pendingRequirements: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            actionId: z.ZodString;
+            flowPosition: z.ZodObject<{
+                nodePath: z.ZodString;
+                snapshotVersion: z.ZodNumber;
+            }, z.core.$strip>;
+            createdAt: z.ZodNumber;
+        }, z.core.$strip>>;
+        currentAction: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    input: z.ZodUnknown;
+    meta: z.ZodObject<{
+        version: z.ZodNumber;
+        timestamp: z.ZodNumber;
+        randomSeed: z.ZodString;
+        schemaHash: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type Snapshot = z.infer<typeof Snapshot>;
+/**
+ * Create initial system state
+ */
+export declare function createInitialSystemState(): SystemState;

package/dist/schema/trace.d.ts

@@ -0,0 +1,97 @@
+import { z } from "zod";
+/**
+ * TraceNodeKind - Types of trace nodes
+ */
+export declare const TraceNodeKind: z.ZodEnum<{
+    error: "error";
+    computed: "computed";
+    expr: "expr";
+    patch: "patch";
+    effect: "effect";
+    call: "call";
+    flow: "flow";
+    halt: "halt";
+    branch: "branch";
+}>;
+export type TraceNodeKind = z.infer<typeof TraceNodeKind>;
+/**
+ * TraceNode - A single node in the execution trace.
+ * Enables explainability - every computation produces a trace.
+ */
+export type TraceNode = {
+    /**
+     * Unique identifier for this trace node
+     */
+    id: string;
+    /**
+     * Type of trace node
+     */
+    kind: TraceNodeKind;
+    /**
+     * Path in the schema that produced this trace
+     */
+    sourcePath: string;
+    /**
+     * Input values at this point
+     */
+    inputs: Record<string, unknown>;
+    /**
+     * Output value produced
+     */
+    output: unknown;
+    /**
+     * Child trace nodes
+     */
+    children: TraceNode[];
+    /**
+     * Timestamp
+     */
+    timestamp: number;
+};
+export declare const TraceNode: z.ZodType<TraceNode>;
+/**
+ * TraceTermination - How the computation ended
+ */
+export declare const TraceTermination: z.ZodEnum<{
+    error: "error";
+    effect: "effect";
+    halt: "halt";
+    complete: "complete";
+}>;
+export type TraceTermination = z.infer<typeof TraceTermination>;
+/**
+ * TraceGraph - Complete trace of a computation
+ */
+export declare const TraceGraph: z.ZodObject<{
+    root: z.ZodType<TraceNode, unknown, z.core.$ZodTypeInternals<TraceNode, unknown>>;
+    nodes: z.ZodRecord<z.ZodString, z.ZodType<TraceNode, unknown, z.core.$ZodTypeInternals<TraceNode, unknown>>>;
+    intent: z.ZodObject<{
+        type: z.ZodString;
+        input: z.ZodUnknown;
+    }, z.core.$strip>;
+    baseVersion: z.ZodNumber;
+    resultVersion: z.ZodNumber;
+    duration: z.ZodNumber;
+    terminatedBy: z.ZodEnum<{
+        error: "error";
+        effect: "effect";
+        halt: "halt";
+        complete: "complete";
+    }>;
+}, z.core.$strip>;
+export type TraceGraph = z.infer<typeof TraceGraph>;
+/**
+ * TraceContext - Deterministic trace ID generation
+ */
+export type TraceContext = {
+    readonly nextId: () => string;
+    readonly timestamp: number;
+};
+/**
+ * Create a trace context for a single compute pass
+ */
+export declare function createTraceContext(timestamp: number): TraceContext;
+/**
+ * Create a trace node
+ */
+export declare function createTraceNode(trace: TraceContext, kind: TraceNodeKind, sourcePath: string, inputs: Record<string, unknown>, output: unknown, children?: TraceNode[]): TraceNode;

package/dist/schema/type-spec.d.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+export type TypeDefinition = {
+    kind: "primitive";
+    type: string;
+} | {
+    kind: "array";
+    element: TypeDefinition;
+} | {
+    kind: "record";
+    key: TypeDefinition;
+    value: TypeDefinition;
+} | {
+    kind: "object";
+    fields: Record<string, {
+        type: TypeDefinition;
+        optional: boolean;
+    }>;
+} | {
+    kind: "union";
+    types: TypeDefinition[];
+} | {
+    kind: "literal";
+    value: string | number | boolean | null;
+} | {
+    kind: "ref";
+    name: string;
+};
+export declare const TypeDefinition: z.ZodType<TypeDefinition>;
+export declare const TypeSpec: z.ZodObject<{
+    name: z.ZodString;
+    definition: z.ZodType<TypeDefinition, unknown, z.core.$ZodTypeInternals<TypeDefinition, unknown>>;
+}, z.core.$strip>;
+export type TypeSpec = z.infer<typeof TypeSpec>;