@sequenceholdings/orm 2.1.0 → 2.1.1

package/dist/canonical.d.ts

@@ -1,4 +1,286 @@
 import { z } from 'zod';
+import { b as CellPart } from './constants-YoFGjIBM.js';
+export { P as PolicyExpression, p as policyExpressionSchema, a as policyVariantSchema } from './policy-1iZbGnZZ.js';
+
+/**
+ * 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: gold.*`) 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 +312,14 @@ declare const canonicalColumnSchema: z.ZodObject<{
     type: z.ZodUnion<readonly [z.ZodEnum<{
         bigint: "bigint";
         boolean: "boolean";
-        uuid: "uuid";
         text: "text";
+        date: "date";
+        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 +337,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<{
@@ -68,6 +360,20 @@ declare const canonicalLinkSchema: z.ZodObject<{
     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 +382,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 +446,14 @@ declare const canonicalActionSchema: z.ZodObject<{
         type: z.ZodEnum<{
             bigint: "bigint";
             boolean: "boolean";
-            uuid: "uuid";
             text: "text";
+            date: "date";
+            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,6 +498,20 @@ 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<{
@@ -218,14 +525,14 @@ declare const canonicalTableSchema: z.ZodObject<{
         type: z.ZodUnion<readonly [z.ZodEnum<{
             bigint: "bigint";
             boolean: "boolean";
-            uuid: "uuid";
             text: "text";
+            date: "date";
+            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 +550,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<{
@@ -256,6 +573,20 @@ declare const canonicalTableSchema: z.ZodObject<{
         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 +594,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 +639,14 @@ declare const canonicalTableSchema: z.ZodObject<{
             type: z.ZodEnum<{
                 bigint: "bigint";
                 boolean: "boolean";
-                uuid: "uuid";
                 text: "text";
+                date: "date";
+                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 +681,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 +710,14 @@ declare const canonicalViewSchema: z.ZodObject<{
         type: z.ZodUnion<readonly [z.ZodEnum<{
             bigint: "bigint";
             boolean: "boolean";
-            uuid: "uuid";
             text: "text";
+            date: "date";
+            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 +735,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<{
@@ -396,6 +758,20 @@ declare const canonicalViewSchema: z.ZodObject<{
         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,8 +786,113 @@ 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>;
+/** 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 canonicalDefinitionSchema: z.ZodObject<{
     definition_format: z.ZodLiteral<2>;
     namespace: z.ZodString;
@@ -431,14 +912,14 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
             type: z.ZodUnion<readonly [z.ZodEnum<{
                 bigint: "bigint";
                 boolean: "boolean";
-                uuid: "uuid";
                 text: "text";
+                date: "date";
+                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 +937,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<{
@@ -469,6 +960,20 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
             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 +981,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 +1026,14 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
                 type: z.ZodEnum<{
                     bigint: "bigint";
                     boolean: "boolean";
-                    uuid: "uuid";
                     text: "text";
+                    date: "date";
+                    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 +1068,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 +1096,14 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
             type: z.ZodUnion<readonly [z.ZodEnum<{
                 bigint: "bigint";
                 boolean: "boolean";
-                uuid: "uuid";
                 text: "text";
+                date: "date";
+                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>]>;
@@ -595,6 +1121,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<{
@@ -608,6 +1144,20 @@ declare const canonicalDefinitionSchema: z.ZodObject<{
             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,6 +1172,95 @@ 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>>>;
     capabilities: z.ZodDefault<z.ZodObject<{
         roles: z.ZodOptional<z.ZodUnknown>;
@@ -636,7 +1275,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 +1289,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, 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, isSingleViewQuerySql, normalizeCanonical, parseDurationMs, trackedCellColumns, validateResolvedView };