latticesql 4.2.2 → 4.2.3

package/dist/cli.js

@@ -1015,7 +1015,7 @@ var init_manifest = __esm({
   "src/lifecycle/manifest.ts"() {
     "use strict";
     init_writer();
-    TEMPLATE_VERSION = 2;
+    TEMPLATE_VERSION = 3;
   }
 });
 
@@ -4208,6 +4208,64 @@ function cleanupEntityContexts(outputDir, entityContexts, currentSlugsByTable, m
     warnings: []
   };
   if (manifest === null) return result;
+  if (options.removeOrphanedDirectories !== false) {
+    for (const [table, entry] of Object.entries(manifest.entityContexts)) {
+      if (entityContexts.has(table)) continue;
+      const directoryRoot = entry.directoryRoot;
+      const rootPath = join6(outputDir, directoryRoot);
+      if (!existsSync6(rootPath)) continue;
+      const globalProtected = new Set(options.protectedFiles ?? []);
+      for (const [slug, files] of Object.entries(entry.entities)) {
+        const entityDir = join6(rootPath, slug);
+        if (!existsSync6(entityDir)) continue;
+        for (const filename of entityFileNames(files)) {
+          if (globalProtected.has(filename)) continue;
+          const filePath = join6(entityDir, filename);
+          if (!existsSync6(filePath)) continue;
+          if (!options.dryRun) unlinkSync3(filePath);
+          options.onOrphan?.(filePath, "file");
+          result.filesRemoved.push(filePath);
+        }
+        let remaining;
+        try {
+          remaining = existsSync6(entityDir) ? readdirSync2(entityDir) : [];
+        } catch {
+          remaining = [];
+        }
+        if (remaining.length === 0) {
+          if (!options.dryRun) {
+            try {
+              rmdirSync(entityDir);
+            } catch {
+            }
+          }
+          options.onOrphan?.(entityDir, "directory");
+          result.directoriesRemoved.push(entityDir);
+        } else {
+          result.directoriesSkipped.push(entityDir);
+          result.warnings.push(
+            `${entityDir}: left in place (contains user files: ${remaining.join(", ")})`
+          );
+        }
+      }
+      let rootRemaining;
+      try {
+        rootRemaining = existsSync6(rootPath) ? readdirSync2(rootPath) : [];
+      } catch {
+        rootRemaining = [];
+      }
+      if (rootRemaining.length === 0) {
+        if (!options.dryRun) {
+          try {
+            rmdirSync(rootPath);
+          } catch {
+          }
+        }
+        options.onOrphan?.(rootPath, "directory");
+        result.directoriesRemoved.push(rootPath);
+      }
+    }
+  }
   for (const [table, def] of entityContexts) {
     const entry = manifest.entityContexts[table];
     if (!entry) continue;
@@ -4704,7 +4762,8 @@ var init_engine = __esm({
         const currentSlugsByTable = /* @__PURE__ */ new Map();
         for (const [table, def] of entityContexts) {
           const rows = await this._schema.queryTable(this._adapter, table, this._schema.readRel);
-          const slugs = new Set(rows.map((row) => def.slug(row)));
+          const entityPk = this._schema.getPrimaryKey(table)[0] ?? "id";
+          const slugs = new Set(_RenderEngine._disambiguateSlugs(rows, def.slug, entityPk));
           currentSlugsByTable.set(table, slugs);
         }
         return cleanupEntityContexts(
@@ -4753,6 +4812,71 @@ var init_engine = __esm({
       static _normKey(v2) {
         return String(v2);
       }
+      /**
+       * Sanitize and validate ONE base slug.
+       *
+       * Replaces non-ASCII whitespace (e.g. the macOS narrow no-break space U+202F
+       * that shows up in screenshot filenames) with a regular space, strips control
+       * characters, then rejects any slug that still contains a character outside the
+       * allowed set (the path-traversal guard). Throws on an invalid slug — never
+       * silently rewrites it.
+       */
+      static _sanitizeSlug(rawSlug) {
+        const slug = rawSlug.replace(/[\u00A0\u2000-\u200B\u202F\u205F\u3000]/g, " ").replace(/[\u0000-\u001F\u007F]/g, "");
+        if (/[^a-zA-Z0-9.\-_ @(),#&'+:;!~[\]]/.test(slug)) {
+          throw new Error(`Invalid slug "${slug}": contains characters outside the allowed set`);
+        }
+        return slug;
+      }
+      /**
+       * Disambiguate per-row slugs so two rows that produce the SAME base slug do not
+       * write to (and clobber) the same directory.
+       *
+       * Returns one final slug per row, in the SAME order as `rows`. A base slug used
+       * by exactly one row is returned unchanged (no churn for the common case). When
+       * a base slug is shared by >1 row, EVERY colliding row gets a short, stable
+       * suffix derived from its primary key (`<base>-<pk8>`), so the result is
+       * order-independent: the same row gets the same slug on every render regardless
+       * of row order. The suffix lengthens only if two rows' 8-char PK prefixes still
+       * collide (e.g. shared prefix), guaranteeing uniqueness without changing the
+       * common-case output. Slugs are sanitized + path-traversal-validated via
+       * {@link _sanitizeSlug}; `def.slug` itself is never modified.
+       */
+      static _disambiguateSlugs(rows, slugFn, pkCol) {
+        const baseSlugs = rows.map((row) => _RenderEngine._sanitizeSlug(slugFn(row)));
+        const byBase = /* @__PURE__ */ new Map();
+        for (let i6 = 0; i6 < baseSlugs.length; i6++) {
+          const base = baseSlugs[i6];
+          const bucket = byBase.get(base);
+          if (bucket) bucket.push(i6);
+          else byBase.set(base, [i6]);
+        }
+        const final = baseSlugs.map(() => "");
+        const pkOf = (i6) => {
+          const v2 = rows[i6]?.[pkCol];
+          let s2;
+          if (v2 == null) s2 = "";
+          else if (typeof v2 === "object") s2 = JSON.stringify(v2);
+          else s2 = String(v2);
+          return _RenderEngine._sanitizeSlug(s2).replace(/[ /\\]/g, "");
+        };
+        for (const [base, indices] of byBase) {
+          if (indices.length === 1) {
+            final[indices[0]] = base;
+            continue;
+          }
+          const pks = indices.map(pkOf);
+          const maxLen = Math.max(...pks.map((p3) => p3.length), 1);
+          let len = 8;
+          while (len < maxLen && new Set(pks.map((p3) => p3.slice(0, len))).size !== pks.length) {
+            len += 4;
+          }
+          for (let k6 = 0; k6 < indices.length; k6++) {
+            final[indices[k6]] = `${base}-${pks[k6].slice(0, len)}`;
+          }
+        }
+        return final;
+      }
       /**
        * Prefetch the batchable belongsTo sources for one entity-context table.
        * For each (target+filters+softDelete) group, issue exactly ONE
@@ -4833,6 +4957,7 @@ var init_engine = __esm({
             const baseRows = await this._schema.queryTable(this._adapter, table, this._schema.readRel);
             const allRows = this._foldRows ? await this._foldRows(table, baseRows) : baseRows;
             const directoryRoot = def.directoryRoot ?? table;
+            const finalSlugs = _RenderEngine._disambiguateSlugs(allRows, def.slug, entityPk);
             const belongsToBatches = await this._prefetchBelongsToBatches(
               def,
               allRows,
@@ -4874,11 +4999,7 @@ var init_engine = __esm({
               if (i6 > 0 && i6 % YIELD_EVERY_ENTITIES === 0) {
                 await new Promise((r6) => setImmediate(r6));
               }
-              const rawSlug = def.slug(entityRow);
-              const slug = rawSlug.replace(/[\u00A0\u2000-\u200B\u202F\u205F\u3000]/g, " ").replace(/[\u0000-\u001F\u007F]/g, "");
-              if (/[^a-zA-Z0-9.\-_ @(),#&'+:;!~[\]]/.test(slug)) {
-                throw new Error(`Invalid slug "${slug}": contains characters outside the allowed set`);
-              }
+              const slug = finalSlugs[i6];
               const entityDir = def.directory ? join7(outputDir, def.directory(entityRow)) : join7(outputDir, directoryRoot, slug);
               const resolvedDir = resolve3(entityDir);
               const resolvedBase = resolve3(outputDir);
@@ -76617,7 +76738,7 @@ function printHelp() {
   );
 }
 function getVersion() {
-  if (true) return "4.2.2";
+  if (true) return "4.2.3";
   try {
     const pkgPath = new URL("../package.json", import.meta.url).pathname;
     const pkg = JSON.parse(readFileSync25(pkgPath, "utf-8"));

package/dist/index.cjs

@@ -249,7 +249,7 @@ var init_manifest = __esm({
     import_node_path2 = require("path");
     import_node_fs2 = require("fs");
     init_writer();
-    TEMPLATE_VERSION = 2;
+    TEMPLATE_VERSION = 3;
   }
 });
 
@@ -3446,6 +3446,64 @@ function cleanupEntityContexts(outputDir, entityContexts, currentSlugsByTable, m
     warnings: []
   };
   if (manifest === null) return result;
+  if (options.removeOrphanedDirectories !== false) {
+    for (const [table, entry] of Object.entries(manifest.entityContexts)) {
+      if (entityContexts.has(table)) continue;
+      const directoryRoot = entry.directoryRoot;
+      const rootPath = (0, import_node_path5.join)(outputDir, directoryRoot);
+      if (!(0, import_node_fs3.existsSync)(rootPath)) continue;
+      const globalProtected = new Set(options.protectedFiles ?? []);
+      for (const [slug, files] of Object.entries(entry.entities)) {
+        const entityDir = (0, import_node_path5.join)(rootPath, slug);
+        if (!(0, import_node_fs3.existsSync)(entityDir)) continue;
+        for (const filename of entityFileNames(files)) {
+          if (globalProtected.has(filename)) continue;
+          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");
+          result.filesRemoved.push(filePath);
+        }
+        let remaining;
+        try {
+          remaining = (0, import_node_fs3.existsSync)(entityDir) ? (0, import_node_fs3.readdirSync)(entityDir) : [];
+        } catch {
+          remaining = [];
+        }
+        if (remaining.length === 0) {
+          if (!options.dryRun) {
+            try {
+              (0, import_node_fs3.rmdirSync)(entityDir);
+            } catch {
+            }
+          }
+          options.onOrphan?.(entityDir, "directory");
+          result.directoriesRemoved.push(entityDir);
+        } else {
+          result.directoriesSkipped.push(entityDir);
+          result.warnings.push(
+            `${entityDir}: left in place (contains user files: ${remaining.join(", ")})`
+          );
+        }
+      }
+      let rootRemaining;
+      try {
+        rootRemaining = (0, import_node_fs3.existsSync)(rootPath) ? (0, import_node_fs3.readdirSync)(rootPath) : [];
+      } catch {
+        rootRemaining = [];
+      }
+      if (rootRemaining.length === 0) {
+        if (!options.dryRun) {
+          try {
+            (0, import_node_fs3.rmdirSync)(rootPath);
+          } catch {
+          }
+        }
+        options.onOrphan?.(rootPath, "directory");
+        result.directoriesRemoved.push(rootPath);
+      }
+    }
+  }
   for (const [table, def] of entityContexts) {
     const entry = manifest.entityContexts[table];
     if (!entry) continue;
@@ -3945,7 +4003,8 @@ var init_engine = __esm({
         const currentSlugsByTable = /* @__PURE__ */ new Map();
         for (const [table, def] of entityContexts) {
           const rows = await this._schema.queryTable(this._adapter, table, this._schema.readRel);
-          const slugs = new Set(rows.map((row) => def.slug(row)));
+          const entityPk = this._schema.getPrimaryKey(table)[0] ?? "id";
+          const slugs = new Set(_RenderEngine._disambiguateSlugs(rows, def.slug, entityPk));
           currentSlugsByTable.set(table, slugs);
         }
         return cleanupEntityContexts(
@@ -3994,6 +4053,71 @@ var init_engine = __esm({
       static _normKey(v2) {
         return String(v2);
       }
+      /**
+       * Sanitize and validate ONE base slug.
+       *
+       * Replaces non-ASCII whitespace (e.g. the macOS narrow no-break space U+202F
+       * that shows up in screenshot filenames) with a regular space, strips control
+       * characters, then rejects any slug that still contains a character outside the
+       * allowed set (the path-traversal guard). Throws on an invalid slug — never
+       * silently rewrites it.
+       */
+      static _sanitizeSlug(rawSlug) {
+        const slug = rawSlug.replace(/[\u00A0\u2000-\u200B\u202F\u205F\u3000]/g, " ").replace(/[\u0000-\u001F\u007F]/g, "");
+        if (/[^a-zA-Z0-9.\-_ @(),#&'+:;!~[\]]/.test(slug)) {
+          throw new Error(`Invalid slug "${slug}": contains characters outside the allowed set`);
+        }
+        return slug;
+      }
+      /**
+       * Disambiguate per-row slugs so two rows that produce the SAME base slug do not
+       * write to (and clobber) the same directory.
+       *
+       * Returns one final slug per row, in the SAME order as `rows`. A base slug used
+       * by exactly one row is returned unchanged (no churn for the common case). When
+       * a base slug is shared by >1 row, EVERY colliding row gets a short, stable
+       * suffix derived from its primary key (`<base>-<pk8>`), so the result is
+       * order-independent: the same row gets the same slug on every render regardless
+       * of row order. The suffix lengthens only if two rows' 8-char PK prefixes still
+       * collide (e.g. shared prefix), guaranteeing uniqueness without changing the
+       * common-case output. Slugs are sanitized + path-traversal-validated via
+       * {@link _sanitizeSlug}; `def.slug` itself is never modified.
+       */
+      static _disambiguateSlugs(rows, slugFn, pkCol) {
+        const baseSlugs = rows.map((row) => _RenderEngine._sanitizeSlug(slugFn(row)));
+        const byBase = /* @__PURE__ */ new Map();
+        for (let i6 = 0; i6 < baseSlugs.length; i6++) {
+          const base = baseSlugs[i6];
+          const bucket = byBase.get(base);
+          if (bucket) bucket.push(i6);
+          else byBase.set(base, [i6]);
+        }
+        const final = baseSlugs.map(() => "");
+        const pkOf = (i6) => {
+          const v2 = rows[i6]?.[pkCol];
+          let s2;
+          if (v2 == null) s2 = "";
+          else if (typeof v2 === "object") s2 = JSON.stringify(v2);
+          else s2 = String(v2);
+          return _RenderEngine._sanitizeSlug(s2).replace(/[ /\\]/g, "");
+        };
+        for (const [base, indices] of byBase) {
+          if (indices.length === 1) {
+            final[indices[0]] = base;
+            continue;
+          }
+          const pks = indices.map(pkOf);
+          const maxLen = Math.max(...pks.map((p3) => p3.length), 1);
+          let len = 8;
+          while (len < maxLen && new Set(pks.map((p3) => p3.slice(0, len))).size !== pks.length) {
+            len += 4;
+          }
+          for (let k6 = 0; k6 < indices.length; k6++) {
+            final[indices[k6]] = `${base}-${pks[k6].slice(0, len)}`;
+          }
+        }
+        return final;
+      }
       /**
        * Prefetch the batchable belongsTo sources for one entity-context table.
        * For each (target+filters+softDelete) group, issue exactly ONE
@@ -4074,6 +4198,7 @@ var init_engine = __esm({
             const baseRows = await this._schema.queryTable(this._adapter, table, this._schema.readRel);
             const allRows = this._foldRows ? await this._foldRows(table, baseRows) : baseRows;
             const directoryRoot = def.directoryRoot ?? table;
+            const finalSlugs = _RenderEngine._disambiguateSlugs(allRows, def.slug, entityPk);
             const belongsToBatches = await this._prefetchBelongsToBatches(
               def,
               allRows,
@@ -4115,11 +4240,7 @@ var init_engine = __esm({
               if (i6 > 0 && i6 % YIELD_EVERY_ENTITIES === 0) {
                 await new Promise((r6) => setImmediate(r6));
               }
-              const rawSlug = def.slug(entityRow);
-              const slug = rawSlug.replace(/[\u00A0\u2000-\u200B\u202F\u205F\u3000]/g, " ").replace(/[\u0000-\u001F\u007F]/g, "");
-              if (/[^a-zA-Z0-9.\-_ @(),#&'+:;!~[\]]/.test(slug)) {
-                throw new Error(`Invalid slug "${slug}": contains characters outside the allowed set`);
-              }
+              const slug = finalSlugs[i6];
               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);

package/dist/index.js

@@ -240,7 +240,7 @@ var init_manifest = __esm({
   "src/lifecycle/manifest.ts"() {
     "use strict";
     init_writer();
-    TEMPLATE_VERSION = 2;
+    TEMPLATE_VERSION = 3;
   }
 });
 
@@ -3437,6 +3437,64 @@ function cleanupEntityContexts(outputDir, entityContexts, currentSlugsByTable, m
     warnings: []
   };
   if (manifest === null) return result;
+  if (options.removeOrphanedDirectories !== false) {
+    for (const [table, entry] of Object.entries(manifest.entityContexts)) {
+      if (entityContexts.has(table)) continue;
+      const directoryRoot = entry.directoryRoot;
+      const rootPath = join3(outputDir, directoryRoot);
+      if (!existsSync3(rootPath)) continue;
+      const globalProtected = new Set(options.protectedFiles ?? []);
+      for (const [slug, files] of Object.entries(entry.entities)) {
+        const entityDir = join3(rootPath, slug);
+        if (!existsSync3(entityDir)) continue;
+        for (const filename of entityFileNames(files)) {
+          if (globalProtected.has(filename)) continue;
+          const filePath = join3(entityDir, filename);
+          if (!existsSync3(filePath)) continue;
+          if (!options.dryRun) unlinkSync2(filePath);
+          options.onOrphan?.(filePath, "file");
+          result.filesRemoved.push(filePath);
+        }
+        let remaining;
+        try {
+          remaining = existsSync3(entityDir) ? readdirSync(entityDir) : [];
+        } catch {
+          remaining = [];
+        }
+        if (remaining.length === 0) {
+          if (!options.dryRun) {
+            try {
+              rmdirSync(entityDir);
+            } catch {
+            }
+          }
+          options.onOrphan?.(entityDir, "directory");
+          result.directoriesRemoved.push(entityDir);
+        } else {
+          result.directoriesSkipped.push(entityDir);
+          result.warnings.push(
+            `${entityDir}: left in place (contains user files: ${remaining.join(", ")})`
+          );
+        }
+      }
+      let rootRemaining;
+      try {
+        rootRemaining = existsSync3(rootPath) ? readdirSync(rootPath) : [];
+      } catch {
+        rootRemaining = [];
+      }
+      if (rootRemaining.length === 0) {
+        if (!options.dryRun) {
+          try {
+            rmdirSync(rootPath);
+          } catch {
+          }
+        }
+        options.onOrphan?.(rootPath, "directory");
+        result.directoriesRemoved.push(rootPath);
+      }
+    }
+  }
   for (const [table, def] of entityContexts) {
     const entry = manifest.entityContexts[table];
     if (!entry) continue;
@@ -3933,7 +3991,8 @@ var init_engine = __esm({
         const currentSlugsByTable = /* @__PURE__ */ new Map();
         for (const [table, def] of entityContexts) {
           const rows = await this._schema.queryTable(this._adapter, table, this._schema.readRel);
-          const slugs = new Set(rows.map((row) => def.slug(row)));
+          const entityPk = this._schema.getPrimaryKey(table)[0] ?? "id";
+          const slugs = new Set(_RenderEngine._disambiguateSlugs(rows, def.slug, entityPk));
           currentSlugsByTable.set(table, slugs);
         }
         return cleanupEntityContexts(
@@ -3982,6 +4041,71 @@ var init_engine = __esm({
       static _normKey(v2) {
         return String(v2);
       }
+      /**
+       * Sanitize and validate ONE base slug.
+       *
+       * Replaces non-ASCII whitespace (e.g. the macOS narrow no-break space U+202F
+       * that shows up in screenshot filenames) with a regular space, strips control
+       * characters, then rejects any slug that still contains a character outside the
+       * allowed set (the path-traversal guard). Throws on an invalid slug — never
+       * silently rewrites it.
+       */
+      static _sanitizeSlug(rawSlug) {
+        const slug = rawSlug.replace(/[\u00A0\u2000-\u200B\u202F\u205F\u3000]/g, " ").replace(/[\u0000-\u001F\u007F]/g, "");
+        if (/[^a-zA-Z0-9.\-_ @(),#&'+:;!~[\]]/.test(slug)) {
+          throw new Error(`Invalid slug "${slug}": contains characters outside the allowed set`);
+        }
+        return slug;
+      }
+      /**
+       * Disambiguate per-row slugs so two rows that produce the SAME base slug do not
+       * write to (and clobber) the same directory.
+       *
+       * Returns one final slug per row, in the SAME order as `rows`. A base slug used
+       * by exactly one row is returned unchanged (no churn for the common case). When
+       * a base slug is shared by >1 row, EVERY colliding row gets a short, stable
+       * suffix derived from its primary key (`<base>-<pk8>`), so the result is
+       * order-independent: the same row gets the same slug on every render regardless
+       * of row order. The suffix lengthens only if two rows' 8-char PK prefixes still
+       * collide (e.g. shared prefix), guaranteeing uniqueness without changing the
+       * common-case output. Slugs are sanitized + path-traversal-validated via
+       * {@link _sanitizeSlug}; `def.slug` itself is never modified.
+       */
+      static _disambiguateSlugs(rows, slugFn, pkCol) {
+        const baseSlugs = rows.map((row) => _RenderEngine._sanitizeSlug(slugFn(row)));
+        const byBase = /* @__PURE__ */ new Map();
+        for (let i6 = 0; i6 < baseSlugs.length; i6++) {
+          const base = baseSlugs[i6];
+          const bucket = byBase.get(base);
+          if (bucket) bucket.push(i6);
+          else byBase.set(base, [i6]);
+        }
+        const final = baseSlugs.map(() => "");
+        const pkOf = (i6) => {
+          const v2 = rows[i6]?.[pkCol];
+          let s2;
+          if (v2 == null) s2 = "";
+          else if (typeof v2 === "object") s2 = JSON.stringify(v2);
+          else s2 = String(v2);
+          return _RenderEngine._sanitizeSlug(s2).replace(/[ /\\]/g, "");
+        };
+        for (const [base, indices] of byBase) {
+          if (indices.length === 1) {
+            final[indices[0]] = base;
+            continue;
+          }
+          const pks = indices.map(pkOf);
+          const maxLen = Math.max(...pks.map((p3) => p3.length), 1);
+          let len = 8;
+          while (len < maxLen && new Set(pks.map((p3) => p3.slice(0, len))).size !== pks.length) {
+            len += 4;
+          }
+          for (let k6 = 0; k6 < indices.length; k6++) {
+            final[indices[k6]] = `${base}-${pks[k6].slice(0, len)}`;
+          }
+        }
+        return final;
+      }
       /**
        * Prefetch the batchable belongsTo sources for one entity-context table.
        * For each (target+filters+softDelete) group, issue exactly ONE
@@ -4062,6 +4186,7 @@ var init_engine = __esm({
             const baseRows = await this._schema.queryTable(this._adapter, table, this._schema.readRel);
             const allRows = this._foldRows ? await this._foldRows(table, baseRows) : baseRows;
             const directoryRoot = def.directoryRoot ?? table;
+            const finalSlugs = _RenderEngine._disambiguateSlugs(allRows, def.slug, entityPk);
             const belongsToBatches = await this._prefetchBelongsToBatches(
               def,
               allRows,
@@ -4103,11 +4228,7 @@ var init_engine = __esm({
               if (i6 > 0 && i6 % YIELD_EVERY_ENTITIES === 0) {
                 await new Promise((r6) => setImmediate(r6));
               }
-              const rawSlug = def.slug(entityRow);
-              const slug = rawSlug.replace(/[\u00A0\u2000-\u200B\u202F\u205F\u3000]/g, " ").replace(/[\u0000-\u001F\u007F]/g, "");
-              if (/[^a-zA-Z0-9.\-_ @(),#&'+:;!~[\]]/.test(slug)) {
-                throw new Error(`Invalid slug "${slug}": contains characters outside the allowed set`);
-              }
+              const slug = finalSlugs[i6];
               const entityDir = def.directory ? join4(outputDir, def.directory(entityRow)) : join4(outputDir, directoryRoot, slug);
               const resolvedDir = resolve(entityDir);
               const resolvedBase = resolve(outputDir);

package/package.json

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