@manifesto-ai/core 2.6.0 → 2.6.1

package/dist/index.d.ts

@@ -1,3 +1,1743 @@
+import { z } from 'zod';
+
+/**
+ * ExprNode - Pure expression language for ComputedSpec and FlowSpec
+ * All expressions are deterministic and side-effect free
+ */
+type ExprNode = LitExpr | GetExpr | EqExpr | NeqExpr | GtExpr | GteExpr | LtExpr | LteExpr | AndExpr | OrExpr | NotExpr | IfExpr | AddExpr | SubExpr | MulExpr | DivExpr | ModExpr | MinExpr | MaxExpr | AbsExpr | NegExpr | FloorExpr | CeilExpr | RoundExpr | SqrtExpr | PowExpr | SumArrayExpr | MinArrayExpr | MaxArrayExpr | ConcatExpr | SubstringExpr | TrimExpr | ToLowerCaseExpr | ToUpperCaseExpr | StrLenExpr | StartsWithExpr | EndsWithExpr | StrIncludesExpr | IndexOfExpr | ReplaceExpr | SplitExpr | LenExpr | AtExpr | FirstExpr | LastExpr | SliceExpr | IncludesExpr | FilterExpr | MapExpr | FindExpr | EveryExpr | SomeExpr | AppendExpr | ReverseExpr | UniqueExpr | FlatExpr | ObjectExpr | FieldExpr | KeysExpr | ValuesExpr | EntriesExpr | MergeExpr | HasKeyExpr | PickExpr | OmitExpr | FromEntriesExpr | TypeofExpr | IsNullExpr | CoalesceExpr | ToStringExpr | ToNumberExpr | ToBooleanExpr;
+declare const LitExpr: z.ZodObject<{
+    kind: z.ZodLiteral<"lit">;
+    value: z.ZodUnknown;
+}, z.core.$strip>;
+type LitExpr = z.infer<typeof LitExpr>;
+declare const GetExpr: z.ZodObject<{
+    kind: z.ZodLiteral<"get">;
+    path: z.ZodString;
+}, z.core.$strip>;
+type GetExpr = z.infer<typeof GetExpr>;
+declare const EqExpr: z.ZodType<{
+    kind: "eq";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+type EqExpr = z.infer<typeof EqExpr>;
+declare const NeqExpr: z.ZodType<{
+    kind: "neq";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+type NeqExpr = z.infer<typeof NeqExpr>;
+declare const GtExpr: z.ZodType<{
+    kind: "gt";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+type GtExpr = z.infer<typeof GtExpr>;
+declare const GteExpr: z.ZodType<{
+    kind: "gte";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+type GteExpr = z.infer<typeof GteExpr>;
+declare const LtExpr: z.ZodType<{
+    kind: "lt";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+type LtExpr = z.infer<typeof LtExpr>;
+declare const LteExpr: z.ZodType<{
+    kind: "lte";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+type LteExpr = z.infer<typeof LteExpr>;
+declare const AndExpr: z.ZodType<{
+    kind: "and";
+    args: ExprNode[];
+}>;
+type AndExpr = z.infer<typeof AndExpr>;
+declare const OrExpr: z.ZodType<{
+    kind: "or";
+    args: ExprNode[];
+}>;
+type OrExpr = z.infer<typeof OrExpr>;
+declare const NotExpr: z.ZodType<{
+    kind: "not";
+    arg: ExprNode;
+}>;
+type NotExpr = z.infer<typeof NotExpr>;
+declare const IfExpr: z.ZodType<{
+    kind: "if";
+    cond: ExprNode;
+    then: ExprNode;
+    else: ExprNode;
+}>;
+type IfExpr = z.infer<typeof IfExpr>;
+declare const AddExpr: z.ZodType<{
+    kind: "add";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+type AddExpr = z.infer<typeof AddExpr>;
+declare const SubExpr: z.ZodType<{
+    kind: "sub";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+type SubExpr = z.infer<typeof SubExpr>;
+declare const MulExpr: z.ZodType<{
+    kind: "mul";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+type MulExpr = z.infer<typeof MulExpr>;
+declare const DivExpr: z.ZodType<{
+    kind: "div";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+type DivExpr = z.infer<typeof DivExpr>;
+declare const ModExpr: z.ZodType<{
+    kind: "mod";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+type ModExpr = z.infer<typeof ModExpr>;
+declare const MinExpr: z.ZodType<{
+    kind: "min";
+    args: ExprNode[];
+}>;
+type MinExpr = z.infer<typeof MinExpr>;
+declare const MaxExpr: z.ZodType<{
+    kind: "max";
+    args: ExprNode[];
+}>;
+type MaxExpr = z.infer<typeof MaxExpr>;
+declare const AbsExpr: z.ZodType<{
+    kind: "abs";
+    arg: ExprNode;
+}>;
+type AbsExpr = z.infer<typeof AbsExpr>;
+declare const NegExpr: z.ZodType<{
+    kind: "neg";
+    arg: ExprNode;
+}>;
+type NegExpr = z.infer<typeof NegExpr>;
+declare const FloorExpr: z.ZodType<{
+    kind: "floor";
+    arg: ExprNode;
+}>;
+type FloorExpr = z.infer<typeof FloorExpr>;
+declare const CeilExpr: z.ZodType<{
+    kind: "ceil";
+    arg: ExprNode;
+}>;
+type CeilExpr = z.infer<typeof CeilExpr>;
+declare const RoundExpr: z.ZodType<{
+    kind: "round";
+    arg: ExprNode;
+}>;
+type RoundExpr = z.infer<typeof RoundExpr>;
+declare const SqrtExpr: z.ZodType<{
+    kind: "sqrt";
+    arg: ExprNode;
+}>;
+type SqrtExpr = z.infer<typeof SqrtExpr>;
+declare const PowExpr: z.ZodType<{
+    kind: "pow";
+    base: ExprNode;
+    exponent: ExprNode;
+}>;
+type PowExpr = z.infer<typeof PowExpr>;
+declare const SumArrayExpr: z.ZodType<{
+    kind: "sumArray";
+    array: ExprNode;
+}>;
+type SumArrayExpr = z.infer<typeof SumArrayExpr>;
+declare const MinArrayExpr: z.ZodType<{
+    kind: "minArray";
+    array: ExprNode;
+}>;
+type MinArrayExpr = z.infer<typeof MinArrayExpr>;
+declare const MaxArrayExpr: z.ZodType<{
+    kind: "maxArray";
+    array: ExprNode;
+}>;
+type MaxArrayExpr = z.infer<typeof MaxArrayExpr>;
+declare const ConcatExpr: z.ZodType<{
+    kind: "concat";
+    args: ExprNode[];
+}>;
+type ConcatExpr = z.infer<typeof ConcatExpr>;
+declare const SubstringExpr: z.ZodType<{
+    kind: "substring";
+    str: ExprNode;
+    start: ExprNode;
+    end?: ExprNode;
+}>;
+type SubstringExpr = z.infer<typeof SubstringExpr>;
+declare const TrimExpr: z.ZodType<{
+    kind: "trim";
+    str: ExprNode;
+}>;
+type TrimExpr = z.infer<typeof TrimExpr>;
+declare const ToLowerCaseExpr: z.ZodType<{
+    kind: "toLowerCase";
+    str: ExprNode;
+}>;
+type ToLowerCaseExpr = z.infer<typeof ToLowerCaseExpr>;
+declare const ToUpperCaseExpr: z.ZodType<{
+    kind: "toUpperCase";
+    str: ExprNode;
+}>;
+type ToUpperCaseExpr = z.infer<typeof ToUpperCaseExpr>;
+declare const StrLenExpr: z.ZodType<{
+    kind: "strLen";
+    str: ExprNode;
+}>;
+type StrLenExpr = z.infer<typeof StrLenExpr>;
+declare const StartsWithExpr: z.ZodType<{
+    kind: "startsWith";
+    str: ExprNode;
+    prefix: ExprNode;
+}>;
+type StartsWithExpr = z.infer<typeof StartsWithExpr>;
+declare const EndsWithExpr: z.ZodType<{
+    kind: "endsWith";
+    str: ExprNode;
+    suffix: ExprNode;
+}>;
+type EndsWithExpr = z.infer<typeof EndsWithExpr>;
+declare const StrIncludesExpr: z.ZodType<{
+    kind: "strIncludes";
+    str: ExprNode;
+    search: ExprNode;
+}>;
+type StrIncludesExpr = z.infer<typeof StrIncludesExpr>;
+declare const IndexOfExpr: z.ZodType<{
+    kind: "indexOf";
+    str: ExprNode;
+    search: ExprNode;
+}>;
+type IndexOfExpr = z.infer<typeof IndexOfExpr>;
+declare const ReplaceExpr: z.ZodType<{
+    kind: "replace";
+    str: ExprNode;
+    search: ExprNode;
+    replacement: ExprNode;
+}>;
+type ReplaceExpr = z.infer<typeof ReplaceExpr>;
+declare const SplitExpr: z.ZodType<{
+    kind: "split";
+    str: ExprNode;
+    delimiter: ExprNode;
+}>;
+type SplitExpr = z.infer<typeof SplitExpr>;
+declare const LenExpr: z.ZodType<{
+    kind: "len";
+    arg: ExprNode;
+}>;
+type LenExpr = z.infer<typeof LenExpr>;
+declare const AtExpr: z.ZodType<{
+    kind: "at";
+    array: ExprNode;
+    index: ExprNode;
+}>;
+type AtExpr = z.infer<typeof AtExpr>;
+declare const FirstExpr: z.ZodType<{
+    kind: "first";
+    array: ExprNode;
+}>;
+type FirstExpr = z.infer<typeof FirstExpr>;
+declare const LastExpr: z.ZodType<{
+    kind: "last";
+    array: ExprNode;
+}>;
+type LastExpr = z.infer<typeof LastExpr>;
+declare const SliceExpr: z.ZodType<{
+    kind: "slice";
+    array: ExprNode;
+    start: ExprNode;
+    end?: ExprNode;
+}>;
+type SliceExpr = z.infer<typeof SliceExpr>;
+declare const IncludesExpr: z.ZodType<{
+    kind: "includes";
+    array: ExprNode;
+    item: ExprNode;
+}>;
+type IncludesExpr = z.infer<typeof IncludesExpr>;
+declare const FilterExpr: z.ZodType<{
+    kind: "filter";
+    array: ExprNode;
+    predicate: ExprNode;
+}>;
+type FilterExpr = z.infer<typeof FilterExpr>;
+declare const MapExpr: z.ZodType<{
+    kind: "map";
+    array: ExprNode;
+    mapper: ExprNode;
+}>;
+type MapExpr = z.infer<typeof MapExpr>;
+declare const FindExpr: z.ZodType<{
+    kind: "find";
+    array: ExprNode;
+    predicate: ExprNode;
+}>;
+type FindExpr = z.infer<typeof FindExpr>;
+declare const EveryExpr: z.ZodType<{
+    kind: "every";
+    array: ExprNode;
+    predicate: ExprNode;
+}>;
+type EveryExpr = z.infer<typeof EveryExpr>;
+declare const SomeExpr: z.ZodType<{
+    kind: "some";
+    array: ExprNode;
+    predicate: ExprNode;
+}>;
+type SomeExpr = z.infer<typeof SomeExpr>;
+declare const AppendExpr: z.ZodType<{
+    kind: "append";
+    array: ExprNode;
+    items: ExprNode[];
+}>;
+type AppendExpr = z.infer<typeof AppendExpr>;
+declare const ReverseExpr: z.ZodType<{
+    kind: "reverse";
+    array: ExprNode;
+}>;
+type ReverseExpr = z.infer<typeof ReverseExpr>;
+declare const UniqueExpr: z.ZodType<{
+    kind: "unique";
+    array: ExprNode;
+}>;
+type UniqueExpr = z.infer<typeof UniqueExpr>;
+declare const FlatExpr: z.ZodType<{
+    kind: "flat";
+    array: ExprNode;
+}>;
+type FlatExpr = z.infer<typeof FlatExpr>;
+declare const ObjectExpr: z.ZodType<{
+    kind: "object";
+    fields: Record<string, ExprNode>;
+}>;
+type ObjectExpr = z.infer<typeof ObjectExpr>;
+declare const FieldExpr: z.ZodType<{
+    kind: "field";
+    object: ExprNode;
+    property: string;
+}>;
+type FieldExpr = z.infer<typeof FieldExpr>;
+declare const KeysExpr: z.ZodType<{
+    kind: "keys";
+    obj: ExprNode;
+}>;
+type KeysExpr = z.infer<typeof KeysExpr>;
+declare const ValuesExpr: z.ZodType<{
+    kind: "values";
+    obj: ExprNode;
+}>;
+type ValuesExpr = z.infer<typeof ValuesExpr>;
+declare const EntriesExpr: z.ZodType<{
+    kind: "entries";
+    obj: ExprNode;
+}>;
+type EntriesExpr = z.infer<typeof EntriesExpr>;
+declare const MergeExpr: z.ZodType<{
+    kind: "merge";
+    objects: ExprNode[];
+}>;
+type MergeExpr = z.infer<typeof MergeExpr>;
+declare const HasKeyExpr: z.ZodType<{
+    kind: "hasKey";
+    obj: ExprNode;
+    key: ExprNode;
+}>;
+type HasKeyExpr = z.infer<typeof HasKeyExpr>;
+declare const PickExpr: z.ZodType<{
+    kind: "pick";
+    obj: ExprNode;
+    keys: ExprNode;
+}>;
+type PickExpr = z.infer<typeof PickExpr>;
+declare const OmitExpr: z.ZodType<{
+    kind: "omit";
+    obj: ExprNode;
+    keys: ExprNode;
+}>;
+type OmitExpr = z.infer<typeof OmitExpr>;
+declare const FromEntriesExpr: z.ZodType<{
+    kind: "fromEntries";
+    entries: ExprNode;
+}>;
+type FromEntriesExpr = z.infer<typeof FromEntriesExpr>;
+declare const TypeofExpr: z.ZodType<{
+    kind: "typeof";
+    arg: ExprNode;
+}>;
+type TypeofExpr = z.infer<typeof TypeofExpr>;
+declare const IsNullExpr: z.ZodType<{
+    kind: "isNull";
+    arg: ExprNode;
+}>;
+type IsNullExpr = z.infer<typeof IsNullExpr>;
+declare const CoalesceExpr: z.ZodType<{
+    kind: "coalesce";
+    args: ExprNode[];
+}>;
+type CoalesceExpr = z.infer<typeof CoalesceExpr>;
+declare const ToStringExpr: z.ZodType<{
+    kind: "toString";
+    arg: ExprNode;
+}>;
+type ToStringExpr = z.infer<typeof ToStringExpr>;
+declare const ToNumberExpr: z.ZodType<{
+    kind: "toNumber";
+    arg: ExprNode;
+}>;
+type ToNumberExpr = z.infer<typeof ToNumberExpr>;
+declare const ToBooleanExpr: z.ZodType<{
+    kind: "toBoolean";
+    arg: ExprNode;
+}>;
+type ToBooleanExpr = z.infer<typeof ToBooleanExpr>;
+declare const ExprNodeSchema: z.ZodType<ExprNode>;
+/**
+ * Expression kinds enum for pattern matching
+ */
+declare const ExprKind: z.ZodEnum<{
+    object: "object";
+    map: "map";
+    lit: "lit";
+    get: "get";
+    merge: "merge";
+    values: "values";
+    keys: "keys";
+    toString: "toString";
+    concat: "concat";
+    reverse: "reverse";
+    slice: "slice";
+    indexOf: "indexOf";
+    every: "every";
+    some: "some";
+    filter: "filter";
+    find: "find";
+    entries: "entries";
+    includes: "includes";
+    flat: "flat";
+    at: "at";
+    replace: "replace";
+    split: "split";
+    substring: "substring";
+    toLowerCase: "toLowerCase";
+    toUpperCase: "toUpperCase";
+    trim: "trim";
+    endsWith: "endsWith";
+    startsWith: "startsWith";
+    sub: "sub";
+    eq: "eq";
+    neq: "neq";
+    gt: "gt";
+    gte: "gte";
+    lt: "lt";
+    lte: "lte";
+    and: "and";
+    or: "or";
+    not: "not";
+    if: "if";
+    add: "add";
+    mul: "mul";
+    div: "div";
+    mod: "mod";
+    min: "min";
+    max: "max";
+    abs: "abs";
+    neg: "neg";
+    floor: "floor";
+    ceil: "ceil";
+    round: "round";
+    sqrt: "sqrt";
+    pow: "pow";
+    sumArray: "sumArray";
+    minArray: "minArray";
+    maxArray: "maxArray";
+    strLen: "strLen";
+    strIncludes: "strIncludes";
+    len: "len";
+    first: "first";
+    last: "last";
+    append: "append";
+    unique: "unique";
+    field: "field";
+    hasKey: "hasKey";
+    pick: "pick";
+    omit: "omit";
+    fromEntries: "fromEntries";
+    typeof: "typeof";
+    isNull: "isNull";
+    coalesce: "coalesce";
+    toNumber: "toNumber";
+    toBoolean: "toBoolean";
+}>;
+type ExprKind = z.infer<typeof ExprKind>;
+
+/**
+ * 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.
+ */
+type FlowNode = SeqFlow | IfFlow | PatchFlow | EffectFlow | CallFlow | HaltFlow | FailFlow;
+/**
+ * Patch operations
+ */
+declare const PatchOp: z.ZodEnum<{
+    set: "set";
+    unset: "unset";
+    merge: "merge";
+}>;
+type PatchOp = z.infer<typeof PatchOp>;
+/**
+ * seq - Execute steps in order
+ */
+declare const SeqFlow: z.ZodType<{
+    kind: "seq";
+    steps: FlowNode[];
+}>;
+type SeqFlow = z.infer<typeof SeqFlow>;
+/**
+ * if - Conditional execution
+ */
+declare const IfFlow: z.ZodType<{
+    kind: "if";
+    cond: ExprNode;
+    then: FlowNode;
+    else?: FlowNode;
+}>;
+type IfFlow = z.infer<typeof IfFlow>;
+/**
+ * patch - State mutation declaration
+ */
+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>;
+type PatchFlow = z.infer<typeof PatchFlow>;
+/**
+ * effect - External operation requirement declaration
+ * Effects are NOT executed by Core. They are declarations recorded in Snapshot.
+ */
+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>;
+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.
+ */
+declare const CallFlow: z.ZodObject<{
+    kind: z.ZodLiteral<"call">;
+    flow: z.ZodString;
+}, z.core.$strip>;
+type CallFlow = z.infer<typeof CallFlow>;
+/**
+ * halt - Stop flow execution normally (not an error)
+ */
+declare const HaltFlow: z.ZodObject<{
+    kind: z.ZodLiteral<"halt">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type HaltFlow = z.infer<typeof HaltFlow>;
+/**
+ * fail - Stop flow execution with an error
+ * The error is recorded in Snapshot.
+ */
+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>;
+type FailFlow = z.infer<typeof FailFlow>;
+declare const FlowNodeSchema: z.ZodType<FlowNode>;
+/**
+ * Flow node kinds enum
+ */
+declare const FlowKind: z.ZodEnum<{
+    patch: "patch";
+    effect: "effect";
+    call: "call";
+    halt: "halt";
+    fail: "fail";
+    if: "if";
+    seq: "seq";
+}>;
+type FlowKind = z.infer<typeof FlowKind>;
+
+/**
+ * Field type definitions
+ */
+declare const PrimitiveFieldType: z.ZodEnum<{
+    string: "string";
+    number: "number";
+    boolean: "boolean";
+    object: "object";
+    null: "null";
+    array: "array";
+}>;
+type PrimitiveFieldType = z.infer<typeof PrimitiveFieldType>;
+declare const EnumFieldType: z.ZodObject<{
+    enum: z.ZodReadonly<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$strip>;
+type EnumFieldType = z.infer<typeof EnumFieldType>;
+declare const FieldType: z.ZodUnion<readonly [z.ZodEnum<{
+    string: "string";
+    number: "number";
+    boolean: "boolean";
+    object: "object";
+    null: "null";
+    array: "array";
+}>, z.ZodObject<{
+    enum: z.ZodReadonly<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$strip>]>;
+type FieldType = z.infer<typeof FieldType>;
+/**
+ * Field specification (recursive for nested objects/arrays)
+ */
+type FieldSpec = {
+    type: FieldType;
+    required: boolean;
+    default?: unknown;
+    description?: string;
+    fields?: Record<string, FieldSpec>;
+    items?: FieldSpec;
+};
+declare const FieldSpec: z.ZodType<FieldSpec>;
+/**
+ * State specification - defines the shape of domain state
+ */
+declare const StateSpec: z.ZodObject<{
+    fields: z.ZodRecord<z.ZodString, z.ZodType<FieldSpec, unknown, z.core.$ZodTypeInternals<FieldSpec, unknown>>>;
+}, z.core.$strip>;
+type StateSpec = z.infer<typeof StateSpec>;
+
+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;
+};
+declare const TypeDefinition: z.ZodType<TypeDefinition>;
+declare const TypeSpec: z.ZodObject<{
+    name: z.ZodString;
+    definition: z.ZodType<TypeDefinition, unknown, z.core.$ZodTypeInternals<TypeDefinition, unknown>>;
+}, z.core.$strip>;
+type TypeSpec = z.infer<typeof TypeSpec>;
+
+/**
+ * Schema metadata
+ */
+declare const SchemaMeta: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type SchemaMeta = z.infer<typeof SchemaMeta>;
+/**
+ * DomainSchema - Complete schema definition
+ *
+ * Defines:
+ * - What the domain looks like (StateSpec)
+ * - What can be derived (ComputedSpec)
+ * - How state transitions occur (Actions → FlowSpec)
+ */
+declare const DomainSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    hash: z.ZodString;
+    types: z.ZodRecord<z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        definition: z.ZodType<TypeDefinition, unknown, z.core.$ZodTypeInternals<TypeDefinition, unknown>>;
+    }, z.core.$strip>>;
+    state: z.ZodObject<{
+        fields: z.ZodRecord<z.ZodString, z.ZodType<FieldSpec, unknown, z.core.$ZodTypeInternals<FieldSpec, unknown>>>;
+    }, z.core.$strip>;
+    computed: z.ZodObject<{
+        fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+            deps: z.ZodArray<z.ZodString>;
+            expr: z.ZodType<ExprNode, unknown, z.core.$ZodTypeInternals<ExprNode, unknown>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    actions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        flow: z.ZodType<FlowNode, unknown, z.core.$ZodTypeInternals<FlowNode, unknown>>;
+        input: z.ZodOptional<z.ZodType<FieldSpec, unknown, z.core.$ZodTypeInternals<FieldSpec, unknown>>>;
+        available: z.ZodOptional<z.ZodType<ExprNode, unknown, z.core.$ZodTypeInternals<ExprNode, unknown>>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    meta: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type DomainSchema = z.infer<typeof DomainSchema>;
+
+/**
+ * ErrorValue - Errors are values in Snapshot, not exceptions.
+ */
+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>;
+type ErrorValue = z.infer<typeof ErrorValue>;
+/**
+ * FlowPosition - Position in the flow where effect was encountered
+ */
+declare const FlowPosition: z.ZodObject<{
+    nodePath: z.ZodString;
+    snapshotVersion: z.ZodNumber;
+}, z.core.$strip>;
+type FlowPosition = z.infer<typeof FlowPosition>;
+/**
+ * Requirement - A recorded effect declaration waiting for Host fulfillment
+ */
+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>;
+type Requirement = z.infer<typeof Requirement>;
+/**
+ * SystemState - Internal system state
+ */
+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>;
+type SystemState = z.infer<typeof SystemState>;
+/**
+ * SnapshotMeta - Snapshot metadata
+ */
+declare const SnapshotMeta: z.ZodObject<{
+    version: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    randomSeed: z.ZodString;
+    schemaHash: z.ZodString;
+}, z.core.$strip>;
+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.
+ */
+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;
+        randomSeed: z.ZodString;
+        schemaHash: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type Snapshot = z.infer<typeof Snapshot>;
+/**
+ * Create initial system state
+ */
+declare function createInitialSystemState(): SystemState;
+
+/**
+ * PatchSegment - A single segment in a patch path.
+ */
+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">;
+type PatchSegment = z.infer<typeof PatchSegment>;
+/**
+ * PatchPath - Path segments rooted at snapshot.data.
+ */
+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">>;
+type PatchPath = z.infer<typeof PatchPath>;
+/**
+ * Patch - A single state modification operation.
+ * Only three operations: set, unset, merge.
+ */
+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">;
+type Patch = z.infer<typeof Patch>;
+/**
+ * SetPatch - Set value at path
+ */
+type SetPatch = Extract<Patch, {
+    op: "set";
+}>;
+/**
+ * UnsetPatch - Remove value at path
+ */
+type UnsetPatch = Extract<Patch, {
+    op: "unset";
+}>;
+/**
+ * MergePatch - Shallow merge object at path
+ */
+type MergePatch = Extract<Patch, {
+    op: "merge";
+}>;
+/**
+ * Intent - A request to perform an action
+ */
+declare const Intent: z.ZodObject<{
+    type: z.ZodString;
+    input: z.ZodOptional<z.ZodUnknown>;
+    intentId: z.ZodString;
+}, z.core.$strip>;
+type Intent = z.infer<typeof Intent>;
+/**
+ * Helper to create a prop segment
+ */
+declare function propSegment(name: string): PatchSegment;
+/**
+ * Helper to create an index segment
+ */
+declare function indexSegment(index: number): PatchSegment;
+/**
+ * Helper to create a set patch
+ */
+declare function setPatch(path: PatchPath, value: unknown): SetPatch;
+/**
+ * Helper to create an unset patch
+ */
+declare function unsetPatch(path: PatchPath): UnsetPatch;
+/**
+ * Helper to create a merge patch
+ */
+declare function mergePatch(path: PatchPath, value: Record<string, unknown>): MergePatch;
+
+/**
+ * Dot-separated path for accessing values (e.g., "user.profile.name")
+ */
+declare const SemanticPath: z.ZodString;
+type SemanticPath = z.infer<typeof SemanticPath>;
+/**
+ * Result type for functions that can fail without throwing
+ */
+declare const Result: <T extends z.ZodTypeAny, E extends z.ZodTypeAny>(valueSchema: T, errorSchema: E) => z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    value: T;
+}, z.core.$strip>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    error: E;
+}, z.core.$strip>], "ok">;
+type Result<T, E> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+/**
+ * Helper functions for Result type
+ */
+declare const ok: <T>(value: T) => Result<T, never>;
+declare const err: <E>(error: E) => Result<never, E>;
+declare const isOk: <T, E>(result: Result<T, E>) => result is {
+    ok: true;
+    value: T;
+};
+declare const isErr: <T, E>(result: Result<T, E>) => result is {
+    ok: false;
+    error: E;
+};
+
+/**
+ * TraceNodeKind - Types of trace nodes
+ */
+declare const TraceNodeKind: z.ZodEnum<{
+    computed: "computed";
+    error: "error";
+    expr: "expr";
+    flow: "flow";
+    patch: "patch";
+    effect: "effect";
+    call: "call";
+    halt: "halt";
+    branch: "branch";
+}>;
+type TraceNodeKind = z.infer<typeof TraceNodeKind>;
+/**
+ * TraceNode - A single node in the execution trace.
+ * Enables explainability - every computation produces a trace.
+ */
+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;
+};
+declare const TraceNode: z.ZodType<TraceNode>;
+/**
+ * TraceTermination - How the computation ended
+ */
+declare const TraceTermination: z.ZodEnum<{
+    error: "error";
+    effect: "effect";
+    halt: "halt";
+    complete: "complete";
+}>;
+type TraceTermination = z.infer<typeof TraceTermination>;
+/**
+ * TraceGraph - Complete trace of a computation
+ */
+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>;
+type TraceGraph = z.infer<typeof TraceGraph>;
+/**
+ * TraceContext - Deterministic trace ID generation
+ */
+type TraceContext = {
+    readonly nextId: () => string;
+    readonly timestamp: number;
+};
+/**
+ * Create a trace context for a single compute pass
+ */
+declare function createTraceContext(timestamp: number): TraceContext;
+/**
+ * Create a trace node
+ */
+declare function createTraceNode(trace: TraceContext, kind: TraceNodeKind, sourcePath: string, inputs: Record<string, unknown>, output: unknown, children?: TraceNode[]): TraceNode;
+
+/**
+ * ComputeStatus - Result of a compute() call
+ */
+declare const ComputeStatus: z.ZodEnum<{
+    error: "error";
+    pending: "pending";
+    complete: "complete";
+    halted: "halted";
+}>;
+type ComputeStatus = z.infer<typeof ComputeStatus>;
+/**
+ * SystemDelta - Declarative system transition emitted by compute().
+ */
+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>>>;
+    appendErrors: 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>>;
+    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>;
+type SystemDelta = z.infer<typeof SystemDelta>;
+/**
+ * ComputeResult - Result of compute() call
+ */
+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>>>;
+        appendErrors: 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>>;
+        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>;
+type ComputeResult = z.infer<typeof ComputeResult>;
+/**
+ * ValidationError - Single validation error
+ */
+declare const ValidationError: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ValidationError = z.infer<typeof ValidationError>;
+/**
+ * ValidationResult - Result of validate() call
+ */
+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>;
+type ValidationResult = z.infer<typeof ValidationResult>;
+/**
+ * ExplainResult - Result of explain() call
+ */
+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>;
+type ExplainResult = z.infer<typeof ExplainResult>;
+/**
+ * Create a successful validation result
+ */
+declare function validResult(): ValidationResult;
+/**
+ * Create a failed validation result
+ */
+declare function invalidResult(errors: ValidationError[]): ValidationResult;
+
+/**
+ * HostContext - Explicit host-provided inputs for determinism
+ */
+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>;
+type HostContext = z.infer<typeof HostContext>;
+
+/**
+ * Compute the result of dispatching an intent (synchronous).
+ *
+ * This is the canonical computation path. Each call is independent -
+ * there is no suspended context.
+ */
+declare function computeSync(schema: DomainSchema, snapshot: Snapshot, intent: Intent, context: HostContext): ComputeResult;
+/**
+ * Compute the result of dispatching an intent (async wrapper).
+ */
+declare function compute(schema: DomainSchema, snapshot: Snapshot, intent: Intent, context: HostContext): Promise<ComputeResult>;
+
+/**
+ * Apply patches to snapshot.data and recompute computed values.
+ *
+ * Patch targets are rooted at snapshot.data only.
+ * System transitions are handled by applySystemDelta().
+ */
+declare function apply(schema: DomainSchema, snapshot: Snapshot, patches: readonly Patch[], context: HostContext): Snapshot;
+
+/**
+ * Apply a declarative system transition to a snapshot.
+ *
+ * This function is pure, deterministic, and total.
+ */
+declare function applySystemDelta(snapshot: Snapshot, delta: SystemDelta): Snapshot;
+
+/**
+ * Validate a domain schema
+ *
+ * Validation rules:
+ * - V-001: All paths in ComputedSpec.deps MUST exist
+ * - V-002: ComputedSpec dependency graph MUST be acyclic
+ * - V-003: All paths in ExprNode.get MUST exist
+ * - V-004: All `call` references in FlowSpec MUST exist
+ * - V-005: FlowSpec `call` graph MUST be acyclic
+ * - V-006: ActionSpec.available expression MUST return boolean (runtime check)
+ * - V-007: ActionSpec.input MUST be valid FieldSpec (Zod handles this)
+ * - V-008: Schema hash MUST match canonical hash
+ */
+declare function validate(schema: unknown): ValidationResult;
+
+/**
+ * Explain why a value is what it is
+ *
+ * @param schema - The domain schema
+ * @param snapshot - Current snapshot state
+ * @param path - The path to explain
+ * @returns ExplainResult with value, trace, and dependencies
+ */
+declare function explain(schema: DomainSchema, snapshot: Snapshot, path: SemanticPath): ExplainResult;
+
+/**
+ * ComputedFieldSpec - Definition of a single computed field
+ */
+declare const ComputedFieldSpec: z.ZodObject<{
+    deps: z.ZodArray<z.ZodString>;
+    expr: z.ZodType<ExprNode, unknown, z.core.$ZodTypeInternals<ExprNode, unknown>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ComputedFieldSpec = z.infer<typeof ComputedFieldSpec>;
+/**
+ * ComputedSpec - Collection of computed field definitions
+ * Computed values form a Directed Acyclic Graph (DAG).
+ */
+declare const ComputedSpec: z.ZodObject<{
+    fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+        deps: z.ZodArray<z.ZodString>;
+        expr: z.ZodType<ExprNode, unknown, z.core.$ZodTypeInternals<ExprNode, unknown>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ComputedSpec = z.infer<typeof ComputedSpec>;
+
+/**
+ * ActionSpec - Maps intents to flows
+ * An action defines what happens when a particular intent is dispatched.
+ */
+declare const ActionSpec: z.ZodObject<{
+    flow: z.ZodType<FlowNode, unknown, z.core.$ZodTypeInternals<FlowNode, unknown>>;
+    input: z.ZodOptional<z.ZodType<FieldSpec, unknown, z.core.$ZodTypeInternals<FieldSpec, unknown>>>;
+    available: z.ZodOptional<z.ZodType<ExprNode, unknown, z.core.$ZodTypeInternals<ExprNode, unknown>>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ActionSpec = z.infer<typeof ActionSpec>;
+
+/**
+ * Extract top-level default values from a StateSpec.
+ *
+ * Iterates `stateSpec.fields` and collects fields with an explicit `default`.
+ * Returns a flat record of field names to default values.
+ *
+ * @param stateSpec - The state specification from a DomainSchema
+ * @returns Record of field names to their default values
+ */
+declare function extractDefaults(stateSpec: StateSpec): Record<string, unknown>;
+
+/**
+ * Parse a dot-separated path into segments.
+ *
+ * Supports escaping literal dots inside segments via backslash (for example `a\\.b` -> `a.b`).
+ */
+declare function parsePath(path: SemanticPath): string[];
+/**
+ * Join path segments into a semantic path
+ */
+declare function joinPath(...segments: string[]): SemanticPath;
+/**
+ * Get value at path from object
+ * Returns undefined for non-existent paths (never throws)
+ */
+declare function getByPath(obj: unknown, path: SemanticPath): unknown;
+/**
+ * Immutably set value at path
+ * Creates intermediate objects as needed
+ */
+declare function setByPath(obj: unknown, path: SemanticPath, value: unknown): unknown;
+/**
+ * Immutably remove value at path
+ */
+declare function unsetByPath(obj: unknown, path: SemanticPath): unknown;
+/**
+ * Immutably shallow merge at path
+ */
+declare function mergeAtPath(obj: unknown, path: SemanticPath, value: Record<string, unknown>): unknown;
+/**
+ * Check if a path exists in an object
+ */
+declare function hasPath(obj: unknown, path: SemanticPath): boolean;
+/**
+ * Get parent path
+ */
+declare function parentPath(path: SemanticPath): SemanticPath;
+/**
+ * Get last segment of path
+ */
+declare function lastSegment(path: SemanticPath): string;
+
+/**
+ * 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
+ */
+declare function sortKeys(obj: unknown): unknown;
+/**
+ * Convert object to canonical JSON string
+ * - Keys are sorted alphabetically
+ * - Undefined values are removed
+ * - No whitespace
+ */
+declare function toCanonical(obj: unknown): string;
+/**
+ * Canonicalize JSON per RFC 8785 (JCS)
+ * - Objects: keys sorted by Unicode code points
+ * - Arrays: preserve order
+ * - Undefined/function/symbol: omitted in objects, null in arrays
+ * - Non-finite numbers: null
+ */
+declare function toJcs(value: unknown): string;
+/**
+ * Parse canonical JSON string
+ */
+declare function fromCanonical<T>(canonical: string): T;
+/**
+ * Check if two objects are equal in canonical form
+ */
+declare function canonicalEqual(a: unknown, b: unknown): boolean;
+
+type SchemaHashMode = "semantic" | "effective";
+type SchemaHashInput = {
+    id: string;
+    version: string;
+    types: Record<string, unknown>;
+    state: {
+        fields: Record<string, unknown>;
+    };
+    computed: {
+        fields: Record<string, {
+            deps: string[];
+            expr: unknown;
+            description?: string;
+        }>;
+    };
+    actions: Record<string, unknown>;
+    meta?: {
+        name?: string;
+        description?: string;
+        authors?: string[];
+    };
+};
+/**
+ * SHA-256 hash using Web Crypto API
+ * Works in both browser and Node.js
+ */
+declare function sha256(message: string): Promise<string>;
+/**
+ * SHA-256 hash using a synchronous pure JS implementation
+ */
+declare function sha256Sync(message: string): string;
+/**
+ * Hash a schema in canonical form
+ */
+declare function hashSchema(schema: SchemaHashInput, mode?: SchemaHashMode): Promise<string>;
+/**
+ * Hash a schema in canonical form (sync)
+ */
+declare function hashSchemaSync(schema: SchemaHashInput, mode?: SchemaHashMode): string;
+declare function hashSchemaEffective(schema: SchemaHashInput): Promise<string>;
+declare function hashSchemaEffectiveSync(schema: SchemaHashInput): string;
+/**
+ * Generate deterministic requirement ID
+ * Based on: schemaHash, intentId, actionId, flowNodePath
+ */
+declare function generateRequirementId(schemaHash: string, intentId: string, actionId: string, flowNodePath: string): Promise<string>;
+/**
+ * Generate deterministic requirement ID (sync)
+ */
+declare function generateRequirementIdSync(schemaHash: string, intentId: string, actionId: string, flowNodePath: string): string;
+/**
+ * Generate a trace node ID
+ */
+declare function generateTraceId(index?: number): string;
+
+/**
+ * Render PatchPath for logs and error messages only.
+ */
+declare function patchPathToDisplayString(path: PatchPath): string;
+/**
+ * Convert a legacy semantic string path into PatchPath segments.
+ * This helper exists for internal bridging only.
+ */
+declare function semanticPathToPatchPath(path: string): PatchPath;
+declare function isSafePatchPath(path: PatchPath): boolean;
+declare function getByPatchPath(obj: unknown, path: PatchPath): unknown;
+declare function setByPatchPath(obj: unknown, path: PatchPath, value: unknown): unknown;
+declare function unsetByPatchPath(obj: unknown, path: PatchPath): unknown;
+declare function mergeAtPatchPath(obj: unknown, path: PatchPath, value: Record<string, unknown>): unknown;
+
+/**
+ * Evaluation context for expressions and flows
+ */
+type EvalContext = {
+    /**
+     * Current snapshot state
+     */
+    readonly snapshot: Snapshot;
+    /**
+     * Domain schema
+     */
+    readonly schema: DomainSchema;
+    /**
+     * Current action being processed (if any)
+     */
+    readonly currentAction: string | null;
+    /**
+     * Current node path in the flow (for tracing)
+     */
+    readonly nodePath: string;
+    /**
+     * Intent ID for the current intent (for re-entry safety)
+     */
+    readonly intentId?: string;
+    /**
+     * UUID generator counter (for deterministic UUID generation)
+     */
+    uuidCounter?: number;
+    /**
+     * Trace context for deterministic trace ID generation
+     */
+    readonly trace: TraceContext;
+    /**
+     * Collection context variables (for filter, map, find, etc.)
+     */
+    readonly $item?: unknown;
+    readonly $index?: number;
+    readonly $array?: unknown[];
+};
+/**
+ * Create a new evaluation context
+ *
+ * @param timestampOrTrace - Required timestamp or TraceContext for deterministic tracing.
+ *                           MUST be provided by Host via HostContext.now to ensure determinism.
+ */
+declare function createContext(snapshot: Snapshot, schema: DomainSchema, currentAction: string | null, nodePath: string, intentId: string | undefined, timestampOrTrace: number | TraceContext): EvalContext;
+/**
+ * Create context with collection variables for filter/map/find/etc.
+ */
+declare function withCollectionContext(ctx: EvalContext, item: unknown, index: number, array: unknown[]): EvalContext;
+/**
+ * Update context with new snapshot
+ */
+declare function withSnapshot(ctx: EvalContext, snapshot: Snapshot): EvalContext;
+/**
+ * Update context with new node path
+ */
+declare function withNodePath(ctx: EvalContext, nodePath: string): EvalContext;
+
+type ExprResult = Result<unknown, ErrorValue>;
+/**
+ * Evaluate an expression node
+ * All expressions are pure and total (always return a value or error)
+ */
+declare function evaluateExpr(expr: ExprNode, ctx: EvalContext): ExprResult;
+
+/**
+ * Flow execution status
+ */
+type FlowStatus = "running" | "complete" | "pending" | "halted" | "error";
+/**
+ * Flow execution state
+ */
+type FlowState = {
+    readonly snapshot: Snapshot;
+    readonly status: FlowStatus;
+    readonly patches: readonly Patch[];
+    readonly requirements: readonly Requirement[];
+    readonly error: ErrorValue | null;
+};
+/**
+ * Flow evaluation result
+ */
+type FlowResult = {
+    readonly state: FlowState;
+    readonly trace: TraceNode;
+};
+/**
+ * Create initial flow state
+ */
+declare function createFlowState(snapshot: Snapshot): FlowState;
+/**
+ * Evaluate a flow node
+ */
+declare function evaluateFlowSync(flow: FlowNode, ctx: EvalContext, state: FlowState, nodePath: string): FlowResult;
+declare function evaluateFlow(flow: FlowNode, ctx: EvalContext, state: FlowState, nodePath: string): Promise<FlowResult>;
+
+/**
+ * Dependency graph for computed values
+ */
+type DependencyGraph = {
+    readonly nodes: readonly SemanticPath[];
+    readonly edges: ReadonlyMap<SemanticPath, readonly SemanticPath[]>;
+};
+/**
+ * Build a dependency graph from ComputedSpec
+ */
+declare function buildDependencyGraph(computed: ComputedSpec): DependencyGraph;
+/**
+ * Topological sort using Kahn's algorithm
+ * Returns sorted order or error if cycles detected
+ */
+declare function topologicalSort(graph: DependencyGraph): Result<SemanticPath[], ValidationError>;
+/**
+ * Detect cycles in the dependency graph
+ * Returns array of cycle paths or null if no cycles
+ */
+declare function detectCycles(graph: DependencyGraph): SemanticPath[][] | null;
+/**
+ * Get all dependencies (transitive) for a given node
+ */
+declare function getTransitiveDeps(graph: DependencyGraph, node: SemanticPath): Set<SemanticPath>;
+
+/**
+ * Evaluate all computed values for a snapshot
+ * Returns the computed values record or an error
+ */
+declare function evaluateComputed(schema: DomainSchema, snapshot: Snapshot): Result<Record<SemanticPath, unknown>, ErrorValue>;
+/**
+ * Evaluate a single computed value
+ */
+declare function evaluateSingleComputed(schema: DomainSchema, snapshot: Snapshot, path: SemanticPath): Result<unknown, ErrorValue>;
+
+/**
+ * Core error codes
+ */
+declare const CoreErrorCode: z.ZodEnum<{
+    VALIDATION_ERROR: "VALIDATION_ERROR";
+    PATH_NOT_FOUND: "PATH_NOT_FOUND";
+    TYPE_MISMATCH: "TYPE_MISMATCH";
+    DIVISION_BY_ZERO: "DIVISION_BY_ZERO";
+    INDEX_OUT_OF_BOUNDS: "INDEX_OUT_OF_BOUNDS";
+    UNKNOWN_ACTION: "UNKNOWN_ACTION";
+    ACTION_UNAVAILABLE: "ACTION_UNAVAILABLE";
+    INVALID_INPUT: "INVALID_INPUT";
+    CYCLIC_DEPENDENCY: "CYCLIC_DEPENDENCY";
+    UNKNOWN_FLOW: "UNKNOWN_FLOW";
+    CYCLIC_CALL: "CYCLIC_CALL";
+    UNKNOWN_EFFECT: "UNKNOWN_EFFECT";
+    INTERNAL_ERROR: "INTERNAL_ERROR";
+}>;
+type CoreErrorCode = z.infer<typeof CoreErrorCode>;
+/**
+ * Create an error value (errors are values, not exceptions)
+ */
+declare function createError(code: CoreErrorCode, message: string, actionId: string, nodePath: string, timestamp: number, context?: Record<string, unknown>): ErrorValue;
+/**
+ * Check if a value is an ErrorValue
+ */
+declare function isErrorValue(value: unknown): value is ErrorValue;
+
+/**
+ * Create a new snapshot with initial data
+ *
+ * @param data - Initial domain data
+ * @param schemaHash - Hash of the schema this snapshot conforms to
+ * @returns New snapshot
+ */
+declare function createSnapshot<T>(data: T, schemaHash: string, context: HostContext): Snapshot;
+/**
+ * Create an intent
+ *
+ * @param type - Action type
+ * @param input - Action input (optional)
+ * @param intentId - Unique identifier for this processing attempt (optional, auto-generated if not provided)
+ * @returns Intent
+ */
+declare function createIntent(type: string, intentId: string): Intent;
+declare function createIntent(type: string, input: unknown, intentId: string): Intent;
+
 /**
  * @manifesto-ai/core
  *
@@ -5,20 +1745,11 @@
  *
  * Core computes. Host executes. These concerns never mix.
  */
-import type { DomainSchema } from "./schema/domain.js";
-import type { Snapshot } from "./schema/snapshot.js";
-import type { Intent, Patch } from "./schema/patch.js";
-import type { SemanticPath } from "./schema/common.js";
-import type { ComputeResult, ValidationResult, ExplainResult } from "./schema/result.js";
-import type { HostContext } from "./schema/host-context.js";
-import { compute, computeSync } from "./core/compute.js";
-import { apply } from "./core/apply.js";
-import { validate } from "./core/validate.js";
-import { explain } from "./core/explain.js";
+
 /**
  * ManifestoCore interface
  */
-export interface ManifestoCore {
+interface ManifestoCore {
     /**
      * Compute the result of dispatching an intent.
      *
@@ -35,6 +1766,10 @@ export interface ManifestoCore {
      * Returns new snapshot with recomputed values.
      */
     apply(schema: DomainSchema, snapshot: Snapshot, patches: readonly Patch[], context: HostContext): Snapshot;
+    /**
+     * Apply a system transition emitted by compute().
+     */
+    applySystemDelta(snapshot: Snapshot, delta: SystemDelta): Snapshot;
     /**
      * Validate a schema.
      */
@@ -47,11 +1782,6 @@ export interface ManifestoCore {
 /**
  * Create a ManifestoCore instance
  */
-export declare function createCore(): ManifestoCore;
-export * from "./schema/index.js";
-export * from "./utils/index.js";
-export * from "./evaluator/index.js";
-export * from "./errors.js";
-export * from "./factories.js";
-export { compute, computeSync, apply, validate, explain };
-//# sourceMappingURL=index.d.ts.map
+declare function createCore(): ManifestoCore;
+
+export { AbsExpr, ActionSpec, AddExpr, AndExpr, AppendExpr, AtExpr, CallFlow, CeilExpr, CoalesceExpr, ComputeResult, ComputeStatus, ComputedFieldSpec, ComputedSpec, ConcatExpr, CoreErrorCode, type DependencyGraph, DivExpr, DomainSchema, EffectFlow, EndsWithExpr, EntriesExpr, EnumFieldType, EqExpr, ErrorValue, type EvalContext, EveryExpr, ExplainResult, ExprKind, type ExprNode, ExprNodeSchema, type ExprResult, FailFlow, FieldExpr, FieldSpec, FieldType, FilterExpr, FindExpr, FirstExpr, FlatExpr, FloorExpr, FlowKind, type FlowNode, FlowNodeSchema, FlowPosition, type FlowResult, type FlowState, type FlowStatus, FromEntriesExpr, GetExpr, GtExpr, GteExpr, HaltFlow, HasKeyExpr, HostContext, IfExpr, IfFlow, IncludesExpr, IndexOfExpr, Intent, IsNullExpr, KeysExpr, LastExpr, LenExpr, LitExpr, LtExpr, LteExpr, type ManifestoCore, MapExpr, MaxArrayExpr, MaxExpr, MergeExpr, type MergePatch, MinArrayExpr, MinExpr, ModExpr, MulExpr, NegExpr, NeqExpr, NotExpr, ObjectExpr, OmitExpr, OrExpr, Patch, PatchFlow, PatchOp, PatchPath, PatchSegment, PickExpr, PowExpr, PrimitiveFieldType, ReplaceExpr, Requirement, Result, ReverseExpr, RoundExpr, type SchemaHashInput, type SchemaHashMode, SchemaMeta, SemanticPath, SeqFlow, type SetPatch, SliceExpr, Snapshot, SnapshotMeta, SomeExpr, SplitExpr, SqrtExpr, StartsWithExpr, StateSpec, StrIncludesExpr, StrLenExpr, SubExpr, SubstringExpr, SumArrayExpr, SystemDelta, SystemState, ToBooleanExpr, ToLowerCaseExpr, ToNumberExpr, ToStringExpr, ToUpperCaseExpr, type TraceContext, TraceGraph, TraceNode, TraceNodeKind, TraceTermination, TrimExpr, TypeDefinition, TypeSpec, TypeofExpr, UniqueExpr, type UnsetPatch, ValidationError, ValidationResult, ValuesExpr, apply, applySystemDelta, buildDependencyGraph, canonicalEqual, compute, computeSync, createContext, createCore, createError, createFlowState, createInitialSystemState, createIntent, createSnapshot, createTraceContext, createTraceNode, detectCycles, err, evaluateComputed, evaluateExpr, evaluateFlow, evaluateFlowSync, evaluateSingleComputed, explain, extractDefaults, fromCanonical, generateRequirementId, generateRequirementIdSync, generateTraceId, getByPatchPath, getByPath, getTransitiveDeps, hasPath, hashSchema, hashSchemaEffective, hashSchemaEffectiveSync, hashSchemaSync, indexSegment, invalidResult, isErr, isErrorValue, isOk, isSafePatchPath, joinPath, lastSegment, mergeAtPatchPath, mergeAtPath, mergePatch, ok, parentPath, parsePath, patchPathToDisplayString, propSegment, semanticPathToPatchPath, setByPatchPath, setByPath, setPatch, sha256, sha256Sync, sortKeys, toCanonical, toJcs, topologicalSort, unsetByPatchPath, unsetByPath, unsetPatch, validResult, validate, withCollectionContext, withNodePath, withSnapshot };