@runa-ai/runa-cli 0.7.1 → 0.7.3

package/dist/{build-HUDIP6KU.js → build-HQMSVN6N.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
 import './chunk-QDF7QXBL.js';
-import { getSnapshotStateName, isSnapshotComplete } from './chunk-EMB6IZFT.js';
-import { guards, manifestActor, supabaseStartActor, envCheckActor, depsInstallActor, detectTurbo, detectManifestTask, detectDatabase, checkSupabaseStatus } from './chunk-2APB25TT.js';
+import { getSnapshotStateName, isSnapshotComplete } from './chunk-XVNDDHAF.js';
+import { guards, manifestActor, supabaseStartActor, envCheckActor, depsInstallActor, detectTurbo, detectManifestTask, detectDatabase, checkSupabaseStatus } from './chunk-VSH3IXDQ.js';
 import { findRepoRoot } from './chunk-3WDV32GA.js';
 import { runLogged } from './chunk-6FAU4IGR.js';
 import { createMachineStateChangeLogger } from './chunk-5FT3F36G.js';
 import './chunk-II7VYQEM.js';
-import './chunk-VM3IWOT5.js';
+import './chunk-QSEF4T3Y.js';
 import { securePnpm } from './chunk-RZLYEO4U.js';
 import { emitJsonSuccess } from './chunk-KE6QJBZG.js';
 import './chunk-WJXC4MVY.js';

package/dist/{check-LOMVIRHX.js → check-PCSQPYDM.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-export { checkCommand, runCheckCommand } from './chunk-QM53IQHM.js';
-import './chunk-644FVGIQ.js';
+export { checkCommand, runCheckCommand } from './chunk-2QX7T24B.js';
+import './chunk-WPMR7RQ4.js';
 import './chunk-DRSUEMAK.js';
 import './chunk-KE6QJBZG.js';
 import './chunk-WJXC4MVY.js';

package/dist/{chunk-QM53IQHM.js → chunk-2QX7T24B.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { loadEnvFiles } from './chunk-644FVGIQ.js';
+import { loadEnvFiles } from './chunk-WPMR7RQ4.js';
 import { emitJsonSuccess } from './chunk-KE6QJBZG.js';
 import { getOutputFormatFromEnv } from './chunk-HKUWEGUX.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';

package/dist/{chunk-CCW3PLQY.js → chunk-3JO6YP3T.js}

@@ -16,7 +16,7 @@ init_esm_shims();
 
 // src/constants/versions.ts
 init_esm_shims();
-var COMPATIBLE_TEMPLATES_VERSION = "0.7.1";
+var COMPATIBLE_TEMPLATES_VERSION = "0.7.3";
 var TEMPLATES_PACKAGE_NAME = "@r06-dev/runa-templates";
 var GITHUB_PACKAGES_REGISTRY = "https://npm.pkg.github.com";
 

package/dist/{chunk-XDCHRVE3.js → chunk-4XHZQRRK.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { stripSqlComments } from './chunk-7B5C6U2K.js';
+import { stripSqlComments } from './chunk-A6A7JIRD.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
@@ -98,7 +98,7 @@ function formatSchemasForSql(schemas) {
   }).join(", ");
 }
 
-// src/commands/ci/utils/db-url-utils.ts
+// src/utils/db-url-utils.ts
 init_esm_shims();
 function resolveHostToIPv4(hostname) {
   const ipVersion = isIP(hostname);

package/dist/{chunk-7B5C6U2K.js → chunk-A6A7JIRD.js}

@@ -2,6 +2,10 @@
 import { createRequire } from 'module';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 import { spawnSync } from 'child_process';
+import { randomUUID } from 'crypto';
+import { writeFileSync, unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
 import { execa } from 'execa';
 
 createRequire(import.meta.url);
@@ -49,7 +53,8 @@ function psqlSyncFile(params) {
   const result = spawnSync("psql", [...args, "-f", params.filePath], {
     encoding: "utf-8",
     stdio: ["pipe", "pipe", "pipe"],
-    env: buildPsqlEnv(conn)
+    env: buildPsqlEnv(conn),
+    timeout: params.timeout ?? 3e5
   });
   return {
     status: result.status,
@@ -81,6 +86,34 @@ async function psqlExec(params) {
     stdio: "inherit"
   });
 }
+function psqlSyncBatch(params) {
+  if (params.statements.length === 0) {
+    return { status: 0, stdout: "", stderr: "" };
+  }
+  if (params.statements.length === 1) {
+    return psqlSyncQuery({
+      databaseUrl: params.databaseUrl,
+      sql: params.statements[0],
+      timeout: params.timeout
+    });
+  }
+  const tmpFile = join(tmpdir(), `runa-batch-${randomUUID()}.sql`);
+  writeFileSync(tmpFile, `${params.statements.join(";\n")};
+`, "utf-8");
+  try {
+    return psqlSyncFile({
+      databaseUrl: params.databaseUrl,
+      filePath: tmpFile,
+      onErrorStop: params.onErrorStop ?? false,
+      timeout: params.timeout ?? 6e4
+    });
+  } finally {
+    try {
+      unlinkSync(tmpFile);
+    } catch {
+    }
+  }
+}
 
 // src/lib/sql-comment-utils.ts
 init_esm_shims();
@@ -271,4 +304,4 @@ function consumeDollarQuotedBody(content, index) {
   };
 }
 
-export { blankDollarQuotedBodies, buildPsqlArgs, buildPsqlEnv, parsePostgresUrl, psqlExec, psqlQuery, psqlSyncFile, psqlSyncQuery, stripSqlComments };
+export { blankDollarQuotedBodies, buildPsqlArgs, buildPsqlEnv, parsePostgresUrl, psqlExec, psqlQuery, psqlSyncBatch, psqlSyncFile, psqlSyncQuery, stripSqlComments };

package/dist/{chunk-AFY3TX4I.js → chunk-AO554K3G.js}

@@ -6,7 +6,7 @@ createRequire(import.meta.url);
 
 // src/version.ts
 init_esm_shims();
-var CLI_VERSION = "0.7.1";
+var CLI_VERSION = "0.7.3";
 var HAS_ADMIN_COMMAND = false;
 
 export { CLI_VERSION, HAS_ADMIN_COMMAND };

package/dist/{chunk-Z4Z5DNW4.js → chunk-B3POLMII.js}

@@ -874,6 +874,18 @@ async function processFiles(options) {
     state.resolutionDetails.push(...result.resolutionDetails);
     await handleChangedFile(result, check, repoRoot, verbose, state);
   }
+  const processedFiles = /* @__PURE__ */ new Set([...withMachineDefinitions, ...withMachineHooks, ...withJsxOnly]);
+  for (const filePath of files) {
+    if (processedFiles.has(filePath)) {
+      continue;
+    }
+    try {
+      const code = await fs2.promises.readFile(filePath, "utf-8");
+      const relativePath = path3.relative(repoRoot, filePath);
+      collectRouteInfo(relativePath, code, verbose);
+    } catch {
+    }
+  }
   if (!check) {
     await formatChangedFiles(state.filesToFormat, repoRoot, verbose);
   }

package/dist/chunk-CKRLVEIO.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { env } from './chunk-UHDAYPHH.js';
+import { redactSecrets } from './chunk-II7VYQEM.js';
+import { init_local_supabase, buildLocalDatabaseUrl } from './chunk-QSEF4T3Y.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { CLIError } from '@runa-ai/runa';
+
+createRequire(import.meta.url);
+
+// src/commands/db/utils/db-target.ts
+init_esm_shims();
+init_local_supabase();
+function getLocalDatabaseUrl() {
+  return buildLocalDatabaseUrl(process.cwd());
+}
+function isLocalHostname(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "host.docker.internal";
+}
+function isLocalDatabaseUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return isLocalHostname(parsed.hostname);
+  } catch {
+    return false;
+  }
+}
+function getExplicitLocalAdminUrl() {
+  const explicitAdminUrl = process.env.DATABASE_URL_ADMIN?.trim();
+  if (!explicitAdminUrl) return void 0;
+  return isLocalDatabaseUrl(explicitAdminUrl) ? explicitAdminUrl : void 0;
+}
+function resolveDatabaseTarget(environment) {
+  switch (environment) {
+    case "local": {
+      const explicitAdminUrl = getExplicitLocalAdminUrl();
+      const url = explicitAdminUrl || getLocalDatabaseUrl();
+      if (!isLocalDatabaseUrl(url)) {
+        throw new CLIError("Local database URL appears to be a remote URL", "LOCAL_DB_URL_REMOTE", [
+          "Local operations should use the local Supabase instance",
+          // SECURITY (Issue #513): Redact credentials from database URL in error message
+          `Current URL: ${redactSecrets(url)}`,
+          "If you need to connect to a remote DB, use --env preview or --env production"
+        ]);
+      }
+      return {
+        url,
+        source: explicitAdminUrl ? "DATABASE_URL_ADMIN" : "LOCAL_SUPABASE"
+      };
+    }
+    case "preview": {
+      const explicitAdminUrl = process.env.DATABASE_URL_ADMIN;
+      if (explicitAdminUrl) {
+        return { url: explicitAdminUrl, source: "DATABASE_URL_ADMIN" };
+      }
+      if (env.DATABASE_URL) {
+        return { url: env.DATABASE_URL, source: "DATABASE_URL" };
+      }
+      const fallbackUrl = process.env.DATABASE_URL;
+      if (!fallbackUrl) {
+        throw new CLIError("Preview database URL not found", "PREVIEW_DB_URL_NOT_FOUND", [
+          "Set DATABASE_URL_ADMIN environment variable (for DDL/migrations)",
+          "Or set DATABASE_URL as fallback"
+        ]);
+      }
+      return { url: fallbackUrl, source: "DATABASE_URL" };
+    }
+    case "main":
+    case "production": {
+      const ghAdminUrl = process.env.GH_DATABASE_URL_ADMIN;
+      if (ghAdminUrl) {
+        if (isLocalDatabaseUrl(ghAdminUrl)) {
+          throw new CLIError(
+            "Production database URL points to localhost",
+            "PRODUCTION_DB_URL_IS_LOCAL",
+            [
+              "Use --env local for local Supabase operations",
+              "Production operations require a remote database URL",
+              "Set DATABASE_URL_ADMIN or GH_DATABASE_URL_ADMIN to the production database URL"
+            ]
+          );
+        }
+        return { url: ghAdminUrl, source: "GH_DATABASE_URL_ADMIN" };
+      }
+      const explicitAdminUrl = process.env.DATABASE_URL_ADMIN;
+      if (explicitAdminUrl) {
+        if (isLocalDatabaseUrl(explicitAdminUrl)) {
+          throw new CLIError(
+            "Production database URL points to localhost",
+            "PRODUCTION_DB_URL_IS_LOCAL",
+            [
+              "Use --env local for local Supabase operations",
+              "Production operations require a remote database URL",
+              "Set DATABASE_URL_ADMIN or GH_DATABASE_URL_ADMIN to the production database URL"
+            ]
+          );
+        }
+        return { url: explicitAdminUrl, source: "DATABASE_URL_ADMIN" };
+      }
+      throw new CLIError("Production database URL not found", "PRODUCTION_DB_URL_NOT_FOUND", [
+        "Set GH_DATABASE_URL_ADMIN (CI) or DATABASE_URL_ADMIN (local) to a direct postgres URL",
+        "Do not use GH_DATABASE_URL or DATABASE_URL for DDL operations"
+      ]);
+    }
+  }
+}
+function resolveDatabaseUrl(environment) {
+  return resolveDatabaseTarget(environment).url;
+}
+function tryResolveDatabaseUrl(environment) {
+  try {
+    return resolveDatabaseUrl(environment);
+  } catch (error) {
+    if (error instanceof CLIError) return void 0;
+    throw error;
+  }
+}
+
+export { resolveDatabaseTarget, resolveDatabaseUrl, tryResolveDatabaseUrl };

package/dist/{chunk-HD74F6W2.js → chunk-FWMGC5FP.js}

@@ -185,6 +185,7 @@ function createErrorOutput(repoRoot, error, extraFields) {
     anonKey: "",
     layers: [],
     expectedDrift: [],
+    diagnostics: {},
     error: error instanceof Error ? error.message : String(error)
   };
   return { ...baseError, ...extraFields };

package/dist/{chunk-FHG3ILE4.js → chunk-OBYZDT2E.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { psqlQuery, stripSqlComments } from './chunk-7B5C6U2K.js';
+import { psqlQuery, stripSqlComments } from './chunk-A6A7JIRD.js';
 import { loadRunaConfig } from './chunk-5NKWR4FF.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 import { existsSync, writeFileSync, unlinkSync, readdirSync, readFileSync, mkdirSync, realpathSync } from 'fs';
@@ -33,6 +33,7 @@ function buildEnvLocalContent(config) {
     "# This file overrides .env.development so that `pnpm dev` uses correct ports.",
     "# Removed automatically by `runa db stop`. Safe to delete manually.",
     `DATABASE_URL=${dbUrl}`,
+    `DATABASE_URL_LISTENER=${dbUrl}`,
     `DATABASE_URL_ADMIN=${dbUrl}`,
     `DATABASE_URL_SERVICE=${dbUrl}`,
     `NEXT_PUBLIC_SUPABASE_URL=http://${config.host}:${config.api}`,
@@ -931,17 +932,32 @@ function convertAstIndexes(indexes, include) {
     isUnique: idx.isUnique
   }));
 }
+async function buildPolicyMap(policies, include) {
+  if (!include) return /* @__PURE__ */ new Map();
+  const map = /* @__PURE__ */ new Map();
+  for (const policy of policies) {
+    const key = `${policy.schema}.${policy.table}`.toLowerCase();
+    const existing = map.get(key) ?? [];
+    existing.push({
+      name: policy.name,
+      command: policy.for.toUpperCase(),
+      using: policy.using,
+      withCheck: policy.withCheck
+    });
+    map.set(key, existing);
+  }
+  return map;
+}
 async function extractTablesWithAst(content, filePath, opts) {
   const parser = await getSqlParserUtils();
   if (!parser) return [];
-  const astTables = await parser.parseCreateTables(content);
+  const schemaDocument = await parser.parseSchemaDocument(content);
+  const astTables = schemaDocument.tables;
+  const policyMap = await buildPolicyMap(schemaDocument.policies, opts.includeRlsPolicies);
   const tables = [];
   for (const astTable of astTables) {
-    if (opts.includeIndexes) {
-      await parser.parseIndexesForTables(content, [astTable]);
-    }
     const hasRls = hasRlsEnabledRegex(content, astTable.schema, astTable.name);
-    const rlsPolicies = opts.includeRlsPolicies && hasRls ? parsePoliciesRegex(content, astTable.schema, astTable.name) : void 0;
+    const rlsPolicies = opts.includeRlsPolicies && hasRls ? policyMap.get(astTable.qualifiedName.toLowerCase()) : void 0;
     tables.push({
       schema: astTable.schema,
       name: astTable.name,
@@ -963,11 +979,25 @@ async function extractTablesWithAst(content, filePath, opts) {
 // src/commands/db/utils/sql-table-extractor.ts
 var sqlParserUtils = null;
 var astAvailable = null;
+function hasRequiredSqlParserSurface(parser) {
+  return Boolean(
+    parser && typeof parser.isSqlParserAvailable === "function" && typeof parser.parseSchemaDocument === "function" && typeof parser.parseCreateTables === "function" && typeof parser.parseIndexesForTables === "function" && typeof parser.parseCreatePolicies === "function"
+  );
+}
+async function loadSqlParserUtilsWithFallback() {
+  const { loadSqlParserUtils } = await import('@runa-ai/runa/ast');
+  const loaded = await loadSqlParserUtils();
+  if (!hasRequiredSqlParserSurface(loaded)) {
+    throw new Error(
+      "SQL parser utilities are unavailable or missing required schema document helpers"
+    );
+  }
+  return loaded;
+}
 async function isAstParserAvailable() {
   if (astAvailable !== null) return astAvailable;
   try {
-    const { loadSqlParserUtils } = await import('@runa-ai/runa/ast');
-    sqlParserUtils = await loadSqlParserUtils();
+    sqlParserUtils = await loadSqlParserUtilsWithFallback();
     const isAvailable = await sqlParserUtils.isSqlParserAvailable();
     astAvailable = isAvailable;
     return isAvailable;

package/dist/{chunk-H2AHNI75.js → chunk-PAWNJA3N.js}

@@ -9,7 +9,7 @@ init_esm_shims();
 var riskDetectorModulePromise = null;
 async function loadRiskDetectorModule() {
   if (!riskDetectorModulePromise) {
-    riskDetectorModulePromise = import('./risk-detector-core-TK4OAI3N.js').catch((error) => {
+    riskDetectorModulePromise = import('./risk-detector-core-TGFKWHRS.js').catch((error) => {
       riskDetectorModulePromise = null;
       throw error;
     });

package/dist/{chunk-VM3IWOT5.js → chunk-QSEF4T3Y.js}

@@ -110,9 +110,10 @@ function resolveSupabaseRoot(projectRoot) {
 function isAllowedLocalhostHost(host) {
   return host === "127.0.0.1" || host === "localhost" || host === "host.docker.internal";
 }
-function buildDetectionCacheKey(projectRoot) {
+function buildDetectionCacheKey(projectRoot, options) {
   return [
     projectRoot,
+    options.skipStatusDetection === true ? "skip-status" : "with-status",
     process.env.LOCAL_SUPABASE_HOST ?? "",
     process.env.LOCAL_SUPABASE_API_PORT ?? "",
     process.env.LOCAL_SUPABASE_DB_PORT ?? "",
@@ -127,9 +128,9 @@ function readSupabaseOverrides() {
     studio: asPort(process.env.LOCAL_SUPABASE_STUDIO_PORT, DEFAULT_STUDIO_PORT)
   };
 }
-function detectLocalSupabasePorts(projectRoot = process.cwd()) {
+function detectLocalSupabasePorts(projectRoot = process.cwd(), options = {}) {
   const resolvedRoot = resolveSupabaseRoot(projectRoot);
-  const cacheKey = buildDetectionCacheKey(resolvedRoot);
+  const cacheKey = buildDetectionCacheKey(resolvedRoot, options);
   if (detectionCache?.key === cacheKey) {
     return detectionCache.config;
   }
@@ -151,7 +152,7 @@ function detectLocalSupabasePorts(projectRoot = process.cwd()) {
     };
     return explicitConfig;
   }
-  const status = detectStatus(resolvedRoot);
+  const status = options.skipStatusDetection === true ? null : detectStatus(resolvedRoot);
   const tomlPorts = parseTomlPorts(resolvedRoot);
   const statusApiUrl = status ? getStatusValue(status, ["API_URL", "API URL", "api_url"]) : null;
   const statusDbUrl = status ? getStatusValue(status, ["DB_URL", "DB URL", "db_url"]) : null;
@@ -200,6 +201,7 @@ function getLocalSupabaseEnvValues(projectRoot = process.cwd()) {
     LOCAL_SUPABASE_API_PORT: String(config.api),
     LOCAL_SUPABASE_DB_PORT: String(config.db),
     DATABASE_URL: databaseUrl,
+    DATABASE_URL_LISTENER: databaseUrl,
     DATABASE_URL_ADMIN: databaseUrl,
     DATABASE_URL_SERVICE: databaseUrl,
     NEXT_PUBLIC_SUPABASE_URL: supabaseUrl,
@@ -214,6 +216,7 @@ function getLocalValueDescriptions(projectRoot = process.cwd()) {
     LOCAL_SUPABASE_API_PORT: `supabase local api port ${config.api}`,
     LOCAL_SUPABASE_DB_PORT: `supabase local db port ${config.db}`,
     DATABASE_URL: `supabase local DB ${config.host}:${config.db}`,
+    DATABASE_URL_LISTENER: `supabase local DB ${config.host}:${config.db}`,
     DATABASE_URL_ADMIN: `supabase local DB ${config.host}:${config.db}`,
     DATABASE_URL_SERVICE: `supabase local DB ${config.host}:${config.db}`,
     NEXT_PUBLIC_SUPABASE_URL: `supabase local API ${config.host}:${config.api}`,
@@ -224,6 +227,7 @@ function getLocalValueDescriptions(projectRoot = process.cwd()) {
 function validateLocalhostValues(envValues) {
   const urlKeys = [
     "DATABASE_URL",
+    "DATABASE_URL_LISTENER",
     "DATABASE_URL_ADMIN",
     "DATABASE_URL_SERVICE",
     "NEXT_PUBLIC_SUPABASE_URL"
@@ -290,7 +294,11 @@ function detectSupabasePorts(projectRoot) {
   }
   let status;
   try {
-    status = JSON.parse(result.stdout);
+    const jsonMatch = result.stdout.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      throw new Error("No JSON object found in output");
+    }
+    status = JSON.parse(jsonMatch[0]);
   } catch {
     throw new Error(
       "Failed to parse Supabase status output.\n\nTry restarting Supabase: supabase stop && supabase start"

package/dist/{chunk-NPSRD26F.js → chunk-UHDAYPHH.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { init_constants, constants_exports } from './chunk-VM3IWOT5.js';
+import { init_constants, constants_exports } from './chunk-QSEF4T3Y.js';
 import { init_esm_shims, __toCommonJS } from './chunk-VRXHCR5K.js';
 import { z } from 'zod';
 

package/dist/{chunk-2APB25TT.js → chunk-VSH3IXDQ.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
 import { runLogged } from './chunk-6FAU4IGR.js';
-import { init_constants, detectSupabasePorts } from './chunk-VM3IWOT5.js';
+import { init_constants, detectSupabasePorts } from './chunk-QSEF4T3Y.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 import { execSync, spawnSync } from 'child_process';
 import { existsSync, statSync, readFileSync } from 'fs';
@@ -301,14 +301,18 @@ var manifestActor = fromPromise(
     const { repoRoot, tmpDir, env = process.env } = input;
     const startTime = Date.now();
     try {
+      const cliEntry = process.argv[1];
+      if (!cliEntry) {
+        throw new Error("Unable to resolve current CLI entry for manifest generation");
+      }
       const fullTmpDir = path2.join(repoRoot, tmpDir);
       await mkdir(fullTmpDir, { recursive: true });
       await runLogged({
         cwd: repoRoot,
         env,
         label: "manifest",
-        command: "pnpm",
-        args: ["exec", "runa", "manifest"],
+        command: process.execPath,
+        args: [cliEntry, "manifest"],
         logFile: path2.join(fullTmpDir, "manifest.log")
       });
       return {

package/dist/{chunk-644FVGIQ.js → chunk-WPMR7RQ4.js}

@@ -114,7 +114,12 @@ function loadEnvFiles(options = {}) {
     applyTargetEnvToProcessEnv({ targetEnv, protectedKeys });
   }
   if (options.runaEnv === "local") {
-    const localExcludedKeys = ["DATABASE_URL", "DATABASE_URL_ADMIN", "DATABASE_URL_SERVICE"];
+    const localExcludedKeys = [
+      "DATABASE_URL",
+      "DATABASE_URL_LISTENER",
+      "DATABASE_URL_ADMIN",
+      "DATABASE_URL_SERVICE"
+    ];
     for (const key of localExcludedKeys) {
       delete process.env[key];
     }
@@ -132,7 +137,9 @@ function loadEnvFiles(options = {}) {
       process.stderr.write("   \u{1F513} Auto-decrypted with .env.keys\n");
     }
     if (options.runaEnv === "local") {
-      process.stderr.write("   \u{1F3E0} Local mode: DATABASE_URL excluded (using local Supabase)\n");
+      process.stderr.write(
+        "   \u{1F3E0} Local mode: runtime DATABASE_URL* vars excluded (using local Supabase)\n"
+      );
     }
   }
   return { projectRoot, loadedFiles };

package/dist/{chunk-EMB6IZFT.js → chunk-XVNDDHAF.js}

@@ -36,6 +36,25 @@ function getSnapshotStateName(snapshot) {
   const nested = flattenState(child);
   return nested ? `${parent}.${nested}` : parent;
 }
+function getSnapshotStatePaths(snapshot) {
+  function collect(value, prefix = "") {
+    if (typeof value === "string") {
+      return [prefix ? `${prefix}.${value}` : value];
+    }
+    if (!value || typeof value !== "object") {
+      return prefix ? [prefix] : [];
+    }
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return prefix ? [prefix] : [];
+    }
+    return entries.flatMap(([key, childValue]) => {
+      const nextPrefix = prefix ? `${prefix}.${key}` : key;
+      return collect(childValue, nextPrefix);
+    });
+  }
+  return collect(snapshot.value);
+}
 function isSnapshotComplete(snapshot) {
   return snapshot.status === "done";
 }
@@ -43,4 +62,4 @@ function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-export { getErrorMessage, getSnapshotStateName, isSnapshotComplete };
+export { getErrorMessage, getSnapshotStateName, getSnapshotStatePaths, isSnapshotComplete };