@manifesto-ai/core 0.3.0 → 1.0.0

package/dist/schema/snapshot.d.ts

@@ -0,0 +1,151 @@
+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>>;
+    errors: z.ZodArray<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;
+    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>>;
+        errors: z.ZodArray<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;
+        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;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/schema/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../src/schema/snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;iBA4BrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD;;GAEG;AACH,eAAO,MAAM,YAAY;;;iBAUvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;iBA+BtB,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBtB,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD;;GAEG;AACH,eAAO,MAAM,YAAY;;;;iBAiBvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBnB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,WAAW,CAQtD"}

package/dist/schema/snapshot.js

@@ -0,0 +1,156 @@
+import { z } from "zod";
+import { SemanticPath } from "./common.js";
+/**
+ * ErrorValue - Errors are values in Snapshot, not exceptions.
+ */
+export const ErrorValue = z.object({
+    /**
+     * Error code
+     */
+    code: z.string(),
+    /**
+     * Human-readable message
+     */
+    message: z.string(),
+    /**
+     * Where the error occurred
+     */
+    source: z.object({
+        actionId: z.string(),
+        nodePath: z.string(),
+    }),
+    /**
+     * When the error occurred
+     */
+    timestamp: z.number(),
+    /**
+     * Additional context
+     */
+    context: z.record(z.string(), z.unknown()).optional(),
+});
+/**
+ * FlowPosition - Position in the flow where effect was encountered
+ */
+export const FlowPosition = z.object({
+    /**
+     * Path to the effect node in the flow
+     */
+    nodePath: z.string(),
+    /**
+     * Snapshot version at time of effect
+     */
+    snapshotVersion: z.number(),
+});
+/**
+ * Requirement - A recorded effect declaration waiting for Host fulfillment
+ */
+export const Requirement = z.object({
+    /**
+     * Unique identifier for this requirement.
+     * Should be deterministic: hash(schemaHash, intentId, actionId, flowNodePath)
+     */
+    id: z.string(),
+    /**
+     * Effect type that generated this requirement
+     */
+    type: z.string(),
+    /**
+     * Resolved parameters
+     */
+    params: z.record(z.string(), z.unknown()),
+    /**
+     * The action that was being computed
+     */
+    actionId: z.string(),
+    /**
+     * Position in the flow where effect was encountered
+     */
+    flowPosition: FlowPosition,
+    /**
+     * Timestamp when requirement was created
+     */
+    createdAt: z.number(),
+});
+/**
+ * SystemState - Internal system state
+ */
+export const SystemState = z.object({
+    /**
+     * Current status
+     */
+    status: z.enum(["idle", "computing", "pending", "error"]),
+    /**
+     * Last error (null if none)
+     */
+    lastError: ErrorValue.nullable(),
+    /**
+     * Error history
+     */
+    errors: z.array(ErrorValue),
+    /**
+     * Pending requirements waiting for Host
+     */
+    pendingRequirements: z.array(Requirement),
+    /**
+     * Current action being processed (if any)
+     */
+    currentAction: z.string().nullable(),
+});
+/**
+ * SnapshotMeta - Snapshot metadata
+ */
+export const SnapshotMeta = z.object({
+    /**
+     * Monotonically increasing version.
+     * Incremented by Core on each apply().
+     */
+    version: z.number(),
+    /**
+     * Timestamp of last modification.
+     * Set by Core on each apply().
+     */
+    timestamp: z.number(),
+    /**
+     * Hash of the schema this snapshot conforms to.
+     */
+    schemaHash: z.string(),
+});
+/**
+ * Snapshot - Immutable, point-in-time representation of world state.
+ * This is the ONLY medium of communication between Core and Host.
+ */
+export const Snapshot = z.object({
+    /**
+     * Domain data (matches StateSpec)
+     */
+    data: z.unknown(),
+    /**
+     * Computed values (matches ComputedSpec)
+     */
+    computed: z.record(SemanticPath, z.unknown()),
+    /**
+     * System state
+     */
+    system: SystemState,
+    /**
+     * Input for current action (if any)
+     */
+    input: z.unknown(),
+    /**
+     * Snapshot metadata
+     */
+    meta: SnapshotMeta,
+});
+/**
+ * Create initial system state
+ */
+export function createInitialSystemState() {
+    return {
+        status: "idle",
+        lastError: null,
+        errors: [],
+        pendingRequirements: [],
+        currentAction: null,
+    };
+}
+//# sourceMappingURL=snapshot.js.map

package/dist/schema/snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.js","sourceRoot":"","sources":["../../src/schema/snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC;IACjC;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAEhB;;OAEG;IACH,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IAEnB;;OAEG;IACH,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC;QACf,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;QACpB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;KACrB,CAAC;IAEF;;OAEG;IACH,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IAErB;;OAEG;IACH,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;CACtD,CAAC,CAAC;AAGH;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC;;OAEG;IACH,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IAEpB;;OAEG;IACH,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE;CAC5B,CAAC,CAAC;AAGH;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC;;;OAGG;IACH,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IAEd;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAEhB;;OAEG;IACH,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;IAEzC;;OAEG;IACH,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IAEpB;;OAEG;IACH,YAAY,EAAE,YAAY;IAE1B;;OAEG;IACH,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;CACtB,CAAC,CAAC;AAGH;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAClC;;OAEG;IACH,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IAEzD;;OAEG;IACH,SAAS,EAAE,UAAU,CAAC,QAAQ,EAAE;IAEhC;;OAEG;IACH,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC;IAE3B;;OAEG;IACH,mBAAmB,EAAE,CAAC,CAAC,KAAK,CAAC,WAAW,CAAC;IAEzC;;OAEG;IACH,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACrC,CAAC,CAAC;AAGH;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC;;;OAGG;IACH,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IAEnB;;;OAGG;IACH,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IAErB;;OAEG;IACH,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;CACvB,CAAC,CAAC;AAGH;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/B;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE;IAEjB;;OAEG;IACH,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;IAE7C;;OAEG;IACH,MAAM,EAAE,WAAW;IAEnB;;OAEG;IACH,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE;IAElB;;OAEG;IACH,IAAI,EAAE,YAAY;CACnB,CAAC,CAAC;AAGH;;GAEG;AACH,MAAM,UAAU,wBAAwB;IACtC,OAAO;QACL,MAAM,EAAE,MAAM;QACd,SAAS,EAAE,IAAI;QACf,MAAM,EAAE,EAAE;QACV,mBAAmB,EAAE,EAAE;QACvB,aAAa,EAAE,IAAI;KACpB,CAAC;AACJ,CAAC"}

package/dist/schema/trace.d.ts

@@ -0,0 +1,87 @@
+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>;
+/**
+ * Create a trace node
+ */
+export declare function createTraceNode(kind: TraceNodeKind, sourcePath: string, inputs: Record<string, unknown>, output: unknown, children?: TraceNode[]): TraceNode;
+//# sourceMappingURL=trace.d.ts.map

package/dist/schema/trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../src/schema/trace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;EAUxB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;OAEG;IACH,IAAI,EAAE,aAAa,CAAC;IAEpB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEhC;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;IAEhB;;OAEG;IACH,QAAQ,EAAE,SAAS,EAAE,CAAC;IAEtB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAU1C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;EAAkD,CAAC;AAChF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;iBAsCrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAEpD;;GAEG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,EACnB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,MAAM,EAAE,OAAO,EACf,QAAQ,GAAE,SAAS,EAAO,GACzB,SAAS,CAUX"}

package/dist/schema/trace.js

@@ -0,0 +1,79 @@
+import { z } from "zod";
+/**
+ * TraceNodeKind - Types of trace nodes
+ */
+export const TraceNodeKind = z.enum([
+    "expr", // Expression evaluation
+    "computed", // Computed field evaluation
+    "flow", // Flow execution
+    "patch", // State mutation
+    "effect", // Effect declaration
+    "branch", // Conditional branch taken
+    "call", // Flow call
+    "halt", // Normal termination
+    "error", // Error occurred
+]);
+export const TraceNode = z.lazy(() => z.object({
+    id: z.string(),
+    kind: TraceNodeKind,
+    sourcePath: z.string(),
+    inputs: z.record(z.string(), z.unknown()),
+    output: z.unknown(),
+    children: z.array(TraceNode),
+    timestamp: z.number(),
+}));
+/**
+ * TraceTermination - How the computation ended
+ */
+export const TraceTermination = z.enum(["complete", "effect", "halt", "error"]);
+/**
+ * TraceGraph - Complete trace of a computation
+ */
+export const TraceGraph = z.object({
+    /**
+     * Root trace node
+     */
+    root: TraceNode,
+    /**
+     * All nodes indexed by ID for quick lookup
+     */
+    nodes: z.record(z.string(), TraceNode),
+    /**
+     * The intent that triggered this computation
+     */
+    intent: z.object({
+        type: z.string(),
+        input: z.unknown(),
+    }),
+    /**
+     * Snapshot version at start
+     */
+    baseVersion: z.number(),
+    /**
+     * Snapshot version at end
+     */
+    resultVersion: z.number(),
+    /**
+     * Total computation time (ms)
+     */
+    duration: z.number(),
+    /**
+     * Termination reason
+     */
+    terminatedBy: TraceTermination,
+});
+/**
+ * Create a trace node
+ */
+export function createTraceNode(kind, sourcePath, inputs, output, children = []) {
+    return {
+        id: `trace-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+        kind,
+        sourcePath,
+        inputs,
+        output,
+        children,
+        timestamp: Date.now(),
+    };
+}
+//# sourceMappingURL=trace.js.map

package/dist/schema/trace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.js","sourceRoot":"","sources":["../../src/schema/trace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC,IAAI,CAAC;IAClC,MAAM,EAAM,wBAAwB;IACpC,UAAU,EAAE,4BAA4B;IACxC,MAAM,EAAM,iBAAiB;IAC7B,OAAO,EAAK,iBAAiB;IAC7B,QAAQ,EAAI,qBAAqB;IACjC,QAAQ,EAAI,2BAA2B;IACvC,MAAM,EAAM,YAAY;IACxB,MAAM,EAAM,qBAAqB;IACjC,OAAO,EAAK,iBAAiB;CAC9B,CAAC,CAAC;AA4CH,MAAM,CAAC,MAAM,SAAS,GAAyB,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CACzD,CAAC,CAAC,MAAM,CAAC;IACP,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,IAAI,EAAE,aAAa;IACnB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;IACzC,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE;IACnB,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC;IAC5B,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;CACtB,CAAC,CACH,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAGhF;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC;IACjC;;OAEG;IACH,IAAI,EAAE,SAAS;IAEf;;OAEG;IACH,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,SAAS,CAAC;IAEtC;;OAEG;IACH,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC;QACf,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;QAChB,KAAK,EAAE,CAAC,CAAC,OAAO,EAAE;KACnB,CAAC;IAEF;;OAEG;IACH,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IAEvB;;OAEG;IACH,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IAEzB;;OAEG;IACH,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;IAEpB;;OAEG;IACH,YAAY,EAAE,gBAAgB;CAC/B,CAAC,CAAC;AAGH;;GAEG;AACH,MAAM,UAAU,eAAe,CAC7B,IAAmB,EACnB,UAAkB,EAClB,MAA+B,EAC/B,MAAe,EACf,WAAwB,EAAE;IAE1B,OAAO;QACL,EAAE,EAAE,SAAS,IAAI,CAAC,GAAG,EAAE,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;QACnE,IAAI;QACJ,UAAU;QACV,MAAM;QACN,MAAM;QACN,QAAQ;QACR,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;KACtB,CAAC;AACJ,CAAC"}

package/dist/utils/canonical.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Canonical form utilities for deterministic hashing
+ *
+ * Algorithm:
+ * 1. Sort all object keys alphabetically (recursive)
+ * 2. Remove all keys with undefined value
+ * 3. Preserve keys with null value
+ * 4. Serialize using JSON with no whitespace
+ */
+/**
+ * Recursively sort object keys alphabetically
+ */
+export declare function sortKeys(obj: unknown): unknown;
+/**
+ * Convert object to canonical JSON string
+ * - Keys are sorted alphabetically
+ * - Undefined values are removed
+ * - No whitespace
+ */
+export declare function toCanonical(obj: unknown): string;
+/**
+ * Parse canonical JSON string
+ */
+export declare function fromCanonical<T>(canonical: string): T;
+/**
+ * Check if two objects are equal in canonical form
+ */
+export declare function canonicalEqual(a: unknown, b: unknown): boolean;
+//# sourceMappingURL=canonical.d.ts.map

package/dist/utils/canonical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.d.ts","sourceRoot":"","sources":["../../src/utils/canonical.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAyB9C;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAGhD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,CAAC,CAErD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CAE9D"}

package/dist/utils/canonical.js

@@ -0,0 +1,56 @@
+/**
+ * Canonical form utilities for deterministic hashing
+ *
+ * Algorithm:
+ * 1. Sort all object keys alphabetically (recursive)
+ * 2. Remove all keys with undefined value
+ * 3. Preserve keys with null value
+ * 4. Serialize using JSON with no whitespace
+ */
+/**
+ * Recursively sort object keys alphabetically
+ */
+export function sortKeys(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(sortKeys);
+    }
+    if (typeof obj === "object") {
+        const sorted = {};
+        const keys = Object.keys(obj).sort();
+        for (const key of keys) {
+            const value = obj[key];
+            // Remove undefined values
+            if (value !== undefined) {
+                sorted[key] = sortKeys(value);
+            }
+        }
+        return sorted;
+    }
+    return obj;
+}
+/**
+ * Convert object to canonical JSON string
+ * - Keys are sorted alphabetically
+ * - Undefined values are removed
+ * - No whitespace
+ */
+export function toCanonical(obj) {
+    const sorted = sortKeys(obj);
+    return JSON.stringify(sorted);
+}
+/**
+ * Parse canonical JSON string
+ */
+export function fromCanonical(canonical) {
+    return JSON.parse(canonical);
+}
+/**
+ * Check if two objects are equal in canonical form
+ */
+export function canonicalEqual(a, b) {
+    return toCanonical(a) === toCanonical(b);
+}
+//# sourceMappingURL=canonical.js.map

package/dist/utils/canonical.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.js","sourceRoot":"","sources":["../../src/utils/canonical.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,MAAM,UAAU,QAAQ,CAAC,GAAY;IACnC,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACtC,OAAO,GAAG,CAAC;IACb,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QACvB,OAAO,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC3B,CAAC;IAED,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QAC5B,MAAM,MAAM,GAA4B,EAAE,CAAC;QAC3C,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,GAA8B,CAAC,CAAC,IAAI,EAAE,CAAC;QAEhE,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,MAAM,KAAK,GAAI,GAA+B,CAAC,GAAG,CAAC,CAAC;YACpD,0BAA0B;YAC1B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxB,MAAM,CAAC,GAAG,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;YAChC,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,GAAY;IACtC,MAAM,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;IAC7B,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;AAChC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAI,SAAiB;IAChD,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,CAAM,CAAC;AACpC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,cAAc,CAAC,CAAU,EAAE,CAAU;IACnD,OAAO,WAAW,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC;AAC3C,CAAC"}

package/dist/utils/canonical.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=canonical.test.d.ts.map

package/dist/utils/canonical.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.test.d.ts","sourceRoot":"","sources":["../../src/utils/canonical.test.ts"],"names":[],"mappings":""}