@prisma-next/utils 0.5.0-dev.7 → 0.5.0-dev.70

package/dist/abortable.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"abortable.d.mts","names":[],"sources":["../src/abortable.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;;;;;;;;;;;;;;;;;iBAAgB,SAAA,SAAkB,2BAA2B,QAAQ,OAAO,QAAQ"}
+{"version":3,"file":"abortable.d.mts","names":[],"sources":["../src/abortable.ts"],"mappings":";;AAuBA;;;;;;;;;;;;;;;;;;;;;;iBAAgB,SAAA,CAAU,MAAA,EAAQ,WAAA,OAAkB,OAAA,EAAS,OAAA,CAAQ,CAAA,MAAO,OAAA,CAAQ,CAAA"}

package/dist/abortable.mjs

@@ -33,7 +33,7 @@ function abortable(signal) {
 		return Promise.race([operation, abortPromise]);
 	};
 }
-
 //#endregion
 export { abortable };
+
 //# sourceMappingURL=abortable.mjs.map

package/dist/abortable.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"abortable.mjs","names":[],"sources":["../src/abortable.ts"],"sourcesContent":["/**\n * Allows aborting an async operation by returning a Promise which rejects if\n * the provided AbortSignal aborts and otherwise resolves with the result of\n * the async operation.\n *\n * Throws immediately if the signal is already aborted.\n * When the signal is aborted later, any wrapped promise will reject with\n * the signal's reason (or a default DOMException).\n *\n * @example\n * ```typescript\n * const { signal = new AbortController().signal } = options;\n * const unlessAborted = abortable(signal);\n *\n * // Any of these will reject if signal is aborted\n * await unlessAborted(asyncOperation());\n * await unlessAborted(fetch(url));\n * ```\n *\n * @param signal - The AbortSignal to race against\n * @returns A function that wraps promises to be cancelable\n * @throws If signal is already aborted\n */\nexport function abortable(signal: AbortSignal): <T>(promise: Promise<T>) => Promise<T> {\n  signal.throwIfAborted();\n\n  const abortPromise = new Promise<never>((_resolve, reject) => {\n    signal.addEventListener(\n      'abort',\n      () => {\n        reject(signal.reason ?? new DOMException('Operation cancelled'));\n      },\n      { once: true },\n    );\n  });\n\n  return <T>(operation: Promise<T>): Promise<T> => {\n    return Promise.race([operation, abortPromise]);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,UAAU,QAA6D;AACrF,QAAO,gBAAgB;CAEvB,MAAM,eAAe,IAAI,SAAgB,UAAU,WAAW;AAC5D,SAAO,iBACL,eACM;AACJ,UAAO,OAAO,UAAU,IAAI,aAAa,sBAAsB,CAAC;KAElE,EAAE,MAAM,MAAM,CACf;GACD;AAEF,SAAW,cAAsC;AAC/C,SAAO,QAAQ,KAAK,CAAC,WAAW,aAAa,CAAC"}
+{"version":3,"file":"abortable.mjs","names":[],"sources":["../src/abortable.ts"],"sourcesContent":["/**\n * Allows aborting an async operation by returning a Promise which rejects if\n * the provided AbortSignal aborts and otherwise resolves with the result of\n * the async operation.\n *\n * Throws immediately if the signal is already aborted.\n * When the signal is aborted later, any wrapped promise will reject with\n * the signal's reason (or a default DOMException).\n *\n * @example\n * ```typescript\n * const { signal = new AbortController().signal } = options;\n * const unlessAborted = abortable(signal);\n *\n * // Any of these will reject if signal is aborted\n * await unlessAborted(asyncOperation());\n * await unlessAborted(fetch(url));\n * ```\n *\n * @param signal - The AbortSignal to race against\n * @returns A function that wraps promises to be cancelable\n * @throws If signal is already aborted\n */\nexport function abortable(signal: AbortSignal): <T>(promise: Promise<T>) => Promise<T> {\n  signal.throwIfAborted();\n\n  const abortPromise = new Promise<never>((_resolve, reject) => {\n    signal.addEventListener(\n      'abort',\n      () => {\n        reject(signal.reason ?? new DOMException('Operation cancelled'));\n      },\n      { once: true },\n    );\n  });\n\n  return <T>(operation: Promise<T>): Promise<T> => {\n    return Promise.race([operation, abortPromise]);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,UAAU,QAA6D;CACrF,OAAO,gBAAgB;CAEvB,MAAM,eAAe,IAAI,SAAgB,UAAU,WAAW;EAC5D,OAAO,iBACL,eACM;GACJ,OAAO,OAAO,UAAU,IAAI,aAAa,sBAAsB,CAAC;KAElE,EAAE,MAAM,MAAM,CACf;GACD;CAEF,QAAW,cAAsC;EAC/C,OAAO,QAAQ,KAAK,CAAC,WAAW,aAAa,CAAC"}

package/dist/array-equal.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"array-equal.d.mts","names":[],"sources":["../src/array-equal.ts"],"sourcesContent":[],"mappings":";;AAgBA;;;;;;;;;;;;;;;iBAAgB,4BAA4B,iBAAiB"}
+{"version":3,"file":"array-equal.d.mts","names":[],"sources":["../src/array-equal.ts"],"mappings":";;AAgBA;;;;;;;;;;;;;;;iBAAgB,YAAA,GAAA,CAAgB,CAAA,WAAY,CAAA,IAAK,CAAA,WAAY,CAAA"}

package/dist/array-equal.mjs

@@ -20,7 +20,7 @@ function isArrayEqual(a, b) {
 	for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
 	return true;
 }
-
 //#endregion
 export { isArrayEqual };
+
 //# sourceMappingURL=array-equal.mjs.map

package/dist/array-equal.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"array-equal.mjs","names":[],"sources":["../src/array-equal.ts"],"sourcesContent":["/**\n * Checks if two arrays are equal using Object.is() for element comparison.\n * Arrays are considered equal if they have the same length and each element\n * at corresponding indices is equal according to Object.is().\n *\n * @param a - First array to compare\n * @param b - Second array to compare\n * @returns true if arrays are equal, false otherwise\n *\n * @example\n * ```typescript\n * isArrayEqual(['a', 'b'], ['a', 'b']); // true\n * isArrayEqual(['a'], ['a', 'b']); // false\n * isArrayEqual([0], [-0]); // false (Object.is distinguishes +0 and -0)\n * ```\n */\nexport function isArrayEqual<T>(a: readonly T[], b: readonly T[]): boolean {\n  if (a.length !== b.length) {\n    return false;\n  }\n  for (let i = 0; i < a.length; i++) {\n    if (!Object.is(a[i], b[i])) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,SAAgB,aAAgB,GAAiB,GAA0B;AACzE,KAAI,EAAE,WAAW,EAAE,OACjB,QAAO;AAET,MAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,IAC5B,KAAI,CAAC,OAAO,GAAG,EAAE,IAAI,EAAE,GAAG,CACxB,QAAO;AAGX,QAAO"}
+{"version":3,"file":"array-equal.mjs","names":[],"sources":["../src/array-equal.ts"],"sourcesContent":["/**\n * Checks if two arrays are equal using Object.is() for element comparison.\n * Arrays are considered equal if they have the same length and each element\n * at corresponding indices is equal according to Object.is().\n *\n * @param a - First array to compare\n * @param b - Second array to compare\n * @returns true if arrays are equal, false otherwise\n *\n * @example\n * ```typescript\n * isArrayEqual(['a', 'b'], ['a', 'b']); // true\n * isArrayEqual(['a'], ['a', 'b']); // false\n * isArrayEqual([0], [-0]); // false (Object.is distinguishes +0 and -0)\n * ```\n */\nexport function isArrayEqual<T>(a: readonly T[], b: readonly T[]): boolean {\n  if (a.length !== b.length) {\n    return false;\n  }\n  for (let i = 0; i < a.length; i++) {\n    if (!Object.is(a[i], b[i])) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,SAAgB,aAAgB,GAAiB,GAA0B;CACzE,IAAI,EAAE,WAAW,EAAE,QACjB,OAAO;CAET,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAC5B,IAAI,CAAC,OAAO,GAAG,EAAE,IAAI,EAAE,GAAG,EACxB,OAAO;CAGX,OAAO"}

package/dist/assertions.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"assertions.d.mts","names":[],"sources":["../src/assertions.ts"],"sourcesContent":[],"mappings":";;AAaA;AAiBA;;;;;;;;;;;iBAjBgB,wBAAwB,yDAAyD;;;;;;;;;;;;iBAiBjF,SAAA"}
+{"version":3,"file":"assertions.d.mts","names":[],"sources":["../src/assertions.ts"],"mappings":";;AAaA;;;;;;;;;;;;iBAAgB,aAAA,GAAA,CAAiB,KAAA,EAAO,CAAA,qBAAsB,OAAA,mBAA0B,KAAA,IAAS,CAAA;;;;;;;;;;;;iBAiBjF,SAAA,CAAU,SAAA,WAAoB,OAAA,mBAA0B,SAAA"}

package/dist/assertions.mjs

@@ -29,7 +29,7 @@ function assertDefined(value, message) {
 function invariant(condition, message) {
 	if (!condition) throw new Error(message);
 }
-
 //#endregion
 export { assertDefined, invariant };
+
 //# sourceMappingURL=assertions.mjs.map

package/dist/assertions.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"assertions.mjs","names":[],"sources":["../src/assertions.ts"],"sourcesContent":["/**\n * Asserts that a value is defined (not null or undefined).\n * Use for invariants where the value should always exist at runtime.\n *\n * @throws Error if value is null or undefined\n *\n * @example\n * ```typescript\n * const table = storage.tables[tableName];\n * assertDefined(table, `Table \"${tableName}\" not found`);\n * // table is now narrowed to non-nullable\n * ```\n */\nexport function assertDefined<T>(value: T | null | undefined, message: string): asserts value is T {\n  if (value === null || value === undefined) {\n    throw new Error(message);\n  }\n}\n\n/**\n * Asserts that a condition is true.\n * Use for invariants that should always hold at runtime.\n *\n * @throws Error if condition is false\n *\n * @example\n * ```typescript\n * invariant(columns.length > 0, 'Primary key must have at least one column');\n * ```\n */\nexport function invariant(condition: boolean, message: string): asserts condition {\n  if (!condition) {\n    throw new Error(message);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,SAAgB,cAAiB,OAA6B,SAAqC;AACjG,KAAI,UAAU,QAAQ,UAAU,OAC9B,OAAM,IAAI,MAAM,QAAQ;;;;;;;;;;;;;AAe5B,SAAgB,UAAU,WAAoB,SAAoC;AAChF,KAAI,CAAC,UACH,OAAM,IAAI,MAAM,QAAQ"}
+{"version":3,"file":"assertions.mjs","names":[],"sources":["../src/assertions.ts"],"sourcesContent":["/**\n * Asserts that a value is defined (not null or undefined).\n * Use for invariants where the value should always exist at runtime.\n *\n * @throws Error if value is null or undefined\n *\n * @example\n * ```typescript\n * const table = storage.tables[tableName];\n * assertDefined(table, `Table \"${tableName}\" not found`);\n * // table is now narrowed to non-nullable\n * ```\n */\nexport function assertDefined<T>(value: T | null | undefined, message: string): asserts value is T {\n  if (value === null || value === undefined) {\n    throw new Error(message);\n  }\n}\n\n/**\n * Asserts that a condition is true.\n * Use for invariants that should always hold at runtime.\n *\n * @throws Error if condition is false\n *\n * @example\n * ```typescript\n * invariant(columns.length > 0, 'Primary key must have at least one column');\n * ```\n */\nexport function invariant(condition: boolean, message: string): asserts condition {\n  if (!condition) {\n    throw new Error(message);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,SAAgB,cAAiB,OAA6B,SAAqC;CACjG,IAAI,UAAU,QAAQ,UAAU,KAAA,GAC9B,MAAM,IAAI,MAAM,QAAQ;;;;;;;;;;;;;AAe5B,SAAgB,UAAU,WAAoB,SAAoC;CAChF,IAAI,CAAC,WACH,MAAM,IAAI,MAAM,QAAQ"}

package/dist/canonical-stringify.d.mts

@@ -0,0 +1,50 @@
+//#region src/canonical-stringify.d.ts
+/**
+ * Produces a deterministic, JSON-like string representation of a value.
+ *
+ * Designed for use as a stable identity / cache key. Two values that are
+ * structurally equivalent — regardless of object key insertion order —
+ * produce the same string. Two values that differ in any meaningful way
+ * (including types that JSON would conflate, like `BigInt(1)` vs `1`)
+ * produce different strings.
+ *
+ * Supported inputs:
+ * - `null`, `undefined` (distinguishable: `null` → `"null"`, `undefined` → `"undefined"`)
+ * - `boolean`, `string`, `number` (including `NaN`, `Infinity`, `-Infinity`)
+ * - `bigint` (suffixed with `n` to disambiguate from `number`)
+ * - `Date` (tagged + ISO string)
+ * - `Buffer` / `Uint8Array` (tagged + hex-encoded as `Bytes(<hex>)`)
+ * - Other `ArrayBuffer` views — `Int8Array`, `Uint16Array`, `Float64Array`,
+ *   `DataView`, etc. (tagged with the constructor name + hex-encoded over
+ *   the underlying bytes, e.g. `Uint16Array(<hex>)`). Note that the bytes
+ *   are read in host byte order, so callers that need cross-platform
+ *   stability for multi-byte typed arrays should normalize endianness
+ *   before passing the value in.
+ * - Arrays (order-preserving)
+ * - Plain objects (key-sorted) — only objects whose prototype is
+ *   `Object.prototype` or `null`. Non-plain objects (`Map`, `Set`,
+ *   `RegExp`, class instances, etc.) are rejected so they cannot silently
+ *   collapse to `{}` and collide with each other.
+ *
+ * Throws on `function`, `symbol`, circular references, non-plain objects,
+ * and objects with symbol-keyed properties (which `Object.keys` would
+ * silently drop). Callers that need to canonicalize any of these must
+ * convert them to a supported representation first.
+ *
+ * The output format is intentionally not JSON: the type tags and BigInt
+ * suffix mean it cannot be round-tripped via `JSON.parse`. The goal is
+ * keying, not serialization.
+ *
+ * @example
+ * ```typescript
+ * canonicalStringify({ a: 1, b: 2 }) === canonicalStringify({ b: 2, a: 1 })
+ * // → true
+ *
+ * canonicalStringify(1n) !== canonicalStringify(1)
+ * // → true
+ * ```
+ */
+declare function canonicalStringify(value: unknown): string;
+//#endregion
+export { canonicalStringify };
+//# sourceMappingURL=canonical-stringify.d.mts.map

package/dist/canonical-stringify.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-stringify.d.mts","names":[],"sources":["../src/canonical-stringify.ts"],"mappings":";;AA6CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,kBAAA,CAAmB,KAAA"}

package/dist/canonical-stringify.mjs

@@ -0,0 +1,104 @@
+//#region src/canonical-stringify.ts
+/**
+* Produces a deterministic, JSON-like string representation of a value.
+*
+* Designed for use as a stable identity / cache key. Two values that are
+* structurally equivalent — regardless of object key insertion order —
+* produce the same string. Two values that differ in any meaningful way
+* (including types that JSON would conflate, like `BigInt(1)` vs `1`)
+* produce different strings.
+*
+* Supported inputs:
+* - `null`, `undefined` (distinguishable: `null` → `"null"`, `undefined` → `"undefined"`)
+* - `boolean`, `string`, `number` (including `NaN`, `Infinity`, `-Infinity`)
+* - `bigint` (suffixed with `n` to disambiguate from `number`)
+* - `Date` (tagged + ISO string)
+* - `Buffer` / `Uint8Array` (tagged + hex-encoded as `Bytes(<hex>)`)
+* - Other `ArrayBuffer` views — `Int8Array`, `Uint16Array`, `Float64Array`,
+*   `DataView`, etc. (tagged with the constructor name + hex-encoded over
+*   the underlying bytes, e.g. `Uint16Array(<hex>)`). Note that the bytes
+*   are read in host byte order, so callers that need cross-platform
+*   stability for multi-byte typed arrays should normalize endianness
+*   before passing the value in.
+* - Arrays (order-preserving)
+* - Plain objects (key-sorted) — only objects whose prototype is
+*   `Object.prototype` or `null`. Non-plain objects (`Map`, `Set`,
+*   `RegExp`, class instances, etc.) are rejected so they cannot silently
+*   collapse to `{}` and collide with each other.
+*
+* Throws on `function`, `symbol`, circular references, non-plain objects,
+* and objects with symbol-keyed properties (which `Object.keys` would
+* silently drop). Callers that need to canonicalize any of these must
+* convert them to a supported representation first.
+*
+* The output format is intentionally not JSON: the type tags and BigInt
+* suffix mean it cannot be round-tripped via `JSON.parse`. The goal is
+* keying, not serialization.
+*
+* @example
+* ```typescript
+* canonicalStringify({ a: 1, b: 2 }) === canonicalStringify({ b: 2, a: 1 })
+* // → true
+*
+* canonicalStringify(1n) !== canonicalStringify(1)
+* // → true
+* ```
+*/
+function canonicalStringify(value) {
+	return write(value, /* @__PURE__ */ new Set());
+}
+function write(value, seen) {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	switch (typeof value) {
+		case "boolean": return value ? "true" : "false";
+		case "number": return writeNumber(value);
+		case "bigint": return `${value.toString()}n`;
+		case "string": return JSON.stringify(value);
+		case "function": throw new TypeError("canonicalStringify: functions are not supported");
+		case "symbol": throw new TypeError("canonicalStringify: symbols are not supported");
+	}
+	const obj = value;
+	if (value instanceof Date) return `Date(${value.toISOString()})`;
+	if (value instanceof Uint8Array) return `Bytes(${bytesToHex(value)})`;
+	if (ArrayBuffer.isView(value)) return `${value.constructor.name}(${bytesToHex(new Uint8Array(value.buffer, value.byteOffset, value.byteLength))})`;
+	if (seen.has(obj)) throw new TypeError("canonicalStringify: circular reference detected");
+	seen.add(obj);
+	try {
+		if (Array.isArray(value)) return `[${value.map((item) => write(item, seen)).join(",")}]`;
+		return writePlainObject(obj, seen);
+	} finally {
+		seen.delete(obj);
+	}
+}
+function writeNumber(value) {
+	if (Number.isNaN(value)) return "NaN";
+	if (value === Number.POSITIVE_INFINITY) return "Infinity";
+	if (value === Number.NEGATIVE_INFINITY) return "-Infinity";
+	if (value === 0 && 1 / value === Number.NEGATIVE_INFINITY) return "-0";
+	return String(value);
+}
+function writePlainObject(obj, seen) {
+	const proto = Object.getPrototypeOf(obj);
+	if (proto !== Object.prototype && proto !== null) {
+		const tag = proto?.constructor?.name ?? "unknown";
+		throw new TypeError(`canonicalStringify: non-plain objects are not supported (got ${tag})`);
+	}
+	if (Object.getOwnPropertySymbols(obj).length > 0) throw new TypeError("canonicalStringify: objects with symbol-keyed properties are not supported");
+	const keys = Object.keys(obj).sort();
+	const parts = [];
+	for (const key of keys) parts.push(`${JSON.stringify(key)}:${write(obj[key], seen)}`);
+	return `{${parts.join(",")}}`;
+}
+function bytesToHex(bytes) {
+	let out = "";
+	for (let i = 0; i < bytes.length; i++) {
+		const byte = bytes[i];
+		out += byte.toString(16).padStart(2, "0");
+	}
+	return out;
+}
+//#endregion
+export { canonicalStringify };
+
+//# sourceMappingURL=canonical-stringify.mjs.map

package/dist/canonical-stringify.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical-stringify.mjs","names":[],"sources":["../src/canonical-stringify.ts"],"sourcesContent":["/**\n * Produces a deterministic, JSON-like string representation of a value.\n *\n * Designed for use as a stable identity / cache key. Two values that are\n * structurally equivalent — regardless of object key insertion order —\n * produce the same string. Two values that differ in any meaningful way\n * (including types that JSON would conflate, like `BigInt(1)` vs `1`)\n * produce different strings.\n *\n * Supported inputs:\n * - `null`, `undefined` (distinguishable: `null` → `\"null\"`, `undefined` → `\"undefined\"`)\n * - `boolean`, `string`, `number` (including `NaN`, `Infinity`, `-Infinity`)\n * - `bigint` (suffixed with `n` to disambiguate from `number`)\n * - `Date` (tagged + ISO string)\n * - `Buffer` / `Uint8Array` (tagged + hex-encoded as `Bytes(<hex>)`)\n * - Other `ArrayBuffer` views — `Int8Array`, `Uint16Array`, `Float64Array`,\n *   `DataView`, etc. (tagged with the constructor name + hex-encoded over\n *   the underlying bytes, e.g. `Uint16Array(<hex>)`). Note that the bytes\n *   are read in host byte order, so callers that need cross-platform\n *   stability for multi-byte typed arrays should normalize endianness\n *   before passing the value in.\n * - Arrays (order-preserving)\n * - Plain objects (key-sorted) — only objects whose prototype is\n *   `Object.prototype` or `null`. Non-plain objects (`Map`, `Set`,\n *   `RegExp`, class instances, etc.) are rejected so they cannot silently\n *   collapse to `{}` and collide with each other.\n *\n * Throws on `function`, `symbol`, circular references, non-plain objects,\n * and objects with symbol-keyed properties (which `Object.keys` would\n * silently drop). Callers that need to canonicalize any of these must\n * convert them to a supported representation first.\n *\n * The output format is intentionally not JSON: the type tags and BigInt\n * suffix mean it cannot be round-tripped via `JSON.parse`. The goal is\n * keying, not serialization.\n *\n * @example\n * ```typescript\n * canonicalStringify({ a: 1, b: 2 }) === canonicalStringify({ b: 2, a: 1 })\n * // → true\n *\n * canonicalStringify(1n) !== canonicalStringify(1)\n * // → true\n * ```\n */\nexport function canonicalStringify(value: unknown): string {\n  return write(value, new Set());\n}\n\nfunction write(value: unknown, seen: Set<object>): string {\n  if (value === null) return 'null';\n  if (value === undefined) return 'undefined';\n\n  switch (typeof value) {\n    case 'boolean':\n      return value ? 'true' : 'false';\n    case 'number':\n      return writeNumber(value);\n    case 'bigint':\n      return `${value.toString()}n`;\n    case 'string':\n      return JSON.stringify(value);\n    case 'function':\n      throw new TypeError('canonicalStringify: functions are not supported');\n    case 'symbol':\n      throw new TypeError('canonicalStringify: symbols are not supported');\n  }\n\n  // From here, value is a non-null object.\n  const obj = value as object;\n\n  // Leaf object types are handled before touching `seen`: they can never\n  // contain back-references, so cycle tracking is wasted work for them.\n  if (value instanceof Date) {\n    return `Date(${value.toISOString()})`;\n  }\n\n  // `Buffer` is a `Uint8Array` subclass; this branch covers both, and\n  // emits the legacy `Bytes(<hex>)` tag so a `Buffer` and a same-content\n  // `Uint8Array` digest identically.\n  if (value instanceof Uint8Array) {\n    return `Bytes(${bytesToHex(value)})`;\n  }\n\n  // Any other `ArrayBuffer` view — typed arrays (`Int8Array`,\n  // `Uint16Array`, `Float64Array`, …) and `DataView`. Without this\n  // branch they would fall through to the plain-object writer and\n  // canonicalize as `{\"0\":1,\"1\":2,...}`, which would silently collide\n  // with a same-keyed plain object. Tagging by constructor name keeps\n  // distinct view families distinct.\n  if (ArrayBuffer.isView(value)) {\n    const tag = value.constructor.name;\n    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);\n    return `${tag}(${bytesToHex(bytes)})`;\n  }\n\n  if (seen.has(obj)) {\n    throw new TypeError('canonicalStringify: circular reference detected');\n  }\n  seen.add(obj);\n  try {\n    if (Array.isArray(value)) {\n      const parts = value.map((item) => write(item, seen));\n      return `[${parts.join(',')}]`;\n    }\n\n    return writePlainObject(obj as Record<string, unknown>, seen);\n  } finally {\n    seen.delete(obj);\n  }\n}\n\nfunction writeNumber(value: number): string {\n  if (Number.isNaN(value)) return 'NaN';\n  if (value === Number.POSITIVE_INFINITY) return 'Infinity';\n  if (value === Number.NEGATIVE_INFINITY) return '-Infinity';\n  // Distinguish `+0` from `-0` so they hash differently.\n  if (value === 0 && 1 / value === Number.NEGATIVE_INFINITY) return '-0';\n  return String(value);\n}\n\nfunction writePlainObject(obj: Record<string, unknown>, seen: Set<object>): string {\n  // Only true plain objects are accepted here. Without this guard, anything\n  // that fell through the type-tagged branches above (`Map`, `Set`,\n  // `RegExp`, class instances, …) would canonicalize to `{}` because\n  // `Object.keys` returns no enumerable string keys for them — silently\n  // colliding with each other and with the literal `{}`.\n  const proto = Object.getPrototypeOf(obj);\n  if (proto !== Object.prototype && proto !== null) {\n    const tag = proto?.constructor?.name ?? 'unknown';\n    throw new TypeError(`canonicalStringify: non-plain objects are not supported (got ${tag})`);\n  }\n\n  // `Object.keys` ignores symbol-keyed properties, so they would be\n  // silently dropped from the canonical form. Force callers to handle\n  // them explicitly instead of producing a key that omits real data.\n  if (Object.getOwnPropertySymbols(obj).length > 0) {\n    throw new TypeError(\n      'canonicalStringify: objects with symbol-keyed properties are not supported',\n    );\n  }\n\n  const keys = Object.keys(obj).sort();\n  const parts: string[] = [];\n  for (const key of keys) {\n    parts.push(`${JSON.stringify(key)}:${write(obj[key], seen)}`);\n  }\n  return `{${parts.join(',')}}`;\n}\n\nfunction bytesToHex(bytes: Uint8Array): string {\n  let out = '';\n  for (let i = 0; i < bytes.length; i++) {\n    const byte = bytes[i] as number;\n    out += byte.toString(16).padStart(2, '0');\n  }\n  return out;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,mBAAmB,OAAwB;CACzD,OAAO,MAAM,uBAAO,IAAI,KAAK,CAAC;;AAGhC,SAAS,MAAM,OAAgB,MAA2B;CACxD,IAAI,UAAU,MAAM,OAAO;CAC3B,IAAI,UAAU,KAAA,GAAW,OAAO;CAEhC,QAAQ,OAAO,OAAf;EACE,KAAK,WACH,OAAO,QAAQ,SAAS;EAC1B,KAAK,UACH,OAAO,YAAY,MAAM;EAC3B,KAAK,UACH,OAAO,GAAG,MAAM,UAAU,CAAC;EAC7B,KAAK,UACH,OAAO,KAAK,UAAU,MAAM;EAC9B,KAAK,YACH,MAAM,IAAI,UAAU,kDAAkD;EACxE,KAAK,UACH,MAAM,IAAI,UAAU,gDAAgD;;CAIxE,MAAM,MAAM;CAIZ,IAAI,iBAAiB,MACnB,OAAO,QAAQ,MAAM,aAAa,CAAC;CAMrC,IAAI,iBAAiB,YACnB,OAAO,SAAS,WAAW,MAAM,CAAC;CASpC,IAAI,YAAY,OAAO,MAAM,EAG3B,OAAO,GAFK,MAAM,YAAY,KAEhB,GAAG,WAAW,IADV,WAAW,MAAM,QAAQ,MAAM,YAAY,MAAM,WAClC,CAAC,CAAC;CAGrC,IAAI,KAAK,IAAI,IAAI,EACf,MAAM,IAAI,UAAU,kDAAkD;CAExE,KAAK,IAAI,IAAI;CACb,IAAI;EACF,IAAI,MAAM,QAAQ,MAAM,EAEtB,OAAO,IADO,MAAM,KAAK,SAAS,MAAM,MAAM,KAAK,CACnC,CAAC,KAAK,IAAI,CAAC;EAG7B,OAAO,iBAAiB,KAAgC,KAAK;WACrD;EACR,KAAK,OAAO,IAAI;;;AAIpB,SAAS,YAAY,OAAuB;CAC1C,IAAI,OAAO,MAAM,MAAM,EAAE,OAAO;CAChC,IAAI,UAAU,OAAO,mBAAmB,OAAO;CAC/C,IAAI,UAAU,OAAO,mBAAmB,OAAO;CAE/C,IAAI,UAAU,KAAK,IAAI,UAAU,OAAO,mBAAmB,OAAO;CAClE,OAAO,OAAO,MAAM;;AAGtB,SAAS,iBAAiB,KAA8B,MAA2B;CAMjF,MAAM,QAAQ,OAAO,eAAe,IAAI;CACxC,IAAI,UAAU,OAAO,aAAa,UAAU,MAAM;EAChD,MAAM,MAAM,OAAO,aAAa,QAAQ;EACxC,MAAM,IAAI,UAAU,gEAAgE,IAAI,GAAG;;CAM7F,IAAI,OAAO,sBAAsB,IAAI,CAAC,SAAS,GAC7C,MAAM,IAAI,UACR,6EACD;CAGH,MAAM,OAAO,OAAO,KAAK,IAAI,CAAC,MAAM;CACpC,MAAM,QAAkB,EAAE;CAC1B,KAAK,MAAM,OAAO,MAChB,MAAM,KAAK,GAAG,KAAK,UAAU,IAAI,CAAC,GAAG,MAAM,IAAI,MAAM,KAAK,GAAG;CAE/D,OAAO,IAAI,MAAM,KAAK,IAAI,CAAC;;AAG7B,SAAS,WAAW,OAA2B;CAC7C,IAAI,MAAM;CACV,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,OAAO,MAAM;EACnB,OAAO,KAAK,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI;;CAE3C,OAAO"}

package/dist/{defined-CV9lG7rM.mjs → defined-BYcWqtXq.mjs}

@@ -24,7 +24,7 @@
 function ifDefined(key, value) {
 	return value !== void 0 ? { [key]: value } : {};
 }
-
 //#endregion
 export { ifDefined as t };
-//# sourceMappingURL=defined-CV9lG7rM.mjs.map
+
+//# sourceMappingURL=defined-BYcWqtXq.mjs.map

package/dist/{defined-CV9lG7rM.mjs.map → defined-BYcWqtXq.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"defined-CV9lG7rM.mjs","names":[],"sources":["../src/defined.ts"],"sourcesContent":["/**\n * Returns an object with the key/value if value is defined, otherwise an empty object.\n *\n * Use with spread to conditionally include optional properties while satisfying\n * exactOptionalPropertyTypes. This is explicit about which properties are optional\n * and won't inadvertently strip other undefined values.\n *\n * @example\n * ```typescript\n * // Instead of:\n * const obj = {\n *   required: 'value',\n *   ...(optional ? { optional } : {}),\n * };\n *\n * // Use:\n * const obj = {\n *   required: 'value',\n *   ...ifDefined('optional', optional),\n * };\n * ```\n */\nexport function ifDefined<K extends string, V>(\n  key: K,\n  value: V | undefined,\n): Record<never, never> | { [P in K]: V } {\n  return value !== undefined ? ({ [key]: value } as { [P in K]: V }) : {};\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,UACd,KACA,OACwC;AACxC,QAAO,UAAU,SAAa,GAAG,MAAM,OAAO,GAAuB,EAAE"}
+{"version":3,"file":"defined-BYcWqtXq.mjs","names":[],"sources":["../src/defined.ts"],"sourcesContent":["/**\n * Returns an object with the key/value if value is defined, otherwise an empty object.\n *\n * Use with spread to conditionally include optional properties while satisfying\n * exactOptionalPropertyTypes. This is explicit about which properties are optional\n * and won't inadvertently strip other undefined values.\n *\n * @example\n * ```typescript\n * // Instead of:\n * const obj = {\n *   required: 'value',\n *   ...(optional ? { optional } : {}),\n * };\n *\n * // Use:\n * const obj = {\n *   required: 'value',\n *   ...ifDefined('optional', optional),\n * };\n * ```\n */\nexport function ifDefined<K extends string, V>(\n  key: K,\n  value: V | undefined,\n): Record<never, never> | { [P in K]: V } {\n  return value !== undefined ? ({ [key]: value } as { [P in K]: V }) : {};\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,UACd,KACA,OACwC;CACxC,OAAO,UAAU,KAAA,IAAa,GAAG,MAAM,OAAO,GAAuB,EAAE"}

package/dist/defined.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"defined.d.mts","names":[],"sources":["../src/defined.ts"],"sourcesContent":[],"mappings":";;AAsBA;;;;;;;;;;;;;;;;;;;;;iBAAgB,oCACT,UACE,gBACN,+BAA+B,IAAI"}
+{"version":3,"file":"defined.d.mts","names":[],"sources":["../src/defined.ts"],"mappings":";;AAsBA;;;;;;;;;;;;;;;;;;;;;iBAAgB,SAAA,qBAAA,CACd,GAAA,EAAK,CAAA,EACL,KAAA,EAAO,CAAA,eACN,MAAA,yBAA+B,CAAA,GAAI,CAAA"}

package/dist/defined.mjs

@@ -1,3 +1,2 @@
-import { t as ifDefined } from "./defined-CV9lG7rM.mjs";
-
-export { ifDefined };
+import { t as ifDefined } from "./defined-BYcWqtXq.mjs";
+export { ifDefined };

package/dist/hash-content.d.mts

@@ -0,0 +1,58 @@
+//#region src/hash-content.d.ts
+/**
+ * Hashes a canonical-string representation of an execution into a bounded,
+ * opaque cache-key digest.
+ *
+ * Designed for use as the final step of `RuntimeMiddlewareContext.contentHash`
+ * implementations: family runtimes compose a canonical string from
+ * `meta.storageHash`, the rendered statement (or wire command), and
+ * canonicalized parameters via `canonicalStringify`, then pipe the result
+ * through this helper.
+ *
+ * Why hash the canonical string instead of using it directly as a `Map` key:
+ *
+ * 1. **Bounded memory.** A raw canonical key includes concrete parameter
+ *    values, so a query bound to a 10 MB JSON column or binary blob produces
+ *    a 10 MB cache key. With `maxEntries = 1000`, that scales to gigabytes
+ *    of cache keys alone. SHA-512 pins per-key cost at a fixed digest
+ *    length regardless of input size.
+ *
+ * 2. **Sensitive-data isolation.** The canonical string contains parameter
+ *    values verbatim. Cache keys flow into debug logs, Redis `KEYS`/`MONITOR`
+ *    output, persistence dumps, monitoring tools, and any user-supplied
+ *    `CacheStore` implementation. Hashing prevents PII / credentials /
+ *    tokens that appear in query parameters from showing up in any of those
+ *    surfaces.
+ *
+ * Algorithm choice — SHA-512 (`SHA-512` via the WebCrypto API):
+ *
+ * - **Portability.** WebCrypto (`globalThis.crypto.subtle`) is available in
+ *   every modern JavaScript runtime — Node, Deno, Bun, browsers, edge
+ *   workers — without importing a Node-specific module. This keeps the
+ *   helper usable in non-Node hosts where `node:crypto` is not available.
+ * - **Collision space.** 512 bits of output makes accidental collisions
+ *   astronomically improbable — far beyond what a cache needs, but the
+ *   incremental cost over 256-bit output is negligible and the headroom
+ *   is free.
+ * - **No additional dependency.** SHA-512 is part of the WebCrypto standard
+ *   set of digest algorithms; no third-party package needed.
+ *
+ * The function is `async` because the WebCrypto digest API is async by
+ * design. Callers must await the result.
+ *
+ * Output format: `sha512:HEXDIGEST` (128-char hex with the algorithm tag
+ * prefix). Self-describing so a future migration to a different hash
+ * produces visibly distinct keys, and consistent with the
+ * `sha256:HEXDIGEST` shape already used by `meta.storageHash`.
+ *
+ * @example
+ * ```typescript
+ * const canonical = `${exec.meta.storageHash}|${exec.sql}|${canonicalStringify(exec.params)}`;
+ * return await hashContent(canonical);
+ * // → 'sha512:8f3...e1c' (always 135 chars: 'sha512:' + 128 hex chars)
+ * ```
+ */
+declare function hashContent(value: string): Promise<string>;
+//#endregion
+export { hashContent };
+//# sourceMappingURL=hash-content.d.mts.map

package/dist/hash-content.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-content.d.mts","names":[],"sources":["../src/hash-content.ts"],"mappings":";;AAqDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAsB,WAAA,CAAY,KAAA,WAAgB,OAAA"}

package/dist/hash-content.mjs

@@ -0,0 +1,63 @@
+//#region src/hash-content.ts
+/**
+* Hashes a canonical-string representation of an execution into a bounded,
+* opaque cache-key digest.
+*
+* Designed for use as the final step of `RuntimeMiddlewareContext.contentHash`
+* implementations: family runtimes compose a canonical string from
+* `meta.storageHash`, the rendered statement (or wire command), and
+* canonicalized parameters via `canonicalStringify`, then pipe the result
+* through this helper.
+*
+* Why hash the canonical string instead of using it directly as a `Map` key:
+*
+* 1. **Bounded memory.** A raw canonical key includes concrete parameter
+*    values, so a query bound to a 10 MB JSON column or binary blob produces
+*    a 10 MB cache key. With `maxEntries = 1000`, that scales to gigabytes
+*    of cache keys alone. SHA-512 pins per-key cost at a fixed digest
+*    length regardless of input size.
+*
+* 2. **Sensitive-data isolation.** The canonical string contains parameter
+*    values verbatim. Cache keys flow into debug logs, Redis `KEYS`/`MONITOR`
+*    output, persistence dumps, monitoring tools, and any user-supplied
+*    `CacheStore` implementation. Hashing prevents PII / credentials /
+*    tokens that appear in query parameters from showing up in any of those
+*    surfaces.
+*
+* Algorithm choice — SHA-512 (`SHA-512` via the WebCrypto API):
+*
+* - **Portability.** WebCrypto (`globalThis.crypto.subtle`) is available in
+*   every modern JavaScript runtime — Node, Deno, Bun, browsers, edge
+*   workers — without importing a Node-specific module. This keeps the
+*   helper usable in non-Node hosts where `node:crypto` is not available.
+* - **Collision space.** 512 bits of output makes accidental collisions
+*   astronomically improbable — far beyond what a cache needs, but the
+*   incremental cost over 256-bit output is negligible and the headroom
+*   is free.
+* - **No additional dependency.** SHA-512 is part of the WebCrypto standard
+*   set of digest algorithms; no third-party package needed.
+*
+* The function is `async` because the WebCrypto digest API is async by
+* design. Callers must await the result.
+*
+* Output format: `sha512:HEXDIGEST` (128-char hex with the algorithm tag
+* prefix). Self-describing so a future migration to a different hash
+* produces visibly distinct keys, and consistent with the
+* `sha256:HEXDIGEST` shape already used by `meta.storageHash`.
+*
+* @example
+* ```typescript
+* const canonical = `${exec.meta.storageHash}|${exec.sql}|${canonicalStringify(exec.params)}`;
+* return await hashContent(canonical);
+* // → 'sha512:8f3...e1c' (always 135 chars: 'sha512:' + 128 hex chars)
+* ```
+*/
+async function hashContent(value) {
+	const bytes = new TextEncoder().encode(value);
+	const digest = await crypto.subtle.digest("SHA-512", bytes);
+	return `sha512:${Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+//#endregion
+export { hashContent };
+
+//# sourceMappingURL=hash-content.mjs.map

package/dist/hash-content.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-content.mjs","names":[],"sources":["../src/hash-content.ts"],"sourcesContent":["/**\n * Hashes a canonical-string representation of an execution into a bounded,\n * opaque cache-key digest.\n *\n * Designed for use as the final step of `RuntimeMiddlewareContext.contentHash`\n * implementations: family runtimes compose a canonical string from\n * `meta.storageHash`, the rendered statement (or wire command), and\n * canonicalized parameters via `canonicalStringify`, then pipe the result\n * through this helper.\n *\n * Why hash the canonical string instead of using it directly as a `Map` key:\n *\n * 1. **Bounded memory.** A raw canonical key includes concrete parameter\n *    values, so a query bound to a 10 MB JSON column or binary blob produces\n *    a 10 MB cache key. With `maxEntries = 1000`, that scales to gigabytes\n *    of cache keys alone. SHA-512 pins per-key cost at a fixed digest\n *    length regardless of input size.\n *\n * 2. **Sensitive-data isolation.** The canonical string contains parameter\n *    values verbatim. Cache keys flow into debug logs, Redis `KEYS`/`MONITOR`\n *    output, persistence dumps, monitoring tools, and any user-supplied\n *    `CacheStore` implementation. Hashing prevents PII / credentials /\n *    tokens that appear in query parameters from showing up in any of those\n *    surfaces.\n *\n * Algorithm choice — SHA-512 (`SHA-512` via the WebCrypto API):\n *\n * - **Portability.** WebCrypto (`globalThis.crypto.subtle`) is available in\n *   every modern JavaScript runtime — Node, Deno, Bun, browsers, edge\n *   workers — without importing a Node-specific module. This keeps the\n *   helper usable in non-Node hosts where `node:crypto` is not available.\n * - **Collision space.** 512 bits of output makes accidental collisions\n *   astronomically improbable — far beyond what a cache needs, but the\n *   incremental cost over 256-bit output is negligible and the headroom\n *   is free.\n * - **No additional dependency.** SHA-512 is part of the WebCrypto standard\n *   set of digest algorithms; no third-party package needed.\n *\n * The function is `async` because the WebCrypto digest API is async by\n * design. Callers must await the result.\n *\n * Output format: `sha512:HEXDIGEST` (128-char hex with the algorithm tag\n * prefix). Self-describing so a future migration to a different hash\n * produces visibly distinct keys, and consistent with the\n * `sha256:HEXDIGEST` shape already used by `meta.storageHash`.\n *\n * @example\n * ```typescript\n * const canonical = `${exec.meta.storageHash}|${exec.sql}|${canonicalStringify(exec.params)}`;\n * return await hashContent(canonical);\n * // → 'sha512:8f3...e1c' (always 135 chars: 'sha512:' + 128 hex chars)\n * ```\n */\nexport async function hashContent(value: string): Promise<string> {\n  const bytes = new TextEncoder().encode(value);\n  const digest = await crypto.subtle.digest('SHA-512', bytes);\n  const hex = Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, '0')).join('');\n  return `sha512:${hex}`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDA,eAAsB,YAAY,OAAgC;CAChE,MAAM,QAAQ,IAAI,aAAa,CAAC,OAAO,MAAM;CAC7C,MAAM,SAAS,MAAM,OAAO,OAAO,OAAO,WAAW,MAAM;CAE3D,OAAO,UADK,MAAM,KAAK,IAAI,WAAW,OAAO,GAAG,MAAM,EAAE,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,KAAK,GACxE"}

package/dist/redact-db-url.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"redact-db-url.d.mts","names":[],"sources":["../src/redact-db-url.ts"],"sourcesContent":[],"mappings":";;AAMA;AAaA;;UAbiB,mBAAA;;;;;;;;;;;;iBAaD,iBAAA,eAAgC"}
+{"version":3,"file":"redact-db-url.d.mts","names":[],"sources":["../src/redact-db-url.ts"],"mappings":";;AAMA;;;UAAiB,mBAAA;EAAA,SACN,IAAA;EAAA,SACA,IAAA;EAAA,SACA,QAAA;EAAA,SACA,QAAA;AAAA;;AASX;;;;;iBAAgB,iBAAA,CAAkB,GAAA,WAAc,mBAAA"}

package/dist/redact-db-url.mjs

@@ -1,5 +1,4 @@
-import { t as ifDefined } from "./defined-CV9lG7rM.mjs";
-
+import { t as ifDefined } from "./defined-BYcWqtXq.mjs";
 //#region src/redact-db-url.ts
 /**
 * Redacts a database connection URL to a minimal metadata object.
@@ -21,7 +20,7 @@ function redactDatabaseUrl(url) {
 		return {};
 	}
 }
-
 //#endregion
 export { redactDatabaseUrl };
+
 //# sourceMappingURL=redact-db-url.mjs.map

package/dist/redact-db-url.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"redact-db-url.mjs","names":[],"sources":["../src/redact-db-url.ts"],"sourcesContent":["import { ifDefined } from './defined';\n\n/**\n * Minimal metadata extracted from a database URL for logging or error output.\n * Sensitive fields (password, full URL) are never returned.\n */\nexport interface RedactedDatabaseUrl {\n  readonly host?: string;\n  readonly port?: string;\n  readonly database?: string;\n  readonly username?: string;\n}\n\n/**\n * Redacts a database connection URL to a minimal metadata object.\n *\n * Parsing errors are ignored and result in an empty object so callers never\n * leak raw URLs when the input is malformed.\n */\nexport function redactDatabaseUrl(url: string): RedactedDatabaseUrl {\n  try {\n    const parsed = new URL(url);\n    const database = parsed.pathname?.replace(/^\\//, '') || undefined;\n    return {\n      ...ifDefined('host', parsed.hostname || undefined),\n      ...ifDefined('port', parsed.port || undefined),\n      ...ifDefined('database', database),\n      ...ifDefined('username', parsed.username || undefined),\n    };\n  } catch {\n    // Ignore parsing errors; return empty metadata\n    return {};\n  }\n}\n"],"mappings":";;;;;;;;;AAmBA,SAAgB,kBAAkB,KAAkC;AAClE,KAAI;EACF,MAAM,SAAS,IAAI,IAAI,IAAI;EAC3B,MAAM,WAAW,OAAO,UAAU,QAAQ,OAAO,GAAG,IAAI;AACxD,SAAO;GACL,GAAG,UAAU,QAAQ,OAAO,YAAY,OAAU;GAClD,GAAG,UAAU,QAAQ,OAAO,QAAQ,OAAU;GAC9C,GAAG,UAAU,YAAY,SAAS;GAClC,GAAG,UAAU,YAAY,OAAO,YAAY,OAAU;GACvD;SACK;AAEN,SAAO,EAAE"}
+{"version":3,"file":"redact-db-url.mjs","names":[],"sources":["../src/redact-db-url.ts"],"sourcesContent":["import { ifDefined } from './defined';\n\n/**\n * Minimal metadata extracted from a database URL for logging or error output.\n * Sensitive fields (password, full URL) are never returned.\n */\nexport interface RedactedDatabaseUrl {\n  readonly host?: string;\n  readonly port?: string;\n  readonly database?: string;\n  readonly username?: string;\n}\n\n/**\n * Redacts a database connection URL to a minimal metadata object.\n *\n * Parsing errors are ignored and result in an empty object so callers never\n * leak raw URLs when the input is malformed.\n */\nexport function redactDatabaseUrl(url: string): RedactedDatabaseUrl {\n  try {\n    const parsed = new URL(url);\n    const database = parsed.pathname?.replace(/^\\//, '') || undefined;\n    return {\n      ...ifDefined('host', parsed.hostname || undefined),\n      ...ifDefined('port', parsed.port || undefined),\n      ...ifDefined('database', database),\n      ...ifDefined('username', parsed.username || undefined),\n    };\n  } catch {\n    // Ignore parsing errors; return empty metadata\n    return {};\n  }\n}\n"],"mappings":";;;;;;;;AAmBA,SAAgB,kBAAkB,KAAkC;CAClE,IAAI;EACF,MAAM,SAAS,IAAI,IAAI,IAAI;EAC3B,MAAM,WAAW,OAAO,UAAU,QAAQ,OAAO,GAAG,IAAI,KAAA;EACxD,OAAO;GACL,GAAG,UAAU,QAAQ,OAAO,YAAY,KAAA,EAAU;GAClD,GAAG,UAAU,QAAQ,OAAO,QAAQ,KAAA,EAAU;GAC9C,GAAG,UAAU,YAAY,SAAS;GAClC,GAAG,UAAU,YAAY,OAAO,YAAY,KAAA,EAAU;GACvD;SACK;EAEN,OAAO,EAAE"}

package/dist/result.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"result.d.mts","names":[],"sources":["../src/result.ts"],"sourcesContent":[],"mappings":";;AAeA;AAUA;AAaA;;;;;;AAgFA;;;;;AAOgB,UA9GC,EA8GI,CAAA,CAAA,CAAA,CAAA;EAAa,SAAA,EAAA,EAAA,IAAA;EAAU,SAAA,KAAA,EA5G1B,CA4G0B;EAAN,QAAA,EAAA,EA3GxB,CA2GwB;EAAK,WAAA,EAAA,EAAA,KAAA;AAc3C;;;;UAlHiB;;oBAEG;;iBAEH;;;;;;;;KASL,eAAe,GAAG,KAAK,MAAM;;;;iBAgFzB,aAAa,IAAI,GAAG;;;;iBAOpB,kBAAkB,IAAI,MAAM;;;;;iBAc5B,MAAA,CAAA,GAAU"}
+{"version":3,"file":"result.d.mts","names":[],"sources":["../src/result.ts"],"mappings":";;AAeA;;;;;;;;;;;;;UAAiB,EAAA;EAAA,SACN,EAAA;EAAA,SACA,KAAA,EAAO,CAAA;EAChB,QAAA,IAAY,CAAA;EACZ,WAAA;AAAA;;;;UAMe,KAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,EAAS,CAAA;EAClB,QAAA;EACA,WAAA,IAAe,CAAA;AAAA;;;;;;;KASL,MAAA,SAAe,EAAA,CAAG,CAAA,IAAK,KAAA,CAAM,CAAA;;;;iBAgFzB,EAAA,GAAA,CAAM,KAAA,EAAO,CAAA,GAAI,EAAA,CAAG,CAAA;;;;iBAOpB,KAAA,GAAA,CAAS,OAAA,EAAS,CAAA,GAAI,KAAA,CAAM,CAAA;AAP5C;;;;AAAA,iBAqBgB,MAAA,CAAA,GAAU,EAAA"}

package/dist/result.mjs

@@ -6,9 +6,9 @@ var ResultImpl = class ResultImpl {
 	ok;
 	_value;
 	_failure;
-	constructor(ok$1, valueOrFailure) {
-		this.ok = ok$1;
-		if (ok$1) this._value = valueOrFailure;
+	constructor(ok, valueOrFailure) {
+		this.ok = ok;
+		if (ok) this._value = valueOrFailure;
 		else this._failure = valueOrFailure;
 		Object.freeze(this);
 	}
@@ -73,7 +73,7 @@ const OK_VOID = ResultImpl.ok(void 0);
 function okVoid() {
 	return OK_VOID;
 }
-
 //#endregion
 export { notOk, ok, okVoid };
+
 //# sourceMappingURL=result.mjs.map

package/dist/result.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"result.mjs","names":["ok","OK_VOID: Ok<void>"],"sources":["../src/result.ts"],"sourcesContent":["/**\n * Generic Result type for representing success or failure outcomes.\n *\n * This is the standard way to return \"expected failures\" as values rather than\n * throwing exceptions. See docs/Error Handling.md for the full taxonomy.\n *\n * Naming rationale:\n * - `Ok<T>` / `NotOk<F>` mirror the `ok: true/false` discriminator\n * - `NotOk` avoids collision with domain types like \"Failure\" or \"Error\"\n * - `failure` property distinguishes from JS Error semantics\n */\n\n/**\n * Represents a successful result containing a value.\n */\nexport interface Ok<T> {\n  readonly ok: true;\n  readonly value: T;\n  assertOk(): T;\n  assertNotOk(): never;\n}\n\n/**\n * Represents an unsuccessful result containing failure details.\n */\nexport interface NotOk<F> {\n  readonly ok: false;\n  readonly failure: F;\n  assertOk(): never;\n  assertNotOk(): F;\n}\n\n/**\n * A discriminated union representing either success (Ok) or failure (NotOk).\n *\n * @typeParam T - The success value type\n * @typeParam F - The failure details type\n */\nexport type Result<T, F> = Ok<T> | NotOk<F>;\n\n/**\n * Result class that implements both Ok and NotOk variants.\n */\nclass ResultImpl<T, F> {\n  readonly ok: boolean;\n  private readonly _value?: T;\n  private readonly _failure?: F;\n\n  private constructor(ok: boolean, valueOrFailure: T | F) {\n    this.ok = ok;\n    if (ok) {\n      this._value = valueOrFailure as T;\n    } else {\n      this._failure = valueOrFailure as F;\n    }\n    Object.freeze(this);\n  }\n\n  get value(): T {\n    if (!this.ok) {\n      throw new Error('Cannot access value on NotOk result');\n    }\n    // biome-ignore lint/style/noNonNullAssertion: must be present if ok is true\n    return this._value!;\n  }\n\n  get failure(): F {\n    if (this.ok) {\n      throw new Error('Cannot access failure on Ok result');\n    }\n    // biome-ignore lint/style/noNonNullAssertion: must be present if ok is false\n    return this._failure!;\n  }\n\n  /**\n   * Creates a successful result.\n   */\n  static ok<T, F = never>(value: T): Ok<T> {\n    // TypeScript cannot express discriminated return types for a single implementation.\n    // Cast is safe: ok=true guarantees this is an Ok<T> at runtime.\n    return new ResultImpl<T, F>(true, value) as unknown as Ok<T>;\n  }\n\n  /**\n   * Creates an unsuccessful result.\n   */\n  static notOk<T = never, F = unknown>(failure: F): NotOk<F> {\n    // TypeScript cannot express discriminated return types for a single implementation.\n    // Cast is safe: ok=false guarantees this is a NotOk<F> at runtime.\n    return new ResultImpl<T, F>(false, failure) as unknown as NotOk<F>;\n  }\n\n  /**\n   * Asserts that this result is Ok and returns the value.\n   * Throws if the result is NotOk.\n   */\n  assertOk(this: Result<T, F>): T {\n    if (!this.ok) {\n      throw new Error('Expected Ok result but got NotOk');\n    }\n    return this.value;\n  }\n\n  /**\n   * Asserts that this result is NotOk and returns the failure.\n   * Throws if the result is Ok.\n   */\n  assertNotOk(this: Result<T, F>): F {\n    if (this.ok) {\n      throw new Error('Expected NotOk result but got Ok');\n    }\n    return this.failure;\n  }\n}\n\n/**\n * Creates a successful result.\n */\nexport function ok<T>(value: T): Ok<T> {\n  return ResultImpl.ok(value);\n}\n\n/**\n * Creates an unsuccessful result.\n */\nexport function notOk<F>(failure: F): NotOk<F> {\n  return ResultImpl.notOk(failure);\n}\n\n/**\n * Singleton for void success results.\n * Use this for validation checks that don't produce a value.\n */\nconst OK_VOID: Ok<void> = ResultImpl.ok<void>(undefined);\n\n/**\n * Returns a successful void result.\n * Use this for validation checks that don't produce a value.\n */\nexport function okVoid(): Ok<void> {\n  return OK_VOID;\n}\n"],"mappings":";;;;AA2CA,IAAM,aAAN,MAAM,WAAiB;CACrB,AAAS;CACT,AAAiB;CACjB,AAAiB;CAEjB,AAAQ,YAAY,MAAa,gBAAuB;AACtD,OAAK,KAAKA;AACV,MAAIA,KACF,MAAK,SAAS;MAEd,MAAK,WAAW;AAElB,SAAO,OAAO,KAAK;;CAGrB,IAAI,QAAW;AACb,MAAI,CAAC,KAAK,GACR,OAAM,IAAI,MAAM,sCAAsC;AAGxD,SAAO,KAAK;;CAGd,IAAI,UAAa;AACf,MAAI,KAAK,GACP,OAAM,IAAI,MAAM,qCAAqC;AAGvD,SAAO,KAAK;;;;;CAMd,OAAO,GAAiB,OAAiB;AAGvC,SAAO,IAAI,WAAiB,MAAM,MAAM;;;;;CAM1C,OAAO,MAA8B,SAAsB;AAGzD,SAAO,IAAI,WAAiB,OAAO,QAAQ;;;;;;CAO7C,WAAgC;AAC9B,MAAI,CAAC,KAAK,GACR,OAAM,IAAI,MAAM,mCAAmC;AAErD,SAAO,KAAK;;;;;;CAOd,cAAmC;AACjC,MAAI,KAAK,GACP,OAAM,IAAI,MAAM,mCAAmC;AAErD,SAAO,KAAK;;;;;;AAOhB,SAAgB,GAAM,OAAiB;AACrC,QAAO,WAAW,GAAG,MAAM;;;;;AAM7B,SAAgB,MAAS,SAAsB;AAC7C,QAAO,WAAW,MAAM,QAAQ;;;;;;AAOlC,MAAMC,UAAoB,WAAW,GAAS,OAAU;;;;;AAMxD,SAAgB,SAAmB;AACjC,QAAO"}
+{"version":3,"file":"result.mjs","names":[],"sources":["../src/result.ts"],"sourcesContent":["/**\n * Generic Result type for representing success or failure outcomes.\n *\n * This is the standard way to return \"expected failures\" as values rather than\n * throwing exceptions. See docs/Error Handling.md for the full taxonomy.\n *\n * Naming rationale:\n * - `Ok<T>` / `NotOk<F>` mirror the `ok: true/false` discriminator\n * - `NotOk` avoids collision with domain types like \"Failure\" or \"Error\"\n * - `failure` property distinguishes from JS Error semantics\n */\n\n/**\n * Represents a successful result containing a value.\n */\nexport interface Ok<T> {\n  readonly ok: true;\n  readonly value: T;\n  assertOk(): T;\n  assertNotOk(): never;\n}\n\n/**\n * Represents an unsuccessful result containing failure details.\n */\nexport interface NotOk<F> {\n  readonly ok: false;\n  readonly failure: F;\n  assertOk(): never;\n  assertNotOk(): F;\n}\n\n/**\n * A discriminated union representing either success (Ok) or failure (NotOk).\n *\n * @typeParam T - The success value type\n * @typeParam F - The failure details type\n */\nexport type Result<T, F> = Ok<T> | NotOk<F>;\n\n/**\n * Result class that implements both Ok and NotOk variants.\n */\nclass ResultImpl<T, F> {\n  readonly ok: boolean;\n  private readonly _value?: T;\n  private readonly _failure?: F;\n\n  private constructor(ok: boolean, valueOrFailure: T | F) {\n    this.ok = ok;\n    if (ok) {\n      this._value = valueOrFailure as T;\n    } else {\n      this._failure = valueOrFailure as F;\n    }\n    Object.freeze(this);\n  }\n\n  get value(): T {\n    if (!this.ok) {\n      throw new Error('Cannot access value on NotOk result');\n    }\n    // biome-ignore lint/style/noNonNullAssertion: must be present if ok is true\n    return this._value!;\n  }\n\n  get failure(): F {\n    if (this.ok) {\n      throw new Error('Cannot access failure on Ok result');\n    }\n    // biome-ignore lint/style/noNonNullAssertion: must be present if ok is false\n    return this._failure!;\n  }\n\n  /**\n   * Creates a successful result.\n   */\n  static ok<T, F = never>(value: T): Ok<T> {\n    // TypeScript cannot express discriminated return types for a single implementation.\n    // Cast is safe: ok=true guarantees this is an Ok<T> at runtime.\n    return new ResultImpl<T, F>(true, value) as unknown as Ok<T>;\n  }\n\n  /**\n   * Creates an unsuccessful result.\n   */\n  static notOk<T = never, F = unknown>(failure: F): NotOk<F> {\n    // TypeScript cannot express discriminated return types for a single implementation.\n    // Cast is safe: ok=false guarantees this is a NotOk<F> at runtime.\n    return new ResultImpl<T, F>(false, failure) as unknown as NotOk<F>;\n  }\n\n  /**\n   * Asserts that this result is Ok and returns the value.\n   * Throws if the result is NotOk.\n   */\n  assertOk(this: Result<T, F>): T {\n    if (!this.ok) {\n      throw new Error('Expected Ok result but got NotOk');\n    }\n    return this.value;\n  }\n\n  /**\n   * Asserts that this result is NotOk and returns the failure.\n   * Throws if the result is Ok.\n   */\n  assertNotOk(this: Result<T, F>): F {\n    if (this.ok) {\n      throw new Error('Expected NotOk result but got Ok');\n    }\n    return this.failure;\n  }\n}\n\n/**\n * Creates a successful result.\n */\nexport function ok<T>(value: T): Ok<T> {\n  return ResultImpl.ok(value);\n}\n\n/**\n * Creates an unsuccessful result.\n */\nexport function notOk<F>(failure: F): NotOk<F> {\n  return ResultImpl.notOk(failure);\n}\n\n/**\n * Singleton for void success results.\n * Use this for validation checks that don't produce a value.\n */\nconst OK_VOID: Ok<void> = ResultImpl.ok<void>(undefined);\n\n/**\n * Returns a successful void result.\n * Use this for validation checks that don't produce a value.\n */\nexport function okVoid(): Ok<void> {\n  return OK_VOID;\n}\n"],"mappings":";;;;AA2CA,IAAM,aAAN,MAAM,WAAiB;CACrB;CACA;CACA;CAEA,YAAoB,IAAa,gBAAuB;EACtD,KAAK,KAAK;EACV,IAAI,IACF,KAAK,SAAS;OAEd,KAAK,WAAW;EAElB,OAAO,OAAO,KAAK;;CAGrB,IAAI,QAAW;EACb,IAAI,CAAC,KAAK,IACR,MAAM,IAAI,MAAM,sCAAsC;EAGxD,OAAO,KAAK;;CAGd,IAAI,UAAa;EACf,IAAI,KAAK,IACP,MAAM,IAAI,MAAM,qCAAqC;EAGvD,OAAO,KAAK;;;;;CAMd,OAAO,GAAiB,OAAiB;EAGvC,OAAO,IAAI,WAAiB,MAAM,MAAM;;;;;CAM1C,OAAO,MAA8B,SAAsB;EAGzD,OAAO,IAAI,WAAiB,OAAO,QAAQ;;;;;;CAO7C,WAAgC;EAC9B,IAAI,CAAC,KAAK,IACR,MAAM,IAAI,MAAM,mCAAmC;EAErD,OAAO,KAAK;;;;;;CAOd,cAAmC;EACjC,IAAI,KAAK,IACP,MAAM,IAAI,MAAM,mCAAmC;EAErD,OAAO,KAAK;;;;;;AAOhB,SAAgB,GAAM,OAAiB;CACrC,OAAO,WAAW,GAAG,MAAM;;;;;AAM7B,SAAgB,MAAS,SAAsB;CAC7C,OAAO,WAAW,MAAM,QAAQ;;;;;;AAOlC,MAAM,UAAoB,WAAW,GAAS,KAAA,EAAU;;;;;AAMxD,SAAgB,SAAmB;CACjC,OAAO"}

package/dist/simplify-deep.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"simplify-deep.d.mts","names":[],"sources":["../src/simplify-deep.ts"],"sourcesContent":[],"mappings":";KAAY,kBAAkB,uCAC1B,sBACE,aAAa,sBACJ,aAAa,aACxB,wDAMM,OACA,SACA,+CAEJ,IACA,2BAfM,MAgBU,CAhBV,GAgBc,YAhBF,CAgBe,CAhBf,CAgBiB,CAhBjB,CAAA,CAAA,EAAM,GAiBtB,CAjBsB"}
+{"version":3,"file":"simplify-deep.d.mts","names":[],"sources":["../src/simplify-deep.ts"],"mappings":";KAAY,YAAA,MAAkB,CAAA,sCAC1B,CAAA,qBACE,YAAA,CAAa,OAAA,eACJ,YAAA,CAAa,OAAA,MACxB,CAAA,uDAMM,IAAA,GACA,MAAA,GACA,UAAA,QACK,IAAA,yBACT,CAAA,GACA,CAAA,gCACgB,CAAA,GAAI,YAAA,CAAa,CAAA,CAAE,CAAA,OACjC,CAAA"}

package/dist/simplify-deep.mjs

@@ -1 +1 @@
-export {  };
+export {};

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@prisma-next/utils",
-  "version": "0.5.0-dev.7",
+  "version": "0.5.0-dev.70",
+  "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Shared utility functions for Prisma Next",
   "devDependencies": {
-    "tsdown": "0.18.4",
+    "tsdown": "0.22.0",
     "typescript": "5.9.3",
-    "vitest": "4.0.17",
+    "vitest": "4.1.5",
     "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0"
   },
@@ -22,7 +23,9 @@
     "./abortable": "./dist/abortable.mjs",
     "./array-equal": "./dist/array-equal.mjs",
     "./assertions": "./dist/assertions.mjs",
+    "./canonical-stringify": "./dist/canonical-stringify.mjs",
     "./defined": "./dist/defined.mjs",
+    "./hash-content": "./dist/hash-content.mjs",
     "./redact-db-url": "./dist/redact-db-url.mjs",
     "./result": "./dist/result.mjs",
     "./simplify-deep": "./dist/simplify-deep.mjs",

package/src/canonical-stringify.ts

@@ -0,0 +1,158 @@
+/**
+ * Produces a deterministic, JSON-like string representation of a value.
+ *
+ * Designed for use as a stable identity / cache key. Two values that are
+ * structurally equivalent — regardless of object key insertion order —
+ * produce the same string. Two values that differ in any meaningful way
+ * (including types that JSON would conflate, like `BigInt(1)` vs `1`)
+ * produce different strings.
+ *
+ * Supported inputs:
+ * - `null`, `undefined` (distinguishable: `null` → `"null"`, `undefined` → `"undefined"`)
+ * - `boolean`, `string`, `number` (including `NaN`, `Infinity`, `-Infinity`)
+ * - `bigint` (suffixed with `n` to disambiguate from `number`)
+ * - `Date` (tagged + ISO string)
+ * - `Buffer` / `Uint8Array` (tagged + hex-encoded as `Bytes(<hex>)`)
+ * - Other `ArrayBuffer` views — `Int8Array`, `Uint16Array`, `Float64Array`,
+ *   `DataView`, etc. (tagged with the constructor name + hex-encoded over
+ *   the underlying bytes, e.g. `Uint16Array(<hex>)`). Note that the bytes
+ *   are read in host byte order, so callers that need cross-platform
+ *   stability for multi-byte typed arrays should normalize endianness
+ *   before passing the value in.
+ * - Arrays (order-preserving)
+ * - Plain objects (key-sorted) — only objects whose prototype is
+ *   `Object.prototype` or `null`. Non-plain objects (`Map`, `Set`,
+ *   `RegExp`, class instances, etc.) are rejected so they cannot silently
+ *   collapse to `{}` and collide with each other.
+ *
+ * Throws on `function`, `symbol`, circular references, non-plain objects,
+ * and objects with symbol-keyed properties (which `Object.keys` would
+ * silently drop). Callers that need to canonicalize any of these must
+ * convert them to a supported representation first.
+ *
+ * The output format is intentionally not JSON: the type tags and BigInt
+ * suffix mean it cannot be round-tripped via `JSON.parse`. The goal is
+ * keying, not serialization.
+ *
+ * @example
+ * ```typescript
+ * canonicalStringify({ a: 1, b: 2 }) === canonicalStringify({ b: 2, a: 1 })
+ * // → true
+ *
+ * canonicalStringify(1n) !== canonicalStringify(1)
+ * // → true
+ * ```
+ */
+export function canonicalStringify(value: unknown): string {
+  return write(value, new Set());
+}
+
+function write(value: unknown, seen: Set<object>): string {
+  if (value === null) return 'null';
+  if (value === undefined) return 'undefined';
+
+  switch (typeof value) {
+    case 'boolean':
+      return value ? 'true' : 'false';
+    case 'number':
+      return writeNumber(value);
+    case 'bigint':
+      return `${value.toString()}n`;
+    case 'string':
+      return JSON.stringify(value);
+    case 'function':
+      throw new TypeError('canonicalStringify: functions are not supported');
+    case 'symbol':
+      throw new TypeError('canonicalStringify: symbols are not supported');
+  }
+
+  // From here, value is a non-null object.
+  const obj = value as object;
+
+  // Leaf object types are handled before touching `seen`: they can never
+  // contain back-references, so cycle tracking is wasted work for them.
+  if (value instanceof Date) {
+    return `Date(${value.toISOString()})`;
+  }
+
+  // `Buffer` is a `Uint8Array` subclass; this branch covers both, and
+  // emits the legacy `Bytes(<hex>)` tag so a `Buffer` and a same-content
+  // `Uint8Array` digest identically.
+  if (value instanceof Uint8Array) {
+    return `Bytes(${bytesToHex(value)})`;
+  }
+
+  // Any other `ArrayBuffer` view — typed arrays (`Int8Array`,
+  // `Uint16Array`, `Float64Array`, …) and `DataView`. Without this
+  // branch they would fall through to the plain-object writer and
+  // canonicalize as `{"0":1,"1":2,...}`, which would silently collide
+  // with a same-keyed plain object. Tagging by constructor name keeps
+  // distinct view families distinct.
+  if (ArrayBuffer.isView(value)) {
+    const tag = value.constructor.name;
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    return `${tag}(${bytesToHex(bytes)})`;
+  }
+
+  if (seen.has(obj)) {
+    throw new TypeError('canonicalStringify: circular reference detected');
+  }
+  seen.add(obj);
+  try {
+    if (Array.isArray(value)) {
+      const parts = value.map((item) => write(item, seen));
+      return `[${parts.join(',')}]`;
+    }
+
+    return writePlainObject(obj as Record<string, unknown>, seen);
+  } finally {
+    seen.delete(obj);
+  }
+}
+
+function writeNumber(value: number): string {
+  if (Number.isNaN(value)) return 'NaN';
+  if (value === Number.POSITIVE_INFINITY) return 'Infinity';
+  if (value === Number.NEGATIVE_INFINITY) return '-Infinity';
+  // Distinguish `+0` from `-0` so they hash differently.
+  if (value === 0 && 1 / value === Number.NEGATIVE_INFINITY) return '-0';
+  return String(value);
+}
+
+function writePlainObject(obj: Record<string, unknown>, seen: Set<object>): string {
+  // Only true plain objects are accepted here. Without this guard, anything
+  // that fell through the type-tagged branches above (`Map`, `Set`,
+  // `RegExp`, class instances, …) would canonicalize to `{}` because
+  // `Object.keys` returns no enumerable string keys for them — silently
+  // colliding with each other and with the literal `{}`.
+  const proto = Object.getPrototypeOf(obj);
+  if (proto !== Object.prototype && proto !== null) {
+    const tag = proto?.constructor?.name ?? 'unknown';
+    throw new TypeError(`canonicalStringify: non-plain objects are not supported (got ${tag})`);
+  }
+
+  // `Object.keys` ignores symbol-keyed properties, so they would be
+  // silently dropped from the canonical form. Force callers to handle
+  // them explicitly instead of producing a key that omits real data.
+  if (Object.getOwnPropertySymbols(obj).length > 0) {
+    throw new TypeError(
+      'canonicalStringify: objects with symbol-keyed properties are not supported',
+    );
+  }
+
+  const keys = Object.keys(obj).sort();
+  const parts: string[] = [];
+  for (const key of keys) {
+    parts.push(`${JSON.stringify(key)}:${write(obj[key], seen)}`);
+  }
+  return `{${parts.join(',')}}`;
+}
+
+function bytesToHex(bytes: Uint8Array): string {
+  let out = '';
+  for (let i = 0; i < bytes.length; i++) {
+    const byte = bytes[i] as number;
+    out += byte.toString(16).padStart(2, '0');
+  }
+  return out;
+}

package/src/exports/canonical-stringify.ts

@@ -0,0 +1 @@
+export { canonicalStringify } from '../canonical-stringify';

package/src/exports/hash-content.ts

@@ -0,0 +1 @@
+export { hashContent } from '../hash-content';

package/src/hash-content.ts

@@ -0,0 +1,59 @@
+/**
+ * Hashes a canonical-string representation of an execution into a bounded,
+ * opaque cache-key digest.
+ *
+ * Designed for use as the final step of `RuntimeMiddlewareContext.contentHash`
+ * implementations: family runtimes compose a canonical string from
+ * `meta.storageHash`, the rendered statement (or wire command), and
+ * canonicalized parameters via `canonicalStringify`, then pipe the result
+ * through this helper.
+ *
+ * Why hash the canonical string instead of using it directly as a `Map` key:
+ *
+ * 1. **Bounded memory.** A raw canonical key includes concrete parameter
+ *    values, so a query bound to a 10 MB JSON column or binary blob produces
+ *    a 10 MB cache key. With `maxEntries = 1000`, that scales to gigabytes
+ *    of cache keys alone. SHA-512 pins per-key cost at a fixed digest
+ *    length regardless of input size.
+ *
+ * 2. **Sensitive-data isolation.** The canonical string contains parameter
+ *    values verbatim. Cache keys flow into debug logs, Redis `KEYS`/`MONITOR`
+ *    output, persistence dumps, monitoring tools, and any user-supplied
+ *    `CacheStore` implementation. Hashing prevents PII / credentials /
+ *    tokens that appear in query parameters from showing up in any of those
+ *    surfaces.
+ *
+ * Algorithm choice — SHA-512 (`SHA-512` via the WebCrypto API):
+ *
+ * - **Portability.** WebCrypto (`globalThis.crypto.subtle`) is available in
+ *   every modern JavaScript runtime — Node, Deno, Bun, browsers, edge
+ *   workers — without importing a Node-specific module. This keeps the
+ *   helper usable in non-Node hosts where `node:crypto` is not available.
+ * - **Collision space.** 512 bits of output makes accidental collisions
+ *   astronomically improbable — far beyond what a cache needs, but the
+ *   incremental cost over 256-bit output is negligible and the headroom
+ *   is free.
+ * - **No additional dependency.** SHA-512 is part of the WebCrypto standard
+ *   set of digest algorithms; no third-party package needed.
+ *
+ * The function is `async` because the WebCrypto digest API is async by
+ * design. Callers must await the result.
+ *
+ * Output format: `sha512:HEXDIGEST` (128-char hex with the algorithm tag
+ * prefix). Self-describing so a future migration to a different hash
+ * produces visibly distinct keys, and consistent with the
+ * `sha256:HEXDIGEST` shape already used by `meta.storageHash`.
+ *
+ * @example
+ * ```typescript
+ * const canonical = `${exec.meta.storageHash}|${exec.sql}|${canonicalStringify(exec.params)}`;
+ * return await hashContent(canonical);
+ * // → 'sha512:8f3...e1c' (always 135 chars: 'sha512:' + 128 hex chars)
+ * ```
+ */
+export async function hashContent(value: string): Promise<string> {
+  const bytes = new TextEncoder().encode(value);
+  const digest = await crypto.subtle.digest('SHA-512', bytes);
+  const hex = Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, '0')).join('');
+  return `sha512:${hex}`;
+}