@nshiab/simple-data-analysis-core 2.1.1 → 2.1.3

package/esm/helpers/normalizeCacheCode.js

@@ -0,0 +1,331 @@
+const lineTerminator = /[\r\n\u2028\u2029]/u;
+const word = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*/u;
+const number = /^(?:0[xX][\da-fA-F_]+n?|0[bB][01_]+n?|0[oO][0-7_]+n?|(?:\d[\d_]*(?:\.[\d_]*)?|\.[\d_]+)(?:[eE][+-]?[\d_]+)?n?)/;
+const punctuation = /^(?:>>>=|===|!==|\*\*=|&&=|\|\|=|\?\?=|>>>|<<=|>>=|=>|==|!=|<=|>=|\+\+|--|&&|\|\||\?\?|\?\.(?!\d)|\*\*|<<|>>|\+=|-=|\*=|%=|&=|\|=|\^=|\.\.\.|[{}()[\].,;:?~!+*%<>=&|^\-#])/;
+const expressionPrefixes = new Set([
+    "(",
+    "[",
+    "{",
+    ",",
+    ";",
+    ":",
+    "?",
+    "=",
+    "=>",
+    "!",
+    "~",
+    "+",
+    "-",
+    "*",
+    "**",
+    "%",
+    "&",
+    "|",
+    "^",
+    "&&",
+    "||",
+    "??",
+    "==",
+    "===",
+    "!=",
+    "!==",
+    "<",
+    ">",
+    "<=",
+    ">=",
+    "<<",
+    ">>",
+    ">>>",
+    "+=",
+    "-=",
+    "*=",
+    "**=",
+    "%=",
+    "&=",
+    "|=",
+    "^=",
+    "&&=",
+    "||=",
+    "??=",
+    "<<=",
+    ">>=",
+    ">>>=",
+    "/",
+    "/=",
+]);
+const expressionKeywords = new Set([
+    "return",
+    "throw",
+    "case",
+    "delete",
+    "void",
+    "typeof",
+    "new",
+    "in",
+    "instanceof",
+    "yield",
+    "await",
+    "else",
+    "do",
+]);
+const restrictedLineBreaks = new Set([
+    "return",
+    "throw",
+    "break",
+    "continue",
+    "yield",
+    "async",
+    "++",
+    "--",
+]);
+/**
+ * Normalizes comments, whitespace, and known optional punctuation without
+ * dependencies or executing user code. Literal contents and token boundaries
+ * stay intact. Potentially significant line breaks are retained; ambiguous
+ * slash syntax falls back to exact source instead of risking a stale cache hit.
+ */
+export default function normalizeCacheCode(source) {
+    let position = 0;
+    let uncertain = false;
+    function quoted(quote) {
+        const start = position++;
+        while (position < source.length) {
+            const character = source[position++];
+            if (character === "\\") {
+                position++;
+            }
+            else if (character === quote) {
+                return source.slice(start, position);
+            }
+            else if (lineTerminator.test(character)) {
+                return undefined;
+            }
+        }
+    }
+    function template() {
+        const parts = [];
+        let start = ++position;
+        while (position < source.length) {
+            if (source[position] === "\\") {
+                position += 2;
+            }
+            else if (source[position] === "`") {
+                parts.push(source.slice(start, position++));
+                return JSON.stringify(parts);
+            }
+            else if (source.startsWith("${", position)) {
+                parts.push(source.slice(start, position));
+                position += 2;
+                const tokens = scan(true);
+                if (uncertain)
+                    return undefined;
+                parts.push(serialize(tokens));
+                start = position;
+            }
+            else {
+                position++;
+            }
+        }
+    }
+    function regex() {
+        const start = position++;
+        let inClass = false;
+        while (position < source.length) {
+            const character = source[position++];
+            if (lineTerminator.test(character))
+                return undefined;
+            if (character === "\\") {
+                position++;
+            }
+            else if (character === "[") {
+                // Nested character classes depend on the v flag. Leave these opaque.
+                if (inClass)
+                    return undefined;
+                inClass = true;
+            }
+            else if (character === "]") {
+                inClass = false;
+            }
+            else if (character === "/" && !inClass) {
+                const flags = source.slice(position).match(word)?.[0] ?? "";
+                position += flags.length;
+                return source.slice(start, position);
+            }
+        }
+    }
+    function scan(interpolation = false) {
+        const tokens = [];
+        let braces = 0;
+        let lineBreak = false;
+        while (position < source.length) {
+            const rest = source.slice(position);
+            const character = source[position];
+            if (/\s/u.test(character)) {
+                lineBreak ||= lineTerminator.test(character);
+                position++;
+                continue;
+            }
+            if (rest.startsWith("//")) {
+                while (position < source.length && !lineTerminator.test(source[position])) {
+                    position++;
+                }
+                continue;
+            }
+            if (rest.startsWith("/*")) {
+                const end = source.indexOf("*/", position + 2);
+                if (end === -1)
+                    break;
+                lineBreak ||= lineTerminator.test(source.slice(position, end + 2));
+                position = end + 2;
+                continue;
+            }
+            if (interpolation && character === "}" && braces === 0) {
+                position++;
+                return tokens;
+            }
+            // Legacy HTML comments and native function text are not ordinary tokens.
+            if (rest.startsWith("<!--") || rest.startsWith("-->") ||
+                rest.startsWith("[native code]"))
+                break;
+            const previous = tokens.at(-1);
+            let kind = "punctuation";
+            let text;
+            if (character === "'" || character === '"') {
+                kind = "literal";
+                text = quoted(character);
+            }
+            else if (character === "`") {
+                kind = "template";
+                text = template();
+            }
+            else if (character === "/") {
+                const property = [".", "?."].includes(tokens.at(-2)?.text ?? "");
+                if (!previous ||
+                    (previous.kind === "punctuation" &&
+                        expressionPrefixes.has(previous.text)) ||
+                    (previous.kind === "word" && !property &&
+                        expressionKeywords.has(previous.text))) {
+                    kind = "literal";
+                    text = regex();
+                }
+                else if (previous.kind === "literal" || previous.kind === "template") {
+                    text = rest.startsWith("/=") ? "/=" : "/";
+                    position += text.length;
+                }
+                else {
+                    // After a closing block/parenthesis or contextual keyword, deciding
+                    // between division and a regex can require a full JavaScript parser.
+                    break;
+                }
+            }
+            else {
+                text = rest.match(word)?.[0];
+                if (text !== undefined) {
+                    kind = "word";
+                }
+                else {
+                    text = rest.match(number)?.[0];
+                    if (text !== undefined)
+                        kind = "literal";
+                    else
+                        text = rest.match(punctuation)?.[0];
+                }
+                if (text !== undefined)
+                    position += text.length;
+            }
+            if (text === undefined) {
+                uncertain = true;
+                break;
+            }
+            if (kind === "punctuation") {
+                if (text === "{")
+                    braces++;
+                if (text === "}")
+                    braces--;
+            }
+            tokens.push({ kind, text, lineBreak });
+            lineBreak = false;
+        }
+        if (position < source.length || interpolation)
+            uncertain = true;
+        return tokens;
+    }
+    const tokens = scan();
+    return uncertain
+        ? JSON.stringify(["source", source])
+        : JSON.stringify(["tokens", serialize(tokens)]);
+}
+function serialize(tokens) {
+    tokens = normalizePunctuation(tokens);
+    return JSON.stringify(tokens.map((token, index) => {
+        const previous = tokens[index - 1];
+        // Only discard newlines where continuation is certain. Keeping other
+        // newlines permits conservative misses rather than unsafe cache hits.
+        const significant = token.lineBreak && previous !== undefined && (restrictedLineBreaks.has(previous.text) ||
+            ["++", "--"].includes(token.text) ||
+            !((previous.kind === "punctuation" &&
+                (expressionPrefixes.has(previous.text) ||
+                    [".", "?.", "}"].includes(previous.text))) ||
+                (token.kind === "punctuation" &&
+                    ([")", "]", "}", ",", ";", ".", "?."].includes(token.text) ||
+                        (expressionPrefixes.has(token.text) &&
+                            !["(", "[", "{", "!", "~"].includes(token.text))))));
+        return [token.kind, token.text, significant];
+    }));
+}
+function normalizePunctuation(input) {
+    const tokens = input.map((token) => ({ ...token }));
+    const result = [];
+    const brackets = [];
+    const controls = new Set(["if", "while", "for", "with", "switch", "catch"]);
+    let previousControl = false;
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const next = tokens[i + 1];
+        const previous = result.at(-1);
+        if (token.kind === "literal" && /^["']/.test(token.text) &&
+            !token.text.includes("\\")) {
+            token.text = JSON.stringify(token.text.slice(1, -1));
+        }
+        // A single arrow parameter has the same binding with or without parentheses.
+        if (token.text === "(" && tokens[i + 1]?.kind === "word" &&
+            tokens[i + 2]?.text === ")" && tokens[i + 3]?.text === "=>") {
+            result.push({ ...tokens[i + 1], lineBreak: token.lineBreak });
+            i += 2;
+            previousControl = false;
+            continue;
+        }
+        // Retain commas representing array holes, including the final hole.
+        if (token.text === "," && [")", "]", "}"].includes(next?.text ?? "") &&
+            previous && ![",", "[", "("].includes(previous.text))
+            continue;
+        const expressionEnd = previous && (previous.kind !== "punctuation" || previous.text === "]" ||
+            (previous.text === ")" && !previousControl));
+        if (token.text === ";" && brackets.at(-1)?.text === "{" && expressionEnd &&
+            !restrictedLineBreaks.has(previous.text)) {
+            if (next?.text === "}")
+                continue;
+            // A call followed by an identifier starts a new statement. Preserve that
+            // boundary as a newline so explicit and automatically inserted semicolons
+            // agree. Never do this in a for header or after a control header.
+            if (previous.text === ")" && next?.kind === "word" &&
+                !["in", "instanceof", "of"].includes(next.text)) {
+                next.lineBreak = true;
+                continue;
+            }
+        }
+        previousControl = false;
+        if (["(", "[", "{"].includes(token.text)) {
+            brackets.push({
+                text: token.text,
+                control: token.text === "(" && (controls.has(previous?.text ?? "") ||
+                    (previous?.text === "await" && result.at(-2)?.text === "for")),
+            });
+        }
+        else if ([")", "]", "}"].includes(token.text)) {
+            previousControl = brackets.pop()?.control ?? false;
+        }
+        result.push(token);
+    }
+    return result;
+}

package/esm/helpers/serializeCacheInputs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serializeCacheInputs.d.ts","sourceRoot":"","sources":["../../src/helpers/serializeCacheInputs.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAC1C,MAAM,EAAE,SAAS,OAAO,EAAE,GACzB,MAAM,CASR;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAIrE"}
+{"version":3,"file":"serializeCacheInputs.d.ts","sourceRoot":"","sources":["../../src/helpers/serializeCacheInputs.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,CAAC,OAAO,UAAU,oBAAoB,CAC1C,MAAM,EAAE,SAAS,OAAO,EAAE,GACzB,MAAM,CASR;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAIrE"}

package/esm/helpers/serializeCacheInputs.js

@@ -1,5 +1,6 @@
 import SimpleTable from "../class/SimpleTable.js";
 import { getTableGeneration } from "./tableGeneration.js";
+import normalizeCacheCode from "./normalizeCacheCode.js";
 /**
  * Converts cache inputs to a deterministic, type-tagged representation.
  * SimpleTable values are represented by their name and current generation.
@@ -34,7 +35,7 @@ function serializeValue(value, path, ancestors) {
         case "function":
             return JSON.stringify([
                 "function",
-                Function.prototype.toString.call(value),
+                normalizeCacheCode(Function.prototype.toString.call(value)),
             ]);
         case "symbol":
             throw new TypeError(`cache() ${path} cannot be a symbol.`);

package/esm/helpers/updateColumnsWithJS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"updateColumnsWithJS.d.ts","sourceRoot":"","sources":["../../src/helpers/updateColumnsWithJS.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAMvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAA8B,mBAAmB,CAC/C,KAAK,EAAE,WAAW,EAClB,YAAY,EAAE,MAAM,EAAE,EACtB,aAAa,EAAE,MAAM,EAAE,EACvB,QAAQ,EAAE,CACR,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,KAC/B,OAAO,CAAC;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,CAAC,EAC1C,OAAO,GAAE;IACP;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACf,GACL,OAAO,CAAC,IAAI,CAAC,CAoJf"}
+{"version":3,"file":"updateColumnsWithJS.d.ts","sourceRoot":"","sources":["../../src/helpers/updateColumnsWithJS.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAQvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAA8B,mBAAmB,CAC/C,KAAK,EAAE,WAAW,EAClB,YAAY,EAAE,MAAM,EAAE,EACtB,aAAa,EAAE,MAAM,EAAE,EACvB,QAAQ,EAAE,CACR,IAAI,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,KAC/B,OAAO,CAAC;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,EAAE,CAAC,EAC1C,OAAO,GAAE;IACP;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACf,GACL,OAAO,CAAC,IAAI,CAAC,CA0Jf"}

package/esm/helpers/updateColumnsWithJS.js

@@ -1,7 +1,9 @@
 import quoteIdentifier from "./quoteIdentifier.js";
 import readMutationRows from "./readMutationRows.js";
 import { retainRegisteredTables } from "./tableRegistry.js";
-import { executePreparedArray, prepareArray } from "../methods/loadArray.js";
+import { prepareArray } from "../methods/loadArray.js";
+import appendColumnBatches from "./appendColumnBatches.js";
+import parseDuckDBType from "./parseDuckDBType.js";
 /**
  * Generates columns from selected input columns, keeping other SQL values in
  * DuckDB. Call from an asynchronous extension barrier. The callback must return
@@ -68,7 +70,6 @@ export default async function updateColumnsWithJS(table, inputColumns, outputCol
     const id = `__sda_id_${suffix}`;
     const snapshot = `__sda_source_${suffix}`;
     const staged = table.sdb.newTable(`__sda_generated_${suffix}`);
-    const batch = table.sdb.newTable(`__sda_batch_${suffix}`);
     const q = quoteIdentifier;
     try {
         // A SQL snapshot gives every row a stable identity, including duplicate rows
@@ -92,17 +93,17 @@ export default async function updateColumnsWithJS(table, inputColumns, outputCol
                 throw new Error("Column generation must return one row per input row.");
             }
             // Generated vectors retain this helper's existing inference contract.
-            await executePreparedArray(batch, prepareArray(generated.map((row, i) => ({
+            const prepared = prepareArray(generated.map((row, i) => ({
                 ...Object.fromEntries(outputColumns.map((name) => [name, row[name]])),
                 [id]: ids[i],
-            }))));
-            const batchTypes = await batch.getTypes();
+            })));
+            const batchTypes = new Map(prepared.keys.map((name, i) => [name, prepared.types[i]]));
             for (const name of outputColumns) {
                 const nonNull = generated.some((row) => row[name] !== null && row[name] !== undefined);
                 if (!nonNull)
                     continue;
                 const previous = knownTypes.get(name);
-                const current = batchTypes[name];
+                const current = batchTypes.get(name);
                 if (previous !== undefined && previous !== current) {
                     throw new Error(`Generated column ${JSON.stringify(name)} changed type from ${previous} to ${current}.`);
                 }
@@ -114,12 +115,13 @@ export default async function updateColumnsWithJS(table, inputColumns, outputCol
                 }
             }
             if (!hasRows) {
-                await table.sdb.customQuery(`CREATE TEMP TABLE ${q(staged.name)} AS SELECT * FROM ${q(batch.name)}`);
+                await table.sdb.customQuery(`CREATE TEMP TABLE ${q(staged.name)} (${prepared.keys.map((name, i) => `${q(name)} ${prepared.types[i]}`)
+                    .join(", ")})`);
                 hasRows = true;
             }
-            else {
-                await table.sdb.customQuery(`INSERT INTO ${q(staged.name)} SELECT * FROM ${q(batch.name)}`);
-            }
+            // All-null batches use the column's established type, avoiding a separate
+            // batch table and SQL copy just to cast nulls into the staged schema.
+            await appendColumnBatches(table.connection, staged.name, prepared.keys.map((name, i) => parseDuckDBType(knownTypes.get(name) ?? prepared.types[i])), prepared.rowCount, (column, start, end) => prepared.columnsData[column].slice(start, end));
         }
         if (!hasRows)
             return;
@@ -139,7 +141,7 @@ export default async function updateColumnsWithJS(table, inputColumns, outputCol
         await table.sdb.customQuery(`CREATE OR REPLACE TABLE ${q(table.name)} AS SELECT ${columns.join(", ")} FROM ${q(snapshot)} original JOIN ${q(staged.name)} generated ON original.${q(id)} = CAST(generated.${q(id)} AS BIGINT) ORDER BY original.${q(id)}`);
     }
     finally {
-        await table.sdb.customQuery(`DROP TABLE IF EXISTS ${q(snapshot)}; DROP TABLE IF EXISTS ${q(staged.name)}; DROP TABLE IF EXISTS ${q(batch.name)};`);
-        retainRegisteredTables(table.sdb, (item) => item !== staged && item !== batch);
+        await table.sdb.customQuery(`DROP TABLE IF EXISTS ${q(snapshot)}; DROP TABLE IF EXISTS ${q(staged.name)};`);
+        retainRegisteredTables(table.sdb, (item) => item !== staged);
     }
 }

package/esm/methods/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/methods/cache.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AA4DvD,wBAA8B,KAAK,CAAC,KAAK,SAAS,WAAW,EAC3D,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC/C,OAAO,GAAE;IACP,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,iBA4LP"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/methods/cache.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AA6DvD,wBAA8B,KAAK,CAAC,KAAK,SAAS,WAAW,EAC3D,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EAC/C,OAAO,GAAE;IACP,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,iBA4LP"}

package/esm/methods/cache.js

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from "nod
 import crypto from "node:crypto";
 import flushAllTables from "../helpers/flushAllTables.js";
 import prettyDuration from "../helpers/prettyDuration.js";
+import normalizeCacheCode from "../helpers/normalizeCacheCode.js";
 import { cacheEntryExpired, cacheLoadMessage, cacheTtlMessage, } from "../helpers/cacheDiagnostics.js";
 import serializeCacheInputs, { getCacheInputLabel, } from "../helpers/serializeCacheInputs.js";
 import { createTableGenerationId, peekTableGeneration, restoreTableGeneration, } from "../helpers/tableGeneration.js";
@@ -27,7 +28,7 @@ export default async function cache(table, compute, options = {}) {
     if (existsSync(cacheSourcesPath)) {
         cacheSources = JSON.parse(readFileSync(cacheSourcesPath, "utf-8"));
     }
-    const functionBody = compute.toString();
+    const functionBody = normalizeCacheCode(compute.toString());
     const entryGeneration = peekTableGeneration(table) ?? null;
     const inputs = options.inputs?.filter((input) => input !== table) ?? [];
     const hasInputs = inputs.length > 0;

package/esm/methods/similarityMahalanobis.d.ts

@@ -0,0 +1,5 @@
+import type SimpleTable from "../class/SimpleTable.js";
+type Options = NonNullable<Parameters<SimpleTable["similarityMahalanobis"]>[3]>;
+export default function similarityMahalanobis(table: SimpleTable, columns: string | string[], referencePoint: number[], newColumn: string, options?: Options): void;
+export {};
+//# sourceMappingURL=similarityMahalanobis.d.ts.map

package/esm/methods/similarityMahalanobis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"similarityMahalanobis.d.ts","sourceRoot":"","sources":["../../src/methods/similarityMahalanobis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AASvD,KAAK,OAAO,GAAG,WAAW,CAAC,UAAU,CAAC,WAAW,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAEhF,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAC3C,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAC1B,cAAc,EAAE,MAAM,EAAE,EACxB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,OAAY,GACpB,IAAI,CAyBN"}

package/esm/methods/{mahalanobis.js → similarityMahalanobis.js}

@@ -5,17 +5,17 @@ import prepareNumericFeatures from "../helpers/prepareNumericFeatures.js";
 import publishPreparedColumns from "../helpers/publishPreparedColumns.js";
 import queueOp from "../helpers/queueOp.js";
 import quoteIdentifier from "../helpers/quoteIdentifier.js";
-export default function mahalanobis(table, columns, referencePoint, newColumn, options = {}) {
+export default function similarityMahalanobis(table, columns, referencePoint, newColumn, options = {}) {
     if (!Array.isArray(referencePoint) || referencePoint.length === 0 ||
         Array.from(referencePoint).some((value) => typeof value !== "number" || !Number.isFinite(value))) {
-        throw new Error("mahalanobis() referencePoint must be a nonempty array of finite numbers in feature-dimension order.");
+        throw new Error("similarityMahalanobis() referencePoint must be a nonempty array of finite numbers in feature-dimension order.");
     }
     const selected = typeof columns === "string" ? columns : [...columns];
     const reference = [...referencePoint];
     const settings = { ...options };
     queueOp(table, {
         kind: "barrier",
-        method: "mahalanobis()",
+        method: "similarityMahalanobis()",
         parameters: {
             columns: selected,
             referencePoint: reference,
@@ -33,23 +33,23 @@ async function execute(table, columns, referencePoint, newColumn, options) {
     const seen = new Set();
     for (const name of outputNames) {
         if (typeof name !== "string" || name.length === 0 || name.includes("\0")) {
-            throw new Error("mahalanobis() output column names must be nonempty strings without null characters.");
+            throw new Error("similarityMahalanobis() output column names must be nonempty strings without null characters.");
         }
         const folded = foldIdentifier(name);
         if (seen.has(folded)) {
-            throw new Error("mahalanobis() distance and similarity score columns must have different names (case-insensitive).");
+            throw new Error("similarityMahalanobis() distance and similarity score columns must have different names (case-insensitive).");
         }
         seen.add(folded);
         if (sourceColumns.some((column) => foldIdentifier(column) === folded)) {
-            throw new Error(`mahalanobis() cannot create ${quoteIdentifier(name)} because that column already exists. Remove it first or choose a different name.`);
+            throw new Error(`similarityMahalanobis() cannot create ${quoteIdentifier(name)} because that column already exists. Remove it first or choose a different name.`);
         }
     }
     const prepared = await prepareNumericFeatures(table, typeof columns === "string"
         ? { kind: "vector", column: columns }
-        : { kind: "scalars", columns }, { method: "mahalanobis()" });
+        : { kind: "scalars", columns }, { method: "similarityMahalanobis()" });
     try {
         if (referencePoint.length !== prepared.dimensions) {
-            throw new Error(`mahalanobis() referencePoint must contain ${prepared.dimensions} values in feature-dimension order; received ${referencePoint.length}.`);
+            throw new Error(`similarityMahalanobis() referencePoint must contain ${prepared.dimensions} values in feature-dimension order; received ${referencePoint.length}.`);
         }
         const model = await computeCovariance(table.connection, {
             relation: prepared.relation,
@@ -73,7 +73,7 @@ async function execute(table, columns, referencePoint, newColumn, options) {
                 });
             }
             await publishPreparedColumns(table, prepared, {
-                method: "mahalanobis()",
+                method: "similarityMahalanobis()",
                 parameters: { columns, referencePoint, newColumn, options },
                 result: {
                     relation: distances.relation,

package/esm/methods/updateWithJS.js

@@ -60,6 +60,7 @@ async function executeUpdateWithJS(simpleTable, dataModifier, options) {
     const accumulator = `updateWithJS_accumulator_${suffix}`;
     try {
         let first = true;
+        let accumulatorSchema;
         let lastRowid = null;
         let sawRows = false;
         let outputOffset = 0;
@@ -131,9 +132,17 @@ async function executeUpdateWithJS(simpleTable, dataModifier, options) {
                 ? parseDuckDBType("VARCHAR")
                 : source.types.get(key) ??
                     parseDuckDBType(added.types[newKeys.indexOf(key)]));
-            await simpleTable.sdb.customQuery(`CREATE OR REPLACE TABLE ${quoteIdentifier(scratch.name)} (${keys.map((key, i) => `${quoteIdentifier(key)} ${columnTypes[i]}`)
-                .join(", ")})`);
-            await appendColumnBatches(simpleTable.connection, scratch.name, columnTypes, modified.length, (column, start, end) => {
+            const schema = JSON.stringify(keys.map((key, i) => [key, columnTypes[i].toString()]));
+            // Append matching native batches directly. SQL still handles conversion
+            // and BY NAME alignment when a callback changes the batch schema.
+            const direct = outputGeometry.length === 0 && outputJSON.length === 0 &&
+                (first || schema === accumulatorSchema);
+            const destination = direct ? accumulator : scratch.name;
+            if (!direct || first) {
+                await simpleTable.sdb.customQuery(`CREATE OR REPLACE TABLE ${quoteIdentifier(destination)} (${keys.map((key, i) => `${quoteIdentifier(key)} ${columnTypes[i]}`)
+                    .join(", ")})`);
+            }
+            await appendColumnBatches(simpleTable.connection, destination, columnTypes, modified.length, (column, start, end) => {
                 const key = keys[column];
                 return outputGeometry.includes(key)
                     ? geometryData.get(key).slice(start, end)
@@ -146,7 +155,11 @@ async function executeUpdateWithJS(simpleTable, dataModifier, options) {
                 : outputJSON.includes(key)
                     ? `${quoteIdentifier(key)}::JSON AS ${quoteIdentifier(key)}`
                     : quoteIdentifier(key)).join(", ");
-            if (first) {
+            if (direct) {
+                accumulatorSchema = schema;
+                first = false;
+            }
+            else if (first) {
                 await simpleTable.sdb.customQuery(`CREATE OR REPLACE TABLE ${quoteIdentifier(accumulator)} AS SELECT ${projection} FROM ${quoteIdentifier(scratch.name)}`);
                 first = false;
             }
@@ -159,7 +172,13 @@ async function executeUpdateWithJS(simpleTable, dataModifier, options) {
         if (first) {
             throw new Error("The dataModifier returned no rows. updateWithJS can't infer the table schema from zero rows.");
         }
-        await simpleTable.sdb.customQuery(`CREATE OR REPLACE TABLE ${quoteIdentifier(simpleTable.name)} AS SELECT * FROM ${quoteIdentifier(accumulator)}`);
+        // Publish the completed ordinary table without copying its rows again.
+        // Qualify the creation namespace: a temporary table or a later search-path
+        // schema can shadow the name without being the destination of replacement.
+        const namespace = await simpleTable.connection.runAndReadAll("SELECT current_database(), current_schema()");
+        const prefix = namespace.getRows()[0].map((name) => quoteIdentifier(String(name))).join(".");
+        await simpleTable.sdb.customQuery(`DROP TABLE IF EXISTS ${prefix}.${quoteIdentifier(simpleTable.name)};
+ALTER TABLE ${prefix}.${quoteIdentifier(accumulator)} RENAME TO ${quoteIdentifier(simpleTable.name)};`);
     }
     finally {
         await simpleTable.sdb.customQuery(`DROP TABLE IF EXISTS ${quoteIdentifier(accumulator)};