@prisma-next/utils 0.3.0-dev.8 → 0.3.0-dev.81

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2026] [Prisma Data, Inc]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/abortable.d.mts

@@ -0,0 +1,28 @@
+//#region src/abortable.d.ts
+/**
+ * Allows aborting an async operation by returning a Promise which rejects if
+ * the provided AbortSignal aborts and otherwise resolves with the result of
+ * the async operation.
+ *
+ * Throws immediately if the signal is already aborted.
+ * When the signal is aborted later, any wrapped promise will reject with
+ * the signal's reason (or a default DOMException).
+ *
+ * @example
+ * ```typescript
+ * const { signal = new AbortController().signal } = options;
+ * const unlessAborted = abortable(signal);
+ *
+ * // Any of these will reject if signal is aborted
+ * await unlessAborted(asyncOperation());
+ * await unlessAborted(fetch(url));
+ * ```
+ *
+ * @param signal - The AbortSignal to race against
+ * @returns A function that wraps promises to be cancelable
+ * @throws If signal is already aborted
+ */
+declare function abortable(signal: AbortSignal): <T>(promise: Promise<T>) => Promise<T>;
+//#endregion
+export { abortable };
+//# sourceMappingURL=abortable.d.mts.map

package/dist/abortable.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abortable.d.mts","names":[],"sources":["../src/abortable.ts"],"sourcesContent":[],"mappings":";;AAuBA;;;;;;;;;;;;;;;;;;;;;;iBAAgB,SAAA,SAAkB,2BAA2B,QAAQ,OAAO,QAAQ"}

package/dist/abortable.mjs

@@ -0,0 +1,39 @@
+//#region src/abortable.ts
+/**
+* Allows aborting an async operation by returning a Promise which rejects if
+* the provided AbortSignal aborts and otherwise resolves with the result of
+* the async operation.
+*
+* Throws immediately if the signal is already aborted.
+* When the signal is aborted later, any wrapped promise will reject with
+* the signal's reason (or a default DOMException).
+*
+* @example
+* ```typescript
+* const { signal = new AbortController().signal } = options;
+* const unlessAborted = abortable(signal);
+*
+* // Any of these will reject if signal is aborted
+* await unlessAborted(asyncOperation());
+* await unlessAborted(fetch(url));
+* ```
+*
+* @param signal - The AbortSignal to race against
+* @returns A function that wraps promises to be cancelable
+* @throws If signal is already aborted
+*/
+function abortable(signal) {
+	signal.throwIfAborted();
+	const abortPromise = new Promise((_resolve, reject) => {
+		signal.addEventListener("abort", () => {
+			reject(signal.reason ?? new DOMException("Operation cancelled"));
+		}, { once: true });
+	});
+	return (operation) => {
+		return Promise.race([operation, abortPromise]);
+	};
+}
+
+//#endregion
+export { abortable };
+//# sourceMappingURL=abortable.mjs.map

package/dist/abortable.mjs.map

@@ -0,0 +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"}

package/dist/{array-equal.d.ts → array-equal.d.mts}

@@ -1,3 +1,4 @@
+//#region src/array-equal.d.ts
 /**
  * Checks if two arrays are equal using Object.is() for element comparison.
  * Arrays are considered equal if they have the same length and each element
@@ -14,5 +15,7 @@
  * isArrayEqual([0], [-0]); // false (Object.is distinguishes +0 and -0)
  * ```
  */
-export declare function isArrayEqual<T>(a: readonly T[], b: readonly T[]): boolean;
-//# sourceMappingURL=array-equal.d.ts.map
+declare function isArrayEqual<T>(a: readonly T[], b: readonly T[]): boolean;
+//#endregion
+export { isArrayEqual };
+//# sourceMappingURL=array-equal.d.mts.map

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

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

package/dist/array-equal.mjs

@@ -0,0 +1,26 @@
+//#region src/array-equal.ts
+/**
+* Checks if two arrays are equal using Object.is() for element comparison.
+* Arrays are considered equal if they have the same length and each element
+* at corresponding indices is equal according to Object.is().
+*
+* @param a - First array to compare
+* @param b - Second array to compare
+* @returns true if arrays are equal, false otherwise
+*
+* @example
+* ```typescript
+* isArrayEqual(['a', 'b'], ['a', 'b']); // true
+* isArrayEqual(['a'], ['a', 'b']); // false
+* isArrayEqual([0], [-0]); // false (Object.is distinguishes +0 and -0)
+* ```
+*/
+function isArrayEqual(a, b) {
+	if (a.length !== b.length) return false;
+	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

@@ -0,0 +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"}

package/dist/assertions.d.mts

@@ -0,0 +1,30 @@
+//#region src/assertions.d.ts
+/**
+ * Asserts that a value is defined (not null or undefined).
+ * Use for invariants where the value should always exist at runtime.
+ *
+ * @throws Error if value is null or undefined
+ *
+ * @example
+ * ```typescript
+ * const table = storage.tables[tableName];
+ * assertDefined(table, `Table "${tableName}" not found`);
+ * // table is now narrowed to non-nullable
+ * ```
+ */
+declare function assertDefined<T>(value: T | null | undefined, message: string): asserts value is T;
+/**
+ * Asserts that a condition is true.
+ * Use for invariants that should always hold at runtime.
+ *
+ * @throws Error if condition is false
+ *
+ * @example
+ * ```typescript
+ * invariant(columns.length > 0, 'Primary key must have at least one column');
+ * ```
+ */
+declare function invariant(condition: boolean, message: string): asserts condition;
+//#endregion
+export { assertDefined, invariant };
+//# sourceMappingURL=assertions.d.mts.map

package/dist/assertions.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertions.d.mts","names":[],"sources":["../src/assertions.ts"],"sourcesContent":[],"mappings":";;AAaA;AAiBA;;;;;;;;;;;iBAjBgB,wBAAwB,yDAAyD;;;;;;;;;;;;iBAiBjF,SAAA"}

package/dist/assertions.mjs

@@ -0,0 +1,35 @@
+//#region src/assertions.ts
+/**
+* Asserts that a value is defined (not null or undefined).
+* Use for invariants where the value should always exist at runtime.
+*
+* @throws Error if value is null or undefined
+*
+* @example
+* ```typescript
+* const table = storage.tables[tableName];
+* assertDefined(table, `Table "${tableName}" not found`);
+* // table is now narrowed to non-nullable
+* ```
+*/
+function assertDefined(value, message) {
+	if (value === null || value === void 0) throw new Error(message);
+}
+/**
+* Asserts that a condition is true.
+* Use for invariants that should always hold at runtime.
+*
+* @throws Error if condition is false
+*
+* @example
+* ```typescript
+* invariant(columns.length > 0, 'Primary key must have at least one column');
+* ```
+*/
+function invariant(condition, message) {
+	if (!condition) throw new Error(message);
+}
+
+//#endregion
+export { assertDefined, invariant };
+//# sourceMappingURL=assertions.mjs.map

package/dist/assertions.mjs.map

@@ -0,0 +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"}

package/dist/defined-BSROFTyI.mjs

@@ -0,0 +1,30 @@
+//#region src/defined.ts
+/**
+* Returns an object with the key/value if value is defined, otherwise an empty object.
+*
+* Use with spread to conditionally include optional properties while satisfying
+* exactOptionalPropertyTypes. This is explicit about which properties are optional
+* and won't inadvertently strip other undefined values.
+*
+* @example
+* ```typescript
+* // Instead of:
+* const obj = {
+*   required: 'value',
+*   ...(optional ? { optional } : {}),
+* };
+*
+* // Use:
+* const obj = {
+*   required: 'value',
+*   ...ifDefined('optional', optional),
+* };
+* ```
+*/
+function ifDefined(key, value) {
+	return value !== void 0 ? { [key]: value } : {};
+}
+
+//#endregion
+export { ifDefined as t };
+//# sourceMappingURL=defined-BSROFTyI.mjs.map

package/dist/defined-BSROFTyI.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"defined-BSROFTyI.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"}

package/dist/{defined.d.ts → defined.d.mts}

@@ -1,3 +1,4 @@
+//#region src/defined.d.ts
 /**
  * Returns an object with the key/value if value is defined, otherwise an empty object.
  *
@@ -20,7 +21,7 @@
  * };
  * ```
  */
-export declare function ifDefined<K extends string, V>(key: K, value: V | undefined): Record<never, never> | {
-    [P in K]: V;
-};
-//# sourceMappingURL=defined.d.ts.map
+declare function ifDefined<K extends string, V>(key: K, value: V | undefined): Record<never, never> | { [P in K]: V };
+//#endregion
+export { ifDefined };
+//# sourceMappingURL=defined.d.mts.map

package/dist/defined.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defined.d.mts","names":[],"sources":["../src/defined.ts"],"sourcesContent":[],"mappings":";;AAsBA;;;;;;;;;;;;;;;;;;;;;iBAAgB,oCACT,UACE,gBACN,+BAA+B,IAAI"}

package/dist/defined.mjs

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

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

@@ -0,0 +1,21 @@
+//#region src/redact-db-url.d.ts
+/**
+ * Minimal metadata extracted from a database URL for logging or error output.
+ * Sensitive fields (password, full URL) are never returned.
+ */
+interface RedactedDatabaseUrl {
+  readonly host?: string;
+  readonly port?: string;
+  readonly database?: string;
+  readonly username?: string;
+}
+/**
+ * Redacts a database connection URL to a minimal metadata object.
+ *
+ * Parsing errors are ignored and result in an empty object so callers never
+ * leak raw URLs when the input is malformed.
+ */
+declare function redactDatabaseUrl(url: string): RedactedDatabaseUrl;
+//#endregion
+export { type RedactedDatabaseUrl, redactDatabaseUrl };
+//# sourceMappingURL=redact-db-url.d.mts.map

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

@@ -0,0 +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"}

package/dist/redact-db-url.mjs

@@ -0,0 +1,27 @@
+import { t as ifDefined } from "./defined-BSROFTyI.mjs";
+
+//#region src/redact-db-url.ts
+/**
+* Redacts a database connection URL to a minimal metadata object.
+*
+* Parsing errors are ignored and result in an empty object so callers never
+* leak raw URLs when the input is malformed.
+*/
+function redactDatabaseUrl(url) {
+	try {
+		const parsed = new URL(url);
+		const database = parsed.pathname?.replace(/^\//, "") || void 0;
+		return {
+			...ifDefined("host", parsed.hostname || void 0),
+			...ifDefined("port", parsed.port || void 0),
+			...ifDefined("database", database),
+			...ifDefined("username", parsed.username || void 0)
+		};
+	} catch {
+		return {};
+	}
+}
+
+//#endregion
+export { redactDatabaseUrl };
+//# sourceMappingURL=redact-db-url.mjs.map

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

@@ -0,0 +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"}

package/dist/{result.d.ts → result.d.mts}

@@ -1,3 +1,4 @@
+//#region src/result.d.ts
 /**
  * Generic Result type for representing success or failure outcomes.
  *
@@ -12,20 +13,20 @@
 /**
  * Represents a successful result containing a value.
  */
-export interface Ok<T> {
-    readonly ok: true;
-    readonly value: T;
-    assertOk(): T;
-    assertNotOk(): never;
+interface Ok<T> {
+  readonly ok: true;
+  readonly value: T;
+  assertOk(): T;
+  assertNotOk(): never;
 }
 /**
  * Represents an unsuccessful result containing failure details.
  */
-export interface NotOk<F> {
-    readonly ok: false;
-    readonly failure: F;
-    assertOk(): never;
-    assertNotOk(): F;
+interface NotOk<F> {
+  readonly ok: false;
+  readonly failure: F;
+  assertOk(): never;
+  assertNotOk(): F;
 }
 /**
  * A discriminated union representing either success (Ok) or failure (NotOk).
@@ -33,18 +34,20 @@ export interface NotOk<F> {
  * @typeParam T - The success value type
  * @typeParam F - The failure details type
  */
-export type Result<T, F> = Ok<T> | NotOk<F>;
+type Result<T, F> = Ok<T> | NotOk<F>;
 /**
  * Creates a successful result.
  */
-export declare function ok<T>(value: T): Ok<T>;
+declare function ok<T>(value: T): Ok<T>;
 /**
  * Creates an unsuccessful result.
  */
-export declare function notOk<F>(failure: F): NotOk<F>;
+declare function notOk<F>(failure: F): NotOk<F>;
 /**
  * Returns a successful void result.
  * Use this for validation checks that don't produce a value.
  */
-export declare function okVoid(): Ok<void>;
-//# sourceMappingURL=result.d.ts.map
+declare function okVoid(): Ok<void>;
+//#endregion
+export { type NotOk, type Ok, type Result, notOk, ok, okVoid };
+//# sourceMappingURL=result.d.mts.map

package/dist/result.d.mts.map

@@ -0,0 +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"}

package/dist/result.mjs

@@ -0,0 +1,79 @@
+//#region src/result.ts
+/**
+* Result class that implements both Ok and NotOk variants.
+*/
+var ResultImpl = class ResultImpl {
+	ok;
+	_value;
+	_failure;
+	constructor(ok$1, valueOrFailure) {
+		this.ok = ok$1;
+		if (ok$1) this._value = valueOrFailure;
+		else this._failure = valueOrFailure;
+		Object.freeze(this);
+	}
+	get value() {
+		if (!this.ok) throw new Error("Cannot access value on NotOk result");
+		return this._value;
+	}
+	get failure() {
+		if (this.ok) throw new Error("Cannot access failure on Ok result");
+		return this._failure;
+	}
+	/**
+	* Creates a successful result.
+	*/
+	static ok(value) {
+		return new ResultImpl(true, value);
+	}
+	/**
+	* Creates an unsuccessful result.
+	*/
+	static notOk(failure) {
+		return new ResultImpl(false, failure);
+	}
+	/**
+	* Asserts that this result is Ok and returns the value.
+	* Throws if the result is NotOk.
+	*/
+	assertOk() {
+		if (!this.ok) throw new Error("Expected Ok result but got NotOk");
+		return this.value;
+	}
+	/**
+	* Asserts that this result is NotOk and returns the failure.
+	* Throws if the result is Ok.
+	*/
+	assertNotOk() {
+		if (this.ok) throw new Error("Expected NotOk result but got Ok");
+		return this.failure;
+	}
+};
+/**
+* Creates a successful result.
+*/
+function ok(value) {
+	return ResultImpl.ok(value);
+}
+/**
+* Creates an unsuccessful result.
+*/
+function notOk(failure) {
+	return ResultImpl.notOk(failure);
+}
+/**
+* Singleton for void success results.
+* Use this for validation checks that don't produce a value.
+*/
+const OK_VOID = ResultImpl.ok(void 0);
+/**
+* Returns a successful void result.
+* Use this for validation checks that don't produce a value.
+*/
+function okVoid() {
+	return OK_VOID;
+}
+
+//#endregion
+export { notOk, ok, okVoid };
+//# sourceMappingURL=result.mjs.map

package/dist/result.mjs.map

@@ -0,0 +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"}

package/package.json

@@ -1,43 +1,43 @@
 {
   "name": "@prisma-next/utils",
-  "version": "0.3.0-dev.8",
+  "version": "0.3.0-dev.81",
   "type": "module",
   "sideEffects": false,
   "description": "Shared utility functions for Prisma Next",
   "devDependencies": {
-    "@vitest/coverage-v8": "4.0.16",
-    "tsup": "8.5.1",
+    "tsdown": "0.18.4",
     "typescript": "5.9.3",
-    "vitest": "4.0.16"
+    "vitest": "4.0.17",
+    "@prisma-next/tsconfig": "0.0.0",
+    "@prisma-next/tsdown": "0.0.0"
   },
   "files": [
     "dist",
     "src"
   ],
+  "engines": {
+    "node": ">=20"
+  },
   "exports": {
-    "./array-equal": {
-      "types": "./dist/exports/array-equal.d.ts",
-      "import": "./dist/exports/array-equal.js"
-    },
-    "./defined": {
-      "types": "./dist/exports/defined.d.ts",
-      "import": "./dist/exports/defined.js"
-    },
-    "./result": {
-      "types": "./dist/exports/result.d.ts",
-      "import": "./dist/exports/result.js"
-    },
-    "./redact-db-url": {
-      "types": "./dist/exports/redact-db-url.d.ts",
-      "import": "./dist/exports/redact-db-url.js"
-    }
+    "./abortable": "./dist/abortable.mjs",
+    "./array-equal": "./dist/array-equal.mjs",
+    "./assertions": "./dist/assertions.mjs",
+    "./defined": "./dist/defined.mjs",
+    "./redact-db-url": "./dist/redact-db-url.mjs",
+    "./result": "./dist/result.mjs",
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/1-framework/1-core/shared/utils"
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
+    "build": "tsdown",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --project tsconfig.json --noEmit",
-    "lint": "biome check . --config-path ../../../../../biome.json --error-on-warnings",
-    "clean": "node ../../../../../scripts/clean.mjs"
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check . --error-on-warnings",
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
   }
 }

package/src/abortable.ts

@@ -0,0 +1,40 @@
+/**
+ * Allows aborting an async operation by returning a Promise which rejects if
+ * the provided AbortSignal aborts and otherwise resolves with the result of
+ * the async operation.
+ *
+ * Throws immediately if the signal is already aborted.
+ * When the signal is aborted later, any wrapped promise will reject with
+ * the signal's reason (or a default DOMException).
+ *
+ * @example
+ * ```typescript
+ * const { signal = new AbortController().signal } = options;
+ * const unlessAborted = abortable(signal);
+ *
+ * // Any of these will reject if signal is aborted
+ * await unlessAborted(asyncOperation());
+ * await unlessAborted(fetch(url));
+ * ```
+ *
+ * @param signal - The AbortSignal to race against
+ * @returns A function that wraps promises to be cancelable
+ * @throws If signal is already aborted
+ */
+export function abortable(signal: AbortSignal): <T>(promise: Promise<T>) => Promise<T> {
+  signal.throwIfAborted();
+
+  const abortPromise = new Promise<never>((_resolve, reject) => {
+    signal.addEventListener(
+      'abort',
+      () => {
+        reject(signal.reason ?? new DOMException('Operation cancelled'));
+      },
+      { once: true },
+    );
+  });
+
+  return <T>(operation: Promise<T>): Promise<T> => {
+    return Promise.race([operation, abortPromise]);
+  };
+}

package/src/assertions.ts

@@ -0,0 +1,35 @@
+/**
+ * Asserts that a value is defined (not null or undefined).
+ * Use for invariants where the value should always exist at runtime.
+ *
+ * @throws Error if value is null or undefined
+ *
+ * @example
+ * ```typescript
+ * const table = storage.tables[tableName];
+ * assertDefined(table, `Table "${tableName}" not found`);
+ * // table is now narrowed to non-nullable
+ * ```
+ */
+export function assertDefined<T>(value: T | null | undefined, message: string): asserts value is T {
+  if (value === null || value === undefined) {
+    throw new Error(message);
+  }
+}
+
+/**
+ * Asserts that a condition is true.
+ * Use for invariants that should always hold at runtime.
+ *
+ * @throws Error if condition is false
+ *
+ * @example
+ * ```typescript
+ * invariant(columns.length > 0, 'Primary key must have at least one column');
+ * ```
+ */
+export function invariant(condition: boolean, message: string): asserts condition {
+  if (!condition) {
+    throw new Error(message);
+  }
+}

package/src/exports/abortable.ts

@@ -0,0 +1 @@
+export { abortable } from '../abortable';

package/src/exports/assertions.ts

@@ -0,0 +1 @@
+export { assertDefined, invariant } from '../assertions';

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

@@ -1 +0,0 @@
-{"version":3,"file":"array-equal.d.ts","sourceRoot":"","sources":["../src/array-equal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,GAAG,OAAO,CAUzE"}

package/dist/chunk-ZDWVVJU6.js

@@ -1,9 +0,0 @@
-// src/defined.ts
-function ifDefined(key, value) {
-  return value !== void 0 ? { [key]: value } : {};
-}
-
-export {
-  ifDefined
-};
-//# sourceMappingURL=chunk-ZDWVVJU6.js.map

package/dist/chunk-ZDWVVJU6.js.map

@@ -1 +0,0 @@
-{"version":3,"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":";AAsBO,SAAS,UACd,KACA,OACwC;AACxC,SAAO,UAAU,SAAa,EAAE,CAAC,GAAG,GAAG,MAAM,IAAwB,CAAC;AACxE;","names":[]}

package/dist/defined.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defined.d.ts","sourceRoot":"","sources":["../src/defined.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAC3C,GAAG,EAAE,CAAC,EACN,KAAK,EAAE,CAAC,GAAG,SAAS,GACnB,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG;KAAG,CAAC,IAAI,CAAC,GAAG,CAAC;CAAE,CAExC"}

package/dist/exports/array-equal.d.ts

@@ -1,2 +0,0 @@
-export { isArrayEqual } from '../array-equal';
-//# sourceMappingURL=array-equal.d.ts.map

package/dist/exports/array-equal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array-equal.d.ts","sourceRoot":"","sources":["../../src/exports/array-equal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/exports/array-equal.js

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

package/dist/exports/array-equal.js.map

@@ -1 +0,0 @@
-{"version":3,"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":";AAgBO,SAAS,aAAgB,GAAiB,GAA0B;AACzE,MAAI,EAAE,WAAW,EAAE,QAAQ;AACzB,WAAO;AAAA,EACT;AACA,WAAS,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AACjC,QAAI,CAAC,OAAO,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG;AAC1B,aAAO;AAAA,IACT;AAAA,EACF;AACA,SAAO;AACT;","names":[]}

package/dist/exports/defined.d.ts

@@ -1,2 +0,0 @@
-export { ifDefined } from '../defined';
-//# sourceMappingURL=defined.d.ts.map

package/dist/exports/defined.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defined.d.ts","sourceRoot":"","sources":["../../src/exports/defined.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC"}

package/dist/exports/defined.js

@@ -1,7 +0,0 @@
-import {
-  ifDefined
-} from "../chunk-ZDWVVJU6.js";
-export {
-  ifDefined
-};
-//# sourceMappingURL=defined.js.map

package/dist/exports/defined.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/exports/redact-db-url.d.ts

@@ -1,3 +0,0 @@
-export type { RedactedDatabaseUrl } from '../redact-db-url';
-export { redactDatabaseUrl } from '../redact-db-url';
-//# sourceMappingURL=redact-db-url.d.ts.map

package/dist/exports/redact-db-url.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"redact-db-url.d.ts","sourceRoot":"","sources":["../../src/exports/redact-db-url.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/exports/redact-db-url.js

@@ -1,23 +0,0 @@
-import {
-  ifDefined
-} from "../chunk-ZDWVVJU6.js";
-
-// src/redact-db-url.ts
-function redactDatabaseUrl(url) {
-  try {
-    const parsed = new URL(url);
-    const database = parsed.pathname?.replace(/^\//, "") || void 0;
-    return {
-      ...ifDefined("host", parsed.hostname || void 0),
-      ...ifDefined("port", parsed.port || void 0),
-      ...ifDefined("database", database),
-      ...ifDefined("username", parsed.username || void 0)
-    };
-  } catch {
-    return {};
-  }
-}
-export {
-  redactDatabaseUrl
-};
-//# sourceMappingURL=redact-db-url.js.map

package/dist/exports/redact-db-url.js.map

@@ -1 +0,0 @@
-{"version":3,"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":";;;;;AAmBO,SAAS,kBAAkB,KAAkC;AAClE,MAAI;AACF,UAAM,SAAS,IAAI,IAAI,GAAG;AAC1B,UAAM,WAAW,OAAO,UAAU,QAAQ,OAAO,EAAE,KAAK;AACxD,WAAO;AAAA,MACL,GAAG,UAAU,QAAQ,OAAO,YAAY,MAAS;AAAA,MACjD,GAAG,UAAU,QAAQ,OAAO,QAAQ,MAAS;AAAA,MAC7C,GAAG,UAAU,YAAY,QAAQ;AAAA,MACjC,GAAG,UAAU,YAAY,OAAO,YAAY,MAAS;AAAA,IACvD;AAAA,EACF,QAAQ;AAEN,WAAO,CAAC;AAAA,EACV;AACF;","names":[]}

package/dist/exports/result.d.ts

@@ -1,3 +0,0 @@
-export type { NotOk, Ok, Result } from '../result';
-export { notOk, ok, okVoid } from '../result';
-//# sourceMappingURL=result.d.ts.map

package/dist/exports/result.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/exports/result.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC"}

package/dist/exports/result.js

@@ -1,75 +0,0 @@
-// src/result.ts
-var ResultImpl = class _ResultImpl {
-  ok;
-  _value;
-  _failure;
-  constructor(ok2, valueOrFailure) {
-    this.ok = ok2;
-    if (ok2) {
-      this._value = valueOrFailure;
-    } else {
-      this._failure = valueOrFailure;
-    }
-    Object.freeze(this);
-  }
-  get value() {
-    if (!this.ok) {
-      throw new Error("Cannot access value on NotOk result");
-    }
-    return this._value;
-  }
-  get failure() {
-    if (this.ok) {
-      throw new Error("Cannot access failure on Ok result");
-    }
-    return this._failure;
-  }
-  /**
-   * Creates a successful result.
-   */
-  static ok(value) {
-    return new _ResultImpl(true, value);
-  }
-  /**
-   * Creates an unsuccessful result.
-   */
-  static notOk(failure) {
-    return new _ResultImpl(false, failure);
-  }
-  /**
-   * Asserts that this result is Ok and returns the value.
-   * Throws if the result is NotOk.
-   */
-  assertOk() {
-    if (!this.ok) {
-      throw new Error("Expected Ok result but got NotOk");
-    }
-    return this.value;
-  }
-  /**
-   * Asserts that this result is NotOk and returns the failure.
-   * Throws if the result is Ok.
-   */
-  assertNotOk() {
-    if (this.ok) {
-      throw new Error("Expected NotOk result but got Ok");
-    }
-    return this.failure;
-  }
-};
-function ok(value) {
-  return ResultImpl.ok(value);
-}
-function notOk(failure) {
-  return ResultImpl.notOk(failure);
-}
-var OK_VOID = ResultImpl.ok(void 0);
-function okVoid() {
-  return OK_VOID;
-}
-export {
-  notOk,
-  ok,
-  okVoid
-};
-//# sourceMappingURL=result.js.map

package/dist/exports/result.js.map

@@ -1 +0,0 @@
-{"version":3,"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,YAAiB;AAAA,EACZ;AAAA,EACQ;AAAA,EACA;AAAA,EAET,YAAYA,KAAa,gBAAuB;AACtD,SAAK,KAAKA;AACV,QAAIA,KAAI;AACN,WAAK,SAAS;AAAA,IAChB,OAAO;AACL,WAAK,WAAW;AAAA,IAClB;AACA,WAAO,OAAO,IAAI;AAAA,EACpB;AAAA,EAEA,IAAI,QAAW;AACb,QAAI,CAAC,KAAK,IAAI;AACZ,YAAM,IAAI,MAAM,qCAAqC;AAAA,IACvD;AAEA,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,IAAI,UAAa;AACf,QAAI,KAAK,IAAI;AACX,YAAM,IAAI,MAAM,oCAAoC;AAAA,IACtD;AAEA,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,OAAO,GAAiB,OAAiB;AAGvC,WAAO,IAAI,YAAiB,MAAM,KAAK;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA,EAKA,OAAO,MAA8B,SAAsB;AAGzD,WAAO,IAAI,YAAiB,OAAO,OAAO;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,WAAgC;AAC9B,QAAI,CAAC,KAAK,IAAI;AACZ,YAAM,IAAI,MAAM,kCAAkC;AAAA,IACpD;AACA,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,cAAmC;AACjC,QAAI,KAAK,IAAI;AACX,YAAM,IAAI,MAAM,kCAAkC;AAAA,IACpD;AACA,WAAO,KAAK;AAAA,EACd;AACF;AAKO,SAAS,GAAM,OAAiB;AACrC,SAAO,WAAW,GAAG,KAAK;AAC5B;AAKO,SAAS,MAAS,SAAsB;AAC7C,SAAO,WAAW,MAAM,OAAO;AACjC;AAMA,IAAM,UAAoB,WAAW,GAAS,MAAS;AAMhD,SAAS,SAAmB;AACjC,SAAO;AACT;","names":["ok"]}

package/dist/redact-db-url.d.ts

@@ -1,18 +0,0 @@
-/**
- * Minimal metadata extracted from a database URL for logging or error output.
- * Sensitive fields (password, full URL) are never returned.
- */
-export interface RedactedDatabaseUrl {
-    readonly host?: string;
-    readonly port?: string;
-    readonly database?: string;
-    readonly username?: string;
-}
-/**
- * Redacts a database connection URL to a minimal metadata object.
- *
- * Parsing errors are ignored and result in an empty object so callers never
- * leak raw URLs when the input is malformed.
- */
-export declare function redactDatabaseUrl(url: string): RedactedDatabaseUrl;
-//# sourceMappingURL=redact-db-url.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"redact-db-url.d.ts","sourceRoot":"","sources":["../src/redact-db-url.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB,CAclE"}

package/dist/result.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../src/result.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;GAEG;AACH,MAAM,WAAW,EAAE,CAAC,CAAC;IACnB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,QAAQ,IAAI,CAAC,CAAC;IACd,WAAW,IAAI,KAAK,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB,QAAQ,IAAI,KAAK,CAAC;IAClB,WAAW,IAAI,CAAC,CAAC;CAClB;AAED;;;;;GAKG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AA6E5C;;GAEG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAErC;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAE7C;AAQD;;;GAGG;AACH,wBAAgB,MAAM,IAAI,EAAE,CAAC,IAAI,CAAC,CAEjC"}