@nshiab/simple-data-analysis-core 2.1.12 → 2.1.14

package/script/helpers/LogValue.d.ts

@@ -1,8 +0,0 @@
-/** Internal display metadata; never returned by public data extraction. */
-export default class LogValue {
-    readonly text: string;
-    readonly jsType: string;
-    readonly category: "number" | "string" | "date" | "boolean" | "null";
-    constructor(text: string, jsType: string, category: "number" | "string" | "date" | "boolean" | "null");
-}
-//# sourceMappingURL=LogValue.d.ts.map

package/script/helpers/LogValue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"LogValue.d.ts","sourceRoot":"","sources":["../../src/helpers/LogValue.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,MAAM,CAAC,OAAO,OAAO,QAAQ;IAEzB,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM;gBAF3D,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM;CAEvE"}

package/script/helpers/LogValue.js

@@ -1,26 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/** Internal display metadata; never returned by public data extraction. */
-class LogValue {
-    constructor(text, jsType, category) {
-        Object.defineProperty(this, "text", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: text
-        });
-        Object.defineProperty(this, "jsType", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: jsType
-        });
-        Object.defineProperty(this, "category", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: category
-        });
-    }
-}
-exports.default = LogValue;

package/script/helpers/appendColumnBatches.d.ts

@@ -1,3 +0,0 @@
-import { type DuckDBConnection, type DuckDBType, type DuckDBValue } from "@duckdb/node-api";
-export default function appendColumnBatches(connection: DuckDBConnection, table: string, types: readonly DuckDBType[], rowCount: number, columnValues: (column: number, start: number, end: number) => readonly DuckDBValue[]): Promise<void>;
-//# sourceMappingURL=appendColumnBatches.d.ts.map

package/script/helpers/appendColumnBatches.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"appendColumnBatches.d.ts","sourceRoot":"","sources":["../../src/helpers/appendColumnBatches.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EAErB,KAAK,UAAU,EACf,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAC;AAI1B,wBAA8B,mBAAmB,CAC/C,UAAU,EAAE,gBAAgB,EAC5B,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,CACZ,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,KACR,SAAS,WAAW,EAAE,iBAiB5B"}

package/script/helpers/appendColumnBatches.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = appendColumnBatches;
-const node_api_1 = require("@duckdb/node-api");
-// Append to an existing table. Callers retain ownership of type conversion and
-// publication; each column callback supplies only the requested [start, end).
-async function appendColumnBatches(connection, table, types, rowCount, columnValues) {
-    const appender = await connection.createAppender(table);
-    try {
-        // Stay below DuckDB's maximum chunk capacity of 2048 rows.
-        for (let start = 0; start < rowCount; start += 2000) {
-            const end = Math.min(start + 2000, rowCount);
-            const chunk = node_api_1.DuckDBDataChunk.create(types, end - start);
-            for (let column = 0; column < types.length; column++) {
-                chunk.setColumnValues(column, columnValues(column, start, end));
-            }
-            appender.appendDataChunk(chunk);
-        }
-        appender.flushSync();
-    }
-    finally {
-        appender.closeSync();
-    }
-}

package/script/helpers/assertColumnsExist.d.ts

@@ -1,16 +0,0 @@
-import type { TableSchema } from "./pendingOps.js";
-/**
- * Throws if any of the named columns is absent from the schema. The mirror of
- * `assertNewColumns`: where that guard rejects a column that unexpectedly
- * already exists, this one rejects a column that should exist but doesn't.
- *
- * It backs methods whose SQL silently tolerates a missing column instead of
- * erroring — notably `SELECT * RENAME (...)`, which drops a rename whose
- * source column is absent rather than failing, so a typo would pass unnoticed.
- *
- * @param schema - The schema of the operation's input.
- * @param columns - The names of the columns the operation reads.
- * @param method - The method name, for the error message (e.g. "renameColumns()").
- */
-export default function assertColumnsExist(schema: TableSchema, columns: string[], method: string): void;
-//# sourceMappingURL=assertColumnsExist.d.ts.map

package/script/helpers/assertColumnsExist.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assertColumnsExist.d.ts","sourceRoot":"","sources":["../../src/helpers/assertColumnsExist.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,CACxC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,MAAM,EAAE,EACjB,MAAM,EAAE,MAAM,GACb,IAAI,CAYN"}

package/script/helpers/assertColumnsExist.js

@@ -1,27 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = assertColumnsExist;
-const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
-/**
- * Throws if any of the named columns is absent from the schema. The mirror of
- * `assertNewColumns`: where that guard rejects a column that unexpectedly
- * already exists, this one rejects a column that should exist but doesn't.
- *
- * It backs methods whose SQL silently tolerates a missing column instead of
- * erroring — notably `SELECT * RENAME (...)`, which drops a rename whose
- * source column is absent rather than failing, so a typo would pass unnoticed.
- *
- * @param schema - The schema of the operation's input.
- * @param columns - The names of the columns the operation reads.
- * @param method - The method name, for the error message (e.g. "renameColumns()").
- */
-function assertColumnsExist(schema, columns, method) {
-    const missing = columns.filter((column) => schema[column] === undefined);
-    if (missing.length > 0) {
-        const plural = missing.length > 1;
-        throw new Error(`${method} the column${plural ? "s" : ""} ${missing.map((column) => `${(0, quoteIdentifier_js_1.default)(column)}`).join(", ")} ${plural ? "do" : "does"} not exist. Check for typos, or load the data first.`);
-    }
-}

package/script/helpers/assertNewColumns.d.ts

@@ -1,17 +0,0 @@
-import type { TableSchema } from "./pendingOps.js";
-/**
- * Throws if any of the target columns already exists in the schema, matching
- * the behavior of the v1 methods that added columns with `ALTER TABLE ADD`
- * (which errored on a duplicate). Without this guard, a `SELECT *, expr AS
- * col` that collides with an existing column is silently renamed to `col_1`
- * by DuckDB, so the operation would appear to succeed while leaving the
- * original column untouched.
- *
- * @param schema - The schema of the operation's input.
- * @param newColumns - The names of the columns the operation adds.
- * @param method - The method name, for the error message (e.g. "cloneColumn()").
- * @param allowInPlace - Columns whose name may already exist because the
- *   operation overwrites them in place rather than adding a new column.
- */
-export default function assertNewColumns(schema: TableSchema, newColumns: string[], method: string, allowInPlace?: string[]): void;
-//# sourceMappingURL=assertNewColumns.d.ts.map

package/script/helpers/assertNewColumns.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assertNewColumns.d.ts","sourceRoot":"","sources":["../../src/helpers/assertNewColumns.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,CACtC,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,MAAM,EAAE,EACpB,MAAM,EAAE,MAAM,EACd,YAAY,GAAE,MAAM,EAAO,GAC1B,IAAI,CAUN"}

package/script/helpers/assertNewColumns.js

@@ -1,28 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = assertNewColumns;
-const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
-/**
- * Throws if any of the target columns already exists in the schema, matching
- * the behavior of the v1 methods that added columns with `ALTER TABLE ADD`
- * (which errored on a duplicate). Without this guard, a `SELECT *, expr AS
- * col` that collides with an existing column is silently renamed to `col_1`
- * by DuckDB, so the operation would appear to succeed while leaving the
- * original column untouched.
- *
- * @param schema - The schema of the operation's input.
- * @param newColumns - The names of the columns the operation adds.
- * @param method - The method name, for the error message (e.g. "cloneColumn()").
- * @param allowInPlace - Columns whose name may already exist because the
- *   operation overwrites them in place rather than adding a new column.
- */
-function assertNewColumns(schema, newColumns, method, allowInPlace = []) {
-    for (const column of newColumns) {
-        if (schema[column] !== undefined && !allowInPlace.includes(column)) {
-            throw new Error(`${method} the column ${(0, quoteIdentifier_js_1.default)(column)} already exists. Remove it first or choose a different name for the new column.`);
-        }
-    }
-}

package/script/helpers/assertSameDatabase.d.ts

@@ -1,11 +0,0 @@
-import type SimpleDB from "../class/SimpleDB.js";
-import type SimpleTable from "../class/SimpleTable.js";
-/**
- * Throws when a method receives a table owned by another database connection.
- *
- * @param simpleDB - The database on which the method will execute.
- * @param tables - The tables that must belong to `simpleDB`.
- * @param method - The SDA method name used in the error message.
- */
-export default function assertSameDatabase(simpleDB: SimpleDB, tables: SimpleTable[], method: string): void;
-//# sourceMappingURL=assertSameDatabase.d.ts.map

package/script/helpers/assertSameDatabase.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assertSameDatabase.d.ts","sourceRoot":"","sources":["../../src/helpers/assertSameDatabase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,kBAAkB,CACxC,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,WAAW,EAAE,EACrB,MAAM,EAAE,MAAM,GACb,IAAI,CAWN"}

package/script/helpers/assertSameDatabase.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = assertSameDatabase;
-/**
- * Throws when a method receives a table owned by another database connection.
- *
- * @param simpleDB - The database on which the method will execute.
- * @param tables - The tables that must belong to `simpleDB`.
- * @param method - The SDA method name used in the error message.
- */
-function assertSameDatabase(simpleDB, tables, method) {
-    const foreignTables = tables.filter((table) => table.sdb !== simpleDB);
-    if (foreignTables.length > 0) {
-        throw new Error(`${method} all tables must belong to the same SimpleDB instance. The following table${foreignTables.length === 1 ? " belongs" : "s belong"} to another database: ${foreignTables.map((table) => JSON.stringify(table.name)).join(", ")}.`);
-    }
-}

package/script/helpers/asyncOperationContext.d.ts

@@ -1,19 +0,0 @@
-import type SimpleDB from "../class/SimpleDB.js";
-import type SimpleTable from "../class/SimpleTable.js";
-import type { PendingOp } from "./pendingOps.js";
-export type PendingEntry = {
-    table: SimpleTable;
-    op: PendingOp;
-};
-export type AsyncOperationFrame = {
-    sdb: SimpleDB;
-    entries: PendingEntry[];
-    drainPromise: Promise<void> | null;
-    open: boolean;
-};
-export declare function getAsyncOperationFrame(sdb: SimpleDB): AsyncOperationFrame | undefined;
-export declare function captureAsyncOperation(sdb: SimpleDB, entry: PendingEntry): boolean;
-export declare function runWithAsyncOperationFrame<T>(sdb: SimpleDB, fn: (frame: AsyncOperationFrame) => Promise<T>): Promise<T>;
-export declare function isDrainingAsyncOperationFrame(frame: AsyncOperationFrame): boolean;
-export declare function runWhileDrainingAsyncOperationFrame<T>(frame: AsyncOperationFrame, fn: () => Promise<T>): Promise<T>;
-//# sourceMappingURL=asyncOperationContext.d.ts.map

package/script/helpers/asyncOperationContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"asyncOperationContext.d.ts","sourceRoot":"","sources":["../../src/helpers/asyncOperationContext.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,MAAM,MAAM,YAAY,GAAG;IACzB,KAAK,EAAE,WAAW,CAAC;IACnB,EAAE,EAAE,SAAS,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,EAAE,QAAQ,CAAC;IACd,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,YAAY,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACnC,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAKF,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,QAAQ,GACZ,mBAAmB,GAAG,SAAS,CAIjC;AAED,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,QAAQ,EACb,KAAK,EAAE,YAAY,GAClB,OAAO,CAOT;AAED,wBAAsB,0BAA0B,CAAC,CAAC,EAChD,GAAG,EAAE,QAAQ,EACb,EAAE,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,OAAO,CAAC,CAAC,CAAC,GAC7C,OAAO,CAAC,CAAC,CAAC,CAcZ;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,mBAAmB,GACzB,OAAO,CAET;AAED,wBAAgB,mCAAmC,CAAC,CAAC,EACnD,KAAK,EAAE,mBAAmB,EAC1B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAIZ"}

package/script/helpers/asyncOperationContext.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAsyncOperationFrame = getAsyncOperationFrame;
-exports.captureAsyncOperation = captureAsyncOperation;
-exports.runWithAsyncOperationFrame = runWithAsyncOperationFrame;
-exports.isDrainingAsyncOperationFrame = isDrainingAsyncOperationFrame;
-exports.runWhileDrainingAsyncOperationFrame = runWhileDrainingAsyncOperationFrame;
-const node_async_hooks_1 = require("node:async_hooks");
-const operationContext = new node_async_hooks_1.AsyncLocalStorage();
-const drainContext = new node_async_hooks_1.AsyncLocalStorage();
-function getAsyncOperationFrame(sdb) {
-    return operationContext.getStore()?.findLast((frame) => frame.sdb === sdb && frame.open);
-}
-function captureAsyncOperation(sdb, entry) {
-    const frame = getAsyncOperationFrame(sdb);
-    if (frame === undefined) {
-        return false;
-    }
-    frame.entries.push(entry);
-    return true;
-}
-async function runWithAsyncOperationFrame(sdb, fn) {
-    const frame = {
-        sdb,
-        entries: [],
-        drainPromise: null,
-        open: true,
-    };
-    const frames = [...(operationContext.getStore() ?? []), frame];
-    try {
-        return await operationContext.run(frames, () => fn(frame));
-    }
-    finally {
-        frame.open = false;
-        frame.entries.length = 0;
-    }
-}
-function isDrainingAsyncOperationFrame(frame) {
-    return drainContext.getStore()?.has(frame) ?? false;
-}
-function runWhileDrainingAsyncOperationFrame(frame, fn) {
-    const draining = new Set(drainContext.getStore());
-    draining.add(frame);
-    return drainContext.run(draining, fn);
-}

package/script/helpers/buildApproximateMutualReachabilityMst.d.ts

@@ -1,45 +0,0 @@
-import { type DuckDBConnection } from "@duckdb/node-api";
-/**
- * Build an explicitly approximate mutual-reachability MST. HNSW supplies a
- * high-recall k-neighbor candidate graph; disconnected components are repaired
- * with deterministic all-member projection sweeps. Neither step guarantees the
- * complete graph's MST.
- */
-export default function buildApproximateMutualReachabilityMst(connection: DuckDBConnection, input: {
-    count: number;
-    dimensions: number;
-    minSamples: number;
-}, options: {
-    metric: "euclidean" | "cosine";
-}, names: {
-    rows: string;
-    neighbors: string;
-    search: string;
-    hnsw: string;
-    candidates: string;
-    coreDistances: string;
-    edges: string;
-    components: string;
-    representatives: string;
-    componentPairs: string;
-    bridgeCandidates: string;
-    mst: string;
-}): Promise<{
-    candidateComponents: number;
-    neighborCount: number;
-}>;
-/** Internal connectivity-repair seam used by focused approximation tests. */
-export declare function repairApproximateConnectivity(connection: DuckDBConnection, input: {
-    count: number;
-}, options: {
-    metric: "euclidean" | "cosine";
-}, names: {
-    rows: string;
-    coreDistances: string;
-    edges: string;
-    components: string;
-    representatives: string;
-    componentPairs: string;
-    bridgeCandidates: string;
-}): Promise<number>;
-//# sourceMappingURL=buildApproximateMutualReachabilityMst.d.ts.map

package/script/helpers/buildApproximateMutualReachabilityMst.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildApproximateMutualReachabilityMst.d.ts","sourceRoot":"","sources":["../../src/helpers/buildApproximateMutualReachabilityMst.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,gBAAgB,EAAW,MAAM,kBAAkB,CAAC;AAQ1E;;;;;GAKG;AACH,wBAA8B,qCAAqC,CACjE,UAAU,EAAE,gBAAgB,EAC5B,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,EAChE,OAAO,EAAE;IAAE,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAA;CAAE,EAC3C,KAAK,EAAE;IACL,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,GAAG,EAAE,MAAM,CAAC;CACb,GACA,OAAO,CAAC;IAAE,mBAAmB,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CAsFjE;AAED,6EAA6E;AAC7E,wBAAsB,6BAA6B,CACjD,UAAU,EAAE,gBAAgB,EAC5B,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,EACxB,OAAO,EAAE;IAAE,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAA;CAAE,EAC3C,KAAK,EAAE;IACL,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,GACA,OAAO,CAAC,MAAM,CAAC,CAsHjB"}

package/script/helpers/buildApproximateMutualReachabilityMst.js

@@ -1,219 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = buildApproximateMutualReachabilityMst;
-exports.repairApproximateConnectivity = repairApproximateConnectivity;
-const node_api_1 = require("@duckdb/node-api");
-const appendColumnBatches_js_1 = __importDefault(require("./appendColumnBatches.js"));
-const buildSparseMutualReachabilityMst_js_1 = __importDefault(require("./buildSparseMutualReachabilityMst.js"));
-const buildVectorNeighbors_js_1 = __importDefault(require("./buildVectorNeighbors.js"));
-const inspectGraphConnectivity_js_1 = __importDefault(require("./inspectGraphConnectivity.js"));
-const quoteIdentifier_js_1 = __importDefault(require("./quoteIdentifier.js"));
-const vectorDistanceExpression_js_1 = __importDefault(require("./vectorDistanceExpression.js"));
-/**
- * Build an explicitly approximate mutual-reachability MST. HNSW supplies a
- * high-recall k-neighbor candidate graph; disconnected components are repaired
- * with deterministic all-member projection sweeps. Neither step guarantees the
- * complete graph's MST.
- */
-async function buildApproximateMutualReachabilityMst(connection, input, options, names) {
-    const q = quoteIdentifier_js_1.default;
-    const quoted = Object.fromEntries(Object.entries(names).map(([key, value]) => [key, q(value)]));
-    const neighborCount = Math.min(input.count - 1, Math.max(input.minSamples, 64));
-    await (0, buildVectorNeighbors_js_1.default)(connection, {
-        count: input.count,
-        dimensions: input.dimensions,
-        neighborCount,
-    }, {
-        metric: options.metric,
-        search: "hnsw",
-        includeSelf: false,
-        hnsw: {
-            efConstruction: 256,
-            efSearch: Math.max(512, neighborCount * 2),
-            connectivity: 32,
-            candidateCount: Math.min(input.count, neighborCount * 2 + 1),
-            singleThreaded: true,
-            cosineAsL2: true,
-        },
-    }, {
-        rows: quoted.rows,
-        neighbors: quoted.neighbors,
-        search: quoted.search,
-        hnsw: quoted.hnsw,
-        candidates: quoted.candidates,
-    });
-    await connection.run(`CREATE OR REPLACE TEMP TABLE ${quoted.coreDistances} AS
-    SELECT source AS vertex,distance
-    FROM ${quoted.neighbors} WHERE rank=${input.minSamples - 1};
-    CREATE OR REPLACE TEMP TABLE ${quoted.edges} AS
-    SELECT least(n.source,n.target)::INTEGER AS source,
-      greatest(n.source,n.target)::INTEGER AS target,
-      min(greatest(cs.distance,ct.distance,n.distance))::DOUBLE AS distance
-    FROM ${quoted.neighbors} n
-    JOIN ${quoted.coreDistances} cs ON cs.vertex=n.source
-    JOIN ${quoted.coreDistances} ct ON ct.vertex=n.target
-    GROUP BY least(n.source,n.target),greatest(n.source,n.target)`);
-    await connection.run(`DROP TABLE IF EXISTS ${quoted.neighbors};
-    DROP TABLE IF EXISTS ${quoted.candidates};
-    DROP TABLE IF EXISTS ${quoted.search}`);
-    const componentCount = await repairApproximateConnectivity(connection, { count: input.count }, options, {
-        rows: names.rows,
-        coreDistances: names.coreDistances,
-        edges: names.edges,
-        components: names.components,
-        representatives: names.representatives,
-        componentPairs: names.componentPairs,
-        bridgeCandidates: names.bridgeCandidates,
-    });
-    const mst = await (0, buildSparseMutualReachabilityMst_js_1.default)(connection, quoted.edges, input.count);
-    await connection.run(`CREATE OR REPLACE TEMP TABLE ${quoted.mst}
-      (source INTEGER,target INTEGER,distance DOUBLE)`);
-    await (0, appendColumnBatches_js_1.default)(connection, names.mst, [node_api_1.INTEGER, node_api_1.INTEGER, node_api_1.DOUBLE], mst.length, (column, start, end) => mst.slice(start, end).map((edge) => column === 0 ? edge.source : column === 1 ? edge.target : edge.distance));
-    return { candidateComponents: componentCount, neighborCount };
-}
-/** Internal connectivity-repair seam used by focused approximation tests. */
-async function repairApproximateConnectivity(connection, input, options, names) {
-    const q = quoteIdentifier_js_1.default;
-    const quoted = Object.fromEntries(Object.entries(names).map(([key, value]) => [key, q(value)]));
-    const componentOf = await readComponents(connection, quoted.edges, input.count);
-    let maximumComponent = -1;
-    for (const component of componentOf) {
-        if (component > maximumComponent)
-            maximumComponent = component;
-    }
-    const componentCount = maximumComponent + 1;
-    if (componentCount > 1) {
-        await createComponentRows(connection, names.components, componentOf);
-        // Each sweep examines every point, rather than a fixed representative
-        // sample. Consecutive component runs in the projected order provide a
-        // connected backbone, while multiple directions offer alternative edges.
-        // We also connect each member of a run to the nearest projected endpoint
-        // in both adjacent runs. All weights are recomputed in the actual metric.
-        const dimensions = Number((await connection.runAndReadAll(`SELECT len(vec) FROM ${quoted.rows} LIMIT 1`)).getRowsJS()[0][0]);
-        await connection.run(`CREATE OR REPLACE TEMP TABLE ${quoted.bridgeCandidates}
-      (source INTEGER,target INTEGER,distance DOUBLE)`);
-        const rawDistance = (0, vectorDistanceExpression_js_1.default)("a.vec", "b.vec", options.metric);
-        const projectionCount = Math.min(dimensions, 8) + (dimensions > 1 ? 16 : 0);
-        for (let projection = 0; projection < projectionCount; projection++) {
-            // Coordinate directions handle axis-aligned and one-dimensional data;
-            // fixed pseudo-random directions cover rotated component boundaries.
-            // Coefficients do not depend on table names, execution order, or RNG state.
-            const coefficients = Array.from({ length: dimensions }, (_, dimension) => {
-                if (projection < Math.min(dimensions, 8)) {
-                    return dimension === projection ? 1 : 0;
-                }
-                let hash = Math.imul(projection + 1, 0x9e3779b1) ^
-                    Math.imul(dimension + 1, 0x85ebca6b);
-                hash = Math.imul(hash ^ (hash >>> 16), 0x7feb352d);
-                hash = Math.imul(hash ^ (hash >>> 15), 0x846ca68b);
-                return ((hash ^ (hash >>> 16)) >>> 0) / 0x100000000 * 2 - 1;
-            });
-            // Scaling each coordinate by the same global factor prevents overflow
-            // in the projection without changing its ordering. Unit directions are
-            // the appropriate search geometry for cosine.
-            const vector = options.metric === "cosine"
-                ? `list_transform(r.vec,x -> x/sqrt(array_inner_product(r.vec,r.vec)))::DOUBLE[${dimensions}]`
-                : `list_transform(r.vec,x -> x/scale.maximum)::DOUBLE[${dimensions}]`;
-            await connection.run(`CREATE OR REPLACE TEMP TABLE ${quoted.representatives} AS
-        WITH projected AS (
-          SELECT r.vertex,c.component,
-            array_inner_product(${vector},[${coefficients.join(",")}]::DOUBLE[${dimensions}]) AS position
-          FROM ${quoted.rows} r JOIN ${quoted.components} c USING(vertex)
-          CROSS JOIN (SELECT greatest(1,max(list_max(list_transform(vec,x -> abs(x))))) AS maximum FROM ${quoted.rows}) scale
-        ), ordered AS (
-          SELECT *,lag(component) OVER w AS previous_component,
-            lead(component) OVER w AS next_component,
-            lag(vertex) OVER w AS previous_vertex,
-            lead(vertex) OVER w AS next_vertex
-          FROM projected WINDOW w AS (ORDER BY position,vertex)
-        )
-        SELECT vertex,
-          last_value(CASE WHEN component != previous_component THEN previous_vertex END IGNORE NULLS)
-            OVER (ORDER BY position,vertex ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS left_vertex,
-          first_value(CASE WHEN component != next_component THEN next_vertex END IGNORE NULLS)
-            OVER (ORDER BY position,vertex ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING) AS right_vertex
-        FROM ordered;
-        INSERT INTO ${quoted.bridgeCandidates}
-        SELECT least(a.vertex,b.vertex)::INTEGER,greatest(a.vertex,b.vertex)::INTEGER,
-          greatest(ca.distance,cb.distance,${rawDistance})::DOUBLE
-        FROM (SELECT vertex,unnest([left_vertex,right_vertex]) AS target FROM ${quoted.representatives}) p
-        JOIN ${quoted.rows} a ON a.vertex=p.vertex
-        JOIN ${quoted.rows} b ON b.vertex=p.target
-        JOIN ${quoted.coreDistances} ca ON ca.vertex=a.vertex
-        JOIN ${quoted.coreDistances} cb ON cb.vertex=b.vertex`);
-        }
-        const invalidBridgeDistances = Number((await connection.runAndReadAll(`SELECT count(*) FROM ${quoted.bridgeCandidates}
-       WHERE distance IS NULL OR NOT isfinite(distance)`)).getRowsJS()[0][0]);
-        if (invalidBridgeDistances > 0) {
-            throw new Error(`Approximate HDBSCAN connectivity repair produced ${invalidBridgeDistances} non-finite candidate distances. Rescale the input features.`);
-        }
-        await connection.run(`INSERT INTO ${quoted.edges}
-      SELECT source,target,min(distance) AS distance
-      FROM ${quoted.bridgeCandidates} GROUP BY source,target`);
-    }
-    const connectivity = await (0, inspectGraphConnectivity_js_1.default)(connection, quoted.edges, input.count);
-    if (connectivity.componentCount !== 1) {
-        throw new Error(`Approximate HDBSCAN connectivity repair left ${connectivity.componentCount} graph components.`);
-    }
-    return componentCount;
-}
-async function readComponents(connection, edges, count) {
-    const parent = new Int32Array(count);
-    const size = new Int32Array(count).fill(1);
-    for (let vertex = 0; vertex < count; vertex++)
-        parent[vertex] = vertex;
-    const find = (start) => {
-        let root = start;
-        while (parent[root] !== root)
-            root = parent[root];
-        let current = start;
-        while (parent[current] !== current) {
-            const next = parent[current];
-            parent[current] = root;
-            current = next;
-        }
-        return root;
-    };
-    const union = (left, right) => {
-        let a = find(left), b = find(right);
-        if (a === b)
-            return;
-        if (size[a] < size[b])
-            [a, b] = [b, a];
-        parent[b] = a;
-        size[a] += size[b];
-    };
-    const result = await connection.stream(`SELECT source,target FROM ${edges}`);
-    while (true) {
-        const chunk = await result.fetchChunk();
-        if (!chunk || chunk.rowCount === 0)
-            break;
-        const sources = chunk.getColumnVector(0);
-        const targets = chunk.getColumnVector(1);
-        for (let row = 0; row < chunk.rowCount; row++) {
-            union(Number(sources.getItem(row)), Number(targets.getItem(row)));
-        }
-    }
-    const minimum = new Map();
-    for (let vertex = 0; vertex < count; vertex++) {
-        const root = find(vertex);
-        minimum.set(root, Math.min(minimum.get(root) ?? vertex, vertex));
-    }
-    const ids = [...minimum]
-        .sort((a, b) => a[1] - b[1])
-        .map(([root], component) => [root, component]);
-    const componentByRoot = new Map(ids);
-    const componentOf = new Int32Array(count);
-    for (let vertex = 0; vertex < count; vertex++) {
-        componentOf[vertex] = componentByRoot.get(find(vertex));
-    }
-    return componentOf;
-}
-async function createComponentRows(connection, name, componentOf) {
-    await connection.run(`CREATE OR REPLACE TEMP TABLE ${(0, quoteIdentifier_js_1.default)(name)}
-      (vertex INTEGER,component INTEGER)`);
-    await (0, appendColumnBatches_js_1.default)(connection, name, [node_api_1.INTEGER, node_api_1.INTEGER], componentOf.length, (column, start, end) => Array.from({ length: end - start }, (_, offset) => column === 0 ? start + offset : componentOf[start + offset]));
-}

package/script/helpers/buildChronologicalGraphComponentsSql.d.ts

@@ -1,14 +0,0 @@
-import type { PreparedGraphTemporalSql } from "./prepareGraphTemporalSql.js";
-import type { PreparedGraphSql } from "./prepareGraphTraversal.js";
-/** Builds all-pairs chronological reachability and maximal-clique membership SQL. */
-export default function buildChronologicalGraphComponentsSql(prepared: PreparedGraphSql, temporal: PreparedGraphTemporalSql): string;
-export type MaximalGraphCliqueRelations = {
-    adjacency: string;
-    initial: string;
-    maximal: string;
-    numbered: string;
-    search: string;
-};
-/** Builds pivoted Bron–Kerbosch CTEs over typed node and mutual-edge relations. */
-export declare function buildMaximalGraphCliquesSql(nodes: string, mutual: string, relations: MaximalGraphCliqueRelations): string;
-//# sourceMappingURL=buildChronologicalGraphComponentsSql.d.ts.map

package/script/helpers/buildChronologicalGraphComponentsSql.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buildChronologicalGraphComponentsSql.d.ts","sourceRoot":"","sources":["../../src/helpers/buildChronologicalGraphComponentsSql.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAGnE,qFAAqF;AACrF,MAAM,CAAC,OAAO,UAAU,oCAAoC,CAC1D,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,wBAAwB,GACjC,MAAM,CA+ER;AAED,MAAM,MAAM,2BAA2B,GAAG;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,mFAAmF;AACnF,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,2BAA2B,GACrC,MAAM,CA2FR"}