@nicolastoulemont/std 0.6.0 → 0.7.0

package/README.md

@@ -15,21 +15,24 @@ pnpm add @nicolastoulemont/std
 ## Quick Start
 
 ```ts
-import { Result, TaggedError, pipe } from "@nicolastoulemont/std"
+import { Result, Data, pipe } from "@nicolastoulemont/std"
 
-class InvalidPortError extends TaggedError("InvalidPortError")<{ input: string }> {}
+class InvalidPortError extends Data.TaggedError("InvalidPortError")<{ input: string }> {}
 
 const parsePort = (input: string) =>
   pipe(
     Result.try(() => Number.parseInt(input, 10)),
-    Result.filter((n) => Number.isInteger(n) && n > 0, () => new InvalidPortError({ input })),
+    Result.filter(
+      (n) => Number.isInteger(n) && n > 0,
+      () => new InvalidPortError({ input }),
+    ),
   )
 ```
 
 ```ts
-import { Fx, Layer, provide, serviceTag, pipe } from "@nicolastoulemont/std"
+import { Fx, Layer, Provide, Service, pipe } from "@nicolastoulemont/std"
 
-const Config = serviceTag<{ baseUrl: string }>("Config")
+const Config = Service.tag<{ baseUrl: string }>("Config")
 
 const ConfigLive = Layer.ok(Config, { baseUrl: "https://api.example.com" })
 
@@ -38,7 +41,7 @@ const program = Fx.gen(function* () {
   return config.baseUrl
 })
 
-const exit = Fx.run(pipe(program, provide(ConfigLive)))
+const exit = Fx.run(pipe(program, Provide.layer(ConfigLive)))
 
 const response = Fx.match(exit, {
   Ok: (ok) => ({ status: 200, body: ok.value }),
@@ -56,15 +59,18 @@ Result models success/failure with typed errors so transformations stay explicit
 #### Abstract Example
 
 ```ts
-import { Result, TaggedError, pipe } from "@nicolastoulemont/std"
+import { Result, Data, pipe } from "@nicolastoulemont/std"
 
-class NotPositiveIntegerError extends TaggedError("NotPositiveIntegerError")<{ input: string }> {}
+class NotPositiveIntegerError extends Data.TaggedError("NotPositiveIntegerError")<{ input: string }> {}
 
 const parsePositiveInt = (input: string) => {
   const parsed = Number.parseInt(input, 10)
   return pipe(
     Result.ok(parsed),
-    Result.filter((n) => Number.isInteger(n) && n > 0, () => new NotPositiveIntegerError({ input })),
+    Result.filter(
+      (n) => Number.isInteger(n) && n > 0,
+      () => new NotPositiveIntegerError({ input }),
+    ),
   )
 }
 ```
@@ -72,16 +78,14 @@ const parsePositiveInt = (input: string) => {
 #### Real-World Example
 
 ```ts
-import { Result, TaggedError, pipe } from "@nicolastoulemont/std"
+import { Result, Data, pipe } from "@nicolastoulemont/std"
 
-class ValidationError extends TaggedError("ValidationError")<{ message: string }> {}
-class ConflictError extends TaggedError("ConflictError")<{ message: string }> {}
+class ValidationError extends Data.TaggedError("ValidationError")<{ message: string }> {}
+class ConflictError extends Data.TaggedError("ConflictError")<{ message: string }> {}
 type SignupError = ValidationError | ConflictError
 
 const validateEmail = (email: string) =>
-  email.includes("@")
-    ? Result.ok(email)
-    : Result.err<SignupError>(new ValidationError({ message: "Invalid email" }))
+  email.includes("@") ? Result.ok(email) : Result.err<SignupError>(new ValidationError({ message: "Invalid email" }))
 
 const createUser = (email: string) =>
   email === "taken@example.com"
@@ -139,8 +143,7 @@ Either models two valid branches where both sides are meaningful outcomes rather
 ```ts
 import { Either } from "@nicolastoulemont/std"
 
-const parseSource = (input: "local" | "remote") =>
-  input === "local" ? Either.left("LOCAL") : Either.right("REMOTE")
+const parseSource = (input: "local" | "remote") => (input === "local" ? Either.left("LOCAL") : Either.right("REMOTE"))
 
 const label = Either.match(parseSource("local"), {
   Left: (source) => `Source: ${source}`,
@@ -157,9 +160,7 @@ type Source = "cache" | "database"
 type User = { id: string; name: string }
 
 const findUser = (id: string) =>
-  id.startsWith("cached:")
-    ? Either.left<Source, User>("cache")
-    : Either.right<Source, User>({ id, name: "Ada" })
+  id.startsWith("cached:") ? Either.left<Source, User>("cache") : Either.right<Source, User>({ id, name: "Ada" })
 
 const responseMeta = (id: string) =>
   pipe(
@@ -178,9 +179,9 @@ Fx models generator-based effects with typed dependencies and short-circuiting t
 #### Abstract Example
 
 ```ts
-import { Fx, Layer, provide, serviceTag, pipe } from "@nicolastoulemont/std"
+import { Fx, Layer, Provide, Service, pipe } from "@nicolastoulemont/std"
 
-const Clock = serviceTag<{ now: () => number }>("Clock")
+const Clock = Service.tag<{ now: () => number }>("Clock")
 const ClockLive = Layer.ok(Clock, { now: () => Date.now() })
 
 const program = Fx.gen(function* () {
@@ -188,7 +189,7 @@ const program = Fx.gen(function* () {
   return clock.now()
 })
 
-const exit = Fx.run(pipe(program, provide(ClockLive)))
+const exit = Fx.run(pipe(program, Provide.layer(ClockLive)))
 
 const timestamp = Fx.match(exit, {
   Ok: (ok) => ok.value,
@@ -200,14 +201,14 @@ const timestamp = Fx.match(exit, {
 #### Real-World Example
 
 ```ts
-import { Fx, Layer, Result, TaggedError, provide, serviceTag, pipe } from "@nicolastoulemont/std"
+import { Fx, Layer, Result, Data, Provide, Service, pipe } from "@nicolastoulemont/std"
 
-const Api = serviceTag<{ postOrder: (input: { sku: string; qty: number }) => Promise<{ orderId: string }> }>("Api")
+const Api = Service.tag<{ postOrder: (input: { sku: string; qty: number }) => Promise<{ orderId: string }> }>("Api")
 const ApiLive = Layer.ok(Api, {
   postOrder: async () => ({ orderId: "ord_42" }),
 })
 
-class InvalidQuantityError extends TaggedError("InvalidQuantityError")<{ qty: number }> {}
+class InvalidQuantityError extends Data.TaggedError("InvalidQuantityError")<{ qty: number }> {}
 
 const submitOrder = Fx.gen(function* (payload: { sku?: string; qty: number }) {
   const api = yield* Api
@@ -220,7 +221,7 @@ const submitOrder = Fx.gen(function* (payload: { sku?: string; qty: number }) {
   return yield* Fx.try(() => api.postOrder({ sku, qty: validQty }))
 })
 
-const exit = Fx.run(pipe(submitOrder({ sku: "book-1", qty: 2 }), provide(ApiLive)))
+const exit = Fx.run(pipe(submitOrder({ sku: "book-1", qty: 2 }), Provide.layer(ApiLive)))
 
 const httpResponse = Fx.match(exit, {
   Ok: (ok) => ({ status: 201, body: ok.value }),
@@ -229,6 +230,155 @@ const httpResponse = Fx.match(exit, {
 })
 ```
 
+#### Retry Example
+
+```ts
+import { Fx, Result, Schedule } from "@nicolastoulemont/std"
+
+let attempts = 0
+
+const flaky = Fx.gen(function* () {
+  attempts += 1
+  if (attempts < 3) {
+    return yield* Result.err("temporary" as const)
+  }
+  return "ok"
+})
+
+const exit = Fx.run(Fx.retry(flaky, Schedule.recurs(5)))
+```
+
+#### Nested Retry with Dependencies
+
+```ts
+import { Fx, Layer, Result, Schedule, pipe, Provide, Service } from "@nicolastoulemont/std"
+
+type ConfigService = { baseUrl: string }
+const Config = Service.tag<ConfigService>("Config")
+const ConfigLive = Layer.ok(Config, { baseUrl: "https://api.example.com" })
+
+let attempts = 0
+
+const inner = Fx.retry(
+  Fx.gen(function* () {
+    const config = yield* Config
+    attempts += 1
+    if (attempts < 2) {
+      return yield* Result.err("temporary" as const)
+    }
+    return config.baseUrl
+  }),
+  Schedule.recurs(2),
+)
+
+const program = Fx.gen(function* () {
+  const baseUrl = yield* inner
+  return `ready:${baseUrl}`
+})
+
+const exit = Fx.run(pipe(program, Provide.layer(ConfigLive)))
+```
+
+#### Concurrent Traversal with Fx.forEach
+
+```ts
+import { Fx } from "@nicolastoulemont/std"
+
+const loadUsers = Fx.forEach(
+  ["u1", "u2", "u3"],
+  (id) =>
+    Fx.gen(async function* () {
+      const response = await fetch(`/api/users/${id}`)
+      return yield* Fx.try(() => response.json())
+    }),
+  { concurrency: 2 },
+)
+
+const exit = await Fx.run(loadUsers)
+```
+
+### Queue
+
+Queue provides a standalone FIFO task queue with configurable concurrency, backpressure (bounded mode), and lifecycle controls.
+
+#### Abstract Example
+
+```ts
+import { Queue } from "@nicolastoulemont/std"
+
+const queue = Queue.make({ concurrency: 2 })
+
+const first = queue.enqueue(() => 1)
+const second = queue.enqueue(async () => 2)
+
+await queue.awaitIdle()
+await queue.shutdown({ mode: "drain" })
+```
+
+#### Real-World Example
+
+```ts
+import { Queue } from "@nicolastoulemont/std"
+
+const imageQueue = Queue.bounded(100, { concurrency: 4 })
+
+const tasks = imageUrls.map((url) =>
+  imageQueue.enqueue(async ({ signal }) => {
+    const response = await fetch(url, { signal })
+    return response.arrayBuffer()
+  }),
+)
+
+const buffers = await Promise.all(tasks)
+await imageQueue.shutdown({ mode: "drain" })
+```
+
+### Multithread
+
+Multithread runs self-contained callbacks in worker threads using a Result-first API while remaining yieldable in `Fx.gen`.
+
+#### Abstract Example
+
+```ts
+import { Multithread } from "@nicolastoulemont/std"
+
+const op = Multithread.run((input: string, ctx) => {
+  ctx.throwIfCancelled()
+  return input.toUpperCase()
+}, "hello")
+
+const result = await op.result()
+```
+
+#### Real-World Example
+
+```ts
+import { Fx, Multithread } from "@nicolastoulemont/std"
+
+const program = Fx.gen(async function* () {
+  const records = yield* Multithread.map(
+    ['{"id":"1","email":"a@example.com"}', '{"id":"2","email":"b@example.com"}'],
+    (line, _index, ctx) => {
+      ctx.throwIfCancelled()
+      try {
+        return JSON.parse(line) as { id: string; email: string }
+      } catch {
+        return { _tag: "Err" as const, error: { _tag: "ParseError" as const, line } }
+      }
+    },
+    { parallelism: 4 },
+  )
+
+  const preferred = yield* Multithread.firstSuccess([Multithread.run(() => "cache"), Multithread.run(() => "database")])
+
+  return { records, preferred }
+})
+
+const exit = await Fx.run(program)
+```
+
+Multithread cancellation is cooperative. `abort()` always cancels logically, and worker code can stop early by calling `ctx.throwIfCancelled()`.
+
 ### Adt
 
 Adt provides schema-backed tagged variants so you can model domain state with exhaustive pattern matching.
@@ -301,6 +451,61 @@ if (previous.equals(next)) {
 }
 ```
 
+### Order
+
+Order provides composable comparators and immutable sorting helpers.
+
+#### Abstract Example
+
+```ts
+import { Order, pipe } from "@nicolastoulemont/std"
+
+type User = { name: string; age: number }
+
+const byAge = Order.by(Order.number, (user: User) => user.age)
+const byName = Order.by(Order.string, (user: User) => user.name)
+
+const userOrder = Order.merge(byAge, byName)
+const sameOrder = pipe(byAge, Order.merge(byName))
+const allOrders = Order.merge([byAge, byName])
+
+const sorted = Order.sort(
+  [
+    { name: "bob", age: 30 },
+    { name: "alice", age: 30 },
+    { name: "zoe", age: 25 },
+  ],
+  allOrders,
+)
+```
+
+#### Real-World Example
+
+```ts
+import { Order } from "@nicolastoulemont/std"
+
+type Product = {
+  id: string
+  category: string
+  price: number
+  rating: number
+}
+
+const byCategory = Order.by(Order.string, (product: Product) => product.category)
+const byPrice = Order.by(Order.number, (product: Product) => product.price)
+const byRatingDesc = Order.reverse(Order.by(Order.number, (product: Product) => product.rating))
+
+const sortProducts = Order.sortBy(byCategory, byPrice, byRatingDesc)
+
+const products: Product[] = [
+  { id: "a", category: "books", price: 20, rating: 4.8 },
+  { id: "b", category: "books", price: 20, rating: 4.5 },
+  { id: "c", category: "games", price: 60, rating: 4.7 },
+]
+
+const sorted = sortProducts(products)
+```
+
 ### pipe / flow
 
 pipe and flow compose sync/async transformations into readable, type-inferred data pipelines.

package/dist/adt/index.d.mts

@@ -1,2 +1,2 @@
-import { a as AdtCodecError, c as AdtInferInput, d as AdtValidationError, f as AdtVariant, g as AdtMatchHandlers, h as AdtVariantOf, i as AdtCodecDef, l as AdtInferOutput, m as AdtVariantNames, n as Adt, o as AdtExtractSchema, p as AdtVariantDef, r as AdtCodecConstraint, s as AdtInfer, t as createCodecError, u as AdtUnion } from "../index-C4v_3f3-.mjs";
-export { Adt, AdtCodecConstraint, AdtCodecDef, AdtCodecError, AdtExtractSchema, AdtInfer, AdtInferInput, AdtInferOutput, AdtMatchHandlers, AdtUnion, AdtValidationError, AdtVariant, AdtVariantDef, AdtVariantNames, AdtVariantOf, createCodecError };
+import { t as adt_d_exports } from "../index-DKS1g1oC.mjs";
+export { adt_d_exports as Adt };

package/dist/adt/index.mjs

@@ -1 +1 @@
-import{n as e,t}from"../adt-CkRcY_GA.mjs";export{t as Adt,e as createCodecError};
+import{t as e}from"../adt-DajUZvJe.mjs";export{e as Adt};

package/dist/adt-DajUZvJe.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"./chunk-C934ptG5.mjs";import{i as t,n,r,t as i}from"./equality-CoyUHWh9.mjs";import{n as a}from"./flow-D8_tllWl.mjs";import{r as o,t as s}from"./result-BEzV0DYC.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){return e.issues?s({issues:e.issues.map(e=>({message:e.message,path:e.path?.map(e=>typeof e==`object`&&`key`in e?e.key:e)}))}):o(e.value)}function f(e,t,n){let r=e[`~standard`].validate(t);if(a(r))throw Error(`Async validation not supported. Schema for "${n}" returned a Promise. Use a synchronous schema or handle async validation separately.`);return d(r)}function p(e){return t=>l(t)&&`_tag`in t&&t._tag===e}function m(e){let t=new Set(e);return e=>l(e)&&`_tag`in e&&typeof e._tag==`string`&&t.has(e._tag)}function h(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 g(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 _(e,t,n){let r=g(e),i={json:n=>{let i=f(t,{...n,_tag:e},e);if(i._tag===`Err`)return s(h(`ValidationError`,`Cannot encode invalid data: ${i.error.issues.map(e=>e.message).join(`, `)}`,void 0,i.error.issues));try{return o(r.to(i.value))}catch(e){return s(h(`EncodingError`,`JSON encoding failed: ${e instanceof Error?e.message:String(e)}`,e))}}};if(n)for(let[r,a]of Object.entries(n))i[r]=n=>{let i=f(t,{...n,_tag:e},e);if(i._tag===`Err`)return s(h(`ValidationError`,`Cannot encode invalid data: ${i.error.issues.map(e=>e.message).join(`, `)}`,void 0,i.error.issues));try{return o(a.to(i.value))}catch(e){return s(h(`EncodingError`,`Encoding with codec '${r}' failed: ${e instanceof Error?e.message:String(e)}`,e))}};return i}function v(e,t,n){let r=g(e),i={json:n=>{let i=r.from(n);if(i===null)return s(h(`DecodingError`,`Invalid JSON format`));let a=f(t,{...i,_tag:e},e);return a._tag===`Err`?s(h(`ValidationError`,`Decoded data failed schema validation`,void 0,a.error.issues)):o({...a.value,_tag:e})}};if(n)for(let[r,a]of Object.entries(n))i[r]=n=>{let i;try{i=a.from(n)}catch(e){return s(h(`DecodingError`,`Decoding with codec '${r}' threw an error`,e))}if(i===null)return s(h(`DecodingError`,`Codec '${r}' failed to decode input`));let c=f(t,{...i,_tag:e},e);return c._tag===`Err`?s(h(`ValidationError`,`Decoded data failed schema validation`,void 0,c.error.issues)):o({...c.value,_tag:e})};return i}function y(e,n,i){let a=p(e),c=_(e,n,i),l=v(e,n,i),u=r(e),d=t(e),m=t=>{let r=f(n,{...t,_tag:e},e);return r._tag===`Err`?s(r.error):o({...r.value,_tag:e})};return m._variant=!0,m._tag=e,m.schema=n,i&&(m.codecs=i),m.is=a,m.to=c,m.from=l,m.equals=u,m.hash=d,m}function b(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]=y(e,n.schema,n.codecs):a[e]=y(e,n.schema):a[e]=y(e,n);return{_name:e,is:m(r),equals:i(r),hash:n(r),...a}}var x=e({match:()=>w,union:()=>S,variant:()=>C});const S=b,C=y,w=c;export{x as t};
+//# sourceMappingURL=adt-DajUZvJe.mjs.map

package/dist/adt-DajUZvJe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"adt-DajUZvJe.mjs","names":["match","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 * const Shape = union('Shape', { Circle, Square })\n * type Shape = AdtInfer<typeof Shape>\n *\n * function describeShape(shape: Shape): string {\n *   return 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 { ok, err } from \"../result/result\"\nimport type { Result } from \"../result/result.types\"\nimport { isPlainObject } from \"../shared/is-plain-object\"\nimport { isPromise } from \"../shared/is-promise\"\nimport type { AdtVariant, AdtValidationError } 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 * Wrap Standard Schema validation result into our Result type.\n */\nfunction wrapValidationResult<T>(result: StandardSchemaV1.Result<T>): Result<T, AdtValidationError> {\n  if (result.issues) {\n    return err({\n      issues: result.issues.map((issue) => ({\n        message: issue.message,\n        path: issue.path?.map((segment) => (typeof segment === \"object\" && \"key\" in segment ? segment.key : segment)),\n      })),\n    })\n  }\n  return ok(result.value)\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>(\n  schema: StandardSchemaV1<unknown, T>,\n  data: unknown,\n  _tag: string,\n): Result<T, AdtValidationError> {\n  const result = schema[\"~standard\"].validate(data)\n\n  if (isPromise(result)) {\n    throw new Error(\n      `Async validation not supported. Schema for \"${_tag}\" returned a Promise. ` +\n        `Use a synchronous schema or handle async validation separately.`,\n    )\n  }\n\n  return wrapValidationResult(result)\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 { Discriminator } from \"../shared/discriminator.types\"\nimport type {\n  AdtCodecConstraint,\n  AdtCodecDef,\n  AdtCodecError,\n  AdtInferInput,\n  AdtInferOutput,\n  AdtValidationError,\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?: AdtValidationError[\"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 { Discriminator } from \"../shared/discriminator.types\"\nimport { createToMethods, createFromMethods } from \"./adt.codec\"\nimport type { AdtCodecConstraint, AdtInferInput, AdtInferOutput, AdtVariant, AdtValidationError } 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, AdtValidationError> => {\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 *\n * const Shape = Adt.union(\"Shape\", {} as never)\n * // => union helper with tagged constructors\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 *\n * type Example = typeof Adt\n * ```\n *\n * @category Type-level\n */\nexport type AdtInfer<T> = AdtInferType<T>\n\n/**\n * Re-exported union variant name helper.\n *\n * @example\n * ```ts\n * import { Adt } from \"@nicolastoulemont/std\"\n *\n * type Example = typeof Adt\n * ```\n *\n * @category Type-level\n */\nexport type AdtVariantNames<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 *\n * type Example = typeof Adt\n * ```\n *\n * @category Type-level\n */\nexport type AdtVariantOf<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 *\n * const Shape = Adt.union(\"Shape\", {} as never)\n * // => union helper with tagged constructors\n * ```\n *\n * @category Constructors\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 *\n * const Circle = Adt.variant(\"Circle\", {} as never)\n * // => callable variant constructor\n * ```\n *\n * @category Constructors\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 *\n * @category Pattern Matching\n */\nexport const match = matchImpl\n"],"mappings":"yLAwCA,SAAgBA,EAId,EAAU,EAA6B,CAEvC,IAAM,EAAU,EADJ,EAAM,MAGlB,OAAO,EAAQ,EAAa,CC3C9B,SAAgB,EAAc,EAAuD,CAKnF,OAJsB,OAAO,GAAU,WAAnC,EACK,GAGF,OAAO,eAAe,EAAM,GAAK,MAAQ,OAAO,eAAe,EAAM,GAAK,OAAO,UCC1F,SAAgB,EAAU,EAAqC,CAC7D,OAAO,OAAO,GAAU,YAAc,aAAc,GAAS,EAAM,WAAgB,GAMrF,SAAS,EAAwB,EAAmE,CASlG,OARI,EAAO,OACF,EAAI,CACT,OAAQ,EAAO,OAAO,IAAK,IAAW,CACpC,QAAS,EAAM,QACf,KAAM,EAAM,MAAM,IAAK,GAAa,OAAO,GAAY,UAAY,QAAS,EAAU,EAAQ,IAAM,EAAS,CAC9G,EAAE,CACJ,CAAC,CAEG,EAAG,EAAO,MAAM,CAOzB,SAAgB,EACd,EACA,EACA,EAC+B,CAC/B,IAAM,EAAS,EAAO,aAAa,SAAS,EAAK,CAEjD,GAAI,EAAU,EAAO,CACnB,MAAU,MACR,+CAA+C,EAAK,uFAErD,CAGH,OAAO,EAAqB,EAAO,CAMrC,SAAgB,EACd,EACyD,CACzD,MAAQ,IACC,EAAc,EAAM,EAAI,SAAU,GAAS,EAAM,OAAY,EAOxE,SAAgB,EAAoB,EAA0D,CAC5F,IAAM,EAAU,IAAI,IAAI,EAAM,CAC9B,MAAQ,IACC,EAAc,EAAM,EAAI,SAAU,GAAS,OAAO,EAAM,MAAY,UAAY,EAAQ,IAAI,EAAM,KAAQ,CCjDrH,SAAS,EACP,EACA,EACA,EACA,EACe,CAUf,OATI,IAAU,IAAA,IAAa,IAAqB,IAAA,GACvC,CAAE,OAAM,UAAS,QAAO,mBAAkB,CAE/C,IAAU,IAAA,GAGV,IAAqB,IAAA,GAGlB,CAAE,OAAM,UAAS,CAFf,CAAE,OAAM,UAAS,mBAAkB,CAHnC,CAAE,OAAM,UAAS,QAAO,CAYnC,SAAS,EACP,EAC+E,CAC/E,MAAO,CACL,GAAK,GAGI,KAAK,UAAU,EAAM,CAG9B,KAAO,GAAkB,CACvB,GAAI,CACF,IAAM,EAAS,KAAK,MAAM,EAAM,CAEhC,GAAI,OAAO,GAAW,UAAY,GAAmB,SAAU,EAAQ,CACrE,GAAM,CAAE,KAAM,EAAG,GAAG,GAAS,EAC7B,OAAO,EAET,OAAO,OACD,CACN,OAAO,OAIZ,CAOH,SAAgB,EAId,EAAW,EAAW,EAA6C,CAGnE,IAAM,EAAY,EAAwB,EAAK,CAGzC,EAA8E,CAClF,KAAO,GAA2D,CAIhE,IAAM,EAAS,EAAa,EADR,CAAE,GAAI,EAAkB,OAAM,CACD,EAAK,CAEtD,GAAI,EAAO,OAAS,MAClB,OAAO,EACL,EACE,kBACA,+BAA+B,EAAO,MAAM,OAAO,IAAK,GAAM,EAAE,QAAQ,CAAC,KAAK,KAAK,GACnF,IAAA,GACA,EAAO,MAAM,OACd,CACF,CAGH,GAAI,CAEF,OAAO,EAAG,EAAU,GAAG,EAAO,MAAgB,CAAC,OACxC,EAAG,CACV,OAAO,EACL,EAAiB,gBAAiB,yBAAyB,aAAa,MAAQ,EAAE,QAAU,OAAO,EAAE,GAAI,EAAE,CAC5G,GAGN,CAGD,GAAI,EAEF,IAAK,GAAM,CAAC,EAAM,KAAU,OAAO,QAAQ,EAAa,CAEtD,EAAG,GAAS,GAAwD,CAIlE,IAAM,EAAS,EAAa,EADR,CAAE,GAAI,EAAkB,OAAM,CACD,EAAK,CAEtD,GAAI,EAAO,OAAS,MAClB,OAAO,EACL,EACE,kBACA,+BAA+B,EAAO,MAAM,OAAO,IAAK,GAAM,EAAE,QAAQ,CAAC,KAAK,KAAK,GACnF,IAAA,GACA,EAAO,MAAM,OACd,CACF,CAGH,GAAI,CAEF,OAAO,EAAG,EAAM,GAAG,EAAO,MAAgB,CAAC,OACpC,EAAG,CACV,OAAO,EACL,EACE,gBACA,wBAAwB,EAAK,YAAY,aAAa,MAAQ,EAAE,QAAU,OAAO,EAAE,GACnF,EACD,CACF,GAOT,OAAO,EAOT,SAAgB,EAId,EAAW,EAAW,EAAoD,CAG1E,IAAM,EAAY,EAAwB,EAAK,CAGzC,EAAsE,CAC1E,KAAO,GAAiD,CAEtD,IAAM,EAAU,EAAU,KAAK,EAAM,CACrC,GAAI,IAAY,KACd,OAAO,EAAI,EAAiB,gBAAiB,sBAAsB,CAAC,CAMtE,IAAM,EAAS,EAAa,EADR,CAAE,GAAI,EAAoB,OAAM,CACH,EAAK,CAWtD,OATI,EAAO,OAAS,MACX,EACL,EAAiB,kBAAmB,wCAAyC,IAAA,GAAW,EAAO,MAAM,OAAO,CAC7G,CAMI,EADQ,CAAE,GAAI,EAAO,MAAkB,OAAM,CACnC,EAEpB,CAGD,GAAI,EAEF,IAAK,GAAM,CAAC,EAAM,KAAU,OAAO,QAAQ,EAAa,CACtD,EAAK,GAAS,GAAkD,CAE9D,IAAI,EACJ,GAAI,CACF,EAAU,EAAM,KAAK,EAAM,OACpB,EAAG,CACV,OAAO,EAAI,EAAiB,gBAAiB,wBAAwB,EAAK,kBAAmB,EAAE,CAAC,CAGlG,GAAI,IAAY,KACd,OAAO,EAAI,EAAiB,gBAAiB,UAAU,EAAK,0BAA0B,CAAC,CAMzF,IAAM,EAAS,EAAa,EADR,CAAE,GAAI,EAAoB,OAAM,CACH,EAAK,CAgBtD,OAdI,EAAO,OAAS,MACX,EACL,EACE,kBACA,wCACA,IAAA,GACA,EAAO,MAAM,OACd,CACF,CAMI,EADQ,CAAE,GAAI,EAAO,MAAkB,OAAM,CACnC,EAMvB,OAAO,ECrKT,SAAgBC,EAId,EAAW,EAAW,EAA6C,CAGnE,IAAM,EAAU,EAA2B,EAAK,CAC1C,EAAK,EAAgB,EAAM,EAAQ,EAAO,CAC1C,EAAO,EAAkB,EAAM,EAAQ,EAAO,CAC9C,EAAS,EAA2C,EAAK,CACzD,EAAO,EAAyC,EAAK,CAGrD,EAAe,GAAgE,CAMnF,IAAM,EAAS,EAAa,EAHR,CAAE,GAAI,EAAkB,OAAM,CAGD,EAAK,CAStD,OAPI,EAAO,OAAS,MACX,EAAI,EAAO,MAAM,CAMnB,EADQ,CAAE,GAAI,EAAO,MAAkB,OAAM,CACnC,EAiBnB,MAbA,GAAY,SAAW,GACvB,EAAY,KAAO,EACnB,EAAY,OAAS,EACjB,IAEA,EAAoC,OAAS,GAEjD,EAAY,GAAK,EACjB,EAAY,GAAK,EACjB,EAAY,KAAO,EACnB,EAAY,OAAS,EACrB,EAAY,KAAO,EAEZ,EChET,SAAgBC,EAA+C,EAAc,EAAyB,CACpG,IAAM,EAAO,OAAO,KAAK,EAAQ,CAC3B,EAAuC,EAAE,CAE/C,IAAK,GAAM,CAAC,EAAM,KAAQ,OAAO,QAAQ,EAAQ,CAC3C,EAAU,EAAI,CAEZ,EAAI,OAAS,EAEf,EAAS,GAAQ,EAER,EAAI,OAGb,EAAS,GAAQC,EAAQ,EAAM,EAAI,OAAQ,EAAI,OAAO,CAGtD,EAAS,GAAQA,EAAQ,EAAM,EAAI,OAAO,CAM5C,EAAS,GAAQA,EAAQ,EAAM,EAAwB,CAU3D,MAAO,CACL,MAAO,EACP,GAPmB,EAAiB,EAAK,CAQzC,OAPa,EAAsB,EAAK,CAQxC,KAPW,EAAoB,EAAK,CAQpC,GAAG,EACJ,kDCCH,MAAa,EAAQC,EAeR,EAAUC,EAiBV,EAAQC"}

package/dist/brand/index.d.mts

@@ -1,2 +1,2 @@
-import { a as unsafeMake, c as BrandKey, d as Unbrand, i as refine, l as BrandRefinement, n as is, o as Brand$1, r as make, s as BrandError, t as Brand, u as Branded } from "../index-jeC5jyRh.mjs";
-export { Brand, BrandError, BrandKey, BrandRefinement, Brand$1 as BrandType, Branded, Unbrand, is, make, refine, unsafeMake };
+import { t as brand_d_exports } from "../index-DXbYlSnB.mjs";
+export { brand_d_exports as Brand };

package/dist/brand/index.mjs

@@ -1 +1 @@
-import{a as e,i as t,n,r,t as i}from"../brand-Gy0kW6-n.mjs";export{i as Brand,n as is,r as make,t as refine,e as unsafeMake};
+import{t as e}from"../brand-Bia3Vj6l.mjs";export{e as Brand};

package/dist/brand-Bia3Vj6l.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"./chunk-C934ptG5.mjs";import{r as t,t as n}from"./result-BEzV0DYC.mjs";var r=e({is:()=>o,make:()=>i,refine:()=>s,unsafeMake:()=>a});const i=e=>e,a=e=>e,o=e=>t=>e(t),s=(e,r)=>i=>e(i)?t(i):n({_tag:`BrandError`,value:i,message:typeof r==`function`?r(i):r??`Brand validation failed`});export{r as t};
+//# sourceMappingURL=brand-Bia3Vj6l.mjs.map

package/dist/brand-Bia3Vj6l.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"brand-Bia3Vj6l.mjs","names":["Result.err","Result.ok"],"sources":["../src/brand/brand.ts"],"sourcesContent":["/**\n * Nominal branding utilities for lightweight domain types.\n *\n * **Mental model**\n * - Brands let you distinguish semantically different values with the same runtime shape.\n * - `Brand.refine` validates and returns `Result`, while `Brand.make` is unchecked.\n *\n * **Common tasks**\n * - Create branded values with `Brand.make`.\n * - Add runtime validation with `Brand.refine`.\n * - Build guards with `Brand.is`.\n *\n * **Gotchas**\n * - Branding is a type-level operation and does not change runtime representation.\n * - `unsafeMake` should be reserved for trusted sources.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Brand } from \"@nicolastoulemont/std\"\n *\n * type UserId = Brand.Branded<string, \"UserId\">\n * const raw = \"user_123\" as UserId\n * const userId = Brand.make<UserId>(raw)\n * // => brand-preserving cast\n * ```\n *\n * @module\n */\nimport { Result } from \"../result\"\nimport type { Result as ResultType } from \"../result/result.types\"\nimport type { BrandError as BrandErrorType, Branded as BrandedType, Unbrand, Validator } from \"./brand.types\"\n\n/**\n * Re-exported nominal brand helper type.\n *\n * @example\n * ```ts\n * import { Brand } from \"@nicolastoulemont/std\"\n *\n * type Example = typeof Brand\n * ```\n *\n * @category Type-level\n */\nexport type Branded<T, K extends string> = BrandedType<T, K>\n\n/**\n * Re-exported brand validation error type.\n *\n * @example\n * ```ts\n * import { Brand } from \"@nicolastoulemont/std\"\n *\n * type Example = typeof Brand\n * ```\n *\n * @category Type-level\n */\nexport type BrandError<T> = BrandErrorType<T>\n\n/* oxlint-disable no-unsafe-type-assertion -- Branding is a deliberate nominal cast at the type level and requires explicit assertions. */\n\n/**\n * Create a branded value without validation.\n * This is a type-level cast with zero runtime cost.\n *\n * Use this when you trust the value source (e.g., from a database)\n * or when validation happens elsewhere.\n *\n * @template B - The branded type\n * @param value - The value to brand\n * @returns The value as a branded type\n *\n * @example\n * ```ts\n * import { Brand } from \"@nicolastoulemont/std\"\n *\n * type UserId = Brand.Branded<string, \"UserId\">\n * const raw = \"user_123\" as UserId\n * const userId = Brand.make<UserId>(raw)\n * // => brand-preserving cast\n * ```\n *\n * @category Utilities\n */\nexport const make = <B extends Branded<unknown, string>>(value: Unbrand<B>): B => {\n  return value as B\n}\n\n/**\n * Alias for make() - explicitly indicates no validation occurs.\n * Prefer this when readability about the lack of validation is important.\n *\n * @template B - The branded type\n * @param value - The value to brand (unchecked)\n * @returns The value as a branded type\n *\n * @example\n * ```ts\n * import { Brand } from \"@nicolastoulemont/std\"\n *\n * type UserId = Brand.Branded<string, \"UserId\">\n * const raw = \"user_123\" as UserId\n * const userId = Brand.unsafeMake<UserId>(raw)\n * // => unchecked brand cast\n * ```\n *\n * @category Utilities\n */\nexport const unsafeMake = <B extends Branded<unknown, string>>(value: Unbrand<B>): B => {\n  return value as B\n}\n\n/**\n * Create a type guard with validation for a branded type.\n * Returns a refinement predicate that narrows to the branded type.\n *\n * @template T - The base type\n * @template K - The brand key (string literal)\n * @param validator - A function that validates the base value\n * @returns A type guard that returns true if validation passes\n *\n * @example\n * ```ts\n * import { Brand } from \"@nicolastoulemont/std\"\n *\n * type UserId = Brand.Branded<string, \"UserId\">\n * const isUserId = Brand.is<string, \"UserId\">((value) => value.startsWith(\"user_\"))\n * const valid = isUserId(\"user_123\")\n * // => true\n * ```\n *\n * @category Utilities\n */\nexport const is = <T, K extends string>(validator: Validator<T>): ((value: T) => value is Branded<T, K>) => {\n  return (value: T): value is Branded<T, K> => validator(value)\n}\n\n/**\n * Create a validated branded value wrapped in a Result.\n * Returns `Result.ok(brandedValue)` on success, `Result.err(BrandError)` on failure.\n *\n * The returned Result is yieldable in Fx.gen computations via `yield*`.\n *\n * @template B - The branded type\n * @param validator - A function that validates the base value\n * @param errorMessage - Optional custom error message (or function)\n * @returns A function that takes a value and returns a Result\n *\n * @example\n * ```ts\n * import { Brand } from \"@nicolastoulemont/std\"\n *\n * type UserId = Brand.Branded<string, \"UserId\">\n * const toUserId = Brand.refine<UserId>((value) => value.startsWith(\"user_\"), \"Invalid user id\")\n * const parsed = toUserId(\"user_123\" as UserId)\n * // => { _tag: \"Ok\", value: \"user_123\" }\n * ```\n *\n * @category Utilities\n */\nexport const refine = <B extends Branded<unknown, string>>(\n  validator: Validator<Unbrand<B>>,\n  errorMessage?: string | ((value: Unbrand<B>) => string),\n): ((value: Unbrand<B>) => ResultType<B, BrandError<Unbrand<B>>>) => {\n  return (value: Unbrand<B>) => {\n    if (!validator(value)) {\n      const msg = typeof errorMessage === \"function\" ? errorMessage(value) : (errorMessage ?? \"Brand validation failed\")\n      return Result.err({ _tag: \"BrandError\" as const, value, message: msg })\n    }\n    return Result.ok(value as B)\n  }\n}\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"uJAuFA,MAAa,EAA4C,GAChD,EAuBI,EAAkD,GACtD,EAwBI,EAA2B,GAC9B,GAAqC,EAAU,EAAM,CA0BlD,GACX,EACA,IAEQ,GACD,EAAU,EAAM,CAIdC,EAAU,EAAW,CAFnBD,EAAW,CAAE,KAAM,aAAuB,QAAO,QAD5C,OAAO,GAAiB,WAAa,EAAa,EAAM,CAAI,GAAgB,0BAClB,CAAC"}

package/dist/context/index.d.mts

@@ -0,0 +1,2 @@
+import { n as context_d_exports } from "../context-r8ESJiFn.mjs";
+export { context_d_exports as Context };

package/dist/context/index.mjs

@@ -0,0 +1 @@
+import{t as e}from"../context-CCHj1nab.mjs";export{e as Context};

package/dist/context-CCHj1nab.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"./chunk-C934ptG5.mjs";var t=e({add:()=>i,empty:()=>n,get:()=>o,has:()=>s,make:()=>r,merge:()=>a,size:()=>c});const n=()=>({_tag:`Context`,_services:new Map,_Services:void 0}),r=(e,t)=>({_tag:`Context`,_services:new Map([[e.key,t]]),_Services:void 0}),i=(e,t)=>n=>({_tag:`Context`,_services:new Map([...n._services,[e.key,t]]),_Services:void 0}),a=(e,t)=>({_tag:`Context`,_services:new Map([...e._services,...t._services]),_Services:void 0});function o(e,t){if(t===void 0){let t=e;return e=>{let n=e._services.get(t.key);if(n===void 0)throw Error(`Service "${t.key}" not found in context. Available services: [${[...e._services.keys()].join(`, `)}]`);return n}}let n=e,r=t,i=n._services.get(r.key);if(i===void 0)throw Error(`Service "${r.key}" not found in context. Available services: [${[...n._services.keys()].join(`, `)}]`);return i}const s=(e,t)=>e._services.has(t.key),c=e=>e._services.size;export{a as i,n,r,t};
+//# sourceMappingURL=context-CCHj1nab.mjs.map

package/dist/context-CCHj1nab.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-CCHj1nab.mjs","names":["service","impl","ctx"],"sources":["../src/context/context.ts"],"sourcesContent":["/**\n * Immutable service context map used by `Fx`, `Layer`, and `Provide`.\n *\n * **Mental model**\n * - A `Context` is a typed map from service key to implementation.\n * - Use it as the runtime carrier for dependency injection.\n *\n * **Common tasks**\n * - Start with `Context.empty` or `Context.make`.\n * - Combine contexts with `Context.add` and `Context.merge`.\n * - Resolve implementations with `Context.get`.\n *\n * **Gotchas**\n * - `Context.get` throws when a service is missing.\n * - Context values are immutable snapshots.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Context } from \"@nicolastoulemont/std\"\n *\n * const ctx = Context.empty()\n * // => { _tag: \"Context\", _services: Map(0) }\n * ```\n *\n * @module\n */\nimport type { ServiceClass } from \"../service/service\"\n\n/* oxlint-disable no-unsafe-type-assertion -- Context uses phantom service-type markers and overloaded accessors that require narrowed assertions. */\n\n// ============================================================================\n// Context Type\n// ============================================================================\n\n/**\n * Context<Services> is an immutable map storing service implementations.\n * The Services type parameter tracks which services are available.\n *\n * @example\n * ```ts\n * import { Context } from \"@nicolastoulemont/std\"\n *\n * type Example = typeof Context\n * ```\n *\n * @category Models\n */\nexport type Context<Services = never> = {\n  readonly _tag: \"Context\"\n  readonly _services: ReadonlyMap<string, unknown>\n  // Phantom type for tracking available services\n  readonly _Services: Services\n}\n\n// ============================================================================\n// Context Constructors\n// ============================================================================\n\n/**\n * Create an empty context with no services.\n *\n * @example\n * ```ts\n * import { Context } from \"@nicolastoulemont/std\"\n *\n * const ctx = Context.empty()\n * // => { _tag: \"Context\", _services: Map(0) }\n * ```\n *\n * @category Constructors\n */\nexport const empty = (): Context => ({\n  _tag: \"Context\",\n  _services: new Map(),\n  _Services: undefined as never,\n})\n\n/**\n * Create a context with a single service.\n *\n * @param service - The service class (tag)\n * @param impl - The service implementation\n * @returns A context containing the service\n *\n * @example\n * ```ts\n * import { Context } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n * \n * const Logger = Service.tag<{ log: (message: string) => void }>(\"Logger\")\n * const ctx = Context.make(Logger, { log: (message) => console.log(message) })\n * // => context containing Logger\n * ```\n *\n * @category Utilities\n */\nexport const make = <S>(service: ServiceClass<S>, impl: S): Context<S> => ({\n  _tag: \"Context\",\n  _services: new Map([[service.key, impl]]),\n  _Services: undefined as unknown as S,\n})\n\n// ============================================================================\n// Context Operations\n// ============================================================================\n\n/**\n * Add a service to an existing context (returns new context).\n * Curried for use with pipe.\n *\n * @param service - The service class (tag)\n * @param impl - The service implementation\n * @returns A function that takes a context and returns a new context with the service added\n *\n * @example\n * ```ts\n * import { Context } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n * \n * const Logger = Service.tag<{ log: (message: string) => void }>(\"Logger\")\n * const Clock = Service.tag<{ now: () => number }>(\"Clock\")\n * const base = Context.make(Logger, { log: () => undefined })\n * const extended = Context.add(Clock, { now: () => 123 })(base)\n * // => context with Logger and Clock\n * ```\n *\n * @category Utilities\n */\nexport const add =\n  <S>(service: ServiceClass<S>, impl: S) =>\n  <Existing>(ctx: Context<Existing>): Context<Existing | S> => ({\n    _tag: \"Context\",\n    _services: new Map([...ctx._services, [service.key, impl]]),\n    _Services: undefined as unknown as Existing | S,\n  })\n\n/**\n * Merge two contexts together.\n * If both contexts have the same service, the second context's implementation wins.\n *\n * @param a - First context\n * @param b - Second context\n * @returns A new context with services from both\n *\n * @example\n * ```ts\n * import { Context } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n * \n * const Logger = Service.tag<{ log: (message: string) => void }>(\"Logger\")\n * const Clock = Service.tag<{ now: () => number }>(\"Clock\")\n * const a = Context.make(Logger, { log: () => undefined })\n * const b = Context.make(Clock, { now: () => 123 })\n * const merged = Context.merge(a, b)\n * // => context with both services\n * ```\n *\n * @category Utilities\n */\nexport const merge = <A, B>(a: Context<A>, b: Context<B>): Context<A | B> => ({\n  _tag: \"Context\",\n  _services: new Map([...a._services, ...b._services]),\n  _Services: undefined as unknown as A | B,\n})\n\n/**\n * Get a service from a context.\n * Throws if the service is not found.\n *\n * @param service - The service class (tag)\n * @returns The service implementation\n * @throws Error if service not found\n *\n * @example\n * ```ts\n * import { Context } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n * \n * const Port = Service.tag<number>(\"Port\")\n * const ctx = Context.make(Port, 3000)\n * const port = Context.get(ctx, Port)\n * // => 3000\n * ```\n *\n * @category Utilities\n */\n// Use overload to handle both curried and uncurried calls\nexport function get<S>(ctx: Context<S>, service: ServiceClass<S>): S\nexport function get<S>(service: ServiceClass<S>): (ctx: Context<S>) => S\nexport function get<S>(\n  ctxOrService: Context<S> | ServiceClass<S>,\n  maybeService?: ServiceClass<S>,\n): S | ((ctx: Context<S>) => S) {\n  // Curried form: get(service)(ctx)\n  if (maybeService === undefined) {\n    const service = ctxOrService as ServiceClass<S>\n    return (ctx: Context<S>): S => {\n      const impl = ctx._services.get(service.key)\n      if (impl === undefined) {\n        throw new Error(\n          `Service \"${service.key}\" not found in context. Available services: [${[...ctx._services.keys()].join(\", \")}]`,\n        )\n      }\n      return impl as S\n    }\n  }\n\n  // Uncurried form: get(ctx, service)\n  const ctx = ctxOrService as Context<S>\n  const service = maybeService\n  const impl = ctx._services.get(service.key)\n  if (impl === undefined) {\n    throw new Error(\n      `Service \"${service.key}\" not found in context. Available services: [${[...ctx._services.keys()].join(\", \")}]`,\n    )\n  }\n  return impl as S\n}\n\n/**\n * Check if a context contains a specific service.\n *\n * @param ctx - The context to check\n * @param service - The service class (tag)\n * @returns true if the service is in the context\n *\n * @example\n * ```ts\n * import { Context } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n * \n * const Port = Service.tag<number>(\"Port\")\n * const ctx = Context.make(Port, 3000)\n * const present = Context.has(ctx, Port)\n * // => true\n * ```\n *\n * @category Guards\n */\nexport const has = <S>(ctx: Context<unknown>, service: ServiceClass<S>): boolean => ctx._services.has(service.key)\n\n/**\n * Get the size (number of services) in a context.\n *\n * @example\n * ```ts\n * import { Context } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n * \n * const Port = Service.tag<number>(\"Port\")\n * const Logger = Service.tag<{ log: (message: string) => void }>(\"Logger\")\n * const ctx = Context.add(Logger, { log: () => undefined })(Context.make(Port, 3000))\n * const count = Context.size(ctx)\n * // => 2\n * ```\n *\n * @category Getters\n */\nexport const size = (ctx: Context<unknown>): number => ctx._services.size\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"gIAyEA,MAAa,OAAwB,CACnC,KAAM,UACN,UAAW,IAAI,IACf,UAAW,IAAA,GACZ,EAsBY,GAAW,EAA0B,KAAyB,CACzE,KAAM,UACN,UAAW,IAAI,IAAI,CAAC,CAAC,EAAQ,IAAK,EAAK,CAAC,CAAC,CACzC,UAAW,IAAA,GACZ,EA6BY,GACP,EAA0B,IACnB,IAAmD,CAC5D,KAAM,UACN,UAAW,IAAI,IAAI,CAAC,GAAG,EAAI,UAAW,CAAC,EAAQ,IAAK,EAAK,CAAC,CAAC,CAC3D,UAAW,IAAA,GACZ,EA0BU,GAAe,EAAe,KAAmC,CAC5E,KAAM,UACN,UAAW,IAAI,IAAI,CAAC,GAAG,EAAE,UAAW,GAAG,EAAE,UAAU,CAAC,CACpD,UAAW,IAAA,GACZ,EA2BD,SAAgB,EACd,EACA,EAC8B,CAE9B,GAAI,IAAiB,IAAA,GAAW,CAC9B,IAAMA,EAAU,EAChB,MAAQ,IAAuB,CAC7B,IAAMC,EAAOC,EAAI,UAAU,IAAIF,EAAQ,IAAI,CAC3C,GAAIC,IAAS,IAAA,GACX,MAAU,MACR,YAAYD,EAAQ,IAAI,+CAA+C,CAAC,GAAGE,EAAI,UAAU,MAAM,CAAC,CAAC,KAAK,KAAK,CAAC,GAC7G,CAEH,OAAOD,GAKX,IAAM,EAAM,EACN,EAAU,EACV,EAAO,EAAI,UAAU,IAAI,EAAQ,IAAI,CAC3C,GAAI,IAAS,IAAA,GACX,MAAU,MACR,YAAY,EAAQ,IAAI,+CAA+C,CAAC,GAAG,EAAI,UAAU,MAAM,CAAC,CAAC,KAAK,KAAK,CAAC,GAC7G,CAEH,OAAO,EAwBT,MAAa,GAAU,EAAuB,IAAsC,EAAI,UAAU,IAAI,EAAQ,IAAI,CAoBrG,EAAQ,GAAkC,EAAI,UAAU"}