naro-mcp 0.9.1 → 0.11.0

package/dist/index.js

@@ -1020,14 +1020,12 @@ var DbApi = class {
    * retrying rather than re-running the file blind.
    */
   async applyMigration(projectId, input) {
-    return this.client.request(
-      this.path(projectId, "/migrations"),
-      {
-        method: "POST",
-        body: { name: input.name, sql: input.sql },
-        context: "Apply migration"
-      }
-    );
+    const body = await this.client.request(this.path(projectId, "/migrations"), {
+      method: "POST",
+      body: { name: input.name, sql: input.sql },
+      context: "Apply migration"
+    });
+    return { ...body, warnings: body.warnings ?? [] };
   }
   /**
    * The current Time Travel bookmark, or the one `timestamp` (RFC 3339 with a
@@ -1142,7 +1140,10 @@ var DbApi = class {
    * `d1_migrations` — all operations or none. `dryRun` returns the SQL and
    * the name without applying anything. Save `sql` as `migrations/<name>` so
    * `naro db reset` re-applies it; a refused operation's index is in
-   * `details.operation`.
+   * `details.operation`. Policies left under a name the change gives to a
+   * table are removed before it runs and stay removed if it then fails:
+   * that refusal carries them in `details.removedPolicies`, shaped as the
+   * result's `removedPolicies`.
    */
   async schema(projectId, operations, options2 = {}) {
     return this.client.request(
@@ -1161,6 +1162,9 @@ var DbApi = class {
   }
 };
 var PROVISION_TIMEOUT_MS = 12e4;
+function writeQuery(options2) {
+  return options2.allowUnindexed === true ? "?allow_unindexed=1" : "";
+}
 function backendInfo(body) {
   return {
     status: body.status,
@@ -1179,6 +1183,35 @@ function backendInfo(body) {
     turningOff: body.turningOff === true
   };
 }
+function authConfig(body) {
+  return {
+    ...body,
+    signupsEnabled: typeof body.signupsEnabled === "boolean" ? body.signupsEnabled : true,
+    passwordMinLength: typeof body.passwordMinLength === "number" ? body.passwordMinLength : 6
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function authChange(answer) {
+  let body;
+  try {
+    body = await answer;
+  } catch (error51) {
+    const details = isNaroError(error51) ? error51.details : void 0;
+    if (isNaroError(error51) && error51.code === "BACKEND_PROVISION_FAILED" && isRecord(details?.auth) && isRecord(details.backend))
+      throw new NaroError(error51.code, error51.message, {
+        ...error51.status !== void 0 ? { status: error51.status } : {},
+        details: {
+          ...details,
+          auth: authConfig(details.auth),
+          backend: backendInfo(details.backend)
+        }
+      });
+    throw error51;
+  }
+  return { auth: authConfig(body.auth), backend: backendInfo(body.backend) };
+}
 var BackendApi = class {
   constructor(client) {
     this.client = client;
@@ -1311,11 +1344,13 @@ var BackendApi = class {
    * and the callback URLs to register with the providers. Never a secret.
    */
   async auth(projectId) {
-    return this.client.request(
-      this.path(projectId, "/auth"),
-      {
-        context: "Read sign-in settings"
-      }
+    return authConfig(
+      await this.client.request(
+        this.path(projectId, "/auth"),
+        {
+          context: "Read sign-in settings"
+        }
+      )
     );
   }
   /**
@@ -1324,34 +1359,93 @@ var BackendApi = class {
    * (nothing is saved), `BACKEND_NOT_READY` before the first provision,
    * `BACKEND_OFF` while the backend is turned off (nothing is saved),
    * `VERIFICATION_NEEDS_EMAIL` for a state where nobody could sign in. A
-   * failed upload is not an error — `backend.status` says `error` and the
-   * settings are saved; `enable` finishes. Two minutes, like enable.
+   * failed upload throws `BACKEND_PROVISION_FAILED` (502): the settings are
+   * saved, the message says whether the worker runs them yet, `details`
+   * holds `{ auth, backend }`, and `enable` finishes. (A control plane from
+   * before that resolves with `backend.status` `error` instead.) Two
+   * minutes, like enable.
    */
   async setAuth(projectId, patch) {
-    const answer = await this.client.request(
-      this.path(projectId, "/auth"),
-      {
+    return authChange(
+      this.client.request(this.path(projectId, "/auth"), {
         method: "PUT",
         body: patch,
         context: "Change sign-in settings",
         timeoutMs: PROVISION_TIMEOUT_MS
-      }
+      })
     );
-    return { auth: answer.auth, backend: backendInfo(answer.backend) };
   }
   /** Removes email or one provider; the same answer as `setAuth`. */
   async removeAuth(projectId, target) {
+    return authChange(
+      this.client.request(
+        this.path(projectId, `/auth?target=${encodeURIComponent(target)}`),
+        {
+          method: "DELETE",
+          context: "Change sign-in settings",
+          timeoutMs: PROVISION_TIMEOUT_MS
+        }
+      )
+    );
+  }
+  /**
+   * The project's users, newest first (spec 2026-09-26 §2.2): page 1 and 50
+   * a page unless given, at most 1000. `database.read`. `BACKEND_OFF` while
+   * the backend is turned off, `BACKEND_NOT_READY` before it is ready,
+   * `BACKEND_OUTDATED` while its Naro worker predates user management
+   * (`enable` updates it), `BACKEND_UNAVAILABLE` when it cannot be reached.
+   */
+  async listUsers(projectId, options2 = {}) {
+    const query = new URLSearchParams();
+    if (options2.page !== void 0) query.set("page", String(options2.page));
+    if (options2.perPage !== void 0)
+      query.set("perPage", String(options2.perPage));
+    const suffix = query.size > 0 ? `?${query.toString()}` : "";
+    const body = await this.client.request(
+      this.path(projectId, `/users${suffix}`),
+      { context: "List users" }
+    );
+    return { users: body.users, total: body.total };
+  }
+  /**
+   * Creates a user with a password, confirmed unless `emailConfirm: false`
+   * — also while sign-ups are closed and while sign-in waits for a
+   * confirmed email. A username-only user answers `email: null`.
+   * `database.write`. The Naro worker's refusals come through as it said
+   * them: `USERNAME_TAKEN` (409), `USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL`
+   * (422), `PASSWORD_TOO_SHORT` ("Use at least {n} characters."),
+   * `VALIDATION_ERROR`, `WRITE_QUOTA_EXCEEDED` (429, `details.retryAfter`).
+   */
+  async createUser(projectId, input) {
+    const body = { password: input.password };
+    if (input.email !== void 0) body.email = input.email;
+    if (input.username !== void 0) body.username = input.username;
+    if (input.emailConfirm !== void 0)
+      body.emailConfirm = input.emailConfirm;
     const answer = await this.client.request(
-      this.path(projectId, `/auth?target=${encodeURIComponent(target)}`),
-      {
-        method: "DELETE",
-        context: "Change sign-in settings",
-        timeoutMs: PROVISION_TIMEOUT_MS
-      }
+      this.path(projectId, "/users"),
+      { method: "POST", body, context: "Create user" }
+    );
+    return answer.user;
+  }
+  /**
+   * Deletes a user with its sign-in methods, and ends its sessions. Answers
+   * the user it was. `USER_NOT_FOUND` (404) for an id that is not one.
+   * `database.write`.
+   */
+  async deleteUser(projectId, userId) {
+    const answer = await this.client.request(
+      this.path(projectId, `/users/${encodeURIComponent(userId)}`),
+      { method: "DELETE", context: "Delete user" }
     );
-    return { auth: answer.auth, backend: backendInfo(answer.backend) };
+    return answer.user;
   }
-  /** Every stored policy, by table name. Tables without one deny anon and signed-in requests. */
+  /**
+   * Every table's policies as rules and conditions, one row per table —
+   * the view `setPolicy` writes through (P2-7 §11.2). A policy that view
+   * cannot show reads `{ invalid }`; `rlsPolicies` shows every one. Tables
+   * without one deny anon and signed-in requests.
+   */
   async policies(projectId) {
     const body = await this.client.request(
       this.path(projectId, "/policies"),
@@ -1375,8 +1469,9 @@ var BackendApi = class {
     return answer.policy;
   }
   /**
-   * Deletes the table's policy, so it denies anon and signed-in requests
-   * again. `POLICY_NOT_FOUND` when the table has none.
+   * Deletes every policy on the table (P2-7: the named ones too, whose
+   * names the answer's `policies` lists), so it denies anon and signed-in
+   * requests again. `POLICY_NOT_FOUND` when the table has none.
    */
   async removePolicy(projectId, table) {
     const answer = await this.client.request(
@@ -1385,6 +1480,75 @@ var BackendApi = class {
     );
     return answer.policy;
   }
+  /*
+   * ---- Named policies (spec 2026-09-24 P2-7 §11.1) ----
+   * As Postgres's CREATE POLICY: any number per table, each permissive or
+   * restrictive, for a command and roles, with USING and WITH CHECK
+   * expressions. The control plane checks them against the live schema
+   * with the worker's own compiler; the worker picks a change up within
+   * about 10 seconds.
+   *
+   * A write — `runPolicySql`, `replaceRlsPolicy`, `dropRlsPolicy`, and
+   * `setPolicy` above — on a backend turned on before named policies is
+   * `409 BACKEND_OUTDATED` "The project backend is older than named
+   * policies. Run `naro backend enable` to update it, then try again."
+   * (`backend.enable` also turns a backend that is off back on.) Reads
+   * and `removePolicy` work there.
+   */
+  /** The named policies, by table then name; only one table's with `table`. */
+  async rlsPolicies(projectId, options2 = {}) {
+    const query = options2.table === void 0 ? "" : `?table=${encodeURIComponent(options2.table)}`;
+    const body = await this.client.request(
+      this.path(projectId, `/rls/policies${query}`),
+      { context: "List policies" }
+    );
+    return body.policies;
+  }
+  /**
+   * Runs one CREATE POLICY or DROP POLICY statement. A statement that does
+   * not parse is `VALIDATION_FAILED` with Postgres's words and where
+   * ("syntax error at or near … at character N."); a policy already there
+   * is `POLICY_EXISTS`; DROP POLICY of none is `POLICY_NOT_FOUND` unless
+   * it says IF EXISTS.
+   */
+  async runPolicySql(projectId, sql, options2 = {}) {
+    const answer = await this.client.request(this.path(projectId, `/rls/policies${writeQuery(options2)}`), {
+      method: "POST",
+      body: { sql },
+      context: "Run policy statement"
+    });
+    return "policy" in answer ? { created: answer.policy } : { dropped: answer.dropped };
+  }
+  /**
+   * Replaces the named policy with a CREATE POLICY on the same table,
+   * which may rename it. `POLICY_NOT_FOUND` when there is none to replace.
+   * `name` is the name as typed: the policy of exactly that name, else the
+   * one of its ASCII lower case — what `CREATE POLICY MyPolicy` stored.
+   */
+  async replaceRlsPolicy(projectId, table, name, sql, options2 = {}) {
+    const answer = await this.client.request(
+      this.path(
+        projectId,
+        `${this.namedPath(table, name)}${writeQuery(options2)}`
+      ),
+      { method: "PUT", body: { sql }, context: "Replace policy" }
+    );
+    return answer.policy;
+  }
+  /**
+   * DROP POLICY: answers the policy dropped; `POLICY_NOT_FOUND` when none.
+   * `name` is the name as typed, as for `replaceRlsPolicy`.
+   */
+  async dropRlsPolicy(projectId, table, name) {
+    const answer = await this.client.request(
+      this.path(projectId, this.namedPath(table, name)),
+      { method: "DELETE", context: "Drop policy" }
+    );
+    return answer.policy;
+  }
+  namedPath(table, name) {
+    return `/rls/policies/${encodeURIComponent(table)}/${encodeURIComponent(name)}`;
+  }
 };
 
 // ../../packages/sdk/src/database.ts
@@ -1422,6 +1586,10 @@ var SYSTEM_TABLE_NAMES = ["d1_migrations"];
 function asciiLower(text) {
   return text.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(text) {
   return text.replace(/[\\%_]/g, (char) => `\\${char}`).replace(/'/g, "''");
 }
@@ -1441,8 +1609,252 @@ function systemTablePredicate(column = "name") {
 }
 var SYSTEM_TABLE_SQL_PREDICATE = systemTablePredicate("name");
 
-// ../../packages/data-core/src/query.ts
-var MAX_BODY_BYTES = 1024 * 1024;
+// ../../packages/data-core/src/d1.ts
+function rowsOf(result) {
+  const rows = result?.results ?? [];
+  return rows.filter(
+    (row) => typeof row === "object" && row !== null && !Array.isArray(row)
+  );
+}
+
+// ../../packages/data-core/src/policy-lexer.ts
+var PolicySyntaxError = class extends Error {
+  constructor(reason, position) {
+    super(`${reason} at character ${String(position)}`);
+    this.reason = reason;
+    this.position = position;
+  }
+};
+var OPERATORS = [
+  "->>",
+  "->",
+  "::",
+  "<>",
+  "!=",
+  "<=",
+  ">=",
+  "<@",
+  "@>",
+  "&&",
+  "(",
+  ")",
+  ",",
+  ".",
+  ";",
+  "=",
+  "<",
+  ">",
+  "[",
+  "]",
+  "*",
+  "-"
+];
+function isSpace(char) {
+  return char === " " || char === "	" || char === "\n" || char === "\r" || char === "\f";
+}
+function isIdentStart(char) {
+  return /[A-Za-z_]/.test(char) || char.charCodeAt(0) >= 128;
+}
+function isIdentChar(char) {
+  return /[A-Za-z0-9_$]/.test(char) || char.charCodeAt(0) >= 128;
+}
+function isDigit(char) {
+  return char >= "0" && char <= "9";
+}
+var NUMBER = /^(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?/;
+function tokenize(text) {
+  const tokens = [];
+  let index = 0;
+  const at = (offset = 0) => text.charAt(index + offset);
+  while (index < text.length) {
+    const char = at();
+    const position = index + 1;
+    if (char === "\0")
+      throw new PolicySyntaxError("NUL characters are not allowed", position);
+    if (isSpace(char)) {
+      index++;
+      continue;
+    }
+    if (char === "-" && at(1) === "-") {
+      while (index < text.length && at() !== "\n" && at() !== "\r") index++;
+      continue;
+    }
+    if (char === "/" && at(1) === "*") {
+      let depth = 0;
+      while (index < text.length) {
+        if (at() === "/" && at(1) === "*") {
+          depth++;
+          index += 2;
+        } else if (at() === "*" && at(1) === "/") {
+          depth--;
+          index += 2;
+          if (depth === 0) break;
+        } else index++;
+      }
+      if (depth !== 0)
+        throw new PolicySyntaxError("unterminated /* comment", position);
+      continue;
+    }
+    if (char === "'") {
+      let value = "";
+      index++;
+      for (; ; ) {
+        if (index >= text.length)
+          throw new PolicySyntaxError("unterminated quoted string", position);
+        if (at() === "'") {
+          if (at(1) === "'") {
+            value += "'";
+            index += 2;
+            continue;
+          }
+          index++;
+          break;
+        }
+        value += at();
+        index++;
+      }
+      tokens.push({ kind: "string", value, quoted: false, position });
+      continue;
+    }
+    if (char === '"') {
+      let value = "";
+      index++;
+      for (; ; ) {
+        if (index >= text.length)
+          throw new PolicySyntaxError(
+            "unterminated quoted identifier",
+            position
+          );
+        if (at() === '"') {
+          if (at(1) === '"') {
+            value += '"';
+            index += 2;
+            continue;
+          }
+          index++;
+          break;
+        }
+        value += at();
+        index++;
+      }
+      if (value === "")
+        throw new PolicySyntaxError("zero-length quoted identifier", position);
+      tokens.push({ kind: "ident", value, quoted: true, position });
+      continue;
+    }
+    if (char === "$")
+      throw new PolicySyntaxError(
+        "dollar-quoted strings are not supported: use '\u2026'",
+        position
+      );
+    if (isDigit(char) || char === "." && isDigit(at(1))) {
+      const match = NUMBER.exec(text.slice(index));
+      const value = match?.[0] ?? char;
+      index += value.length;
+      if (index < text.length && isIdentChar(at()))
+        throw new PolicySyntaxError(
+          `trailing junk after numeric literal ${value}`,
+          position
+        );
+      tokens.push({ kind: "number", value, quoted: false, position });
+      continue;
+    }
+    if (isIdentStart(char)) {
+      let end = index + 1;
+      while (end < text.length && isIdentChar(text.charAt(end))) end++;
+      const value = text.slice(index, end);
+      if (text.charAt(end) === "'")
+        throw new PolicySyntaxError(
+          `${value}'\u2026' strings are not supported: use a plain '\u2026' string`,
+          position
+        );
+      index = end;
+      tokens.push({ kind: "ident", value, quoted: false, position });
+      continue;
+    }
+    const operator = OPERATORS.find(
+      (candidate) => text.startsWith(candidate, index)
+    );
+    if (!operator)
+      throw new PolicySyntaxError(
+        `unexpected character ${JSON.stringify(char)}`,
+        position
+      );
+    index += operator.length;
+    tokens.push({ kind: "op", value: operator, quoted: false, position });
+  }
+  tokens.push({
+    kind: "eof",
+    value: "",
+    quoted: false,
+    position: text.length + 1
+  });
+  return tokens;
+}
+function isKeyword(token, word) {
+  return token !== void 0 && token.kind === "ident" && !token.quoted && asciiLower(token.value) === word;
+}
+function isOperator(token, op) {
+  return token !== void 0 && token.kind === "op" && token.value === op;
+}
+function describeToken(token) {
+  if (token.kind === "eof") return "end of input";
+  if (token.kind === "string") return `'${token.value}'`;
+  if (token.kind === "ident" && token.quoted) return `"${token.value}"`;
+  return `"${token.value}"`;
+}
+var TokenStream = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  #index = 0;
+  peek(offset = 0) {
+    const token = this.tokens[Math.min(this.#index + offset, this.tokens.length - 1)];
+    if (!token) throw new Error("TokenStream: no eof token");
+    return token;
+  }
+  next() {
+    const token = this.peek();
+    if (token.kind !== "eof") this.#index++;
+    return token;
+  }
+  /** Takes the keyword when it is next. */
+  acceptKeyword(word) {
+    if (!isKeyword(this.peek(), word)) return false;
+    this.next();
+    return true;
+  }
+  acceptOperator(op) {
+    if (!isOperator(this.peek(), op)) return false;
+    this.next();
+    return true;
+  }
+  expectKeyword(word) {
+    const token = this.peek();
+    if (!isKeyword(token, word))
+      throw new PolicySyntaxError(
+        `expected ${word.toUpperCase()}, found ${describeToken(token)}`,
+        token.position
+      );
+    return this.next();
+  }
+  expectOperator(op) {
+    const token = this.peek();
+    if (!isOperator(token, op))
+      throw new PolicySyntaxError(
+        `expected ${op}, found ${describeToken(token)}`,
+        token.position
+      );
+    return this.next();
+  }
+  /** Postgres's own words for anything else. */
+  unexpected(token = this.peek()) {
+    throw new PolicySyntaxError(
+      token.kind === "eof" ? "syntax error at end of input" : `syntax error at or near ${describeToken(token)}`,
+      token.position
+    );
+  }
+};
 
 // ../../packages/data-core/src/schema.ts
 var SCHEMA_SQL = [
@@ -1453,11 +1865,1763 @@ var SCHEMA_SQL = [
   // `sqlite_master` reads (the database routes' `_tables.ts` reads it too).
   `SELECT name AS table_name, sql AS table_sql FROM sqlite_master WHERE type = 'table' AND ${systemTablePredicate("name")}`
 ];
+var TABLE_NAMES_SQL = `SELECT name AS table_name FROM pragma_table_list WHERE schema = 'main' AND type IN ('table', 'virtual') AND ${systemTablePredicate("name")}`;
+function tableNamesFromRows(rows) {
+  const names = [];
+  for (const row of rows) {
+    const name = row.table_name;
+    if (typeof name === "string" && name !== "" && !isSystemTable(name))
+      names.push(name);
+  }
+  return names;
+}
+async function readTableNames(db) {
+  return tableNamesFromRows(rowsOf(await db.prepare(TABLE_NAMES_SQL).all()));
+}
+
+// ../../packages/data-core/src/values.ts
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isValue(value) {
+  return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+}
+function utf8ByteLength(text) {
+  let bytes = 0;
+  for (let index = 0; index < text.length; index++) {
+    const unit = text.charCodeAt(index);
+    if (unit < 128) bytes += 1;
+    else if (unit < 2048) bytes += 2;
+    else if (unit >= 55296 && unit <= 56319 && index + 1 < text.length) {
+      const next = text.charCodeAt(index + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        index++;
+      } else bytes += 3;
+    } else bytes += 3;
+  }
+  return bytes;
+}
+
+// ../../packages/data-core/src/sql-fragments.ts
+function globLiteral(char) {
+  return char === "*" || char === "?" || char === "[" ? `[${char}]` : char;
+}
+function likeToGlob(pattern) {
+  let glob = "";
+  for (let index = 0; index < pattern.length; index++) {
+    const char = pattern.charAt(index);
+    if (char === "\\" && index + 1 < pattern.length) {
+      index++;
+      glob += globLiteral(pattern.charAt(index));
+    } else if (char === "%") glob += "*";
+    else if (char === "_") glob += "?";
+    else glob += globLiteral(char);
+  }
+  return glob;
+}
+var MAX_PATTERN_BYTES = 50;
+function boundPattern(pattern, caseInsensitive) {
+  return caseInsensitive ? pattern : likeToGlob(pattern);
+}
+function patternTooLong(pattern, caseInsensitive) {
+  if (pattern.length > MAX_PATTERN_BYTES * 2) return true;
+  return utf8ByteLength(boundPattern(pattern, caseInsensitive)) > MAX_PATTERN_BYTES;
+}
+
+// ../../packages/data-core/src/policy-expr.ts
+var MAX_EXPRESSION_BYTES = 3 * 16384;
+var MAX_EXPRESSION_NODES = 1600;
+var MAX_EXPRESSION_DEPTH = 32;
+var MAX_SUBQUERIES = 4;
+var MAX_SUBQUERY_DEPTH = 2;
+var MAX_ARRAY_OPERATORS = 4;
+var MAX_POLICY_ARRAY_VALUES = 100;
+var MAX_IN_VALUES = 100;
+var MAX_POLICY_PATTERN_LENGTH = MAX_PATTERN_BYTES;
+var JWT_CLAIMS = ["sub", "role", "email", "email_verified"];
+var POLICY_FUNCTIONS = [
+  "lower",
+  "upper",
+  "length",
+  "coalesce",
+  "now"
+];
+var VALUE_KINDS = /* @__PURE__ */ new Set([
+  "literal",
+  "column",
+  "auth",
+  "jwt",
+  "func",
+  "cast"
+]);
+function isValueExpr(expr) {
+  return VALUE_KINDS.has(expr.kind);
+}
+function isConditionExpr(expr) {
+  if (!isValueExpr(expr)) return true;
+  if (expr.kind === "column") return true;
+  return expr.kind === "literal" && (expr.value === null || typeof expr.value === "boolean");
+}
+var RESERVED = /* @__PURE__ */ new Set([
+  "all",
+  "and",
+  "array",
+  "as",
+  "between",
+  "check",
+  "current_timestamp",
+  "distinct",
+  "exists",
+  "false",
+  "for",
+  `from`,
+  "ilike",
+  "in",
+  "is",
+  "like",
+  "not",
+  "null",
+  "on",
+  "or",
+  "select",
+  "to",
+  "true",
+  "using",
+  "where",
+  "with"
+]);
+var CLAUSE_WORDS = /* @__PURE__ */ new Set([
+  "join",
+  "group",
+  "order",
+  "limit",
+  "union",
+  "having",
+  "left",
+  "inner",
+  "cross"
+]);
+var SPECIAL_WORDS = /* @__PURE__ */ new Set([
+  ...RESERVED,
+  ...CLAUSE_WORDS,
+  "symmetric",
+  "auth"
+]);
+var TEXT_TYPES = /* @__PURE__ */ new Set(["text", "varchar", "uuid"]);
+function count(state, token) {
+  if (++state.nodes > MAX_EXPRESSION_NODES)
+    throw new PolicySyntaxError(
+      `the expression has more than ${String(MAX_EXPRESSION_NODES)} parts`,
+      token.position
+    );
+}
+function nested(state, token, read) {
+  if (++state.depth > MAX_EXPRESSION_DEPTH)
+    throw new PolicySyntaxError(
+      `the expression nests deeper than ${String(MAX_EXPRESSION_DEPTH)} levels`,
+      token.position
+    );
+  try {
+    return read();
+  } finally {
+    state.depth--;
+  }
+}
+function truthProblem(operand) {
+  const text = "is text, where 'true' reads as false";
+  switch (operand.kind) {
+    case "column":
+      return void 0;
+    case "literal":
+      return typeof operand.value === "string" ? `a '\u2026' string ${text}: write TRUE or FALSE, or compare the string with =` : void 0;
+    case "jwt": {
+      const claim = printValue(operand);
+      return `${claim} ${text}: compare it with text, ${claim} = 'true'`;
+    }
+    case "auth":
+      return operand.fn === "uid" ? "auth.uid() is text: compare it, auth.uid() = user_id, or test auth.uid() IS NOT NULL" : "auth.role() is text: compare it, auth.role() = 'authenticated'";
+    case "cast":
+      return `a ::text cast ${text}: compare it with text, (\u2026)::text = 'true'`;
+    case "func":
+      switch (operand.name) {
+        case "lower":
+        case "upper":
+          return `${operand.name}(\u2026) ${text}: compare it with text, ${operand.name}(\u2026) = 'true'`;
+        case "coalesce":
+          return "coalesce(\u2026) is not a boolean: compare it, coalesce(\u2026) = 'true'";
+        case "length":
+          return "length(\u2026) is a number: compare it, length(\u2026) > 0";
+        case "now":
+          return "now() is a time: compare it, created_at < now()";
+      }
+  }
+}
+function truthTestProblem(operand) {
+  const problem = truthProblem(operand);
+  return problem === void 0 ? void 0 : `IS TRUE and IS FALSE test a boolean, and ${problem}`;
+}
+function operandValues(operand) {
+  return operand.kind === "func" && operand.name === "coalesce" ? operand.args.flatMap(operandValues) : [operand];
+}
+function isBooleanConstant(value) {
+  return value.kind === "literal" && typeof value.value === "boolean";
+}
+function isTextValue(value) {
+  switch (value.kind) {
+    case "literal":
+      return typeof value.value === "string";
+    case "auth":
+    case "jwt":
+    case "cast":
+      return true;
+    case "func":
+      return value.name !== "length" && value.name !== "coalesce";
+    case "column":
+      return false;
+  }
+}
+function pair(left, right, inner = false) {
+  return { left, right, inner };
+}
+function comparedPairs(expr) {
+  switch (expr.kind) {
+    case "compare":
+    case "distinct":
+      return [pair(expr.left, expr.right)];
+    case "in":
+      return expr.list.map((item) => pair(expr.operand, item));
+    case "inSelect":
+      return expr.subquery.select === "*" ? [] : [pair(expr.operand, expr.subquery.select, true)];
+    case "between":
+      return [pair(expr.operand, expr.low), pair(expr.operand, expr.high)];
+    case "like":
+      return [pair(expr.operand, { kind: "literal", value: expr.pattern })];
+    default:
+      return [];
+  }
+}
+function booleanComparisonProblem(expr) {
+  for (const { left, right } of comparedPairs(expr)) {
+    const met = [...operandValues(left), ...operandValues(right)];
+    if (!met.some(isBooleanConstant)) continue;
+    const texts = met.filter(isTextValue);
+    const text = texts.find((value) => value.kind !== "literal") ?? texts[0];
+    if (text === void 0) continue;
+    const problem = text.kind === "literal" ? "a '\u2026' string is text, where 'true' reads as false: write TRUE or FALSE on both sides, or a '\u2026' string on both" : truthProblem(text);
+    return `a comparison with TRUE or FALSE compares a boolean, and ${String(problem)}`;
+  }
+  return void 0;
+}
+function comparable(expr, token) {
+  const problem = booleanComparisonProblem(expr);
+  if (problem !== void 0)
+    throw new PolicySyntaxError(problem, token.position);
+  return expr;
+}
+function requireCondition(expr, token) {
+  if (!isConditionExpr(expr)) {
+    const problem = isValueExpr(expr) ? truthProblem(expr) : void 0;
+    throw new PolicySyntaxError(
+      `this is a value, not a condition: ${problem ?? "compare it with =, IN, LIKE, IS \u2026 (a column alone reads as its truth value)"}`,
+      token.position
+    );
+  }
+  return expr;
+}
+function requireValue(expr, token) {
+  if (!isValueExpr(expr))
+    throw new PolicySyntaxError(
+      "a comparison compares values: combine conditions with AND, OR and NOT",
+      token.position
+    );
+  return expr;
+}
+function readOr(state) {
+  const first = state.stream.peek();
+  const args = [readAnd(state)];
+  while (isKeyword(state.stream.peek(), "or")) {
+    const token = state.stream.next();
+    count(state, token);
+    args.push(readAnd(state));
+  }
+  if (args.length === 1) return args[0];
+  for (const arg of args) requireCondition(arg, first);
+  return { kind: "or", args };
+}
+function readAnd(state) {
+  const first = state.stream.peek();
+  const args = [readNot(state)];
+  while (isKeyword(state.stream.peek(), "and")) {
+    const token = state.stream.next();
+    count(state, token);
+    args.push(readNot(state));
+  }
+  if (args.length === 1) return args[0];
+  for (const arg of args) requireCondition(arg, first);
+  return { kind: "and", args };
+}
+function readNot(state) {
+  const token = state.stream.peek();
+  if (isKeyword(token, "not")) {
+    state.stream.next();
+    count(state, token);
+    return nested(state, token, () => {
+      const inner = state.stream.peek();
+      return { kind: "not", arg: requireCondition(readNot(state), inner) };
+    });
+  }
+  return readPredicate(state);
+}
+function readPredicate(state) {
+  const { stream } = state;
+  const token = stream.peek();
+  if (isKeyword(token, "exists")) {
+    stream.next();
+    count(state, token);
+    stream.expectOperator("(");
+    const subquery = readSubquery(state, token, "exists");
+    stream.expectOperator(")");
+    return { kind: "exists", subquery };
+  }
+  const left = readValue(state);
+  const next = stream.peek();
+  const compare = ["=", "<>", "!=", "<", "<=", ">", ">="].find(
+    (op) => isOperator(next, op)
+  );
+  if (compare) {
+    stream.next();
+    count(state, next);
+    const right = readValue(state);
+    return comparable(
+      {
+        kind: "compare",
+        op: compare === "!=" ? "<>" : compare,
+        left: requireValue(left, token),
+        right: requireValue(right, next)
+      },
+      next
+    );
+  }
+  if (isKeyword(next, "is")) {
+    stream.next();
+    count(state, next);
+    const operand = requireValue(left, token);
+    const not2 = stream.acceptKeyword("not");
+    if (stream.acceptKeyword("null"))
+      return { kind: "is", not: not2, operand, value: null };
+    const truth = stream.acceptKeyword("true") ? true : stream.acceptKeyword("false") ? false : void 0;
+    if (truth !== void 0) {
+      const problem = truthTestProblem(operand);
+      if (problem !== void 0)
+        throw new PolicySyntaxError(problem, next.position);
+      return { kind: "is", not: not2, operand, value: truth };
+    }
+    if (stream.acceptKeyword("distinct")) {
+      stream.expectKeyword(`from`);
+      const right = requireValue(readValue(state), stream.peek());
+      return comparable({ kind: "distinct", not: not2, left: operand, right }, next);
+    }
+    stream.unexpected();
+  }
+  if (isOperator(next, "@>") || isOperator(next, "<@") || isOperator(next, "&&"))
+    return readArray(state, left, token);
+  let not = false;
+  let word = next;
+  if (isKeyword(next, "not")) {
+    const after = stream.peek(1);
+    if (isKeyword(after, "in") || isKeyword(after, "like") || isKeyword(after, "ilike") || isKeyword(after, "between")) {
+      stream.next();
+      not = true;
+      word = after;
+    } else return left;
+  }
+  if (isKeyword(word, "in")) {
+    stream.next();
+    count(state, word);
+    const operand = requireValue(left, token);
+    stream.expectOperator("(");
+    if (isKeyword(stream.peek(), "select")) {
+      const subquery = readSubquery(state, word, "in");
+      stream.expectOperator(")");
+      return comparable({ kind: "inSelect", not, operand, subquery }, word);
+    }
+    const list = [];
+    do {
+      if (list.length >= MAX_IN_VALUES)
+        throw new PolicySyntaxError(
+          `IN lists at most ${String(MAX_IN_VALUES)} values`,
+          stream.peek().position
+        );
+      const item = stream.peek();
+      list.push(requireValue(readValue(state), item));
+    } while (stream.acceptOperator(","));
+    stream.expectOperator(")");
+    return comparable({ kind: "in", not, operand, list }, word);
+  }
+  if (isKeyword(word, "like") || isKeyword(word, "ilike")) {
+    stream.next();
+    count(state, word);
+    const operand = requireValue(left, token);
+    const pattern = stream.peek();
+    if (pattern.kind !== "string")
+      throw new PolicySyntaxError(
+        "a LIKE or ILIKE pattern must be a '\u2026' string",
+        pattern.position
+      );
+    stream.next();
+    const ci = isKeyword(word, "ilike");
+    checkPattern(pattern, ci);
+    return comparable(
+      { kind: "like", not, ci, operand, pattern: pattern.value },
+      word
+    );
+  }
+  if (isKeyword(word, "between")) {
+    stream.next();
+    count(state, word);
+    const operand = requireValue(left, token);
+    if (stream.acceptKeyword("symmetric"))
+      throw new PolicySyntaxError(
+        "BETWEEN SYMMETRIC is not supported",
+        word.position
+      );
+    const low = requireValue(readValue(state), stream.peek());
+    stream.expectKeyword("and");
+    const high = requireValue(readValue(state), stream.peek());
+    return comparable({ kind: "between", not, operand, low, high }, word);
+  }
+  return left;
+}
+var PATTERN_SHOWN = 24;
+function policyPatternProblem(pattern, ci) {
+  if (!patternTooLong(pattern, ci)) return void 0;
+  const chars = [...pattern];
+  const shown = `${commentText(chars.slice(0, PATTERN_SHOWN).join(""))}${chars.length > PATTERN_SHOWN ? "\u2026" : ""}`;
+  const bytes = utf8ByteLength(boundPattern(pattern, ci));
+  return `${ci ? "an ILIKE" : "a LIKE"} pattern may be at most ${String(MAX_POLICY_PATTERN_LENGTH)} bytes of UTF-8, D1's limit, and '${shown}' is ${String(bytes)}${ci ? "" : " (LIKE counts each *, ? and [ as 3 bytes)"}`;
+}
+function checkPattern(token, ci) {
+  const pattern = token.value;
+  const problem = policyPatternProblem(pattern, ci);
+  if (problem !== void 0)
+    throw new PolicySyntaxError(problem, token.position);
+  let run = 0;
+  for (let index = pattern.length - 1; index >= 0; index--) {
+    if (pattern[index] !== "\\") break;
+    run++;
+  }
+  if (run % 2 === 1)
+    throw new PolicySyntaxError(
+      "a LIKE pattern must not end with an unescaped backslash",
+      token.position
+    );
+}
+function readArray(state, left, start) {
+  const { stream } = state;
+  const opToken = stream.next();
+  count(state, opToken);
+  if (left.kind !== "column")
+    throw new PolicySyntaxError(
+      `the left side of ${opToken.value} must be a column`,
+      start.position
+    );
+  if (++state.arrays > MAX_ARRAY_OPERATORS)
+    throw new PolicySyntaxError(
+      `an expression may use @>, <@ and && at most ${String(MAX_ARRAY_OPERATORS)} times`,
+      opToken.position
+    );
+  stream.expectKeyword("array");
+  stream.expectOperator("[");
+  const values = [];
+  do {
+    const item = stream.peek();
+    if (values.length >= MAX_POLICY_ARRAY_VALUES)
+      throw new PolicySyntaxError(
+        `ARRAY[\u2026] lists at most ${String(MAX_POLICY_ARRAY_VALUES)} values`,
+        item.position
+      );
+    const value = readValue(state);
+    if (value.kind === "auth" && value.fn === "uid") values.push(value);
+    else if (value.kind === "literal" && (typeof value.value === "string" || typeof value.value === "number"))
+      values.push(value.value);
+    else
+      throw new PolicySyntaxError(
+        "ARRAY[\u2026] holds strings, numbers and auth.uid()",
+        item.position
+      );
+  } while (stream.acceptOperator(","));
+  stream.expectOperator("]");
+  return {
+    kind: "array",
+    op: opToken.value,
+    operand: left,
+    values
+  };
+}
+function readSubquery(state, start, kind) {
+  const { stream } = state;
+  if (++state.subqueries > MAX_SUBQUERIES)
+    throw new PolicySyntaxError(
+      `an expression may have at most ${String(MAX_SUBQUERIES)} subqueries`,
+      start.position
+    );
+  if (++state.subqueryDepth > MAX_SUBQUERY_DEPTH)
+    throw new PolicySyntaxError(
+      `subqueries nest at most ${String(MAX_SUBQUERY_DEPTH)} deep`,
+      start.position
+    );
+  try {
+    stream.expectKeyword("select");
+    let select;
+    const item = stream.peek();
+    if (stream.acceptOperator("*")) {
+      if (kind === "in")
+        throw new PolicySyntaxError(
+          "IN (SELECT \u2026) selects one value, not *",
+          item.position
+        );
+      select = "*";
+    } else select = requireValue(readValue(state), item);
+    if (isOperator(stream.peek(), ","))
+      throw new PolicySyntaxError(
+        "a subquery here selects one value",
+        stream.peek().position
+      );
+    stream.expectKeyword(`from`);
+    const table = readTableName(stream);
+    let alias = null;
+    if (stream.acceptKeyword("as")) alias = readIdentifier(stream, "an alias");
+    else {
+      const next = stream.peek();
+      if (next.kind === "ident" && (next.quoted || !isReservedWord(next)))
+        alias = readIdentifier(stream, "an alias");
+    }
+    let where = null;
+    if (stream.acceptKeyword("where")) {
+      const token = stream.peek();
+      where = requireCondition(
+        nested(state, token, () => readOr(state)),
+        token
+      );
+    }
+    const after = stream.peek();
+    for (const word of ["join", "group", "order", "limit", "union", "having"])
+      if (isKeyword(after, word) || isOperator(after, ","))
+        throw new PolicySyntaxError(
+          "a subquery in a policy reads one table: SELECT \u2026 FROM t [alias] [WHERE \u2026]",
+          after.position
+        );
+    return { table, alias, select, where };
+  } finally {
+    state.subqueryDepth--;
+  }
+}
+function isReservedWord(token) {
+  return token.kind === "ident" && !token.quoted && (RESERVED.has(asciiLower(token.value)) || CLAUSE_WORDS.has(asciiLower(token.value)));
+}
+function readIdentifier(stream, what) {
+  const token = stream.peek();
+  if (token.kind !== "ident" || !token.quoted && isReservedWord(token))
+    throw new PolicySyntaxError(
+      `expected ${what}, found ${token.kind === "eof" ? "end of input" : JSON.stringify(token.value)}`,
+      token.position
+    );
+  stream.next();
+  return token.value;
+}
+function readTableName(stream) {
+  const first = stream.peek();
+  const name = readIdentifier(stream, "a table name");
+  if (!stream.acceptOperator(".")) return name;
+  if (first.quoted ? name !== "public" : asciiLower(name) !== "public")
+    throw new PolicySyntaxError(
+      `schema ${name} does not exist: naro's tables are in public`,
+      first.position
+    );
+  return readIdentifier(stream, "a table name");
+}
+function readNumber(token, negative) {
+  const value = Number(token.value) * (negative ? -1 : 1);
+  if (!Number.isFinite(value))
+    throw new PolicySyntaxError(
+      `${token.value} is out of range`,
+      token.position
+    );
+  if (/[.eE]/.test(token.value)) return { kind: "literal", value };
+  if (!Number.isSafeInteger(value))
+    throw new PolicySyntaxError(
+      `${token.value} is out of range: integers are at most 9007199254740991`,
+      token.position
+    );
+  return { kind: "literal", value: value === 0 ? 0 : value };
+}
+function readValue(state) {
+  const { stream } = state;
+  const token = stream.peek();
+  count(state, token);
+  let value = nested(state, token, () => readPrimary(state));
+  while (isOperator(stream.peek(), "::")) {
+    const cast = stream.next();
+    count(state, cast);
+    const type = stream.peek();
+    if (type.kind !== "ident" || type.quoted || !TEXT_TYPES.has(asciiLower(type.value)))
+      throw new PolicySyntaxError(
+        "casts are ::text, ::varchar and ::uuid (all read as text)",
+        type.position
+      );
+    stream.next();
+    value = { kind: "cast", operand: requireValue(value, token) };
+  }
+  return value;
+}
+function readAuth(state, start, allowBareJwt) {
+  const { stream } = state;
+  const name = stream.next();
+  const fn = name.kind === "ident" ? asciiLower(name.value) : "";
+  if (!isOperator(stream.peek(), "(")) {
+    if (fn === "uid" || fn === "role" || fn === "jwt")
+      throw new PolicySyntaxError(
+        `auth.${fn} needs parentheses: auth.${fn}()`,
+        start.position
+      );
+    throw new PolicySyntaxError(
+      `auth.${name.value} is not available: use auth.uid(), auth.role() or auth.jwt()`,
+      start.position
+    );
+  }
+  if (fn !== "uid" && fn !== "role" && fn !== "jwt")
+    throw new PolicySyntaxError(
+      `auth.${name.value}() is not available: use auth.uid(), auth.role() or auth.jwt()`,
+      start.position
+    );
+  stream.expectOperator("(");
+  stream.expectOperator(")");
+  if (fn !== "jwt") return { kind: "auth", fn };
+  const access = readJwtAccess(stream);
+  if (access) return access;
+  if (allowBareJwt) return "jwt";
+  throw new PolicySyntaxError(
+    "auth.jwt() is read one claim at a time: auth.jwt() ->> 'email'",
+    start.position
+  );
+}
+function readJwtAccess(stream) {
+  const arrow = stream.peek();
+  if (!isOperator(arrow, "->") && !isOperator(arrow, "->>")) return void 0;
+  stream.next();
+  const claim = stream.peek();
+  if (claim.kind !== "string")
+    throw new PolicySyntaxError(
+      "a claim is a '\u2026' string: auth.jwt() ->> 'email'",
+      claim.position
+    );
+  stream.next();
+  if (!JWT_CLAIMS.includes(claim.value))
+    throw new PolicySyntaxError(
+      `auth.jwt() has ${JWT_CLAIMS.slice(0, -1).join(", ")} and ${String(JWT_CLAIMS.at(-1))}; ${JSON.stringify(claim.value)} is not one of them`,
+      claim.position
+    );
+  const next = stream.peek();
+  if (isOperator(next, "->") || isOperator(next, "->>"))
+    throw new PolicySyntaxError(
+      "naro's auth.jwt() claims are not nested",
+      next.position
+    );
+  return {
+    kind: "jwt",
+    op: arrow.value,
+    claim: claim.value
+  };
+}
+function readPrimary(state) {
+  const { stream } = state;
+  const token = stream.next();
+  switch (token.kind) {
+    case "string":
+      return { kind: "literal", value: token.value };
+    case "number":
+      return readNumber(token, false);
+    case "op": {
+      if (token.value === "-") {
+        const number4 = stream.peek();
+        if (number4.kind !== "number")
+          throw new PolicySyntaxError(
+            "only a number can be negated",
+            token.position
+          );
+        stream.next();
+        return readNumber(number4, true);
+      }
+      if (token.value === "(") {
+        if (isKeyword(stream.peek(), "select")) {
+          const select = stream.next();
+          const auth = stream.peek();
+          if (!isKeyword(auth, "auth") || !isOperator(stream.peek(1), "."))
+            throw new PolicySyntaxError(
+              "a scalar subquery here must be (select auth.uid()), (select auth.role()) or (select auth.jwt() ->> '\u2026'): read other tables with EXISTS (\u2026) or IN (SELECT \u2026)",
+              select.position
+            );
+          stream.next();
+          stream.next();
+          const inner2 = readAuth(state, auth, true);
+          stream.expectOperator(")");
+          if (inner2 !== "jwt") return inner2;
+          const access = readJwtAccess(stream);
+          if (!access)
+            throw new PolicySyntaxError(
+              "auth.jwt() is read one claim at a time: (select auth.jwt()) ->> 'email'",
+              auth.position
+            );
+          return access;
+        }
+        const inner = readOr(state);
+        stream.expectOperator(")");
+        return inner;
+      }
+      return stream.unexpected(token);
+    }
+    case "ident": {
+      if (!token.quoted) {
+        const word = asciiLower(token.value);
+        if (word === "true") return { kind: "literal", value: true };
+        if (word === "false") return { kind: "literal", value: false };
+        if (word === "null") return { kind: "literal", value: null };
+        if (word === "current_timestamp")
+          return { kind: "func", name: "now", args: [] };
+        if (word === "auth" && isOperator(stream.peek(), ".")) {
+          stream.next();
+          const auth = readAuth(state, token, false);
+          if (auth === "jwt") return stream.unexpected();
+          return auth;
+        }
+        if (isOperator(stream.peek(), "(")) return readCall(state, token);
+        if (RESERVED.has(word)) return stream.unexpected(token);
+      }
+      if (isOperator(stream.peek(), ".")) {
+        stream.next();
+        const name = stream.peek();
+        if (name.kind !== "ident" || !name.quoted && isReservedWord(name))
+          return stream.unexpected(name);
+        stream.next();
+        if (isOperator(stream.peek(), "(") || isOperator(stream.peek(), "."))
+          throw new PolicySyntaxError(
+            `${token.value}.${name.value} is not a column: naro reads column or table.column`,
+            token.position
+          );
+        return { kind: "column", qualifier: token.value, name: name.value };
+      }
+      return { kind: "column", qualifier: null, name: token.value };
+    }
+    default:
+      return stream.unexpected(token);
+  }
+}
+function readCall(state, name) {
+  const { stream } = state;
+  const word = asciiLower(name.value);
+  if (!POLICY_FUNCTIONS.includes(word))
+    throw new PolicySyntaxError(
+      `function ${name.value} is not available in policies: use lower, upper, coalesce, length or now`,
+      name.position
+    );
+  stream.expectOperator("(");
+  const args = [];
+  if (!isOperator(stream.peek(), ")"))
+    do {
+      const item = stream.peek();
+      args.push(requireValue(readValue(state), item));
+    } while (stream.acceptOperator(","));
+  stream.expectOperator(")");
+  const arity = {
+    lower: [1, 1],
+    upper: [1, 1],
+    length: [1, 1],
+    coalesce: [1, 16],
+    now: [0, 0]
+  };
+  const [min, max] = arity[word];
+  if (args.length < min || args.length > max)
+    throw new PolicySyntaxError(
+      min === max ? `${word}() takes ${String(min)} argument${min === 1 ? "" : "s"}` : `${word}() takes ${String(min)} to ${String(max)} arguments`,
+      name.position
+    );
+  return { kind: "func", name: word, args };
+}
+function newState(stream) {
+  return {
+    stream,
+    nodes: 0,
+    depth: 0,
+    subqueries: 0,
+    subqueryDepth: 0,
+    arrays: 0
+  };
+}
+function readCondition(stream) {
+  const token = stream.peek();
+  const expr = readOr(newState(stream));
+  return requireCondition(expr, token);
+}
+function checkExpressionSize(expr, position) {
+  const text = printExpr(expr);
+  if (utf8ByteLength(text) > MAX_EXPRESSION_BYTES)
+    throw new PolicySyntaxError(
+      `the expression is longer than ${String(MAX_EXPRESSION_BYTES)} bytes`,
+      position
+    );
+  return text;
+}
+function parseExpression(text) {
+  try {
+    const stream = new TokenStream(tokenize(text));
+    if (stream.peek().kind === "eof")
+      throw new PolicySyntaxError("the expression is empty", 1);
+    const expr = readCondition(stream);
+    if (stream.peek().kind !== "eof") stream.unexpected();
+    return { ok: true, expr, text: checkExpressionSize(expr, 1) };
+  } catch (error51) {
+    if (error51 instanceof PolicySyntaxError)
+      return { ok: false, reason: error51.reason, position: error51.position };
+    throw error51;
+  }
+}
+function quoteIdent(name) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) && !SPECIAL_WORDS.has(asciiLower(name)) ? name : `"${name.replaceAll('"', '""')}"`;
+}
+function commentText(text) {
+  let out = "";
+  for (const char of text) {
+    const code = char.charCodeAt(0);
+    const control = code < 32 || code >= 127 && code <= 159 || code === 8232 || code === 8233;
+    out += control ? `\\u${code.toString(16).padStart(4, "0")}` : char;
+  }
+  return out;
+}
+function quoteString(text) {
+  return `'${text.replaceAll("'", "''")}'`;
+}
+function printNumber(value) {
+  if (Object.is(value, -0)) return "-0.0";
+  const text = String(value);
+  return Number.isSafeInteger(value) || /[.e]/.test(text) ? text : `${text}.0`;
+}
+function printLiteral(value) {
+  if (value === null) return "NULL";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") return printNumber(value);
+  return quoteString(value);
+}
+function printValue(expr) {
+  switch (expr.kind) {
+    case "literal":
+      return printLiteral(expr.value);
+    case "column":
+      return expr.qualifier === null ? quoteIdent(expr.name) : `${quoteIdent(expr.qualifier)}.${quoteIdent(expr.name)}`;
+    case "auth":
+      return `auth.${expr.fn}()`;
+    case "jwt":
+      return `(auth.jwt() ${expr.op} ${quoteString(expr.claim)})`;
+    case "func":
+      return expr.name === "now" ? "now()" : `${expr.name}(${expr.args.map(printValue).join(", ")})`;
+    case "cast":
+      return `(${printValue(expr.operand)})::text`;
+  }
+}
+function printSubquery(subquery) {
+  const select = subquery.select === "*" ? "*" : printValue(subquery.select);
+  const alias = subquery.alias === null ? "" : ` ${quoteIdent(subquery.alias)}`;
+  const where = subquery.where === null ? "" : ` WHERE ${printExpr(subquery.where)}`;
+  return `SELECT ${select} FROM ${quoteIdent(subquery.table)}${alias}${where}`;
+}
+function printElement(element) {
+  if (typeof element === "object") return printValue(element);
+  return typeof element === "number" ? printNumber(element) : quoteString(element);
+}
+function printExpr(expr) {
+  if (isValueExpr(expr)) return printValue(expr);
+  switch (expr.kind) {
+    case "and":
+    case "or":
+      return `(${expr.args.map(printExpr).join(expr.kind === "and" ? " AND " : " OR ")})`;
+    case "not":
+      return `(NOT ${printExpr(expr.arg)})`;
+    case "compare":
+      return `(${printValue(expr.left)} ${expr.op} ${printValue(expr.right)})`;
+    case "distinct":
+      return `(${printValue(expr.left)} IS ${expr.not ? "NOT " : ""}DISTINCT FROM ${printValue(expr.right)})`;
+    case "is":
+      return `(${printValue(expr.operand)} IS ${expr.not ? "NOT " : ""}${printLiteral(expr.value)})`;
+    case "in":
+      return `(${printValue(expr.operand)} ${expr.not ? "NOT " : ""}IN (${expr.list.map(printValue).join(", ")}))`;
+    case "inSelect":
+      return `(${printValue(expr.operand)} ${expr.not ? "NOT " : ""}IN (${printSubquery(expr.subquery)}))`;
+    case "like":
+      return `(${printValue(expr.operand)} ${expr.not ? "NOT " : ""}${expr.ci ? "ILIKE" : "LIKE"} ${quoteString(expr.pattern)})`;
+    case "between":
+      return `(${printValue(expr.operand)} ${expr.not ? "NOT " : ""}BETWEEN ${printValue(expr.low)} AND ${printValue(expr.high)})`;
+    case "array":
+      return `(${printValue(expr.operand)} ${expr.op} ARRAY[${expr.values.map(printElement).join(", ")}])`;
+    case "exists":
+      return `(EXISTS (${printSubquery(expr.subquery)}))`;
+  }
+}
+function unqualifiedInSubquery(expr) {
+  let found;
+  function value(node, inside) {
+    if (found !== void 0) return;
+    switch (node.kind) {
+      case "column":
+        if (inside && node.qualifier === null) found = node;
+        return;
+      case "func":
+        for (const arg of node.args) value(arg, inside);
+        return;
+      case "cast":
+        value(node.operand, inside);
+        return;
+      default:
+        return;
+    }
+  }
+  function subquery(node) {
+    if (node.select !== "*") value(node.select, true);
+    if (node.where !== null) visit(node.where, true);
+  }
+  function visit(node, inside) {
+    if (found !== void 0) return;
+    if (isValueExpr(node)) {
+      value(node, inside);
+      return;
+    }
+    switch (node.kind) {
+      case "and":
+      case "or":
+        for (const arg of node.args) visit(arg, inside);
+        return;
+      case "not":
+        visit(node.arg, inside);
+        return;
+      case "compare":
+      case "distinct":
+        value(node.left, inside);
+        value(node.right, inside);
+        return;
+      case "is":
+      case "like":
+      case "array":
+        value(node.operand, inside);
+        return;
+      case "in":
+        value(node.operand, inside);
+        for (const item of node.list) value(item, inside);
+        return;
+      case "between":
+        for (const item of [node.operand, node.low, node.high])
+          value(item, inside);
+        return;
+      case "inSelect":
+        value(node.operand, inside);
+        subquery(node.subquery);
+        return;
+      case "exists":
+        subquery(node.subquery);
+        return;
+    }
+  }
+  visit(expr, false);
+  return found;
+}
+function unqualifiedProblem(ref) {
+  const name = quoteIdent(ref.name);
+  return `column ${name} has no table or alias in front of it inside a subquery: naro policy create writes one on every column there, so that a column added to a table later cannot change which table the policy reads it from \u2014 drop the policy and create it again`;
+}
+
+// ../../packages/data-core/src/named-policy.ts
+var POLICY_COMMANDS = [
+  "all",
+  "select",
+  "insert",
+  "update",
+  "delete"
+];
+var POLICY_ROLES = ["anon", "authenticated"];
+var MAX_POLICY_NAME_LENGTH = 63;
+var MAX_POLICY_SQL_BYTES = 16 * 1024;
+function rolesText(roles) {
+  const set2 = new Set(roles);
+  if (set2.has("anon") && set2.has("authenticated")) return "public";
+  return set2.has("anon") ? "anon" : "authenticated";
+}
+function readRoles(names) {
+  const set2 = /* @__PURE__ */ new Set();
+  if (names.length === 0)
+    return { ok: false, reason: "Roles are public, anon and authenticated." };
+  for (const name of names) {
+    if (name === "public") {
+      set2.add("anon");
+      set2.add("authenticated");
+    } else if (name === "anon" || name === "authenticated") set2.add(name);
+    else
+      return {
+        ok: false,
+        reason: name === "service_role" ? "Roles are public, anon and authenticated: the service key skips every policy." : "Roles are public, anon and authenticated."
+      };
+  }
+  return { ok: true, roles: POLICY_ROLES.filter((role) => set2.has(role)) };
+}
+function policyShapeProblem(policy) {
+  const { name, command, using, check: check2 } = policy;
+  if (name === "" || [...name].length > MAX_POLICY_NAME_LENGTH || name.includes("\0"))
+    return `Policy names are 1 to ${String(MAX_POLICY_NAME_LENGTH)} characters.`;
+  const upper = command.toUpperCase();
+  if ((command === "select" || command === "delete") && check2 !== null)
+    return "WITH CHECK cannot be applied to SELECT or DELETE.";
+  if (command === "insert" && using !== null)
+    return "Only WITH CHECK expression allowed for INSERT.";
+  if ((command === "select" || command === "delete") && using === null)
+    return `A ${upper} policy needs USING (\u2026).`;
+  if (command === "insert" && check2 === null)
+    return "An INSERT policy needs WITH CHECK (\u2026).";
+  if (using === null && check2 === null)
+    return `${command === "all" ? "An ALL" : "An UPDATE"} policy needs USING (\u2026), WITH CHECK (\u2026) or both.`;
+  return void 0;
+}
+function ownerExpression(column) {
+  return printExpr({
+    kind: "compare",
+    op: "=",
+    left: { kind: "column", qualifier: null, name: column },
+    right: { kind: "auth", fn: "uid" }
+  });
+}
+function ownerClauses(column, command) {
+  const text = ownerExpression(column);
+  return command === "insert" ? { using: null, check: text } : { using: text, check: null };
+}
+var NAMED_POLICY_TABLE = "_naro_policies_v2";
+var NAMED_POLICY_TABLE_SQL = `CREATE TABLE IF NOT EXISTS ${NAMED_POLICY_TABLE} (table_name TEXT NOT NULL, name TEXT NOT NULL, kind TEXT NOT NULL DEFAULT 'permissive', command TEXT NOT NULL DEFAULT 'all', roles TEXT NOT NULL DEFAULT 'public', using_expr TEXT, check_expr TEXT, owner_column TEXT, created_at TEXT NOT NULL DEFAULT (datetime('now')), updated_at TEXT NOT NULL DEFAULT (datetime('now')), PRIMARY KEY (table_name, name))`;
+var NAMED_POLICY_SQL = {
+  list: `SELECT table_name, name, kind, command, roles, using_expr, check_expr, owner_column FROM ${NAMED_POLICY_TABLE} ORDER BY table_name, name`,
+  insert: `INSERT INTO ${NAMED_POLICY_TABLE} (table_name, name, kind, command, roles, using_expr, check_expr, owner_column) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+  replace: `UPDATE ${NAMED_POLICY_TABLE} SET table_name = ?, name = ?, kind = ?, command = ?, roles = ?, using_expr = ?, check_expr = ?, owner_column = ?, updated_at = datetime('now') WHERE table_name = ? AND name = ?`,
+  remove: `DELETE FROM ${NAMED_POLICY_TABLE} WHERE table_name = ? COLLATE NOCASE AND name = ?`,
+  removeTable: `DELETE FROM ${NAMED_POLICY_TABLE} WHERE table_name = ? COLLATE NOCASE`
+};
+function policyValues(policy) {
+  return [
+    policy.table,
+    policy.name,
+    policy.permissive ? "permissive" : "restrictive",
+    policy.command,
+    rolesText(policy.roles),
+    policy.using,
+    policy.check,
+    policy.owner
+  ];
+}
+function storedExpression(value, field) {
+  if (value === null || value === void 0) return { expr: null, text: null };
+  if (typeof value !== "string")
+    return { expr: null, text: null, problem: `${field} is not text` };
+  const parsed = parseExpression(value);
+  if (!parsed.ok)
+    return {
+      expr: null,
+      text: value,
+      problem: `${field}: ${parsed.reason} at character ${String(parsed.position)}`
+    };
+  const unbound = unqualifiedInSubquery(parsed.expr);
+  if (unbound !== void 0)
+    return {
+      expr: null,
+      text: value,
+      problem: `${field}: ${unqualifiedProblem(unbound)}`
+    };
+  return { expr: parsed.expr, text: parsed.text };
+}
+function loadPolicy(row, log) {
+  const table = row.table_name;
+  if (typeof table !== "string" || table === "") return void 0;
+  const problems = [];
+  const name = typeof row.name === "string" && row.name !== "" ? row.name : "(unnamed)";
+  if (name === "(unnamed)") problems.push("the name is missing");
+  const kind = row.kind;
+  if (kind !== "permissive" && kind !== "restrictive")
+    problems.push("kind is not permissive or restrictive");
+  const command = POLICY_COMMANDS.includes(row.command) ? row.command : void 0;
+  if (!command)
+    problems.push("command is not one of all, select, insert, update, delete");
+  const roles = typeof row.roles === "string" && ["public", "anon", "authenticated"].includes(row.roles) ? readRoles([row.roles]) : void 0;
+  if (!roles?.ok) problems.push("roles is not public, anon or authenticated");
+  const using = storedExpression(row.using_expr, "using");
+  const check2 = storedExpression(row.check_expr, "check");
+  if (using.problem) problems.push(using.problem);
+  if (check2.problem) problems.push(check2.problem);
+  const owner = row.owner_column;
+  const policy = {
+    table,
+    name,
+    permissive: kind !== "restrictive",
+    // What cannot be read applies everywhere: it refuses, never allows.
+    command: command ?? "all",
+    roles: roles?.ok ? roles.roles : [...POLICY_ROLES],
+    using: using.text,
+    check: check2.text,
+    owner: typeof owner === "string" ? owner : null,
+    invalid: null,
+    usingExpr: using.expr,
+    checkExpr: check2.expr
+  };
+  if (command && problems.length === 0) {
+    const shape = policyShapeProblem(policy);
+    if (shape) problems.push(shape);
+  }
+  if (policy.owner !== null && policy.owner !== "" && command && problems.length === 0) {
+    const expected = ownerClauses(policy.owner, command);
+    if (policy.using !== expected.using || policy.check !== expected.check)
+      problems.push(
+        "an owner policy's expressions are not its owner condition"
+      );
+  }
+  if (problems.length > 0) {
+    policy.invalid = problems.join("; ");
+    log?.(
+      `naro data-core: policy ${name} on ${table} cannot be read: ${policy.invalid}`
+    );
+  }
+  return policy;
+}
+
+// ../../packages/data-core/src/query.ts
+var FILTER_OPERATORS = [
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "is",
+  "like",
+  "ilike",
+  // Phase 2-1: for a TEXT column holding a JSON array (spec P2-1 §2).
+  "contains",
+  "containedBy",
+  "overlaps"
+];
+function isAuthUid(value) {
+  return isPlainObject(value) && Object.keys(value).length === 1 && Object.hasOwn(value, "auth") && value.auth === "uid";
+}
+var MAX_BODY_BYTES = 1024 * 1024;
+var MAX_FILTERS = 100;
+var MAX_FILTER_DEPTH = 4;
+var MAX_ARRAY_VALUES = 100;
+var MAX_ARRAY_CONDITIONS = 4;
+var ARRAY_OPERATORS = [
+  "contains",
+  "containedBy",
+  "overlaps"
+];
+function patternProblem(operator, pattern) {
+  if (!patternTooLong(pattern, operator === "ilike")) return void 0;
+  const limit = `must be at most ${String(MAX_PATTERN_BYTES)} bytes of UTF-8, D1's limit for a pattern`;
+  return operator === "ilike" ? limit : `${limit} (like counts each *, ? and [ as 3 bytes)`;
+}
+var MAX_IDENTIFIER_LENGTH = 128;
+var Invalid = class extends Error {
+  constructor(path, reason) {
+    super(reason);
+    this.path = path;
+    this.reason = reason;
+  }
+};
+function invalid(path, reason) {
+  throw new Invalid(path, reason);
+}
+function own(object2, key) {
+  return Object.hasOwn(object2, key) ? object2[key] : void 0;
+}
+function isOperator2(value) {
+  return FILTER_OPERATORS.includes(value);
+}
+function readObject(value, path) {
+  if (!isPlainObject(value)) invalid(path, "must be an object");
+  return value;
+}
+function checkKeys(object2, allowed, path) {
+  for (const key of Object.keys(object2)) {
+    if (allowed.includes(key)) continue;
+    if (longerThan(key, MAX_IDENTIFIER_LENGTH))
+      invalid(path, "has a field that is not a known field");
+    invalid(path ? `${path}.${key}` : key, "is not a known field");
+  }
+}
+function readName(value, path) {
+  if (typeof value !== "string" || value === "")
+    invalid(path, "must be a non-empty string");
+  if (longerThan(value, MAX_IDENTIFIER_LENGTH))
+    invalid(
+      path,
+      `must be at most ${String(MAX_IDENTIFIER_LENGTH)} characters`
+    );
+  return value;
+}
+function readValue2(value, path, auth = false) {
+  if (auth && isAuthUid(value)) return { auth: "uid" };
+  if (!isValue(value))
+    invalid(
+      path,
+      auth ? 'must be a string, a finite number, a boolean, null or {"auth":"uid"}' : "must be a string, a finite number, a boolean or null"
+    );
+  return value;
+}
+function longerThan(text, max) {
+  if (text.length <= max) return false;
+  if (text.length > max * 2) return true;
+  let count2 = 0;
+  for (const _ of text) if (++count2 > max) return true;
+  return false;
+}
+function endsWithLoneEscape(pattern) {
+  let run = 0;
+  for (let index = pattern.length - 1; index >= 0; index--) {
+    if (pattern[index] !== "\\") break;
+    run++;
+  }
+  return run % 2 === 1;
+}
+function readFilter(value, path, auth) {
+  const object2 = readObject(value, path);
+  checkKeys(object2, ["operator", "column", "value"], path);
+  const operator = own(object2, "operator");
+  if (!isOperator2(operator))
+    invalid(
+      `${path}.operator`,
+      `must be one of ${FILTER_OPERATORS.join(", ")}`
+    );
+  const column = readName(own(object2, "column"), `${path}.column`);
+  if (!Object.hasOwn(object2, "value")) invalid(`${path}.value`, "is required");
+  const raw = own(object2, "value");
+  const valuePath = `${path}.value`;
+  switch (operator) {
+    case "in": {
+      if (!Array.isArray(raw)) invalid(valuePath, "must be an array");
+      const values = raw.map(
+        (item, index) => readValue2(item, `${valuePath}[${index}]`, auth)
+      );
+      return { operator, column, value: values };
+    }
+    case "is":
+      if (raw !== null && raw !== true && raw !== false)
+        invalid(valuePath, "must be null, true or false");
+      return { operator, column, value: raw };
+    case "like":
+    case "ilike": {
+      if (typeof raw !== "string") invalid(valuePath, "must be a string");
+      const tooLong = patternProblem(operator, raw);
+      if (tooLong !== void 0) invalid(valuePath, tooLong);
+      if (raw.includes("\0"))
+        invalid(valuePath, "must not contain a NUL character");
+      if (endsWithLoneEscape(raw))
+        invalid(valuePath, "must not end with an unescaped backslash");
+      return { operator, column, value: raw };
+    }
+    case "contains":
+    case "containedBy":
+    case "overlaps":
+      if (!Array.isArray(raw) || raw.length === 0 || raw.length > MAX_ARRAY_VALUES || !raw.every(
+        (item) => typeof item === "string" || typeof item === "number" && Number.isFinite(item) || auth && isAuthUid(item)
+      ))
+        invalid(
+          valuePath,
+          auth ? `must be a non-empty array of strings, numbers and {"auth":"uid"} (at most ${String(MAX_ARRAY_VALUES)})` : `must be a non-empty array of strings and numbers (at most ${String(MAX_ARRAY_VALUES)})`
+        );
+      return {
+        operator,
+        column,
+        value: raw.map(
+          (item) => isAuthUid(item) ? { auth: "uid" } : item
+        )
+      };
+    default:
+      return { operator, column, value: readValue2(raw, valuePath, auth) };
+  }
+}
+var NODE_KEYS = ["operator", "or", "and", "not"];
+function readNode(value, path, depth, budget) {
+  const object2 = readObject(value, path);
+  const kinds = NODE_KEYS.filter((key) => Object.hasOwn(object2, key));
+  const [kind] = kinds;
+  if (kinds.length !== 1 || kind === void 0)
+    invalid(path, `needs exactly one of ${NODE_KEYS.join(", ")}`);
+  if (kind === "operator") {
+    if (++budget.conditions > MAX_FILTERS)
+      invalid(budget.path, `has more than ${String(MAX_FILTERS)} conditions`);
+    const filter = readFilter(object2, path, budget.auth);
+    if (ARRAY_OPERATORS.includes(filter.operator) && ++budget.arrays > MAX_ARRAY_CONDITIONS)
+      invalid(
+        budget.path,
+        `has more than ${String(MAX_ARRAY_CONDITIONS)} ${ARRAY_OPERATORS.join("/")} conditions`
+      );
+    return filter;
+  }
+  if (depth >= MAX_FILTER_DEPTH)
+    invalid(path, `nests deeper than ${String(MAX_FILTER_DEPTH)} groups`);
+  checkKeys(object2, [kind], path);
+  const inner = own(object2, kind);
+  const innerPath = `${path}.${kind}`;
+  if (kind === "not")
+    return { not: readNode(inner, innerPath, depth + 1, budget) };
+  if (!Array.isArray(inner)) invalid(innerPath, "must be an array");
+  if (inner.length === 0) invalid(innerPath, "must not be empty");
+  const children = inner.map(
+    (child, index) => readNode(child, `${innerPath}[${index}]`, depth + 1, budget)
+  );
+  return kind === "or" ? { or: children } : { and: children };
+}
+function parsePolicyNode(value, path) {
+  try {
+    const budget = { path, conditions: 0, arrays: 0, auth: true };
+    return { ok: true, node: readNode(value, path, 0, budget) };
+  } catch (error51) {
+    if (error51 instanceof Invalid)
+      return { ok: false, path: error51.path, reason: error51.reason };
+    throw error51;
+  }
+}
 
 // ../../packages/data-core/src/condition.ts
+var CONDITION_RULE = "condition";
 var MAX_CONDITION_BYTES = 16 * 1024;
+var TREES = {
+  select: ["using"],
+  delete: ["using"],
+  insert: ["check"],
+  update: ["using", "check"]
+};
+function parseCondition(action, value) {
+  if (!isPlainObject(value))
+    return { ok: false, path: "", reason: "must be an object" };
+  const trees = TREES[action];
+  for (const key of Object.keys(value))
+    if (key !== "role" && !trees.includes(key))
+      return key.length > MAX_IDENTIFIER_LENGTH ? {
+        ok: false,
+        path: "",
+        reason: "has a field that is not a known field"
+      } : { ok: false, path: key, reason: "is not a known field" };
+  const condition = {};
+  if (Object.hasOwn(value, "role")) {
+    const role = value.role;
+    if (role !== "any" && role !== "authenticated")
+      return {
+        ok: false,
+        path: "role",
+        reason: 'must be "any" or "authenticated"'
+      };
+    if (role === "authenticated") condition.role = role;
+  }
+  const [required3] = trees;
+  for (const key of trees) {
+    if (!Object.hasOwn(value, key)) {
+      if (key === required3)
+        return { ok: false, path: key, reason: "is required" };
+      continue;
+    }
+    const parsed = parsePolicyNode(value[key], key);
+    if (!parsed.ok) return parsed;
+    condition[key] = parsed.node;
+  }
+  return { ok: true, condition };
+}
+function conditionsTooLarge(texts) {
+  let total = 0;
+  for (const text of texts)
+    if (typeof text === "string") total += utf8ByteLength(text);
+  return total > MAX_CONDITION_BYTES;
+}
+function isInvalidCondition(value) {
+  return isPlainObject(value) && typeof value.invalid === "string";
+}
+function checkOf(action, condition) {
+  if (action === "insert") return condition.check;
+  if (action === "update") return condition.check ?? condition.using;
+  return void 0;
+}
+var MAX_CONDITION_VALUES = 50;
+var ARRAY_OPERATORS2 = ["contains", "containedBy", "overlaps"];
+function treeValues(node, rebinds) {
+  if ("not" in node) return treeValues(node.not, rebinds);
+  if ("or" in node || "and" in node)
+    return ("or" in node ? node.or : node.and).reduce(
+      (sum, child) => sum + treeValues(child, rebinds),
+      0
+    );
+  const value = node.value;
+  const own2 = Array.isArray(value) ? ARRAY_OPERATORS2.includes(node.operator) ? new Set(value.map((item) => JSON.stringify(item))).size : value.length : node.operator === "is" && value !== null ? 0 : 1;
+  if (!rebinds || Array.isArray(value) && value.length === 0) return own2;
+  return own2 + (ARRAY_OPERATORS2.includes(node.operator) ? 5 : 1);
+}
+function conditionValueCount(action, condition) {
+  let count2 = 0;
+  if (action !== "insert" && condition.using)
+    count2 += treeValues(condition.using, false);
+  const check2 = checkOf(action, condition);
+  if (check2) count2 += treeValues(check2, action === "update");
+  return count2;
+}
+
+// ../../packages/data-core/src/legacy-policy.ts
+var RULES = ["none", "public", "authenticated", "owner"];
+var POLICY_ACTIONS2 = ["select", "insert", "update", "delete"];
+function isRule(value) {
+  return RULES.includes(value);
+}
+function sugarName(action) {
+  return `naro_${action}`;
+}
+var CONVERTED_RULE = "rls";
+var ROW_AS_READ = "table_name = ? AND select_rule IS ? AND insert_rule IS ? AND update_rule IS ? AND delete_rule IS ? AND owner_column IS ? AND select_condition IS ? AND insert_condition IS ? AND update_condition IS ? AND delete_condition IS ? AND updated_at IS ?";
+var LEGACY_ROW_COLUMNS = [
+  "table_name",
+  "select_rule",
+  "insert_rule",
+  "update_rule",
+  "delete_rule",
+  "owner_column",
+  "select_condition",
+  "insert_condition",
+  "update_condition",
+  "delete_condition",
+  "updated_at"
+];
+function legacyRowAsRead(row) {
+  const values = [];
+  for (const column of LEGACY_ROW_COLUMNS) {
+    const value = row[column];
+    if (value === null || value === void 0) values.push(null);
+    else if (typeof value === "string") values.push(value);
+    else return void 0;
+  }
+  return values;
+}
+var POLICY_SQL = {
+  list: "SELECT * FROM _naro_policies",
+  upsert: "INSERT INTO _naro_policies (table_name, select_rule, insert_rule, update_rule, delete_rule, owner_column, updated_at) VALUES (?, ?, ?, ?, ?, ?, datetime('now')) ON CONFLICT(table_name) DO UPDATE SET select_rule = excluded.select_rule, insert_rule = excluded.insert_rule, update_rule = excluded.update_rule, delete_rule = excluded.delete_rule, owner_column = excluded.owner_column, updated_at = excluded.updated_at",
+  upsertWithConditions: "INSERT INTO _naro_policies (table_name, select_rule, insert_rule, update_rule, delete_rule, owner_column, select_condition, insert_condition, update_condition, delete_condition, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now')) ON CONFLICT(table_name) DO UPDATE SET select_rule = excluded.select_rule, insert_rule = excluded.insert_rule, update_rule = excluded.update_rule, delete_rule = excluded.delete_rule, owner_column = excluded.owner_column, select_condition = excluded.select_condition, insert_condition = excluded.insert_condition, update_condition = excluded.update_condition, delete_condition = excluded.delete_condition, updated_at = excluded.updated_at",
+  remove: "DELETE FROM _naro_policies WHERE table_name = ?",
+  /**
+   * Migration 4: the rules of a converted row, if it is still as read —
+   * binds `legacyRowAsRead(row)`.
+   */
+  markConverted: `UPDATE _naro_policies SET select_rule = '${CONVERTED_RULE}', insert_rule = '${CONVERTED_RULE}', update_rule = '${CONVERTED_RULE}', delete_rule = '${CONVERTED_RULE}' WHERE ${ROW_AS_READ}`,
+  /**
+   * Migration 4: one named policy a row converts to, written only if the
+   * row is still as read — the same gate as `markConverted`, so a row the
+   * old control plane changed in between is neither converted nor marked.
+   * Binds `policyValues` and then `legacyRowAsRead(row)`.
+   */
+  insertConverted: `INSERT OR IGNORE INTO _naro_policies_v2 (table_name, name, kind, command, roles, using_expr, check_expr, owner_column) SELECT ?, ?, ?, ?, ?, ?, ?, ? WHERE EXISTS (SELECT 1 FROM _naro_policies WHERE ${ROW_AS_READ})`
+};
+function readStoredCondition(action, text, tooLarge) {
+  if (text === void 0 || text === null) return "is missing";
+  if (typeof text !== "string") return "is not JSON";
+  if (tooLarge)
+    return `the conditions of the policy are larger than ${String(MAX_CONDITION_BYTES)} bytes`;
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return "is not JSON";
+  }
+  const parsed = parseCondition(action, value);
+  if (parsed.ok) return parsed.condition;
+  return parsed.path === "" ? parsed.reason : `${parsed.path} ${parsed.reason}`;
+}
+function policyFromRow(row, log) {
+  const table = row.table_name;
+  if (typeof table !== "string" || table === "") return void 0;
+  const texts = POLICY_ACTIONS2.map(
+    (action) => row[`${action}_rule`] === CONDITION_RULE ? row[`${action}_condition`] : void 0
+  );
+  const tooLarge = conditionsTooLarge(
+    texts.filter((text) => typeof text === "string")
+  );
+  const read = POLICY_ACTIONS2.map(
+    (action, index) => {
+      const value = row[`${action}_rule`];
+      if (value !== CONDITION_RULE) return isRule(value) ? value : "none";
+      return readStoredCondition(action, texts[index], tooLarge);
+    }
+  );
+  const values = POLICY_ACTIONS2.reduce((sum, action, index) => {
+    const item = read[index];
+    return typeof item === "object" ? sum + conditionValueCount(action, item) : sum;
+  }, 0);
+  const rule = (action, index) => {
+    let item = read[index] ?? "none";
+    if (typeof item === "object" && values > MAX_CONDITION_VALUES)
+      item = `the conditions of the policy use more than ${String(MAX_CONDITION_VALUES)} values`;
+    if (typeof item === "object" || isRule(item)) return item;
+    log?.(
+      `naro data-core: the ${action} condition of ${table} cannot be read: ${item}`
+    );
+    return { invalid: item };
+  };
+  const owner = row.owner_column;
+  return {
+    table,
+    select: rule("select", 0),
+    insert: rule("insert", 1),
+    update: rule("update", 2),
+    delete: rule("delete", 3),
+    ownerColumn: typeof owner === "string" && owner !== "" ? owner : null
+  };
+}
+function findPolicy(policies, table) {
+  const exact = policies.find((policy) => policy.table === table);
+  if (exact) return exact;
+  const folded = asciiLower(table);
+  const matches = policies.filter(
+    (policy) => asciiLower(policy.table) === folded
+  );
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function legacyInForce(policies, tables) {
+  const picked = /* @__PURE__ */ new Set();
+  for (const table of tables) {
+    const policy = findPolicy(policies, table);
+    if (policy) picked.add(policy);
+  }
+  return policies.filter((policy) => picked.has(policy));
+}
+function valueExpr(value) {
+  if (typeof value === "object" && value !== null)
+    return { kind: "auth", fn: "uid" };
+  return { kind: "literal", value };
+}
+var COMPARISONS = {
+  eq: "=",
+  neq: "<>",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<="
+};
+var ARRAYS = { contains: "@>", containedBy: "<@", overlaps: "&&" };
+var UID = { kind: "auth", fn: "uid" };
+function uidIsNull(not) {
+  return { kind: "is", not, operand: UID, value: null };
+}
+function anonDiffers(expr) {
+  if (expr.kind === "array")
+    return expr.values.some((value) => typeof value === "object");
+  if (expr.kind !== "in") return false;
+  const uids = expr.list.filter((item) => item.kind === "auth").length;
+  return uids > 0 && uids < expr.list.length;
+}
+function filterNodeToExpr(node, negated = false) {
+  if ("not" in node)
+    return { kind: "not", arg: filterNodeToExpr(node.not, !negated) };
+  if ("or" in node || "and" in node) {
+    const children = ("or" in node ? node.or : node.and).map(
+      (child) => filterNodeToExpr(child, negated)
+    );
+    if (children.length === 1) return children[0];
+    return { kind: "or" in node ? "or" : "and", args: children };
+  }
+  const leaf = leafToExpr(node);
+  if (!anonDiffers(leaf)) return leaf;
+  return negated ? { kind: "or", args: [leaf, uidIsNull(false)] } : { kind: "and", args: [leaf, uidIsNull(true)] };
+}
+function leafToExpr(node) {
+  const column = {
+    kind: "column",
+    qualifier: null,
+    name: node.column
+  };
+  const value = node.value;
+  switch (node.operator) {
+    case "eq":
+    case "neq":
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte":
+      return {
+        kind: "compare",
+        op: COMPARISONS[node.operator],
+        left: column,
+        right: valueExpr(Array.isArray(value) ? null : value)
+      };
+    case "in": {
+      const list = Array.isArray(value) ? value : [value];
+      if (list.length === 0) return { kind: "literal", value: false };
+      return {
+        kind: "in",
+        not: false,
+        operand: column,
+        list: list.map(valueExpr)
+      };
+    }
+    case "is":
+      return {
+        kind: "is",
+        not: false,
+        operand: column,
+        value: value === true || value === false ? value : null
+      };
+    case "like":
+    case "ilike":
+      return {
+        kind: "like",
+        not: false,
+        ci: node.operator === "ilike",
+        operand: column,
+        pattern: typeof value === "string" ? value : ""
+      };
+    case "contains":
+    case "containedBy":
+    case "overlaps":
+      return {
+        kind: "array",
+        op: ARRAYS[node.operator],
+        operand: { kind: "column", qualifier: null, name: node.column },
+        values: (Array.isArray(value) ? value : []).map(
+          (item) => typeof item === "object" && item !== null ? { kind: "auth", fn: "uid" } : typeof item === "number" ? item : String(item)
+        )
+      };
+  }
+}
+var TRUE_TEXT = printExpr({ kind: "literal", value: true });
+function treeText(node) {
+  return node === void 0 ? null : printExpr(filterNodeToExpr(node));
+}
+function namedFromRule(table, action, rule, ownerColumn) {
+  const base = {
+    table,
+    name: sugarName(action),
+    permissive: true,
+    command: action,
+    owner: null
+  };
+  const everyone = [...POLICY_ROLES];
+  if (rule === "none" || typeof rule === "string" && !isRule(rule))
+    return null;
+  if (rule === "public" || rule === "authenticated")
+    return {
+      ...base,
+      roles: rule === "public" ? everyone : ["authenticated"],
+      using: action === "insert" ? null : TRUE_TEXT,
+      check: action === "insert" ? TRUE_TEXT : null
+    };
+  if (rule === "owner") {
+    const column = ownerColumn ?? "";
+    return {
+      ...base,
+      roles: ["authenticated"],
+      ...column === "" ? { using: null, check: null } : ownerClauses(column, action),
+      owner: column
+    };
+  }
+  if (isInvalidCondition(rule) || (action === "insert" ? rule.check : rule.using) === void 0)
+    return { ...base, roles: everyone, using: null, check: null };
+  return {
+    ...base,
+    roles: rule.role === "authenticated" ? ["authenticated"] : everyone,
+    using: action === "insert" ? null : treeText(rule.using),
+    check: action === "insert" || action === "update" ? treeText(rule.check) : null
+  };
+}
+function namedFromLegacy(policy) {
+  return POLICY_ACTIONS2.flatMap((action) => {
+    const named = namedFromRule(
+      policy.table,
+      action,
+      policy[action],
+      policy.ownerColumn
+    );
+    return named ? [named] : [];
+  });
+}
+function loadNamed(policies, log) {
+  const columns = [
+    "table_name",
+    "name",
+    "kind",
+    "command",
+    "roles",
+    "using_expr",
+    "check_expr",
+    "owner_column"
+  ];
+  return policies.flatMap((policy) => {
+    const values = policyValues(policy);
+    const loaded = loadPolicy(
+      Object.fromEntries(
+        columns.map((column, index) => [column, values[index]])
+      ),
+      log
+    );
+    return loaded ? [loaded] : [];
+  });
+}
+function unreadableConversions(policy) {
+  const found = [];
+  for (const action of POLICY_ACTIONS2) {
+    const rule = policy[action];
+    const named = namedFromRule(policy.table, action, rule, policy.ownerColumn);
+    if (!named) continue;
+    const [loaded] = loadNamed([named]);
+    if (!loaded || loaded.invalid === null) continue;
+    found.push({
+      table: named.table,
+      policy: named.name,
+      reason: isInvalidCondition(rule) ? `the old ${action} condition could not be read: ${rule.invalid}` : rule === "owner" && named.owner === "" ? `the old ${action} rule is owner, and the row has no owner column` : loaded.invalid
+    });
+  }
+  return found;
+}
+
+// ../../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`;
+
+// ../../packages/data-core/src/policy-migration.ts
+var SYSTEM_PREDICATE = systemTablePredicate("name");
 
 // ../../packages/data-core/src/system-sql.ts
+async function convertLegacyPolicies(db, found) {
+  const rows = rowsOf(await db.prepare(POLICY_SQL.list).all());
+  if (rows.length === 0) return [];
+  const read = rows.map((row) => ({
+    policy: policyFromRow(row),
+    asRead: legacyRowAsRead(row)
+  }));
+  const inForce = new Set(
+    legacyInForce(
+      read.flatMap(({ policy }) => policy ? [policy] : []),
+      await readTableNames(db)
+    )
+  );
+  const statements = [];
+  for (const { policy, asRead } of read) {
+    if (!policy || !asRead) continue;
+    if (inForce.has(policy)) {
+      for (const named of namedFromLegacy(policy))
+        statements.push({
+          sql: POLICY_SQL.insertConverted,
+          params: [...policyValues(named), ...asRead]
+        });
+      found.unreadable.push(...unreadableConversions(policy));
+    }
+    statements.push({ sql: POLICY_SQL.markConverted, params: asRead });
+  }
+  return statements;
+}
 var MIGRATIONS_TABLE = "CREATE TABLE IF NOT EXISTS _naro_migrations (version INTEGER PRIMARY KEY, name TEXT NOT NULL, applied_at TEXT NOT NULL DEFAULT (datetime('now')))";
 var SYSTEM_MIGRATIONS = [
   {
@@ -1499,6 +3663,15 @@ var SYSTEM_MIGRATIONS = [
       "CREATE INDEX IF NOT EXISTS _naro_auth_email_log_address ON _naro_auth_email_log (address_hash, sent_at)",
       "CREATE TABLE IF NOT EXISTS _naro_auth_contested (user_id TEXT PRIMARY KEY, contested_at INTEGER NOT NULL)"
     ]
+  },
+  {
+    // P2-7 §9: named policies, many per table. The old rows are converted
+    // in the same batch and their rules set to a word old workers read as
+    // `none`.
+    version: 4,
+    name: "named_policies",
+    statements: [NAMED_POLICY_TABLE_SQL],
+    compute: convertLegacyPolicies
   }
 ];
 
@@ -1564,12 +3737,12 @@ function sqlSkeleton(sql) {
   let index = 0;
   while (index < sql.length) {
     const char = sql[index] ?? "";
-    const pair = sql.slice(index, index + 2);
-    if (pair === "--") {
+    const pair2 = sql.slice(index, index + 2);
+    if (pair2 === "--") {
       const end = sql.indexOf("\n", index);
       index = end < 0 ? sql.length : end;
       out += " ";
-    } else if (pair === "/*") {
+    } else if (pair2 === "/*") {
       const end = sql.indexOf("*/", index + 2);
       index = end < 0 ? sql.length : end + 2;
       out += " ";
@@ -1739,6 +3912,9 @@ function generateTypes(tables, options2 = {}) {
 `;
 }
 
+// ../../packages/core/src/route-patterns.ts
+var MAX_ROUTE_LIST_BYTES = 64 * 1024;
+
 // ../../packages/core/src/artifact-manifest.ts
 var MAX_FILE_BYTES2 = 25 * 1024 * 1024;
 var MAX_ARTIFACT_BYTES = 64 * 1024 * 1024;
@@ -6440,8 +8616,8 @@ function az_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/be.js
-function getBelarusianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getBelarusianPlural(count2, one, few, many) {
+  const absCount = Math.abs(count2);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -8519,8 +10695,8 @@ function hu_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/hy.js
-function getArmenianPlural(count, one, many) {
-  return Math.abs(count) === 1 ? one : many;
+function getArmenianPlural(count2, one, many) {
+  return Math.abs(count2) === 1 ? one : many;
 }
 function withDefiniteArticle(word) {
   if (!word)
@@ -10648,8 +12824,8 @@ function ro_default() {
 }
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/locales/ru.js
-function getRussianPlural(count, one, few, many) {
-  const absCount = Math.abs(count);
+function getRussianPlural(count2, one, few, many) {
+  const absCount = Math.abs(count2);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -16552,6 +18728,9 @@ function migrationNameMismatch(sent, recorded) {
   return `The control plane recorded the migration as ${recorded}, but naro sent ${sent} and wrote the file under that name. Until the two match, naro migration list shows them apart and naro db push would apply the file again.`;
 }
 
+// ../../packages/sdk/src/reset-plan.ts
+var RESET_CLEAR_POLICIES = `DELETE FROM ${NAMED_POLICY_TABLE};`;
+
 // src/naro.ts
 import { deployDirectory } from "naro-cli";
 function createNaroDeps() {
@@ -17031,7 +19210,7 @@ var DATABASE_TOOLS = [
       destructiveHint: true,
       idempotentHint: false
     },
-    description: `${DESTRUCTIVE}executes raw SQL in the D1 database \u2014 it can change or delete data. Use \`apply_migration\` instead for DDL operations. ${UNTRUSTED} Pass values through params (bound to ? placeholders) instead of building them into the SQL text; params work with a single statement only. Several statements in one call run as one transaction: if one fails, none of them is applied. ${SHARED_DATABASE} ${LIMITS} ${SINGLE_THREADED}`,
+    description: `${DESTRUCTIVE}executes raw SQL in the D1 database \u2014 it can change or delete data. Use \`apply_migration\` instead for DDL operations. ${UNTRUSTED} Pass values through params (bound to ? placeholders) instead of building them into the SQL text; params work with a single statement only. Several statements in one call run as one transaction: if one fails, none of them is applied. CREATE/DROP POLICY work here too (see \`apply_migration\`; they take no params), and result.warnings, when present, says what a policy needs. ${SHARED_DATABASE} ${LIMITS} ${SINGLE_THREADED}`,
     readOnlyVariant: {
       description: `Executes a single read-only SQL statement in the D1 database. This server runs with --read-only: writes, DDL and multi-statement batches are refused with DATABASE_READ_ONLY. ${UNTRUSTED} Pass values through params (bound to ? placeholders) instead of building them into the SQL text. ${SHARED_DATABASE} ${LIMITS} ${SINGLE_THREADED}`,
       annotations: {
@@ -17090,7 +19269,7 @@ var DATABASE_TOOLS = [
       destructiveHint: true,
       idempotentHint: false
     },
-    description: `${DESTRUCTIVE}applies a migration (DDL) to the D1 database and records it in the d1_migrations ledger \u2014 the same ledger wrangler uses. \`name\` is a short snake_case title; naro numbers it (NNNN_name.sql) and, when the project directory is known, writes the file to ./migrations so \`naro db push\` sees it as applied. All-or-nothing: if a statement fails, the whole migration is rolled back and not recorded. ${UNTRUSTED} ${SHARED_DATABASE} ${LIMITS}`,
+    description: `${DESTRUCTIVE}applies a migration (DDL) to the D1 database and records it in the d1_migrations ledger \u2014 the same ledger wrangler uses. \`name\` is a short snake_case title; naro numbers it (NNNN_name.sql) and, when the project directory is known, writes the file to ./migrations so \`naro db push\` sees it as applied. All-or-nothing: if a statement fails, the whole migration is rolled back and not recorded. Write CREATE POLICY in the same migration as the table, as in Supabase: it is applied with the table, all or nothing. A table without a policy refuses every anon and signed-in request to the Data API. DROP POLICY [IF EXISTS], COMMENT ON POLICY p ON t IS 'naro:owner <column>' and ALTER TABLE t ENABLE ROW LEVEL SECURITY are accepted too; DISABLE ROW LEVEL SECURITY, GRANT, REVOKE and ALTER POLICY are refused before anything runs. Dropping a table drops its policies, so a SQLite table rebuild (create __new_x, copy, drop x, rename) must create the policies again after the rename: warnings lists the ones it removed, with their SQL. ${UNTRUSTED} ${SHARED_DATABASE} ${LIMITS}`,
     inputSchema: {
       type: "object",
       properties: {
@@ -17101,7 +19280,7 @@ var DATABASE_TOOLS = [
         },
         query: {
           type: "string",
-          description: "The migration's SQL (DDL) to apply."
+          description: "The migration's SQL (DDL) to apply, with CREATE POLICY for its tables in the same SQL."
         },
         rootDirectory: {
           type: "string",
@@ -17130,6 +19309,8 @@ var DATABASE_TOOLS = [
         migration: applied.migration,
         file: file2,
         result: applied.result,
+        // P2-7b: what the migration's policies need, in the server's words.
+        warnings: applied.warnings,
         ...fileWarning ? { fileWarning } : {}
       };
     }
@@ -17143,7 +19324,7 @@ var DATABASE_TOOLS = [
       destructiveHint: false,
       idempotentHint: false
     },
-    description: `Creates a table in the project's D1 database without writing SQL: naro renders the CREATE TABLE from columns, applies it as one migration recorded in d1_migrations and, when the project directory is known, writes it to ./migrations as NNNN_schema_create_table_<table>.sql so naro db push and naro db reset see it. Column types: INTEGER, REAL, TEXT, BLOB, NUMERIC, BOOLEAN, DATETIME, JSON \u2014 store JSON in TEXT, since a JSON column turns '123' into a number. default takes a literal (a string, a number, true, false, null) or {"keyword": "CURRENT_TIMESTAMP"}, never an expression. Every primary key but a single INTEGER one is NOT NULL. owner: {column} adds that column as TEXT NOT NULL and, when the project's backend is ready, an owner policy for select, insert, update and delete. Without a policy the Data API refuses every anon and signed-in request to the table; warnings says so. dryRun: true returns the SQL and the migration name without applying anything. ${UNTRUSTED} ${SHARED_DATABASE}`,
+    description: `Creates a table in the project's D1 database without writing SQL: naro renders the CREATE TABLE from columns, applies it as one migration recorded in d1_migrations and, when the project directory is known, writes it to ./migrations as NNNN_schema_create_table_<table>.sql so naro db push and naro db reset see it. Column types: INTEGER, REAL, TEXT, BLOB, NUMERIC, BOOLEAN, DATETIME, JSON \u2014 store JSON in TEXT, since a JSON column turns '123' into a number. default takes a literal (a string, a number, true, false, null) or {"keyword": "CURRENT_TIMESTAMP"}, never an expression. Every primary key but a single INTEGER one is NOT NULL. owner: {column} adds that column as TEXT NOT NULL and, when the project's backend is ready, an owner policy for select, insert, update and delete \u2014 not in that migration file, so naro db reset lists it, with its SQL, before it removes it: add that SQL to a migration to keep it. Without a policy the Data API refuses every anon and signed-in request to the table; warnings says so. Policies an earlier table left under the name are removed before the table is created, whenever the project has a backend: removedPolicies lists them: statements has each as the CREATE POLICY that naro policy create takes back, except an owner rule (its ownerColumn is set), which CREATE POLICY cannot say \u2014 setCommand is the naro policy set command that sets those again. dryRun: true returns the SQL and the migration name without applying anything. ${UNTRUSTED} ${SHARED_DATABASE}`,
     inputSchema: {
       type: "object",
       properties: {
@@ -17190,7 +19371,7 @@ var DATABASE_TOOLS = [
       destructiveHint: true,
       idempotentHint: false
     },
-    description: `${DESTRUCTIVE}changes a table of the project's D1 database without writing SQL, as one migration recorded in d1_migrations and written to ./migrations when the project directory is known. action is add_column (newColumn, shaped like a create_table column), rename_column (column, to), rename_table (to) or drop_column (column) \u2014 which deletes the column and its value in every row and needs confirm set to "<table>.<column>". SQLite cannot add a PRIMARY KEY or UNIQUE column, a NOT NULL column without a default that is not NULL, or a column defaulting to CURRENT_TIMESTAMP, and cannot drop a primary key, UNIQUE or indexed column: naro refuses those up front and says why. It also refuses to drop or rename a table or column that a trigger or view uses (read from their SQL; when the SQL leaves it open, a warning instead) \u2014 drop or recreate that trigger or view with apply_migration first. Changing a column's type is not an action \u2014 it needs a table rebuild, so write that migration with apply_migration. Data API policies are kept by table name and are not moved: read warnings after a rename or a drop. dryRun: true returns the SQL without applying anything. ${UNTRUSTED} ${SHARED_DATABASE}`,
+    description: `${DESTRUCTIVE}changes a table of the project's D1 database without writing SQL, as one migration recorded in d1_migrations and written to ./migrations when the project directory is known. action is add_column (newColumn, shaped like a create_table column), rename_column (column, to), rename_table (to) or drop_column (column) \u2014 which deletes the column and its value in every row and needs confirm set to "<table>.<column>". SQLite cannot add a PRIMARY KEY or UNIQUE column, a NOT NULL column without a default that is not NULL, or a column defaulting to CURRENT_TIMESTAMP, and cannot drop a primary key, UNIQUE or indexed column: naro refuses those up front and says why. It also refuses to drop or rename a table or column that a trigger or view uses (read from their SQL; when the SQL leaves it open, a warning instead) \u2014 drop or recreate that trigger or view with apply_migration first. Changing a column's type is not an action \u2014 it needs a table rebuild, so write that migration with apply_migration. Data API policies are kept by table name and are not moved. A rename leaves the table's Data API policies under the old name, where they apply to no table, and they are removed when a table is next created as that name or renamed to it \u2014 renaming the table back included: removedPolicies lists them: statements has each as the CREATE POLICY that naro policy create takes back, except an owner rule (its ownerColumn is set), which CREATE POLICY cannot say \u2014 setCommand is the naro policy set command that sets those again. Move them to the new name right after a rename. A rename or drop that takes a table or column from under a policy \u2014 this table's or, through a subquery, another table's \u2014 makes the requests that policy applies to answer 500 POLICY_INVALID: warnings names each policy the change breaks, with dryRun: true before anything is applied. Read warnings after a rename or a drop. dryRun: true returns the SQL without applying anything. ${UNTRUSTED} ${SHARED_DATABASE}`,
     inputSchema: {
       type: "object",
       properties: {
@@ -17274,7 +19455,7 @@ var DATABASE_TOOLS = [
       destructiveHint: true,
       idempotentHint: false
     },
-    description: `${DESTRUCTIVE}drops a table of the project's D1 database and every row in it, as one migration recorded in d1_migrations. Needs confirm set to the table's name. A table that another table's foreign key references, or that a trigger or view uses, is refused. restore_database can bring it back (Time Travel, 30 days). Its Data API policy is removed with it whenever the project has a backend, on or off (removedPolicies); otherwise it stays under the table's name: read warnings. dryRun: true returns the SQL without applying anything. ${UNTRUSTED} ${SHARED_DATABASE}`,
+    description: `${DESTRUCTIVE}drops a table of the project's D1 database and every row in it, as one migration recorded in d1_migrations. Needs confirm set to the table's name. A table that another table's foreign key references, or that a trigger or view uses, is refused. restore_database can bring it back (Time Travel, 30 days). Its Data API policies are removed with it whenever the project has a backend, on or off: removedPolicies lists them: statements has each as the CREATE POLICY that naro policy create takes back, except an owner rule (its ownerColumn is set), which CREATE POLICY cannot say \u2014 setCommand is the naro policy set command that sets those again. Otherwise they stay under the table's name: read warnings \u2014 which also names each policy of another table that reads this one in a subquery and stops applying (500 POLICY_INVALID); dryRun: true says so before the drop. dryRun: true returns the SQL without applying anything. ${UNTRUSTED} ${SHARED_DATABASE}`,
     inputSchema: {
       type: "object",
       properties: {
@@ -18339,7 +20520,7 @@ function toolErrorJson(error51) {
 }
 
 // src/server.ts
-var SERVER_VERSION = "0.9.1";
+var SERVER_VERSION = "0.11.0";
 function visibleTools(options2) {
   const { features, readOnly } = options2;
   return TOOLS.flatMap((tool) => {