latticesql 4.2.0 → 4.2.2

package/dist/index.cjs

@@ -231,10 +231,10 @@ function manifestPath(outputDir) {
   return (0, import_node_path2.join)(outputDir, ".lattice", "manifest.json");
 }
 function readManifest(outputDir) {
-  const path2 = manifestPath(outputDir);
-  if (!(0, import_node_fs2.existsSync)(path2)) return null;
+  const path3 = manifestPath(outputDir);
+  if (!(0, import_node_fs2.existsSync)(path3)) return null;
   try {
-    return JSON.parse((0, import_node_fs2.readFileSync)(path2, "utf8"));
+    return JSON.parse((0, import_node_fs2.readFileSync)(path3, "utf8"));
   } catch {
     return null;
   }
@@ -249,7 +249,7 @@ var init_manifest = __esm({
     import_node_path2 = require("path");
     import_node_fs2 = require("fs");
     init_writer();
-    TEMPLATE_VERSION = 1;
+    TEMPLATE_VERSION = 2;
   }
 });
 
@@ -424,20 +424,131 @@ var init_render_cursor = __esm({
   }
 });
 
+// src/db/load-sqlite.ts
+function runtimeRequire() {
+  const importMetaUrl = import_meta.url;
+  return importMetaUrl ? (0, import_node_module.createRequire)(importMetaUrl) : (
+    // CJS fallback — Node provides `require` on every CJS module scope. Under
+    // tsup's CJS output `import.meta.url` is rewritten to undefined, so this
+    // branch keeps the loader working in the published .cjs bundle.
+    require
+  );
+}
+function asCtor(mod) {
+  return mod.default ?? mod;
+}
+function isAbiMismatch(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  const code = err.code;
+  return message.includes("NODE_MODULE_VERSION") || code === "ERR_DLOPEN_FAILED" || message.includes("was compiled against a different Node.js version");
+}
+function autoRebuildDisabled() {
+  const v2 = process.env.LATTICE_SQLITE_NO_AUTOREBUILD;
+  if (!v2) return false;
+  const normalized = v2.trim().toLowerCase();
+  return normalized !== "" && normalized !== "0" && normalized !== "false" && normalized !== "no";
+}
+function installRootFor(req) {
+  const pkgJsonPath = req.resolve("better-sqlite3/package.json");
+  return import_node_path3.default.resolve(import_node_path3.default.dirname(pkgJsonPath), "..", "..");
+}
+function defaultRebuild(installRoot) {
+  const npmBin = process.platform === "win32" ? "npm.cmd" : "npm";
+  const res = (0, import_node_child_process.spawnSync)(npmBin, ["rebuild", "better-sqlite3"], {
+    cwd: installRoot,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf8",
+    timeout: 5 * 60 * 1e3
+  });
+  if (res.error) {
+    return { ok: false, reason: res.error.message };
+  }
+  if (res.status !== 0) {
+    const stderr = res.stderr.trim();
+    const tail = stderr ? stderr.slice(-300) : `npm rebuild exited with code ${String(res.status)}`;
+    return { ok: false, reason: tail };
+  }
+  return { ok: true };
+}
+function resolveSqliteCtor(options = {}) {
+  const req = options.require ?? runtimeRequire();
+  const rebuild = options.rebuild ?? defaultRebuild;
+  const resolveInstallRoot = options.installRoot ?? installRootFor;
+  const log = options.log ?? ((msg) => process.stderr.write(msg + "\n"));
+  let firstError;
+  try {
+    return asCtor(req("better-sqlite3"));
+  } catch (err) {
+    firstError = err;
+  }
+  if (!isAbiMismatch(firstError)) {
+    throw new Error(PEER_DEP_MISSING_MESSAGE);
+  }
+  if (autoRebuildDisabled()) {
+    throw new Error(
+      rebuildFailedMessage("automatic rebuild is disabled (LATTICE_SQLITE_NO_AUTOREBUILD)")
+    );
+  }
+  log("[latticesql] SQLite engine built for a different Node runtime \u2014 rebuilding better-sqlite3\u2026");
+  let installRoot;
+  try {
+    installRoot = resolveInstallRoot(req);
+  } catch (err) {
+    throw new Error(
+      rebuildFailedMessage(
+        "could not locate the better-sqlite3 install root (" + (err instanceof Error ? err.message : String(err)) + ")"
+      )
+    );
+  }
+  const outcome = rebuild(installRoot);
+  if (!outcome.ok) {
+    throw new Error(rebuildFailedMessage(outcome.reason));
+  }
+  try {
+    return asCtor(req("better-sqlite3"));
+  } catch (err) {
+    throw new Error(
+      rebuildFailedMessage(
+        "the rebuilt module still failed to load (" + (err instanceof Error ? err.message : String(err)) + ")"
+      )
+    );
+  }
+}
+function rebuildFailedMessage(reason) {
+  return "latticesql: the better-sqlite3 native module doesn\u2019t match this Node runtime and an automatic rebuild did not complete (" + reason + "). Run `npm rebuild better-sqlite3` (or reinstall) and retry.";
+}
+function loadSqlite() {
+  if (_ctor) return _ctor;
+  _ctor = resolveSqliteCtor();
+  return _ctor;
+}
+var import_node_path3, import_node_module, import_node_child_process, import_meta, PEER_DEP_MISSING_MESSAGE, _ctor;
+var init_load_sqlite = __esm({
+  "src/db/load-sqlite.ts"() {
+    "use strict";
+    import_node_path3 = __toESM(require("path"), 1);
+    import_node_module = require("module");
+    import_node_child_process = require("child_process");
+    import_meta = {};
+    PEER_DEP_MISSING_MESSAGE = "better-sqlite3 is a required peer dependency of latticesql \u2014 install it (npm install better-sqlite3).";
+    _ctor = null;
+  }
+});
+
 // src/db/sqlite.ts
-var import_better_sqlite3, SQLiteAdapter;
+var SQLiteAdapter;
 var init_sqlite = __esm({
   "src/db/sqlite.ts"() {
     "use strict";
-    import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+    init_load_sqlite();
     SQLiteAdapter = class {
       dialect = "sqlite";
       _db = null;
       _path;
       _wal;
       _busyTimeout;
-      constructor(path2, options) {
-        this._path = path2;
+      constructor(path3, options) {
+        this._path = path3;
         this._wal = options?.wal ?? true;
         this._busyTimeout = options?.busyTimeout ?? 5e3;
       }
@@ -446,7 +557,8 @@ var init_sqlite = __esm({
         return this._db;
       }
       open() {
-        this._db = new import_better_sqlite3.default(this._path);
+        const Ctor = loadSqlite();
+        this._db = new Ctor(this._path);
         this._db.pragma(`busy_timeout = ${this._busyTimeout.toString()}`);
         if (this._wal) {
           this._db.pragma("journal_mode = WAL");
@@ -620,11 +732,11 @@ var init_sqlite = __esm({
 // src/db/postgres.ts
 function moduleContext() {
   if (_moduleContext) return _moduleContext;
-  const importMetaUrl = import_meta.url;
+  const importMetaUrl = import_meta2.url;
   if (importMetaUrl) {
     _moduleContext = {
-      dir: import_node_path3.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl)),
-      require: (0, import_node_module.createRequire)(importMetaUrl)
+      dir: import_node_path4.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl)),
+      require: (0, import_node_module2.createRequire)(importMetaUrl)
     };
   } else {
     _moduleContext = { dir: __dirname, require };
@@ -882,14 +994,14 @@ function rewriteParams(sql) {
 function rewrite(sql) {
   return rewriteParams(translateDialect(sql));
 }
-var import_node_path3, import_node_url, import_node_module, import_meta, _moduleContext, SYNC_NOT_SUPPORTED_MSG, PostgresAdapter, POSTGRES_POLYFILLS;
+var import_node_path4, import_node_url, import_node_module2, import_meta2, _moduleContext, SYNC_NOT_SUPPORTED_MSG, PostgresAdapter, POSTGRES_POLYFILLS;
 var init_postgres = __esm({
   "src/db/postgres.ts"() {
     "use strict";
-    import_node_path3 = __toESM(require("path"), 1);
+    import_node_path4 = __toESM(require("path"), 1);
     import_node_url = require("url");
-    import_node_module = require("module");
-    import_meta = {};
+    import_node_module2 = require("module");
+    import_meta2 = {};
     _moduleContext = null;
     SYNC_NOT_SUPPORTED_MSG = "PostgresAdapter: synchronous adapter methods (run/get/all/prepare/introspectColumns/addColumn) are no longer supported on Postgres as of latticesql 1.10.0. Use the async surface (runAsync/getAsync/allAsync/prepareAsync/introspectColumnsAsync/addColumnAsync/withClient) instead. Lattice core methods (Lattice.query, .insert, .update, .render, etc.) already route through the async surface \u2014 only consumer code that escapes into adapter.run/get/all directly needs migrating.";
     PostgresAdapter = class {
@@ -2557,14 +2669,14 @@ var init_core = __esm({
       columnRef(f6) {
         const col = `"${ident(f6.col)}"`;
         if (f6.jsonPath === void 0) return { sql: col, params: [] };
-        const path2 = Array.isArray(f6.jsonPath) ? f6.jsonPath : [f6.jsonPath];
+        const path3 = Array.isArray(f6.jsonPath) ? f6.jsonPath : [f6.jsonPath];
         const numeric = isNumericComparison(f6);
         if (this.adapter.dialect === "postgres") {
           const extract2 = `((${col})::jsonb #>> ?::text[])`;
           const sql2 = numeric ? `(${extract2})::numeric` : extract2;
-          return { sql: sql2, params: [path2] };
+          return { sql: sql2, params: [path3] };
         }
-        const jsonpath = `$.${path2.join(".")}`;
+        const jsonpath = `$.${path3.join(".")}`;
         const extract = `json_extract(${col}, ?)`;
         const sql = numeric ? `CAST(${extract} AS REAL)` : extract;
         return { sql, params: [jsonpath] };
@@ -3343,14 +3455,14 @@ function cleanupEntityContexts(outputDir, entityContexts, currentSlugsByTable, m
       ...def.protectedFiles ?? [],
       ...options.protectedFiles ?? []
     ]);
-    const rootPath = (0, import_node_path4.join)(outputDir, directoryRoot);
+    const rootPath = (0, import_node_path5.join)(outputDir, directoryRoot);
     if (!(0, import_node_fs3.existsSync)(rootPath)) continue;
     if (options.removeOrphanedDirectories !== false && !def.directory) {
       let actualDirs;
       try {
         actualDirs = (0, import_node_fs3.readdirSync)(rootPath).filter((name) => {
           try {
-            return (0, import_node_fs3.statSync)((0, import_node_path4.join)(rootPath, name)).isDirectory();
+            return (0, import_node_fs3.statSync)((0, import_node_path5.join)(rootPath, name)).isDirectory();
           } catch {
             return false;
           }
@@ -3361,11 +3473,11 @@ function cleanupEntityContexts(outputDir, entityContexts, currentSlugsByTable, m
       for (const dirName of actualDirs) {
         if (currentSlugs.has(dirName)) continue;
         if (!Object.prototype.hasOwnProperty.call(entry.entities, dirName)) continue;
-        const entityDir = (0, import_node_path4.join)(rootPath, dirName);
+        const entityDir = (0, import_node_path5.join)(rootPath, dirName);
         const managedFiles = entityFileNames(entry.entities[dirName] ?? []);
         for (const filename of managedFiles) {
           if (globalProtected.has(filename)) continue;
-          const filePath = (0, import_node_path4.join)(entityDir, filename);
+          const filePath = (0, import_node_path5.join)(entityDir, filename);
           if (!(0, import_node_fs3.existsSync)(filePath)) continue;
           if (!options.dryRun) (0, import_node_fs3.unlinkSync)(filePath);
           options.onOrphan?.(filePath, "file");
@@ -3399,7 +3511,7 @@ function cleanupEntityContexts(outputDir, entityContexts, currentSlugsByTable, m
       const declaredFiles = new Set(Object.keys(def.files));
       if (def.combined) declaredFiles.add(def.combined.outputFile);
       for (const slug of currentSlugs) {
-        const entityDir = def.directory ? null : (0, import_node_path4.join)(rootPath, slug);
+        const entityDir = def.directory ? null : (0, import_node_path5.join)(rootPath, slug);
         if (!entityDir || !(0, import_node_fs3.existsSync)(entityDir)) continue;
         const previouslyWritten = entityFileNames(entry.entities[slug] ?? []);
         const currentlyWritten = new Set(entityFileNames(newEntry?.entities[slug] ?? []));
@@ -3410,7 +3522,7 @@ function cleanupEntityContexts(outputDir, entityContexts, currentSlugsByTable, m
             if (declaredFiles.has(filename)) continue;
           }
           if (globalProtected.has(filename)) continue;
-          const filePath = (0, import_node_path4.join)(entityDir, filename);
+          const filePath = (0, import_node_path5.join)(entityDir, filename);
           if (!(0, import_node_fs3.existsSync)(filePath)) continue;
           if (!options.dryRun) (0, import_node_fs3.unlinkSync)(filePath);
           options.onOrphan?.(filePath, "file");
@@ -3421,11 +3533,11 @@ function cleanupEntityContexts(outputDir, entityContexts, currentSlugsByTable, m
   }
   return result;
 }
-var import_node_path4, import_node_fs3;
+var import_node_path5, import_node_fs3;
 var init_cleanup = __esm({
   "src/lifecycle/cleanup.ts"() {
     "use strict";
-    import_node_path4 = require("path");
+    import_node_path5 = require("path");
     import_node_fs3 = require("fs");
     init_manifest();
   }
@@ -3517,11 +3629,11 @@ function isScalarKey(v2) {
   const t8 = typeof v2;
   return t8 === "string" || t8 === "number" || t8 === "bigint" || t8 === "boolean";
 }
-var import_node_path5, import_node_fs4, DeferredTableProgress, YIELD_EVERY_ENTITIES, RENDER_TABLE_CONCURRENCY, NOOP_RENDER, RenderEngine;
+var import_node_path6, import_node_fs4, DeferredTableProgress, YIELD_EVERY_ENTITIES, RENDER_TABLE_CONCURRENCY, NOOP_RENDER, RenderEngine;
 var init_engine = __esm({
   "src/render/engine.ts"() {
     "use strict";
-    import_node_path5 = require("path");
+    import_node_path6 = require("path");
     import_node_fs4 = require("fs");
     init_adapter();
     init_writer();
@@ -3689,7 +3801,7 @@ var init_engine = __esm({
             for (const fn of def.enrich) rows = fn(rows);
           }
           const content = def.tokenBudget ? applyTokenBudget(rows, def.render, def.tokenBudget, def.prioritizeBy) : def.render(rows);
-          const filePath = (0, import_node_path5.join)(outputDir, def.outputFile);
+          const filePath = (0, import_node_path6.join)(outputDir, def.outputFile);
           const wrote = atomicWrite(filePath, content);
           if (wrote) {
             filesWritten.push(filePath);
@@ -3723,7 +3835,7 @@ var init_engine = __esm({
           let wroteAny = false;
           for (const key of keys) {
             const content = def.render(key, tables);
-            const filePath = (0, import_node_path5.join)(outputDir, def.outputFile(key));
+            const filePath = (0, import_node_path6.join)(outputDir, def.outputFile(key));
             if (atomicWrite(filePath, content)) {
               filesWritten.push(filePath);
               wroteAny = true;
@@ -3801,9 +3913,9 @@ var init_engine = __esm({
        * not pre-empted.
        */
       _preflightWritable(outputDir) {
-        const dirs = /* @__PURE__ */ new Set([outputDir, (0, import_node_path5.join)(outputDir, ".lattice")]);
+        const dirs = /* @__PURE__ */ new Set([outputDir, (0, import_node_path6.join)(outputDir, ".lattice")]);
         for (const [table, def] of this._schema.getEntityContexts()) {
-          dirs.add((0, import_node_path5.join)(outputDir, def.directoryRoot ?? table));
+          dirs.add((0, import_node_path6.join)(outputDir, def.directoryRoot ?? table));
         }
         for (const dir of dirs) probeDirWritable(dir);
       }
@@ -3990,7 +4102,7 @@ var init_engine = __esm({
               entities: {}
             };
             if (def.index) {
-              const indexPath = (0, import_node_path5.join)(outputDir, def.index.outputFile);
+              const indexPath = (0, import_node_path6.join)(outputDir, def.index.outputFile);
               if (atomicWrite(indexPath, def.index.render(allRows))) {
                 filesWritten.push(indexPath);
               } else {
@@ -4008,10 +4120,10 @@ var init_engine = __esm({
               if (/[^a-zA-Z0-9.\-_ @(),#&'+:;!~[\]]/.test(slug)) {
                 throw new Error(`Invalid slug "${slug}": contains characters outside the allowed set`);
               }
-              const entityDir = def.directory ? (0, import_node_path5.join)(outputDir, def.directory(entityRow)) : (0, import_node_path5.join)(outputDir, directoryRoot, slug);
-              const resolvedDir = (0, import_node_path5.resolve)(entityDir);
-              const resolvedBase = (0, import_node_path5.resolve)(outputDir);
-              if (!resolvedDir.startsWith(resolvedBase + import_node_path5.sep) && resolvedDir !== resolvedBase) {
+              const entityDir = def.directory ? (0, import_node_path6.join)(outputDir, def.directory(entityRow)) : (0, import_node_path6.join)(outputDir, directoryRoot, slug);
+              const resolvedDir = (0, import_node_path6.resolve)(entityDir);
+              const resolvedBase = (0, import_node_path6.resolve)(outputDir);
+              if (!resolvedDir.startsWith(resolvedBase + import_node_path6.sep) && resolvedDir !== resolvedBase) {
                 throw new Error(`Path traversal detected: slug "${slug}" escapes output directory`);
               }
               (0, import_node_fs4.mkdirSync)(entityDir, { recursive: true });
@@ -4019,7 +4131,7 @@ var init_engine = __esm({
                 const filePath = entityRow[def.attachFileColumn];
                 if (filePath && typeof filePath === "string" && filePath.length > 0) {
                   if (def.attachFileMode === "reference") {
-                    const refPath = (0, import_node_path5.join)(entityDir, `${(0, import_node_path5.basename)(filePath)}.ref.md`);
+                    const refPath = (0, import_node_path6.join)(entityDir, `${(0, import_node_path6.basename)(filePath)}.ref.md`);
                     if (atomicWrite(refPath, `# Reference
 
 - **location:** ${filePath}
@@ -4027,9 +4139,9 @@ var init_engine = __esm({
                       filesWritten.push(refPath);
                     }
                   } else {
-                    const absPath = (0, import_node_path5.isAbsolute)(filePath) ? filePath : (0, import_node_path5.resolve)(outputDir, filePath);
+                    const absPath = (0, import_node_path6.isAbsolute)(filePath) ? filePath : (0, import_node_path6.resolve)(outputDir, filePath);
                     if ((0, import_node_fs4.existsSync)(absPath)) {
-                      const destPath = (0, import_node_path5.join)(entityDir, (0, import_node_path5.basename)(absPath));
+                      const destPath = (0, import_node_path6.join)(entityDir, (0, import_node_path6.basename)(absPath));
                       if (!(0, import_node_fs4.existsSync)(destPath)) {
                         (0, import_node_fs4.copyFileSync)(absPath, destPath);
                         filesWritten.push(destPath);
@@ -4067,7 +4179,7 @@ var init_engine = __esm({
                 const content = truncateContent(renderFn(rows), spec.budget);
                 renderedFiles.set(filename, content);
                 entityFileHashes[filename] = { hash: contentHash(content), rowVersion };
-                const filePath = (0, import_node_path5.join)(entityDir, filename);
+                const filePath = (0, import_node_path6.join)(entityDir, filename);
                 if (atomicWrite(filePath, content)) {
                   filesWritten.push(filePath);
                 } else {
@@ -4089,7 +4201,7 @@ var init_engine = __esm({
                 }
                 if (parts.length > 0) {
                   const combinedContent = parts.join("\n\n---\n\n");
-                  const combinedPath = (0, import_node_path5.join)(entityDir, effectiveCombined.outputFile);
+                  const combinedPath = (0, import_node_path6.join)(entityDir, effectiveCombined.outputFile);
                   if (atomicWrite(combinedPath, combinedContent)) {
                     filesWritten.push(combinedPath);
                   } else {
@@ -4421,11 +4533,11 @@ function parseEntityProfileContent(content) {
   }
   return row;
 }
-var import_node_path6, import_node_fs5, ReverseSeedEngine;
+var import_node_path7, import_node_fs5, ReverseSeedEngine;
 var init_engine2 = __esm({
   "src/reverse-seed/engine.ts"() {
     "use strict";
-    import_node_path6 = require("path");
+    import_node_path7 = require("path");
     import_node_fs5 = require("fs");
     init_adapter();
     ReverseSeedEngine = class {
@@ -4455,7 +4567,7 @@ var init_engine2 = __esm({
           const tableDef = this._schema.getTables().get(table);
           if (tableDef?.reverseSeed === false) continue;
           const directoryRoot = ecDef.directoryRoot ?? table;
-          const rootPath = (0, import_node_path6.join)(outputDir, directoryRoot);
+          const rootPath = (0, import_node_path7.join)(outputDir, directoryRoot);
           if (!(0, import_node_fs5.existsSync)(rootPath)) continue;
           let dbRows;
           try {
@@ -4472,7 +4584,7 @@ var init_engine2 = __esm({
           }
           for (const entry of entries) {
             if (entry.startsWith(".")) continue;
-            const entityDir = (0, import_node_path6.join)(rootPath, entry);
+            const entityDir = (0, import_node_path7.join)(rootPath, entry);
             try {
               if (!(0, import_node_fs5.statSync)(entityDir).isDirectory()) continue;
             } catch {
@@ -4489,7 +4601,7 @@ var init_engine2 = __esm({
           const countRow = await getAsyncOrSync(this._adapter, `SELECT COUNT(*) AS n FROM "${name}"`);
           const count = Number(countRow?.n ?? 0);
           if (count > 0) continue;
-          const filePath = (0, import_node_path6.join)(outputDir, def.outputFile);
+          const filePath = (0, import_node_path7.join)(outputDir, def.outputFile);
           if (!(0, import_node_fs5.existsSync)(filePath)) continue;
           try {
             const content = (0, import_node_fs5.readFileSync)(filePath, "utf8");
@@ -4540,7 +4652,7 @@ var init_engine2 = __esm({
             }
             continue;
           }
-          const filePath = (0, import_node_path6.join)(outputDir, def.outputFile);
+          const filePath = (0, import_node_path7.join)(outputDir, def.outputFile);
           if (!(0, import_node_fs5.existsSync)(filePath)) continue;
           let content;
           try {
@@ -4572,7 +4684,7 @@ var init_engine2 = __esm({
           }
           if (!selfFilename && !entityParser) continue;
           const directoryRoot = ecDef.directoryRoot ?? table;
-          const rootPath = (0, import_node_path6.join)(outputDir, directoryRoot);
+          const rootPath = (0, import_node_path7.join)(outputDir, directoryRoot);
           if (!(0, import_node_fs5.existsSync)(rootPath)) continue;
           let entries;
           try {
@@ -4592,7 +4704,7 @@ var init_engine2 = __esm({
             await withClient(async (tx) => {
               for (const entry of entries) {
                 if (entry.startsWith(".")) continue;
-                const entityDir = (0, import_node_path6.join)(rootPath, entry);
+                const entityDir = (0, import_node_path7.join)(rootPath, entry);
                 try {
                   if (!(0, import_node_fs5.statSync)(entityDir).isDirectory()) continue;
                 } catch {
@@ -4601,7 +4713,7 @@ var init_engine2 = __esm({
                 if (dbSlugs.has(entry)) continue;
                 const targetFile = selfFilename ?? Object.keys(ecDef.files)[0];
                 if (!targetFile) continue;
-                const filePath = (0, import_node_path6.join)(entityDir, targetFile);
+                const filePath = (0, import_node_path7.join)(entityDir, targetFile);
                 if (!(0, import_node_fs5.existsSync)(filePath)) continue;
                 let content;
                 try {
@@ -4768,11 +4880,11 @@ var init_default_reverse_sync = __esm({
 });
 
 // src/reverse-sync/engine.ts
-var import_node_path7, import_node_fs6, ReverseSyncEngine;
+var import_node_path8, import_node_fs6, ReverseSyncEngine;
 var init_engine3 = __esm({
   "src/reverse-sync/engine.ts"() {
     "use strict";
-    import_node_path7 = require("path");
+    import_node_path8 = require("path");
     import_node_fs6 = require("fs");
     init_writer();
     init_default_reverse_sync();
@@ -4826,14 +4938,14 @@ var init_engine3 = __esm({
           for (const [slug, entityFilesRaw] of Object.entries(manifestEntry.entities)) {
             const entityRow = slugToRow.get(slug);
             if (!entityRow) continue;
-            const entityDir = def.directory ? (0, import_node_path7.join)(outputDir, def.directory(entityRow)) : (0, import_node_path7.join)(outputDir, directoryRoot, slug);
+            const entityDir = def.directory ? (0, import_node_path8.join)(outputDir, def.directory(entityRow)) : (0, import_node_path8.join)(outputDir, directoryRoot, slug);
             if (Array.isArray(entityFilesRaw)) continue;
             const entityFiles = entityFilesRaw;
             for (const [filename, reverseSyncFn] of fileFns) {
               const fileInfo = entityFiles[filename];
               if (!fileInfo) continue;
               if (!fileInfo.hash) continue;
-              const filePath = (0, import_node_path7.join)(entityDir, filename);
+              const filePath = (0, import_node_path8.join)(entityDir, filename);
               result.filesScanned++;
               if (!(0, import_node_fs6.existsSync)(filePath)) continue;
               let currentContent;
@@ -5088,13 +5200,13 @@ var init_state_store = __esm({
 });
 
 // src/writeback/pipeline.ts
-var import_node_fs7, import_node_string_decoder, import_node_path8, WritebackPipeline;
+var import_node_fs7, import_node_string_decoder, import_node_path9, WritebackPipeline;
 var init_pipeline = __esm({
   "src/writeback/pipeline.ts"() {
     "use strict";
     import_node_fs7 = require("fs");
     import_node_string_decoder = require("string_decoder");
-    import_node_path8 = require("path");
+    import_node_path9 = require("path");
     init_state_store();
     WritebackPipeline = class {
       _definitions = [];
@@ -5179,12 +5291,12 @@ var init_pipeline = __esm({
         if (!pattern.includes("*") && !pattern.includes("?")) {
           return [pattern];
         }
-        const dir = (0, import_node_path8.dirname)(pattern);
-        const filePattern = (0, import_node_path8.basename)(pattern);
+        const dir = (0, import_node_path9.dirname)(pattern);
+        const filePattern = (0, import_node_path9.basename)(pattern);
         if (!(0, import_node_fs7.existsSync)(dir)) return [];
         const regexStr = filePattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
         const regex = new RegExp(`^${regexStr}$`);
-        return (0, import_node_fs7.readdirSync)(dir).filter((f6) => regex.test(f6)).map((f6) => (0, import_node_path8.join)(dir, f6));
+        return (0, import_node_fs7.readdirSync)(dir).filter((f6) => regex.test(f6)).map((f6) => (0, import_node_path9.join)(dir, f6));
       }
     };
   }
@@ -5192,8 +5304,8 @@ var init_pipeline = __esm({
 
 // src/render/interpolate.ts
 function interpolate(template, row) {
-  return template.replace(/\{\{([^}]+)\}\}/g, (_, path2) => {
-    const parts = path2.trim().split(".");
+  return template.replace(/\{\{([^}]+)\}\}/g, (_, path3) => {
+    const parts = path3.trim().split(".");
     let val = row;
     for (const part of parts) {
       if (val == null || typeof val !== "object") return "";
@@ -5318,7 +5430,7 @@ var init_templates = __esm({
 
 // src/framework/lattice-root.ts
 function isRoot(dir) {
-  return (0, import_node_fs8.existsSync)((0, import_node_path9.join)(dir, CONFIG_SUBDIR));
+  return (0, import_node_fs8.existsSync)((0, import_node_path10.join)(dir, CONFIG_SUBDIR));
 }
 function findLatticeRoot(startDir = process.cwd()) {
   const override = process.env.LATTICE_ROOT;
@@ -5326,18 +5438,18 @@ function findLatticeRoot(startDir = process.cwd()) {
     return override;
   }
   let dir = startDir;
-  const { root: fsRoot } = (0, import_node_path9.parse)(dir);
+  const { root: fsRoot } = (0, import_node_path10.parse)(dir);
   for (; ; ) {
-    const candidate = (0, import_node_path9.join)(dir, ROOT_DIRNAME);
+    const candidate = (0, import_node_path10.join)(dir, ROOT_DIRNAME);
     if (isRoot(candidate)) return candidate;
     if (dir === fsRoot) return null;
-    const parent = (0, import_node_path9.dirname)(dir);
+    const parent = (0, import_node_path10.dirname)(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 function resolveLatticeRoot(startDir = process.cwd()) {
-  return findLatticeRoot(startDir) ?? (0, import_node_path9.join)(startDir, ROOT_DIRNAME);
+  return findLatticeRoot(startDir) ?? (0, import_node_path10.join)(startDir, ROOT_DIRNAME);
 }
 function chmod0700(dir) {
   if ((0, import_node_os2.platform)() === "win32") return;
@@ -5352,48 +5464,48 @@ function ensureLatticeRoot(startDir = process.cwd()) {
     (0, import_node_fs8.mkdirSync)(root6, { recursive: true });
     chmod0700(root6);
   }
-  const config = (0, import_node_path9.join)(root6, CONFIG_SUBDIR);
+  const config = (0, import_node_path10.join)(root6, CONFIG_SUBDIR);
   if (!(0, import_node_fs8.existsSync)(config)) {
     (0, import_node_fs8.mkdirSync)(config, { recursive: true });
     chmod0700(config);
   }
-  const workspaces = (0, import_node_path9.join)(root6, WORKSPACES_SUBDIR);
+  const workspaces = (0, import_node_path10.join)(root6, WORKSPACES_SUBDIR);
   if (!(0, import_node_fs8.existsSync)(workspaces)) {
     (0, import_node_fs8.mkdirSync)(workspaces, { recursive: true });
   }
   return root6;
 }
 function rootConfigDir(root6) {
-  return (0, import_node_path9.join)(root6, CONFIG_SUBDIR);
+  return (0, import_node_path10.join)(root6, CONFIG_SUBDIR);
 }
 function workspacesDir(root6) {
-  return (0, import_node_path9.join)(root6, WORKSPACES_SUBDIR);
+  return (0, import_node_path10.join)(root6, WORKSPACES_SUBDIR);
 }
 function registryPath(root6) {
-  return (0, import_node_path9.join)(rootConfigDir(root6), "registry.json");
+  return (0, import_node_path10.join)(rootConfigDir(root6), "registry.json");
 }
 function workspaceDir(root6, dir) {
-  return (0, import_node_path9.join)(workspacesDir(root6), dir);
+  return (0, import_node_path10.join)(workspacesDir(root6), dir);
 }
 function workspaceDataDir(root6, dir) {
-  return (0, import_node_path9.join)(workspaceDir(root6, dir), "Data");
+  return (0, import_node_path10.join)(workspaceDir(root6, dir), "Data");
 }
 function workspaceContextDir(root6, dir) {
-  return (0, import_node_path9.join)(workspaceDir(root6, dir), "Context");
+  return (0, import_node_path10.join)(workspaceDir(root6, dir), "Context");
 }
 function workspaceBlobsDir(root6, dir) {
-  return (0, import_node_path9.join)(workspaceDataDir(root6, dir), "blobs");
+  return (0, import_node_path10.join)(workspaceDataDir(root6, dir), "blobs");
 }
 function workspaceConfigPath(root6, dir) {
-  return (0, import_node_path9.join)(workspaceDir(root6, dir), "workspace.yml");
+  return (0, import_node_path10.join)(workspaceDir(root6, dir), "workspace.yml");
 }
-var import_node_fs8, import_node_os2, import_node_path9, ROOT_DIRNAME, CONFIG_SUBDIR, WORKSPACES_SUBDIR;
+var import_node_fs8, import_node_os2, import_node_path10, ROOT_DIRNAME, CONFIG_SUBDIR, WORKSPACES_SUBDIR;
 var init_lattice_root = __esm({
   "src/framework/lattice-root.ts"() {
     "use strict";
     import_node_fs8 = require("fs");
     import_node_os2 = require("os");
-    import_node_path9 = require("path");
+    import_node_path10 = require("path");
     ROOT_DIRNAME = ".lattice";
     CONFIG_SUBDIR = ".config";
     WORKSPACES_SUBDIR = "Workspaces";
@@ -5403,12 +5515,12 @@ var init_lattice_root = __esm({
 // src/framework/user-config.ts
 function configDir() {
   if (process.env.LATTICE_CONFIG_DIR) return process.env.LATTICE_CONFIG_DIR;
-  const legacy = (0, import_node_path10.join)((0, import_node_os3.homedir)(), ".lattice");
+  const legacy = (0, import_node_path11.join)((0, import_node_os3.homedir)(), ".lattice");
   const root6 = findLatticeRoot();
   if (root6) {
     const rootDir = rootConfigDir(root6);
-    if ((0, import_node_fs9.existsSync)((0, import_node_path10.join)(rootDir, MASTER_KEY_FILENAME))) return rootDir;
-    if (!(0, import_node_fs9.existsSync)((0, import_node_path10.join)(legacy, MASTER_KEY_FILENAME))) return rootDir;
+    if ((0, import_node_fs9.existsSync)((0, import_node_path11.join)(rootDir, MASTER_KEY_FILENAME))) return rootDir;
+    if (!(0, import_node_fs9.existsSync)((0, import_node_path11.join)(legacy, MASTER_KEY_FILENAME))) return rootDir;
   }
   return legacy;
 }
@@ -5429,7 +5541,7 @@ function getOrCreateMasterKey() {
   const envKey = process.env.LATTICE_ENCRYPTION_KEY;
   if (envKey && envKey.length > 0) return envKey;
   const dir = ensureConfigDir();
-  const keyPath = (0, import_node_path10.join)(dir, MASTER_KEY_FILENAME);
+  const keyPath = (0, import_node_path11.join)(dir, MASTER_KEY_FILENAME);
   if ((0, import_node_fs9.existsSync)(keyPath)) {
     return (0, import_node_fs9.readFileSync)(keyPath, "utf8").trim();
   }
@@ -5442,10 +5554,10 @@ function getOrCreateMasterKey() {
 }
 function readIdentity() {
   const dir = ensureConfigDir();
-  const path2 = (0, import_node_path10.join)(dir, IDENTITY_FILENAME);
-  if (!(0, import_node_fs9.existsSync)(path2)) return { ...EMPTY_IDENTITY };
+  const path3 = (0, import_node_path11.join)(dir, IDENTITY_FILENAME);
+  if (!(0, import_node_fs9.existsSync)(path3)) return { ...EMPTY_IDENTITY };
   try {
-    const parsed = JSON.parse((0, import_node_fs9.readFileSync)(path2, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs9.readFileSync)(path3, "utf8"));
     return {
       display_name: typeof parsed.display_name === "string" ? parsed.display_name : "",
       email: typeof parsed.email === "string" ? parsed.email : ""
@@ -5456,26 +5568,26 @@ function readIdentity() {
 }
 function writeIdentity(identity) {
   const dir = ensureConfigDir();
-  const path2 = (0, import_node_path10.join)(dir, IDENTITY_FILENAME);
+  const path3 = (0, import_node_path11.join)(dir, IDENTITY_FILENAME);
   const body = JSON.stringify(
     { display_name: identity.display_name, email: identity.email },
     null,
     2
   );
-  (0, import_node_fs9.writeFileSync)(path2, body + "\n", "utf8");
+  (0, import_node_fs9.writeFileSync)(path3, body + "\n", "utf8");
   if ((0, import_node_os3.platform)() !== "win32") {
     try {
-      (0, import_node_fs9.chmodSync)(path2, 384);
+      (0, import_node_fs9.chmodSync)(path3, 384);
     } catch {
     }
   }
 }
 function readPreferences() {
   const dir = ensureConfigDir();
-  const path2 = (0, import_node_path10.join)(dir, PREFERENCES_FILENAME);
-  if (!(0, import_node_fs9.existsSync)(path2)) return { ...DEFAULT_PREFERENCES };
+  const path3 = (0, import_node_path11.join)(dir, PREFERENCES_FILENAME);
+  if (!(0, import_node_fs9.existsSync)(path3)) return { ...DEFAULT_PREFERENCES };
   try {
-    const parsed = JSON.parse((0, import_node_fs9.readFileSync)(path2, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs9.readFileSync)(path3, "utf8"));
     const agg = typeof parsed.aggressiveness === "number" ? parsed.aggressiveness : NaN;
     return {
       show_system_tables: typeof parsed.show_system_tables === "boolean" ? parsed.show_system_tables : DEFAULT_PREFERENCES.show_system_tables,
@@ -5489,7 +5601,7 @@ function readPreferences() {
 }
 function writePreferences(prefs) {
   const dir = ensureConfigDir();
-  const path2 = (0, import_node_path10.join)(dir, PREFERENCES_FILENAME);
+  const path3 = (0, import_node_path11.join)(dir, PREFERENCES_FILENAME);
   const body = JSON.stringify(
     {
       show_system_tables: prefs.show_system_tables,
@@ -5500,10 +5612,10 @@ function writePreferences(prefs) {
     null,
     2
   );
-  (0, import_node_fs9.writeFileSync)(path2, body + "\n", "utf8");
+  (0, import_node_fs9.writeFileSync)(path3, body + "\n", "utf8");
   if ((0, import_node_os3.platform)() !== "win32") {
     try {
-      (0, import_node_fs9.chmodSync)(path2, 384);
+      (0, import_node_fs9.chmodSync)(path3, 384);
     } catch {
     }
   }
@@ -5528,7 +5640,7 @@ function withCredentialLock(fn) {
     }
   }
   const dir = ensureConfigDir();
-  const lockPath = (0, import_node_path10.join)(dir, CRED_LOCK_FILENAME);
+  const lockPath = (0, import_node_path11.join)(dir, CRED_LOCK_FILENAME);
   const deadline = Date.now() + LOCK_TIMEOUT_MS;
   let fd;
   for (; ; ) {
@@ -5567,8 +5679,8 @@ function withCredentialLock(fn) {
     }
   }
 }
-function writeFileAtomic(path2, data) {
-  const tmp = `${path2}.${String(process.pid)}.${(0, import_node_crypto5.randomBytes)(4).toString("hex")}.tmp`;
+function writeFileAtomic(path3, data) {
+  const tmp = `${path3}.${String(process.pid)}.${(0, import_node_crypto5.randomBytes)(4).toString("hex")}.tmp`;
   (0, import_node_fs9.writeFileSync)(tmp, data, "utf8");
   if ((0, import_node_os3.platform)() !== "win32") {
     try {
@@ -5576,7 +5688,7 @@ function writeFileAtomic(path2, data) {
     } catch {
     }
   }
-  (0, import_node_fs9.renameSync)(tmp, path2);
+  (0, import_node_fs9.renameSync)(tmp, path3);
 }
 function mutateCredentials(mutate) {
   withCredentialLock(() => {
@@ -5587,11 +5699,11 @@ function mutateCredentials(mutate) {
 }
 function loadCredentials() {
   const dir = ensureConfigDir();
-  const path2 = (0, import_node_path10.join)(dir, DB_CREDENTIALS_FILENAME);
-  if (!(0, import_node_fs9.existsSync)(path2)) return {};
+  const path3 = (0, import_node_path11.join)(dir, DB_CREDENTIALS_FILENAME);
+  if (!(0, import_node_fs9.existsSync)(path3)) return {};
   const key = deriveKey(getOrCreateMasterKey());
   try {
-    const ciphertext = (0, import_node_fs9.readFileSync)(path2, "utf8").trim();
+    const ciphertext = (0, import_node_fs9.readFileSync)(path3, "utf8").trim();
     const plaintext = decrypt(ciphertext, key);
     const parsed = JSON.parse(plaintext);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
@@ -5606,10 +5718,10 @@ function loadCredentials() {
 }
 function saveCredentials(creds) {
   const dir = ensureConfigDir();
-  const path2 = (0, import_node_path10.join)(dir, DB_CREDENTIALS_FILENAME);
+  const path3 = (0, import_node_path11.join)(dir, DB_CREDENTIALS_FILENAME);
   const key = deriveKey(getOrCreateMasterKey());
   const ciphertext = encrypt(JSON.stringify(creds), key);
-  writeFileAtomic(path2, ciphertext + "\n");
+  writeFileAtomic(path3, ciphertext + "\n");
 }
 function listDbCredentials() {
   return Object.keys(loadCredentials()).sort();
@@ -5657,11 +5769,11 @@ function healRawDbUrl(configPath) {
 }
 function loadS3Configs() {
   const dir = ensureConfigDir();
-  const path2 = (0, import_node_path10.join)(dir, S3_CONFIG_FILENAME);
-  if (!(0, import_node_fs9.existsSync)(path2)) return {};
+  const path3 = (0, import_node_path11.join)(dir, S3_CONFIG_FILENAME);
+  if (!(0, import_node_fs9.existsSync)(path3)) return {};
   const key = deriveKey(getOrCreateMasterKey());
   try {
-    const parsed = JSON.parse(decrypt((0, import_node_fs9.readFileSync)(path2, "utf8").trim(), key));
+    const parsed = JSON.parse(decrypt((0, import_node_fs9.readFileSync)(path3, "utf8").trim(), key));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
     }
@@ -5675,12 +5787,12 @@ function loadS3Configs() {
 }
 function saveS3Configs(cfgs) {
   const dir = ensureConfigDir();
-  const path2 = (0, import_node_path10.join)(dir, S3_CONFIG_FILENAME);
+  const path3 = (0, import_node_path11.join)(dir, S3_CONFIG_FILENAME);
   const key = deriveKey(getOrCreateMasterKey());
-  (0, import_node_fs9.writeFileSync)(path2, encrypt(JSON.stringify(cfgs), key) + "\n", "utf8");
+  (0, import_node_fs9.writeFileSync)(path3, encrypt(JSON.stringify(cfgs), key) + "\n", "utf8");
   if ((0, import_node_os3.platform)() !== "win32") {
     try {
-      (0, import_node_fs9.chmodSync)(path2, 384);
+      (0, import_node_fs9.chmodSync)(path3, 384);
     } catch {
     }
   }
@@ -5717,11 +5829,11 @@ function deleteDbCredential(label) {
 }
 function loadAssistantCredentials() {
   const dir = ensureConfigDir();
-  const path2 = (0, import_node_path10.join)(dir, ASSISTANT_CREDENTIALS_FILENAME);
-  if (!(0, import_node_fs9.existsSync)(path2)) return {};
+  const path3 = (0, import_node_path11.join)(dir, ASSISTANT_CREDENTIALS_FILENAME);
+  if (!(0, import_node_fs9.existsSync)(path3)) return {};
   const key = deriveKey(getOrCreateMasterKey());
   try {
-    const ciphertext = (0, import_node_fs9.readFileSync)(path2, "utf8").trim();
+    const ciphertext = (0, import_node_fs9.readFileSync)(path3, "utf8").trim();
     const plaintext = decrypt(ciphertext, key);
     const parsed = JSON.parse(plaintext);
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
@@ -5736,13 +5848,13 @@ function loadAssistantCredentials() {
 }
 function saveAssistantCredentials(creds) {
   const dir = ensureConfigDir();
-  const path2 = (0, import_node_path10.join)(dir, ASSISTANT_CREDENTIALS_FILENAME);
+  const path3 = (0, import_node_path11.join)(dir, ASSISTANT_CREDENTIALS_FILENAME);
   const key = deriveKey(getOrCreateMasterKey());
   const ciphertext = encrypt(JSON.stringify(creds), key);
-  (0, import_node_fs9.writeFileSync)(path2, ciphertext + "\n", "utf8");
+  (0, import_node_fs9.writeFileSync)(path3, ciphertext + "\n", "utf8");
   if ((0, import_node_os3.platform)() !== "win32") {
     try {
-      (0, import_node_fs9.chmodSync)(path2, 384);
+      (0, import_node_fs9.chmodSync)(path3, 384);
     } catch {
     }
   }
@@ -5780,7 +5892,7 @@ function clearAssistantCredentialCleared(kind) {
   saveAssistantCredentials(rest);
 }
 function ensureKeysDir() {
-  const dir = (0, import_node_path10.join)(ensureConfigDir(), KEYS_SUBDIR);
+  const dir = (0, import_node_path11.join)(ensureConfigDir(), KEYS_SUBDIR);
   if (!(0, import_node_fs9.existsSync)(dir)) {
     (0, import_node_fs9.mkdirSync)(dir, { recursive: true });
     if ((0, import_node_os3.platform)() !== "win32") {
@@ -5803,34 +5915,34 @@ function listTokens() {
 }
 function readToken(label) {
   assertSafeLabel(label);
-  const path2 = (0, import_node_path10.join)(ensureKeysDir(), label + TOKEN_EXT);
-  if (!(0, import_node_fs9.existsSync)(path2)) return null;
-  return (0, import_node_fs9.readFileSync)(path2, "utf8").trim();
+  const path3 = (0, import_node_path11.join)(ensureKeysDir(), label + TOKEN_EXT);
+  if (!(0, import_node_fs9.existsSync)(path3)) return null;
+  return (0, import_node_fs9.readFileSync)(path3, "utf8").trim();
 }
 function writeToken(label, token) {
   assertSafeLabel(label);
-  const path2 = (0, import_node_path10.join)(ensureKeysDir(), label + TOKEN_EXT);
-  (0, import_node_fs9.writeFileSync)(path2, token + "\n", "utf8");
+  const path3 = (0, import_node_path11.join)(ensureKeysDir(), label + TOKEN_EXT);
+  (0, import_node_fs9.writeFileSync)(path3, token + "\n", "utf8");
   if ((0, import_node_os3.platform)() !== "win32") {
     try {
-      (0, import_node_fs9.chmodSync)(path2, 384);
+      (0, import_node_fs9.chmodSync)(path3, 384);
     } catch {
     }
   }
 }
 function deleteToken(label) {
   assertSafeLabel(label);
-  const path2 = (0, import_node_path10.join)(ensureKeysDir(), label + TOKEN_EXT);
-  if ((0, import_node_fs9.existsSync)(path2)) (0, import_node_fs9.unlinkSync)(path2);
+  const path3 = (0, import_node_path11.join)(ensureKeysDir(), label + TOKEN_EXT);
+  if ((0, import_node_fs9.existsSync)(path3)) (0, import_node_fs9.unlinkSync)(path3);
 }
-var import_node_crypto5, import_node_fs9, import_node_os3, import_node_path10, import_yaml2, MASTER_KEY_FILENAME, IDENTITY_FILENAME, EMPTY_IDENTITY, PREFERENCES_FILENAME, DEFAULT_PREFERENCES, DB_CREDENTIALS_FILENAME, CRED_LOCK_FILENAME, LOCK_STALE_MS, LOCK_TIMEOUT_MS, lockDepthInProcess, S3_CONFIG_FILENAME, ASSISTANT_CREDENTIALS_FILENAME, CLEARED_SENTINEL_PREFIX, KEYS_SUBDIR, TOKEN_EXT;
+var import_node_crypto5, import_node_fs9, import_node_os3, import_node_path11, import_yaml2, MASTER_KEY_FILENAME, IDENTITY_FILENAME, EMPTY_IDENTITY, PREFERENCES_FILENAME, DEFAULT_PREFERENCES, DB_CREDENTIALS_FILENAME, CRED_LOCK_FILENAME, LOCK_STALE_MS, LOCK_TIMEOUT_MS, lockDepthInProcess, S3_CONFIG_FILENAME, ASSISTANT_CREDENTIALS_FILENAME, CLEARED_SENTINEL_PREFIX, KEYS_SUBDIR, TOKEN_EXT;
 var init_user_config = __esm({
   "src/framework/user-config.ts"() {
     "use strict";
     import_node_crypto5 = require("crypto");
     import_node_fs9 = require("fs");
     import_node_os3 = require("os");
-    import_node_path10 = require("path");
+    import_node_path11 = require("path");
     import_yaml2 = require("yaml");
     init_encryption();
     init_lattice_root();
@@ -5859,8 +5971,8 @@ var init_user_config = __esm({
 
 // src/config/parser.ts
 function parseConfigFile(configPath) {
-  const absPath = (0, import_node_path11.resolve)(configPath);
-  const configDir2 = (0, import_node_path11.dirname)(absPath);
+  const absPath = (0, import_node_path12.resolve)(configPath);
+  const configDir2 = (0, import_node_path12.dirname)(absPath);
   let raw;
   try {
     raw = (0, import_node_fs10.readFileSync)(absPath, "utf-8");
@@ -5943,7 +6055,7 @@ function resolveDbPath(raw, configDir2) {
       )} as a database path \u2014 it looks like a malformed variable reference, not a file path.`
     );
   }
-  return (0, import_node_path11.resolve)(configDir2, raw);
+  return (0, import_node_path12.resolve)(configDir2, raw);
 }
 function entityToTableDef(entityName, entity) {
   const rawFields = entity.fields;
@@ -6165,12 +6277,12 @@ function parseEntityContexts(entityContexts) {
   }
   return result;
 }
-var import_node_fs10, import_node_path11, import_yaml3;
+var import_node_fs10, import_node_path12, import_yaml3;
 var init_parser = __esm({
   "src/config/parser.ts"() {
     "use strict";
     import_node_fs10 = require("fs");
-    import_node_path11 = require("path");
+    import_node_path12 = require("path");
     import_yaml3 = require("yaml");
     init_user_config();
   }
@@ -6199,13 +6311,13 @@ function uniqueDirName(displayName, existing) {
   }
 }
 function readRegistry(root6) {
-  const path2 = registryPath(root6);
-  if (!(0, import_node_fs11.existsSync)(path2)) return { ...EMPTY_REGISTRY, workspaces: [] };
+  const path3 = registryPath(root6);
+  if (!(0, import_node_fs11.existsSync)(path3)) return { ...EMPTY_REGISTRY, workspaces: [] };
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs11.readFileSync)(path2, "utf-8"));
+    parsed = JSON.parse((0, import_node_fs11.readFileSync)(path3, "utf-8"));
   } catch (e6) {
-    throw new Error(`Lattice: corrupt workspace registry at "${path2}": ${e6.message}`);
+    throw new Error(`Lattice: corrupt workspace registry at "${path3}": ${e6.message}`);
   }
   const reg = parsed;
   return {
@@ -6215,11 +6327,11 @@ function readRegistry(root6) {
   };
 }
 function writeRegistry(root6, registry) {
-  const path2 = registryPath(root6);
-  const tmp = `${path2}.tmp-${String(process.pid)}`;
+  const path3 = registryPath(root6);
+  const tmp = `${path3}.tmp-${String(process.pid)}`;
   (0, import_node_fs11.writeFileSync)(tmp, `${JSON.stringify(registry, null, 2)}
 `, "utf-8");
-  (0, import_node_fs11.renameSync)(tmp, path2);
+  (0, import_node_fs11.renameSync)(tmp, path3);
 }
 function listWorkspaces(root6) {
   return readRegistry(root6).workspaces;
@@ -6242,12 +6354,12 @@ function setActiveWorkspace(root6, id) {
 }
 function resolveWorkspacePaths(root6, ws) {
   if (ws.configPath) {
-    const dir = (0, import_node_path12.dirname)(ws.configPath);
+    const dir = (0, import_node_path13.dirname)(ws.configPath);
     return {
       dir,
       configPath: ws.configPath,
-      dataDir: (0, import_node_path12.join)(dir, "Data"),
-      contextDir: ws.contextDir ?? (0, import_node_path12.resolve)(dir, "context")
+      dataDir: (0, import_node_path13.join)(dir, "Data"),
+      contextDir: ws.contextDir ?? (0, import_node_path13.resolve)(dir, "context")
     };
   }
   return {
@@ -6261,8 +6373,8 @@ function effectiveConfigPath(root6, ws) {
   return ws.configPath ?? workspaceConfigPath(root6, ws.dir);
 }
 function findWorkspaceByConfigPath(root6, configPath) {
-  const target = (0, import_node_path12.resolve)(configPath);
-  return listWorkspaces(root6).find((w2) => (0, import_node_path12.resolve)(effectiveConfigPath(root6, w2)) === target) ?? null;
+  const target = (0, import_node_path13.resolve)(configPath);
+  return listWorkspaces(root6).find((w2) => (0, import_node_path13.resolve)(effectiveConfigPath(root6, w2)) === target) ?? null;
 }
 function isCloudDb(db) {
   const trimmed = db.trim();
@@ -6307,7 +6419,7 @@ function addWorkspace(root6, opts) {
   return record;
 }
 function workspaceDbPath(root6, ws) {
-  return (0, import_node_path12.join)(workspaceDataDir(root6, ws.dir), "database.db");
+  return (0, import_node_path13.join)(workspaceDataDir(root6, ws.dir), "database.db");
 }
 function addAdoptedWorkspace(root6, opts) {
   if (!(0, import_node_fs11.existsSync)(rootConfigDir(root6))) {
@@ -6327,8 +6439,8 @@ function addAdoptedWorkspace(root6, opts) {
     db: opts.db,
     kind: isCloudDb(opts.db) ? "cloud" : "local",
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    configPath: (0, import_node_path12.resolve)(opts.configPath),
-    contextDir: (0, import_node_path12.resolve)(opts.contextDir)
+    configPath: (0, import_node_path13.resolve)(opts.configPath),
+    contextDir: (0, import_node_path13.resolve)(opts.contextDir)
   };
   reg.workspaces.push(record);
   const makeActive = opts.makeActive ?? reg.activeWorkspaceId === null;
@@ -6378,12 +6490,12 @@ function renameWorkspaceByConfigPath(root6, configPath, displayName) {
     writeRegistry(root6, reg);
   }
 }
-var import_node_fs11, import_node_path12, import_uuid2, EMPTY_REGISTRY, LOCAL_DB_RELPATH, WINDOWS_RESERVED, ILLEGAL_DIR_CHARS;
+var import_node_fs11, import_node_path13, import_uuid2, EMPTY_REGISTRY, LOCAL_DB_RELPATH, WINDOWS_RESERVED, ILLEGAL_DIR_CHARS;
 var init_workspace = __esm({
   "src/framework/workspace.ts"() {
     "use strict";
     import_node_fs11 = require("fs");
-    import_node_path12 = require("path");
+    import_node_path13 = require("path");
     import_uuid2 = require("uuid");
     init_lattice_root();
     EMPTY_REGISTRY = {
@@ -8003,18 +8115,18 @@ function computedColumnOrder(table, computed) {
   const names = new Set(Object.keys(computed));
   const order = [];
   const state2 = /* @__PURE__ */ new Map();
-  const visit = (name, path2) => {
+  const visit = (name, path3) => {
     const st = state2.get(name);
     if (st === "done") return;
     if (st === "visiting") {
-      const start = path2.indexOf(name);
-      throw new ComputedColumnCycleError(table, [...path2.slice(start), name]);
+      const start = path3.indexOf(name);
+      throw new ComputedColumnCycleError(table, [...path3.slice(start), name]);
     }
     state2.set(name, "visiting");
     const spec = computed[name];
     if (spec) {
       for (const dep of spec.deps) {
-        if (names.has(dep)) visit(dep, [...path2, name]);
+        if (names.has(dep)) visit(dep, [...path3, name]);
       }
     }
     state2.set(name, "done");
@@ -15907,12 +16019,12 @@ var init_types = __esm({
 });
 
 // node_modules/@smithy/core/dist-es/submodules/config/shared-ini-file-loader/getHomeDir.js
-var import_node_os4, import_node_path15, homeDirCache, getHomeDirCacheKey, getHomeDir;
+var import_node_os4, import_node_path16, homeDirCache, getHomeDirCacheKey, getHomeDir;
 var init_getHomeDir = __esm({
   "node_modules/@smithy/core/dist-es/submodules/config/shared-ini-file-loader/getHomeDir.js"() {
     "use strict";
     import_node_os4 = require("os");
-    import_node_path15 = require("path");
+    import_node_path16 = require("path");
     homeDirCache = {};
     getHomeDirCacheKey = () => {
       if (process && process.geteuid) {
@@ -15921,7 +16033,7 @@ var init_getHomeDir = __esm({
       return "DEFAULT";
     };
     getHomeDir = () => {
-      const { HOME, USERPROFILE, HOMEPATH, HOMEDRIVE = `C:${import_node_path15.sep}` } = process.env;
+      const { HOME, USERPROFILE, HOMEPATH, HOMEDRIVE = `C:${import_node_path16.sep}` } = process.env;
       if (HOME)
         return HOME;
       if (USERPROFILE)
@@ -15948,17 +16060,17 @@ var init_getProfileName = __esm({
 });
 
 // node_modules/@smithy/core/dist-es/submodules/config/shared-ini-file-loader/getSSOTokenFilepath.js
-var import_node_crypto9, import_node_path16, getSSOTokenFilepath;
+var import_node_crypto9, import_node_path17, getSSOTokenFilepath;
 var init_getSSOTokenFilepath = __esm({
   "node_modules/@smithy/core/dist-es/submodules/config/shared-ini-file-loader/getSSOTokenFilepath.js"() {
     "use strict";
     import_node_crypto9 = require("crypto");
-    import_node_path16 = require("path");
+    import_node_path17 = require("path");
     init_getHomeDir();
     getSSOTokenFilepath = (id) => {
       const hasher = (0, import_node_crypto9.createHash)("sha1");
       const cacheName = hasher.update(id).digest("hex");
-      return (0, import_node_path16.join)(getHomeDir(), ".aws", "sso", "cache", `${cacheName}.json`);
+      return (0, import_node_path17.join)(getHomeDir(), ".aws", "sso", "cache", `${cacheName}.json`);
     };
   }
 });
@@ -16016,26 +16128,26 @@ var init_getConfigData = __esm({
 });
 
 // node_modules/@smithy/core/dist-es/submodules/config/shared-ini-file-loader/getConfigFilepath.js
-var import_node_path17, ENV_CONFIG_PATH, getConfigFilepath;
+var import_node_path18, ENV_CONFIG_PATH, getConfigFilepath;
 var init_getConfigFilepath = __esm({
   "node_modules/@smithy/core/dist-es/submodules/config/shared-ini-file-loader/getConfigFilepath.js"() {
     "use strict";
-    import_node_path17 = require("path");
+    import_node_path18 = require("path");
     init_getHomeDir();
     ENV_CONFIG_PATH = "AWS_CONFIG_FILE";
-    getConfigFilepath = () => process.env[ENV_CONFIG_PATH] || (0, import_node_path17.join)(getHomeDir(), ".aws", "config");
+    getConfigFilepath = () => process.env[ENV_CONFIG_PATH] || (0, import_node_path18.join)(getHomeDir(), ".aws", "config");
   }
 });
 
 // node_modules/@smithy/core/dist-es/submodules/config/shared-ini-file-loader/getCredentialsFilepath.js
-var import_node_path18, ENV_CREDENTIALS_PATH, getCredentialsFilepath;
+var import_node_path19, ENV_CREDENTIALS_PATH, getCredentialsFilepath;
 var init_getCredentialsFilepath = __esm({
   "node_modules/@smithy/core/dist-es/submodules/config/shared-ini-file-loader/getCredentialsFilepath.js"() {
     "use strict";
-    import_node_path18 = require("path");
+    import_node_path19 = require("path");
     init_getHomeDir();
     ENV_CREDENTIALS_PATH = "AWS_SHARED_CREDENTIALS_FILE";
-    getCredentialsFilepath = () => process.env[ENV_CREDENTIALS_PATH] || (0, import_node_path18.join)(getHomeDir(), ".aws", "credentials");
+    getCredentialsFilepath = () => process.env[ENV_CREDENTIALS_PATH] || (0, import_node_path19.join)(getHomeDir(), ".aws", "credentials");
   }
 });
 
@@ -16104,24 +16216,24 @@ var init_readFile = __esm({
     import_promises2 = require("fs/promises");
     filePromises = {};
     fileIntercept = {};
-    readFile2 = (path2, options) => {
-      if (fileIntercept[path2] !== void 0) {
-        return fileIntercept[path2];
+    readFile2 = (path3, options) => {
+      if (fileIntercept[path3] !== void 0) {
+        return fileIntercept[path3];
       }
-      if (!filePromises[path2] || options?.ignoreCache) {
-        filePromises[path2] = (0, import_promises2.readFile)(path2, "utf8");
+      if (!filePromises[path3] || options?.ignoreCache) {
+        filePromises[path3] = (0, import_promises2.readFile)(path3, "utf8");
       }
-      return filePromises[path2];
+      return filePromises[path3];
     };
   }
 });
 
 // node_modules/@smithy/core/dist-es/submodules/config/shared-ini-file-loader/loadSharedConfigFiles.js
-var import_node_path19, swallowError, loadSharedConfigFiles;
+var import_node_path20, swallowError, loadSharedConfigFiles;
 var init_loadSharedConfigFiles = __esm({
   "node_modules/@smithy/core/dist-es/submodules/config/shared-ini-file-loader/loadSharedConfigFiles.js"() {
     "use strict";
-    import_node_path19 = require("path");
+    import_node_path20 = require("path");
     init_getConfigData();
     init_getConfigFilepath();
     init_getCredentialsFilepath();
@@ -16136,11 +16248,11 @@ var init_loadSharedConfigFiles = __esm({
       const relativeHomeDirPrefix = "~/";
       let resolvedFilepath = filepath;
       if (filepath.startsWith(relativeHomeDirPrefix)) {
-        resolvedFilepath = (0, import_node_path19.join)(homeDir, filepath.slice(2));
+        resolvedFilepath = (0, import_node_path20.join)(homeDir, filepath.slice(2));
       }
       let resolvedConfigFilepath = configFilepath;
       if (configFilepath.startsWith(relativeHomeDirPrefix)) {
-        resolvedConfigFilepath = (0, import_node_path19.join)(homeDir, configFilepath.slice(2));
+        resolvedConfigFilepath = (0, import_node_path20.join)(homeDir, configFilepath.slice(2));
       }
       const parsedFiles = await Promise.all([
         readFile2(resolvedConfigFilepath, {
@@ -16229,8 +16341,8 @@ var init_externalDataInterceptor = __esm({
       getFileRecord() {
         return fileIntercept;
       },
-      interceptFile(path2, contents) {
-        fileIntercept[path2] = Promise.resolve(contents);
+      interceptFile(path3, contents) {
+        fileIntercept[path3] = Promise.resolve(contents);
       },
       getTokenRecord() {
         return tokenIntercept;
@@ -16564,13 +16676,13 @@ var init_resolveDefaultsModeConfig = __esm({
       }
       return { hostname: "169.254.169.254", path: "/" };
     };
-    imdsHttpGet = async ({ hostname, path: path2 }) => {
+    imdsHttpGet = async ({ hostname, path: path3 }) => {
       const { request } = await import("http");
       return new Promise((resolve17, reject) => {
         const req = request({
           method: "GET",
           hostname: hostname.replace(/^\[(.+)]$/, "$1"),
-          path: path2,
+          path: path3,
           timeout: 1e3,
           signal: AbortSignal.timeout(1e3)
         });
@@ -16771,8 +16883,8 @@ var init_createConfigValueProvider = __esm({
               return endpoint.url.href;
             }
             if ("hostname" in endpoint) {
-              const { protocol, hostname, port, path: path2 } = endpoint;
-              return `${protocol}//${hostname}${port ? ":" + port : ""}${path2}`;
+              const { protocol, hostname, port, path: path3 } = endpoint;
+              return `${protocol}//${hostname}${port ? ":" + port : ""}${path3}`;
             }
           }
           return endpoint;
@@ -17209,18 +17321,18 @@ var init_getAttrPathList = __esm({
   "node_modules/@smithy/core/dist-es/submodules/endpoints/util-endpoints/lib/getAttrPathList.js"() {
     "use strict";
     init_types2();
-    getAttrPathList = (path2) => {
-      const parts = path2.split(".");
+    getAttrPathList = (path3) => {
+      const parts = path3.split(".");
       const pathList = [];
       for (const part of parts) {
         const squareBracketIndex = part.indexOf("[");
         if (squareBracketIndex !== -1) {
           if (part.indexOf("]") !== part.length - 1) {
-            throw new EndpointError(`Path: '${path2}' does not end with ']'`);
+            throw new EndpointError(`Path: '${path3}' does not end with ']'`);
           }
           const arrayIndex = part.slice(squareBracketIndex + 1, -1);
           if (Number.isNaN(parseInt(arrayIndex))) {
-            throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path2}'`);
+            throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path3}'`);
           }
           if (squareBracketIndex !== 0) {
             pathList.push(part.slice(0, squareBracketIndex));
@@ -17242,9 +17354,9 @@ var init_getAttr = __esm({
     "use strict";
     init_types2();
     init_getAttrPathList();
-    getAttr = (value, path2) => getAttrPathList(path2).reduce((acc, index) => {
+    getAttr = (value, path3) => getAttrPathList(path3).reduce((acc, index) => {
       if (typeof acc !== "object") {
-        throw new EndpointError(`Index '${index}' in '${path2}' not found in '${JSON.stringify(value)}'`);
+        throw new EndpointError(`Index '${index}' in '${path3}' not found in '${JSON.stringify(value)}'`);
       } else if (Array.isArray(acc)) {
         const i6 = parseInt(index);
         return acc[i6 < 0 ? acc.length + i6 : i6];
@@ -17310,8 +17422,8 @@ var init_parseURL = __esm({
             return value;
           }
           if (typeof value === "object" && "hostname" in value) {
-            const { hostname: hostname2, port, protocol: protocol2 = "", path: path2 = "", query = {} } = value;
-            const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path2}`);
+            const { hostname: hostname2, port, protocol: protocol2 = "", path: path3 = "", query = {} } = value;
+            const url = new URL(`${protocol2}//${hostname2}${port ? `:${port}` : ""}${path3}`);
             url.search = Object.entries(query).map(([k6, v2]) => `${k6}=${v2}`).join("&");
             return url;
           }
@@ -20424,11 +20536,11 @@ var init_HttpBindingProtocol = __esm({
           const opTraits = translateTraits(operationSchema.traits);
           if (opTraits.http) {
             request.method = opTraits.http[0];
-            const [path2, search] = opTraits.http[1].split("?");
+            const [path3, search] = opTraits.http[1].split("?");
             if (request.path == "/") {
-              request.path = path2;
+              request.path = path3;
             } else {
-              request.path += path2;
+              request.path += path3;
             }
             const traitSearchParams = new URLSearchParams(search ?? "");
             for (const [key, value] of traitSearchParams) {
@@ -22407,9 +22519,9 @@ var init_createPaginator = __esm({
       command = withCommand(command) ?? command;
       return await client.send(command, ...args);
     };
-    get = (fromObject, path2) => {
+    get = (fromObject, path3) => {
       let cursor = fromObject;
-      const pathComponents = path2.split(".");
+      const pathComponents = path3.split(".");
       for (const step of pathComponents) {
         if (!cursor || typeof cursor !== "object") {
           return void 0;
@@ -22853,20 +22965,20 @@ var init_getRuntimeUserAgentPair = __esm({
 });
 
 // node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/getNodeModulesParentDirs.js
-var import_node_path20, getNodeModulesParentDirs;
+var import_node_path21, getNodeModulesParentDirs;
 var init_getNodeModulesParentDirs = __esm({
   "node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/getNodeModulesParentDirs.js"() {
     "use strict";
-    import_node_path20 = require("path");
+    import_node_path21 = require("path");
     getNodeModulesParentDirs = (dirname18) => {
       const cwd = process.cwd();
       if (!dirname18) {
         return [cwd];
       }
-      const normalizedPath = (0, import_node_path20.normalize)(dirname18);
-      const parts = normalizedPath.split(import_node_path20.sep);
+      const normalizedPath = (0, import_node_path21.normalize)(dirname18);
+      const parts = normalizedPath.split(import_node_path21.sep);
       const nodeModulesIndex = parts.indexOf("node_modules");
-      const parentDir = nodeModulesIndex !== -1 ? parts.slice(0, nodeModulesIndex).join(import_node_path20.sep) : normalizedPath;
+      const parentDir = nodeModulesIndex !== -1 ? parts.slice(0, nodeModulesIndex).join(import_node_path21.sep) : normalizedPath;
       if (cwd === parentDir) {
         return [cwd];
       }
@@ -22915,17 +23027,17 @@ var init_getSanitizedDevTypeScriptVersion = __esm({
 });
 
 // node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/getTypeScriptUserAgentPair.js
-var import_promises3, import_node_path21, tscVersion, TS_PACKAGE_JSON, getTypeScriptUserAgentPair;
+var import_promises3, import_node_path22, tscVersion, TS_PACKAGE_JSON, getTypeScriptUserAgentPair;
 var init_getTypeScriptUserAgentPair = __esm({
   "node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/getTypeScriptUserAgentPair.js"() {
     "use strict";
     init_config3();
     import_promises3 = require("fs/promises");
-    import_node_path21 = require("path");
+    import_node_path22 = require("path");
     init_getNodeModulesParentDirs();
     init_getSanitizedDevTypeScriptVersion();
     init_getSanitizedTypeScriptVersion();
-    TS_PACKAGE_JSON = (0, import_node_path21.join)("node_modules", "typescript", "package.json");
+    TS_PACKAGE_JSON = (0, import_node_path22.join)("node_modules", "typescript", "package.json");
     getTypeScriptUserAgentPair = async () => {
       if (tscVersion === null) {
         return void 0;
@@ -22946,7 +23058,7 @@ var init_getTypeScriptUserAgentPair = __esm({
       let versionFromApp;
       for (const nodeModulesParentDir of nodeModulesParentDirs) {
         try {
-          const appPackageJsonPath = (0, import_node_path21.join)(nodeModulesParentDir, "package.json");
+          const appPackageJsonPath = (0, import_node_path22.join)(nodeModulesParentDir, "package.json");
           const packageJson = await (0, import_promises3.readFile)(appPackageJsonPath, "utf-8");
           const { dependencies, devDependencies } = JSON.parse(packageJson);
           const version = devDependencies?.typescript ?? dependencies?.typescript;
@@ -22965,7 +23077,7 @@ var init_getTypeScriptUserAgentPair = __esm({
       let versionFromNodeModules;
       for (const nodeModulesParentDir of nodeModulesParentDirs) {
         try {
-          const tsPackageJsonPath = (0, import_node_path21.join)(nodeModulesParentDir, TS_PACKAGE_JSON);
+          const tsPackageJsonPath = (0, import_node_path22.join)(nodeModulesParentDir, TS_PACKAGE_JSON);
           const packageJson = await (0, import_promises3.readFile)(tsPackageJsonPath, "utf-8");
           const { version } = JSON.parse(packageJson);
           const sanitizedVersion2 = getSanitizedTypeScriptVersion(version);
@@ -24901,10 +25013,10 @@ ${longDate}
 ${credentialScope}
 ${toHex(hashedRequest)}`;
       }
-      getCanonicalPath({ path: path2 }) {
+      getCanonicalPath({ path: path3 }) {
         if (this.uriEscapePath) {
           const normalizedPathSegments = [];
-          for (const pathSegment of path2.split("/")) {
+          for (const pathSegment of path3.split("/")) {
             if (pathSegment?.length === 0)
               continue;
             if (pathSegment === ".")
@@ -24915,11 +25027,11 @@ ${toHex(hashedRequest)}`;
               normalizedPathSegments.push(pathSegment);
             }
           }
-          const normalizedPath = `${path2?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path2?.endsWith("/") ? "/" : ""}`;
+          const normalizedPath = `${path3?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path3?.endsWith("/") ? "/" : ""}`;
           const doubleEncoded = escapeUri(normalizedPath);
           return doubleEncoded.replace(/%2F/g, "/");
         }
-        return path2;
+        return path3;
       }
       validateResolvedCredentials(credentials) {
         if (typeof credentials !== "object" || typeof credentials.accessKeyId !== "string" || typeof credentials.secretAccessKey !== "string") {
@@ -29837,16 +29949,16 @@ var init_Matcher = __esm({
        * @returns {string|undefined}
        */
       getCurrentTag() {
-        const path2 = this._matcher.path;
-        return path2.length > 0 ? path2[path2.length - 1].tag : void 0;
+        const path3 = this._matcher.path;
+        return path3.length > 0 ? path3[path3.length - 1].tag : void 0;
       }
       /**
        * Get current namespace.
        * @returns {string|undefined}
        */
       getCurrentNamespace() {
-        const path2 = this._matcher.path;
-        return path2.length > 0 ? path2[path2.length - 1].namespace : void 0;
+        const path3 = this._matcher.path;
+        return path3.length > 0 ? path3[path3.length - 1].namespace : void 0;
       }
       /**
        * Get current node's attribute value.
@@ -29854,9 +29966,9 @@ var init_Matcher = __esm({
        * @returns {*}
        */
       getAttrValue(attrName) {
-        const path2 = this._matcher.path;
-        if (path2.length === 0) return void 0;
-        return path2[path2.length - 1].values?.[attrName];
+        const path3 = this._matcher.path;
+        if (path3.length === 0) return void 0;
+        return path3[path3.length - 1].values?.[attrName];
       }
       /**
        * Check if current node has an attribute.
@@ -29864,9 +29976,9 @@ var init_Matcher = __esm({
        * @returns {boolean}
        */
       hasAttr(attrName) {
-        const path2 = this._matcher.path;
-        if (path2.length === 0) return false;
-        const current = path2[path2.length - 1];
+        const path3 = this._matcher.path;
+        if (path3.length === 0) return false;
+        const current = path3[path3.length - 1];
         return current.values !== void 0 && attrName in current.values;
       }
       /**
@@ -29874,18 +29986,18 @@ var init_Matcher = __esm({
        * @returns {number}
        */
       getPosition() {
-        const path2 = this._matcher.path;
-        if (path2.length === 0) return -1;
-        return path2[path2.length - 1].position ?? 0;
+        const path3 = this._matcher.path;
+        if (path3.length === 0) return -1;
+        return path3[path3.length - 1].position ?? 0;
       }
       /**
        * Get current node's repeat counter (occurrence count of this tag name).
        * @returns {number}
        */
       getCounter() {
-        const path2 = this._matcher.path;
-        if (path2.length === 0) return -1;
-        return path2[path2.length - 1].counter ?? 0;
+        const path3 = this._matcher.path;
+        if (path3.length === 0) return -1;
+        return path3[path3.length - 1].counter ?? 0;
       }
       /**
        * Get current node's sibling index (alias for getPosition).
@@ -41653,12 +41765,12 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             const password = request.password ?? "";
             auth = `${username}:${password}`;
           }
-          let path2 = request.path;
+          let path3 = request.path;
           if (queryString) {
-            path2 += `?${queryString}`;
+            path3 += `?${queryString}`;
           }
           if (request.fragment) {
-            path2 += `#${request.fragment}`;
+            path3 += `#${request.fragment}`;
           }
           let hostname = request.hostname ?? "";
           if (hostname[0] === "[" && hostname.endsWith("]")) {
@@ -41670,7 +41782,7 @@ or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler conf
             headers: request.headers,
             host: hostname,
             method: request.method,
-            path: path2,
+            path: path3,
             port: request.port,
             agent,
             auth
@@ -46417,7 +46529,7 @@ var init_signin = __esm({
 });
 
 // node_modules/@aws-sdk/credential-provider-login/dist-es/LoginCredentialsFetcher.js
-var import_node_crypto12, import_node_fs17, import_node_os6, import_node_path22, LoginCredentialsFetcher;
+var import_node_crypto12, import_node_fs17, import_node_os6, import_node_path23, LoginCredentialsFetcher;
 var init_LoginCredentialsFetcher = __esm({
   "node_modules/@aws-sdk/credential-provider-login/dist-es/LoginCredentialsFetcher.js"() {
     "use strict";
@@ -46426,7 +46538,7 @@ var init_LoginCredentialsFetcher = __esm({
     import_node_crypto12 = require("crypto");
     import_node_fs17 = require("fs");
     import_node_os6 = require("os");
-    import_node_path22 = require("path");
+    import_node_path23 = require("path");
     LoginCredentialsFetcher = class _LoginCredentialsFetcher {
       profileData;
       init;
@@ -46574,7 +46686,7 @@ var init_LoginCredentialsFetcher = __esm({
       }
       async saveToken(token) {
         const tokenFilePath = this.getTokenFilePath();
-        const directory = (0, import_node_path22.dirname)(tokenFilePath);
+        const directory = (0, import_node_path23.dirname)(tokenFilePath);
         try {
           await import_node_fs17.promises.mkdir(directory, { recursive: true });
         } catch (error) {
@@ -46582,10 +46694,10 @@ var init_LoginCredentialsFetcher = __esm({
         await import_node_fs17.promises.writeFile(tokenFilePath, JSON.stringify(token, null, 2), "utf8");
       }
       getTokenFilePath() {
-        const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? (0, import_node_path22.join)((0, import_node_os6.homedir)(), ".aws", "login", "cache");
+        const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? (0, import_node_path23.join)((0, import_node_os6.homedir)(), ".aws", "login", "cache");
         const loginSessionBytes = Buffer.from(this.loginSession, "utf8");
         const loginSessionSha256 = (0, import_node_crypto12.createHash)("sha256").update(loginSessionBytes).digest("hex");
-        return (0, import_node_path22.join)(directory, `${loginSessionSha256}.json`);
+        return (0, import_node_path23.join)(directory, `${loginSessionSha256}.json`);
       }
       derToRawSignature(derSignature) {
         let offset = 2;
@@ -46779,12 +46891,12 @@ var init_getValidatedProcessCredentials = __esm({
 });
 
 // node_modules/@aws-sdk/credential-provider-process/dist-es/resolveProcessCredentials.js
-var import_node_child_process2, import_node_util, resolveProcessCredentials;
+var import_node_child_process3, import_node_util, resolveProcessCredentials;
 var init_resolveProcessCredentials = __esm({
   "node_modules/@aws-sdk/credential-provider-process/dist-es/resolveProcessCredentials.js"() {
     "use strict";
     init_config3();
-    import_node_child_process2 = require("child_process");
+    import_node_child_process3 = require("child_process");
     import_node_util = require("util");
     init_getValidatedProcessCredentials();
     resolveProcessCredentials = async (profileName, profiles, logger2) => {
@@ -46792,7 +46904,7 @@ var init_resolveProcessCredentials = __esm({
       if (profiles[profileName]) {
         const credentialProcess = profile["credential_process"];
         if (credentialProcess !== void 0) {
-          const execPromise = (0, import_node_util.promisify)(externalDataInterceptor?.getTokenRecord?.().exec ?? import_node_child_process2.exec);
+          const execPromise = (0, import_node_util.promisify)(externalDataInterceptor?.getTokenRecord?.().exec ?? import_node_child_process3.exec);
           try {
             const { stdout } = await execPromise(credentialProcess);
             let data;
@@ -52251,11 +52363,11 @@ var init_table_policy = __esm({
 });
 
 // src/ai/llm-client.ts
-var import_node_module2, DEFAULT_MODEL, CHEAPEST_MODEL;
+var import_node_module3, DEFAULT_MODEL, CHEAPEST_MODEL;
 var init_llm_client = __esm({
   "src/ai/llm-client.ts"() {
     "use strict";
-    import_node_module2 = require("module");
+    import_node_module3 = require("module");
     DEFAULT_MODEL = "claude-haiku-4-5";
     CHEAPEST_MODEL = "claude-haiku-4-5";
   }
@@ -52640,7 +52752,7 @@ function strippedBodyText(dom) {
 function titleFromUrl(rawUrl) {
   try {
     const u2 = new URL(rawUrl);
-    const last = (0, import_node_path26.basename)(u2.pathname);
+    const last = (0, import_node_path27.basename)(u2.pathname);
     return last && last !== "/" ? last : u2.hostname;
   } catch {
     return rawUrl;
@@ -52667,8 +52779,8 @@ async function sniffMime(body) {
 async function renderViaPlaywright(url, timeoutMs, warnIfMissing = false) {
   let chromium;
   try {
-    const importMetaUrl = import_meta2.url;
-    const req = importMetaUrl ? (0, import_node_module3.createRequire)(importMetaUrl) : require;
+    const importMetaUrl = import_meta3.url;
+    const req = importMetaUrl ? (0, import_node_module4.createRequire)(importMetaUrl) : require;
     const pw = req("playwright");
     chromium = pw.chromium;
   } catch {
@@ -52692,16 +52804,16 @@ async function renderViaPlaywright(url, timeoutMs, warnIfMissing = false) {
     if (browser) await browser.close().catch(() => void 0);
   }
 }
-var import_jsdom, import_readability, import_node_path26, import_node_module3, import_meta2, DEFAULT_MAX_BYTES2, DEFAULT_TIMEOUT_MS, DEFAULT_UA, DOMAIN_EXTRACTORS, warnedPlaywrightMissing;
+var import_jsdom, import_readability, import_node_path27, import_node_module4, import_meta3, DEFAULT_MAX_BYTES2, DEFAULT_TIMEOUT_MS, DEFAULT_UA, DOMAIN_EXTRACTORS, warnedPlaywrightMissing;
 var init_crawl = __esm({
   "src/ai/crawl.ts"() {
     "use strict";
     import_jsdom = require("jsdom");
     import_readability = require("@mozilla/readability");
-    import_node_path26 = require("path");
-    import_node_module3 = require("module");
+    import_node_path27 = require("path");
+    import_node_module4 = require("module");
     init_url_safety();
-    import_meta2 = {};
+    import_meta3 = {};
     DEFAULT_MAX_BYTES2 = 25 * 1024 * 1024;
     DEFAULT_TIMEOUT_MS = 3e4;
     DEFAULT_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
@@ -53267,9 +53379,9 @@ function entityDescriptions(configPath, outputDir) {
   return out;
 }
 function safeResolveInside(baseDir, requestedPath) {
-  const resolvedBase = (0, import_node_path27.resolve)(baseDir);
-  const resolved = (0, import_node_path27.resolve)(baseDir, requestedPath);
-  if (resolved !== resolvedBase && !resolved.startsWith(resolvedBase + import_node_path27.sep)) {
+  const resolvedBase = (0, import_node_path28.resolve)(baseDir);
+  const resolved = (0, import_node_path28.resolve)(baseDir, requestedPath);
+  if (resolved !== resolvedBase && !resolved.startsWith(resolvedBase + import_node_path28.sep)) {
     throw new Error(`Path escapes output directory: ${requestedPath}`);
   }
   return resolved;
@@ -53281,7 +53393,7 @@ function fileSummary(outputDir, relPath) {
   if (exists) {
     bytes = (0, import_node_fs26.readFileSync)(absPath).byteLength;
   }
-  return { name: (0, import_node_path27.basename)(relPath), path: relPath, exists, bytes };
+  return { name: (0, import_node_path28.basename)(relPath), path: relPath, exists, bytes };
 }
 function collectEntities(outputDir, manifest) {
   if (!manifest) return [];
@@ -53332,9 +53444,9 @@ function loadGuiData(configPath, outputDir) {
     tables,
     entities,
     project: {
-      configPath: (0, import_node_path27.resolve)(configPath),
-      outputDir: (0, import_node_path27.resolve)(outputDir),
-      dbName: (0, import_node_path27.basename)(parsed.dbPath),
+      configPath: (0, import_node_path28.resolve)(configPath),
+      outputDir: (0, import_node_path28.resolve)(outputDir),
+      dbName: (0, import_node_path28.basename)(parsed.dbPath),
       tableCount: tables.length,
       entityContextCount: parsed.entityContexts.length,
       manifestVersion: manifest?.version ?? null,
@@ -53499,10 +53611,10 @@ function buildGuiGraph(configPath, outputDir, options = {}) {
       for (const href of markdownLinks(content)) {
         let relTarget;
         try {
-          relTarget = (0, import_node_path27.relative)(
-            (0, import_node_path27.resolve)(outputDir),
-            safeResolveInside(outputDir, (0, import_node_path27.join)(fileDir, href))
-          ).split(import_node_path27.sep).join("/");
+          relTarget = (0, import_node_path28.relative)(
+            (0, import_node_path28.resolve)(outputDir),
+            safeResolveInside(outputDir, (0, import_node_path28.join)(fileDir, href))
+          ).split(import_node_path28.sep).join("/");
         } catch {
           continue;
         }
@@ -53599,12 +53711,12 @@ function tableJunctions(table, configPath, outputDir) {
   }
   return out;
 }
-var import_node_fs26, import_node_path27, _parsedCache, JUNCTION_ALLOWED_NONFK;
+var import_node_fs26, import_node_path28, _parsedCache, JUNCTION_ALLOWED_NONFK;
 var init_data = __esm({
   "src/gui/data.ts"() {
     "use strict";
     import_node_fs26 = require("fs");
-    import_node_path27 = require("path");
+    import_node_path28 = require("path");
     init_parser();
     init_manifest();
     init_native_entities();
@@ -54613,17 +54725,17 @@ function findDocsDir() {
   if (_docsDir !== void 0) return _docsDir;
   let dir;
   try {
-    dir = (0, import_node_path28.dirname)((0, import_node_url2.fileURLToPath)(import_meta5.url));
+    dir = (0, import_node_path29.dirname)((0, import_node_url2.fileURLToPath)(import_meta6.url));
   } catch {
     dir = process.cwd();
   }
   for (let i6 = 0; i6 < 8; i6++) {
-    const candidate = (0, import_node_path28.join)(dir, "docs");
-    if ((0, import_node_fs27.existsSync)((0, import_node_path28.join)(candidate, "cloud.md"))) {
+    const candidate = (0, import_node_path29.join)(dir, "docs");
+    if ((0, import_node_fs27.existsSync)((0, import_node_path29.join)(candidate, "cloud.md"))) {
       _docsDir = candidate;
       return _docsDir;
     }
-    const parent = (0, import_node_path28.dirname)(dir);
+    const parent = (0, import_node_path29.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -54666,7 +54778,7 @@ function allSections() {
   }
   for (const f6 of files) {
     try {
-      out.push(...sectionsOf(f6, (0, import_node_fs27.readFileSync)((0, import_node_path28.join)(dir, f6), "utf8")));
+      out.push(...sectionsOf(f6, (0, import_node_fs27.readFileSync)((0, import_node_path29.join)(dir, f6), "utf8")));
     } catch {
     }
   }
@@ -54708,14 +54820,14 @@ function searchLatticeDocs(query, limit = 4) {
     }))
   };
 }
-var import_node_fs27, import_node_path28, import_node_url2, import_meta5, _docsDir, MAX_SECTION_CHARS, _cache;
+var import_node_fs27, import_node_path29, import_node_url2, import_meta6, _docsDir, MAX_SECTION_CHARS, _cache;
 var init_lattice_docs = __esm({
   "src/gui/ai/lattice-docs.ts"() {
     "use strict";
     import_node_fs27 = require("fs");
-    import_node_path28 = require("path");
+    import_node_path29 = require("path");
     import_node_url2 = require("url");
-    import_meta5 = {};
+    import_meta6 = {};
     MAX_SECTION_CHARS = 2400;
     _cache = /* @__PURE__ */ new Map();
   }
@@ -54748,13 +54860,13 @@ function buildRowContextLocator(table, row, schemaDef, manifest) {
 }
 function readRowContext(outputDir, locator, secretCols) {
   const { slug, directoryRoot, fileNames } = locator;
-  const entityDir = (0, import_node_path29.resolve)(outputDir, directoryRoot, slug);
-  const resolvedBase = (0, import_node_path29.resolve)(outputDir);
-  if (entityDir !== resolvedBase && !entityDir.startsWith(resolvedBase + import_node_path29.sep)) {
+  const entityDir = (0, import_node_path30.resolve)(outputDir, directoryRoot, slug);
+  const resolvedBase = (0, import_node_path30.resolve)(outputDir);
+  if (entityDir !== resolvedBase && !entityDir.startsWith(resolvedBase + import_node_path30.sep)) {
     throw new Error(`Path traversal detected: slug "${slug}" escapes output directory`);
   }
   return fileNames.map((filename) => {
-    const absPath = (0, import_node_path29.join)(entityDir, filename);
+    const absPath = (0, import_node_path30.join)(entityDir, filename);
     const relPath = [directoryRoot, slug, filename].join("/");
     if (!(0, import_node_fs28.existsSync)(absPath)) return { name: filename, path: relPath, content: "" };
     let content = (0, import_node_fs28.readFileSync)(absPath, "utf8");
@@ -54765,11 +54877,11 @@ function readRowContext(outputDir, locator, secretCols) {
     return { name: filename, path: relPath, content };
   });
 }
-var import_node_path29, import_node_fs28;
+var import_node_path30, import_node_fs28;
 var init_row_context = __esm({
   "src/gui/row-context.ts"() {
     "use strict";
-    import_node_path29 = require("path");
+    import_node_path30 = require("path");
     import_node_fs28 = require("fs");
     init_manifest();
   }
@@ -55595,11 +55707,11 @@ function stripHtml(html) {
   const text = decodeXmlEntities(stripTags(noScript));
   return text.replace(/[ \t\f\r]+/g, " ").replace(/ *\n */g, "\n").replace(/\n{3,}/g, "\n\n").trim();
 }
-async function unzip(path2) {
+async function unzip(path3) {
   const fflate = await loadParser("fflate");
   if (!fflate || typeof fflate.unzipSync !== "function") return null;
   try {
-    const buf = await (0, import_promises8.readFile)(path2);
+    const buf = await (0, import_promises8.readFile)(path3);
     let total = 0;
     return fflate.unzipSync(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength), {
       filter: (file) => {
@@ -55628,35 +55740,35 @@ var init_helpers2 = __esm({
 });
 
 // src/gui/ai/doc/ooxml.ts
-async function extractDocx(path2) {
+async function extractDocx(path3) {
   const mod = await loadParser("mammoth");
   const lib = mod?.default ?? mod;
   if (!lib || typeof lib.extractRawText !== "function") return null;
   try {
-    const { value } = await lib.extractRawText({ path: path2 });
+    const { value } = await lib.extractRawText({ path: path3 });
     return nullIfEmpty(value);
   } catch {
     return null;
   }
 }
-async function extractDoc(path2) {
+async function extractDoc(path3) {
   const mod = await loadParser(
     "word-extractor"
   );
   const Ctor = mod && "default" in mod ? mod.default : mod;
   if (typeof Ctor !== "function") return null;
   try {
-    const doc = await new Ctor().extract(path2);
+    const doc = await new Ctor().extract(path3);
     return nullIfEmpty(doc.getBody());
   } catch {
     return null;
   }
 }
-async function extractPdf(path2) {
+async function extractPdf(path3) {
   const unpdf = await loadParser("unpdf");
   if (!unpdf || typeof unpdf.getDocumentProxy !== "function") return null;
   try {
-    const buf = await (0, import_promises9.readFile)(path2);
+    const buf = await (0, import_promises9.readFile)(path3);
     const data = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
     const text = await withTimeout(
       (async () => {
@@ -55688,8 +55800,8 @@ function slideText(xml) {
   }
   return paras.join("\n");
 }
-async function extractPptx(path2) {
-  const entries = await unzip(path2);
+async function extractPptx(path3) {
+  const entries = await unzip(path3);
   if (!entries) return null;
   const slides = Object.keys(entries).filter((n3) => /^ppt\/slides\/slide\d+\.xml$/.test(n3)).sort((a6, b6) => partNumber(a6) - partNumber(b6));
   if (slides.length === 0) return null;
@@ -55707,8 +55819,8 @@ async function extractPptx(path2) {
   }
   return nullIfEmpty(parts.join("\n\n"));
 }
-async function extractXlsx(path2) {
-  const entries = await unzip(path2);
+async function extractXlsx(path3) {
+  const entries = await unzip(path3);
   if (!entries) return null;
   const shared = [];
   const ssBytes = entries["xl/sharedStrings.xml"];
@@ -55768,8 +55880,8 @@ function odfWhitespace(s2) {
 function odfParagraph(inner) {
   return decodeXmlEntities(stripTags(odfWhitespace(inner))).trim();
 }
-async function extractOdfText(path2) {
-  const entries = await unzip(path2);
+async function extractOdfText(path3) {
+  const entries = await unzip(path3);
   if (!entries) return null;
   const contentBytes = entries["content.xml"];
   if (!contentBytes) return null;
@@ -55791,8 +55903,8 @@ async function extractOdfText(path2) {
   }
   return nullIfEmpty(lines.join("\n"));
 }
-async function extractOds(path2) {
-  const entries = await unzip(path2);
+async function extractOds(path3) {
+  const entries = await unzip(path3);
   if (!entries) return null;
   const contentBytes = entries["content.xml"];
   if (!contentBytes) return null;
@@ -55850,8 +55962,8 @@ function resolveHref(baseDir, href) {
   }
   return normalizeZipPath(baseDir + h6);
 }
-async function extractEpub(path2) {
-  const entries = await unzip(path2);
+async function extractEpub(path3) {
+  const entries = await unzip(path3);
   if (!entries) return null;
   let order = [];
   const container = entries["META-INF/container.xml"];
@@ -55935,9 +56047,9 @@ function rtfToText(rtf) {
   s2 = s2.replace(/[{}]/g, "");
   return s2.replace(/[ \t]+/g, (m4) => m4.includes("	") ? "	" : " ").replace(/[ \t]\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
 }
-async function extractRtf(path2) {
+async function extractRtf(path3) {
   try {
-    const raw = await (0, import_promises10.readFile)(path2, "latin1");
+    const raw = await (0, import_promises10.readFile)(path3, "latin1");
     if (!raw.startsWith("{\\rtf")) return null;
     return nullIfEmpty(rtfToText(raw));
   } catch {
@@ -55984,27 +56096,27 @@ var init_other = __esm({
 });
 
 // src/gui/ai/doc-extractors.ts
-async function extractDocument(path2, ext) {
+async function extractDocument(path3, ext) {
   switch (ext) {
     case ".docx":
-      return extractDocx(path2);
+      return extractDocx(path3);
     case ".doc":
-      return extractDoc(path2);
+      return extractDoc(path3);
     case ".pdf":
-      return extractPdf(path2);
+      return extractPdf(path3);
     case ".pptx":
-      return extractPptx(path2);
+      return extractPptx(path3);
     case ".xlsx":
-      return extractXlsx(path2);
+      return extractXlsx(path3);
     case ".odt":
     case ".odp":
-      return extractOdfText(path2);
+      return extractOdfText(path3);
     case ".ods":
-      return extractOds(path2);
+      return extractOds(path3);
     case ".epub":
-      return extractEpub(path2);
+      return extractEpub(path3);
     case ".rtf":
-      return extractRtf(path2);
+      return extractRtf(path3);
     default:
       return null;
   }
@@ -56020,22 +56132,22 @@ var init_doc_extractors = __esm({
 
 // src/gui/ai/extract.ts
 function languageOf(name) {
-  return CODE_LANGS[(0, import_node_path30.extname)(name).toLowerCase()] ?? null;
+  return CODE_LANGS[(0, import_node_path31.extname)(name).toLowerCase()] ?? null;
 }
 function truncate2(s2) {
   return s2.length > MAX_TEXT2 ? s2.slice(0, MAX_TEXT2) : s2;
 }
-async function parseFile(path2, mimeHint, originalName) {
-  const name = originalName ?? (0, import_node_path30.basename)(path2);
-  const ext = (0, import_node_path30.extname)(name).toLowerCase();
+async function parseFile(path3, mimeHint, originalName) {
+  const name = originalName ?? (0, import_node_path31.basename)(path3);
+  const ext = (0, import_node_path31.extname)(name).toLowerCase();
   const lang = languageOf(name);
   if (lang) {
-    return { text: truncate2(await (0, import_promises11.readFile)(path2, "utf8")), language: lang };
+    return { text: truncate2(await (0, import_promises11.readFile)(path3, "utf8")), language: lang };
   }
   if (mimeHint && TEXT_MIME.test(mimeHint) || TEXT_EXT.has(ext)) {
-    return { text: truncate2(await (0, import_promises11.readFile)(path2, "utf8")) };
+    return { text: truncate2(await (0, import_promises11.readFile)(path3, "utf8")) };
   }
-  const doc = await extractDocument(path2, ext);
+  const doc = await extractDocument(path3, ext);
   if (doc != null) {
     return { text: truncate2(doc) };
   }
@@ -56048,12 +56160,12 @@ function describe(text, mime, name) {
   }
   return `Binary file: ${name}${mime ? ` (${mime})` : ""}`;
 }
-var import_promises11, import_node_path30, MAX_TEXT2, CODE_LANGS, TEXT_EXT, TEXT_MIME;
+var import_promises11, import_node_path31, MAX_TEXT2, CODE_LANGS, TEXT_EXT, TEXT_MIME;
 var init_extract = __esm({
   "src/gui/ai/extract.ts"() {
     "use strict";
     import_promises11 = require("fs/promises");
-    import_node_path30 = require("path");
+    import_node_path31 = require("path");
     init_doc_extractors();
     MAX_TEXT2 = 2e5;
     CODE_LANGS = {
@@ -56625,8 +56737,8 @@ function isWriteConflict(e6) {
 function normalizeUrl(s2) {
   try {
     const u2 = new URL(s2.trim());
-    const path2 = u2.pathname.replace(/\/+$/, "");
-    return `${u2.protocol}//${u2.host.toLowerCase()}${path2}${u2.search}`;
+    const path3 = u2.pathname.replace(/\/+$/, "");
+    return `${u2.protocol}//${u2.host.toLowerCase()}${path3}${u2.search}`;
   } catch {
     return null;
   }
@@ -57582,8 +57694,8 @@ async function* runChat(opts) {
 }
 function loadSdk() {
   if (!_sdk) {
-    const importMetaUrl = import_meta6.url;
-    const req = importMetaUrl ? (0, import_node_module6.createRequire)(importMetaUrl) : require;
+    const importMetaUrl = import_meta7.url;
+    const req = importMetaUrl ? (0, import_node_module7.createRequire)(importMetaUrl) : require;
     try {
       _sdk = req("@anthropic-ai/sdk");
     } catch (err) {
@@ -57640,15 +57752,15 @@ function createAnthropicClient(auth) {
     }
   };
 }
-var import_node_module6, import_meta6, DEFAULT_MODEL2, MAX_TOOL_LOOPS, MAX_CONSECUTIVE_TOOL_FAILURES, MAX_TOKENS, MAX_TOOL_RESULT_CHARS, MAX_TOOL_RESULT_SKIP, MAX_TOOL_INPUT_CHARS, LIVE_TOOL_RESULT_CHARS, MAX_CONTEXT_RECOVERY_TRIMS, TRIMMED_PLACEHOLDER, BASE_SYSTEM_PROMPT, LOCAL_GUI_RECORD_RE, _sdk;
+var import_node_module7, import_meta7, DEFAULT_MODEL2, MAX_TOOL_LOOPS, MAX_CONSECUTIVE_TOOL_FAILURES, MAX_TOKENS, MAX_TOOL_RESULT_CHARS, MAX_TOOL_RESULT_SKIP, MAX_TOOL_INPUT_CHARS, LIVE_TOOL_RESULT_CHARS, MAX_CONTEXT_RECOVERY_TRIMS, TRIMMED_PLACEHOLDER, BASE_SYSTEM_PROMPT, LOCAL_GUI_RECORD_RE, _sdk;
 var init_chat = __esm({
   "src/gui/ai/chat.ts"() {
     "use strict";
-    import_node_module6 = require("module");
+    import_node_module7 = require("module");
     init_dispatch();
     init_tools();
     init_column_descriptions();
-    import_meta6 = {};
+    import_meta7 = {};
     DEFAULT_MODEL2 = "claude-haiku-4-5";
     MAX_TOOL_LOOPS = 16;
     MAX_CONSECUTIVE_TOOL_FAILURES = 3;
@@ -58383,13 +58495,13 @@ function applyWriteEntry(db, entry) {
 init_constants();
 
 // src/auto-update.ts
-var import_node_child_process = require("child_process");
+var import_node_child_process2 = require("child_process");
 var import_node_fs13 = require("fs");
-var import_node_path13 = require("path");
+var import_node_path14 = require("path");
 init_user_config();
 function getInstalledVersion(pkgName) {
   try {
-    const pkgPath = (0, import_node_path13.join)(process.cwd(), "node_modules", pkgName, "package.json");
+    const pkgPath = (0, import_node_path14.join)(process.cwd(), "node_modules", pkgName, "package.json");
     const pkg = JSON.parse((0, import_node_fs13.readFileSync)(pkgPath, "utf-8"));
     return pkg.version;
   } catch {
@@ -58433,7 +58545,7 @@ async function autoUpdate(opts) {
   }
   log(`[latticesql] Updating: latticesql@${installed} \u2192 ${latest}`);
   try {
-    (0, import_node_child_process.execFileSync)("npm", ["install", `latticesql@${latest}`], {
+    (0, import_node_child_process2.execFileSync)("npm", ["install", `latticesql@${latest}`], {
       cwd: process.cwd(),
       stdio: opts?.quiet ? "ignore" : "inherit",
       timeout: 6e4,
@@ -58690,7 +58802,7 @@ init_native_entities();
 // src/framework/blob-store.ts
 var import_node_crypto8 = require("crypto");
 var import_node_fs14 = require("fs");
-var import_node_path14 = require("path");
+var import_node_path15 = require("path");
 async function hashFile(srcPath) {
   return new Promise((resolve17, reject) => {
     const hash = (0, import_node_crypto8.createHash)("sha256");
@@ -58708,9 +58820,9 @@ async function attachBlob(srcPath, latticeRoot) {
     throw new Error(`attachBlob: ${srcPath} is not a regular file`);
   }
   const sha256 = await hashFile(srcPath);
-  const blobDir = (0, import_node_path14.join)(latticeRoot, "data", "blobs");
+  const blobDir = (0, import_node_path15.join)(latticeRoot, "data", "blobs");
   (0, import_node_fs14.mkdirSync)(blobDir, { recursive: true });
-  const destAbs = (0, import_node_path14.join)(blobDir, sha256);
+  const destAbs = (0, import_node_path15.join)(blobDir, sha256);
   if (!(0, import_node_fs14.existsSync)(destAbs)) {
     (0, import_node_fs14.copyFileSync)(srcPath, destAbs);
   }
@@ -58720,7 +58832,7 @@ async function attachBlob(srcPath, latticeRoot) {
     // across machines (path.join would emit backslashes on Windows).
     blob_path: `data/blobs/${sha256}`,
     size_bytes: stats.size,
-    original_name: (0, import_node_path14.basename)(srcPath)
+    original_name: (0, import_node_path15.basename)(srcPath)
   };
 }
 
@@ -58878,7 +58990,7 @@ init_canonical_context();
 // src/framework/migrate-to-root.ts
 var import_node_fs20 = require("fs");
 var import_node_os7 = require("os");
-var import_node_path23 = require("path");
+var import_node_path24 = require("path");
 init_lattice_root();
 var LEGACY_ENTRIES = [
   "master.key",
@@ -58888,16 +59000,16 @@ var LEGACY_ENTRIES = [
   "keys"
 ];
 function importLegacyUserConfig(root6) {
-  const legacy = process.env.LATTICE_CONFIG_DIR ?? (0, import_node_path23.join)((0, import_node_os7.homedir)(), ".lattice");
+  const legacy = process.env.LATTICE_CONFIG_DIR ?? (0, import_node_path24.join)((0, import_node_os7.homedir)(), ".lattice");
   const dest = rootConfigDir(root6);
   const copied = [];
-  if (!(0, import_node_fs20.existsSync)((0, import_node_path23.join)(legacy, "master.key"))) return { migrated: false, copied };
-  if ((0, import_node_fs20.existsSync)((0, import_node_path23.join)(dest, "master.key"))) return { migrated: false, copied };
+  if (!(0, import_node_fs20.existsSync)((0, import_node_path24.join)(legacy, "master.key"))) return { migrated: false, copied };
+  if ((0, import_node_fs20.existsSync)((0, import_node_path24.join)(dest, "master.key"))) return { migrated: false, copied };
   (0, import_node_fs20.mkdirSync)(dest, { recursive: true });
   for (const entry of LEGACY_ENTRIES) {
-    const src = (0, import_node_path23.join)(legacy, entry);
+    const src = (0, import_node_path24.join)(legacy, entry);
     if ((0, import_node_fs20.existsSync)(src)) {
-      (0, import_node_fs20.cpSync)(src, (0, import_node_path23.join)(dest, entry), { recursive: true });
+      (0, import_node_fs20.cpSync)(src, (0, import_node_path24.join)(dest, entry), { recursive: true });
       copied.push(entry);
     }
   }
@@ -58906,7 +59018,7 @@ function importLegacyUserConfig(root6) {
 
 // src/sources/resolver.ts
 var import_promises6 = require("fs/promises");
-var import_node_path24 = require("path");
+var import_node_path25 = require("path");
 init_url_safety();
 
 // src/sources/types.ts
@@ -58935,7 +59047,7 @@ function refKindOf(row) {
 }
 function blobHandle(row, latticeRoot) {
   const rel = row.blob_path ?? null;
-  const abs = rel ? (0, import_node_path24.join)(latticeRoot, rel) : null;
+  const abs = rel ? (0, import_node_path25.join)(latticeRoot, rel) : null;
   const location = rel ? `blob:${rel}` : "blob:?";
   return {
     kind: "blob",
@@ -58956,20 +59068,20 @@ function blobHandle(row, latticeRoot) {
   };
 }
 function fsHandle(row) {
-  const path2 = row.ref_uri ?? "";
+  const path3 = row.ref_uri ?? "";
   return {
     kind: "local_ref",
     provider: "fs",
-    location: path2,
+    location: path3,
     async readContent() {
       try {
-        return await (0, import_promises6.readFile)(path2);
+        return await (0, import_promises6.readFile)(path3);
       } catch (e6) {
-        throw new ReferenceUnavailableError(path2, e6.message);
+        throw new ReferenceUnavailableError(path3, e6.message);
       }
     },
     async getMetadata() {
-      return statMeta(path2, row);
+      return statMeta(path3, row);
     }
   };
 }
@@ -59038,9 +59150,9 @@ function meta(available, parts = {}) {
   if (parts.extra != null) m4.extra = parts.extra;
   return m4;
 }
-async function statMeta(path2, row) {
+async function statMeta(path3, row) {
   try {
-    const s2 = await (0, import_promises6.stat)(path2);
+    const s2 = await (0, import_promises6.stat)(path3);
     return meta(true, {
       size_bytes: s2.size,
       modified_at: s2.mtime.toISOString(),
@@ -59068,15 +59180,15 @@ init_benchmark();
 
 // src/framework/reference-store.ts
 var import_node_fs21 = require("fs");
-var import_node_path25 = require("path");
+var import_node_path26 = require("path");
 init_url_safety();
 function referenceLocalFile(srcPath) {
-  const abs = (0, import_node_path25.resolve)(srcPath);
+  const abs = (0, import_node_path26.resolve)(srcPath);
   const meta2 = {
     ref_kind: "local_ref",
     ref_uri: abs,
     ref_provider: "fs",
-    original_name: (0, import_node_path25.basename)(abs),
+    original_name: (0, import_node_path26.basename)(abs),
     extraction_status: "pending",
     source_json: JSON.stringify({ last_seen_at: (/* @__PURE__ */ new Date()).toISOString() })
   };
@@ -59774,14 +59886,14 @@ function isBetter(next, prev) {
 }
 
 // src/ai/vision.ts
-var import_node_module4 = require("module");
+var import_node_module5 = require("module");
 var import_promises7 = require("fs/promises");
 init_llm_client();
-var import_meta3 = {};
+var import_meta4 = {};
 var DEFAULT_PROMPT = "Describe this image for a knowledge base in 2-4 factual sentences: what it shows, any visible text, and notable details. No preamble.";
 var MAX_DIM = 1568;
-async function describeImage(auth, path2, opts = {}) {
-  const data = (await normalizeImage(path2, opts.maxBytes ?? 14e5)).toString("base64");
+async function describeImage(auth, path3, opts = {}) {
+  const data = (await normalizeImage(path3, opts.maxBytes ?? 14e5)).toString("base64");
   const sender = opts.sender ?? defaultSender(auth);
   const text = await sender({
     media_type: "image/jpeg",
@@ -59792,8 +59904,8 @@ async function describeImage(auth, path2, opts = {}) {
   return text.trim();
 }
 var DEFAULT_PDF_PROMPT = "Read this document for a knowledge base. First transcribe its readable text, then add a 2-4 sentence factual summary of what it is and its key details. It may be a scanned/image-only PDF \u2014 read the text from the page images. No preamble.";
-async function describePdf(auth, path2, opts = {}) {
-  const buf = await (0, import_promises7.readFile)(path2);
+async function describePdf(auth, path3, opts = {}) {
+  const buf = await (0, import_promises7.readFile)(path3);
   const maxBytes = opts.maxBytes ?? 3e7;
   if (buf.length > maxBytes) {
     throw new Error(
@@ -59808,19 +59920,19 @@ async function describePdf(auth, path2, opts = {}) {
   });
   return text.trim();
 }
-async function normalizeImage(path2, maxBytes) {
+async function normalizeImage(path3, maxBytes) {
   const sharpMod = await import("sharp");
   const sharp = sharpMod.default;
   let quality = 80;
-  let buf = await renderJpeg(sharp, path2, quality);
+  let buf = await renderJpeg(sharp, path3, quality);
   while (buf.length > maxBytes && quality > 35) {
     quality -= 15;
-    buf = await renderJpeg(sharp, path2, quality);
+    buf = await renderJpeg(sharp, path3, quality);
   }
   return buf;
 }
-function renderJpeg(sharp, path2, quality) {
-  return sharp(path2).rotate().resize({ width: MAX_DIM, height: MAX_DIM, fit: "inside", withoutEnlargement: true }).jpeg({ quality }).toBuffer();
+function renderJpeg(sharp, path3, quality) {
+  return sharp(path3).rotate().resize({ width: MAX_DIM, height: MAX_DIM, fit: "inside", withoutEnlargement: true }).jpeg({ quality }).toBuffer();
 }
 function buildVisionAnthropicConfig(auth) {
   const config = {};
@@ -59837,8 +59949,8 @@ function buildVisionAnthropicConfig(auth) {
 }
 function defaultSender(auth) {
   return async (input) => {
-    const importMetaUrl = import_meta3.url;
-    const req = importMetaUrl ? (0, import_node_module4.createRequire)(importMetaUrl) : require;
+    const importMetaUrl = import_meta4.url;
+    const req = importMetaUrl ? (0, import_node_module5.createRequire)(importMetaUrl) : require;
     const sdk = req("@anthropic-ai/sdk");
     const Anthropic = sdk.Anthropic ?? sdk.default;
     if (!Anthropic) throw new Error("Could not resolve Anthropic from '@anthropic-ai/sdk'");
@@ -59864,8 +59976,8 @@ function defaultSender(auth) {
 }
 function defaultPdfSender(auth) {
   return async (input) => {
-    const importMetaUrl = import_meta3.url;
-    const req = importMetaUrl ? (0, import_node_module4.createRequire)(importMetaUrl) : require;
+    const importMetaUrl = import_meta4.url;
+    const req = importMetaUrl ? (0, import_node_module5.createRequire)(importMetaUrl) : require;
     const sdk = req("@anthropic-ai/sdk");
     const Anthropic = sdk.Anthropic ?? sdk.default;
     if (!Anthropic) throw new Error("Could not resolve Anthropic from '@anthropic-ai/sdk'");
@@ -59895,9 +60007,9 @@ init_summarize();
 
 // src/gui/server.ts
 var import_node_http3 = require("http");
-var import_node_child_process5 = require("child_process");
+var import_node_child_process6 = require("child_process");
 var import_ws = require("ws");
-var import_node_path47 = require("path");
+var import_node_path48 = require("path");
 init_http2();
 
 // src/gui/active-db.ts
@@ -59950,7 +60062,7 @@ async function attachRowAccess(db, table, rows) {
 }
 
 // src/gui/lifecycle.ts
-var import_node_path31 = require("path");
+var import_node_path32 = require("path");
 var import_node_fs29 = require("fs");
 init_lattice();
 init_parser();
@@ -60176,13 +60288,13 @@ init_postgres();
 
 // src/gui/realtime.ts
 var import_node_events = require("events");
-var import_node_module5 = require("module");
-var import_meta4 = {};
+var import_node_module6 = require("module");
+var import_meta5 = {};
 var _pgModule = null;
 function loadPg() {
   if (_pgModule) return _pgModule;
-  const importMetaUrl = import_meta4.url;
-  const requireFromHere = importMetaUrl ? (0, import_node_module5.createRequire)(importMetaUrl) : (
+  const importMetaUrl = import_meta5.url;
+  const requireFromHere = importMetaUrl ? (0, import_node_module6.createRequire)(importMetaUrl) : (
     // CJS fallback — Node provides `require` on every CJS module scope.
     require
   );
@@ -61067,7 +61179,7 @@ async function openConfig(configPath, outputDir, autoRender = false, realtimeWat
   }
   const parsed = parseConfigFile(configPath);
   if (!/^postgres(ql)?:\/\//i.test(parsed.dbPath) && !parsed.dbPath.startsWith("file:") && parsed.dbPath !== ":memory:") {
-    (0, import_node_fs29.mkdirSync)((0, import_node_path31.dirname)(parsed.dbPath), { recursive: true });
+    (0, import_node_fs29.mkdirSync)((0, import_node_path32.dirname)(parsed.dbPath), { recursive: true });
   }
   const encryptionKey = getOrCreateMasterKey();
   if (/^postgres(ql)?:\/\//i.test(parsed.dbPath)) {
@@ -61556,7 +61668,7 @@ async function applySchemaConfig(active, entry, direction, autoRender) {
   const doc = loadConfigDoc(active.configPath);
   const inv = direction === "inverse";
   const ddl = [];
-  const has = (path2) => doc.getIn(path2) !== void 0;
+  const has = (path3) => doc.getIn(path3) !== void 0;
   const reAddEntity = async (name, def) => {
     if (has(["entities", name])) {
       throw new Error(`Cannot restore "${name}": an entity with that name already exists`);
@@ -71485,7 +71597,7 @@ var guiAppHtml = `<!doctype html>
 
 // src/update-check.ts
 var import_node_fs30 = require("fs");
-var import_node_path32 = require("path");
+var import_node_path33 = require("path");
 var import_node_os8 = require("os");
 var ONE_DAY_MS = 864e5;
 function isNewer2(latest, current) {
@@ -71501,8 +71613,8 @@ function isNewer2(latest, current) {
 }
 async function checkForUpdate(pkgName, currentVersion, opts = {}) {
   const ttlMs = opts.ttlMs ?? ONE_DAY_MS;
-  const cacheDir = (0, import_node_path32.join)((0, import_node_os8.homedir)(), ".lattice");
-  const cachePath = (0, import_node_path32.join)(cacheDir, `update-check-${pkgName}.json`);
+  const cacheDir = (0, import_node_path33.join)((0, import_node_os8.homedir)(), ".lattice");
+  const cachePath = (0, import_node_path33.join)(cacheDir, `update-check-${pkgName}.json`);
   try {
     if (!opts.force && (0, import_node_fs30.existsSync)(cachePath)) {
       const cached = JSON.parse((0, import_node_fs30.readFileSync)(cachePath, "utf-8"));
@@ -71528,9 +71640,9 @@ async function checkForUpdate(pkgName, currentVersion, opts = {}) {
 }
 
 // src/update-context.ts
-var import_node_child_process3 = require("child_process");
+var import_node_child_process4 = require("child_process");
 var import_node_fs31 = require("fs");
-var import_node_path33 = require("path");
+var import_node_path34 = require("path");
 init_user_config();
 var SEMVER_RE = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
 function isValidVersion(v2) {
@@ -71539,7 +71651,7 @@ function isValidVersion(v2) {
 function findPackageRoot(start, pkgName) {
   let dir = start;
   for (let depth = 0; depth < 12; depth++) {
-    const pkgJson = (0, import_node_path33.join)(dir, "package.json");
+    const pkgJson = (0, import_node_path34.join)(dir, "package.json");
     if ((0, import_node_fs31.existsSync)(pkgJson)) {
       try {
         const { name } = JSON.parse((0, import_node_fs31.readFileSync)(pkgJson, "utf-8"));
@@ -71547,16 +71659,16 @@ function findPackageRoot(start, pkgName) {
       } catch {
       }
     }
-    const parent = (0, import_node_path33.dirname)(dir);
+    const parent = (0, import_node_path34.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
   return null;
 }
 function isUnderGlobalPrefix(packageRoot, execPath) {
-  if (packageRoot.includes(`${import_node_path33.sep}lib${import_node_path33.sep}node_modules${import_node_path33.sep}`)) return true;
-  const prefix = (0, import_node_path33.dirname)((0, import_node_path33.dirname)(execPath));
-  return packageRoot.startsWith(prefix + import_node_path33.sep) && packageRoot.includes(`node_modules${import_node_path33.sep}`);
+  if (packageRoot.includes(`${import_node_path34.sep}lib${import_node_path34.sep}node_modules${import_node_path34.sep}`)) return true;
+  const prefix = (0, import_node_path34.dirname)((0, import_node_path34.dirname)(execPath));
+  return packageRoot.startsWith(prefix + import_node_path34.sep) && packageRoot.includes(`node_modules${import_node_path34.sep}`);
 }
 function detectInstallContext(opts = {}) {
   const pkgName = opts.pkgName ?? "latticesql";
@@ -71573,8 +71685,8 @@ function detectInstallContext(opts = {}) {
   };
   const modulePath = resolveReal(rawModulePath);
   const cwd = resolveReal(rawCwd);
-  const packageRoot = findPackageRoot((0, import_node_path33.dirname)(modulePath), pkgName);
-  if (packageRoot && (0, import_node_fs31.existsSync)((0, import_node_path33.join)(packageRoot, ".git"))) {
+  const packageRoot = findPackageRoot((0, import_node_path34.dirname)(modulePath), pkgName);
+  if (packageRoot && (0, import_node_fs31.existsSync)((0, import_node_path34.join)(packageRoot, ".git"))) {
     return {
       kind: "linked-dev",
       installable: false,
@@ -71583,7 +71695,7 @@ function detectInstallContext(opts = {}) {
       reason: "running from a git checkout \u2014 auto-update disabled (dev build)"
     };
   }
-  const localLink = (0, import_node_path33.join)(cwd, "node_modules", pkgName);
+  const localLink = (0, import_node_path34.join)(cwd, "node_modules", pkgName);
   try {
     if ((0, import_node_fs31.lstatSync)(localLink).isSymbolicLink()) {
       return {
@@ -71597,7 +71709,7 @@ function detectInstallContext(opts = {}) {
   } catch {
   }
   const ua = env2.npm_config_user_agent ?? "";
-  const npxLike = ua.includes("npx") || env2.npm_command === "exec" || (packageRoot?.includes(`${import_node_path33.sep}_npx${import_node_path33.sep}`) ?? false) || modulePath.includes(`${import_node_path33.sep}_npx${import_node_path33.sep}`);
+  const npxLike = ua.includes("npx") || env2.npm_command === "exec" || (packageRoot?.includes(`${import_node_path34.sep}_npx${import_node_path34.sep}`) ?? false) || modulePath.includes(`${import_node_path34.sep}_npx${import_node_path34.sep}`);
   if (npxLike) {
     return {
       kind: "npx",
@@ -71640,7 +71752,7 @@ function installArgsFor(ctx, version, pkgName = "latticesql") {
 function installLatest(ctx, version, opts = {}) {
   const args = installArgsFor(ctx, version, opts.pkgName ?? "latticesql");
   if (!args) return false;
-  (0, import_node_child_process3.execFileSync)("npm", args, {
+  (0, import_node_child_process4.execFileSync)("npm", args, {
     cwd: ctx.cwd,
     stdio: opts.quiet ? "ignore" : "inherit",
     timeout: 12e4,
@@ -71775,15 +71887,15 @@ init_column_descriptions();
 
 // src/gui/userconfig-routes.ts
 var import_node_fs33 = require("fs");
-var import_node_path35 = require("path");
+var import_node_path36 = require("path");
 init_user_config();
 init_parser();
 init_http2();
 
 // src/gui/files-routes.ts
 var import_node_fs32 = require("fs");
-var import_node_path34 = require("path");
-var import_node_child_process4 = require("child_process");
+var import_node_path35 = require("path");
+var import_node_child_process5 = require("child_process");
 init_http2();
 function localFileOpenEnabled() {
   return process.env.LATTICE_LOCAL_OPEN !== "0";
@@ -71793,7 +71905,7 @@ function localPathOf(row, latticeRoot) {
     return row.ref_uri;
   }
   if ((row.ref_kind === "blob" || row.ref_kind === "cloud_ref") && typeof row.blob_path === "string" && row.blob_path) {
-    return (0, import_node_path34.isAbsolute)(row.blob_path) ? row.blob_path : latticeRoot ? (0, import_node_path34.join)(latticeRoot, row.blob_path) : null;
+    return (0, import_node_path35.isAbsolute)(row.blob_path) ? row.blob_path : latticeRoot ? (0, import_node_path35.join)(latticeRoot, row.blob_path) : null;
   }
   return null;
 }
@@ -71818,8 +71930,8 @@ function revealTargetFor(row, latticeRoot, loc, id) {
     const ext = typeof row.mime === "string" ? MIME_EXT[row.mime] : void 0;
     if (ext) name += ext;
   }
-  const dir = (0, import_node_path34.join)(latticeRoot, "data", "finder", id.replace(/[^A-Za-z0-9_-]/g, "_"));
-  const named = (0, import_node_path34.join)(dir, name);
+  const dir = (0, import_node_path35.join)(latticeRoot, "data", "finder", id.replace(/[^A-Za-z0-9_-]/g, "_"));
+  const named = (0, import_node_path35.join)(dir, name);
   try {
     const fresh = (0, import_node_fs32.existsSync)(named) && (0, import_node_fs32.statSync)(named).size === (0, import_node_fs32.statSync)(loc).size;
     if (!fresh) {
@@ -71955,9 +72067,9 @@ async function dispatchFilesRoute(req, res, ctx) {
       return true;
     }
     const target = revealTargetFor(row, ctx.latticeRoot, loc, id);
-    const reveal = process.platform === "darwin" ? { cmd: "open", args: ["-R", target] } : process.platform === "win32" ? { cmd: "explorer", args: [`/select,${target}`] } : { cmd: "xdg-open", args: [(0, import_node_path34.dirname)(target)] };
+    const reveal = process.platform === "darwin" ? { cmd: "open", args: ["-R", target] } : process.platform === "win32" ? { cmd: "explorer", args: [`/select,${target}`] } : { cmd: "xdg-open", args: [(0, import_node_path35.dirname)(target)] };
     try {
-      const child = (0, import_node_child_process4.spawn)(reveal.cmd, reveal.args, { detached: true, stdio: "ignore" });
+      const child = (0, import_node_child_process5.spawn)(reveal.cmd, reveal.args, { detached: true, stdio: "ignore" });
       child.on("error", () => {
       });
       child.unref();
@@ -71990,18 +72102,18 @@ async function upsertIdentityRow(db, identity) {
   }
 }
 function listProjectConfigs(activeConfigPath) {
-  const dir = (0, import_node_path35.dirname)(activeConfigPath);
+  const dir = (0, import_node_path36.dirname)(activeConfigPath);
   const out = [];
   if (!(0, import_node_fs33.existsSync)(dir)) return out;
   for (const fname of (0, import_node_fs33.readdirSync)(dir)) {
     if (!fname.endsWith(".yml") && !fname.endsWith(".yaml")) continue;
-    const full = (0, import_node_path35.join)(dir, fname);
+    const full = (0, import_node_path36.join)(dir, fname);
     try {
       const parsed = parseConfigFile(full);
       out.push({
         path: full,
         name: fname.replace(/\.(ya?ml)$/, ""),
-        dbFile: (0, import_node_path35.basename)(parsed.dbPath)
+        dbFile: (0, import_node_path36.basename)(parsed.dbPath)
       });
     } catch {
     }
@@ -72088,7 +72200,7 @@ async function dispatchUserConfigRoute(req, res, ctx) {
 
 // src/gui/dbconfig/shared.ts
 var import_node_fs34 = require("fs");
-var import_node_path36 = require("path");
+var import_node_path37 = require("path");
 var import_yaml6 = require("yaml");
 function buildPostgresUrl(params) {
   const u2 = encodeURIComponent(params.user);
@@ -72118,9 +72230,9 @@ function rewriteDbLine(configPath, newValue) {
 function parseSaveBody(body) {
   const type = body.type;
   if (type === "sqlite") {
-    const path2 = typeof body.path === "string" && body.path.trim() ? body.path.trim() : "";
-    if (!path2) return null;
-    return { type: "sqlite", path: path2 };
+    const path3 = typeof body.path === "string" && body.path.trim() ? body.path.trim() : "";
+    if (!path3) return null;
+    return { type: "sqlite", path: path3 };
   }
   if (type === "postgres") {
     const label = typeof body.label === "string" && body.label.trim() ? body.label.trim() : "";
@@ -72136,12 +72248,12 @@ function parseSaveBody(body) {
   return null;
 }
 function resolveRelativeToConfig(configPath, candidate) {
-  return (0, import_node_path36.isAbsolute)(candidate) ? candidate : (0, import_node_path36.resolve)(configPath, "..", candidate);
+  return (0, import_node_path37.isAbsolute)(candidate) ? candidate : (0, import_node_path37.resolve)(configPath, "..", candidate);
 }
 
 // src/gui/dbconfig/connection-routes.ts
 var import_node_fs35 = require("fs");
-var import_node_path37 = require("path");
+var import_node_path38 = require("path");
 var import_yaml7 = require("yaml");
 init_lattice();
 init_http2();
@@ -72190,7 +72302,7 @@ async function describeCurrent(configPath, db) {
   return {
     type: "sqlite",
     state: "local",
-    dbFile: (0, import_node_path37.basename)(dbLine),
+    dbFile: (0, import_node_path38.basename)(dbLine),
     isCloud: false
   };
 }
@@ -72231,8 +72343,8 @@ async function dispatchConnection(req, res, ctx) {
         return;
       }
       const abs = resolveRelativeToConfig(ctx.configPath, parsed.path);
-      const rel = (0, import_node_path37.relative)((0, import_node_path37.resolve)(ctx.configPath, ".."), abs);
-      const dbLine = rel.startsWith("..") ? abs : "./" + rel.split(import_node_path37.sep).join("/");
+      const rel = (0, import_node_path38.relative)((0, import_node_path38.resolve)(ctx.configPath, ".."), abs);
+      const dbLine = rel.startsWith("..") ? abs : "./" + rel.split(import_node_path38.sep).join("/");
       rewriteDbLine(ctx.configPath, dbLine);
       sendJson(res, { ok: true, type: "sqlite", path: dbLine });
     });
@@ -72298,7 +72410,7 @@ async function dispatchConnection(req, res, ctx) {
       const doc = (0, import_yaml7.parseDocument)((0, import_node_fs35.readFileSync)(ctx.configPath, "utf8"));
       doc.set("name", name);
       (0, import_node_fs35.writeFileSync)(ctx.configPath, doc.toString(), "utf8");
-      const root6 = findLatticeRoot((0, import_node_path37.dirname)(ctx.configPath));
+      const root6 = findLatticeRoot((0, import_node_path38.dirname)(ctx.configPath));
       if (root6) renameWorkspaceByConfigPath(root6, ctx.configPath, name);
       const info = await describeCurrent(ctx.configPath, ctx.db);
       sendJson(res, { ok: true, kind: info.isCloud ? "cloud" : "local", name });
@@ -72310,7 +72422,7 @@ async function dispatchConnection(req, res, ctx) {
 
 // src/gui/dbconfig/cloud-state-routes.ts
 var import_node_fs37 = require("fs");
-var import_node_path39 = require("path");
+var import_node_path40 = require("path");
 var import_yaml9 = require("yaml");
 var import_node_crypto20 = require("crypto");
 init_http2();
@@ -72415,22 +72527,22 @@ init_workspace();
 
 // src/framework/gui-bootstrap.ts
 var import_node_fs36 = require("fs");
-var import_node_path38 = require("path");
+var import_node_path39 = require("path");
 var import_yaml8 = require("yaml");
 init_lattice_root();
 init_workspace();
 function resolveContextDirForConfig(configPath) {
-  const base = (0, import_node_path38.dirname)((0, import_node_path38.resolve)(configPath));
+  const base = (0, import_node_path39.dirname)((0, import_node_path39.resolve)(configPath));
   for (const dir of ["context", ".", "generated"]) {
-    const abs = (0, import_node_path38.resolve)(base, dir);
-    if ((0, import_node_fs36.existsSync)((0, import_node_path38.join)(abs, ".lattice", "manifest.json"))) return abs;
+    const abs = (0, import_node_path39.resolve)(base, dir);
+    if ((0, import_node_fs36.existsSync)((0, import_node_path39.join)(abs, ".lattice", "manifest.json"))) return abs;
   }
-  return (0, import_node_path38.resolve)(base, "context");
+  return (0, import_node_path39.resolve)(base, "context");
 }
 
 // src/gui/dbconfig/cloud-state-routes.ts
 function updateActiveWorkspaceToCloud(configPath, displayName, key) {
-  const root6 = findLatticeRoot((0, import_node_path39.dirname)(configPath));
+  const root6 = findLatticeRoot((0, import_node_path40.dirname)(configPath));
   if (!root6) return;
   registerOrUpdateCloudWorkspace(root6, {
     configPath,
@@ -72694,7 +72806,7 @@ async function dispatchCloudState(req, res, ctx) {
       await assertScopedMemberRole(ctx.db, role);
       const user = poolerAwareUser(coords.host, role, coords.user);
       const expiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1e3);
-      const inviteRoot = findLatticeRoot((0, import_node_path39.dirname)(ctx.configPath));
+      const inviteRoot = findLatticeRoot((0, import_node_path40.dirname)(ctx.configPath));
       const ownerWs = inviteRoot ? getActiveWorkspace(inviteRoot) : null;
       const token = mintInviteToken({
         coords,
@@ -73637,7 +73749,7 @@ async function dispatchChatRoute(req, res, ctx) {
 var import_node_fs40 = require("fs");
 var import_promises12 = require("fs/promises");
 var import_node_os9 = require("os");
-var import_node_path42 = require("path");
+var import_node_path43 = require("path");
 init_mutations();
 init_extract();
 var import_node_crypto23 = require("crypto");
@@ -74098,7 +74210,7 @@ function dedupeAndDetectViews(plan, data) {
 }
 
 // src/import/excel.ts
-var import_node_path40 = require("path");
+var import_node_path41 = require("path");
 var HEADER_SCAN_ROWS = 25;
 function cellValue(v2) {
   if (v2 === null || v2 === void 0) return null;
@@ -74169,7 +74281,7 @@ function sheetToRecords(ws) {
 }
 var preambleCache = /* @__PURE__ */ new Map();
 function excelPreambleText(absPath) {
-  return preambleCache.get((0, import_node_path40.resolve)(absPath)) ?? "";
+  return preambleCache.get((0, import_node_path41.resolve)(absPath)) ?? "";
 }
 function sheetPreamble(ws) {
   const lines = [];
@@ -74206,7 +74318,7 @@ async function excelToRecords(absPath) {
     const records = sheetToRecords(ws);
     if (records.length > 0) out[ws.name] = records;
   }
-  preambleCache.set((0, import_node_path40.resolve)(absPath), preamble.filter(Boolean).join("\n"));
+  preambleCache.set((0, import_node_path41.resolve)(absPath), preamble.filter(Boolean).join("\n"));
   return out;
 }
 
@@ -74643,7 +74755,7 @@ async function materializeImport(ctx, data, plan, views = [], opts = {}) {
 init_native_entities();
 
 // src/gui/import-detect.ts
-var import_node_path41 = require("path");
+var import_node_path42 = require("path");
 
 // src/gui/ai/asof-llm.ts
 init_assistant_routes();
@@ -74687,7 +74799,7 @@ ${trimmed.slice(0, MAX_CHARS)}` }],
 
 // src/gui/import-detect.ts
 async function detectImportAsOf(db, data, opts = {}) {
-  const fileName = opts.fileName ?? (opts.abs ? (0, import_node_path41.basename)(opts.abs).replace(/^[0-9a-f]{8}-/, "") : "");
+  const fileName = opts.fileName ?? (opts.abs ? (0, import_node_path42.basename)(opts.abs).replace(/^[0-9a-f]{8}-/, "") : "");
   const texts = [];
   for (const [k6, v2] of Object.entries(data)) {
     if (!Array.isArray(v2)) texts.push({ label: "data", text: `${k6}: ${JSON.stringify(v2)}` });
@@ -74826,7 +74938,7 @@ var MIME_BY_EXT = {
   ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
 };
 function mimeFor(name) {
-  return MIME_BY_EXT[(0, import_node_path42.extname)(name).toLowerCase()] ?? "application/octet-stream";
+  return MIME_BY_EXT[(0, import_node_path43.extname)(name).toLowerCase()] ?? "application/octet-stream";
 }
 var RETAINABLE_DOC_MIMES = /* @__PURE__ */ new Set([
   "application/pdf",
@@ -74901,28 +75013,28 @@ ${err.stack ?? ""}`
     return null;
   }
 }
-async function extractImage(db, path2, mime) {
+async function extractImage(db, path3, mime) {
   if (!mime.startsWith("image/")) return null;
   const auth = await resolveClaudeAuth(db);
   if (!auth) return null;
   try {
-    const text = await describeImage(auth, path2);
+    const text = await describeImage(auth, path3);
     return text.trim() ? { text, skip: false } : null;
   } catch (e6) {
     console.warn("[ingest] image vision failed:", e6.message);
     return null;
   }
 }
-async function extractSource(db, path2, mime, name) {
-  const vision = await extractImage(db, path2, mime);
+async function extractSource(db, path3, mime, name) {
+  const vision = await extractImage(db, path3, mime);
   if (vision) return vision;
-  const parsed = await parseFile(path2, mime, name);
+  const parsed = await parseFile(path3, mime, name);
   if (!parsed.skip) return parsed;
   if (mime === "application/pdf") {
     const auth = await resolveClaudeAuth(db);
     if (auth) {
       try {
-        const text = await describePdf(auth, path2);
+        const text = await describePdf(auth, path3);
         if (text.trim()) return { ...parsed, text, skip: false };
       } catch (e6) {
         console.warn("[ingest] Claude PDF read failed:", e6.message);
@@ -74993,7 +75105,7 @@ async function dispatchIngestRoute(req, res, ctx) {
       sendJson(res, { error: "empty upload" }, 400);
       return true;
     }
-    const tmp = (0, import_node_path42.join)((0, import_node_os9.tmpdir)(), `lattice-ingest-${crypto.randomUUID()}${(0, import_node_path42.extname)(name2)}`);
+    const tmp = (0, import_node_path43.join)((0, import_node_os9.tmpdir)(), `lattice-ingest-${crypto.randomUUID()}${(0, import_node_path43.extname)(name2)}`);
     let result;
     let blob = null;
     let autoImport = null;
@@ -75216,7 +75328,7 @@ async function dispatchIngestRoute(req, res, ctx) {
     sendJson(res, { error: "path is required" }, 400);
     return true;
   }
-  const abs = (0, import_node_path42.resolve)(rawPath);
+  const abs = (0, import_node_path43.resolve)(rawPath);
   let size = 0;
   try {
     const st = (0, import_node_fs40.statSync)(abs);
@@ -75233,7 +75345,7 @@ async function dispatchIngestRoute(req, res, ctx) {
     sendJson(res, { error: "file too large" }, 413);
     return true;
   }
-  const name = (0, import_node_path42.basename)(abs);
+  const name = (0, import_node_path43.basename)(abs);
   const mime = mimeFor(name);
   const localFileId = crypto.randomUUID();
   const localRow = {
@@ -75301,7 +75413,7 @@ ${err.stack ?? ""}`
 
 // src/gui/import-routes.ts
 var import_node_fs41 = require("fs");
-var import_node_path43 = require("path");
+var import_node_path44 = require("path");
 init_adapter();
 init_http2();
 init_native_entities();
@@ -75313,7 +75425,7 @@ function badRequest(message) {
 function localPathOf2(row, latticeRoot) {
   if (row.ref_kind === "local_ref" && row.ref_uri) return row.ref_uri;
   if ((row.ref_kind === "blob" || row.ref_kind === "cloud_ref") && row.blob_path) {
-    return (0, import_node_path43.isAbsolute)(row.blob_path) ? row.blob_path : latticeRoot ? (0, import_node_path43.join)(latticeRoot, row.blob_path) : null;
+    return (0, import_node_path44.isAbsolute)(row.blob_path) ? row.blob_path : latticeRoot ? (0, import_node_path44.join)(latticeRoot, row.blob_path) : null;
   }
   return null;
 }
@@ -75335,11 +75447,11 @@ async function readImportSourceFromFile(db, fileId, latticeRoot) {
     [fileId]
   );
   if (!row) throw badRequest("Unknown import file: " + fileId);
-  const path2 = localPathOf2(row, latticeRoot);
-  if (!path2 || !(0, import_node_fs41.existsSync)(path2)) {
+  const path3 = localPathOf2(row, latticeRoot);
+  if (!path3 || !(0, import_node_fs41.existsSync)(path3)) {
     throw badRequest("The import file\u2019s bytes are not available locally.");
   }
-  const sizeBytes = (0, import_node_fs41.statSync)(path2).size;
+  const sizeBytes = (0, import_node_fs41.statSync)(path3).size;
   if (sizeBytes > MAX_INGEST_BYTES) {
     throw badRequest(
       `The import file is too large (${String(Math.round(sizeBytes / 1e6))} MB); the limit is ${String(Math.round(MAX_INGEST_BYTES / 1e6))} MB.`
@@ -75348,11 +75460,11 @@ async function readImportSourceFromFile(db, fileId, latticeRoot) {
   const name = row.original_name ?? "";
   const mime = row.mime ?? "";
   if (/\.xlsx?$/i.test(name) || mime.includes("spreadsheet") || mime.includes("excel")) {
-    return excelToRecords(path2);
+    return excelToRecords(path3);
   }
   let parsed;
   try {
-    parsed = JSON.parse((0, import_node_fs41.readFileSync)(path2, "utf8"));
+    parsed = JSON.parse((0, import_node_fs41.readFileSync)(path3, "utf8"));
   } catch {
     throw badRequest("The import file is not valid JSON.");
   }
@@ -76776,7 +76888,7 @@ async function handleHistoryRoutes(req, res, ctx, deps) {
 }
 
 // src/gui/workspaces-routes.ts
-var import_node_path44 = require("path");
+var import_node_path45 = require("path");
 var import_node_fs42 = require("fs");
 init_http2();
 init_workspace();
@@ -76940,7 +77052,7 @@ async function handleWorkspacesRoutes(req, res, ctx, deps) {
       return true;
     }
     const wsPaths = resolveWorkspacePaths(latticeRoot, ws);
-    const isActive = (0, import_node_path44.resolve)(active.configPath) === (0, import_node_path44.resolve)(wsPaths.configPath);
+    const isActive = (0, import_node_path45.resolve)(active.configPath) === (0, import_node_path45.resolve)(wsPaths.configPath);
     let switchedTo = null;
     if (isActive) {
       const fallback = listWorkspaces(latticeRoot).find((w2) => w2.id !== ws.id);
@@ -76988,34 +77100,34 @@ async function handleWorkspacesRoutes(req, res, ctx, deps) {
 }
 
 // src/gui/databases-routes.ts
-var import_node_path46 = require("path");
+var import_node_path47 = require("path");
 var import_node_fs44 = require("fs");
 init_http2();
 init_parser();
 
 // src/gui/config-paths.ts
-var import_node_path45 = require("path");
+var import_node_path46 = require("path");
 var import_node_fs43 = require("fs");
 var import_yaml10 = require("yaml");
 init_parser();
 function resolveOutputDirForConfig(configPath) {
-  const base = (0, import_node_path45.dirname)((0, import_node_path45.resolve)(configPath));
+  const base = (0, import_node_path46.dirname)((0, import_node_path46.resolve)(configPath));
   for (const dir of ["context", ".", "generated"]) {
-    const abs = (0, import_node_path45.resolve)(base, dir);
-    if ((0, import_node_fs43.existsSync)((0, import_node_path45.join)(abs, ".lattice", "manifest.json"))) return abs;
+    const abs = (0, import_node_path46.resolve)(base, dir);
+    if ((0, import_node_fs43.existsSync)((0, import_node_path46.join)(abs, ".lattice", "manifest.json"))) return abs;
   }
-  return (0, import_node_path45.resolve)(base, "context");
+  return (0, import_node_path46.resolve)(base, "context");
 }
 function friendlyConfigName(parsedName, configPath) {
   if (parsedName && parsedName.trim().length > 0) return parsedName.trim();
-  return (0, import_node_path45.basename)(configPath).replace(/\.(ya?ml)$/, "");
+  return (0, import_node_path46.basename)(configPath).replace(/\.(ya?ml)$/, "");
 }
 function listConfigs(activeConfigPath) {
-  const dir = (0, import_node_path45.dirname)(activeConfigPath);
+  const dir = (0, import_node_path46.dirname)(activeConfigPath);
   const entries = [];
   for (const fname of (0, import_node_fs43.readdirSync)(dir)) {
     if (!fname.endsWith(".yml") && !fname.endsWith(".yaml")) continue;
-    const full = (0, import_node_path45.join)(dir, fname);
+    const full = (0, import_node_path46.join)(dir, fname);
     try {
       const parsed = parseConfigFile(full);
       entries.push({
@@ -77026,7 +77138,7 @@ function listConfigs(activeConfigPath) {
         // `label` is the friendly DB name — what the user sees in the
         // dropdown + settings. Falls back to the basename when unset.
         label: friendlyConfigName(parsed.name, full),
-        dbFile: (0, import_node_path45.basename)(parsed.dbPath),
+        dbFile: (0, import_node_path46.basename)(parsed.dbPath),
         active: full === activeConfigPath,
         // `${LATTICE_DB:...}` and postgres:// configs resolve to a
         // postgres URL; everything else is a local SQLite file. This
@@ -77040,17 +77152,17 @@ function listConfigs(activeConfigPath) {
   return entries.sort((a6, b6) => a6.label.localeCompare(b6.label));
 }
 function createBlankConfig(activeConfigPath, dbName) {
-  const dir = (0, import_node_path45.dirname)(activeConfigPath);
+  const dir = (0, import_node_path46.dirname)(activeConfigPath);
   const slug = dbName.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
   if (!slug) throw new Error("Workspace name must contain at least one alphanumeric character");
-  const configPath = (0, import_node_path45.join)(dir, `${slug}.config.yml`);
+  const configPath = (0, import_node_path46.join)(dir, `${slug}.config.yml`);
   if ((0, import_node_fs43.existsSync)(configPath)) throw new Error(`Config already exists: ${slug}.config.yml`);
   const yaml = `db: ./data/${slug}.db
 
 entities: {}
 `;
   (0, import_node_fs43.writeFileSync)(configPath, yaml, "utf8");
-  (0, import_node_fs43.mkdirSync)((0, import_node_path45.join)(dir, "data"), { recursive: true });
+  (0, import_node_fs43.mkdirSync)((0, import_node_path46.join)(dir, "data"), { recursive: true });
   return configPath;
 }
 function sqliteFileForConfig(configPath) {
@@ -77059,7 +77171,7 @@ function sqliteFileForConfig(configPath) {
   if (!raw) return null;
   if (isPostgresUrl(raw) || raw.startsWith("${LATTICE_DB:")) return null;
   if (raw === ":memory:" || raw.startsWith("file:")) return null;
-  return (0, import_node_path45.resolve)((0, import_node_path45.dirname)(configPath), raw);
+  return (0, import_node_path46.resolve)((0, import_node_path46.dirname)(configPath), raw);
 }
 function deleteDatabaseFiles(targetConfigPath) {
   const sqliteFile = sqliteFileForConfig(targetConfigPath);
@@ -77073,7 +77185,7 @@ function deleteDatabaseFiles(targetConfigPath) {
       if ((0, import_node_fs43.existsSync)(sidecar)) (0, import_node_fs43.unlinkSync)(sidecar);
     }
   }
-  return { deletedConfig: (0, import_node_path45.basename)(targetConfigPath), deletedDbFile };
+  return { deletedConfig: (0, import_node_path46.basename)(targetConfigPath), deletedDbFile };
 }
 
 // src/gui/databases-routes.ts
@@ -77089,7 +77201,7 @@ async function handleDatabasesRoutes(req, res, ctx, deps) {
     sendJson(res, {
       current: {
         path: active.configPath,
-        dbFile: (0, import_node_path46.basename)(parsedActive.dbPath),
+        dbFile: (0, import_node_path47.basename)(parsedActive.dbPath),
         label: friendlyLabel,
         kind
       },
@@ -77103,7 +77215,7 @@ async function handleDatabasesRoutes(req, res, ctx, deps) {
       sendJson(res, { error: "path must be a string" }, 400);
       return true;
     }
-    const newPath = (0, import_node_path46.resolve)(body.path);
+    const newPath = (0, import_node_path47.resolve)(body.path);
     if (!(0, import_node_fs44.existsSync)(newPath)) {
       sendJson(res, { error: `Config not found: ${newPath}` }, 400);
       return true;
@@ -77146,16 +77258,16 @@ async function handleDatabasesRoutes(req, res, ctx, deps) {
       sendJson(res, { error: "path must be a non-empty string" }, 400);
       return true;
     }
-    const target = (0, import_node_path46.resolve)(body.path);
+    const target = (0, import_node_path47.resolve)(body.path);
     const known = listConfigs(active.configPath);
-    const match = known.find((c6) => (0, import_node_path46.resolve)(c6.path) === target);
+    const match = known.find((c6) => (0, import_node_path47.resolve)(c6.path) === target);
     if (!match) {
       sendJson(res, { error: `Not a known database config: ${target}` }, 400);
       return true;
     }
     let switchedTo = null;
-    if ((0, import_node_path46.resolve)(active.configPath) === target) {
-      const fallback = known.find((c6) => (0, import_node_path46.resolve)(c6.path) !== target);
+    if ((0, import_node_path47.resolve)(active.configPath) === target) {
+      const fallback = known.find((c6) => (0, import_node_path47.resolve)(c6.path) !== target);
       if (!fallback) {
         sendJson(
           res,
@@ -77216,7 +77328,7 @@ function sendText(res, body, status = 200, contentType = "text/plain; charset=ut
 function openUrl(url) {
   const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
   const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-  const child = (0, import_node_child_process5.spawn)(command, args, { stdio: "ignore", detached: true });
+  const child = (0, import_node_child_process6.spawn)(command, args, { stdio: "ignore", detached: true });
   child.unref();
 }
 function listen(server, port, host) {
@@ -77246,8 +77358,8 @@ async function listenWithPortFallback(server, startPort, host) {
   throw new Error(`No available port found starting at ${String(startPort)}`);
 }
 async function startGuiServer(options) {
-  const bootConfigPath = options.configPath ? (0, import_node_path47.resolve)(options.configPath) : null;
-  const bootOutputDir = options.outputDir ? (0, import_node_path47.resolve)(options.outputDir) : null;
+  const bootConfigPath = options.configPath ? (0, import_node_path48.resolve)(options.configPath) : null;
+  const bootOutputDir = options.outputDir ? (0, import_node_path48.resolve)(options.outputDir) : null;
   const startPort = options.port ?? 4317;
   const host = options.host ?? "127.0.0.1";
   const isLoopbackHost2 = host === "localhost" || host === "::1" || host.startsWith("127.");
@@ -77261,11 +77373,11 @@ async function startGuiServer(options) {
   const sessionId = crypto.randomUUID();
   let updateService = null;
   let activeRef = bootConfigPath && bootOutputDir ? await openConfig(bootConfigPath, bootOutputDir, autoRender, options.realtimeWatchdogMs) : null;
-  const latticeRoot = (bootConfigPath ? findLatticeRoot((0, import_node_path47.dirname)(bootConfigPath)) : null) ?? (options.latticeRoot ? (0, import_node_path47.resolve)(options.latticeRoot) : null);
+  const latticeRoot = (bootConfigPath ? findLatticeRoot((0, import_node_path48.dirname)(bootConfigPath)) : null) ?? (options.latticeRoot ? (0, import_node_path48.resolve)(options.latticeRoot) : null);
   let currentWorkspaceId = null;
   if (latticeRoot && bootConfigPath) {
     const launched = listWorkspaces(latticeRoot).find(
-      (w2) => (0, import_node_path47.resolve)(resolveWorkspacePaths(latticeRoot, w2).configPath) === (0, import_node_path47.resolve)(bootConfigPath)
+      (w2) => (0, import_node_path48.resolve)(resolveWorkspacePaths(latticeRoot, w2).configPath) === (0, import_node_path48.resolve)(bootConfigPath)
     );
     if (launched) {
       currentWorkspaceId = launched.id;
@@ -77601,7 +77713,7 @@ async function startGuiServer(options) {
                 createJunction: (otherTable) => createFileJunction(active, otherTable, sessionId),
                 createEntity: (entity, columns) => createUserEntity(active, entity, columns, sessionId),
                 aggressiveness: getAggressiveness(),
-                latticeRoot: (0, import_node_path47.dirname)(active.configPath),
+                latticeRoot: (0, import_node_path48.dirname)(active.configPath),
                 configPath: active.configPath,
                 outputDir: active.outputDir,
                 sessionId,
@@ -77620,7 +77732,7 @@ async function startGuiServer(options) {
               return await dispatchImportRoute(req2, res2, {
                 db: active.db,
                 configPath: active.configPath,
-                latticeRoot: (0, import_node_path47.dirname)(active.configPath),
+                latticeRoot: (0, import_node_path48.dirname)(active.configPath),
                 validTables: active.validTables,
                 softDeletable: active.softDeletable
               });
@@ -77632,7 +77744,7 @@ async function startGuiServer(options) {
               if (!pathname.startsWith("/api/files/")) return false;
               return await dispatchFilesRoute(req2, res2, {
                 db: active.db,
-                latticeRoot: (0, import_node_path47.dirname)(active.configPath),
+                latticeRoot: (0, import_node_path48.dirname)(active.configPath),
                 configPath: active.configPath,
                 pathname,
                 method
@@ -77844,7 +77956,7 @@ ${e6.stack ?? ""}`
 
 // src/cloud/file-source-key-store.ts
 var import_node_fs45 = require("fs");
-var import_node_path48 = require("path");
+var import_node_path49 = require("path");
 var import_node_crypto24 = require("crypto");
 var ENC_HEADER = "LATTICE-KMS-v1\n";
 var SCRYPT_N = 1 << 15;
@@ -77862,7 +77974,7 @@ var FileSourceKeyStore = class {
     if (!opts.path || typeof opts.path !== "string") {
       throw new Error("lattice: FileSourceKeyStore requires a non-empty `path`");
     }
-    this.path = (0, import_node_path48.resolve)(opts.path);
+    this.path = (0, import_node_path49.resolve)(opts.path);
     this.passphrase = opts.passphrase;
     this.cache = this.load();
   }
@@ -77896,7 +78008,7 @@ var FileSourceKeyStore = class {
   load() {
     const out = /* @__PURE__ */ new Map();
     if (!(0, import_node_fs45.existsSync)(this.path)) {
-      const dir = (0, import_node_path48.dirname)(this.path);
+      const dir = (0, import_node_path49.dirname)(this.path);
       if (!(0, import_node_fs45.existsSync)(dir)) (0, import_node_fs45.mkdirSync)(dir, { recursive: true, mode: 448 });
       return out;
     }