@happyvertical/smrt-core 0.55.6 → 0.55.8

package/dist/testing/database.js

@@ -3,11 +3,11 @@ import { detectEngine } from "../schema/ddl/index.js";
 import { getSystemTableDDL } from "../system/schema.js";
 import { ensurePostgresChangeFeedAppendFunction } from "../change-feed.js";
 import { ensureLegacySystemTableCompatibility } from "../system/compatibility.js";
-import { SchemaGenerator } from "../schema/generator.js";
 import { recordRegistryDiagnostic } from "../registry/diagnostics.js";
 import { isFrameworkBaseClass } from "../registry/framework-base-classes.js";
 import { isCollectionRegistration, resolveCollectionItemClassName, resolveRelatedRegistration } from "../registry/collection-resolution.js";
 import { ObjectRegistry } from "../registry.js";
+import { SchemaGenerator } from "../schema/generator.js";
 import { planForeignKeyCreation } from "../schema/foreign-key-planner.js";
 import { getDatabase } from "@happyvertical/sql";
 //#region src/testing/database.ts

package/dist/tools/index.js

@@ -1,3 +1,3 @@
-import { convertTypeToJsonSchema, generateToolFromMethod, generateToolManifest, shouldIncludeMethod } from "./tool-generator.js";
 import { executeToolCall, executeToolCalls, formatToolResults, validateToolCall } from "./tool-executor.js";
+import { convertTypeToJsonSchema, generateToolFromMethod, generateToolManifest, shouldIncludeMethod } from "./tool-generator.js";
 export { convertTypeToJsonSchema, executeToolCall, executeToolCalls, formatToolResults, generateToolFromMethod, generateToolManifest, shouldIncludeMethod, validateToolCall };

package/dist/unchanged-indexed.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Unchanged indexed assignments on persisted rows (#3737).
+ *
+ * DuckDB rewrites a row (delete + insert) when an INDEXED column is assigned,
+ * even with its existing value. A parent that a foreign key still references
+ * therefore raises a referenced-parent violation for `SET slug = <same slug>`.
+ * `SmrtObject.save()` serializes the whole model, so every existing-row write
+ * used to assign `slug`, `context`, `tenant_id`, `created_at`, ... unchanged.
+ *
+ * This module holds the pure decisions: which columns are indexed, whether a
+ * pending value provably equals the stored one, and how an assignment value
+ * is bound by the generic UPDATE API. Nothing here touches a database, so the
+ * save path keeps owning revision checks, tenant isolation and error typing.
+ *
+ * Everything errs toward "assign as before": an unknown column, a missing
+ * stored value or a value that cannot be compared is NOT reported unchanged.
+ */
+import type { SchemaDefinition } from './schema/types.js';
+/**
+ * Columns whose assignment DuckDB may treat as an index rewrite.
+ *
+ * The union of what the registry schema declares (primary key, UNIQUE, every
+ * declared index including partial and JSON-path ones, foreign keys) and the
+ * natural-key / ownership columns the runtime itself keys writes by. Being
+ * over-inclusive is harmless — a column is only skipped when it is also proven
+ * unchanged — so this never has to be an exact model of the physical DDL.
+ */
+export declare function collectIndexedColumns(schemas: ReadonlyArray<SchemaDefinition | undefined>, runtimeKeyColumns: Iterable<string>): Set<string>;
+/**
+ * An instant as whole microseconds since the epoch, or `undefined` when it
+ * cannot be established exactly.
+ *
+ * A `Date` holds milliseconds. Text is read at its full written precision;
+ * digits beyond microseconds must be zero. Text without a zone is a wall
+ * clock in the process zone unless `naiveIsUtc` (DuckDB's `TIMESTAMP` text,
+ * which this runtime always writes as UTC).
+ */
+export declare function timestampMicros(value: unknown, naiveIsUtc?: boolean): bigint | undefined;
+/**
+ * Whether every number literal in JSON text survives `JSON.parse` exactly.
+ *
+ * `JSON.parse` reads numbers as doubles, so `9007199254740993` and
+ * `9007199254740992` parse to the same value. A literal is exact when the
+ * double it parses to prints back as the same text; anything else (unsafe
+ * integers, more digits than a double holds, `1.0`, `1e2`) makes the text
+ * unprovable. Digits inside JSON strings are not numbers and are skipped.
+ */
+export declare function jsonNumbersRoundTrip(text: string): boolean;
+/**
+ * Whether `next` (the value about to be written) provably equals `stored`
+ * (the canonical value read back from the row). `false` means "assign it":
+ * either it differs or equality cannot be established.
+ */
+export declare function storedValueEquals(columnType: string | undefined, next: unknown, stored: unknown, exactStoredTimestamp?: string): boolean;
+/**
+ * `TIMESTAMP` columns of `data` whose equality needs the stored value at full
+ * precision (see {@link storedValueEquals}); the caller reads them as text.
+ */
+export declare function timestampColumnsToProve(data: Readonly<Record<string, unknown>>, stored: Readonly<Record<string, unknown>>, indexedColumns: ReadonlySet<string>, columnTypes: Readonly<Record<string, {
+    type?: string;
+} | undefined>>): string[];
+/**
+ * Indexed columns of `data` whose value provably equals the stored row's, in
+ * snake_case column names. `id` and `updated_at` are never reported: the
+ * revision token always advances, and `id` is the write's key.
+ */
+export declare function unchangedIndexedColumns(data: Readonly<Record<string, unknown>>, stored: Readonly<Record<string, unknown>>, indexedColumns: ReadonlySet<string>, columnTypes: Readonly<Record<string, {
+    type?: string;
+} | undefined>>, exactTimestamps?: Readonly<Record<string, string>>): Set<string>;
+/**
+ * An id-targeted `UPDATE` for native DuckDB, with every identifier quoted and
+ * every value bound the way the DuckDB adapter's `upsert()` binds its
+ * `DO UPDATE SET` values: `NULL` literals, `''` cast to TEXT, dates as ISO
+ * strings, arrays and plain objects as JSON text.
+ *
+ * The adapter's generic `update()` is not used because it renders column names
+ * unquoted (a column named `order` or `group` is a syntax error) and hands
+ * dates and structures to the driver untouched; the `upsert()` it replaces
+ * handled both.
+ */
+export declare function buildDuckDbIdUpdate(table: string, id: unknown, assignments: Readonly<Record<string, unknown>>): {
+    sql: string;
+    values: unknown[];
+};
+//# sourceMappingURL=unchanged-indexed.d.ts.map

package/dist/unchanged-indexed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unchanged-indexed.d.ts","sourceRoot":"","sources":["../src/unchanged-indexed.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAM1D;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,aAAa,CAAC,gBAAgB,GAAG,SAAS,CAAC,EACpD,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,GAClC,GAAG,CAAC,MAAM,CAAC,CAuBb;AAWD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,OAAO,EACd,UAAU,UAAQ,GACjB,MAAM,GAAG,SAAS,CAwCpB;AAID;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAuB1D;AA8BD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,OAAO,EACf,oBAAoB,CAAC,EAAE,MAAM,GAC5B,OAAO,CAwCT;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACvC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,EACnC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC,CAAC,GACnE,MAAM,EAAE,CAUV;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACvC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,EACnC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC,CAAC,EACpE,eAAe,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM,GACrD,GAAG,CAAC,MAAM,CAAC,CAkBb;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,OAAO,EACX,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC7C;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAgCpC"}

package/dist/unchanged-indexed.js

@@ -0,0 +1,219 @@
+import { toSnakeCase } from "./utils/naming.js";
+import "./utils.js";
+//#region src/unchanged-indexed.ts
+/** Columns the save path always writes, whatever their stored value. */
+var ALWAYS_ASSIGNED = /* @__PURE__ */ new Set(["id", "updated_at"]);
+/**
+* Columns whose assignment DuckDB may treat as an index rewrite.
+*
+* The union of what the registry schema declares (primary key, UNIQUE, every
+* declared index including partial and JSON-path ones, foreign keys) and the
+* natural-key / ownership columns the runtime itself keys writes by. Being
+* over-inclusive is harmless — a column is only skipped when it is also proven
+* unchanged — so this never has to be an exact model of the physical DDL.
+*/
+function collectIndexedColumns(schemas, runtimeKeyColumns) {
+	const indexed = /* @__PURE__ */ new Set();
+	for (const column of runtimeKeyColumns) indexed.add(/[A-Z]/u.test(column) ? toSnakeCase(column) : column);
+	for (const schema of schemas) {
+		if (!schema) continue;
+		for (const [name, column] of Object.entries(schema.columns ?? {})) if (column.primaryKey || column.unique || column.foreignKey) indexed.add(name);
+		for (const index of schema.indexes ?? []) {
+			for (const name of index.columns ?? []) indexed.add(name);
+			if (index.jsonPath?.column) indexed.add(index.jsonPath.column);
+		}
+		for (const foreignKey of schema.foreignKeys ?? []) indexed.add(foreignKey.column);
+	}
+	return indexed;
+}
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+var TIMESTAMP_TEXT = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?\s*(Z|[+-]\d{2}(?::?\d{2})?)?$/iu;
+function isNullish(value) {
+	return value === null || value === void 0;
+}
+/**
+* An instant as whole microseconds since the epoch, or `undefined` when it
+* cannot be established exactly.
+*
+* A `Date` holds milliseconds. Text is read at its full written precision;
+* digits beyond microseconds must be zero. Text without a zone is a wall
+* clock in the process zone unless `naiveIsUtc` (DuckDB's `TIMESTAMP` text,
+* which this runtime always writes as UTC).
+*/
+function timestampMicros(value, naiveIsUtc = false) {
+	if (value instanceof Date) {
+		const time = value.getTime();
+		return Number.isNaN(time) ? void 0 : BigInt(time) * 1000n;
+	}
+	if (typeof value !== "string") return void 0;
+	const match = TIMESTAMP_TEXT.exec(value.trim());
+	if (!match) return void 0;
+	const [, year, month, day, hour, minute, second, fraction = "", zone] = match;
+	if (fraction.length > 6 && /[1-9]/u.test(fraction.slice(6))) return void 0;
+	if (zone === void 0 && !naiveIsUtc) return void 0;
+	const date = /* @__PURE__ */ new Date(0);
+	date.setUTCFullYear(Number(year), Number(month) - 1, Number(day));
+	date.setUTCHours(Number(hour), Number(minute), Number(second), 0);
+	const wall = date.getTime();
+	if (Number.isNaN(wall)) return void 0;
+	if (date.getUTCFullYear() !== Number(year) || date.getUTCMonth() !== Number(month) - 1 || date.getUTCDate() !== Number(day) || date.getUTCHours() !== Number(hour) || date.getUTCMinutes() !== Number(minute) || date.getUTCSeconds() !== Number(second)) return;
+	let offsetMinutes = 0;
+	if (zone && zone.toUpperCase() !== "Z") {
+		const digits = zone.slice(1).replace(":", "");
+		const offsetHours = Number(digits.slice(0, 2));
+		const offsetRest = Number(digits.slice(2) || "0");
+		if (offsetHours > 23 || offsetRest > 59) return void 0;
+		offsetMinutes = (zone.startsWith("-") ? -1 : 1) * (offsetHours * 60 + offsetRest);
+	}
+	const micros = BigInt(fraction.slice(0, 6).padEnd(6, "0"));
+	return (BigInt(wall) - BigInt(offsetMinutes) * 60000n) * 1000n + micros;
+}
+var JSON_NUMBER = /-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
+/**
+* Whether every number literal in JSON text survives `JSON.parse` exactly.
+*
+* `JSON.parse` reads numbers as doubles, so `9007199254740993` and
+* `9007199254740992` parse to the same value. A literal is exact when the
+* double it parses to prints back as the same text; anything else (unsafe
+* integers, more digits than a double holds, `1.0`, `1e2`) makes the text
+* unprovable. Digits inside JSON strings are not numbers and are skipped.
+*/
+function jsonNumbersRoundTrip(text) {
+	let inString = false;
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index];
+		if (inString) {
+			if (char === "\\") index += 1;
+			else if (char === "\"") inString = false;
+			continue;
+		}
+		if (char === "\"") {
+			inString = true;
+			continue;
+		}
+		if (char === "-" || char >= "0" && char <= "9") {
+			JSON_NUMBER.lastIndex = index;
+			const match = JSON_NUMBER.exec(text);
+			if (!match) return false;
+			const literal = match[0];
+			if (JSON.stringify(Number(literal)) !== literal) return false;
+			index += literal.length - 1;
+		}
+	}
+	return true;
+}
+function canonicalJson(value) {
+	let parsed = value;
+	if (typeof value === "string") {
+		if (!jsonNumbersRoundTrip(value)) return void 0;
+		try {
+			parsed = JSON.parse(value);
+		} catch {
+			return;
+		}
+	}
+	const normalize = (node) => {
+		if (Array.isArray(node)) return node.map(normalize);
+		if (node !== null && typeof node === "object") return Object.fromEntries(Object.entries(node).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, child]) => [key, normalize(child)]));
+		return node;
+	};
+	try {
+		return JSON.stringify(normalize(parsed));
+	} catch {
+		return;
+	}
+}
+/**
+* Whether `next` (the value about to be written) provably equals `stored`
+* (the canonical value read back from the row). `false` means "assign it":
+* either it differs or equality cannot be established.
+*/
+function storedValueEquals(columnType, next, stored, exactStoredTimestamp) {
+	if (isNullish(next) || isNullish(stored)) return isNullish(next) && isNullish(stored);
+	const type = (columnType ?? "").toUpperCase();
+	if (type === "TIMESTAMP") {
+		if (exactStoredTimestamp === void 0) return false;
+		const a = timestampMicros(next);
+		const b = timestampMicros(exactStoredTimestamp, true);
+		return a !== void 0 && b !== void 0 && a === b;
+	}
+	if (type === "JSON") {
+		const a = canonicalJson(next);
+		const b = canonicalJson(stored);
+		return a !== void 0 && b !== void 0 && a === b;
+	}
+	if (typeof next === "string" && typeof stored === "string") {
+		if (type === "UUID" && UUID_PATTERN.test(next) && UUID_PATTERN.test(stored)) return next.toLowerCase() === stored.toLowerCase();
+		return next === stored;
+	}
+	if (typeof next === "boolean" && typeof stored === "boolean") return next === stored;
+	const numeric = (value) => typeof value === "bigint" || typeof value === "number" ? value : void 0;
+	const a = numeric(next);
+	const b = numeric(stored);
+	if (a !== void 0 && b !== void 0) return a == b;
+	return false;
+}
+/**
+* `TIMESTAMP` columns of `data` whose equality needs the stored value at full
+* precision (see {@link storedValueEquals}); the caller reads them as text.
+*/
+function timestampColumnsToProve(data, stored, indexedColumns, columnTypes) {
+	return Object.keys(data).filter((column) => !ALWAYS_ASSIGNED.has(column) && indexedColumns.has(column) && Object.hasOwn(stored, column) && !isNullish(data[column]) && !isNullish(stored[column]) && (columnTypes[column]?.type ?? "").toUpperCase() === "TIMESTAMP");
+}
+/**
+* Indexed columns of `data` whose value provably equals the stored row's, in
+* snake_case column names. `id` and `updated_at` are never reported: the
+* revision token always advances, and `id` is the write's key.
+*/
+function unchangedIndexedColumns(data, stored, indexedColumns, columnTypes, exactTimestamps = {}) {
+	const unchanged = /* @__PURE__ */ new Set();
+	for (const [column, value] of Object.entries(data)) {
+		if (ALWAYS_ASSIGNED.has(column) || !indexedColumns.has(column)) continue;
+		if (!Object.hasOwn(stored, column)) continue;
+		if (storedValueEquals(columnTypes[column]?.type, value, stored[column], exactTimestamps[column])) unchanged.add(column);
+	}
+	return unchanged;
+}
+/**
+* An id-targeted `UPDATE` for native DuckDB, with every identifier quoted and
+* every value bound the way the DuckDB adapter's `upsert()` binds its
+* `DO UPDATE SET` values: `NULL` literals, `''` cast to TEXT, dates as ISO
+* strings, arrays and plain objects as JSON text.
+*
+* The adapter's generic `update()` is not used because it renders column names
+* unquoted (a column named `order` or `group` is a syntax error) and hands
+* dates and structures to the driver untouched; the `upsert()` it replaces
+* handled both.
+*/
+function buildDuckDbIdUpdate(table, id, assignments) {
+	const quote = (identifier) => `"${identifier.replaceAll("\"", "\"\"")}"`;
+	const values = [];
+	const sets = [];
+	for (const [column, value] of Object.entries(assignments)) {
+		let expression;
+		if (value === null || value === void 0) expression = "NULL";
+		else if (value === "") {
+			values.push(value);
+			expression = "CAST(? AS TEXT)";
+		} else if (value instanceof Date) {
+			values.push(value.toISOString());
+			expression = "?";
+		} else if (Array.isArray(value) || typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+			values.push(JSON.stringify(value));
+			expression = "CAST(? AS JSON)";
+		} else {
+			values.push(value);
+			expression = "?";
+		}
+		sets.push(`${quote(column)} = ${expression}`);
+	}
+	values.push(id);
+	return {
+		sql: `UPDATE ${quote(table)} SET ${sets.join(", ")} WHERE ${quote("id")} = ?`,
+		values
+	};
+}
+//#endregion
+export { buildDuckDbIdUpdate, collectIndexedColumns, jsonNumbersRoundTrip, storedValueEquals, timestampColumnsToProve, timestampMicros, unchangedIndexedColumns };
+
+//# sourceMappingURL=unchanged-indexed.js.map

package/dist/unchanged-indexed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unchanged-indexed.js","names":[],"sources":["../src/unchanged-indexed.ts"],"sourcesContent":["/**\n * Unchanged indexed assignments on persisted rows (#3737).\n *\n * DuckDB rewrites a row (delete + insert) when an INDEXED column is assigned,\n * even with its existing value. A parent that a foreign key still references\n * therefore raises a referenced-parent violation for `SET slug = <same slug>`.\n * `SmrtObject.save()` serializes the whole model, so every existing-row write\n * used to assign `slug`, `context`, `tenant_id`, `created_at`, ... unchanged.\n *\n * This module holds the pure decisions: which columns are indexed, whether a\n * pending value provably equals the stored one, and how an assignment value\n * is bound by the generic UPDATE API. Nothing here touches a database, so the\n * save path keeps owning revision checks, tenant isolation and error typing.\n *\n * Everything errs toward \"assign as before\": an unknown column, a missing\n * stored value or a value that cannot be compared is NOT reported unchanged.\n */\n\nimport type { SchemaDefinition } from './schema/types.js';\nimport { toSnakeCase } from './utils';\n\n/** Columns the save path always writes, whatever their stored value. */\nconst ALWAYS_ASSIGNED = new Set(['id', 'updated_at']);\n\n/**\n * Columns whose assignment DuckDB may treat as an index rewrite.\n *\n * The union of what the registry schema declares (primary key, UNIQUE, every\n * declared index including partial and JSON-path ones, foreign keys) and the\n * natural-key / ownership columns the runtime itself keys writes by. Being\n * over-inclusive is harmless — a column is only skipped when it is also proven\n * unchanged — so this never has to be an exact model of the physical DDL.\n */\nexport function collectIndexedColumns(\n  schemas: ReadonlyArray<SchemaDefinition | undefined>,\n  runtimeKeyColumns: Iterable<string>,\n): Set<string> {\n  const indexed = new Set<string>();\n  for (const column of runtimeKeyColumns) {\n    // Only camelCase field names need mapping; `toSnakeCase` would strip the\n    // leading underscore of `_meta_type`.\n    indexed.add(/[A-Z]/u.test(column) ? toSnakeCase(column) : column);\n  }\n  for (const schema of schemas) {\n    if (!schema) continue;\n    for (const [name, column] of Object.entries(schema.columns ?? {})) {\n      if (column.primaryKey || column.unique || column.foreignKey) {\n        indexed.add(name);\n      }\n    }\n    for (const index of schema.indexes ?? []) {\n      for (const name of index.columns ?? []) indexed.add(name);\n      if (index.jsonPath?.column) indexed.add(index.jsonPath.column);\n    }\n    for (const foreignKey of schema.foreignKeys ?? []) {\n      indexed.add(foreignKey.column);\n    }\n  }\n  return indexed;\n}\n\nconst UUID_PATTERN =\n  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;\nconst TIMESTAMP_TEXT =\n  /^(\\d{4})-(\\d{2})-(\\d{2})[T ](\\d{2}):(\\d{2}):(\\d{2})(?:\\.(\\d+))?\\s*(Z|[+-]\\d{2}(?::?\\d{2})?)?$/iu;\n\nfunction isNullish(value: unknown): value is null | undefined {\n  return value === null || value === undefined;\n}\n\n/**\n * An instant as whole microseconds since the epoch, or `undefined` when it\n * cannot be established exactly.\n *\n * A `Date` holds milliseconds. Text is read at its full written precision;\n * digits beyond microseconds must be zero. Text without a zone is a wall\n * clock in the process zone unless `naiveIsUtc` (DuckDB's `TIMESTAMP` text,\n * which this runtime always writes as UTC).\n */\nexport function timestampMicros(\n  value: unknown,\n  naiveIsUtc = false,\n): bigint | undefined {\n  if (value instanceof Date) {\n    const time = value.getTime();\n    return Number.isNaN(time) ? undefined : BigInt(time) * 1000n;\n  }\n  if (typeof value !== 'string') return undefined;\n  const match = TIMESTAMP_TEXT.exec(value.trim());\n  if (!match) return undefined;\n  const [, year, month, day, hour, minute, second, fraction = '', zone] = match;\n  if (fraction.length > 6 && /[1-9]/u.test(fraction.slice(6))) return undefined;\n  if (zone === undefined && !naiveIsUtc) return undefined;\n  // `Date.UTC` maps years 0-99 onto 1900-1999; set the literal year instead.\n  const date = new Date(0);\n  date.setUTCFullYear(Number(year), Number(month) - 1, Number(day));\n  date.setUTCHours(Number(hour), Number(minute), Number(second), 0);\n  const wall = date.getTime();\n  if (Number.isNaN(wall)) return undefined;\n  // Date rolls impossible fields over (month 13, minute 60, Feb 30); a field\n  // that does not survive the round trip makes the text unprovable.\n  if (\n    date.getUTCFullYear() !== Number(year) ||\n    date.getUTCMonth() !== Number(month) - 1 ||\n    date.getUTCDate() !== Number(day) ||\n    date.getUTCHours() !== Number(hour) ||\n    date.getUTCMinutes() !== Number(minute) ||\n    date.getUTCSeconds() !== Number(second)\n  ) {\n    return undefined;\n  }\n  let offsetMinutes = 0;\n  if (zone && zone.toUpperCase() !== 'Z') {\n    const digits = zone.slice(1).replace(':', '');\n    const offsetHours = Number(digits.slice(0, 2));\n    const offsetRest = Number(digits.slice(2) || '0');\n    if (offsetHours > 23 || offsetRest > 59) return undefined;\n    offsetMinutes =\n      (zone.startsWith('-') ? -1 : 1) * (offsetHours * 60 + offsetRest);\n  }\n  const micros = BigInt(fraction.slice(0, 6).padEnd(6, '0'));\n  return (BigInt(wall) - BigInt(offsetMinutes) * 60000n) * 1000n + micros;\n}\n\nconst JSON_NUMBER = /-?\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?/y;\n\n/**\n * Whether every number literal in JSON text survives `JSON.parse` exactly.\n *\n * `JSON.parse` reads numbers as doubles, so `9007199254740993` and\n * `9007199254740992` parse to the same value. A literal is exact when the\n * double it parses to prints back as the same text; anything else (unsafe\n * integers, more digits than a double holds, `1.0`, `1e2`) makes the text\n * unprovable. Digits inside JSON strings are not numbers and are skipped.\n */\nexport function jsonNumbersRoundTrip(text: string): boolean {\n  let inString = false;\n  for (let index = 0; index < text.length; index += 1) {\n    const char = text[index];\n    if (inString) {\n      if (char === '\\\\') index += 1;\n      else if (char === '\"') inString = false;\n      continue;\n    }\n    if (char === '\"') {\n      inString = true;\n      continue;\n    }\n    if (char === '-' || (char >= '0' && char <= '9')) {\n      JSON_NUMBER.lastIndex = index;\n      const match = JSON_NUMBER.exec(text);\n      if (!match) return false;\n      const literal = match[0];\n      if (JSON.stringify(Number(literal)) !== literal) return false;\n      index += literal.length - 1;\n    }\n  }\n  return true;\n}\n\nfunction canonicalJson(value: unknown): string | undefined {\n  let parsed = value;\n  if (typeof value === 'string') {\n    if (!jsonNumbersRoundTrip(value)) return undefined;\n    try {\n      parsed = JSON.parse(value);\n    } catch {\n      return undefined;\n    }\n  }\n  const normalize = (node: unknown): unknown => {\n    if (Array.isArray(node)) return node.map(normalize);\n    if (node !== null && typeof node === 'object') {\n      return Object.fromEntries(\n        Object.entries(node as Record<string, unknown>)\n          .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n          .map(([key, child]) => [key, normalize(child)]),\n      );\n    }\n    return node;\n  };\n  try {\n    return JSON.stringify(normalize(parsed));\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Whether `next` (the value about to be written) provably equals `stored`\n * (the canonical value read back from the row). `false` means \"assign it\":\n * either it differs or equality cannot be established.\n */\nexport function storedValueEquals(\n  columnType: string | undefined,\n  next: unknown,\n  stored: unknown,\n  exactStoredTimestamp?: string,\n): boolean {\n  if (isNullish(next) || isNullish(stored)) {\n    return isNullish(next) && isNullish(stored);\n  }\n  const type = (columnType ?? '').toUpperCase();\n  if (type === 'TIMESTAMP') {\n    // A hydrated `Date` has already lost anything below the millisecond, so\n    // only the stored value as the database writes it can prove equality.\n    if (exactStoredTimestamp === undefined) return false;\n    const a = timestampMicros(next);\n    const b = timestampMicros(exactStoredTimestamp, true);\n    return a !== undefined && b !== undefined && a === b;\n  }\n  if (type === 'JSON') {\n    const a = canonicalJson(next);\n    const b = canonicalJson(stored);\n    return a !== undefined && b !== undefined && a === b;\n  }\n  if (typeof next === 'string' && typeof stored === 'string') {\n    if (\n      type === 'UUID' &&\n      UUID_PATTERN.test(next) &&\n      UUID_PATTERN.test(stored)\n    ) {\n      return next.toLowerCase() === stored.toLowerCase();\n    }\n    return next === stored;\n  }\n  if (typeof next === 'boolean' && typeof stored === 'boolean') {\n    return next === stored;\n  }\n  const numeric = (value: unknown): bigint | number | undefined =>\n    typeof value === 'bigint' || typeof value === 'number' ? value : undefined;\n  const a = numeric(next);\n  const b = numeric(stored);\n  if (a !== undefined && b !== undefined) {\n    // biome-ignore lint/suspicious/noDoubleEquals: bigint/number cross-type value equality is the point.\n    return a == b;\n  }\n  return false;\n}\n\n/**\n * `TIMESTAMP` columns of `data` whose equality needs the stored value at full\n * precision (see {@link storedValueEquals}); the caller reads them as text.\n */\nexport function timestampColumnsToProve(\n  data: Readonly<Record<string, unknown>>,\n  stored: Readonly<Record<string, unknown>>,\n  indexedColumns: ReadonlySet<string>,\n  columnTypes: Readonly<Record<string, { type?: string } | undefined>>,\n): string[] {\n  return Object.keys(data).filter(\n    (column) =>\n      !ALWAYS_ASSIGNED.has(column) &&\n      indexedColumns.has(column) &&\n      Object.hasOwn(stored, column) &&\n      !isNullish(data[column]) &&\n      !isNullish(stored[column]) &&\n      (columnTypes[column]?.type ?? '').toUpperCase() === 'TIMESTAMP',\n  );\n}\n\n/**\n * Indexed columns of `data` whose value provably equals the stored row's, in\n * snake_case column names. `id` and `updated_at` are never reported: the\n * revision token always advances, and `id` is the write's key.\n */\nexport function unchangedIndexedColumns(\n  data: Readonly<Record<string, unknown>>,\n  stored: Readonly<Record<string, unknown>>,\n  indexedColumns: ReadonlySet<string>,\n  columnTypes: Readonly<Record<string, { type?: string } | undefined>>,\n  exactTimestamps: Readonly<Record<string, string>> = {},\n): Set<string> {\n  const unchanged = new Set<string>();\n  for (const [column, value] of Object.entries(data)) {\n    if (ALWAYS_ASSIGNED.has(column) || !indexedColumns.has(column)) continue;\n    // A column the stored row does not carry cannot be compared.\n    if (!Object.hasOwn(stored, column)) continue;\n    if (\n      storedValueEquals(\n        columnTypes[column]?.type,\n        value,\n        stored[column],\n        exactTimestamps[column],\n      )\n    ) {\n      unchanged.add(column);\n    }\n  }\n  return unchanged;\n}\n\n/**\n * An id-targeted `UPDATE` for native DuckDB, with every identifier quoted and\n * every value bound the way the DuckDB adapter's `upsert()` binds its\n * `DO UPDATE SET` values: `NULL` literals, `''` cast to TEXT, dates as ISO\n * strings, arrays and plain objects as JSON text.\n *\n * The adapter's generic `update()` is not used because it renders column names\n * unquoted (a column named `order` or `group` is a syntax error) and hands\n * dates and structures to the driver untouched; the `upsert()` it replaces\n * handled both.\n */\nexport function buildDuckDbIdUpdate(\n  table: string,\n  id: unknown,\n  assignments: Readonly<Record<string, unknown>>,\n): { sql: string; values: unknown[] } {\n  const quote = (identifier: string) => `\"${identifier.replaceAll('\"', '\"\"')}\"`;\n  const values: unknown[] = [];\n  const sets: string[] = [];\n  for (const [column, value] of Object.entries(assignments)) {\n    let expression: string;\n    if (value === null || value === undefined) {\n      expression = 'NULL';\n    } else if (value === '') {\n      values.push(value);\n      expression = 'CAST(? AS TEXT)';\n    } else if (value instanceof Date) {\n      values.push(value.toISOString());\n      expression = '?';\n    } else if (\n      Array.isArray(value) ||\n      (typeof value === 'object' &&\n        Object.getPrototypeOf(value) === Object.prototype)\n    ) {\n      values.push(JSON.stringify(value));\n      expression = 'CAST(? AS JSON)';\n    } else {\n      values.push(value);\n      expression = '?';\n    }\n    sets.push(`${quote(column)} = ${expression}`);\n  }\n  values.push(id);\n  return {\n    sql: `UPDATE ${quote(table)} SET ${sets.join(', ')} WHERE ${quote('id')} = ?`,\n    values,\n  };\n}\n"],"mappings":"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"}

package/dist/utils/async-context.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Async-local state that survives `await`, without a static `node:async_hooks`
+ * import (#2838).
+ *
+ * A Node host backs it with `AsyncLocalStorage`, resolved through
+ * `process.getBuiltinModule()` so a browser bundle never reaches the built-in.
+ * Browsers have no equivalent that propagates through promises, so there
+ * `run()` only calls the callback, `getStore()` stays empty, and
+ * `propagatesAcrossAwait` is false. Callers whose correctness needs the
+ * store to reach nested async work (re-entrant locks) must check that flag
+ * and not rely on the store when it is false.
+ */
+export interface AsyncContext<T> {
+    /** Whether a value passed to `run()` reaches async work started inside it. */
+    readonly propagatesAcrossAwait: boolean;
+    /** Run `callback` with `store` visible to `getStore()` for its async extent. */
+    run<R>(store: T, callback: () => R): R;
+    /** The value of the innermost enclosing `run()`, if any. */
+    getStore(): T | undefined;
+}
+export declare function createAsyncContext<T>(): AsyncContext<T>;
+//# sourceMappingURL=async-context.d.ts.map

package/dist/utils/async-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-context.d.ts","sourceRoot":"","sources":["../../src/utils/async-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,8EAA8E;IAC9E,QAAQ,CAAC,qBAAqB,EAAE,OAAO,CAAC;IACxC,gFAAgF;IAChF,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IACvC,4DAA4D;IAC5D,QAAQ,IAAI,CAAC,GAAG,SAAS,CAAC;CAC3B;AAmBD,wBAAgB,kBAAkB,CAAC,CAAC,KAAK,YAAY,CAAC,CAAC,CAAC,CAevD"}

package/dist/utils/async-context.js

@@ -0,0 +1,27 @@
+//#region src/utils/async-context.ts
+function resolveAsyncLocalStorage() {
+	if (typeof process === "undefined") return void 0;
+	const getBuiltinModule = process.getBuiltinModule;
+	if (typeof getBuiltinModule !== "function") return void 0;
+	return getBuiltinModule("node:async_hooks")?.AsyncLocalStorage;
+}
+function createAsyncContext() {
+	const Storage = resolveAsyncLocalStorage();
+	if (Storage) {
+		const storage = new Storage();
+		return {
+			propagatesAcrossAwait: true,
+			run: (store, callback) => storage.run(store, callback),
+			getStore: () => storage.getStore()
+		};
+	}
+	return {
+		propagatesAcrossAwait: false,
+		run: (_store, callback) => callback(),
+		getStore: () => void 0
+	};
+}
+//#endregion
+export { createAsyncContext };
+
+//# sourceMappingURL=async-context.js.map

package/dist/utils/async-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-context.js","names":[],"sources":["../../src/utils/async-context.ts"],"sourcesContent":["/**\n * Async-local state that survives `await`, without a static `node:async_hooks`\n * import (#2838).\n *\n * A Node host backs it with `AsyncLocalStorage`, resolved through\n * `process.getBuiltinModule()` so a browser bundle never reaches the built-in.\n * Browsers have no equivalent that propagates through promises, so there\n * `run()` only calls the callback, `getStore()` stays empty, and\n * `propagatesAcrossAwait` is false. Callers whose correctness needs the\n * store to reach nested async work (re-entrant locks) must check that flag\n * and not rely on the store when it is false.\n */\n\nexport interface AsyncContext<T> {\n  /** Whether a value passed to `run()` reaches async work started inside it. */\n  readonly propagatesAcrossAwait: boolean;\n  /** Run `callback` with `store` visible to `getStore()` for its async extent. */\n  run<R>(store: T, callback: () => R): R;\n  /** The value of the innermost enclosing `run()`, if any. */\n  getStore(): T | undefined;\n}\n\ntype AsyncLocalStorageConstructor = new <T>() => {\n  run<R>(store: T, callback: () => R): R;\n  getStore(): T | undefined;\n};\n\nfunction resolveAsyncLocalStorage(): AsyncLocalStorageConstructor | undefined {\n  if (typeof process === 'undefined') return undefined;\n  const getBuiltinModule = (\n    process as typeof process & { getBuiltinModule?: (id: string) => unknown }\n  ).getBuiltinModule;\n  if (typeof getBuiltinModule !== 'function') return undefined;\n  const hooks = getBuiltinModule('node:async_hooks') as\n    | { AsyncLocalStorage?: AsyncLocalStorageConstructor }\n    | undefined;\n  return hooks?.AsyncLocalStorage;\n}\n\nexport function createAsyncContext<T>(): AsyncContext<T> {\n  const Storage = resolveAsyncLocalStorage();\n  if (Storage) {\n    const storage = new Storage<T>();\n    return {\n      propagatesAcrossAwait: true,\n      run: (store, callback) => storage.run(store, callback),\n      getStore: () => storage.getStore(),\n    };\n  }\n  return {\n    propagatesAcrossAwait: false,\n    run: (_store, callback) => callback(),\n    getStore: () => undefined,\n  };\n}\n"],"mappings":";AA2BA,SAAS,2BAAqE;CAC5E,IAAI,OAAO,YAAY,aAAa,OAAO,KAAA;CAC3C,MAAM,mBACJ,QACA;CACF,IAAI,OAAO,qBAAqB,YAAY,OAAO,KAAA;CAInD,OAHc,iBAAiB,kBAGxB,CAAA,EAAO;AAChB;AAEA,SAAgB,qBAAyC;CACvD,MAAM,UAAU,yBAAyB;CACzC,IAAI,SAAS;EACX,MAAM,UAAU,IAAI,QAAW;EAC/B,OAAO;GACL,uBAAuB;GACvB,MAAM,OAAO,aAAa,QAAQ,IAAI,OAAO,QAAQ;GACrD,gBAAgB,QAAQ,SAAS;EACnC;CACF;CACA,OAAO;EACL,uBAAuB;EACvB,MAAM,QAAQ,aAAa,SAAS;EACpC,gBAAgB,KAAA;CAClB;AACF"}

package/dist/utils/import-project-vite.js

@@ -1,6 +1,6 @@
+import { dirname, join, resolve } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 //#region src/utils/import-project-vite.ts
 /** Picks the ESM entry of a package `exports["."]` target (string or conditions). */

package/dist/utils/import-workspace-module.js

@@ -1,5 +1,5 @@
-import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { existsSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 //#region src/utils/import-workspace-module.ts
 function findWorkspaceRoot(startDir) {

package/dist/utils/json.browser.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Browser build of `json.ts` (#2838): selected through `package.json#browser`.
+ *
+ * `json.ts` asks `@happyvertical/json` for an adapter, and that package's
+ * SIMD adapter loader reaches `node:module`, `node:path` and `node:url`. A
+ * page has no SIMD adapter to pick, so this build is the native `JSON`
+ * implementation `json.ts` already falls back to. Typed against `json.ts`,
+ * so the two cannot drift.
+ */
+import type * as NodeJson from './json.js';
+export declare const parse: typeof NodeJson.parse;
+export declare const stringify: typeof NodeJson.stringify;
+export declare const clone: typeof NodeJson.clone;
+export declare const safeParse: typeof NodeJson.safeParse;
+export declare const safeStringify: typeof NodeJson.safeStringify;
+export declare const isValid: typeof NodeJson.isValid;
+export declare const getAdapterInfo: typeof NodeJson.getAdapterInfo;
+//# sourceMappingURL=json.browser.d.ts.map

package/dist/utils/json.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.browser.d.ts","sourceRoot":"","sources":["../../src/utils/json.browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,KAAK,QAAQ,MAAM,WAAW,CAAC;AAE3C,eAAO,MAAM,KAAK,EAAE,OAAO,QAAQ,CAAC,KACb,CAAC;AAExB,eAAO,MAAM,SAAS,EAAE,OAAO,QAAQ,CAAC,SAKrC,CAAC;AAEJ,eAAO,MAAM,KAAK,EAAE,OAAO,QAAQ,CAAC,KACI,CAAC;AAEzC,eAAO,MAAM,SAAS,EAAE,OAAO,QAAQ,CAAC,SAavC,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,OAAO,QAAQ,CAAC,aAW3C,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,OAAO,QAAQ,CAAC,OAOrC,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,OAAO,QAAQ,CAAC,cAI3C,CAAC"}

package/dist/utils/json.browser.js

@@ -0,0 +1,47 @@
+//#region src/utils/json.browser.ts
+var parse = (text) => JSON.parse(text);
+var stringify = (value, replacer, space) => JSON.stringify(value, replacer, space);
+var clone = (value) => JSON.parse(JSON.stringify(value));
+var safeParse = (text) => {
+	try {
+		return {
+			success: true,
+			value: JSON.parse(text)
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: { message: error instanceof Error ? error.message : String(error) }
+		};
+	}
+};
+var safeStringify = (value) => {
+	try {
+		return {
+			success: true,
+			value: JSON.stringify(value)
+		};
+	} catch (error) {
+		return {
+			success: false,
+			error: { message: error instanceof Error ? error.message : String(error) }
+		};
+	}
+};
+var isValid = (text) => {
+	try {
+		JSON.parse(text);
+		return true;
+	} catch {
+		return false;
+	}
+};
+var getAdapterInfo = () => ({
+	name: "native",
+	isNative: true,
+	simdEnabled: false
+});
+//#endregion
+export { clone, getAdapterInfo, isValid, parse, safeParse, safeStringify, stringify };
+
+//# sourceMappingURL=json.browser.js.map

package/dist/utils/json.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.browser.js","names":[],"sources":["../../src/utils/json.browser.ts"],"sourcesContent":["/**\n * Browser build of `json.ts` (#2838): selected through `package.json#browser`.\n *\n * `json.ts` asks `@happyvertical/json` for an adapter, and that package's\n * SIMD adapter loader reaches `node:module`, `node:path` and `node:url`. A\n * page has no SIMD adapter to pick, so this build is the native `JSON`\n * implementation `json.ts` already falls back to. Typed against `json.ts`,\n * so the two cannot drift.\n */\nimport type * as NodeJson from './json.js';\n\nexport const parse: typeof NodeJson.parse = <T = unknown>(text: string): T =>\n  JSON.parse(text) as T;\n\nexport const stringify: typeof NodeJson.stringify = (value, replacer, space) =>\n  JSON.stringify(\n    value,\n    replacer as Parameters<typeof JSON.stringify>[1],\n    space,\n  );\n\nexport const clone: typeof NodeJson.clone = <T>(value: T): T =>\n  JSON.parse(JSON.stringify(value)) as T;\n\nexport const safeParse: typeof NodeJson.safeParse = <T = unknown>(\n  text: string,\n) => {\n  try {\n    return { success: true, value: JSON.parse(text) as T } as const;\n  } catch (error) {\n    return {\n      success: false,\n      error: {\n        message: error instanceof Error ? error.message : String(error),\n      },\n    } as const;\n  }\n};\n\nexport const safeStringify: typeof NodeJson.safeStringify = (value) => {\n  try {\n    return { success: true, value: JSON.stringify(value) } as const;\n  } catch (error) {\n    return {\n      success: false,\n      error: {\n        message: error instanceof Error ? error.message : String(error),\n      },\n    } as const;\n  }\n};\n\nexport const isValid: typeof NodeJson.isValid = (text) => {\n  try {\n    JSON.parse(text);\n    return true;\n  } catch {\n    return false;\n  }\n};\n\nexport const getAdapterInfo: typeof NodeJson.getAdapterInfo = () => ({\n  name: 'native',\n  isNative: true,\n  simdEnabled: false,\n});\n"],"mappings":";AAWA,IAAa,SAA6C,SACxD,KAAK,MAAM,IAAI;AAEjB,IAAa,aAAwC,OAAO,UAAU,UACpE,KAAK,UACH,OACA,UACA,KACF;AAEF,IAAa,SAAmC,UAC9C,KAAK,MAAM,KAAK,UAAU,KAAK,CAAC;AAElC,IAAa,aACX,SACG;CACH,IAAI;EACF,OAAO;GAAE,SAAS;GAAM,OAAO,KAAK,MAAM,IAAI;EAAO;CACvD,SAAS,OAAO;EACd,OAAO;GACL,SAAS;GACT,OAAO,EACL,SAAS,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,EAChE;EACF;CACF;AACF;AAEA,IAAa,iBAAgD,UAAU;CACrE,IAAI;EACF,OAAO;GAAE,SAAS;GAAM,OAAO,KAAK,UAAU,KAAK;EAAE;CACvD,SAAS,OAAO;EACd,OAAO;GACL,SAAS;GACT,OAAO,EACL,SAAS,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,EAChE;EACF;CACF;AACF;AAEA,IAAa,WAAoC,SAAS;CACxD,IAAI;EACF,KAAK,MAAM,IAAI;EACf,OAAO;CACT,QAAQ;EACN,OAAO;CACT;AACF;AAEA,IAAa,wBAAwD;CACnE,MAAM;CACN,UAAU;CACV,aAAa;AACf"}

package/dist/utils/sha256.d.ts

@@ -0,0 +1,15 @@
+/**
+ * SHA-256 of `text` (UTF-8) as lowercase hex.
+ *
+ * Synchronous and free of `node:crypto`, so the schema, registry and
+ * embedding paths that fingerprint strings load in a browser (#2838). The
+ * digest is identical to `createHash('sha256').update(text).digest('hex')`;
+ * `sha256.test.ts` pins that against Node's implementation.
+ */
+export declare function sha256Hex(text: string): string;
+/**
+ * SHA-256 of `text` (UTF-8) as unpadded base64url, identical to
+ * `createHash('sha256').update(text).digest('base64url')`.
+ */
+export declare function sha256Base64Url(text: string): string;
+//# sourceMappingURL=sha256.d.ts.map

package/dist/utils/sha256.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.d.ts","sourceRoot":"","sources":["../../src/utils/sha256.ts"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQpD"}

package/dist/utils/sha256.js

@@ -0,0 +1,29 @@
+import { bytesToHex } from "../node_modules/.pnpm/@noble_hashes@2.4.0/node_modules/@noble/hashes/utils.js";
+import { sha256 } from "../node_modules/.pnpm/@noble_hashes@2.4.0/node_modules/@noble/hashes/sha2.js";
+//#region src/utils/sha256.ts
+var encoder = new TextEncoder();
+/**
+* SHA-256 of `text` (UTF-8) as lowercase hex.
+*
+* Synchronous and free of `node:crypto`, so the schema, registry and
+* embedding paths that fingerprint strings load in a browser (#2838). The
+* digest is identical to `createHash('sha256').update(text).digest('hex')`;
+* `sha256.test.ts` pins that against Node's implementation.
+*/
+function sha256Hex(text) {
+	return bytesToHex(sha256(encoder.encode(text)));
+}
+/**
+* SHA-256 of `text` (UTF-8) as unpadded base64url, identical to
+* `createHash('sha256').update(text).digest('base64url')`.
+*/
+function sha256Base64Url(text) {
+	const bytes = sha256(encoder.encode(text));
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+//#endregion
+export { sha256Base64Url, sha256Hex };
+
+//# sourceMappingURL=sha256.js.map

package/dist/utils/sha256.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.js","names":[],"sources":["../../src/utils/sha256.ts"],"sourcesContent":["import { sha256 } from '@noble/hashes/sha2.js';\nimport { bytesToHex } from '@noble/hashes/utils.js';\n\nconst encoder = new TextEncoder();\n\n/**\n * SHA-256 of `text` (UTF-8) as lowercase hex.\n *\n * Synchronous and free of `node:crypto`, so the schema, registry and\n * embedding paths that fingerprint strings load in a browser (#2838). The\n * digest is identical to `createHash('sha256').update(text).digest('hex')`;\n * `sha256.test.ts` pins that against Node's implementation.\n */\nexport function sha256Hex(text: string): string {\n  return bytesToHex(sha256(encoder.encode(text)));\n}\n\n/**\n * SHA-256 of `text` (UTF-8) as unpadded base64url, identical to\n * `createHash('sha256').update(text).digest('base64url')`.\n */\nexport function sha256Base64Url(text: string): string {\n  const bytes = sha256(encoder.encode(text));\n  let binary = '';\n  for (const byte of bytes) binary += String.fromCharCode(byte);\n  return btoa(binary)\n    .replace(/\\+/g, '-')\n    .replace(/\\//g, '_')\n    .replace(/=+$/, '');\n}\n"],"mappings":";;;AAGA,IAAM,UAAU,IAAI,YAAY;;;;;;;;;AAUhC,SAAgB,UAAU,MAAsB;CAC9C,OAAO,WAAW,OAAO,QAAQ,OAAO,IAAI,CAAC,CAAC;AAChD;;;;;AAMA,SAAgB,gBAAgB,MAAsB;CACpD,MAAM,QAAQ,OAAO,QAAQ,OAAO,IAAI,CAAC;CACzC,IAAI,SAAS;CACb,KAAK,MAAM,QAAQ,OAAO,UAAU,OAAO,aAAa,IAAI;CAC5D,OAAO,KAAK,MAAM,CAAC,CAChB,QAAQ,OAAO,GAAG,CAAC,CACnB,QAAQ,OAAO,GAAG,CAAC,CACnB,QAAQ,OAAO,EAAE;AACtB"}

package/dist/vite-plugin/changes-route.js

@@ -1,7 +1,7 @@
 import { AUTO_GENERATED_ROUTE_HEADER } from "./route-header.js";
 import { generateCollectionAccessImports } from "./sveltekit-config-import.js";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 //#region src/vite-plugin/changes-route.ts
 /**
 * SvelteKit `_changes` route generation for the change feed (issue #1758).

package/dist/vite-plugin/dev-plane-route.js

@@ -1,8 +1,8 @@
 import { AUTO_GENERATED_ROUTE_HEADER } from "./route-header.js";
 import { generateCollectionAccessImports } from "./sveltekit-config-import.js";
+import { join } from "node:path";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 //#region src/vite-plugin/dev-plane-route.ts
 /**

package/dist/vite-plugin/events-route.js

@@ -1,8 +1,8 @@
 import { AUTO_GENERATED_ROUTE_HEADER } from "./route-header.js";
 import { generateCollectionAccessImports } from "./sveltekit-config-import.js";
 import { manifestHasTenantScopedObject, resolveAnchorClassName } from "./changes-route.js";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 //#region src/vite-plugin/events-route.ts
 /**
 * SvelteKit `_events` route generation — live change signals (issue #1763,

package/dist/vite-plugin/import-build-aware.js

@@ -1,6 +1,6 @@
+import { dirname, extname, resolve } from "node:path";
 import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname, extname, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 //#region src/vite-plugin/import-build-aware.ts
 /**