@amerged/ohmyhost-cli 0.1.44 → 0.1.46

package/dist/{chunk-VJWPDFZ5.js → chunk-A4ZYW4XW.js}

@@ -26645,7 +26645,7 @@ var require_discriminator = __commonJS({
       error,
       code(cxt) {
         const { gen, data, schema, parentSchema, it } = cxt;
-        const { oneOf: oneOf2 } = parentSchema;
+        const { oneOf: oneOf3 } = parentSchema;
         if (!it.opts.discriminator) {
           throw new Error("discriminator: requires discriminator option");
         }
@@ -26654,7 +26654,7 @@ var require_discriminator = __commonJS({
           throw new Error("discriminator: requires propertyName");
         if (schema.mapping)
           throw new Error("discriminator: mapping is not supported");
-        if (!oneOf2)
+        if (!oneOf3)
           throw new Error("discriminator: requires oneOf keyword");
         const valid = gen.let("valid", false);
         const tag = gen.const("tag", (0, codegen_1._)`${data}${(0, codegen_1.getProperty)(tagName)}`);
@@ -26682,8 +26682,8 @@ var require_discriminator = __commonJS({
           const oneOfMapping = {};
           const topRequired = hasRequired(parentSchema);
           let tagRequired = true;
-          for (let i = 0; i < oneOf2.length; i++) {
-            let sch = oneOf2[i];
+          for (let i = 0; i < oneOf3.length; i++) {
+            let sch = oneOf3[i];
             if ((sch === null || sch === void 0 ? void 0 : sch.$ref) && !(0, util_1.schemaHasRulesButRef)(sch, it.self.RULES)) {
               const ref = sch.$ref;
               sch = compile_1.resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref);
@@ -38776,14 +38776,14 @@ function isFrameworkConversionDiagnosticCode(value) {
 function parseFrameworkConversionDiagnostic(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     return null;
-  const record7 = value;
-  const code = Object.hasOwn(record7, "code") ? record7["code"] : void 0;
-  const path2 = Object.hasOwn(record7, "path") ? record7["path"] : void 0;
+  const record8 = value;
+  const code = Object.hasOwn(record8, "code") ? record8["code"] : void 0;
+  const path2 = Object.hasOwn(record8, "path") ? record8["path"] : void 0;
   if (!isFrameworkConversionDiagnosticCode(code) || typeof path2 !== "string")
     return null;
   const definition = DETAIL_DEFINITIONS[code];
-  const fields = Object.entries(definition.fields ?? {}).map(([name, grammar]) => [name, grammar, Object.hasOwn(record7, name) ? record7[name] : void 0]);
-  if (Object.keys(record7).length !== fields.length + 2 || pathClassOf(definition, path2) === null || fields.some(([, grammar, field]) => !fieldMatches(grammar, field)))
+  const fields = Object.entries(definition.fields ?? {}).map(([name, grammar]) => [name, grammar, Object.hasOwn(record8, name) ? record8[name] : void 0]);
+  if (Object.keys(record8).length !== fields.length + 2 || pathClassOf(definition, path2) === null || fields.some(([, grammar, field]) => !fieldMatches(grammar, field)))
     return null;
   return Object.freeze(Object.fromEntries([
     ["code", code],
@@ -40219,6 +40219,48 @@ var PROBLEM_POLICY = {
     action: "The platform is still retrying this webhook delivery. Read the delivery in the delivery list; replay it only if it ends dead_lettered or the receiver needs the event again.",
     title: "Webhook delivery still pending"
   },
+  database_watch_limit: {
+    status: 409,
+    retryable: false,
+    action: "List the project's database watches for this environment and delete one you no longer need, then create the watch again.",
+    title: "Database watch limit reached"
+  },
+  database_watch_table_unavailable: {
+    status: 409,
+    retryable: false,
+    action: "The table must exist as an ordinary table owned by the application, created by a deployed migration; views, partitions, temporary tables and the schemas pgcf, ohmyhost, information_schema and pg_* cannot be watched. Fix the name or deploy the migration, then create the watch again.",
+    title: "Table cannot be watched"
+  },
+  database_watch_column_unavailable: {
+    status: 409,
+    retryable: false,
+    action: "List only existing column names exactly as written, names are case-sensitive. Delete the watch before a migration drops a published column, because the write would fail.",
+    title: "Watched column does not exist"
+  },
+  database_watch_events_unavailable: {
+    status: 409,
+    retryable: false,
+    action: "The platform event schema is installed when the database wakes: run any query against that environment, wait for the answer, then create the watch again. If it still fails, report the request_id through feedback.",
+    title: "Database events not installed yet"
+  },
+  database_watch_conflict: {
+    status: 409,
+    retryable: false,
+    action: "A migration already attaches a capture trigger to this table: keep it and skip the watch, or remove it from the migrations, deploy and create the watch again. A table carries one capture trigger.",
+    title: "Table already has a capture trigger"
+  },
+  database_table_conflict: {
+    status: 409,
+    retryable: false,
+    action: "A table with this name already exists with another definition. Choose another table name, or create the table again with the same columns, types, nullability, identity, defaults and primary key it has.",
+    title: "Table already exists with another definition"
+  },
+  database_table_limit: {
+    status: 409,
+    retryable: false,
+    action: "This database already holds the maximum number of tables in its public schema, so no table can be added. Use an existing table, or remove a table you no longer need through a deployed migration, then create the table again.",
+    title: "Database table limit reached"
+  },
   project_notes_conflict: {
     status: 409,
     retryable: false,
@@ -40483,7 +40525,7 @@ var PROBLEM_POLICY = {
   api_key_permissions_unavailable: {
     status: 503,
     retryable: false,
-    action: "Report the platform user-key permission configuration through feedback. Repeated login or creation will not fix it.",
+    action: "Report the platform user-key permission configuration through feedback with this request_id; it affects every token the same way, whatever the integration. Repeated login does not fix it. After the platform confirms the fix, repeat the same create with the same name and Idempotency-Key.",
     title: "Token permissions unavailable"
   },
   reconciliation_exhausted: {
@@ -41354,8 +41396,8 @@ var isPaidValidationRecord = (value) => {
   if (typeof value !== "object" || value === null || Array.isArray(value) || Object.keys(value).sort().join(",") !== "content,name,purpose,type") {
     return false;
   }
-  const record7 = value;
-  return (record7["type"] === "CNAME" || record7["type"] === "TXT") && boundedString(record7["name"], 1, 253) && boundedString(record7["content"], 1, 2048) && ["traffic", "ownership", "ssl", "dcv_delegation"].includes(String(record7["purpose"]));
+  const record8 = value;
+  return (record8["type"] === "CNAME" || record8["type"] === "TXT") && boundedString(record8["name"], 1, 253) && boundedString(record8["content"], 1, 2048) && ["traffic", "ownership", "ssl", "dcv_delegation"].includes(String(record8["purpose"]));
 };
 var isHttpsUrlValue = (value) => typeof value === "string" && isHttpsUrl(value);
 
@@ -41500,7 +41542,7 @@ async function prepareLocalSourcePublication(input) {
     request = { ...request, expected_commit_sha: link2.source.last_confirmed_commit_sha };
   }
   parseManagedSourceRequest("upload", request);
-  const record7 = {
+  const record8 = {
     version: 1,
     ...scope,
     operation_id: null,
@@ -41509,16 +41551,16 @@ async function prepareLocalSourcePublication(input) {
     request
   };
   if (original !== null) {
-    assertSameAttempt(original, record7);
+    assertSameAttempt(original, record8);
   } else
-    await writePending(record7, true);
+    await writePending(record8, true);
   return {
     request,
     accepted: async (operation) => {
       const current = await readPending(scope, replay);
       if (current === null)
         throw new LocalSourcePublicationError("source_publication_missing");
-      assertSameAttempt(current, record7);
+      assertSameAttempt(current, record8);
       if (current.operation_id !== null && current.operation_id !== operation.id)
         throw new ResponseContractError();
       if (!replay)
@@ -41537,7 +41579,7 @@ async function prepareLocalSourcePublication(input) {
         const current = await readPending(scope);
         if (current === null || current.operation_id !== null)
           return;
-        assertSameAttempt(current, record7);
+        assertSameAttempt(current, record8);
       } catch (error2) {
         if (error2 instanceof LocalSourcePublicationError && (error2.code === "source_publication_scope_mismatch" || error2.code === "source_publication_pending"))
           return;
@@ -41740,12 +41782,12 @@ async function readRecord(path2) {
     await handle?.close();
   }
 }
-async function writePending(record7, create, completed = false) {
-  const parent = join3(record7.directory, ".ohmyhost");
+async function writePending(record8, create, completed = false) {
+  const parent = join3(record8.directory, ".ohmyhost");
   for (const directory of [
     parent,
-    record7.metadata_directory,
-    join3(record7.metadata_directory, "publications")
+    record8.metadata_directory,
+    join3(record8.metadata_directory, "publications")
   ]) {
     try {
       await fs2.mkdir(directory, { mode: 448 });
@@ -41756,10 +41798,10 @@ async function writePending(record7, create, completed = false) {
     await checkedDirectory(directory);
     await fs2.chmod(directory, 448);
   }
-  const target = completed ? completedPath(record7) : pendingPath(record7);
+  const target = completed ? completedPath(record8) : pendingPath(record8);
   const temporary = create ? target : `${target}.${randomUUID()}.tmp`;
   try {
-    await fs2.writeFile(temporary, `${JSON.stringify(record7)}
+    await fs2.writeFile(temporary, `${JSON.stringify(record8)}
 `, { mode: 384, flag: "wx" });
     if (!create)
       await fs2.rename(temporary, target);
@@ -42389,6 +42431,9 @@ var DATABASE_WEBHOOK_EVENT_TYPES = [
   "database.resized",
   "database.deleted"
 ];
+var DATABASE_WATCH_OPERATIONS = ["insert", "update", "delete"];
+var DATABASE_WATCH_MAX_COLUMNS = 32;
+var DATABASE_WATCH_DEFAULT_SCHEMA = "public";
 var DATABASE_WEBHOOK_MAX_EVENT_TYPES = 16;
 var DATABASE_WEBHOOK_MAX_HEADERS = 8;
 var DATABASE_WEBHOOK_URL_MAX_LENGTH = 2048;
@@ -42432,7 +42477,22 @@ var USAGE_MAX_RANGE_MS = 31 * 24 * USAGE_HOUR_MS;
 var WEBHOOK_KEYS = ["id", "environment", "url", "event_types", "header_names", "created_at"];
 var WEBHOOK_ID_PATTERN = /^whk_[a-z0-9]{20}$/u;
 var DELIVERY_ID_PATTERN = /^dlv_[0-9a-f]{20}$/u;
-var EVENT_ID_PATTERN = /^evt_[0-9a-f]{20}$/u;
+var EVENT_ID_PATTERN = /^(?:evt_[0-9a-f]{20}|[a-z][a-z0-9]{19}:[1-9][0-9]{0,15}:[1-9][0-9]{0,15})$/u;
+var DATA_SUBSCRIPTION_PATTERN = /^data\.(?:\*|[a-z][a-z0-9_]{0,47})$/u;
+var DATA_EVENT_TYPE_PATTERN = /^data\.[a-z][a-z0-9_]{0,47}$/u;
+var DATABASE_WATCH_ID_PATTERN = /^pgcf_watch_[0-9a-f]{8}$/u;
+var DATABASE_WATCH_IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/u;
+var DATABASE_WATCH_FORBIDDEN_SCHEMAS = ["information_schema", "pgcf", "ohmyhost"];
+var DATABASE_WATCH_KEYS = [
+  "id",
+  "environment",
+  "schema",
+  "table",
+  "columns",
+  "operations",
+  "topic",
+  "event_type"
+];
 var SCHEDULE_NAME_PATTERN = /^[a-z][a-z0-9_-]{0,62}$/u;
 var CURSOR_PATTERN = /^[A-Za-z0-9._|:=+/-]{1,200}$/u;
 var HEADER_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9-]{0,63}$/u;
@@ -42454,11 +42514,53 @@ function parseDatabaseWebhookId(value) {
     throw new TypeError("Invalid database webhook id");
   return value;
 }
+function parseDatabaseWatchId(value) {
+  if (!isDatabaseWatchTriggerName(value))
+    throw new TypeError("Invalid database watch id");
+  return value;
+}
 function parseDatabaseDeliveryId(value) {
   if (!matches(value, DELIVERY_ID_PATTERN))
     throw new TypeError("Invalid database delivery id");
   return value;
 }
+function isDatabaseWatchTriggerName(value) {
+  return matches(value, DATABASE_WATCH_ID_PATTERN);
+}
+function isDatabaseWatchIdentifier(value) {
+  return matches(value, DATABASE_WATCH_IDENTIFIER_PATTERN);
+}
+function isDatabaseWatchSchema(value) {
+  if (!isDatabaseWatchIdentifier(value))
+    return false;
+  const lower = value.toLowerCase();
+  return !lower.startsWith("pg_") && !DATABASE_WATCH_FORBIDDEN_SCHEMAS.includes(lower);
+}
+function dataEventTopic(tableName) {
+  const mapped = Array.from(tableName, (character) => {
+    const lower = Array.from(character.toLowerCase())[0] ?? "_";
+    return /^[a-z0-9_]$/u.test(lower) ? lower : "_";
+  }).join("");
+  const topic = /^[a-z]/u.test(mapped) ? mapped : `t_${mapped}`;
+  return topic.slice(0, 48);
+}
+function parseDatabaseWatchCreateRequest(value) {
+  if (!record2(value) || !onlyKeys(value, ["schema", "table", "columns", "operations"]) || !isDatabaseWatchIdentifier(value["table"]) || !Array.isArray(value["columns"]) || value["columns"].length < 1 || value["columns"].length > DATABASE_WATCH_MAX_COLUMNS || !value["columns"].every(isDatabaseWatchIdentifier) || new Set(value["columns"]).size !== value["columns"].length)
+    throw new TypeError("Invalid database watch request");
+  return {
+    ...parseDatabaseWatchTarget({ schema: value["schema"], table: value["table"] }),
+    columns: value["columns"],
+    operations: parseWatchOperations(value["operations"])
+  };
+}
+function parseDatabaseWatchTarget(value) {
+  if (!record2(value) || !onlyKeys(value, ["schema", "table"]) || !isDatabaseWatchIdentifier(value["table"]))
+    throw new TypeError("Invalid database watch target");
+  const schema = value["schema"] === void 0 ? DATABASE_WATCH_DEFAULT_SCHEMA : value["schema"];
+  if (!isDatabaseWatchSchema(schema))
+    throw new TypeError("Invalid database watch target");
+  return { schema, table: value["table"] };
+}
 function parseDatabaseScheduleName(value) {
   if (!matches(value, SCHEDULE_NAME_PATTERN))
     throw new TypeError("Invalid database schedule name");
@@ -42515,6 +42617,20 @@ function assertDatabaseWebhook(value) {
     throw new TypeError("Invalid database webhook");
   assertWebhookFields(value);
 }
+function assertDatabaseWatch(value) {
+  if (!record2(value) || !exact2(value, DATABASE_WATCH_KEYS) || !matches(value["id"], DATABASE_WATCH_ID_PATTERN) || !oneOf(["dev", "prod"], value["environment"]) || !isDatabaseWatchSchema(value["schema"]) || !isDatabaseWatchIdentifier(value["table"]) || !Array.isArray(value["columns"]) || value["columns"].length < 1 || value["columns"].length > DATABASE_WATCH_MAX_COLUMNS || !value["columns"].every(isDatabaseWatchIdentifier) || !isCanonicalOperations(value["operations"]) || value["topic"] !== dataEventTopic(value["table"]) || value["event_type"] !== `data.${value["topic"]}`)
+    throw new TypeError("Invalid database watch");
+}
+function assertDatabaseWatchPage(value) {
+  if (!record2(value) || !exact2(value, ["items"]) || !pageItems(value["items"]))
+    throw new TypeError("Invalid database watch page");
+  for (const item of value["items"])
+    assertDatabaseWatch(item);
+}
+function assertDatabaseWatchDeleted(value) {
+  if (!record2(value) || !exact2(value, ["id", "deleted"]) || !matches(value["id"], DATABASE_WATCH_ID_PATTERN) || value["deleted"] !== true)
+    throw new TypeError("Invalid database watch deletion");
+}
 function assertDatabaseWebhookCreated(value) {
   if (!record2(value) || !exact2(value, [...WEBHOOK_KEYS, "secret"]) || typeof value["secret"] !== "string" || value["secret"].length === 0)
     throw new TypeError("Invalid database webhook");
@@ -42543,7 +42659,7 @@ function assertDatabaseWebhookDelivery(value) {
     "delivered_at",
     "last_status",
     "last_error"
-  ]) || !matches(value["id"], DELIVERY_ID_PATTERN) || !matches(value["event_id"], EVENT_ID_PATTERN) || !oneOf(DATABASE_WEBHOOK_EVENT_TYPES, value["event_type"]) || !matches(value["webhook_id"], WEBHOOK_ID_PATTERN) || !oneOf(["pending", "delivered", "dead_lettered"], value["state"]) || !nonNegativeInteger(value["attempts"]) || !timestamp2(value["created_at"]) || !nullable(value["next_attempt_at"], timestamp2) || !nullable(value["delivered_at"], timestamp2) || !nullable(value["last_status"], Number.isSafeInteger) || !nullable(value["last_error"], (error) => oneOf(["timeout", "network", "http", "expired", "permanent"], error)))
+  ]) || !matches(value["id"], DELIVERY_ID_PATTERN) || !matches(value["event_id"], EVENT_ID_PATTERN) || !isDeliveredEventType(value["event_type"]) || !matches(value["webhook_id"], WEBHOOK_ID_PATTERN) || !oneOf(["pending", "delivered", "dead_lettered"], value["state"]) || !nonNegativeInteger(value["attempts"]) || !timestamp2(value["created_at"]) || !nullable(value["next_attempt_at"], timestamp2) || !nullable(value["delivered_at"], timestamp2) || !nullable(value["last_status"], Number.isSafeInteger) || !nullable(value["last_error"], (error) => oneOf(["timeout", "network", "http", "expired", "permanent"], error)))
     throw new TypeError("Invalid database webhook delivery");
 }
 function assertDatabaseWebhookDeliveryPage(value) {
@@ -42626,7 +42742,7 @@ function assertUsageRow(value) {
     throw new TypeError("Invalid database execution usage row");
 }
 function assertWebhookFields(value) {
-  if (!matches(value["id"], WEBHOOK_ID_PATTERN) || !oneOf(["dev", "prod"], value["environment"]) || !isHttpsUrl2(value["url"]) || !Array.isArray(value["event_types"]) || value["event_types"].length < 1 || value["event_types"].length > DATABASE_WEBHOOK_MAX_EVENT_TYPES || !value["event_types"].every((type) => oneOf(DATABASE_WEBHOOK_EVENT_TYPES, type)) || !Array.isArray(value["header_names"]) || value["header_names"].length > DATABASE_WEBHOOK_MAX_HEADERS || !value["header_names"].every((name) => matches(name, HEADER_NAME_PATTERN)) || !timestamp2(value["created_at"]))
+  if (!matches(value["id"], WEBHOOK_ID_PATTERN) || !oneOf(["dev", "prod"], value["environment"]) || !isHttpsUrl2(value["url"]) || !Array.isArray(value["event_types"]) || value["event_types"].length < 1 || value["event_types"].length > DATABASE_WEBHOOK_MAX_EVENT_TYPES || !value["event_types"].every(isDatabaseWebhookEventPattern) || !Array.isArray(value["header_names"]) || value["header_names"].length > DATABASE_WEBHOOK_MAX_HEADERS || !value["header_names"].every((name) => matches(name, HEADER_NAME_PATTERN)) || !timestamp2(value["created_at"]))
     throw new TypeError("Invalid database webhook");
 }
 function parseHttpsUrl(value) {
@@ -42643,11 +42759,33 @@ function isHttpsUrl2(value) {
     return false;
   }
 }
+function isDatabaseWebhookEventPattern(value) {
+  return oneOf(DATABASE_WEBHOOK_EVENT_TYPES, value) || matches(value, DATA_SUBSCRIPTION_PATTERN);
+}
+function isDeliveredEventType(value) {
+  return oneOf(DATABASE_WEBHOOK_EVENT_TYPES, value) || matches(value, DATA_EVENT_TYPE_PATTERN);
+}
+function isDatabaseWebhookEventTypes(value) {
+  return Array.isArray(value) && value.length >= 1 && value.length <= DATABASE_WEBHOOK_MAX_EVENT_TYPES && value.every(isDatabaseWebhookEventPattern) && new Set(value).size === value.length;
+}
 function parseEventTypes(value) {
-  if (!Array.isArray(value) || value.length < 1 || value.length > DATABASE_WEBHOOK_MAX_EVENT_TYPES || !value.every((type) => oneOf(DATABASE_WEBHOOK_EVENT_TYPES, type)) || new Set(value).size !== value.length)
+  if (!isDatabaseWebhookEventTypes(value))
     throw new TypeError("Invalid database webhook event types");
   return value;
 }
+function parseWatchOperations(value) {
+  if (value === void 0)
+    return DATABASE_WATCH_OPERATIONS;
+  if (!Array.isArray(value) || value.length < 1 || !value.every((operation) => oneOf(DATABASE_WATCH_OPERATIONS, operation)) || new Set(value).size !== value.length)
+    throw new TypeError("Invalid database watch request");
+  return DATABASE_WATCH_OPERATIONS.filter((operation) => value.includes(operation));
+}
+function isCanonicalOperations(value) {
+  if (!Array.isArray(value) || value.length < 1)
+    return false;
+  const canonical = DATABASE_WATCH_OPERATIONS.filter((operation) => value.includes(operation));
+  return canonical.length === value.length && canonical.every((op, index) => op === value[index]);
+}
 function parseHeaders(value) {
   if (!record2(value) || Object.keys(value).length > DATABASE_WEBHOOK_MAX_HEADERS || new Set(Object.keys(value).map((name) => name.toLowerCase())).size !== Object.keys(value).length)
     throw new TypeError("Invalid database webhook headers");
@@ -42723,6 +42861,170 @@ function exact2(value, keys) {
   return Object.keys(value).sort().join(",") === [...keys].sort().join(",");
 }
 
+// packages/contracts/dist/database-tables.js
+var DATABASE_TABLE_COLUMN_TYPES = [
+  "text",
+  "integer",
+  "bigint",
+  "boolean",
+  "numeric",
+  "double precision",
+  "timestamptz",
+  "date",
+  "uuid",
+  "jsonb"
+];
+var DATABASE_TABLE_DEFAULTS = ["now", "uuid"];
+var DATABASE_TABLE_MAX_COLUMNS = 64;
+var DATABASE_TABLE_MAX_PRIMARY_KEY_COLUMNS = 8;
+var DATABASE_TABLE_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_]{0,62}$/u;
+var RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "all",
+  "analyse",
+  "analyze",
+  "and",
+  "any",
+  "array",
+  "as",
+  "asc",
+  "asymmetric",
+  "both",
+  "case",
+  "cast",
+  "check",
+  "collate",
+  "column",
+  "constraint",
+  "create",
+  "current_catalog",
+  "current_date",
+  "current_role",
+  "current_time",
+  "current_timestamp",
+  "current_user",
+  "default",
+  "deferrable",
+  "desc",
+  "distinct",
+  "do",
+  "else",
+  "end",
+  "except",
+  "false",
+  "fetch",
+  "for",
+  "foreign",
+  "from",
+  "grant",
+  "group",
+  "having",
+  "in",
+  "initially",
+  "intersect",
+  "into",
+  "lateral",
+  "leading",
+  "limit",
+  "localtime",
+  "localtimestamp",
+  "not",
+  "null",
+  "offset",
+  "on",
+  "only",
+  "or",
+  "order",
+  "placing",
+  "primary",
+  "references",
+  "returning",
+  "select",
+  "session_user",
+  "some",
+  "symmetric",
+  "table",
+  "then",
+  "to",
+  "trailing",
+  "true",
+  "union",
+  "unique",
+  "user",
+  "using",
+  "variadic",
+  "when",
+  "where",
+  "window",
+  "with"
+]);
+function isDatabaseTableIdentifier(value) {
+  return typeof value === "string" && DATABASE_TABLE_IDENTIFIER_PATTERN.test(value) && !value.startsWith("pg_") && !RESERVED_WORDS.has(value);
+}
+function parseDatabaseTableCreateRequest(value) {
+  if (!record3(value) || !onlyKeys2(value, ["table", "columns", "primaryKey"]) || !isDatabaseTableIdentifier(value["table"]) || !Array.isArray(value["columns"]) || value["columns"].length < 1 || value["columns"].length > DATABASE_TABLE_MAX_COLUMNS)
+    throw new TypeError("Invalid database table request");
+  const inputs = value["columns"].map(parseColumn);
+  const names = inputs.map((column) => column.name);
+  if (new Set(names).size !== names.length || inputs.filter((column) => column.identity).length > 1)
+    throw new TypeError("Invalid database table request");
+  const primaryKey = parsePrimaryKey(value["primaryKey"], names);
+  return {
+    table: value["table"],
+    columns: inputs.map((column) => completeColumn(column, primaryKey.includes(column.name))),
+    primaryKey
+  };
+}
+function parseColumn(value) {
+  if (!record3(value) || !onlyKeys2(value, ["name", "type", "nullable", "identity", "default"]) || !isDatabaseTableIdentifier(value["name"]) || !oneOf2(DATABASE_TABLE_COLUMN_TYPES, value["type"]) || value["nullable"] !== void 0 && typeof value["nullable"] !== "boolean" || value["identity"] !== void 0 && typeof value["identity"] !== "boolean" || value["default"] !== void 0 && !oneOf2(DATABASE_TABLE_DEFAULTS, value["default"]))
+    throw new TypeError("Invalid database table request");
+  const type = value["type"];
+  const identity = value["identity"] === true;
+  const defaultValue = value["default"] ?? null;
+  if (identity && type !== "integer" && type !== "bigint")
+    throw new TypeError("Invalid database table request");
+  if (identity && defaultValue !== null)
+    throw new TypeError("Invalid database table request");
+  if (defaultValue === "now" && type !== "timestamptz")
+    throw new TypeError("Invalid database table request");
+  if (defaultValue === "uuid" && type !== "uuid")
+    throw new TypeError("Invalid database table request");
+  return {
+    name: value["name"],
+    type,
+    nullable: value["nullable"],
+    identity,
+    default: defaultValue
+  };
+}
+function parsePrimaryKey(value, names) {
+  if (value === void 0)
+    return [];
+  if (!Array.isArray(value) || value.length < 1 || value.length > DATABASE_TABLE_MAX_PRIMARY_KEY_COLUMNS || new Set(value).size !== value.length || !value.every((name) => typeof name === "string" && names.includes(name)))
+    throw new TypeError("Invalid database table request");
+  return value;
+}
+function completeColumn(column, keyed) {
+  const required = column.identity || keyed;
+  if (required && column.nullable === true)
+    throw new TypeError("Invalid database table request");
+  return {
+    name: column.name,
+    type: column.type,
+    nullable: required ? false : column.nullable ?? true,
+    identity: column.identity,
+    default: column.default
+  };
+}
+function oneOf2(allowed, value) {
+  return typeof value === "string" && allowed.includes(value);
+}
+function record3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function onlyKeys2(value, allowed) {
+  return Object.keys(value).every((key) => allowed.includes(key));
+}
+
 // packages/contracts/dist/database-sizes.js
 var DATABASE_SIZES = Object.freeze([
   Object.freeze({
@@ -43083,6 +43385,16 @@ var recognizedCommandLabel = (argv) => {
       if (values[1] === "revoke")
         return "database access revoke";
     }
+    if (value === "database" && values[0] === "watch") {
+      if (values[1] === "create")
+        return "database watch create";
+      if (values[1] === "list")
+        return "database watch list";
+      if (values[1] === "delete")
+        return "database watch delete";
+    }
+    if (value === "database" && values[0] === "table" && values[1] === "create")
+      return "database table create";
     if (value === "database" && values[0] === "webhook") {
       if (values[1] === "create")
         return "database webhook create";
@@ -43932,6 +44244,105 @@ var parseProductCliCommand = (argv) => {
     }
     throw new InvalidCommandError();
   }
+  if (first === "database" && values[0] === "watch") {
+    values.shift();
+    const subcommand = values.shift();
+    if (subcommand === "create") {
+      if (!yes || wait || follow || revoke || stdin)
+        throw new InvalidCommandError();
+      const options = parseOptionalOptions(values, [
+        "--project",
+        "--environment",
+        "--table",
+        "--schema",
+        "--columns",
+        "--operations",
+        "--idempotency-key"
+      ]);
+      const projectId = options["--project"], environment = options["--environment"], table = options["--table"], schema = options["--schema"], columns = options["--columns"], operations = options["--operations"], idempotencyKey = options["--idempotency-key"];
+      if (!isValue(projectId) || !isValue(idempotencyKey) || !isValue(table) || !isValue(columns) || environment !== "dev" && environment !== "prod")
+        throw new InvalidCommandError();
+      const request = contractValue(() => parseDatabaseWatchCreateRequest({
+        schema,
+        table,
+        columns: columns.split(","),
+        ...operations === void 0 ? {} : { operations: operations.split(",") }
+      }));
+      return {
+        kind: "database-watch-create",
+        projectId,
+        environment,
+        request,
+        idempotencyKey,
+        yes: true,
+        credentialStore
+      };
+    }
+    if (subcommand === "list") {
+      if (yes || wait || follow || revoke || stdin)
+        throw new InvalidCommandError();
+      const options = parseOptionalOptions(values, ["--project", "--environment"]);
+      const projectId = options["--project"], environment = options["--environment"] ?? "dev";
+      if (!isValue(projectId) || environment !== "dev" && environment !== "prod")
+        throw new InvalidCommandError();
+      return { kind: "database-watch-list", projectId, environment, credentialStore };
+    }
+    if (subcommand === "delete") {
+      if (!yes || wait || follow || revoke || stdin)
+        throw new InvalidCommandError();
+      const options = parseOptionalOptions(values, [
+        "--project",
+        "--environment",
+        "--watch",
+        "--idempotency-key"
+      ]);
+      const projectId = options["--project"], environment = options["--environment"], watchId = options["--watch"], idempotencyKey = options["--idempotency-key"];
+      if (!isValue(projectId) || !isValue(idempotencyKey) || environment !== "dev" && environment !== "prod")
+        throw new InvalidCommandError();
+      return {
+        kind: "database-watch-delete",
+        projectId,
+        environment,
+        watchId: contractValue(() => parseDatabaseWatchId(watchId)),
+        idempotencyKey,
+        yes: true,
+        credentialStore
+      };
+    }
+    throw new InvalidCommandError();
+  }
+  if (first === "database" && values[0] === "table") {
+    values.shift();
+    const subcommand = values.shift();
+    if (subcommand === "create") {
+      if (!yes || wait || follow || revoke || stdin)
+        throw new InvalidCommandError();
+      const options = parseOptionalOptions(values, [
+        "--project",
+        "--environment",
+        "--table",
+        "--columns-file",
+        "--primary-key",
+        "--idempotency-key"
+      ]);
+      const projectId = options["--project"], environment = options["--environment"], table = options["--table"], columnsFile = options["--columns-file"], primaryKey = options["--primary-key"], idempotencyKey = options["--idempotency-key"];
+      const keyNames = primaryKey === void 0 ? [] : primaryKey.split(",");
+      if (!isValue(projectId) || !isValue(idempotencyKey) || !isValue(table) || !isValue(columnsFile) || primaryKey !== void 0 && !keyNames.every(isDatabaseTableIdentifier) || keyNames.length > DATABASE_TABLE_MAX_PRIMARY_KEY_COLUMNS || !isDatabaseTableIdentifier(table) || environment !== "dev" && environment !== "prod")
+        throw new InvalidCommandError();
+      return {
+        kind: "database-table-create",
+        projectId,
+        environment,
+        table,
+        columnsFile,
+        primaryKey: keyNames,
+        idempotencyKey,
+        yes: true,
+        credentialStore
+      };
+    }
+    throw new InvalidCommandError();
+  }
   if (first === "database" && values[0] === "webhook") {
     values.shift();
     const subcommand = values.shift();
@@ -45078,7 +45489,7 @@ import { join as join5, resolve as resolve4 } from "node:path";
 
 // packages/contracts/dist/database-access.js
 function parseProjectDatabaseWrite(value) {
-  if (!record3(value) || !exact3(value, ["environment", "statement", "parameters"]) || !["dev", "prod"].includes(String(value["environment"])) || typeof value["statement"] !== "string" || !/^\s*(?:insert|update|delete)\b/iu.test(value["statement"]) || new TextEncoder().encode(value["statement"]).byteLength > 65536 || value["statement"].includes("\0") || !Array.isArray(value["parameters"]) || value["parameters"].length > 100)
+  if (!record4(value) || !exact3(value, ["environment", "statement", "parameters"]) || !["dev", "prod"].includes(String(value["environment"])) || typeof value["statement"] !== "string" || !/^\s*(?:insert|update|delete)\b/iu.test(value["statement"]) || new TextEncoder().encode(value["statement"]).byteLength > 65536 || value["statement"].includes("\0") || !Array.isArray(value["parameters"]) || value["parameters"].length > 100)
     throw new TypeError("Invalid database write");
   const budget = { nodes: 0 };
   for (const parameter of value["parameters"])
@@ -45092,7 +45503,7 @@ function parseProjectDatabaseWrite(value) {
   };
 }
 function assertProjectDatabaseWriteReceipt(value) {
-  if (!record3(value) || !exact3(value, ["operation_id", "environment", "state", "command", "affected_rows", "error"]) || typeof value["operation_id"] !== "string" || !/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/u.test(value["operation_id"]) || !["dev", "prod"].includes(String(value["environment"])) || !["running", "succeeded", "failed"].includes(String(value["state"])))
+  if (!record4(value) || !exact3(value, ["operation_id", "environment", "state", "command", "affected_rows", "error"]) || typeof value["operation_id"] !== "string" || !/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/u.test(value["operation_id"]) || !["dev", "prod"].includes(String(value["environment"])) || !["running", "succeeded", "failed"].includes(String(value["state"])))
     throw new TypeError("Invalid database write receipt");
   if (value["state"] === "succeeded") {
     if (!["INSERT", "UPDATE", "DELETE"].includes(String(value["command"])) || !Number.isSafeInteger(value["affected_rows"]) || Number(value["affected_rows"]) < 0 || Number(value["affected_rows"]) > 1e3 || value["error"] !== null)
@@ -45105,7 +45516,7 @@ function assertProjectDatabaseWriteReceipt(value) {
         throw new TypeError("Invalid database write result");
     } else {
       const error = value["error"];
-      if (!record3(error) || typeof error["code"] !== "string" || !error["code"].startsWith("database_write_") || JSON.stringify(error) !== JSON.stringify(publicOperationFailure(error["code"])))
+      if (!record4(error) || typeof error["code"] !== "string" || !error["code"].startsWith("database_write_") || JSON.stringify(error) !== JSON.stringify(publicOperationFailure(error["code"])))
         throw new TypeError("Invalid database write error");
     }
   }
@@ -45129,12 +45540,12 @@ var ACCESS_KEYS = [
 ];
 var ACCESS_ROLE_PATTERN = /^ohmyho_da_[0-7][0-9a-hjkmnp-tv-z]{25}_[0-9a-z]{8}$/u;
 function assertProjectDatabaseAccess(value) {
-  if (!record3(value) || !exact3(value, ACCESS_KEYS))
+  if (!record4(value) || !exact3(value, ACCESS_KEYS))
     throw new TypeError("Invalid database access");
   assertAccessFields(value);
 }
 function assertProjectDatabaseAccessCredential(value) {
-  if (!record3(value) || !exact3(value, [...ACCESS_KEYS, "connection_uri", "psql_command"]))
+  if (!record4(value) || !exact3(value, [...ACCESS_KEYS, "connection_uri", "psql_command"]))
     throw new TypeError("Invalid database access credential");
   assertAccessFields(value);
   const uri = value["connection_uri"];
@@ -45150,7 +45561,7 @@ function assertProjectDatabaseAccessCredential(value) {
     throw new TypeError("Invalid database access credential");
 }
 function assertProjectDatabaseAccessPage(value) {
-  if (!record3(value) || !exact3(value, ["items"]) || !Array.isArray(value["items"]) || value["items"].length > 50)
+  if (!record4(value) || !exact3(value, ["items"]) || !Array.isArray(value["items"]) || value["items"].length > 50)
     throw new TypeError("Invalid database access page");
   for (const item of value["items"])
     assertProjectDatabaseAccess(item);
@@ -45185,14 +45596,14 @@ function json(value, depth, budget) {
       json(entry, depth + 1, budget);
     return;
   }
-  if (record3(value)) {
+  if (record4(value)) {
     for (const entry of Object.values(value))
       json(entry, depth + 1, budget);
     return;
   }
   throw new TypeError("Invalid database parameter");
 }
-function record3(value) {
+function record4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function exact3(value, keys) {
@@ -45201,7 +45612,7 @@ function exact3(value, keys) {
 
 // packages/contracts/dist/credit-pricing.js
 function assertOrganizationCreditUsage(value) {
-  const record7 = (input, keys) => {
+  const record8 = (input, keys) => {
     if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).sort().join() !== keys.split(",").sort().join())
       throw new TypeError("Invalid usage fields");
     return input;
@@ -45209,30 +45620,30 @@ function assertOrganizationCreditUsage(value) {
   const identifier2 = (input) => typeof input === "string" && /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/u.test(input);
   const amount = (input) => typeof input === "string" && /^(0|[1-9][0-9]{0,37})$/u.test(input);
   const instant2 = (input) => typeof input === "string" && Number.isFinite(Date.parse(input)) && new Date(input).toISOString() === input;
-  const report = record7(value, "organization_id,as_of,unit,period,from,projects,days");
+  const report = record8(value, "organization_id,as_of,unit,period,from,projects,days");
   if (!identifier2(report["organization_id"]) || !instant2(report["as_of"]) || !instant2(report["from"]) || report["unit"] !== "microcredits" || typeof report["period"] !== "string" || !/^20[0-9]{2}-(0[1-9]|1[0-2])$/u.test(report["period"]) || !Array.isArray(report["projects"]) || report["projects"].length > 1e3 || !Array.isArray(report["days"]) || report["days"].length > 15)
     throw new TypeError("Invalid usage report");
   let previous = "";
   for (const input of report["projects"]) {
-    const project = record7(input, "project_id,used_micros");
+    const project = record8(input, "project_id,used_micros");
     if (!identifier2(project["project_id"]) || String(project["project_id"]) <= previous || !amount(project["used_micros"]))
       throw new TypeError("Invalid usage project");
     previous = String(project["project_id"]);
   }
   let previousDay = "";
   for (const input of report["days"]) {
-    const day = record7(input, "day,projects");
+    const day = record8(input, "day,projects");
     if (typeof day["day"] !== "string" || !/^20[0-9]{2}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/u.test(day["day"]) || day["day"] <= previousDay || !Array.isArray(day["projects"]) || day["projects"].length > 1e3)
       throw new TypeError("Invalid usage day");
     previousDay = day["day"];
     previous = "";
     for (const projectInput of day["projects"]) {
-      const project = record7(projectInput, "project_id,meters");
+      const project = record8(projectInput, "project_id,meters");
       if (!identifier2(project["project_id"]) || String(project["project_id"]) <= previous || !Array.isArray(project["meters"]) || project["meters"].length > 1e3)
         throw new TypeError("Invalid usage project");
       previous = String(project["project_id"]);
       for (const meterInput of project["meters"]) {
-        const meter = record7(meterInput, "environment_id,meter,unit,rate_card_id,quantity,charged_micros");
+        const meter = record8(meterInput, "environment_id,meter,unit,rate_card_id,quantity,charged_micros");
         if (meter["environment_id"] !== null && !identifier2(meter["environment_id"]))
           throw new TypeError("Invalid usage environment");
         for (const key of ["meter", "unit", "rate_card_id"])
@@ -45267,16 +45678,16 @@ function assertOrganizationAccount(value) {
 
 // packages/contracts/dist/database-compute.js
 function assertDatabaseCompute(value) {
-  if (!record4(value) || !exact4(value, ["data_mode", "database", "environment", "observed_at", "project_id"]) || typeof value["project_id"] !== "string" || !/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/u.test(value["project_id"]) || !["dev", "prod"].includes(String(value["environment"])) || !["shared", "isolated"].includes(String(value["data_mode"])) || typeof value["observed_at"] !== "string" || !Number.isFinite(Date.parse(value["observed_at"])) || new Date(value["observed_at"]).toISOString() !== value["observed_at"])
+  if (!record5(value) || !exact4(value, ["data_mode", "database", "environment", "observed_at", "project_id"]) || typeof value["project_id"] !== "string" || !/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/u.test(value["project_id"]) || !["dev", "prod"].includes(String(value["environment"])) || !["shared", "isolated"].includes(String(value["data_mode"])) || typeof value["observed_at"] !== "string" || !Number.isFinite(Date.parse(value["observed_at"])) || new Date(value["observed_at"]).toISOString() !== value["observed_at"])
     throw new TypeError("Invalid database compute report");
   const db = value["database"];
   if (db === null)
     return;
-  if (record4(db) && db["provider"] === "pgcf") {
+  if (record5(db) && db["provider"] === "pgcf") {
     assertPgcfCompute(db);
     return;
   }
-  if (!record4(db) || !exact4(db, [
+  if (!record5(db) || !exact4(db, [
     "disabled",
     "max_cu",
     "max_memory_gb",
@@ -45307,7 +45718,7 @@ function assertPgcfCompute(db) {
   ]) || db["memory_mib"] !== size.memoryMiB || db["cpu_millicores"] !== size.cpuMillicores || db["storage_mib"] !== size.storageMiB || db["max_connections"] !== size.maxConnections || !Number.isSafeInteger(db["suspend_timeout_seconds"]) || Number(db["suspend_timeout_seconds"]) < 60 || Number(db["suspend_timeout_seconds"]) > 900 || !states.includes(String(db["state"])) || db["pending_state"] !== null && !states.includes(String(db["pending_state"])) || typeof db["disabled"] !== "boolean" || !["us", "eu"].includes(String(db["region"])))
     throw new TypeError("Invalid fixed database compute configuration");
 }
-function record4(v) {
+function record5(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 function exact4(v, keys) {
@@ -45317,7 +45728,7 @@ function exact4(v, keys) {
 // apps/product-cli/package.json
 var package_default = {
   name: "@ohmyhost/product-cli",
-  version: "0.1.44",
+  version: "0.1.46",
   private: true,
   ohmyhost: {
     deployment: "production",
@@ -45364,32 +45775,32 @@ var package_default = {
 };
 
 // packages/contracts/dist/project-context.js
-var record5 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var record6 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var timestamp4 = (v) => typeof v === "string" && Number.isFinite(Date.parse(v)) && new Date(v).toISOString() === v;
 var version = (v) => Number.isInteger(v) && Number(v) >= 0 && Number(v) <= 2147483647;
 var bounded = (v, lines, bytes) => typeof v === "string" && !/[\r\u2028\u2029]/u.test(v) && !new RegExp("\\p{Cc}", "u").test(v.replace(/[\n\t]/gu, "")) && v.split("\n").length <= lines && new TextEncoder().encode(v).length <= bytes;
 function assertProjectNotesReceipt(v) {
-  if (!record5(v) || Object.keys(v).sort().join(",") !== "updated_at,version" || !version(v["version"]) || v["version"] === 0 || !timestamp4(v["updated_at"]))
+  if (!record6(v) || Object.keys(v).sort().join(",") !== "updated_at,version" || !version(v["version"]) || v["version"] === 0 || !timestamp4(v["updated_at"]))
     throw new TypeError("Invalid project notes receipt");
 }
 function assertProjectContext(v) {
-  if (!record5(v) || Object.keys(v).sort().join(",") !== "credit_access,generated_at,markdown,notes,project_id" || typeof v["project_id"] !== "string" || !/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/u.test(v["project_id"]) || !timestamp4(v["generated_at"]) || !["included", "not_authorized"].includes(String(v["credit_access"])) || !bounded(v["markdown"], 500, 32768))
+  if (!record6(v) || Object.keys(v).sort().join(",") !== "credit_access,generated_at,markdown,notes,project_id" || typeof v["project_id"] !== "string" || !/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/u.test(v["project_id"]) || !timestamp4(v["generated_at"]) || !["included", "not_authorized"].includes(String(v["credit_access"])) || !bounded(v["markdown"], 500, 32768))
     throw new TypeError("Invalid project context");
   const notes = v["notes"];
-  if (!record5(notes) || Object.keys(notes).sort().join(",") !== "markdown,updated_at,version" || !version(notes["version"]) || !bounded(notes["markdown"], 250, 16384) || (notes["version"] === 0 ? notes["updated_at"] !== null || notes["markdown"] !== "" : !timestamp4(notes["updated_at"])))
+  if (!record6(notes) || Object.keys(notes).sort().join(",") !== "markdown,updated_at,version" || !version(notes["version"]) || !bounded(notes["markdown"], 250, 16384) || (notes["version"] === 0 ? notes["updated_at"] !== null || notes["markdown"] !== "" : !timestamp4(notes["updated_at"])))
     throw new TypeError("Invalid project notes");
 }
 
 // packages/contracts/dist/project-exports.js
 function assertProjectExport(value) {
-  if (!record6(value) || Object.keys(value).sort().join(",") !== "archive,error,id,next_poll_after_seconds,next_request_at,project_id,requested_at,state" || typeof value["id"] !== "string" || !id.test(value["id"]) || typeof value["project_id"] !== "string" || !id.test(value["project_id"]) || !["queued", "running", "succeeded", "failed", "cancelled"].includes(String(value["state"])) || !timestamp5(value["requested_at"]) || !timestamp5(value["next_request_at"]))
+  if (!record7(value) || Object.keys(value).sort().join(",") !== "archive,error,id,next_poll_after_seconds,next_request_at,project_id,requested_at,state" || typeof value["id"] !== "string" || !id.test(value["id"]) || typeof value["project_id"] !== "string" || !id.test(value["project_id"]) || !["queued", "running", "succeeded", "failed", "cancelled"].includes(String(value["state"])) || !timestamp5(value["requested_at"]) || !timestamp5(value["next_request_at"]))
     invalid4();
   const active = value["state"] === "queued" || value["state"] === "running";
   if (value["next_poll_after_seconds"] !== (active ? 5 : null))
     invalid4();
   if (value["state"] === "failed") {
     const error = value["error"];
-    if (!record6(error) || Object.keys(error).sort().join(",") !== "code,message,retryable,suggested_action" || typeof error["code"] !== "string")
+    if (!record7(error) || Object.keys(error).sort().join(",") !== "code,message,retryable,suggested_action" || typeof error["code"] !== "string")
       invalid4();
     const expected = publicOperationFailure(error["code"]);
     for (const key of Object.keys(expected))
@@ -45403,7 +45814,7 @@ function assertProjectExport(value) {
       invalid4();
     return;
   }
-  if (value["state"] !== "succeeded" || !record6(archive) || Object.keys(archive).sort().join(",") !== "bytes,captured_at,download_expires_at,download_url,expires_at,sha256,sql_files" || !Number.isSafeInteger(archive["bytes"]) || Number(archive["bytes"]) < 1 || Number(archive["bytes"]) > 536870912 || typeof archive["sha256"] !== "string" || !/^sha256:[a-f0-9]{64}$/u.test(archive["sha256"]) || !['["dev.sql"]', '["prod.sql"]', '["dev.sql","prod.sql"]', '["shared.sql"]'].includes(JSON.stringify(archive["sql_files"])) || !timestamp5(archive["captured_at"]) || !timestamp5(archive["expires_at"]))
+  if (value["state"] !== "succeeded" || !record7(archive) || Object.keys(archive).sort().join(",") !== "bytes,captured_at,download_expires_at,download_url,expires_at,sha256,sql_files" || !Number.isSafeInteger(archive["bytes"]) || Number(archive["bytes"]) < 1 || Number(archive["bytes"]) > 536870912 || typeof archive["sha256"] !== "string" || !/^sha256:[a-f0-9]{64}$/u.test(archive["sha256"]) || !['["dev.sql"]', '["prod.sql"]', '["dev.sql","prod.sql"]', '["shared.sql"]'].includes(JSON.stringify(archive["sql_files"])) || !timestamp5(archive["captured_at"]) || !timestamp5(archive["expires_at"]))
     invalid4();
   if (archive["download_url"] === null) {
     if (archive["download_expires_at"] !== null)
@@ -45422,7 +45833,7 @@ function assertProjectExport(value) {
     invalid4();
 }
 var id = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/u;
-function record6(value) {
+function record7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function timestamp5(value) {
@@ -45662,7 +46073,11 @@ var HELP_USAGE = Object.freeze({
   "database access create": "ohmyhost database access create --project ULID --environment dev|prod [--mode read|write] [--ttl 5m|1h|24h|SECONDS] [--label TEXT] --yes --json\n  The connection URI is shown once. Use it immediately, never store it in files, notes or source, and revoke it when finished.",
   "database access list": "ohmyhost database access list --project ULID [--environment dev|prod] --json",
   "database access revoke": "ohmyhost database access revoke --project ULID --access ULID --yes --json",
-  "database webhook create": "ohmyhost database webhook create --project ULID --environment dev|prod --url HTTPS_URL --event-types TYPE[,TYPE] [--headers-file PATH] --idempotency-key KEY --yes --json (the signing secret is shown once in this answer; types: database.created, database.ready, database.woke, database.slept, database.suspended, database.resized, database.deleted; the headers file is a UTF-8 JSON object of at most 8 KiB)",
+  "database watch create": "ohmyhost database watch create --project ULID --environment dev|prod --table NAME [--schema public] --columns COL[,COL] [--operations insert,update,delete] --idempotency-key KEY --yes --json (publishes only the listed columns, at most 32, of each row change as the event type data.<topic> printed in this answer; the table must exist as an ordinary table of the application; a sleeping database wakes; next, subscribe with 'ohmyhost database webhook create ... --event-types data.<topic>')",
+  "database watch list": "ohmyhost database watch list --project ULID [--environment dev|prod] --json (dev when omitted; a sleeping database wakes)",
+  "database watch delete": "ohmyhost database watch delete --project ULID --environment dev|prod --watch ID --idempotency-key KEY --yes --json",
+  "database table create": "ohmyhost database table create --project ULID --environment dev|prod --table NAME --columns-file PATH [--primary-key COL[,COL]] --idempotency-key KEY --yes --json (the table is created in the public schema as the migration role, with the same access as migration tables, so a database watch can attach later; the columns file is a UTF-8 JSON array of 1 to 64 column objects, at most 64 KiB, each with name, type and optional nullable, identity and default; types: text, integer, bigint, boolean, numeric, double precision, timestamptz, date, uuid, jsonb; identity needs integer or bigint; default now needs timestamptz and default uuid needs uuid; identical repeats answer created false; at most 100 tables, 64 columns per table)",
+  "database webhook create": "ohmyhost database webhook create --project ULID --environment dev|prod --url HTTPS_URL --event-types TYPE[,TYPE] [--headers-file PATH] --idempotency-key KEY --yes --json (the signing secret is shown once in this answer; types: database.created, database.ready, database.woke, database.slept, database.suspended, database.resized, database.deleted, data.<topic> for the rows of one watched table printed by database watch create, or data.* for every watched table; a bare * is not accepted and does not include data events; the headers file is a UTF-8 JSON object of at most 8 KiB)",
   "database webhook list": "ohmyhost database webhook list --project ULID [--environment dev|prod] --json (dev when omitted; the secret is never listed)",
   "database webhook get": "ohmyhost database webhook get --project ULID [--environment dev|prod] --webhook ID --json",
   "database webhook delete": "ohmyhost database webhook delete --project ULID --environment dev|prod --webhook ID --yes --json",
@@ -45787,6 +46202,7 @@ var LOGOUT_UNCONFIRMED_ACTION = "The saved login was removed from this computer,
 var HEADERS_FILE_INVALID_ACTION = "Put one JSON object of header names and values in the file named by --headers-file: UTF-8, at most 8 KiB, unique names, values of visible ASCII characters. Names such as content-type, host, content-length, connection, transfer-encoding, user-agent, te, upgrade and expect, and names starting with pgcf-, cf- or x-forwarded-, are refused. Nothing was sent; fix the file and run the command again.";
 var SCHEDULE_STATEMENTS_FILE_INVALID_ACTION = "Put one JSON array of 1 to 20 non-empty SQL strings in the file named by --statements-file: UTF-8, at most 64 KiB in total and 16 KiB per statement, without NUL characters. Nothing was saved; fix the file and run the command again.";
 var SCHEDULE_INVALID_ACTION = "Check the schedule request: --cron takes five fields in UTC (9 to 120 characters), or --every-seconds takes 60 to 2678400, never both; --timeout-ms takes 1000 to 30000; the statements file must hold 1 to 20 non-blank SQL strings of at most 16 KiB each and 64 KiB in total. Nothing was saved; fix it and run the command again.";
+var COLUMNS_FILE_INVALID_ACTION = "Put one JSON array of 1 to 64 column objects in the file named by --columns-file: UTF-8, at most 64 KiB, each with a lower-case name, a type (text, integer, bigint, boolean, numeric, double precision, timestamptz, date, uuid or jsonb) and optional nullable, identity (integer or bigint only) and default (now for timestamptz, uuid for uuid). Each --primary-key column must be one of them, at most 8 names. Nothing was created; fix the file or the flags and run the command again.";
 var STATEMENT_FILE_INVALID_ACTION = "Put one INSERT, UPDATE or DELETE statement that starts with that keyword (no leading comment or WITH), UTF-8, at most 64 KiB, in the file named by --statement-file, then rerun with the same --idempotency-key.";
 var signInCommand = (commandPrefix, profile) => profile === void 0 ? `${commandPrefix} login --json` : `${commandPrefix} login${profile.organizationId === null ? "" : ` --organization ${profile.organizationId}`} --user ${profile.userId} --profile-name ${profile.name} --json`;
 var endedLoginAction = (commandPrefix, profile) => `The sign-in of ${profile === void 0 ? "this computer's saved login" : `saved login ${profile.name} (user ${profile.userId}${profile.organizationId === null ? "" : `, organization ${profile.organizationId}`})`} ended and it was removed. Run '${signInCommand(commandPrefix, profile)}' to sign it in again.`;
@@ -46153,6 +46569,14 @@ var ProductCli = class {
         return await this.listDatabaseAccess(command, signal);
       if (command.kind === "database-access-revoke")
         return await this.revokeDatabaseAccess(command, signal);
+      if (command.kind === "database-watch-create")
+        return await this.createDatabaseWatch(command, signal);
+      if (command.kind === "database-watch-list")
+        return await this.listDatabaseWatches(command, signal);
+      if (command.kind === "database-watch-delete")
+        return await this.deleteDatabaseWatch(command, signal);
+      if (command.kind === "database-table-create")
+        return await this.createDatabaseTable(command, signal);
       if (command.kind === "database-webhook-create")
         return await this.createDatabaseWebhook(command, signal);
       if (command.kind === "database-webhook-list")
@@ -46684,6 +47108,51 @@ var ProductCli = class {
     assertProjectDatabaseAccess(access);
     return success("database access revoke", { status: "succeeded", access });
   }
+  /** The answer names the event type to subscribe to; the watch already carries the columns and the topic. */
+  async createDatabaseWatch(command, signal) {
+    const api = await this.authenticatedApi(command.credentialStore, signal);
+    const watch = await api.createProjectDatabaseWatch({
+      projectId: command.projectId,
+      environment: command.environment,
+      idempotencyKey: command.idempotencyKey,
+      request: command.request
+    });
+    return success("database watch create", {
+      status: "succeeded",
+      watch,
+      next_action: `Run '${this.dependencies.commandPrefix} database webhook create --project ${command.projectId} --environment ${command.environment} --url HTTPS_URL --event-types ${watch.event_type} --idempotency-key KEY --yes --json' to receive ${watch.event_type} events at an HTTPS receiver.`
+    });
+  }
+  async listDatabaseWatches(command, signal) {
+    const api = await this.authenticatedApi(command.credentialStore, signal);
+    const page = await api.listProjectDatabaseWatches({
+      projectId: command.projectId,
+      environment: command.environment
+    });
+    return success("database watch list", { status: "succeeded", watch: page.items });
+  }
+  async deleteDatabaseWatch(command, signal) {
+    const api = await this.authenticatedApi(command.credentialStore, signal);
+    const deleted = await api.deleteProjectDatabaseWatch({
+      projectId: command.projectId,
+      environment: command.environment,
+      idempotencyKey: command.idempotencyKey,
+      watchId: command.watchId
+    });
+    return success("database watch delete", { status: "succeeded", deleted });
+  }
+  /** The columns file and the key are checked before any request; a repeat answers the same table with created false. */
+  async createDatabaseTable(command, signal) {
+    const request = await tableCreateRequest(command);
+    const api = await this.authenticatedApi(command.credentialStore, signal);
+    const answer = await api.createProjectDatabaseTable({
+      projectId: command.projectId,
+      environment: command.environment,
+      idempotencyKey: command.idempotencyKey,
+      request
+    });
+    return success("database table create", { status: "succeeded", table: answer.table });
+  }
   /** The signing secret is returned by create only; every other answer carries no secret. */
   async createDatabaseWebhook(command, signal) {
     const request = await webhookCreateRequest(command);
@@ -47575,6 +48044,37 @@ var scheduleSetRequest = async (command) => {
     throw new ProductCliFailure(2, "schedule_invalid", false, SCHEDULE_INVALID_ACTION);
   }
 };
+var tableCreateRequest = async (command) => {
+  const columnsFailure = () => new ProductCliFailure(2, "columns_file_invalid", false, COLUMNS_FILE_INVALID_ACTION);
+  const columns = await readBoundedUtf8File(command.columnsFile, 65536, columnsFailure).then((text) => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw columnsFailure();
+    }
+  });
+  try {
+    const parsed = parseDatabaseTableCreateRequest({
+      table: command.table,
+      columns,
+      ...command.primaryKey.length === 0 ? {} : { primaryKey: command.primaryKey }
+    });
+    return {
+      table: parsed.table,
+      columns: parsed.columns.map(tableColumnInput),
+      primaryKey: parsed.primaryKey
+    };
+  } catch {
+    throw columnsFailure();
+  }
+};
+var tableColumnInput = (column) => ({
+  name: column.name,
+  type: column.type,
+  nullable: column.nullable,
+  identity: column.identity,
+  ...column.default === null ? {} : { default: column.default }
+});
 var psqlUnavailable = () => failure("database psql", 9, "psql_unavailable", false, "Install the PostgreSQL client (psql) and make it available on PATH, or run 'ohmyhost database access create' and connect with your own SQL client.");
 var success = (command, body) => ({
   exitCode: 0,
@@ -47714,6 +48214,14 @@ var parsedCommandName = (command) => {
     return "database access revoke";
   if (command.kind === "database-psql")
     return "database psql";
+  if (command.kind === "database-watch-create")
+    return "database watch create";
+  if (command.kind === "database-watch-list")
+    return "database watch list";
+  if (command.kind === "database-watch-delete")
+    return "database watch delete";
+  if (command.kind === "database-table-create")
+    return "database table create";
   if (command.kind === "database-webhook-create")
     return "database webhook create";
   if (command.kind === "database-webhook-list")
@@ -47936,12 +48444,12 @@ function buildClientParams(args, fields) {
   };
   const map = buildKeyMap(fields);
   function writeSlot(slot, key, value) {
-    let record7 = params[slot];
-    if (record7 === void 0) {
-      record7 = /* @__PURE__ */ Object.create(null);
-      params[slot] = record7;
+    let record8 = params[slot];
+    if (record8 === void 0) {
+      record8 = /* @__PURE__ */ Object.create(null);
+      params[slot] = record8;
     }
-    record7[key] = value;
+    record8[key] = value;
   }
   let config;
   for (const [index, arg] of args.entries()) {
@@ -50586,6 +51094,92 @@ var revokeProjectDatabaseAccess = (parameters, options) => {
     ...params
   });
 };
+var createProjectDatabaseTable = (parameters, options) => {
+  const params = buildClientParams([parameters], [
+    {
+      args: [
+        { in: "headers", key: "X-Request-Id" },
+        { in: "headers", key: "Idempotency-Key" },
+        { in: "path", key: "project_id" },
+        { key: "databaseTableCreateRequest", map: "body" }
+      ]
+    }
+  ]);
+  return (options?.client ?? client).post({
+    responseStyle: "data",
+    security: [{ scheme: "bearer", type: "http" }],
+    url: "/v1/projects/{project_id}/database/tables",
+    ...options,
+    ...params,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers,
+      ...params.headers
+    }
+  });
+};
+var listProjectDatabaseWatches = (parameters, options) => {
+  const params = buildClientParams([parameters], [
+    {
+      args: [
+        { in: "headers", key: "X-Request-Id" },
+        { in: "path", key: "project_id" },
+        { in: "query", key: "environment" }
+      ]
+    }
+  ]);
+  return (options?.client ?? client).get({
+    responseStyle: "data",
+    security: [{ scheme: "bearer", type: "http" }],
+    url: "/v1/projects/{project_id}/database/watches",
+    ...options,
+    ...params
+  });
+};
+var createProjectDatabaseWatch = (parameters, options) => {
+  const params = buildClientParams([parameters], [
+    {
+      args: [
+        { in: "headers", key: "X-Request-Id" },
+        { in: "headers", key: "Idempotency-Key" },
+        { in: "path", key: "project_id" },
+        { key: "databaseWatchCreateRequest", map: "body" }
+      ]
+    }
+  ]);
+  return (options?.client ?? client).post({
+    responseStyle: "data",
+    security: [{ scheme: "bearer", type: "http" }],
+    url: "/v1/projects/{project_id}/database/watches",
+    ...options,
+    ...params,
+    headers: {
+      "Content-Type": "application/json",
+      ...options?.headers,
+      ...params.headers
+    }
+  });
+};
+var deleteProjectDatabaseWatch = (parameters, options) => {
+  const params = buildClientParams([parameters], [
+    {
+      args: [
+        { in: "headers", key: "X-Request-Id" },
+        { in: "headers", key: "Idempotency-Key" },
+        { in: "path", key: "project_id" },
+        { in: "path", key: "watch_id" },
+        { in: "query", key: "environment" }
+      ]
+    }
+  ]);
+  return (options?.client ?? client).delete({
+    responseStyle: "data",
+    security: [{ scheme: "bearer", type: "http" }],
+    url: "/v1/projects/{project_id}/database/watches/{watch_id}",
+    ...options,
+    ...params
+  });
+};
 var listProjectDatabaseWebhooks = (parameters, options) => {
   const params = buildClientParams([parameters], [
     {
@@ -51959,7 +52553,25 @@ function checkedResponse(kind, value) {
 
 // apps/product-cli/dist/product-api.js
 var WEBHOOK_SCOPE_MISMATCH = "Webhook response scope mismatch";
+var WATCH_SCOPE_MISMATCH = "Watch response scope mismatch";
+var TABLE_SCOPE_MISMATCH = "Table response scope mismatch";
 var SCHEDULE_SCOPE_MISMATCH = "Schedule response scope mismatch";
+function assertDatabaseTableAnswer(value) {
+  const table = isRecordValue(value) ? value["table"] : void 0;
+  const columns = isRecordValue(table) ? table["columns"] : void 0;
+  const primaryKey = isRecordValue(table) ? table["primary_key"] : void 0;
+  if (!isRecordValue(table) || !hasExactKeys(table, ["environment", "schema", "table", "columns", "primary_key", "created"]) || table["environment"] !== "dev" && table["environment"] !== "prod" || table["schema"] !== "public" || !isDatabaseTableIdentifier(table["table"]) || typeof table["created"] !== "boolean" || !Array.isArray(columns) || columns.length < 1 || !columns.every(isDatabaseTableAnswerColumn) || !Array.isArray(primaryKey) || !primaryKey.every((name) => columns.some((column) => column["name"] === name)))
+    throw new TypeError("Invalid database table answer");
+}
+function isDatabaseTableAnswerColumn(value) {
+  return isRecordValue(value) && hasExactKeys(value, ["name", "type", "nullable", "identity", "default"]) && isDatabaseTableIdentifier(value["name"]) && DATABASE_TABLE_COLUMN_TYPES.includes(value["type"]) && typeof value["nullable"] === "boolean" && typeof value["identity"] === "boolean" && (value["default"] === null || DATABASE_TABLE_DEFAULTS.includes(value["default"]));
+}
+function isRecordValue(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+  return Object.keys(value).sort().join(",") === [...keys].sort().join(",");
+}
 var GeneratedSdkProductApi = class {
   #client;
   managedSource;
@@ -52156,6 +52768,58 @@ var GeneratedSdkProductApi = class {
     assertProjectDatabaseAccess(value);
     return value;
   }
+  async createProjectDatabaseWatch(input) {
+    const value = await createProjectDatabaseWatch({
+      project_id: input.projectId,
+      "Idempotency-Key": input.idempotencyKey,
+      databaseWatchCreateRequest: {
+        environment: input.environment,
+        schema: input.request.schema,
+        table: input.request.table,
+        columns: [...input.request.columns],
+        operations: [...input.request.operations]
+      }
+    }, { client: this.#client });
+    assertDatabaseWatch(value);
+    if (value.environment !== input.environment || value.schema !== input.request.schema || value.table !== input.request.table)
+      throw new TypeError(WATCH_SCOPE_MISMATCH);
+    return value;
+  }
+  async listProjectDatabaseWatches(input) {
+    const value = await listProjectDatabaseWatches({ project_id: input.projectId, environment: input.environment }, { client: this.#client });
+    assertDatabaseWatchPage(value);
+    if (value.items.some((item) => item.environment !== input.environment))
+      throw new TypeError(WATCH_SCOPE_MISMATCH);
+    return value;
+  }
+  async deleteProjectDatabaseWatch(input) {
+    const value = await deleteProjectDatabaseWatch({
+      project_id: input.projectId,
+      environment: input.environment,
+      "Idempotency-Key": input.idempotencyKey,
+      watch_id: input.watchId
+    }, { client: this.#client });
+    assertDatabaseWatchDeleted(value);
+    if (value.id !== input.watchId)
+      throw new TypeError(WATCH_SCOPE_MISMATCH);
+    return value;
+  }
+  async createProjectDatabaseTable(input) {
+    const value = await createProjectDatabaseTable({
+      project_id: input.projectId,
+      "Idempotency-Key": input.idempotencyKey,
+      databaseTableCreateRequest: {
+        environment: input.environment,
+        table: input.request.table,
+        columns: [...input.request.columns],
+        ...input.request.primaryKey.length === 0 ? {} : { primary_key: [...input.request.primaryKey] }
+      }
+    }, { client: this.#client });
+    assertDatabaseTableAnswer(value);
+    if (value.table.environment !== input.environment || value.table.table !== input.request.table)
+      throw new TypeError(TABLE_SCOPE_MISMATCH);
+    return value;
+  }
   /** The signing secret exists only in this answer; the CLI prints it once and stores nothing. */
   async createProjectDatabaseWebhook(input) {
     const value = await createProjectDatabaseWebhook({
@@ -53762,8 +54426,8 @@ function pnpmLockedVersion(document2, packageName) {
   }
   return null;
 }
-function ownValue(record7, key) {
-  return isRecord4(record7) && Object.hasOwn(record7, key) ? record7[key] : void 0;
+function ownValue(record8, key) {
+  return isRecord4(record8) && Object.hasOwn(record8, key) ? record8[key] : void 0;
 }
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -54123,6 +54787,8 @@ function rejectMigrationSqlReferences(tokens, allowIdentityHelpers = false) {
     if (token?.kind !== "word" && token?.kind !== "identifier")
       continue;
     const value = token.value.toLowerCase();
+    if (value === "pgcf")
+      throw new DatabaseMigrationAdmissionError("unsupported");
     if (value === "ohmyhost") {
       if (allowIdentityHelpers && token.value === "ohmyhost" && tokens[index + 1]?.kind === "symbol" && tokens[index + 1]?.value === "." && ["user_id", "claims"].includes(tokens[index + 2]?.value ?? "") && ["word", "identifier"].includes(tokens[index + 2]?.kind ?? "") && tokens[index + 3]?.kind === "symbol" && tokens[index + 3]?.value === "(" && tokens[index + 4]?.kind === "symbol" && tokens[index + 4]?.value === ")")
         continue;
@@ -54134,6 +54800,139 @@ function rejectMigrationSqlReferences(tokens, allowIdentityHelpers = false) {
   }
 }
 
+// packages/contracts/dist/database-migration-capture.js
+var MAX_NAME_BYTES = 63;
+function readMigrationCaptureTrigger(tokens) {
+  if (!isSqlKeyword(tokens[0], "create") || !isSqlKeyword(tokens[1], "trigger"))
+    return void 0;
+  if (!tokens.some((token) => isNamedPgcf(token, true)))
+    return void 0;
+  return new CaptureReader(tokens).read();
+}
+var CaptureReader = class {
+  tokens;
+  position = 2;
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  read() {
+    const trigger = this.triggerName();
+    this.expectKeyword("after");
+    const operations = this.operations();
+    this.expectKeyword("on");
+    const schema = this.name();
+    this.expectSymbol(".");
+    const table = this.name();
+    if (!isDatabaseWatchSchema(schema))
+      throw unsupported();
+    for (const keyword of ["for", "each", "row", "execute", "function"]) {
+      this.expectKeyword(keyword);
+    }
+    const header = this.tokens.slice(0, this.position);
+    if (!isNamedPgcf(this.token(), false))
+      throw unsupported();
+    this.position += 1;
+    this.expectSymbol(".");
+    this.expectCapture();
+    this.expectSymbol("(");
+    const columns = this.columns();
+    this.expectSymbol(")");
+    if (this.position !== this.tokens.length)
+      throw unsupported();
+    return Object.freeze({
+      target: Object.freeze({ trigger, schema, table, operations, columns }),
+      header
+    });
+  }
+  triggerName() {
+    const token = this.token();
+    if (token.kind !== "word" && token.kind !== "identifier" || !isDatabaseWatchIdentifier(token.value)) {
+      throw unsupported();
+    }
+    this.position += 1;
+    return token.value;
+  }
+  /** Table and schema names may be quoted identifiers; the executor checks the catalog for the exact name. */
+  name() {
+    const token = this.token();
+    const valid = token.kind === "word" ? isDatabaseWatchIdentifier(token.value) : token.kind === "identifier" && isQuotedName(token.value);
+    if (!valid)
+      throw unsupported();
+    this.position += 1;
+    return token.value;
+  }
+  operations() {
+    const events = [];
+    do {
+      const token = this.token();
+      const operation = DATABASE_WATCH_OPERATIONS.find((name) => isSqlKeyword(token, name));
+      if (operation === void 0 || events.includes(operation))
+        throw unsupported();
+      this.position += 1;
+      events.push(operation);
+    } while (this.takeKeyword("or"));
+    return DATABASE_WATCH_OPERATIONS.filter((operation) => events.includes(operation));
+  }
+  expectCapture() {
+    const token = this.token();
+    if (token.kind !== "word" && token.kind !== "identifier" || token.value !== "capture") {
+      throw unsupported();
+    }
+    this.position += 1;
+  }
+  columns() {
+    const columns = [];
+    do {
+      const token = this.token();
+      if (columns.length >= DATABASE_WATCH_MAX_COLUMNS || token.kind !== "string" || token.text !== `'${token.value}'` || !isDatabaseWatchIdentifier(token.value) || columns.includes(token.value)) {
+        throw unsupported();
+      }
+      this.position += 1;
+      columns.push(token.value);
+    } while (this.takeSymbol(","));
+    return columns;
+  }
+  token() {
+    const token = this.tokens[this.position];
+    if (token === void 0)
+      throw unsupported();
+    return token;
+  }
+  takeKeyword(keyword) {
+    if (!isSqlKeyword(this.tokens[this.position], keyword))
+      return false;
+    this.position += 1;
+    return true;
+  }
+  expectKeyword(keyword) {
+    if (!this.takeKeyword(keyword))
+      throw unsupported();
+  }
+  takeSymbol(symbol) {
+    const token = this.tokens[this.position];
+    if (token?.kind !== "symbol" || token.value !== symbol)
+      return false;
+    this.position += 1;
+    return true;
+  }
+  expectSymbol(symbol) {
+    if (!this.takeSymbol(symbol))
+      throw unsupported();
+  }
+};
+function isNamedPgcf(token, ignoreCase) {
+  if (token.kind !== "word" && token.kind !== "identifier")
+    return false;
+  return ignoreCase ? token.value.toLowerCase() === "pgcf" : token.value === "pgcf";
+}
+function isQuotedName(value) {
+  const bytes = new TextEncoder().encode(value).byteLength;
+  return bytes >= 1 && bytes <= MAX_NAME_BYTES;
+}
+function unsupported() {
+  return new DatabaseMigrationAdmissionError("unsupported");
+}
+
 // packages/contracts/dist/database-migration-policies.js
 var PolicyReader = class {
   tokens;
@@ -54287,6 +55086,9 @@ function admitExpandOnlyMigrations(migrations) {
       throw new DatabaseMigrationAdmissionError("invalid");
     }
     const statements = parseDatabaseMigrationStatements(sql);
+    if (statements.some((statement) => statement.captureTrigger !== void 0 && isDatabaseWatchTriggerName(statement.captureTrigger.trigger))) {
+      throw new DatabaseMigrationAdmissionError("unsupported");
+    }
     statementCount += statements.length;
     return Object.freeze({ path: migration.path, statementCount: statements.length });
   });
@@ -54300,6 +55102,11 @@ function parseDatabaseMigrationStatements(sql) {
   if (statements.length === 0)
     throw new DatabaseMigrationAdmissionError("invalid");
   return Object.freeze(statements.map((statement) => {
+    const capture = readMigrationCaptureTrigger(statement.tokens);
+    if (capture !== void 0) {
+      rejectMigrationSqlReferences(capture.header);
+      return Object.freeze({ sql: statement.sql, captureTrigger: capture.target });
+    }
     rejectMigrationSqlReferences(statement.tokens, true);
     const rlsTarget = readMigrationRlsTarget(statement.tokens);
     if (rlsTarget !== void 0)
@@ -56956,6 +57763,7 @@ export {
   ACCOUNT_SENSITIVE_PROBLEMS,
   classifyCliFailure,
   GeneratedSdkManagedSourceApi,
+  assertDatabaseTableAnswer,
   GeneratedSdkProductApi,
   RepositoryInitError,
   RepositoryInitBlockedError,