@autonoma-ai/sdk 0.2.1-canary.aa1079f → 0.2.2

package/dist/{graph-OB0ohy_v.d.ts → graph-Bh_9SEer.d.ts}

@@ -1,21 +1,24 @@
-/** Minimal SQL executor — wrap your DB connection (pg Pool, Prisma, Drizzle, etc.) into this. */
-interface SQLExecutor {
-    /** Execute a SQL query with parameterized values. Returns rows as plain objects. */
-    query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
-    /**
-     * Execute a block within a transaction.
-     * The callback receives an executor scoped to the transaction.
-     * If the callback throws, the transaction is rolled back.
-     */
-    transaction<T>(fn: (tx: SQLExecutor) => Promise<T>): Promise<T>;
-}
+import { ZodTypeAny, z } from 'zod';
+
+/**
+ * Public types for the Autonoma SDK.
+ *
+ * The SDK is now factory-driven: every model the dashboard can create
+ * comes from a registered factory, and each factory carries a Zod input
+ * schema (and optional ref schema). There is no SQL introspection, no
+ * SQL fallback, and no executor on `HandlerConfig`. Factories that need
+ * DB access use whatever client the host already has.
+ */
+
 interface SchemaInfo {
     models: ModelInfo[];
+    /** Always emitted as `[]` in factory-driven mode; kept for wire-shape symmetry. */
     edges: FKEdge[];
+    /** Always emitted as `[]` in factory-driven mode; kept for wire-shape symmetry. */
     relations: SchemaRelation[];
     scopeField: string;
 }
-/** Maps a parent's relation field name to the child model and its FK */
+/** Wire-shape relic — emitted as an empty array in factory-driven mode. */
 interface SchemaRelation {
     parentModel: string;
     childModel: string;
@@ -24,6 +27,7 @@ interface SchemaRelation {
 }
 interface ModelInfo {
     name: string;
+    /** Cosmetic — snake_case of `name`; the dashboard renders it for display only. */
     tableName: string;
     fields: FieldInfo[];
 }
@@ -34,6 +38,7 @@ interface FieldInfo {
     isId: boolean;
     hasDefault: boolean;
 }
+/** Wire-shape relic — emitted as an empty array in factory-driven mode. */
 interface FKEdge {
     from: string;
     to: string;
@@ -41,20 +46,6 @@ interface FKEdge {
     foreignField: string;
     nullable: boolean;
 }
-interface ResolvedEntitySpec {
-    count: number;
-    fields: Record<string, unknown>[];
-    batch?: boolean;
-}
-interface CreateContext {
-    testRunId: string;
-    refs: Record<string, Record<string, unknown>[]>;
-}
-/** Scenario sent inline in the `up` request body */
-interface ScenarioDefinition {
-    /** Nested tree: model name → array of node objects with nested children */
-    create: Record<string, Record<string, unknown>[]>;
-}
 interface SdkInfo {
     language: string;
     orm: string;
@@ -63,42 +54,59 @@ interface SdkInfo {
 interface FactoryContext {
     /** All refs created so far, keyed by model name */
     refs: Record<string, Record<string, unknown>[]>;
-    /** The SQL executor (for factories that need direct DB access) */
-    executor: SQLExecutor;
-    /** The detected or fallback scope value */
+    /** Logical scope value or testRunId fallback (kept for backwards-compat). */
     scenarioName: string;
     /** Unique ID for this test run */
     testRunId: string;
 }
-interface FactoryDefinition {
-    /** Create a single entity. Receives pre-resolved fields (temp IDs already replaced). Must return at least { id }. */
-    create: (data: Record<string, unknown>, ctx: FactoryContext) => Promise<Record<string, unknown>>;
-    /** Optional teardown per record. If omitted, falls back to SQL DELETE. */
-    teardown?: (record: Record<string, unknown>, ctx: FactoryContext) => Promise<void>;
-}
-type FactoryRegistry = Record<string, FactoryDefinition>;
+/**
+ * Factory definition.
+ *
+ * The two type parameters are bound to the Zod schemas you pass in:
+ *   - `TInput extends ZodTypeAny` — the create input. `data` arrives
+ *     already validated and typed as `z.infer<TInput>`, so your factory
+ *     body doesn't need a manual `z.infer<...>` annotation.
+ *   - `TRef extends ZodTypeAny` — the shape your `create` returns and
+ *     `teardown` later receives. When `refSchema` is omitted, `TRef`
+ *     widens to a generic `{ id; ... }` record so old factories keep
+ *     compiling without a refSchema.
+ *
+ * Bind both at the call site by writing `defineFactory({...})` — TS
+ * infers the generics from the schema instances.
+ */
+interface FactoryDefinition<TInput extends ZodTypeAny = ZodTypeAny, TRef extends ZodTypeAny | undefined = undefined> {
+    /**
+     * Create a single entity. Receives the validated input (parsed by
+     * `inputSchema`) and must return at least `{ id }`. When `refSchema`
+     * is set, the return type is constrained to `z.input<TRef>` so the
+     * teardown signature lines up exactly.
+     */
+    create: (data: z.infer<TInput>, ctx: FactoryContext) => Promise<RefRecord<TRef>> | RefRecord<TRef>;
+    /**
+     * Optional teardown per record. Receives whatever `create` returned —
+     * validated through `refSchema` first when one is registered. If
+     * omitted the model is left alone on `down`. There is no SQL fallback.
+     */
+    teardown?: (record: TRef extends ZodTypeAny ? z.infer<TRef> : Record<string, unknown> & {
+        id: string | number;
+    }, ctx: FactoryContext) => Promise<void> | void;
+    /** Required Zod schema for the create input — drives both validation and discover. */
+    inputSchema: TInput;
+    /** Optional Zod schema for the record returned by `create` (validated on teardown). */
+    refSchema?: TRef;
+}
+type RefRecord<TRef extends ZodTypeAny | undefined> = TRef extends ZodTypeAny ? z.input<TRef> : Record<string, unknown> & {
+    id: string | number;
+};
+type FactoryRegistry = Record<string, FactoryDefinition<any, any>>;
 interface HandlerConfig {
-    /** SQL executor wrapping your database connection */
-    executor: SQLExecutor;
     /** Scope field name (camelCase), e.g., 'organizationId' */
     scopeField: string;
-    /** Database dialect. Defaults to 'postgres'. */
-    dialect?: 'postgres' | 'mysql' | 'sqlite';
-    /** DB schema name. Defaults to 'public' for Postgres. */
-    dbSchema?: string;
-    /**
-     * Map scenario model names to DB table names.
-     * Keys are model names (PascalCase), values are DB table names.
-     * If omitted, auto-detected from information_schema with PascalCase inference.
-     */
-    tableNameMap?: Record<string, string>;
-    /** Tables to exclude from introspection. Defaults to ['_prisma_migrations']. */
-    excludeTables?: string[];
     /** Shared secret — known by both you and Autonoma. Used to verify HMAC signatures on incoming requests. */
     sharedSecret: string;
     /** Internal secret — only you know this. Used to sign the refs JWT token. Autonoma never sees it. */
     signingSecret: string;
-    /** Factory definitions per model. If a factory exists for a model, it is used instead of raw SQL INSERT. */
+    /** Factory definitions per model. Required: every model the dashboard sends in `create` must have one. */
     factories?: FactoryRegistry;
     allowProduction?: boolean;
     /**
@@ -118,7 +126,7 @@ interface HandlerConfig {
      * Can modify the auth result before it is returned to the caller.
      */
     afterUp?: (context: HookContext, authResult: AuthResult) => Promise<AuthResult> | AuthResult;
-    /** SDK identity metadata. Server and ORM adapters populate this. */
+    /** SDK identity metadata. Server adapters populate this. */
     sdk?: Partial<SdkInfo>;
 }
 interface AuthContext {
@@ -185,4 +193,4 @@ declare function topoSort(nodes: string[], edges: FKEdge[]): TopoSortResult;
  */
 declare function findDeferrableEdge(cycle: string[], edges: FKEdge[]): FKEdge | null;
 
-export { type AuthContext as A, type CreateContext as C, type DiscoverResponse as D, type FactoryDefinition as F, type HandlerConfig as H, type ModelInfo as M, type ResolvedEntitySpec as R, type SchemaInfo as S, type TopoSortResult as T, type UpResponse as U, type HandlerRequest as a, type HandlerResponse as b, type SQLExecutor as c, type ScenarioDefinition as d, type AuthCookie as e, type AuthResult as f, type DownResponse as g, type FKEdge as h, type FactoryContext as i, type FactoryRegistry as j, type FieldInfo as k, type HookContext as l, type SchemaRelation as m, type SdkInfo as n, findDeferrableEdge as o, topoSort as t };
+export { type AuthContext as A, type DiscoverResponse as D, type FactoryRegistry as F, type HandlerConfig as H, type ModelInfo as M, type SchemaInfo as S, type TopoSortResult as T, type UpResponse as U, type HandlerRequest as a, type HandlerResponse as b, type FactoryDefinition as c, type AuthCookie as d, type AuthResult as e, type DownResponse as f, type FKEdge as g, type FactoryContext as h, type FieldInfo as i, type HookContext as j, type SchemaRelation as k, type SdkInfo as l, findDeferrableEdge as m, topoSort as t };

package/dist/graph.d.ts

@@ -1 +1,2 @@
-export { h as FKEdge, T as TopoSortResult, o as findDeferrableEdge, t as topoSort } from './graph-OB0ohy_v.js';
+export { g as FKEdge, T as TopoSortResult, m as findDeferrableEdge, t as topoSort } from './graph-Bh_9SEer.js';
+import 'zod';

package/dist/index.d.ts

@@ -1,6 +1,25 @@
-import { H as HandlerConfig, a as HandlerRequest, b as HandlerResponse, S as SchemaInfo, c as SQLExecutor, d as ScenarioDefinition, R as ResolvedEntitySpec, C as CreateContext, M as ModelInfo, F as FactoryDefinition } from './graph-OB0ohy_v.js';
-export { A as AuthContext, e as AuthCookie, f as AuthResult, D as DiscoverResponse, g as DownResponse, h as FKEdge, i as FactoryContext, j as FactoryRegistry, k as FieldInfo, l as HookContext, m as SchemaRelation, n as SdkInfo, U as UpResponse, o as findDeferrableEdge, t as topoSort } from './graph-OB0ohy_v.js';
+import { H as HandlerConfig, a as HandlerRequest, b as HandlerResponse, F as FactoryRegistry, S as SchemaInfo, c as FactoryDefinition } from './graph-Bh_9SEer.js';
+export { A as AuthContext, d as AuthCookie, e as AuthResult, D as DiscoverResponse, f as DownResponse, g as FKEdge, h as FactoryContext, i as FieldInfo, j as HookContext, M as ModelInfo, k as SchemaRelation, l as SdkInfo, U as UpResponse, m as findDeferrableEdge, t as topoSort } from './graph-Bh_9SEer.js';
+import { ZodTypeAny } from 'zod';
 
+/**
+ * Request routing for discover / up / down protocol actions.
+ *
+ * Factory-driven design: every model in `body.create` must have a
+ * registered factory. The SDK uses each factory's `inputSchema` (Zod)
+ * to validate inputs and to build the `discover` schema. Ordering for
+ * `up` and `down` comes from the create payload's `_alias` / `_ref`
+ * graph (see `payload-topo.ts`); there is no SQL introspection.
+ */
+
+/**
+ * Substitute built-in tokens in field values: {{testRunId}}, {{index}},
+ * {{cycle(a,b,c)}}. Defense-in-depth: the test runner should substitute
+ * recipe variables before calling /up, but if a literal {{…}} slips
+ * through we fail loudly with UNRESOLVED_TOKEN rather than INSERT the
+ * raw string.
+ */
+declare function resolveTokens(value: unknown, testRunId: string, index: number): unknown;
 declare const PROTOCOL_VERSION: string;
 declare function handleRequest(config: HandlerConfig, req: HandlerRequest): Promise<HandlerResponse>;
 
@@ -11,6 +30,13 @@ interface RefsPayload {
     refs: Record<string, Record<string, unknown>[]>;
     testRunId: string;
     environment: string;
+    /**
+     * Captured at `up` time so `down` can topo-sort teardown without
+     * re-parsing the create payload. Optional — older tokens omitted it
+     * and `down` falls back to refs-key insertion order.
+     */
+    aliasDependencies?: Record<string, string[]>;
+    aliasOwnerModel?: Record<string, string>;
 }
 /**
  * Sign refs into a JWT-like token (header.payload.signature).
@@ -28,50 +54,84 @@ declare function verifyRefs(token: string, secret: string): RefsPayload;
  */
 declare function fingerprint(value: unknown): string;
 
-/** A create operation produced by the tree resolver */
 interface CreateOp {
     model: string;
     fields: Record<string, unknown>;
     tempId: string;
-    batch: boolean;
 }
-/**
- * A deferred FK update — emitted when a _ref points to a node that hasn't
- * been created yet (circular dependency). Resolved after all creates.
- */
-interface DeferredUpdate {
-    /** Temp ID of the record that needs to be updated */
-    targetTempId: string;
-    /** Model name of the record to update */
-    model: string;
-    /** Field on the record that holds the deferred FK */
-    field: string;
-    /** Alias that will resolve to the FK value once created */
-    refAlias: string;
-}
-/** Result of resolving a tree scenario */
 interface ResolvedTree {
     ops: CreateOp[];
-    deferredUpdates: DeferredUpdate[];
-    aliases: Map<string, string>;
-}
-/** A resolved reference to another node's id */
-interface RefNode {
-    _ref: string;
+    /** alias → temp id assigned to the entity declaring that alias. */
+    aliases: Record<string, string>;
+    /** alias → model name, used by teardown to pick the right factory. */
+    aliasOwnerModel: Record<string, string>;
+    /** alias → list of aliases the owner depends on (may include unknowns). */
+    aliasDependencies: Record<string, string[]>;
 }
 /**
- * Resolve a nested scenario tree into an ordered list of create operations.
+ * Topo-sort a create payload into an ordered list of `CreateOp`.
+ *
+ * `create` is the dashboard's nested map `{ model: [entity, ...] }`.
+ * Each entity is an object; `_alias` (declared by dependency targets)
+ * and `_ref` (declared by dependents, anywhere in the field tree) are
+ * the only reserved keys.
+ *
+ * Throws INVALID_BODY if the payload references an alias that is never
+ * declared, or if the alias graph contains a cycle.
+ */
+declare function resolvePayloadTree(create: Record<string, unknown>): ResolvedTree;
+/**
+ * Order models for teardown.
+ *
+ * With `aliasDependencies` available (newer refs tokens carry it), we
+ * run the same Kahn's topo sort over models — derived from aggregating
+ * each alias's dependencies — and return the *reverse* topo so children
+ * are torn down before parents.
+ *
+ * Without it (older refs tokens), fall back to reversing the insertion
+ * order of `refs` keys, which is what the SDK always did for factory
+ * teardown.
+ */
+declare function computeTeardownOrder(refs: Record<string, unknown[]>, aliasDependencies?: Record<string, string[]>, aliasOwnerModel?: Record<string, string>): string[];
+
+/**
+ * Build the SDK's wire-shape schema from registered factories.
+ *
+ * The dashboard's `discover` response carries a `schema` block listing
+ * every model the host can create. With the old SDK that came from
+ * `information_schema` queries; with this one it comes from each
+ * factory's `inputSchema` (a Zod schema).
+ *
+ * The mapping from a Zod type to the dashboard's coarse type string is
+ * intentionally lossy — the dashboard only branches on a handful of
+ * categories (`string`, `integer`, `boolean`, `timestamp`, ...) and
+ * treats everything else as opaque JSON.
+ */
+
+/**
+ * Map a Zod schema to the SDK's coarse type string.
+ *
+ * Unknown schemas fall back to `string` — the conservative default the
+ * dashboard renders as a free-form text input.
+ */
+declare function fieldTypeFromZod(schema: ZodTypeAny): string;
+/**
+ * Build the SDK's discover-time schema from registered factories.
  *
- * Walks depth-first. Parent-child FKs are wired automatically.
- * Handles both directions:
- *   - FK on child (Application.organizationId → Organization): set child FK to parent ID
- *   - FK on parent (Member.userId → User): create child first, set parent FK to child ID
+ * `edges` and `relations` are emitted as empty arrays. They were
+ * populated from FK introspection in the old design; here the create
+ * payload's `_alias` / `_ref` graph carries equivalent information at
+ * request time, so the static schema doesn't need them.
+ */
+declare function buildSchemaFromFactories(factories: FactoryRegistry, scopeField: string): SchemaInfo;
+/**
+ * Serialise a `SchemaInfo` to the JSON shape the dashboard expects.
  *
- * Circular FK cycles (e.g. Application.mainBranchId ↔ Branch.applicationId) are handled
- * transparently: the nullable FK is omitted on the first create and emitted as a
- * DeferredUpdate to be applied via UPDATE after all records exist.
+ * Field names in the wire JSON are camelCase (`isRequired`, not
+ * `is_required`); kept here so both halves of the discover response
+ * live in one place.
  */
-declare function resolveTree(create: Record<string, Record<string, unknown>[]>, schema: SchemaInfo): ResolvedTree;
+declare function schemaToWire(schema: SchemaInfo): Record<string, unknown>;
 
 interface CheckResult {
     valid: boolean;
@@ -87,117 +147,48 @@ interface CheckError {
     message: string;
     fix?: string;
 }
+interface CheckScenario {
+    /** Flat map: model name → list of entity payloads (with `_alias` / `_ref`). */
+    create: Record<string, Record<string, unknown>[]>;
+}
 /**
- * Dry-run a scenario against a real database.
- * Runs the full up → down cycle and returns structured errors.
+ * Dry-run a scenario through the same handler the dashboard hits. Runs
+ * `up` then `down` and returns structured errors if either fails.
  */
-declare function checkScenario(executor: SQLExecutor, scenario: ScenarioDefinition, options?: {
-    scopeField: string;
-    dialect?: HandlerConfig['dialect'];
-    dbSchema?: string;
-    tableNameMap?: Record<string, string>;
+declare function checkScenario(factories: FactoryRegistry, scenario: CheckScenario, options?: {
+    scopeField?: string;
     sharedSecret?: string;
     signingSecret?: string;
     auth?: HandlerConfig['auth'];
 }): Promise<CheckResult>;
-/**
- * Check multiple scenarios sequentially.
- */
-declare function checkAllScenarios(executor: SQLExecutor, scenarios: ScenarioDefinition[], options?: {
-    scopeField: string;
-    dialect?: HandlerConfig['dialect'];
-    dbSchema?: string;
-    tableNameMap?: Record<string, string>;
-    sharedSecret?: string;
-    signingSecret?: string;
-    auth?: HandlerConfig['auth'];
-}): Promise<CheckResult[]>;
-
-/** Database dialect abstraction — generates dialect-specific SQL strings. */
-interface Dialect {
-    readonly name: 'postgres' | 'mysql' | 'sqlite';
-    /** Parameter placeholder for index (1-based). Postgres: $1, MySQL/SQLite: ? */
-    param(index: number): string;
-    /** Quote an identifier. Postgres: "name", MySQL: `name` */
-    quoteId(name: string): string;
-    /** Whether INSERT ... RETURNING is supported */
-    readonly supportsReturning: boolean;
-    /** SQL to list all base tables in a schema/database */
-    tablesSQL(schema: string): string;
-    /** SQL to list all columns for all tables in a schema/database */
-    columnsSQL(schema: string): string;
-    /** SQL to list primary key columns */
-    primaryKeysSQL(schema: string): string;
-    /** SQL to list foreign key relationships */
-    foreignKeysSQL(schema: string): string;
-    /** SQL to list enum types and their values */
-    enumsSQL(schema: string): string;
-}
-declare function getDialect(name?: 'postgres' | 'mysql' | 'sqlite'): Dialect;
-
-/** Internal result including name mapping tables */
-interface IntrospectionResult {
-    schema: SchemaInfo;
-    /** model name → DB table name */
-    tableMap: Map<string, string>;
-    /** model name → (field name → DB column name) */
-    columnMaps: Map<string, Map<string, string>>;
-    /** model name → (field name → Postgres enum type name). Only populated for Postgres. */
-    enumTypeMaps: Map<string, Map<string, string>>;
-}
-/**
- * Introspect a database via information_schema to build SchemaInfo.
- *
- * Auto-maps DB names (snake_case) to model names (PascalCase) and
- * field names (camelCase). Override with `tableNameMap`.
- */
-declare function introspectDatabase(executor: SQLExecutor, dialect: Dialect, config: {
-    scopeField: string;
-    schema?: string;
-    tableNameMap?: Record<string, string>;
-    excludeTables?: string[];
-}): Promise<IntrospectionResult>;
+declare function checkAllScenarios(factories: FactoryRegistry, scenarios: CheckScenario[], options?: Parameters<typeof checkScenario>[2]): Promise<CheckResult[]>;
 
 /**
- * Create entities via raw SQL INSERT.
+ * Define a factory for creating entities via user code.
  *
- * Entities arrive pre-sorted by FK order (handler does topo-sort via tree.ts).
- * Each model in `spec` is inserted sequentially; within a model, batch mode
- * uses a single multi-row INSERT while normal mode inserts one row at a time.
+ * Every factory must declare an `inputSchema` (Zod) so the SDK can:
+ *   1. validate the create payload before invoking `create`, and
+ *   2. derive the `discover` schema from the Zod shape (no DB introspection).
  *
- * For dialects with RETURNING (Postgres): INSERT ... RETURNING *
- * For dialects without (MySQL): INSERT then SELECT via LAST_INSERT_ID()
+ * The generics are inferred from the schemas you pass in: `create`'s
+ * `data` argument is typed as `z.infer<typeof inputSchema>`, and
+ * `teardown`'s `record` argument is typed as `z.infer<typeof refSchema>`
+ * when one is set. No call-site `z.infer<...>` annotations needed.
  */
-declare function createEntities(executor: SQLExecutor, dialect: Dialect, tableMap: Map<string, string>, columnMaps: Map<string, Map<string, string>>, spec: Record<string, ResolvedEntitySpec>, _context: CreateContext, enumTypeMaps?: Map<string, Map<string, string>>, schemaModels?: ModelInfo[]): Promise<Record<string, Record<string, unknown>[]>>;
+declare function defineFactory<TInput extends ZodTypeAny, TRef extends ZodTypeAny | undefined = undefined>(definition: FactoryDefinition<TInput, TRef>): FactoryDefinition<TInput, TRef>;
 
-/**
- * Tear down all data scoped to a value, in reverse topological order.
- *
- * Strategy:
- *   1. Find the scope root model (e.g. Organization) from FK edges
- *   2. Any model with a FK pointing to the scope root is "scoped"
- *   3. Delete scoped models by their FK = scopeValue
- *   4. Delete non-scoped models by their record IDs from refs
- *   5. Delete the scope root entity last by id = scopeValue
- */
-/**
- * Compute the teardown order for models (reverse topological order).
- * Returns an array of model names in the order they should be deleted,
- * plus the scope root model name (deleted last) and cycle info for FK nullification.
- */
-declare function computeTeardownOrder(schema: SchemaInfo): {
-    order: string[];
-    scopeRootModel: string | null;
-    cycles: string[][];
-    scopeFieldByModel: Map<string, string>;
+declare class AutonomaError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(message: string, code: string, status: number);
+}
+declare const Errors: {
+    readonly unknownAction: (action: string) => AutonomaError;
+    readonly unknownEnvironment: (name: string) => AutonomaError;
+    readonly invalidSignature: () => AutonomaError;
+    readonly invalidRefsToken: (reason: string) => AutonomaError;
+    readonly productionBlocked: (detail?: string) => AutonomaError;
+    readonly invalidBody: (reason: string) => AutonomaError;
 };
-declare function teardown(executor: SQLExecutor, dialect: Dialect, tableMap: Map<string, string>, columnMaps: Map<string, Map<string, string>>, schema: SchemaInfo, scopeValue: string, refs?: Record<string, Record<string, unknown>[]>, skipModels?: Set<string>): Promise<void>;
-
-/**
- * Define a factory for creating entities via user code instead of raw SQL.
- * The factory's `create` function receives pre-resolved fields (temp IDs replaced with real IDs)
- * and must return at least the primary key field.
- */
-declare function defineFactory(definition: FactoryDefinition): FactoryDefinition;
 
-export { type CheckError, type CheckResult, CreateContext, type CreateOp, type Dialect, FactoryDefinition, HandlerConfig, HandlerRequest, HandlerResponse, type IntrospectionResult, ModelInfo, PROTOCOL_VERSION, type RefNode, ResolvedEntitySpec, type ResolvedTree, SQLExecutor, ScenarioDefinition, SchemaInfo, checkAllScenarios, checkScenario, computeTeardownOrder, createEntities, defineFactory, fingerprint, getDialect, handleRequest, introspectDatabase, resolveTree, signBody, signRefs, teardown, verifyRefs, verifySignature };
+export { AutonomaError, type CheckError, type CheckResult, type CheckScenario, type CreateOp, Errors, FactoryDefinition, FactoryRegistry, HandlerConfig, HandlerRequest, HandlerResponse, PROTOCOL_VERSION, type RefsPayload, type ResolvedTree, SchemaInfo, buildSchemaFromFactories, checkAllScenarios, checkScenario, computeTeardownOrder, defineFactory, fieldTypeFromZod, fingerprint, handleRequest, resolvePayloadTree, resolveTokens, schemaToWire, signBody, signRefs, verifyRefs, verifySignature };