@manifesto-ai/core 2.8.0 → 2.9.0

package/dist/schema/action.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { FieldSpec } from "./field.js";
+/**
+ * ActionSpec - Maps intents to flows
+ * An action defines what happens when a particular intent is dispatched.
+ */
+export declare const ActionSpec: z.ZodObject<{
+    flow: z.ZodType<import("./flow.js").FlowNode, unknown, z.core.$ZodTypeInternals<import("./flow.js").FlowNode, unknown>>;
+    input: z.ZodOptional<z.ZodType<FieldSpec, unknown, z.core.$ZodTypeInternals<FieldSpec, unknown>>>;
+    available: z.ZodOptional<z.ZodType<import("./expr.js").ExprNode, unknown, z.core.$ZodTypeInternals<import("./expr.js").ExprNode, unknown>>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ActionSpec = z.infer<typeof ActionSpec>;

package/dist/schema/common.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/**
+ * Dot-separated path for accessing values (e.g., "user.profile.name")
+ */
+export declare const SemanticPath: z.ZodString;
+export type SemanticPath = z.infer<typeof SemanticPath>;
+/**
+ * Result type for functions that can fail without throwing
+ */
+export 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">;
+export type Result<T, E> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+/**
+ * Helper functions for Result type
+ */
+export declare const ok: <T>(value: T) => Result<T, never>;
+export declare const err: <E>(error: E) => Result<never, E>;
+export declare const isOk: <T, E>(result: Result<T, E>) => result is {
+    ok: true;
+    value: T;
+};
+export declare const isErr: <T, E>(result: Result<T, E>) => result is {
+    ok: false;
+    error: E;
+};

package/dist/schema/computed.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+/**
+ * ComputedFieldSpec - Definition of a single computed field
+ */
+export declare const ComputedFieldSpec: z.ZodObject<{
+    deps: z.ZodArray<z.ZodString>;
+    expr: z.ZodType<import("./expr.js").ExprNode, unknown, z.core.$ZodTypeInternals<import("./expr.js").ExprNode, unknown>>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ComputedFieldSpec = z.infer<typeof ComputedFieldSpec>;
+/**
+ * ComputedSpec - Collection of computed field definitions
+ * Computed values form a Directed Acyclic Graph (DAG).
+ */
+export declare const ComputedSpec: z.ZodObject<{
+    fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+        deps: z.ZodArray<z.ZodString>;
+        expr: z.ZodType<import("./expr.js").ExprNode, unknown, z.core.$ZodTypeInternals<import("./expr.js").ExprNode, unknown>>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ComputedSpec = z.infer<typeof ComputedSpec>;

package/dist/schema/defaults.d.ts

@@ -0,0 +1,11 @@
+import type { StateSpec } from "./field.js";
+/**
+ * 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
+ */
+export declare function extractDefaults(stateSpec: StateSpec): Record<string, unknown>;

package/dist/schema/domain.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+/**
+ * Schema metadata
+ */
+export 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>;
+export 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)
+ */
+export 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<import("./type-spec.js").TypeDefinition, unknown, z.core.$ZodTypeInternals<import("./type-spec.js").TypeDefinition, unknown>>;
+    }, z.core.$strip>>;
+    state: z.ZodObject<{
+        fields: z.ZodRecord<z.ZodString, z.ZodType<import("./field.js").FieldSpec, unknown, z.core.$ZodTypeInternals<import("./field.js").FieldSpec, unknown>>>;
+    }, z.core.$strip>;
+    computed: z.ZodObject<{
+        fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+            deps: z.ZodArray<z.ZodString>;
+            expr: z.ZodType<import("./expr.js").ExprNode, unknown, z.core.$ZodTypeInternals<import("./expr.js").ExprNode, unknown>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    actions: z.ZodRecord<z.ZodString, z.ZodObject<{
+        flow: z.ZodType<import("./flow.js").FlowNode, unknown, z.core.$ZodTypeInternals<import("./flow.js").FlowNode, unknown>>;
+        input: z.ZodOptional<z.ZodType<import("./field.js").FieldSpec, unknown, z.core.$ZodTypeInternals<import("./field.js").FieldSpec, unknown>>>;
+        available: z.ZodOptional<z.ZodType<import("./expr.js").ExprNode, unknown, z.core.$ZodTypeInternals<import("./expr.js").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>;
+export type DomainSchema = z.infer<typeof DomainSchema>;

package/dist/schema/expr.d.ts

@@ -0,0 +1,482 @@
+import { z } from "zod";
+/**
+ * ExprNode - Pure expression language for ComputedSpec and FlowSpec
+ * All expressions are deterministic and side-effect free
+ */
+export 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;
+export declare const LitExpr: z.ZodObject<{
+    kind: z.ZodLiteral<"lit">;
+    value: z.ZodUnknown;
+}, z.core.$strip>;
+export type LitExpr = z.infer<typeof LitExpr>;
+export declare const GetExpr: z.ZodObject<{
+    kind: z.ZodLiteral<"get">;
+    path: z.ZodString;
+}, z.core.$strip>;
+export type GetExpr = z.infer<typeof GetExpr>;
+export declare const EqExpr: z.ZodType<{
+    kind: "eq";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+export type EqExpr = z.infer<typeof EqExpr>;
+export declare const NeqExpr: z.ZodType<{
+    kind: "neq";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+export type NeqExpr = z.infer<typeof NeqExpr>;
+export declare const GtExpr: z.ZodType<{
+    kind: "gt";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+export type GtExpr = z.infer<typeof GtExpr>;
+export declare const GteExpr: z.ZodType<{
+    kind: "gte";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+export type GteExpr = z.infer<typeof GteExpr>;
+export declare const LtExpr: z.ZodType<{
+    kind: "lt";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+export type LtExpr = z.infer<typeof LtExpr>;
+export declare const LteExpr: z.ZodType<{
+    kind: "lte";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+export type LteExpr = z.infer<typeof LteExpr>;
+export declare const AndExpr: z.ZodType<{
+    kind: "and";
+    args: ExprNode[];
+}>;
+export type AndExpr = z.infer<typeof AndExpr>;
+export declare const OrExpr: z.ZodType<{
+    kind: "or";
+    args: ExprNode[];
+}>;
+export type OrExpr = z.infer<typeof OrExpr>;
+export declare const NotExpr: z.ZodType<{
+    kind: "not";
+    arg: ExprNode;
+}>;
+export type NotExpr = z.infer<typeof NotExpr>;
+export declare const IfExpr: z.ZodType<{
+    kind: "if";
+    cond: ExprNode;
+    then: ExprNode;
+    else: ExprNode;
+}>;
+export type IfExpr = z.infer<typeof IfExpr>;
+export declare const AddExpr: z.ZodType<{
+    kind: "add";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+export type AddExpr = z.infer<typeof AddExpr>;
+export declare const SubExpr: z.ZodType<{
+    kind: "sub";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+export type SubExpr = z.infer<typeof SubExpr>;
+export declare const MulExpr: z.ZodType<{
+    kind: "mul";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+export type MulExpr = z.infer<typeof MulExpr>;
+export declare const DivExpr: z.ZodType<{
+    kind: "div";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+export type DivExpr = z.infer<typeof DivExpr>;
+export declare const ModExpr: z.ZodType<{
+    kind: "mod";
+    left: ExprNode;
+    right: ExprNode;
+}>;
+export type ModExpr = z.infer<typeof ModExpr>;
+export declare const MinExpr: z.ZodType<{
+    kind: "min";
+    args: ExprNode[];
+}>;
+export type MinExpr = z.infer<typeof MinExpr>;
+export declare const MaxExpr: z.ZodType<{
+    kind: "max";
+    args: ExprNode[];
+}>;
+export type MaxExpr = z.infer<typeof MaxExpr>;
+export declare const AbsExpr: z.ZodType<{
+    kind: "abs";
+    arg: ExprNode;
+}>;
+export type AbsExpr = z.infer<typeof AbsExpr>;
+export declare const NegExpr: z.ZodType<{
+    kind: "neg";
+    arg: ExprNode;
+}>;
+export type NegExpr = z.infer<typeof NegExpr>;
+export declare const FloorExpr: z.ZodType<{
+    kind: "floor";
+    arg: ExprNode;
+}>;
+export type FloorExpr = z.infer<typeof FloorExpr>;
+export declare const CeilExpr: z.ZodType<{
+    kind: "ceil";
+    arg: ExprNode;
+}>;
+export type CeilExpr = z.infer<typeof CeilExpr>;
+export declare const RoundExpr: z.ZodType<{
+    kind: "round";
+    arg: ExprNode;
+}>;
+export type RoundExpr = z.infer<typeof RoundExpr>;
+export declare const SqrtExpr: z.ZodType<{
+    kind: "sqrt";
+    arg: ExprNode;
+}>;
+export type SqrtExpr = z.infer<typeof SqrtExpr>;
+export declare const PowExpr: z.ZodType<{
+    kind: "pow";
+    base: ExprNode;
+    exponent: ExprNode;
+}>;
+export type PowExpr = z.infer<typeof PowExpr>;
+export declare const SumArrayExpr: z.ZodType<{
+    kind: "sumArray";
+    array: ExprNode;
+}>;
+export type SumArrayExpr = z.infer<typeof SumArrayExpr>;
+export declare const MinArrayExpr: z.ZodType<{
+    kind: "minArray";
+    array: ExprNode;
+}>;
+export type MinArrayExpr = z.infer<typeof MinArrayExpr>;
+export declare const MaxArrayExpr: z.ZodType<{
+    kind: "maxArray";
+    array: ExprNode;
+}>;
+export type MaxArrayExpr = z.infer<typeof MaxArrayExpr>;
+export declare const ConcatExpr: z.ZodType<{
+    kind: "concat";
+    args: ExprNode[];
+}>;
+export type ConcatExpr = z.infer<typeof ConcatExpr>;
+export declare const SubstringExpr: z.ZodType<{
+    kind: "substring";
+    str: ExprNode;
+    start: ExprNode;
+    end?: ExprNode;
+}>;
+export type SubstringExpr = z.infer<typeof SubstringExpr>;
+export declare const TrimExpr: z.ZodType<{
+    kind: "trim";
+    str: ExprNode;
+}>;
+export type TrimExpr = z.infer<typeof TrimExpr>;
+export declare const ToLowerCaseExpr: z.ZodType<{
+    kind: "toLowerCase";
+    str: ExprNode;
+}>;
+export type ToLowerCaseExpr = z.infer<typeof ToLowerCaseExpr>;
+export declare const ToUpperCaseExpr: z.ZodType<{
+    kind: "toUpperCase";
+    str: ExprNode;
+}>;
+export type ToUpperCaseExpr = z.infer<typeof ToUpperCaseExpr>;
+export declare const StrLenExpr: z.ZodType<{
+    kind: "strLen";
+    str: ExprNode;
+}>;
+export type StrLenExpr = z.infer<typeof StrLenExpr>;
+export declare const StartsWithExpr: z.ZodType<{
+    kind: "startsWith";
+    str: ExprNode;
+    prefix: ExprNode;
+}>;
+export type StartsWithExpr = z.infer<typeof StartsWithExpr>;
+export declare const EndsWithExpr: z.ZodType<{
+    kind: "endsWith";
+    str: ExprNode;
+    suffix: ExprNode;
+}>;
+export type EndsWithExpr = z.infer<typeof EndsWithExpr>;
+export declare const StrIncludesExpr: z.ZodType<{
+    kind: "strIncludes";
+    str: ExprNode;
+    search: ExprNode;
+}>;
+export type StrIncludesExpr = z.infer<typeof StrIncludesExpr>;
+export declare const IndexOfExpr: z.ZodType<{
+    kind: "indexOf";
+    str: ExprNode;
+    search: ExprNode;
+}>;
+export type IndexOfExpr = z.infer<typeof IndexOfExpr>;
+export declare const ReplaceExpr: z.ZodType<{
+    kind: "replace";
+    str: ExprNode;
+    search: ExprNode;
+    replacement: ExprNode;
+}>;
+export type ReplaceExpr = z.infer<typeof ReplaceExpr>;
+export declare const SplitExpr: z.ZodType<{
+    kind: "split";
+    str: ExprNode;
+    delimiter: ExprNode;
+}>;
+export type SplitExpr = z.infer<typeof SplitExpr>;
+export declare const LenExpr: z.ZodType<{
+    kind: "len";
+    arg: ExprNode;
+}>;
+export type LenExpr = z.infer<typeof LenExpr>;
+export declare const AtExpr: z.ZodType<{
+    kind: "at";
+    array: ExprNode;
+    index: ExprNode;
+}>;
+export type AtExpr = z.infer<typeof AtExpr>;
+export declare const FirstExpr: z.ZodType<{
+    kind: "first";
+    array: ExprNode;
+}>;
+export type FirstExpr = z.infer<typeof FirstExpr>;
+export declare const LastExpr: z.ZodType<{
+    kind: "last";
+    array: ExprNode;
+}>;
+export type LastExpr = z.infer<typeof LastExpr>;
+export declare const SliceExpr: z.ZodType<{
+    kind: "slice";
+    array: ExprNode;
+    start: ExprNode;
+    end?: ExprNode;
+}>;
+export type SliceExpr = z.infer<typeof SliceExpr>;
+export declare const IncludesExpr: z.ZodType<{
+    kind: "includes";
+    array: ExprNode;
+    item: ExprNode;
+}>;
+export type IncludesExpr = z.infer<typeof IncludesExpr>;
+export declare const FilterExpr: z.ZodType<{
+    kind: "filter";
+    array: ExprNode;
+    predicate: ExprNode;
+}>;
+export type FilterExpr = z.infer<typeof FilterExpr>;
+export declare const MapExpr: z.ZodType<{
+    kind: "map";
+    array: ExprNode;
+    mapper: ExprNode;
+}>;
+export type MapExpr = z.infer<typeof MapExpr>;
+export declare const FindExpr: z.ZodType<{
+    kind: "find";
+    array: ExprNode;
+    predicate: ExprNode;
+}>;
+export type FindExpr = z.infer<typeof FindExpr>;
+export declare const EveryExpr: z.ZodType<{
+    kind: "every";
+    array: ExprNode;
+    predicate: ExprNode;
+}>;
+export type EveryExpr = z.infer<typeof EveryExpr>;
+export declare const SomeExpr: z.ZodType<{
+    kind: "some";
+    array: ExprNode;
+    predicate: ExprNode;
+}>;
+export type SomeExpr = z.infer<typeof SomeExpr>;
+export declare const AppendExpr: z.ZodType<{
+    kind: "append";
+    array: ExprNode;
+    items: ExprNode[];
+}>;
+export type AppendExpr = z.infer<typeof AppendExpr>;
+export declare const ReverseExpr: z.ZodType<{
+    kind: "reverse";
+    array: ExprNode;
+}>;
+export type ReverseExpr = z.infer<typeof ReverseExpr>;
+export declare const UniqueExpr: z.ZodType<{
+    kind: "unique";
+    array: ExprNode;
+}>;
+export type UniqueExpr = z.infer<typeof UniqueExpr>;
+export declare const FlatExpr: z.ZodType<{
+    kind: "flat";
+    array: ExprNode;
+}>;
+export type FlatExpr = z.infer<typeof FlatExpr>;
+export declare const ObjectExpr: z.ZodType<{
+    kind: "object";
+    fields: Record<string, ExprNode>;
+}>;
+export type ObjectExpr = z.infer<typeof ObjectExpr>;
+export declare const FieldExpr: z.ZodType<{
+    kind: "field";
+    object: ExprNode;
+    property: string;
+}>;
+export type FieldExpr = z.infer<typeof FieldExpr>;
+export declare const KeysExpr: z.ZodType<{
+    kind: "keys";
+    obj: ExprNode;
+}>;
+export type KeysExpr = z.infer<typeof KeysExpr>;
+export declare const ValuesExpr: z.ZodType<{
+    kind: "values";
+    obj: ExprNode;
+}>;
+export type ValuesExpr = z.infer<typeof ValuesExpr>;
+export declare const EntriesExpr: z.ZodType<{
+    kind: "entries";
+    obj: ExprNode;
+}>;
+export type EntriesExpr = z.infer<typeof EntriesExpr>;
+export declare const MergeExpr: z.ZodType<{
+    kind: "merge";
+    objects: ExprNode[];
+}>;
+export type MergeExpr = z.infer<typeof MergeExpr>;
+export declare const HasKeyExpr: z.ZodType<{
+    kind: "hasKey";
+    obj: ExprNode;
+    key: ExprNode;
+}>;
+export type HasKeyExpr = z.infer<typeof HasKeyExpr>;
+export declare const PickExpr: z.ZodType<{
+    kind: "pick";
+    obj: ExprNode;
+    keys: ExprNode;
+}>;
+export type PickExpr = z.infer<typeof PickExpr>;
+export declare const OmitExpr: z.ZodType<{
+    kind: "omit";
+    obj: ExprNode;
+    keys: ExprNode;
+}>;
+export type OmitExpr = z.infer<typeof OmitExpr>;
+export declare const FromEntriesExpr: z.ZodType<{
+    kind: "fromEntries";
+    entries: ExprNode;
+}>;
+export type FromEntriesExpr = z.infer<typeof FromEntriesExpr>;
+export declare const TypeofExpr: z.ZodType<{
+    kind: "typeof";
+    arg: ExprNode;
+}>;
+export type TypeofExpr = z.infer<typeof TypeofExpr>;
+export declare const IsNullExpr: z.ZodType<{
+    kind: "isNull";
+    arg: ExprNode;
+}>;
+export type IsNullExpr = z.infer<typeof IsNullExpr>;
+export declare const CoalesceExpr: z.ZodType<{
+    kind: "coalesce";
+    args: ExprNode[];
+}>;
+export type CoalesceExpr = z.infer<typeof CoalesceExpr>;
+export declare const ToStringExpr: z.ZodType<{
+    kind: "toString";
+    arg: ExprNode;
+}>;
+export type ToStringExpr = z.infer<typeof ToStringExpr>;
+export declare const ToNumberExpr: z.ZodType<{
+    kind: "toNumber";
+    arg: ExprNode;
+}>;
+export type ToNumberExpr = z.infer<typeof ToNumberExpr>;
+export declare const ToBooleanExpr: z.ZodType<{
+    kind: "toBoolean";
+    arg: ExprNode;
+}>;
+export type ToBooleanExpr = z.infer<typeof ToBooleanExpr>;
+export declare const ExprNodeSchema: z.ZodType<ExprNode>;
+/**
+ * Expression kinds enum for pattern matching
+ */
+export declare const ExprKind: z.ZodEnum<{
+    object: "object";
+    map: "map";
+    values: "values";
+    merge: "merge";
+    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";
+    lit: "lit";
+    get: "get";
+    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";
+}>;
+export type ExprKind = z.infer<typeof ExprKind>;

package/dist/schema/field.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+/**
+ * Field type definitions
+ */
+export declare const PrimitiveFieldType: z.ZodEnum<{
+    string: "string";
+    number: "number";
+    boolean: "boolean";
+    object: "object";
+    null: "null";
+    array: "array";
+}>;
+export type PrimitiveFieldType = z.infer<typeof PrimitiveFieldType>;
+export declare const EnumFieldType: z.ZodObject<{
+    enum: z.ZodReadonly<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$strip>;
+export type EnumFieldType = z.infer<typeof EnumFieldType>;
+export 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>]>;
+export type FieldType = z.infer<typeof FieldType>;
+/**
+ * Field specification (recursive for nested objects/arrays)
+ */
+export type FieldSpec = {
+    type: FieldType;
+    required: boolean;
+    default?: unknown;
+    description?: string;
+    fields?: Record<string, FieldSpec>;
+    items?: FieldSpec;
+};
+export declare const FieldSpec: z.ZodType<FieldSpec>;
+/**
+ * State specification - defines the shape of domain state
+ */
+export declare const StateSpec: z.ZodObject<{
+    fields: z.ZodRecord<z.ZodString, z.ZodType<FieldSpec, unknown, z.core.$ZodTypeInternals<FieldSpec, unknown>>>;
+}, z.core.$strip>;
+export type StateSpec = z.infer<typeof StateSpec>;