@sequenceholdings/orm 0.1.2 → 2.0.0

package/dist/cli.js

@@ -5,9 +5,9 @@ import { fileURLToPath, pathToFileURL } from 'url';
 import { createJiti } from 'jiti';
 import { createHash } from 'crypto';
 import { z } from 'zod';
-import { buildSchema, parse, validate, Kind, valueFromASTUntyped, print } from 'graphql';
 import { sql } from 'drizzle-orm';
-import { pgSchema, primaryKey, uniqueIndex, index, foreignKey, jsonb, date, timestamp, boolean, doublePrecision, numeric, bigint, integer, text, uuid } from 'drizzle-orm/pg-core';
+import { pgSchema, PgDialect, QueryBuilder, getViewConfig, extractUsedTable, primaryKey, uniqueIndex, index, foreignKey, jsonb, date, timestamp, boolean, doublePrecision, numeric, bigint, integer, text, uuid } from 'drizzle-orm/pg-core';
+import { buildSchema, parse, validate, Kind, valueFromASTUntyped, print } from 'graphql';
 import { generateDrizzleJson, upPgSnapshot, generateMigration } from 'drizzle-kit/api';
 import { load } from 'js-yaml';
 import { capabilityPinsSchema, customRolesBlockSchema, validateCapabilityPins } from '@sequenceholdings/custom-roles-manifest';
@@ -108,8 +108,190 @@ var policyExpressionSchema = z.union([
 ]);
 var canonicalPoliciesSchema = z.object({
   read: policyExpressionSchema.optional(),
-  write: policyExpressionSchema.optional()
+  write: policyExpressionSchema.optional(),
+  insert: policyExpressionSchema.optional(),
+  update: policyExpressionSchema.optional()
 });
+function isSingleViewQuerySql(value) {
+  const query = value.trim();
+  if (!/^\(*(?:select|with)\b/i.test(query) || query.includes("\0")) return false;
+  let state = "normal";
+  for (let index3 = 0; index3 < query.length; index3 += 1) {
+    const char = query[index3];
+    const next = query[index3 + 1];
+    if (state === "single") {
+      if (char === "'" && next === "'") index3 += 1;
+      else if (char === "'") state = "normal";
+      continue;
+    }
+    if (state === "double") {
+      if (char === '"' && next === '"') index3 += 1;
+      else if (char === '"') state = "normal";
+      continue;
+    }
+    if (char === "'") state = "single";
+    else if (char === '"') state = "double";
+    else if (char === ";" || char === "-" && next === "-" || char === "/" && next === "*") return false;
+  }
+  return state === "normal" && !/\$[a-z_0-9]*\$/i.test(query);
+}
+var VIEW_QUERY_FUNCTION_ALLOWLIST = [
+  "abs",
+  "age",
+  "array_agg",
+  "array_append",
+  "array_cat",
+  "array_dims",
+  "array_length",
+  "array_lower",
+  "array_ndims",
+  "array_position",
+  "array_positions",
+  "array_prepend",
+  "array_remove",
+  "array_replace",
+  "array_to_string",
+  "array_trim",
+  "array_upper",
+  "ascii",
+  "avg",
+  "bit_and",
+  "bit_or",
+  "bit_xor",
+  "bool_and",
+  "bool_or",
+  "btrim",
+  "cardinality",
+  "cbrt",
+  "ceil",
+  "ceiling",
+  "char_length",
+  "character_length",
+  "chr",
+  "concat",
+  "concat_ws",
+  "count",
+  "cume_dist",
+  "date_bin",
+  "date_part",
+  "date_trunc",
+  "decode",
+  "degrees",
+  "dense_rank",
+  "encode",
+  "enum_first",
+  "enum_last",
+  "enum_range",
+  "every",
+  "exp",
+  "first_value",
+  "floor",
+  "format",
+  "grouping",
+  "initcap",
+  "json_agg",
+  "json_array_length",
+  "json_build_array",
+  "json_build_object",
+  "json_extract_path",
+  "json_extract_path_text",
+  "json_object_agg",
+  "json_object_keys",
+  "json_strip_nulls",
+  "json_typeof",
+  "jsonb_agg",
+  "jsonb_array_length",
+  "jsonb_build_array",
+  "jsonb_build_object",
+  "jsonb_extract_path",
+  "jsonb_extract_path_text",
+  "jsonb_insert",
+  "jsonb_object_agg",
+  "jsonb_object_keys",
+  "jsonb_path_exists",
+  "jsonb_path_match",
+  "jsonb_path_query",
+  "jsonb_path_query_array",
+  "jsonb_path_query_first",
+  "jsonb_pretty",
+  "jsonb_set",
+  "jsonb_set_lax",
+  "jsonb_strip_nulls",
+  "jsonb_typeof",
+  "justify_days",
+  "justify_hours",
+  "justify_interval",
+  "lag",
+  "last_value",
+  "lead",
+  "left",
+  "length",
+  "ln",
+  "log",
+  "lower",
+  "lpad",
+  "ltrim",
+  "make_date",
+  "make_interval",
+  "make_time",
+  "make_timestamp",
+  "make_timestamptz",
+  "max",
+  "md5",
+  "min",
+  "mod",
+  "nth_value",
+  "ntile",
+  "octet_length",
+  "percent_rank",
+  "pi",
+  "power",
+  "quote_ident",
+  "quote_literal",
+  "quote_nullable",
+  "radians",
+  "rank",
+  "regexp_count",
+  "regexp_instr",
+  "regexp_like",
+  "regexp_match",
+  "regexp_matches",
+  "regexp_replace",
+  "regexp_split_to_array",
+  "regexp_split_to_table",
+  "repeat",
+  "replace",
+  "reverse",
+  "right",
+  "round",
+  "row_number",
+  "rpad",
+  "rtrim",
+  "sign",
+  "split_part",
+  "sqrt",
+  "starts_with",
+  "string_agg",
+  "string_to_array",
+  "strpos",
+  "substr",
+  "substring",
+  "sum",
+  "timezone",
+  "to_ascii",
+  "to_char",
+  "to_date",
+  "to_hex",
+  "to_json",
+  "to_jsonb",
+  "to_number",
+  "to_timestamp",
+  "translate",
+  "trunc",
+  "unnest",
+  "upper",
+  "width_bucket"
+];
 var canonicalActionSchema = z.object({
   name: identifier,
   requires: z.string().max(1e3).optional(),
@@ -121,6 +303,37 @@ var canonicalActionSchema = z.object({
   returns: z.enum(["rows", "rowsAffected", "scalar"]).default("rowsAffected"),
   audit: z.object({ action: z.string(), resource: z.string() }).optional()
 });
+var canonicalCowMutationSchema = z.object({
+  kind: z.enum(["override", "revert"]),
+  name: identifier,
+  /** Synced table (same namespace) the overlay copies from / falls back to. */
+  synced: identifier,
+  /** Single-column primary key PROPERTY (TS camelCase, like column `name`) shared by overlay and synced. */
+  pk: z.string().min(1).max(63),
+  /** Override: contract properties copied INSERT…SELECT from synced (pk included). Empty for revert. */
+  copy: z.array(z.string().min(1).max(63)).default([]),
+  /** Override: overlay properties written by the UPDATE (never the pk). Empty for revert. */
+  set: z.array(z.string().min(1).max(63)).default([])
+}).superRefine((mutation, ctx) => {
+  if (mutation.kind === "override") {
+    if (mutation.set.length === 0) {
+      ctx.addIssue({ code: "custom", path: ["set"], message: "override mutations must set at least one column" });
+    }
+    if (!mutation.copy.includes(mutation.pk)) {
+      ctx.addIssue({ code: "custom", path: ["copy"], message: "override copy list must include the pk" });
+    }
+  } else if (mutation.set.length > 0 || mutation.copy.length > 0) {
+    ctx.addIssue({ code: "custom", path: ["set"], message: "revert mutations take no copy/set columns" });
+  }
+  if (mutation.set.includes(mutation.pk)) {
+    ctx.addIssue({ code: "custom", path: ["set"], message: "set must not include the pk \u2014 identity columns are pinned" });
+  }
+  for (const [field, values] of [["copy", mutation.copy], ["set", mutation.set]]) {
+    if (new Set(values).size !== values.length) {
+      ctx.addIssue({ code: "custom", path: [field], message: `${field} must not contain duplicate columns` });
+    }
+  }
+});
 var canonicalTableSchema = z.object({
   table: identifier,
   description: z.string().max(2e3).optional(),
@@ -133,7 +346,45 @@ var canonicalTableSchema = z.object({
   links: z.array(canonicalLinkSchema).default([]),
   indexes: z.array(canonicalIndexSchema).default([]),
   policies: canonicalPoliciesSchema.default({}),
-  actions: z.array(canonicalActionSchema).default([])
+  /**
+   * v1-conversion carry-over only. v2 has no action surface — the runtime
+   * neither compiles nor executes these; writes are mutations. Kept parseable
+   * so stored definitions and their content hashes stay stable.
+   */
+  actions: z.array(canonicalActionSchema).default([]),
+  /** Optional (not defaulted) so pre-CoW canonical documents keep byte-identical hashes. */
+  cowMutations: z.array(canonicalCowMutationSchema).optional()
+});
+var canonicalViewSchema = z.object({
+  view: identifier,
+  description: z.string().max(2e3).optional(),
+  columns: z.array(canonicalColumnSchema).min(1),
+  /** Logical identity for GraphQL only; PostgreSQL views have no PK constraint. */
+  primaryKey: z.array(identifier).min(1).max(8).optional(),
+  links: z.array(canonicalLinkSchema).default([]),
+  policies: z.object({ read: policyExpressionSchema }).strict(),
+  query: z.string().min(1).max(1e5).refine(isSingleViewQuerySql, {
+    message: "view query must be one SELECT/WITH statement without comments or dollar-quoted bodies"
+  }),
+  /** Namespace-local logical relation names, sorted for deterministic hashing. */
+  dependencies: z.array(identifier).max(500)
+}).superRefine((view, ctx) => {
+  for (const [index3, column] of view.columns.entries()) {
+    if (column.default !== void 0 || column.defaultFn !== void 0) {
+      ctx.addIssue({ code: "custom", path: ["columns", index3], message: `view column '${column.name}' cannot declare a default` });
+    }
+    if (column.unique) {
+      ctx.addIssue({ code: "custom", path: ["columns", index3], message: `view column '${column.name}' cannot declare unique` });
+    }
+    if (column.renamedFrom !== void 0 || column.cast !== void 0) {
+      ctx.addIssue({ code: "custom", path: ["columns", index3], message: `view column '${column.name}' cannot declare migration hints` });
+    }
+  }
+  for (const [index3, link] of view.links.entries()) {
+    if (link.enforce) {
+      ctx.addIssue({ code: "custom", path: ["links", index3, "enforce"], message: `view link '${link.name}' cannot enforce a foreign key` });
+    }
+  }
 });
 var canonicalDefinitionSchema = z.object({
   definition_format: z.literal(CANONICAL_FORMAT),
@@ -141,24 +392,174 @@ var canonicalDefinitionSchema = z.object({
   description: z.string().max(2e3).optional(),
   enums: z.array(canonicalEnumSchema).default([]),
   tables: z.array(canonicalTableSchema).min(0).max(500),
+  /** Optional to preserve byte-identical hashes for pre-view canonical v2 documents. */
+  views: z.array(canonicalViewSchema).max(500).optional(),
   /** Verbatim custom-roles grammar (@sequenceholdings/custom-roles-manifest). */
   capabilities: z.object({
     roles: z.unknown().optional(),
     uses: z.array(z.string()).default([])
   }).default({ uses: [] })
+}).superRefine((definition, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index3, table] of definition.tables.entries()) {
+    if (seen.has(table.table)) {
+      ctx.addIssue({ code: "custom", path: ["tables", index3, "table"], message: `duplicate relation '${table.table}'` });
+    }
+    seen.add(table.table);
+  }
+  const tableByName = new Map(definition.tables.map((table) => [table.table, table]));
+  for (const [tableIndex, table] of definition.tables.entries()) {
+    const cowMutations = table.cowMutations ?? [];
+    if (cowMutations.length === 0) continue;
+    const path = (index3, ...rest) => ["tables", tableIndex, "cowMutations", index3, ...rest];
+    if (table.source !== void 0) {
+      ctx.addIssue({ code: "custom", path: path(0), message: `synced table '${table.table}' cannot declare cow mutations \u2014 it is read-only` });
+      continue;
+    }
+    for (const [index3, mutation] of cowMutations.entries()) {
+      const synced = tableByName.get(mutation.synced);
+      if (!synced || synced.source === void 0) {
+        ctx.addIssue({
+          code: "custom",
+          path: path(index3, "synced"),
+          message: `cow mutation '${mutation.name}' references '${mutation.synced}', which is not a synced table in this namespace`
+        });
+        continue;
+      }
+      const overlayColumnsByName = new Map(table.columns.map((column) => [column.name, column]));
+      const syncedColumnsByName = new Map(synced.columns.map((column) => [column.name, column]));
+      let columnsExist = true;
+      for (const property of [mutation.pk, ...mutation.copy, ...mutation.set]) {
+        if (!overlayColumnsByName.has(property)) {
+          columnsExist = false;
+          ctx.addIssue({ code: "custom", path: path(index3), message: `cow mutation '${mutation.name}': column '${property}' does not exist on overlay '${table.table}'` });
+        }
+      }
+      for (const property of [mutation.pk, ...mutation.copy]) {
+        if (!syncedColumnsByName.has(property)) {
+          columnsExist = false;
+          ctx.addIssue({ code: "custom", path: path(index3), message: `cow mutation '${mutation.name}': column '${property}' does not exist on synced '${mutation.synced}'` });
+        }
+      }
+      if (!columnsExist) continue;
+      const overlayPk = table.primaryKey ?? [];
+      const syncedPk = synced.primaryKey ?? [];
+      if (overlayPk.length !== 1 || overlayPk[0] !== mutation.pk || syncedPk.length !== 1 || syncedPk[0] !== mutation.pk) {
+        ctx.addIssue({
+          code: "custom",
+          path: path(index3, "pk"),
+          message: `cow mutation '${mutation.name}': pk '${mutation.pk}' must be the single-column primary key on both '${table.table}' and '${mutation.synced}'`
+        });
+      }
+      for (const property of [mutation.pk, ...mutation.copy]) {
+        const overlayColumn = overlayColumnsByName.get(property);
+        const syncedColumn = syncedColumnsByName.get(property);
+        if (!overlayColumn || !syncedColumn) continue;
+        if (JSON.stringify(overlayColumn.type) !== JSON.stringify(syncedColumn.type)) {
+          ctx.addIssue({
+            code: "custom",
+            path: path(index3),
+            message: `cow mutation '${mutation.name}': column '${property}' must have the same type on overlay and synced`
+          });
+        }
+        if (overlayColumn.columnName !== syncedColumn.columnName) {
+          ctx.addIssue({
+            code: "custom",
+            path: path(index3),
+            message: `cow mutation '${mutation.name}': column '${property}' maps to different Postgres names on overlay ('${overlayColumn.columnName}') and synced ('${syncedColumn.columnName}')`
+          });
+        }
+        if (syncedColumn.nullable !== false && overlayColumn.nullable === false) {
+          ctx.addIssue({
+            code: "custom",
+            path: path(index3),
+            message: `cow mutation '${mutation.name}': column '${property}' is nullable on synced but NOT NULL on overlay \u2014 a NULL synced value would fail the copy`
+          });
+        }
+      }
+    }
+  }
+  for (const [index3, view] of (definition.views ?? []).entries()) {
+    if (seen.has(view.view)) {
+      ctx.addIssue({ code: "custom", path: ["views", index3, "view"], message: `duplicate relation '${view.view}'` });
+    }
+    seen.add(view.view);
+  }
+  const views = definition.views ?? [];
+  const viewByName = new Map(views.map((view) => [view.view, view]));
+  for (const [viewIndex, view] of views.entries()) {
+    for (const [dependencyIndex, dependency] of view.dependencies.entries()) {
+      if (!seen.has(dependency)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["views", viewIndex, "dependencies", dependencyIndex],
+          message: `view '${view.view}' depends on unknown relation '${dependency}'`
+        });
+      }
+    }
+  }
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  let cycleReported = false;
+  const visit = (name, path) => {
+    if (visited.has(name) || cycleReported) return;
+    if (visiting.has(name)) {
+      cycleReported = true;
+      ctx.addIssue({
+        code: "custom",
+        path: ["views"],
+        message: `view dependencies form a cycle: ${[...path, name].join(" -> ")}`
+      });
+      return;
+    }
+    visiting.add(name);
+    const view = viewByName.get(name);
+    for (const dependency of view?.dependencies ?? []) {
+      if (viewByName.has(dependency)) visit(dependency, [...path, name]);
+    }
+    visiting.delete(name);
+    visited.add(name);
+  };
+  for (const view of views) visit(view.view, []);
 });
+function canonicalRelations(definition) {
+  const views = (definition.views ?? []).map((view) => ({
+    table: view.view,
+    ...view.description !== void 0 ? { description: view.description } : {},
+    columns: view.columns,
+    ...view.primaryKey !== void 0 ? { primaryKey: view.primaryKey } : {},
+    links: view.links,
+    indexes: [],
+    policies: { read: view.policies.read },
+    actions: []
+  }));
+  return [...definition.tables, ...views].sort((a, b) => a.table.localeCompare(b.table));
+}
 function normalizeCanonical(definition) {
   const sortByName = (items) => [...items].sort((a, b) => a.name.localeCompare(b.name));
-  return {
+  const normalized = {
     ...definition,
     enums: sortByName(definition.enums),
-    tables: [...definition.tables].sort((a, b) => a.table.localeCompare(b.table)).map((t2) => ({
-      ...t2,
-      links: sortByName(t2.links),
-      indexes: [...t2.indexes].sort((a, b) => (a.name ?? a.columns.join("_")).localeCompare(b.name ?? b.columns.join("_"))),
-      actions: sortByName(t2.actions)
-    }))
+    tables: [...definition.tables].sort((a, b) => a.table.localeCompare(b.table)).map((t2) => {
+      const { cowMutations, ...rest } = t2;
+      return {
+        ...rest,
+        links: sortByName(t2.links),
+        indexes: [...t2.indexes].sort((a, b) => (a.name ?? a.columns.join("_")).localeCompare(b.name ?? b.columns.join("_"))),
+        actions: sortByName(t2.actions),
+        // Omitted entirely when absent/empty so pre-CoW documents hash unchanged.
+        ...cowMutations !== void 0 && cowMutations.length > 0 ? { cowMutations: sortByName(cowMutations) } : {}
+      };
+    })
   };
+  if (definition.views !== void 0) {
+    normalized.views = [...definition.views].sort((a, b) => a.view.localeCompare(b.view)).map((view) => ({
+      ...view,
+      links: sortByName(view.links),
+      dependencies: [...view.dependencies].sort()
+    }));
+  }
+  return normalized;
 }
 
 // src/constants.ts
@@ -199,9 +600,13 @@ function canonicalTable(table) {
     source: table.source ?? null,
     links: emptyToNull(table.links),
     indexes: emptyToNull(table.indexes),
+    // insert/update are omitted rather than nulled when absent, so definitions
+    // predating split policies keep the hash they were registered under.
     policies: {
       read: table.policies?.read?.source ?? null,
-      write: table.policies?.write?.source ?? null
+      write: table.policies?.write?.source ?? null,
+      ...table.policies?.insert !== void 0 ? { insert: table.policies.insert.source } : {},
+      ...table.policies?.update !== void 0 ? { update: table.policies.update.source } : {}
     },
     actions: emptyToNull(
       Object.fromEntries(
@@ -273,7 +678,7 @@ function contextStack() {
   return created;
 }
 function beginAuthoringContext() {
-  const context = { currentFile: void 0, tables: [], enums: [], configs: [] };
+  const context = { currentFile: void 0, tables: [], views: [], enums: [], configs: [] };
   contextStack().push(context);
   return context;
 }
@@ -291,6 +696,155 @@ var TABLE_BRAND = "seq-table";
 function isSeqTable(value) {
   return typeof value === "object" && value !== null && value.kind === TABLE_BRAND;
 }
+var VIEW_BRAND = "seq-view";
+function isSeqView(value) {
+  return typeof value === "object" && value !== null && value.kind === VIEW_BRAND;
+}
+var QUERY_COLUMN_FACTORIES = {
+  uuid: (name) => uuid(name),
+  text: (name) => text(name),
+  integer: (name) => integer(name),
+  bigint: (name) => bigint(name, { mode: "bigint" }),
+  numeric: (name) => numeric(name),
+  double: (name) => doublePrecision(name),
+  boolean: (name) => boolean(name),
+  timestamptz: (name) => timestamp(name, { withTimezone: true }),
+  date: (name) => date(name),
+  jsonb: (name) => jsonb(name)
+};
+function compileViewQueries(input) {
+  const schemaName = `orm_${input.namespace}`;
+  const schema = pgSchema(schemaName);
+  const enumFactories = /* @__PURE__ */ new Map();
+  for (const entry of input.enums) {
+    const values = entry.values;
+    enumFactories.set(entry.name, schema.enum(entry.name, values));
+  }
+  const handles = /* @__PURE__ */ new Map();
+  const physicalToLogical = /* @__PURE__ */ new Map();
+  const tableByName = new Map(input.tables.map((table) => [table.table, table]));
+  for (const authored of input.authoredTables) {
+    const canonical = tableByName.get(authored.tableName);
+    if (!canonical) continue;
+    const physicalSchema = schemaName;
+    const physicalName = canonical.table;
+    const relationSchema = pgSchema(physicalSchema);
+    const columns = buildQueryColumns(canonical.columns, enumFactories);
+    const handle = relationSchema.table(physicalName, columns);
+    handles.set(authored, handle);
+    physicalToLogical.set(`${physicalSchema}.${physicalName}`, canonical.table);
+  }
+  const viewByName = new Map(input.views.map((view) => [view.view, view]));
+  for (const authored of input.authoredViews) {
+    const canonical = viewByName.get(authored.viewName);
+    if (!canonical) continue;
+    const columns = buildQueryColumns(canonical.columns, enumFactories);
+    const handle = schema.view(canonical.view, columns).existing();
+    handles.set(authored, handle);
+    physicalToLogical.set(`${schemaName}.${canonical.view}`, canonical.view);
+  }
+  const dialect = new PgDialect();
+  const compiled = /* @__PURE__ */ new Map();
+  for (const authored of input.authoredViews) {
+    const expectedFields = Object.keys(authored.columns);
+    const declaredDependencies = /* @__PURE__ */ new Set();
+    const relation = (ref) => {
+      let resolved;
+      try {
+        resolved = typeof ref === "function" ? ref() : ref;
+      } catch (error) {
+        throw new OrmDefinitionError(
+          `view "${authored.viewName}" relation thunk threw: ${error instanceof Error ? error.message : String(error)}`,
+          authored.file
+        );
+      }
+      if (!isSeqTable(resolved) && !isSeqView(resolved)) {
+        throw new OrmDefinitionError(
+          `view "${authored.viewName}" relation() expects a table or view defined by this ORM`,
+          authored.file
+        );
+      }
+      const handle = handles.get(resolved);
+      if (!handle) {
+        const name = isSeqTable(resolved) ? resolved.tableName : resolved.viewName;
+        throw new OrmDefinitionError(
+          `view "${authored.viewName}" references relation "${name}" which is not part of this namespace`,
+          authored.file
+        );
+      }
+      declaredDependencies.add(isSeqTable(resolved) ? resolved.tableName : resolved.viewName);
+      return handle;
+    };
+    let queryBuilder;
+    try {
+      queryBuilder = authored.config.query({ qb: new QueryBuilder(), relation });
+    } catch (error) {
+      if (error instanceof OrmDefinitionError) throw error;
+      throw new OrmDefinitionError(
+        `view "${authored.viewName}" query callback failed: ${error instanceof Error ? error.message : String(error)}`,
+        authored.file
+      );
+    }
+    let config;
+    try {
+      config = getViewConfig(schema.view(authored.viewName).as(queryBuilder));
+    } catch (error) {
+      throw new OrmDefinitionError(
+        `view "${authored.viewName}" query must return a Drizzle select builder: ${error instanceof Error ? error.message : String(error)}`,
+        authored.file
+      );
+    }
+    const selectedFields = Object.keys(config.selectedFields);
+    if (selectedFields.length !== expectedFields.length || selectedFields.some((field, index3) => field !== expectedFields[index3])) {
+      throw new OrmDefinitionError(
+        `view "${authored.viewName}" query selects [${selectedFields.join(", ")}], but declared columns are [${expectedFields.join(", ")}]`,
+        authored.file
+      );
+    }
+    if (!config.query) throw new OrmDefinitionError(`view "${authored.viewName}" produced no query`, authored.file);
+    const tableDependencies = extractUsedTable(config.query).map((physical) => {
+      const logical = physicalToLogical.get(physical);
+      if (!logical) {
+        throw new OrmDefinitionError(
+          `view "${authored.viewName}" query references unmanaged relation "${physical}" \u2014 use relation(...) with a namespace table or view`,
+          authored.file
+        );
+      }
+      return logical;
+    });
+    const renderedQuery = dialect.sqlToQuery(config.query.inlineParams());
+    if (renderedQuery.params.length > 0) {
+      throw new OrmDefinitionError(
+        `view "${authored.viewName}" query produced bind parameters which cannot be persisted in view DDL`,
+        authored.file
+      );
+    }
+    compiled.set(authored.viewName, {
+      query: renderedQuery.sql,
+      dependencies: [.../* @__PURE__ */ new Set([...declaredDependencies, ...tableDependencies])].sort()
+    });
+  }
+  return compiled;
+}
+function buildQueryColumns(columns, enumFactories) {
+  return Object.fromEntries(columns.map((column) => [column.name, buildQueryColumn(column, enumFactories)]));
+}
+function buildQueryColumn(column, enumFactories) {
+  const factory = typeof column.type === "string" ? QUERY_COLUMN_FACTORIES[column.type] : enumFactories.get(column.type.enum);
+  if (!factory) {
+    const type = typeof column.type === "string" ? column.type : column.type.enum;
+    throw new OrmDefinitionError(`view query column '${column.columnName}' references unknown type '${type}'`);
+  }
+  let builder = factory(column.columnName);
+  if (!column.nullable) builder = builder.notNull();
+  return builder;
+}
+function relationName(relation) {
+  return isSeqTable(relation) ? relation.tableName : relation.viewName;
+}
+function relationKind(relation) {
+  return isSeqTable(relation) ? "table" : "view";
+}
 
 // src/authoring/namespace.ts
 var NAMESPACE_CONFIG_BRAND = "seq-namespace-config";
@@ -299,6 +853,7 @@ function isSeqNamespaceConfig(value) {
 }
 function serializeNamespace(input) {
   const { config, tables } = input;
+  const views = input.views ?? [];
   const enums = input.enums ?? [];
   const tablesByName = /* @__PURE__ */ new Map();
   for (const table of tables) {
@@ -311,6 +866,29 @@ function serializeNamespace(input) {
     }
     tablesByName.set(table.tableName, table);
   }
+  const viewsByName = /* @__PURE__ */ new Map();
+  for (const view of views) {
+    const existing = viewsByName.get(view.viewName);
+    if (existing) {
+      throw new OrmDefinitionError(
+        `duplicate view "${view.viewName}" (defined in ${describeFile(existing)} and ${describeFile(view)})`,
+        view.file
+      );
+    }
+    viewsByName.set(view.viewName, view);
+  }
+  const relationsByName = /* @__PURE__ */ new Map();
+  for (const relation of [...tables, ...views]) {
+    const name = relationName(relation);
+    const existing = relationsByName.get(name);
+    if (existing) {
+      throw new OrmDefinitionError(
+        `duplicate relation "${name}" (defined as ${relationKind(existing)} in ${describeFile(existing)} and ${relationKind(relation)} in ${describeFile(relation)})`,
+        relation.file
+      );
+    }
+    relationsByName.set(name, relation);
+  }
   const enumsByName = /* @__PURE__ */ new Map();
   for (const ref of enums) {
     if (enumsByName.has(ref.name)) {
@@ -318,11 +896,26 @@ function serializeNamespace(input) {
     }
     enumsByName.set(ref.name, ref);
   }
-  const canonicalTables = tables.map((table) => buildCanonicalTable({ table, tablesByName, enumsByName }));
+  const canonicalTables = tables.map((table) => buildCanonicalTable({ table, relationsByName, enumsByName }));
   const canonicalEnums = [...enumsByName.values()].map((ref) => ({
     name: ref.name,
     values: [...ref.values]
   }));
+  const viewDrafts = views.map((view) => buildCanonicalView({ view, relationsByName, enumsByName }));
+  const compiledViews = compileViewQueries({
+    namespace: config.namespace,
+    tables: canonicalTables,
+    views: viewDrafts,
+    enums: canonicalEnums,
+    authoredTables: tables,
+    authoredViews: views
+  });
+  const canonicalViews = viewDrafts.map((draft) => {
+    const compiled = compiledViews.get(draft.view);
+    if (!compiled) throw new OrmDefinitionError(`view "${draft.view}" did not compile`, viewsByName.get(draft.view)?.file);
+    return canonicalViewSchema.parse({ ...draft, ...compiled });
+  });
+  assertAcyclicViewDependencies(canonicalViews);
   const candidate = {
     definition_format: CANONICAL_FORMAT,
     namespace: config.namespace,
@@ -334,6 +927,7 @@ function serializeNamespace(input) {
     }
   };
   if (config.description !== void 0) candidate.description = config.description;
+  if (canonicalViews.length > 0) candidate.views = canonicalViews;
   let parsed;
   try {
     parsed = canonicalDefinitionSchema.parse(candidate);
@@ -348,7 +942,7 @@ function serializeNamespace(input) {
 function computeCanonicalHash(definition) {
   return createHash("sha256").update(HASH_DOMAIN).update(stableJson(definition)).digest("hex");
 }
-function buildCanonicalTable({ table, tablesByName, enumsByName }) {
+function buildCanonicalTable({ table, relationsByName, enumsByName }) {
   const candidate = {
     table: table.tableName,
     columns: [],
@@ -360,6 +954,31 @@ function buildCanonicalTable({ table, tablesByName, enumsByName }) {
   if (table.config.description !== void 0) candidate.description = table.config.description;
   if (table.config.renamedFrom !== void 0) candidate.renamedFrom = table.config.renamedFrom;
   if (table.source !== void 0) candidate.source = table.source;
+  if (table.source !== void 0) {
+    if (table.config.indexes !== void 0 && table.config.indexes.length > 0) {
+      throw new OrmDefinitionError(
+        `synced table "${table.tableName}" is system-owned; indexes are not allowed`,
+        table.file
+      );
+    }
+    if (table.config.cowMutations !== void 0 && table.config.cowMutations.length > 0) {
+      throw new OrmDefinitionError(
+        `synced table "${table.tableName}" is read-only; cow mutations belong on the overlay table`,
+        table.file
+      );
+    }
+    if (table.config.policies?.write !== void 0 || table.config.policies?.insert !== void 0 || table.config.policies?.update !== void 0) {
+      throw new OrmDefinitionError(`synced table "${table.tableName}" is read-only`, table.file);
+    }
+    for (const [linkName, link] of Object.entries(table.config.links ?? {})) {
+      if (link.enforce) {
+        throw new OrmDefinitionError(
+          `synced table "${table.tableName}": link "${linkName}" cannot enforce foreign keys \u2014 its DDL is owned by the sync`,
+          table.file
+        );
+      }
+    }
+  }
   const columnLevelPk = [];
   for (const [propertyName, builder] of Object.entries(table.columns)) {
     const column = builder.toCanonicalColumn(propertyName);
@@ -381,40 +1000,38 @@ function buildCanonicalTable({ table, tablesByName, enumsByName }) {
       );
     }
     candidate.primaryKey = table.config.primaryKey.map(
-      (ref) => resolveColumnRef({ table, ref, role: "primaryKey" })
+      (ref) => resolveColumnRef({ relation: table, ref, role: "primaryKey" })
     );
   } else if (columnLevelPk.length > 0) {
     candidate.primaryKey = columnLevelPk;
   }
   for (const index3 of table.config.indexes ?? []) {
     const entry = {
-      columns: index3.columns.map((ref) => resolveColumnRef({ table, ref, role: "index" }))
+      columns: index3.columns.map((ref) => resolveColumnRef({ relation: table, ref, role: "index" }))
     };
     if (index3.unique !== void 0) entry.unique = index3.unique;
     if (index3.name !== void 0) entry.name = index3.name;
     candidate.indexes?.push(entry);
   }
   for (const [linkName, link] of Object.entries(table.config.links ?? {})) {
-    candidate.links?.push(buildCanonicalLink({ table, linkName, link, tablesByName }));
+    candidate.links?.push(buildCanonicalLink({ relation: table, linkName, link, relationsByName }));
   }
   const policies = {};
   if (table.config.policies?.read !== void 0) policies.read = toCanonicalPolicy(table.config.policies.read);
   if (table.config.policies?.write !== void 0) policies.write = toCanonicalPolicy(table.config.policies.write);
+  if (table.config.policies?.insert !== void 0) policies.insert = toCanonicalPolicy(table.config.policies.insert);
+  if (table.config.policies?.update !== void 0) policies.update = toCanonicalPolicy(table.config.policies.update);
   candidate.policies = policies;
-  for (const action of table.config.actions ?? []) {
-    candidate.actions?.push({
-      name: action.name,
-      ...action.requires !== void 0 ? { requires: action.requires } : {},
-      params: Object.fromEntries(
-        Object.entries(action.params ?? {}).map(([name, param]) => [
-          name,
-          { type: param.type, nullable: param.nullable ?? false }
-        ])
-      ),
-      executes: action.executes,
-      returns: action.returns ?? "rowsAffected",
-      ...action.audit !== void 0 ? { audit: action.audit } : {}
-    });
+  const cowMutations = table.config.cowMutations ?? [];
+  if (cowMutations.length > 0) {
+    candidate.cowMutations = cowMutations.map((mutation) => ({
+      kind: mutation.kind,
+      name: mutation.name,
+      synced: mutation.synced,
+      pk: mutation.pk,
+      copy: [...mutation.copy],
+      set: [...mutation.set]
+    }));
   }
   try {
     return canonicalTableSchema.parse(candidate);
@@ -425,14 +1042,71 @@ function buildCanonicalTable({ table, tablesByName, enumsByName }) {
     throw error;
   }
 }
+function buildCanonicalView({
+  view,
+  relationsByName,
+  enumsByName
+}) {
+  if (view.config.policies?.read === void 0) {
+    throw new OrmDefinitionError(`view "${view.viewName}" must declare policies.read`, view.file);
+  }
+  const columns = [];
+  const columnLevelPk = [];
+  for (const [propertyName, builder] of Object.entries(view.columns)) {
+    const column = builder.toCanonicalColumn(propertyName);
+    if (column.default !== void 0 || column.defaultFn !== void 0) {
+      throw new OrmDefinitionError(`view "${view.viewName}": column "${propertyName}" cannot declare a default`, view.file);
+    }
+    if (column.unique) {
+      throw new OrmDefinitionError(`view "${view.viewName}": column "${propertyName}" cannot declare unique`, view.file);
+    }
+    if (column.renamedFrom !== void 0 || column.cast !== void 0) {
+      throw new OrmDefinitionError(`view "${view.viewName}": column "${propertyName}" cannot declare migration hints`, view.file);
+    }
+    const enumName = builder.enumName;
+    if (enumName !== void 0 && !enumsByName.has(enumName)) {
+      throw new OrmDefinitionError(
+        `view "${view.viewName}": column "${propertyName}" references enum "${enumName}" which is not part of this namespace`,
+        view.file
+      );
+    }
+    if (builder.isPrimaryKey) columnLevelPk.push(column.columnName);
+    columns.push(column);
+  }
+  let primaryKey2;
+  if (view.config.primaryKey !== void 0) {
+    if (columnLevelPk.length > 0) {
+      throw new OrmDefinitionError(
+        `view "${view.viewName}": declare the logical primary key either on columns or with config.primaryKey \u2014 not both`,
+        view.file
+      );
+    }
+    primaryKey2 = view.config.primaryKey.map((ref) => resolveColumnRef({ relation: view, ref, role: "primaryKey" }));
+  } else if (columnLevelPk.length > 0) {
+    primaryKey2 = columnLevelPk;
+  }
+  const links = Object.entries(view.config.links ?? {}).map(
+    ([linkName, link]) => buildCanonicalLink({ relation: view, linkName, link, relationsByName })
+  );
+  return {
+    view: view.viewName,
+    ...view.config.description !== void 0 ? { description: view.config.description } : {},
+    columns,
+    ...primaryKey2 !== void 0 ? { primaryKey: primaryKey2 } : {},
+    links,
+    policies: { read: toCanonicalPolicy(view.config.policies.read) }
+  };
+}
 function buildCanonicalLink({
-  table,
+  relation,
   linkName,
   link,
-  tablesByName
+  relationsByName
 }) {
+  const ownerKind = relationKind(relation);
+  const ownerName = relationName(relation);
   const fail2 = (message) => {
-    throw new OrmDefinitionError(`table "${table.tableName}": link "${linkName}" ${message}`, table.file);
+    throw new OrmDefinitionError(`${ownerKind} "${ownerName}": link "${linkName}" ${message}`, relation.file);
   };
   if (link.enforce && link.linkKind !== "toOne") {
     return fail2("sets enforce: true, which is only supported on toOne links");
@@ -442,29 +1116,34 @@ function buildCanonicalLink({
     return {
       name: linkName,
       kind: "toPlatformUser",
-      on: resolveColumnRef({ table, ref: link.on, role: `link "${linkName}" on` }),
+      on: resolveColumnRef({ relation, ref: link.on, role: `link "${linkName}" on` }),
       ...link.references !== void 0 ? { references: deriveColumnName(link.references) } : {},
       enforce: false,
       ...link.description !== void 0 ? { description: link.description } : {}
     };
   }
-  const target = resolveTableRef({ ref: link.target, fail: fail2 });
-  if (!tablesByName.has(target.tableName)) {
-    return fail2(`targets table "${target.tableName}" which is not part of this namespace`);
+  const target = resolveRelationRef({ ref: link.target, fail: fail2 });
+  const targetName = relationName(target);
+  if (!relationsByName.has(targetName)) {
+    return fail2(`targets ${relationKind(target)} "${targetName}" which is not part of this namespace`);
+  }
+  if (link.enforce && (!isSeqTable(relation) || !isSeqTable(target))) {
+    return fail2("cannot enforce a PostgreSQL foreign key involving a view");
   }
-  const owningSide = link.linkKind === "toOne" ? table : target;
+  const owningSide = link.linkKind === "toOne" ? relation : target;
+  const referencedSide = link.linkKind === "toOne" ? target : relation;
   return {
     name: linkName,
     kind: link.linkKind,
-    target: target.tableName,
-    on: resolveColumnRef({ table: owningSide, ref: link.on, role: `link "${linkName}" on` }),
-    ...link.references !== void 0 ? { references: resolveColumnRef({ table: target, ref: link.references, role: `link "${linkName}" references` }) } : {},
+    target: targetName,
+    on: resolveColumnRef({ relation: owningSide, ref: link.on, role: `link "${linkName}" on` }),
+    ...link.references !== void 0 ? { references: resolveColumnRef({ relation: referencedSide, ref: link.references, role: `link "${linkName}" references` }) } : {},
     enforce: link.enforce,
     ...link.description !== void 0 ? { description: link.description } : {}
   };
 }
-function resolveTableRef({ ref, fail: fail2 }) {
-  if (ref === void 0) return fail2("declares no target table");
+function resolveRelationRef({ ref, fail: fail2 }) {
+  if (ref === void 0) return fail2("declares no target relation");
   if (typeof ref !== "function") return ref;
   let resolved;
   try {
@@ -474,21 +1153,36 @@ function resolveTableRef({ ref, fail: fail2 }) {
       `target thunk threw (${error instanceof Error ? error.message : String(error)}) \u2014 lazy refs resolve at serialize time; make sure the target module ran`
     );
   }
-  if (!isSeqTable(resolved)) return fail2("target thunk did not return a table defined with defineTable");
+  if (!isSeqTable(resolved) && !isSeqView(resolved)) {
+    return fail2("target thunk did not return a relation defined with defineTable/defineView");
+  }
   return resolved;
 }
-function resolveColumnRef({ table, ref, role }) {
-  const direct = table.columns[ref];
+function resolveColumnRef({ relation, ref, role }) {
+  const direct = relation.columns[ref];
   if (direct) return direct.columnNameFor(ref);
-  for (const [propertyName, builder] of Object.entries(table.columns)) {
+  for (const [propertyName, builder] of Object.entries(relation.columns)) {
     if (builder.columnNameFor(propertyName) === ref) return ref;
   }
-  const known = Object.keys(table.columns).join(", ");
+  const known = Object.keys(relation.columns).join(", ");
   throw new OrmDefinitionError(
-    `table "${table.tableName}": ${role} references unknown column "${ref}" (known columns: ${known || "none"})`,
-    table.file
+    `${relationKind(relation)} "${relationName(relation)}": ${role} references unknown column "${ref}" (known columns: ${known || "none"})`,
+    relation.file
   );
 }
+function assertAcyclicViewDependencies(views) {
+  const viewNames = new Set(views.map((view) => view.view));
+  const remaining = new Map(
+    views.map((view) => [view.view, new Set(view.dependencies.filter((dependency) => viewNames.has(dependency)))])
+  );
+  while (remaining.size > 0) {
+    const ready = [...remaining.entries()].filter(([, dependencies]) => [...dependencies].every((dependency) => !remaining.has(dependency))).map(([name]) => name);
+    if (ready.length === 0) {
+      throw new OrmDefinitionError(`view dependencies form a cycle among: ${[...remaining.keys()].sort().join(", ")}`);
+    }
+    for (const name of ready) remaining.delete(name);
+  }
+}
 function toCanonicalPolicy(policy) {
   if (typeof policy === "string") return policy;
   return {
@@ -500,8 +1194,8 @@ function toCanonicalPolicy(policy) {
     }))
   };
 }
-function describeFile(table) {
-  return table.file ?? "<unknown file>";
+function describeFile(relation) {
+  return relation.file ?? "<unknown file>";
 }
 function formatZodIssues(error) {
   return error.issues.map((issue) => issue.path.length > 0 ? `${issue.path.join(".")}: ${issue.message}` : issue.message).join("; ");
@@ -525,7 +1219,12 @@ async function loadNamespaceFromDir(dir, options = {}) {
   const jiti = createJiti(import.meta.url, {
     interopDefault: true,
     fsCache: false,
-    ...options.ormModulePath !== void 0 ? { alias: { "@sequenceholdings/orm": options.ormModulePath } } : {}
+    ...options.ormModulePath !== void 0 ? {
+      alias: {
+        "@sequenceholdings/orm": options.ormModulePath,
+        "@sequenceholdings/orm/authoring": options.ormModulePath
+      }
+    } : {}
   });
   const context = beginAuthoringContext();
   try {
@@ -566,16 +1265,20 @@ async function loadNamespaceFromDir(dir, options = {}) {
   for (const entry of context.tables) {
     if (isSeqTable(entry.value)) tables.push(entry.value);
   }
-  if (tables.length === 0) {
+  const views = [];
+  for (const entry of context.views) {
+    if (isSeqView(entry.value)) views.push(entry.value);
+  }
+  if (tables.length === 0 && views.length === 0) {
     throw new OrmDefinitionError(
-      `no tables registered \u2014 ${SCHEMA_DIR}/*.ts modules must call defineTable(...) at import time`
+      `no relations registered \u2014 ${SCHEMA_DIR}/*.ts modules must call defineTable(...) or defineView(...) at import time`
     );
   }
   const enums = [];
   for (const entry of context.enums) {
     if (isEnumRef(entry.value)) enums.push(entry.value);
   }
-  const canonical = serializeNamespace({ config: configEntry.value, tables, enums });
+  const canonical = serializeNamespace({ config: configEntry.value, tables, views, enums });
   return { canonical, hash: computeCanonicalHash(canonical), files };
 }
 async function listSchemaFiles(root) {
@@ -609,10 +1312,10 @@ var manifestRequiresSchema = z.object({
 }).nullable();
 var manifestOperationSchema = z.object({
   hash: z.string().regex(OP_HASH_RE),
-  kind: z.enum(["query", "mutation", "action"]),
+  kind: z.enum(["query", "mutation"]),
   requires: manifestRequiresSchema
 });
-z.object({
+var operationsManifestSchema = z.object({
   manifestVersion: z.literal(MANIFEST_VERSION),
   schemaHash: z.string().min(1),
   opsHash: z.string().regex(OP_HASH_RE),
@@ -772,14 +1475,14 @@ function generateTypePolicies(canonical) {
   const def = normalizeCanonical(canonicalDefinitionSchema.parse(canonical));
   const entries = [];
   let hasPlatformUser = false;
-  for (const table of def.tables) {
+  for (const table of canonicalRelations(def)) {
     if (table.source !== void 0) continue;
     if (table.links.some((link) => link.kind === "toPlatformUser")) hasPlatformUser = true;
     if (!table.primaryKey || table.primaryKey.length === 0) continue;
     const keyFields = table.primaryKey.map((identifier2) => {
       const column = table.columns.find((c) => c.columnName === identifier2 || c.name === identifier2);
       if (!column) {
-        throw new CodegenGqlError(`Primary key column "${identifier2}" not found on table "${table.table}".`);
+        throw new CodegenGqlError(`Primary key column "${identifier2}" not found on relation "${table.table}".`);
       }
       return fieldName(column.name);
     });
@@ -933,9 +1636,23 @@ var onConflictIrSchema = z.union([
 ]);
 var mutationRootSchema = z.object({
   kind: z.literal("mutation"),
-  op: z.enum(["insert", "insertOne", "update", "updateByPk", "delete", "deleteByPk"]),
+  /**
+   * CRUD verbs plus the structured copy-on-write ops. `cowOverride` copies the
+   * synced row into the overlay (INSERT…SELECT, ON CONFLICT DO NOTHING) then
+   * applies `set` — both statements generated by the executor from this
+   * metadata, never authored SQL. `cowRevert` deletes the override so the
+   * coalesce view falls back to synced. Both are gated on a matching synced
+   * row and carry the write policy in `where` like update/delete.
+   */
+  op: z.enum(["insert", "insertOne", "update", "updateByPk", "delete", "deleteByPk", "cowOverride", "cowRevert"]),
   alias: z.string(),
   table: z.string(),
+  /** CoW ops: logical name of the synced twin (read through its policy-filtered view). */
+  cowSynced: z.string().optional(),
+  /** cowOverride: logical properties copied INSERT…SELECT from synced (pk included). */
+  cowCopyColumns: z.array(z.string()).optional(),
+  /** cowOverride: insert-policy WITH CHECK evaluated over the copied rows. */
+  cowCopyCheck: predIrSchema.optional(),
   /** insert/insertOne: rows come from a slot ($object/$objects) or literals. */
   objects: z.union([
     z.object({ slot: z.string() }),
@@ -956,19 +1673,11 @@ var mutationRootSchema = z.object({
   affectedRows: z.boolean().default(false),
   includeIf: includeIfSchema.optional()
 });
-var actionRootSchema = z.object({
-  kind: z.literal("action"),
-  alias: z.string(),
-  name: z.string(),
-  params: z.array(z.object({ name: z.string(), value: valueIrSchema })),
-  returns: z.enum(["rows", "rowsAffected", "scalar"])
-});
 var rootIrSchema = z.discriminatedUnion("kind", [
   selectRootSchema,
   byPkRootSchema,
   aggregateRootSchema,
-  mutationRootSchema,
-  actionRootSchema
+  mutationRootSchema
 ]);
 var INPUT_REF_KINDS = [
   "boolExp",
@@ -1000,7 +1709,7 @@ var compiledOperationSchema = z.object({
   irVersion: z.literal(IR_VERSION),
   name: z.string(),
   opHash: z.string().regex(/^sha256:[0-9a-f]{64}$/),
-  kind: z.enum(["query", "mutation", "action"]),
+  kind: z.enum(["query", "mutation"]),
   requires: z.object({
     capability: z.string().optional(),
     role: z.string().optional()
@@ -1014,13 +1723,24 @@ var tableMetaIrSchema = z.object({
   table: z.string(),
   schema: z.string(),
   typename: z.string(),
+  /**
+   * True when statements over this relation evaluate a claims-gated synced
+   * view: synced twins (`source: gold.*`) materialize as views whose baked
+   * policy reads `current_setting('request.jwt.claims')`, and namespace views
+   * inherit the gate transitively through their declared dependencies. The
+   * executor must stamp that GUC (transaction-scoped) before any statement
+   * touching such a relation, or the synced arm yields zero rows regardless
+   * of the compiled predicates.
+   */
+  claimsGated: z.boolean().default(false),
   columns: z.array(z.object({
     name: z.string(),
     columnName: z.string(),
     type: z.union([z.enum(COLUMN_TYPES), z.object({ enum: z.string(), values: z.array(z.string()) })]),
     nullable: z.boolean()
   })),
-  primaryKey: z.array(z.string()).min(1),
+  /** Empty for keyless read-only views; keyed tables and views list logical columns. */
+  primaryKey: z.array(z.string()),
   links: z.array(z.object({
     name: z.string(),
     kind: z.enum(["toOne", "toMany", "toPlatformUser"]),
@@ -1206,6 +1926,10 @@ var Parser = class {
       this.expect("rparen", "')'");
       return inner;
     }
+    if (this.peekKeyword("true") || this.peekKeyword("false")) {
+      const token = this.advance();
+      return { kind: "literal", value: token.value === "true" };
+    }
     if (this.peekKeyword("capability") || this.peekKeyword("role")) {
       const fn = this.peek().value;
       const node = this.parseBooleanCall(fn);
@@ -1389,6 +2113,8 @@ var PolicyCompiler = class {
   }
   compile(node, table, depth) {
     switch (node.kind) {
+      case "literal":
+        return { kind: "const", value: node.value };
       case "and":
       case "or":
         return { kind: node.kind, operands: node.operands.map((operand) => this.compile(operand, table, depth)) };
@@ -1559,6 +2285,7 @@ var NamespaceCompileError = class extends Error {
 
 // src/compiler-gql/pred-utils.ts
 var CONST_TRUE = { kind: "const", value: true };
+var CONST_FALSE = { kind: "const", value: false };
 function andPred(...preds) {
   const operands = preds.filter(
     (pred) => pred !== void 0 && !(pred.kind === "const" && pred.value)
@@ -1644,6 +2371,12 @@ var PolicyInjector = class {
   write(table) {
     return this.ctx.writePolicies.get(table) ?? { kind: "const", value: true };
   }
+  insert(table) {
+    return this.ctx.insertPolicies.get(table) ?? this.write(table);
+  }
+  update(table) {
+    return this.ctx.updatePolicies.get(table) ?? this.write(table);
+  }
   linkTarget(table, link) {
     const meta = this.ctx.tables[table];
     const resolved = meta?.links.find((l) => l.name === link);
@@ -1718,31 +2451,50 @@ var PolicyInjector = class {
         };
       case "mutation":
         return this.injectMutation(root);
-      case "action":
-        return root;
     }
   }
   injectMutation(root) {
     const table = root.table;
-    const writePolicy = this.write(table);
     const returning = root.returning ? this.injectSelection(root.returning, table) : root.returning;
     if (root.op === "insert" || root.op === "insertOne") {
-      if (predContainsExists(writePolicy)) {
+      const insertPolicy = this.insert(table);
+      if (predContainsExists(insertPolicy)) {
         throw new DocumentCompileError(
-          `table '${table}' cannot be inserted into: v2.0 insert checks are claims + inserted-values only, but its write policy traverses a link (exists)`,
+          `table '${table}' cannot be inserted into: v2.0 insert checks are claims + inserted-values only, but its insert policy traverses a link (exists)`,
           "insert-check-unrepresentable"
         );
       }
       const pins = (this.ctx.pins.get(table) ?? []).map(
         (pin) => ({ column: pin.column, value: { kind: "claim", key: pin.claim } })
       );
-      return { ...root, pinnedColumns: pins, insertCheck: writePolicy, returning };
+      if (root.onConflict && this.ctx.splitWritePolicyTables.has(table)) {
+        throw new DocumentCompileError(
+          `table '${table}' cannot use onConflict while insert and update policies are split \u2014 use separate insert and update mutations`,
+          "on-conflict-split-policies"
+        );
+      }
+      return { ...root, pinnedColumns: pins, insertCheck: insertPolicy, returning };
     }
-    const where = andPred(writePolicy, root.where ? this.injectDocPred(root.where, table) : void 0);
+    const updatePolicy = this.update(table);
+    const where = andPred(updatePolicy, root.where ? this.injectDocPred(root.where, table) : void 0);
     if (root.op === "update" || root.op === "updateByPk") {
-      const check = predContainsExists(writePolicy) ? {} : { insertCheck: writePolicy };
+      const check = predContainsExists(updatePolicy) ? {} : { insertCheck: updatePolicy };
       return { ...root, where, ...check, returning };
     }
+    if (root.op === "cowOverride") {
+      const insertPolicy = this.insert(table);
+      if (predContainsExists(insertPolicy)) {
+        throw new DocumentCompileError(
+          `table '${table}' cannot be copy-on-write overridden: v2.0 insert checks are claims + inserted-values only, but its insert policy traverses a link (exists)`,
+          "insert-check-unrepresentable"
+        );
+      }
+      const pins = (this.ctx.pins.get(table) ?? []).map(
+        (pin) => ({ column: pin.column, value: { kind: "claim", key: pin.claim } })
+      );
+      const check = predContainsExists(updatePolicy) ? {} : { insertCheck: updatePolicy };
+      return { ...root, pinnedColumns: pins, cowCopyCheck: insertPolicy, where, ...check, returning };
+    }
     return { ...root, where, returning };
   }
 };
@@ -1788,7 +2540,6 @@ function collectTableSet(roots, ctx) {
     }
   };
   for (const root of roots) {
-    if (root.kind === "action") continue;
     tables.add(root.table);
     if (root.kind === "select" || root.kind === "byPk") {
       visitPred(root.where, root.table);
@@ -1799,8 +2550,10 @@ function collectTableSet(roots, ctx) {
       if (root.nodes) visitSelection(root.nodes, root.table);
     }
     if (root.kind === "mutation") {
+      if (root.cowSynced !== void 0) tables.add(root.cowSynced);
       if (root.where) visitPred(root.where, root.table);
       if (root.insertCheck) visitPred(root.insertCheck, root.table);
+      if (root.cowCopyCheck) visitPred(root.cowCopyCheck, root.table);
       if (root.returning) visitSelection(root.returning, root.table);
     }
   }
@@ -1867,6 +2620,7 @@ function platformUserMeta() {
     table: "users_directory",
     schema: "platform",
     typename: PLATFORM_USER_TYPENAME,
+    claimsGated: false,
     columns: columns.map((c) => ({ ...c })),
     primaryKey: ["sub"],
     links: [],
@@ -1909,15 +2663,30 @@ function buildCompileContext(rawCanonical) {
   const canonical = normalizeCanonical(canonicalDefinitionSchema.parse(rawCanonical));
   const diagnostics = [];
   const enums = new Map(canonical.enums.map((e) => [e.name, e]));
+  const relations = canonicalRelations(canonical);
+  const viewNames = new Set((canonical.views ?? []).map((view) => view.view));
   const columnEntries = /* @__PURE__ */ new Map();
   const tables = {};
-  const usesPlatformUsers = canonical.tables.some((t2) => t2.links.some((l) => l.kind === "toPlatformUser"));
+  const usesPlatformUsers = relations.some((t2) => t2.links.some((l) => l.kind === "toPlatformUser"));
   const platformMeta = usesPlatformUsers ? platformUserMeta() : void 0;
   if (platformMeta) tables[PLATFORM_USER_TABLE] = platformMeta;
-  for (const table of canonical.tables) {
+  const syncedTableNames = new Set(canonical.tables.filter((t2) => t2.source !== void 0).map((t2) => t2.table));
+  const viewDependencies = new Map((canonical.views ?? []).map((view) => [view.view, view.dependencies]));
+  const claimsGatedMemo = /* @__PURE__ */ new Map();
+  const relationIsClaimsGated = (name) => {
+    if (syncedTableNames.has(name)) return true;
+    const memo = claimsGatedMemo.get(name);
+    if (memo !== void 0) return memo;
+    claimsGatedMemo.set(name, false);
+    const gated = (viewDependencies.get(name) ?? []).some(relationIsClaimsGated);
+    claimsGatedMemo.set(name, gated);
+    return gated;
+  };
+  for (const table of relations) {
+    const isView = viewNames.has(table.table);
     const entries = resolveColumnEntries(table, enums, diagnostics);
     columnEntries.set(table.table, entries);
-    const pkRefs = table.primaryKey ?? ["id"];
+    const pkRefs = table.primaryKey ?? (isView ? [] : ["id"]);
     const primaryKey2 = [];
     for (const ref of pkRefs) {
       const resolved = logicalColumn(entries, ref);
@@ -1938,7 +2707,7 @@ function buildCompileContext(rawCanonical) {
     for (const column of table.columns) {
       if (column.unique) {
         const logical = logicalColumn(entries, column.columnName);
-        constraints.push({ name: `${table.table}_${column.columnName}_key`, columns: [logical] });
+        constraints.push({ name: `${table.table}_${column.columnName}_unique`, columns: [logical] });
       }
     }
     for (const index3 of table.indexes) {
@@ -1950,20 +2719,23 @@ function buildCompileContext(rawCanonical) {
       table: table.table,
       schema: ormSchemaName(canonical.namespace),
       typename: typeNameForTable(table.table),
+      // Synced twins (and views reading them, resolved transitively below)
+      // are claims-gated — see tableMetaIrSchema.claimsGated.
+      claimsGated: relationIsClaimsGated(table.table),
       columns: entries.map(({ deprecated: _deprecated, ...column }) => column),
-      primaryKey: primaryKey2.length > 0 ? primaryKey2 : ["id"],
+      primaryKey: isView ? primaryKey2 : primaryKey2.length > 0 ? primaryKey2 : ["id"],
       links: [],
       filterable: entries.map((c) => c.name),
       orderable: entries.filter((c) => c.type !== "jsonb").map((c) => c.name),
-      insertable: active.map((c) => c.name),
-      settable: active.map((c) => c.name),
-      appendable: active.filter((c) => c.type === "jsonb").map((c) => c.name),
-      constraints,
+      insertable: isView ? [] : active.map((c) => c.name),
+      settable: isView ? [] : active.map((c) => c.name),
+      appendable: isView ? [] : active.filter((c) => c.type === "jsonb").map((c) => c.name),
+      constraints: isView ? [] : constraints,
       dynamicFilterMaxDepth: 6,
       dynamicFilterMaxNodes: 64
     };
   }
-  for (const table of canonical.tables) {
+  for (const table of relations) {
     const meta = tables[table.table];
     const entries = columnEntries.get(table.table);
     for (const link of table.links) {
@@ -1998,17 +2770,17 @@ function buildCompileContext(rawCanonical) {
   }
   const readPolicies = /* @__PURE__ */ new Map();
   const writePolicies = /* @__PURE__ */ new Map();
+  const insertPolicies = /* @__PURE__ */ new Map();
+  const updatePolicies = /* @__PURE__ */ new Map();
   const pins = /* @__PURE__ */ new Map();
+  const splitWritePolicyTables = /* @__PURE__ */ new Set();
   const resolver = { tables };
-  for (const table of canonical.tables) {
-    for (const [access, store] of [
-      ["read", readPolicies],
-      ["write", writePolicies]
-    ]) {
+  for (const table of relations) {
+    const isView = viewNames.has(table.table);
+    const compilePolicyFor = (access, store) => {
       const expression = table.policies[access];
       if (expression === void 0) {
-        store.set(table.table, CONST_TRUE);
-        continue;
+        return;
       }
       try {
         store.set(table.table, compilePolicy({ expression, table: table.table, resolver }));
@@ -2021,37 +2793,117 @@ function buildCompileContext(rawCanonical) {
             table: table.table
           });
           store.set(table.table, CONST_TRUE);
-          continue;
+          return;
         }
         throw error;
       }
+    };
+    compilePolicyFor("read", readPolicies);
+    compilePolicyFor("write", writePolicies);
+    compilePolicyFor("insert", insertPolicies);
+    compilePolicyFor("update", updatePolicies);
+    if (isView) {
+      writePolicies.set(table.table, CONST_FALSE);
+      insertPolicies.set(table.table, CONST_FALSE);
+      updatePolicies.set(table.table, CONST_FALSE);
+      pins.set(table.table, []);
+      continue;
+    }
+    if (table.policies.insert !== void 0 || table.policies.update !== void 0) {
+      splitWritePolicyTables.add(table.table);
+    }
+    const fallbackWrite = writePolicies.get(table.table);
+    const hasSplitPolicy = table.policies.insert !== void 0 || table.policies.update !== void 0;
+    if (!insertPolicies.has(table.table)) {
+      if (fallbackWrite !== void 0) insertPolicies.set(table.table, fallbackWrite);
+      else if (hasSplitPolicy) insertPolicies.set(table.table, CONST_FALSE);
+      else insertPolicies.set(table.table, CONST_TRUE);
     }
-    const tablePins = collectPinnedColumns(writePolicies.get(table.table));
+    if (!updatePolicies.has(table.table)) {
+      if (fallbackWrite !== void 0) updatePolicies.set(table.table, fallbackWrite);
+      else if (hasSplitPolicy) updatePolicies.set(table.table, CONST_FALSE);
+      else updatePolicies.set(table.table, CONST_TRUE);
+    }
+    const tablePins = collectPinnedColumns(insertPolicies.get(table.table));
     pins.set(table.table, tablePins);
     const pinned = new Set(tablePins.map((pin) => pin.column));
     const meta = tables[table.table];
     meta.insertable = meta.insertable.filter((column) => !pinned.has(column));
-    meta.settable = meta.settable.filter((column) => !pinned.has(column));
   }
   if (platformMeta) {
     readPolicies.set(PLATFORM_USER_TABLE, CONST_TRUE);
     writePolicies.set(PLATFORM_USER_TABLE, { kind: "const", value: false });
+    insertPolicies.set(PLATFORM_USER_TABLE, { kind: "const", value: false });
+    updatePolicies.set(PLATFORM_USER_TABLE, { kind: "const", value: false });
     pins.set(PLATFORM_USER_TABLE, []);
   }
   const tableByTypename = new Map(Object.entries(tables).map(([key, meta]) => [meta.typename, key]));
   const queryRoots = /* @__PURE__ */ new Map();
   const mutationRoots = /* @__PURE__ */ new Map();
-  for (const table of canonical.tables) {
+  for (const table of relations) {
     const roots = queryRootNames(table.table);
     queryRoots.set(roots.select, { kind: "select", table: table.table });
-    queryRoots.set(roots.byPk, { kind: "byPk", table: table.table });
+    if ((tables[table.table]?.primaryKey.length ?? 0) > 0) {
+      queryRoots.set(roots.byPk, { kind: "byPk", table: table.table });
+    }
     queryRoots.set(roots.aggregate, { kind: "aggregate", table: table.table });
-    if (table.source === void 0) {
+    const hasWritePolicy = table.policies.write !== void 0 || table.policies.insert !== void 0 || table.policies.update !== void 0;
+    if (!viewNames.has(table.table) && table.source === void 0 && hasWritePolicy) {
       for (const [op, field] of Object.entries(mutationRootNames(table.table))) {
         mutationRoots.set(field, { op, table: table.table });
       }
     }
   }
+  for (const table of relations) {
+    for (const mutation of table.cowMutations ?? []) {
+      const hasWritePolicy = table.policies.write !== void 0 || table.policies.insert !== void 0 || table.policies.update !== void 0;
+      if (!hasWritePolicy) {
+        diagnostics.push({
+          severity: "error",
+          code: "cow-mutation-unpoliced",
+          message: `cow mutation '${mutation.name}' on '${table.table}' requires a write (or insert/update) policy on the overlay table`,
+          table: table.table
+        });
+        continue;
+      }
+      const field = camelCase(mutation.name);
+      if (mutationRoots.has(field) || queryRoots.has(field)) {
+        diagnostics.push({
+          severity: "error",
+          code: "cow-mutation-name-collision",
+          message: `cow mutation '${mutation.name}' on '${table.table}' collides with the generated root '${field}'`,
+          table: table.table
+        });
+        continue;
+      }
+      if (mutation.kind === "override") {
+        const pinned = new Set((pins.get(table.table) ?? []).map((pin) => pin.column));
+        const covered = /* @__PURE__ */ new Set([mutation.pk, ...mutation.copy, ...pinned]);
+        const gaps = table.columns.filter((column) => {
+          if (covered.has(column.name)) return false;
+          const hasDefault = column.default !== void 0 || column.defaultFn !== void 0;
+          return column.nullable === false && !hasDefault;
+        });
+        if (gaps.length > 0) {
+          diagnostics.push({
+            severity: "error",
+            code: "cow-copy-uncovered-column",
+            message: `cow mutation '${mutation.name}' on '${table.table}': overlay-only column(s) ${gaps.map((column) => `'${column.name}'`).join(", ")} are NOT NULL without a default, a policy pin, or a synced contract column \u2014 the copy insert cannot populate them`,
+            table: table.table
+          });
+          continue;
+        }
+      }
+      mutationRoots.set(field, {
+        op: mutation.kind === "override" ? "cowOverride" : "cowRevert",
+        table: table.table,
+        synced: mutation.synced,
+        pk: mutation.pk,
+        set: mutation.set,
+        copyColumns: mutation.copy
+      });
+    }
+  }
   const enumsByTypeName = new Map(canonical.enums.map((e) => [enumTypeName(e.name), e]));
   return {
     ctx: {
@@ -2063,7 +2915,10 @@ function buildCompileContext(rawCanonical) {
       enumsByTypeName,
       readPolicies,
       writePolicies,
-      pins
+      insertPolicies,
+      updatePolicies,
+      pins,
+      splitWritePolicyTables
     },
     diagnostics
   };
@@ -2615,6 +3470,9 @@ var OperationLowerer = class {
     const alias = node.alias?.value ?? name;
     const rootInfo = this.ctx.mutationRoots.get(name);
     if (!rootInfo) fail(`unknown mutation root '${name}'`, "unknown-root", [...this.ctx.mutationRoots.keys()]);
+    if (rootInfo.op === "cowOverride" || rootInfo.op === "cowRevert") {
+      return this.lowerCowRoot(node, rootInfo);
+    }
     const { op, table } = rootInfo;
     const args = argsByName(node);
     if (!node.selectionSet) fail(`'${name}' needs a selection set`, "invalid-selection");
@@ -2684,6 +3542,55 @@ var OperationLowerer = class {
       }
     }
   }
+  /**
+   * Copy-on-write roots: flat args — the pk plus (override only) every
+   * declared set column. Overrides are full snapshots of the set columns, so
+   * every set argument must be supplied explicitly (pass null to clear a
+   * nullable column); the executor generates the copy/update/delete SQL from
+   * the structured fields, never from authored statements.
+   */
+  lowerCowRoot(node, rootInfo) {
+    const name = node.name.value;
+    const alias = node.alias?.value ?? name;
+    const { table } = rootInfo;
+    if (!node.selectionSet) fail(`'${name}' needs a selection set`, "invalid-selection");
+    const meta = this.meta(table);
+    const args = argsByName(node);
+    const pkArg = args.get(rootInfo.pk);
+    if (!pkArg) fail(`'${name}' is missing primary-key argument '${rootInfo.pk}'`, "missing-pk-argument", [rootInfo.pk]);
+    const pk = [{ column: rootInfo.pk, value: this.lowerValue(pkArg.value) }];
+    const base = {
+      kind: "mutation",
+      op: rootInfo.op,
+      alias,
+      table,
+      pinnedColumns: [],
+      affectedRows: false,
+      pk,
+      cowSynced: rootInfo.synced,
+      returning: this.lowerSelection(node.selectionSet, table)
+    };
+    if (rootInfo.op === "cowRevert") {
+      assertKnownArgs(node, [rootInfo.pk]);
+      return base;
+    }
+    assertKnownArgs(node, [rootInfo.pk, ...rootInfo.set]);
+    const entries = rootInfo.set.map((column) => {
+      const arg = args.get(column);
+      if (!arg) {
+        fail(
+          `'${name}' is missing set argument '${column}' \u2014 a cow override writes every declared set column (pass null to clear a nullable one)`,
+          "missing-argument",
+          [...rootInfo.set]
+        );
+      }
+      if (!meta.settable.includes(column)) {
+        fail(`column '${table}.${column}' is not updatable (pinned by the write policy or deprecated)`, "column-not-settable", meta.settable);
+      }
+      return { column, value: this.lowerValue(arg.value) };
+    });
+    return { ...base, set: { entries }, cowCopyColumns: [...rootInfo.copyColumns] };
+  }
   lowerMutationResponse(selectionSet, table) {
     let affectedRows = false;
     let returning = null;
@@ -2777,8 +3684,8 @@ var OperationLowerer = class {
       if (inc.value.kind === Kind.VARIABLE) {
         fail("_inc has no dynamic input type \u2014 inline the columns with variable leaf values", "invalid-inc");
       }
-      const numeric3 = meta.columns.filter((c) => typeof c.type === "string" && NUMERIC_TYPES.has(c.type) && meta.settable.includes(c.name)).map((c) => c.name);
-      result.inc = { entries: this.lowerColumnEntries(inc.value, table, numeric3, "_inc") };
+      const numeric4 = meta.columns.filter((c) => typeof c.type === "string" && NUMERIC_TYPES.has(c.type) && meta.settable.includes(c.name)).map((c) => c.name);
+      result.inc = { entries: this.lowerColumnEntries(inc.value, table, numeric4, "_inc") };
     }
     if (!result.set && !result.append && !result.inc) {
       fail(`an update on '${table}' needs at least one of _set/_append/_inc`, "missing-argument");
@@ -3129,13 +4036,17 @@ function generateNamespaceTypes(definition) {
     `export type ${typesInterfaceName(definition.namespace)} = {`
   ];
   for (const table of definition.tables) {
-    if (table.source) {
+    const columns = Object.entries(table.columns ?? {});
+    if (table.source && columns.length === 0) {
       lines.push(`  /** Synced from ${table.source} \u2014 columns reflect the gold source. */`);
       lines.push(`  ${table.table}: Record<string, unknown>`);
       continue;
     }
+    if (table.source) {
+      lines.push(`  /** Synced from ${table.source} \u2014 read-only typed contract. */`);
+    }
     lines.push(`  ${table.table}: {`);
-    for (const [name, column] of Object.entries(table.columns ?? {})) {
+    for (const [name, column] of columns) {
       if (column.deprecated) continue;
       lines.push(`    ${name}: ${columnWireType(column)}`);
     }
@@ -3601,8 +4512,8 @@ var actionSchema = z.strictObject({
     }
   }
 });
-function extractNamedParams(sql3) {
-  const withoutStrings = sql3.replace(QUOTED_STRING_PATTERN, "''");
+function extractNamedParams(sql4) {
+  const withoutStrings = sql4.replace(QUOTED_STRING_PATTERN, "''");
   const names = [...withoutStrings.matchAll(NAMED_PARAM_PATTERN)].map((match) => match[1]);
   return [...new Set(names)];
 }
@@ -3656,7 +4567,9 @@ var indexSchema = z.union([
 ]).transform((index3) => Array.isArray(index3) ? { columns: index3 } : index3);
 var policiesSchema = z.strictObject({
   read: parsedPredicateSchema.optional(),
-  write: parsedPredicateSchema.optional()
+  write: parsedPredicateSchema.optional(),
+  insert: parsedPredicateSchema.optional(),
+  update: parsedPredicateSchema.optional()
 });
 var tableFileSchema = z.strictObject({
   namespace: namespaceSchema,
@@ -3692,7 +4605,6 @@ var policyName = (table, suffix) => `${table}_${suffix}`;
 var foreignKeyName = (table, link) => `fk_${table}_${link}`;
 function validateSyncedTable(table, ctx) {
   const forbidden = [
-    ["columns", "synced tables reflect their source; columns are not declared"],
     ["actions", "synced tables are read-only; actions are not allowed"],
     ["indexes", "synced tables are system-owned; indexes are not allowed"]
   ];
@@ -3702,6 +4614,39 @@ function validateSyncedTable(table, ctx) {
   if (table.policies?.write) {
     ctx.addIssue({ code: "custom", message: "synced tables are read-only", path: ["policies", "write"] });
   }
+  if (table.policies?.insert) {
+    ctx.addIssue({ code: "custom", message: "synced tables are read-only", path: ["policies", "insert"] });
+  }
+  if (table.policies?.update) {
+    ctx.addIssue({ code: "custom", message: "synced tables are read-only", path: ["policies", "update"] });
+  }
+  const columns = table.columns ?? {};
+  const names = Object.keys(columns);
+  if (names.length === 0) return;
+  const primaryKeys = names.filter((name) => columns[name]?.primary_key);
+  if (primaryKeys.length !== 1) {
+    ctx.addIssue({ code: "custom", message: "exactly one column must be primary_key", path: ["columns"] });
+  }
+  validateRenames(columns, names, ctx);
+  for (const name of names) {
+    const column = columns[name];
+    if (!column) continue;
+    const cast = column.cast ? castParts(column.cast) : null;
+    if (column.cast && cast?.column !== name) {
+      ctx.addIssue({
+        code: "custom",
+        message: "cast must reference the column it is declared on",
+        path: ["columns", name, "cast"]
+      });
+    }
+    if (cast && cast.type !== column.type) {
+      ctx.addIssue({
+        code: "custom",
+        message: `cast target '${cast.type}' must match the declared type '${column.type}'`,
+        path: ["columns", name, "cast"]
+      });
+    }
+  }
 }
 function validateRenames(columns, names, ctx) {
   const renameSources = /* @__PURE__ */ new Map();
@@ -3779,7 +4724,7 @@ function validateColumnTable(table, ctx) {
 function validateLinks(table, ctx) {
   const columnNames = Object.keys(table.columns ?? {});
   for (const [name, link] of Object.entries(table.links ?? {})) {
-    if (!table.source && !columnNames.includes(link.on)) {
+    if (columnNames.length > 0 && !columnNames.includes(link.on)) {
       ctx.addIssue({ code: "custom", message: `link references unknown column '${link.on}'`, path: ["links", name, "on"] });
     }
     if (link.enforce && link.to.includes(".")) {
@@ -3852,10 +4797,10 @@ var TYPE_GROUPS = {
 };
 var columnTypeGroup = (type) => TYPE_GROUPS[type];
 function validatePolicyColumns(table, ctx) {
-  if (table.source) return;
   const columns = table.columns ?? {};
   const columnNames = Object.keys(columns);
-  for (const kind of ["read", "write"]) {
+  if (columnNames.length === 0) return;
+  for (const kind of ["read", "write", "insert", "update"]) {
     const predicate = table.policies?.[kind];
     if (!predicate) continue;
     for (const column of referencedColumns(predicate.ast)) {
@@ -4010,10 +4955,15 @@ function policyStatements(schema, table) {
   if (read) {
     statements.push(`CREATE POLICY ${policyName2("read")} ON ${qualified} FOR SELECT USING (${compilePredicate(read.ast, columnTypes)})`);
   }
-  const write = table.policies?.write;
-  if (write) {
-    const predicate = compilePredicate(write.ast, columnTypes);
-    statements.push(`CREATE POLICY ${policyName2("insert")} ON ${qualified} FOR INSERT WITH CHECK (${predicate})`);
+  const insertPolicy = table.policies?.insert ?? table.policies?.write;
+  const updatePolicy = table.policies?.update ?? table.policies?.write;
+  if (insertPolicy) {
+    statements.push(
+      `CREATE POLICY ${policyName2("insert")} ON ${qualified} FOR INSERT WITH CHECK (${compilePredicate(insertPolicy.ast, columnTypes)})`
+    );
+  }
+  if (updatePolicy) {
+    const predicate = compilePredicate(updatePolicy.ast, columnTypes);
     statements.push(
       `CREATE POLICY ${policyName2("update")} ON ${qualified} FOR UPDATE USING (${predicate}) WITH CHECK (${predicate})`
     );
@@ -4237,11 +5187,268 @@ function buildDrizzleEntitiesV2(definition) {
     imports[table.table] = drizzleTable;
     tables[table.table] = drizzleTable;
   }
+  for (const view of definition.views ?? []) {
+    const columns = Object.fromEntries(
+      view.columns.map((column) => [column.columnName, buildViewColumnV2({ view: view.view, column, enums })])
+    );
+    imports[view.view] = schema.view(view.view, columns).as(
+      sql.raw(
+        rewriteSyncedSourceRelationsInViewQuery({
+          query: view.query,
+          canonical: definition,
+          schemaName,
+          dependencies: view.dependencies
+        })
+      )
+    );
+  }
   return { imports, tables, schemaName };
 }
+function rewriteSyncedSourceRelationsInViewQuery({
+  query,
+  canonical,
+  schemaName,
+  dependencies
+}) {
+  const tablesBySource = /* @__PURE__ */ new Map();
+  for (const table of canonical.tables) {
+    if (!table.source) continue;
+    tablesBySource.set(table.source, [...tablesBySource.get(table.source) ?? [], table.table]);
+  }
+  const declared = new Set(dependencies ?? []);
+  const boundTableBySource = /* @__PURE__ */ new Map();
+  for (const [source, tables] of tablesBySource) {
+    if (tables.length === 1) {
+      boundTableBySource.set(source, tables[0]);
+      continue;
+    }
+    const [sourceSchema, sourceName] = source.split(".");
+    if (!sourceSchema || !sourceName) continue;
+    const referenced = sqlReferencesQualifiedRelation(query, sourceSchema, sourceName);
+    if (!referenced) continue;
+    const declaredMatches = tables.filter((table) => declared.has(table));
+    if (declaredMatches.length === 1) {
+      boundTableBySource.set(source, declaredMatches[0]);
+      continue;
+    }
+    throw new OrmDefinitionError(
+      `synced source '${source}' is declared by multiple synced tables (${[...tables].sort().join(", ")}) \u2014 this view references it but its declared dependencies do not name exactly one of them, so the rewrite is ambiguous`
+    );
+  }
+  return transformSqlOutsideLiterals(query, (segment) => {
+    let rewritten = segment;
+    for (const table of canonical.tables) {
+      if (!table.source) continue;
+      const boundTable = boundTableBySource.get(table.source);
+      if (boundTable === void 0 || boundTable !== table.table) continue;
+      const [sourceSchema, sourceName] = table.source.split(".");
+      if (!sourceSchema || !sourceName) continue;
+      rewritten = replaceQualifiedRelation(
+        rewritten,
+        sourceSchema,
+        sourceName,
+        schemaName,
+        table.table
+      );
+    }
+    return rewritten;
+  });
+}
+function transformSqlOutsideLiterals(sql4, transform) {
+  const out = [];
+  let state = { kind: "normal" };
+  let i = 0;
+  let codeStart = 0;
+  const emitCode = (end) => {
+    if (end > codeStart) out.push(transform(sql4.slice(codeStart, end)));
+    codeStart = end;
+  };
+  while (i < sql4.length) {
+    const c = sql4[i];
+    const next = i + 1 < sql4.length ? sql4[i + 1] : "";
+    switch (state.kind) {
+      case "normal": {
+        if (c === "-" && next === "-") {
+          emitCode(i);
+          state = { kind: "line-comment" };
+          out.push("--");
+          i += 2;
+          codeStart = i;
+          break;
+        }
+        if (c === "/" && next === "*") {
+          emitCode(i);
+          state = { kind: "block-comment", depth: 1 };
+          out.push("/*");
+          i += 2;
+          codeStart = i;
+          break;
+        }
+        if ((c === "E" || c === "e") && next === "'") {
+          const prev = i > 0 ? sql4[i - 1] : "";
+          if (!/[A-Za-z0-9_]/.test(prev)) {
+            emitCode(i);
+            state = { kind: "e-single" };
+            out.push("E'");
+            i += 2;
+            codeStart = i;
+            break;
+          }
+        }
+        if (c === "'") {
+          emitCode(i);
+          state = { kind: "single" };
+          out.push("'");
+          i += 1;
+          codeStart = i;
+          break;
+        }
+        if (c === "$") {
+          const prev = i > 0 ? sql4[i - 1] : "";
+          if (!/[A-Za-z0-9_$]/.test(prev)) {
+            const tagMatch = /^\$([A-Za-z_][A-Za-z0-9_]*)?\$/.exec(sql4.slice(i));
+            if (tagMatch) {
+              emitCode(i);
+              state = { kind: "dollar", tag: tagMatch[1] ?? "" };
+              out.push(tagMatch[0]);
+              i += tagMatch[0].length;
+              codeStart = i;
+              break;
+            }
+          }
+        }
+        i += 1;
+        break;
+      }
+      case "single": {
+        if (c === "'" && next === "'") {
+          out.push("''");
+          i += 2;
+          break;
+        }
+        if (c === "'") {
+          out.push("'");
+          state = { kind: "normal" };
+          i += 1;
+          codeStart = i;
+          break;
+        }
+        out.push(c);
+        i += 1;
+        break;
+      }
+      case "e-single": {
+        if (c === "\\" && i + 1 < sql4.length) {
+          out.push(c, sql4[i + 1]);
+          i += 2;
+          break;
+        }
+        if (c === "'" && next === "'") {
+          out.push("''");
+          i += 2;
+          break;
+        }
+        if (c === "'") {
+          out.push("'");
+          state = { kind: "normal" };
+          i += 1;
+          codeStart = i;
+          break;
+        }
+        out.push(c);
+        i += 1;
+        break;
+      }
+      case "dollar": {
+        const closer = `$${state.tag}$`;
+        if (sql4.startsWith(closer, i)) {
+          out.push(closer);
+          state = { kind: "normal" };
+          i += closer.length;
+          codeStart = i;
+          break;
+        }
+        out.push(c);
+        i += 1;
+        break;
+      }
+      case "line-comment": {
+        if (c === "\n") {
+          out.push("\n");
+          state = { kind: "normal" };
+          i += 1;
+          codeStart = i;
+          break;
+        }
+        out.push(c);
+        i += 1;
+        break;
+      }
+      case "block-comment": {
+        if (c === "/" && next === "*") {
+          out.push("/*");
+          state = { kind: "block-comment", depth: state.depth + 1 };
+          i += 2;
+          break;
+        }
+        if (c === "*" && next === "/") {
+          out.push("*/");
+          const newDepth = state.depth - 1;
+          state = newDepth === 0 ? { kind: "normal" } : { kind: "block-comment", depth: newDepth };
+          i += 2;
+          if (state.kind === "normal") codeStart = i;
+          break;
+        }
+        out.push(c);
+        i += 1;
+        break;
+      }
+    }
+  }
+  emitCode(sql4.length);
+  return out.join("");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function sqlReferencesQualifiedRelation(sql4, sourceSchema, sourceName) {
+  let referenced = false;
+  transformSqlOutsideLiterals(sql4, (segment) => {
+    if (qualifiedRelationPattern(sourceSchema, sourceName).test(segment)) referenced = true;
+    return segment;
+  });
+  return referenced;
+}
+function qualifiedRelationPattern(sourceSchema, sourceName) {
+  const schemaPattern = `(?:"${escapeRegExp(sourceSchema)}"|${escapeRegExp(sourceSchema)})`;
+  const namePattern = `(?:"${escapeRegExp(sourceName)}"|${escapeRegExp(sourceName)})`;
+  return new RegExp(`(?<![\\w."])${schemaPattern}\\.${namePattern}(?![\\w"])`, "g");
+}
+function replaceQualifiedRelation(sql4, sourceSchema, sourceName, boundSchema, boundTable) {
+  return sql4.replace(qualifiedRelationPattern(sourceSchema, sourceName), `"${boundSchema}"."${boundTable}"`);
+}
 function generateSnapshotV2(definition, previousId3) {
   const { imports, schemaName } = buildDrizzleEntitiesV2(definition);
-  return generateDrizzleJson(imports, previousId3, [schemaName]);
+  const snapshot = generateDrizzleJson(imports, previousId3, [schemaName]);
+  if ((definition.views?.length ?? 0) > 0) {
+    const extended = snapshot;
+    extended._sequenceOrm = {
+      viewDependencies: Object.fromEntries(
+        (definition.views ?? []).map((view) => [view.view, [...view.dependencies].sort()])
+      )
+    };
+  }
+  return snapshot;
+}
+function buildViewColumnV2({
+  view,
+  column,
+  enums
+}) {
+  const factory = resolveColumnFactory(view, column, enums);
+  let builder = factory(column.columnName);
+  if (!column.nullable) builder = builder.notNull();
+  return builder;
 }
 function buildTable2(schema, table, built, enums, byName) {
   const primaryKeyColumns2 = table.primaryKey ?? [];
@@ -4485,16 +5692,270 @@ async function planMigrationV2({
 }) {
   const schema = ormSchemaName(canonical.namespace);
   const previous = previousSnapshot ? normalizeSnapshot(previousSnapshot) : emptySnapshot(canonical.namespace);
+  assertValidViewDependencies(canonical);
   const hints = applyMigrationHintsV2(previous, canonical);
   const snapshot = generateSnapshotV2(canonical, previousId(previous));
-  const ddl = await diffStatements(hints.adjusted, snapshot);
+  const baseDdl = await diffStatements(withoutViews(hints.adjusted), withoutViews(snapshot));
+  const previousViews = snapshotViews(hints.adjusted);
+  const currentViews = snapshotViews(snapshot);
+  const previousDependencies = snapshotViewDependencies(hints.adjusted);
+  const currentDependencies = snapshotViewDependencies(snapshot);
+  const affected = affectedViewNames({
+    previousViews,
+    currentViews,
+    previousDependencies,
+    currentDependencies,
+    baseChanged: hints.statements.length > 0 || baseDdl.length > 0
+  });
+  const dropOrder = topologicalViewNames(
+    new Set([...affected].filter((name) => previousViews.has(name))),
+    previousDependencies
+  ).reverse();
+  const createOrder = topologicalViewNames(
+    new Set([...affected].filter((name) => currentViews.has(name))),
+    currentDependencies
+  );
+  const dropDdl = await generatedViewStatements({
+    snapshot: hints.adjusted,
+    names: new Set(dropOrder),
+    mode: "drop",
+    schema
+  });
+  const createDdl = await generatedViewStatements({
+    snapshot,
+    names: new Set(createOrder),
+    mode: "create",
+    schema
+  });
+  const currentViewDefinitions = new Map((canonical.views ?? []).map((view) => [view.view, view]));
   const statements = [
+    ...dropOrder.map((name) => ({ kind: "ddl", sql: requiredViewStatement(dropDdl, name, schema, "DROP") })),
     ...hints.statements.map((statement) => ({ kind: "hint", sql: statement })),
-    ...ddl.map((statement) => ({ kind: "ddl", sql: statement.replace(/;\s*$/, "") }))
+    ...baseDdl.map((statement) => ({ kind: "ddl", sql: statement.replace(/;\s*$/, "") })),
+    ...createOrder.map((name) => ({ kind: "ddl", sql: requiredViewStatement(createDdl, name, schema, "CREATE") })),
+    ...createOrder.map((name) => {
+      const view = currentViewDefinitions.get(name);
+      if (!view) throw new OrmDefinitionError(`missing canonical definition for view '${name}'`);
+      return { kind: "ddl", sql: validateViewCatalogStatement({ canonical, view, schema }) };
+    })
   ];
   return { namespace: canonical.namespace, schema, statements, snapshot };
 }
+function validateViewCatalogStatement({
+  canonical,
+  view,
+  schema
+}) {
+  const qualified = `${schema}.${view.view}`;
+  const expectedColumns = sqlTextArray(view.columns.map((column) => column.columnName));
+  const expectedTypes = `ARRAY[${view.columns.map((column) => `${viewTypeRegtype(column, schema)}::oid`).join(", ")}]::oid[]`;
+  const relationIdentity = /* @__PURE__ */ new Map();
+  for (const table of canonical.tables) {
+    relationIdentity.set(table.table, `${schema}.${table.table}`);
+  }
+  for (const candidate of canonical.views ?? []) {
+    relationIdentity.set(candidate.view, `${schema}.${candidate.view}`);
+  }
+  const expectedDependencies = sqlTextArray(
+    view.dependencies.map((dependency) => {
+      const physical = relationIdentity.get(dependency);
+      if (!physical) throw new OrmDefinitionError(`view '${view.view}' depends on unknown relation '${dependency}'`);
+      return physical;
+    }).sort()
+  );
+  const allowedFunctions = sqlTextArray(VIEW_QUERY_FUNCTION_ALLOWLIST);
+  return `DO $sequence_orm_validate_view$
+DECLARE
+  actual_columns text[];
+  actual_types oid[];
+  actual_dependencies text[];
+BEGIN
+  SELECT
+    array_agg(attribute.attname ORDER BY attribute.attnum),
+    array_agg(attribute.atttypid ORDER BY attribute.attnum)
+  INTO actual_columns, actual_types
+  FROM pg_catalog.pg_attribute AS attribute
+  WHERE attribute.attrelid = pg_catalog.to_regclass(${quoteLiteral(qualified)})
+    AND attribute.attnum > 0
+    AND NOT attribute.attisdropped;
+
+  IF actual_columns IS DISTINCT FROM ${expectedColumns} THEN
+    RAISE EXCEPTION 'managed view ${qualified} columns do not match its declaration: expected %, got %', ${expectedColumns}, actual_columns
+      USING ERRCODE = '42804';
+  END IF;
+  IF actual_types IS DISTINCT FROM ${expectedTypes} THEN
+    RAISE EXCEPTION 'managed view ${qualified} types do not match its declaration: expected %, got %', ${expectedTypes}, actual_types
+      USING ERRCODE = '42804';
+  END IF;
+
+  SELECT coalesce(array_agg(found.name ORDER BY found.name), ARRAY[]::text[])
+  INTO actual_dependencies
+  FROM (
+    SELECT DISTINCT dependency_namespace.nspname || '.' || dependency_relation.relname AS name
+    FROM pg_catalog.pg_rewrite AS rewrite
+    JOIN pg_catalog.pg_depend AS dependency
+      ON dependency.classid = 'pg_catalog.pg_rewrite'::regclass
+      AND dependency.objid = rewrite.oid
+      AND dependency.refclassid = 'pg_catalog.pg_class'::regclass
+    JOIN pg_catalog.pg_class AS dependency_relation ON dependency_relation.oid = dependency.refobjid
+    JOIN pg_catalog.pg_namespace AS dependency_namespace ON dependency_namespace.oid = dependency_relation.relnamespace
+    WHERE rewrite.ev_class = pg_catalog.to_regclass(${quoteLiteral(qualified)})
+      AND dependency.refobjid <> rewrite.ev_class
+      AND dependency_relation.relkind IN ('r', 'p', 'v', 'm', 'f')
+  ) AS found;
+
+  IF actual_dependencies IS DISTINCT FROM ${expectedDependencies} THEN
+    RAISE EXCEPTION 'managed view ${qualified} dependencies do not match its declaration: expected %, got %', ${expectedDependencies}, actual_dependencies
+      USING ERRCODE = '2BP01';
+  END IF;
+
+  IF EXISTS (
+    SELECT 1
+    FROM pg_catalog.pg_rewrite AS rewrite
+    JOIN pg_catalog.pg_depend AS dependency
+      ON dependency.classid = 'pg_catalog.pg_rewrite'::regclass
+      AND dependency.objid = rewrite.oid
+      AND dependency.refclassid = 'pg_catalog.pg_proc'::regclass
+    JOIN pg_catalog.pg_proc AS dependency_function ON dependency_function.oid = dependency.refobjid
+    JOIN pg_catalog.pg_namespace AS function_namespace ON function_namespace.oid = dependency_function.pronamespace
+    WHERE rewrite.ev_class = pg_catalog.to_regclass(${quoteLiteral(qualified)})
+      AND (
+        function_namespace.nspname <> 'pg_catalog'
+        OR dependency_function.proname <> ALL (${allowedFunctions})
+      )
+  ) THEN
+    RAISE EXCEPTION 'managed view ${qualified} may only call explicitly allowlisted side-effect-free pg_catalog functions'
+      USING ERRCODE = '42501';
+  END IF;
+
+  IF EXISTS (
+    SELECT 1
+    FROM pg_catalog.pg_rewrite AS rewrite
+    JOIN pg_catalog.pg_depend AS dependency
+      ON dependency.classid = 'pg_catalog.pg_rewrite'::regclass
+      AND dependency.objid = rewrite.oid
+      AND dependency.refclassid = 'pg_catalog.pg_operator'::regclass
+    JOIN pg_catalog.pg_operator AS dependency_operator ON dependency_operator.oid = dependency.refobjid
+    JOIN pg_catalog.pg_namespace AS operator_namespace ON operator_namespace.oid = dependency_operator.oprnamespace
+    WHERE rewrite.ev_class = pg_catalog.to_regclass(${quoteLiteral(qualified)})
+      AND operator_namespace.nspname <> 'pg_catalog'
+  ) THEN
+    RAISE EXCEPTION 'managed view ${qualified} may only use pg_catalog operators'
+      USING ERRCODE = '42501';
+  END IF;
+END
+$sequence_orm_validate_view$`;
+}
+function sqlTextArray(values) {
+  return values.length === 0 ? "ARRAY[]::text[]" : `ARRAY[${values.map((value) => quoteLiteral(value)).join(", ")}]::text[]`;
+}
+function viewTypeRegtype(column, schema) {
+  if (typeof column.type === "string") return `${quoteLiteral(sqlTypeName(column.type))}::regtype`;
+  return `${quoteLiteral(`${quoteIdentifier(schema)}.${quoteIdentifier(column.type.enum)}`)}::regtype`;
+}
 var previousId = (snapshot) => snapshot.id;
+function snapshotViews(snapshot) {
+  const views = snapshot.views ?? {};
+  return new Map(Object.values(views).map((view) => [view.name, view]));
+}
+function snapshotViewDependencies(snapshot) {
+  const metadata = snapshot._sequenceOrm;
+  return metadata?.viewDependencies ?? {};
+}
+function withoutViews(snapshot) {
+  const clone = structuredClone(snapshot);
+  clone.views = {};
+  delete clone._sequenceOrm;
+  return clone;
+}
+function affectedViewNames({
+  previousViews,
+  currentViews,
+  previousDependencies,
+  currentDependencies,
+  baseChanged
+}) {
+  const allNames = /* @__PURE__ */ new Set([...previousViews.keys(), ...currentViews.keys()]);
+  if (baseChanged) return allNames;
+  const affected = new Set(
+    [...allNames].filter((name) => {
+      const before = previousViews.get(name);
+      const after = currentViews.get(name);
+      return before === void 0 || after === void 0 || stableJson(before) !== stableJson(after);
+    })
+  );
+  let grew = true;
+  while (grew) {
+    grew = false;
+    for (const name of allNames) {
+      if (affected.has(name)) continue;
+      const dependencies = /* @__PURE__ */ new Set([...previousDependencies[name] ?? [], ...currentDependencies[name] ?? []]);
+      if ([...dependencies].some((dependency) => affected.has(dependency))) {
+        affected.add(name);
+        grew = true;
+      }
+    }
+  }
+  return affected;
+}
+function topologicalViewNames(names, dependencies) {
+  const remaining = new Set(names);
+  const ordered = [];
+  while (remaining.size > 0) {
+    const ready = [...remaining].filter((name) => (dependencies[name] ?? []).every((dependency) => !remaining.has(dependency))).sort();
+    if (ready.length === 0) {
+      throw new OrmDefinitionError(`view dependencies form a cycle among: ${[...remaining].sort().join(", ")}`);
+    }
+    for (const name of ready) {
+      ordered.push(name);
+      remaining.delete(name);
+    }
+  }
+  return ordered;
+}
+async function generatedViewStatements({
+  snapshot,
+  names,
+  mode,
+  schema
+}) {
+  if (names.size === 0) return /* @__PURE__ */ new Map();
+  const without = structuredClone(snapshot);
+  const holder = without;
+  const views = holder.views ?? {};
+  holder.views = Object.fromEntries(Object.entries(views).filter(([, view]) => !names.has(view.name)));
+  const generated = mode === "drop" ? await diffStatements(snapshot, without) : await diffStatements(without, snapshot);
+  const statements = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const qualified = `${quoteIdentifier(schema)}.${quoteIdentifier(name)}`;
+    const prefix = mode === "drop" ? "DROP VIEW" : "CREATE VIEW";
+    const statement = generated.find((candidate) => candidate.trimStart().startsWith(`${prefix} ${qualified}`));
+    if (statement) statements.set(name, statement.replace(/;\s*$/, ""));
+  }
+  return statements;
+}
+function requiredViewStatement(statements, name, schema, operation) {
+  const statement = statements.get(name);
+  if (!statement) {
+    throw new OrmDefinitionError(`drizzle-kit did not generate ${operation} VIEW for '${schema}.${name}'`);
+  }
+  return statement;
+}
+function assertValidViewDependencies(canonical) {
+  const views = canonical.views ?? [];
+  const known = /* @__PURE__ */ new Set([...canonical.tables.map((table) => table.table), ...views.map((view) => view.view)]);
+  for (const view of views) {
+    for (const dependency of view.dependencies) {
+      if (!known.has(dependency)) {
+        throw new OrmDefinitionError(`view '${view.view}' depends on unknown relation '${dependency}'`);
+      }
+    }
+  }
+  topologicalViewNames(
+    new Set(views.map((view) => view.view)),
+    Object.fromEntries(views.map((view) => [view.view, view.dependencies]))
+  );
+}
 var QUOTED_STRING_PATTERN2 = /'(?:[^']|'')*'/g;
 var TOKEN_PATTERN = /\bclaim\(\s*'((?:[^']|'')*)'\s*\)|\bcapability\(\s*'((?:[^']|'')*)'\s*\)|'(?:[^']|'')*'|(?<!:):([a-z][a-z0-9_]*)/g;
 var BARE_CALL_PATTERN = /\b(?:claim|capability)\s*\(/;
@@ -4515,8 +5976,8 @@ var actionParamArg = (name) => `p_${name}`;
 function compileActionStatements(action, renderParam = actionParamArg) {
   return actionStatementSources(action.executes).map((statement) => compileStatement(statement, renderParam));
 }
-function compileStatement(sql3, renderParam) {
-  const compiled = sql3.replace(TOKEN_PATTERN, (token, claimKey, capabilityKey, paramName) => {
+function compileStatement(sql4, renderParam) {
+  const compiled = sql4.replace(TOKEN_PATTERN, (token, claimKey, capabilityKey, paramName) => {
     if (claimKey !== void 0) {
       if (!CLAIM_KEY_PATTERN.test(claimKey)) throw new OrmDefinitionError(`invalid claim key in executes: ${token}`);
       return claimExpression(claimKey);
@@ -4569,8 +6030,8 @@ function actionPrepareChecks(definition) {
     const order = actionParamOrder(action);
     const signature = order.length > 0 ? ` (${order.map((param) => sqlTypeName(action.params[param].type)).join(", ")})` : "";
     const compiled = compileActionStatements(action, (param) => `$${order.indexOf(param) + 1}`);
-    compiled.forEach((sql3, index3) => {
-      const checked = action.returns && index3 === compiled.length - 1 ? returnProjection(action.returns, sql3) : sql3;
+    compiled.forEach((sql4, index3) => {
+      const checked = action.returns && index3 === compiled.length - 1 ? returnProjection(action.returns, sql4) : sql4;
       statements.push(`PREPARE ${quoteIdentifier(`orm_check_${name}_${index3}`)}${signature} AS ${checked}`);
     });
   }
@@ -4686,15 +6147,15 @@ async function planMigration({
   const ddl = await diffStatements(hints.adjusted, snapshot);
   const policyDrops = policyDropStatements(schema, snapshotTableNames(previous, schema));
   const statements = [
-    ...policyDrops.map((sql3) => ({ kind: "security", sql: sql3 })),
-    ...hints.statements.map((sql3) => ({ kind: "hint", sql: sql3 })),
-    ...ddl.map((sql3) => ({ kind: "ddl", sql: sql3.replace(/;\s*$/, "") })),
-    ...securityStatements(definition).map((sql3) => ({ kind: "security", sql: sql3 })),
+    ...policyDrops.map((sql4) => ({ kind: "security", sql: sql4 })),
+    ...hints.statements.map((sql4) => ({ kind: "hint", sql: sql4 })),
+    ...ddl.map((sql4) => ({ kind: "ddl", sql: sql4.replace(/;\s*$/, "") })),
+    ...securityStatements(definition).map((sql4) => ({ kind: "security", sql: sql4 })),
     // PREPARE each action's executes first (plpgsql bodies don't check columns
     // at CREATE), then create the functions. Both reference the tables the DDL
     // above creates, so they close the plan.
-    ...actionPrepareChecks(definition).map((sql3) => ({ kind: "function", sql: sql3 })),
-    ...actionFunctionStatements(definition).map((sql3) => ({ kind: "function", sql: sql3 }))
+    ...actionPrepareChecks(definition).map((sql4) => ({ kind: "function", sql: sql4 })),
+    ...actionFunctionStatements(definition).map((sql4) => ({ kind: "function", sql: sql4 }))
   ];
   return { namespace: definition.namespace, schema, statements, snapshot };
 }
@@ -4823,6 +6284,8 @@ function validateCapabilityRefs(files, declared) {
     const referenced = [
       ...table.policies?.read ? referencedCapabilities(table.policies.read.ast) : [],
       ...table.policies?.write ? referencedCapabilities(table.policies.write.ast) : [],
+      ...table.policies?.insert ? referencedCapabilities(table.policies.insert.ast) : [],
+      ...table.policies?.update ? referencedCapabilities(table.policies.update.ast) : [],
       ...Object.values(table.actions ?? {}).flatMap((action) => [
         ...action.requires ? referencedCapabilities(action.requires.ast) : [],
         ...referencedExecuteCapabilities(action)
@@ -4980,7 +6443,7 @@ async function readMigrationSql(dir, entry) {
     throw new OrmDefinitionError("missing migration file", path);
   });
 }
-var checksumOf = (text3) => createHash("sha256").update(text3).digest("hex");
+var checksumOf = (text4) => createHash("sha256").update(text4).digest("hex");
 var migrationName = (ordinal, contentHash) => `${pad(ordinal)}_${contentHash.slice(0, 12)}`;
 function renderMigrationSql({
   name,
@@ -5006,12 +6469,12 @@ async function writeMigration({
   const tip = workspace.journal.entries.at(-1);
   const ordinal = (tip?.ordinal ?? 0) + 1;
   const name = migrationName(ordinal, contentHash);
-  const sql3 = renderMigrationSql({ name, namespace: workspace.journal.namespace, contentHash, plan });
+  const sql4 = renderMigrationSql({ name, namespace: workspace.journal.namespace, contentHash, plan });
   const metaDir = join(dir, MIGRATIONS_DIRNAME, META_DIRNAME);
   await mkdir(metaDir, { recursive: true });
   const snapshotText = `${JSON.stringify(plan.snapshot, null, 2)}
 `;
-  await writeFile(join(dir, MIGRATIONS_DIRNAME, `${name}.sql`), sql3);
+  await writeFile(join(dir, MIGRATIONS_DIRNAME, `${name}.sql`), sql4);
   await writeFile(join(metaDir, `${pad(ordinal)}.snapshot.json`), snapshotText);
   const journal = {
     ...workspace.journal,
@@ -5022,7 +6485,7 @@ async function writeMigration({
         name,
         content_hash: contentHash,
         previous_content_hash: tip?.content_hash ?? null,
-        checksum: checksumOf(sql3),
+        checksum: checksumOf(sql4),
         snapshot_checksum: checksumOf(snapshotText),
         destructive
       }
@@ -5137,8 +6600,8 @@ async function checkWorkspace({
   let previousId3;
   let previousHash = null;
   for (const entry of workspace.journal.entries) {
-    const sql3 = await readMigrationSql(dir, entry);
-    if (checksumOf(sql3) !== entry.checksum) {
+    const sql4 = await readMigrationSql(dir, entry);
+    if (checksumOf(sql4) !== entry.checksum) {
       log(`${MIGRATIONS_DIRNAME}/${entry.name}.sql does not match its journal checksum \u2014 committed migrations must not be edited`);
       return 1;
     }
@@ -5178,7 +6641,7 @@ async function checkWorkspace({
   log(`migrations in sync \u2014 ${workspace.journal.entries.length} committed, tip ${tip.name}`);
   return 0;
 }
-var firstLine = (sql3) => sql3.split("\n")[0] ?? sql3;
+var firstLine = (sql4) => sql4.split("\n")[0] ?? sql4;
 
 // src/migrations/from-yaml.ts
 function convertV1DefinitionToCanonical(definition) {
@@ -5210,7 +6673,7 @@ function convertTable(table) {
     description: table.description,
     source: table.source,
     columns: columns.map(([name, column]) => convertColumn(name, column)),
-    // Synced tables reflect their source — no columns, no primary key.
+    // Synced tables may declare a typed column/PK contract; untyped remain empty.
     primaryKey: primaryKey2.length > 0 ? primaryKey2 : void 0,
     links: Object.entries(table.links ?? {}).map(([name, link]) => convertLink(table.table, name, link)),
     indexes: (table.indexes ?? []).map((index3) => ({
@@ -5223,9 +6686,20 @@ function convertTable(table) {
       read: table.policies?.read?.source,
       write: table.policies?.write?.source
     },
-    actions: Object.entries(table.actions ?? {}).map(([name, action]) => convertAction(table.table, name, action))
+    // v2 has no action surface (writes are mutations); the transition sweep
+    // drops the plpgsql action_* functions, so carrying the metadata would be
+    // dead weight. droppedV1Actions() surfaces them for the emitter's TODO.
+    actions: []
   };
 }
+function droppedV1Actions(definition) {
+  const dropped = /* @__PURE__ */ new Map();
+  for (const table of definition.tables) {
+    const names = Object.keys(table.actions ?? {});
+    if (names.length > 0) dropped.set(table.table, names);
+  }
+  return dropped;
+}
 function convertColumn(name, column) {
   const isDefaultFn = column.default !== void 0 && isFunctionDefault(column.default, column.type);
   return {
@@ -5259,25 +6733,6 @@ function convertLink(table, name, link) {
     description: link.description
   };
 }
-function convertAction(table, name, action) {
-  return {
-    name,
-    requires: action.requires?.source,
-    params: Object.fromEntries(
-      Object.entries(action.params ?? {}).map(([param, definition]) => [
-        param,
-        { type: definition.type, nullable: definition.optional === true }
-      ])
-    ),
-    // The v2 contract carries one SQL string; statement boundaries survive as
-    // `;\n` (v1 validation guarantees no bare `;` inside a single statement).
-    executes: actionStatementSources(action.executes).join(";\n"),
-    // v1 declared the RETURNING columns inline; v2 types them at compile time,
-    // so the shape collapses to rows-vs-rowsAffected.
-    returns: action.returns ? "rows" : "rowsAffected",
-    audit: action.audit ? { action: action.audit.action, resource: action.audit.resource ?? table } : void 0
-  };
-}
 
 // src/migrations/v2.ts
 var SHA256_HEX = /^[0-9a-f]{64}$/;
@@ -5300,7 +6755,7 @@ function buildRebaseJournalEntry({ namespace, previousHash, newHash, ordinal, sn
     throw new OrmDefinitionError(`rebase ordinal must be an integer \u2265 2 (a rebase sits on an existing journal tip); got ${ordinal}`);
   }
   const name = migrationName(ordinal, newHash);
-  const sql3 = renderRebaseMigrationSql({ name, namespace, previousHash, newHash });
+  const sql4 = renderRebaseMigrationSql({ name, namespace, previousHash, newHash });
   const snapshotText = `${JSON.stringify(snapshot, null, 2)}
 `;
   const entry = {
@@ -5308,11 +6763,11 @@ function buildRebaseJournalEntry({ namespace, previousHash, newHash, ordinal, sn
     name,
     content_hash: newHash,
     previous_content_hash: previousHash,
-    checksum: checksumOf(sql3),
+    checksum: checksumOf(sql4),
     snapshot_checksum: checksumOf(snapshotText),
     destructive: false
   };
-  return { name, entry, sql: sql3, snapshotText };
+  return { name, entry, sql: sql4, snapshotText };
 }
 function renderRebaseMigrationSql({
   name,
@@ -5350,15 +6805,15 @@ var PLATFORM_USER_FIELDS = [
 ];
 function generateSdl(canonical, options = {}) {
   const def = normalizeCanonical(canonicalDefinitionSchema.parse(canonical));
-  const tables = def.tables.filter((table) => table.source === void 0);
+  const tables = canonicalRelations(def).filter((table) => table.source === void 0);
   if (tables.length === 0) {
     throw new SdlGenerationError(
-      `Namespace "${def.namespace}" exposes no tables (synced tables are excluded from SDL in v2.0) \u2014 nothing to generate.`
+      `Namespace "${def.namespace}" exposes no relations (synced tables are excluded from SDL in v2.0) \u2014 nothing to generate.`
     );
   }
   for (const table of tables) {
     if (table.columns.length === 0) {
-      throw new SdlGenerationError(`Table "${table.table}" has no columns \u2014 cannot generate an object type.`);
+      throw new SdlGenerationError(`Relation "${table.table}" has no columns \u2014 cannot generate an object type.`);
     }
   }
   const namesByTable = new Map(tables.map((table) => [table.table, tableNames(table.table)]));
@@ -5452,8 +6907,8 @@ function renderEnum(name, values) {
 ${values.map((value) => `  ${value}`).join("\n")}
 }`;
 }
-function descriptionLines(text3, indent) {
-  const escaped = text3.replace(/"""/g, '\\"""');
+function descriptionLines(text4, indent) {
+  const escaped = text4.replace(/"""/g, '\\"""');
   return [`${indent}"""`, ...escaped.split("\n").map((line) => `${indent}${line}`), `${indent}"""`];
 }
 function renderComparisonExp(gqlTypeName) {
@@ -5538,10 +6993,20 @@ function renderTableBlocks(ctx) {
 ${fields}
 }`);
   }
-  if (isWritable(table)) blocks.push(...renderWriteBlocks(ctx));
+  if (allowsInsert(table) || allowsUpdate(table)) {
+    blocks.push(...renderWriteBlocks(ctx, { insert: allowsInsert(table), update: allowsUpdate(table) }));
+  }
   return blocks;
 }
-function isWritable(table) {
+function allowsInsert(table) {
+  return table.policies.write !== void 0 || table.policies.insert !== void 0;
+}
+function allowsUpdate(table) {
+  return table.policies.write !== void 0 || table.policies.update !== void 0;
+}
+function allowsOnConflict(table) {
+  if (!allowsInsert(table) || !allowsUpdate(table)) return false;
+  if (table.policies.insert !== void 0 || table.policies.update !== void 0) return false;
   return table.policies.write !== void 0;
 }
 function renderObjectType(ctx) {
@@ -5673,46 +7138,50 @@ function constraintValues(table) {
   const values = /* @__PURE__ */ new Set();
   if (table.primaryKey && table.primaryKey.length > 0) values.add(`${table.table}_pkey`);
   for (const column of table.columns) {
-    if (column.unique) values.add(`${table.table}_${column.columnName}_key`);
+    if (column.unique) values.add(`${table.table}_${column.columnName}_unique`);
   }
   for (const index3 of table.indexes) {
     if (index3.unique) values.add(index3.name ?? `${table.table}_${index3.columns.join("_")}_key`);
   }
   return [...values].sort();
 }
-function renderWriteBlocks(ctx) {
+function renderWriteBlocks(ctx, access) {
   const { table, names, pinned } = ctx;
   const blocks = [];
-  const pinnedSet = new Set(pinned);
-  const insertable = table.columns.filter(
-    (column) => !pinnedSet.has(column.name) && !pinnedSet.has(column.columnName)
-  );
-  if (insertable.length === 0) {
-    throw new SdlGenerationError(
-      `Table "${table.table}" has no insertable columns after excluding pinned columns [${pinned.join(", ")}].`
+  if (access.insert) {
+    const pinnedSet = new Set(pinned);
+    const insertable = table.columns.filter(
+      (column) => !pinnedSet.has(column.name) && !pinnedSet.has(column.columnName)
     );
-  }
-  const insertLines = insertable.map(
-    (column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`
-  );
-  blocks.push(`input ${names.insertInput} {
+    if (insertable.length === 0) {
+      throw new SdlGenerationError(
+        `Table "${table.table}" has no insertable columns after excluding pinned columns [${pinned.join(", ")}].`
+      );
+    }
+    const insertLines = insertable.map(
+      (column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`
+    );
+    blocks.push(`input ${names.insertInput} {
 ${insertLines.join("\n")}
 }`);
-  const setLines = table.columns.map(
-    (column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`
-  );
-  blocks.push(`input ${names.setInput} {
+  }
+  if (access.update) {
+    const setLines = table.columns.map(
+      (column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`
+    );
+    blocks.push(`input ${names.setInput} {
 ${setLines.join("\n")}
 }`);
-  const jsonb3 = jsonbColumns(table);
-  if (jsonb3.length > 0) {
-    const appendLines = jsonb3.map((column) => `  ${fieldName(column.name)}: jsonb`);
+  }
+  const jsonb4 = jsonbColumns(table);
+  if (access.update && jsonb4.length > 0) {
+    const appendLines = jsonb4.map((column) => `  ${fieldName(column.name)}: jsonb`);
     blocks.push(`input ${names.appendInput} {
 ${appendLines.join("\n")}
 }`);
   }
   const numericish = numericishColumns(table);
-  if (numericish.length > 0) {
+  if (access.update && numericish.length > 0) {
     const incLines = numericish.map(
       (column) => `  ${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}`
     );
@@ -5721,7 +7190,7 @@ ${incLines.join("\n")}
 }`);
   }
   const constraints = constraintValues(table);
-  if (constraints.length > 0) {
+  if (access.insert && allowsOnConflict(table) && constraints.length > 0) {
     for (const value of constraints) assertEnumValue(value, `constraint enum for table "${table.table}"`);
     blocks.push(renderEnum(names.constraintEnum, constraints));
     const updateColumns = table.columns.map((column) => fieldName(column.name));
@@ -5734,12 +7203,14 @@ ${incLines.join("\n")}
 }`
     );
   }
-  blocks.push(
-    `type ${names.mutationResponse} {
+  if (access.insert || access.update) {
+    blocks.push(
+      `type ${names.mutationResponse} {
   affectedRows: Int!
   returning: [${names.typename}!]!
 }`
-  );
+    );
+  }
   return blocks;
 }
 function renderQueryRoot(tables, namesByTable) {
@@ -5764,35 +7235,64 @@ function columnGqlTypeOf(table, column) {
 function renderMutationRoot(tables, namesByTable) {
   const lines = [];
   for (const table of tables) {
-    if (!isWritable(table)) continue;
+    const canInsert = allowsInsert(table);
+    const canUpdate = allowsUpdate(table);
+    if (!canInsert && !canUpdate) continue;
     const names = namesByTable.get(table.table);
     if (!names) continue;
     const constraints = constraintValues(table);
-    const onConflictArg = constraints.length > 0 ? `, onConflict: ${names.onConflict}` : "";
+    const onConflictArg = canInsert && allowsOnConflict(table) && constraints.length > 0 ? `, onConflict: ${names.onConflict}` : "";
     const updateArgs = [`_set: ${names.setInput}`];
     if (jsonbColumns(table).length > 0) updateArgs.push(`_append: ${names.appendInput}`);
     if (numericishColumns(table).length > 0) updateArgs.push(`_inc: ${names.incInput}`);
     const updateArgList = updateArgs.join(", ");
-    lines.push(`  ${names.insertRoot}(objects: [${names.insertInput}!]!${onConflictArg}): ${names.mutationResponse}`);
-    lines.push(`  ${names.insertOneRoot}(object: ${names.insertInput}!${onConflictArg}): ${names.typename}`);
-    lines.push(`  ${names.updateRoot}(where: ${names.boolExp}!, ${updateArgList}): ${names.mutationResponse}`);
-    const pk = primaryKeyColumns(table);
-    if (pk.length > 0) {
-      lines.push(
-        `  ${names.updateByPkRoot}(pkColumns: ${names.pkColumnsInput}!, ${updateArgList}): ${names.typename}`
-      );
-    }
-    lines.push(`  ${names.deleteRoot}(where: ${names.boolExp}!): ${names.mutationResponse}`);
-    if (pk.length > 0) {
-      const args = pk.map((column) => `${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}!`).join(", ");
-      lines.push(`  ${names.deleteByPkRoot}(${args}): ${names.typename}`);
+    if (canInsert) {
+      lines.push(`  ${names.insertRoot}(objects: [${names.insertInput}!]!${onConflictArg}): ${names.mutationResponse}`);
+      lines.push(`  ${names.insertOneRoot}(object: ${names.insertInput}!${onConflictArg}): ${names.typename}`);
+    }
+    if (canUpdate) {
+      lines.push(`  ${names.updateRoot}(where: ${names.boolExp}!, ${updateArgList}): ${names.mutationResponse}`);
+      const pk = primaryKeyColumns(table);
+      if (pk.length > 0) {
+        lines.push(
+          `  ${names.updateByPkRoot}(pkColumns: ${names.pkColumnsInput}!, ${updateArgList}): ${names.typename}`
+        );
+      }
+      lines.push(`  ${names.deleteRoot}(where: ${names.boolExp}!): ${names.mutationResponse}`);
+      if (pk.length > 0) {
+        const args = pk.map((column) => `${fieldName(column.name)}: ${columnGqlTypeOf(table, column)}!`).join(", ");
+        lines.push(`  ${names.deleteByPkRoot}(${args}): ${names.typename}`);
+      }
     }
+    lines.push(...renderCowMutationFields(table, names));
   }
   if (lines.length === 0) return null;
   return `type Mutation {
 ${lines.join("\n")}
 }`;
 }
+function renderCowMutationFields(table, names) {
+  const lines = [];
+  const columnByName = new Map(table.columns.map((column) => [column.name, column]));
+  for (const mutation of table.cowMutations ?? []) {
+    const pkColumn = columnByName.get(mutation.pk);
+    if (!pkColumn) continue;
+    const pkArg = `${fieldName(mutation.pk)}: ${columnGqlTypeOf(table, pkColumn)}!`;
+    if (mutation.kind === "revert") {
+      lines.push(`  ${fieldName(mutation.name)}(${pkArg}): ${names.typename}`);
+      continue;
+    }
+    const setArgs = mutation.set.map((property) => {
+      const column = columnByName.get(property);
+      if (!column) return null;
+      const bang = column.nullable === false ? "!" : "";
+      return `${fieldName(property)}: ${columnGqlTypeOf(table, column)}${bang}`;
+    });
+    if (setArgs.some((arg) => arg === null)) continue;
+    lines.push(`  ${fieldName(mutation.name)}(${pkArg}, ${setArgs.join(", ")}): ${names.typename}`);
+  }
+  return lines;
+}
 
 // src/cli.ts
 var BASE_URL_ENV = "SEQUENCE_ORM_BASE_URL";
@@ -5806,6 +7306,8 @@ var USAGE = `usage:
   seq-studio orm apply [dir] -e <env>    author the migration, register, apply, and refresh the generated outputs (the everyday command)
   seq-studio orm apply --dry-run -e <env>  rehearse the migration on a copy of the environment's real data, then discard it (no real apply)
   seq-studio orm apply --no-create -e <env>  apply only if the namespace is already registered (CI guard; never provisions a new namespace)
+  seq-studio orm execute <operation> [dir] --variables-file <file> -e <env>
+                                        execute one named persisted operation as the signed-in caller
   seq-studio orm diff [dir]              write/verify the committed migration standalone (--check is the offline CI gate; --allow-destructive consents; --rebase records a v1 -> v2 conversion as a verified no-op)
   seq-studio orm migrate-from-yaml <dir> convert a v1 YAML namespace to the v2 TypeScript format (migrations/ preserved)
 
@@ -5829,6 +7331,10 @@ async function runCli(argv) {
     console.log(USAGE);
     return command ? 0 : 1;
   }
+  if (rest.includes("--help") || rest.includes("-h")) {
+    console.log(USAGE);
+    return 0;
+  }
   try {
     switch (command) {
       case "init":
@@ -5866,6 +7372,8 @@ async function runCli(argv) {
         const dir = positional(rest) ?? ".";
         return await detectProjectFormat(dir) === "v2" ? await applyV2Command(rest, dir) : await applyCommand(rest);
       }
+      case "execute":
+        return await executeV2Command(rest);
       default:
         console.error(`unknown command: ${command}`);
         console.log(USAGE);
@@ -5876,13 +7384,14 @@ async function runCli(argv) {
     return 1;
   }
 }
+var NON_DEFINITION_YAML_FILES = /* @__PURE__ */ new Set(["pnpm-lock.yaml", "pnpm-workspace.yaml"]);
 async function detectProjectFormat(dir) {
   const entries = await readdir(dir, { withFileTypes: true }).catch(() => {
     throw new OrmDefinitionError(`namespace directory not found: ${dir}`);
   });
   const hasConfig = entries.some((entry) => entry.isFile() && entry.name === NAMESPACE_CONFIG_FILE);
   const hasYaml = entries.some(
-    (entry) => entry.isFile() && DEFINITION_FILE_EXTENSIONS.some((extension) => entry.name.endsWith(extension))
+    (entry) => entry.isFile() && !NON_DEFINITION_YAML_FILES.has(entry.name) && DEFINITION_FILE_EXTENSIONS.some((extension) => entry.name.endsWith(extension))
   );
   if (hasConfig && hasYaml) {
     throw new OrmDefinitionError(
@@ -6030,7 +7539,7 @@ async function generateCommand(rest) {
   await writeGenerateOutputs(dir, compiled.project);
   const { loaded, manifest } = compiled.project;
   console.log(
-    `wrote ${SCHEMA_GRAPHQL_FILE}, ${OPERATIONS_MANIFEST_FILE}, ${TYPE_POLICIES_FILE} (${loaded.canonical.tables.length} table(s), ${Object.keys(manifest.operations).length} operation(s))`
+    `wrote ${SCHEMA_GRAPHQL_FILE}, ${OPERATIONS_MANIFEST_FILE}, ${TYPE_POLICIES_FILE} (${loaded.canonical.tables.length} table(s), ${loaded.canonical.views?.length ?? 0} view(s), ${Object.keys(manifest.operations).length} operation(s))`
   );
   return runConsumerCodegen(dir);
 }
@@ -6077,13 +7586,86 @@ async function runConsumerCodegen(dir) {
   console.log(`ran consumer graphql-codegen (${CODEGEN_CONFIG_FILE})`);
   return 0;
 }
+function isVariablesObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function parseExecuteArgs(rest) {
+  const args = [...rest];
+  const variablesIndex = args.indexOf("--variables-file");
+  if (variablesIndex === -1) {
+    throw new OrmDefinitionError("execute requires --variables-file <file>");
+  }
+  const variablesFile = args[variablesIndex + 1];
+  if (!variablesFile) {
+    throw new OrmDefinitionError("execute requires --variables-file <file>");
+  }
+  args.splice(variablesIndex, 2);
+  const envIndex = args.indexOf("--env");
+  if (envIndex !== -1) args.splice(envIndex, 2);
+  if (args.some((arg) => arg.startsWith("-"))) {
+    throw new OrmDefinitionError("execute accepts only <operation>, [dir], --variables-file, and --env");
+  }
+  const operation = args[0];
+  if (!operation || args.length > 2) {
+    throw new OrmDefinitionError("usage: seq-studio orm execute <operation> [dir] --variables-file <file> -e <env>");
+  }
+  return {
+    operation,
+    dir: args[1] ?? ".",
+    variablesFile
+  };
+}
+async function readExecuteVariables(variablesFile) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(resolve(variablesFile), "utf8"));
+  } catch (error) {
+    throw new OrmDefinitionError(
+      `could not read JSON variables from ${variablesFile}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!isVariablesObject(parsed)) {
+    throw new OrmDefinitionError("--variables-file must contain a JSON object");
+  }
+  return parsed;
+}
+async function executeV2Command(rest) {
+  const { dir, operation, variablesFile } = parseExecuteArgs(rest);
+  if (await detectProjectFormat(dir) !== "v2") {
+    throw new OrmDefinitionError("execute supports TypeScript ORM v2 namespaces only");
+  }
+  const loaded = await loadV2(dir);
+  const manifestPath = join(dir, OPERATIONS_MANIFEST_FILE);
+  let manifest;
+  try {
+    manifest = operationsManifestSchema.parse(JSON.parse(await readFile(manifestPath, "utf8")));
+  } catch (error) {
+    throw new OrmDefinitionError(
+      `could not read ${OPERATIONS_MANIFEST_FILE}: ${error instanceof Error ? error.message : String(error)} \u2014 run \`seq-studio orm generate ${dir}\` first`
+    );
+  }
+  const selected = manifest.operations[operation];
+  if (!selected) {
+    throw new OrmDefinitionError(
+      `operation "${operation}" is not in ${OPERATIONS_MANIFEST_FILE}; run \`seq-studio orm generate ${dir}\` after editing GraphQL documents`
+    );
+  }
+  const variables = await readExecuteVariables(variablesFile);
+  const response = await apiRequestStrict(
+    "POST",
+    `/_data/v2/${loaded.canonical.namespace}`,
+    { op: selected.hash, variables }
+  );
+  console.log(JSON.stringify(response, null, 2));
+  return 0;
+}
 async function validateV2Command(dir) {
   const compiled = await compileV2Project(dir);
   printDiagnostics(compiled.ok ? compiled.project.diagnostics : compiled.diagnostics);
   if (!compiled.ok) return 1;
   const { loaded, manifest } = compiled.project;
   console.log(
-    `namespace ${loaded.canonical.namespace}: ${loaded.canonical.tables.length} table(s), ${Object.keys(manifest.operations).length} operation(s) valid`
+    `namespace ${loaded.canonical.namespace}: ${loaded.canonical.tables.length} table(s), ${loaded.canonical.views?.length ?? 0} view(s), ${Object.keys(manifest.operations).length} operation(s) valid`
   );
   console.log(`content hash ${loaded.hash}`);
   const workspace = await readMigrationWorkspace(dir, loaded.canonical.namespace);
@@ -6213,8 +7795,8 @@ async function checkWorkspaceV2({
   let previousId3;
   let previousHash = null;
   for (const entry of workspace.journal.entries) {
-    const sql3 = await readMigrationSql(dir, entry);
-    if (checksumOf(sql3) !== entry.checksum) {
+    const sql4 = await readMigrationSql(dir, entry);
+    if (checksumOf(sql4) !== entry.checksum) {
       log(`${MIGRATIONS_DIRNAME}/${entry.name}.sql does not match its journal checksum \u2014 committed migrations must not be edited`);
       return 1;
     }
@@ -6401,9 +7983,15 @@ async function migrateFromYamlCommand(rest) {
   }
   const v1 = await loadNamespaceDefinition(dir);
   const canonical = convertV1DefinitionToCanonical(v1.definition);
+  const droppedActions = droppedV1Actions(v1.definition);
   await writeConverted(join(dir, NAMESPACE_CONFIG_FILE), emitSequenceConfig(canonical));
   await mkdir(join(dir, SCHEMA_DIR), { recursive: true });
-  await writeConverted(join(dir, SCHEMA_DIR, "tables.ts"), emitSchemaTables(canonical));
+  await writeConverted(join(dir, SCHEMA_DIR, "tables.ts"), emitSchemaTables(canonical, droppedActions));
+  for (const [table, names] of droppedActions) {
+    console.log(
+      `note: v1 actions on '${table}' were dropped (${names.join(", ")}) \u2014 v2 has no action surface; re-author them as persisted mutations (see the TODO in schema/tables.ts)`
+    );
+  }
   const reloaded = await loadV2(dir);
   if (JSON.stringify(sortKeys(reloaded.canonical)) !== JSON.stringify(sortKeys(canonical))) {
     console.error(
@@ -6467,14 +8055,15 @@ function emitSequenceConfig(canonical) {
   lines.push("})", "");
   return lines.join("\n");
 }
-function emitSchemaTables(canonical) {
+function emitSchemaTables(canonical, droppedActions) {
   const columnTables2 = canonical.tables.filter((table) => table.source === void 0);
   const syncedTables = canonical.tables.filter((table) => table.source !== void 0);
   const hasLinks = canonical.tables.some((table) => table.links.length > 0);
+  const syncedHasColumns = syncedTables.some((table) => table.columns.length > 0);
   const imports = [
     ...columnTables2.length > 0 ? ["defineTable"] : [],
     ...syncedTables.length > 0 ? ["defineSyncedTable"] : [],
-    ...columnTables2.length > 0 ? ["t"] : [],
+    ...columnTables2.length > 0 || syncedHasColumns ? ["t"] : [],
     ...hasLinks ? ["toOne"] : []
   ].sort((a, b) => a.localeCompare(b));
   const parts = [
@@ -6488,18 +8077,62 @@ function emitSchemaTables(canonical) {
     ""
   ];
   for (const table of canonical.tables) {
+    const dropped = droppedActions?.get(table.table) ?? [];
+    if (dropped.length > 0) {
+      parts.push(
+        `// TODO: v1 actions dropped by the conversion \u2014 v2 has no action surface (writes`,
+        `// are persisted mutations). Re-author for '${table.table}': ${dropped.join(", ")}`
+      );
+    }
     parts.push(table.source !== void 0 ? emitSyncedTable(table) : emitTable(table));
   }
   return parts.join("\n");
 }
 function emitSyncedTable(table) {
+  const singlePrimaryKey = table.primaryKey?.length === 1 ? table.primaryKey[0] : void 0;
+  if (table.columns.length === 0) {
+    const lines2 = [
+      `export const ${tableVarName(table.table)} = defineSyncedTable(${quote(table.table)}, {`,
+      `  source: ${quote(table.source ?? "")},`
+    ];
+    if (table.description !== void 0) lines2.push(`  description: ${quote(table.description)},`);
+    if (table.policies.read !== void 0) {
+      lines2.push("  policies: {", `    read: ${policyLiteral(table.policies.read)},`, "  },");
+    }
+    lines2.push("})", "");
+    return lines2.join("\n");
+  }
   const lines = [
-    `export const ${tableVarName(table.table)} = defineSyncedTable(${quote(table.table)}, {`,
-    // `source` is guaranteed by the caller's filter.
-    `  source: ${quote(table.source ?? "")},`
+    `export const ${tableVarName(table.table)} = defineSyncedTable(`,
+    `  ${quote(table.table)},`,
+    "  {"
   ];
-  if (table.description !== void 0) lines.push(`  description: ${quote(table.description)},`);
-  lines.push("})", "");
+  for (const column of table.columns) lines.push(`    ${columnProperty(table.table, column, singlePrimaryKey)}`);
+  lines.push("  },", "  {");
+  lines.push(`    source: ${quote(table.source ?? "")},`);
+  if (table.description !== void 0) lines.push(`    description: ${quote(table.description)},`);
+  if (singlePrimaryKey === void 0 && table.primaryKey && table.primaryKey.length > 0) {
+    lines.push(`    primaryKey: ${jsonLiteral(table.primaryKey, 4)},`);
+  }
+  if (table.links.length > 0) {
+    lines.push("    links: {");
+    for (const link of table.links) {
+      if (link.kind !== "toOne" || link.target === void 0) {
+        throw new OrmDefinitionError(
+          `link '${link.name}' on synced '${table.table}' is not a toOne link \u2014 not a v1 conversion output`
+        );
+      }
+      const options = [`on: ${quote(link.on)}`];
+      if (link.references !== void 0) options.push(`references: ${quote(link.references)}`);
+      if (link.description !== void 0) options.push(`description: ${quote(link.description)}`);
+      lines.push(`      ${objectKey(link.name)}: toOne(() => ${tableVarName(link.target)}, { ${options.join(", ")} }),`);
+    }
+    lines.push("    },");
+  }
+  if (table.policies.read !== void 0) {
+    lines.push("    policies: {", `      read: ${policyLiteral(table.policies.read)},`, "    },");
+  }
+  lines.push("  },", ")", "");
   return lines.join("\n");
 }
 function emitTable(table) {
@@ -6569,7 +8202,6 @@ function emitTableConfig(table, singlePrimaryKey) {
     if (table.policies.write !== void 0) lines.push(`      write: ${policyLiteral(table.policies.write)},`);
     lines.push("    },");
   }
-  if (table.actions.length > 0) lines.push(`    actions: ${jsonLiteral(table.actions, 4)},`);
   return lines;
 }
 function policyLiteral(policy) {
@@ -6870,7 +8502,7 @@ function positional(rest) {
   if (envIndex !== -1) args.splice(envIndex, 2);
   return args.find((arg) => !arg.startsWith("-"));
 }
-var firstLine2 = (sql3) => sql3.split("\n")[0] ?? sql3;
+var firstLine2 = (sql4) => sql4.split("\n")[0] ?? sql4;
 
 export { BASE_URL_ENV, ORM_MODULE_PATH_ENV, TOKEN_ENV, runCli, setTokenProvider };
 //# sourceMappingURL=cli.js.map