@sequenceholdings/orm 2.1.0 → 2.2.0

package/dist/canonical.d.ts

@@ -1,4 +1,298 @@
 import { z } from 'zod';
+import { b as CellPart } from './constants-C6EG6Wq7.js';
+export { P as PolicyExpression, p as policyExpressionSchema, a as policyVariantSchema } from './policy-1iZbGnZZ.js';
+
+/** Authored intent only. Operation compilation validates reach; it never adds declarations. */
+declare const ontologyContractSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    read: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    write: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    produce: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    invoke: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+type OntologyContract = z.infer<typeof ontologyContractSchema>;
+/** Missing is legacy; present-but-invalid fails closed, including null. */
+declare function readOntologyContract(manifest: unknown): OntologyContract | undefined;
+
+/**
+ * Canonical contract for resolved tables: one logical table (a generated
+ * managed view) backed by N source tables of three kinds —
+ *
+ *  - `manual`   an internal ORM table holding sparse user edits (the only
+ *               GraphQL mutation target),
+ *  - `etl`      a synced (`source: schema.table`) table fed by a pipeline,
+ *  - `prefetch` an internal ORM "live" table filled by a function that reads
+ *               the source system on demand (and confirms writebacks).
+ *
+ * Each column picks its value across candidate sources with a SQL comparator
+ * compiled into the view, so policies, filters, sorting and nested relations
+ * all see resolved values. This module owns the metadata the compiler (write
+ * roots, directives) and data plane (prefetch, writeback) need; the view SQL
+ * itself is generated at authoring time and validated like any managed view.
+ */
+
+/** `'1500ms'` / `'30s'` / `'5m'` (or a millisecond number) → milliseconds; undefined when malformed. */
+declare function parseDurationMs(input: number | string): number | undefined;
+/**
+ * Row-level system columns the generated view adds after the authored columns
+ * (GraphQL fields). Per-cell provenance lives in typed cell parts instead —
+ * see RESOLVED_VIEW_CELL_PARTS.
+ */
+declare const RESOLVED_VIEW_SYSTEM_COLUMNS: {
+    readonly writebackStatus: {
+        readonly name: "writebackStatus";
+        readonly columnName: "_writeback_status";
+        readonly type: "text";
+    };
+    readonly writebackError: {
+        readonly name: "writebackError";
+        readonly columnName: "_writeback_error";
+        readonly type: "text";
+    };
+};
+/** System columns on the internal manual / live tables (never exposed in GraphQL). */
+declare const RESOLVED_SOURCE_SYSTEM_COLUMNS: {
+    readonly tombstoned: {
+        readonly name: "sysTombstoned";
+        readonly columnName: "_tombstoned";
+    };
+    readonly fetchedAt: {
+        readonly name: "sysFetchedAt";
+        readonly columnName: "_fetched_at";
+    };
+    readonly writebackStatus: {
+        readonly name: "sysWritebackStatus";
+        readonly columnName: "_writeback_status";
+    };
+    readonly writebackError: {
+        readonly name: "sysWritebackError";
+        readonly columnName: "_writeback_error";
+    };
+    readonly writebackAt: {
+        readonly name: "sysWritebackAt";
+        readonly columnName: "_writeback_at";
+    };
+};
+/** Cell parts the resolved view exposes per resolved column: the winner's source, time, actor, and newer losers. */
+declare const RESOLVED_VIEW_CELL_PARTS: readonly ["source", "at", "by", "conflicts"];
+/** Cell parts on a resolved table's internal sources; only the manual source carries `rev`. */
+declare const RESOLVED_SOURCE_CELL_PARTS: {
+    readonly manual: readonly ["at", "by", "rev"];
+    readonly prefetch: readonly ["at", "by"];
+};
+declare const RESERVED_RESOLVED_COLUMN_NAMES: ReadonlySet<string>;
+declare const COMPARATORS: readonly ["latest", "highest", "lowest", "priority", "nonNullFirst", "custom"];
+type ComparatorKind = (typeof COMPARATORS)[number];
+declare const canonicalFunctionRefSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        managed: "managed";
+        native: "native";
+    }>;
+    id: z.ZodString;
+}, z.core.$strict>;
+type CanonicalFunctionRef = z.infer<typeof canonicalFunctionRefSchema>;
+/** What the source API can fetch: one key per call, or a batch of up to maxKeys. */
+declare const canonicalFetchShapeSchema: z.ZodUnion<readonly [z.ZodObject<{
+    shape: z.ZodLiteral<"single">;
+}, z.core.$strict>, z.ZodObject<{
+    shape: z.ZodLiteral<"batch">;
+    maxKeys: z.ZodNumber;
+}, z.core.$strict>]>;
+type CanonicalFetchShape = z.infer<typeof canonicalFetchShapeSchema>;
+declare const canonicalResolvedSourceSchema: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        manual: "manual";
+        prefetch: "prefetch";
+        etl: "etl";
+    }>;
+    table: z.ZodString;
+    columns: z.ZodArray<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    fetch: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        shape: z.ZodLiteral<"single">;
+    }, z.core.$strict>, z.ZodObject<{
+        shape: z.ZodLiteral<"batch">;
+        maxKeys: z.ZodNumber;
+    }, z.core.$strict>]>>;
+    function: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            managed: "managed";
+            native: "native";
+        }>;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    prefetchDefaults: z.ZodOptional<z.ZodObject<{
+        maxStalenessMs: z.ZodNumber;
+        timeoutMs: z.ZodNumber;
+        onError: z.ZodEnum<{
+            fallback: "fallback";
+            fail: "fail";
+        }>;
+    }, z.core.$strict>>;
+    writeback: z.ZodOptional<z.ZodObject<{
+        columns: z.ZodArray<z.ZodString>;
+        defaultMode: z.ZodEnum<{
+            sync: "sync";
+            async: "async";
+        }>;
+        timeoutMs: z.ZodNumber;
+        clearManualOnConfirm: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type CanonicalResolvedSource = z.infer<typeof canonicalResolvedSourceSchema>;
+declare const canonicalResolveRuleSchema: z.ZodObject<{
+    column: z.ZodString;
+    comparator: z.ZodEnum<{
+        custom: "custom";
+        latest: "latest";
+        highest: "highest";
+        lowest: "lowest";
+        priority: "priority";
+        nonNullFirst: "nonNullFirst";
+    }>;
+    candidates: z.ZodArray<z.ZodString>;
+    orderBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type CanonicalResolveRule = z.infer<typeof canonicalResolveRuleSchema>;
+declare const canonicalResolvedSchema: z.ZodObject<{
+    sources: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            manual: "manual";
+            prefetch: "prefetch";
+            etl: "etl";
+        }>;
+        table: z.ZodString;
+        columns: z.ZodArray<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+        fetch: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+            shape: z.ZodLiteral<"single">;
+        }, z.core.$strict>, z.ZodObject<{
+            shape: z.ZodLiteral<"batch">;
+            maxKeys: z.ZodNumber;
+        }, z.core.$strict>]>>;
+        function: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                managed: "managed";
+                native: "native";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>>;
+        prefetchDefaults: z.ZodOptional<z.ZodObject<{
+            maxStalenessMs: z.ZodNumber;
+            timeoutMs: z.ZodNumber;
+            onError: z.ZodEnum<{
+                fallback: "fallback";
+                fail: "fail";
+            }>;
+        }, z.core.$strict>>;
+        writeback: z.ZodOptional<z.ZodObject<{
+            columns: z.ZodArray<z.ZodString>;
+            defaultMode: z.ZodEnum<{
+                sync: "sync";
+                async: "async";
+            }>;
+            timeoutMs: z.ZodNumber;
+            clearManualOnConfirm: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    resolve: z.ZodArray<z.ZodObject<{
+        column: z.ZodString;
+        comparator: z.ZodEnum<{
+            custom: "custom";
+            latest: "latest";
+            highest: "highest";
+            lowest: "lowest";
+            priority: "priority";
+            nonNullFirst: "nonNullFirst";
+        }>;
+        candidates: z.ZodArray<z.ZodString>;
+        orderBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    deletedBy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    materialized: z.ZodOptional<z.ZodObject<{
+        table: z.ZodString;
+        compute: z.ZodString;
+    }, z.core.$strict>>;
+    policies: z.ZodDefault<z.ZodObject<{
+        write: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            default: z.ZodString;
+            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                when: z.ZodString;
+                allow: z.ZodOptional<z.ZodLiteral<true>>;
+                policy: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>]>>;
+        insert: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            default: z.ZodString;
+            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                when: z.ZodString;
+                allow: z.ZodOptional<z.ZodLiteral<true>>;
+                policy: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>]>>;
+        update: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            default: z.ZodString;
+            variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                when: z.ZodString;
+                allow: z.ZodOptional<z.ZodLiteral<true>>;
+                policy: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type CanonicalResolved = z.infer<typeof canonicalResolvedSchema>;
+interface RelationShape {
+    table: string;
+    source?: string;
+    internal?: true;
+    cellMetadata?: true;
+    materializes?: string;
+    policies?: {
+        read?: string | {
+            default: string;
+            variants: unknown[];
+        };
+    };
+    primaryKey?: string[];
+    columns: Array<{
+        name: string;
+        columnName: string;
+        type: unknown;
+        cell?: {
+            of: string;
+            part: CellPart;
+        };
+    }>;
+}
+interface ViewShape {
+    view: string;
+    internal?: true;
+    primaryKey?: string[];
+    columns: Array<{
+        name: string;
+        columnName: string;
+        type: unknown;
+        nullable?: boolean;
+        cell?: {
+            of: string;
+            part: CellPart;
+        };
+    }>;
+    resolved?: CanonicalResolved;
+}
+/**
+ * Cross-relation validation for one resolved view. Returns messages rather
+ * than throwing so the definition-level superRefine can attach paths.
+ */
+declare function validateResolvedView({ view, tables, views }: {
+    view: ViewShape;
+    tables: readonly RelationShape[];
+    views?: readonly ViewShape[];
+}): string[];
 
 /**
  * Canonical namespace definition v2 — the data-only JSON a consumer's
@@ -30,14 +324,14 @@ declare const canonicalColumnSchema: z.ZodObject<{
     type: z.ZodUnion<readonly [z.ZodEnum<{
         bigint: "bigint";
         boolean: "boolean";
-        uuid: "uuid";
+        date: "date";
         text: "text";
+        timestamptz: "timestamptz";
+        jsonb: "jsonb";
+        uuid: "uuid";
         integer: "integer";
         numeric: "numeric";
         double: "double";
-        timestamptz: "timestamptz";
-        date: "date";
-        jsonb: "jsonb";
     }>, z.ZodObject<{
         enum: z.ZodString;
     }, z.core.$strip>]>;
@@ -55,6 +349,16 @@ declare const canonicalColumnSchema: z.ZodObject<{
     renamedFrom: z.ZodOptional<z.ZodString>;
     cast: z.ZodOptional<z.ZodString>;
     deprecated: z.ZodDefault<z.ZodBoolean>;
+    cell: z.ZodOptional<z.ZodObject<{
+        of: z.ZodString;
+        part: z.ZodEnum<{
+            at: "at";
+            by: "by";
+            rev: "rev";
+            source: "source";
+            conflicts: "conflicts";
+        }>;
+    }, z.core.$strict>>;
 }, z.core.$strip>;
 type CanonicalColumn = z.infer<typeof canonicalColumnSchema>;
 declare const canonicalLinkSchema: z.ZodObject<{
@@ -65,9 +369,24 @@ declare const canonicalLinkSchema: z.ZodObject<{
         toPlatformUser: "toPlatformUser";
     }>;
     target: z.ZodOptional<z.ZodString>;
+    namespace: z.ZodOptional<z.ZodString>;
     on: z.ZodString;
     references: z.ZodOptional<z.ZodString>;
     enforce: z.ZodDefault<z.ZodBoolean>;
+    onDelete: z.ZodOptional<z.ZodEnum<{
+        cascade: "cascade";
+        restrict: "restrict";
+        "no action": "no action";
+        "set null": "set null";
+        "set default": "set default";
+    }>>;
+    onUpdate: z.ZodOptional<z.ZodEnum<{
+        cascade: "cascade";
+        restrict: "restrict";
+        "no action": "no action";
+        "set null": "set null";
+        "set default": "set default";
+    }>>;
     description: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type CanonicalLink = z.infer<typeof canonicalLinkSchema>;
@@ -76,25 +395,12 @@ declare const canonicalIndexSchema: z.ZodObject<{
     unique: z.ZodDefault<z.ZodBoolean>;
     name: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-/**
- * Policy expressions stay DSL SOURCE STRINGS in the canonical form — parsing
- * and claim-key validation happen in both CLI and server via the shared
- * predicate parser. Variants follow §4c permissive-union semantics.
- */
-declare const policyVariantSchema: z.ZodObject<{
-    when: z.ZodString;
-    allow: z.ZodOptional<z.ZodLiteral<true>>;
-    policy: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-declare const policyExpressionSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    default: z.ZodString;
-    variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        when: z.ZodString;
-        allow: z.ZodOptional<z.ZodLiteral<true>>;
-        policy: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>]>;
-type PolicyExpression = z.infer<typeof policyExpressionSchema>;
+declare const canonicalCheckSchema: z.ZodObject<{
+    name: z.ZodString;
+    expression: z.ZodString;
+}, z.core.$strict>;
+type CanonicalCheck = z.infer<typeof canonicalCheckSchema>;
+
 declare const canonicalPoliciesSchema: z.ZodObject<{
     read: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         default: z.ZodString;
@@ -153,14 +459,14 @@ declare const canonicalActionSchema: z.ZodObject<{
         type: z.ZodEnum<{
             bigint: "bigint";
             boolean: "boolean";
-            uuid: "uuid";
+            date: "date";
             text: "text";
+            timestamptz: "timestamptz";
+            jsonb: "jsonb";
+            uuid: "uuid";
             integer: "integer";
             numeric: "numeric";
             double: "double";
-            timestamptz: "timestamptz";
-            date: "date";
-            jsonb: "jsonb";
         }>;
         nullable: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>>;
@@ -205,10 +511,25 @@ declare const canonicalForeignKeySchema: z.ZodObject<{
         "initially-immediate": "initially-immediate";
         "initially-deferred": "initially-deferred";
     }>>;
+    onDelete: z.ZodOptional<z.ZodEnum<{
+        cascade: "cascade";
+        restrict: "restrict";
+        "no action": "no action";
+        "set null": "set null";
+        "set default": "set default";
+    }>>;
+    onUpdate: z.ZodOptional<z.ZodEnum<{
+        cascade: "cascade";
+        restrict: "restrict";
+        "no action": "no action";
+        "set null": "set null";
+        "set default": "set default";
+    }>>;
 }, z.core.$strict>;
 type CanonicalForeignKey = z.infer<typeof canonicalForeignKeySchema>;
 declare const canonicalTableSchema: z.ZodObject<{
     table: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     renamedFrom: z.ZodOptional<z.ZodString>;
     source: z.ZodOptional<z.ZodString>;
@@ -218,14 +539,14 @@ declare const canonicalTableSchema: z.ZodObject<{
         type: z.ZodUnion<readonly [z.ZodEnum<{
             bigint: "bigint";
             boolean: "boolean";
-            uuid: "uuid";
+            date: "date";
             text: "text";
+            timestamptz: "timestamptz";
+            jsonb: "jsonb";
+            uuid: "uuid";
             integer: "integer";
             numeric: "numeric";
             double: "double";
-            timestamptz: "timestamptz";
-            date: "date";
-            jsonb: "jsonb";
         }>, z.ZodObject<{
             enum: z.ZodString;
         }, z.core.$strip>]>;
@@ -243,6 +564,16 @@ declare const canonicalTableSchema: z.ZodObject<{
         renamedFrom: z.ZodOptional<z.ZodString>;
         cast: z.ZodOptional<z.ZodString>;
         deprecated: z.ZodDefault<z.ZodBoolean>;
+        cell: z.ZodOptional<z.ZodObject<{
+            of: z.ZodString;
+            part: z.ZodEnum<{
+                at: "at";
+                by: "by";
+                rev: "rev";
+                source: "source";
+                conflicts: "conflicts";
+            }>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>>;
     primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
     links: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -253,9 +584,24 @@ declare const canonicalTableSchema: z.ZodObject<{
             toPlatformUser: "toPlatformUser";
         }>;
         target: z.ZodOptional<z.ZodString>;
+        namespace: z.ZodOptional<z.ZodString>;
         on: z.ZodString;
         references: z.ZodOptional<z.ZodString>;
         enforce: z.ZodDefault<z.ZodBoolean>;
+        onDelete: z.ZodOptional<z.ZodEnum<{
+            cascade: "cascade";
+            restrict: "restrict";
+            "no action": "no action";
+            "set null": "set null";
+            "set default": "set default";
+        }>>;
+        onUpdate: z.ZodOptional<z.ZodEnum<{
+            cascade: "cascade";
+            restrict: "restrict";
+            "no action": "no action";
+            "set null": "set null";
+            "set default": "set default";
+        }>>;
         description: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     indexes: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -263,6 +609,10 @@ declare const canonicalTableSchema: z.ZodObject<{
         unique: z.ZodDefault<z.ZodBoolean>;
         name: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
+    checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        expression: z.ZodString;
+    }, z.core.$strict>>>;
     policies: z.ZodDefault<z.ZodObject<{
         read: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             default: z.ZodString;
@@ -304,14 +654,14 @@ declare const canonicalTableSchema: z.ZodObject<{
             type: z.ZodEnum<{
                 bigint: "bigint";
                 boolean: "boolean";
-                uuid: "uuid";
+                date: "date";
                 text: "text";
+                timestamptz: "timestamptz";
+                jsonb: "jsonb";
+                uuid: "uuid";
                 integer: "integer";
                 numeric: "numeric";
                 double: "double";
-                timestamptz: "timestamptz";
-                date: "date";
-                jsonb: "jsonb";
             }>;
             nullable: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strip>>>;
@@ -346,7 +696,24 @@ declare const canonicalTableSchema: z.ZodObject<{
             "initially-immediate": "initially-immediate";
             "initially-deferred": "initially-deferred";
         }>>;
+        onDelete: z.ZodOptional<z.ZodEnum<{
+            cascade: "cascade";
+            restrict: "restrict";
+            "no action": "no action";
+            "set null": "set null";
+            "set default": "set default";
+        }>>;
+        onUpdate: z.ZodOptional<z.ZodEnum<{
+            cascade: "cascade";
+            restrict: "restrict";
+            "no action": "no action";
+            "set null": "set null";
+            "set default": "set default";
+        }>>;
     }, z.core.$strict>>>;
+    cellMetadata: z.ZodOptional<z.ZodLiteral<true>>;
+    internal: z.ZodOptional<z.ZodLiteral<true>>;
+    materializes: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type CanonicalTable = z.infer<typeof canonicalTableSchema>;
 declare const canonicalViewSchema: z.ZodObject<{
@@ -358,14 +725,14 @@ declare const canonicalViewSchema: z.ZodObject<{
         type: z.ZodUnion<readonly [z.ZodEnum<{
             bigint: "bigint";
             boolean: "boolean";
-            uuid: "uuid";
+            date: "date";
             text: "text";
+            timestamptz: "timestamptz";
+            jsonb: "jsonb";
+            uuid: "uuid";
             integer: "integer";
             numeric: "numeric";
             double: "double";
-            timestamptz: "timestamptz";
-            date: "date";
-            jsonb: "jsonb";
         }>, z.ZodObject<{
             enum: z.ZodString;
         }, z.core.$strip>]>;
@@ -383,6 +750,16 @@ declare const canonicalViewSchema: z.ZodObject<{
         renamedFrom: z.ZodOptional<z.ZodString>;
         cast: z.ZodOptional<z.ZodString>;
         deprecated: z.ZodDefault<z.ZodBoolean>;
+        cell: z.ZodOptional<z.ZodObject<{
+            of: z.ZodString;
+            part: z.ZodEnum<{
+                at: "at";
+                by: "by";
+                rev: "rev";
+                source: "source";
+                conflicts: "conflicts";
+            }>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
     links: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -393,9 +770,24 @@ declare const canonicalViewSchema: z.ZodObject<{
             toPlatformUser: "toPlatformUser";
         }>;
         target: z.ZodOptional<z.ZodString>;
+        namespace: z.ZodOptional<z.ZodString>;
         on: z.ZodString;
         references: z.ZodOptional<z.ZodString>;
         enforce: z.ZodDefault<z.ZodBoolean>;
+        onDelete: z.ZodOptional<z.ZodEnum<{
+            cascade: "cascade";
+            restrict: "restrict";
+            "no action": "no action";
+            "set null": "set null";
+            "set default": "set default";
+        }>>;
+        onUpdate: z.ZodOptional<z.ZodEnum<{
+            cascade: "cascade";
+            restrict: "restrict";
+            "no action": "no action";
+            "set null": "set null";
+            "set default": "set default";
+        }>>;
         description: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     policies: z.ZodObject<{
@@ -410,9 +802,131 @@ declare const canonicalViewSchema: z.ZodObject<{
     }, z.core.$strict>;
     query: z.ZodString;
     dependencies: z.ZodArray<z.ZodString>;
+    resolved: z.ZodOptional<z.ZodObject<{
+        sources: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                manual: "manual";
+                prefetch: "prefetch";
+                etl: "etl";
+            }>;
+            table: z.ZodString;
+            columns: z.ZodArray<z.ZodString>;
+            updatedAt: z.ZodOptional<z.ZodString>;
+            key: z.ZodOptional<z.ZodString>;
+            fetch: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                shape: z.ZodLiteral<"single">;
+            }, z.core.$strict>, z.ZodObject<{
+                shape: z.ZodLiteral<"batch">;
+                maxKeys: z.ZodNumber;
+            }, z.core.$strict>]>>;
+            function: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    managed: "managed";
+                    native: "native";
+                }>;
+                id: z.ZodString;
+            }, z.core.$strict>>;
+            prefetchDefaults: z.ZodOptional<z.ZodObject<{
+                maxStalenessMs: z.ZodNumber;
+                timeoutMs: z.ZodNumber;
+                onError: z.ZodEnum<{
+                    fallback: "fallback";
+                    fail: "fail";
+                }>;
+            }, z.core.$strict>>;
+            writeback: z.ZodOptional<z.ZodObject<{
+                columns: z.ZodArray<z.ZodString>;
+                defaultMode: z.ZodEnum<{
+                    sync: "sync";
+                    async: "async";
+                }>;
+                timeoutMs: z.ZodNumber;
+                clearManualOnConfirm: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        resolve: z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            comparator: z.ZodEnum<{
+                custom: "custom";
+                latest: "latest";
+                highest: "highest";
+                lowest: "lowest";
+                priority: "priority";
+                nonNullFirst: "nonNullFirst";
+            }>;
+            candidates: z.ZodArray<z.ZodString>;
+            orderBy: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        deletedBy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        materialized: z.ZodOptional<z.ZodObject<{
+            table: z.ZodString;
+            compute: z.ZodString;
+        }, z.core.$strict>>;
+        policies: z.ZodDefault<z.ZodObject<{
+            write: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                default: z.ZodString;
+                variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    when: z.ZodString;
+                    allow: z.ZodOptional<z.ZodLiteral<true>>;
+                    policy: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>]>>;
+            insert: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                default: z.ZodString;
+                variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    when: z.ZodString;
+                    allow: z.ZodOptional<z.ZodLiteral<true>>;
+                    policy: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>]>>;
+            update: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                default: z.ZodString;
+                variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    when: z.ZodString;
+                    allow: z.ZodOptional<z.ZodLiteral<true>>;
+                    policy: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    internal: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strip>;
 type CanonicalView = z.infer<typeof canonicalViewSchema>;
-declare const canonicalDefinitionSchema: z.ZodObject<{
+/** The type each cell part is stored as. */
+declare const CELL_PART_TYPES: Readonly<Record<CellPart, ColumnType>>;
+interface TrackedShape {
+    columns: ReadonlyArray<{
+        name: string;
+        columnName: string;
+        onUpdateFn?: string;
+        cell?: {
+            of: string;
+            part: CellPart;
+        };
+    }>;
+    primaryKey?: readonly string[];
+}
+/** Columns a cell-tracking table stamps: everything except the primary key, clock columns and cell parts. */
+declare function trackedCellColumns<T extends TrackedShape>(table: T): Array<T['columns'][number]>;
+declare const exportGateSchema: z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+    capability: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    role: z.ZodString;
+}, z.core.$strict>]>;
+declare const relationExportSchema: z.ZodObject<{
+    read: z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+        capability: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        role: z.ZodString;
+    }, z.core.$strict>]>;
+    write: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+        capability: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        role: z.ZodString;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+declare const localDefinitionSchema: z.ZodObject<{
     definition_format: z.ZodLiteral<2>;
     namespace: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -422,6 +936,7 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
     }, z.core.$strip>>>;
     tables: z.ZodArray<z.ZodObject<{
         table: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
         renamedFrom: z.ZodOptional<z.ZodString>;
         source: z.ZodOptional<z.ZodString>;
@@ -431,14 +946,14 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
             type: z.ZodUnion<readonly [z.ZodEnum<{
                 bigint: "bigint";
                 boolean: "boolean";
-                uuid: "uuid";
+                date: "date";
                 text: "text";
+                timestamptz: "timestamptz";
+                jsonb: "jsonb";
+                uuid: "uuid";
                 integer: "integer";
                 numeric: "numeric";
                 double: "double";
-                timestamptz: "timestamptz";
-                date: "date";
-                jsonb: "jsonb";
             }>, z.ZodObject<{
                 enum: z.ZodString;
             }, z.core.$strip>]>;
@@ -456,6 +971,16 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
             renamedFrom: z.ZodOptional<z.ZodString>;
             cast: z.ZodOptional<z.ZodString>;
             deprecated: z.ZodDefault<z.ZodBoolean>;
+            cell: z.ZodOptional<z.ZodObject<{
+                of: z.ZodString;
+                part: z.ZodEnum<{
+                    at: "at";
+                    by: "by";
+                    rev: "rev";
+                    source: "source";
+                    conflicts: "conflicts";
+                }>;
+            }, z.core.$strict>>;
         }, z.core.$strip>>>;
         primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
         links: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -466,9 +991,24 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                 toPlatformUser: "toPlatformUser";
             }>;
             target: z.ZodOptional<z.ZodString>;
+            namespace: z.ZodOptional<z.ZodString>;
             on: z.ZodString;
             references: z.ZodOptional<z.ZodString>;
             enforce: z.ZodDefault<z.ZodBoolean>;
+            onDelete: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
+            onUpdate: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
             description: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
         indexes: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -476,6 +1016,10 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
             unique: z.ZodDefault<z.ZodBoolean>;
             name: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
+        checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            expression: z.ZodString;
+        }, z.core.$strict>>>;
         policies: z.ZodDefault<z.ZodObject<{
             read: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                 default: z.ZodString;
@@ -517,14 +1061,14 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                 type: z.ZodEnum<{
                     bigint: "bigint";
                     boolean: "boolean";
-                    uuid: "uuid";
+                    date: "date";
                     text: "text";
+                    timestamptz: "timestamptz";
+                    jsonb: "jsonb";
+                    uuid: "uuid";
                     integer: "integer";
                     numeric: "numeric";
                     double: "double";
-                    timestamptz: "timestamptz";
-                    date: "date";
-                    jsonb: "jsonb";
                 }>;
                 nullable: z.ZodDefault<z.ZodBoolean>;
             }, z.core.$strip>>>;
@@ -559,7 +1103,24 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                 "initially-immediate": "initially-immediate";
                 "initially-deferred": "initially-deferred";
             }>>;
+            onDelete: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
+            onUpdate: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
         }, z.core.$strict>>>;
+        cellMetadata: z.ZodOptional<z.ZodLiteral<true>>;
+        internal: z.ZodOptional<z.ZodLiteral<true>>;
+        materializes: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     views: z.ZodOptional<z.ZodArray<z.ZodObject<{
         view: z.ZodString;
@@ -570,14 +1131,403 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
             type: z.ZodUnion<readonly [z.ZodEnum<{
                 bigint: "bigint";
                 boolean: "boolean";
-                uuid: "uuid";
+                date: "date";
                 text: "text";
+                timestamptz: "timestamptz";
+                jsonb: "jsonb";
+                uuid: "uuid";
                 integer: "integer";
                 numeric: "numeric";
                 double: "double";
+            }>, z.ZodObject<{
+                enum: z.ZodString;
+            }, z.core.$strip>]>;
+            nullable: z.ZodDefault<z.ZodBoolean>;
+            unique: z.ZodDefault<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+            defaultFn: z.ZodOptional<z.ZodEnum<{
+                "gen_random_uuid()": "gen_random_uuid()";
+                "now()": "now()";
+            }>>;
+            onUpdateFn: z.ZodOptional<z.ZodEnum<{
+                "now()": "now()";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+            renamedFrom: z.ZodOptional<z.ZodString>;
+            cast: z.ZodOptional<z.ZodString>;
+            deprecated: z.ZodDefault<z.ZodBoolean>;
+            cell: z.ZodOptional<z.ZodObject<{
+                of: z.ZodString;
+                part: z.ZodEnum<{
+                    at: "at";
+                    by: "by";
+                    rev: "rev";
+                    source: "source";
+                    conflicts: "conflicts";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strip>>;
+        primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                toOne: "toOne";
+                toMany: "toMany";
+                toPlatformUser: "toPlatformUser";
+            }>;
+            target: z.ZodOptional<z.ZodString>;
+            namespace: z.ZodOptional<z.ZodString>;
+            on: z.ZodString;
+            references: z.ZodOptional<z.ZodString>;
+            enforce: z.ZodDefault<z.ZodBoolean>;
+            onDelete: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
+            onUpdate: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        policies: z.ZodObject<{
+            read: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                default: z.ZodString;
+                variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    when: z.ZodString;
+                    allow: z.ZodOptional<z.ZodLiteral<true>>;
+                    policy: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>]>;
+        }, z.core.$strict>;
+        query: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+        resolved: z.ZodOptional<z.ZodObject<{
+            sources: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                kind: z.ZodEnum<{
+                    manual: "manual";
+                    prefetch: "prefetch";
+                    etl: "etl";
+                }>;
+                table: z.ZodString;
+                columns: z.ZodArray<z.ZodString>;
+                updatedAt: z.ZodOptional<z.ZodString>;
+                key: z.ZodOptional<z.ZodString>;
+                fetch: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    shape: z.ZodLiteral<"single">;
+                }, z.core.$strict>, z.ZodObject<{
+                    shape: z.ZodLiteral<"batch">;
+                    maxKeys: z.ZodNumber;
+                }, z.core.$strict>]>>;
+                function: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        managed: "managed";
+                        native: "native";
+                    }>;
+                    id: z.ZodString;
+                }, z.core.$strict>>;
+                prefetchDefaults: z.ZodOptional<z.ZodObject<{
+                    maxStalenessMs: z.ZodNumber;
+                    timeoutMs: z.ZodNumber;
+                    onError: z.ZodEnum<{
+                        fallback: "fallback";
+                        fail: "fail";
+                    }>;
+                }, z.core.$strict>>;
+                writeback: z.ZodOptional<z.ZodObject<{
+                    columns: z.ZodArray<z.ZodString>;
+                    defaultMode: z.ZodEnum<{
+                        sync: "sync";
+                        async: "async";
+                    }>;
+                    timeoutMs: z.ZodNumber;
+                    clearManualOnConfirm: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            resolve: z.ZodArray<z.ZodObject<{
+                column: z.ZodString;
+                comparator: z.ZodEnum<{
+                    custom: "custom";
+                    latest: "latest";
+                    highest: "highest";
+                    lowest: "lowest";
+                    priority: "priority";
+                    nonNullFirst: "nonNullFirst";
+                }>;
+                candidates: z.ZodArray<z.ZodString>;
+                orderBy: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            deletedBy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            materialized: z.ZodOptional<z.ZodObject<{
+                table: z.ZodString;
+                compute: z.ZodString;
+            }, z.core.$strict>>;
+            policies: z.ZodDefault<z.ZodObject<{
+                write: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    default: z.ZodString;
+                    variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        when: z.ZodString;
+                        allow: z.ZodOptional<z.ZodLiteral<true>>;
+                        policy: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>]>>;
+                insert: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    default: z.ZodString;
+                    variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        when: z.ZodString;
+                        allow: z.ZodOptional<z.ZodLiteral<true>>;
+                        policy: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>]>>;
+                update: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    default: z.ZodString;
+                    variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        when: z.ZodString;
+                        allow: z.ZodOptional<z.ZodLiteral<true>>;
+                        policy: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        internal: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strip>>>;
+    exports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        read: z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+            capability: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            role: z.ZodString;
+        }, z.core.$strict>]>;
+        write: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+            capability: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            role: z.ZodString;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>>;
+    capabilities: z.ZodDefault<z.ZodObject<{
+        roles: z.ZodOptional<z.ZodUnknown>;
+        uses: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const canonicalDefinitionSchema: z.ZodObject<{
+    definition_format: z.ZodLiteral<2>;
+    namespace: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    enums: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        values: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    tables: z.ZodArray<z.ZodObject<{
+        table: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        renamedFrom: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+        columns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            columnName: z.ZodString;
+            type: z.ZodUnion<readonly [z.ZodEnum<{
+                bigint: "bigint";
+                boolean: "boolean";
+                date: "date";
+                text: "text";
                 timestamptz: "timestamptz";
+                jsonb: "jsonb";
+                uuid: "uuid";
+                integer: "integer";
+                numeric: "numeric";
+                double: "double";
+            }>, z.ZodObject<{
+                enum: z.ZodString;
+            }, z.core.$strip>]>;
+            nullable: z.ZodDefault<z.ZodBoolean>;
+            unique: z.ZodDefault<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+            defaultFn: z.ZodOptional<z.ZodEnum<{
+                "gen_random_uuid()": "gen_random_uuid()";
+                "now()": "now()";
+            }>>;
+            onUpdateFn: z.ZodOptional<z.ZodEnum<{
+                "now()": "now()";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+            renamedFrom: z.ZodOptional<z.ZodString>;
+            cast: z.ZodOptional<z.ZodString>;
+            deprecated: z.ZodDefault<z.ZodBoolean>;
+            cell: z.ZodOptional<z.ZodObject<{
+                of: z.ZodString;
+                part: z.ZodEnum<{
+                    at: "at";
+                    by: "by";
+                    rev: "rev";
+                    source: "source";
+                    conflicts: "conflicts";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strip>>>;
+        primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                toOne: "toOne";
+                toMany: "toMany";
+                toPlatformUser: "toPlatformUser";
+            }>;
+            target: z.ZodOptional<z.ZodString>;
+            namespace: z.ZodOptional<z.ZodString>;
+            on: z.ZodString;
+            references: z.ZodOptional<z.ZodString>;
+            enforce: z.ZodDefault<z.ZodBoolean>;
+            onDelete: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
+            onUpdate: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        indexes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            columns: z.ZodArray<z.ZodString>;
+            unique: z.ZodDefault<z.ZodBoolean>;
+            name: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            expression: z.ZodString;
+        }, z.core.$strict>>>;
+        policies: z.ZodDefault<z.ZodObject<{
+            read: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                default: z.ZodString;
+                variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    when: z.ZodString;
+                    allow: z.ZodOptional<z.ZodLiteral<true>>;
+                    policy: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>]>>;
+            write: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                default: z.ZodString;
+                variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    when: z.ZodString;
+                    allow: z.ZodOptional<z.ZodLiteral<true>>;
+                    policy: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>]>>;
+            insert: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                default: z.ZodString;
+                variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    when: z.ZodString;
+                    allow: z.ZodOptional<z.ZodLiteral<true>>;
+                    policy: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>]>>;
+            update: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                default: z.ZodString;
+                variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    when: z.ZodString;
+                    allow: z.ZodOptional<z.ZodLiteral<true>>;
+                    policy: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>>;
+        actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            requires: z.ZodOptional<z.ZodString>;
+            params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    bigint: "bigint";
+                    boolean: "boolean";
+                    date: "date";
+                    text: "text";
+                    timestamptz: "timestamptz";
+                    jsonb: "jsonb";
+                    uuid: "uuid";
+                    integer: "integer";
+                    numeric: "numeric";
+                    double: "double";
+                }>;
+                nullable: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            executes: z.ZodString;
+            returns: z.ZodDefault<z.ZodEnum<{
+                rows: "rows";
+                rowsAffected: "rowsAffected";
+                scalar: "scalar";
+            }>>;
+            audit: z.ZodOptional<z.ZodObject<{
+                action: z.ZodString;
+                resource: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        cowMutations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                override: "override";
+                revert: "revert";
+            }>;
+            name: z.ZodString;
+            synced: z.ZodString;
+            pk: z.ZodString;
+            copy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            set: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        foreignKeys: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            columns: z.ZodArray<z.ZodString>;
+            target: z.ZodString;
+            references: z.ZodArray<z.ZodString>;
+            deferrable: z.ZodOptional<z.ZodEnum<{
+                "initially-immediate": "initially-immediate";
+                "initially-deferred": "initially-deferred";
+            }>>;
+            onDelete: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
+            onUpdate: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
+        }, z.core.$strict>>>;
+        cellMetadata: z.ZodOptional<z.ZodLiteral<true>>;
+        internal: z.ZodOptional<z.ZodLiteral<true>>;
+        materializes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    views: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        view: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        columns: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            columnName: z.ZodString;
+            type: z.ZodUnion<readonly [z.ZodEnum<{
+                bigint: "bigint";
+                boolean: "boolean";
                 date: "date";
+                text: "text";
+                timestamptz: "timestamptz";
                 jsonb: "jsonb";
+                uuid: "uuid";
+                integer: "integer";
+                numeric: "numeric";
+                double: "double";
             }>, z.ZodObject<{
                 enum: z.ZodString;
             }, z.core.$strip>]>;
@@ -595,6 +1545,16 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
             renamedFrom: z.ZodOptional<z.ZodString>;
             cast: z.ZodOptional<z.ZodString>;
             deprecated: z.ZodDefault<z.ZodBoolean>;
+            cell: z.ZodOptional<z.ZodObject<{
+                of: z.ZodString;
+                part: z.ZodEnum<{
+                    at: "at";
+                    by: "by";
+                    rev: "rev";
+                    source: "source";
+                    conflicts: "conflicts";
+                }>;
+            }, z.core.$strict>>;
         }, z.core.$strip>>;
         primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
         links: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -605,9 +1565,24 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                 toPlatformUser: "toPlatformUser";
             }>;
             target: z.ZodOptional<z.ZodString>;
+            namespace: z.ZodOptional<z.ZodString>;
             on: z.ZodString;
             references: z.ZodOptional<z.ZodString>;
             enforce: z.ZodDefault<z.ZodBoolean>;
+            onDelete: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
+            onUpdate: z.ZodOptional<z.ZodEnum<{
+                cascade: "cascade";
+                restrict: "restrict";
+                "no action": "no action";
+                "set null": "set null";
+                "set default": "set default";
+            }>>;
             description: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
         policies: z.ZodObject<{
@@ -622,11 +1597,501 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
         }, z.core.$strict>;
         query: z.ZodString;
         dependencies: z.ZodArray<z.ZodString>;
+        resolved: z.ZodOptional<z.ZodObject<{
+            sources: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                kind: z.ZodEnum<{
+                    manual: "manual";
+                    prefetch: "prefetch";
+                    etl: "etl";
+                }>;
+                table: z.ZodString;
+                columns: z.ZodArray<z.ZodString>;
+                updatedAt: z.ZodOptional<z.ZodString>;
+                key: z.ZodOptional<z.ZodString>;
+                fetch: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    shape: z.ZodLiteral<"single">;
+                }, z.core.$strict>, z.ZodObject<{
+                    shape: z.ZodLiteral<"batch">;
+                    maxKeys: z.ZodNumber;
+                }, z.core.$strict>]>>;
+                function: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        managed: "managed";
+                        native: "native";
+                    }>;
+                    id: z.ZodString;
+                }, z.core.$strict>>;
+                prefetchDefaults: z.ZodOptional<z.ZodObject<{
+                    maxStalenessMs: z.ZodNumber;
+                    timeoutMs: z.ZodNumber;
+                    onError: z.ZodEnum<{
+                        fallback: "fallback";
+                        fail: "fail";
+                    }>;
+                }, z.core.$strict>>;
+                writeback: z.ZodOptional<z.ZodObject<{
+                    columns: z.ZodArray<z.ZodString>;
+                    defaultMode: z.ZodEnum<{
+                        sync: "sync";
+                        async: "async";
+                    }>;
+                    timeoutMs: z.ZodNumber;
+                    clearManualOnConfirm: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            resolve: z.ZodArray<z.ZodObject<{
+                column: z.ZodString;
+                comparator: z.ZodEnum<{
+                    custom: "custom";
+                    latest: "latest";
+                    highest: "highest";
+                    lowest: "lowest";
+                    priority: "priority";
+                    nonNullFirst: "nonNullFirst";
+                }>;
+                candidates: z.ZodArray<z.ZodString>;
+                orderBy: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            deletedBy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            materialized: z.ZodOptional<z.ZodObject<{
+                table: z.ZodString;
+                compute: z.ZodString;
+            }, z.core.$strict>>;
+            policies: z.ZodDefault<z.ZodObject<{
+                write: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    default: z.ZodString;
+                    variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        when: z.ZodString;
+                        allow: z.ZodOptional<z.ZodLiteral<true>>;
+                        policy: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>]>>;
+                insert: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    default: z.ZodString;
+                    variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        when: z.ZodString;
+                        allow: z.ZodOptional<z.ZodLiteral<true>>;
+                        policy: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>]>>;
+                update: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    default: z.ZodString;
+                    variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        when: z.ZodString;
+                        allow: z.ZodOptional<z.ZodLiteral<true>>;
+                        policy: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        internal: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strip>>>;
+    exports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        read: z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+            capability: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            role: z.ZodString;
+        }, z.core.$strict>]>;
+        write: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+            capability: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            role: z.ZodString;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>>;
     capabilities: z.ZodDefault<z.ZodObject<{
         roles: z.ZodOptional<z.ZodUnknown>;
         uses: z.ZodDefault<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
+    imports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        definition_format: z.ZodLiteral<2>;
+        namespace: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        enums: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            values: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>>;
+        tables: z.ZodArray<z.ZodObject<{
+            table: z.ZodString;
+            displayName: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            renamedFrom: z.ZodOptional<z.ZodString>;
+            source: z.ZodOptional<z.ZodString>;
+            columns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                columnName: z.ZodString;
+                type: z.ZodUnion<readonly [z.ZodEnum<{
+                    bigint: "bigint";
+                    boolean: "boolean";
+                    date: "date";
+                    text: "text";
+                    timestamptz: "timestamptz";
+                    jsonb: "jsonb";
+                    uuid: "uuid";
+                    integer: "integer";
+                    numeric: "numeric";
+                    double: "double";
+                }>, z.ZodObject<{
+                    enum: z.ZodString;
+                }, z.core.$strip>]>;
+                nullable: z.ZodDefault<z.ZodBoolean>;
+                unique: z.ZodDefault<z.ZodBoolean>;
+                default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+                defaultFn: z.ZodOptional<z.ZodEnum<{
+                    "gen_random_uuid()": "gen_random_uuid()";
+                    "now()": "now()";
+                }>>;
+                onUpdateFn: z.ZodOptional<z.ZodEnum<{
+                    "now()": "now()";
+                }>>;
+                description: z.ZodOptional<z.ZodString>;
+                renamedFrom: z.ZodOptional<z.ZodString>;
+                cast: z.ZodOptional<z.ZodString>;
+                deprecated: z.ZodDefault<z.ZodBoolean>;
+                cell: z.ZodOptional<z.ZodObject<{
+                    of: z.ZodString;
+                    part: z.ZodEnum<{
+                        at: "at";
+                        by: "by";
+                        rev: "rev";
+                        source: "source";
+                        conflicts: "conflicts";
+                    }>;
+                }, z.core.$strict>>;
+            }, z.core.$strip>>>;
+            primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                kind: z.ZodEnum<{
+                    toOne: "toOne";
+                    toMany: "toMany";
+                    toPlatformUser: "toPlatformUser";
+                }>;
+                target: z.ZodOptional<z.ZodString>;
+                namespace: z.ZodOptional<z.ZodString>;
+                on: z.ZodString;
+                references: z.ZodOptional<z.ZodString>;
+                enforce: z.ZodDefault<z.ZodBoolean>;
+                onDelete: z.ZodOptional<z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                    "no action": "no action";
+                    "set null": "set null";
+                    "set default": "set default";
+                }>>;
+                onUpdate: z.ZodOptional<z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                    "no action": "no action";
+                    "set null": "set null";
+                    "set default": "set default";
+                }>>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            indexes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                columns: z.ZodArray<z.ZodString>;
+                unique: z.ZodDefault<z.ZodBoolean>;
+                name: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            checks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                expression: z.ZodString;
+            }, z.core.$strict>>>;
+            policies: z.ZodDefault<z.ZodObject<{
+                read: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    default: z.ZodString;
+                    variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        when: z.ZodString;
+                        allow: z.ZodOptional<z.ZodLiteral<true>>;
+                        policy: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>]>>;
+                write: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    default: z.ZodString;
+                    variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        when: z.ZodString;
+                        allow: z.ZodOptional<z.ZodLiteral<true>>;
+                        policy: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>]>>;
+                insert: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    default: z.ZodString;
+                    variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        when: z.ZodString;
+                        allow: z.ZodOptional<z.ZodLiteral<true>>;
+                        policy: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>]>>;
+                update: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    default: z.ZodString;
+                    variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        when: z.ZodString;
+                        allow: z.ZodOptional<z.ZodLiteral<true>>;
+                        policy: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>]>>;
+            }, z.core.$strip>>;
+            actions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                requires: z.ZodOptional<z.ZodString>;
+                params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    type: z.ZodEnum<{
+                        bigint: "bigint";
+                        boolean: "boolean";
+                        date: "date";
+                        text: "text";
+                        timestamptz: "timestamptz";
+                        jsonb: "jsonb";
+                        uuid: "uuid";
+                        integer: "integer";
+                        numeric: "numeric";
+                        double: "double";
+                    }>;
+                    nullable: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>>>;
+                executes: z.ZodString;
+                returns: z.ZodDefault<z.ZodEnum<{
+                    rows: "rows";
+                    rowsAffected: "rowsAffected";
+                    scalar: "scalar";
+                }>>;
+                audit: z.ZodOptional<z.ZodObject<{
+                    action: z.ZodString;
+                    resource: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            cowMutations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    override: "override";
+                    revert: "revert";
+                }>;
+                name: z.ZodString;
+                synced: z.ZodString;
+                pk: z.ZodString;
+                copy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                set: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            foreignKeys: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                columns: z.ZodArray<z.ZodString>;
+                target: z.ZodString;
+                references: z.ZodArray<z.ZodString>;
+                deferrable: z.ZodOptional<z.ZodEnum<{
+                    "initially-immediate": "initially-immediate";
+                    "initially-deferred": "initially-deferred";
+                }>>;
+                onDelete: z.ZodOptional<z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                    "no action": "no action";
+                    "set null": "set null";
+                    "set default": "set default";
+                }>>;
+                onUpdate: z.ZodOptional<z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                    "no action": "no action";
+                    "set null": "set null";
+                    "set default": "set default";
+                }>>;
+            }, z.core.$strict>>>;
+            cellMetadata: z.ZodOptional<z.ZodLiteral<true>>;
+            internal: z.ZodOptional<z.ZodLiteral<true>>;
+            materializes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        views: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            view: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            columns: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                columnName: z.ZodString;
+                type: z.ZodUnion<readonly [z.ZodEnum<{
+                    bigint: "bigint";
+                    boolean: "boolean";
+                    date: "date";
+                    text: "text";
+                    timestamptz: "timestamptz";
+                    jsonb: "jsonb";
+                    uuid: "uuid";
+                    integer: "integer";
+                    numeric: "numeric";
+                    double: "double";
+                }>, z.ZodObject<{
+                    enum: z.ZodString;
+                }, z.core.$strip>]>;
+                nullable: z.ZodDefault<z.ZodBoolean>;
+                unique: z.ZodDefault<z.ZodBoolean>;
+                default: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+                defaultFn: z.ZodOptional<z.ZodEnum<{
+                    "gen_random_uuid()": "gen_random_uuid()";
+                    "now()": "now()";
+                }>>;
+                onUpdateFn: z.ZodOptional<z.ZodEnum<{
+                    "now()": "now()";
+                }>>;
+                description: z.ZodOptional<z.ZodString>;
+                renamedFrom: z.ZodOptional<z.ZodString>;
+                cast: z.ZodOptional<z.ZodString>;
+                deprecated: z.ZodDefault<z.ZodBoolean>;
+                cell: z.ZodOptional<z.ZodObject<{
+                    of: z.ZodString;
+                    part: z.ZodEnum<{
+                        at: "at";
+                        by: "by";
+                        rev: "rev";
+                        source: "source";
+                        conflicts: "conflicts";
+                    }>;
+                }, z.core.$strict>>;
+            }, z.core.$strip>>;
+            primaryKey: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            links: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                kind: z.ZodEnum<{
+                    toOne: "toOne";
+                    toMany: "toMany";
+                    toPlatformUser: "toPlatformUser";
+                }>;
+                target: z.ZodOptional<z.ZodString>;
+                namespace: z.ZodOptional<z.ZodString>;
+                on: z.ZodString;
+                references: z.ZodOptional<z.ZodString>;
+                enforce: z.ZodDefault<z.ZodBoolean>;
+                onDelete: z.ZodOptional<z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                    "no action": "no action";
+                    "set null": "set null";
+                    "set default": "set default";
+                }>>;
+                onUpdate: z.ZodOptional<z.ZodEnum<{
+                    cascade: "cascade";
+                    restrict: "restrict";
+                    "no action": "no action";
+                    "set null": "set null";
+                    "set default": "set default";
+                }>>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            policies: z.ZodObject<{
+                read: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                    default: z.ZodString;
+                    variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        when: z.ZodString;
+                        allow: z.ZodOptional<z.ZodLiteral<true>>;
+                        policy: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>]>;
+            }, z.core.$strict>;
+            query: z.ZodString;
+            dependencies: z.ZodArray<z.ZodString>;
+            resolved: z.ZodOptional<z.ZodObject<{
+                sources: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    kind: z.ZodEnum<{
+                        manual: "manual";
+                        prefetch: "prefetch";
+                        etl: "etl";
+                    }>;
+                    table: z.ZodString;
+                    columns: z.ZodArray<z.ZodString>;
+                    updatedAt: z.ZodOptional<z.ZodString>;
+                    key: z.ZodOptional<z.ZodString>;
+                    fetch: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        shape: z.ZodLiteral<"single">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        shape: z.ZodLiteral<"batch">;
+                        maxKeys: z.ZodNumber;
+                    }, z.core.$strict>]>>;
+                    function: z.ZodOptional<z.ZodObject<{
+                        kind: z.ZodEnum<{
+                            managed: "managed";
+                            native: "native";
+                        }>;
+                        id: z.ZodString;
+                    }, z.core.$strict>>;
+                    prefetchDefaults: z.ZodOptional<z.ZodObject<{
+                        maxStalenessMs: z.ZodNumber;
+                        timeoutMs: z.ZodNumber;
+                        onError: z.ZodEnum<{
+                            fallback: "fallback";
+                            fail: "fail";
+                        }>;
+                    }, z.core.$strict>>;
+                    writeback: z.ZodOptional<z.ZodObject<{
+                        columns: z.ZodArray<z.ZodString>;
+                        defaultMode: z.ZodEnum<{
+                            sync: "sync";
+                            async: "async";
+                        }>;
+                        timeoutMs: z.ZodNumber;
+                        clearManualOnConfirm: z.ZodBoolean;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                resolve: z.ZodArray<z.ZodObject<{
+                    column: z.ZodString;
+                    comparator: z.ZodEnum<{
+                        custom: "custom";
+                        latest: "latest";
+                        highest: "highest";
+                        lowest: "lowest";
+                        priority: "priority";
+                        nonNullFirst: "nonNullFirst";
+                    }>;
+                    candidates: z.ZodArray<z.ZodString>;
+                    orderBy: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                deletedBy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                materialized: z.ZodOptional<z.ZodObject<{
+                    table: z.ZodString;
+                    compute: z.ZodString;
+                }, z.core.$strict>>;
+                policies: z.ZodDefault<z.ZodObject<{
+                    write: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        default: z.ZodString;
+                        variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            when: z.ZodString;
+                            allow: z.ZodOptional<z.ZodLiteral<true>>;
+                            policy: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>]>>;
+                    insert: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        default: z.ZodString;
+                        variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            when: z.ZodString;
+                            allow: z.ZodOptional<z.ZodLiteral<true>>;
+                            policy: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>]>>;
+                    update: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                        default: z.ZodString;
+                        variants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            when: z.ZodString;
+                            allow: z.ZodOptional<z.ZodLiteral<true>>;
+                            policy: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            internal: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strip>>>;
+        exports: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            read: z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                capability: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                role: z.ZodString;
+            }, z.core.$strict>]>;
+            write: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                capability: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                role: z.ZodString;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>>;
+        capabilities: z.ZodDefault<z.ZodObject<{
+            roles: z.ZodOptional<z.ZodUnknown>;
+            uses: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 type CanonicalDefinition = z.infer<typeof canonicalDefinitionSchema>;
 /**
@@ -636,7 +2101,11 @@ type CanonicalDefinition = z.infer<typeof canonicalDefinitionSchema>;
  * the canonical boundary makes SDL and compiler behavior identical without
  * pretending views are writable tables in the wire contract.
  */
-declare function canonicalRelations(definition: CanonicalDefinition): CanonicalTable[];
+/** A table or view as the compiler/SDL see it; resolved views also carry their multi-source metadata. */
+type CanonicalRelation = CanonicalTable & {
+    resolved?: CanonicalResolved;
+};
+declare function canonicalRelations(definition: CanonicalDefinition): CanonicalRelation[];
 /**
  * Deterministic serialization discipline: tables sorted by name, columns in
  * declaration order (order is meaningful for DDL), links/indexes/actions
@@ -646,4 +2115,4 @@ declare function canonicalRelations(definition: CanonicalDefinition): CanonicalT
  */
 declare function normalizeCanonical(definition: CanonicalDefinition): CanonicalDefinition;
 
-export { CANONICAL_FORMAT, COLUMN_TYPES, type CanonicalColumn, type CanonicalCowMutation, type CanonicalDefinition, type CanonicalEnum, type CanonicalForeignKey, type CanonicalLink, type CanonicalTable, type CanonicalView, type ColumnType, IDENTIFIER_RE, type PolicyExpression, VIEW_QUERY_FUNCTION_ALLOWLIST, canonicalActionSchema, canonicalColumnSchema, canonicalCowMutationSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalForeignKeySchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalTableSchema, canonicalViewSchema, isSingleViewQuerySql, normalizeCanonical, policyExpressionSchema, policyVariantSchema };
+export { CANONICAL_FORMAT, CELL_PART_TYPES, COLUMN_TYPES, COMPARATORS, type CanonicalCheck, type CanonicalColumn, type CanonicalCowMutation, type CanonicalDefinition, type CanonicalEnum, type CanonicalFetchShape, type CanonicalForeignKey, type CanonicalFunctionRef, type CanonicalLink, type CanonicalRelation, type CanonicalResolveRule, type CanonicalResolved, type CanonicalResolvedSource, type CanonicalTable, type CanonicalView, type ColumnType, type ComparatorKind, IDENTIFIER_RE, type OntologyContract, RESERVED_RESOLVED_COLUMN_NAMES, RESOLVED_SOURCE_CELL_PARTS, RESOLVED_SOURCE_SYSTEM_COLUMNS, RESOLVED_VIEW_CELL_PARTS, RESOLVED_VIEW_SYSTEM_COLUMNS, VIEW_QUERY_FUNCTION_ALLOWLIST, canonicalActionSchema, canonicalCheckSchema, canonicalColumnSchema, canonicalCowMutationSchema, canonicalDefinitionSchema, canonicalEnumSchema, canonicalFetchShapeSchema, canonicalForeignKeySchema, canonicalFunctionRefSchema, canonicalIndexSchema, canonicalLinkSchema, canonicalPoliciesSchema, canonicalRelations, canonicalResolveRuleSchema, canonicalResolvedSchema, canonicalResolvedSourceSchema, canonicalTableSchema, canonicalViewSchema, exportGateSchema, isSingleViewQuerySql, localDefinitionSchema, normalizeCanonical, ontologyContractSchema, parseDurationMs, readOntologyContract, relationExportSchema, trackedCellColumns, validateResolvedView };