@nicolastoulemont/std 0.8.0 → 0.8.2

package/README.md

@@ -260,7 +260,10 @@ Schema wraps Standard Schema-compatible validators for two production use cases:
 boundary parsing and sync-only refinement.
 
 Use `Schema.parse` at I/O boundaries when a broad external type hides smaller implicit subtypes.
-Use `Schema.is` only when the schema is a true refinement of an in-memory value and does not rely on transforms, defaults, or coercions.
+Use `Schema.is` for direct in-memory proof checks.
+Use `Schema.refine` when you need a reusable preserved-shape predicate, especially with higher-order APIs like `Array.filter`.
+Use `Schema.Refine<Base, typeof schema>` for a reusable preserved-shape narrowed type, and `Schema.Infer<typeof schema>` for the exact schema output type.
+Only use `Schema.is` and `Schema.refine` with sync proof schemas that validate the current value in place. Transforms, defaults, and coercions should continue to use `Schema.parse`.
 
 #### Boundary Parsing Example
 
@@ -305,13 +308,14 @@ if (Result.isOk(result)) {
 }
 ```
 
-#### In-Memory Refinement Example
+#### Direct In-Memory Proof Example
 
 ```ts
 import { Schema } from "@nicolastoulemont/std"
 import { z } from "zod"
 
-type Ticket = {
+type PersistedTicket = {
+  id: string
   channel: "chat" | "email"
   chatId?: string | null
   metadata?: {
@@ -319,31 +323,59 @@ type Ticket = {
   } | null
 }
 
-type ChatTicket = {
+type ChatTicketFields = {
   channel: "chat"
   chatId: string
-  metadata: {
-    conversationId: string
-  }
 }
 
-const ChatTicketSchema: Schema.SyncRefinementSchema<Ticket, ChatTicket> = z.object({
+const ChatTicketSchema: Schema.SyncSchema<PersistedTicket, ChatTicketFields> = z.object({
   channel: z.literal("chat"),
   chatId: z.string(),
-  metadata: z.object({
-    conversationId: z.string(),
-  }),
 })
 
-const isChatTicket = Schema.is(ChatTicketSchema)
+declare const ticket: PersistedTicket
+
+if (Schema.is(ticket, ChatTicketSchema)) {
+  ticket.id
+  ticket.chatId.toUpperCase()
+}
+```
+
+In direct control flow, TypeScript preserves the current type shape and intersects in the schema-proven fields.
+
+#### Reusable Preserved-Shape Predicate Example
+
+```ts
+import { Schema } from "@nicolastoulemont/std"
+import { z } from "zod"
 
-declare const ticket: Ticket
+type PersistedTicket = {
+  id: string
+  channel: "chat" | "email"
+  chatId?: string | null
+}
 
-if (isChatTicket(ticket)) {
-  ticket.metadata.conversationId
+type ChatTicketFields = {
+  channel: "chat"
+  chatId: string
 }
+
+const ChatTicketSchema: Schema.SyncSchema<PersistedTicket, ChatTicketFields> = z.object({
+  channel: z.literal("chat"),
+  chatId: z.string(),
+})
+
+type ChatTicket = Schema.Refine<PersistedTicket, typeof ChatTicketSchema>
+
+const isChatTicket = Schema.refine(ChatTicketSchema)
+
+declare const tickets: PersistedTicket[]
+
+const chatTickets = tickets.filter(isChatTicket)
 ```
 
+Use `Schema.Infer<typeof schema>` when you need the exact schema output, and use `Schema.parse` whenever the schema changes the output shape.
+
 ### Adt
 
 Adt builds tagged unions backed by any Standard Schema-compatible validator.

package/dist/adt/index.d.mts

@@ -1,2 +1,2 @@
-import { t as adt_d_exports } from "../index-DfQGXBQI.mjs";
+import { t as adt_d_exports } from "../index-C6W3_n_Q.mjs";
 export { adt_d_exports as Adt };

package/dist/adt/index.mjs

@@ -1 +1 @@
-import{t as e}from"../adt-CzdkjlUM.mjs";export{e as Adt};
+import{t as e}from"../adt-CPG_sa8q.mjs";export{e as Adt};

package/dist/{adt-CzdkjlUM.mjs → adt-CPG_sa8q.mjs}

@@ -1,2 +1,2 @@
-import{t as e}from"./chunk-oQKkju2G.mjs";import{i as t,n,r,t as i}from"./equality-BX6BUidG.mjs";import{i as a,t as o}from"./result-D3VY0qBG.mjs";import{n as s}from"./schema.shared-CI4eydjX.mjs";function c(e,t){let n=t[e._tag];return n(e)}function l(e){return typeof e!=`object`||!e?!1:Object.getPrototypeOf(e)===null||Object.getPrototypeOf(e)===Object.prototype}function u(e){return typeof e==`function`&&`_variant`in e&&e._variant===!0}function d(e,t,n){return s(e,t,`ADT variant "${n}"`)}function f(e){return t=>l(t)&&`_tag`in t&&t._tag===e}function p(e){let t=new Set(e);return e=>l(e)&&`_tag`in e&&typeof e._tag==`string`&&t.has(e._tag)}function m(e,t,n,r){return n!==void 0&&r!==void 0?{kind:e,message:t,cause:n,validationIssues:r}:n===void 0?r===void 0?{kind:e,message:t}:{kind:e,message:t,validationIssues:r}:{kind:e,message:t,cause:n}}function h(e){return{to:e=>JSON.stringify(e),from:e=>{try{let t=JSON.parse(e);if(typeof t==`object`&&t&&`_tag`in t){let{_tag:e,...n}=t;return n}return t}catch{return null}}}}function g(e,t,n){let r=h(e),i={json:n=>{let i=d(t,{...n,_tag:e},e);if(i._tag===`Err`)return o(m(`ValidationError`,`Cannot encode invalid data: ${i.error.issues.map(e=>e.message).join(`, `)}`,void 0,i.error.issues));try{return a(r.to(i.value))}catch(e){return o(m(`EncodingError`,`JSON encoding failed: ${e instanceof Error?e.message:String(e)}`,e))}}};if(n)for(let[r,s]of Object.entries(n))i[r]=n=>{let i=d(t,{...n,_tag:e},e);if(i._tag===`Err`)return o(m(`ValidationError`,`Cannot encode invalid data: ${i.error.issues.map(e=>e.message).join(`, `)}`,void 0,i.error.issues));try{return a(s.to(i.value))}catch(e){return o(m(`EncodingError`,`Encoding with codec '${r}' failed: ${e instanceof Error?e.message:String(e)}`,e))}};return i}function _(e,t,n){let r=h(e),i={json:n=>{let i=r.from(n);if(i===null)return o(m(`DecodingError`,`Invalid JSON format`));let s=d(t,{...i,_tag:e},e);return s._tag===`Err`?o(m(`ValidationError`,`Decoded data failed schema validation`,void 0,s.error.issues)):a({...s.value,_tag:e})}};if(n)for(let[r,s]of Object.entries(n))i[r]=n=>{let i;try{i=s.from(n)}catch(e){return o(m(`DecodingError`,`Decoding with codec '${r}' threw an error`,e))}if(i===null)return o(m(`DecodingError`,`Codec '${r}' failed to decode input`));let c=d(t,{...i,_tag:e},e);return c._tag===`Err`?o(m(`ValidationError`,`Decoded data failed schema validation`,void 0,c.error.issues)):a({...c.value,_tag:e})};return i}function v(e,n,i){let s=f(e),c=g(e,n,i),l=_(e,n,i),u=r(e),p=t(e),m=t=>{let r=d(n,{...t,_tag:e},e);return r._tag===`Err`?o(r.error):a({...r.value,_tag:e})};return m._variant=!0,m._tag=e,m.schema=n,i&&(m.codecs=i),m.is=s,m.to=c,m.from=l,m.equals=u,m.hash=p,m}function y(e,t){let r=Object.keys(t),a={};for(let[e,n]of Object.entries(t))u(n)?n._tag===e?a[e]=n:n.codecs?a[e]=v(e,n.schema,n.codecs):a[e]=v(e,n.schema):a[e]=v(e,n);return{_name:e,is:p(r),equals:i(r),hash:n(r),...a}}var b=e({match:()=>C,union:()=>x,variant:()=>S});const x=y,S=v,C=c;export{b as t};
-//# sourceMappingURL=adt-CzdkjlUM.mjs.map
+import{t as e}from"./chunk-oQKkju2G.mjs";import{i as t,n,r,t as i}from"./equality-BX6BUidG.mjs";import{i as a,t as o}from"./result-D3VY0qBG.mjs";import{r as s}from"./schema.shared-Bjyroa6b.mjs";function c(e,t){let n=t[e._tag];return n(e)}function l(e){return typeof e!=`object`||!e?!1:Object.getPrototypeOf(e)===null||Object.getPrototypeOf(e)===Object.prototype}function u(e){return typeof e==`function`&&`_variant`in e&&e._variant===!0}function d(e,t,n){return s(e,t,`ADT variant "${n}"`)}function f(e){return t=>l(t)&&`_tag`in t&&t._tag===e}function p(e){let t=new Set(e);return e=>l(e)&&`_tag`in e&&typeof e._tag==`string`&&t.has(e._tag)}function m(e,t,n,r){return n!==void 0&&r!==void 0?{kind:e,message:t,cause:n,validationIssues:r}:n===void 0?r===void 0?{kind:e,message:t}:{kind:e,message:t,validationIssues:r}:{kind:e,message:t,cause:n}}function h(e){return{to:e=>JSON.stringify(e),from:e=>{try{let t=JSON.parse(e);if(typeof t==`object`&&t&&`_tag`in t){let{_tag:e,...n}=t;return n}return t}catch{return null}}}}function g(e,t,n){let r=h(e),i={json:n=>{let i=d(t,{...n,_tag:e},e);if(i._tag===`Err`)return o(m(`ValidationError`,`Cannot encode invalid data: ${i.error.issues.map(e=>e.message).join(`, `)}`,void 0,i.error.issues));try{return a(r.to(i.value))}catch(e){return o(m(`EncodingError`,`JSON encoding failed: ${e instanceof Error?e.message:String(e)}`,e))}}};if(n)for(let[r,s]of Object.entries(n))i[r]=n=>{let i=d(t,{...n,_tag:e},e);if(i._tag===`Err`)return o(m(`ValidationError`,`Cannot encode invalid data: ${i.error.issues.map(e=>e.message).join(`, `)}`,void 0,i.error.issues));try{return a(s.to(i.value))}catch(e){return o(m(`EncodingError`,`Encoding with codec '${r}' failed: ${e instanceof Error?e.message:String(e)}`,e))}};return i}function _(e,t,n){let r=h(e),i={json:n=>{let i=r.from(n);if(i===null)return o(m(`DecodingError`,`Invalid JSON format`));let s=d(t,{...i,_tag:e},e);return s._tag===`Err`?o(m(`ValidationError`,`Decoded data failed schema validation`,void 0,s.error.issues)):a({...s.value,_tag:e})}};if(n)for(let[r,s]of Object.entries(n))i[r]=n=>{let i;try{i=s.from(n)}catch(e){return o(m(`DecodingError`,`Decoding with codec '${r}' threw an error`,e))}if(i===null)return o(m(`DecodingError`,`Codec '${r}' failed to decode input`));let c=d(t,{...i,_tag:e},e);return c._tag===`Err`?o(m(`ValidationError`,`Decoded data failed schema validation`,void 0,c.error.issues)):a({...c.value,_tag:e})};return i}function v(e,n,i){let s=f(e),c=g(e,n,i),l=_(e,n,i),u=r(e),p=t(e),m=t=>{let r=d(n,{...t,_tag:e},e);return r._tag===`Err`?o(r.error):a({...r.value,_tag:e})};return m._variant=!0,m._tag=e,m.schema=n,i&&(m.codecs=i),m.is=s,m.to=c,m.from=l,m.equals=u,m.hash=p,m}function y(e,t){let r=Object.keys(t),a={};for(let[e,n]of Object.entries(t))u(n)?n._tag===e?a[e]=n:n.codecs?a[e]=v(e,n.schema,n.codecs):a[e]=v(e,n.schema):a[e]=v(e,n);return{_name:e,is:p(r),equals:i(r),hash:n(r),...a}}var b=e({match:()=>C,union:()=>x,variant:()=>S});const x=y,S=v,C=c;export{b as t};
+//# sourceMappingURL=adt-CPG_sa8q.mjs.map

package/dist/{adt-CzdkjlUM.mjs.map → adt-CPG_sa8q.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"adt-CzdkjlUM.mjs","names":["match","validateSchemaSync","variant","union","variant","unionImpl","variantImpl","matchImpl"],"sources":["../src/adt/adt.match.ts","../src/shared/is-plain-object.ts","../src/adt/adt.utils.ts","../src/adt/adt.codec.ts","../src/adt/adt.variant.ts","../src/adt/adt.union.ts","../src/adt/adt.ts"],"sourcesContent":["/**\n * Handler functions for each variant in a discriminated union.\n * Each key maps to a function that receives the variant value and returns TResult.\n *\n * @template T - The discriminated union type (must have readonly _tag)\n * @template TResult - The return type of all handlers\n */\ntype AdtMatchHandlers<T extends { readonly _tag: string }, TResult> = {\n  [K in T[\"_tag\"]]: (value: Extract<T, { readonly _tag: K }>) => TResult\n}\n\n/**\n * Exhaustive pattern matching for discriminated unions.\n *\n * TypeScript will error if any variant is missing from handlers,\n * ensuring exhaustive handling of all cases.\n *\n * @template T - The discriminated union type (must have readonly _tag)\n * @template TResult - The return type of all handlers\n * @template Handlers - The handler object type (inferred)\n * @param value - A discriminated union value with _tag\n * @param handlers - An object with a handler function for each variant\n * @returns The result of calling the matching handler\n *\n * @see {@link union} for creating discriminated unions\n * @see {@link variant} for creating individual variant types\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const Circle = Adt.variant(\"Circle\", z.object({ radius: z.number() }))\n * const Square = Adt.variant(\"Square\", z.object({ size: z.number() }))\n * const Shape = Adt.union(\"Shape\", { Circle, Square })\n * type Shape = Adt.Infer<typeof Shape>\n *\n * function describeShape(shape: Shape): string {\n *   return Adt.match(shape, {\n *     Circle: (c) => `Circle with radius ${c.radius}`,\n *     Square: (s) => `Square with size ${s.size}`,\n *   })\n * }\n * ```\n */\nexport function match<\n  T extends { readonly _tag: string },\n  TResult,\n  Handlers extends AdtMatchHandlers<T, TResult> = AdtMatchHandlers<T, TResult>,\n>(value: T, handlers: Handlers): TResult {\n  const tag = value._tag as keyof Handlers\n  const handler = handlers[tag]\n  // oxlint-disable-next-line no-explicit-any, no-unsafe-argument, no-unsafe-type-assertion -- Required for variant dispatch\n  return handler(value as any)\n}\n","/**\n * Check if a value is a plain object.\n * A plain object is an object created with `{}`, `Object.create(null)`, or `new Object()`.\n * Arrays, functions, dates, maps, etc. are not considered plain objects.\n */\nexport function isPlainObject(value: unknown): value is Record<PropertyKey, unknown> {\n  if (value === null || typeof value !== \"object\") {\n    return false\n  }\n\n  return Object.getPrototypeOf(value) === null || Object.getPrototypeOf(value) === Object.prototype\n}\n","import { validateSync as validateSchemaSync } from \"../schema/schema.shared\"\nimport { isPlainObject } from \"../shared/is-plain-object\"\nimport type { AdtVariant } from \"./adt.types\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Check if a value is an AdtVariant created by variant().\n * AdtVariants are callable functions with static properties.\n */\nexport function isVariant(value: unknown): value is AdtVariant {\n  return typeof value === \"function\" && \"_variant\" in value && value[\"_variant\"] === true\n}\n\n/**\n * Validate data using a Standard Schema, enforcing sync-only validation.\n * Throws if the schema returns a Promise.\n */\nexport function validateSync<T>(schema: StandardSchemaV1<unknown, T>, data: unknown, _tag: string) {\n  return validateSchemaSync(schema, data, `ADT variant \"${_tag}\"`)\n}\n\n/**\n * Create a type guard function for a specific _tag.\n */\nexport function createIsGuard<Tag extends string, T>(\n  _tag: Tag,\n): (value: unknown) => value is T & { readonly _tag: Tag } {\n  return (value: unknown): value is T & { readonly _tag: Tag } => {\n    return isPlainObject(value) && \"_tag\" in value && value[\"_tag\"] === _tag\n  }\n}\n\n/**\n * Create a type guard function for multiple _tags (AdtUnion root guard).\n */\nexport function createIsAnyGuard<T>(_tags: readonly string[]): (value: unknown) => value is T {\n  const _tagSet = new Set(_tags)\n  return (value: unknown): value is T => {\n    return isPlainObject(value) && \"_tag\" in value && typeof value[\"_tag\"] === \"string\" && _tagSet.has(value[\"_tag\"])\n  }\n}\n","import { ok, err } from \"../result/result\"\nimport type { Result } from \"../result/result.types\"\nimport type { ValidationError } from \"../schema/schema.types\"\nimport type { Discriminator } from \"../shared/discriminator.types\"\nimport type {\n  AdtCodecConstraint,\n  AdtCodecDef,\n  AdtCodecError,\n  AdtInferInput,\n  AdtInferOutput,\n  ToMethods,\n  FromMethods,\n} from \"./adt.types\"\nimport { validateSync } from \"./adt.utils\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Create a AdtCodecError with consistent structure.\n */\nfunction createCodecError(\n  kind: AdtCodecError[\"kind\"],\n  message: string,\n  cause?: unknown,\n  validationIssues?: ValidationError[\"issues\"],\n): AdtCodecError {\n  if (cause !== undefined && validationIssues !== undefined) {\n    return { kind, message, cause, validationIssues }\n  }\n  if (cause !== undefined) {\n    return { kind, message, cause }\n  }\n  if (validationIssues !== undefined) {\n    return { kind, message, validationIssues }\n  }\n  return { kind, message }\n}\n\n/**\n * Built-in JSON codec that works with any schema.\n * Encodes to JSON string and decodes with JSON.parse.\n */\nfunction createJsonCodec<Tag extends string, S extends StandardSchemaV1>(\n  _tag: Tag,\n): AdtCodecDef<AdtInferOutput<S> & Discriminator<Tag>, string, AdtInferInput<S>> {\n  return {\n    to: (value) => {\n      // JSON.stringify can throw for circular references, BigInt, etc.\n      // We let it throw and catch it in the wrapper\n      return JSON.stringify(value)\n    },\n    /* oxlint-disable no-unsafe-assignment, no-unsafe-type-assertion, no-unsafe-return -- Required for JSON parsing which returns unknown types */\n    from: (input: string) => {\n      try {\n        const parsed = JSON.parse(input)\n        // Return parsed object without _tag - it will be added during validation\n        if (typeof parsed === \"object\" && parsed !== null && \"_tag\" in parsed) {\n          const { _tag: _, ...rest } = parsed\n          return rest as AdtInferInput<S>\n        }\n        return parsed\n      } catch {\n        return null\n      }\n    },\n    /* oxlint-enable no-unsafe-assignment, no-unsafe-type-assertion, no-unsafe-return */\n  }\n}\n\n/**\n * Create the \"to\" methods object with JSON codec and custom codecs.\n * All methods return Result<T, AdtCodecError> for consistent error handling.\n */\nexport function createToMethods<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends AdtCodecConstraint<Tag, S> | undefined = undefined,\n>(_tag: Tag, schema: S, customCodecs?: Codecs): ToMethods<S, Codecs> {\n  type Output = AdtInferOutput<S> & Discriminator<Tag>\n\n  const jsonCodec = createJsonCodec<Tag, S>(_tag)\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const to: Record<string, (value: AdtInferInput<S>) => Result<any, AdtCodecError>> = {\n    json: (value: AdtInferInput<S>): Result<string, AdtCodecError> => {\n      // First, create a validated variant to ensure the encoded payload is well-typed.\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading generic input into object\n      const taggedInput = { ...(value as object), _tag }\n      const result = validateSync(schema, taggedInput, _tag)\n\n      if (result._tag === \"Err\") {\n        return err(\n          createCodecError(\n            \"ValidationError\",\n            `Cannot encode invalid data: ${result.error.issues.map((i) => i.message).join(\", \")}`,\n            undefined,\n            result.error.issues,\n          ),\n        )\n      }\n\n      try {\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for validated value cast\n        return ok(jsonCodec.to(result.value as Output))\n      } catch (e) {\n        return err(\n          createCodecError(\"EncodingError\", `JSON encoding failed: ${e instanceof Error ? e.message : String(e)}`, e),\n        )\n      }\n    },\n  }\n\n  // Add custom codecs\n  if (customCodecs) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    for (const [name, codec] of Object.entries(customCodecs) as Array<[string, AdtCodecDef<Output, any, any>]>) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      to[name] = (value: AdtInferInput<S>): Result<any, AdtCodecError> => {\n        // Validate input first\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading generic input\n        const taggedInput = { ...(value as object), _tag }\n        const result = validateSync(schema, taggedInput, _tag)\n\n        if (result._tag === \"Err\") {\n          return err(\n            createCodecError(\n              \"ValidationError\",\n              `Cannot encode invalid data: ${result.error.issues.map((i) => i.message).join(\", \")}`,\n              undefined,\n              result.error.issues,\n            ),\n          )\n        }\n\n        try {\n          // oxlint-disable-next-line no-unsafe-type-assertion -- Required for validated value cast\n          return ok(codec.to(result.value as Output))\n        } catch (e) {\n          return err(\n            createCodecError(\n              \"EncodingError\",\n              `Encoding with codec '${name}' failed: ${e instanceof Error ? e.message : String(e)}`,\n              e,\n            ),\n          )\n        }\n      }\n    }\n  }\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic return type\n  return to as ToMethods<S, Codecs>\n}\n\n/**\n * Create the \"from\" methods object with JSON codec and custom codecs.\n * All methods return Result<T, AdtCodecError> for consistent error handling.\n */\nexport function createFromMethods<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends AdtCodecConstraint<Tag, S> | undefined = undefined,\n>(_tag: Tag, schema: S, customCodecs?: Codecs): FromMethods<Tag, S, Codecs> {\n  type Output = AdtInferOutput<S> & Discriminator<Tag>\n\n  const jsonCodec = createJsonCodec<Tag, S>(_tag)\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const from: Record<string, (input: any) => Result<Output, AdtCodecError>> = {\n    json: (input: string): Result<Output, AdtCodecError> => {\n      // Decode\n      const decoded = jsonCodec.from(input)\n      if (decoded === null) {\n        return err(createCodecError(\"DecodingError\", \"Invalid JSON format\"))\n      }\n\n      // Validate through schema\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading decoded value\n      const taggedInput = { ...(decoded as object), _tag }\n      const result = validateSync(schema, taggedInput, _tag)\n\n      if (result._tag === \"Err\") {\n        return err(\n          createCodecError(\"ValidationError\", \"Decoded data failed schema validation\", undefined, result.error.issues),\n        )\n      }\n\n      // Ensure _tag in output\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for output construction\n      const output = { ...(result.value as object), _tag } as Output\n      return ok(output)\n    },\n  }\n\n  // Add custom codecs\n  if (customCodecs) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    for (const [name, codec] of Object.entries(customCodecs) as Array<[string, AdtCodecDef<Output, any, any>]>) {\n      from[name] = (input: unknown): Result<Output, AdtCodecError> => {\n        // Decode\n        let decoded: unknown\n        try {\n          decoded = codec.from(input)\n        } catch (e) {\n          return err(createCodecError(\"DecodingError\", `Decoding with codec '${name}' threw an error`, e))\n        }\n\n        if (decoded === null) {\n          return err(createCodecError(\"DecodingError\", `Codec '${name}' failed to decode input`))\n        }\n\n        // Validate through schema\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading decoded value\n        const taggedInput = { ...(decoded as object), _tag }\n        const result = validateSync(schema, taggedInput, _tag)\n\n        if (result._tag === \"Err\") {\n          return err(\n            createCodecError(\n              \"ValidationError\",\n              \"Decoded data failed schema validation\",\n              undefined,\n              result.error.issues,\n            ),\n          )\n        }\n\n        // Ensure _tag in output\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for output construction\n        const output = { ...(result.value as object), _tag } as Output\n        return ok(output)\n      }\n    }\n  }\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic return type\n  return from as FromMethods<Tag, S, Codecs>\n}\n","import { createEqualsMethod, createHashMethod } from \"../equality/equality\"\nimport { ok, err } from \"../result/result\"\nimport type { Result } from \"../result/result.types\"\nimport type { ValidationError } from \"../schema/schema.types\"\nimport type { Discriminator } from \"../shared/discriminator.types\"\nimport { createToMethods, createFromMethods } from \"./adt.codec\"\nimport type { AdtCodecConstraint, AdtInferInput, AdtInferOutput, AdtVariant } from \"./adt.types\"\nimport { createIsGuard, validateSync } from \"./adt.utils\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Create a standalone tagged variant from a Standard Schema with optional codecs.\n *\n * Variants can be used independently or composed into an AdtUnion via union().\n * All defaults should be defined at the schema level (e.g., Zod's .default()).\n *\n * @template Tag - The string literal type for the _tag discriminator\n * @template S - The Standard Schema type for validation\n * @template Codecs - Optional codec definitions for custom serialization formats\n * @param _tag - The _tag discriminator value\n * @param schema - A Standard Schema compliant validator\n * @param codecs - Optional codec definitions for custom serialization formats\n * @returns A callable AdtVariant with is(), to, and from methods\n *\n * @see {@link union} for composing variants into discriminated unions\n * @see {@link tagged} for unvalidated tagged value constructors\n *\n * @example\n * ```ts\n * const CircleSchema = z.object({\n *   radius: z.number().positive(),\n *   color: z.string().default('blue')\n * })\n *\n * // Basic variant with JSON codec (always included)\n * const Circle = variant('Circle', CircleSchema)\n *\n * const result = Circle({ radius: 10 })\n * // { _tag: \"Ok\", value: { _tag: \"Circle\", radius: 10, color: \"blue\" } }\n *\n * Circle.is(someValue) // type guard\n *\n * const json = Circle.to.json({ radius: 10 }) // JSON string\n * const result2 = Circle.from.json(json) // Result<Circle, AdtCodecError>\n *\n * // Variant with custom codec\n * const Circle2 = variant('Circle', CircleSchema, {\n *   graphic: {\n *     to: (circle) => `(${circle.radius})`,\n *     from: (input: string) => {\n *       const match = input.match(/^\\((\\d+)\\)$/)\n *       return match ? { radius: parseInt(match[1]!) } : null\n *     }\n *   }\n * })\n *\n * const graphic = Circle2.to.graphic({ radius: 10 }) // \"(10)\"\n * const result3 = Circle2.from.graphic(\"(10)\") // Result<Circle, AdtCodecError>\n * ```\n */\n// Overload: with codecs\nexport function variant<Tag extends string, S extends StandardSchemaV1, Codecs extends AdtCodecConstraint<Tag, S>>(\n  _tag: Tag,\n  schema: S,\n  codecs: Codecs,\n): AdtVariant<Tag, S, Codecs>\n\n// Overload: without codecs\nexport function variant<Tag extends string, S extends StandardSchemaV1>(_tag: Tag, schema: S): AdtVariant<Tag, S>\n\n// Implementation\nexport function variant<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends AdtCodecConstraint<Tag, S> | undefined,\n>(_tag: Tag, schema: S, codecs?: Codecs): AdtVariant<Tag, S, Codecs> {\n  type Output = AdtInferOutput<S> & Discriminator<Tag>\n\n  const isGuard = createIsGuard<Tag, Output>(_tag)\n  const to = createToMethods(_tag, schema, codecs)\n  const from = createFromMethods(_tag, schema, codecs)\n  const equals = createEqualsMethod<Tag, AdtInferOutput<S>>(_tag)\n  const hash = createHashMethod<Tag, AdtInferOutput<S>>(_tag)\n\n  // Constructor function\n  const constructor = (input: AdtInferInput<S>): Result<Output, ValidationError> => {\n    // Add _tag to the input before validation\n    // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading generic input\n    const taggedInput = { ...(input as object), _tag }\n\n    // Validate using the schema\n    const result = validateSync(schema, taggedInput, _tag)\n\n    if (result._tag === \"Err\") {\n      return err(result.error)\n    }\n\n    // Ensure _tag is in the output (schema might strip unknown keys)\n    // oxlint-disable-next-line no-unsafe-type-assertion -- Required for output construction\n    const output = { ...(result.value as object), _tag } as Output\n    return ok(output)\n  }\n\n  // Attach static properties to constructor function\n  constructor._variant = true as const\n  constructor._tag = _tag\n  constructor.schema = schema\n  if (codecs) {\n    // oxlint-disable-next-line no-unsafe-type-assertion -- Conditional assignment of codecs\n    ;(constructor as { codecs?: Codecs }).codecs = codecs\n  }\n  constructor.is = isGuard\n  constructor.to = to\n  constructor.from = from\n  constructor.equals = equals\n  constructor.hash = hash\n\n  return constructor as AdtVariant<Tag, S, Codecs>\n}\n","import { createADTEqualsMethod, createADTHashMethod } from \"../equality/equality\"\nimport type { AdtUnion, AdtVariantDef, AdtVariant } from \"./adt.types\"\nimport { createIsAnyGuard, isVariant } from \"./adt.utils\"\nimport { variant } from \"./adt.variant\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Compose records or schemas into a discriminated union (AdtUnion).\n *\n * Accepts either:\n * - Pre-built AdtVariants from variant() (codecs are preserved)\n * - Raw Standard Schema validators (will be wrapped internally)\n *\n * When using pre-built records, the object key overrides the original _tag.\n *\n * @template R - Record of variant names to AdtVariants or StandardSchema validators\n * @param name - The name of this AdtUnion (for identification)\n * @param records - An object mapping _tag names to AdtVariants or schemas\n * @returns An AdtUnion object with accessors for each variant\n *\n * @see {@link variant} for creating individual variant types\n * @see {@link match} for exhaustive pattern matching on AdtUnion values\n *\n * @example\n * ```ts\n * // From pre-built variants\n * const Circle = variant('Circle', CircleSchema)\n * const Square = variant('Square', SquareSchema)\n * const Shape = union('Shape', { Circle, Square })\n *\n * // From raw schemas (JSON codec is automatically included)\n * const Shape = union('Shape', {\n *   Circle: CircleSchema,\n *   Square: SquareSchema\n * })\n *\n * // JSON codec works on all variants\n * Shape.Circle.to.json({ radius: 10 })\n * Shape.Circle.from.json(jsonString)\n *\n * // Mixed\n * const Shape = union('Shape', {\n *   Circle,              // Pre-built variant\n *   Square: SquareSchema // Raw schema\n * })\n *\n * // Usage\n * Shape.Circle({ radius: 10 })\n * Shape.is(someValue)        // type guard for any variant\n * Shape.Circle.is(someValue) // type guard for Circle\n * ```\n */\nexport function union<R extends Record<string, AdtVariantDef>>(name: string, records: R): AdtUnion<R> {\n  const tags = Object.keys(records)\n  const variants: Record<string, AdtVariant> = {}\n\n  for (const [_tag, def] of Object.entries(records)) {\n    if (isVariant(def)) {\n      // Pre-built AdtVariant - key overrides original _tag\n      if (def._tag === _tag) {\n        // _tag matches key, use as-is (preserves codecs)\n        variants[_tag] = def\n        // oxlint-disable-next-line strict-boolean-expressions -- codecs can be undefined\n      } else if (def.codecs) {\n        // _tag differs from key - create new variant with key as _tag\n        // Preserve codecs\n        variants[_tag] = variant(_tag, def.schema, def.codecs)\n      } else {\n        // _tag differs from key and no codecs\n        variants[_tag] = variant(_tag, def.schema)\n      }\n    } else {\n      // Raw schema - wrap in variant\n      // Note: Even without custom codecs, this still gets JSON codec!\n      // oxlint-disable-next-line no-unsafe-type-assertion -- def is a StandardSchemaV1 in this branch\n      variants[_tag] = variant(_tag, def as StandardSchemaV1)\n    }\n  }\n\n  // Create the root type guard for any variant\n  const isAnyVariant = createIsAnyGuard(tags)\n  const equals = createADTEqualsMethod(tags)\n  const hash = createADTHashMethod(tags)\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic AdtUnion return type\n  return {\n    _name: name,\n    is: isAnyVariant,\n    equals,\n    hash,\n    ...variants,\n  } as AdtUnion<R>\n}\n","/**\n * Tagged union builders and match helpers.\n *\n * **Mental model**\n * - `Adt` helps build discriminated unions with runtime validation.\n * - Use `union`, `variant`, and `match` to model algebraic data types.\n *\n * **Common tasks**\n * - Define variants with `Adt.variant`.\n * - Combine variants with `Adt.union`.\n * - Pattern-match with `Adt.match`.\n *\n * **Gotchas**\n * - `Adt` codec/type helpers are mostly type-level.\n * - Prefer namespace imports from `@nicolastoulemont/std`.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const CircleSchema = z.object({ radius: z.number() })\n *\n * const Shape = Adt.union(\"Shape\", { Circle: CircleSchema })\n * const result = Shape.Circle({ radius: 2 })\n * // => { _tag: \"Ok\", value: { _tag: \"Circle\", radius: 2 } }\n * ```\n *\n * @module\n */\nimport { match as matchImpl } from \"./adt.match\"\nimport type {\n  AdtInfer as AdtInferType,\n  AdtVariantNames as AdtVariantNamesType,\n  AdtVariantOf as AdtVariantOfType,\n} from \"./adt.types\"\nimport { union as unionImpl } from \"./adt.union\"\nimport { variant as variantImpl } from \"./adt.variant\"\n\n/**\n * Re-exported ADT inferred union helper.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const Shape = Adt.union(\"Shape\", {\n *   Circle: z.object({ radius: z.number() }),\n * })\n * type Shape = Adt.Infer<typeof Shape>\n * ```\n */\nexport type Infer<T> = AdtInferType<T>\n\n/**\n * Re-exported union variant name helper.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const Shape = Adt.union(\"Shape\", {\n *   Circle: z.object({ radius: z.number() }),\n * })\n * type Names = Adt.VariantNames<typeof Shape>\n * ```\n */\nexport type VariantNames<T> = AdtVariantNamesType<T>\n\n/**\n * Re-exported helper to extract a specific variant from an ADT.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const Shape = Adt.union(\"Shape\", {\n *   Circle: z.object({ radius: z.number() }),\n * })\n * type Circle = Adt.VariantOf<typeof Shape, \"Circle\">\n * ```\n */\nexport type VariantOf<T, K extends string> = AdtVariantOfType<T, K>\n\n/**\n * Build an ADT union from named variants.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const CircleSchema = z.object({ radius: z.number() })\n *\n * const Shape = Adt.union(\"Shape\", { Circle: CircleSchema })\n * const result = Shape.Circle({ radius: 2 })\n * // => { _tag: \"Ok\", value: { _tag: \"Circle\", radius: 2 } }\n * ```\n */\nexport const union = unionImpl\n\n/**\n * Define one ADT variant with schema-backed validation.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const CircleSchema = z.object({ radius: z.number() })\n *\n * const Circle = Adt.variant(\"Circle\", CircleSchema)\n * const result = Circle({ radius: 2 })\n * // => { _tag: \"Ok\", value: { _tag: \"Circle\", radius: 2 } }\n * ```\n */\nexport const variant = variantImpl\n\n/**\n * Match over ADT variants by discriminator tag.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n *\n * const label = Adt.match({ _tag: \"Circle\", radius: 2 } as const, {\n *   Circle: (circle) => `r=${circle.radius}` ,\n * })\n * // => \"r=2\"\n * ```\n */\nexport const match = matchImpl\n"],"mappings":"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"}
+{"version":3,"file":"adt-CPG_sa8q.mjs","names":["match","validateSchemaSync","variant","union","variant","unionImpl","variantImpl","matchImpl"],"sources":["../src/adt/adt.match.ts","../src/shared/is-plain-object.ts","../src/adt/adt.utils.ts","../src/adt/adt.codec.ts","../src/adt/adt.variant.ts","../src/adt/adt.union.ts","../src/adt/adt.ts"],"sourcesContent":["/**\n * Handler functions for each variant in a discriminated union.\n * Each key maps to a function that receives the variant value and returns TResult.\n *\n * @template T - The discriminated union type (must have readonly _tag)\n * @template TResult - The return type of all handlers\n */\ntype AdtMatchHandlers<T extends { readonly _tag: string }, TResult> = {\n  [K in T[\"_tag\"]]: (value: Extract<T, { readonly _tag: K }>) => TResult\n}\n\n/**\n * Exhaustive pattern matching for discriminated unions.\n *\n * TypeScript will error if any variant is missing from handlers,\n * ensuring exhaustive handling of all cases.\n *\n * @template T - The discriminated union type (must have readonly _tag)\n * @template TResult - The return type of all handlers\n * @template Handlers - The handler object type (inferred)\n * @param value - A discriminated union value with _tag\n * @param handlers - An object with a handler function for each variant\n * @returns The result of calling the matching handler\n *\n * @see {@link union} for creating discriminated unions\n * @see {@link variant} for creating individual variant types\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const Circle = Adt.variant(\"Circle\", z.object({ radius: z.number() }))\n * const Square = Adt.variant(\"Square\", z.object({ size: z.number() }))\n * const Shape = Adt.union(\"Shape\", { Circle, Square })\n * type Shape = Adt.Infer<typeof Shape>\n *\n * function describeShape(shape: Shape): string {\n *   return Adt.match(shape, {\n *     Circle: (c) => `Circle with radius ${c.radius}`,\n *     Square: (s) => `Square with size ${s.size}`,\n *   })\n * }\n * ```\n */\nexport function match<\n  T extends { readonly _tag: string },\n  TResult,\n  Handlers extends AdtMatchHandlers<T, TResult> = AdtMatchHandlers<T, TResult>,\n>(value: T, handlers: Handlers): TResult {\n  const tag = value._tag as keyof Handlers\n  const handler = handlers[tag]\n  // oxlint-disable-next-line no-explicit-any, no-unsafe-argument, no-unsafe-type-assertion -- Required for variant dispatch\n  return handler(value as any)\n}\n","/**\n * Check if a value is a plain object.\n * A plain object is an object created with `{}`, `Object.create(null)`, or `new Object()`.\n * Arrays, functions, dates, maps, etc. are not considered plain objects.\n */\nexport function isPlainObject(value: unknown): value is Record<PropertyKey, unknown> {\n  if (value === null || typeof value !== \"object\") {\n    return false\n  }\n\n  return Object.getPrototypeOf(value) === null || Object.getPrototypeOf(value) === Object.prototype\n}\n","import { validateSync as validateSchemaSync } from \"../schema/schema.shared\"\nimport { isPlainObject } from \"../shared/is-plain-object\"\nimport type { AdtVariant } from \"./adt.types\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Check if a value is an AdtVariant created by variant().\n * AdtVariants are callable functions with static properties.\n */\nexport function isVariant(value: unknown): value is AdtVariant {\n  return typeof value === \"function\" && \"_variant\" in value && value[\"_variant\"] === true\n}\n\n/**\n * Validate data using a Standard Schema, enforcing sync-only validation.\n * Throws if the schema returns a Promise.\n */\nexport function validateSync<T>(schema: StandardSchemaV1<unknown, T>, data: unknown, _tag: string) {\n  return validateSchemaSync(schema, data, `ADT variant \"${_tag}\"`)\n}\n\n/**\n * Create a type guard function for a specific _tag.\n */\nexport function createIsGuard<Tag extends string, T>(\n  _tag: Tag,\n): (value: unknown) => value is T & { readonly _tag: Tag } {\n  return (value: unknown): value is T & { readonly _tag: Tag } => {\n    return isPlainObject(value) && \"_tag\" in value && value[\"_tag\"] === _tag\n  }\n}\n\n/**\n * Create a type guard function for multiple _tags (AdtUnion root guard).\n */\nexport function createIsAnyGuard<T>(_tags: readonly string[]): (value: unknown) => value is T {\n  const _tagSet = new Set(_tags)\n  return (value: unknown): value is T => {\n    return isPlainObject(value) && \"_tag\" in value && typeof value[\"_tag\"] === \"string\" && _tagSet.has(value[\"_tag\"])\n  }\n}\n","import { ok, err } from \"../result/result\"\nimport type { Result } from \"../result/result.types\"\nimport type { ValidationError } from \"../schema/schema.types\"\nimport type { Discriminator } from \"../shared/discriminator.types\"\nimport type {\n  AdtCodecConstraint,\n  AdtCodecDef,\n  AdtCodecError,\n  AdtInferInput,\n  AdtInferOutput,\n  ToMethods,\n  FromMethods,\n} from \"./adt.types\"\nimport { validateSync } from \"./adt.utils\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Create a AdtCodecError with consistent structure.\n */\nfunction createCodecError(\n  kind: AdtCodecError[\"kind\"],\n  message: string,\n  cause?: unknown,\n  validationIssues?: ValidationError[\"issues\"],\n): AdtCodecError {\n  if (cause !== undefined && validationIssues !== undefined) {\n    return { kind, message, cause, validationIssues }\n  }\n  if (cause !== undefined) {\n    return { kind, message, cause }\n  }\n  if (validationIssues !== undefined) {\n    return { kind, message, validationIssues }\n  }\n  return { kind, message }\n}\n\n/**\n * Built-in JSON codec that works with any schema.\n * Encodes to JSON string and decodes with JSON.parse.\n */\nfunction createJsonCodec<Tag extends string, S extends StandardSchemaV1>(\n  _tag: Tag,\n): AdtCodecDef<AdtInferOutput<S> & Discriminator<Tag>, string, AdtInferInput<S>> {\n  return {\n    to: (value) => {\n      // JSON.stringify can throw for circular references, BigInt, etc.\n      // We let it throw and catch it in the wrapper\n      return JSON.stringify(value)\n    },\n    /* oxlint-disable no-unsafe-assignment, no-unsafe-type-assertion, no-unsafe-return -- Required for JSON parsing which returns unknown types */\n    from: (input: string) => {\n      try {\n        const parsed = JSON.parse(input)\n        // Return parsed object without _tag - it will be added during validation\n        if (typeof parsed === \"object\" && parsed !== null && \"_tag\" in parsed) {\n          const { _tag: _, ...rest } = parsed\n          return rest as AdtInferInput<S>\n        }\n        return parsed\n      } catch {\n        return null\n      }\n    },\n    /* oxlint-enable no-unsafe-assignment, no-unsafe-type-assertion, no-unsafe-return */\n  }\n}\n\n/**\n * Create the \"to\" methods object with JSON codec and custom codecs.\n * All methods return Result<T, AdtCodecError> for consistent error handling.\n */\nexport function createToMethods<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends AdtCodecConstraint<Tag, S> | undefined = undefined,\n>(_tag: Tag, schema: S, customCodecs?: Codecs): ToMethods<S, Codecs> {\n  type Output = AdtInferOutput<S> & Discriminator<Tag>\n\n  const jsonCodec = createJsonCodec<Tag, S>(_tag)\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const to: Record<string, (value: AdtInferInput<S>) => Result<any, AdtCodecError>> = {\n    json: (value: AdtInferInput<S>): Result<string, AdtCodecError> => {\n      // First, create a validated variant to ensure the encoded payload is well-typed.\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading generic input into object\n      const taggedInput = { ...(value as object), _tag }\n      const result = validateSync(schema, taggedInput, _tag)\n\n      if (result._tag === \"Err\") {\n        return err(\n          createCodecError(\n            \"ValidationError\",\n            `Cannot encode invalid data: ${result.error.issues.map((i) => i.message).join(\", \")}`,\n            undefined,\n            result.error.issues,\n          ),\n        )\n      }\n\n      try {\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for validated value cast\n        return ok(jsonCodec.to(result.value as Output))\n      } catch (e) {\n        return err(\n          createCodecError(\"EncodingError\", `JSON encoding failed: ${e instanceof Error ? e.message : String(e)}`, e),\n        )\n      }\n    },\n  }\n\n  // Add custom codecs\n  if (customCodecs) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    for (const [name, codec] of Object.entries(customCodecs) as Array<[string, AdtCodecDef<Output, any, any>]>) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      to[name] = (value: AdtInferInput<S>): Result<any, AdtCodecError> => {\n        // Validate input first\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading generic input\n        const taggedInput = { ...(value as object), _tag }\n        const result = validateSync(schema, taggedInput, _tag)\n\n        if (result._tag === \"Err\") {\n          return err(\n            createCodecError(\n              \"ValidationError\",\n              `Cannot encode invalid data: ${result.error.issues.map((i) => i.message).join(\", \")}`,\n              undefined,\n              result.error.issues,\n            ),\n          )\n        }\n\n        try {\n          // oxlint-disable-next-line no-unsafe-type-assertion -- Required for validated value cast\n          return ok(codec.to(result.value as Output))\n        } catch (e) {\n          return err(\n            createCodecError(\n              \"EncodingError\",\n              `Encoding with codec '${name}' failed: ${e instanceof Error ? e.message : String(e)}`,\n              e,\n            ),\n          )\n        }\n      }\n    }\n  }\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic return type\n  return to as ToMethods<S, Codecs>\n}\n\n/**\n * Create the \"from\" methods object with JSON codec and custom codecs.\n * All methods return Result<T, AdtCodecError> for consistent error handling.\n */\nexport function createFromMethods<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends AdtCodecConstraint<Tag, S> | undefined = undefined,\n>(_tag: Tag, schema: S, customCodecs?: Codecs): FromMethods<Tag, S, Codecs> {\n  type Output = AdtInferOutput<S> & Discriminator<Tag>\n\n  const jsonCodec = createJsonCodec<Tag, S>(_tag)\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const from: Record<string, (input: any) => Result<Output, AdtCodecError>> = {\n    json: (input: string): Result<Output, AdtCodecError> => {\n      // Decode\n      const decoded = jsonCodec.from(input)\n      if (decoded === null) {\n        return err(createCodecError(\"DecodingError\", \"Invalid JSON format\"))\n      }\n\n      // Validate through schema\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading decoded value\n      const taggedInput = { ...(decoded as object), _tag }\n      const result = validateSync(schema, taggedInput, _tag)\n\n      if (result._tag === \"Err\") {\n        return err(\n          createCodecError(\"ValidationError\", \"Decoded data failed schema validation\", undefined, result.error.issues),\n        )\n      }\n\n      // Ensure _tag in output\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for output construction\n      const output = { ...(result.value as object), _tag } as Output\n      return ok(output)\n    },\n  }\n\n  // Add custom codecs\n  if (customCodecs) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    for (const [name, codec] of Object.entries(customCodecs) as Array<[string, AdtCodecDef<Output, any, any>]>) {\n      from[name] = (input: unknown): Result<Output, AdtCodecError> => {\n        // Decode\n        let decoded: unknown\n        try {\n          decoded = codec.from(input)\n        } catch (e) {\n          return err(createCodecError(\"DecodingError\", `Decoding with codec '${name}' threw an error`, e))\n        }\n\n        if (decoded === null) {\n          return err(createCodecError(\"DecodingError\", `Codec '${name}' failed to decode input`))\n        }\n\n        // Validate through schema\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading decoded value\n        const taggedInput = { ...(decoded as object), _tag }\n        const result = validateSync(schema, taggedInput, _tag)\n\n        if (result._tag === \"Err\") {\n          return err(\n            createCodecError(\n              \"ValidationError\",\n              \"Decoded data failed schema validation\",\n              undefined,\n              result.error.issues,\n            ),\n          )\n        }\n\n        // Ensure _tag in output\n        // oxlint-disable-next-line no-unsafe-type-assertion -- Required for output construction\n        const output = { ...(result.value as object), _tag } as Output\n        return ok(output)\n      }\n    }\n  }\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic return type\n  return from as FromMethods<Tag, S, Codecs>\n}\n","import { createEqualsMethod, createHashMethod } from \"../equality/equality\"\nimport { ok, err } from \"../result/result\"\nimport type { Result } from \"../result/result.types\"\nimport type { ValidationError } from \"../schema/schema.types\"\nimport type { Discriminator } from \"../shared/discriminator.types\"\nimport { createToMethods, createFromMethods } from \"./adt.codec\"\nimport type { AdtCodecConstraint, AdtInferInput, AdtInferOutput, AdtVariant } from \"./adt.types\"\nimport { createIsGuard, validateSync } from \"./adt.utils\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Create a standalone tagged variant from a Standard Schema with optional codecs.\n *\n * Variants can be used independently or composed into an AdtUnion via union().\n * All defaults should be defined at the schema level (e.g., Zod's .default()).\n *\n * @template Tag - The string literal type for the _tag discriminator\n * @template S - The Standard Schema type for validation\n * @template Codecs - Optional codec definitions for custom serialization formats\n * @param _tag - The _tag discriminator value\n * @param schema - A Standard Schema compliant validator\n * @param codecs - Optional codec definitions for custom serialization formats\n * @returns A callable AdtVariant with is(), to, and from methods\n *\n * @see {@link union} for composing variants into discriminated unions\n * @see {@link tagged} for unvalidated tagged value constructors\n *\n * @example\n * ```ts\n * const CircleSchema = z.object({\n *   radius: z.number().positive(),\n *   color: z.string().default('blue')\n * })\n *\n * // Basic variant with JSON codec (always included)\n * const Circle = variant('Circle', CircleSchema)\n *\n * const result = Circle({ radius: 10 })\n * // { _tag: \"Ok\", value: { _tag: \"Circle\", radius: 10, color: \"blue\" } }\n *\n * Circle.is(someValue) // type guard\n *\n * const json = Circle.to.json({ radius: 10 }) // JSON string\n * const result2 = Circle.from.json(json) // Result<Circle, AdtCodecError>\n *\n * // Variant with custom codec\n * const Circle2 = variant('Circle', CircleSchema, {\n *   graphic: {\n *     to: (circle) => `(${circle.radius})`,\n *     from: (input: string) => {\n *       const match = input.match(/^\\((\\d+)\\)$/)\n *       return match ? { radius: parseInt(match[1]!) } : null\n *     }\n *   }\n * })\n *\n * const graphic = Circle2.to.graphic({ radius: 10 }) // \"(10)\"\n * const result3 = Circle2.from.graphic(\"(10)\") // Result<Circle, AdtCodecError>\n * ```\n */\n// Overload: with codecs\nexport function variant<Tag extends string, S extends StandardSchemaV1, Codecs extends AdtCodecConstraint<Tag, S>>(\n  _tag: Tag,\n  schema: S,\n  codecs: Codecs,\n): AdtVariant<Tag, S, Codecs>\n\n// Overload: without codecs\nexport function variant<Tag extends string, S extends StandardSchemaV1>(_tag: Tag, schema: S): AdtVariant<Tag, S>\n\n// Implementation\nexport function variant<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends AdtCodecConstraint<Tag, S> | undefined,\n>(_tag: Tag, schema: S, codecs?: Codecs): AdtVariant<Tag, S, Codecs> {\n  type Output = AdtInferOutput<S> & Discriminator<Tag>\n\n  const isGuard = createIsGuard<Tag, Output>(_tag)\n  const to = createToMethods(_tag, schema, codecs)\n  const from = createFromMethods(_tag, schema, codecs)\n  const equals = createEqualsMethod<Tag, AdtInferOutput<S>>(_tag)\n  const hash = createHashMethod<Tag, AdtInferOutput<S>>(_tag)\n\n  // Constructor function\n  const constructor = (input: AdtInferInput<S>): Result<Output, ValidationError> => {\n    // Add _tag to the input before validation\n    // oxlint-disable-next-line no-unsafe-type-assertion -- Required for spreading generic input\n    const taggedInput = { ...(input as object), _tag }\n\n    // Validate using the schema\n    const result = validateSync(schema, taggedInput, _tag)\n\n    if (result._tag === \"Err\") {\n      return err(result.error)\n    }\n\n    // Ensure _tag is in the output (schema might strip unknown keys)\n    // oxlint-disable-next-line no-unsafe-type-assertion -- Required for output construction\n    const output = { ...(result.value as object), _tag } as Output\n    return ok(output)\n  }\n\n  // Attach static properties to constructor function\n  constructor._variant = true as const\n  constructor._tag = _tag\n  constructor.schema = schema\n  if (codecs) {\n    // oxlint-disable-next-line no-unsafe-type-assertion -- Conditional assignment of codecs\n    ;(constructor as { codecs?: Codecs }).codecs = codecs\n  }\n  constructor.is = isGuard\n  constructor.to = to\n  constructor.from = from\n  constructor.equals = equals\n  constructor.hash = hash\n\n  return constructor as AdtVariant<Tag, S, Codecs>\n}\n","import { createADTEqualsMethod, createADTHashMethod } from \"../equality/equality\"\nimport type { AdtUnion, AdtVariantDef, AdtVariant } from \"./adt.types\"\nimport { createIsAnyGuard, isVariant } from \"./adt.utils\"\nimport { variant } from \"./adt.variant\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Compose records or schemas into a discriminated union (AdtUnion).\n *\n * Accepts either:\n * - Pre-built AdtVariants from variant() (codecs are preserved)\n * - Raw Standard Schema validators (will be wrapped internally)\n *\n * When using pre-built records, the object key overrides the original _tag.\n *\n * @template R - Record of variant names to AdtVariants or StandardSchema validators\n * @param name - The name of this AdtUnion (for identification)\n * @param records - An object mapping _tag names to AdtVariants or schemas\n * @returns An AdtUnion object with accessors for each variant\n *\n * @see {@link variant} for creating individual variant types\n * @see {@link match} for exhaustive pattern matching on AdtUnion values\n *\n * @example\n * ```ts\n * // From pre-built variants\n * const Circle = variant('Circle', CircleSchema)\n * const Square = variant('Square', SquareSchema)\n * const Shape = union('Shape', { Circle, Square })\n *\n * // From raw schemas (JSON codec is automatically included)\n * const Shape = union('Shape', {\n *   Circle: CircleSchema,\n *   Square: SquareSchema\n * })\n *\n * // JSON codec works on all variants\n * Shape.Circle.to.json({ radius: 10 })\n * Shape.Circle.from.json(jsonString)\n *\n * // Mixed\n * const Shape = union('Shape', {\n *   Circle,              // Pre-built variant\n *   Square: SquareSchema // Raw schema\n * })\n *\n * // Usage\n * Shape.Circle({ radius: 10 })\n * Shape.is(someValue)        // type guard for any variant\n * Shape.Circle.is(someValue) // type guard for Circle\n * ```\n */\nexport function union<R extends Record<string, AdtVariantDef>>(name: string, records: R): AdtUnion<R> {\n  const tags = Object.keys(records)\n  const variants: Record<string, AdtVariant> = {}\n\n  for (const [_tag, def] of Object.entries(records)) {\n    if (isVariant(def)) {\n      // Pre-built AdtVariant - key overrides original _tag\n      if (def._tag === _tag) {\n        // _tag matches key, use as-is (preserves codecs)\n        variants[_tag] = def\n        // oxlint-disable-next-line strict-boolean-expressions -- codecs can be undefined\n      } else if (def.codecs) {\n        // _tag differs from key - create new variant with key as _tag\n        // Preserve codecs\n        variants[_tag] = variant(_tag, def.schema, def.codecs)\n      } else {\n        // _tag differs from key and no codecs\n        variants[_tag] = variant(_tag, def.schema)\n      }\n    } else {\n      // Raw schema - wrap in variant\n      // Note: Even without custom codecs, this still gets JSON codec!\n      // oxlint-disable-next-line no-unsafe-type-assertion -- def is a StandardSchemaV1 in this branch\n      variants[_tag] = variant(_tag, def as StandardSchemaV1)\n    }\n  }\n\n  // Create the root type guard for any variant\n  const isAnyVariant = createIsAnyGuard(tags)\n  const equals = createADTEqualsMethod(tags)\n  const hash = createADTHashMethod(tags)\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic AdtUnion return type\n  return {\n    _name: name,\n    is: isAnyVariant,\n    equals,\n    hash,\n    ...variants,\n  } as AdtUnion<R>\n}\n","/**\n * Tagged union builders and match helpers.\n *\n * **Mental model**\n * - `Adt` helps build discriminated unions with runtime validation.\n * - Use `union`, `variant`, and `match` to model algebraic data types.\n *\n * **Common tasks**\n * - Define variants with `Adt.variant`.\n * - Combine variants with `Adt.union`.\n * - Pattern-match with `Adt.match`.\n *\n * **Gotchas**\n * - `Adt` codec/type helpers are mostly type-level.\n * - Prefer namespace imports from `@nicolastoulemont/std`.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const CircleSchema = z.object({ radius: z.number() })\n *\n * const Shape = Adt.union(\"Shape\", { Circle: CircleSchema })\n * const result = Shape.Circle({ radius: 2 })\n * // => { _tag: \"Ok\", value: { _tag: \"Circle\", radius: 2 } }\n * ```\n *\n * @module\n */\nimport { match as matchImpl } from \"./adt.match\"\nimport type {\n  AdtInfer as AdtInferType,\n  AdtVariantNames as AdtVariantNamesType,\n  AdtVariantOf as AdtVariantOfType,\n} from \"./adt.types\"\nimport { union as unionImpl } from \"./adt.union\"\nimport { variant as variantImpl } from \"./adt.variant\"\n\n/**\n * Re-exported ADT inferred union helper.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const Shape = Adt.union(\"Shape\", {\n *   Circle: z.object({ radius: z.number() }),\n * })\n * type Shape = Adt.Infer<typeof Shape>\n * ```\n */\nexport type Infer<T> = AdtInferType<T>\n\n/**\n * Re-exported union variant name helper.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const Shape = Adt.union(\"Shape\", {\n *   Circle: z.object({ radius: z.number() }),\n * })\n * type Names = Adt.VariantNames<typeof Shape>\n * ```\n */\nexport type VariantNames<T> = AdtVariantNamesType<T>\n\n/**\n * Re-exported helper to extract a specific variant from an ADT.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const Shape = Adt.union(\"Shape\", {\n *   Circle: z.object({ radius: z.number() }),\n * })\n * type Circle = Adt.VariantOf<typeof Shape, \"Circle\">\n * ```\n */\nexport type VariantOf<T, K extends string> = AdtVariantOfType<T, K>\n\n/**\n * Build an ADT union from named variants.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const CircleSchema = z.object({ radius: z.number() })\n *\n * const Shape = Adt.union(\"Shape\", { Circle: CircleSchema })\n * const result = Shape.Circle({ radius: 2 })\n * // => { _tag: \"Ok\", value: { _tag: \"Circle\", radius: 2 } }\n * ```\n */\nexport const union = unionImpl\n\n/**\n * Define one ADT variant with schema-backed validation.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n * import { z } from \"zod\"\n *\n * // Adt accepts any Standard Schema-compatible schema, such as zod, valibot, or arktype.\n * const CircleSchema = z.object({ radius: z.number() })\n *\n * const Circle = Adt.variant(\"Circle\", CircleSchema)\n * const result = Circle({ radius: 2 })\n * // => { _tag: \"Ok\", value: { _tag: \"Circle\", radius: 2 } }\n * ```\n */\nexport const variant = variantImpl\n\n/**\n * Match over ADT variants by discriminator tag.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n *\n * const label = Adt.match({ _tag: \"Circle\", radius: 2 } as const, {\n *   Circle: (circle) => `r=${circle.radius}` ,\n * })\n * // => \"r=2\"\n * ```\n */\nexport const match = matchImpl\n"],"mappings":"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"}

package/dist/data/index.d.mts

@@ -1,2 +1,2 @@
-import { t as data_d_exports } from "../index-UINIHFuh.mjs";
+import { t as data_d_exports } from "../index-B2Z7-XGR.mjs";
 export { data_d_exports as Data };

package/dist/data-BHYPdqWZ.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"data-BHYPdqWZ.mjs","names":["array","struct","tagged","TaggedError","tuple","taggedImpl","TaggedErrorImpl","structImpl","tupleImpl","arrayImpl"],"sources":["../src/data/data.array.ts","../src/data/data.struct.ts","../src/data/data.tagged.ts","../src/data/data.tagged-error.ts","../src/data/data.tuple.ts","../src/data/data.ts"],"sourcesContent":["import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { ArrayValue } from \"./data.types\"\n\n/**\n * Create an array with structural equality.\n *\n * The returned array is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * The map() and filter() methods are overridden to return ArrayValue,\n * enabling method chaining with preserved equality semantics.\n *\n * @template T - The element type of the array\n * @param items - The array elements\n * @returns A frozen array with equals(), hash(), map(), and filter()\n *\n * @see {@link tuple} for fixed-length typed tuples\n * @see {@link struct} for object value types\n *\n * @example\n * ```ts\n * const arr1 = array([1, 2, 3])\n * const arr2 = array([1, 2, 3])\n *\n * arr1.equals(arr2) // true\n * arr1.hash() // number\n *\n * // Chainable operations return ArrayValue\n * arr1.map(x => x * 2) // ArrayValue<number>\n * arr1.filter(x => x > 1) // ArrayValue<number>\n *\n * // Chained equality check\n * arr1.map(x => x * 2).equals(array([2, 4, 6])) // true\n *\n * // Array is frozen\n * arr1[0] = 5 // TypeError\n * arr1.push(4) // TypeError\n * ```\n */\nexport function array<T>(items: readonly T[]): ArrayValue<T> {\n  const value = [...items]\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: readonly T[]) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override map to return ArrayValue\n  const originalMap = value.map.bind(value)\n  Object.defineProperty(value, \"map\", {\n    value: <U>(fn: (item: T, index: number, arr: readonly T[]) => U): ArrayValue<U> => {\n      return array(originalMap(fn))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override filter to return ArrayValue\n  const originalFilter = value.filter.bind(value)\n  Object.defineProperty(value, \"filter\", {\n    value: (fn: (item: T, index: number, arr: readonly T[]) => boolean): ArrayValue<T> => {\n      return array(originalFilter(fn))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override slice to return ArrayValue\n  const originalSlice = value.slice.bind(value)\n  Object.defineProperty(value, \"slice\", {\n    value: (start?: number, end?: number): ArrayValue<T> => {\n      return array(originalSlice(start, end))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override concat to return ArrayValue\n  const originalConcat = value.concat.bind(value)\n  Object.defineProperty(value, \"concat\", {\n    value: (...args: readonly (T | readonly T[])[]): ArrayValue<T> => {\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for concat argument spread\n      return array(originalConcat(...(args as T[][])))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic array return type\n  return Object.freeze(value) as unknown as ArrayValue<T>\n}\n","import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { StructValue } from \"./data.types\"\n\n/**\n * Create a frozen value object with structural equality.\n *\n * Unlike tagged(), struct() does not add a _tag discriminator.\n * Use this for simple value objects that don't need discrimination.\n *\n * The returned object is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * @template T - The object shape type\n * @param input - The object to wrap\n * @returns A frozen object with equals() and hash() methods\n *\n * @see {@link tagged} for discriminated value objects with _tag\n * @see {@link array} for array value types\n *\n * @example\n * ```ts\n * const point = struct({ x: 10, y: 20 })\n * const point2 = struct({ x: 10, y: 20 })\n *\n * point.equals(point2) // true\n * point.hash() // number\n *\n * // Object is frozen\n * point.x = 5 // TypeError\n *\n * // equals/hash are non-enumerable\n * Object.keys(point) // [\"x\", \"y\"]\n * ```\n */\nexport function struct<T extends Record<string, unknown>>(input: T): StructValue<T> {\n  const value = { ...input }\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: T) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic struct return type\n  return Object.freeze(value) as StructValue<T>\n}\n","import { createEqualsMethod, createHashMethod } from \"../equality/equality\"\nimport type { Discriminator } from \"../shared/discriminator.types\"\nimport type { TaggedConstructor, TaggedValue } from \"./data.types\"\n\n/**\n * Create a tagged value constructor without schema validation.\n *\n * Unlike variant(), this creates values directly without validation.\n * Values are frozen and have structural equality via equals() and hash() methods.\n *\n * @template T - The data shape type (excluding _tag)\n * @param tag - The _tag discriminator value\n * @returns A constructor function with is(), equals(), and hash() methods\n *\n * @see {@link variant} for validated variant with schema support\n * @see {@link struct} for untagged value objects\n *\n * @example\n * ```ts\n * const Person = tagged<{ name: string; age: number }>(\"Person\")\n *\n * const alice = Person({ name: \"Alice\", age: 30 })\n * // => { _tag: \"Person\", name: \"Alice\", age: 30 }\n *\n * Person.equals(alice, Person({ name: \"Alice\", age: 30 })) // true\n * Person.is(alice) // true\n *\n * // Type guard usage\n * if (Person.is(unknownValue)) {\n *   console.log(unknownValue.name) // TypeScript knows it's a Person\n * }\n *\n * // Values are frozen (immutable)\n * alice.name = \"Bob\" // TypeError\n * ```\n */\nexport function tagged<T extends Record<string, unknown>>(tag: string): TaggedConstructor<typeof tag, T> {\n  type Output = TaggedValue<typeof tag, T>\n\n  // Constructor function\n  const constructor = (input: T): Output => {\n    return Object.freeze({ ...input, _tag: tag }) as Output\n  }\n\n  // Type guard\n  constructor.is = (value: unknown): value is Output => {\n    return (\n      typeof value === \"object\" &&\n      value !== null &&\n      \"_tag\" in value &&\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Already checked with 'in' operator\n      (value as Discriminator)._tag === tag\n    )\n  }\n\n  // Equality (static method on constructor)\n  constructor.equals = createEqualsMethod<typeof tag, T>(tag)\n\n  // Hashing (static method on constructor)\n  constructor.hash = createHashMethod<typeof tag, T>(tag)\n\n  // Store tag for reflection\n  constructor._tag = tag\n\n  return constructor as TaggedConstructor<typeof tag, T>\n}\n","import { FxTypeId } from \"../fx/fx.types\"\nimport type { TaggedErrorFactory } from \"./data.tagged-error.types\"\n\n/* oxlint-disable no-unsafe-type-assertion -- Tagged error factories intentionally cast to preserve ergonomic constructor signatures and Fx marker channels. */\n\n/**\n * Create a class-based tagged error type (Effect-style syntax).\n * Returns a class that can be extended to create custom error types.\n * Errors are native Error objects with proper stack traces and instanceof support.\n * Implements Yieldable protocol so errors can be directly yielded in Fx.gen computations.\n *\n * @template Tag - The error tag (discriminator string)\n * @param tag - The error tag\n * @returns A class that can be extended with custom data\n *\n * @example\n * ```ts\n * // Error with data\n * class NotFoundError extends TaggedError(\"NotFoundError\")<{ id: string }> {}\n * const err = new NotFoundError({ id: \"123\" })\n * err.id // \"123\"\n * err._tag // \"NotFoundError\"\n * err.stack // Error stack trace\n *\n * // Error without data\n * class UnauthorizedError extends TaggedError(\"UnauthorizedError\") {}\n * const err2 = new UnauthorizedError()\n *\n * // Direct yielding in Fx.gen computation\n * const program = Fx.gen(function* () {\n *   yield* new NotFoundError({ id: \"123\" })  // Short-circuits with error\n * })\n *\n * // instanceof checks work\n * if (err instanceof NotFoundError) {\n *   console.log(err.id)\n * }\n * ```\n */\nexport function TaggedError<Tag extends string>(tag: Tag): TaggedErrorFactory<Tag> {\n  return class TaggedErrorImpl<Data extends object = object> extends Error {\n    static readonly _tag: Tag = tag\n    readonly _tag: Tag = tag\n\n    readonly [FxTypeId] = {\n      _A: () => undefined as never,\n      _E: () => this as TaggedErrorImpl<Data>,\n      _R: () => undefined as never,\n    }\n\n    constructor(...args: keyof Data extends never ? [] : [data: Data]) {\n      super(tag)\n      this.name = tag\n      const data = args[0]\n      if (data) Object.assign(this, data)\n      Object.setPrototypeOf(this, new.target.prototype)\n    }\n\n    *[Symbol.iterator](): Generator<this, never, unknown> {\n      yield this\n      throw new Error(\"Unreachable: Fx.gen should short-circuit on error\")\n    }\n  } as unknown as TaggedErrorFactory<Tag>\n}\n\n/* oxlint-enable no-unsafe-type-assertion */\n","import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { TupleValue } from \"./data.types\"\n\n/**\n * Create a tuple with structural equality.\n *\n * The returned tuple is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * @template T - The tuple type as a readonly array of element types\n * @param args - The tuple elements\n * @returns A frozen tuple-like array with equals() and hash() methods\n *\n * @see {@link array} for variable-length arrays with equality\n * @see {@link struct} for object value types\n *\n * @example\n * ```ts\n * const t1 = tuple(1, \"hello\", true)\n * const t2 = tuple(1, \"hello\", true)\n *\n * t1.equals(t2) // true\n * t1.hash() // number\n *\n * // Access elements (typed)\n * t1[0] // number\n * t1[1] // string\n * t1[2] // boolean\n *\n * // Tuple is frozen\n * t1[0] = 5 // TypeError\n * ```\n */\nexport function tuple<T extends readonly unknown[]>(...args: T): TupleValue<T> {\n  const value = [...args]\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: readonly unknown[]) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic tuple return type\n  return Object.freeze(value) as unknown as TupleValue<T>\n}\n","/**\n * Structural data constructors for tagged objects, tuples, arrays, and records.\n *\n * **Mental model**\n * - `Data` helpers create immutable-friendly values with structural equality semantics.\n * - Use `tagged` and `TaggedError` to model domain objects and errors.\n *\n * **Common tasks**\n * - Build tagged records via `Data.tagged`.\n * - Define typed tagged errors with `Data.TaggedError`.\n * - Create structural containers with `Data.struct`, `Data.tuple`, and `Data.array`.\n *\n * **Gotchas**\n * - These constructors are value-level utilities, not validation schemas.\n * - Prefer explicit tagged names for debugging and pattern matching.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const User = Data.tagged<{ id: string }>(\"User\")\n * const user = User({ id: \"u1\" })\n * // => { _tag: \"User\", id: \"u1\" }\n * ```\n *\n * @module\n */\nimport { array as arrayImpl } from \"./data.array\"\nimport { struct as structImpl } from \"./data.struct\"\nimport { tagged as taggedImpl } from \"./data.tagged\"\nimport { TaggedError as TaggedErrorImpl } from \"./data.tagged-error\"\nexport type { TaggedErrorClass, TaggedErrorFactory, TaggedErrorInstance } from \"./data.tagged-error.types\"\nimport { tuple as tupleImpl } from \"./data.tuple\"\n\n/**\n * Construct tagged data objects.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const User = Data.tagged<{ id: string }>(\"User\")\n * const user = User({ id: \"u1\" })\n * // => { _tag: \"User\", id: \"u1\" }\n * ```\n */\nexport const tagged = taggedImpl\n\n/**\n * Construct tagged error classes.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * class NotFoundError extends Data.TaggedError(\"NotFoundError\")<{ id: string }> {}\n * const error = new NotFoundError({ id: \"u1\" })\n * // => { _tag: \"NotFoundError\", id: \"u1\" }\n * ```\n */\nexport const TaggedError = TaggedErrorImpl\n\n/**\n * Construct immutable-like structs with stable structural behavior.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const point = Data.struct({ x: 1, y: 2 })\n * const same = point.equals({ x: 1, y: 2 })\n * // => true\n * ```\n */\nexport const struct = structImpl\n\n/**\n * Construct immutable-like tuples with stable structural behavior.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const pair = Data.tuple(\"left\", 1)\n * const first = pair[0]\n * // => \"left\"\n * ```\n */\nexport const tuple = tupleImpl\n\n/**\n * Construct immutable-like arrays with stable structural behavior.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const ids = Data.array([\"a\", \"b\"])\n * const upper = ids.map((id) => id.toUpperCase())\n * // => [\"A\", \"B\"]\n * ```\n */\nexport const array = arrayImpl\n"],"mappings":"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"}
+{"version":3,"file":"data-BHYPdqWZ.mjs","names":["array","struct","tagged","TaggedError","tuple","taggedImpl","TaggedErrorImpl","structImpl","tupleImpl","arrayImpl"],"sources":["../src/data/data.array.ts","../src/data/data.struct.ts","../src/data/data.tagged.ts","../src/data/data.tagged-error.ts","../src/data/data.tuple.ts","../src/data/data.ts"],"sourcesContent":["import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { ArrayValue } from \"./data.types\"\n\n/**\n * Create an array with structural equality.\n *\n * The returned array is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * The map() and filter() methods are overridden to return ArrayValue,\n * enabling method chaining with preserved equality semantics.\n *\n * @template T - The element type of the array\n * @param items - The array elements\n * @returns A frozen array with equals(), hash(), map(), and filter()\n *\n * @see {@link tuple} for fixed-length typed tuples\n * @see {@link struct} for object value types\n *\n * @example\n * ```ts\n * const arr1 = array([1, 2, 3])\n * const arr2 = array([1, 2, 3])\n *\n * arr1.equals(arr2) // true\n * arr1.hash() // number\n *\n * // Chainable operations return ArrayValue\n * arr1.map(x => x * 2) // ArrayValue<number>\n * arr1.filter(x => x > 1) // ArrayValue<number>\n *\n * // Chained equality check\n * arr1.map(x => x * 2).equals(array([2, 4, 6])) // true\n *\n * // Array is frozen\n * arr1[0] = 5 // TypeError\n * arr1.push(4) // TypeError\n * ```\n */\nexport function array<T>(items: readonly T[]): ArrayValue<T> {\n  const value = [...items]\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: readonly T[]) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override map to return ArrayValue\n  const originalMap = value.map.bind(value)\n  Object.defineProperty(value, \"map\", {\n    value: <U>(fn: (item: T, index: number, arr: readonly T[]) => U): ArrayValue<U> => {\n      return array(originalMap(fn))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override filter to return ArrayValue\n  const originalFilter = value.filter.bind(value)\n  Object.defineProperty(value, \"filter\", {\n    value: (fn: (item: T, index: number, arr: readonly T[]) => boolean): ArrayValue<T> => {\n      return array(originalFilter(fn))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override slice to return ArrayValue\n  const originalSlice = value.slice.bind(value)\n  Object.defineProperty(value, \"slice\", {\n    value: (start?: number, end?: number): ArrayValue<T> => {\n      return array(originalSlice(start, end))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Override concat to return ArrayValue\n  const originalConcat = value.concat.bind(value)\n  Object.defineProperty(value, \"concat\", {\n    value: (...args: readonly (T | readonly T[])[]): ArrayValue<T> => {\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for concat argument spread\n      return array(originalConcat(...(args as T[][])))\n    },\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic array return type\n  return Object.freeze(value) as unknown as ArrayValue<T>\n}\n","import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { StructValue } from \"./data.types\"\n\n/**\n * Create a frozen value object with structural equality.\n *\n * Unlike tagged(), struct() does not add a _tag discriminator.\n * Use this for simple value objects that don't need discrimination.\n *\n * The returned object is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * @template T - The object shape type\n * @param input - The object to wrap\n * @returns A frozen object with equals() and hash() methods\n *\n * @see {@link tagged} for discriminated value objects with _tag\n * @see {@link array} for array value types\n *\n * @example\n * ```ts\n * const point = struct({ x: 10, y: 20 })\n * const point2 = struct({ x: 10, y: 20 })\n *\n * point.equals(point2) // true\n * point.hash() // number\n *\n * // Object is frozen\n * point.x = 5 // TypeError\n *\n * // equals/hash are non-enumerable\n * Object.keys(point) // [\"x\", \"y\"]\n * ```\n */\nexport function struct<T extends Record<string, unknown>>(input: T): StructValue<T> {\n  const value = { ...input }\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: T) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic struct return type\n  return Object.freeze(value) as StructValue<T>\n}\n","import { createEqualsMethod, createHashMethod } from \"../equality/equality\"\nimport type { Discriminator } from \"../shared/discriminator.types\"\nimport type { TaggedConstructor, TaggedValue } from \"./data.types\"\n\n/**\n * Create a tagged value constructor without schema validation.\n *\n * Unlike variant(), this creates values directly without validation.\n * Values are frozen and have structural equality via equals() and hash() methods.\n *\n * @template T - The data shape type (excluding _tag)\n * @param tag - The _tag discriminator value\n * @returns A constructor function with is(), equals(), and hash() methods\n *\n * @see {@link variant} for validated variant with schema support\n * @see {@link struct} for untagged value objects\n *\n * @example\n * ```ts\n * const Person = tagged<{ name: string; age: number }>(\"Person\")\n *\n * const alice = Person({ name: \"Alice\", age: 30 })\n * // => { _tag: \"Person\", name: \"Alice\", age: 30 }\n *\n * Person.equals(alice, Person({ name: \"Alice\", age: 30 })) // true\n * Person.is(alice) // true\n *\n * // Type guard usage\n * if (Person.is(unknownValue)) {\n *   console.log(unknownValue.name) // TypeScript knows it's a Person\n * }\n *\n * // Values are frozen (immutable)\n * alice.name = \"Bob\" // TypeError\n * ```\n */\nexport function tagged<T extends Record<string, unknown>>(tag: string): TaggedConstructor<typeof tag, T> {\n  type Output = TaggedValue<typeof tag, T>\n\n  // Constructor function\n  const constructor = (input: T): Output => {\n    return Object.freeze({ ...input, _tag: tag }) as Output\n  }\n\n  // Type guard\n  constructor.is = (value: unknown): value is Output => {\n    return (\n      typeof value === \"object\" &&\n      value !== null &&\n      \"_tag\" in value &&\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Already checked with 'in' operator\n      (value as Discriminator)._tag === tag\n    )\n  }\n\n  // Equality (static method on constructor)\n  constructor.equals = createEqualsMethod<typeof tag, T>(tag)\n\n  // Hashing (static method on constructor)\n  constructor.hash = createHashMethod<typeof tag, T>(tag)\n\n  // Store tag for reflection\n  constructor._tag = tag\n\n  return constructor as TaggedConstructor<typeof tag, T>\n}\n","import { FxTypeId } from \"../fx/fx.types\"\nimport type { TaggedErrorFactory } from \"./data.tagged-error.types\"\n\n/* oxlint-disable no-unsafe-type-assertion -- Tagged error factories intentionally cast to preserve ergonomic constructor signatures and Fx marker channels. */\n\n/**\n * Create a class-based tagged error type (Effect-style syntax).\n * Returns a class that can be extended to create custom error types.\n * Errors are native Error objects with proper stack traces and instanceof support.\n * Implements Yieldable protocol so errors can be directly yielded in Fx.gen computations.\n *\n * @template Tag - The error tag (discriminator string)\n * @param tag - The error tag\n * @returns A class that can be extended with custom data\n *\n * @example\n * ```ts\n * // Error with data\n * class NotFoundError extends TaggedError(\"NotFoundError\")<{ id: string }> {}\n * const err = new NotFoundError({ id: \"123\" })\n * err.id // \"123\"\n * err._tag // \"NotFoundError\"\n * err.stack // Error stack trace\n *\n * // Error without data\n * class UnauthorizedError extends TaggedError(\"UnauthorizedError\") {}\n * const err2 = new UnauthorizedError()\n *\n * // Direct yielding in Fx.gen computation\n * const program = Fx.gen(function* () {\n *   yield* new NotFoundError({ id: \"123\" })  // Short-circuits with error\n * })\n *\n * // instanceof checks work\n * if (err instanceof NotFoundError) {\n *   console.log(err.id)\n * }\n * ```\n */\nexport function TaggedError<Tag extends string>(tag: Tag): TaggedErrorFactory<Tag> {\n  return class TaggedErrorImpl<Data extends object = object> extends Error {\n    static readonly _tag: Tag = tag\n    readonly _tag: Tag = tag\n\n    readonly [FxTypeId] = {\n      _A: () => undefined as never,\n      _E: () => this as TaggedErrorImpl<Data>,\n      _R: () => undefined as never,\n    }\n\n    constructor(...args: keyof Data extends never ? [] : [data: Data]) {\n      super(tag)\n      this.name = tag\n      const data = args[0]\n      if (data) Object.assign(this, data)\n      Object.setPrototypeOf(this, new.target.prototype)\n    }\n\n    *[Symbol.iterator](): Generator<this, never, unknown> {\n      yield this\n      throw new Error(\"Unreachable: Fx.gen should short-circuit on error\")\n    }\n  } as unknown as TaggedErrorFactory<Tag>\n}\n\n/* oxlint-enable no-unsafe-type-assertion */\n","import { deepEquals, deepHash } from \"../equality/equality\"\nimport type { TupleValue } from \"./data.types\"\n\n/**\n * Create a tuple with structural equality.\n *\n * The returned tuple is frozen (immutable) and has non-enumerable\n * equals() and hash() methods for structural comparison.\n *\n * @template T - The tuple type as a readonly array of element types\n * @param args - The tuple elements\n * @returns A frozen tuple-like array with equals() and hash() methods\n *\n * @see {@link array} for variable-length arrays with equality\n * @see {@link struct} for object value types\n *\n * @example\n * ```ts\n * const t1 = tuple(1, \"hello\", true)\n * const t2 = tuple(1, \"hello\", true)\n *\n * t1.equals(t2) // true\n * t1.hash() // number\n *\n * // Access elements (typed)\n * t1[0] // number\n * t1[1] // string\n * t1[2] // boolean\n *\n * // Tuple is frozen\n * t1[0] = 5 // TypeError\n * ```\n */\nexport function tuple<T extends readonly unknown[]>(...args: T): TupleValue<T> {\n  const value = [...args]\n\n  // Add equals method (non-enumerable)\n  Object.defineProperty(value, \"equals\", {\n    value: (other: readonly unknown[]) => deepEquals(value, other),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // Add hash method (non-enumerable)\n  Object.defineProperty(value, \"hash\", {\n    value: () => deepHash(value),\n    enumerable: false,\n    writable: false,\n    configurable: false,\n  })\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for generic tuple return type\n  return Object.freeze(value) as unknown as TupleValue<T>\n}\n","/**\n * Structural data constructors for tagged objects, tuples, arrays, and records.\n *\n * **Mental model**\n * - `Data` helpers create immutable-friendly values with structural equality semantics.\n * - Use `tagged` and `TaggedError` to model domain objects and errors.\n *\n * **Common tasks**\n * - Build tagged records via `Data.tagged`.\n * - Define typed tagged errors with `Data.TaggedError`.\n * - Create structural containers with `Data.struct`, `Data.tuple`, and `Data.array`.\n *\n * **Gotchas**\n * - These constructors are value-level utilities, not validation schemas.\n * - Prefer explicit tagged names for debugging and pattern matching.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const User = Data.tagged<{ id: string }>(\"User\")\n * const user = User({ id: \"u1\" })\n * // => { _tag: \"User\", id: \"u1\" }\n * ```\n *\n * @module\n */\nimport { array as arrayImpl } from \"./data.array\"\nimport { struct as structImpl } from \"./data.struct\"\nimport { tagged as taggedImpl } from \"./data.tagged\"\nimport { TaggedError as TaggedErrorImpl } from \"./data.tagged-error\"\nexport type { TaggedErrorClass, TaggedErrorCore, TaggedErrorFactory, TaggedErrorInstance } from \"./data.tagged-error.types\"\nimport { tuple as tupleImpl } from \"./data.tuple\"\n\n/**\n * Construct tagged data objects.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const User = Data.tagged<{ id: string }>(\"User\")\n * const user = User({ id: \"u1\" })\n * // => { _tag: \"User\", id: \"u1\" }\n * ```\n */\nexport const tagged = taggedImpl\n\n/**\n * Construct tagged error classes.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * class NotFoundError extends Data.TaggedError(\"NotFoundError\")<{ id: string }> {}\n * const error = new NotFoundError({ id: \"u1\" })\n * // => { _tag: \"NotFoundError\", id: \"u1\" }\n * ```\n */\nexport const TaggedError = TaggedErrorImpl\n\n/**\n * Construct immutable-like structs with stable structural behavior.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const point = Data.struct({ x: 1, y: 2 })\n * const same = point.equals({ x: 1, y: 2 })\n * // => true\n * ```\n */\nexport const struct = structImpl\n\n/**\n * Construct immutable-like tuples with stable structural behavior.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const pair = Data.tuple(\"left\", 1)\n * const first = pair[0]\n * // => \"left\"\n * ```\n */\nexport const tuple = tupleImpl\n\n/**\n * Construct immutable-like arrays with stable structural behavior.\n *\n * @example\n * ```ts\n * import { Data } from \"@nicolastoulemont/std\"\n *\n * const ids = Data.array([\"a\", \"b\"])\n * const upper = ids.map((id) => id.toUpperCase())\n * // => [\"A\", \"B\"]\n * ```\n */\nexport const array = arrayImpl\n"],"mappings":"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"}

package/dist/duration/index.d.mts

@@ -1,2 +1,2 @@
-import { r as duration_d_exports } from "../index-BsPOcZk9.mjs";
+import { r as duration_d_exports } from "../index-DCUGtEcj.mjs";
 export { duration_d_exports as Duration };

package/dist/fx/index.d.mts

@@ -1,2 +1,2 @@
-import { t as fx_d_exports } from "../index-MsJqfQu0.mjs";
+import { t as fx_d_exports } from "../index-C4DOLLaU.mjs";
 export { fx_d_exports as Fx };

package/dist/{index-Ctqe1fD1.d.mts → index-B0flvtFB.d.mts}

@@ -1,4 +1,4 @@
-import { n as TaggedErrorFactory } from "./index-UINIHFuh.mjs";
+import { n as TaggedErrorFactory } from "./index-B2Z7-XGR.mjs";
 import { i as QueueOptions, n as Queue, r as QueueBoundedOptions } from "./queue.types-B-l5XYbU.mjs";
 
 //#region src/queue/queue.d.ts
@@ -104,4 +104,4 @@ declare const bounded: (maxSize: number, options?: QueueBoundedOptions) => Queue
 declare const unbounded: (options?: QueueOptions) => Queue;
 //#endregion
 export { queue_d_exports as t };
-//# sourceMappingURL=index-Ctqe1fD1.d.mts.map
+//# sourceMappingURL=index-B0flvtFB.d.mts.map

package/dist/{index-Ctqe1fD1.d.mts.map → index-B0flvtFB.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-Ctqe1fD1.d.mts","names":[],"sources":["../src/queue/queue.ts"],"sourcesContent":[],"mappings":";;;;;;;cAsCsB,uBAAA;;;;;;;;;;;;cAcT,gBAAA,SAAyB;;;cAA0E,wBAAA;;;;;;;;;;;;cAYnG,iBAAA,SAA0B;;;cAA8D,4BAAA;;;;;;;;;;;;cAYxF,qBAAA,SAA8B;;;;;;;;;;;;;;;cAoG9B,iCAAgC;;;;;;;;;;;;;cAoWhC,iBAAkB,iBAAe;;;;;;;;;;;;;cAcjC,qCAAsC,wBAAsB;;;;;;;;;;;;;cAc5D,sBAAuB,iBAAe"}
+{"version":3,"file":"index-B0flvtFB.d.mts","names":[],"sources":["../src/queue/queue.ts"],"sourcesContent":[],"mappings":";;;;;;;cAsCsB,uBAAA;;;;;;;;;;;;cAcT,gBAAA,SAAyB;;;cAA0E,wBAAA;;;;;;;;;;;;cAYnG,iBAAA,SAA0B;;;cAA8D,4BAAA;;;;;;;;;;;;cAYxF,qBAAA,SAA8B;;;;;;;;;;;;;;;cAoG9B,iCAAgC;;;;;;;;;;;;;cAoWhC,iBAAkB,iBAAe;;;;;;;;;;;;;cAcjC,qCAAsC,wBAAsB;;;;;;;;;;;;;cAc5D,sBAAuB,iBAAe"}

package/dist/{index-UINIHFuh.d.mts → index-B2Z7-XGR.d.mts}

@@ -289,7 +289,7 @@ declare function TaggedError$1<Tag extends string>(tag: Tag): TaggedErrorFactory
  */
 declare function tuple$1<T extends readonly unknown[]>(...args: T): TupleValue<T>;
 declare namespace data_d_exports {
-  export { TaggedError, TaggedErrorClass, TaggedErrorFactory, TaggedErrorInstance, array, struct, tagged, tuple };
+  export { TaggedError, TaggedErrorClass, TaggedErrorCore, TaggedErrorFactory, TaggedErrorInstance, array, struct, tagged, tuple };
 }
 /**
  * Construct tagged data objects.
@@ -358,4 +358,4 @@ declare const tuple: typeof tuple$1;
 declare const array: typeof array$1;
 //#endregion
 export { TaggedErrorFactory as n, data_d_exports as t };
-//# sourceMappingURL=index-UINIHFuh.d.mts.map
+//# sourceMappingURL=index-B2Z7-XGR.d.mts.map

package/dist/{index-UINIHFuh.d.mts.map → index-B2Z7-XGR.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-UINIHFuh.d.mts","names":[],"sources":["../src/data/data.types.ts","../src/data/data.array.ts","../src/data/data.struct.ts","../src/data/data.tagged.ts","../src/data/data.tagged-error.types.ts","../src/data/data.tagged-error.ts","../src/data/data.tuple.ts","../src/data/data.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index-B2Z7-XGR.d.mts","names":[],"sources":["../src/data/data.types.ts","../src/data/data.array.ts","../src/data/data.struct.ts","../src/data/data.tagged.ts","../src/data/data.tagged-error.types.ts","../src/data/data.tagged-error.ts","../src/data/data.tuple.ts","../src/data/data.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index-B41_sFR6.d.mts

@@ -0,0 +1,64 @@
+import { t as Result } from "./result.types-BKzChyWY.mjs";
+import { a as RefinementSchema, c as ValidationError, i as Refine, l as ValidationIssue, n as Input, o as SyncRefinementSchema, r as Output, s as SyncSchema, t as Infer } from "./schema.types-E1pjcc0Y.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/schema/schema.d.ts
+declare namespace schema_d_exports {
+  export { Infer, Input, Is, Output, Refine, RefineFn, RefinementSchema, SyncRefinementSchema, SyncSchema, ValidationError, ValidationIssue, is, parse, refine };
+}
+/**
+ * Create a schema-backed parser.
+ *
+ * For sync schemas the returned parser is sync.
+ * For general Standard Schema values the returned parser is async.
+ */
+declare function parse<S extends SyncSchema>(schema: S): (value: Input<S>) => Result<Output<S>, ValidationError>;
+declare function parse<S extends StandardSchemaV1>(schema: S): (value: Input<S>) => Promise<Result<Output<S>, ValidationError>>;
+type RefineFn = {
+  <S extends SyncSchema, Base extends Input<S>>(value: Base, schema: S): value is Refine<Base, S>;
+  <S extends SyncSchema>(schema: S): <Base extends Input<S>>(value: Base) => value is Refine<Base, S>;
+};
+type Is = {
+  <Base, Sub extends Base>(value: Base, schema: SyncRefinementSchema<Base, Sub>): value is Sub;
+  <S extends SyncSchema>(value: unknown, schema: S): value is Output<S>;
+  <Base, Sub extends Base>(schema: SyncRefinementSchema<Base, Sub>): (value: Base) => value is Sub;
+  <S extends SyncSchema>(schema: S): (value: unknown) => value is Output<S>;
+};
+/**
+ * Create a sync-only schema-backed reusable type guard that preserves the original value shape.
+ *
+ * Use this when a schema validates only a subset of a broader in-memory value
+ * and you need the preserved shape to survive higher-order APIs like
+ * `Array.filter`. The narrowed type is `Base & Output<typeof schema>`, not the
+ * exact schema output.
+ *
+ * Supports both data-first and data-last styles:
+ * - Data-first: `Schema.refine(value, schema)`
+ * - Data-last: `Schema.refine(schema)(value)`
+ *
+ * Only use this with sync proof schemas that validate properties already
+ * present on the original value. Transforms, defaults, and coercions are not
+ * safe here because they can change the schema output without changing the
+ * original input value.
+ */
+declare function refine<S extends SyncSchema, Base extends Input<S>>(value: Base, schema: S): value is Refine<Base, S>;
+declare function refine<S extends SyncSchema>(schema: S): <Base extends Input<S>>(value: Base) => value is Refine<Base, S>;
+/**
+ * Create a sync-only schema-backed proof guard.
+ *
+ * On `unknown` values this narrows to the exact schema output. On already-typed
+ * values, TypeScript preserves the current shape during direct control-flow
+ * checks. Use `Schema.refine` when that preserved shape must survive
+ * higher-order APIs like `Array.filter`.
+ *
+ * Supports both data-first and data-last styles:
+ * - Data-first: `Schema.is(value, schema)`
+ * - Data-last: `Schema.is(schema)(value)`
+ */
+declare function is<Base, Sub extends Base>(value: Base, schema: SyncRefinementSchema<Base, Sub>): value is Sub;
+declare function is<S extends SyncSchema>(value: unknown, schema: S): value is Output<S>;
+declare function is<Base, Sub extends Base>(schema: SyncRefinementSchema<Base, Sub>): (value: Base) => value is Sub;
+declare function is<S extends SyncSchema>(schema: S): (value: unknown) => value is Output<S>;
+//#endregion
+export { schema_d_exports as t };
+//# sourceMappingURL=index-B41_sFR6.d.mts.map

package/dist/index-B41_sFR6.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-B41_sFR6.d.mts","names":[],"sources":["../src/schema/schema.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;iBA0DgB,gBAAgB,oBAAoB,YAAY,MAAM,OAAO,OAAW,OAAO,IAAI;iBACnF,gBAAgB,0BACtB,YACC,MAAM,OAAO,QAAQ,OAAW,OAAO,IAAI;KAoB1C,QAAA;aACC,yBAAyB,MAAM,WAAW,cAAc,aAAa,OAAQ,MAAM;aACnF,oBAAoB,kBAAkB,MAAM,WAAW,kBAAkB,OAAQ,MAAM;;KAGxF,EAAA;qBACS,aAAa,cAAc,qBAAqB,MAAM,gBAAgB;aAC9E,oCAAoC,aAAa,OAAO;qBAChD,cAAc,qBAAqB,MAAM,eAAe,kBAAkB;aAClF,oBAAoB,iCAAiC,OAAO;;AAhCzE;;;;;;;;;;AACA;;;;;;;AAEsD,iBAsDtC,MAtDsC,CAAA,UAsDrB,UAtDqB,EAAA,aAsDI,KAtDJ,CAsDU,CAtDV,CAAA,CAAA,CAAA,KAAA,EAsDqB,IAtDrB,EAAA,MAAA,EAsDmC,CAtDnC,CAAA,EAAA,KAAA,IAsDgD,MAtDhD,CAsDwD,IAtDxD,EAsD8D,CAtD9D,CAAA;AAAtB,iBAuDhB,MAvDgB,CAAA,UAuDC,UAvDD,CAAA,CAAA,MAAA,EAuDqB,CAvDrB,CAAA,EAAA,CAAA,aAuDuC,KAvDvC,CAuD6C,CAvD7C,CAAA,CAAA,CAAA,KAAA,EAuDwD,IAvDxD,EAAA,GAAA,KAAA,IAuD0E,MAvD1E,CAuDkF,IAvDlF,EAuDwF,CAvDxF,CAAA;;;AAoBhC;;;;;;;;;;AAEiC,iBAsDjB,EAtDiB,CAAA,IAAA,EAAA,YAsDI,IAtDJ,CAAA,CAAA,KAAA,EAsDiB,IAtDjB,EAAA,MAAA,EAsD+B,oBAtD/B,CAsDoD,IAtDpD,EAsD0D,GAtD1D,CAAA,CAAA,EAAA,KAAA,IAsD0E,GAtD1E;AAAwB,iBAuDzC,EAvDyC,CAAA,UAuD5B,UAvD4B,CAAA,CAAA,KAAA,EAAA,OAAA,EAAA,MAAA,EAuDQ,CAvDR,CAAA,EAAA,KAAA,IAuDqB,MAvDrB,CAuD4B,CAvD5B,CAAA;AAAN,iBAwDnC,EAxDmC,CAAA,IAAA,EAAA,YAwDd,IAxDc,CAAA,CAAA,MAAA,EAwDA,oBAxDA,CAwDqB,IAxDrB,EAwD2B,GAxD3B,CAAA,CAAA,EAAA,CAAA,KAAA,EAwD0C,IAxD1C,EAAA,GAAA,KAAA,IAwD4D,GAxD5D;AAAiB,iBAyDpD,EAzDoD,CAAA,UAyDvC,UAzDuC,CAAA,CAAA,MAAA,EAyDnB,CAzDmB,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,KAAA,IAyDc,MAzDd,CAyDqB,CAzDrB,CAAA"}

package/dist/{index-MsJqfQu0.d.mts → index-C4DOLLaU.d.mts}

@@ -2,7 +2,7 @@ import { a as FxError, c as FxTypeId, d as FxYieldable, f as RunnableFx, h as is
 import { a as ResultFromTry, m as Ok, p as Err, t as Result } from "./result.types-BKzChyWY.mjs";
 import { r as Option } from "./option.types-D9hrKcfa.mjs";
 import { t as Concurrency } from "./queue.types-B-l5XYbU.mjs";
-import { n as SyncRetrySchedule, t as RetrySchedule } from "./schedule-B9K_2Z21.mjs";
+import { n as SyncRetrySchedule, t as RetrySchedule } from "./schedule-D2651VJY.mjs";
 
 //#region src/fx/exit.d.ts
 /**
@@ -455,4 +455,4 @@ declare const match: {
 };
 //#endregion
 export { fx_d_exports as t };
-//# sourceMappingURL=index-MsJqfQu0.d.mts.map
+//# sourceMappingURL=index-C4DOLLaU.d.mts.map

package/dist/{index-MsJqfQu0.d.mts.map → index-C4DOLLaU.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-MsJqfQu0.d.mts","names":[],"sources":["../src/fx/exit.ts","../src/fx/fx.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index-C4DOLLaU.d.mts","names":[],"sources":["../src/fx/exit.ts","../src/fx/fx.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/{index-DfQGXBQI.d.mts → index-C6W3_n_Q.d.mts}

@@ -1,5 +1,5 @@
 import { h as Prettify, t as Result } from "./result.types-BKzChyWY.mjs";
-import { o as ValidationError } from "./schema.types-CFzzx4bw.mjs";
+import { c as ValidationError } from "./schema.types-E1pjcc0Y.mjs";
 import { t as Discriminator } from "./discriminator.types-C-ygT2S1.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
@@ -455,4 +455,4 @@ declare const variant: typeof variant$1;
 declare const match: typeof match$1;
 //#endregion
 export { adt_d_exports as t };
-//# sourceMappingURL=index-DfQGXBQI.d.mts.map
+//# sourceMappingURL=index-C6W3_n_Q.d.mts.map

package/dist/{index-DfQGXBQI.d.mts.map → index-C6W3_n_Q.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-DfQGXBQI.d.mts","names":[],"sources":["../src/adt/adt.match.ts","../src/adt/adt.types.ts","../src/adt/adt.union.ts","../src/adt/adt.variant.ts","../src/adt/adt.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index-C6W3_n_Q.d.mts","names":[],"sources":["../src/adt/adt.match.ts","../src/adt/adt.types.ts","../src/adt/adt.union.ts","../src/adt/adt.variant.ts","../src/adt/adt.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index-D8rDE60Y.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index-D8rDE60Y.d.mts","names":[],"sources":["../src/order/order.types.ts","../src/order/order.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index-D8rDE60Y.d.mts","names":[],"sources":["../src/order/order.types.ts","../src/order/order.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/{index-BsPOcZk9.d.mts → index-DCUGtEcj.d.mts}

@@ -1,5 +1,5 @@
 import { n as Branded } from "./brand.types-B3NDX1vo.mjs";
-import { n as TaggedErrorFactory } from "./index-UINIHFuh.mjs";
+import { n as TaggedErrorFactory } from "./index-B2Z7-XGR.mjs";
 import { t as Result } from "./index-CIvNgjsx.mjs";
 
 //#region src/duration/duration.d.ts
@@ -93,4 +93,4 @@ declare const parse: (input: string) => Result<Duration, DurationParseError>;
 declare const from: (input: Input) => Result<Duration, InputError>;
 //#endregion
 export { InputError as n, duration_d_exports as r, Input as t };
-//# sourceMappingURL=index-BsPOcZk9.d.mts.map
+//# sourceMappingURL=index-DCUGtEcj.d.mts.map

package/dist/{index-BsPOcZk9.d.mts.map → index-DCUGtEcj.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-BsPOcZk9.d.mts","names":[],"sources":["../src/duration/duration.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;KA4BY,QAAA,GAAW;;;;KAKX,IAAA;;;;KAiBA,WAAA,gBAA2B;;;;KAK3B,KAAA,GAAQ,oBAAoB;cAAW,yBAAA;;;;cAKtC,kBAAA,SAA2B;;;AAhCxC,CAAA,CAAA,CAAA;AAsBA,cAaK,8BAbsC,EAatC,kBAbsC,CAAA,2BAAA,CAAA;AAK3C;AAAmD;AAKnD;AAGK,cAKQ,yBAAA,SAAkC,8BAL1C,CAAA;EAKQ,KAAA,EAAA,MAAA;EAGR,OAAA,EAAA,MAAA;AAKL,CAAA,CAAA,CAAA;cALK,8BAQK,EARL,kBAQK,CAAA,2BAAA,CAAA;;;;AAME,cATC,yBAAA,SAAkC,8BASJ,CAAA;EAK/B,KAAA,EAbH,KAaG;EAAa,OAAA,EAAA,MAAA;EAA4B,KAAA,CAAA,EAX3C,kBAW2C,GAXtB,yBAWsB;CAAqB,CAAA,CAAA;AAwB1E;AAKA;AAKA;AAKa,KA5CD,UAAA,GAAa,kBA4CkD;AAK3E;AAKA;AAKA;AAiCa,KAvFD,UAAA,GAAa,yBAkHxB,GAlHoD,kBAkHpD,GAlHyE,yBAkHzE;;;;AA3BkD,cA/DtC,MA+DsC,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GA/DZ,QA+DY;AAgCnD;;;AAA4D,cA1F/C,OA0F+C,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GA1FpB,QA0FoB;;;;cArF/C,4BAA2B;;;;cAK3B,0BAAyB;;;;cAKzB,yBAAwB;;;;cAKxB,0BAAyB;;;;cAKzB,qBAAsB;;;;cAiCtB,0BAAyB,OAAc,UAAU;;;;cAgCjD,cAAe,UAAQ,OAAc,UAAU"}
+{"version":3,"file":"index-DCUGtEcj.d.mts","names":[],"sources":["../src/duration/duration.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;KA4BY,QAAA,GAAW;;;;KAKX,IAAA;;;;KAiBA,WAAA,gBAA2B;;;;KAK3B,KAAA,GAAQ,oBAAoB;cAAW,yBAAA;;;;cAKtC,kBAAA,SAA2B;;;AAhCxC,CAAA,CAAA,CAAA;AAsBA,cAaK,8BAbsC,EAatC,kBAbsC,CAAA,2BAAA,CAAA;AAK3C;AAAmD;AAKnD;AAGK,cAKQ,yBAAA,SAAkC,8BAL1C,CAAA;EAKQ,KAAA,EAAA,MAAA;EAGR,OAAA,EAAA,MAAA;AAKL,CAAA,CAAA,CAAA;cALK,8BAQK,EARL,kBAQK,CAAA,2BAAA,CAAA;;;;AAME,cATC,yBAAA,SAAkC,8BASJ,CAAA;EAK/B,KAAA,EAbH,KAaG;EAAa,OAAA,EAAA,MAAA;EAA4B,KAAA,CAAA,EAX3C,kBAW2C,GAXtB,yBAWsB;CAAqB,CAAA,CAAA;AAwB1E;AAKA;AAKA;AAKa,KA5CD,UAAA,GAAa,kBA4CkD;AAK3E;AAKA;AAKA;AAiCa,KAvFD,UAAA,GAAa,yBAkHxB,GAlHoD,kBAkHpD,GAlHyE,yBAkHzE;;;;AA3BkD,cA/DtC,MA+DsC,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GA/DZ,QA+DY;AAgCnD;;;AAA4D,cA1F/C,OA0F+C,EAAA,CAAA,KAAA,EAAA,MAAA,EAAA,GA1FpB,QA0FoB;;;;cArF/C,4BAA2B;;;;cAK3B,0BAAyB;;;;cAKzB,yBAAwB;;;;cAKxB,0BAAyB;;;;cAKzB,qBAAsB;;;;cAiCtB,0BAAyB,OAAc,UAAU;;;;cAgCjD,cAAe,UAAQ,OAAc,UAAU"}

package/dist/index.d.mts

@@ -1,15 +1,15 @@
-import { t as adt_d_exports } from "./index-DfQGXBQI.mjs";
+import { t as adt_d_exports } from "./index-C6W3_n_Q.mjs";
 import { t as brand_d_exports } from "./index-BA0EsFxS.mjs";
 import { n as service_d_exports } from "./service-D8mr0wwg.mjs";
 import { n as context_d_exports } from "./context-B2dWloPl.mjs";
 import "./context/index.mjs";
-import { t as data_d_exports } from "./index-UINIHFuh.mjs";
+import { t as data_d_exports } from "./index-B2Z7-XGR.mjs";
 import { n as result_d_exports } from "./index-CIvNgjsx.mjs";
-import { r as duration_d_exports } from "./index-BsPOcZk9.mjs";
+import { r as duration_d_exports } from "./index-DCUGtEcj.mjs";
 import { t as either_d_exports } from "./index-dCRymj_g.mjs";
 import { n as flow, t as pipe } from "./index-D7mFNjot.mjs";
-import { r as schedule_d_exports } from "./schedule-B9K_2Z21.mjs";
-import { t as fx_d_exports } from "./index-MsJqfQu0.mjs";
+import { r as schedule_d_exports } from "./schedule-D2651VJY.mjs";
+import { t as fx_d_exports } from "./index-C4DOLLaU.mjs";
 import { r as scope_d_exports } from "./scope-CuM3CzwG.mjs";
 import { t as layer_d_exports } from "./index-uE3S3Krx.mjs";
 import { t as multithread_d_exports } from "./index-DR7hzXU4.mjs";
@@ -17,9 +17,9 @@ import { t as option_d_exports } from "./index-BqJ1GWAF.mjs";
 import { t as order_d_exports } from "./index-D8rDE60Y.mjs";
 import { t as predicate_d_exports } from "./index-CNTYbcY9.mjs";
 import { t as provide_d_exports } from "./index-crtzMG48.mjs";
-import { t as queue_d_exports } from "./index-Ctqe1fD1.mjs";
+import { t as queue_d_exports } from "./index-B0flvtFB.mjs";
 import "./schedule/index.mjs";
-import { t as schema_d_exports } from "./index-Ctg7XUOs.mjs";
+import { t as schema_d_exports } from "./index-B41_sFR6.mjs";
 import "./scope/index.mjs";
 import "./service/index.mjs";
 export { adt_d_exports as Adt, brand_d_exports as Brand, context_d_exports as Context, data_d_exports as Data, duration_d_exports as Duration, either_d_exports as Either, fx_d_exports as Fx, layer_d_exports as Layer, multithread_d_exports as Multithread, option_d_exports as Option, order_d_exports as Order, predicate_d_exports as Predicate, provide_d_exports as Provide, queue_d_exports as Queue, result_d_exports as Result, schedule_d_exports as Schedule, schema_d_exports as Schema, scope_d_exports as Scope, service_d_exports as Service, flow, pipe };

package/dist/index.mjs

@@ -1 +1 @@
-import{t as e}from"./adt-CzdkjlUM.mjs";import{t}from"./flow-CNyLsPGb.mjs";import{a as n}from"./result-D3VY0qBG.mjs";import{t as r}from"./brand-DZgGDrAe.mjs";import{t as i}from"./context-0xDbwtpx.mjs";import"./context/index.mjs";import{n as a}from"./data-BHYPdqWZ.mjs";import{t as o}from"./duration-CYoDHcOR.mjs";import{r as s}from"./option-C2iCxAuJ.mjs";import{t as c}from"./either-G7uOu4Ar.mjs";import{t as l}from"./functions-ByAk682_.mjs";import{a as u}from"./queue-apiEOlRD.mjs";import{t as d}from"./fx-DUXDxwsU.mjs";import{t as f}from"./layer-CKtH7TRL.mjs";import{t as p}from"./multithread-Cyc8Bz45.mjs";import{t as m}from"./order-BXOBEKvB.mjs";import{t as h}from"./predicate-D_1SsIi4.mjs";import{n as g}from"./scope-gVt4PESc.mjs";import{t as _}from"./provide--yZE8x-n.mjs";import"./queue/index.mjs";import{t as v}from"./schedule-C6iN3oMt.mjs";import{t as y}from"./schema-D87TVF_b.mjs";import"./scope/index.mjs";import{t as b}from"./service-CWAIEH46.mjs";export{e as Adt,r as Brand,i as Context,a as Data,o as Duration,c as Either,d as Fx,f as Layer,p as Multithread,s as Option,m as Order,h as Predicate,_ as Provide,u as Queue,n as Result,v as Schedule,y as Schema,g as Scope,b as Service,t as flow,l as pipe};
+import{t as e}from"./adt-CPG_sa8q.mjs";import{t}from"./flow-CNyLsPGb.mjs";import{a as n}from"./result-D3VY0qBG.mjs";import{t as r}from"./brand-DZgGDrAe.mjs";import{t as i}from"./context-0xDbwtpx.mjs";import"./context/index.mjs";import{n as a}from"./data-BHYPdqWZ.mjs";import{t as o}from"./duration-CYoDHcOR.mjs";import{r as s}from"./option-C2iCxAuJ.mjs";import{t as c}from"./either-G7uOu4Ar.mjs";import{t as l}from"./functions-ByAk682_.mjs";import{a as u}from"./queue-apiEOlRD.mjs";import{t as d}from"./fx-DUXDxwsU.mjs";import{t as f}from"./layer-CKtH7TRL.mjs";import{t as p}from"./multithread-Cyc8Bz45.mjs";import{t as m}from"./order-BXOBEKvB.mjs";import{t as h}from"./predicate-D_1SsIi4.mjs";import{n as g}from"./scope-gVt4PESc.mjs";import{t as _}from"./provide--yZE8x-n.mjs";import"./queue/index.mjs";import{t as v}from"./schedule-C6iN3oMt.mjs";import{t as y}from"./schema-DstB1_VK.mjs";import"./scope/index.mjs";import{t as b}from"./service-CWAIEH46.mjs";export{e as Adt,r as Brand,i as Context,a as Data,o as Duration,c as Either,d as Fx,f as Layer,p as Multithread,s as Option,m as Order,h as Predicate,_ as Provide,u as Queue,n as Result,v as Schedule,y as Schema,g as Scope,b as Service,t as flow,l as pipe};

package/dist/queue/index.d.mts

@@ -1,2 +1,2 @@
-import { t as queue_d_exports } from "../index-Ctqe1fD1.mjs";
+import { t as queue_d_exports } from "../index-B0flvtFB.mjs";
 export { queue_d_exports as Queue };

package/dist/schedule/index.d.mts

@@ -1,2 +1,2 @@
-import { r as schedule_d_exports } from "../schedule-B9K_2Z21.mjs";
+import { r as schedule_d_exports } from "../schedule-D2651VJY.mjs";
 export { schedule_d_exports as Schedule };

package/dist/{schedule-B9K_2Z21.d.mts → schedule-D2651VJY.d.mts}

@@ -1,5 +1,5 @@
-import { n as TaggedErrorFactory } from "./index-UINIHFuh.mjs";
-import { n as InputError, t as Input } from "./index-BsPOcZk9.mjs";
+import { n as TaggedErrorFactory } from "./index-B2Z7-XGR.mjs";
+import { n as InputError, t as Input } from "./index-DCUGtEcj.mjs";
 
 //#region src/schedule/schedule.d.ts
 declare namespace schedule_d_exports {
@@ -180,4 +180,4 @@ declare const fixed: (options: FixedScheduleOptions) => AsyncRetrySchedule;
 declare const exponential: (options: ExponentialScheduleOptions) => AsyncRetrySchedule;
 //#endregion
 export { SyncRetrySchedule as n, schedule_d_exports as r, RetrySchedule as t };
-//# sourceMappingURL=schedule-B9K_2Z21.d.mts.map
+//# sourceMappingURL=schedule-D2651VJY.d.mts.map

package/dist/{schedule-B9K_2Z21.d.mts.map → schedule-D2651VJY.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"schedule-B9K_2Z21.d.mts","names":[],"sources":["../src/schedule/schedule.ts"],"sourcesContent":[],"mappings":";;;;;;;AAoPA;AAiBA;AAmBA;;;;;;;;;;;;KAzOY,aAAA,GAAgB,oBAAoB;;;;;;;;;;;KAYpC,iBAAA;;;;;;;;;;;;;;;;KAiBA,kBAAA;;;;;;cAKX,qCAAA;;;;;;;;;;;;;;;cAgBY,8BAAA,SAAuC;;;;cAG/C,gCAAA;;;;;;;;;;;;;;;;cAiBQ,yBAAA,SAAkC;;SAEtC;;UAEC;;cACL,iCAAA;;;;;;;;;;;;;;;cAgBQ,0BAAA,SAAmC;;;;KAK3C,oBAAA;;;;;;kBAMa;;KAGb,0BAAA;;;;;;sBAMiB;;;;;;;;;;sBAUA;;;;;;;;;;;;;;cA4ET,2BAA0B;;;;;;;;;;;;;cAiB1B,iBAAkB,yBAAuB;;;;;;;;;;;;;;cAmBzC,uBAAwB,+BAA6B"}
+{"version":3,"file":"schedule-D2651VJY.d.mts","names":[],"sources":["../src/schedule/schedule.ts"],"sourcesContent":[],"mappings":";;;;;;;AAoPA;AAiBA;AAmBA;;;;;;;;;;;;KAzOY,aAAA,GAAgB,oBAAoB;;;;;;;;;;;KAYpC,iBAAA;;;;;;;;;;;;;;;;KAiBA,kBAAA;;;;;;cAKX,qCAAA;;;;;;;;;;;;;;;cAgBY,8BAAA,SAAuC;;;;cAG/C,gCAAA;;;;;;;;;;;;;;;;cAiBQ,yBAAA,SAAkC;;SAEtC;;UAEC;;cACL,iCAAA;;;;;;;;;;;;;;;cAgBQ,0BAAA,SAAmC;;;;KAK3C,oBAAA;;;;;;kBAMa;;KAGb,0BAAA;;;;;;sBAMiB;;;;;;;;;;sBAUA;;;;;;;;;;;;;;cA4ET,2BAA0B;;;;;;;;;;;;;cAiB1B,iBAAkB,yBAAuB;;;;;;;;;;;;;;cAmBzC,uBAAwB,+BAA6B"}

package/dist/schema/index.d.mts

@@ -1,2 +1,2 @@
-import { t as schema_d_exports } from "../index-Ctg7XUOs.mjs";
+import { t as schema_d_exports } from "../index-B41_sFR6.mjs";
 export { schema_d_exports as Schema };

package/dist/schema/index.mjs

@@ -1 +1 @@
-import{t as e}from"../schema-D87TVF_b.mjs";export{e as Schema};
+import{t as e}from"../schema-DstB1_VK.mjs";export{e as Schema};

package/dist/schema-DstB1_VK.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"./chunk-oQKkju2G.mjs";import{t}from"./dual-fN6OUwN_.mjs";import{n}from"./flow-CNyLsPGb.mjs";import{t as r}from"./result-D3VY0qBG.mjs";import{n as i,r as a,t as o}from"./schema.shared-Bjyroa6b.mjs";var s=e({is:()=>f,parse:()=>c,refine:()=>u});function c(e){return t=>{try{let a=e[`~standard`].validate(t);return n(a)?Promise.resolve(a).then(e=>i(e),e=>r(o(e))):i(a)}catch(e){return r(o(e))}}}const l=t(2,(e,t)=>a(t,e,`Schema.refine()`)._tag===`Ok`);function u(...e){return l(...e)}const d=t(2,(e,t)=>a(t,e,`Schema.is()`)._tag===`Ok`);function f(...e){return d(...e)}export{s as t};
+//# sourceMappingURL=schema-DstB1_VK.mjs.map

package/dist/schema-DstB1_VK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-DstB1_VK.mjs","names":["Result.err"],"sources":["../src/schema/schema.ts"],"sourcesContent":["import { Result } from \"../result\"\nimport type { Result as ResultType } from \"../result/result.types\"\n/**\n * Standard Schema-backed parsing and refinement helpers.\n *\n * **Mental model**\n * - `Schema.parse` is for boundary validation and parsing.\n * - `Schema.is` is a sync-only proof guard for direct in-memory checks.\n * - `Schema.refine` is the reusable preserved-shape guard for higher-order APIs like `Array.filter`.\n *\n * **Common tasks**\n * - Parse loose external data into validated subtypes.\n * - Use `Schema.is` for direct control-flow checks against already-typed values.\n * - Reuse a schema as a preserved-shape predicate with `Schema.refine`.\n * - Name reusable narrowed types with `Schema.Refine<Base, typeof schema>` or exact schema outputs with `Schema.Infer<typeof schema>`.\n *\n * **Gotchas**\n * - `Schema.parse` may be sync or async based on the schema type you preserve.\n * - `Schema.refine` and `Schema.is` support both data-first and data-last styles.\n * - `Schema.refine` and `Schema.is` are sync-only.\n * - `Schema.is` and `Schema.refine` must only be used with proof schemas that validate the current value in place.\n * - Transforms, defaults, coercions, and other output-changing schemas should use `Schema.parse`.\n * - `Schema.is` narrows `unknown` to the exact schema output, but in direct control flow TypeScript preserves the current value shape.\n * - `Schema.refine` exists for the cases where you need that preserved shape to survive higher-order APIs like `Array.filter`.\n *\n * @module\n */\nimport { dual } from \"../shared/dual\"\nimport { isPromise } from \"../shared/is-promise\"\nimport { toThrownValidationError, toValidationResult, validateSync } from \"./schema.shared\"\nimport type {\n  Input,\n  Output,\n  Refine as Refined,\n  SyncRefinementSchema,\n  SyncSchema,\n  ValidationError,\n} from \"./schema.types\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\nexport type {\n  Infer,\n  Input,\n  Output,\n  Refine,\n  RefinementSchema,\n  SyncRefinementSchema,\n  SyncSchema,\n  ValidationError,\n  ValidationIssue,\n} from \"./schema.types\"\n\n/**\n * Create a schema-backed parser.\n *\n * For sync schemas the returned parser is sync.\n * For general Standard Schema values the returned parser is async.\n */\nexport function parse<S extends SyncSchema>(schema: S): (value: Input<S>) => ResultType<Output<S>, ValidationError>\nexport function parse<S extends StandardSchemaV1>(\n  schema: S,\n): (value: Input<S>) => Promise<ResultType<Output<S>, ValidationError>>\nexport function parse<S extends StandardSchemaV1>(schema: S) {\n  return (value: Input<S>) => {\n    try {\n      const result = schema[\"~standard\"].validate(value)\n\n      if (isPromise(result)) {\n        return Promise.resolve(result).then(\n          (validated) => toValidationResult(validated),\n          (error) => Result.err(toThrownValidationError(error)),\n        )\n      }\n\n      return toValidationResult(result)\n    } catch (error) {\n      return Result.err(toThrownValidationError(error))\n    }\n  }\n}\n\nexport type RefineFn = {\n  <S extends SyncSchema, Base extends Input<S>>(value: Base, schema: S): value is Refined<Base, S>\n  <S extends SyncSchema>(schema: S): <Base extends Input<S>>(value: Base) => value is Refined<Base, S>\n}\n\nexport type Is = {\n  <Base, Sub extends Base>(value: Base, schema: SyncRefinementSchema<Base, Sub>): value is Sub\n  <S extends SyncSchema>(value: unknown, schema: S): value is Output<S>\n  <Base, Sub extends Base>(schema: SyncRefinementSchema<Base, Sub>): (value: Base) => value is Sub\n  <S extends SyncSchema>(schema: S): (value: unknown) => value is Output<S>\n}\n\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- dual() requires a single implementation signature */\nconst refineImpl = dual(2, (value: unknown, schema: SyncSchema) => {\n  return validateSync(schema, value, \"Schema.refine()\")._tag === \"Ok\"\n}) as RefineFn\n\n/**\n * Create a sync-only schema-backed reusable type guard that preserves the original value shape.\n *\n * Use this when a schema validates only a subset of a broader in-memory value\n * and you need the preserved shape to survive higher-order APIs like\n * `Array.filter`. The narrowed type is `Base & Output<typeof schema>`, not the\n * exact schema output.\n *\n * Supports both data-first and data-last styles:\n * - Data-first: `Schema.refine(value, schema)`\n * - Data-last: `Schema.refine(schema)(value)`\n *\n * Only use this with sync proof schemas that validate properties already\n * present on the original value. Transforms, defaults, and coercions are not\n * safe here because they can change the schema output without changing the\n * original input value.\n */\nexport function refine<S extends SyncSchema, Base extends Input<S>>(value: Base, schema: S): value is Refined<Base, S>\nexport function refine<S extends SyncSchema>(schema: S): <Base extends Input<S>>(value: Base) => value is Refined<Base, S>\nexport function refine(...args: [value: unknown, schema: SyncSchema] | [schema: SyncSchema]) {\n  return (refineImpl as (...args: [unknown, SyncSchema] | [SyncSchema]) => boolean | ((value: unknown) => boolean))(...args)\n}\n\nconst isImpl = dual(2, (value: unknown, schema: SyncSchema) => {\n  return validateSync(schema, value, \"Schema.is()\")._tag === \"Ok\"\n}) as Is\n\n/**\n * Create a sync-only schema-backed proof guard.\n *\n * On `unknown` values this narrows to the exact schema output. On already-typed\n * values, TypeScript preserves the current shape during direct control-flow\n * checks. Use `Schema.refine` when that preserved shape must survive\n * higher-order APIs like `Array.filter`.\n *\n * Supports both data-first and data-last styles:\n * - Data-first: `Schema.is(value, schema)`\n * - Data-last: `Schema.is(schema)(value)`\n */\nexport function is<Base, Sub extends Base>(value: Base, schema: SyncRefinementSchema<Base, Sub>): value is Sub\nexport function is<S extends SyncSchema>(value: unknown, schema: S): value is Output<S>\nexport function is<Base, Sub extends Base>(schema: SyncRefinementSchema<Base, Sub>): (value: Base) => value is Sub\nexport function is<S extends SyncSchema>(schema: S): (value: unknown) => value is Output<S>\nexport function is(...args: [value: unknown, schema: SyncSchema] | [schema: SyncSchema]) {\n  return (isImpl as (...args: [unknown, SyncSchema] | [SyncSchema]) => boolean | ((value: unknown) => boolean))(...args)\n}\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n"],"mappings":"qQA8DA,SAAgB,EAAkC,EAAW,CAC3D,MAAQ,IAAoB,CAC1B,GAAI,CACF,IAAM,EAAS,EAAO,aAAa,SAAS,EAAM,CASlD,OAPI,EAAU,EAAO,CACZ,QAAQ,QAAQ,EAAO,CAAC,KAC5B,GAAc,EAAmB,EAAU,CAC3C,GAAUA,EAAW,EAAwB,EAAM,CAAC,CACtD,CAGI,EAAmB,EAAO,OAC1B,EAAO,CACd,OAAOA,EAAW,EAAwB,EAAM,CAAC,GAkBvD,MAAM,EAAa,EAAK,GAAI,EAAgB,IACnC,EAAa,EAAQ,EAAO,kBAAkB,CAAC,OAAS,KAC/D,CAqBF,SAAgB,EAAO,GAAG,EAAmE,CAC3F,OAAQ,EAA0G,GAAG,EAAK,CAG5H,MAAM,EAAS,EAAK,GAAI,EAAgB,IAC/B,EAAa,EAAQ,EAAO,cAAc,CAAC,OAAS,KAC3D,CAkBF,SAAgB,EAAG,GAAG,EAAmE,CACvF,OAAQ,EAAsG,GAAG,EAAK"}

package/dist/schema.shared-Bjyroa6b.mjs

@@ -0,0 +1,2 @@
+import{n as e}from"./flow-CNyLsPGb.mjs";import{i as t,t as n}from"./result-D3VY0qBG.mjs";function r(e){return typeof e==`object`&&e&&`key`in e?e.key:e}function i(e){return e.map(e=>({message:e.message,path:e.path?.map(r)}))}function a(e){return e.issues?n({issues:i(e.issues)}):t(e.value)}function o(e){return e instanceof Error&&e.message.length>0?e.message:typeof e==`string`&&e.length>0?e:`Schema validation failed.`}function s(e){return{issues:[{message:o(e)}]}}function c(t,n,r){let i=t[`~standard`].validate(n);if(e(i))throw TypeError(`Async validation is not supported in ${r}.`);return a(i)}export{a as n,c as r,s as t};
+//# sourceMappingURL=schema.shared-Bjyroa6b.mjs.map

package/dist/schema.shared-Bjyroa6b.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.shared-Bjyroa6b.mjs","names":["Result.err","Result.ok"],"sources":["../src/schema/schema.shared.ts"],"sourcesContent":["import { Result } from \"../result\"\nimport type { Result as ResultType } from \"../result/result.types\"\nimport { isPromise } from \"../shared/is-promise\"\nimport type { ValidationError, ValidationIssue } from \"./schema.types\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\nfunction normalizePathSegment(segment: PropertyKey | { readonly key: PropertyKey }): PropertyKey {\n  return typeof segment === \"object\" && segment !== null && \"key\" in segment ? segment.key : segment\n}\n\nfunction normalizeIssues(\n  issues: NonNullable<StandardSchemaV1.Result<unknown>[\"issues\"]>,\n): ReadonlyArray<ValidationIssue> {\n  return issues.map((issue) => ({\n    message: issue.message,\n    path: issue.path?.map(normalizePathSegment),\n  }))\n}\n\nexport function toValidationResult<T>(result: StandardSchemaV1.Result<T>): ResultType<T, ValidationError> {\n  if (result.issues) {\n    return Result.err({ issues: normalizeIssues(result.issues) })\n  }\n\n  return Result.ok(result.value)\n}\n\nfunction toErrorMessage(error: unknown): string {\n  if (error instanceof Error && error.message.length > 0) {\n    return error.message\n  }\n\n  if (typeof error === \"string\" && error.length > 0) {\n    return error\n  }\n\n  return \"Schema validation failed.\"\n}\n\nexport function toThrownValidationError(error: unknown): ValidationError {\n  return {\n    issues: [{ message: toErrorMessage(error) }],\n  }\n}\n\nexport function validateSync<T>(\n  schema: StandardSchemaV1<unknown, T>,\n  value: unknown,\n  operation: string,\n): ResultType<T, ValidationError> {\n  const result = schema[\"~standard\"].validate(value)\n\n  if (isPromise(result)) {\n    throw new TypeError(`Async validation is not supported in ${operation}.`)\n  }\n\n  return toValidationResult(result)\n}\n"],"mappings":"yFAMA,SAAS,EAAqB,EAAmE,CAC/F,OAAO,OAAO,GAAY,UAAY,GAAoB,QAAS,EAAU,EAAQ,IAAM,EAG7F,SAAS,EACP,EACgC,CAChC,OAAO,EAAO,IAAK,IAAW,CAC5B,QAAS,EAAM,QACf,KAAM,EAAM,MAAM,IAAI,EAAqB,CAC5C,EAAE,CAGL,SAAgB,EAAsB,EAAoE,CAKxG,OAJI,EAAO,OACFA,EAAW,CAAE,OAAQ,EAAgB,EAAO,OAAO,CAAE,CAAC,CAGxDC,EAAU,EAAO,MAAM,CAGhC,SAAS,EAAe,EAAwB,CAS9C,OARI,aAAiB,OAAS,EAAM,QAAQ,OAAS,EAC5C,EAAM,QAGX,OAAO,GAAU,UAAY,EAAM,OAAS,EACvC,EAGF,4BAGT,SAAgB,EAAwB,EAAiC,CACvE,MAAO,CACL,OAAQ,CAAC,CAAE,QAAS,EAAe,EAAM,CAAE,CAAC,CAC7C,CAGH,SAAgB,EACd,EACA,EACA,EACgC,CAChC,IAAM,EAAS,EAAO,aAAa,SAAS,EAAM,CAElD,GAAI,EAAU,EAAO,CACnB,MAAU,UAAU,wCAAwC,EAAU,GAAG,CAG3E,OAAO,EAAmB,EAAO"}

package/dist/{schema.types-CFzzx4bw.d.mts → schema.types-E1pjcc0Y.d.mts}

@@ -1,3 +1,4 @@
+import { h as Prettify } from "./result.types-BKzChyWY.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region src/schema/schema.types.d.ts
@@ -10,6 +11,22 @@ type Input<S extends StandardSchemaV1> = NonNullable<S["~standard"]["types"]>["i
  * Infer the output type from a Standard Schema.
  */
 type Output<S extends StandardSchemaV1> = NonNullable<S["~standard"]["types"]>["output"];
+/**
+ * Infer the validated output type from a Standard Schema.
+ *
+ * This matches the exact schema output used by `Schema.parse()` and by
+ * `Schema.is()` when the starting value is `unknown`.
+ */
+type Infer<S extends StandardSchemaV1> = Output<S>;
+/**
+ * Compute the base-shape-preserving narrowed type used by `Schema.refine()`.
+ *
+ * This preserves fields already present on the base value while intersecting in
+ * the schema-proven output fields. This is also the shape TypeScript derives in
+ * direct control-flow checks when `Schema.is()` is used on an already-typed
+ * value.
+ */
+type Refine<Base, S extends StandardSchemaV1> = Base extends Input<S> ? Base extends unknown ? Prettify<Base & Output<S>> : never : never;
 /**
  * Normalized validation issue shape used across std modules.
  */
@@ -41,5 +58,5 @@ type RefinementSchema<Base, Sub extends Base> = StandardSchemaV1<Base, Sub>;
  */
 type SyncRefinementSchema<Base, Sub extends Base> = SyncSchema<Base, Sub>;
 //#endregion
-export { SyncSchema as a, SyncRefinementSchema as i, Output as n, ValidationError as o, RefinementSchema as r, ValidationIssue as s, Input as t };
-//# sourceMappingURL=schema.types-CFzzx4bw.d.mts.map
+export { RefinementSchema as a, ValidationError as c, Refine as i, ValidationIssue as l, Input as n, SyncRefinementSchema as o, Output as r, SyncSchema as s, Infer as t };
+//# sourceMappingURL=schema.types-E1pjcc0Y.d.mts.map

package/dist/schema.types-E1pjcc0Y.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.types-E1pjcc0Y.d.mts","names":[],"sources":["../src/schema/schema.types.ts"],"sourcesContent":[],"mappings":";;;;;;;AAMA;AAA4B,KAAhB,KAAgB,CAAA,UAAA,gBAAA,CAAA,GAAoB,WAApB,CAAgC,CAAhC,CAAA,WAAA,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,OAAA,CAAA;;;;AAKhB,KAAA,MAAM,CAAA,UAAW,gBAAX,CAAA,GAA+B,WAA/B,CAA2C,CAA3C,CAAA,WAAA,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,QAAA,CAAA;;;;;AAQlB;;AAAuD,KAA3C,KAA2C,CAAA,UAA3B,gBAA2B,CAAA,GAAP,MAAO,CAAA,CAAA,CAAA;;;AAUvD;;;;;;AAEe,KAFH,MAEG,CAAA,IAAA,EAAA,UAFoB,gBAEpB,CAAA,GAFwC,IAExC,SAFqD,KAErD,CAF2D,CAE3D,CAAA,GADX,IACW,SAAA,OAAA,GAAT,QAAS,CAAA,IAAA,GAAO,MAAP,CAAc,CAAd,CAAA,CAAA,GAAA,KAAA,GAAA,KAAA;;;;AAAD,KAOF,eAAA,GAPE;EAOF,SAAA,OAAA,EAAe,MAAA;EAQf,SAAA,IAAA,CAAA,EANM,aAMS,CANK,WAOC,CAAA,GAAA,SAAd;AAOnB,CAAA;;;;AAAkE,KARtD,eAAA,GAQsD;EAAL,SAAA,MAAA,EAP1C,aAO0C,CAP5B,eAO4B,CAAA;CACf;;;;;AACZ,KAFtB,UAEuC,CAAA,SAAA,OAAA,EAAA,UAFA,MAEA,CAAA,GAFU,IAEV,CAFe,gBAEf,CAFgC,MAEhC,EAFwC,OAExC,CAAA,EAAA,WAAA,CAAA,GAAA;EAAM,SAAA,WAAA,EADjC,IACiC,CAD5B,gBAC4B,CADX,MACW,EADH,OACG,CAAA,CAAA,WAAA,CAAA,EAAA,UAAA,CAAA,GAAA;IAO7C,QAAA,EAAA,CAAA,KAAgB,EAAA,OAAA,EAAA,GAPM,gBAAA,CAAiB,MAOvB,CAP8B,OAO9B,CAAA;EAAmB,CAAA;CAAyB;;;;AAK5D,KALA,gBAKoB,CAAA,IAAA,EAAA,YALe,IAKf,CAAA,GALuB,gBAKvB,CALwC,IAKxC,EAL8C,GAK9C,CAAA;;;;AAA2B,KAA/C,oBAA+C,CAAA,IAAA,EAAA,YAAR,IAAQ,CAAA,GAAA,UAAA,CAAW,IAAX,EAAiB,GAAjB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nicolastoulemont/std",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Collection of utility functions",
   "homepage": "https://github.com/nicolastoulemont/toolbelt/tree/main/packages/std",
   "license": "ISC",

package/dist/index-Ctg7XUOs.d.mts

@@ -1,36 +0,0 @@
-import { t as Result } from "./result.types-BKzChyWY.mjs";
-import { a as SyncSchema, i as SyncRefinementSchema, n as Output, o as ValidationError, r as RefinementSchema, s as ValidationIssue, t as Input } from "./schema.types-CFzzx4bw.mjs";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-
-//#region src/schema/schema.d.ts
-declare namespace schema_d_exports {
-  export { Input, Is, Output, RefinementSchema, SyncRefinementSchema, SyncSchema, ValidationError, ValidationIssue, is, parse };
-}
-/**
- * Create a schema-backed parser.
- *
- * For sync schemas the returned parser is sync.
- * For general Standard Schema values the returned parser is async.
- */
-declare function parse<S extends SyncSchema>(schema: S): (value: Input<S>) => Result<Output<S>, ValidationError>;
-declare function parse<S extends StandardSchemaV1>(schema: S): (value: Input<S>) => Promise<Result<Output<S>, ValidationError>>;
-/**
- * Create a sync-only schema-backed type guard.
- *
- * This is intended for refinement schemas where the validated output is a
- * subtype of the input value already in memory.
- *
- * Supports both data-first and data-last styles:
- * - Data-first: `Schema.is(value, schema)`
- * - Data-last: `Schema.is(schema)(value)`
- */
-type Is = {
-  <Base, Sub extends Base>(value: Base, schema: SyncRefinementSchema<Base, Sub>): value is Sub;
-  <S extends SyncSchema>(value: unknown, schema: S): value is Output<S>;
-  <Base, Sub extends Base>(schema: SyncRefinementSchema<Base, Sub>): (value: Base) => value is Sub;
-  <S extends SyncSchema>(schema: S): (value: unknown) => value is Output<S>;
-};
-declare const is: Is;
-//#endregion
-export { schema_d_exports as t };
-//# sourceMappingURL=index-Ctg7XUOs.d.mts.map

package/dist/index-Ctg7XUOs.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-Ctg7XUOs.d.mts","names":[],"sources":["../src/schema/schema.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;iBAyCgB,gBAAgB,oBAAoB,YAAY,MAAM,OAAO,OAAW,OAAO,IAAI;iBACnF,gBAAgB,0BACtB,YACC,MAAM,OAAO,QAAQ,OAAW,OAAO,IAAI;;;;;;;AAHtD;;;;AAAgE,KA0BpD,EAAA,GA1BoD;EAA+B,CAAA,IAAA,EAAA,YA2B1E,IA3B0E,CAAA,CAAA,KAAA,EA2B7D,IA3B6D,EAAA,MAAA,EA2B/C,oBA3B+C,CA2B1B,IA3B0B,EA2BpB,GA3BoB,CAAA,CAAA,EAAA,KAAA,IA2BJ,GA3BI;EAAP,CAAA,UA4B3E,UA5B2E,CAAA,CAAA,KAAA,EAAA,OAAA,EAAA,MAAA,EA4BvC,CA5BuC,CAAA,EAAA,KAAA,IA4B1B,MA5B0B,CA4BnB,CA5BmB,CAAA;EAAW,CAAA,IAAA,EAAA,YA6B9E,IA7B8E,CAAA,CAAA,MAAA,EA6BhE,oBA7BgE,CA6B3C,IA7B2C,EA6BrC,GA7BqC,CAAA,CAAA,EAAA,CAAA,KAAA,EA6BtB,IA7BsB,EAAA,GAAA,KAAA,IA6BJ,GA7BI;EAAtB,CAAA,UA8BhE,UA9BgE,CAAA,CAAA,MAAA,EA8B5C,CA9B4C,CAAA,EAAA,CAAA,KAAA,EAAA,OAAA,EAAA,GAAA,KAAA,IA8BX,MA9BW,CA8BJ,CA9BI,CAAA;CAAU;AACvE,cAiCH,EAjCQ,EAiCJ,EAjCI"}

package/dist/schema-D87TVF_b.mjs

@@ -1,2 +0,0 @@
-import{t as e}from"./chunk-oQKkju2G.mjs";import{t}from"./dual-fN6OUwN_.mjs";import{n}from"./flow-CNyLsPGb.mjs";import{n as r,t as i}from"./schema.shared-CI4eydjX.mjs";var a=e({is:()=>s,parse:()=>o});function o(e){return t=>{let r=e[`~standard`].validate(t);return n(r)?Promise.resolve(r).then(i):i(r)}}const s=t(2,(e,t)=>r(t,e,`Schema.is()`)._tag===`Ok`);export{a as t};
-//# sourceMappingURL=schema-D87TVF_b.mjs.map

package/dist/schema-D87TVF_b.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-D87TVF_b.mjs","names":[],"sources":["../src/schema/schema.ts"],"sourcesContent":["import type { Result as ResultType } from \"../result/result.types\"\n/**\n * Standard Schema-backed parsing and refinement helpers.\n *\n * **Mental model**\n * - `Schema.parse` is for boundary validation and parsing.\n * - `Schema.is` is for sync-only refinement of values already in memory.\n *\n * **Common tasks**\n * - Parse loose external data into validated subtypes.\n * - Reuse a schema as a type guard for refinement-only narrowing.\n *\n * **Gotchas**\n * - `Schema.parse` may be sync or async based on the schema type you preserve.\n * - `Schema.is` supports both data-first and data-last styles.\n * - `Schema.is` must only be used with sync schemas that do not rely on transforms.\n *\n * @module\n */\nimport { dual } from \"../shared/dual\"\nimport { isPromise } from \"../shared/is-promise\"\nimport { toValidationResult, validateSync } from \"./schema.shared\"\nimport type { Input, Output, SyncRefinementSchema, SyncSchema, ValidationError } from \"./schema.types\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\nexport type {\n  Input,\n  Output,\n  RefinementSchema,\n  SyncRefinementSchema,\n  SyncSchema,\n  ValidationError,\n  ValidationIssue,\n} from \"./schema.types\"\n\n/**\n * Create a schema-backed parser.\n *\n * For sync schemas the returned parser is sync.\n * For general Standard Schema values the returned parser is async.\n */\nexport function parse<S extends SyncSchema>(schema: S): (value: Input<S>) => ResultType<Output<S>, ValidationError>\nexport function parse<S extends StandardSchemaV1>(\n  schema: S,\n): (value: Input<S>) => Promise<ResultType<Output<S>, ValidationError>>\nexport function parse<S extends StandardSchemaV1>(schema: S) {\n  return (value: Input<S>) => {\n    const result = schema[\"~standard\"].validate(value)\n\n    if (isPromise(result)) {\n      return Promise.resolve(result).then(toValidationResult)\n    }\n\n    return toValidationResult(result)\n  }\n}\n\n/**\n * Create a sync-only schema-backed type guard.\n *\n * This is intended for refinement schemas where the validated output is a\n * subtype of the input value already in memory.\n *\n * Supports both data-first and data-last styles:\n * - Data-first: `Schema.is(value, schema)`\n * - Data-last: `Schema.is(schema)(value)`\n */\nexport type Is = {\n  <Base, Sub extends Base>(value: Base, schema: SyncRefinementSchema<Base, Sub>): value is Sub\n  <S extends SyncSchema>(value: unknown, schema: S): value is Output<S>\n  <Base, Sub extends Base>(schema: SyncRefinementSchema<Base, Sub>): (value: Base) => value is Sub\n  <S extends SyncSchema>(schema: S): (value: unknown) => value is Output<S>\n}\n\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- dual() requires a single implementation signature */\nexport const is: Is = dual(2, (value: unknown, schema: SyncSchema) => {\n  return validateSync(schema, value, \"Schema.is()\")._tag === \"Ok\"\n}) as Is\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n"],"mappings":"uMA6CA,SAAgB,EAAkC,EAAW,CAC3D,MAAQ,IAAoB,CAC1B,IAAM,EAAS,EAAO,aAAa,SAAS,EAAM,CAMlD,OAJI,EAAU,EAAO,CACZ,QAAQ,QAAQ,EAAO,CAAC,KAAK,EAAmB,CAGlD,EAAmB,EAAO,EAsBrC,MAAa,EAAS,EAAK,GAAI,EAAgB,IACtC,EAAa,EAAQ,EAAO,cAAc,CAAC,OAAS,KAC3D"}

package/dist/schema.shared-CI4eydjX.mjs

@@ -1,2 +0,0 @@
-import{n as e}from"./flow-CNyLsPGb.mjs";import{i as t,t as n}from"./result-D3VY0qBG.mjs";function r(e){return typeof e==`object`&&e&&`key`in e?e.key:e}function i(e){return e.map(e=>({message:e.message,path:e.path?.map(r)}))}function a(e){return e.issues?n({issues:i(e.issues)}):t(e.value)}function o(t,n,r){let i=t[`~standard`].validate(n);if(e(i))throw TypeError(`Async validation is not supported in ${r}.`);return a(i)}export{o as n,a as t};
-//# sourceMappingURL=schema.shared-CI4eydjX.mjs.map

package/dist/schema.shared-CI4eydjX.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.shared-CI4eydjX.mjs","names":["Result.err","Result.ok"],"sources":["../src/schema/schema.shared.ts"],"sourcesContent":["import { Result } from \"../result\"\nimport type { Result as ResultType } from \"../result/result.types\"\nimport { isPromise } from \"../shared/is-promise\"\nimport type { ValidationError, ValidationIssue } from \"./schema.types\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\nfunction normalizePathSegment(segment: PropertyKey | { readonly key: PropertyKey }): PropertyKey {\n  return typeof segment === \"object\" && segment !== null && \"key\" in segment ? segment.key : segment\n}\n\nfunction normalizeIssues(\n  issues: NonNullable<StandardSchemaV1.Result<unknown>[\"issues\"]>,\n): ReadonlyArray<ValidationIssue> {\n  return issues.map((issue) => ({\n    message: issue.message,\n    path: issue.path?.map(normalizePathSegment),\n  }))\n}\n\nexport function toValidationResult<T>(result: StandardSchemaV1.Result<T>): ResultType<T, ValidationError> {\n  if (result.issues) {\n    return Result.err({ issues: normalizeIssues(result.issues) })\n  }\n\n  return Result.ok(result.value)\n}\n\nexport function validateSync<T>(\n  schema: StandardSchemaV1<unknown, T>,\n  value: unknown,\n  operation: string,\n): ResultType<T, ValidationError> {\n  const result = schema[\"~standard\"].validate(value)\n\n  if (isPromise(result)) {\n    throw new TypeError(`Async validation is not supported in ${operation}.`)\n  }\n\n  return toValidationResult(result)\n}\n"],"mappings":"yFAMA,SAAS,EAAqB,EAAmE,CAC/F,OAAO,OAAO,GAAY,UAAY,GAAoB,QAAS,EAAU,EAAQ,IAAM,EAG7F,SAAS,EACP,EACgC,CAChC,OAAO,EAAO,IAAK,IAAW,CAC5B,QAAS,EAAM,QACf,KAAM,EAAM,MAAM,IAAI,EAAqB,CAC5C,EAAE,CAGL,SAAgB,EAAsB,EAAoE,CAKxG,OAJI,EAAO,OACFA,EAAW,CAAE,OAAQ,EAAgB,EAAO,OAAO,CAAE,CAAC,CAGxDC,EAAU,EAAO,MAAM,CAGhC,SAAgB,EACd,EACA,EACA,EACgC,CAChC,IAAM,EAAS,EAAO,aAAa,SAAS,EAAM,CAElD,GAAI,EAAU,EAAO,CACnB,MAAU,UAAU,wCAAwC,EAAU,GAAG,CAG3E,OAAO,EAAmB,EAAO"}

package/dist/schema.types-CFzzx4bw.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.types-CFzzx4bw.d.mts","names":[],"sources":["../src/schema/schema.types.ts"],"sourcesContent":[],"mappings":";;;;;;AAKA;AAA4B,KAAhB,KAAgB,CAAA,UAAA,gBAAA,CAAA,GAAoB,WAApB,CAAgC,CAAhC,CAAA,WAAA,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,OAAA,CAAA;;;;AAKhB,KAAA,MAAM,CAAA,UAAW,gBAAX,CAAA,GAA+B,WAA/B,CAA2C,CAA3C,CAAA,WAAA,CAAA,CAAA,OAAA,CAAA,CAAA,CAAA,QAAA,CAAA;;;;AAA0C,KAKhD,eAAA,GALgD;EAKhD,SAAA,OAAA,EAAe,MAAA;EAQf,SAAA,IAAA,CAAA,EANM,aAMS,CANK,WAOC,CAAA,GAAA,SAAd;AAOnB,CAAA;;;;AAAkE,KARtD,eAAA,GAQsD;EAAL,SAAA,MAAA,EAP1C,aAO0C,CAP5B,eAO4B,CAAA;CACf;;;;;AACZ,KAFtB,UAEuC,CAAA,SAAA,OAAA,EAAA,UAFA,MAEA,CAAA,GAFU,IAEV,CAFe,gBAEf,CAFgC,MAEhC,EAFwC,OAExC,CAAA,EAAA,WAAA,CAAA,GAAA;EAAM,SAAA,WAAA,EADjC,IACiC,CAD5B,gBAC4B,CADX,MACW,EADH,OACG,CAAA,CAAA,WAAA,CAAA,EAAA,UAAA,CAAA,GAAA;IAO7C,QAAA,EAAA,CAAA,KAAgB,EAAA,OAAA,EAAA,GAPM,gBAAA,CAAiB,MAOvB,CAP8B,OAO9B,CAAA;EAAmB,CAAA;CAAyB;;;;AAK5D,KALA,gBAKoB,CAAA,IAAA,EAAA,YALe,IAKf,CAAA,GALuB,gBAKvB,CALwC,IAKxC,EAL8C,GAK9C,CAAA;;;;AAA2B,KAA/C,oBAA+C,CAAA,IAAA,EAAA,YAAR,IAAQ,CAAA,GAAA,UAAA,CAAW,IAAX,EAAiB,GAAjB,CAAA"}