latticesql 4.3.1 → 4.3.3

package/dist/index.js

@@ -909,7 +909,7 @@ async function registerPostgresPolyfills(run) {
       await run(sql);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      if (/permission denied/i.test(msg)) {
+      if (/permission denied/i.test(msg) || /must be owner of/i.test(msg)) {
         permissionDenied = true;
       } else {
         console.warn(`[PostgresAdapter] ${warn}`, msg);
@@ -1427,40 +1427,111 @@ var init_postgres = __esm({
             SELECT doc::jsonb #>> string_to_array(regexp_replace(path, '^\\$\\.?', ''), '.')
           $fn$;
       END IF;
+    END $do$;`
+      },
+      {
+        warn: "could not register strftime format helper:",
+        // Shared format translator (SQLite strftime tokens → to_char patterns), in UTC.
+        // Factored out so the 2-arg and 3-arg strftime overloads share one definition.
+        // Each polyfill below is CREATE OR REPLACE (so an existing cloud's prior copy is
+        // UPGRADED when the owner opens), wrapped in a DO block whose EXCEPTION swallows a
+        // scoped member's insufficient-privilege failure IN A SUBTRANSACTION — so a member
+        // that runs registration inside a transaction is NOT aborted. ("must be owner of
+        // function", raised when a non-owner CREATE OR REPLACEs another role's function, is
+        // SQLSTATE 42501 / `insufficient_privilege`, same class as "permission denied".) The
+        // owner already owns + replaced the function; the member simply uses the owner's
+        // copy — and `ownPolyfillsByGroup` re-owns the whole set to the member group so any
+        // member can replace them on a later upgrade.
+        sql: `DO $do$ BEGIN
+      CREATE OR REPLACE FUNCTION __lattice_strftime_fmt(ts timestamptz, format text)
+        RETURNS text
+        LANGUAGE sql
+        IMMUTABLE
+        AS $fn$
+          SELECT to_char(
+            ts AT TIME ZONE 'UTC',
+            replace(replace(replace(replace(replace(replace(replace(replace(
+              format,
+              '%Y', 'YYYY'),
+              '%m', 'MM'),
+              '%d', 'DD'),
+              '%H', 'HH24'),
+              '%M', 'MI'),
+              '%S', 'SS'),
+              '%f', 'MS'),
+              'T', '"T"')
+          );
+        $fn$;
+    EXCEPTION WHEN insufficient_privilege THEN NULL;
     END $do$;`
       },
       {
         warn: "could not register strftime polyfill:",
+        // The pre-4.3.3 strftime cast the modifier straight to timestamptz and threw
+        // `invalid input syntax for type timestamp with time zone: ""` on a legacy ''
+        // value (3.x stored nullable TEXT timestamps as ''), bricking the whole workspace
+        // open. Now an empty, whitespace, or unparseable time string returns NULL (SQLite's
+        // strftime semantics) instead of aborting the query.
         sql: `DO $do$ BEGIN
-      IF to_regprocedure('strftime(text, text)') IS NULL THEN
-        CREATE FUNCTION strftime(format text, modifier text)
-          RETURNS text
-          LANGUAGE plpgsql
-          IMMUTABLE
-          AS $fn$
-          DECLARE ts timestamptz;
-          BEGIN
-            IF modifier = 'now' THEN
-              ts := now();
-            ELSE
+      CREATE OR REPLACE FUNCTION strftime(format text, modifier text)
+        RETURNS text
+        LANGUAGE plpgsql
+        IMMUTABLE
+        AS $fn$
+        DECLARE ts timestamptz;
+        BEGIN
+          IF modifier = 'now' THEN
+            ts := now();
+          ELSIF NULLIF(btrim(modifier), '') IS NULL THEN
+            RETURN NULL;
+          ELSE
+            BEGIN
               ts := modifier::timestamptz;
-            END IF;
-            RETURN to_char(
-              ts AT TIME ZONE 'UTC',
-              replace(replace(replace(replace(replace(replace(replace(replace(
-                format,
-                '%Y', 'YYYY'),
-                '%m', 'MM'),
-                '%d', 'DD'),
-                '%H', 'HH24'),
-                '%M', 'MI'),
-                '%S', 'SS'),
-                '%f', 'MS'),
-                'T', '"T"')
-            );
+            EXCEPTION WHEN others THEN
+              RETURN NULL;
+            END;
+          END IF;
+          RETURN __lattice_strftime_fmt(ts, format);
+        END;
+        $fn$;
+    EXCEPTION WHEN insufficient_privilege THEN NULL;
+    END $do$;`
+      },
+      {
+        warn: "could not register 3-arg strftime polyfill:",
+        // SQLite's 3-arg strftime(format, timestring, modifier) — used by the changelog
+        // retention prune (e.g. strftime('%Y-...','now','-30 days')). Postgres had no
+        // 3-arg overload, so that prune threw `function strftime(...) does not exist` on
+        // every PG cloud with retention. Resolve the base time, apply the modifier as an
+        // interval, then reuse the shared formatter. Empty/invalid → NULL, never throws.
+        sql: `DO $do$ BEGIN
+      CREATE OR REPLACE FUNCTION strftime(format text, timestring text, modifier text)
+        RETURNS text
+        LANGUAGE plpgsql
+        IMMUTABLE
+        AS $fn$
+        DECLARE ts timestamptz;
+        BEGIN
+          IF timestring = 'now' THEN
+            ts := now();
+          ELSIF NULLIF(btrim(timestring), '') IS NULL THEN
+            RETURN NULL;
+          ELSE
+            BEGIN
+              ts := timestring::timestamptz;
+            EXCEPTION WHEN others THEN
+              RETURN NULL;
+            END;
+          END IF;
+          BEGIN
+            ts := ts + modifier::interval;
+          EXCEPTION WHEN others THEN
+            RETURN NULL;
           END;
-          $fn$;
-      END IF;
+          RETURN __lattice_strftime_fmt(ts, format);
+        END;
+        $fn$;
+    EXCEPTION WHEN insufficient_privilege THEN NULL;
     END $do$;`
       }
     ];
@@ -9397,7 +9468,12 @@ CREATE TRIGGER "${trg}" AFTER INSERT OR UPDATE OR DELETE ON ${q3}
 async function ownPolyfillsByGroup(db) {
   if (!isPg(db)) return;
   const group3 = await memberGroupFor(db);
-  for (const sig of ["json_extract(text, text)", "strftime(text, text)"]) {
+  for (const sig of [
+    "json_extract(text, text)",
+    "strftime(text, text)",
+    "strftime(text, text, text)",
+    "__lattice_strftime_fmt(timestamptz, text)"
+  ]) {
     try {
       const reg = await getAsyncOrSync(db.adapter, `SELECT to_regprocedure($1) AS reg`, [sig]);
       if (reg?.reg == null) continue;
@@ -23495,12 +23571,12 @@ var getNodeModulesParentDirs;
 var init_getNodeModulesParentDirs = __esm({
   "node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/getNodeModulesParentDirs.js"() {
     "use strict";
-    getNodeModulesParentDirs = (dirname18) => {
+    getNodeModulesParentDirs = (dirname19) => {
       const cwd = process.cwd();
-      if (!dirname18) {
+      if (!dirname19) {
         return [cwd];
       }
-      const normalizedPath = normalize(dirname18);
+      const normalizedPath = normalize(dirname19);
       const parts = normalizedPath.split(sep3);
       const nodeModulesIndex = parts.indexOf("node_modules");
       const parentDir = nodeModulesIndex !== -1 ? parts.slice(0, nodeModulesIndex).join(sep3) : normalizedPath;
@@ -23578,8 +23654,8 @@ var init_getTypeScriptUserAgentPair = __esm({
         tscVersion = null;
         return void 0;
       }
-      const dirname18 = typeof __dirname !== "undefined" ? __dirname : void 0;
-      const nodeModulesParentDirs = getNodeModulesParentDirs(dirname18);
+      const dirname19 = typeof __dirname !== "undefined" ? __dirname : void 0;
+      const nodeModulesParentDirs = getNodeModulesParentDirs(dirname19);
       let versionFromApp;
       for (const nodeModulesParentDir of nodeModulesParentDirs) {
         try {
@@ -62153,9 +62229,9 @@ init_summarize();
 init_http2();
 import { createServer } from "http";
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync31 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 import { WebSocketServer, WebSocket } from "ws";
-import { dirname as dirname16, resolve as resolve16 } from "path";
+import { dirname as dirname17, resolve as resolve16 } from "path";
 
 // src/gui/active-db.ts
 init_adapter();
@@ -79982,8 +80058,16 @@ async function dispatchIngestRoute(req, res, ctx) {
 
 // src/gui/sources-routes.ts
 init_user_config();
-import { statSync as statSync10, readdirSync as readdirSync8, readFileSync as readFileSync24, writeFileSync as writeFileSync9 } from "fs";
-import { resolve as resolve12, join as join30, basename as basename13, sep as sep8 } from "path";
+import {
+  statSync as statSync10,
+  readdirSync as readdirSync8,
+  readFileSync as readFileSync24,
+  writeFileSync as writeFileSync9,
+  existsSync as existsSync26,
+  mkdirSync as mkdirSync11,
+  rmSync
+} from "fs";
+import { resolve as resolve12, join as join30, basename as basename13, sep as sep8, dirname as dirname15 } from "path";
 import { execFile } from "child_process";
 import { randomUUID as randomUUID4 } from "crypto";
 init_http2();
@@ -79991,20 +80075,49 @@ var MAX_LIST_ENTRIES = 2e3;
 var MAX_INGEST_FILES = 500;
 var MAX_INGEST_DEPTH = 8;
 var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".DS_Store", "__pycache__", ".venv", "venv"]);
-function rootsFile() {
-  return join30(configDir(), "sources.json");
+function rootsFile(configPath) {
+  return join30(dirname15(configPath), "sources.json");
+}
+function migrateGlobalRootsIfNeeded(configPath) {
+  const wsFile = rootsFile(configPath);
+  if (existsSync26(wsFile)) return;
+  const globalFile = join30(configDir(), "sources.json");
+  if (globalFile === wsFile || !existsSync26(globalFile)) return;
+  let roots;
+  try {
+    const parsed = JSON.parse(readFileSync24(globalFile, "utf8"));
+    if (!Array.isArray(parsed.roots) || parsed.roots.length === 0) return;
+    roots = parsed.roots;
+  } catch {
+    return;
+  }
+  try {
+    mkdirSync11(dirname15(wsFile), { recursive: true });
+    writeFileSync9(wsFile, JSON.stringify({ roots }, null, 2), "utf8");
+  } catch {
+    return;
+  }
+  try {
+    rmSync(globalFile, { force: true });
+  } catch {
+    try {
+      writeFileSync9(globalFile, JSON.stringify({ roots: [] }, null, 2), "utf8");
+    } catch {
+    }
+  }
 }
-function readRoots() {
+function readRoots(configPath) {
+  migrateGlobalRootsIfNeeded(configPath);
   try {
-    const raw = readFileSync24(rootsFile(), "utf8");
+    const raw = readFileSync24(rootsFile(configPath), "utf8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed.roots) ? parsed.roots : [];
   } catch {
     return [];
   }
 }
-function writeRoots(roots) {
-  writeFileSync9(rootsFile(), JSON.stringify({ roots }, null, 2), "utf8");
+function writeRoots(configPath, roots) {
+  writeFileSync9(rootsFile(configPath), JSON.stringify({ roots }, null, 2), "utf8");
 }
 function safeResolveInside2(target, roots) {
   const abs = resolve12(target);
@@ -80094,14 +80207,14 @@ async function ingestFolder(abs, ingestFile) {
   return { ingested, skipped };
 }
 async function dispatchSourcesRoute(req, res, deps) {
-  const { pathname, method, ingestFile } = deps;
+  const { pathname, method, ingestFile, configPath } = deps;
   if (!pathname.startsWith("/api/sources/")) return false;
   if (!localFileOpenEnabled()) {
     sendJson(res, { enabled: false });
     return true;
   }
   if (pathname === "/api/sources/roots" && method === "GET") {
-    sendJson(res, { enabled: true, roots: readRoots() });
+    sendJson(res, { enabled: true, roots: readRoots(configPath) });
     return true;
   }
   if (pathname === "/api/sources/roots" && method === "POST") {
@@ -80127,12 +80240,12 @@ async function dispatchSourcesRoute(req, res, deps) {
       sendJson(res, { error: `path not found: ${abs}` }, 400);
       return true;
     }
-    const roots = readRoots();
+    const roots = readRoots(configPath);
     let root6 = roots.find((r6) => resolve12(r6.path) === abs);
     if (!root6) {
       root6 = { id: randomUUID4(), path: abs, kind, name: basename13(abs) || abs };
       roots.push(root6);
-      writeRoots(roots);
+      writeRoots(configPath, roots);
     }
     let result;
     if (kind === "folder") result = await ingestFolder(abs, ingestFile);
@@ -80143,8 +80256,8 @@ async function dispatchSourcesRoute(req, res, deps) {
   const delMatch = /^\/api\/sources\/roots\/([^/]+)$/.exec(pathname);
   if (delMatch && method === "DELETE") {
     const id = decodeURIComponent(delMatch[1] ?? "");
-    const roots = readRoots().filter((r6) => r6.id !== id);
-    writeRoots(roots);
+    const roots = readRoots(configPath).filter((r6) => r6.id !== id);
+    writeRoots(configPath, roots);
     sendJson(res, { ok: true });
     return true;
   }
@@ -80162,7 +80275,7 @@ async function dispatchSourcesRoute(req, res, deps) {
       sendJson(res, { error: "path is required" }, 400);
       return true;
     }
-    const abs = safeResolveInside2(target, readRoots());
+    const abs = safeResolveInside2(target, readRoots(configPath));
     if (!abs) {
       sendJson(res, { error: "path is outside any registered source root" }, 403);
       return true;
@@ -80177,7 +80290,7 @@ async function dispatchSourcesRoute(req, res, deps) {
   if (pathname === "/api/sources/ingest-folder" && method === "POST") {
     const body = await readJson(req).catch(() => ({}));
     const target = typeof body.path === "string" ? body.path : "";
-    const abs = safeResolveInside2(target, readRoots());
+    const abs = safeResolveInside2(target, readRoots(configPath));
     if (!abs) {
       sendJson(res, { error: "path is outside any registered source root" }, 403);
       return true;
@@ -80191,7 +80304,7 @@ async function dispatchSourcesRoute(req, res, deps) {
 // src/gui/import-routes.ts
 init_adapter();
 init_http2();
-import { existsSync as existsSync26, readFileSync as readFileSync25, statSync as statSync11 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync25, statSync as statSync11 } from "fs";
 import { isAbsolute as isAbsolute4, join as join31 } from "path";
 init_native_entities();
 function badRequest(message) {
@@ -80225,7 +80338,7 @@ async function readImportSourceFromFile(db, fileId, latticeRoot) {
   );
   if (!row) throw badRequest("Unknown import file: " + fileId);
   const path3 = localPathOf2(row, latticeRoot);
-  if (!path3 || !existsSync26(path3)) {
+  if (!path3 || !existsSync27(path3)) {
     throw badRequest("The import file\u2019s bytes are not available locally.");
   }
   const sizeBytes = statSync11(path3).size;
@@ -80520,7 +80633,7 @@ init_dispatch();
 init_column_descriptions();
 init_mutations();
 init_native_entities();
-import { createReadStream as createReadStream3, existsSync as existsSync27, realpathSync as realpathSync2, statSync as statSync12 } from "fs";
+import { createReadStream as createReadStream3, existsSync as existsSync28, realpathSync as realpathSync2, statSync as statSync12 } from "fs";
 import { extname as extname3, join as join32, normalize as normalize2, sep as sep9 } from "path";
 
 // src/gui/count-many.ts
@@ -80728,7 +80841,7 @@ async function handleReadRoutes(req, res, ctx, deps) {
     const base = deps.guiAssetsDir.replace(/[/\\]+$/, "");
     const target = normalize2(join32(base, rel));
     const within = target === base || target.startsWith(base + sep9);
-    if (!within || !existsSync27(target) || !statSync12(target).isFile()) {
+    if (!within || !existsSync28(target) || !statSync12(target).isFile()) {
       sendJson(res, { error: "asset not found" }, 404);
       return true;
     }
@@ -81936,16 +82049,16 @@ async function handleHistoryRoutes(req, res, ctx, deps) {
 // src/gui/workspaces-routes.ts
 init_http2();
 import { resolve as resolve13 } from "path";
-import { existsSync as existsSync28, rmSync } from "fs";
+import { existsSync as existsSync29, rmSync as rmSync2 } from "fs";
 init_workspace();
 init_lattice_root();
 init_user_config();
 function cleanupWorkspaceFiles(root6, ws) {
   if (!ws.configPath && ws.kind === "local") {
-    rmSync(workspaceDir(root6, ws.dir), { recursive: true, force: true });
+    rmSync2(workspaceDir(root6, ws.dir), { recursive: true, force: true });
   } else if (ws.kind === "cloud") {
-    if (ws.configPath && existsSync28(ws.configPath)) {
-      rmSync(ws.configPath, { force: true });
+    if (ws.configPath && existsSync29(ws.configPath)) {
+      rmSync2(ws.configPath, { force: true });
     }
     const labelMatch = /^\$\{LATTICE_DB:([A-Za-z0-9._-]+)\}$/.exec(ws.db.trim());
     const label = labelMatch?.[1];
@@ -82148,15 +82261,15 @@ async function handleWorkspacesRoutes(req, res, ctx, deps) {
 // src/gui/databases-routes.ts
 init_http2();
 import { basename as basename15, resolve as resolve15 } from "path";
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 init_parser();
 
 // src/gui/config-paths.ts
 init_parser();
-import { basename as basename14, dirname as dirname15, join as join33, resolve as resolve14 } from "path";
+import { basename as basename14, dirname as dirname16, join as join33, resolve as resolve14 } from "path";
 import {
-  existsSync as existsSync29,
-  mkdirSync as mkdirSync11,
+  existsSync as existsSync30,
+  mkdirSync as mkdirSync12,
   readFileSync as readFileSync26,
   readdirSync as readdirSync9,
   unlinkSync as unlinkSync5,
@@ -82164,10 +82277,10 @@ import {
 } from "fs";
 import { parseDocument as parseDocument7 } from "yaml";
 function resolveOutputDirForConfig(configPath) {
-  const base = dirname15(resolve14(configPath));
+  const base = dirname16(resolve14(configPath));
   for (const dir of ["context", ".", "generated"]) {
     const abs = resolve14(base, dir);
-    if (existsSync29(join33(abs, ".lattice", "manifest.json"))) return abs;
+    if (existsSync30(join33(abs, ".lattice", "manifest.json"))) return abs;
   }
   return resolve14(base, "context");
 }
@@ -82176,7 +82289,7 @@ function friendlyConfigName(parsedName, configPath) {
   return basename14(configPath).replace(/\.(ya?ml)$/, "");
 }
 function listConfigs(activeConfigPath) {
-  const dir = dirname15(activeConfigPath);
+  const dir = dirname16(activeConfigPath);
   const entries = [];
   for (const fname of readdirSync9(dir)) {
     if (!fname.endsWith(".yml") && !fname.endsWith(".yaml")) continue;
@@ -82205,17 +82318,17 @@ function listConfigs(activeConfigPath) {
   return entries.sort((a6, b6) => a6.label.localeCompare(b6.label));
 }
 function createBlankConfig(activeConfigPath, dbName) {
-  const dir = dirname15(activeConfigPath);
+  const dir = dirname16(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 = join33(dir, `${slug}.config.yml`);
-  if (existsSync29(configPath)) throw new Error(`Config already exists: ${slug}.config.yml`);
+  if (existsSync30(configPath)) throw new Error(`Config already exists: ${slug}.config.yml`);
   const yaml = `db: ./data/${slug}.db
 
 entities: {}
 `;
   writeFileSync10(configPath, yaml, "utf8");
-  mkdirSync11(join33(dir, "data"), { recursive: true });
+  mkdirSync12(join33(dir, "data"), { recursive: true });
   return configPath;
 }
 function sqliteFileForConfig(configPath) {
@@ -82224,18 +82337,18 @@ 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 resolve14(dirname15(configPath), raw);
+  return resolve14(dirname16(configPath), raw);
 }
 function deleteDatabaseFiles(targetConfigPath) {
   const sqliteFile = sqliteFileForConfig(targetConfigPath);
   unlinkSync5(targetConfigPath);
   let deletedDbFile = null;
-  if (sqliteFile && existsSync29(sqliteFile)) {
+  if (sqliteFile && existsSync30(sqliteFile)) {
     unlinkSync5(sqliteFile);
     deletedDbFile = sqliteFile;
     for (const suffix of ["-wal", "-shm", "-journal"]) {
       const sidecar = sqliteFile + suffix;
-      if (existsSync29(sidecar)) unlinkSync5(sidecar);
+      if (existsSync30(sidecar)) unlinkSync5(sidecar);
     }
   }
   return { deletedConfig: basename14(targetConfigPath), deletedDbFile };
@@ -82269,7 +82382,7 @@ async function handleDatabasesRoutes(req, res, ctx, deps) {
       return true;
     }
     const newPath = resolve15(body.path);
-    if (!existsSync30(newPath)) {
+    if (!existsSync31(newPath)) {
       sendJson(res, { error: `Config not found: ${newPath}` }, 400);
       return true;
     }
@@ -82375,8 +82488,8 @@ async function handleDatabasesRoutes(req, res, ctx, deps) {
 // src/gui/server.ts
 init_user_config();
 function resolveDefaultGuiAssetsDir() {
-  const bundleSibling = process.argv[1] ? resolve16(dirname16(process.argv[1]), "gui-assets") : null;
-  if (bundleSibling && existsSync31(bundleSibling)) return bundleSibling;
+  const bundleSibling = process.argv[1] ? resolve16(dirname17(process.argv[1]), "gui-assets") : null;
+  if (bundleSibling && existsSync32(bundleSibling)) return bundleSibling;
   return resolve16(process.cwd(), "dist", "gui-assets");
 }
 function sendText(res, body, status = 200, contentType = "text/plain; charset=utf-8") {
@@ -82433,7 +82546,7 @@ 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(dirname16(bootConfigPath)) : null) ?? (options.latticeRoot ? resolve16(options.latticeRoot) : null);
+  const latticeRoot = (bootConfigPath ? findLatticeRoot(dirname17(bootConfigPath)) : null) ?? (options.latticeRoot ? resolve16(options.latticeRoot) : null);
   let currentWorkspaceId = null;
   if (latticeRoot && bootConfigPath) {
     const launched = listWorkspaces(latticeRoot).find(
@@ -82787,7 +82900,7 @@ async function startGuiServer(options) {
                 createJunction: (otherTable) => createFileJunction(active, otherTable, sessionId),
                 createEntity: (entity, columns) => createUserEntity(active, entity, columns, sessionId),
                 aggressiveness: getAggressiveness(),
-                latticeRoot: dirname16(active.configPath),
+                latticeRoot: dirname17(active.configPath),
                 configPath: active.configPath,
                 outputDir: active.outputDir,
                 sessionId,
@@ -82812,7 +82925,7 @@ async function startGuiServer(options) {
                 createJunction: (otherTable) => createFileJunction(active, otherTable, sessionId),
                 createEntity: (entity, columns) => createUserEntity(active, entity, columns, sessionId),
                 aggressiveness: getAggressiveness(),
-                latticeRoot: dirname16(active.configPath),
+                latticeRoot: dirname17(active.configPath),
                 configPath: active.configPath,
                 outputDir: active.outputDir,
                 sessionId,
@@ -82823,6 +82936,7 @@ async function startGuiServer(options) {
               return await dispatchSourcesRoute(req2, res2, {
                 db: active.db,
                 ingestFile: (p3) => ingestLocalFile(ingestCtx, mctx, p3, false),
+                configPath: active.configPath,
                 pathname,
                 method
               });
@@ -82838,7 +82952,7 @@ async function startGuiServer(options) {
               return await dispatchImportRoute(req2, res2, {
                 db: active.db,
                 configPath: active.configPath,
-                latticeRoot: dirname16(active.configPath),
+                latticeRoot: dirname17(active.configPath),
                 validTables: active.validTables,
                 softDeletable: active.softDeletable
               });
@@ -82867,7 +82981,7 @@ async function startGuiServer(options) {
               if (!pathname.startsWith("/api/files/")) return false;
               return await dispatchFilesRoute(req2, res2, {
                 db: active.db,
-                latticeRoot: dirname16(active.configPath),
+                latticeRoot: dirname17(active.configPath),
                 configPath: active.configPath,
                 pathname,
                 method
@@ -83078,8 +83192,8 @@ ${e6.stack ?? ""}`
 }
 
 // src/cloud/file-source-key-store.ts
-import { readFileSync as readFileSync27, writeFileSync as writeFileSync11, existsSync as existsSync32, mkdirSync as mkdirSync12, renameSync as renameSync5, chmodSync as chmodSync3 } from "fs";
-import { dirname as dirname17, resolve as resolve17 } from "path";
+import { readFileSync as readFileSync27, writeFileSync as writeFileSync11, existsSync as existsSync33, mkdirSync as mkdirSync13, renameSync as renameSync5, chmodSync as chmodSync3 } from "fs";
+import { dirname as dirname18, resolve as resolve17 } from "path";
 import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes9, scryptSync as scryptSync3 } from "crypto";
 var ENC_HEADER = "LATTICE-KMS-v1\n";
 var SCRYPT_N = 1 << 15;
@@ -83130,9 +83244,9 @@ var FileSourceKeyStore = class {
   // ── internals ────────────────────────────────────────────────────────
   load() {
     const out = /* @__PURE__ */ new Map();
-    if (!existsSync32(this.path)) {
-      const dir = dirname17(this.path);
-      if (!existsSync32(dir)) mkdirSync12(dir, { recursive: true, mode: 448 });
+    if (!existsSync33(this.path)) {
+      const dir = dirname18(this.path);
+      if (!existsSync33(dir)) mkdirSync13(dir, { recursive: true, mode: 448 });
       return out;
     }
     const raw = readFileSync27(this.path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "latticesql",
-  "version": "4.3.1",
+  "version": "4.3.3",
   "description": "Persistent structured memory for AI agent systems — pluggable SQLite or Postgres backend, LLM context bridge",
   "type": "module",
   "main": "./dist/index.js",