naro-cli 0.19.1 → 0.21.0

package/dist/{chunk-ZO2BEC46.js → chunk-FFPOVA7I.js}

@@ -345,6 +345,8 @@ var DEPLOYMENT_ERROR_CODES = [
   "FORBIDDEN",
   "NOT_FOUND",
   "DEPLOYMENT_NOT_PROMOTABLE",
+  /** A promotion to another surface rebuilds the commit, and the source was not built from Git (spec 2026-10-18-named-environments §9.1). */
+  "PROMOTE_NEEDS_GIT_SOURCE",
   "DEPLOYMENT_NOT_CANCELABLE",
   "SUBDOMAIN_TAKEN",
   "FLAG_EXISTS",
@@ -511,6 +513,9 @@ function projectPath(teamSlug, projectSlug) {
   return `/${teamSlug}/projects/${projectSlug}`;
 }
 
+// ../../packages/core/src/platform-mail.ts
+var encoder = new TextEncoder();
+
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -18506,6 +18511,7 @@ function forkedAppRoot(checkout, appRoot, forkCheckout) {
 }
 
 // ../../packages/build/src/local-build-executor.ts
+var PINNED_COMMIT_SHA = /^[0-9a-f]{40}$/;
 function concurrencyFromEnvironment() {
   const raw = Number(process.env.NARO_RESOLVER_CONCURRENCY ?? "1");
   return Number.isInteger(raw) && raw > 0 ? raw : 1;
@@ -18650,6 +18656,68 @@ var LocalBuildExecutor = class {
   constructor(dependencies = defaultLocalBuildDependencies) {
     this.dependencies = dependencies;
   }
+  /**
+   * Checks out one commit, whichever ref reaches it: GitHub serves any
+   * reachable commit by SHA, which `clone --branch` cannot ask for. The URL
+   * carries the installation token and is only ever an argument — runCommand
+   * logs a command's output (redacted), never the command line, and a failed
+   * command's message names the command, not its arguments.
+   *
+   * The commit is an argument of `git fetch`, so it is checked before any git
+   * command runs: a value git could read as an option (`--upload-pack=…`) or a
+   * ref name must not get that far. The build container checks it on the way
+   * in; the local runner passes claim's input straight through, so this is the
+   * check that covers it.
+   */
+  async checkoutPinnedCommit(commitSha, repositoryUrl, workspace, checkout, observer) {
+    if (!PINNED_COMMIT_SHA.test(commitSha)) {
+      throw new DeploymentError(
+        "CLONE_FAILED",
+        "The pinned commit is not a 40-character lowercase hex SHA."
+      );
+    }
+    const git2 = (args) => this.dependencies.runCommand(
+      {
+        command: "git",
+        args,
+        cwd: workspace,
+        timeoutMs: 12e4,
+        stage: "CLONING",
+        errorCode: "CLONE_FAILED"
+      },
+      observer
+    );
+    await git2(["init", "--quiet", checkout]);
+    await git2(["-C", checkout, "remote", "add", "origin", "--", repositoryUrl]);
+    try {
+      await git2([
+        "-C",
+        checkout,
+        "fetch",
+        "--quiet",
+        "--depth",
+        "1",
+        "origin",
+        commitSha
+      ]);
+    } catch (error51) {
+      if (!(error51 instanceof CommandExecutionError)) throw error51;
+      if (error51.timedOut) throw error51;
+      throw new DeploymentError(
+        "CLONE_FAILED",
+        `Could not fetch commit ${commitSha.slice(0, 7)}. It may have been removed from the repository.`,
+        { cause: error51 }
+      );
+    }
+    await git2([
+      "-C",
+      checkout,
+      "checkout",
+      "--quiet",
+      "--detach",
+      "FETCH_HEAD"
+    ]);
+  }
   async build(input, observer, cache) {
     const workspace = await this.dependencies.createWorkspace();
     const checkout = join18(workspace, "checkout");
@@ -18675,27 +18743,37 @@ var LocalBuildExecutor = class {
           message: `Build cache disabled: ${compressor} is not installed. Install it to reuse dependencies between deploys.`
         });
       }
-      await this.dependencies.runCommand(
-        {
-          command: "git",
-          args: [
-            "clone",
-            "--depth",
-            "1",
-            "--branch",
-            input.branch,
-            "--single-branch",
-            "--",
-            input.repositoryUrl,
-            checkout
-          ],
-          cwd: workspace,
-          timeoutMs: 12e4,
-          stage: "CLONING",
-          errorCode: "CLONE_FAILED"
-        },
-        observer
-      );
+      if (input.commitSha !== void 0) {
+        await this.checkoutPinnedCommit(
+          input.commitSha,
+          input.repositoryUrl,
+          workspace,
+          checkout,
+          observer
+        );
+      } else {
+        await this.dependencies.runCommand(
+          {
+            command: "git",
+            args: [
+              "clone",
+              "--depth",
+              "1",
+              "--branch",
+              input.branch,
+              "--single-branch",
+              "--",
+              input.repositoryUrl,
+              checkout
+            ],
+            cwd: workspace,
+            timeoutMs: 12e4,
+            stage: "CLONING",
+            errorCode: "CLONE_FAILED"
+          },
+          observer
+        );
+      }
       const revision = await this.dependencies.runCommand(
         {
           command: "git",
@@ -18714,6 +18792,12 @@ var LocalBuildExecutor = class {
           "Git returned an invalid commit SHA."
         );
       }
+      if (input.commitSha !== void 0 && gitCommitSha !== input.commitSha) {
+        throw new DeploymentError(
+          "CLONE_FAILED",
+          `Checked out ${gitCommitSha.slice(0, 7)} instead of the pinned commit ${input.commitSha.slice(0, 7)}.`
+        );
+      }
       const reportedSha = gitCommitSha.length === 40 ? gitCommitSha : null;
       if (!reportedSha)
         await info2(
@@ -19129,6 +19213,14 @@ var NaroError = class extends Error {
     if (options?.details !== void 0) this.details = options.details;
   }
 };
+var PROMOTE_TARGET_UNSUPPORTED_MESSAGE = "This control plane cannot promote to an environment yet. Deploy the latest web first, then try again.";
+function promoteTargetUnsupported(cause) {
+  return new NaroError(
+    "PROMOTE_TARGET_UNSUPPORTED",
+    PROMOTE_TARGET_UNSUPPORTED_MESSAGE,
+    cause !== void 0 ? { cause } : void 0
+  );
+}
 function isNaroError(error51) {
   return error51 instanceof NaroError || error51 instanceof Error && error51.name === "NaroError" && typeof error51.code === "string";
 }
@@ -19234,7 +19326,7 @@ var STYLES = `
   *{box-sizing:border-box}
   :root{
     --bg:#000;--surface:#0a0a0a;--surface-2:#111;--border:#232323;
-    --text:#ededed;--muted:#a1a1a1;--faint:#6f6f6f;
+    --text:#ededed;--muted:#a1a1a1;--faint:#808080;
     --sans:ui-sans-serif,system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;
     --mono:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;
   }
@@ -19698,6 +19790,8 @@ function deploymentInfo(row) {
     errorMessage: row.error_message,
     gitCommitSha: row.git_commit_sha,
     gitCommitMessage: row.git_commit_message,
+    pinnedCommitSha: row.pinned_commit_sha ?? null,
+    rebuiltFromDeploymentId: row.rebuilt_from_deployment_id ?? null,
     createdAt: row.created_at,
     startedAt: row.started_at,
     finishedAt: row.finished_at
@@ -19730,6 +19824,7 @@ var NaroClient = class {
   db;
   backend;
   storage;
+  realtime;
   insights;
   analytics;
   protection;
@@ -19749,6 +19844,7 @@ var NaroClient = class {
     this.db = new DbApi(this);
     this.backend = new BackendApi(this);
     this.storage = new StorageApi(this);
+    this.realtime = new RealtimeApi(this);
     this.insights = new InsightsApi(this);
     this.analytics = new AnalyticsApi(this);
     this.protection = new ProtectionApi(this);
@@ -19949,16 +20045,65 @@ var DeploymentsApi = class {
     return { current, target: production.slice(1).find(differs) ?? null };
   }
   /**
-   * Redeploys an existing READY deployment's artifact to production.
-   * Used by both `naro promote` (preview → production) and `naro rollback`
-   * (older production build → production).
+   * Promotes an existing READY deployment: with no `target` (or
+   * `production`) it goes to production — `naro promote` (preview →
+   * production) and `naro rollback` (older production build → production).
+   * A deployment from an environment is rebuilt from its commit with
+   * production's variables (`mode: "rebuild"`); any other is published as
+   * stored (`mode: "reupload"`). With an environment `target` the control
+   * plane likewise rebuilds the deployment's commit with that environment's
+   * variables or publishes the stored build.
+   *
+   * No `target` sends no body, exactly as clients before targets did. A
+   * control plane from before targets ignores `target` and promotes to
+   * production, so an environment target is first checked with
+   * `promoteCheck`: a 405 there (no such route) stops with
+   * `PROMOTE_TARGET_UNSUPPORTED` before anything is promoted. The target is
+   * trimmed once, as the control plane trims it, so `" production"` is
+   * production and asks no preview.
+   */
+  async promote(projectId, deploymentId, options = {}) {
+    const target2 = options.target?.trim();
+    if (target2 !== void 0 && target2 !== "production") {
+      try {
+        await this.promoteCheck(projectId, deploymentId, target2);
+      } catch (error51) {
+        if (isNaroError(error51) && error51.status === 405) {
+          throw promoteTargetUnsupported(error51);
+        }
+        throw error51;
+      }
+    }
+    const body = await this.client.request(this.promotePath(projectId, deploymentId), {
+      method: "POST",
+      ...target2 !== void 0 ? { body: { target: target2 } } : {},
+      context: "Promote deployment"
+    });
+    return {
+      ...deploymentInfo(body.deployment),
+      mode: body.mode ?? "reupload"
+    };
+  }
+  /**
+   * What promoting to `target` would do, changing nothing: how it gets its
+   * build, the migrations the target's database has not applied (null when
+   * they cannot be compared) and the warnings to show first. Answers 405 from
+   * a control plane that predates promote targets.
    */
-  async promote(projectId, deploymentId) {
+  async promoteCheck(projectId, deploymentId, target2) {
+    const query = target2 !== void 0 ? `?target=${encodeURIComponent(target2)}` : "";
     const body = await this.client.request(
-      `/api/projects/${encodeURIComponent(projectId)}/deployments/${encodeURIComponent(deploymentId)}/promote`,
-      { method: "POST", context: "Promote deployment" }
+      `${this.promotePath(projectId, deploymentId)}${query}`,
+      { context: "Check promotion" }
     );
-    return deploymentInfo(body.deployment);
+    return {
+      mode: body.mode ?? "reupload",
+      pendingMigrations: body.pendingMigrations ?? null,
+      warnings: body.warnings ?? []
+    };
+  }
+  promotePath(projectId, deploymentId) {
+    return `/api/projects/${encodeURIComponent(projectId)}/deployments/${encodeURIComponent(deploymentId)}/promote`;
   }
   /**
    * Stops an in-flight build (QUEUED through BUILDING) and marks the row
@@ -20713,6 +20858,7 @@ function storageInfo(body) {
   return {
     enabled: body.enabled,
     bucket: body.bucket ?? null,
+    disabledAt: body.disabledAt ?? null,
     limits: {
       bytes: body.limits.bytes,
       objectBytes: body.limits.objectBytes,
@@ -20724,6 +20870,18 @@ function storageInfo(body) {
     buckets: (body.buckets ?? []).map(storageBucket)
   };
 }
+function provisionFailure(error51, feature) {
+  const details = isNaroError(error51) ? error51.details : void 0;
+  if (isNaroError(error51) && error51.code === "BACKEND_PROVISION_FAILED" && isRecord(details?.[feature]) && isRecord(details.backend))
+    return new NaroError(error51.code, error51.message, {
+      ...error51.status !== void 0 ? { status: error51.status } : {},
+      details: {
+        ...details,
+        backend: backendInfo(details.backend)
+      }
+    });
+  return error51;
+}
 function bucketFields(fields, into = {}) {
   for (const key of ["public", "fileSizeLimit", "allowedMimeTypes"])
     if (fields[key] !== void 0) into[key] = fields[key];
@@ -21152,16 +21310,45 @@ var StorageApi = class {
         }
       );
     } catch (error51) {
-      const details = isNaroError(error51) ? error51.details : void 0;
-      if (isNaroError(error51) && error51.code === "BACKEND_PROVISION_FAILED" && isRecord(details?.storage) && isRecord(details.backend))
-        throw new NaroError(error51.code, error51.message, {
-          ...error51.status !== void 0 ? { status: error51.status } : {},
-          details: {
-            ...details,
-            backend: backendInfo(details.backend)
-          }
-        });
-      throw error51;
+      throw provisionFailure(error51, "storage");
+    }
+    return storageInfo(body.storage);
+  }
+  /**
+   * Turns Storage off and keeps its files (Storage 3-1k): the Naro worker is
+   * uploaded again without the bucket, so the app's Storage calls and file
+   * URLs answer `404 STORAGE_NOT_ENABLED` until `enable` binds the same
+   * bucket again. The bucket, its files and their storage cost stay; while
+   * it is off, bucket writes and the object routes answer `409
+   * STORAGE_OFF`, and reads go on. Safe to repeat: Storage never on, or
+   * already off, comes back as it is, and a turn-off that stopped is
+   * finished. Two minutes, like `enable`.
+   *
+   * Refusals, in the order they are checked: `BACKEND_DISABLED`,
+   * `FORBIDDEN` (`storage.manage`), `DATABASE_NOT_ENABLED`,
+   * `BACKEND_NOT_READY` (no backend), `BACKEND_OFF`, `BACKEND_BUSY` (another
+   * change holds the backend — or turning Storage on again took this
+   * turn-off over, and Storage is on), `STORAGE_DISABLE_FAILED` (502: the
+   * turn-off could not be recorded; nothing changed), and
+   * `BACKEND_PROVISION_FAILED` (502) when it is
+   * recorded but the worker's upload — or a step after it — stopped:
+   * `details` holds `{ storage: { applied: false, enabled: false }, backend
+   * }`, and `disable` again finishes. Never `STORAGE_DISABLED`: the control
+   * plane's Storage switch does not hold a removal back.
+   */
+  async disable(projectId) {
+    let body;
+    try {
+      body = await this.client.request(
+        this.path(projectId),
+        {
+          method: "DELETE",
+          context: "Turn off Storage",
+          timeoutMs: PROVISION_TIMEOUT_MS
+        }
+      );
+    } catch (error51) {
+      throw provisionFailure(error51, "storage");
     }
     return storageInfo(body.storage);
   }
@@ -21320,6 +21507,114 @@ var StorageApi = class {
     return body.objects;
   }
 };
+var RealtimeApi = class {
+  constructor(client) {
+    this.client = client;
+  }
+  path(projectId, suffix = "") {
+    return `/api/projects/${encodeURIComponent(projectId)}/backend/realtime${suffix}`;
+  }
+  /**
+   * Like `StorageApi.bucketPath`: URL parsing folds `.` and `..`, an empty
+   * name is the collection, and `encodeURIComponent` throws on a lone
+   * surrogate — so a name no URL can carry is refused here, before a
+   * request. SQLite does make tables named `.` and `..`, and one with the
+   * empty name (`CREATE TABLE "" (a)`); such a table cannot be published
+   * or unpublished through this API.
+   */
+  tablePath(projectId, table) {
+    if (table === "" || table === "." || table === ".." || LONE_SURROGATE.test(table))
+      throw new NaroError("INVALID_PATH", "The table name is not valid.");
+    return this.path(projectId, `/tables/${encodeURIComponent(table)}`);
+  }
+  /**
+   * Whether Realtime is on, the limits the hub enforces, the published
+   * tables and the hub's own numbers. A project that never turned it on
+   * answers `enabled: false` with no tables.
+   */
+  async info(projectId) {
+    const body = await this.client.request(
+      this.path(projectId),
+      { context: "Read realtime" }
+    );
+    return body.realtime;
+  }
+  /**
+   * Turns Realtime on: the request and the plan's limits are recorded, and
+   * the Naro worker is uploaded again with its hub (a Durable Object). Safe
+   * to repeat, and a repair — also after a plan change. The project must have
+   * a backend, turned on, with its database. A backend in `error` or with a
+   * run that stalled is not refused: its provisioning is resumed on the way.
+   * Two minutes, like `backend.enable`.
+   *
+   * Refusals, in the order they are checked: `BACKEND_DISABLED` (the control
+   * plane's backend switch), `FORBIDDEN` (`database.write`),
+   * `REALTIME_DISABLED` (the control plane's Realtime switch),
+   * `DATABASE_NOT_ENABLED` (the project's database is external),
+   * `BACKEND_NOT_READY` (409, only when the project has no backend at all),
+   * `BACKEND_OFF`, `BACKEND_BUSY`, `REALTIME_ENABLE_FAILED` (502: the request
+   * could not be recorded; nothing changed), and `BACKEND_PROVISION_FAILED`
+   * (502) when Realtime is recorded as on but the worker's upload stopped.
+   * The last one's `details` hold a `RealtimeProvisionFailure` — `{ realtime:
+   * { applied: false, enabled: true }, backend }`, the backend read like
+   * `backend.info` — and `enable` again finishes.
+   */
+  async enable(projectId) {
+    let body;
+    try {
+      body = await this.client.request(
+        this.path(projectId),
+        {
+          method: "POST",
+          context: "Turn on Realtime",
+          timeoutMs: PROVISION_TIMEOUT_MS
+        }
+      );
+    } catch (error51) {
+      throw provisionFailure(error51, "realtime");
+    }
+    return body.realtime;
+  }
+  /**
+   * The tables whose Data API writes are published, in the order they were
+   * published. `exists: false` is a published name whose table was dropped.
+   * `REALTIME_NOT_ENABLED` (409) before `enable`; it answers while the
+   * backend is off, since the list is in the project's database.
+   */
+  async listTables(projectId) {
+    const body = await this.client.request(
+      this.path(projectId, "/tables"),
+      { context: "List realtime tables" }
+    );
+    return body.tables;
+  }
+  /**
+   * Publishes a table's changes to the subscribers of its channel. Safe to
+   * repeat. Only changes made through the Data API are published — writes
+   * the app makes with `env.DB` are not (`warnings` says so).
+   * `TABLE_NOT_FOUND` (404) for a table that does not exist;
+   * `VALIDATION_FAILED` (400) for a Naro system table, a virtual table, a
+   * name over 256 characters, or the 100-table cap; `REALTIME_NOT_ENABLED`
+   * (409) before `enable`.
+   */
+  async publishTable(projectId, table) {
+    return this.client.request(
+      this.tablePath(projectId, table),
+      { method: "PUT", context: "Publish a realtime table" }
+    );
+  }
+  /**
+   * Stops publishing a table's changes; a table dropped since can still be
+   * unpublished. `TABLE_NOT_PUBLISHED` (404) for a table that does not
+   * publish, `REALTIME_NOT_ENABLED` (409) before `enable`.
+   */
+  async unpublishTable(projectId, table) {
+    return this.client.request(
+      this.tablePath(projectId, table),
+      { method: "DELETE", context: "Stop publishing a realtime table" }
+    );
+  }
+};
 
 // ../../packages/sdk/src/database.ts
 var BOOKMARK_RE = /^[0-9a-f]{8}-[0-9a-f]{8}-[0-9a-f]{8}-[0-9a-f]{32}$/;
@@ -21717,93 +22012,272 @@ function detectFramework2(dir) {
   };
 }
 
-// ../../packages/data-core/src/unicode-controls.ts
-function hasControlCharacter(text2) {
-  for (let i = 0; i < text2.length; i += 1) {
-    const code = text2.charCodeAt(i);
-    if (code <= 31 || code >= 127 && code <= 159) return true;
-  }
-  return false;
-}
-function hasBidiControl(text2) {
-  for (let i = 0; i < text2.length; i += 1) {
-    const code = text2.charCodeAt(i);
-    if (code === 1564 || code === 8206 || code === 8207 || code >= 8234 && code <= 8238 || code >= 8294 && code <= 8297)
-      return true;
-  }
-  return false;
-}
-
-// ../../packages/data-core/src/storage-path.ts
-var MAX_SINGLE_UPLOAD_BYTES = 52428800;
-var MAX_OBJECT_NAME_BYTES = 900;
-var STORAGE_RESERVED_WORDS = [
-  "authenticated",
-  "copy",
-  "info",
-  "list",
-  "move",
-  "public",
-  "render",
-  "sign",
-  "upload"
+// ../../packages/data-core/src/system-tables.ts
+var SYSTEM_TABLE_PREFIXES = [
+  "_naro_",
+  "_cf_",
+  "sqlite_"
 ];
-var RESERVED = new Set(STORAGE_RESERVED_WORDS);
-var ENCODER = new TextEncoder();
-var LONE_SURROGATE2 = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
-var LONE_SURROGATES = new RegExp(LONE_SURROGATE2.source, "g");
-function hasLoneSurrogate(text2) {
-  return LONE_SURROGATE2.test(text2);
+var SYSTEM_TABLE_NAMES = ["d1_migrations"];
+function asciiLower(text2) {
+  return text2.replace(/[A-Z]+/g, (run) => run.toLowerCase());
 }
-function refuse(reason) {
-  return { ok: false, reason };
+function isSystemTable(name) {
+  const lower = asciiLower(name);
+  return SYSTEM_TABLE_PREFIXES.some((prefix) => lower.startsWith(prefix)) || SYSTEM_TABLE_NAMES.includes(lower);
 }
-function checkWellFormed(name) {
-  if (name === "") return refuse("is empty");
-  if (name.length > MAX_OBJECT_NAME_BYTES || ENCODER.encode(name).length > MAX_OBJECT_NAME_BYTES)
-    return refuse(`is longer than ${String(MAX_OBJECT_NAME_BYTES)} bytes`);
-  if (name.startsWith("/") || name.endsWith("/"))
-    return refuse("starts or ends with /");
-  if (name.includes("//")) return refuse("has an empty segment (//)");
-  for (const segment of name.split("/"))
-    if (segment === "." || segment === "..")
-      return refuse("has a . or .. segment");
-  if (hasControlCharacter(name)) return refuse("has a control character");
-  if (name.includes("\\")) return refuse("has a backslash");
-  if (hasBidiControl(name))
-    return refuse("has a bidirectional control character");
-  return { ok: true, name };
+function likeLiteral(text2) {
+  return text2.replace(/[\\%_]/g, (char) => `\\${char}`).replace(/'/g, "''");
 }
-function checkObjectName(name) {
-  if (hasLoneSurrogate(name)) return refuse("is not valid UTF-8");
-  return checkWellFormed(name);
+var COLUMN_REFERENCE = /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)?$/;
+function systemTablePredicate(column2 = "name") {
+  if (!COLUMN_REFERENCE.test(column2))
+    throw new Error(`Not a column reference: ${column2}`);
+  return [
+    ...SYSTEM_TABLE_PREFIXES.map(
+      (prefix) => `${column2} NOT LIKE '${likeLiteral(prefix)}%' ESCAPE '\\'`
+    ),
+    ...SYSTEM_TABLE_NAMES.map(
+      (name) => `${column2} NOT LIKE '${likeLiteral(name)}' ESCAPE '\\'`
+    ),
+    `${column2} NOT IN (SELECT name FROM pragma_table_list WHERE schema = 'main' AND type = 'shadow')`
+  ].join(" AND ");
 }
-function objectParent(name) {
-  const slash = name.lastIndexOf("/");
-  return slash < 0 ? "" : name.slice(0, slash);
+var SYSTEM_TABLE_SQL_PREDICATE = systemTablePredicate("name");
+
+// ../../packages/data-core/src/collation.ts
+var COLLATIONS = ["BINARY", "NOCASE", "RTRIM"];
+function isSpace(char) {
+  return char === " " || char === "	" || char === "\n" || char === "\f" || char === "\r";
 }
-var TOKEN_CHARACTERS = "[!#$%&'*+\\-.^_`|~0-9A-Za-z]";
-var TOKEN = new RegExp(`^${TOKEN_CHARACTERS}+$`);
-var MEDIA_TYPE = new RegExp(`^${TOKEN_CHARACTERS}+/${TOKEN_CHARACTERS}+$`);
-var DEFAULT_MAX_AGE = 3600;
-var MAX_MAX_AGE = 31536e3;
-function parseCacheControl(header) {
-  if (header === null) return { ok: true, maxAge: DEFAULT_MAX_AGE };
-  const match = /^[ \t]*max-age=(\d{1,8})[ \t]*$/i.exec(header);
-  if (match?.[1] === void 0) return { ok: false };
-  const maxAge = Number(match[1]);
-  return maxAge <= MAX_MAX_AGE ? { ok: true, maxAge } : { ok: false };
+function isWordChar(char) {
+  return /[A-Za-z0-9_$]/.test(char) || char.charCodeAt(0) >= 128;
 }
-var MAX_NAME_IN_MESSAGE = 256;
-function storageName(text2) {
-  if (text2.length <= MAX_NAME_IN_MESSAGE) return text2;
-  const cut = text2.slice(0, MAX_NAME_IN_MESSAGE);
-  const last = cut.charCodeAt(MAX_NAME_IN_MESSAGE - 1);
-  return last >= 55296 && last <= 56319 ? cut.slice(0, MAX_NAME_IN_MESSAGE - 1) : cut;
+function asciiUpper2(text2) {
+  return text2.replace(/[a-z]/g, (letter) => letter.toUpperCase());
 }
-
-// ../../packages/data-core/src/storage-table.ts
-var STORAGE_OBJECTS = "storage.objects";
+function quoted(sql, start, close, doubles) {
+  let value = "";
+  for (let index = start + 1; index < sql.length; index++) {
+    const char = sql.charAt(index);
+    if (char !== close) {
+      value += char;
+      continue;
+    }
+    if (doubles && sql.charAt(index + 1) === close) {
+      value += close;
+      index++;
+      continue;
+    }
+    return { value, end: index + 1 };
+  }
+  return void 0;
+}
+function tokenize(sql) {
+  const tokens = [];
+  let index = 0;
+  while (index < sql.length) {
+    const char = sql.charAt(index);
+    if (isSpace(char)) {
+      index++;
+    } else if (char === "-" && sql.charAt(index + 1) === "-") {
+      const end = sql.indexOf("\n", index);
+      index = end < 0 ? sql.length : end + 1;
+    } else if (char === "/" && sql.charAt(index + 1) === "*") {
+      const end = sql.indexOf("*/", index + 2);
+      if (end < 0) return void 0;
+      index = end + 2;
+    } else if (char === '"' || char === "`" || char === "[" || char === "'") {
+      const close = char === "[" ? "]" : char;
+      const read = quoted(sql, index, close, char !== "[");
+      if (!read) return void 0;
+      tokens.push({
+        kind: char === "'" ? "string" : "name",
+        value: read.value
+      });
+      index = read.end;
+    } else if (char === "(" || char === ")" || char === ",") {
+      tokens.push({ kind: "punct", value: char });
+      index++;
+    } else if (isWordChar(char)) {
+      let end = index;
+      while (end < sql.length && isWordChar(sql.charAt(end))) end++;
+      tokens.push({ kind: "word", value: sql.slice(index, end) });
+      index = end;
+    } else {
+      tokens.push({ kind: "other", value: char });
+      index++;
+    }
+  }
+  return tokens;
+}
+function isWord2(token, word) {
+  return token?.kind === "word" && asciiLower(token.value) === word;
+}
+function definitions(tokens) {
+  const open = tokens.findIndex(
+    (token) => token.kind === "punct" && token.value === "("
+  );
+  if (open < 0) return void 0;
+  const found = [[]];
+  let depth = 0;
+  for (const token of tokens.slice(open + 1)) {
+    if (token.kind === "punct" && token.value === "(") depth++;
+    if (token.kind === "punct" && token.value === ")") {
+      if (depth === 0) return found;
+      depth--;
+    }
+    if (depth === 0 && token.kind === "punct" && token.value === ",") {
+      found.push([]);
+      continue;
+    }
+    found.at(-1)?.push(token);
+  }
+  return void 0;
+}
+function collationOf(definition) {
+  const named = [];
+  let depth = 0;
+  for (const [index, token] of definition.entries()) {
+    if (token.kind === "punct" && token.value === "(") depth++;
+    else if (token.kind === "punct" && token.value === ")") depth--;
+    else if (depth === 0 && index > 0 && isWord2(token, "collate")) {
+      const name = definition[index + 1];
+      if (!name || name.kind === "punct" || name.kind === "other") return null;
+      named.push(asciiUpper2(name.value));
+    }
+  }
+  if (named.length === 0) return "BINARY";
+  const [first] = named;
+  if (named.some((name) => name !== first)) return null;
+  return COLLATIONS.includes(first ?? "") ? first : null;
+}
+function declaresStrict(sql) {
+  if (typeof sql !== "string") return void 0;
+  const tokens = tokenize(sql);
+  if (!tokens || !isWord2(tokens[0], "create")) return void 0;
+  const kind = isWord2(tokens[1], "temp") || isWord2(tokens[1], "temporary") ? tokens[2] : tokens[1];
+  if (!isWord2(kind, "table")) return void 0;
+  const open = tokens.findIndex(
+    (token) => token.kind === "punct" && token.value === "("
+  );
+  if (open < 0) return void 0;
+  let depth = 0;
+  for (const [index, token] of tokens.entries()) {
+    if (index < open || token.kind !== "punct") continue;
+    if (token.value === "(") depth++;
+    else if (token.value === ")" && --depth === 0)
+      return tokens.slice(index + 1).some((option) => isWord2(option, "strict"));
+  }
+  return void 0;
+}
+function declaredCollations(sql, columns) {
+  const unknown2 = columns.map(() => null);
+  if (typeof sql !== "string") return unknown2;
+  const tokens = tokenize(sql);
+  if (!tokens || !isWord2(tokens[0], "create")) return unknown2;
+  const kind = isWord2(tokens[1], "temp") || isWord2(tokens[1], "temporary") ? tokens[2] : tokens[1];
+  if (!isWord2(kind, "table")) return unknown2;
+  const found = definitions(tokens);
+  if (!found || found.length < columns.length) return unknown2;
+  const collations = [];
+  for (const [index, column2] of columns.entries()) {
+    const definition = found[index] ?? [];
+    const name = definition[0];
+    if (!name || name.kind === "punct" || name.kind === "other" || asciiLower(name.value) !== asciiLower(column2))
+      return unknown2;
+    collations.push(collationOf(definition));
+  }
+  return collations;
+}
+
+// ../../packages/data-core/src/unicode-controls.ts
+function hasControlCharacter(text2) {
+  for (let i = 0; i < text2.length; i += 1) {
+    const code = text2.charCodeAt(i);
+    if (code <= 31 || code >= 127 && code <= 159) return true;
+  }
+  return false;
+}
+function hasBidiControl(text2) {
+  for (let i = 0; i < text2.length; i += 1) {
+    const code = text2.charCodeAt(i);
+    if (code === 1564 || code === 8206 || code === 8207 || code >= 8234 && code <= 8238 || code >= 8294 && code <= 8297)
+      return true;
+  }
+  return false;
+}
+
+// ../../packages/data-core/src/storage-path.ts
+var MAX_SINGLE_UPLOAD_BYTES = 52428800;
+var MAX_OBJECT_NAME_BYTES = 900;
+var STORAGE_RESERVED_WORDS = [
+  "authenticated",
+  "copy",
+  "info",
+  "list",
+  "move",
+  "public",
+  "render",
+  "sign",
+  "upload"
+];
+var RESERVED = new Set(STORAGE_RESERVED_WORDS);
+var ENCODER = new TextEncoder();
+var LONE_SURROGATE2 = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
+var LONE_SURROGATES = new RegExp(LONE_SURROGATE2.source, "g");
+function hasLoneSurrogate(text2) {
+  return LONE_SURROGATE2.test(text2);
+}
+function refuse(reason) {
+  return { ok: false, reason };
+}
+function checkWellFormed(name) {
+  if (name === "") return refuse("is empty");
+  if (name.length > MAX_OBJECT_NAME_BYTES || ENCODER.encode(name).length > MAX_OBJECT_NAME_BYTES)
+    return refuse(`is longer than ${String(MAX_OBJECT_NAME_BYTES)} bytes`);
+  if (name.startsWith("/") || name.endsWith("/"))
+    return refuse("starts or ends with /");
+  if (name.includes("//")) return refuse("has an empty segment (//)");
+  for (const segment of name.split("/"))
+    if (segment === "." || segment === "..")
+      return refuse("has a . or .. segment");
+  if (hasControlCharacter(name)) return refuse("has a control character");
+  if (name.includes("\\")) return refuse("has a backslash");
+  if (hasBidiControl(name))
+    return refuse("has a bidirectional control character");
+  return { ok: true, name };
+}
+function checkObjectName(name) {
+  if (hasLoneSurrogate(name)) return refuse("is not valid UTF-8");
+  return checkWellFormed(name);
+}
+function objectParent(name) {
+  const slash = name.lastIndexOf("/");
+  return slash < 0 ? "" : name.slice(0, slash);
+}
+var TOKEN_CHARACTERS = "[!#$%&'*+\\-.^_`|~0-9A-Za-z]";
+var TOKEN = new RegExp(`^${TOKEN_CHARACTERS}+$`);
+var MEDIA_TYPE = new RegExp(`^${TOKEN_CHARACTERS}+/${TOKEN_CHARACTERS}+$`);
+var DEFAULT_MAX_AGE = 3600;
+var MAX_MAX_AGE = 31536e3;
+function parseCacheControl(header) {
+  if (header === null) return { ok: true, maxAge: DEFAULT_MAX_AGE };
+  const match = /^[ \t]*max-age=(\d{1,8})[ \t]*$/i.exec(header);
+  if (match?.[1] === void 0) return { ok: false };
+  const maxAge = Number(match[1]);
+  return maxAge <= MAX_MAX_AGE ? { ok: true, maxAge } : { ok: false };
+}
+var MAX_NAME_IN_MESSAGE = 256;
+function storageName(text2) {
+  if (text2.length <= MAX_NAME_IN_MESSAGE) return text2;
+  const cut = text2.slice(0, MAX_NAME_IN_MESSAGE);
+  const last = cut.charCodeAt(MAX_NAME_IN_MESSAGE - 1);
+  return last >= 55296 && last <= 56319 ? cut.slice(0, MAX_NAME_IN_MESSAGE - 1) : cut;
+}
+
+// ../../packages/data-core/src/storage-table.ts
+var STORAGE_OBJECTS = "storage.objects";
 var STORAGE_OBJECTS_TABLE = "_naro_storage_objects";
 var STORAGE_OBJECTS_QUALIFIER = "objects";
 var STORAGE_UNAVAILABLE_MESSAGE = "storage.objects is not available on this backend yet. Run `naro backend enable` to update it.";
@@ -21861,39 +22335,6 @@ var STORAGE_BUCKET_DELETING_COLUMN = {
   definition: "TEXT"
 };
 
-// ../../packages/data-core/src/system-tables.ts
-var SYSTEM_TABLE_PREFIXES = [
-  "_naro_",
-  "_cf_",
-  "sqlite_"
-];
-var SYSTEM_TABLE_NAMES = ["d1_migrations"];
-function asciiLower(text2) {
-  return text2.replace(/[A-Z]+/g, (run) => run.toLowerCase());
-}
-function isSystemTable(name) {
-  const lower = asciiLower(name);
-  return SYSTEM_TABLE_PREFIXES.some((prefix) => lower.startsWith(prefix)) || SYSTEM_TABLE_NAMES.includes(lower);
-}
-function likeLiteral(text2) {
-  return text2.replace(/[\\%_]/g, (char) => `\\${char}`).replace(/'/g, "''");
-}
-var COLUMN_REFERENCE = /^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)?$/;
-function systemTablePredicate(column2 = "name") {
-  if (!COLUMN_REFERENCE.test(column2))
-    throw new Error(`Not a column reference: ${column2}`);
-  return [
-    ...SYSTEM_TABLE_PREFIXES.map(
-      (prefix) => `${column2} NOT LIKE '${likeLiteral(prefix)}%' ESCAPE '\\'`
-    ),
-    ...SYSTEM_TABLE_NAMES.map(
-      (name) => `${column2} NOT LIKE '${likeLiteral(name)}' ESCAPE '\\'`
-    ),
-    `${column2} NOT IN (SELECT name FROM pragma_table_list WHERE schema = 'main' AND type = 'shadow')`
-  ].join(" AND ");
-}
-var SYSTEM_TABLE_SQL_PREDICATE = systemTablePredicate("name");
-
 // ../../packages/data-core/src/errors.ts
 var DATABASE_FULL_MESSAGE = "The database has reached D1's 10 GB limit, which cannot be raised. Delete data to free space; writes fail until it is under the limit.";
 var STORAGE_MIGRATION_PENDING_MESSAGE = "The project backend is partway through an update. Run `naro backend enable` to finish it, then try again.";
@@ -22171,7 +22612,7 @@ var OPERATORS = [
   "*",
   "-"
 ];
-function isSpace(char) {
+function isSpace2(char) {
   return char === " " || char === "	" || char === "\n" || char === "\r" || char === "\f";
 }
 function isIdentStart(char) {
@@ -22184,7 +22625,7 @@ function isDigit(char) {
   return char >= "0" && char <= "9";
 }
 var NUMBER = /^(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/;
-function tokenize(text2) {
+function tokenize2(text2) {
   const tokens = [];
   let index = 0;
   const at = (offset = 0) => text2.charAt(index + offset);
@@ -22193,7 +22634,7 @@ function tokenize(text2) {
     const position = index + 1;
     if (char === "\0")
       throw new PolicySyntaxError("NUL characters are not allowed", position);
-    if (isSpace(char)) {
+    if (isSpace2(char)) {
       index++;
       continue;
     }
@@ -22378,133 +22819,6 @@ var TokenStream = class {
   }
 };
 
-// ../../packages/data-core/src/collation.ts
-var COLLATIONS = ["BINARY", "NOCASE", "RTRIM"];
-function isSpace2(char) {
-  return char === " " || char === "	" || char === "\n" || char === "\f" || char === "\r";
-}
-function isWordChar(char) {
-  return /[A-Za-z0-9_$]/.test(char) || char.charCodeAt(0) >= 128;
-}
-function asciiUpper2(text2) {
-  return text2.replace(/[a-z]/g, (letter) => letter.toUpperCase());
-}
-function quoted(sql, start, close, doubles) {
-  let value = "";
-  for (let index = start + 1; index < sql.length; index++) {
-    const char = sql.charAt(index);
-    if (char !== close) {
-      value += char;
-      continue;
-    }
-    if (doubles && sql.charAt(index + 1) === close) {
-      value += close;
-      index++;
-      continue;
-    }
-    return { value, end: index + 1 };
-  }
-  return void 0;
-}
-function tokenize2(sql) {
-  const tokens = [];
-  let index = 0;
-  while (index < sql.length) {
-    const char = sql.charAt(index);
-    if (isSpace2(char)) {
-      index++;
-    } else if (char === "-" && sql.charAt(index + 1) === "-") {
-      const end = sql.indexOf("\n", index);
-      index = end < 0 ? sql.length : end + 1;
-    } else if (char === "/" && sql.charAt(index + 1) === "*") {
-      const end = sql.indexOf("*/", index + 2);
-      if (end < 0) return void 0;
-      index = end + 2;
-    } else if (char === '"' || char === "`" || char === "[" || char === "'") {
-      const close = char === "[" ? "]" : char;
-      const read = quoted(sql, index, close, char !== "[");
-      if (!read) return void 0;
-      tokens.push({
-        kind: char === "'" ? "string" : "name",
-        value: read.value
-      });
-      index = read.end;
-    } else if (char === "(" || char === ")" || char === ",") {
-      tokens.push({ kind: "punct", value: char });
-      index++;
-    } else if (isWordChar(char)) {
-      let end = index;
-      while (end < sql.length && isWordChar(sql.charAt(end))) end++;
-      tokens.push({ kind: "word", value: sql.slice(index, end) });
-      index = end;
-    } else {
-      tokens.push({ kind: "other", value: char });
-      index++;
-    }
-  }
-  return tokens;
-}
-function isWord2(token, word) {
-  return token?.kind === "word" && asciiLower(token.value) === word;
-}
-function definitions(tokens) {
-  const open = tokens.findIndex(
-    (token) => token.kind === "punct" && token.value === "("
-  );
-  if (open < 0) return void 0;
-  const found = [[]];
-  let depth = 0;
-  for (const token of tokens.slice(open + 1)) {
-    if (token.kind === "punct" && token.value === "(") depth++;
-    if (token.kind === "punct" && token.value === ")") {
-      if (depth === 0) return found;
-      depth--;
-    }
-    if (depth === 0 && token.kind === "punct" && token.value === ",") {
-      found.push([]);
-      continue;
-    }
-    found.at(-1)?.push(token);
-  }
-  return void 0;
-}
-function collationOf(definition) {
-  const named = [];
-  let depth = 0;
-  for (const [index, token] of definition.entries()) {
-    if (token.kind === "punct" && token.value === "(") depth++;
-    else if (token.kind === "punct" && token.value === ")") depth--;
-    else if (depth === 0 && index > 0 && isWord2(token, "collate")) {
-      const name = definition[index + 1];
-      if (!name || name.kind === "punct" || name.kind === "other") return null;
-      named.push(asciiUpper2(name.value));
-    }
-  }
-  if (named.length === 0) return "BINARY";
-  const [first] = named;
-  if (named.some((name) => name !== first)) return null;
-  return COLLATIONS.includes(first ?? "") ? first : null;
-}
-function declaredCollations(sql, columns) {
-  const unknown2 = columns.map(() => null);
-  if (typeof sql !== "string") return unknown2;
-  const tokens = tokenize2(sql);
-  if (!tokens || !isWord2(tokens[0], "create")) return unknown2;
-  const kind = isWord2(tokens[1], "temp") || isWord2(tokens[1], "temporary") ? tokens[2] : tokens[1];
-  if (!isWord2(kind, "table")) return unknown2;
-  const found = definitions(tokens);
-  if (!found || found.length < columns.length) return unknown2;
-  const collations = [];
-  for (const [index, column2] of columns.entries()) {
-    const definition = found[index] ?? [];
-    const name = definition[0];
-    if (!name || name.kind === "punct" || name.kind === "other" || asciiLower(name.value) !== asciiLower(column2))
-      return unknown2;
-    collations.push(collationOf(definition));
-  }
-  return collations;
-}
-
 // ../../packages/data-core/src/realtime-table.ts
 var REALTIME_MESSAGES = "realtime.messages";
 var REALTIME_MESSAGES_NAMES = ["messages", REALTIME_MESSAGES];
@@ -22582,6 +22896,9 @@ function columnAffinity(column2) {
     return "REAL";
   return "NUMERIC";
 }
+function isAnyType(type) {
+  return asciiLower(type.trim()) === "any";
+}
 function numberClass(type) {
   const affinity2 = columnAffinity({ type });
   if (affinity2 === "TEXT" || affinity2 === "BLOB") return void 0;
@@ -22783,6 +23100,9 @@ function utf8ByteLength(text2) {
 function quoteIdentifier(name) {
   return `"${name.replaceAll('"', '""')}"`;
 }
+function qualifiedColumn(table, column2) {
+  return `${quoteIdentifier(table)}.${quoteIdentifier(column2)}`;
+}
 var SIDE_BY_SIDE = 8;
 function joinConditions(terms, op) {
   if (terms.length <= SIDE_BY_SIDE) return `(${terms.join(` ${op} `)})`;
@@ -22874,6 +23194,11 @@ function refusesText(item, text2) {
 function readsAsIs(item, value) {
   return typeof value === "string" && numberClass(item.type) === "fallback" && !storesAsNumber(value);
 }
+function heldAsInteger(item, value) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value)) return false;
+  const affinity2 = columnAffinity(item);
+  return affinity2 === "INTEGER" || affinity2 === "NUMERIC";
+}
 function asStored(item, sql) {
   switch (columnAffinity(item)) {
     case "INTEGER":
@@ -22940,6 +23265,9 @@ function checkMarker(action, nonce, restrictive) {
 function schemaMarker(nonce) {
   return `json_extract('{}', 'naro:schema:${nonce}')`;
 }
+function captureMarker(nonce) {
+  return `json_extract('{}', 'naro:capture:${nonce}')`;
+}
 
 // ../../packages/data-core/src/policy-expr.ts
 var MAX_EXPRESSION_BYTES = 3 * 16384;
@@ -23867,7 +24195,7 @@ function checkExpressionSize(expr, position) {
 }
 function parseExpression(text2) {
   try {
-    const stream = new TokenStream(tokenize(text2));
+    const stream = new TokenStream(tokenize2(text2));
     if (stream.peek().kind === "eof")
       throw new PolicySyntaxError("the expression is empty", 1);
     const expr = readCondition(stream);
@@ -24879,8 +25207,36 @@ function policyInvalid(policy, action) {
     policy: policy.name
   });
 }
+var ROWID_NAMES = /* @__PURE__ */ new Set(["rowid", "oid", "_rowid_"]);
+function isRowidName(name) {
+  return ROWID_NAMES.has(asciiLower(name));
+}
+function noteRowidColumn(state, table, column2) {
+  const seen = state.rowidColumns.some(
+    (item) => asciiLower(item.table) === asciiLower(table) && asciiLower(item.column) === asciiLower(column2)
+  );
+  if (!seen) state.rowidColumns.push({ table, column: column2 });
+}
+function rowidColumnsGuard(columns) {
+  if (columns.length === 0) return null;
+  const terms = columns.map(
+    (item) => `EXISTS (SELECT 1 FROM pragma_table_xinfo(${quoteString(item.table)}) WHERE name = ${quoteString(item.column)} COLLATE NOCASE)`
+  );
+  return {
+    sql: terms.length === 1 ? terms[0] ?? "" : joinConditions(terms, "AND"),
+    params: []
+  };
+}
+function rowidGuarded(columns, fragment) {
+  const guard = rowidColumnsGuard(columns);
+  if (!guard) return fragment;
+  return {
+    sql: `(CASE WHEN ${guard.sql} THEN ${fragment.sql} ELSE 0 END)`,
+    params: [...guard.params, ...fragment.params]
+  };
+}
 function newState2() {
-  return { aliases: 0, subqueries: 0, depth: 0, active: [] };
+  return { aliases: 0, subqueries: 0, depth: 0, active: [], rowidColumns: [] };
 }
 function bind(env, value) {
   env.params.push(value);
@@ -24890,10 +25246,15 @@ function blamed(env, reason) {
   return fail(policyInvalid(env.blame.policy, env.blame.action), reason);
 }
 function storedSource(table, names, alias) {
+  const qualifier = alias ?? table.name;
   return {
     table,
     names,
-    read: (column2, _env, how) => alias !== null ? `${quoteIdentifier(alias)}.${quoteIdentifier(column2.name)}` : how.qualified ? `${quoteIdentifier(table.name)}.${quoteIdentifier(column2.name)}` : quoteIdentifier(column2.name),
+    read: (column2, env) => {
+      if (isRowidName(column2.name))
+        noteRowidColumn(env.state, table.name, column2.name);
+      return qualifiedColumn(qualifier, column2.name);
+    },
     operand: (column2) => ({
       stable: true,
       newColumnish: true,
@@ -24962,7 +25323,7 @@ function jwtValue(env, expr) {
   if (expr.op === "->") return bind(env, JSON.stringify(value));
   return bind(env, typeof value === "boolean" ? String(value) : value);
 }
-function valueSql(env, expr, textual = null) {
+function valueSql(env, expr, textual = null, exact = false, ordered = false) {
   switch (expr.kind) {
     case "literal":
       if (expr.value === null) return "NULL";
@@ -24972,8 +25333,9 @@ function valueSql(env, expr, textual = null) {
     case "realtime": {
       const { source, column: column2 } = columnOf(env, expr);
       return source.read(column2, env, {
-        qualified: env.scopes.length > 1,
-        textual
+        textual,
+        exact: textual === null && exact,
+        ...textual === null && ordered ? { ordered: true } : {}
       });
     }
     case "auth":
@@ -24984,7 +25346,10 @@ function valueSql(env, expr, textual = null) {
     case "func": {
       if (expr.name === "now") return "CURRENT_TIMESTAMP";
       if (expr.name === "coalesce") {
-        const args = expr.args.map((arg2) => valueSql(env, arg2, textual));
+        const one = expr.args.length === 1;
+        const args = expr.args.map(
+          (arg2) => valueSql(env, arg2, textual, exact, one && ordered)
+        );
         return args.length === 1 ? `(${String(args[0])})` : `coalesce(${args.join(", ")})`;
       }
       const [arg] = expr.args;
@@ -25008,7 +25373,7 @@ function columnOf(env, expr) {
   return expr.kind === "column" ? resolveColumn(env, expr) : realtimeTopic(env);
 }
 function pathArray(operand) {
-  return `('["' || replace(replace(${operand()}, '"', '\\"'), '/', '","') || '"]')`;
+  return `('[' || replace(json_quote(${operand()} || ''), '/', '","') || ']')`;
 }
 function storageHelperSql(fn, index, operand) {
   switch (fn) {
@@ -25039,10 +25404,7 @@ function storageCallSql(env, expr) {
   return storageHelperSql(
     expr.fn,
     index,
-    () => source.read(column2, env, {
-      qualified: env.scopes.length > 1,
-      textual: "textual"
-    })
+    () => source.read(column2, env, { textual: "textual" })
   );
 }
 function operandSide(env, value) {
@@ -25080,10 +25442,73 @@ var ARRAY_OPERATORS3 = {
   "<@": "containedBy",
   "&&": "overlaps"
 };
+function readsBack(env) {
+  return env.scopes.some((scope) => scope.readBack === true);
+}
+function textAffinity(env, value) {
+  const expr = comparedValue(value);
+  if (expr.kind === "cast") return true;
+  if (expr.kind !== "column" && expr.kind !== "realtime") return false;
+  try {
+    return columnAffinity(columnOf(env, expr).column) === "TEXT";
+  } catch {
+    return true;
+  }
+}
+function selectedTextAffinity(env, subquery) {
+  if (subquery.select === "*") return true;
+  const table = resolveSubqueryTable(env.snapshot, subquery.table);
+  if (!table) return true;
+  const source = storedSource(
+    table,
+    [asciiLower(subqueryName(subquery))],
+    null
+  );
+  return textAffinity(
+    { ...env, scopes: [...env.scopes, source] },
+    subquery.select
+  );
+}
+var ORDERING = /* @__PURE__ */ new Set(["<", "<=", ">", ">="]);
+function orderSafe(env, value) {
+  const expr = comparedValue(value);
+  switch (expr.kind) {
+    case "literal":
+      return typeof expr.value !== "string" || !storesAsNumber(expr.value);
+    case "func":
+      return expr.name === "now";
+    case "column": {
+      let column2;
+      try {
+        column2 = columnOf(env, expr).column;
+      } catch {
+        return false;
+      }
+      const kind = numberClass(column2.type);
+      return kind === "number" || kind === "fallback" && !isAnyType(column2.type);
+    }
+    default:
+      return false;
+  }
+}
 function comparison(env, left, op, right) {
-  const l = valueSql(env, left);
+  const back = readsBack(env);
+  const ordered = back && ORDERING.has(op);
+  const l = valueSql(
+    env,
+    left,
+    null,
+    back && !textAffinity(env, right),
+    ordered && !orderSafe(env, right)
+  );
   const collate = env.check ? checkCollation(env, operandSide(env, left), operandSide(env, right)) : "";
-  const r = valueSql(env, right);
+  const r = valueSql(
+    env,
+    right,
+    null,
+    back && !textAffinity(env, left),
+    ordered && !orderSafe(env, left)
+  );
   return `(${l}${collate} ${op} ${r})`;
 }
 function knownNullTest(env, expr) {
@@ -25128,22 +25553,36 @@ function conditionSql(env, expr) {
       if (untestable !== void 0) return blamed(env, untestable);
       const known = knownNullTest(env, expr);
       if (known !== void 0) return known;
-      const target2 = valueSql(env, expr.operand);
+      const target2 = valueSql(env, expr.operand, null, true);
       if (expr.value === null)
         return `(${target2} IS ${expr.not ? "NOT " : ""}NULL)`;
       const test = isBoolean(target2, expr.value);
       return expr.not ? `(NOT (${test}))` : `(${test})`;
     }
     case "in": {
-      const left = valueSql(env, expr.operand);
+      const left = valueSql(env, expr.operand, null, true);
       const collate = env.check ? checkCollation(env, operandSide(env, expr.operand), null) : "";
-      const list = expr.list.map((item) => valueSql(env, item));
+      const itemsExact = readsBack(env) && !textAffinity(env, expr.operand);
+      const list = expr.list.map(
+        (item) => valueSql(env, item, null, itemsExact)
+      );
       return `(${left}${collate} ${expr.not ? "NOT " : ""}IN (${list.join(", ")}))`;
     }
     case "inSelect": {
-      const left = valueSql(env, expr.operand);
+      const back = readsBack(env);
+      const left = valueSql(
+        env,
+        expr.operand,
+        null,
+        back && !selectedTextAffinity(env, expr.subquery)
+      );
       const leftSide = env.check ? operandSide(env, expr.operand) : null;
-      const sub = subquerySql(env, expr.subquery, "value");
+      const sub = subquerySql(
+        env,
+        expr.subquery,
+        "value",
+        back && !textAffinity(env, expr.operand)
+      );
       const collate = leftSide && sub.item ? checkCollation(env, leftSide, sub.item) : "";
       return `(${left}${collate} ${expr.not ? "NOT " : ""}IN (${sub.sql}))`;
     }
@@ -25180,7 +25619,7 @@ function conditionSql(env, expr) {
       return arraySql(
         () => (() => {
           const { source, column: column2 } = resolveColumn(env, expr.operand);
-          return source.read(column2, env, { qualified: true, textual: null });
+          return source.read(column2, env, { textual: null });
         })(),
         ARRAY_OPERATORS3[expr.op],
         values.length,
@@ -25192,7 +25631,7 @@ function conditionSql(env, expr) {
       return `(EXISTS (${subquerySql(env, expr.subquery, "one").sql}))`;
   }
 }
-function subquerySql(env, subquery, select) {
+function subquerySql(env, subquery, select, selectExact = false) {
   const table = resolveSubqueryTable(env.snapshot, subquery.table);
   if (!table) return blamed(env, unresolvedSubqueryReason(subquery.table));
   const { state } = env;
@@ -25217,7 +25656,7 @@ function subquerySql(env, subquery, select) {
     if (select === "value") {
       if (subquery.select === "*")
         return blamed(env, "IN (SELECT \u2026) selects one value, not *");
-      selected = valueSql(inner, subquery.select);
+      selected = valueSql(inner, subquery.select, null, selectExact);
       if (env.check) item = operandSide(inner, subquery.select);
     }
     const own2 = storedSource(table, ownNames(table), alias);
@@ -25570,7 +26009,9 @@ function selectCheckRefusal(path, column2, problem) {
     generated: `is not available: the select policy reads the generated column ${column2}, which a new row cannot be checked against`,
     collation: `is not available: the select policy reads ${column2}, whose collation naro cannot read, so a new row cannot be checked against it`,
     pattern: `is not available: the select policy compares the number column ${column2} with like or ilike, which a new row cannot be checked against`,
-    textual: `is not available: the select policy turns the number column ${column2} into text, which a new row cannot be checked against`
+    textual: `is not available: the select policy turns the number column ${column2} into text, which a new row cannot be checked against`,
+    readBack: `is not available: the select policy reads ${column2}, a number in a column that declares no number type, as text, which a new row cannot be checked against`,
+    orderedText: `is not available: the select policy orders ${column2}, text in a column of NUMERIC affinity, against what may read as a number, which a new row cannot be checked against`
   }[problem];
   return invalidQuery(path, reason);
 }
@@ -25632,6 +26073,15 @@ function decideQuery(context, query, policies, table) {
 var MAX_PARAMETERS = 100;
 var MAX_STATEMENT_BYTES = 1e5;
 var MAX_INSERT_STATEMENTS = 100;
+var MAX_CAPTURE_ROWS = 1e3;
+var MAX_CAPTURE_BYTES = 8388608;
+function triggersRead(table) {
+  const name = table.name;
+  return statement(
+    "SELECT sql, tbl_name = ? COLLATE NOCASE AS own FROM sqlite_master WHERE type = 'trigger' AND (tbl_name = ? COLLATE NOCASE OR instr(lower(sql), lower(?)) > 0 OR instr(lower(sql), lower(?)) > 0 OR instr(lower(sql), lower(?)) > 0)",
+    [name, name, name, name.replaceAll('"', '""'), name.replaceAll("`", "``")]
+  );
+}
 var OR_ABORT = "OR ABORT";
 function column(table, name) {
   return table.byName.get(asciiLower(name)) ?? fail(dataError("COLUMN_NOT_FOUND", { column: name, table: table.name }));
@@ -25647,7 +26097,13 @@ function columnList(table, names) {
   }
   return columns;
 }
-function selectList(columns) {
+function columnSql(table, item) {
+  return qualifiedColumn(table.name, item.name);
+}
+function outputList(table, columns) {
+  return columns.map((item) => columnSql(table, item)).join(", ");
+}
+function columnNames(columns) {
   return columns.map((item) => quoteIdentifier(item.name)).join(", ");
 }
 function returningClause(table, returning, action) {
@@ -25662,7 +26118,31 @@ function returningClause(table, returning, action) {
       )
     );
   const columns = returning === "*" ? table.columns : columnList(table, returning);
-  return ` RETURNING ${selectList(columns)}`;
+  return ` RETURNING ${outputList(table, columns)}`;
+}
+function writeReturning(table, returning, action, capture) {
+  const own2 = returningClause(table, returning, action);
+  return capture ? ` RETURNING ${outputList(table, table.columns)}` : own2;
+}
+function balancedSum(terms) {
+  if (terms.length === 0) return "0";
+  if (terms.length === 1) return terms[0] ?? "0";
+  const half = Math.ceil(terms.length / 2);
+  return `(${balancedSum(terms.slice(0, half))} + ${balancedSum(terms.slice(half))})`;
+}
+function boundBytes(value) {
+  return typeof value === "string" ? utf8ByteLength(value) : 8;
+}
+function captureGuard(table, where, params, nonce, set2) {
+  const bytes = balancedSum(
+    table.columns.map(
+      (item) => set2.has(item.name) ? String(boundBytes(set2.get(item.name) ?? null)) : `coalesce(length(CAST(${qualifiedColumn(table.name, item.name)} AS BLOB)), 8)`
+    )
+  );
+  return statement(
+    `SELECT CASE WHEN n > ${String(MAX_CAPTURE_ROWS)} OR b > ${String(MAX_CAPTURE_BYTES)} THEN ${captureMarker(nonce)} ELSE 1 END AS ok FROM (SELECT count(*) AS n, coalesce(sum(r), 0) AS b FROM (SELECT ${bytes} AS r FROM ${quoteIdentifier(table.name)}${where} LIMIT ${String(MAX_CAPTURE_ROWS + 1)}))`,
+    params
+  );
 }
 function scalar(value, path) {
   if (Array.isArray(value) || !isValue(value))
@@ -25683,7 +26163,7 @@ function arrayValues(value, path) {
 }
 function filterSql(table, filter, params, path) {
   const resolved = column(table, filter.column);
-  const target2 = quoteIdentifier(resolved.name);
+  const target2 = columnSql(table, resolved);
   const valuePath = `${path}.value`;
   switch (filter.operator) {
     case "eq":
@@ -25735,10 +26215,9 @@ function filterSql(table, filter, params, path) {
     case "containedBy":
     case "overlaps": {
       const values = arrayValues(filter.value, valuePath);
-      const qualified = `${quoteIdentifier(table.name)}.${target2}`;
       let next = 0;
       return arraySql(
-        () => qualified,
+        () => target2,
         filter.operator,
         values.length,
         () => {
@@ -25761,8 +26240,12 @@ function nodeSql(table, node, params, path) {
   );
   return joinConditions(terms, key === "or" ? "OR" : "AND");
 }
-function whereClause(table, filters, policy, params) {
+function whereClause(table, filters, policy, params, guard = null) {
   const parts = [];
+  if (guard) {
+    parts.push(guard.sql);
+    params.push(...guard.params);
+  }
   if (policy) {
     parts.push(policy.sql);
     params.push(...policy.params);
@@ -25778,7 +26261,7 @@ function orderClause(table, order) {
   const terms = order.map((term) => {
     const direction = term.ascending ? "ASC" : "DESC";
     const nulls = term.nullsFirst === void 0 ? "" : term.nullsFirst ? " NULLS FIRST" : " NULLS LAST";
-    return `${quoteIdentifier(column(table, term.column).name)} ${direction}${nulls}`;
+    return `${columnSql(table, column(table, term.column))} ${direction}${nulls}`;
   });
   return ` ORDER BY ${terms.join(", ")}`;
 }
@@ -25927,6 +26410,10 @@ function checkProblemReason(column2, problem) {
       return `${column2} is a number column, which a WITH CHECK cannot compare with LIKE or ILIKE`;
     case "textual":
       return `${column2} is a number column, which a WITH CHECK cannot turn into text (lower, upper, length, ::text)`;
+    case "readBack":
+      return `${column2} holds a number in a column that declares no number type, which a WITH CHECK cannot read as text (lower, upper, length, ::text, LIKE, or beside text)`;
+    case "orderedText":
+      return `${column2} holds text in a column of NUMERIC affinity (a date, uuid or json type), which a WITH CHECK cannot order against anything but a number, a number column or text that reads as no number (<, <=, >, >=, BETWEEN)`;
   }
 }
 function usingProblemReason(name, problem) {
@@ -25939,6 +26426,10 @@ function usingProblemReason(name, problem) {
       return `${name} is a number column, which a USING judged on a row's values cannot compare with LIKE or ILIKE`;
     case "textual":
       return `${name} is a number column, which a USING judged on a row's values cannot turn into text (lower, upper, length, ::text)`;
+    case "readBack":
+      return `${name} holds a number in a column that declares no number type, which a USING judged on a row's values cannot read as text (lower, upper, length, ::text, LIKE, or beside text)`;
+    case "orderedText":
+      return `${name} holds text in a column of NUMERIC affinity (a date, uuid or json type), which a USING judged on a row's values cannot order against anything but a number, a number column or text that reads as no number (<, <=, >, >=, BETWEEN)`;
   }
 }
 function isTrue(term) {
@@ -26347,6 +26838,19 @@ function schemaGuard(name, sql, kind, nonce) {
     policy: void 0
   };
 }
+function rowidTerm(table, state, nonce, kind) {
+  const own2 = newState2();
+  for (const item of table.columns)
+    if (isRowidName(item.name)) noteRowidColumn(own2, table.name, item.name);
+  for (const read of state.rowidColumns)
+    noteRowidColumn(own2, read.table, read.column);
+  const guard = rowidColumnsGuard(own2.rowidColumns);
+  return guard ? { ...guard, marker: schemaMarker(nonce), kind, policy: void 0 } : void 0;
+}
+function rowidWhere(table, state, nonce, kind) {
+  const term = rowidTerm(table, state, nonce, kind);
+  return term ? nestedChecks([term], { sql: "1", params: [] }) : null;
+}
 function nestedChecks(terms, pass) {
   let sql = pass.sql;
   let params = pass.params;
@@ -26374,11 +26878,15 @@ function usingFragment(target2, req, snapshot, commands, alias) {
     names: targetNames(target2),
     alias
   });
-  return rls.using(commands) ?? { sql: "1", params: [] };
+  return rowidGuarded(
+    rls.state.rowidColumns,
+    rls.using(commands) ?? { sql: "1", params: [] }
+  );
 }
-function rowSource(target2, row, action, stored) {
+function rowSource(target2, row, action, stored, readBack = false) {
   const { table } = target2;
   const kept = new Set(stored?.columns ?? []);
+  const strict = readBack ? declaresStrict(table.sql) : false;
   const storedRow = stored ? storedSource(table, targetNames(target2), stored.alias) : void 0;
   const source = {
     table,
@@ -26403,14 +26911,21 @@ function rowSource(target2, row, action, stored) {
           `the new row of ${target2.name} has no value for ${item.name}`
         );
       const bound = row[item.name] ?? null;
-      if (typeof bound === "string" && refusesText(item, bound))
+      const anyStrict = readBack && isAnyType(item.type) ? strict : false;
+      if (anyStrict !== true && typeof bound === "string" && refusesText(item, bound))
         fail(invalidQuery(`row.${item.name}`, mustBeNumber(action)));
+      if (readBack && typeof bound === "number" && (anyStrict === void 0 || (!isNumeric(item) || anyStrict) && how.exact !== true))
+        check2.problem(item.name, "readBack", env.blame.policy);
+      if (readBack && anyStrict !== true && how.ordered === true && readsAsIs(item, bound))
+        check2.problem(item.name, "orderedText", env.blame.policy);
       env.params.push(bound);
-      return readsAsIs(item, bound) ? "?" : asStored(item, "?");
+      if (anyStrict === true || readsAsIs(item, bound)) return "?";
+      return readBack && heldAsInteger(item, bound) ? "CAST(? AS INTEGER)" : asStored(item, "?");
     },
     // A stored column is the statement's own table's: SQLite compares it
     // with its own collation, the snapshot's — which the guard holds to.
-    operand: (item) => kept.has(item.name) ? { stable: true, newColumnish: true, newCollation: item.collation } : { stable: false, newColumnish: false, newCollation: null }
+    operand: (item) => kept.has(item.name) ? { stable: true, newColumnish: true, newCollation: item.collation } : { stable: false, newColumnish: false, newCollation: null },
+    ...readBack ? { readBack } : {}
   };
   return source;
 }
@@ -26450,7 +26965,17 @@ function checkFragment(target2, req, snapshot, command, row, nonce, stored, with
     () => false,
     () => false
   );
-  if (!source.storedRead || terms.length === 0) return terms;
+  if (terms.length === 0) return terms;
+  const rowid = rowidColumnsGuard(rls.state.rowidColumns);
+  const guards = rowid ? [
+    {
+      ...rowid,
+      marker: schemaMarker(checked),
+      kind: command,
+      policy: void 0
+    }
+  ] : [];
+  if (!source.storedRead) return [...guards, ...terms];
   const { name, sql } = target2.table;
   if (sql === null) {
     const first = terms.find((term) => term.policy !== void 0)?.policy;
@@ -26459,7 +26984,7 @@ function checkFragment(target2, req, snapshot, command, row, nonce, stored, with
       `naro cannot read the schema of ${target2.name}, so a check of the stored row cannot be guarded`
     );
   }
-  return [schemaGuard(name, sql, command, checked), ...terms];
+  return [schemaGuard(name, sql, command, checked), ...guards, ...terms];
 }
 var Unsupported = class extends Error {
   constructor(columnName, problem, policy) {
@@ -26469,9 +26994,15 @@ var Unsupported = class extends Error {
     this.policy = policy;
   }
 };
-function policyValue(target2, req, snapshot, command, row, nonce, state = newState2()) {
+function policyValue(target2, req, snapshot, command, row, nonce, state = newState2(), options = {}) {
   const checked = checkNonceOf(nonce, "policyValue");
-  const source = rowSource(target2, row, "insert", void 0);
+  const source = rowSource(
+    target2,
+    row,
+    "insert",
+    void 0,
+    options.readBack === true
+  );
   const rls = new Rls(
     req,
     snapshot,
@@ -26518,34 +27049,42 @@ function policyValue(target2, req, snapshot, command, row, nonce, state = newSta
   ].filter((term) => !isTrue(term));
   const [only] = kept;
   if (!only) return { ok: true, fragment: { sql: "1", params: [] } };
-  if (kept.length === 1) return { ok: true, fragment: only };
+  const read = state.rowidColumns;
+  if (kept.length === 1)
+    return { ok: true, fragment: rowidGuarded(read, only) };
   return {
     ok: true,
-    fragment: {
+    fragment: rowidGuarded(read, {
       sql: `(${kept.map((term) => term.sql).join(" AND ")})`,
       params: kept.flatMap((term) => term.params)
-    }
+    })
   };
 }
-function compileSelect(query, table, rls) {
+function compileSelect(query, table, rls, { state, nonce }) {
   if (query.columns !== "*" && query.columns.length === 0)
     fail(invalidQuery("columns", "must name at least one column"));
   const columns = query.columns === "*" ? table.columns : columnList(table, query.columns);
   const params = [];
   const policy = rls?.where("select") ?? null;
   if (rls && policy) rls.budget([policy]);
-  const where = whereClause(table, query.filters ?? [], policy, params);
+  const where = whereClause(
+    table,
+    query.filters ?? [],
+    policy,
+    params,
+    rowidWhere(table, state, nonce, "select")
+  );
   const order = orderClause(table, query.order ?? []);
   const limit = query.limit ?? MAX_LIMIT;
   params.push(query.single ? Math.min(limit, 2) : limit, query.offset ?? 0);
   return [
     statement(
-      `SELECT ${selectList(columns)} FROM ${quoteIdentifier(table.name)}${where}${order} LIMIT ? OFFSET ?`,
+      `SELECT ${outputList(table, columns)} FROM ${quoteIdentifier(table.name)}${where}${order} LIMIT ? OFFSET ?`,
       params
     )
   ];
 }
-function compileInsert(query, table, rls, nonce) {
+function compileInsert(query, table, rls, { state, nonce }, capture) {
   const uid = rls?.req.uid ?? null;
   const ownerInsert = rls?.ownerOnly("insert");
   const ownerRead = rls && query.returning !== void 0 ? rls.ownerOnly("select") : void 0;
@@ -26614,6 +27153,12 @@ function compileInsert(query, table, rls, nonce) {
         ]);
       }
     }
+    const rowid = rowidTerm(table, state, nonce, "insert");
+    if (rowid)
+      where = nestedChecks(
+        [rowid],
+        where ?? { sql: width === 0 ? "0" : "1", params: [] }
+      );
     const checkParams = where?.params ?? [];
     const room = MAX_PARAMETERS - checkParams.length;
     if (width > 0 && room < width) fail(dataError("TOO_MANY_PARAMETERS"));
@@ -26630,7 +27175,7 @@ function compileInsert(query, table, rls, nonce) {
       )
     );
   const into = `INSERT ${OR_ABORT} INTO ${quoteIdentifier(table.name)}`;
-  const returning = returningClause(table, query.returning, "insert");
+  const returning = writeReturning(table, query.returning, "insert", capture);
   if (rls) {
     for (const { group } of plans)
       for (const [row, values] of group.rows.entries())
@@ -26656,7 +27201,7 @@ function compileInsert(query, table, rls, nonce) {
       continue;
     }
     const tuple2 = `(${group.columns.map(() => "?").join(", ")})`;
-    const names = selectList(group.columns);
+    const names = columnNames(group.columns);
     for (let start = 0; start < group.rows.length; start += perStatement) {
       const chunk = group.rows.slice(start, start + perStatement);
       const values = chunk.map(() => tuple2).join(", ");
@@ -26673,7 +27218,7 @@ function compileInsert(query, table, rls, nonce) {
   }
   return statements;
 }
-function compileUpdate(query, table, context, rls, nonce) {
+function compileUpdate(query, table, context, rls, { state, nonce }, capture) {
   requireFilter(query, context);
   const values = assignments(table, query.values, "values");
   if (values.size === 0)
@@ -26711,8 +27256,9 @@ function compileUpdate(query, table, context, rls, nonce) {
     { sql: checkSql, params: terms.flatMap((term) => term.params) },
     ...policy ? [policy] : []
   ]);
-  const where = whereClause(table, query.filters ?? [], policy, params);
-  const returning = returningClause(table, query.returning, "update");
+  const rowid = rowidWhere(table, state, nonce, "update");
+  const where = whereClause(table, query.filters ?? [], policy, params, rowid);
+  const returning = writeReturning(table, query.returning, "update", capture);
   for (const item of values.values())
     rls?.refuseText(
       "update",
@@ -26720,63 +27266,170 @@ function compileUpdate(query, table, context, rls, nonce) {
       item.column,
       toBoundValue(item.value)
     );
-  return [
-    statement(
-      `UPDATE ${OR_ABORT} ${quoteIdentifier(table.name)} SET ${assigned.join(", ")}${where}${returning}`,
-      params
-    )
-  ];
+  const write = statement(
+    `UPDATE ${OR_ABORT} ${quoteIdentifier(table.name)} SET ${assigned.join(", ")}${where}${returning}`,
+    params
+  );
+  if (!capture) return { statements: [write], guard: null };
+  const guardParams = [];
+  const guardWhere = whereClause(
+    table,
+    query.filters ?? [],
+    policy,
+    guardParams,
+    rowid
+  );
+  const sent = new Map(
+    [...values.values()].map((item) => [
+      item.column.name,
+      toBoundValue(item.value)
+    ])
+  );
+  return {
+    statements: [write],
+    guard: captureGuard(table, guardWhere, guardParams, nonce, sent)
+  };
 }
-function compileDelete(query, table, context, rls) {
+function compileDelete(query, table, context, rls, { state, nonce }, capture) {
   requireFilter(query, context);
   const params = [];
   const policy = rls?.where("delete") ?? null;
   if (rls && policy) rls.budget([policy]);
-  const where = whereClause(table, query.filters ?? [], policy, params);
-  return [
-    statement(
-      `DELETE FROM ${quoteIdentifier(table.name)}${where}${returningClause(table, query.returning, "delete")}`,
-      params
-    )
-  ];
-}
-function compile(query, snapshot, decision, context, options = {}) {
-  const nonce = checkNonceOf(
-    options.checkNonce ?? DEFAULT_CHECK_NONCE,
-    "compile"
+  const rowid = rowidWhere(table, state, nonce, "select");
+  const where = whereClause(table, query.filters ?? [], policy, params, rowid);
+  const write = statement(
+    `DELETE FROM ${quoteIdentifier(table.name)}${where}${writeReturning(table, query.returning, "delete", capture)}`,
+    params
   );
-  if (!decision.allow)
-    return decision.reason === void 0 ? { ok: false, error: decision.error } : { ok: false, error: decision.error, reason: decision.reason };
-  const table = resolveTable(snapshot, query.table);
-  if (!table)
-    return {
-      ok: false,
-      error: dataError("TABLE_NOT_FOUND", { table: query.table })
-    };
+  if (!capture) return { statements: [write], guard: null };
+  const guardParams = [];
+  const guardWhere = whereClause(
+    table,
+    query.filters ?? [],
+    policy,
+    guardParams,
+    rowid
+  );
+  return {
+    statements: [write],
+    guard: captureGuard(table, guardWhere, guardParams, nonce, /* @__PURE__ */ new Map())
+  };
+}
+function ownReturning(table, query) {
+  if (query.action === "select" || query.returning === void 0) return null;
+  if (query.returning === "*") return table.columns.map((item) => item.name);
+  return columnList(table, query.returning).map((item) => item.name);
+}
+function bulkPlan(table) {
+  return {
+    columns: table.columns,
+    guard: null,
+    triggers: null,
+    returning: null,
+    bulk: true
+  };
+}
+function compileWith(query, snapshot, decision, context, table, nonce, capture) {
   try {
-    const rls = decision.rls ? new Rls(decision.rls, snapshot, table, nonce, commandsOf(query)) : void 0;
+    const state = newState2();
+    const rls = decision.rls ? new Rls(
+      decision.rls,
+      snapshot,
+      table,
+      nonce,
+      commandsOf(query),
+      void 0,
+      state
+    ) : void 0;
+    const statementContext = { state, nonce };
     let statements;
+    let guard = null;
     switch (query.action) {
       case "select":
-        statements = compileSelect(query, table, rls);
+        statements = compileSelect(query, table, rls, statementContext);
         break;
       case "insert":
-        statements = compileInsert(query, table, rls, nonce);
+        statements = compileInsert(
+          query,
+          table,
+          rls,
+          statementContext,
+          capture
+        );
         break;
       case "update":
-        statements = compileUpdate(query, table, context, rls, nonce);
+        ({ statements, guard } = compileUpdate(
+          query,
+          table,
+          context,
+          rls,
+          statementContext,
+          capture
+        ));
         break;
       case "delete":
-        statements = compileDelete(query, table, context, rls);
+        ({ statements, guard } = compileDelete(
+          query,
+          table,
+          context,
+          rls,
+          statementContext,
+          capture
+        ));
         break;
     }
-    return { ok: true, statements, restrictive: rls?.restrictive ?? [] };
+    const compiled = {
+      ok: true,
+      statements,
+      restrictive: rls?.restrictive ?? []
+    };
+    if (!capture) return compiled;
+    return {
+      ...compiled,
+      capture: {
+        columns: table.columns,
+        guard,
+        // A DELETE is judged on the row as it was before the write
+        // (original spec §8.5), which its RETURNING is.
+        triggers: query.action === "insert" || query.action === "update" ? triggersRead(table) : null,
+        returning: ownReturning(table, query),
+        bulk: false
+      }
+    };
   } catch (error51) {
     if (error51 instanceof Failure)
       return error51.reason === void 0 ? { ok: false, error: error51.error } : { ok: false, error: error51.error, reason: error51.reason };
     throw error51;
   }
 }
+function compile(query, snapshot, decision, context, options = {}) {
+  const nonce = checkNonceOf(
+    options.checkNonce ?? DEFAULT_CHECK_NONCE,
+    "compile"
+  );
+  if (!decision.allow)
+    return decision.reason === void 0 ? { ok: false, error: decision.error } : { ok: false, error: decision.error, reason: decision.reason };
+  const table = resolveTable(snapshot, query.table);
+  if (!table)
+    return {
+      ok: false,
+      error: dataError("TABLE_NOT_FOUND", { table: query.table })
+    };
+  if (options.capture !== true || query.action === "select")
+    return compileWith(query, snapshot, decision, context, table, nonce, false);
+  const captured = table.kind === "virtual" && query.action !== "insert" ? void 0 : compileWith(query, snapshot, decision, context, table, nonce, true);
+  if (captured?.ok) return captured;
+  const plain = compileWith(
+    query,
+    snapshot,
+    decision,
+    context,
+    table,
+    nonce,
+    false
+  );
+  return plain.ok ? { ...plain, capture: bulkPlan(table) } : plain;
+}
 
 // ../../packages/data-core/src/sql-depth.ts
 var D1_EXPRESSION_DEPTH = 100;
@@ -27550,6 +28203,231 @@ function expressionDepth(sql, { planner = true } = {}) {
   }
 }
 
+// ../../packages/data-core/src/sql-head.ts
+var HEAD_TOKENS = 12;
+var BOM2 = 65279;
+function isBlankStart(char) {
+  return char === " " || char === "	" || char === "\n" || char === "\f" || char === "\r";
+}
+function isBlank(char) {
+  return isBlankStart(char) || char === "\v";
+}
+function isWordStart2(char) {
+  return /[A-Za-z_]/.test(char) || char.charCodeAt(0) >= 128;
+}
+function isWordPart2(char) {
+  return /[A-Za-z0-9_$]/.test(char) || char.charCodeAt(0) >= 128;
+}
+function skipBlanks(text2, from) {
+  let index = from;
+  for (; ; ) {
+    const char = text2.charAt(index);
+    if (isBlankStart(char)) {
+      index++;
+      while (index < text2.length && isBlank(text2.charAt(index))) index++;
+    } else if (text2.charCodeAt(index) === BOM2) index++;
+    else if (char === "-" && text2.charAt(index + 1) === "-") {
+      const end = text2.indexOf("\n", index + 2);
+      index = end < 0 ? text2.length : end;
+    } else if (char === "/" && text2.charAt(index + 1) === "*") {
+      const end = text2.indexOf("*/", index + 2);
+      index = end < 0 ? text2.length : end + 2;
+    } else return index;
+  }
+}
+function readQuoted(text2, start, delimiter) {
+  let value = "";
+  let index = start + 1;
+  for (; ; ) {
+    const close = text2.indexOf(delimiter, index);
+    if (close < 0) return void 0;
+    value += text2.slice(index, close);
+    if (text2.charAt(close + 1) === delimiter) {
+      value += delimiter;
+      index = close + 2;
+      continue;
+    }
+    return { text: value, end: close + 1 };
+  }
+}
+function headTokens(text2) {
+  const tokens = [];
+  let index = 0;
+  while (tokens.length < HEAD_TOKENS) {
+    index = skipBlanks(text2, index);
+    const char = text2.charAt(index);
+    if (index >= text2.length) break;
+    if (char === '"' || char === "`" || char === "'") {
+      const quoted2 = readQuoted(text2, index, char);
+      if (!quoted2) break;
+      tokens.push({ kind: "name", text: quoted2.text });
+      index = quoted2.end;
+    } else if (char === "[") {
+      const close = text2.indexOf("]", index + 1);
+      if (close < 0) break;
+      tokens.push({ kind: "name", text: text2.slice(index + 1, close) });
+      index = close + 1;
+    } else if ((char === "x" || char === "X") && text2.charAt(index + 1) === "'") {
+      break;
+    } else if (isWordStart2(char)) {
+      let end = index + 1;
+      while (end < text2.length && isWordPart2(text2.charAt(end))) end++;
+      tokens.push({ kind: "word", text: text2.slice(index, end) });
+      index = end;
+    } else if (char === "." && !/[0-9]/.test(text2.charAt(index + 1))) {
+      tokens.push({ kind: "dot" });
+      index++;
+    } else break;
+  }
+  tokens.push({ kind: "stop" });
+  return tokens;
+}
+var OTHER = { kind: "other" };
+var NO_NAME = {
+  kind: "unreadable",
+  reason: "the table name could not be read"
+};
+var NO_COLUMN = {
+  kind: "unreadable",
+  reason: "the column name could not be read"
+};
+var OTHER_SCHEMA = {
+  kind: "unreadable",
+  reason: "a table in another schema"
+};
+var PUBLIC_SCHEMA = {
+  kind: "unreadable",
+  reason: 'SQLite has no schema "public": write the table name without "public."'
+};
+var Head = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  token(at) {
+    return this.tokens[Math.min(at, this.tokens.length - 1)] ?? { kind: "stop" };
+  }
+  /** The bare word `word` (lower case), in any ASCII case. */
+  is(at, word) {
+    const token = this.token(at);
+    return token.kind === "word" && asciiLower(token.text) === word;
+  }
+  nameAt(at) {
+    const token = this.token(at);
+    return token.kind === "word" || token.kind === "name" ? token.text : void 0;
+  }
+  /**
+   * SQLite's `fullname`. `main.` is the database a migration writes: the
+   * name goes without it, and `main` says it was written (known-issues
+   * #226); `temp.` (in any case, quoted or not, as sqlite3FindDbName
+   * matches it) is a table that goes with the connection; `public.` is
+   * what a Postgres migration writes, said in its own words; any other
+   * schema is one D1 does not have.
+   */
+  table(at) {
+    const first = this.nameAt(at);
+    if (first === void 0) return { ok: false, head: NO_NAME };
+    if (this.token(at + 1).kind !== "dot")
+      return { ok: true, name: first, next: at + 1, main: false };
+    const second = this.nameAt(at + 2);
+    if (second === void 0) return { ok: false, head: NO_NAME };
+    const schema = asciiLower(first);
+    if (schema === "main")
+      return { ok: true, name: second, next: at + 3, main: true };
+    let head = OTHER_SCHEMA;
+    if (schema === "temp") head = OTHER;
+    else if (schema === "public") head = PUBLIC_SCHEMA;
+    return { ok: false, head, next: at + 3 };
+  }
+};
+function inMain(read) {
+  return read.main ? { main: true } : {};
+}
+function readCreate(head) {
+  if (head.is(1, "policy")) return { kind: "create-policy" };
+  if (head.is(1, "temp") || head.is(1, "temporary")) return OTHER;
+  let at;
+  if (head.is(1, "table")) at = 2;
+  else if (head.is(1, "virtual") && head.is(2, "table")) at = 3;
+  else return OTHER;
+  if (head.is(at, "if")) {
+    if (!head.is(at + 1, "not") || !head.is(at + 2, "exists")) return NO_NAME;
+    at += 3;
+  }
+  const table = head.table(at);
+  return table.ok ? { kind: "create-table", table: table.name } : table.head;
+}
+function readDrop(head) {
+  if (head.is(1, "policy")) return { kind: "drop-policy" };
+  if (!head.is(1, "table")) return OTHER;
+  let at = 2;
+  if (head.is(at, "if")) {
+    if (!head.is(at + 1, "exists")) return NO_NAME;
+    at += 2;
+  }
+  const table = head.table(at);
+  return table.ok ? { kind: "drop-table", table: table.name, ...inMain(table) } : table.head;
+}
+var RLS_ACTIONS = ["enable", "disable", "force", "no"];
+function readRenameColumn(head, table, at) {
+  let from = at;
+  if (head.is(from, "column") && head.nameAt(from + 1) !== void 0 && head.is(from + 2, "to"))
+    from += 1;
+  const column2 = head.nameAt(from);
+  if (column2 === void 0 || !head.is(from + 1, "to")) return NO_COLUMN;
+  const to = head.nameAt(from + 2);
+  return to === void 0 ? NO_COLUMN : {
+    kind: "rename-column",
+    table: table.name,
+    column: column2,
+    to,
+    ...inMain(table)
+  };
+}
+function readAlter(head) {
+  if (head.is(1, "policy")) return { kind: "alter-policy" };
+  if (!head.is(1, "table")) return OTHER;
+  const sqlite = head.table(2);
+  const action = sqlite.next;
+  if (action !== void 0) {
+    if (head.is(action, "rename") && head.is(action + 1, "to")) {
+      if (!sqlite.ok) return sqlite.head;
+      const to = head.table(action + 2);
+      return to.ok ? {
+        kind: "rename-table",
+        table: sqlite.name,
+        to: to.name,
+        ...inMain(sqlite)
+      } : to.head;
+    }
+    if (head.is(action, "rename")) {
+      if (!sqlite.ok) return sqlite.head;
+      return readRenameColumn(head, sqlite, action + 1);
+    }
+    if (head.is(action, "add") || head.is(action, "drop"))
+      return sqlite.ok ? { kind: "alter-table", table: sqlite.name } : sqlite.head;
+  }
+  let at = 2;
+  if (head.is(at, "if") && head.is(at + 1, "exists")) at += 2;
+  if (head.is(at, "only")) at++;
+  const next = head.table(at).next;
+  if (next !== void 0 && RLS_ACTIONS.some((word) => head.is(next, word)))
+    return { kind: "rls" };
+  return sqlite.ok ? OTHER : sqlite.head;
+}
+function readSqlHead(text2) {
+  if (text2.includes("\0"))
+    return { kind: "unreadable", reason: "the statement has a NUL character" };
+  const head = new Head(headTokens(text2));
+  if (head.is(0, "create")) return readCreate(head);
+  if (head.is(0, "drop")) return readDrop(head);
+  if (head.is(0, "alter")) return readAlter(head);
+  if (head.is(0, "comment") && head.is(1, "on") && head.is(2, "policy"))
+    return { kind: "comment-policy" };
+  if (head.is(0, "grant")) return { kind: "grant" };
+  if (head.is(0, "revoke")) return { kind: "revoke" };
+  return OTHER;
+}
+
 // ../../packages/data-core/src/policy-index.ts
 var INDEX_SQL = `SELECT t.name AS table_name, il.name AS index_name, il."partial" AS partial, ix.name AS column_name, ix.coll AS collation FROM pragma_table_list AS t JOIN pragma_index_list(t.name, t.schema) AS il JOIN pragma_index_xinfo(il.name, t.schema) AS ix WHERE t.schema = 'main' AND t.type = 'table' AND ${systemTablePredicate("t.name")} AND ix.seqno = 0`;
 function indexesFromRows(rows) {
@@ -27826,8 +28704,34 @@ function unindexedSubqueries(snapshot, indexes, policies) {
   return found;
 }
 
+// ../../packages/data-core/src/realtime-filter.ts
+var FILTER_REASONS = {
+  bytes: "must be a string of up to 1024 bytes in UTF-8",
+  control: "must have no control character",
+  syntax: "supports eq, neq, lt, lte, gt, gte and in, one condition",
+  list: "needs in.(a,b) with 1 to 100 values"
+};
+
 // ../../packages/data-core/src/realtime-protocol.ts
 var REALTIME_PROTOCOL_VERSION = "1.0.0";
+var MAX_CHANGE_CHANNELS_PER_TABLE = 4;
+var JOIN_CONFIG_REASONS = {
+  object: "must be an object",
+  unsupported: "is not supported",
+  boolean: "must be true or false",
+  presenceKey: "must be 1 to 128 characters",
+  changes: "must be an array of up to 16 subscriptions",
+  changeEvent: "must be *, INSERT, UPDATE or DELETE",
+  schema: "must be public",
+  table: "must be a table name of 1 to 128 characters, or *",
+  filter: FILTER_REASONS.bytes,
+  filterControl: FILTER_REASONS.control,
+  filterSyntax: FILTER_REASONS.syntax,
+  filterList: FILTER_REASONS.list,
+  filterTable: "needs a table: a filter cannot go with *",
+  /** The hub's, after `config.postgres_changes[<i>].table` (3-2c-1): `MAX_CHANGE_CHANNELS_PER_TABLE` against the connection's joins. */
+  changeChannels: `would put more than ${String(MAX_CHANGE_CHANNELS_PER_TABLE)} channels of this connection on one table's changes (* counts for every table): add the subscription to a channel it already has`
+};
 var REALTIME_CLOSE = {
   UNSUPPORTED_PROTOCOL: {
     code: 4e3,
@@ -29018,7 +29922,7 @@ function readClause(stream) {
   checkExpressionSize(expr, open.position);
   return { text: printExpr(expr), position: open.position };
 }
-function readCreate(stream, start) {
+function readCreate2(stream, start) {
   stream.expectKeyword("policy");
   const name = readPolicyName(stream);
   stream.expectKeyword("on");
@@ -29078,7 +29982,7 @@ function readCreate(stream, start) {
     throw new PolicySyntaxError(problem.replace(/\.$/, ""), position);
   return { kind: "create", policy };
 }
-function readDrop(stream) {
+function readDrop2(stream) {
   stream.expectKeyword("policy");
   let ifExists = false;
   if (stream.acceptKeyword("if")) {
@@ -29109,11 +30013,11 @@ function parsePolicyStatement(text2) {
       position: 1
     };
   try {
-    const stream = new TokenStream(tokenize(text2));
+    const stream = new TokenStream(tokenize2(text2));
     const start = stream.next();
     let statement2;
-    if (isKeyword(start, "create")) statement2 = readCreate(stream, start);
-    else if (isKeyword(start, "drop")) statement2 = readDrop(stream);
+    if (isKeyword(start, "create")) statement2 = readCreate2(stream, start);
+    else if (isKeyword(start, "drop")) statement2 = readDrop2(stream);
     else if (isKeyword(start, "alter"))
       throw new PolicySyntaxError(
         "ALTER POLICY is not supported here yet: DROP POLICY and CREATE POLICY again",
@@ -29136,7 +30040,7 @@ function parsePolicyStatement(text2) {
 function splitPolicyStatements(text2) {
   let tokens;
   try {
-    tokens = tokenize(text2);
+    tokens = tokenize2(text2);
   } catch (error51) {
     if (error51 instanceof PolicySyntaxError)
       return { ok: false, reason: error51.reason, position: error51.position };
@@ -29225,7 +30129,7 @@ function parseMigrationPolicyStatement(text2) {
       position: 1
     };
   try {
-    const stream = new TokenStream(tokenize(text2));
+    const stream = new TokenStream(tokenize2(text2));
     let statement2;
     if (stream.acceptKeyword("comment")) statement2 = readComment(stream);
     else if (isKeyword(stream.peek(), "alter") && isKeyword(stream.peek(1), "table")) {
@@ -29242,230 +30146,11 @@ function parseMigrationPolicyStatement(text2) {
   }
 }
 
-// ../../packages/data-core/src/sql-head.ts
-var HEAD_TOKENS = 12;
-var BOM2 = 65279;
-function isBlankStart(char) {
-  return char === " " || char === "	" || char === "\n" || char === "\f" || char === "\r";
-}
-function isBlank(char) {
-  return isBlankStart(char) || char === "\v";
-}
-function isWordStart2(char) {
-  return /[A-Za-z_]/.test(char) || char.charCodeAt(0) >= 128;
-}
-function isWordPart2(char) {
-  return /[A-Za-z0-9_$]/.test(char) || char.charCodeAt(0) >= 128;
-}
-function skipBlanks(text2, from) {
-  let index = from;
-  for (; ; ) {
-    const char = text2.charAt(index);
-    if (isBlankStart(char)) {
-      index++;
-      while (index < text2.length && isBlank(text2.charAt(index))) index++;
-    } else if (text2.charCodeAt(index) === BOM2) index++;
-    else if (char === "-" && text2.charAt(index + 1) === "-") {
-      const end = text2.indexOf("\n", index + 2);
-      index = end < 0 ? text2.length : end;
-    } else if (char === "/" && text2.charAt(index + 1) === "*") {
-      const end = text2.indexOf("*/", index + 2);
-      index = end < 0 ? text2.length : end + 2;
-    } else return index;
-  }
-}
-function readQuoted(text2, start, delimiter) {
-  let value = "";
-  let index = start + 1;
-  for (; ; ) {
-    const close = text2.indexOf(delimiter, index);
-    if (close < 0) return void 0;
-    value += text2.slice(index, close);
-    if (text2.charAt(close + 1) === delimiter) {
-      value += delimiter;
-      index = close + 2;
-      continue;
-    }
-    return { text: value, end: close + 1 };
-  }
-}
-function headTokens(text2) {
-  const tokens = [];
-  let index = 0;
-  while (tokens.length < HEAD_TOKENS) {
-    index = skipBlanks(text2, index);
-    const char = text2.charAt(index);
-    if (index >= text2.length) break;
-    if (char === '"' || char === "`" || char === "'") {
-      const quoted2 = readQuoted(text2, index, char);
-      if (!quoted2) break;
-      tokens.push({ kind: "name", text: quoted2.text });
-      index = quoted2.end;
-    } else if (char === "[") {
-      const close = text2.indexOf("]", index + 1);
-      if (close < 0) break;
-      tokens.push({ kind: "name", text: text2.slice(index + 1, close) });
-      index = close + 1;
-    } else if ((char === "x" || char === "X") && text2.charAt(index + 1) === "'") {
-      break;
-    } else if (isWordStart2(char)) {
-      let end = index + 1;
-      while (end < text2.length && isWordPart2(text2.charAt(end))) end++;
-      tokens.push({ kind: "word", text: text2.slice(index, end) });
-      index = end;
-    } else if (char === "." && !/[0-9]/.test(text2.charAt(index + 1))) {
-      tokens.push({ kind: "dot" });
-      index++;
-    } else break;
-  }
-  tokens.push({ kind: "stop" });
-  return tokens;
-}
-var OTHER = { kind: "other" };
-var NO_NAME = {
-  kind: "unreadable",
-  reason: "the table name could not be read"
-};
-var NO_COLUMN = {
-  kind: "unreadable",
-  reason: "the column name could not be read"
-};
-var OTHER_SCHEMA = {
-  kind: "unreadable",
-  reason: "a table in another schema"
-};
-var PUBLIC_SCHEMA = {
-  kind: "unreadable",
-  reason: 'SQLite has no schema "public": write the table name without "public."'
-};
-var Head = class {
-  constructor(tokens) {
-    this.tokens = tokens;
-  }
-  token(at) {
-    return this.tokens[Math.min(at, this.tokens.length - 1)] ?? { kind: "stop" };
-  }
-  /** The bare word `word` (lower case), in any ASCII case. */
-  is(at, word) {
-    const token = this.token(at);
-    return token.kind === "word" && asciiLower(token.text) === word;
-  }
-  nameAt(at) {
-    const token = this.token(at);
-    return token.kind === "word" || token.kind === "name" ? token.text : void 0;
-  }
-  /**
-   * SQLite's `fullname`. `main.` is the database a migration writes: the
-   * name goes without it, and `main` says it was written (known-issues
-   * #226); `temp.` (in any case, quoted or not, as sqlite3FindDbName
-   * matches it) is a table that goes with the connection; `public.` is
-   * what a Postgres migration writes, said in its own words; any other
-   * schema is one D1 does not have.
-   */
-  table(at) {
-    const first = this.nameAt(at);
-    if (first === void 0) return { ok: false, head: NO_NAME };
-    if (this.token(at + 1).kind !== "dot")
-      return { ok: true, name: first, next: at + 1, main: false };
-    const second = this.nameAt(at + 2);
-    if (second === void 0) return { ok: false, head: NO_NAME };
-    const schema = asciiLower(first);
-    if (schema === "main")
-      return { ok: true, name: second, next: at + 3, main: true };
-    let head = OTHER_SCHEMA;
-    if (schema === "temp") head = OTHER;
-    else if (schema === "public") head = PUBLIC_SCHEMA;
-    return { ok: false, head, next: at + 3 };
-  }
-};
-function inMain(read) {
-  return read.main ? { main: true } : {};
-}
-function readCreate2(head) {
-  if (head.is(1, "policy")) return { kind: "create-policy" };
-  if (head.is(1, "temp") || head.is(1, "temporary")) return OTHER;
-  let at;
-  if (head.is(1, "table")) at = 2;
-  else if (head.is(1, "virtual") && head.is(2, "table")) at = 3;
-  else return OTHER;
-  if (head.is(at, "if")) {
-    if (!head.is(at + 1, "not") || !head.is(at + 2, "exists")) return NO_NAME;
-    at += 3;
-  }
-  const table = head.table(at);
-  return table.ok ? { kind: "create-table", table: table.name } : table.head;
-}
-function readDrop2(head) {
-  if (head.is(1, "policy")) return { kind: "drop-policy" };
-  if (!head.is(1, "table")) return OTHER;
-  let at = 2;
-  if (head.is(at, "if")) {
-    if (!head.is(at + 1, "exists")) return NO_NAME;
-    at += 2;
-  }
-  const table = head.table(at);
-  return table.ok ? { kind: "drop-table", table: table.name, ...inMain(table) } : table.head;
-}
-var RLS_ACTIONS = ["enable", "disable", "force", "no"];
-function readRenameColumn(head, table, at) {
-  let from = at;
-  if (head.is(from, "column") && head.nameAt(from + 1) !== void 0 && head.is(from + 2, "to"))
-    from += 1;
-  const column2 = head.nameAt(from);
-  if (column2 === void 0 || !head.is(from + 1, "to")) return NO_COLUMN;
-  const to = head.nameAt(from + 2);
-  return to === void 0 ? NO_COLUMN : {
-    kind: "rename-column",
-    table: table.name,
-    column: column2,
-    to,
-    ...inMain(table)
-  };
-}
-function readAlter(head) {
-  if (head.is(1, "policy")) return { kind: "alter-policy" };
-  if (!head.is(1, "table")) return OTHER;
-  const sqlite = head.table(2);
-  const action = sqlite.next;
-  if (action !== void 0) {
-    if (head.is(action, "rename") && head.is(action + 1, "to")) {
-      if (!sqlite.ok) return sqlite.head;
-      const to = head.table(action + 2);
-      return to.ok ? {
-        kind: "rename-table",
-        table: sqlite.name,
-        to: to.name,
-        ...inMain(sqlite)
-      } : to.head;
-    }
-    if (head.is(action, "rename")) {
-      if (!sqlite.ok) return sqlite.head;
-      return readRenameColumn(head, sqlite, action + 1);
-    }
-    if (head.is(action, "add") || head.is(action, "drop"))
-      return sqlite.ok ? { kind: "alter-table", table: sqlite.name } : sqlite.head;
-  }
-  let at = 2;
-  if (head.is(at, "if") && head.is(at + 1, "exists")) at += 2;
-  if (head.is(at, "only")) at++;
-  const next = head.table(at).next;
-  if (next !== void 0 && RLS_ACTIONS.some((word) => head.is(next, word)))
-    return { kind: "rls" };
-  return sqlite.ok ? OTHER : sqlite.head;
-}
-function readSqlHead(text2) {
-  if (text2.includes("\0"))
-    return { kind: "unreadable", reason: "the statement has a NUL character" };
-  const head = new Head(headTokens(text2));
-  if (head.is(0, "create")) return readCreate2(head);
-  if (head.is(0, "drop")) return readDrop2(head);
-  if (head.is(0, "alter")) return readAlter(head);
-  if (head.is(0, "comment") && head.is(1, "on") && head.is(2, "policy"))
-    return { kind: "comment-policy" };
-  if (head.is(0, "grant")) return { kind: "grant" };
-  if (head.is(0, "revoke")) return { kind: "revoke" };
-  return OTHER;
-}
+// ../../packages/data-core/src/realtime-publication.ts
+var REALTIME_TABLES = "_naro_realtime_tables";
+var REALTIME_TABLES_SQL = `CREATE TABLE IF NOT EXISTS ${REALTIME_TABLES} (table_name TEXT NOT NULL PRIMARY KEY COLLATE NOCASE, created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')))`;
+var MAX_PUBLISHED_TABLES = 100;
+var PUBLISHED_TABLES_SQL = `SELECT table_name FROM ${REALTIME_TABLES} ORDER BY rowid LIMIT ${String(MAX_PUBLISHED_TABLES)}`;
 
 // ../../packages/data-core/src/system-sql.ts
 async function convertLegacyPolicies(db, found) {
@@ -29500,6 +30185,7 @@ var MIGRATIONS_TABLE = "CREATE TABLE IF NOT EXISTS _naro_migrations (version INT
 var STORAGE_SUBQUERIES_VERSION = 7;
 var STORAGE_SUBQUERIES_NAME = "storage_subquery_policies";
 var STORAGE_SUBQUERIES_SQL = `SELECT version FROM _naro_migrations WHERE version = ${String(STORAGE_SUBQUERIES_VERSION)} AND name = '${STORAGE_SUBQUERIES_NAME}'`;
+var REALTIME_TABLES_VERSION = 8;
 var SYSTEM_MIGRATIONS = [
   {
     version: 1,
@@ -29588,6 +30274,14 @@ var SYSTEM_MIGRATIONS = [
     version: STORAGE_SUBQUERIES_VERSION,
     name: STORAGE_SUBQUERIES_NAME,
     statements: []
+  },
+  {
+    // Realtime 3-2b (original spec §9.1, design §7.1): the tables whose
+    // Data API writes reach the hub. Empty until the publish API (3-2c)
+    // writes it. A worker from before it never reads it.
+    version: REALTIME_TABLES_VERSION,
+    name: "realtime",
+    statements: [REALTIME_TABLES_SQL]
   }
 ];
 
@@ -29787,6 +30481,10 @@ var ENTERPRISE_REALTIME_LIMITS = Object.freeze({
   restRequestsPerSecond: 100
 });
 
+// ../../packages/data-core/src/realtime-changes.ts
+var CHANGE_TYPES = Object.freeze({ insert: "INSERT", update: "UPDATE", delete: "DELETE" });
+var CHANGE_EVENT_CODES = Object.freeze({ "*": 0, INSERT: 1, UPDATE: 2, DELETE: 3 });
+
 // ../../packages/data-core/src/redirect-origins.ts
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
   "localhost",
@@ -31628,6 +32326,7 @@ export {
   splitStatements,
   ANALYTICS_FILTER_KEYS,
   NaroError,
+  promoteTargetUnsupported,
   isNaroError,
   toNaroError,
   saveSession,
@@ -31661,11 +32360,11 @@ export {
   summarizeStatement,
   parseDotenvDetailed,
   serializeDotenv,
+  systemTablePredicate,
   MAX_SINGLE_UPLOAD_BYTES,
   checkObjectName,
   parseCacheControl,
   STORAGE_OBJECTS_TABLE,
-  systemTablePredicate,
   dataError,
   SCHEMA_SQL,
   tableNames,