naro-cli 0.10.0 → 0.11.0

package/dist/{chunk-5U6YPVZS.js → chunk-L7JOGWP3.js}

@@ -7,7 +7,7 @@ import {
 import { existsSync as existsSync7 } from "fs";
 import { cp as cp2, mkdtemp as mkdtemp2, readFile as readFile13, rm as rm3 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename3, dirname as dirname4, join as join23, resolve as resolve9 } from "path";
+import { basename as basename3, dirname as dirname4, join as join24, resolve as resolve9 } from "path";
 import { fileURLToPath } from "url";
 
 // ../../packages/build/src/artifact-upload.ts
@@ -226,7 +226,22 @@ function hashAsset(data, contentType2) {
 // ../../packages/build/src/local-build-executor.ts
 import { access as access8, mkdtemp, readFile as readFile12, rm as rm2 } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname3, join as join16, resolve as resolve7 } from "path";
+import { dirname as dirname3, join as join17, resolve as resolve7 } from "path";
+
+// ../../packages/core/src/route-patterns.ts
+var ROUTE_PATTERN = /^\/[A-Za-z0-9\-._~%!$&()*+,;=:@/[\]]*$/;
+var MAX_ROUTE_LENGTH = 256;
+var MAX_ROUTES = 2e3;
+var MAX_ROUTE_LIST_BYTES = 64 * 1024;
+function isRoutePattern(value) {
+  return typeof value === "string" && value.length <= MAX_ROUTE_LENGTH && ROUTE_PATTERN.test(value);
+}
+function sanitizeRoutes(value) {
+  if (!Array.isArray(value)) return void 0;
+  const routes = [...new Set(value.filter(isRoutePattern))].sort();
+  if (routes.length > MAX_ROUTES) return void 0;
+  return JSON.stringify(routes).length > MAX_ROUTE_LIST_BYTES ? void 0 : routes;
+}
 
 // ../../packages/core/src/artifact-manifest.ts
 var MAX_FILE_BYTES = 25 * 1024 * 1024;
@@ -4950,8 +4965,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) {
@@ -7029,8 +7044,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)
@@ -9158,8 +9173,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) {
@@ -16015,6 +16030,93 @@ async function detectFramework(root, overrides = {}) {
   };
 }
 
+// ../../packages/build/src/next-routes.ts
+import { readdir as readdir2, stat as stat2 } from "fs/promises";
+import { join as join8 } from "path";
+var APP_PAGE_FILE = /^page\.(?:js|jsx|ts|tsx|md|mdx)$/;
+var PAGES_ROUTER_FILE = /^(.+)\.(?:js|jsx|ts|tsx)$/;
+var DECLARATION_FILE = /\.d\.ts$/;
+var PAGES_ROUTER_SPECIAL = /* @__PURE__ */ new Set(["_app", "_document", "_error", "api"]);
+var DYNAMIC_SEGMENT = /^\[.+\]$/;
+var ROUTE_GROUP = /^\(.+\)$/;
+var INTERCEPTING = /^\(\.{1,3}\)/;
+var LITERAL_IN_PATHNAME = /%(?:21|24|26|28|29|2A|2B|2C|3B|3D|3A|40)/g;
+function errorCode(error51) {
+  return error51?.code;
+}
+async function firstDirectory(root, candidates) {
+  for (const candidate of candidates) {
+    const path = join8(root, candidate);
+    try {
+      if ((await stat2(path)).isDirectory()) return path;
+    } catch (error51) {
+      const code = errorCode(error51);
+      if (code !== "ENOENT" && code !== "ENOTDIR") throw error51;
+    }
+  }
+  return null;
+}
+function urlSegment(name, router) {
+  if (DYNAMIC_SEGMENT.test(name)) return name;
+  const decoded = router === "app" ? name.replace(/%5F/gi, "_") : name;
+  return encodeURIComponent(decoded).replace(/'/g, "%27").replace(
+    LITERAL_IN_PATHNAME,
+    (escape) => String.fromCharCode(Number.parseInt(escape.slice(1), 16))
+  );
+}
+function toRoute(segments) {
+  return `/${segments.join("/")}`;
+}
+async function readAppRouter(dir, segments, routes) {
+  const entries = await readdir2(dir, { withFileTypes: true });
+  if (entries.some((entry) => entry.isFile() && APP_PAGE_FILE.test(entry.name)))
+    routes.add(toRoute(segments));
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const name = entry.name;
+    if (name.startsWith("_") || INTERCEPTING.test(name)) continue;
+    const next = ROUTE_GROUP.test(name) || name.startsWith("@") ? segments : [...segments, urlSegment(name, "app")];
+    await readAppRouter(join8(dir, name), next, routes);
+  }
+}
+async function readPagesRouter(dir, segments, routes) {
+  const entries = await readdir2(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (segments.length === 0 && entry.name === "api") continue;
+      await readPagesRouter(
+        join8(dir, entry.name),
+        [...segments, urlSegment(entry.name, "pages")],
+        routes
+      );
+      continue;
+    }
+    if (!entry.isFile() || DECLARATION_FILE.test(entry.name)) continue;
+    const base2 = PAGES_ROUTER_FILE.exec(entry.name)?.[1];
+    if (!base2) continue;
+    if (segments.length === 0 && PAGES_ROUTER_SPECIAL.has(base2)) continue;
+    routes.add(
+      toRoute(
+        base2 === "index" ? segments : [...segments, urlSegment(base2, "pages")]
+      )
+    );
+  }
+}
+async function listNextRoutes(appRoot) {
+  const app = await firstDirectory(appRoot, ["app", join8("src", "app")]);
+  const pages = await firstDirectory(appRoot, ["pages", join8("src", "pages")]);
+  if (!app && !pages) return null;
+  const routes = /* @__PURE__ */ new Set();
+  if (app) await readAppRouter(app, [], routes);
+  if (pages) await readPagesRouter(pages, [], routes);
+  const valid = sanitizeRoutes([...routes]);
+  if (!valid)
+    throw new Error(
+      "the app has more than 2,000 routes or its route list is over 64 KiB"
+    );
+  return valid.length > 0 ? valid : null;
+}
+
 // ../../packages/build/src/process.ts
 import { spawn } from "child_process";
 import { createInterface } from "readline";
@@ -16246,8 +16348,8 @@ function resolveAppRoot(checkout, configuredRoot) {
 }
 
 // ../../packages/build/src/static-artifact.ts
-import { readdir as readdir2, readFile as readFile7 } from "fs/promises";
-import { isAbsolute as isAbsolute3, join as join8, relative as relative3, resolve as resolve4, sep as sep2 } from "path";
+import { readdir as readdir3, readFile as readFile7 } from "fs/promises";
+import { isAbsolute as isAbsolute3, join as join9, relative as relative3, resolve as resolve4, sep as sep2 } from "path";
 var SHIM_WORKER_SOURCE = "export default { fetch: (request, env) => env.ASSETS.fetch(request) };\n";
 var EXCLUDED_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules"]);
 var ALLOWED_DOTFILE = ".well-known";
@@ -16270,12 +16372,12 @@ async function readStaticArtifact(appRoot, outputDirectory, identity, options, o
     );
   const assets = [];
   async function visit(directory) {
-    const entries = await readdir2(directory, { withFileTypes: true });
+    const entries = await readdir3(directory, { withFileTypes: true });
     for (const entry of entries.sort(
       (left, right) => left.name.localeCompare(right.name)
     )) {
       if (excluded(entry.name)) continue;
-      const path = join8(directory, entry.name);
+      const path = join9(directory, entry.name);
       if (entry.isSymbolicLink())
         throw new DeploymentError(
           "ARTIFACT_INVALID",
@@ -16331,7 +16433,7 @@ async function readStaticArtifact(appRoot, outputDirectory, identity, options, o
 // ../../packages/build/src/strategy/fingerprint.ts
 import { createHash as createHash3 } from "crypto";
 import { readFile as readFile8 } from "fs/promises";
-import { join as join9, relative as relative4, sep as sep3 } from "path";
+import { join as join10, relative as relative4, sep as sep3 } from "path";
 var APP_ROOT_FILES = [
   "package.json",
   "next.config.js",
@@ -16375,11 +16477,11 @@ async function hashFile(path) {
 }
 async function hashStrategyInputs(checkout, appRoot) {
   const candidates = /* @__PURE__ */ new Set();
-  for (const name of CHECKOUT_FILES) candidates.add(join9(checkout, name));
-  for (const name of APP_ROOT_FILES) candidates.add(join9(appRoot, name));
+  for (const name of CHECKOUT_FILES) candidates.add(join10(checkout, name));
+  for (const name of APP_ROOT_FILES) candidates.add(join10(appRoot, name));
   for (const base2 of SOURCE_FILES) {
     for (const ext of SOURCE_EXTENSIONS) {
-      candidates.add(join9(appRoot, `${base2}.${ext}`));
+      candidates.add(join10(appRoot, `${base2}.${ext}`));
     }
   }
   const entries = [];
@@ -16408,7 +16510,7 @@ async function computeStrategyFingerprint(input) {
 
 // ../../packages/build/src/strategy/project-facts.ts
 import { access as access6, readFile as readFile9 } from "fs/promises";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 var SOURCE_EXTENSIONS2 = ["ts", "tsx", "js", "jsx", "mjs", "mts"];
 var SOURCE_DIRECTORIES = ["", "src"];
 var VITE_CONFIGS = [
@@ -16429,7 +16531,7 @@ async function findSourceFile(appRoot, basename4) {
   for (const dir of SOURCE_DIRECTORIES) {
     for (const ext of SOURCE_EXTENSIONS2) {
       const rel = dir ? `${dir}/${basename4}.${ext}` : `${basename4}.${ext}`;
-      if (await exists4(join10(appRoot, rel))) return rel;
+      if (await exists4(join11(appRoot, rel))) return rel;
     }
   }
   return null;
@@ -16458,10 +16560,10 @@ async function collectProjectFacts(appRoot) {
   const proxyFile = await findSourceFile(appRoot, "proxy");
   const middlewareFile = await findSourceFile(appRoot, "middleware");
   const routeSourceFile = middlewareFile ?? proxyFile;
-  const routeSource = routeSourceFile ? await readIfExists(join10(appRoot, routeSourceFile)) : null;
+  const routeSource = routeSourceFile ? await readIfExists(join11(appRoot, routeSourceFile)) : null;
   let usesVinext = false;
   let nextSpec = null;
-  const packageJsonSource = await readIfExists(join10(appRoot, "package.json"));
+  const packageJsonSource = await readIfExists(join11(appRoot, "package.json"));
   if (packageJsonSource) {
     try {
       const packageJson = JSON.parse(packageJsonSource);
@@ -16472,7 +16574,7 @@ async function collectProjectFacts(appRoot) {
       nextSpec = dependency("next");
       if (dependency("vinext") !== null) {
         for (const name of VITE_CONFIGS) {
-          const config2 = await readIfExists(join10(appRoot, name));
+          const config2 = await readIfExists(join11(appRoot, name));
           if (config2 && /\bvinext\s*\(/.test(config2) && /@cloudflare\/vite-plugin/.test(config2)) {
             usesVinext = true;
             break;
@@ -16726,7 +16828,7 @@ function createSmokeTester(options = {}) {
   const pollIntervalMs = options.pollIntervalMs ?? 1e3;
   async function runOnce(request, observer) {
     const stage = request.stage ?? "BUILDING";
-    const errorCode = request.errorCode ?? "BUILD_FAILED";
+    const errorCode2 = request.errorCode ?? "BUILD_FAILED";
     const bootTimeoutMs = request.bootTimeoutMs ?? 9e4;
     const probeTimeoutMs = request.probeTimeoutMs ?? 15e3;
     const port = await allocatePort();
@@ -16734,7 +16836,7 @@ function createSmokeTester(options = {}) {
     const boot = request.boot(port);
     const recent = [];
     const server = start(
-      { ...boot, stage, errorCode },
+      { ...boot, stage, errorCode: errorCode2 },
       // The dev server is chatty; keep its stderr from reading as build
       // errors in the deployment log.
       {
@@ -16850,11 +16952,11 @@ function defaultSmokeProbes(matcherRoutes) {
 
 // ../../packages/build/src/strategy/strategies/opennext-aws.ts
 import { writeFile as writeFile6 } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 
 // ../../packages/build/src/strategy/strategies/shared.ts
 import { access as access7, readFile as readFile10, rm, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname2, join as join11, resolve as resolve5 } from "path";
+import { dirname as dirname2, join as join12, resolve as resolve5 } from "path";
 function capturingObserver(observer) {
   const lines = [];
   return {
@@ -16907,7 +17009,7 @@ async function findProjectBin(appRoot, checkout, name) {
   let dir = resolve5(appRoot);
   const stop = resolve5(checkout);
   for (; ; ) {
-    const candidate = join11(dir, "node_modules", ".bin", name);
+    const candidate = join12(dir, "node_modules", ".bin", name);
     if (await pathExists2(candidate)) return candidate;
     if (dir === stop) return null;
     const parent = dirname2(dir);
@@ -16921,7 +17023,7 @@ function dotenvQuote(value) {
   return `"${value.replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r")}"`;
 }
 async function withDevVars(wranglerConfigPath, env, run) {
-  const path = join11(dirname2(wranglerConfigPath), ".dev.vars");
+  const path = join12(dirname2(wranglerConfigPath), ".dev.vars");
   const keys = Object.keys(env).filter(
     (key) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key)
   );
@@ -16938,7 +17040,7 @@ async function withDevVars(wranglerConfigPath, env, run) {
     await rm(path, { force: true });
   }
 }
-async function bundleWorker(context, layout, observer, errorCode) {
+async function bundleWorker(context, layout, observer, errorCode2) {
   return runStep(
     context,
     {
@@ -16954,7 +17056,7 @@ async function bundleWorker(context, layout, observer, errorCode) {
       cwd: layout.appRoot,
       env: {
         CI: "1",
-        WRANGLER_LOG_PATH: join11(
+        WRANGLER_LOG_PATH: join12(
           layout.appRoot,
           layout.outputRoot,
           "wrangler.log"
@@ -16962,7 +17064,7 @@ async function bundleWorker(context, layout, observer, errorCode) {
       },
       timeoutMs: 5 * 6e4,
       stage: "BUILDING",
-      errorCode
+      errorCode: errorCode2
     },
     observer
   );
@@ -16987,12 +17089,12 @@ async function smokeWorker(context, layout, observer) {
             "--show-interactive-dev-session=false",
             "--log-level=warn",
             "--persist-to",
-            join11(layout.appRoot, layout.outputRoot, ".naro-smoke-state")
+            join12(layout.appRoot, layout.outputRoot, ".naro-smoke-state")
           ],
           cwd: layout.appRoot,
           env: {
             CI: "1",
-            WRANGLER_LOG_PATH: join11(
+            WRANGLER_LOG_PATH: join12(
               layout.appRoot,
               layout.outputRoot,
               "wrangler-dev.log"
@@ -17008,7 +17110,7 @@ async function smokeWorker(context, layout, observer) {
   );
 }
 async function approvePnpmBuilds(checkout, packages) {
-  const path = join11(checkout, "pnpm-workspace.yaml");
+  const path = join12(checkout, "pnpm-workspace.yaml");
   let source = "";
   try {
     source = await readFile10(path, "utf8");
@@ -17104,7 +17206,7 @@ function createOpenNextAwsStrategy() {
       } catch (error51) {
         return failed("prepare", describeError(error51));
       }
-      const configPath = join12(fork.appRoot, CONFIG_NAME);
+      const configPath = join13(fork.appRoot, CONFIG_NAME);
       try {
         await writeFile6(
           configPath,
@@ -17133,7 +17235,7 @@ function createOpenNextAwsStrategy() {
         observer
       );
       if (!build.ok) return failed("build", describeFailure(build));
-      const serverFunction = join12(fork.appRoot, SERVER_FUNCTION);
+      const serverFunction = join13(fork.appRoot, SERVER_FUNCTION);
       if (!await pathExists2(serverFunction))
         return failed("bundle", `OpenNext AWS produced no ${SERVER_FUNCTION}.`);
       const smoke = await context.ports.smoke.run(
@@ -17155,7 +17257,7 @@ function createOpenNextAwsStrategy() {
         status: "success",
         artifact: {
           kind: "opennext-aws",
-          outputRoot: join12(fork.appRoot, ".open-next"),
+          outputRoot: join13(fork.appRoot, ".open-next"),
           serverFunction
         },
         notes: [
@@ -17168,14 +17270,14 @@ function createOpenNextAwsStrategy() {
 
 // ../../packages/build/src/strategy/strategies/opennext-cloudflare.ts
 import { readFile as readFile11 } from "fs/promises";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 var PROXY_TO_MIDDLEWARE_VARIANT = "proxy-to-middleware";
 var NODE_MIDDLEWARE_REFUSAL = /Node\.js middleware is not (?:currently )?supported/i;
 async function buildDeclaresNodeMiddleware(appRoot) {
   try {
     const manifest2 = JSON.parse(
       await readFile11(
-        join13(appRoot, ".next", "server", "functions-config-manifest.json"),
+        join14(appRoot, ".next", "server", "functions-config-manifest.json"),
         "utf8"
       )
     );
@@ -17387,7 +17489,7 @@ function createAwsMiddlewareCloudflareAppStrategy() {
 }
 
 // ../../packages/build/src/strategy/strategies/vinext-cloudflare.ts
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var VINEXT_MIN_NEXT_MAJOR = 16;
 var VINEXT_BUILD_SCRIPTS = ["esbuild", "workerd"];
 var VINEXT_OUTPUT = {
@@ -17542,7 +17644,7 @@ function createVinextCloudflareStrategy(options) {
         context,
         {
           appRoot: fork.appRoot,
-          wranglerConfigPath: join14(
+          wranglerConfigPath: join15(
             fork.appRoot,
             "dist",
             "server",
@@ -17566,7 +17668,7 @@ function createVinextCloudflareStrategy(options) {
 
 // ../../packages/build/src/strategy/workspace.ts
 import { cp } from "fs/promises";
-import { basename as basename2, join as join15, relative as relative5, resolve as resolve6 } from "path";
+import { basename as basename2, join as join16, relative as relative5, resolve as resolve6 } from "path";
 var SKIPPED_ANYWHERE = /* @__PURE__ */ new Set(["node_modules"]);
 function shouldCopy(path) {
   const name = basename2(path);
@@ -17582,7 +17684,7 @@ async function copyCheckout(source, target) {
   });
 }
 function forkedAppRoot(checkout, appRoot, forkCheckout) {
-  return join15(forkCheckout, relative5(checkout, appRoot));
+  return join16(forkCheckout, relative5(checkout, appRoot));
 }
 
 // ../../packages/build/src/local-build-executor.ts
@@ -17590,8 +17692,21 @@ function concurrencyFromEnvironment() {
   const raw = Number(process.env.NARO_RESOLVER_CONCURRENCY ?? "1");
   return Number.isInteger(raw) && raw > 0 ? raw : 1;
 }
+async function withRouteList(artifact, list, appRoot, observer) {
+  try {
+    const routes = await list(appRoot);
+    return routes ? { ...artifact, routes } : artifact;
+  } catch (error51) {
+    await observer.onLog({
+      level: "WARN",
+      stage: "BUILDING",
+      message: `Speed Insights route list skipped: ${error51 instanceof Error ? error51.message : String(error51)}`
+    });
+    return artifact;
+  }
+}
 var defaultLocalBuildDependencies = {
-  createWorkspace: () => mkdtemp(join16(tmpdir(), "next-deploy-build-")),
+  createWorkspace: () => mkdtemp(join17(tmpdir(), "next-deploy-build-")),
   removeWorkspace: (path) => rm2(path, { recursive: true, force: true }),
   runCommand,
   detectPackageManager,
@@ -17613,6 +17728,7 @@ var defaultLocalBuildDependencies = {
   vinextCommand: "vinext",
   forkWorkspace: copyCheckout,
   collectProjectFacts,
+  listNextRoutes,
   hashFingerprintInputs: hashStrategyInputs,
   computeFingerprint: computeStrategyFingerprint,
   targets: { cloudflare: true },
@@ -17624,7 +17740,7 @@ async function readInstalledNextVersion(appRoot, checkout) {
   for (; ; ) {
     try {
       const source = await readFile12(
-        join16(dir, "node_modules", "next", "package.json"),
+        join17(dir, "node_modules", "next", "package.json"),
         "utf8"
       );
       const version2 = JSON.parse(source).version;
@@ -17717,8 +17833,8 @@ var LocalBuildExecutor = class {
   }
   async build(input, observer, cache) {
     const workspace = await this.dependencies.createWorkspace();
-    const checkout = join16(workspace, "checkout");
-    const pmCacheDir = join16(workspace, ".pm-store");
+    const checkout = join17(workspace, "checkout");
+    const pmCacheDir = join17(workspace, ".pm-store");
     let cacheSeq = 0;
     const commandAvailable = this.dependencies.commandAvailable ?? hasCommand;
     const compressor = "zstd";
@@ -17727,7 +17843,7 @@ var LocalBuildExecutor = class {
       transport: cache,
       fetch: this.dependencies.cacheFetch ?? ((url2, init) => fetch(url2, init)),
       runCommand: this.dependencies.runCommand,
-      tmpFile: (suffix) => join16(workspace, `cache-${String(cacheSeq++)}${suffix}`),
+      tmpFile: (suffix) => join17(workspace, `cache-${String(cacheSeq++)}${suffix}`),
       // One latch for the whole build so a disabled cache warns once.
       report: { unavailable: false }
     } : null;
@@ -17911,7 +18027,7 @@ var LocalBuildExecutor = class {
           }
         }
         await notifyStatus(observer, "BUILDING");
-        const buildCacheDir = resolved.preset.cachePath ? join16(appRoot, resolved.preset.cachePath) : null;
+        const buildCacheDir = resolved.preset.cachePath ? join17(appRoot, resolved.preset.cachePath) : null;
         const buildCacheKey = sanitizeCacheKey(input.branch);
         if (cachePorts && buildCacheDir) {
           await tryRestore(
@@ -17935,12 +18051,12 @@ var LocalBuildExecutor = class {
             entries: fingerprintEntries,
             nextVersion: nextVersion ? `${String(nextVersion.major)}.${String(nextVersion.minor)}.${String(nextVersion.patch)}` : "unknown"
           });
-          const pristine = join16(workspace, "pristine");
+          const pristine = join17(workspace, "pristine");
           const fork = this.dependencies.forkWorkspace ?? defaultFork;
           await fork(checkout, pristine);
           let forks = 0;
           const forkWorkspace = async (label2) => {
-            const target = join16(
+            const target = join17(
               workspace,
               "forks",
               `${String(forks++)}-${label2.replace(/[^a-z0-9-]/gi, "-")}`
@@ -17997,7 +18113,12 @@ var LocalBuildExecutor = class {
               `Strategy ${resolution.strategy.id} produced a ${resolution.outcome.artifact.kind} artifact, which this control plane cannot deploy.`
             );
           }
-          artifact = resolution.outcome.artifact.artifact;
+          artifact = await withRouteList(
+            resolution.outcome.artifact.artifact,
+            this.dependencies.listNextRoutes ?? listNextRoutes,
+            appRoot,
+            observer
+          );
           strategyRecord = resolution.record;
           await observer.onMetadata?.({ strategy: resolution.record });
         } else {
@@ -18034,6 +18155,13 @@ var LocalBuildExecutor = class {
       }
       await notifyStatus(observer, "DEPLOYING");
       artifact ??= await this.readStatic(appRoot, resolved, identity, observer);
+      if (resolved.preset.id === "next-export")
+        artifact = await withRouteList(
+          artifact,
+          this.dependencies.listNextRoutes ?? listNextRoutes,
+          appRoot,
+          observer
+        );
       return {
         gitCommitSha,
         artifact,
@@ -18193,12 +18321,12 @@ async function errorFromResponse(response, context) {
 // ../../packages/sdk/src/session.ts
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 function credentialsDir(home = homedir()) {
-  return join17(home, ".naro");
+  return join18(home, ".naro");
 }
 function credentialsFile(home = homedir()) {
-  return join17(credentialsDir(home), "credentials.json");
+  return join18(credentialsDir(home), "credentials.json");
 }
 function saveSession(session, home = homedir()) {
   mkdirSync(credentialsDir(home), { recursive: true, mode: 448 });
@@ -19287,7 +19415,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, options = {}) {
     return this.client.request(
@@ -19306,6 +19437,9 @@ var DbApi = class {
   }
 };
 var PROVISION_TIMEOUT_MS = 12e4;
+function writeQuery(options) {
+  return options.allowUnindexed === true ? "?allow_unindexed=1" : "";
+}
 function backendInfo(body) {
   return {
     status: body.status,
@@ -19581,7 +19715,12 @@ var BackendApi = class {
     );
     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"),
@@ -19605,8 +19744,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(
@@ -19615,6 +19755,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, options = {}) {
+    const query = options.table === void 0 ? "" : `?table=${encodeURIComponent(options.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, options = {}) {
+    const answer = await this.client.request(this.path(projectId, `/rls/policies${writeQuery(options)}`), {
+      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, options = {}) {
+    const answer = await this.client.request(
+      this.path(
+        projectId,
+        `${this.namedPath(table, name)}${writeQuery(options)}`
+      ),
+      { 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
@@ -19667,7 +19876,7 @@ function summarizeStatement(statement) {
 
 // ../../packages/sdk/src/dotenv.ts
 import { existsSync, readFileSync as readFileSync2 } from "fs";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 function parseDotenv(text) {
   const out = {};
   for (const line of text.split(/\r?\n/)) {
@@ -19685,7 +19894,7 @@ function parseDotenv(text) {
 }
 function readProjectEnv(dir) {
   for (const name of [".env.local", ".env.production", ".env"]) {
-    const path = join18(dir, name);
+    const path = join19(dir, name);
     if (existsSync(path)) return parseDotenv(readFileSync2(path, "utf8"));
   }
   return {};
@@ -19700,7 +19909,7 @@ function serializeDotenv(vars) {
 
 // ../../packages/sdk/src/env-scan.ts
 import { existsSync as existsSync2, readFileSync as readFileSync3, readdirSync, statSync } from "fs";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 var SOURCE_EXTENSIONS3 = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -19755,7 +19964,7 @@ function collect(dir, out) {
   for (const entry of entries) {
     if (out.length >= MAX_FILES) return;
     if (entry.isSymbolicLink()) continue;
-    const path = join19(dir, entry.name);
+    const path = join20(dir, entry.name);
     if (entry.isDirectory()) {
       if (entry.name.startsWith(".") || SKIP_DIRECTORIES.has(entry.name))
         continue;
@@ -19787,7 +19996,7 @@ function scanEnvReferences(dir) {
     }
   }
   for (const name of EXAMPLE_FILES) {
-    const path = join19(dir, name);
+    const path = join20(dir, name);
     if (!existsSync2(path)) continue;
     let parsed;
     try {
@@ -19805,11 +20014,11 @@ function scanEnvReferences(dir) {
 
 // ../../packages/sdk/src/framework.ts
 import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 function readPackageJson2(dir) {
   try {
     return JSON.parse(
-      readFileSync4(join20(dir, "package.json"), "utf8")
+      readFileSync4(join21(dir, "package.json"), "utf8")
     );
   } catch {
     return null;
@@ -19820,7 +20029,7 @@ function hasDependency(pkg, name) {
 }
 function hasConfig(dir, base2, evidence) {
   for (const ext of ["js", "mjs", "cjs", "ts", "mts"]) {
-    if (existsSync3(join20(dir, `${base2}.${ext}`))) {
+    if (existsSync3(join21(dir, `${base2}.${ext}`))) {
       evidence.push(`${base2}.${ext}`);
       return true;
     }
@@ -19928,8 +20137,8 @@ function detectFramework2(dir) {
     if (!byDependency && !byConfig) continue;
     if (byDependency) evidence.push(`package.json: ${detector.dependency}`);
     if (detector.framework === "nextjs") {
-      if (existsSync3(join20(dir, "app"))) evidence.push("app/");
-      if (existsSync3(join20(dir, "pages"))) evidence.push("pages/");
+      if (existsSync3(join21(dir, "app"))) evidence.push("app/");
+      if (existsSync3(join21(dir, "pages"))) evidence.push("pages/");
     }
     return {
       framework: detector.framework,
@@ -19940,7 +20149,7 @@ function detectFramework2(dir) {
       deployable: true
     };
   }
-  if (!pkg && existsSync3(join20(dir, "index.html"))) {
+  if (!pkg && existsSync3(join21(dir, "index.html"))) {
     evidence.push("index.html (no package.json)");
     return {
       framework: "static",
@@ -19994,6 +20203,276 @@ function systemTablePredicate(column = "name") {
 }
 var SYSTEM_TABLE_SQL_PREDICATE = systemTablePredicate("name");
 
+// ../../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 = [
+  `SELECT t.name AS table_name, t.type AS table_type, c.cid AS cid, c.name AS column_name, c.type AS column_type, c."notnull" AS not_null, c.dflt_value AS default_value, c.pk AS pk, c.hidden AS hidden FROM pragma_table_list AS t JOIN pragma_table_xinfo(t.name, t.schema) AS c WHERE t.schema = 'main' AND t.type IN ('table', 'virtual') AND ${systemTablePredicate("t.name")} ORDER BY t.name, c.cid`,
+  // Phase 2-2 (적대적 리뷰 반영): each table's CREATE TABLE text, where
+  // alone a column's collation is written. A separate statement, so the
+  // text comes once per table rather than once per column. D1 answers
+  // `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 isPlainObject2(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
@@ -20004,6 +20483,1121 @@ function isPlainObject2(value) {
 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 compare2 = ["=", "<>", "!=", "<", "<=", ">", ">="].find(
+    (op) => isOperator(next, op)
+  );
+  if (compare2) {
+    stream.next();
+    count(state, next);
+    const right = readValue(state);
+    return comparable(
+      {
+        kind: "compare",
+        op: compare2 === "!=" ? "<>" : compare2,
+        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 access9 = readJwtAccess(stream);
+  if (access9) return access9;
+  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 access9 = readJwtAccess(stream);
+          if (!access9)
+            throw new PolicySyntaxError(
+              "auth.jwt() is read one claim at a time: (select auth.jwt()) ->> 'email'",
+              auth.position
+            );
+          return access9;
+        }
+        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 quotePolicyName(name) {
+  return /^[a-z_][a-z0-9_]*$/.test(name) && quoteIdent(name) === name ? name : `"${name.replaceAll('"', '""')}"`;
+}
+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, log2) {
+  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("; ");
+    log2?.(
+      `naro data-core: policy ${name} on ${table} cannot be read: ${policy.invalid}`
+    );
+  }
+  return policy;
+}
+function foldPolicyName(name, quoted) {
+  return quoted ? name : asciiLower(name);
+}
+function policySqlTooLong(text) {
+  return utf8ByteLength(text) > MAX_POLICY_SQL_BYTES;
+}
 
 // ../../packages/data-core/src/query.ts
 var FILTER_OPERATORS = [
@@ -20035,7 +21629,11 @@ var ARRAY_OPERATORS = [
   "containedBy",
   "overlaps"
 ];
-var MAX_PATTERN_LENGTH = 1024;
+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) {
@@ -20050,7 +21648,7 @@ function invalid(path, reason) {
 function own(object2, key) {
   return Object.hasOwn(object2, key) ? object2[key] : void 0;
 }
-function isOperator(value) {
+function isOperator2(value) {
   return FILTER_OPERATORS.includes(value);
 }
 function readObject(value, path) {
@@ -20075,7 +21673,7 @@ function readName(value, path) {
     );
   return value;
 }
-function readValue(value, path, auth = false) {
+function readValue2(value, path, auth = false) {
   if (auth && isAuthUid(value)) return { auth: "uid" };
   if (!isValue(value))
     invalid(
@@ -20087,8 +21685,8 @@ function readValue(value, path, auth = false) {
 function longerThan(text, max) {
   if (text.length <= max) return false;
   if (text.length > max * 2) return true;
-  let count = 0;
-  for (const _ of text) if (++count > max) return true;
+  let count2 = 0;
+  for (const _ of text) if (++count2 > max) return true;
   return false;
 }
 function endsWithLoneEscape(pattern) {
@@ -20103,7 +21701,7 @@ function readFilter(value, path, auth) {
   const object2 = readObject(value, path);
   checkKeys(object2, ["operator", "column", "value"], path);
   const operator = own(object2, "operator");
-  if (!isOperator(operator))
+  if (!isOperator2(operator))
     invalid(
       `${path}.operator`,
       `must be one of ${FILTER_OPERATORS.join(", ")}`
@@ -20116,7 +21714,7 @@ function readFilter(value, path, auth) {
     case "in": {
       if (!Array.isArray(raw)) invalid(valuePath, "must be an array");
       const values = raw.map(
-        (item, index) => readValue(item, `${valuePath}[${index}]`, auth)
+        (item, index) => readValue2(item, `${valuePath}[${index}]`, auth)
       );
       return { operator, column, value: values };
     }
@@ -20125,18 +21723,16 @@ function readFilter(value, path, auth) {
         invalid(valuePath, "must be null, true or false");
       return { operator, column, value: raw };
     case "like":
-    case "ilike":
+    case "ilike": {
       if (typeof raw !== "string") invalid(valuePath, "must be a string");
-      if (longerThan(raw, MAX_PATTERN_LENGTH))
-        invalid(
-          valuePath,
-          `must be at most ${String(MAX_PATTERN_LENGTH)} characters`
-        );
+      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":
@@ -20155,7 +21751,7 @@ function readFilter(value, path, auth) {
         )
       };
     default:
-      return { operator, column, value: readValue(raw, valuePath, auth) };
+      return { operator, column, value: readValue2(raw, valuePath, auth) };
   }
 }
 var NODE_KEYS = ["operator", "or", "and", "not"];
@@ -20201,18 +21797,579 @@ function parsePolicyNode(value, path) {
   }
 }
 
-// ../../packages/data-core/src/schema.ts
-var SCHEMA_SQL = [
-  `SELECT t.name AS table_name, t.type AS table_type, c.cid AS cid, c.name AS column_name, c.type AS column_type, c."notnull" AS not_null, c.dflt_value AS default_value, c.pk AS pk, c.hidden AS hidden FROM pragma_table_list AS t JOIN pragma_table_xinfo(t.name, t.schema) AS c WHERE t.schema = 'main' AND t.type IN ('table', 'virtual') AND ${systemTablePredicate("t.name")} ORDER BY t.name, c.cid`,
-  // Phase 2-2 (적대적 리뷰 반영): each table's CREATE TABLE text, where
-  // alone a column's collation is written. A separate statement, so the
-  // text comes once per table rather than once per column. D1 answers
-  // `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")}`
-];
-
 // ../../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 (!isPlainObject2(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 [required2] = trees;
+  for (const key of trees) {
+    if (!Object.hasOwn(value, key)) {
+      if (key === required2)
+        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 isPlainObject2(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, log2) {
+  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;
+    log2?.(
+      `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 base2 = {
+    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 {
+      ...base2,
+      roles: rule === "public" ? everyone : ["authenticated"],
+      using: action === "insert" ? null : TRUE_TEXT,
+      check: action === "insert" ? TRUE_TEXT : null
+    };
+  if (rule === "owner") {
+    const column = ownerColumn ?? "";
+    return {
+      ...base2,
+      roles: ["authenticated"],
+      ...column === "" ? { using: null, check: null } : ownerClauses(column, action),
+      owner: column
+    };
+  }
+  if (isInvalidCondition(rule) || (action === "insert" ? rule.check : rule.using) === void 0)
+    return { ...base2, roles: everyone, using: null, check: null };
+  return {
+    ...base2,
+    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, log2) {
+  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]])
+      ),
+      log2
+    );
+    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-statement.ts
+function readPolicyName(stream) {
+  const token = stream.peek();
+  if (token.kind !== "ident")
+    throw new PolicySyntaxError(
+      `expected a policy name, found ${describeToken(token)}`,
+      token.position
+    );
+  stream.next();
+  return foldPolicyName(token.value, token.quoted);
+}
+function readRoleName(token) {
+  if (token.kind !== "ident")
+    throw new PolicySyntaxError(
+      `expected a role, found ${describeToken(token)}`,
+      token.position
+    );
+  return token.quoted ? token.value : asciiLower(token.value);
+}
+function readCommand(stream) {
+  const token = stream.next();
+  for (const command of [
+    "all",
+    "select",
+    "insert",
+    "update",
+    "delete"
+  ])
+    if (isKeyword(token, command)) return command;
+  throw new PolicySyntaxError(
+    `expected ALL, SELECT, INSERT, UPDATE or DELETE, found ${describeToken(token)}`,
+    token.position
+  );
+}
+function readClause(stream) {
+  const open = stream.expectOperator("(");
+  const expr = readCondition(stream);
+  stream.expectOperator(")");
+  checkExpressionSize(expr, open.position);
+  return { text: printExpr(expr), position: open.position };
+}
+function readCreate(stream, start) {
+  stream.expectKeyword("policy");
+  const name = readPolicyName(stream);
+  stream.expectKeyword("on");
+  const table = readTableName(stream);
+  let permissive = true;
+  if (stream.acceptKeyword("as")) {
+    const token = stream.next();
+    if (isKeyword(token, "restrictive")) permissive = false;
+    else if (!isKeyword(token, "permissive"))
+      throw new PolicySyntaxError(
+        `expected PERMISSIVE or RESTRICTIVE, found ${describeToken(token)}`,
+        token.position
+      );
+  }
+  let command = "all";
+  if (stream.acceptKeyword("for")) command = readCommand(stream);
+  let roles = readRoles(["public"]);
+  if (isKeyword(stream.peek(), "to")) {
+    const to = stream.next();
+    const names = [];
+    do
+      names.push(readRoleName(stream.next()));
+    while (stream.acceptOperator(","));
+    roles = readRoles(names);
+    if (!roles.ok)
+      throw new PolicySyntaxError(roles.reason.replace(/\.$/, ""), to.position);
+  }
+  let using = null;
+  let check2 = null;
+  let position = start.position;
+  if (stream.acceptKeyword("using")) {
+    const clause = readClause(stream);
+    using = clause.text;
+    position = clause.position;
+  }
+  if (isKeyword(stream.peek(), "with")) {
+    stream.next();
+    stream.expectKeyword("check");
+    const clause = readClause(stream);
+    check2 = clause.text;
+    position = clause.position;
+  }
+  if (!roles.ok) throw new Error("unreachable");
+  const policy = {
+    table,
+    name,
+    permissive,
+    command,
+    roles: roles.roles,
+    using,
+    check: check2,
+    owner: null
+  };
+  const problem = policyShapeProblem(policy);
+  if (problem)
+    throw new PolicySyntaxError(problem.replace(/\.$/, ""), position);
+  return { kind: "create", policy };
+}
+function readDrop(stream) {
+  stream.expectKeyword("policy");
+  let ifExists = false;
+  if (stream.acceptKeyword("if")) {
+    stream.expectKeyword("exists");
+    ifExists = true;
+  }
+  const name = readPolicyName(stream);
+  stream.expectKeyword("on");
+  const table = readTableName(stream);
+  if (!stream.acceptKeyword("cascade")) stream.acceptKeyword("restrict");
+  return { kind: "drop", name, table, ifExists };
+}
+function parsePolicyStatement(text) {
+  if (policySqlTooLong(text))
+    return {
+      ok: false,
+      reason: `the statement is longer than ${String(MAX_POLICY_SQL_BYTES)} bytes`,
+      position: 1
+    };
+  try {
+    const stream = new TokenStream(tokenize(text));
+    const start = stream.next();
+    let statement;
+    if (isKeyword(start, "create")) statement = readCreate(stream, start);
+    else if (isKeyword(start, "drop")) statement = readDrop(stream);
+    else if (isKeyword(start, "alter"))
+      throw new PolicySyntaxError(
+        "ALTER POLICY is not supported here yet: DROP POLICY and CREATE POLICY again",
+        start.position
+      );
+    else if (start.kind === "eof")
+      throw new PolicySyntaxError("the statement is empty", 1);
+    else
+      throw new PolicySyntaxError(
+        "only CREATE POLICY and DROP POLICY are accepted here",
+        start.position
+      );
+    stream.acceptOperator(";");
+    const rest = stream.peek();
+    if (rest.kind !== "eof")
+      throw new PolicySyntaxError(
+        isKeyword(rest, "create") || isKeyword(rest, "drop") ? "one statement at a time" : `syntax error at or near ${describeToken(rest)}`,
+        rest.position
+      );
+    return { ok: true, statement };
+  } catch (error51) {
+    if (error51 instanceof PolicySyntaxError)
+      return { ok: false, reason: error51.reason, position: error51.position };
+    throw error51;
+  }
+}
+function splitPolicyStatements(text) {
+  let tokens;
+  try {
+    tokens = tokenize(text);
+  } catch (error51) {
+    if (error51 instanceof PolicySyntaxError)
+      return { ok: false, reason: error51.reason, position: error51.position };
+    throw error51;
+  }
+  const statements = [];
+  let start;
+  for (const token of tokens) {
+    if (token.kind === "eof") break;
+    start ??= token.position - 1;
+    if (token.kind === "op" && token.value === ";") {
+      statements.push(text.slice(start, token.position).trim());
+      start = void 0;
+    }
+  }
+  if (start !== void 0) {
+    const last = text.slice(start).trim();
+    if (last !== "") statements.push(last);
+  }
+  return { ok: true, statements };
+}
 
 // ../../packages/data-core/src/redirect-origins.ts
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
@@ -20259,6 +22416,34 @@ function formatRedirectEntry(entry) {
 }
 
 // ../../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 = [
   {
@@ -20300,6 +22485,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
   }
 ];
 
@@ -20365,12 +22559,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 += " ";
@@ -20548,12 +22742,12 @@ import {
   rmSync as rmSync2,
   writeFileSync as writeFileSync2
 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 function linkDir(dir) {
-  return join21(dir, ".naro");
+  return join22(dir, ".naro");
 }
 function linkFile(dir) {
-  return join21(linkDir(dir), "project.json");
+  return join22(linkDir(dir), "project.json");
 }
 function readProjectLink(dir) {
   try {
@@ -20575,7 +22769,7 @@ function writeProjectLink(dir, link) {
   writeFileSync2(linkFile(dir), `${JSON.stringify(link, null, 2)}
 `);
   writeFileSync2(
-    join21(linkDir(dir), "README.txt"),
+    join22(linkDir(dir), "README.txt"),
     "This directory links the project to Naro and should not be committed.\n"
   );
 }
@@ -20585,9 +22779,9 @@ function removeProjectLink(dir) {
   return true;
 }
 function ensureGitignoreHasNaro(dir) {
-  const gitignorePath = join21(dir, ".gitignore");
+  const gitignorePath = join22(dir, ".gitignore");
   const hasGitignore = existsSync4(gitignorePath);
-  if (!hasGitignore && !existsSync4(join21(dir, ".git"))) return false;
+  if (!hasGitignore && !existsSync4(join22(dir, ".git"))) return false;
   const current = hasGitignore ? readFileSync5(gitignorePath, "utf8") : "";
   const covered = current.split(/\r?\n/).map((line) => line.trim()).some((line) => line === ".naro" || line === ".naro/" || line === "/.naro");
   if (covered) return false;
@@ -20928,10 +23122,10 @@ function buildResetPlan(input) {
   const triggers = sorted(
     objects.filter((object2) => object2.type === "trigger").map((object2) => object2.name)
   );
-  const tableNames = sorted(
+  const tableNames2 = sorted(
     objects.filter((object2) => object2.type === "table" || object2.type === "virtual").map((object2) => object2.name)
   );
-  const canonical = new Map(tableNames.map((name) => [asciiLower(name), name]));
+  const canonical = new Map(tableNames2.map((name) => [asciiLower(name), name]));
   const edges = [];
   for (const edge of input.foreignKeys) {
     const child = canonical.get(asciiLower(edge.child));
@@ -20939,7 +23133,7 @@ function buildResetPlan(input) {
     if (child !== void 0 && parent !== void 0 && child !== parent)
       edges.push({ child, parent });
   }
-  const ordered = tableGroups(tableNames, edges);
+  const ordered = tableGroups(tableNames2, edges);
   refuseOversizedCycle(ordered);
   const clear = clearInternal(input.internal);
   const groups = [
@@ -20958,7 +23152,7 @@ function buildResetPlan(input) {
 
 // src/env-consent.ts
 import { existsSync as existsSync6 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 var DOTENV_FILES = [".env.local", ".env.production", ".env"];
 var PUBLIC_PREFIXES = ["NEXT_PUBLIC_", "VITE_", "REACT_APP_", "PUBLIC_"];
 function maskEnvValue(key, value) {
@@ -20967,7 +23161,7 @@ function maskEnvValue(key, value) {
   return value.length <= 8 ? "****" : `${value.slice(0, 4)}****`;
 }
 function findDotenvFile(dir) {
-  for (const name of DOTENV_FILES) if (existsSync6(join22(dir, name))) return name;
+  for (const name of DOTENV_FILES) if (existsSync6(join23(dir, name))) return name;
   return null;
 }
 function envAddGuidance(keys) {
@@ -21038,6 +23232,24 @@ async function tryExec(exec, args, cwd) {
     return null;
   }
 }
+var COMMIT_SHA = /^[0-9a-f]{40}$/;
+var MAX_COMMIT_MESSAGE = 300;
+async function detectCommit(exec, dir) {
+  const sha = (await tryExec(exec, ["rev-parse", "HEAD"], dir))?.toLowerCase();
+  if (!sha || !COMMIT_SHA.test(sha)) return null;
+  const subject = await tryExec(exec, ["log", "-1", "--format=%s"], dir);
+  let dirty;
+  try {
+    dirty = (await exec(["status", "--porcelain"], dir)).trim().length > 0;
+  } catch {
+    dirty = true;
+  }
+  return {
+    sha,
+    message: subject === null ? null : [...subject].slice(0, MAX_COMMIT_MESSAGE).join(""),
+    dirty
+  };
+}
 async function detectGitInfo(dir, exec = defaultExec) {
   const remote = await tryExec(exec, ["remote", "get-url", "origin"], dir);
   const branch = await tryExec(
@@ -21046,10 +23258,12 @@ async function detectGitInfo(dir, exec = defaultExec) {
     dir
   );
   const prefix = await tryExec(exec, ["rev-parse", "--show-prefix"], dir);
+  const commit = await detectCommit(exec, dir);
   return {
     repositoryUrl: remote !== null && SUPPORTED_REMOTE.some((re) => re.test(remote)) ? remote : null,
     branch: branch !== null && branch !== "HEAD" ? branch : null,
-    prefix: prefix === null ? null : prefix.replace(/\/+$/, "") || null
+    prefix: prefix === null ? null : prefix.replace(/\/+$/, "") || null,
+    commit
   };
 }
 
@@ -21133,7 +23347,8 @@ function manifest(artifact) {
     compatibilityDate: artifact.compatibilityDate,
     compatibilityFlags: artifact.compatibilityFlags,
     assetsBinding: artifact.assetsBinding,
-    ...artifact.assetsConfig ? { assetsConfig: artifact.assetsConfig } : {}
+    ...artifact.assetsConfig ? { assetsConfig: artifact.assetsConfig } : {},
+    ...artifact.routes ? { routes: artifact.routes } : {}
   };
 }
 async function uploadArtifact(artifact, opts) {
@@ -21215,8 +23430,14 @@ function eventsObserver(cp3, deploymentId, token, fetchImpl = fetch, logIngestUr
     onLog: (log2) => batcher.add(log2).catch(() => {
     }),
     onMetadata: async (metadata) => {
+      const {
+        gitCommitSha: _sha,
+        gitCommitMessage: _message,
+        ...rest
+      } = metadata;
+      if (Object.keys(rest).length === 0) return;
       await flushLogs();
-      await post({ type: "metadata", metadata }).catch(() => {
+      await post({ type: "metadata", metadata: rest }).catch(() => {
       });
     }
   };
@@ -21228,7 +23449,7 @@ function slugify2(value) {
 async function projectName(sourceDir) {
   try {
     const pkg = JSON.parse(
-      await readFile13(join23(sourceDir, "package.json"), "utf8")
+      await readFile13(join24(sourceDir, "package.json"), "utf8")
     );
     if (pkg.name) return pkg.name;
   } catch {
@@ -21239,7 +23460,7 @@ var COPY_SKIP = /(^|[\\/])(node_modules|\.next|\.open-next|\.git|\.wrangler|\.tu
 function resolveBin(name) {
   let dir = dirname4(fileURLToPath(import.meta.url));
   for (; ; ) {
-    const candidate = join23(dir, "node_modules", ".bin", name);
+    const candidate = join24(dir, "node_modules", ".bin", name);
     if (existsSync7(candidate)) return candidate;
     const parent = dirname4(dir);
     if (parent === dir) return name;
@@ -21266,7 +23487,7 @@ async function detectPackageManagerLenient(root) {
 }
 function localDependencies(sourceDir) {
   return {
-    createWorkspace: () => mkdtemp2(join23(tmpdir2(), "naro-build-")),
+    createWorkspace: () => mkdtemp2(join24(tmpdir2(), "naro-build-")),
     removeWorkspace: (path) => rm3(path, { recursive: true, force: true }),
     async runCommand(spec, observer) {
       if (spec.command === "git" && spec.args[0] === "clone") {
@@ -21371,7 +23592,8 @@ async function deployDirectory(sourceDir, options, log2) {
     ...git.repositoryUrl != null && { repositoryUrl: git.repositoryUrl },
     ...branch != null && { branch },
     ...repositoryRoot != null && { rootDirectory: repositoryRoot },
-    ...Object.keys(envToSend).length > 0 && { env: envToSend }
+    ...Object.keys(envToSend).length > 0 && { env: envToSend },
+    ...git.commit != null && { commit: git.commit }
   });
   if (ctx.envSkipped?.length)
     log2(`\u26A0 skipped env: ${ctx.envSkipped.join(", ")}`);
@@ -21487,7 +23709,12 @@ export {
   summarizeStatement,
   serializeDotenv,
   systemTablePredicate,
+  quoteIdent,
+  commentText,
+  quotePolicyName,
   parsePolicyNode,
+  parsePolicyStatement,
+  splitPolicyStatements,
   parseRedirectEntry,
   formatRedirectEntry,
   policiesForTypes,