wellcrafted 0.33.0 → 0.34.0

package/dist/error/index.d.ts

@@ -1,18 +1,7 @@
-import { Err } from "../result-DolxQXIZ.js";
+import { Err } from "../result-BgPMmUXd.js";
 
 //#region src/error/types.d.ts
 
-/**
- * JSON-serializable value types for error context.
- * Ensures all error data can be safely serialized via JSON.stringify.
- */
-type JsonValue = string | number | boolean | null | JsonValue[] | {
-  [key: string]: JsonValue;
-};
-/**
- * JSON-serializable object type for error context.
- */
-type JsonObject = Record<string, JsonValue>;
 /**
  * Base type for any tagged error, used as a minimum constraint.
  */
@@ -63,12 +52,16 @@ type InferErrors<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => Err<in
  * @example
  * ```ts
  * const HttpError = defineErrors({
- *   Connection: ({ cause }: { cause: string }) => ({
- *     message: `Failed to connect: ${cause}`,
+ *   Connection: ({ cause }: { cause: unknown }) => ({
+ *     message: `Failed to connect: ${extractErrorMessage(cause)}`,
  *     cause,
  *   }),
- *   Parse: ({ cause }: { cause: string }) => ({
- *     message: `Failed to parse: ${cause}`,
+ *   Response: ({ status }: { status: number; bodyMessage?: string }) => ({
+ *     message: `HTTP ${status}`,
+ *     status,
+ *   }),
+ *   Parse: ({ cause }: { cause: unknown }) => ({
+ *     message: `Failed to parse response body: ${extractErrorMessage(cause)}`,
  *     cause,
  *   }),
  * });
@@ -77,6 +70,30 @@ type InferErrors<T> = { [K in keyof T]: T[K] extends ((...args: any[]) => Err<in
  *
  * const result = HttpError.Connection({ cause: 'timeout' }); // Err<...>
  * ```
+ *
+ * Inspired by Rust's {@link https://docs.rs/thiserror | thiserror} crate. The
+ * mapping is nearly 1:1:
+ *
+ * - `enum HttpError` → `const HttpError = defineErrors(...)`
+ * - Variant `Connection { cause: String }` → key `Connection: ({ cause }: { cause: unknown }) => (...)`
+ * - `#[error("Failed: {cause}")]` → `` message: `Failed: ${extractErrorMessage(cause)}` ``
+ * - `HttpError::Connection { ... }` → `HttpError.Connection({ ... })`
+ * - `match error { Connection { .. } => }` → `switch (error.name) { case 'Connection': }`
+ *
+ * The equivalent Rust `thiserror` enum:
+ * ```rust
+ * #[derive(Error, Debug)]
+ * enum HttpError {
+ *     #[error("Failed to connect: {cause}")]
+ *     Connection { cause: String },
+ *
+ *     #[error("HTTP {status}")]
+ *     Response { status: u16, body_message: Option<String> },
+ *
+ *     #[error("Failed to parse response body: {cause}")]
+ *     Parse { cause: String },
+ * }
+ * ```
  */
 declare function defineErrors<const TConfig extends ErrorsConfig>(config: TConfig & ValidatedConfig<TConfig>): DefineErrorsReturn<TConfig>;
 //# sourceMappingURL=defineErrors.d.ts.map
@@ -92,5 +109,5 @@ declare function extractErrorMessage(error: unknown): string;
 //# sourceMappingURL=extractErrorMessage.d.ts.map
 
 //#endregion
-export { AnyTaggedError, DefineErrorsReturn, ErrorBody, ErrorsConfig, InferError, InferErrors, JsonObject, JsonValue, ValidatedConfig, defineErrors, extractErrorMessage };
+export { AnyTaggedError, DefineErrorsReturn, ErrorBody, ErrorsConfig, InferError, InferErrors, ValidatedConfig, defineErrors, extractErrorMessage };
 //# sourceMappingURL=index.d.ts.map

package/dist/error/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/error/types.ts","../../src/error/defineErrors.ts","../../src/error/extractErrorMessage.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/error/types.ts","../../src/error/defineErrors.ts","../../src/error/extractErrorMessage.ts"],"sourcesContent":[],"mappings":";;;;;;AAKA;AAWY,KAXA,cAAA,GAWS;EAMhB,IAAA,EAAA,MAAA;EAOO,OAAA,EAAA,MAAY;CAAA;;;AAAS;AAGjC;;AAAsC,KAhB1B,SAAA,GAgB0B;EAAY,OAErC,EAAA,MAAA;CAAC;;;;;KAZT,iBAamB,CAAA,UAAA,MAAA,CAAA,GAAA;EAAiB,OACrC,EAAA,MAAA;EAAC,IAAC,CAAA,EAAA,kCAZoC,CAYpC,eAAA;AAAC,CAAA;AACL;AAGe,KAXL,YAAA,GAAe,MAWV,CAAA,MAAA,EAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAX6C,SAW7C,CAAA;;AAKV,KAbK,eAaL,CAAA,UAb+B,YAa/B,CAAA,GAAA,QACe,MAZT,CAYS,GAAA,MAAA,GAZI,CAYJ,CAZM,CAYN,CAAA,UAAA,CAAA,GAAA,IAAA,EAAA,KAAA,EAAA,EAAA,GAAA,KAAA,EAAA,IAAA,CAAA,GAAA,IAAA,EAXR,CAWQ,EAAA,GAXF,CAWE,GAXE,iBAWF,CAXoB,CAWpB,CAAA,GAVlB,CAUkB,CAVhB,CAUgB,CAAA,EAAG;;KANpB,YAO2C,CAAA,cAAA,MAAA,EAAA,YAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAJf,SAIe,CAAA,GAAA,QAFzC,KAE8B,GAAA,CAAA,GAAA,IAAA,EAD1B,UAC0B,CADf,GACe,CAAA,EAAA,GAA/B,GAA+B,CAA3B,QAA2B,CAAA;EAA3B,IAAA,EAAiB,KAAjB;AAAQ,CAAA,GAAmB,UAA/B,CAA0C,GAA1C,CAAA,CAAA,CAAA,EAAG;AAAA,KAIJ,mBAAA,CAAA,CAAmB,CAAA,GAAA,CAAO,CAAP,SAAA,GAAA,GAAA,CAAA,CAAA,EAA2B,CAA3B,EAAA,GAAA,IAAA,GAAA,KAAA,CAAA,UAAA,CAAA,CAAA,EAAA,KAAA,EAAA,EAAA,GAAA,IAAA,IAGrB,CAHqB,GAAA,KAAA;;AAAO,KAOnB,kBAPmB,CAAA,gBAOgB,YAPhB,CAAA,GAQ9B,mBAR8B,CAAA,QAAoB,MAUpC,OAVoC,GAAA,MAAA,GAUjB,YAViB,CAUJ,CAVI,EAUD,OAVC,CAUO,CAVP,CAAA,CAAA,EAAC,CAAA,MAW1C,OARP,GAAA,MAAA,CAAA,CAAA;AAAC;AAIQ,KAQA,UARA,CAAA,CAAA,CAAkB,GAU7B,CAV6B,UAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAUC,GAVD,CAAA,KAAA,EAAA,CAAA,IAUgB,CAVhB,GAAA,KAAA;;AAAiB,KAanC,WAbmC,CAAA,CAAA,CAAA,GAAA,QAGhC,MAYF,CAZE,GAYE,CAZF,CAYI,CAZJ,CAAA,UAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAYmC,GAZnC,CAAA,KAAA,EAAA,CAAA,IAYkD,CAZlD,GAAA,KAAA,EAAO,CAAA,MAad,CAbuC,CAAA;;;;;AAxD/C;AAWA;AAA4C;AAa5C;;;;AAAiC;AAGjC;;;;;;;;;;;;AAIO;AACL;;;;;;;;;;;AAUO;AAAA;;;;;AAOL;AAIJ;;;;;;;;;;AACoB;AAOpB;AAAsB,iBCNN,YDMM,CAAA,sBCN6B,YDM7B,CAAA,CAAA,MAAA,ECLb,ODKa,GCLH,eDKG,CCLa,ODKb,CAAA,CAAA,ECJnB,kBDImB,CCJA,ODIA,CAAA;;;;;;;AA7DtB;AAWA;AAA4C;AAahC,iBEvBI,mBAAA,CFuBQ,KAAA,EAAA,OAAA,CAAA,EAAA,MAAA"}

package/dist/error/index.js

@@ -11,12 +11,16 @@ import { Err } from "../result-DnOm5ds5.js";
 * @example
 * ```ts
 * const HttpError = defineErrors({
-*   Connection: ({ cause }: { cause: string }) => ({
-*     message: `Failed to connect: ${cause}`,
+*   Connection: ({ cause }: { cause: unknown }) => ({
+*     message: `Failed to connect: ${extractErrorMessage(cause)}`,
 *     cause,
 *   }),
-*   Parse: ({ cause }: { cause: string }) => ({
-*     message: `Failed to parse: ${cause}`,
+*   Response: ({ status }: { status: number; bodyMessage?: string }) => ({
+*     message: `HTTP ${status}`,
+*     status,
+*   }),
+*   Parse: ({ cause }: { cause: unknown }) => ({
+*     message: `Failed to parse response body: ${extractErrorMessage(cause)}`,
 *     cause,
 *   }),
 * });
@@ -25,6 +29,30 @@ import { Err } from "../result-DnOm5ds5.js";
 *
 * const result = HttpError.Connection({ cause: 'timeout' }); // Err<...>
 * ```
+*
+* Inspired by Rust's {@link https://docs.rs/thiserror | thiserror} crate. The
+* mapping is nearly 1:1:
+*
+* - `enum HttpError` → `const HttpError = defineErrors(...)`
+* - Variant `Connection { cause: String }` → key `Connection: ({ cause }: { cause: unknown }) => (...)`
+* - `#[error("Failed: {cause}")]` → `` message: `Failed: ${extractErrorMessage(cause)}` ``
+* - `HttpError::Connection { ... }` → `HttpError.Connection({ ... })`
+* - `match error { Connection { .. } => }` → `switch (error.name) { case 'Connection': }`
+*
+* The equivalent Rust `thiserror` enum:
+* ```rust
+* #[derive(Error, Debug)]
+* enum HttpError {
+*     #[error("Failed to connect: {cause}")]
+*     Connection { cause: String },
+*
+*     #[error("HTTP {status}")]
+*     Response { status: u16, body_message: Option<String> },
+*
+*     #[error("Failed to parse response body: {cause}")]
+*     Parse { cause: String },
+* }
+* ```
 */
 function defineErrors(config) {
 	const result = {};

package/dist/error/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["config: TConfig & ValidatedConfig<TConfig>","result: Record<string, unknown>","error: unknown"],"sources":["../../src/error/defineErrors.ts","../../src/error/extractErrorMessage.ts"],"sourcesContent":["import { Err } from \"../result/result.js\";\nimport type {\n\tDefineErrorsReturn,\n\tErrorsConfig,\n\tValidatedConfig,\n} from \"./types.js\";\n\n/**\n * Defines a set of typed error factories using Rust-style namespaced variants.\n *\n * Each key is a short variant name (the namespace provides context). Every\n * factory returns `Err<...>` directly — ready for `trySync`/`tryAsync` catch\n * handlers. The variant name is stamped as `name` on the error object.\n *\n * @example\n * ```ts\n * const HttpError = defineErrors({\n *   Connection: ({ cause }: { cause: string }) => ({\n *     message: `Failed to connect: ${cause}`,\n *     cause,\n *   }),\n *   Parse: ({ cause }: { cause: string }) => ({\n *     message: `Failed to parse: ${cause}`,\n *     cause,\n *   }),\n * });\n *\n * type HttpError = InferErrors<typeof HttpError>;\n *\n * const result = HttpError.Connection({ cause: 'timeout' }); // Err<...>\n * ```\n */\nexport function defineErrors<const TConfig extends ErrorsConfig>(\n\tconfig: TConfig & ValidatedConfig<TConfig>,\n): DefineErrorsReturn<TConfig> {\n\tconst result: Record<string, unknown> = {};\n\n\tfor (const [name, ctor] of Object.entries(config)) {\n\t\tresult[name] = (...args: unknown[]) => {\n\t\t\tconst body = (ctor as (...a: unknown[]) => Record<string, unknown>)(\n\t\t\t\t...args,\n\t\t\t);\n\t\t\treturn Err(Object.freeze({ ...body, name }));\n\t\t};\n\t}\n\n\treturn result as DefineErrorsReturn<TConfig>;\n}\n","/**\n * Extracts a readable error message from an unknown error value\n *\n * @param error - The unknown error to extract a message from\n * @returns A string representation of the error\n */\nexport function extractErrorMessage(error: unknown): string {\n\t// Handle Error instances\n\tif (error instanceof Error) {\n\t\treturn error.message;\n\t}\n\n\t// Handle primitives\n\tif (typeof error === \"string\") return error;\n\tif (\n\t\ttypeof error === \"number\" ||\n\t\ttypeof error === \"boolean\" ||\n\t\ttypeof error === \"bigint\"\n\t)\n\t\treturn String(error);\n\tif (typeof error === \"symbol\") return error.toString();\n\tif (error === null) return \"null\";\n\tif (error === undefined) return \"undefined\";\n\n\t// Handle arrays\n\tif (Array.isArray(error)) return JSON.stringify(error);\n\n\t// Handle plain objects\n\tif (typeof error === \"object\") {\n\t\tconst errorObj = error as Record<string, unknown>;\n\n\t\t// Check common error properties\n\t\tconst messageProps = [\n\t\t\t\"message\",\n\t\t\t\"error\",\n\t\t\t\"description\",\n\t\t\t\"title\",\n\t\t\t\"reason\",\n\t\t\t\"details\",\n\t\t] as const;\n\t\tfor (const prop of messageProps) {\n\t\t\tif (prop in errorObj && typeof errorObj[prop] === \"string\") {\n\t\t\t\treturn errorObj[prop];\n\t\t\t}\n\t\t}\n\n\t\t// Fallback to JSON stringification\n\t\ttry {\n\t\t\treturn JSON.stringify(error);\n\t\t} catch {\n\t\t\treturn String(error);\n\t\t}\n\t}\n\n\t// Final fallback\n\treturn String(error);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,aACfA,QAC8B;CAC9B,MAAMC,SAAkC,CAAE;AAE1C,MAAK,MAAM,CAAC,MAAM,KAAK,IAAI,OAAO,QAAQ,OAAO,CAChD,QAAO,QAAQ,CAAC,GAAG,SAAoB;EACtC,MAAM,OAAO,AAAC,KACb,GAAG,KACH;AACD,SAAO,IAAI,OAAO,OAAO;GAAE,GAAG;GAAM;EAAM,EAAC,CAAC;CAC5C;AAGF,QAAO;AACP;;;;;;;;;;ACzCD,SAAgB,oBAAoBC,OAAwB;AAE3D,KAAI,iBAAiB,MACpB,QAAO,MAAM;AAId,YAAW,UAAU,SAAU,QAAO;AACtC,YACQ,UAAU,mBACV,UAAU,oBACV,UAAU,SAEjB,QAAO,OAAO,MAAM;AACrB,YAAW,UAAU,SAAU,QAAO,MAAM,UAAU;AACtD,KAAI,UAAU,KAAM,QAAO;AAC3B,KAAI,iBAAqB,QAAO;AAGhC,KAAI,MAAM,QAAQ,MAAM,CAAE,QAAO,KAAK,UAAU,MAAM;AAGtD,YAAW,UAAU,UAAU;EAC9B,MAAM,WAAW;EAGjB,MAAM,eAAe;GACpB;GACA;GACA;GACA;GACA;GACA;EACA;AACD,OAAK,MAAM,QAAQ,aAClB,KAAI,QAAQ,mBAAmB,SAAS,UAAU,SACjD,QAAO,SAAS;AAKlB,MAAI;AACH,UAAO,KAAK,UAAU,MAAM;EAC5B,QAAO;AACP,UAAO,OAAO,MAAM;EACpB;CACD;AAGD,QAAO,OAAO,MAAM;AACpB"}
+{"version":3,"file":"index.js","names":["config: TConfig & ValidatedConfig<TConfig>","result: Record<string, unknown>","error: unknown"],"sources":["../../src/error/defineErrors.ts","../../src/error/extractErrorMessage.ts"],"sourcesContent":["import { Err } from \"../result/result.js\";\nimport type {\n\tDefineErrorsReturn,\n\tErrorsConfig,\n\tValidatedConfig,\n} from \"./types.js\";\n\n/**\n * Defines a set of typed error factories using Rust-style namespaced variants.\n *\n * Each key is a short variant name (the namespace provides context). Every\n * factory returns `Err<...>` directly — ready for `trySync`/`tryAsync` catch\n * handlers. The variant name is stamped as `name` on the error object.\n *\n * @example\n * ```ts\n * const HttpError = defineErrors({\n *   Connection: ({ cause }: { cause: unknown }) => ({\n *     message: `Failed to connect: ${extractErrorMessage(cause)}`,\n *     cause,\n *   }),\n *   Response: ({ status }: { status: number; bodyMessage?: string }) => ({\n *     message: `HTTP ${status}`,\n *     status,\n *   }),\n *   Parse: ({ cause }: { cause: unknown }) => ({\n *     message: `Failed to parse response body: ${extractErrorMessage(cause)}`,\n *     cause,\n *   }),\n * });\n *\n * type HttpError = InferErrors<typeof HttpError>;\n *\n * const result = HttpError.Connection({ cause: 'timeout' }); // Err<...>\n * ```\n *\n * Inspired by Rust's {@link https://docs.rs/thiserror | thiserror} crate. The\n * mapping is nearly 1:1:\n *\n * - `enum HttpError` → `const HttpError = defineErrors(...)`\n * - Variant `Connection { cause: String }` → key `Connection: ({ cause }: { cause: unknown }) => (...)`\n * - `#[error(\"Failed: {cause}\")]` → `` message: `Failed: ${extractErrorMessage(cause)}` ``\n * - `HttpError::Connection { ... }` → `HttpError.Connection({ ... })`\n * - `match error { Connection { .. } => }` → `switch (error.name) { case 'Connection': }`\n *\n * The equivalent Rust `thiserror` enum:\n * ```rust\n * #[derive(Error, Debug)]\n * enum HttpError {\n *     #[error(\"Failed to connect: {cause}\")]\n *     Connection { cause: String },\n *\n *     #[error(\"HTTP {status}\")]\n *     Response { status: u16, body_message: Option<String> },\n *\n *     #[error(\"Failed to parse response body: {cause}\")]\n *     Parse { cause: String },\n * }\n * ```\n */\nexport function defineErrors<const TConfig extends ErrorsConfig>(\n\tconfig: TConfig & ValidatedConfig<TConfig>,\n): DefineErrorsReturn<TConfig> {\n\tconst result: Record<string, unknown> = {};\n\n\tfor (const [name, ctor] of Object.entries(config)) {\n\t\tresult[name] = (...args: unknown[]) => {\n\t\t\tconst body = (ctor as (...a: unknown[]) => Record<string, unknown>)(\n\t\t\t\t...args,\n\t\t\t);\n\t\t\treturn Err(Object.freeze({ ...body, name }));\n\t\t};\n\t}\n\n\treturn result as DefineErrorsReturn<TConfig>;\n}\n","/**\n * Extracts a readable error message from an unknown error value\n *\n * @param error - The unknown error to extract a message from\n * @returns A string representation of the error\n */\nexport function extractErrorMessage(error: unknown): string {\n\t// Handle Error instances\n\tif (error instanceof Error) {\n\t\treturn error.message;\n\t}\n\n\t// Handle primitives\n\tif (typeof error === \"string\") return error;\n\tif (\n\t\ttypeof error === \"number\" ||\n\t\ttypeof error === \"boolean\" ||\n\t\ttypeof error === \"bigint\"\n\t)\n\t\treturn String(error);\n\tif (typeof error === \"symbol\") return error.toString();\n\tif (error === null) return \"null\";\n\tif (error === undefined) return \"undefined\";\n\n\t// Handle arrays\n\tif (Array.isArray(error)) return JSON.stringify(error);\n\n\t// Handle plain objects\n\tif (typeof error === \"object\") {\n\t\tconst errorObj = error as Record<string, unknown>;\n\n\t\t// Check common error properties\n\t\tconst messageProps = [\n\t\t\t\"message\",\n\t\t\t\"error\",\n\t\t\t\"description\",\n\t\t\t\"title\",\n\t\t\t\"reason\",\n\t\t\t\"details\",\n\t\t] as const;\n\t\tfor (const prop of messageProps) {\n\t\t\tif (prop in errorObj && typeof errorObj[prop] === \"string\") {\n\t\t\t\treturn errorObj[prop];\n\t\t\t}\n\t\t}\n\n\t\t// Fallback to JSON stringification\n\t\ttry {\n\t\t\treturn JSON.stringify(error);\n\t\t} catch {\n\t\t\treturn String(error);\n\t\t}\n\t}\n\n\t// Final fallback\n\treturn String(error);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,SAAgB,aACfA,QAC8B;CAC9B,MAAMC,SAAkC,CAAE;AAE1C,MAAK,MAAM,CAAC,MAAM,KAAK,IAAI,OAAO,QAAQ,OAAO,CAChD,QAAO,QAAQ,CAAC,GAAG,SAAoB;EACtC,MAAM,OAAO,AAAC,KACb,GAAG,KACH;AACD,SAAO,IAAI,OAAO,OAAO;GAAE,GAAG;GAAM;EAAM,EAAC,CAAC;CAC5C;AAGF,QAAO;AACP;;;;;;;;;;ACrED,SAAgB,oBAAoBC,OAAwB;AAE3D,KAAI,iBAAiB,MACpB,QAAO,MAAM;AAId,YAAW,UAAU,SAAU,QAAO;AACtC,YACQ,UAAU,mBACV,UAAU,oBACV,UAAU,SAEjB,QAAO,OAAO,MAAM;AACrB,YAAW,UAAU,SAAU,QAAO,MAAM,UAAU;AACtD,KAAI,UAAU,KAAM,QAAO;AAC3B,KAAI,iBAAqB,QAAO;AAGhC,KAAI,MAAM,QAAQ,MAAM,CAAE,QAAO,KAAK,UAAU,MAAM;AAGtD,YAAW,UAAU,UAAU;EAC9B,MAAM,WAAW;EAGjB,MAAM,eAAe;GACpB;GACA;GACA;GACA;GACA;GACA;EACA;AACD,OAAK,MAAM,QAAQ,aAClB,KAAI,QAAQ,mBAAmB,SAAS,UAAU,SACjD,QAAO,SAAS;AAKlB,MAAI;AACH,UAAO,KAAK,UAAU,MAAM;EAC5B,QAAO;AACP,UAAO,OAAO,MAAM;EACpB;CACD;AAGD,QAAO,OAAO,MAAM;AACpB"}

package/dist/{index-Cd0uJHqj.d.ts → index-8WW9UMob.d.ts}

@@ -1,4 +1,4 @@
-import { Err, Ok, Result } from "./result-DolxQXIZ.js";
+import { Err, Ok, Result } from "./result-BgPMmUXd.js";
 
 //#region src/result/utils.d.ts
 
@@ -25,4 +25,4 @@ declare function partitionResults<T, E>(results: Result<T, E>[]): {
 //# sourceMappingURL=utils.d.ts.map
 //#endregion
 export { partitionResults };
-//# sourceMappingURL=index-Cd0uJHqj.d.ts.map
+//# sourceMappingURL=index-8WW9UMob.d.ts.map

package/dist/{index-Cd0uJHqj.d.ts.map → index-8WW9UMob.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-Cd0uJHqj.d.ts","names":[],"sources":["../src/result/utils.ts"],"sourcesContent":[],"mappings":";;;;;;AAmBA;;;;;;;;;AAK+B;;;;;iBALf,gCAAgC,OAAO,GAAG;OAK7C,GAAG;QAAY,IAAI"}
+{"version":3,"file":"index-8WW9UMob.d.ts","names":[],"sources":["../src/result/utils.ts"],"sourcesContent":[],"mappings":";;;;;;AAmBA;;;;;;;;;AAK+B;;;;;iBALf,gCAAgC,OAAO,GAAG;OAK7C,GAAG;QAAY,IAAI"}

package/dist/json.d.ts

@@ -0,0 +1,25 @@
+//#region src/json.d.ts
+/**
+ * JSON-serializable value types.
+ * Ensures data can be safely serialized via JSON.stringify.
+ *
+ * @example
+ * ```typescript
+ * import type { JsonValue, JsonObject } from "wellcrafted/json";
+ *
+ * const value: JsonValue = { key: [1, "two", true, null] };
+ * const obj: JsonObject = { name: "Alice", age: 30 };
+ * ```
+ */
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+/**
+ * JSON-serializable object type.
+ * A record where every value is a {@link JsonValue}.
+ */
+type JsonObject = Record<string, JsonValue>;
+//# sourceMappingURL=json.d.ts.map
+//#endregion
+export { JsonObject, JsonValue };
+//# sourceMappingURL=json.d.ts.map

package/dist/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","names":[],"sources":["../src/json.ts"],"sourcesContent":[],"mappings":";;AAYA;;;;AAM6B;AAM7B;;;;AAA+B;;KAZnB,SAAA,sCAKT;iBACiB;;;;;;KAMR,UAAA,GAAa,eAAe"}

package/dist/query/index.d.ts

@@ -1,5 +1,5 @@
-import { Result } from "../result-DolxQXIZ.js";
-import "../index-Cd0uJHqj.js";
+import { Result } from "../result-BgPMmUXd.js";
+import "../index-8WW9UMob.js";
 import { DefaultError, MutationFunction, MutationKey, MutationOptions, QueryClient, QueryFunction, QueryKey, QueryObserverOptions } from "@tanstack/query-core";
 
 //#region src/query/utils.d.ts
@@ -155,7 +155,6 @@ declare function createQueryFactories(queryClient: QueryClient): {
   defineQuery: <TQueryFnData = unknown, TError = Error, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = readonly unknown[]>(options: DefineQueryInput<TQueryFnData, TError, TData, TQueryData, TQueryKey>) => DefineQueryOutput<TQueryFnData, TError, TData, TQueryData, TQueryKey>;
   defineMutation: <TData, TError, TVariables = void, TContext = unknown>(options: DefineMutationInput<TData, TError, TVariables, TContext>) => DefineMutationOutput<TData, TError, TVariables, TContext>;
 };
-//# sourceMappingURL=utils.d.ts.map
 //#endregion
 export { createQueryFactories };
 //# sourceMappingURL=index.d.ts.map

package/dist/query/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/query/utils.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAwBA;;;;;;;;;AAO4C,KAPhC,gBAOgC,CAAA,eAAA,OAAA,EAAA,SALlC,YAKkC,EAAA,QAJnC,YAImC,EAAA,aAH9B,YAG8B,EAAA,kBAFzB,QAEyB,GAFd,QAEc,CAAA,GADxC,IACwC,CAA3C,oBAA2C,CAAtB,YAAsB,EAAR,MAAQ,EAAA,KAAA,EAAO,UAAP,EAAmB,SAAnB,CAAA,EAAA,SAAA,CAAA,GAAA;EAAK,QAAE,EAGxC,SAHwC;EAAU,OAAE,EAIrD,aAJqD,CAIvC,MAJuC,CAIhC,YAJgC,EAIlB,MAJkB,CAAA,EAIT,SAJS,CAAA;CAAS;;;;;;;;AAIjD;AAoCvB;;;;;;;;;;;;;;;;;;;;;;;;;AAesB,KAfV,iBAeU,CAAA,eAAA,OAAA,EAAA,SAbZ,YAaY,EAAA,QAZb,YAYa,EAAA,aAXR,YAWQ,EAAA,kBAVH,QAUG,GAVQ,QAUR,CAAA,GAAA,CAAA,GAAA,GATX,OASW,CATH,MASG,CATI,UASJ,EATgB,MAShB,CAAA,CAAA,CAAA,GAAA;EAeV,OAAA,EAvBF,oBAuBqB,CAtB7B,YAsB6B,EArB7B,MAqB6B,EApB7B,KAoB6B,EAnB7B,UAmB6B,EAlB7B,SAkB6B,CAAA;EAAA,KAAA,EAAA,GAAA,GAhBjB,OAgBiB,CAhBT,MAgBS,CAhBF,UAgBE,EAhBU,MAgBV,CAAA,CAAA;EAAA,MAKN,EAAA,GAAA,GApBV,OAoBU,CApBF,MAoBE,CApBK,UAoBL,EApBiB,MAoBjB,CAAA,CAAA;CAAK;;;;;;;;;;;AAED;AAkC7B;AAAgC,KAzCpB,mBAyCoB,CAAA,KAAA,EAAA,MAAA,EAAA,aAAA,IAAA,EAAA,WAAA,OAAA,CAAA,GApC5B,IAoC4B,CApCvB,eAoCuB,CApCP,KAoCO,EApCA,MAoCA,EApCQ,UAoCR,EApCoB,QAoCpB,CAAA,EAAA,YAAA,CAAA,GAAA;EAAA,WAKf,EAxCH,WAwCG;EAAU,UAAoB,EAvClC,gBAuCkC,CAvCjB,MAuCiB,CAvCV,KAuCU,EAvCH,MAuCG,CAAA,EAvCM,UAuCN,CAAA;CAAK;;;;;;;;;;;;;AAER;AA6C5C;;;;;;;;;;;;;;;;;;AA+EI,KAnIQ,oBAmIR,CAAA,KAAA,EAAA,MAAA,EAAA,aAAA,IAAA,EAAA,WAAA,OAAA,CAAA,GAAA,CAAA,CAAA,SAAA,EA9Ha,UA8Hb,EAAA,GA9H4B,OA8H5B,CA9HoC,MA8HpC,CA9H2C,KA8H3C,EA9HkD,MA8HlD,CAAA,CAAA,CAAA,GAAA;EAAiB,OA8LU,EA3TrB,eA2TqB,CA3TL,KA2TK,EA3TE,MA2TF,EA3TU,UA2TV,EA3TsB,QA2TtB,CAAA;EAAK,OAAE,EAAA,CAAA,SAAA,EA1ThB,UA0TgB,EAAA,GA1TD,OA0TC,CA1TO,MA0TP,CA1Tc,KA0Td,EA1TqB,MA0TrB,CAAA,CAAA;CAAM;;;;;;;;AACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA9QR,oBAAA,cAAkC;iDAmE1C,eACD,2BACK,gCACQ,wCAET,iBACR,cACA,QACA,OACA,YACA,eAEC,kBAAkB,cAAc,QAAQ,OAAO,YAAY;kFA8LpD,oBAAoB,OAAO,QAAQ,YAAY,cACtD,qBAAqB,OAAO,QAAQ,YAAY"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/query/utils.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAUmE;;;;;;;;;KAc9D,gBAOuC,CAAA,eAAA,OAAA,EAAA,SALlC,YAKkC,EAAA,QAJnC,YAImC,EAAA,aAH9B,YAG8B,EAAA,kBAFzB,QAEyB,GAFd,QAEc,CAAA,GADxC,IACwC,CAA3C,oBAA2C,CAAtB,YAAsB,EAAR,MAAQ,EAAA,KAAA,EAAO,UAAP,EAAmB,SAAnB,CAAA,EAAA,SAAA,CAAA,GAAA;EAAK,QAAE,EAGxC,SAHwC;EAAU,OAAE,EAIrD,aAJqD,CAIvC,MAJuC,CAIhC,YAJgC,EAIlB,MAJkB,CAAA,EAIT,SAJS,CAAA;CAAS;;;;;;;;AAIjD;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;AAmDD,KAfjB,iBAeiB,CAAA,eAAA,OAAA,EAAA,SAbZ,YAaY,EAAA,QAZb,YAYa,EAAA,aAXR,YAWQ,EAAA,kBAVH,QAUG,GAVQ,QAUR,CAAA,GAAA,CAAA,GAAA,GATX,OASW,CATH,MASG,CATI,UASJ,EATgB,MAShB,CAAA,CAAA,CAAA,GAAA;EAejB,OAAA,EAvBK,oBAuBc,CAtBtB,YAsBsB,EArBtB,MAqBsB,EApBtB,KAoBsB,EAnBtB,UAmBsB,EAlBtB,SAkBsB,CAAA;EAAA,KAAA,EAAA,GAAA,GAhBV,OAgBU,CAhBF,MAgBE,CAhBK,UAgBL,EAhBiB,MAgBjB,CAAA,CAAA;EAAA,MAKC,EAAA,GAAA,GApBV,OAoBU,CApBF,MAoBE,CApBK,UAoBL,EApBiB,MAoBjB,CAAA,CAAA;CAAK;;;;;;;;;;;AAED;AAAA;KAPxB,mBAyCoB,CAAA,KAAA,EAAA,MAAA,EAAA,aAAA,IAAA,EAAA,WAAA,OAAA,CAAA,GApCrB,IAoCqB,CApChB,eAoCgB,CApCA,KAoCA,EApCO,MAoCP,EApCe,UAoCf,EApC2B,QAoC3B,CAAA,EAAA,YAAA,CAAA,GAAA;EAAA,WAKR,EAxCH,WAwCG;EAAU,UAAoB,EAvClC,gBAuCkC,CAvCjB,MAuCiB,CAvCV,KAuCU,EAvCH,MAuCG,CAAA,EAvCM,UAuCN,CAAA;CAAK;;;;;;;;;;;;;AAER;AA6C5C;;;;;;;;;;;;;;;;;;KApDK,oBAmID,CAAA,KAAA,EAAA,MAAA,EAAA,aAAA,IAAA,EAAA,WAAA,OAAA,CAAA,GAAA,CAAA,CAAA,SAAA,EA9Ha,UA8Hb,EAAA,GA9H4B,OA8H5B,CA9HoC,MA8HpC,CA9H2C,KA8H3C,EA9HkD,MA8HlD,CAAA,CAAA,CAAA,GAAA;EAAiB,OA8LU,EA3TrB,eA2TqB,CA3TL,KA2TK,EA3TE,MA2TF,EA3TU,UA2TV,EA3TsB,QA2TtB,CAAA;EAAK,OAAE,EAAA,CAAA,SAAA,EA1ThB,UA0TgB,EAAA,GA1TD,OA0TC,CA1TO,MA0TP,CA1Tc,KA0Td,EA1TqB,MA0TrB,CAAA,CAAA;CAAM;;;;;;;;AACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA9QR,oBAAA,cAAkC;iDAmE1C,eACD,2BACK,gCACQ,wCAET,iBACR,cACA,QACA,OACA,YACA,eAEC,kBAAkB,cAAc,QAAQ,OAAO,YAAY;kFA8LpD,oBAAoB,OAAO,QAAQ,YAAY,cACtD,qBAAqB,OAAO,QAAQ,YAAY"}

package/dist/query/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["queryClient: QueryClient","options: DefineQueryInput<\n\t\t\tTQueryFnData,\n\t\t\tTError,\n\t\t\tTData,\n\t\t\tTQueryData,\n\t\t\tTQueryKey\n\t\t>","options: DefineMutationInput<TData, TError, TVariables, TContext>","variables: TVariables","options: MutationOptions<TData, TError, TVariables, TContext>"],"sources":["../../src/query/utils.ts"],"sourcesContent":["import type {\n\tDefaultError,\n\tMutationFunction,\n\tMutationKey,\n\tMutationOptions,\n\tQueryClient,\n\tQueryFunction,\n\tQueryKey,\n\tQueryObserverOptions,\n} from \"@tanstack/query-core\";\nimport { Err, Ok, type Result, resolve } from \"../result/index.js\";\n\n/**\n * Input options for defining a query.\n *\n * Extends TanStack Query's QueryObserverOptions but expects queryFn to return a Result type.\n * This type represents the configuration for creating a query definition with both\n * reactive and imperative interfaces for data fetching.\n *\n * @template TQueryFnData - The type of data returned by the query function\n * @template TError - The type of error that can be thrown\n * @template TData - The type of data returned by the query (after select transform)\n * @template TQueryKey - The type of the query key\n */\nexport type DefineQueryInput<\n\tTQueryFnData = unknown,\n\tTError = DefaultError,\n\tTData = TQueryFnData,\n\tTQueryData = TQueryFnData,\n\tTQueryKey extends QueryKey = QueryKey,\n> = Omit<\n\tQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n\t\"queryFn\"\n> & {\n\tqueryKey: TQueryKey;\n\tqueryFn: QueryFunction<Result<TQueryFnData, TError>, TQueryKey>;\n};\n\n/**\n * Output of defineQuery function.\n *\n * The query definition is directly callable and defaults to `ensure()` behavior,\n * which is recommended for most imperative use cases like preloaders.\n *\n * Provides both reactive and imperative interfaces for data fetching:\n * - `()` (callable): Same as `ensure()` - returns cached data if available, fetches if not\n * - `options`: Returns config for use with useQuery() or createQuery()\n * - `fetch()`: Always attempts to fetch data (from cache if fresh, network if stale)\n * - `ensure()`: Guarantees data availability, preferring cached data (recommended for preloaders)\n *\n * @template TQueryFnData - The type of data returned by the query function\n * @template TError - The type of error that can be thrown\n * @template TData - The type of data returned by the query (after select transform)\n * @template TQueryKey - The type of the query key\n *\n * @example\n * ```typescript\n * const userQuery = defineQuery({...});\n *\n * // Directly callable (same as .ensure())\n * const { data, error } = await userQuery();\n *\n * // Or use explicit methods\n * const { data, error } = await userQuery.ensure();\n * const { data, error } = await userQuery.fetch();\n *\n * // For reactive usage (Svelte 5 requires accessor wrapper)\n * const query = createQuery(() => userQuery.options); // Svelte 5\n * const query = useQuery(userQuery.options); // React\n * ```\n */\nexport type DefineQueryOutput<\n\tTQueryFnData = unknown,\n\tTError = DefaultError,\n\tTData = TQueryFnData,\n\tTQueryData = TQueryFnData,\n\tTQueryKey extends QueryKey = QueryKey,\n> = (() => Promise<Result<TQueryData, TError>>) & {\n\toptions: QueryObserverOptions<\n\t\tTQueryFnData,\n\t\tTError,\n\t\tTData,\n\t\tTQueryData,\n\t\tTQueryKey\n\t>;\n\tfetch: () => Promise<Result<TQueryData, TError>>;\n\tensure: () => Promise<Result<TQueryData, TError>>;\n};\n\n/**\n * Input options for defining a mutation.\n *\n * Extends TanStack Query's MutationOptions but expects mutationFn to return a Result type.\n * This type represents the configuration for creating a mutation definition with both\n * reactive and imperative interfaces for data mutations.\n *\n * @template TData - The type of data returned by the mutation\n * @template TError - The type of error that can be thrown\n * @template TVariables - The type of variables passed to the mutation\n * @template TContext - The type of context data for optimistic updates\n */\nexport type DefineMutationInput<\n\tTData,\n\tTError,\n\tTVariables = void,\n\tTContext = unknown,\n> = Omit<MutationOptions<TData, TError, TVariables, TContext>, \"mutationFn\"> & {\n\tmutationKey: MutationKey;\n\tmutationFn: MutationFunction<Result<TData, TError>, TVariables>;\n};\n\n/**\n * Output of defineMutation function.\n *\n * The mutation definition is directly callable, which executes the mutation\n * and returns a Result. This is equivalent to calling `.execute()`.\n *\n * Provides both reactive and imperative interfaces for data mutations:\n * - `(variables)` (callable): Same as `execute()` - directly executes the mutation\n * - `options`: Returns config for use with useMutation() or createMutation()\n * - `execute(variables)`: Directly executes the mutation and returns a Result\n *\n * @template TData - The type of data returned by the mutation\n * @template TError - The type of error that can be thrown\n * @template TVariables - The type of variables passed to the mutation\n * @template TContext - The type of context data for optimistic updates\n *\n * @example\n * ```typescript\n * const createUser = defineMutation({...});\n *\n * // Directly callable (same as .execute())\n * const { data, error } = await createUser({ name: 'John' });\n *\n * // Or use explicit method\n * const { data, error } = await createUser.execute({ name: 'John' });\n *\n * // For reactive usage (Svelte 5 requires accessor wrapper)\n * const mutation = createMutation(() => createUser.options); // Svelte 5\n * const mutation = useMutation(createUser.options); // React\n * ```\n */\nexport type DefineMutationOutput<\n\tTData,\n\tTError,\n\tTVariables = void,\n\tTContext = unknown,\n> = ((variables: TVariables) => Promise<Result<TData, TError>>) & {\n\toptions: MutationOptions<TData, TError, TVariables, TContext>;\n\texecute: (variables: TVariables) => Promise<Result<TData, TError>>;\n};\n\n/**\n * Creates factory functions for defining queries and mutations bound to a specific QueryClient.\n *\n * This factory pattern allows you to create isolated query/mutation definitions that are\n * bound to a specific QueryClient instance, enabling:\n * - Multiple query clients in the same application\n * - Testing with isolated query clients\n * - Framework-agnostic query definitions\n * - Proper separation of concerns between query logic and client instances\n *\n * The returned functions handle Result types automatically, unwrapping them for TanStack Query\n * while maintaining type safety throughout your application.\n *\n * @param queryClient - The QueryClient instance to bind the factories to\n * @returns An object containing defineQuery and defineMutation functions bound to the provided client\n *\n * @example\n * ```typescript\n * // Create your query client\n * const queryClient = new QueryClient({\n *   defaultOptions: {\n *     queries: { staleTime: 5 * 60 * 1000 }\n *   }\n * });\n *\n * // Create the factory functions\n * const { defineQuery, defineMutation } = createQueryFactories(queryClient);\n *\n * // Now use defineQuery and defineMutation as before\n * const userQuery = defineQuery({\n *   queryKey: ['user', userId],\n *   queryFn: () => services.getUser(userId)\n * });\n *\n * // Use in components (Svelte 5 requires accessor wrapper)\n * const query = createQuery(() => userQuery.options); // Svelte 5\n * const query = useQuery(userQuery.options); // React\n *\n * // Or imperatively\n * const { data, error } = await userQuery.fetch();\n * ```\n */\nexport function createQueryFactories(queryClient: QueryClient) {\n\t/**\n\t * Creates a query definition that bridges the gap between pure service functions and reactive UI components.\n\t *\n\t * This factory function is the cornerstone of our data fetching architecture. It wraps service calls\n\t * with TanStack Query superpowers while maintaining type safety through Result types.\n\t *\n\t * The returned query definition is **directly callable** and defaults to `ensure()` behavior,\n\t * which is recommended for most imperative use cases like preloaders.\n\t *\n\t * ## Why use defineQuery?\n\t *\n\t * 1. **Callable**: Call directly like `userQuery()` for imperative data fetching\n\t * 2. **Dual Interface**: Also provides reactive (`.options`) and explicit imperative (`.fetch()`, `.ensure()`) APIs\n\t * 3. **Automatic Error Handling**: Service functions return `Result<T, E>` types which are automatically\n\t *    unwrapped by TanStack Query, giving you proper error states in your components\n\t * 4. **Type Safety**: Full TypeScript support with proper inference for data and error types\n\t * 5. **Consistency**: Every query in the app follows the same pattern, making it easy to understand\n\t *\n\t * @template TQueryFnData - The type of data returned by the query function\n\t * @template TError - The type of error that can be thrown\n\t * @template TData - The type of data returned by the query (after select transform)\n\t * @template TQueryKey - The type of the query key\n\t *\n\t * @param options - Query configuration object\n\t * @param options.queryKey - Unique key for this query (used for caching and refetching)\n\t * @param options.queryFn - Function that fetches data and returns a Result type\n\t * @param options.* - Any other TanStack Query options (staleTime, refetchInterval, etc.)\n\t *\n\t * @returns Callable query definition with:\n\t *   - `()` (callable): Same as `ensure()` - returns cached data if available, fetches if not\n\t *   - `.options`: Config for use with useQuery() or createQuery()\n\t *   - `.fetch()`: Always attempts to fetch (from cache if fresh, network if stale)\n\t *   - `.ensure()`: Guarantees data availability, preferring cached data (recommended for preloaders)\n\t *\n\t * @example\n\t * ```typescript\n\t * // Step 1: Define your query in the query layer\n\t * const userQuery = defineQuery({\n\t *   queryKey: ['users', userId],\n\t *   queryFn: () => services.getUser(userId), // Returns Result<User, ApiError>\n\t *   staleTime: 5 * 60 * 1000, // Consider data fresh for 5 minutes\n\t * });\n\t *\n\t * // Step 2a: Use reactively in a Svelte 5 component (accessor wrapper required)\n\t * const query = createQuery(() => userQuery.options);\n\t * // query.data is User | undefined\n\t * // query.error is ApiError | null\n\t *\n\t * // Step 2b: Call directly in preloaders (recommended)\n\t * export const load = async () => {\n\t *   const { data, error } = await userQuery(); // Same as userQuery.ensure()\n\t *   if (error) throw error;\n\t *   return { user: data };\n\t * };\n\t *\n\t * // Step 2c: Use explicit methods when needed\n\t * async function refreshUser() {\n\t *   const { data, error } = await userQuery.fetch(); // Force fresh fetch\n\t *   if (error) {\n\t *     console.error('Failed to fetch user:', error);\n\t *   }\n\t * }\n\t * ```\n\t */\n\tconst defineQuery = <\n\t\tTQueryFnData = unknown,\n\t\tTError = DefaultError,\n\t\tTData = TQueryFnData,\n\t\tTQueryData = TQueryFnData,\n\t\tTQueryKey extends QueryKey = QueryKey,\n\t>(\n\t\toptions: DefineQueryInput<\n\t\t\tTQueryFnData,\n\t\t\tTError,\n\t\t\tTData,\n\t\t\tTQueryData,\n\t\t\tTQueryKey\n\t\t>,\n\t): DefineQueryOutput<TQueryFnData, TError, TData, TQueryData, TQueryKey> => {\n\t\tconst newOptions = {\n\t\t\t...options,\n\t\t\tqueryFn: async (context) => {\n\t\t\t\tlet result = options.queryFn(context);\n\t\t\t\tif (result instanceof Promise) result = await result;\n\t\t\t\treturn resolve(result);\n\t\t\t},\n\t\t} satisfies QueryObserverOptions<\n\t\t\tTQueryFnData,\n\t\t\tTError,\n\t\t\tTData,\n\t\t\tTQueryData,\n\t\t\tTQueryKey\n\t\t>;\n\n\t\t/**\n\t\t * Fetches data for this query using queryClient.fetchQuery().\n\t\t *\n\t\t * This method ALWAYS evaluates freshness and will refetch if data is stale.\n\t\t * It wraps TanStack Query's fetchQuery method, which returns cached data if fresh\n\t\t * or makes a network request if the data is stale or missing.\n\t\t *\n\t\t * **When to use fetch():**\n\t\t * - When you explicitly want to check data freshness\n\t\t * - For user-triggered refresh actions\n\t\t * - When you need the most up-to-date data\n\t\t *\n\t\t * **For preloaders, use ensure() instead** - it's more efficient for initial data loading.\n\t\t *\n\t\t * @returns Promise that resolves with a Result containing either the data or an error\n\t\t *\n\t\t * @example\n\t\t * // Good for user-triggered refresh\n\t\t * const { data, error } = await userQuery.fetch();\n\t\t * if (error) {\n\t\t *   console.error('Failed to load user:', error);\n\t\t * }\n\t\t */\n\t\tasync function fetch(): Promise<Result<TQueryData, TError>> {\n\t\t\ttry {\n\t\t\t\treturn Ok(\n\t\t\t\t\tawait queryClient.fetchQuery<\n\t\t\t\t\t\tTQueryFnData,\n\t\t\t\t\t\tTError,\n\t\t\t\t\t\tTQueryData,\n\t\t\t\t\t\tTQueryKey\n\t\t\t\t\t>({\n\t\t\t\t\t\tqueryKey: newOptions.queryKey,\n\t\t\t\t\t\tqueryFn: newOptions.queryFn,\n\t\t\t\t\t}),\n\t\t\t\t);\n\t\t\t} catch (error) {\n\t\t\t\treturn Err(error as TError);\n\t\t\t}\n\t\t}\n\n\t\t/**\n\t\t * Ensures data is available for this query using queryClient.ensureQueryData().\n\t\t *\n\t\t * This method PRIORITIZES cached data and only calls fetchQuery internally if no cached\n\t\t * data exists. It wraps TanStack Query's ensureQueryData method, which is perfect for\n\t\t * guaranteeing data availability with minimal network requests.\n\t\t *\n\t\t * **This is the RECOMMENDED method for preloaders** because:\n\t\t * - It returns cached data immediately if available\n\t\t * - It updates the query client cache properly\n\t\t * - It minimizes network requests during navigation\n\t\t * - It ensures components have data ready when they mount\n\t\t *\n\t\t * **When to use ensure():**\n\t\t * - Route preloaders and data loading functions\n\t\t * - Initial component data requirements\n\t\t * - When cached data is acceptable for immediate display\n\t\t *\n\t\t * This is also the default behavior when calling the query directly.\n\t\t *\n\t\t * @returns Promise that resolves with a Result containing either the data or an error\n\t\t *\n\t\t * @example\n\t\t * // Perfect for preloaders\n\t\t * export const load = async () => {\n\t\t *   const { data, error } = await userQuery.ensure();\n\t\t *   // Or simply: await userQuery();\n\t\t *   if (error) {\n\t\t *     throw error;\n\t\t *   }\n\t\t *   return { user: data };\n\t\t * };\n\t\t */\n\t\tasync function ensure(): Promise<Result<TQueryData, TError>> {\n\t\t\ttry {\n\t\t\t\treturn Ok(\n\t\t\t\t\tawait queryClient.ensureQueryData<\n\t\t\t\t\t\tTQueryFnData,\n\t\t\t\t\t\tTError,\n\t\t\t\t\t\tTQueryData,\n\t\t\t\t\t\tTQueryKey\n\t\t\t\t\t>({\n\t\t\t\t\t\tqueryKey: newOptions.queryKey,\n\t\t\t\t\t\tqueryFn: newOptions.queryFn,\n\t\t\t\t\t}),\n\t\t\t\t);\n\t\t\t} catch (error) {\n\t\t\t\treturn Err(error as TError);\n\t\t\t}\n\t\t}\n\n\t\t// Create a callable function that defaults to ensure() behavior\n\t\t// and attach options, fetch, and ensure as properties\n\t\treturn Object.assign(ensure, {\n\t\t\toptions: newOptions,\n\t\t\tfetch,\n\t\t\tensure,\n\t\t});\n\t};\n\n\t/**\n\t * Creates a mutation definition for operations that modify data (create, update, delete).\n\t *\n\t * This factory function is the mutation counterpart to defineQuery. It provides a clean way to\n\t * wrap service functions that perform side effects, while maintaining the same dual interface\n\t * pattern for maximum flexibility.\n\t *\n\t * The returned mutation definition is **directly callable**, which executes the mutation\n\t * and returns a Result. This is equivalent to calling `.execute()`.\n\t *\n\t * ## Why use defineMutation?\n\t *\n\t * 1. **Callable**: Call directly like `createUser({ name: 'John' })` for imperative execution\n\t * 2. **Dual Interface**: Also provides reactive (`.options`) and explicit imperative (`.execute()`) APIs\n\t * 3. **Consistent Error Handling**: Service functions return `Result<T, E>` types, ensuring\n\t *    errors are handled consistently throughout the app\n\t * 4. **Cache Management**: Mutations often update the cache after success (see examples)\n\t *\n\t * @template TData - The type of data returned by the mutation\n\t * @template TError - The type of error that can be thrown\n\t * @template TVariables - The type of variables passed to the mutation\n\t * @template TContext - The type of context data for optimistic updates\n\t *\n\t * @param options - Mutation configuration object\n\t * @param options.mutationKey - Unique key for this mutation (used for tracking in-flight state)\n\t * @param options.mutationFn - Function that performs the mutation and returns a Result type\n\t * @param options.* - Any other TanStack Mutation options (onSuccess, onError, etc.)\n\t *\n\t * @returns Callable mutation definition with:\n\t *   - `(variables)` (callable): Same as `execute()` - directly executes the mutation\n\t *   - `.options`: Config for use with useMutation() or createMutation()\n\t *   - `.execute(variables)`: Directly executes the mutation and returns a Result\n\t *\n\t * @example\n\t * ```typescript\n\t * // Step 1: Define your mutation with cache updates\n\t * const createRecording = defineMutation({\n\t *   mutationKey: ['recordings', 'create'],\n\t *   mutationFn: async (recording: Recording) => {\n\t *     // Call the service\n\t *     const result = await services.db.createRecording(recording);\n\t *     if (result.error) return Err(result.error);\n\t *\n\t *     // Update cache on success\n\t *     queryClient.setQueryData(['recordings'], (old) =>\n\t *       [...(old || []), recording]\n\t *     );\n\t *\n\t *     return Ok(result.data);\n\t *   }\n\t * });\n\t *\n\t * // Step 2a: Use reactively in a Svelte 5 component (accessor wrapper required)\n\t * const mutation = createMutation(() => createRecording.options);\n\t * // Call with: mutation.mutate(recordingData)\n\t *\n\t * // Step 2b: Call directly in an action (recommended)\n\t * async function saveRecording(data: Recording) {\n\t *   const { error } = await createRecording(data); // Same as createRecording.execute(data)\n\t *   if (error) {\n\t *     notify.error({ title: 'Failed to save', description: error.message });\n\t *   } else {\n\t *     notify.success({ title: 'Recording saved!' });\n\t *   }\n\t * }\n\t * ```\n\t *\n\t * @tip Calling directly is especially useful for:\n\t * - Event handlers that need to await the result\n\t * - Sequential operations that depend on each other\n\t * - Non-component code that needs to trigger mutations\n\t */\n\tconst defineMutation = <TData, TError, TVariables = void, TContext = unknown>(\n\t\toptions: DefineMutationInput<TData, TError, TVariables, TContext>,\n\t): DefineMutationOutput<TData, TError, TVariables, TContext> => {\n\t\tconst newOptions = {\n\t\t\t...options,\n\t\t\tmutationFn: async (variables: TVariables) => {\n\t\t\t\treturn resolve(await options.mutationFn(variables));\n\t\t\t},\n\t\t} satisfies MutationOptions<TData, TError, TVariables, TContext>;\n\n\t\t/**\n\t\t * Executes the mutation imperatively and returns a Result.\n\t\t *\n\t\t * This is the recommended way to trigger mutations from:\n\t\t * - Button click handlers\n\t\t * - Form submissions\n\t\t * - Keyboard shortcuts\n\t\t * - Any non-component code\n\t\t *\n\t\t * The method automatically wraps the result in a Result type, so you always\n\t\t * get back `{ data, error }` for consistent error handling.\n\t\t *\n\t\t * This is also the default behavior when calling the mutation directly.\n\t\t *\n\t\t * @param variables - The variables to pass to the mutation function\n\t\t * @returns Promise that resolves with a Result containing either the data or an error\n\t\t *\n\t\t * @example\n\t\t * // In an event handler\n\t\t * async function handleSubmit(formData: FormData) {\n\t\t *   const { data, error } = await createUser.execute(formData);\n\t\t *   // Or simply: await createUser(formData);\n\t\t *   if (error) {\n\t\t *     notify.error({ title: 'Failed to create user', description: error.message });\n\t\t *     return;\n\t\t *   }\n\t\t *   goto(`/users/${data.id}`);\n\t\t * }\n\t\t */\n\t\tasync function execute(variables: TVariables) {\n\t\t\ttry {\n\t\t\t\treturn Ok(await runMutation(queryClient, newOptions, variables));\n\t\t\t} catch (error) {\n\t\t\t\treturn Err(error as TError);\n\t\t\t}\n\t\t}\n\n\t\t// Create a callable function that executes the mutation\n\t\t// and attach options and execute as properties\n\t\treturn Object.assign(execute, {\n\t\t\toptions: newOptions,\n\t\t\texecute,\n\t\t});\n\t};\n\n\treturn {\n\t\tdefineQuery,\n\t\tdefineMutation,\n\t};\n}\n\n/**\n * Internal helper that executes a mutation directly using the query client's mutation cache.\n *\n * This is what powers the callable behavior and `.execute()` method on mutations.\n * It bypasses the reactive mutation hooks and runs the mutation imperatively,\n * which is perfect for event handlers and other imperative code.\n *\n * @internal\n * @template TData - The type of data returned by the mutation\n * @template TError - The type of error that can be thrown\n * @template TVariables - The type of variables passed to the mutation\n * @template TContext - The type of context data\n * @param queryClient - The query client instance to use\n * @param options - The mutation options including mutationFn and mutationKey\n * @param variables - The variables to pass to the mutation function\n * @returns Promise that resolves with the mutation result\n */\nfunction runMutation<TData, TError, TVariables, TContext>(\n\tqueryClient: QueryClient,\n\toptions: MutationOptions<TData, TError, TVariables, TContext>,\n\tvariables: TVariables,\n) {\n\tconst mutation = queryClient.getMutationCache().build(queryClient, options);\n\treturn mutation.execute(variables);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkMA,SAAgB,qBAAqBA,aAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiE9D,MAAM,cAAc,CAOnBC,YAO2E;EAC3E,MAAM,aAAa;GAClB,GAAG;GACH,SAAS,OAAO,YAAY;IAC3B,IAAI,SAAS,QAAQ,QAAQ,QAAQ;AACrC,QAAI,kBAAkB,QAAS,UAAS,MAAM;AAC9C,WAAO,QAAQ,OAAO;GACtB;EACD;;;;;;;;;;;;;;;;;;;;;;;;EA+BD,eAAe,QAA6C;AAC3D,OAAI;AACH,WAAO,GACN,MAAM,YAAY,WAKhB;KACD,UAAU,WAAW;KACrB,SAAS,WAAW;IACpB,EAAC,CACF;GACD,SAAQ,OAAO;AACf,WAAO,IAAI,MAAgB;GAC3B;EACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCD,eAAe,SAA8C;AAC5D,OAAI;AACH,WAAO,GACN,MAAM,YAAY,gBAKhB;KACD,UAAU,WAAW;KACrB,SAAS,WAAW;IACpB,EAAC,CACF;GACD,SAAQ,OAAO;AACf,WAAO,IAAI,MAAgB;GAC3B;EACD;AAID,SAAO,OAAO,OAAO,QAAQ;GAC5B,SAAS;GACT;GACA;EACA,EAAC;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0ED,MAAM,iBAAiB,CACtBC,YAC+D;EAC/D,MAAM,aAAa;GAClB,GAAG;GACH,YAAY,OAAOC,cAA0B;AAC5C,WAAO,QAAQ,MAAM,QAAQ,WAAW,UAAU,CAAC;GACnD;EACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BD,eAAe,QAAQA,WAAuB;AAC7C,OAAI;AACH,WAAO,GAAG,MAAM,YAAY,aAAa,YAAY,UAAU,CAAC;GAChE,SAAQ,OAAO;AACf,WAAO,IAAI,MAAgB;GAC3B;EACD;AAID,SAAO,OAAO,OAAO,SAAS;GAC7B,SAAS;GACT;EACA,EAAC;CACF;AAED,QAAO;EACN;EACA;CACA;AACD;;;;;;;;;;;;;;;;;;AAmBD,SAAS,YACRH,aACAI,SACAD,WACC;CACD,MAAM,WAAW,YAAY,kBAAkB,CAAC,MAAM,aAAa,QAAQ;AAC3E,QAAO,SAAS,QAAQ,UAAU;AAClC"}
+{"version":3,"file":"index.js","names":["queryClient: QueryClient","options: DefineQueryInput<\n\t\t\tTQueryFnData,\n\t\t\tTError,\n\t\t\tTData,\n\t\t\tTQueryData,\n\t\t\tTQueryKey\n\t\t>","options: DefineMutationInput<TData, TError, TVariables, TContext>","variables: TVariables","options: MutationOptions<TData, TError, TVariables, TContext>"],"sources":["../../src/query/utils.ts"],"sourcesContent":["import type {\n\tDefaultError,\n\tMutationFunction,\n\tMutationKey,\n\tMutationOptions,\n\tQueryClient,\n\tQueryFunction,\n\tQueryKey,\n\tQueryObserverOptions,\n} from \"@tanstack/query-core\";\nimport { Err, Ok, type Result, resolve } from \"../result/index.js\";\n\n/**\n * Input options for defining a query.\n *\n * Extends TanStack Query's QueryObserverOptions but expects queryFn to return a Result type.\n * This type represents the configuration for creating a query definition with both\n * reactive and imperative interfaces for data fetching.\n *\n * @template TQueryFnData - The type of data returned by the query function\n * @template TError - The type of error that can be thrown\n * @template TData - The type of data returned by the query (after select transform)\n * @template TQueryKey - The type of the query key\n */\ntype DefineQueryInput<\n\tTQueryFnData = unknown,\n\tTError = DefaultError,\n\tTData = TQueryFnData,\n\tTQueryData = TQueryFnData,\n\tTQueryKey extends QueryKey = QueryKey,\n> = Omit<\n\tQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n\t\"queryFn\"\n> & {\n\tqueryKey: TQueryKey;\n\tqueryFn: QueryFunction<Result<TQueryFnData, TError>, TQueryKey>;\n};\n\n/**\n * Output of defineQuery function.\n *\n * The query definition is directly callable and defaults to `ensure()` behavior,\n * which is recommended for most imperative use cases like preloaders.\n *\n * Provides both reactive and imperative interfaces for data fetching:\n * - `()` (callable): Same as `ensure()` - returns cached data if available, fetches if not\n * - `options`: Returns config for use with useQuery() or createQuery()\n * - `fetch()`: Always attempts to fetch data (from cache if fresh, network if stale)\n * - `ensure()`: Guarantees data availability, preferring cached data (recommended for preloaders)\n *\n * @template TQueryFnData - The type of data returned by the query function\n * @template TError - The type of error that can be thrown\n * @template TData - The type of data returned by the query (after select transform)\n * @template TQueryKey - The type of the query key\n *\n * @example\n * ```typescript\n * const userQuery = defineQuery({...});\n *\n * // Directly callable (same as .ensure())\n * const { data, error } = await userQuery();\n *\n * // Or use explicit methods\n * const { data, error } = await userQuery.ensure();\n * const { data, error } = await userQuery.fetch();\n *\n * // For reactive usage (Svelte 5 requires accessor wrapper)\n * const query = createQuery(() => userQuery.options); // Svelte 5\n * const query = useQuery(userQuery.options); // React\n * ```\n */\ntype DefineQueryOutput<\n\tTQueryFnData = unknown,\n\tTError = DefaultError,\n\tTData = TQueryFnData,\n\tTQueryData = TQueryFnData,\n\tTQueryKey extends QueryKey = QueryKey,\n> = (() => Promise<Result<TQueryData, TError>>) & {\n\toptions: QueryObserverOptions<\n\t\tTQueryFnData,\n\t\tTError,\n\t\tTData,\n\t\tTQueryData,\n\t\tTQueryKey\n\t>;\n\tfetch: () => Promise<Result<TQueryData, TError>>;\n\tensure: () => Promise<Result<TQueryData, TError>>;\n};\n\n/**\n * Input options for defining a mutation.\n *\n * Extends TanStack Query's MutationOptions but expects mutationFn to return a Result type.\n * This type represents the configuration for creating a mutation definition with both\n * reactive and imperative interfaces for data mutations.\n *\n * @template TData - The type of data returned by the mutation\n * @template TError - The type of error that can be thrown\n * @template TVariables - The type of variables passed to the mutation\n * @template TContext - The type of context data for optimistic updates\n */\ntype DefineMutationInput<\n\tTData,\n\tTError,\n\tTVariables = void,\n\tTContext = unknown,\n> = Omit<MutationOptions<TData, TError, TVariables, TContext>, \"mutationFn\"> & {\n\tmutationKey: MutationKey;\n\tmutationFn: MutationFunction<Result<TData, TError>, TVariables>;\n};\n\n/**\n * Output of defineMutation function.\n *\n * The mutation definition is directly callable, which executes the mutation\n * and returns a Result. This is equivalent to calling `.execute()`.\n *\n * Provides both reactive and imperative interfaces for data mutations:\n * - `(variables)` (callable): Same as `execute()` - directly executes the mutation\n * - `options`: Returns config for use with useMutation() or createMutation()\n * - `execute(variables)`: Directly executes the mutation and returns a Result\n *\n * @template TData - The type of data returned by the mutation\n * @template TError - The type of error that can be thrown\n * @template TVariables - The type of variables passed to the mutation\n * @template TContext - The type of context data for optimistic updates\n *\n * @example\n * ```typescript\n * const createUser = defineMutation({...});\n *\n * // Directly callable (same as .execute())\n * const { data, error } = await createUser({ name: 'John' });\n *\n * // Or use explicit method\n * const { data, error } = await createUser.execute({ name: 'John' });\n *\n * // For reactive usage (Svelte 5 requires accessor wrapper)\n * const mutation = createMutation(() => createUser.options); // Svelte 5\n * const mutation = useMutation(createUser.options); // React\n * ```\n */\ntype DefineMutationOutput<\n\tTData,\n\tTError,\n\tTVariables = void,\n\tTContext = unknown,\n> = ((variables: TVariables) => Promise<Result<TData, TError>>) & {\n\toptions: MutationOptions<TData, TError, TVariables, TContext>;\n\texecute: (variables: TVariables) => Promise<Result<TData, TError>>;\n};\n\n/**\n * Creates factory functions for defining queries and mutations bound to a specific QueryClient.\n *\n * This factory pattern allows you to create isolated query/mutation definitions that are\n * bound to a specific QueryClient instance, enabling:\n * - Multiple query clients in the same application\n * - Testing with isolated query clients\n * - Framework-agnostic query definitions\n * - Proper separation of concerns between query logic and client instances\n *\n * The returned functions handle Result types automatically, unwrapping them for TanStack Query\n * while maintaining type safety throughout your application.\n *\n * @param queryClient - The QueryClient instance to bind the factories to\n * @returns An object containing defineQuery and defineMutation functions bound to the provided client\n *\n * @example\n * ```typescript\n * // Create your query client\n * const queryClient = new QueryClient({\n *   defaultOptions: {\n *     queries: { staleTime: 5 * 60 * 1000 }\n *   }\n * });\n *\n * // Create the factory functions\n * const { defineQuery, defineMutation } = createQueryFactories(queryClient);\n *\n * // Now use defineQuery and defineMutation as before\n * const userQuery = defineQuery({\n *   queryKey: ['user', userId],\n *   queryFn: () => services.getUser(userId)\n * });\n *\n * // Use in components (Svelte 5 requires accessor wrapper)\n * const query = createQuery(() => userQuery.options); // Svelte 5\n * const query = useQuery(userQuery.options); // React\n *\n * // Or imperatively\n * const { data, error } = await userQuery.fetch();\n * ```\n */\nexport function createQueryFactories(queryClient: QueryClient) {\n\t/**\n\t * Creates a query definition that bridges the gap between pure service functions and reactive UI components.\n\t *\n\t * This factory function is the cornerstone of our data fetching architecture. It wraps service calls\n\t * with TanStack Query superpowers while maintaining type safety through Result types.\n\t *\n\t * The returned query definition is **directly callable** and defaults to `ensure()` behavior,\n\t * which is recommended for most imperative use cases like preloaders.\n\t *\n\t * ## Why use defineQuery?\n\t *\n\t * 1. **Callable**: Call directly like `userQuery()` for imperative data fetching\n\t * 2. **Dual Interface**: Also provides reactive (`.options`) and explicit imperative (`.fetch()`, `.ensure()`) APIs\n\t * 3. **Automatic Error Handling**: Service functions return `Result<T, E>` types which are automatically\n\t *    unwrapped by TanStack Query, giving you proper error states in your components\n\t * 4. **Type Safety**: Full TypeScript support with proper inference for data and error types\n\t * 5. **Consistency**: Every query in the app follows the same pattern, making it easy to understand\n\t *\n\t * @template TQueryFnData - The type of data returned by the query function\n\t * @template TError - The type of error that can be thrown\n\t * @template TData - The type of data returned by the query (after select transform)\n\t * @template TQueryKey - The type of the query key\n\t *\n\t * @param options - Query configuration object\n\t * @param options.queryKey - Unique key for this query (used for caching and refetching)\n\t * @param options.queryFn - Function that fetches data and returns a Result type\n\t * @param options.* - Any other TanStack Query options (staleTime, refetchInterval, etc.)\n\t *\n\t * @returns Callable query definition with:\n\t *   - `()` (callable): Same as `ensure()` - returns cached data if available, fetches if not\n\t *   - `.options`: Config for use with useQuery() or createQuery()\n\t *   - `.fetch()`: Always attempts to fetch (from cache if fresh, network if stale)\n\t *   - `.ensure()`: Guarantees data availability, preferring cached data (recommended for preloaders)\n\t *\n\t * @example\n\t * ```typescript\n\t * // Step 1: Define your query in the query layer\n\t * const userQuery = defineQuery({\n\t *   queryKey: ['users', userId],\n\t *   queryFn: () => services.getUser(userId), // Returns Result<User, ApiError>\n\t *   staleTime: 5 * 60 * 1000, // Consider data fresh for 5 minutes\n\t * });\n\t *\n\t * // Step 2a: Use reactively in a Svelte 5 component (accessor wrapper required)\n\t * const query = createQuery(() => userQuery.options);\n\t * // query.data is User | undefined\n\t * // query.error is ApiError | null\n\t *\n\t * // Step 2b: Call directly in preloaders (recommended)\n\t * export const load = async () => {\n\t *   const { data, error } = await userQuery(); // Same as userQuery.ensure()\n\t *   if (error) throw error;\n\t *   return { user: data };\n\t * };\n\t *\n\t * // Step 2c: Use explicit methods when needed\n\t * async function refreshUser() {\n\t *   const { data, error } = await userQuery.fetch(); // Force fresh fetch\n\t *   if (error) {\n\t *     console.error('Failed to fetch user:', error);\n\t *   }\n\t * }\n\t * ```\n\t */\n\tconst defineQuery = <\n\t\tTQueryFnData = unknown,\n\t\tTError = DefaultError,\n\t\tTData = TQueryFnData,\n\t\tTQueryData = TQueryFnData,\n\t\tTQueryKey extends QueryKey = QueryKey,\n\t>(\n\t\toptions: DefineQueryInput<\n\t\t\tTQueryFnData,\n\t\t\tTError,\n\t\t\tTData,\n\t\t\tTQueryData,\n\t\t\tTQueryKey\n\t\t>,\n\t): DefineQueryOutput<TQueryFnData, TError, TData, TQueryData, TQueryKey> => {\n\t\tconst newOptions = {\n\t\t\t...options,\n\t\t\tqueryFn: async (context) => {\n\t\t\t\tlet result = options.queryFn(context);\n\t\t\t\tif (result instanceof Promise) result = await result;\n\t\t\t\treturn resolve(result);\n\t\t\t},\n\t\t} satisfies QueryObserverOptions<\n\t\t\tTQueryFnData,\n\t\t\tTError,\n\t\t\tTData,\n\t\t\tTQueryData,\n\t\t\tTQueryKey\n\t\t>;\n\n\t\t/**\n\t\t * Fetches data for this query using queryClient.fetchQuery().\n\t\t *\n\t\t * This method ALWAYS evaluates freshness and will refetch if data is stale.\n\t\t * It wraps TanStack Query's fetchQuery method, which returns cached data if fresh\n\t\t * or makes a network request if the data is stale or missing.\n\t\t *\n\t\t * **When to use fetch():**\n\t\t * - When you explicitly want to check data freshness\n\t\t * - For user-triggered refresh actions\n\t\t * - When you need the most up-to-date data\n\t\t *\n\t\t * **For preloaders, use ensure() instead** - it's more efficient for initial data loading.\n\t\t *\n\t\t * @returns Promise that resolves with a Result containing either the data or an error\n\t\t *\n\t\t * @example\n\t\t * // Good for user-triggered refresh\n\t\t * const { data, error } = await userQuery.fetch();\n\t\t * if (error) {\n\t\t *   console.error('Failed to load user:', error);\n\t\t * }\n\t\t */\n\t\tasync function fetch(): Promise<Result<TQueryData, TError>> {\n\t\t\ttry {\n\t\t\t\treturn Ok(\n\t\t\t\t\tawait queryClient.fetchQuery<\n\t\t\t\t\t\tTQueryFnData,\n\t\t\t\t\t\tTError,\n\t\t\t\t\t\tTQueryData,\n\t\t\t\t\t\tTQueryKey\n\t\t\t\t\t>({\n\t\t\t\t\t\tqueryKey: newOptions.queryKey,\n\t\t\t\t\t\tqueryFn: newOptions.queryFn,\n\t\t\t\t\t}),\n\t\t\t\t);\n\t\t\t} catch (error) {\n\t\t\t\treturn Err(error as TError);\n\t\t\t}\n\t\t}\n\n\t\t/**\n\t\t * Ensures data is available for this query using queryClient.ensureQueryData().\n\t\t *\n\t\t * This method PRIORITIZES cached data and only calls fetchQuery internally if no cached\n\t\t * data exists. It wraps TanStack Query's ensureQueryData method, which is perfect for\n\t\t * guaranteeing data availability with minimal network requests.\n\t\t *\n\t\t * **This is the RECOMMENDED method for preloaders** because:\n\t\t * - It returns cached data immediately if available\n\t\t * - It updates the query client cache properly\n\t\t * - It minimizes network requests during navigation\n\t\t * - It ensures components have data ready when they mount\n\t\t *\n\t\t * **When to use ensure():**\n\t\t * - Route preloaders and data loading functions\n\t\t * - Initial component data requirements\n\t\t * - When cached data is acceptable for immediate display\n\t\t *\n\t\t * This is also the default behavior when calling the query directly.\n\t\t *\n\t\t * @returns Promise that resolves with a Result containing either the data or an error\n\t\t *\n\t\t * @example\n\t\t * // Perfect for preloaders\n\t\t * export const load = async () => {\n\t\t *   const { data, error } = await userQuery.ensure();\n\t\t *   // Or simply: await userQuery();\n\t\t *   if (error) {\n\t\t *     throw error;\n\t\t *   }\n\t\t *   return { user: data };\n\t\t * };\n\t\t */\n\t\tasync function ensure(): Promise<Result<TQueryData, TError>> {\n\t\t\ttry {\n\t\t\t\treturn Ok(\n\t\t\t\t\tawait queryClient.ensureQueryData<\n\t\t\t\t\t\tTQueryFnData,\n\t\t\t\t\t\tTError,\n\t\t\t\t\t\tTQueryData,\n\t\t\t\t\t\tTQueryKey\n\t\t\t\t\t>({\n\t\t\t\t\t\tqueryKey: newOptions.queryKey,\n\t\t\t\t\t\tqueryFn: newOptions.queryFn,\n\t\t\t\t\t}),\n\t\t\t\t);\n\t\t\t} catch (error) {\n\t\t\t\treturn Err(error as TError);\n\t\t\t}\n\t\t}\n\n\t\t// Create a callable function that defaults to ensure() behavior\n\t\t// and attach options, fetch, and ensure as properties\n\t\treturn Object.assign(ensure, {\n\t\t\toptions: newOptions,\n\t\t\tfetch,\n\t\t\tensure,\n\t\t});\n\t};\n\n\t/**\n\t * Creates a mutation definition for operations that modify data (create, update, delete).\n\t *\n\t * This factory function is the mutation counterpart to defineQuery. It provides a clean way to\n\t * wrap service functions that perform side effects, while maintaining the same dual interface\n\t * pattern for maximum flexibility.\n\t *\n\t * The returned mutation definition is **directly callable**, which executes the mutation\n\t * and returns a Result. This is equivalent to calling `.execute()`.\n\t *\n\t * ## Why use defineMutation?\n\t *\n\t * 1. **Callable**: Call directly like `createUser({ name: 'John' })` for imperative execution\n\t * 2. **Dual Interface**: Also provides reactive (`.options`) and explicit imperative (`.execute()`) APIs\n\t * 3. **Consistent Error Handling**: Service functions return `Result<T, E>` types, ensuring\n\t *    errors are handled consistently throughout the app\n\t * 4. **Cache Management**: Mutations often update the cache after success (see examples)\n\t *\n\t * @template TData - The type of data returned by the mutation\n\t * @template TError - The type of error that can be thrown\n\t * @template TVariables - The type of variables passed to the mutation\n\t * @template TContext - The type of context data for optimistic updates\n\t *\n\t * @param options - Mutation configuration object\n\t * @param options.mutationKey - Unique key for this mutation (used for tracking in-flight state)\n\t * @param options.mutationFn - Function that performs the mutation and returns a Result type\n\t * @param options.* - Any other TanStack Mutation options (onSuccess, onError, etc.)\n\t *\n\t * @returns Callable mutation definition with:\n\t *   - `(variables)` (callable): Same as `execute()` - directly executes the mutation\n\t *   - `.options`: Config for use with useMutation() or createMutation()\n\t *   - `.execute(variables)`: Directly executes the mutation and returns a Result\n\t *\n\t * @example\n\t * ```typescript\n\t * // Step 1: Define your mutation with cache updates\n\t * const createRecording = defineMutation({\n\t *   mutationKey: ['recordings', 'create'],\n\t *   mutationFn: async (recording: Recording) => {\n\t *     // Call the service\n\t *     const result = await services.db.createRecording(recording);\n\t *     if (result.error) return Err(result.error);\n\t *\n\t *     // Update cache on success\n\t *     queryClient.setQueryData(['recordings'], (old) =>\n\t *       [...(old || []), recording]\n\t *     );\n\t *\n\t *     return Ok(result.data);\n\t *   }\n\t * });\n\t *\n\t * // Step 2a: Use reactively in a Svelte 5 component (accessor wrapper required)\n\t * const mutation = createMutation(() => createRecording.options);\n\t * // Call with: mutation.mutate(recordingData)\n\t *\n\t * // Step 2b: Call directly in an action (recommended)\n\t * async function saveRecording(data: Recording) {\n\t *   const { error } = await createRecording(data); // Same as createRecording.execute(data)\n\t *   if (error) {\n\t *     notify.error({ title: 'Failed to save', description: error.message });\n\t *   } else {\n\t *     notify.success({ title: 'Recording saved!' });\n\t *   }\n\t * }\n\t * ```\n\t *\n\t * @tip Calling directly is especially useful for:\n\t * - Event handlers that need to await the result\n\t * - Sequential operations that depend on each other\n\t * - Non-component code that needs to trigger mutations\n\t */\n\tconst defineMutation = <TData, TError, TVariables = void, TContext = unknown>(\n\t\toptions: DefineMutationInput<TData, TError, TVariables, TContext>,\n\t): DefineMutationOutput<TData, TError, TVariables, TContext> => {\n\t\tconst newOptions = {\n\t\t\t...options,\n\t\t\tmutationFn: async (variables: TVariables) => {\n\t\t\t\treturn resolve(await options.mutationFn(variables));\n\t\t\t},\n\t\t} satisfies MutationOptions<TData, TError, TVariables, TContext>;\n\n\t\t/**\n\t\t * Executes the mutation imperatively and returns a Result.\n\t\t *\n\t\t * This is the recommended way to trigger mutations from:\n\t\t * - Button click handlers\n\t\t * - Form submissions\n\t\t * - Keyboard shortcuts\n\t\t * - Any non-component code\n\t\t *\n\t\t * The method automatically wraps the result in a Result type, so you always\n\t\t * get back `{ data, error }` for consistent error handling.\n\t\t *\n\t\t * This is also the default behavior when calling the mutation directly.\n\t\t *\n\t\t * @param variables - The variables to pass to the mutation function\n\t\t * @returns Promise that resolves with a Result containing either the data or an error\n\t\t *\n\t\t * @example\n\t\t * // In an event handler\n\t\t * async function handleSubmit(formData: FormData) {\n\t\t *   const { data, error } = await createUser.execute(formData);\n\t\t *   // Or simply: await createUser(formData);\n\t\t *   if (error) {\n\t\t *     notify.error({ title: 'Failed to create user', description: error.message });\n\t\t *     return;\n\t\t *   }\n\t\t *   goto(`/users/${data.id}`);\n\t\t * }\n\t\t */\n\t\tasync function execute(variables: TVariables) {\n\t\t\ttry {\n\t\t\t\treturn Ok(await runMutation(queryClient, newOptions, variables));\n\t\t\t} catch (error) {\n\t\t\t\treturn Err(error as TError);\n\t\t\t}\n\t\t}\n\n\t\t// Create a callable function that executes the mutation\n\t\t// and attach options and execute as properties\n\t\treturn Object.assign(execute, {\n\t\t\toptions: newOptions,\n\t\t\texecute,\n\t\t});\n\t};\n\n\treturn {\n\t\tdefineQuery,\n\t\tdefineMutation,\n\t};\n}\n\n/**\n * Internal helper that executes a mutation directly using the query client's mutation cache.\n *\n * This is what powers the callable behavior and `.execute()` method on mutations.\n * It bypasses the reactive mutation hooks and runs the mutation imperatively,\n * which is perfect for event handlers and other imperative code.\n *\n * @internal\n * @template TData - The type of data returned by the mutation\n * @template TError - The type of error that can be thrown\n * @template TVariables - The type of variables passed to the mutation\n * @template TContext - The type of context data\n * @param queryClient - The query client instance to use\n * @param options - The mutation options including mutationFn and mutationKey\n * @param variables - The variables to pass to the mutation function\n * @returns Promise that resolves with the mutation result\n */\nfunction runMutation<TData, TError, TVariables, TContext>(\n\tqueryClient: QueryClient,\n\toptions: MutationOptions<TData, TError, TVariables, TContext>,\n\tvariables: TVariables,\n) {\n\tconst mutation = queryClient.getMutationCache().build(queryClient, options);\n\treturn mutation.execute(variables);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkMA,SAAgB,qBAAqBA,aAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiE9D,MAAM,cAAc,CAOnBC,YAO2E;EAC3E,MAAM,aAAa;GAClB,GAAG;GACH,SAAS,OAAO,YAAY;IAC3B,IAAI,SAAS,QAAQ,QAAQ,QAAQ;AACrC,QAAI,kBAAkB,QAAS,UAAS,MAAM;AAC9C,WAAO,QAAQ,OAAO;GACtB;EACD;;;;;;;;;;;;;;;;;;;;;;;;EA+BD,eAAe,QAA6C;AAC3D,OAAI;AACH,WAAO,GACN,MAAM,YAAY,WAKhB;KACD,UAAU,WAAW;KACrB,SAAS,WAAW;IACpB,EAAC,CACF;GACD,SAAQ,OAAO;AACf,WAAO,IAAI,MAAgB;GAC3B;EACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCD,eAAe,SAA8C;AAC5D,OAAI;AACH,WAAO,GACN,MAAM,YAAY,gBAKhB;KACD,UAAU,WAAW;KACrB,SAAS,WAAW;IACpB,EAAC,CACF;GACD,SAAQ,OAAO;AACf,WAAO,IAAI,MAAgB;GAC3B;EACD;AAID,SAAO,OAAO,OAAO,QAAQ;GAC5B,SAAS;GACT;GACA;EACA,EAAC;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0ED,MAAM,iBAAiB,CACtBC,YAC+D;EAC/D,MAAM,aAAa;GAClB,GAAG;GACH,YAAY,OAAOC,cAA0B;AAC5C,WAAO,QAAQ,MAAM,QAAQ,WAAW,UAAU,CAAC;GACnD;EACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BD,eAAe,QAAQA,WAAuB;AAC7C,OAAI;AACH,WAAO,GAAG,MAAM,YAAY,aAAa,YAAY,UAAU,CAAC;GAChE,SAAQ,OAAO;AACf,WAAO,IAAI,MAAgB;GAC3B;EACD;AAID,SAAO,OAAO,OAAO,SAAS;GAC7B,SAAS;GACT;EACA,EAAC;CACF;AAED,QAAO;EACN;EACA;CACA;AACD;;;;;;;;;;;;;;;;;;AAmBD,SAAS,YACRH,aACAI,SACAD,WACC;CACD,MAAM,WAAW,YAAY,kBAAkB,CAAC,MAAM,aAAa,QAAQ;AAC3E,QAAO,SAAS,QAAQ,UAAU;AAClC"}

package/dist/result/index.d.ts

@@ -1,3 +1,3 @@
-import { Err, ExtractErrFromResult, ExtractOkFromResult, Ok, Result, UnwrapErr, UnwrapOk, isErr, isOk, isResult, resolve, tryAsync, trySync, unwrap } from "../result-DolxQXIZ.js";
-import { partitionResults } from "../index-Cd0uJHqj.js";
-export { Err, ExtractErrFromResult, ExtractOkFromResult, Ok, Result, UnwrapErr, UnwrapOk, isErr, isOk, isResult, partitionResults, resolve, tryAsync, trySync, unwrap };
+import { Err, Ok, Result, UnwrapErr, UnwrapOk, isErr, isOk, isResult, resolve, tryAsync, trySync, unwrap } from "../result-BgPMmUXd.js";
+import { partitionResults } from "../index-8WW9UMob.js";
+export { Err, Ok, Result, UnwrapErr, UnwrapOk, isErr, isOk, isResult, partitionResults, resolve, tryAsync, trySync, unwrap };

package/dist/{result-DolxQXIZ.d.ts → result-BgPMmUXd.d.ts}

@@ -97,30 +97,6 @@ declare const Ok: <T>(data: T) => Ok<T>;
  * ```
  */
 declare const Err: <E>(error: E) => Err<E>;
-/**
- * Utility type to extract the `Ok<T>` variant from a `Result<T, E>` union type.
- *
- * If `R` is a `Result` type (e.g., `Result<string, Error>`), this type will resolve
- * to `Ok<string>`. This can be useful in generic contexts or for type narrowing.
- *
- * @template R - The `Result<T, E>` union type from which to extract the `Ok<T>` variant.
- *             Must extend `Result<unknown, unknown>`.
- */
-type ExtractOkFromResult<R extends Result<unknown, unknown>> = Extract<R, {
-  error: null;
-}>;
-/**
- * Utility type to extract the `Err<E>` variant from a `Result<T, E>` union type.
- *
- * If `R` is a `Result` type (e.g., `Result<string, Error>`), this type will resolve
- * to `Err<Error>`. This can be useful in generic contexts or for type narrowing.
- *
- * @template R - The `Result<T, E>` union type from which to extract the `Err<E>` variant.
- *             Must extend `Result<unknown, unknown>`.
- */
-type ExtractErrFromResult<R extends Result<unknown, unknown>> = Extract<R, {
-  data: null;
-}>;
 /**
  * Utility type to extract the success value's type `T` from a `Result<T, E>` type.
  *
@@ -447,5 +423,5 @@ declare function unwrap<T, E>(result: Result<T, E>): T;
 declare function resolve<T, E>(value: T | Result<T, E>): T;
 //# sourceMappingURL=result.d.ts.map
 //#endregion
-export { Err, ExtractErrFromResult, ExtractOkFromResult, Ok, Result, UnwrapErr, UnwrapOk, isErr, isOk, isResult, resolve, tryAsync, trySync, unwrap };
-//# sourceMappingURL=result-DolxQXIZ.d.ts.map
+export { Err, Ok, Result, UnwrapErr, UnwrapOk, isErr, isOk, isResult, resolve, tryAsync, trySync, unwrap };
+//# sourceMappingURL=result-BgPMmUXd.d.ts.map

package/dist/result-BgPMmUXd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-BgPMmUXd.d.ts","names":[],"sources":["../src/result/result.ts"],"sourcesContent":[],"mappings":";;AAWA;AAaA;AAqCA;;;;;;AAAsC;AAiBtC;AAAgE,KAnEpD,EAmEoD,CAAA,CAAA,CAAA,GAAA;EAAA,IAApC,EAnEA,CAmEA;EAAC,KAAM,EAAA,IAAA;CAAC;AAAF;AAiBlC;;;;;AAAqC;AAoBrC;;;;AAAqE,KA3FzD,GA2FyD,CAAA,CAAA,CAAA,GAAA;EAAE,KACpE,EA5F2B,CA4F3B;EAAC,IAAA,EAAA,IAAA;AAqBJ,CAAA;;;;;;AAGI;AAgCJ;;;;;AAEkB;AAgClB;;;;;;;AAA8D;AAyB9D;;;;;;;AAAgE;AAgDhE;;;;;;;AAGM,KA7NM,MA6NN,CAAA,CAAA,EAAA,CAAA,CAAA,GA7NqB,EA6NrB,CA7NwB,CA6NxB,CAAA,GA7N6B,GA6N7B,CA7NiC,CA6NjC,CAAA;AAEN;;;;;;;;AAGU;AAEV;;;;;;AAEoC,cArNvB,EAqNuB,EAAA,CAAA,CAAA,CAAA,CAAA,IAAA,EArNR,CAqNQ,EAAA,GArNJ,EAqNI,CArND,CAqNC,CAAA;;;;AAC1B;AAiEV;;;;;;;;;AAGW;AAEX;AAA8B,cA3QjB,GA2QiB,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EA3QA,CA2QA,EAAA,GA3QI,GA2QJ,CA3QQ,CA2QR,CAAA;;;;;;;;;AAGnB;AAEX;;;;;;;;;AAGsB,KA/PV,QA+PU,CAAA,UA/PS,MA+PT,CAAA,OAAA,EAAA,OAAA,CAAA,CAAA,GA/PqC,CA+PrC,SA/P+C,EA+P/C,CAAA,KAAA,EAAA,CAAA,GA9PnB,CA8PmB,GAAA,KAAA;;;AAAX;AA+GX;;;;;;AAAqD;AAOrD;;;;;;;AAAyD;KA/V7C,oBAAoB,4BAA4B,UAAU,eAGnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCa,6DAEJ,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;iBAgCN,mBAAmB,OAAO,GAAG,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;iBAyB/C,oBAAoB,OAAO,GAAG,eAAe,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDjD;aACJ;6BACgB,GAAG;IAC3B,GAAG;iBAES;aACJ;6BACgB,IAAI;IAC5B,OAAO,GAAG;iBAEE;aACJ;6BACgB,GAAG,KAAK,IAAI;IACpC,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEQ;aACV,QAAQ;6BACQ,GAAG;IAC3B,QAAQ,GAAG;iBAEO;aACV,QAAQ;6BACQ,IAAI;IAC5B,QAAQ,OAAO,GAAG;iBAEA;aACV,QAAQ;6BACQ,GAAG,KAAK,IAAI;IACpC,QAAQ,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+GN,qBAAqB,OAAO,GAAG,KAAK;iBAOpC,qBAAqB,IAAI,OAAO,GAAG,KAAK"}

package/dist/result-DnOm5ds5.js.map

@@ -1 +1 @@
-{"version":3,"file":"result-DnOm5ds5.js","names":["data: T","error: E","value: unknown","result: Result<T, E>","value: T | Result<T, E>"],"sources":["../src/result/result.ts"],"sourcesContent":["/**\n * Represents the successful outcome of an operation, encapsulating the success value.\n *\n * This is the 'Ok' variant of the `Result` type. It holds a `data` property\n * of type `T` (the success value) and an `error` property explicitly set to `null`,\n * signifying no error occurred.\n *\n * Use this type in conjunction with `Err<E>` and `Result<T, E>`.\n *\n * @template T - The type of the success value contained within.\n */\nexport type Ok<T> = { data: T; error: null };\n\n/**\n * Represents the failure outcome of an operation, encapsulating the error value.\n *\n * This is the 'Err' variant of the `Result` type. It holds an `error` property\n * of type `E` (the error value) and a `data` property explicitly set to `null`,\n * signifying that no success value is present due to the failure.\n *\n * Use this type in conjunction with `Ok<T>` and `Result<T, E>`.\n *\n * @template E - The type of the error value contained within.\n */\nexport type Err<E> = { error: E; data: null };\n\n/**\n * A type that represents the outcome of an operation that can either succeed or fail.\n *\n * `Result<T, E>` is a discriminated union type with two possible variants:\n * - `Ok<T>`: Represents a successful outcome, containing a `data` field with the success value of type `T`.\n *            In this case, the `error` field is `null`.\n * - `Err<E>`: Represents a failure outcome, containing an `error` field with the error value of type `E`.\n *            In this case, the `data` field is `null`.\n *\n * This type promotes explicit error handling by requiring developers to check\n * the variant of the `Result` before accessing its potential value or error.\n * It helps avoid runtime errors often associated with implicit error handling (e.g., relying on `try-catch` for all errors).\n *\n * @template T - The type of the success value if the operation is successful (held in `Ok<T>`).\n * @template E - The type of the error value if the operation fails (held in `Err<E>`).\n * @example\n * ```ts\n * function divide(numerator: number, denominator: number): Result<number, string> {\n *   if (denominator === 0) {\n *     return Err(\"Cannot divide by zero\");\n *   }\n *   return Ok(numerator / denominator);\n * }\n *\n * const result1 = divide(10, 2);\n * if (isOk(result1)) {\n *   console.log(\"Success:\", result1.data); // Output: Success: 5\n * }\n *\n * const result2 = divide(10, 0);\n * if (isErr(result2)) {\n *   console.error(\"Failure:\", result2.error); // Output: Failure: Cannot divide by zero\n * }\n * ```\n */\nexport type Result<T, E> = Ok<T> | Err<E>;\n\n/**\n * Constructs an `Ok<T>` variant, representing a successful outcome.\n *\n * This factory function creates the success variant of a `Result`.\n * It wraps the provided `data` (the success value) and ensures the `error` property is `null`.\n *\n * @template T - The type of the success value.\n * @param data - The success value to be wrapped in the `Ok` variant.\n * @returns An `Ok<T>` object with the provided data and `error` set to `null`.\n * @example\n * ```ts\n * const successfulResult = Ok(\"Operation completed successfully\");\n * // successfulResult is { data: \"Operation completed successfully\", error: null }\n * ```\n */\nexport const Ok = <T>(data: T): Ok<T> => ({ data, error: null });\n\n/**\n * Constructs an `Err<E>` variant, representing a failure outcome.\n *\n * This factory function creates the error variant of a `Result`.\n * It wraps the provided `error` (the error value) and ensures the `data` property is `null`.\n *\n * @template E - The type of the error value.\n * @param error - The error value to be wrapped in the `Err` variant. This value represents the specific error that occurred.\n * @returns An `Err<E>` object with the provided error and `data` set to `null`.\n * @example\n * ```ts\n * const failedResult = Err(new TypeError(\"Invalid input\"));\n * // failedResult is { error: TypeError(\"Invalid input\"), data: null }\n * ```\n */\nexport const Err = <E>(error: E): Err<E> => ({ error, data: null });\n\n/**\n * Utility type to extract the `Ok<T>` variant from a `Result<T, E>` union type.\n *\n * If `R` is a `Result` type (e.g., `Result<string, Error>`), this type will resolve\n * to `Ok<string>`. This can be useful in generic contexts or for type narrowing.\n *\n * @template R - The `Result<T, E>` union type from which to extract the `Ok<T>` variant.\n *             Must extend `Result<unknown, unknown>`.\n */\nexport type ExtractOkFromResult<R extends Result<unknown, unknown>> = Extract<\n\tR,\n\t{ error: null }\n>;\n\n/**\n * Utility type to extract the `Err<E>` variant from a `Result<T, E>` union type.\n *\n * If `R` is a `Result` type (e.g., `Result<string, Error>`), this type will resolve\n * to `Err<Error>`. This can be useful in generic contexts or for type narrowing.\n *\n * @template R - The `Result<T, E>` union type from which to extract the `Err<E>` variant.\n *             Must extend `Result<unknown, unknown>`.\n */\nexport type ExtractErrFromResult<R extends Result<unknown, unknown>> = Extract<\n\tR,\n\t{ data: null }\n>;\n\n/**\n * Utility type to extract the success value's type `T` from a `Result<T, E>` type.\n *\n * If `R` is an `Ok<T>` variant (or a `Result<T, E>` that could be an `Ok<T>`),\n * this type resolves to `T`. If `R` can only be an `Err<E>` variant, it resolves to `never`.\n * This is useful for obtaining the type of the `data` field when you know you have a success.\n *\n * @template R - The `Result<T, E>` type from which to extract the success value's type.\n *             Must extend `Result<unknown, unknown>`.\n * @example\n * ```ts\n * type MyResult = Result<number, string>;\n * type SuccessValueType = UnwrapOk<MyResult>; // SuccessValueType is number\n *\n * type MyErrorResult = Err<string>;\n * type ErrorValueType = UnwrapOk<MyErrorResult>; // ErrorValueType is never\n * ```\n */\nexport type UnwrapOk<R extends Result<unknown, unknown>> = R extends Ok<infer U>\n\t? U\n\t: never;\n\n/**\n * Utility type to extract the error value's type `E` from a `Result<T, E>` type.\n *\n * If `R` is an `Err<E>` variant (or a `Result<T, E>` that could be an `Err<E>`),\n * this type resolves to `E`. If `R` can only be an `Ok<T>` variant, it resolves to `never`.\n * This is useful for obtaining the type of the `error` field when you know you have a failure.\n *\n * @template R - The `Result<T, E>` type from which to extract the error value's type.\n *             Must extend `Result<unknown, unknown>`.\n * @example\n * ```ts\n * type MyResult = Result<number, string>;\n * type ErrorValueType = UnwrapErr<MyResult>; // ErrorValueType is string\n *\n * type MySuccessResult = Ok<number>;\n * type SuccessValueType = UnwrapErr<MySuccessResult>; // SuccessValueType is never\n * ```\n */\nexport type UnwrapErr<R extends Result<unknown, unknown>> = R extends Err<\n\tinfer E\n>\n\t? E\n\t: never;\n\n/**\n * Type guard to runtime check if an unknown value is a valid `Result<T, E>`.\n *\n * A value is considered a valid `Result` if:\n * 1. It is a non-null object.\n * 2. It has both `data` and `error` properties.\n * 3. At least one of the `data` or `error` channels is `null`. Both being `null` represents `Ok(null)`.\n *\n * This function does not validate the types of `data` or `error` beyond `null` checks.\n *\n * @template T - The expected type of the success value if the value is an `Ok` variant (defaults to `unknown`).\n * @template E - The expected type of the error value if the value is an `Err` variant (defaults to `unknown`).\n * @param value - The value to check.\n * @returns `true` if the value conforms to the `Result` structure, `false` otherwise.\n *          If `true`, TypeScript's type system will narrow `value` to `Result<T, E>`.\n * @example\n * ```ts\n * declare const someValue: unknown;\n *\n * if (isResult<string, Error>(someValue)) {\n *   // someValue is now typed as Result<string, Error>\n *   if (isOk(someValue)) {\n *     console.log(someValue.data); // string\n *   } else {\n *     console.error(someValue.error); // Error\n *   }\n * }\n * ```\n */\nexport function isResult<T = unknown, E = unknown>(\n\tvalue: unknown,\n): value is Result<T, E> {\n\tconst isNonNullObject = typeof value === \"object\" && value !== null;\n\tif (!isNonNullObject) return false;\n\n\tconst hasDataProperty = \"data\" in value;\n\tconst hasErrorProperty = \"error\" in value;\n\tif (!hasDataProperty || !hasErrorProperty) return false;\n\n\treturn true;\n}\n\n/**\n * Type guard to runtime check if a `Result<T, E>` is an `Ok<T>` variant.\n *\n * This function narrows the type of a `Result` to `Ok<T>` if it represents a successful outcome.\n * An `Ok<T>` variant is identified by its `error` property being `null`.\n *\n * @template T - The success value type.\n * @template E - The error value type.\n * @param result - The `Result<T, E>` to check.\n * @returns `true` if the `result` is an `Ok<T>` variant, `false` otherwise.\n *          If `true`, TypeScript's type system will narrow `result` to `Ok<T>`.\n * @example\n * ```ts\n * declare const myResult: Result<number, string>;\n *\n * if (isOk(myResult)) {\n *   // myResult is now typed as Ok<number>\n *   console.log(\"Success value:\", myResult.data); // myResult.data is number\n * }\n * ```\n */\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T> {\n\treturn result.error === null;\n}\n\n/**\n * Type guard to runtime check if a `Result<T, E>` is an `Err<E>` variant.\n *\n * This function narrows the type of a `Result` to `Err<E>` if it represents a failure outcome.\n * An `Err<E>` variant is identified by its `error` property being non-`null` (and thus `data` being `null`).\n *\n * @template T - The success value type.\n * @template E - The error value type.\n * @param result - The `Result<T, E>` to check.\n * @returns `true` if the `result` is an `Err<E>` variant, `false` otherwise.\n *          If `true`, TypeScript's type system will narrow `result` to `Err<E>`.\n * @example\n * ```ts\n * declare const myResult: Result<number, string>;\n *\n * if (isErr(myResult)) {\n *   // myResult is now typed as Err<string>\n *   console.error(\"Error value:\", myResult.error); // myResult.error is string\n * }\n * ```\n */\nexport function isErr<T, E>(result: Result<T, E>): result is Err<E> {\n\treturn result.error !== null; // Equivalent to result.data === null\n}\n\n/**\n * Executes a synchronous operation and wraps its outcome in a Result type.\n *\n * This function attempts to execute the `try` operation:\n * - If the `try` operation completes successfully, its return value is wrapped in an `Ok<T>` variant.\n * - If the `try` operation throws an exception, the caught exception (of type `unknown`) is passed to\n *   the `catch` function, which transforms it into either an `Ok<T>` (recovery) or `Err<E>` (propagation).\n *\n * The return type is automatically narrowed based on what your catch function returns:\n * - If catch always returns `Ok<T>`, the function returns `Ok<T>` (guaranteed success)\n * - If catch always returns `Err<E>`, the function returns `Result<T, E>` (may succeed or fail)\n * - If catch can return either `Ok<T>` or `Err<E>`, the function returns `Result<T, E>` (conditional recovery)\n *\n * @template T - The success value type\n * @template E - The error value type (when catch can return errors)\n * @param options - Configuration object\n * @param options.try - The operation to execute\n * @param options.catch - Error handler that transforms caught exceptions into either `Ok<T>` (recovery) or `Err<E>` (propagation)\n * @returns `Ok<T>` if catch always returns Ok (recovery), otherwise `Result<T, E>` (propagation or conditional recovery)\n *\n * @example\n * ```ts\n * // Returns Ok<string> - guaranteed success since catch always returns Ok\n * const alwaysOk = trySync({\n *   try: () => JSON.parse(input),\n *   catch: () => Ok(\"fallback\") // Always Ok<T>\n * });\n *\n * // Returns Result<object, string> - may fail since catch always returns Err\n * const mayFail = trySync({\n *   try: () => JSON.parse(input),\n *   catch: (err) => Err(\"Parse failed\") // Returns Err<E>\n * });\n *\n * // Returns Result<void, MyError> - conditional recovery based on error type\n * const conditional = trySync({\n *   try: () => riskyOperation(),\n *   catch: (err) => {\n *     if (isRecoverable(err)) return Ok(undefined);\n *     return MyErr({ message: \"Unrecoverable\" });\n *   }\n * });\n * ```\n */\nexport function trySync<T>(options: {\n\ttry: () => T;\n\tcatch: (error: unknown) => Ok<T>;\n}): Ok<T>;\n\nexport function trySync<T, E>(options: {\n\ttry: () => T;\n\tcatch: (error: unknown) => Err<E>;\n}): Result<T, E>;\n\nexport function trySync<T, E>(options: {\n\ttry: () => T;\n\tcatch: (error: unknown) => Ok<T> | Err<E>;\n}): Result<T, E>;\n\nexport function trySync<T, E>({\n\ttry: operation,\n\tcatch: catchFn,\n}: {\n\ttry: () => T;\n\tcatch: (error: unknown) => Ok<T> | Err<E>;\n}): Ok<T> | Result<T, E> {\n\ttry {\n\t\tconst data = operation();\n\t\treturn Ok(data);\n\t} catch (error) {\n\t\treturn catchFn(error);\n\t}\n}\n\n/**\n * Executes an asynchronous operation and wraps its outcome in a Promise<Result>.\n *\n * This function attempts to execute the `try` operation:\n * - If the `try` operation resolves successfully, its resolved value is wrapped in an `Ok<T>` variant.\n * - If the `try` operation rejects or throws an exception, the caught error (of type `unknown`) is passed to\n *   the `catch` function, which transforms it into either an `Ok<T>` (recovery) or `Err<E>` (propagation).\n *\n * The return type is automatically narrowed based on what your catch function returns:\n * - If catch always returns `Ok<T>`, the function returns `Promise<Ok<T>>` (guaranteed success)\n * - If catch always returns `Err<E>`, the function returns `Promise<Result<T, E>>` (may succeed or fail)\n * - If catch can return either `Ok<T>` or `Err<E>`, the function returns `Promise<Result<T, E>>` (conditional recovery)\n *\n * @template T - The success value type\n * @template E - The error value type (when catch can return errors)\n * @param options - Configuration object\n * @param options.try - The async operation to execute\n * @param options.catch - Error handler that transforms caught exceptions/rejections into either `Ok<T>` (recovery) or `Err<E>` (propagation)\n * @returns `Promise<Ok<T>>` if catch always returns Ok (recovery), otherwise `Promise<Result<T, E>>` (propagation or conditional recovery)\n *\n * @example\n * ```ts\n * // Returns Promise<Ok<Response>> - guaranteed success since catch always returns Ok\n * const alwaysOk = tryAsync({\n *   try: async () => fetch(url),\n *   catch: () => Ok(new Response()) // Always Ok<T>\n * });\n *\n * // Returns Promise<Result<Response, Error>> - may fail since catch always returns Err\n * const mayFail = tryAsync({\n *   try: async () => fetch(url),\n *   catch: (err) => Err(new Error(\"Fetch failed\")) // Returns Err<E>\n * });\n *\n * // Returns Promise<Result<void, BlobError>> - conditional recovery based on error type\n * const conditional = await tryAsync({\n *   try: async () => {\n *     await deleteFile(filename);\n *   },\n *   catch: (err) => {\n *     if ((err as { name?: string }).name === 'NotFoundError') {\n *       return Ok(undefined); // Already deleted, that's fine\n *     }\n *     return BlobErr({ message: \"Delete failed\" });\n *   }\n * });\n * ```\n */\nexport async function tryAsync<T>(options: {\n\ttry: () => Promise<T>;\n\tcatch: (error: unknown) => Ok<T>;\n}): Promise<Ok<T>>;\n\nexport async function tryAsync<T, E>(options: {\n\ttry: () => Promise<T>;\n\tcatch: (error: unknown) => Err<E>;\n}): Promise<Result<T, E>>;\n\nexport async function tryAsync<T, E>(options: {\n\ttry: () => Promise<T>;\n\tcatch: (error: unknown) => Ok<T> | Err<E>;\n}): Promise<Result<T, E>>;\n\nexport async function tryAsync<T, E>({\n\ttry: operation,\n\tcatch: catchFn,\n}: {\n\ttry: () => Promise<T>;\n\tcatch: (error: unknown) => Ok<T> | Err<E>;\n}): Promise<Ok<T> | Result<T, E>> {\n\ttry {\n\t\tconst data = await operation();\n\t\treturn Ok(data);\n\t} catch (error) {\n\t\treturn catchFn(error);\n\t}\n}\n\n/**\n * Resolves a value that may or may not be wrapped in a `Result`, returning the final value.\n *\n * This function handles the common pattern where a value might be a `Result<T, E>` or a plain `T`:\n * - If `value` is an `Ok<T>` variant, returns the contained success value.\n * - If `value` is an `Err<E>` variant, throws the contained error value.\n * - If `value` is not a `Result` (i.e., it's already a plain value of type `T`),\n *   returns it as-is.\n *\n * This is useful when working with APIs that might return either direct values or Results,\n * allowing you to normalize them to the actual value or propagate errors via throwing.\n *\n * Use `resolve` when the input might or might not be a Result.\n * Use `unwrap` when you know the input is definitely a Result.\n *\n * @template T - The type of the success value (if `value` is `Ok<T>`) or the type of the plain value.\n * @template E - The type of the error value (if `value` is `Err<E>`).\n * @param value - The value to resolve. Can be a `Result<T, E>` or a plain value of type `T`.\n * @returns The final value of type `T` if `value` is `Ok<T>` or if `value` is already a plain `T`.\n * @throws The error value `E` if `value` is an `Err<E>` variant.\n *\n * @example\n * ```ts\n * // Example with an Ok variant\n * const okResult = Ok(\"success data\");\n * const resolved = resolve(okResult); // \"success data\"\n *\n * // Example with an Err variant\n * const errResult = Err(new Error(\"failure\"));\n * try {\n *   resolve(errResult);\n * } catch (e) {\n *   console.error(e.message); // \"failure\"\n * }\n *\n * // Example with a plain value\n * const plainValue = \"plain data\";\n * const resolved = resolve(plainValue); // \"plain data\"\n *\n * // Example with a function that might return Result or plain value\n * declare function mightReturnResult(): string | Result<string, Error>;\n * const outcome = mightReturnResult();\n * try {\n *  const finalValue = resolve(outcome); // handles both cases\n *  console.log(\"Final value:\", finalValue);\n * } catch (e) {\n *  console.error(\"Operation failed:\", e);\n * }\n * ```\n */\n/**\n * Unwraps a `Result<T, E>`, returning the success value or throwing the error.\n *\n * This function extracts the data from a `Result`:\n * - If the `Result` is an `Ok<T>` variant, returns the contained success value of type `T`.\n * - If the `Result` is an `Err<E>` variant, throws the contained error value of type `E`.\n *\n * Unlike `resolve`, this function expects the input to always be a `Result` type,\n * making it more direct for cases where you know you're working with a `Result`.\n *\n * @template T - The type of the success value contained in the `Ok<T>` variant.\n * @template E - The type of the error value contained in the `Err<E>` variant.\n * @param result - The `Result<T, E>` to unwrap.\n * @returns The success value of type `T` if the `Result` is `Ok<T>`.\n * @throws The error value of type `E` if the `Result` is `Err<E>`.\n *\n * @example\n * ```ts\n * // Example with an Ok variant\n * const okResult = Ok(\"success data\");\n * const value = unwrap(okResult); // \"success data\"\n *\n * // Example with an Err variant\n * const errResult = Err(new Error(\"something went wrong\"));\n * try {\n *   unwrap(errResult);\n * } catch (error) {\n *   console.error(error.message); // \"something went wrong\"\n * }\n *\n * // Usage in a function that returns Result\n * function divide(a: number, b: number): Result<number, string> {\n *   if (b === 0) return Err(\"Division by zero\");\n *   return Ok(a / b);\n * }\n *\n * try {\n *   const result = unwrap(divide(10, 2)); // 5\n *   console.log(\"Result:\", result);\n * } catch (error) {\n *   console.error(\"Division failed:\", error);\n * }\n * ```\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n\tif (isOk(result)) {\n\t\treturn result.data;\n\t}\n\tthrow result.error;\n}\n\nexport function resolve<T, E>(value: T | Result<T, E>): T {\n\tif (isResult<T, E>(value)) {\n\t\tif (isOk(value)) {\n\t\t\treturn value.data;\n\t\t}\n\t\t// If it's a Result and not Ok, it must be Err.\n\t\t// The type guard isResult<T,E>(value) and isOk(value) already refine the type.\n\t\t// So, 'value' here is known to be Err<E>.\n\t\tthrow value.error;\n\t}\n\n\t// If it's not a Result type, return the value as-is.\n\t// 'value' here is known to be of type T.\n\treturn value;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA8EA,MAAa,KAAK,CAAIA,UAAoB;CAAE;CAAM,OAAO;AAAM;;;;;;;;;;;;;;;;AAiB/D,MAAa,MAAM,CAAIC,WAAsB;CAAE;CAAO,MAAM;AAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyGlE,SAAgB,SACfC,OACwB;CACxB,MAAM,yBAAyB,UAAU,YAAY,UAAU;AAC/D,MAAK,gBAAiB,QAAO;CAE7B,MAAM,kBAAkB,UAAU;CAClC,MAAM,mBAAmB,WAAW;AACpC,MAAK,oBAAoB,iBAAkB,QAAO;AAElD,QAAO;AACP;;;;;;;;;;;;;;;;;;;;;;AAuBD,SAAgB,KAAWC,QAAuC;AACjE,QAAO,OAAO,UAAU;AACxB;;;;;;;;;;;;;;;;;;;;;;AAuBD,SAAgB,MAAYA,QAAwC;AACnE,QAAO,OAAO,UAAU;AACxB;AA6DD,SAAgB,QAAc,EAC7B,KAAK,WACL,OAAO,SAIP,EAAwB;AACxB,KAAI;EACH,MAAM,OAAO,WAAW;AACxB,SAAO,GAAG,KAAK;CACf,SAAQ,OAAO;AACf,SAAO,QAAQ,MAAM;CACrB;AACD;AAiED,eAAsB,SAAe,EACpC,KAAK,WACL,OAAO,SAIP,EAAiC;AACjC,KAAI;EACH,MAAM,OAAO,MAAM,WAAW;AAC9B,SAAO,GAAG,KAAK;CACf,SAAQ,OAAO;AACf,SAAO,QAAQ,MAAM;CACrB;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgGD,SAAgB,OAAaA,QAAyB;AACrD,KAAI,KAAK,OAAO,CACf,QAAO,OAAO;AAEf,OAAM,OAAO;AACb;AAED,SAAgB,QAAcC,OAA4B;AACzD,KAAI,SAAe,MAAM,EAAE;AAC1B,MAAI,KAAK,MAAM,CACd,QAAO,MAAM;AAKd,QAAM,MAAM;CACZ;AAID,QAAO;AACP"}
+{"version":3,"file":"result-DnOm5ds5.js","names":["data: T","error: E","value: unknown","result: Result<T, E>","value: T | Result<T, E>"],"sources":["../src/result/result.ts"],"sourcesContent":["/**\n * Represents the successful outcome of an operation, encapsulating the success value.\n *\n * This is the 'Ok' variant of the `Result` type. It holds a `data` property\n * of type `T` (the success value) and an `error` property explicitly set to `null`,\n * signifying no error occurred.\n *\n * Use this type in conjunction with `Err<E>` and `Result<T, E>`.\n *\n * @template T - The type of the success value contained within.\n */\nexport type Ok<T> = { data: T; error: null };\n\n/**\n * Represents the failure outcome of an operation, encapsulating the error value.\n *\n * This is the 'Err' variant of the `Result` type. It holds an `error` property\n * of type `E` (the error value) and a `data` property explicitly set to `null`,\n * signifying that no success value is present due to the failure.\n *\n * Use this type in conjunction with `Ok<T>` and `Result<T, E>`.\n *\n * @template E - The type of the error value contained within.\n */\nexport type Err<E> = { error: E; data: null };\n\n/**\n * A type that represents the outcome of an operation that can either succeed or fail.\n *\n * `Result<T, E>` is a discriminated union type with two possible variants:\n * - `Ok<T>`: Represents a successful outcome, containing a `data` field with the success value of type `T`.\n *            In this case, the `error` field is `null`.\n * - `Err<E>`: Represents a failure outcome, containing an `error` field with the error value of type `E`.\n *            In this case, the `data` field is `null`.\n *\n * This type promotes explicit error handling by requiring developers to check\n * the variant of the `Result` before accessing its potential value or error.\n * It helps avoid runtime errors often associated with implicit error handling (e.g., relying on `try-catch` for all errors).\n *\n * @template T - The type of the success value if the operation is successful (held in `Ok<T>`).\n * @template E - The type of the error value if the operation fails (held in `Err<E>`).\n * @example\n * ```ts\n * function divide(numerator: number, denominator: number): Result<number, string> {\n *   if (denominator === 0) {\n *     return Err(\"Cannot divide by zero\");\n *   }\n *   return Ok(numerator / denominator);\n * }\n *\n * const result1 = divide(10, 2);\n * if (isOk(result1)) {\n *   console.log(\"Success:\", result1.data); // Output: Success: 5\n * }\n *\n * const result2 = divide(10, 0);\n * if (isErr(result2)) {\n *   console.error(\"Failure:\", result2.error); // Output: Failure: Cannot divide by zero\n * }\n * ```\n */\nexport type Result<T, E> = Ok<T> | Err<E>;\n\n/**\n * Constructs an `Ok<T>` variant, representing a successful outcome.\n *\n * This factory function creates the success variant of a `Result`.\n * It wraps the provided `data` (the success value) and ensures the `error` property is `null`.\n *\n * @template T - The type of the success value.\n * @param data - The success value to be wrapped in the `Ok` variant.\n * @returns An `Ok<T>` object with the provided data and `error` set to `null`.\n * @example\n * ```ts\n * const successfulResult = Ok(\"Operation completed successfully\");\n * // successfulResult is { data: \"Operation completed successfully\", error: null }\n * ```\n */\nexport const Ok = <T>(data: T): Ok<T> => ({ data, error: null });\n\n/**\n * Constructs an `Err<E>` variant, representing a failure outcome.\n *\n * This factory function creates the error variant of a `Result`.\n * It wraps the provided `error` (the error value) and ensures the `data` property is `null`.\n *\n * @template E - The type of the error value.\n * @param error - The error value to be wrapped in the `Err` variant. This value represents the specific error that occurred.\n * @returns An `Err<E>` object with the provided error and `data` set to `null`.\n * @example\n * ```ts\n * const failedResult = Err(new TypeError(\"Invalid input\"));\n * // failedResult is { error: TypeError(\"Invalid input\"), data: null }\n * ```\n */\nexport const Err = <E>(error: E): Err<E> => ({ error, data: null });\n\n/**\n * Utility type to extract the success value's type `T` from a `Result<T, E>` type.\n *\n * If `R` is an `Ok<T>` variant (or a `Result<T, E>` that could be an `Ok<T>`),\n * this type resolves to `T`. If `R` can only be an `Err<E>` variant, it resolves to `never`.\n * This is useful for obtaining the type of the `data` field when you know you have a success.\n *\n * @template R - The `Result<T, E>` type from which to extract the success value's type.\n *             Must extend `Result<unknown, unknown>`.\n * @example\n * ```ts\n * type MyResult = Result<number, string>;\n * type SuccessValueType = UnwrapOk<MyResult>; // SuccessValueType is number\n *\n * type MyErrorResult = Err<string>;\n * type ErrorValueType = UnwrapOk<MyErrorResult>; // ErrorValueType is never\n * ```\n */\nexport type UnwrapOk<R extends Result<unknown, unknown>> = R extends Ok<infer U>\n\t? U\n\t: never;\n\n/**\n * Utility type to extract the error value's type `E` from a `Result<T, E>` type.\n *\n * If `R` is an `Err<E>` variant (or a `Result<T, E>` that could be an `Err<E>`),\n * this type resolves to `E`. If `R` can only be an `Ok<T>` variant, it resolves to `never`.\n * This is useful for obtaining the type of the `error` field when you know you have a failure.\n *\n * @template R - The `Result<T, E>` type from which to extract the error value's type.\n *             Must extend `Result<unknown, unknown>`.\n * @example\n * ```ts\n * type MyResult = Result<number, string>;\n * type ErrorValueType = UnwrapErr<MyResult>; // ErrorValueType is string\n *\n * type MySuccessResult = Ok<number>;\n * type SuccessValueType = UnwrapErr<MySuccessResult>; // SuccessValueType is never\n * ```\n */\nexport type UnwrapErr<R extends Result<unknown, unknown>> = R extends Err<\n\tinfer E\n>\n\t? E\n\t: never;\n\n/**\n * Type guard to runtime check if an unknown value is a valid `Result<T, E>`.\n *\n * A value is considered a valid `Result` if:\n * 1. It is a non-null object.\n * 2. It has both `data` and `error` properties.\n * 3. At least one of the `data` or `error` channels is `null`. Both being `null` represents `Ok(null)`.\n *\n * This function does not validate the types of `data` or `error` beyond `null` checks.\n *\n * @template T - The expected type of the success value if the value is an `Ok` variant (defaults to `unknown`).\n * @template E - The expected type of the error value if the value is an `Err` variant (defaults to `unknown`).\n * @param value - The value to check.\n * @returns `true` if the value conforms to the `Result` structure, `false` otherwise.\n *          If `true`, TypeScript's type system will narrow `value` to `Result<T, E>`.\n * @example\n * ```ts\n * declare const someValue: unknown;\n *\n * if (isResult<string, Error>(someValue)) {\n *   // someValue is now typed as Result<string, Error>\n *   if (isOk(someValue)) {\n *     console.log(someValue.data); // string\n *   } else {\n *     console.error(someValue.error); // Error\n *   }\n * }\n * ```\n */\nexport function isResult<T = unknown, E = unknown>(\n\tvalue: unknown,\n): value is Result<T, E> {\n\tconst isNonNullObject = typeof value === \"object\" && value !== null;\n\tif (!isNonNullObject) return false;\n\n\tconst hasDataProperty = \"data\" in value;\n\tconst hasErrorProperty = \"error\" in value;\n\tif (!hasDataProperty || !hasErrorProperty) return false;\n\n\treturn true;\n}\n\n/**\n * Type guard to runtime check if a `Result<T, E>` is an `Ok<T>` variant.\n *\n * This function narrows the type of a `Result` to `Ok<T>` if it represents a successful outcome.\n * An `Ok<T>` variant is identified by its `error` property being `null`.\n *\n * @template T - The success value type.\n * @template E - The error value type.\n * @param result - The `Result<T, E>` to check.\n * @returns `true` if the `result` is an `Ok<T>` variant, `false` otherwise.\n *          If `true`, TypeScript's type system will narrow `result` to `Ok<T>`.\n * @example\n * ```ts\n * declare const myResult: Result<number, string>;\n *\n * if (isOk(myResult)) {\n *   // myResult is now typed as Ok<number>\n *   console.log(\"Success value:\", myResult.data); // myResult.data is number\n * }\n * ```\n */\nexport function isOk<T, E>(result: Result<T, E>): result is Ok<T> {\n\treturn result.error === null;\n}\n\n/**\n * Type guard to runtime check if a `Result<T, E>` is an `Err<E>` variant.\n *\n * This function narrows the type of a `Result` to `Err<E>` if it represents a failure outcome.\n * An `Err<E>` variant is identified by its `error` property being non-`null` (and thus `data` being `null`).\n *\n * @template T - The success value type.\n * @template E - The error value type.\n * @param result - The `Result<T, E>` to check.\n * @returns `true` if the `result` is an `Err<E>` variant, `false` otherwise.\n *          If `true`, TypeScript's type system will narrow `result` to `Err<E>`.\n * @example\n * ```ts\n * declare const myResult: Result<number, string>;\n *\n * if (isErr(myResult)) {\n *   // myResult is now typed as Err<string>\n *   console.error(\"Error value:\", myResult.error); // myResult.error is string\n * }\n * ```\n */\nexport function isErr<T, E>(result: Result<T, E>): result is Err<E> {\n\treturn result.error !== null; // Equivalent to result.data === null\n}\n\n/**\n * Executes a synchronous operation and wraps its outcome in a Result type.\n *\n * This function attempts to execute the `try` operation:\n * - If the `try` operation completes successfully, its return value is wrapped in an `Ok<T>` variant.\n * - If the `try` operation throws an exception, the caught exception (of type `unknown`) is passed to\n *   the `catch` function, which transforms it into either an `Ok<T>` (recovery) or `Err<E>` (propagation).\n *\n * The return type is automatically narrowed based on what your catch function returns:\n * - If catch always returns `Ok<T>`, the function returns `Ok<T>` (guaranteed success)\n * - If catch always returns `Err<E>`, the function returns `Result<T, E>` (may succeed or fail)\n * - If catch can return either `Ok<T>` or `Err<E>`, the function returns `Result<T, E>` (conditional recovery)\n *\n * @template T - The success value type\n * @template E - The error value type (when catch can return errors)\n * @param options - Configuration object\n * @param options.try - The operation to execute\n * @param options.catch - Error handler that transforms caught exceptions into either `Ok<T>` (recovery) or `Err<E>` (propagation)\n * @returns `Ok<T>` if catch always returns Ok (recovery), otherwise `Result<T, E>` (propagation or conditional recovery)\n *\n * @example\n * ```ts\n * // Returns Ok<string> - guaranteed success since catch always returns Ok\n * const alwaysOk = trySync({\n *   try: () => JSON.parse(input),\n *   catch: () => Ok(\"fallback\") // Always Ok<T>\n * });\n *\n * // Returns Result<object, string> - may fail since catch always returns Err\n * const mayFail = trySync({\n *   try: () => JSON.parse(input),\n *   catch: (err) => Err(\"Parse failed\") // Returns Err<E>\n * });\n *\n * // Returns Result<void, MyError> - conditional recovery based on error type\n * const conditional = trySync({\n *   try: () => riskyOperation(),\n *   catch: (err) => {\n *     if (isRecoverable(err)) return Ok(undefined);\n *     return MyErr({ message: \"Unrecoverable\" });\n *   }\n * });\n * ```\n */\nexport function trySync<T>(options: {\n\ttry: () => T;\n\tcatch: (error: unknown) => Ok<T>;\n}): Ok<T>;\n\nexport function trySync<T, E>(options: {\n\ttry: () => T;\n\tcatch: (error: unknown) => Err<E>;\n}): Result<T, E>;\n\nexport function trySync<T, E>(options: {\n\ttry: () => T;\n\tcatch: (error: unknown) => Ok<T> | Err<E>;\n}): Result<T, E>;\n\nexport function trySync<T, E>({\n\ttry: operation,\n\tcatch: catchFn,\n}: {\n\ttry: () => T;\n\tcatch: (error: unknown) => Ok<T> | Err<E>;\n}): Ok<T> | Result<T, E> {\n\ttry {\n\t\tconst data = operation();\n\t\treturn Ok(data);\n\t} catch (error) {\n\t\treturn catchFn(error);\n\t}\n}\n\n/**\n * Executes an asynchronous operation and wraps its outcome in a Promise<Result>.\n *\n * This function attempts to execute the `try` operation:\n * - If the `try` operation resolves successfully, its resolved value is wrapped in an `Ok<T>` variant.\n * - If the `try` operation rejects or throws an exception, the caught error (of type `unknown`) is passed to\n *   the `catch` function, which transforms it into either an `Ok<T>` (recovery) or `Err<E>` (propagation).\n *\n * The return type is automatically narrowed based on what your catch function returns:\n * - If catch always returns `Ok<T>`, the function returns `Promise<Ok<T>>` (guaranteed success)\n * - If catch always returns `Err<E>`, the function returns `Promise<Result<T, E>>` (may succeed or fail)\n * - If catch can return either `Ok<T>` or `Err<E>`, the function returns `Promise<Result<T, E>>` (conditional recovery)\n *\n * @template T - The success value type\n * @template E - The error value type (when catch can return errors)\n * @param options - Configuration object\n * @param options.try - The async operation to execute\n * @param options.catch - Error handler that transforms caught exceptions/rejections into either `Ok<T>` (recovery) or `Err<E>` (propagation)\n * @returns `Promise<Ok<T>>` if catch always returns Ok (recovery), otherwise `Promise<Result<T, E>>` (propagation or conditional recovery)\n *\n * @example\n * ```ts\n * // Returns Promise<Ok<Response>> - guaranteed success since catch always returns Ok\n * const alwaysOk = tryAsync({\n *   try: async () => fetch(url),\n *   catch: () => Ok(new Response()) // Always Ok<T>\n * });\n *\n * // Returns Promise<Result<Response, Error>> - may fail since catch always returns Err\n * const mayFail = tryAsync({\n *   try: async () => fetch(url),\n *   catch: (err) => Err(new Error(\"Fetch failed\")) // Returns Err<E>\n * });\n *\n * // Returns Promise<Result<void, BlobError>> - conditional recovery based on error type\n * const conditional = await tryAsync({\n *   try: async () => {\n *     await deleteFile(filename);\n *   },\n *   catch: (err) => {\n *     if ((err as { name?: string }).name === 'NotFoundError') {\n *       return Ok(undefined); // Already deleted, that's fine\n *     }\n *     return BlobErr({ message: \"Delete failed\" });\n *   }\n * });\n * ```\n */\nexport async function tryAsync<T>(options: {\n\ttry: () => Promise<T>;\n\tcatch: (error: unknown) => Ok<T>;\n}): Promise<Ok<T>>;\n\nexport async function tryAsync<T, E>(options: {\n\ttry: () => Promise<T>;\n\tcatch: (error: unknown) => Err<E>;\n}): Promise<Result<T, E>>;\n\nexport async function tryAsync<T, E>(options: {\n\ttry: () => Promise<T>;\n\tcatch: (error: unknown) => Ok<T> | Err<E>;\n}): Promise<Result<T, E>>;\n\nexport async function tryAsync<T, E>({\n\ttry: operation,\n\tcatch: catchFn,\n}: {\n\ttry: () => Promise<T>;\n\tcatch: (error: unknown) => Ok<T> | Err<E>;\n}): Promise<Ok<T> | Result<T, E>> {\n\ttry {\n\t\tconst data = await operation();\n\t\treturn Ok(data);\n\t} catch (error) {\n\t\treturn catchFn(error);\n\t}\n}\n\n/**\n * Resolves a value that may or may not be wrapped in a `Result`, returning the final value.\n *\n * This function handles the common pattern where a value might be a `Result<T, E>` or a plain `T`:\n * - If `value` is an `Ok<T>` variant, returns the contained success value.\n * - If `value` is an `Err<E>` variant, throws the contained error value.\n * - If `value` is not a `Result` (i.e., it's already a plain value of type `T`),\n *   returns it as-is.\n *\n * This is useful when working with APIs that might return either direct values or Results,\n * allowing you to normalize them to the actual value or propagate errors via throwing.\n *\n * Use `resolve` when the input might or might not be a Result.\n * Use `unwrap` when you know the input is definitely a Result.\n *\n * @template T - The type of the success value (if `value` is `Ok<T>`) or the type of the plain value.\n * @template E - The type of the error value (if `value` is `Err<E>`).\n * @param value - The value to resolve. Can be a `Result<T, E>` or a plain value of type `T`.\n * @returns The final value of type `T` if `value` is `Ok<T>` or if `value` is already a plain `T`.\n * @throws The error value `E` if `value` is an `Err<E>` variant.\n *\n * @example\n * ```ts\n * // Example with an Ok variant\n * const okResult = Ok(\"success data\");\n * const resolved = resolve(okResult); // \"success data\"\n *\n * // Example with an Err variant\n * const errResult = Err(new Error(\"failure\"));\n * try {\n *   resolve(errResult);\n * } catch (e) {\n *   console.error(e.message); // \"failure\"\n * }\n *\n * // Example with a plain value\n * const plainValue = \"plain data\";\n * const resolved = resolve(plainValue); // \"plain data\"\n *\n * // Example with a function that might return Result or plain value\n * declare function mightReturnResult(): string | Result<string, Error>;\n * const outcome = mightReturnResult();\n * try {\n *  const finalValue = resolve(outcome); // handles both cases\n *  console.log(\"Final value:\", finalValue);\n * } catch (e) {\n *  console.error(\"Operation failed:\", e);\n * }\n * ```\n */\n/**\n * Unwraps a `Result<T, E>`, returning the success value or throwing the error.\n *\n * This function extracts the data from a `Result`:\n * - If the `Result` is an `Ok<T>` variant, returns the contained success value of type `T`.\n * - If the `Result` is an `Err<E>` variant, throws the contained error value of type `E`.\n *\n * Unlike `resolve`, this function expects the input to always be a `Result` type,\n * making it more direct for cases where you know you're working with a `Result`.\n *\n * @template T - The type of the success value contained in the `Ok<T>` variant.\n * @template E - The type of the error value contained in the `Err<E>` variant.\n * @param result - The `Result<T, E>` to unwrap.\n * @returns The success value of type `T` if the `Result` is `Ok<T>`.\n * @throws The error value of type `E` if the `Result` is `Err<E>`.\n *\n * @example\n * ```ts\n * // Example with an Ok variant\n * const okResult = Ok(\"success data\");\n * const value = unwrap(okResult); // \"success data\"\n *\n * // Example with an Err variant\n * const errResult = Err(new Error(\"something went wrong\"));\n * try {\n *   unwrap(errResult);\n * } catch (error) {\n *   console.error(error.message); // \"something went wrong\"\n * }\n *\n * // Usage in a function that returns Result\n * function divide(a: number, b: number): Result<number, string> {\n *   if (b === 0) return Err(\"Division by zero\");\n *   return Ok(a / b);\n * }\n *\n * try {\n *   const result = unwrap(divide(10, 2)); // 5\n *   console.log(\"Result:\", result);\n * } catch (error) {\n *   console.error(\"Division failed:\", error);\n * }\n * ```\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n\tif (isOk(result)) {\n\t\treturn result.data;\n\t}\n\tthrow result.error;\n}\n\nexport function resolve<T, E>(value: T | Result<T, E>): T {\n\tif (isResult<T, E>(value)) {\n\t\tif (isOk(value)) {\n\t\t\treturn value.data;\n\t\t}\n\t\t// If it's a Result and not Ok, it must be Err.\n\t\t// The type guard isResult<T,E>(value) and isOk(value) already refine the type.\n\t\t// So, 'value' here is known to be Err<E>.\n\t\tthrow value.error;\n\t}\n\n\t// If it's not a Result type, return the value as-is.\n\t// 'value' here is known to be of type T.\n\treturn value;\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA8EA,MAAa,KAAK,CAAIA,UAAoB;CAAE;CAAM,OAAO;AAAM;;;;;;;;;;;;;;;;AAiB/D,MAAa,MAAM,CAAIC,WAAsB;CAAE;CAAO,MAAM;AAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6ElE,SAAgB,SACfC,OACwB;CACxB,MAAM,yBAAyB,UAAU,YAAY,UAAU;AAC/D,MAAK,gBAAiB,QAAO;CAE7B,MAAM,kBAAkB,UAAU;CAClC,MAAM,mBAAmB,WAAW;AACpC,MAAK,oBAAoB,iBAAkB,QAAO;AAElD,QAAO;AACP;;;;;;;;;;;;;;;;;;;;;;AAuBD,SAAgB,KAAWC,QAAuC;AACjE,QAAO,OAAO,UAAU;AACxB;;;;;;;;;;;;;;;;;;;;;;AAuBD,SAAgB,MAAYA,QAAwC;AACnE,QAAO,OAAO,UAAU;AACxB;AA6DD,SAAgB,QAAc,EAC7B,KAAK,WACL,OAAO,SAIP,EAAwB;AACxB,KAAI;EACH,MAAM,OAAO,WAAW;AACxB,SAAO,GAAG,KAAK;CACf,SAAQ,OAAO;AACf,SAAO,QAAQ,MAAM;CACrB;AACD;AAiED,eAAsB,SAAe,EACpC,KAAK,WACL,OAAO,SAIP,EAAiC;AACjC,KAAI;EACH,MAAM,OAAO,MAAM,WAAW;AAC9B,SAAO,GAAG,KAAK;CACf,SAAQ,OAAO;AACf,SAAO,QAAQ,MAAM;CACrB;AACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgGD,SAAgB,OAAaA,QAAyB;AACrD,KAAI,KAAK,OAAO,CACf,QAAO,OAAO;AAEf,OAAM,OAAO;AACb;AAED,SAAgB,QAAcC,OAA4B;AACzD,KAAI,SAAe,MAAM,EAAE;AAC1B,MAAI,KAAK,MAAM,CACd,QAAO,MAAM;AAKd,QAAM,MAAM;CACZ;AAID,QAAO;AACP"}

package/dist/standard-schema/index.d.ts

@@ -132,12 +132,6 @@ declare namespace StandardJSONSchemaV1 {
   /** Infers the output type of a Standard JSON Schema. */
   type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
 }
-/**
- * A schema that implements both StandardSchemaV1 and StandardJSONSchemaV1.
- */
-type StandardFullSchemaV1<Input = unknown, Output = Input> = {
-  readonly "~standard": StandardSchemaV1.Props<Input, Output> & StandardJSONSchemaV1.Props<Input, Output>;
-};
 /**
  * Checks if a schema has validation capability.
  */
@@ -367,5 +361,5 @@ declare function ResultSchema<TDataSchema extends StandardTypedV1, TErrorSchema
 //# sourceMappingURL=result.d.ts.map
 
 //#endregion
-export { Err, ErrSchema, FAILURES, Ok, OkSchema, Result$1 as Result, ResultSchema, StandardFullSchemaV1, StandardJSONSchemaV1, StandardSchemaV1, StandardTypedV1, hasJsonSchema, hasValidate };
+export { Err, ErrSchema, FAILURES, Ok, OkSchema, Result$1 as Result, ResultSchema, StandardJSONSchemaV1, StandardSchemaV1, StandardTypedV1, hasJsonSchema, hasValidate };
 //# sourceMappingURL=index.d.ts.map

package/dist/standard-schema/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/standard-schema/types.ts","../../src/standard-schema/err.ts","../../src/standard-schema/failures.ts","../../src/standard-schema/ok.ts","../../src/standard-schema/result.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/standard-schema/types.ts","../../src/standard-schema/err.ts","../../src/standard-schema/failures.ts","../../src/standard-schema/ok.ts","../../src/standard-schema/result.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/standard-schema/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["schema: T","innerSchema: TSchema","value: unknown","issue: StandardSchemaV1.Issue","options: StandardJSONSchemaV1.Options","innerSchema: TSchema","value: unknown","issue: StandardSchemaV1.Issue","options: StandardJSONSchemaV1.Options","dataSchema: TDataSchema","errorSchema: TErrorSchema","value: unknown","innerResult","issue: StandardSchemaV1.Issue","options: StandardJSONSchemaV1.Options"],"sources":["../../src/standard-schema/failures.ts","../../src/standard-schema/types.ts","../../src/standard-schema/err.ts","../../src/standard-schema/ok.ts","../../src/standard-schema/result.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"./types.js\";\n\nexport const FAILURES = {\n\tEXPECTED_OBJECT: { issues: [{ message: \"Expected object\" }] },\n\tEXPECTED_DATA_ERROR_PROPS: {\n\t\tissues: [{ message: \"Expected object with 'data' and 'error' properties\" }],\n\t},\n\tEXPECTED_ERROR_NULL: {\n\t\tissues: [\n\t\t\t{\n\t\t\t\tmessage: \"Expected 'error' to be null for Ok variant\",\n\t\t\t\tpath: [\"error\"],\n\t\t\t},\n\t\t],\n\t},\n\tEXPECTED_ERROR_NOT_NULL: {\n\t\tissues: [\n\t\t\t{\n\t\t\t\tmessage: \"Expected 'error' to be non-null for Err variant\",\n\t\t\t\tpath: [\"error\"],\n\t\t\t},\n\t\t],\n\t},\n} as const satisfies Record<string, StandardSchemaV1.FailureResult>;\n","/**\n * Standard Schema type definitions.\n *\n * These interfaces are copied from the Standard Schema specification\n * (https://standardschema.dev) to avoid external dependencies.\n *\n * @see https://github.com/standard-schema/standard-schema\n */\n\n// #########################\n// ###   Standard Typed  ###\n// #########################\n\n/**\n * The Standard Typed interface. This is a base type extended by other specs.\n */\nexport type StandardTypedV1<Input = unknown, Output = Input> = {\n\t/** The Standard properties. */\n\treadonly \"~standard\": StandardTypedV1.Props<Input, Output>;\n};\n\nexport declare namespace StandardTypedV1 {\n\t/** The Standard Typed properties interface. */\n\ttype Props<Input = unknown, Output = Input> = {\n\t\t/** The version number of the standard. */\n\t\treadonly version: 1;\n\t\t/** The vendor name of the schema library. */\n\t\treadonly vendor: string;\n\t\t/** Inferred types associated with the schema. */\n\t\treadonly types?: Types<Input, Output> | undefined;\n\t};\n\n\t/** The Standard Typed types interface. */\n\ttype Types<Input = unknown, Output = Input> = {\n\t\t/** The input type of the schema. */\n\t\treadonly input: Input;\n\t\t/** The output type of the schema. */\n\t\treadonly output: Output;\n\t};\n\n\t/** Infers the input type of a Standard Typed. */\n\ttype InferInput<Schema extends StandardTypedV1> = NonNullable<\n\t\tSchema[\"~standard\"][\"types\"]\n\t>[\"input\"];\n\n\t/** Infers the output type of a Standard Typed. */\n\ttype InferOutput<Schema extends StandardTypedV1> = NonNullable<\n\t\tSchema[\"~standard\"][\"types\"]\n\t>[\"output\"];\n}\n\n// ##########################\n// ###   Standard Schema  ###\n// ##########################\n\n/**\n * The Standard Schema interface.\n *\n * Extends StandardTypedV1 with a validate function for runtime validation.\n */\nexport type StandardSchemaV1<Input = unknown, Output = Input> = {\n\t/** The Standard Schema properties. */\n\treadonly \"~standard\": StandardSchemaV1.Props<Input, Output>;\n};\n\nexport declare namespace StandardSchemaV1 {\n\t/** The Standard Schema properties interface. */\n\ttype Props<Input = unknown, Output = Input> = StandardTypedV1.Props<\n\t\tInput,\n\t\tOutput\n\t> & {\n\t\t/** Validates unknown input values. */\n\t\treadonly validate: (\n\t\t\tvalue: unknown,\n\t\t\toptions?: StandardSchemaV1.Options | undefined,\n\t\t) => Result<Output> | Promise<Result<Output>>;\n\t};\n\n\t/** The result interface of the validate function. */\n\ttype Result<Output> = SuccessResult<Output> | FailureResult;\n\n\t/** The result interface if validation succeeds. */\n\ttype SuccessResult<Output> = {\n\t\t/** The typed output value. */\n\t\treadonly value: Output;\n\t\t/** A falsy value for `issues` indicates success. */\n\t\treadonly issues?: undefined;\n\t};\n\n\t/** Options for the validate function. */\n\ttype Options = {\n\t\t/** Explicit support for additional vendor-specific parameters, if needed. */\n\t\treadonly libraryOptions?: Record<string, unknown> | undefined;\n\t};\n\n\t/** The result interface if validation fails. */\n\ttype FailureResult = {\n\t\t/** The issues of failed validation. */\n\t\treadonly issues: ReadonlyArray<Issue>;\n\t};\n\n\t/** The issue interface of the failure output. */\n\ttype Issue = {\n\t\t/** The error message of the issue. */\n\t\treadonly message: string;\n\t\t/** The path of the issue, if any. */\n\t\treadonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;\n\t};\n\n\t/** The path segment interface of the issue. */\n\ttype PathSegment = {\n\t\t/** The key representing a path segment. */\n\t\treadonly key: PropertyKey;\n\t};\n\n\t/** Infers the input type of a Standard Schema. */\n\ttype InferInput<Schema extends StandardTypedV1> =\n\t\tStandardTypedV1.InferInput<Schema>;\n\n\t/** Infers the output type of a Standard Schema. */\n\ttype InferOutput<Schema extends StandardTypedV1> =\n\t\tStandardTypedV1.InferOutput<Schema>;\n}\n\n// ###############################\n// ###   Standard JSON Schema  ###\n// ###############################\n\n/**\n * The Standard JSON Schema interface.\n *\n * Extends StandardTypedV1 with methods for generating JSON Schema.\n */\nexport type StandardJSONSchemaV1<Input = unknown, Output = Input> = {\n\t/** The Standard JSON Schema properties. */\n\treadonly \"~standard\": StandardJSONSchemaV1.Props<Input, Output>;\n};\n\nexport declare namespace StandardJSONSchemaV1 {\n\t/** The Standard JSON Schema properties interface. */\n\ttype Props<Input = unknown, Output = Input> = StandardTypedV1.Props<\n\t\tInput,\n\t\tOutput\n\t> & {\n\t\t/** Methods for generating the input/output JSON Schema. */\n\t\treadonly jsonSchema: StandardJSONSchemaV1.Converter;\n\t};\n\n\t/** The Standard JSON Schema converter interface. */\n\ttype Converter = {\n\t\t/** Converts the input type to JSON Schema. May throw if conversion is not supported. */\n\t\treadonly input: (\n\t\t\toptions: StandardJSONSchemaV1.Options,\n\t\t) => Record<string, unknown>;\n\t\t/** Converts the output type to JSON Schema. May throw if conversion is not supported. */\n\t\treadonly output: (\n\t\t\toptions: StandardJSONSchemaV1.Options,\n\t\t) => Record<string, unknown>;\n\t};\n\n\t/**\n\t * The target version of the generated JSON Schema.\n\t *\n\t * It is *strongly recommended* that implementers support `\"draft-2020-12\"` and `\"draft-07\"`,\n\t * as they are both in wide use. All other targets can be implemented on a best-effort basis.\n\t * Libraries should throw if they don't support a specified target.\n\t *\n\t * The `\"openapi-3.0\"` target is intended as a standardized specifier for OpenAPI 3.0\n\t * which is a superset of JSON Schema `\"draft-04\"`.\n\t */\n\ttype Target =\n\t\t| \"draft-2020-12\"\n\t\t| \"draft-07\"\n\t\t| \"openapi-3.0\"\n\t\t// Accepts any string for future targets while preserving autocomplete\n\t\t| (string & {});\n\n\t/** The options for the input/output methods. */\n\ttype Options = {\n\t\t/** Specifies the target version of the generated JSON Schema. */\n\t\treadonly target: Target;\n\t\t/** Explicit support for additional vendor-specific parameters, if needed. */\n\t\treadonly libraryOptions?: Record<string, unknown> | undefined;\n\t};\n\n\t/** Infers the input type of a Standard JSON Schema. */\n\ttype InferInput<Schema extends StandardTypedV1> =\n\t\tStandardTypedV1.InferInput<Schema>;\n\n\t/** Infers the output type of a Standard JSON Schema. */\n\ttype InferOutput<Schema extends StandardTypedV1> =\n\t\tStandardTypedV1.InferOutput<Schema>;\n}\n\n// ###############################\n// ###   Utility Types         ###\n// ###############################\n\n/**\n * A schema that implements both StandardSchemaV1 and StandardJSONSchemaV1.\n */\nexport type StandardFullSchemaV1<Input = unknown, Output = Input> = {\n\treadonly \"~standard\": StandardSchemaV1.Props<Input, Output> &\n\t\tStandardJSONSchemaV1.Props<Input, Output>;\n};\n\n/**\n * Checks if a schema has validation capability.\n */\nexport function hasValidate<T extends StandardTypedV1>(\n\tschema: T,\n): schema is T & StandardSchemaV1 {\n\treturn (\n\t\t\"validate\" in schema[\"~standard\"] &&\n\t\ttypeof schema[\"~standard\"].validate === \"function\"\n\t);\n}\n\n/**\n * Checks if a schema has JSON Schema generation capability.\n */\nexport function hasJsonSchema<T extends StandardTypedV1>(\n\tschema: T,\n): schema is T & StandardJSONSchemaV1 {\n\treturn (\n\t\t\"jsonSchema\" in schema[\"~standard\"] &&\n\t\ttypeof schema[\"~standard\"].jsonSchema === \"object\" &&\n\t\tschema[\"~standard\"].jsonSchema !== null\n\t);\n}\n","import { FAILURES } from \"./failures.js\";\nimport {\n\thasJsonSchema,\n\thasValidate,\n\ttype StandardJSONSchemaV1,\n\ttype StandardSchemaV1,\n\ttype StandardTypedV1,\n} from \"./types.js\";\n\n/**\n * Output type for ErrSchema - wraps inner schema's types with Err structure.\n *\n * Preserves the capabilities of the input schema:\n * - If input has validate, output has validate\n * - If input has jsonSchema, output has jsonSchema\n */\nexport type Err<TSchema extends StandardTypedV1> = {\n\treadonly \"~standard\": {\n\t\treadonly version: 1;\n\t\treadonly vendor: \"wellcrafted\";\n\t\treadonly types: {\n\t\t\treadonly input: {\n\t\t\t\tdata: null;\n\t\t\t\terror: StandardTypedV1.InferInput<TSchema>;\n\t\t\t};\n\t\t\treadonly output: {\n\t\t\t\tdata: null;\n\t\t\t\terror: StandardTypedV1.InferOutput<TSchema>;\n\t\t\t};\n\t\t};\n\t} & (TSchema extends StandardSchemaV1\n\t\t? {\n\t\t\t\treadonly validate: StandardSchemaV1.Props<\n\t\t\t\t\t{ data: null; error: StandardTypedV1.InferInput<TSchema> },\n\t\t\t\t\t{ data: null; error: StandardTypedV1.InferOutput<TSchema> }\n\t\t\t\t>[\"validate\"];\n\t\t\t}\n\t\t: Record<string, never>) &\n\t\t(TSchema extends StandardJSONSchemaV1\n\t\t\t? { readonly jsonSchema: StandardJSONSchemaV1.Converter }\n\t\t\t: Record<string, never>);\n};\n\nfunction createErrValidate<TSchema extends StandardSchemaV1>(\n\tinnerSchema: TSchema,\n): StandardSchemaV1.Props<\n\t{ data: null; error: StandardTypedV1.InferInput<TSchema> },\n\t{ data: null; error: StandardTypedV1.InferOutput<TSchema> }\n>[\"validate\"] {\n\treturn (value: unknown) => {\n\t\tif (typeof value !== \"object\" || value === null) {\n\t\t\treturn FAILURES.EXPECTED_OBJECT;\n\t\t}\n\n\t\tif (!(\"data\" in value) || !(\"error\" in value)) {\n\t\t\treturn FAILURES.EXPECTED_DATA_ERROR_PROPS;\n\t\t}\n\n\t\tconst obj = value as { data: unknown; error: unknown };\n\n\t\tif (obj.error === null) {\n\t\t\treturn FAILURES.EXPECTED_ERROR_NOT_NULL;\n\t\t}\n\n\t\tconst innerResult = innerSchema[\"~standard\"].validate(obj.error);\n\n\t\tif (innerResult instanceof Promise) {\n\t\t\treturn innerResult.then((r) => {\n\t\t\t\tif (r.issues) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tissues: r.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t\t\t...issue,\n\t\t\t\t\t\t\tpath: [\"error\", ...(issue.path || [])],\n\t\t\t\t\t\t})),\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t\treturn { value: { data: null as null, error: r.value } };\n\t\t\t});\n\t\t}\n\n\t\tif (innerResult.issues) {\n\t\t\treturn {\n\t\t\t\tissues: innerResult.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t...issue,\n\t\t\t\t\tpath: [\"error\", ...(issue.path || [])],\n\t\t\t\t})),\n\t\t\t};\n\t\t}\n\n\t\treturn { value: { data: null as null, error: innerResult.value } };\n\t};\n}\n\nfunction createErrJsonSchema<TSchema extends StandardJSONSchemaV1>(\n\tinnerSchema: TSchema,\n): StandardJSONSchemaV1.Converter {\n\treturn {\n\t\tinput(options: StandardJSONSchemaV1.Options) {\n\t\t\treturn {\n\t\t\t\ttype: \"object\",\n\t\t\t\tproperties: {\n\t\t\t\t\tdata: { type: \"null\" },\n\t\t\t\t\terror: innerSchema[\"~standard\"].jsonSchema.input(options),\n\t\t\t\t},\n\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\tadditionalProperties: false,\n\t\t\t};\n\t\t},\n\t\toutput(options: StandardJSONSchemaV1.Options) {\n\t\t\treturn {\n\t\t\t\ttype: \"object\",\n\t\t\t\tproperties: {\n\t\t\t\t\tdata: { type: \"null\" },\n\t\t\t\t\terror: innerSchema[\"~standard\"].jsonSchema.output(options),\n\t\t\t\t},\n\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\tadditionalProperties: false,\n\t\t\t};\n\t\t},\n\t};\n}\n\n/**\n * Wraps a Standard Schema into an Err variant schema.\n *\n * Takes a schema for type E and returns a schema for `{ data: null, error: E }`.\n * Preserves the capabilities of the input schema (validate, jsonSchema, or both).\n *\n * @example\n * ```typescript\n * import { z } from \"zod\";\n * import { ErrSchema } from \"wellcrafted/standard-schema\";\n *\n * const errorSchema = z.object({ code: z.string(), message: z.string() });\n * const errResultSchema = ErrSchema(errorSchema);\n *\n * // Validates: { data: null, error: { code: \"NOT_FOUND\", message: \"User not found\" } }\n * const result = errResultSchema[\"~standard\"].validate({\n *   data: null,\n *   error: { code: \"NOT_FOUND\", message: \"User not found\" },\n * });\n * ```\n */\nexport function ErrSchema<TSchema extends StandardTypedV1>(\n\tinnerSchema: TSchema,\n): Err<TSchema> {\n\tconst base = {\n\t\t\"~standard\": {\n\t\t\tversion: 1 as const,\n\t\t\tvendor: \"wellcrafted\",\n\t\t\ttypes: {\n\t\t\t\tinput: undefined as unknown as {\n\t\t\t\t\tdata: null;\n\t\t\t\t\terror: StandardTypedV1.InferInput<TSchema>;\n\t\t\t\t},\n\t\t\t\toutput: undefined as unknown as {\n\t\t\t\t\tdata: null;\n\t\t\t\t\terror: StandardTypedV1.InferOutput<TSchema>;\n\t\t\t\t},\n\t\t\t},\n\t\t},\n\t};\n\n\tif (hasValidate(innerSchema)) {\n\t\t(base[\"~standard\"] as Record<string, unknown>).validate =\n\t\t\tcreateErrValidate(innerSchema);\n\t}\n\n\tif (hasJsonSchema(innerSchema)) {\n\t\t(base[\"~standard\"] as Record<string, unknown>).jsonSchema =\n\t\t\tcreateErrJsonSchema(innerSchema);\n\t}\n\n\treturn base as Err<TSchema>;\n}\n","import { FAILURES } from \"./failures.js\";\nimport {\n\thasJsonSchema,\n\thasValidate,\n\ttype StandardJSONSchemaV1,\n\ttype StandardSchemaV1,\n\ttype StandardTypedV1,\n} from \"./types.js\";\n\n/**\n * Output type for OkSchema - wraps inner schema's types with Ok structure.\n *\n * Preserves the capabilities of the input schema:\n * - If input has validate, output has validate\n * - If input has jsonSchema, output has jsonSchema\n */\nexport type Ok<TSchema extends StandardTypedV1> = {\n\treadonly \"~standard\": {\n\t\treadonly version: 1;\n\t\treadonly vendor: \"wellcrafted\";\n\t\treadonly types: {\n\t\t\treadonly input: {\n\t\t\t\tdata: StandardTypedV1.InferInput<TSchema>;\n\t\t\t\terror: null;\n\t\t\t};\n\t\t\treadonly output: {\n\t\t\t\tdata: StandardTypedV1.InferOutput<TSchema>;\n\t\t\t\terror: null;\n\t\t\t};\n\t\t};\n\t} & (TSchema extends StandardSchemaV1\n\t\t? {\n\t\t\t\treadonly validate: StandardSchemaV1.Props<\n\t\t\t\t\t{ data: StandardTypedV1.InferInput<TSchema>; error: null },\n\t\t\t\t\t{ data: StandardTypedV1.InferOutput<TSchema>; error: null }\n\t\t\t\t>[\"validate\"];\n\t\t\t}\n\t\t: Record<string, never>) &\n\t\t(TSchema extends StandardJSONSchemaV1\n\t\t\t? { readonly jsonSchema: StandardJSONSchemaV1.Converter }\n\t\t\t: Record<string, never>);\n};\n\nfunction createOkValidate<TSchema extends StandardSchemaV1>(\n\tinnerSchema: TSchema,\n): StandardSchemaV1.Props<\n\t{ data: StandardTypedV1.InferInput<TSchema>; error: null },\n\t{ data: StandardTypedV1.InferOutput<TSchema>; error: null }\n>[\"validate\"] {\n\treturn (value: unknown) => {\n\t\tif (typeof value !== \"object\" || value === null) {\n\t\t\treturn FAILURES.EXPECTED_OBJECT;\n\t\t}\n\n\t\tif (!(\"data\" in value) || !(\"error\" in value)) {\n\t\t\treturn FAILURES.EXPECTED_DATA_ERROR_PROPS;\n\t\t}\n\n\t\tconst obj = value as { data: unknown; error: unknown };\n\n\t\tif (obj.error !== null) {\n\t\t\treturn FAILURES.EXPECTED_ERROR_NULL;\n\t\t}\n\n\t\tconst innerResult = innerSchema[\"~standard\"].validate(obj.data);\n\n\t\tif (innerResult instanceof Promise) {\n\t\t\treturn innerResult.then((r) => {\n\t\t\t\tif (r.issues) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tissues: r.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t\t\t...issue,\n\t\t\t\t\t\t\tpath: [\"data\", ...(issue.path || [])],\n\t\t\t\t\t\t})),\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t\treturn { value: { data: r.value, error: null as null } };\n\t\t\t});\n\t\t}\n\n\t\tif (innerResult.issues) {\n\t\t\treturn {\n\t\t\t\tissues: innerResult.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t...issue,\n\t\t\t\t\tpath: [\"data\", ...(issue.path || [])],\n\t\t\t\t})),\n\t\t\t};\n\t\t}\n\n\t\treturn { value: { data: innerResult.value, error: null as null } };\n\t};\n}\n\nfunction createOkJsonSchema<TSchema extends StandardJSONSchemaV1>(\n\tinnerSchema: TSchema,\n): StandardJSONSchemaV1.Converter {\n\treturn {\n\t\tinput(options: StandardJSONSchemaV1.Options) {\n\t\t\treturn {\n\t\t\t\ttype: \"object\",\n\t\t\t\tproperties: {\n\t\t\t\t\tdata: innerSchema[\"~standard\"].jsonSchema.input(options),\n\t\t\t\t\terror: { type: \"null\" },\n\t\t\t\t},\n\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\tadditionalProperties: false,\n\t\t\t};\n\t\t},\n\t\toutput(options: StandardJSONSchemaV1.Options) {\n\t\t\treturn {\n\t\t\t\ttype: \"object\",\n\t\t\t\tproperties: {\n\t\t\t\t\tdata: innerSchema[\"~standard\"].jsonSchema.output(options),\n\t\t\t\t\terror: { type: \"null\" },\n\t\t\t\t},\n\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\tadditionalProperties: false,\n\t\t\t};\n\t\t},\n\t};\n}\n\n/**\n * Wraps a Standard Schema into an Ok variant schema.\n *\n * Takes a schema for type T and returns a schema for `{ data: T, error: null }`.\n * Preserves the capabilities of the input schema (validate, jsonSchema, or both).\n *\n * @example\n * ```typescript\n * import { z } from \"zod\";\n * import { OkSchema } from \"wellcrafted/standard-schema\";\n *\n * const userSchema = z.object({ name: z.string() });\n * const okUserSchema = OkSchema(userSchema);\n *\n * // Validates: { data: { name: \"Alice\" }, error: null }\n * const result = okUserSchema[\"~standard\"].validate({\n *   data: { name: \"Alice\" },\n *   error: null,\n * });\n * ```\n */\nexport function OkSchema<TSchema extends StandardTypedV1>(\n\tinnerSchema: TSchema,\n): Ok<TSchema> {\n\tconst base = {\n\t\t\"~standard\": {\n\t\t\tversion: 1 as const,\n\t\t\tvendor: \"wellcrafted\",\n\t\t\ttypes: {\n\t\t\t\tinput: undefined as unknown as {\n\t\t\t\t\tdata: StandardTypedV1.InferInput<TSchema>;\n\t\t\t\t\terror: null;\n\t\t\t\t},\n\t\t\t\toutput: undefined as unknown as {\n\t\t\t\t\tdata: StandardTypedV1.InferOutput<TSchema>;\n\t\t\t\t\terror: null;\n\t\t\t\t},\n\t\t\t},\n\t\t},\n\t};\n\n\tif (hasValidate(innerSchema)) {\n\t\t(base[\"~standard\"] as Record<string, unknown>).validate =\n\t\t\tcreateOkValidate(innerSchema);\n\t}\n\n\tif (hasJsonSchema(innerSchema)) {\n\t\t(base[\"~standard\"] as Record<string, unknown>).jsonSchema =\n\t\t\tcreateOkJsonSchema(innerSchema);\n\t}\n\n\treturn base as Ok<TSchema>;\n}\n","import { FAILURES } from \"./failures.js\";\nimport {\n\thasJsonSchema,\n\thasValidate,\n\ttype StandardJSONSchemaV1,\n\ttype StandardSchemaV1,\n\ttype StandardTypedV1,\n} from \"./types.js\";\n\n/**\n * Output type for ResultSchema - creates a discriminated union of Ok and Err.\n *\n * Preserves the capabilities of the input schemas:\n * - If both inputs have validate, output has validate\n * - If both inputs have jsonSchema, output has jsonSchema\n */\nexport type Result<\n\tTDataSchema extends StandardTypedV1,\n\tTErrorSchema extends StandardTypedV1,\n> = {\n\treadonly \"~standard\": {\n\t\treadonly version: 1;\n\t\treadonly vendor: \"wellcrafted\";\n\t\treadonly types: {\n\t\t\treadonly input:\n\t\t\t\t| { data: StandardTypedV1.InferInput<TDataSchema>; error: null }\n\t\t\t\t| { data: null; error: StandardTypedV1.InferInput<TErrorSchema> };\n\t\t\treadonly output:\n\t\t\t\t| { data: StandardTypedV1.InferOutput<TDataSchema>; error: null }\n\t\t\t\t| { data: null; error: StandardTypedV1.InferOutput<TErrorSchema> };\n\t\t};\n\t} & (TDataSchema extends StandardSchemaV1\n\t\t? TErrorSchema extends StandardSchemaV1\n\t\t\t? {\n\t\t\t\t\treadonly validate: StandardSchemaV1.Props<\n\t\t\t\t\t\t| {\n\t\t\t\t\t\t\t\tdata: StandardTypedV1.InferInput<TDataSchema>;\n\t\t\t\t\t\t\t\terror: null;\n\t\t\t\t\t\t  }\n\t\t\t\t\t\t| {\n\t\t\t\t\t\t\t\tdata: null;\n\t\t\t\t\t\t\t\terror: StandardTypedV1.InferInput<TErrorSchema>;\n\t\t\t\t\t\t  },\n\t\t\t\t\t\t| {\n\t\t\t\t\t\t\t\tdata: StandardTypedV1.InferOutput<TDataSchema>;\n\t\t\t\t\t\t\t\terror: null;\n\t\t\t\t\t\t  }\n\t\t\t\t\t\t| {\n\t\t\t\t\t\t\t\tdata: null;\n\t\t\t\t\t\t\t\terror: StandardTypedV1.InferOutput<TErrorSchema>;\n\t\t\t\t\t\t  }\n\t\t\t\t\t>[\"validate\"];\n\t\t\t\t}\n\t\t\t: Record<string, never>\n\t\t: Record<string, never>) &\n\t\t(TDataSchema extends StandardJSONSchemaV1\n\t\t\t? TErrorSchema extends StandardJSONSchemaV1\n\t\t\t\t? { readonly jsonSchema: StandardJSONSchemaV1.Converter }\n\t\t\t\t: Record<string, never>\n\t\t\t: Record<string, never>);\n};\n\nfunction createResultValidate<\n\tTDataSchema extends StandardSchemaV1,\n\tTErrorSchema extends StandardSchemaV1,\n>(\n\tdataSchema: TDataSchema,\n\terrorSchema: TErrorSchema,\n): StandardSchemaV1.Props<\n\t| { data: StandardTypedV1.InferInput<TDataSchema>; error: null }\n\t| { data: null; error: StandardTypedV1.InferInput<TErrorSchema> },\n\t| { data: StandardTypedV1.InferOutput<TDataSchema>; error: null }\n\t| { data: null; error: StandardTypedV1.InferOutput<TErrorSchema> }\n>[\"validate\"] {\n\treturn (value: unknown) => {\n\t\tif (typeof value !== \"object\" || value === null) {\n\t\t\treturn FAILURES.EXPECTED_OBJECT;\n\t\t}\n\n\t\tif (!(\"data\" in value) || !(\"error\" in value)) {\n\t\t\treturn FAILURES.EXPECTED_DATA_ERROR_PROPS;\n\t\t}\n\n\t\tconst obj = value as { data: unknown; error: unknown };\n\n\t\tconst isOk = obj.error === null;\n\n\t\tif (isOk) {\n\t\t\tconst innerResult = dataSchema[\"~standard\"].validate(obj.data);\n\n\t\t\tif (innerResult instanceof Promise) {\n\t\t\t\treturn innerResult.then((r) => {\n\t\t\t\t\tif (r.issues) {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\tissues: r.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t\t\t\t...issue,\n\t\t\t\t\t\t\t\tpath: [\"data\", ...(issue.path || [])],\n\t\t\t\t\t\t\t})),\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t\treturn { value: { data: r.value, error: null as null } };\n\t\t\t\t});\n\t\t\t}\n\n\t\t\tif (innerResult.issues) {\n\t\t\t\treturn {\n\t\t\t\t\tissues: innerResult.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t\t...issue,\n\t\t\t\t\t\tpath: [\"data\", ...(issue.path || [])],\n\t\t\t\t\t})),\n\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn { value: { data: innerResult.value, error: null as null } };\n\t\t}\n\n\t\tconst innerResult = errorSchema[\"~standard\"].validate(obj.error);\n\n\t\tif (innerResult instanceof Promise) {\n\t\t\treturn innerResult.then((r) => {\n\t\t\t\tif (r.issues) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tissues: r.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t\t\t...issue,\n\t\t\t\t\t\t\tpath: [\"error\", ...(issue.path || [])],\n\t\t\t\t\t\t})),\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t\treturn { value: { data: null as null, error: r.value } };\n\t\t\t});\n\t\t}\n\n\t\tif (innerResult.issues) {\n\t\t\treturn {\n\t\t\t\tissues: innerResult.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t...issue,\n\t\t\t\t\tpath: [\"error\", ...(issue.path || [])],\n\t\t\t\t})),\n\t\t\t};\n\t\t}\n\n\t\treturn { value: { data: null as null, error: innerResult.value } };\n\t};\n}\n\nfunction createResultJsonSchema<\n\tTDataSchema extends StandardJSONSchemaV1,\n\tTErrorSchema extends StandardJSONSchemaV1,\n>(\n\tdataSchema: TDataSchema,\n\terrorSchema: TErrorSchema,\n): StandardJSONSchemaV1.Converter {\n\treturn {\n\t\tinput(options: StandardJSONSchemaV1.Options) {\n\t\t\treturn {\n\t\t\t\toneOf: [\n\t\t\t\t\t{\n\t\t\t\t\t\ttype: \"object\",\n\t\t\t\t\t\tproperties: {\n\t\t\t\t\t\t\tdata: dataSchema[\"~standard\"].jsonSchema.input(options),\n\t\t\t\t\t\t\terror: { type: \"null\" },\n\t\t\t\t\t\t},\n\t\t\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\t\t\tadditionalProperties: false,\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\ttype: \"object\",\n\t\t\t\t\t\tproperties: {\n\t\t\t\t\t\t\tdata: { type: \"null\" },\n\t\t\t\t\t\t\terror: errorSchema[\"~standard\"].jsonSchema.input(options),\n\t\t\t\t\t\t},\n\t\t\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\t\t\tadditionalProperties: false,\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t};\n\t\t},\n\t\toutput(options: StandardJSONSchemaV1.Options) {\n\t\t\treturn {\n\t\t\t\toneOf: [\n\t\t\t\t\t{\n\t\t\t\t\t\ttype: \"object\",\n\t\t\t\t\t\tproperties: {\n\t\t\t\t\t\t\tdata: dataSchema[\"~standard\"].jsonSchema.output(options),\n\t\t\t\t\t\t\terror: { type: \"null\" },\n\t\t\t\t\t\t},\n\t\t\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\t\t\tadditionalProperties: false,\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\ttype: \"object\",\n\t\t\t\t\t\tproperties: {\n\t\t\t\t\t\t\tdata: { type: \"null\" },\n\t\t\t\t\t\t\terror: errorSchema[\"~standard\"].jsonSchema.output(options),\n\t\t\t\t\t\t},\n\t\t\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\t\t\tadditionalProperties: false,\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t};\n\t\t},\n\t};\n}\n\n/**\n * Combines two Standard Schemas into a Result discriminated union schema.\n *\n * Takes a data schema for type T and an error schema for type E, returning a schema\n * for `{ data: T, error: null } | { data: null, error: E }`.\n *\n * Preserves the capabilities of the input schemas - if both have validate, output\n * has validate; if both have jsonSchema, output has jsonSchema.\n *\n * @example\n * ```typescript\n * import { z } from \"zod\";\n * import { ResultSchema } from \"wellcrafted/standard-schema\";\n *\n * const userSchema = z.object({ id: z.string(), name: z.string() });\n * const errorSchema = z.object({ code: z.string(), message: z.string() });\n * const resultSchema = ResultSchema(userSchema, errorSchema);\n *\n * // Validates Ok variant: { data: { id: \"1\", name: \"Alice\" }, error: null }\n * // Validates Err variant: { data: null, error: { code: \"NOT_FOUND\", message: \"...\" } }\n * const result = resultSchema[\"~standard\"].validate({\n *   data: { id: \"1\", name: \"Alice\" },\n *   error: null,\n * });\n * ```\n */\nexport function ResultSchema<\n\tTDataSchema extends StandardTypedV1,\n\tTErrorSchema extends StandardTypedV1,\n>(\n\tdataSchema: TDataSchema,\n\terrorSchema: TErrorSchema,\n): Result<TDataSchema, TErrorSchema> {\n\tconst base = {\n\t\t\"~standard\": {\n\t\t\tversion: 1 as const,\n\t\t\tvendor: \"wellcrafted\",\n\t\t\ttypes: {\n\t\t\t\tinput: undefined as unknown as\n\t\t\t\t\t| { data: StandardTypedV1.InferInput<TDataSchema>; error: null }\n\t\t\t\t\t| { data: null; error: StandardTypedV1.InferInput<TErrorSchema> },\n\t\t\t\toutput: undefined as unknown as\n\t\t\t\t\t| { data: StandardTypedV1.InferOutput<TDataSchema>; error: null }\n\t\t\t\t\t| { data: null; error: StandardTypedV1.InferOutput<TErrorSchema> },\n\t\t\t},\n\t\t},\n\t};\n\n\tif (hasValidate(dataSchema) && hasValidate(errorSchema)) {\n\t\t(base[\"~standard\"] as Record<string, unknown>).validate =\n\t\t\tcreateResultValidate(dataSchema, errorSchema);\n\t}\n\n\tif (hasJsonSchema(dataSchema) && hasJsonSchema(errorSchema)) {\n\t\t(base[\"~standard\"] as Record<string, unknown>).jsonSchema =\n\t\t\tcreateResultJsonSchema(dataSchema, errorSchema);\n\t}\n\n\treturn base as Result<TDataSchema, TErrorSchema>;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["schema: T","innerSchema: TSchema","value: unknown","issue: StandardSchemaV1.Issue","options: StandardJSONSchemaV1.Options","innerSchema: TSchema","value: unknown","issue: StandardSchemaV1.Issue","options: StandardJSONSchemaV1.Options","dataSchema: TDataSchema","errorSchema: TErrorSchema","value: unknown","innerResult","issue: StandardSchemaV1.Issue","options: StandardJSONSchemaV1.Options"],"sources":["../../src/standard-schema/failures.ts","../../src/standard-schema/types.ts","../../src/standard-schema/err.ts","../../src/standard-schema/ok.ts","../../src/standard-schema/result.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"./types.js\";\n\nexport const FAILURES = {\n\tEXPECTED_OBJECT: { issues: [{ message: \"Expected object\" }] },\n\tEXPECTED_DATA_ERROR_PROPS: {\n\t\tissues: [{ message: \"Expected object with 'data' and 'error' properties\" }],\n\t},\n\tEXPECTED_ERROR_NULL: {\n\t\tissues: [\n\t\t\t{\n\t\t\t\tmessage: \"Expected 'error' to be null for Ok variant\",\n\t\t\t\tpath: [\"error\"],\n\t\t\t},\n\t\t],\n\t},\n\tEXPECTED_ERROR_NOT_NULL: {\n\t\tissues: [\n\t\t\t{\n\t\t\t\tmessage: \"Expected 'error' to be non-null for Err variant\",\n\t\t\t\tpath: [\"error\"],\n\t\t\t},\n\t\t],\n\t},\n} as const satisfies Record<string, StandardSchemaV1.FailureResult>;\n","/**\n * Standard Schema type definitions.\n *\n * These interfaces are copied from the Standard Schema specification\n * (https://standardschema.dev) to avoid external dependencies.\n *\n * @see https://github.com/standard-schema/standard-schema\n */\n\n// #########################\n// ###   Standard Typed  ###\n// #########################\n\n/**\n * The Standard Typed interface. This is a base type extended by other specs.\n */\nexport type StandardTypedV1<Input = unknown, Output = Input> = {\n\t/** The Standard properties. */\n\treadonly \"~standard\": StandardTypedV1.Props<Input, Output>;\n};\n\nexport declare namespace StandardTypedV1 {\n\t/** The Standard Typed properties interface. */\n\ttype Props<Input = unknown, Output = Input> = {\n\t\t/** The version number of the standard. */\n\t\treadonly version: 1;\n\t\t/** The vendor name of the schema library. */\n\t\treadonly vendor: string;\n\t\t/** Inferred types associated with the schema. */\n\t\treadonly types?: Types<Input, Output> | undefined;\n\t};\n\n\t/** The Standard Typed types interface. */\n\ttype Types<Input = unknown, Output = Input> = {\n\t\t/** The input type of the schema. */\n\t\treadonly input: Input;\n\t\t/** The output type of the schema. */\n\t\treadonly output: Output;\n\t};\n\n\t/** Infers the input type of a Standard Typed. */\n\ttype InferInput<Schema extends StandardTypedV1> = NonNullable<\n\t\tSchema[\"~standard\"][\"types\"]\n\t>[\"input\"];\n\n\t/** Infers the output type of a Standard Typed. */\n\ttype InferOutput<Schema extends StandardTypedV1> = NonNullable<\n\t\tSchema[\"~standard\"][\"types\"]\n\t>[\"output\"];\n}\n\n// ##########################\n// ###   Standard Schema  ###\n// ##########################\n\n/**\n * The Standard Schema interface.\n *\n * Extends StandardTypedV1 with a validate function for runtime validation.\n */\nexport type StandardSchemaV1<Input = unknown, Output = Input> = {\n\t/** The Standard Schema properties. */\n\treadonly \"~standard\": StandardSchemaV1.Props<Input, Output>;\n};\n\nexport declare namespace StandardSchemaV1 {\n\t/** The Standard Schema properties interface. */\n\ttype Props<Input = unknown, Output = Input> = StandardTypedV1.Props<\n\t\tInput,\n\t\tOutput\n\t> & {\n\t\t/** Validates unknown input values. */\n\t\treadonly validate: (\n\t\t\tvalue: unknown,\n\t\t\toptions?: StandardSchemaV1.Options | undefined,\n\t\t) => Result<Output> | Promise<Result<Output>>;\n\t};\n\n\t/** The result interface of the validate function. */\n\ttype Result<Output> = SuccessResult<Output> | FailureResult;\n\n\t/** The result interface if validation succeeds. */\n\ttype SuccessResult<Output> = {\n\t\t/** The typed output value. */\n\t\treadonly value: Output;\n\t\t/** A falsy value for `issues` indicates success. */\n\t\treadonly issues?: undefined;\n\t};\n\n\t/** Options for the validate function. */\n\ttype Options = {\n\t\t/** Explicit support for additional vendor-specific parameters, if needed. */\n\t\treadonly libraryOptions?: Record<string, unknown> | undefined;\n\t};\n\n\t/** The result interface if validation fails. */\n\ttype FailureResult = {\n\t\t/** The issues of failed validation. */\n\t\treadonly issues: ReadonlyArray<Issue>;\n\t};\n\n\t/** The issue interface of the failure output. */\n\ttype Issue = {\n\t\t/** The error message of the issue. */\n\t\treadonly message: string;\n\t\t/** The path of the issue, if any. */\n\t\treadonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;\n\t};\n\n\t/** The path segment interface of the issue. */\n\ttype PathSegment = {\n\t\t/** The key representing a path segment. */\n\t\treadonly key: PropertyKey;\n\t};\n\n\t/** Infers the input type of a Standard Schema. */\n\ttype InferInput<Schema extends StandardTypedV1> =\n\t\tStandardTypedV1.InferInput<Schema>;\n\n\t/** Infers the output type of a Standard Schema. */\n\ttype InferOutput<Schema extends StandardTypedV1> =\n\t\tStandardTypedV1.InferOutput<Schema>;\n}\n\n// ###############################\n// ###   Standard JSON Schema  ###\n// ###############################\n\n/**\n * The Standard JSON Schema interface.\n *\n * Extends StandardTypedV1 with methods for generating JSON Schema.\n */\nexport type StandardJSONSchemaV1<Input = unknown, Output = Input> = {\n\t/** The Standard JSON Schema properties. */\n\treadonly \"~standard\": StandardJSONSchemaV1.Props<Input, Output>;\n};\n\nexport declare namespace StandardJSONSchemaV1 {\n\t/** The Standard JSON Schema properties interface. */\n\ttype Props<Input = unknown, Output = Input> = StandardTypedV1.Props<\n\t\tInput,\n\t\tOutput\n\t> & {\n\t\t/** Methods for generating the input/output JSON Schema. */\n\t\treadonly jsonSchema: StandardJSONSchemaV1.Converter;\n\t};\n\n\t/** The Standard JSON Schema converter interface. */\n\ttype Converter = {\n\t\t/** Converts the input type to JSON Schema. May throw if conversion is not supported. */\n\t\treadonly input: (\n\t\t\toptions: StandardJSONSchemaV1.Options,\n\t\t) => Record<string, unknown>;\n\t\t/** Converts the output type to JSON Schema. May throw if conversion is not supported. */\n\t\treadonly output: (\n\t\t\toptions: StandardJSONSchemaV1.Options,\n\t\t) => Record<string, unknown>;\n\t};\n\n\t/**\n\t * The target version of the generated JSON Schema.\n\t *\n\t * It is *strongly recommended* that implementers support `\"draft-2020-12\"` and `\"draft-07\"`,\n\t * as they are both in wide use. All other targets can be implemented on a best-effort basis.\n\t * Libraries should throw if they don't support a specified target.\n\t *\n\t * The `\"openapi-3.0\"` target is intended as a standardized specifier for OpenAPI 3.0\n\t * which is a superset of JSON Schema `\"draft-04\"`.\n\t */\n\ttype Target =\n\t\t| \"draft-2020-12\"\n\t\t| \"draft-07\"\n\t\t| \"openapi-3.0\"\n\t\t// Accepts any string for future targets while preserving autocomplete\n\t\t| (string & {});\n\n\t/** The options for the input/output methods. */\n\ttype Options = {\n\t\t/** Specifies the target version of the generated JSON Schema. */\n\t\treadonly target: Target;\n\t\t/** Explicit support for additional vendor-specific parameters, if needed. */\n\t\treadonly libraryOptions?: Record<string, unknown> | undefined;\n\t};\n\n\t/** Infers the input type of a Standard JSON Schema. */\n\ttype InferInput<Schema extends StandardTypedV1> =\n\t\tStandardTypedV1.InferInput<Schema>;\n\n\t/** Infers the output type of a Standard JSON Schema. */\n\ttype InferOutput<Schema extends StandardTypedV1> =\n\t\tStandardTypedV1.InferOutput<Schema>;\n}\n\n/**\n * Checks if a schema has validation capability.\n */\nexport function hasValidate<T extends StandardTypedV1>(\n\tschema: T,\n): schema is T & StandardSchemaV1 {\n\treturn (\n\t\t\"validate\" in schema[\"~standard\"] &&\n\t\ttypeof schema[\"~standard\"].validate === \"function\"\n\t);\n}\n\n/**\n * Checks if a schema has JSON Schema generation capability.\n */\nexport function hasJsonSchema<T extends StandardTypedV1>(\n\tschema: T,\n): schema is T & StandardJSONSchemaV1 {\n\treturn (\n\t\t\"jsonSchema\" in schema[\"~standard\"] &&\n\t\ttypeof schema[\"~standard\"].jsonSchema === \"object\" &&\n\t\tschema[\"~standard\"].jsonSchema !== null\n\t);\n}\n","import { FAILURES } from \"./failures.js\";\nimport {\n\thasJsonSchema,\n\thasValidate,\n\ttype StandardJSONSchemaV1,\n\ttype StandardSchemaV1,\n\ttype StandardTypedV1,\n} from \"./types.js\";\n\n/**\n * Output type for ErrSchema - wraps inner schema's types with Err structure.\n *\n * Preserves the capabilities of the input schema:\n * - If input has validate, output has validate\n * - If input has jsonSchema, output has jsonSchema\n */\nexport type Err<TSchema extends StandardTypedV1> = {\n\treadonly \"~standard\": {\n\t\treadonly version: 1;\n\t\treadonly vendor: \"wellcrafted\";\n\t\treadonly types: {\n\t\t\treadonly input: {\n\t\t\t\tdata: null;\n\t\t\t\terror: StandardTypedV1.InferInput<TSchema>;\n\t\t\t};\n\t\t\treadonly output: {\n\t\t\t\tdata: null;\n\t\t\t\terror: StandardTypedV1.InferOutput<TSchema>;\n\t\t\t};\n\t\t};\n\t} & (TSchema extends StandardSchemaV1\n\t\t? {\n\t\t\t\treadonly validate: StandardSchemaV1.Props<\n\t\t\t\t\t{ data: null; error: StandardTypedV1.InferInput<TSchema> },\n\t\t\t\t\t{ data: null; error: StandardTypedV1.InferOutput<TSchema> }\n\t\t\t\t>[\"validate\"];\n\t\t\t}\n\t\t: Record<string, never>) &\n\t\t(TSchema extends StandardJSONSchemaV1\n\t\t\t? { readonly jsonSchema: StandardJSONSchemaV1.Converter }\n\t\t\t: Record<string, never>);\n};\n\nfunction createErrValidate<TSchema extends StandardSchemaV1>(\n\tinnerSchema: TSchema,\n): StandardSchemaV1.Props<\n\t{ data: null; error: StandardTypedV1.InferInput<TSchema> },\n\t{ data: null; error: StandardTypedV1.InferOutput<TSchema> }\n>[\"validate\"] {\n\treturn (value: unknown) => {\n\t\tif (typeof value !== \"object\" || value === null) {\n\t\t\treturn FAILURES.EXPECTED_OBJECT;\n\t\t}\n\n\t\tif (!(\"data\" in value) || !(\"error\" in value)) {\n\t\t\treturn FAILURES.EXPECTED_DATA_ERROR_PROPS;\n\t\t}\n\n\t\tconst obj = value as { data: unknown; error: unknown };\n\n\t\tif (obj.error === null) {\n\t\t\treturn FAILURES.EXPECTED_ERROR_NOT_NULL;\n\t\t}\n\n\t\tconst innerResult = innerSchema[\"~standard\"].validate(obj.error);\n\n\t\tif (innerResult instanceof Promise) {\n\t\t\treturn innerResult.then((r) => {\n\t\t\t\tif (r.issues) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tissues: r.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t\t\t...issue,\n\t\t\t\t\t\t\tpath: [\"error\", ...(issue.path || [])],\n\t\t\t\t\t\t})),\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t\treturn { value: { data: null as null, error: r.value } };\n\t\t\t});\n\t\t}\n\n\t\tif (innerResult.issues) {\n\t\t\treturn {\n\t\t\t\tissues: innerResult.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t...issue,\n\t\t\t\t\tpath: [\"error\", ...(issue.path || [])],\n\t\t\t\t})),\n\t\t\t};\n\t\t}\n\n\t\treturn { value: { data: null as null, error: innerResult.value } };\n\t};\n}\n\nfunction createErrJsonSchema<TSchema extends StandardJSONSchemaV1>(\n\tinnerSchema: TSchema,\n): StandardJSONSchemaV1.Converter {\n\treturn {\n\t\tinput(options: StandardJSONSchemaV1.Options) {\n\t\t\treturn {\n\t\t\t\ttype: \"object\",\n\t\t\t\tproperties: {\n\t\t\t\t\tdata: { type: \"null\" },\n\t\t\t\t\terror: innerSchema[\"~standard\"].jsonSchema.input(options),\n\t\t\t\t},\n\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\tadditionalProperties: false,\n\t\t\t};\n\t\t},\n\t\toutput(options: StandardJSONSchemaV1.Options) {\n\t\t\treturn {\n\t\t\t\ttype: \"object\",\n\t\t\t\tproperties: {\n\t\t\t\t\tdata: { type: \"null\" },\n\t\t\t\t\terror: innerSchema[\"~standard\"].jsonSchema.output(options),\n\t\t\t\t},\n\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\tadditionalProperties: false,\n\t\t\t};\n\t\t},\n\t};\n}\n\n/**\n * Wraps a Standard Schema into an Err variant schema.\n *\n * Takes a schema for type E and returns a schema for `{ data: null, error: E }`.\n * Preserves the capabilities of the input schema (validate, jsonSchema, or both).\n *\n * @example\n * ```typescript\n * import { z } from \"zod\";\n * import { ErrSchema } from \"wellcrafted/standard-schema\";\n *\n * const errorSchema = z.object({ code: z.string(), message: z.string() });\n * const errResultSchema = ErrSchema(errorSchema);\n *\n * // Validates: { data: null, error: { code: \"NOT_FOUND\", message: \"User not found\" } }\n * const result = errResultSchema[\"~standard\"].validate({\n *   data: null,\n *   error: { code: \"NOT_FOUND\", message: \"User not found\" },\n * });\n * ```\n */\nexport function ErrSchema<TSchema extends StandardTypedV1>(\n\tinnerSchema: TSchema,\n): Err<TSchema> {\n\tconst base = {\n\t\t\"~standard\": {\n\t\t\tversion: 1 as const,\n\t\t\tvendor: \"wellcrafted\",\n\t\t\ttypes: {\n\t\t\t\tinput: undefined as unknown as {\n\t\t\t\t\tdata: null;\n\t\t\t\t\terror: StandardTypedV1.InferInput<TSchema>;\n\t\t\t\t},\n\t\t\t\toutput: undefined as unknown as {\n\t\t\t\t\tdata: null;\n\t\t\t\t\terror: StandardTypedV1.InferOutput<TSchema>;\n\t\t\t\t},\n\t\t\t},\n\t\t},\n\t};\n\n\tif (hasValidate(innerSchema)) {\n\t\t(base[\"~standard\"] as Record<string, unknown>).validate =\n\t\t\tcreateErrValidate(innerSchema);\n\t}\n\n\tif (hasJsonSchema(innerSchema)) {\n\t\t(base[\"~standard\"] as Record<string, unknown>).jsonSchema =\n\t\t\tcreateErrJsonSchema(innerSchema);\n\t}\n\n\treturn base as Err<TSchema>;\n}\n","import { FAILURES } from \"./failures.js\";\nimport {\n\thasJsonSchema,\n\thasValidate,\n\ttype StandardJSONSchemaV1,\n\ttype StandardSchemaV1,\n\ttype StandardTypedV1,\n} from \"./types.js\";\n\n/**\n * Output type for OkSchema - wraps inner schema's types with Ok structure.\n *\n * Preserves the capabilities of the input schema:\n * - If input has validate, output has validate\n * - If input has jsonSchema, output has jsonSchema\n */\nexport type Ok<TSchema extends StandardTypedV1> = {\n\treadonly \"~standard\": {\n\t\treadonly version: 1;\n\t\treadonly vendor: \"wellcrafted\";\n\t\treadonly types: {\n\t\t\treadonly input: {\n\t\t\t\tdata: StandardTypedV1.InferInput<TSchema>;\n\t\t\t\terror: null;\n\t\t\t};\n\t\t\treadonly output: {\n\t\t\t\tdata: StandardTypedV1.InferOutput<TSchema>;\n\t\t\t\terror: null;\n\t\t\t};\n\t\t};\n\t} & (TSchema extends StandardSchemaV1\n\t\t? {\n\t\t\t\treadonly validate: StandardSchemaV1.Props<\n\t\t\t\t\t{ data: StandardTypedV1.InferInput<TSchema>; error: null },\n\t\t\t\t\t{ data: StandardTypedV1.InferOutput<TSchema>; error: null }\n\t\t\t\t>[\"validate\"];\n\t\t\t}\n\t\t: Record<string, never>) &\n\t\t(TSchema extends StandardJSONSchemaV1\n\t\t\t? { readonly jsonSchema: StandardJSONSchemaV1.Converter }\n\t\t\t: Record<string, never>);\n};\n\nfunction createOkValidate<TSchema extends StandardSchemaV1>(\n\tinnerSchema: TSchema,\n): StandardSchemaV1.Props<\n\t{ data: StandardTypedV1.InferInput<TSchema>; error: null },\n\t{ data: StandardTypedV1.InferOutput<TSchema>; error: null }\n>[\"validate\"] {\n\treturn (value: unknown) => {\n\t\tif (typeof value !== \"object\" || value === null) {\n\t\t\treturn FAILURES.EXPECTED_OBJECT;\n\t\t}\n\n\t\tif (!(\"data\" in value) || !(\"error\" in value)) {\n\t\t\treturn FAILURES.EXPECTED_DATA_ERROR_PROPS;\n\t\t}\n\n\t\tconst obj = value as { data: unknown; error: unknown };\n\n\t\tif (obj.error !== null) {\n\t\t\treturn FAILURES.EXPECTED_ERROR_NULL;\n\t\t}\n\n\t\tconst innerResult = innerSchema[\"~standard\"].validate(obj.data);\n\n\t\tif (innerResult instanceof Promise) {\n\t\t\treturn innerResult.then((r) => {\n\t\t\t\tif (r.issues) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tissues: r.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t\t\t...issue,\n\t\t\t\t\t\t\tpath: [\"data\", ...(issue.path || [])],\n\t\t\t\t\t\t})),\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t\treturn { value: { data: r.value, error: null as null } };\n\t\t\t});\n\t\t}\n\n\t\tif (innerResult.issues) {\n\t\t\treturn {\n\t\t\t\tissues: innerResult.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t...issue,\n\t\t\t\t\tpath: [\"data\", ...(issue.path || [])],\n\t\t\t\t})),\n\t\t\t};\n\t\t}\n\n\t\treturn { value: { data: innerResult.value, error: null as null } };\n\t};\n}\n\nfunction createOkJsonSchema<TSchema extends StandardJSONSchemaV1>(\n\tinnerSchema: TSchema,\n): StandardJSONSchemaV1.Converter {\n\treturn {\n\t\tinput(options: StandardJSONSchemaV1.Options) {\n\t\t\treturn {\n\t\t\t\ttype: \"object\",\n\t\t\t\tproperties: {\n\t\t\t\t\tdata: innerSchema[\"~standard\"].jsonSchema.input(options),\n\t\t\t\t\terror: { type: \"null\" },\n\t\t\t\t},\n\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\tadditionalProperties: false,\n\t\t\t};\n\t\t},\n\t\toutput(options: StandardJSONSchemaV1.Options) {\n\t\t\treturn {\n\t\t\t\ttype: \"object\",\n\t\t\t\tproperties: {\n\t\t\t\t\tdata: innerSchema[\"~standard\"].jsonSchema.output(options),\n\t\t\t\t\terror: { type: \"null\" },\n\t\t\t\t},\n\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\tadditionalProperties: false,\n\t\t\t};\n\t\t},\n\t};\n}\n\n/**\n * Wraps a Standard Schema into an Ok variant schema.\n *\n * Takes a schema for type T and returns a schema for `{ data: T, error: null }`.\n * Preserves the capabilities of the input schema (validate, jsonSchema, or both).\n *\n * @example\n * ```typescript\n * import { z } from \"zod\";\n * import { OkSchema } from \"wellcrafted/standard-schema\";\n *\n * const userSchema = z.object({ name: z.string() });\n * const okUserSchema = OkSchema(userSchema);\n *\n * // Validates: { data: { name: \"Alice\" }, error: null }\n * const result = okUserSchema[\"~standard\"].validate({\n *   data: { name: \"Alice\" },\n *   error: null,\n * });\n * ```\n */\nexport function OkSchema<TSchema extends StandardTypedV1>(\n\tinnerSchema: TSchema,\n): Ok<TSchema> {\n\tconst base = {\n\t\t\"~standard\": {\n\t\t\tversion: 1 as const,\n\t\t\tvendor: \"wellcrafted\",\n\t\t\ttypes: {\n\t\t\t\tinput: undefined as unknown as {\n\t\t\t\t\tdata: StandardTypedV1.InferInput<TSchema>;\n\t\t\t\t\terror: null;\n\t\t\t\t},\n\t\t\t\toutput: undefined as unknown as {\n\t\t\t\t\tdata: StandardTypedV1.InferOutput<TSchema>;\n\t\t\t\t\terror: null;\n\t\t\t\t},\n\t\t\t},\n\t\t},\n\t};\n\n\tif (hasValidate(innerSchema)) {\n\t\t(base[\"~standard\"] as Record<string, unknown>).validate =\n\t\t\tcreateOkValidate(innerSchema);\n\t}\n\n\tif (hasJsonSchema(innerSchema)) {\n\t\t(base[\"~standard\"] as Record<string, unknown>).jsonSchema =\n\t\t\tcreateOkJsonSchema(innerSchema);\n\t}\n\n\treturn base as Ok<TSchema>;\n}\n","import { FAILURES } from \"./failures.js\";\nimport {\n\thasJsonSchema,\n\thasValidate,\n\ttype StandardJSONSchemaV1,\n\ttype StandardSchemaV1,\n\ttype StandardTypedV1,\n} from \"./types.js\";\n\n/**\n * Output type for ResultSchema - creates a discriminated union of Ok and Err.\n *\n * Preserves the capabilities of the input schemas:\n * - If both inputs have validate, output has validate\n * - If both inputs have jsonSchema, output has jsonSchema\n */\nexport type Result<\n\tTDataSchema extends StandardTypedV1,\n\tTErrorSchema extends StandardTypedV1,\n> = {\n\treadonly \"~standard\": {\n\t\treadonly version: 1;\n\t\treadonly vendor: \"wellcrafted\";\n\t\treadonly types: {\n\t\t\treadonly input:\n\t\t\t\t| { data: StandardTypedV1.InferInput<TDataSchema>; error: null }\n\t\t\t\t| { data: null; error: StandardTypedV1.InferInput<TErrorSchema> };\n\t\t\treadonly output:\n\t\t\t\t| { data: StandardTypedV1.InferOutput<TDataSchema>; error: null }\n\t\t\t\t| { data: null; error: StandardTypedV1.InferOutput<TErrorSchema> };\n\t\t};\n\t} & (TDataSchema extends StandardSchemaV1\n\t\t? TErrorSchema extends StandardSchemaV1\n\t\t\t? {\n\t\t\t\t\treadonly validate: StandardSchemaV1.Props<\n\t\t\t\t\t\t| {\n\t\t\t\t\t\t\t\tdata: StandardTypedV1.InferInput<TDataSchema>;\n\t\t\t\t\t\t\t\terror: null;\n\t\t\t\t\t\t  }\n\t\t\t\t\t\t| {\n\t\t\t\t\t\t\t\tdata: null;\n\t\t\t\t\t\t\t\terror: StandardTypedV1.InferInput<TErrorSchema>;\n\t\t\t\t\t\t  },\n\t\t\t\t\t\t| {\n\t\t\t\t\t\t\t\tdata: StandardTypedV1.InferOutput<TDataSchema>;\n\t\t\t\t\t\t\t\terror: null;\n\t\t\t\t\t\t  }\n\t\t\t\t\t\t| {\n\t\t\t\t\t\t\t\tdata: null;\n\t\t\t\t\t\t\t\terror: StandardTypedV1.InferOutput<TErrorSchema>;\n\t\t\t\t\t\t  }\n\t\t\t\t\t>[\"validate\"];\n\t\t\t\t}\n\t\t\t: Record<string, never>\n\t\t: Record<string, never>) &\n\t\t(TDataSchema extends StandardJSONSchemaV1\n\t\t\t? TErrorSchema extends StandardJSONSchemaV1\n\t\t\t\t? { readonly jsonSchema: StandardJSONSchemaV1.Converter }\n\t\t\t\t: Record<string, never>\n\t\t\t: Record<string, never>);\n};\n\nfunction createResultValidate<\n\tTDataSchema extends StandardSchemaV1,\n\tTErrorSchema extends StandardSchemaV1,\n>(\n\tdataSchema: TDataSchema,\n\terrorSchema: TErrorSchema,\n): StandardSchemaV1.Props<\n\t| { data: StandardTypedV1.InferInput<TDataSchema>; error: null }\n\t| { data: null; error: StandardTypedV1.InferInput<TErrorSchema> },\n\t| { data: StandardTypedV1.InferOutput<TDataSchema>; error: null }\n\t| { data: null; error: StandardTypedV1.InferOutput<TErrorSchema> }\n>[\"validate\"] {\n\treturn (value: unknown) => {\n\t\tif (typeof value !== \"object\" || value === null) {\n\t\t\treturn FAILURES.EXPECTED_OBJECT;\n\t\t}\n\n\t\tif (!(\"data\" in value) || !(\"error\" in value)) {\n\t\t\treturn FAILURES.EXPECTED_DATA_ERROR_PROPS;\n\t\t}\n\n\t\tconst obj = value as { data: unknown; error: unknown };\n\n\t\tconst isOk = obj.error === null;\n\n\t\tif (isOk) {\n\t\t\tconst innerResult = dataSchema[\"~standard\"].validate(obj.data);\n\n\t\t\tif (innerResult instanceof Promise) {\n\t\t\t\treturn innerResult.then((r) => {\n\t\t\t\t\tif (r.issues) {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\tissues: r.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t\t\t\t...issue,\n\t\t\t\t\t\t\t\tpath: [\"data\", ...(issue.path || [])],\n\t\t\t\t\t\t\t})),\n\t\t\t\t\t\t};\n\t\t\t\t\t}\n\t\t\t\t\treturn { value: { data: r.value, error: null as null } };\n\t\t\t\t});\n\t\t\t}\n\n\t\t\tif (innerResult.issues) {\n\t\t\t\treturn {\n\t\t\t\t\tissues: innerResult.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t\t...issue,\n\t\t\t\t\t\tpath: [\"data\", ...(issue.path || [])],\n\t\t\t\t\t})),\n\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn { value: { data: innerResult.value, error: null as null } };\n\t\t}\n\n\t\tconst innerResult = errorSchema[\"~standard\"].validate(obj.error);\n\n\t\tif (innerResult instanceof Promise) {\n\t\t\treturn innerResult.then((r) => {\n\t\t\t\tif (r.issues) {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tissues: r.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t\t\t...issue,\n\t\t\t\t\t\t\tpath: [\"error\", ...(issue.path || [])],\n\t\t\t\t\t\t})),\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t\treturn { value: { data: null as null, error: r.value } };\n\t\t\t});\n\t\t}\n\n\t\tif (innerResult.issues) {\n\t\t\treturn {\n\t\t\t\tissues: innerResult.issues.map((issue: StandardSchemaV1.Issue) => ({\n\t\t\t\t\t...issue,\n\t\t\t\t\tpath: [\"error\", ...(issue.path || [])],\n\t\t\t\t})),\n\t\t\t};\n\t\t}\n\n\t\treturn { value: { data: null as null, error: innerResult.value } };\n\t};\n}\n\nfunction createResultJsonSchema<\n\tTDataSchema extends StandardJSONSchemaV1,\n\tTErrorSchema extends StandardJSONSchemaV1,\n>(\n\tdataSchema: TDataSchema,\n\terrorSchema: TErrorSchema,\n): StandardJSONSchemaV1.Converter {\n\treturn {\n\t\tinput(options: StandardJSONSchemaV1.Options) {\n\t\t\treturn {\n\t\t\t\toneOf: [\n\t\t\t\t\t{\n\t\t\t\t\t\ttype: \"object\",\n\t\t\t\t\t\tproperties: {\n\t\t\t\t\t\t\tdata: dataSchema[\"~standard\"].jsonSchema.input(options),\n\t\t\t\t\t\t\terror: { type: \"null\" },\n\t\t\t\t\t\t},\n\t\t\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\t\t\tadditionalProperties: false,\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\ttype: \"object\",\n\t\t\t\t\t\tproperties: {\n\t\t\t\t\t\t\tdata: { type: \"null\" },\n\t\t\t\t\t\t\terror: errorSchema[\"~standard\"].jsonSchema.input(options),\n\t\t\t\t\t\t},\n\t\t\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\t\t\tadditionalProperties: false,\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t};\n\t\t},\n\t\toutput(options: StandardJSONSchemaV1.Options) {\n\t\t\treturn {\n\t\t\t\toneOf: [\n\t\t\t\t\t{\n\t\t\t\t\t\ttype: \"object\",\n\t\t\t\t\t\tproperties: {\n\t\t\t\t\t\t\tdata: dataSchema[\"~standard\"].jsonSchema.output(options),\n\t\t\t\t\t\t\terror: { type: \"null\" },\n\t\t\t\t\t\t},\n\t\t\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\t\t\tadditionalProperties: false,\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\ttype: \"object\",\n\t\t\t\t\t\tproperties: {\n\t\t\t\t\t\t\tdata: { type: \"null\" },\n\t\t\t\t\t\t\terror: errorSchema[\"~standard\"].jsonSchema.output(options),\n\t\t\t\t\t\t},\n\t\t\t\t\t\trequired: [\"data\", \"error\"],\n\t\t\t\t\t\tadditionalProperties: false,\n\t\t\t\t\t},\n\t\t\t\t],\n\t\t\t};\n\t\t},\n\t};\n}\n\n/**\n * Combines two Standard Schemas into a Result discriminated union schema.\n *\n * Takes a data schema for type T and an error schema for type E, returning a schema\n * for `{ data: T, error: null } | { data: null, error: E }`.\n *\n * Preserves the capabilities of the input schemas - if both have validate, output\n * has validate; if both have jsonSchema, output has jsonSchema.\n *\n * @example\n * ```typescript\n * import { z } from \"zod\";\n * import { ResultSchema } from \"wellcrafted/standard-schema\";\n *\n * const userSchema = z.object({ id: z.string(), name: z.string() });\n * const errorSchema = z.object({ code: z.string(), message: z.string() });\n * const resultSchema = ResultSchema(userSchema, errorSchema);\n *\n * // Validates Ok variant: { data: { id: \"1\", name: \"Alice\" }, error: null }\n * // Validates Err variant: { data: null, error: { code: \"NOT_FOUND\", message: \"...\" } }\n * const result = resultSchema[\"~standard\"].validate({\n *   data: { id: \"1\", name: \"Alice\" },\n *   error: null,\n * });\n * ```\n */\nexport function ResultSchema<\n\tTDataSchema extends StandardTypedV1,\n\tTErrorSchema extends StandardTypedV1,\n>(\n\tdataSchema: TDataSchema,\n\terrorSchema: TErrorSchema,\n): Result<TDataSchema, TErrorSchema> {\n\tconst base = {\n\t\t\"~standard\": {\n\t\t\tversion: 1 as const,\n\t\t\tvendor: \"wellcrafted\",\n\t\t\ttypes: {\n\t\t\t\tinput: undefined as unknown as\n\t\t\t\t\t| { data: StandardTypedV1.InferInput<TDataSchema>; error: null }\n\t\t\t\t\t| { data: null; error: StandardTypedV1.InferInput<TErrorSchema> },\n\t\t\t\toutput: undefined as unknown as\n\t\t\t\t\t| { data: StandardTypedV1.InferOutput<TDataSchema>; error: null }\n\t\t\t\t\t| { data: null; error: StandardTypedV1.InferOutput<TErrorSchema> },\n\t\t\t},\n\t\t},\n\t};\n\n\tif (hasValidate(dataSchema) && hasValidate(errorSchema)) {\n\t\t(base[\"~standard\"] as Record<string, unknown>).validate =\n\t\t\tcreateResultValidate(dataSchema, errorSchema);\n\t}\n\n\tif (hasJsonSchema(dataSchema) && hasJsonSchema(errorSchema)) {\n\t\t(base[\"~standard\"] as Record<string, unknown>).jsonSchema =\n\t\t\tcreateResultJsonSchema(dataSchema, errorSchema);\n\t}\n\n\treturn base as Result<TDataSchema, TErrorSchema>;\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wellcrafted",
-	"version": "0.33.0",
+	"version": "0.34.0",
 	"description": "Delightful TypeScript patterns for elegant, type-safe applications",
 	"type": "module",
 	"files": [
@@ -17,6 +17,10 @@
 			"types": "./dist/error/index.d.ts",
 			"import": "./dist/error/index.js"
 		},
+		"./json": {
+			"types": "./dist/json.d.ts",
+			"import": "./dist/json.js"
+		},
 		"./brand": {
 			"types": "./dist/brand.d.ts",
 			"import": "./dist/brand.js"

package/dist/result-DolxQXIZ.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"result-DolxQXIZ.d.ts","names":[],"sources":["../src/result/result.ts"],"sourcesContent":[],"mappings":";;AAWA;AAaA;AAqCA;;;;;;AAAsC;AAiBtC;AAAgE,KAnEpD,EAmEoD,CAAA,CAAA,CAAA,GAAA;EAAA,IAApC,EAnEA,CAmEA;EAAC,KAAM,EAAA,IAAA;CAAC;AAAF;AAiBlC;;;;;AAAqC;AAWrC;;;;AAAsE,KAlF1D,GAkF0D,CAAA,CAAA,CAAA,GAAA;EAAO,KAAA,EAlF/C,CAkF+C;EAcjE,IAAA,EAAA,IAAA;CAAoB;;;;AAA8C;AAuB9E;;;;;;AACI;AAqBJ;;;;;;AAGI;AAgCJ;;;;;AAEkB;AAgClB;;;;;;;AAA8D;AAyB9D;;;AAA8C,KAtMlC,MAsMkC,CAAA,CAAA,EAAA,CAAA,CAAA,GAtMnB,EAsMmB,CAtMhB,CAsMgB,CAAA,GAtMX,GAsMW,CAtMP,CAsMO,CAAA;;;;AAAkB;AAgDhE;;;;;;;AAGM;AAEN;;;AAEgC,cA5OnB,EA4OmB,EAAA,CAAA,CAAA,CAAA,CAAA,IAAA,EA5OJ,CA4OI,EAAA,GA5OA,EA4OA,CA5OG,CA4OH,CAAA;;;;;AACtB;AAEV;;;;;;;;;;AAGU,cAjOG,GAiOH,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAjOoB,CAiOpB,EAAA,GAjOwB,GAiOxB,CAjO4B,CAiO5B,CAAA;AAiEV;;;;;;;;;AAGW,KA1RC,mBA0RD,CAAA,UA1R+B,MA0R/B,CAAA,OAAA,EAAA,OAAA,CAAA,CAAA,GA1R2D,OA0R3D,CAzRV,CAyRU,EAAA;EAEW,KAAA,EAAA,IAAQ;CAAA,CAAA;;;;;;;;;AAGnB;AAEW,KAnRV,oBAmRkB,CAAA,UAnRa,MAmRb,CAAA,OAAA,EAAA,OAAA,CAAA,CAAA,GAnRyC,OAmRzC,CAlR7B,CAkR6B,EAAA;EAAA,IAAA,EAAA,IAAA;CAAA,CAAA;;;;;;;;;;AAGnB;AA+GX;;;;;;AAAqD;AAOrD;AAAuB,KArXX,QAqXW,CAAA,UArXQ,MAqXR,CAAA,OAAA,EAAA,OAAA,CAAA,CAAA,GArXoC,CAqXpC,SArX8C,EAqX9C,CAAA,KAAA,EAAA,CAAA,GApXpB,CAoXoB,GAAA,KAAA;;;;;;AAAkC;;;;;;;;;;;;;KA/V7C,oBAAoB,4BAA4B,UAAU,eAGnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgCa,6DAEJ,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;iBAgCN,mBAAmB,OAAO,GAAG,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;iBAyB/C,oBAAoB,OAAO,GAAG,eAAe,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDjD;aACJ;6BACgB,GAAG;IAC3B,GAAG;iBAES;aACJ;6BACgB,IAAI;IAC5B,OAAO,GAAG;iBAEE;aACJ;6BACgB,GAAG,KAAK,IAAI;IACpC,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEQ;aACV,QAAQ;6BACQ,GAAG;IAC3B,QAAQ,GAAG;iBAEO;aACV,QAAQ;6BACQ,IAAI;IAC5B,QAAQ,OAAO,GAAG;iBAEA;aACV,QAAQ;6BACQ,GAAG,KAAK,IAAI;IACpC,QAAQ,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+GN,qBAAqB,OAAO,GAAG,KAAK;iBAOpC,qBAAqB,IAAI,OAAO,GAAG,KAAK"}