@nicolastoulemont/std 0.2.0 → 0.4.0

package/dist/adt/index.d.mts

@@ -1,2 +1,2 @@
-import { _ as VariantNames, a as record, c as CodecDef, d as Infer, f as InferInput, g as ValidationError, h as RecordObject, i as data, l as CodecError, m as RecordDef, n as MatchHandlers, o as ADT, p as InferOutput, r as match, s as CodecConstraint, t as createCodecError, u as ExtractSchema, v as VariantOf } from "../index-Cp_4sFun.mjs";
+import { _ as VariantNames, a as record, c as CodecDef, d as Infer, f as InferInput, g as ValidationError, h as RecordObject, i as data, l as CodecError, m as RecordDef, n as MatchHandlers, o as ADT, p as InferOutput, r as match, s as CodecConstraint, t as createCodecError, u as ExtractSchema, v as VariantOf } from "../index-FySViSfh.mjs";
 export { ADT, CodecConstraint, CodecDef, CodecError, ExtractSchema, Infer, InferInput, InferOutput, MatchHandlers, RecordDef, RecordObject, ValidationError, VariantNames, VariantOf, createCodecError, data, match, record };

package/dist/adt/index.mjs

@@ -1,3 +1,3 @@
-import { i as createCodecError, n as data, r as record, t as match } from "../adt-DraJkmij.mjs";
+import { i as createCodecError, n as data, r as record, t as match } from "../adt-DH37Pprw.mjs";
 
 export { createCodecError, data, match, record };

package/dist/{adt-DraJkmij.mjs → adt-DH37Pprw.mjs}

@@ -1,6 +1,6 @@
-import { i as createHashMethod, n as createADTHashMethod, r as createEqualsMethod, t as createADTEqualsMethod } from "./equality-YMebYwm1.mjs";
-import { t as isPromise } from "./is-promise-BEl3eGZg.mjs";
-import { n as err, r as ok } from "./result-C5tPWR60.mjs";
+import { i as createHashMethod, n as createADTHashMethod, r as createEqualsMethod, t as createADTEqualsMethod } from "./equality-C2l3BIi8.mjs";
+import { n as isPromise } from "./flow-D4cE0EAg.mjs";
+import { f as ok, r as err } from "./result-DhYA-J-M.mjs";
 
 //#region src/shared/is-plain-object.ts
 /**
@@ -37,26 +37,26 @@ function wrapValidationResult(result) {
 * Validate data using a Standard Schema, enforcing sync-only validation.
 * Throws if the schema returns a Promise.
 */
-function validateSync(schema, data$1, __typename) {
+function validateSync(schema, data$1, _tag) {
 	const result = schema["~standard"].validate(data$1);
-	if (isPromise(result)) throw new Error(`Async validation not supported. Schema for "${__typename}" returned a Promise. Use a synchronous schema or handle async validation separately.`);
+	if (isPromise(result)) throw new Error(`Async validation not supported. Schema for "${_tag}" returned a Promise. Use a synchronous schema or handle async validation separately.`);
 	return wrapValidationResult(result);
 }
 /**
-* Create a type guard function for a specific __typename.
+* Create a type guard function for a specific _tag.
 */
-function createIsGuard(__typename) {
+function createIsGuard(_tag) {
 	return (value) => {
-		return isPlainObject(value) && "__typename" in value && value["__typename"] === __typename;
+		return isPlainObject(value) && "_tag" in value && value["_tag"] === _tag;
 	};
 }
 /**
-* Create a type guard function for multiple __typenames (ADT root guard).
+* Create a type guard function for multiple _tags (ADT root guard).
 */
-function createIsAnyGuard(__typenames) {
-	const __typenameSet = new Set(__typenames);
+function createIsAnyGuard(_tags) {
+	const _tagSet = new Set(_tags);
 	return (value) => {
-		return isPlainObject(value) && "__typename" in value && typeof value["__typename"] === "string" && __typenameSet.has(value["__typename"]);
+		return isPlainObject(value) && "_tag" in value && typeof value["_tag"] === "string" && _tagSet.has(value["_tag"]);
 	};
 }
 
@@ -91,7 +91,7 @@ function createCodecError(kind, message, cause, validationIssues) {
 * Built-in JSON codec that works with any schema.
 * Encodes to JSON string and decodes with JSON.parse.
 */
-function createJsonCodec(__typename) {
+function createJsonCodec(_tag) {
 	return {
 		to: (value) => {
 			return JSON.stringify(value);
@@ -99,8 +99,8 @@ function createJsonCodec(__typename) {
 		from: (input) => {
 			try {
 				const parsed = JSON.parse(input);
-				if (typeof parsed === "object" && parsed !== null && "__typename" in parsed) {
-					const { __typename: _, ...rest } = parsed;
+				if (typeof parsed === "object" && parsed !== null && "_tag" in parsed) {
+					const { _tag: _, ...rest } = parsed;
 					return rest;
 				}
 				return parsed;
@@ -114,13 +114,13 @@ function createJsonCodec(__typename) {
 * Create the "to" methods object with JSON codec and custom codecs.
 * All methods return Result<T, CodecError> for consistent error handling.
 */
-function createToMethods(__typename, schema, customCodecs) {
-	const jsonCodec = createJsonCodec(__typename);
+function createToMethods(_tag, schema, customCodecs) {
+	const jsonCodec = createJsonCodec(_tag);
 	const to = { json: (value) => {
 		const result = validateSync(schema, {
 			...value,
-			__typename
-		}, __typename);
+			_tag
+		}, _tag);
 		if (!result.ok) return err(createCodecError("ValidationError", `Cannot encode invalid data: ${result.error.issues.map((i) => i.message).join(", ")}`, void 0, result.error.issues));
 		try {
 			return ok(jsonCodec.to(result.value));
@@ -131,8 +131,8 @@ function createToMethods(__typename, schema, customCodecs) {
 	if (customCodecs) for (const [name, codec] of Object.entries(customCodecs)) to[name] = (value) => {
 		const result = validateSync(schema, {
 			...value,
-			__typename
-		}, __typename);
+			_tag
+		}, _tag);
 		if (!result.ok) return err(createCodecError("ValidationError", `Cannot encode invalid data: ${result.error.issues.map((i) => i.message).join(", ")}`, void 0, result.error.issues));
 		try {
 			return ok(codec.to(result.value));
@@ -146,19 +146,19 @@ function createToMethods(__typename, schema, customCodecs) {
 * Create the "from" methods object with JSON codec and custom codecs.
 * All methods return Result<T, CodecError> for consistent error handling.
 */
-function createFromMethods(__typename, schema, customCodecs) {
-	const jsonCodec = createJsonCodec(__typename);
+function createFromMethods(_tag, schema, customCodecs) {
+	const jsonCodec = createJsonCodec(_tag);
 	const from = { json: (input) => {
 		const decoded = jsonCodec.from(input);
 		if (decoded === null) return err(createCodecError("DecodingError", "Invalid JSON format"));
 		const result = validateSync(schema, {
 			...decoded,
-			__typename
-		}, __typename);
+			_tag
+		}, _tag);
 		if (!result.ok) return err(createCodecError("ValidationError", "Decoded data failed schema validation", void 0, result.error.issues));
 		return ok({
 			...result.value,
-			__typename
+			_tag
 		});
 	} };
 	if (customCodecs) for (const [name, codec] of Object.entries(customCodecs)) from[name] = (input) => {
@@ -171,12 +171,12 @@ function createFromMethods(__typename, schema, customCodecs) {
 		if (decoded === null) return err(createCodecError("DecodingError", `Codec '${name}' failed to decode input`));
 		const result = validateSync(schema, {
 			...decoded,
-			__typename
-		}, __typename);
+			_tag
+		}, _tag);
 		if (!result.ok) return err(createCodecError("ValidationError", "Decoded data failed schema validation", void 0, result.error.issues));
 		return ok({
 			...result.value,
-			__typename
+			_tag
 		});
 	};
 	return from;
@@ -184,25 +184,25 @@ function createFromMethods(__typename, schema, customCodecs) {
 
 //#endregion
 //#region src/adt/adt.record.ts
-function record(__typename, schema, codecs) {
-	const isGuard = createIsGuard(__typename);
-	const to = createToMethods(__typename, schema, codecs);
-	const from = createFromMethods(__typename, schema, codecs);
-	const equals = createEqualsMethod(__typename);
-	const hash = createHashMethod(__typename);
+function record(_tag, schema, codecs) {
+	const isGuard = createIsGuard(_tag);
+	const to = createToMethods(_tag, schema, codecs);
+	const from = createFromMethods(_tag, schema, codecs);
+	const equals = createEqualsMethod(_tag);
+	const hash = createHashMethod(_tag);
 	const constructor = (input) => {
 		const result = validateSync(schema, {
 			...input,
-			__typename
-		}, __typename);
+			_tag
+		}, _tag);
 		if (!result.ok) return err(result.error);
 		return ok({
 			...result.value,
-			__typename
+			_tag
 		});
 	};
 	constructor._record = true;
-	constructor.__typename = __typename;
+	constructor._tag = _tag;
 	constructor.schema = schema;
 	if (codecs) constructor.codecs = codecs;
 	constructor.is = isGuard;
@@ -222,11 +222,11 @@ function record(__typename, schema, codecs) {
 * - Pre-built RecordObjects from record() (codecs are preserved)
 * - Raw Standard Schema validators (will be wrapped internally)
 *
-* When using pre-built records, the object key overrides the original __typename.
+* When using pre-built records, the object key overrides the original _tag.
 *
 * @template R - Record of variant names to RecordObjects or StandardSchema validators
 * @param name - The name of this ADT (for identification)
-* @param records - An object mapping __typename names to RecordObjects or schemas
+* @param records - An object mapping _tag names to RecordObjects or schemas
 * @returns An ADT object with accessors for each variant
 *
 * @see {@link record} for creating individual record types
@@ -262,17 +262,17 @@ function record(__typename, schema, codecs) {
 * ```
 */
 function data(name, records) {
-	const typenames = Object.keys(records);
+	const tags = Object.keys(records);
 	const variants = {};
-	for (const [__typename, def] of Object.entries(records)) if (isRecord(def)) if (def.__typename === __typename) variants[__typename] = def;
-	else if (def.codecs) variants[__typename] = record(__typename, def.schema, def.codecs);
-	else variants[__typename] = record(__typename, def.schema);
-	else variants[__typename] = record(__typename, def);
+	for (const [_tag, def] of Object.entries(records)) if (isRecord(def)) if (def._tag === _tag) variants[_tag] = def;
+	else if (def.codecs) variants[_tag] = record(_tag, def.schema, def.codecs);
+	else variants[_tag] = record(_tag, def.schema);
+	else variants[_tag] = record(_tag, def);
 	return {
 		_name: name,
-		is: createIsAnyGuard(typenames),
-		equals: createADTEqualsMethod(typenames),
-		hash: createADTHashMethod(typenames),
+		is: createIsAnyGuard(tags),
+		equals: createADTEqualsMethod(tags),
+		hash: createADTHashMethod(tags),
 		...variants
 	};
 }
@@ -285,10 +285,10 @@ function data(name, records) {
 * TypeScript will error if any variant is missing from handlers,
 * ensuring exhaustive handling of all cases.
 *
-* @template T - The discriminated union type (must have readonly __typename)
+* @template T - The discriminated union type (must have readonly _tag)
 * @template TResult - The return type of all handlers
 * @template Handlers - The handler object type (inferred)
-* @param value - A discriminated union value with __typename
+* @param value - A discriminated union value with _tag
 * @param handlers - An object with a handler function for each variant
 * @returns The result of calling the matching handler
 *
@@ -309,10 +309,10 @@ function data(name, records) {
 * ```
 */
 function match(value, handlers) {
-	const handler = handlers[value.__typename];
+	const handler = handlers[value._tag];
 	return handler(value);
 }
 
 //#endregion
 export { createCodecError as i, data as n, record as r, match as t };
-//# sourceMappingURL=adt-DraJkmij.mjs.map
+//# sourceMappingURL=adt-DH37Pprw.mjs.map

package/dist/adt-DH37Pprw.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"adt-DH37Pprw.mjs","names":["data"],"sources":["../src/shared/is-plain-object.ts","../src/adt/adt.utils.ts","../src/adt/adt.codec.ts","../src/adt/adt.record.ts","../src/adt/adt.data.ts","../src/adt/adt.match.ts"],"sourcesContent":["/**\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  const proto = Object.getPrototypeOf(value)\n  return proto === null || proto === 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 { RecordObject, ValidationError } from \"./adt.types\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Check if a value is a RecordObject created by record().\n * RecordObjects are callable functions with static properties.\n */\nexport function isRecord(value: unknown): value is RecordObject {\n  return typeof value === \"function\" && \"_record\" in value && value[\"_record\"] === true\n}\n\n/**\n * Wrap Standard Schema validation result into our Result type.\n */\nfunction wrapValidationResult<T>(result: StandardSchemaV1.Result<T>): Result<T, ValidationError> {\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, ValidationError> {\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 (ADT 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  CodecConstraint,\n  CodecDef,\n  CodecError,\n  InferInput,\n  InferOutput,\n  ValidationError,\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 CodecError with consistent structure.\n */\nexport function createCodecError(\n  kind: CodecError[\"kind\"],\n  message: string,\n  cause?: unknown,\n  validationIssues?: ValidationError[\"issues\"],\n): CodecError {\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): CodecDef<InferOutput<S> & Discriminator<Tag>, string, InferInput<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 InferInput<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, CodecError> for consistent error handling.\n */\nexport function createToMethods<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends CodecConstraint<Tag, S> | undefined = undefined,\n>(_tag: Tag, schema: S, customCodecs?: Codecs): ToMethods<S, Codecs> {\n  type Output = InferOutput<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: InferInput<S>) => Result<any, CodecError>> = {\n    json: (value: InferInput<S>): Result<string, CodecError> => {\n      // First, create a validated record to ensure we're encoding valid data\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.ok) {\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, CodecDef<Output, any, any>]>) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      to[name] = (value: InferInput<S>): Result<any, CodecError> => {\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.ok) {\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, CodecError> for consistent error handling.\n */\nexport function createFromMethods<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends CodecConstraint<Tag, S> | undefined = undefined,\n>(_tag: Tag, schema: S, customCodecs?: Codecs): FromMethods<Tag, S, Codecs> {\n  type Output = InferOutput<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, CodecError>> = {\n    json: (input: string): Result<Output, CodecError> => {\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.ok) {\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, CodecDef<Output, any, any>]>) {\n      from[name] = (input: unknown): Result<Output, CodecError> => {\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.ok) {\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 { CodecConstraint, InferInput, InferOutput, RecordObject, ValidationError } from \"./adt.types\"\nimport { createIsGuard, validateSync } from \"./adt.utils\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Create a standalone tagged record from a Standard Schema with optional codecs.\n *\n * Records can be used independently or composed into an ADT via data().\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 RecordObject with is(), to, and from methods\n *\n * @see {@link data} for composing records 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 record with JSON codec (always included)\n * const Circle = record('Circle', CircleSchema)\n *\n * const result = Circle({ radius: 10 })\n * // { ok: true, 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, CodecError>\n *\n * // Record with custom codec\n * const Circle2 = record('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, CodecError>\n * ```\n */\n// Overload: with codecs\nexport function record<Tag extends string, S extends StandardSchemaV1, Codecs extends CodecConstraint<Tag, S>>(\n  _tag: Tag,\n  schema: S,\n  codecs: Codecs,\n): RecordObject<Tag, S, Codecs>\n\n// Overload: without codecs\nexport function record<Tag extends string, S extends StandardSchemaV1>(_tag: Tag, schema: S): RecordObject<Tag, S>\n\n// Implementation\nexport function record<\n  Tag extends string,\n  S extends StandardSchemaV1,\n  Codecs extends CodecConstraint<Tag, S> | undefined,\n>(_tag: Tag, schema: S, codecs?: Codecs): RecordObject<Tag, S, Codecs> {\n  type Output = InferOutput<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, InferOutput<S>>(_tag)\n  const hash = createHashMethod<Tag, InferOutput<S>>(_tag)\n\n  // Constructor function\n  const constructor = (input: InferInput<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.ok) {\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._record = 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 RecordObject<Tag, S, Codecs>\n}\n","import { createADTEqualsMethod, createADTHashMethod } from \"../equality/equality\"\nimport { record } from \"./adt.record\"\nimport type { ADT, RecordDef, RecordObject } from \"./adt.types\"\nimport { createIsAnyGuard, isRecord } from \"./adt.utils\"\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\"\n\n/**\n * Compose records or schemas into a discriminated union (ADT).\n *\n * Accepts either:\n * - Pre-built RecordObjects from record() (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 RecordObjects or StandardSchema validators\n * @param name - The name of this ADT (for identification)\n * @param records - An object mapping _tag names to RecordObjects or schemas\n * @returns An ADT object with accessors for each variant\n *\n * @see {@link record} for creating individual record types\n * @see {@link match} for exhaustive pattern matching on ADT values\n *\n * @example\n * ```ts\n * // From pre-built records\n * const Circle = record('Circle', CircleSchema)\n * const Square = record('Square', SquareSchema)\n * const Shape = data('Shape', { Circle, Square })\n *\n * // From raw schemas (JSON codec is automatically included)\n * const Shape = data('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 = data('Shape', {\n *   Circle,              // Pre-built record\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 data<R extends Record<string, RecordDef>>(name: string, records: R): ADT<R> {\n  const tags = Object.keys(records)\n  const variants: Record<string, RecordObject> = {}\n\n  for (const [_tag, def] of Object.entries(records)) {\n    if (isRecord(def)) {\n      // Pre-built RecordObject - 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 record with key as _tag\n        // Preserve codecs\n        variants[_tag] = record(_tag, def.schema, def.codecs)\n      } else {\n        // _tag differs from key and no codecs\n        variants[_tag] = record(_tag, def.schema)\n      }\n    } else {\n      // Raw schema - wrap in record\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] = record(_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 ADT return type\n  return {\n    _name: name,\n    is: isAnyVariant,\n    equals,\n    hash,\n    ...variants,\n  } as ADT<R>\n}\n","/**\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 */\nexport type MatchHandlers<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 data} for creating discriminated unions\n * @see {@link record} for creating individual record types\n *\n * @example\n * ```ts\n * const Shape = data('Shape', { Circle, Square })\n * type Shape = Infer<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 MatchHandlers<T, TResult> = MatchHandlers<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"],"mappings":"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"}

package/dist/{apply-fn.types-CXDoeA7D.d.mts → apply-fn.types-0g_9eXRy.d.mts}

@@ -5,4 +5,4 @@ type λ<TA extends any[] = any[], TR = any> = (...args: TA) => TR;
 type ApplyFn<F extends λ, Arg> = F extends ((arg: Arg) => infer R) ? R : F extends ((arg: any) => infer R) ? R : never;
 //#endregion
 export { λ as n, ApplyFn as t };
-//# sourceMappingURL=apply-fn.types-CXDoeA7D.d.mts.map
+//# sourceMappingURL=apply-fn.types-0g_9eXRy.d.mts.map

package/dist/{apply-fn.types-CXDoeA7D.d.mts.map → apply-fn.types-0g_9eXRy.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"apply-fn.types-CXDoeA7D.d.mts","names":[],"sources":["../src/shared/lambda.types.ts","../src/shared/apply-fn.types.ts"],"sourcesContent":[],"mappings":";KACY,kDAAkD,OAAO;;;ACMzD,KAAA,OAAO,CAAA,UAAW,CAAX,EAAA,GAAA,CAAA,GAAqB,CAArB,UAAA,CAAA,GAAA,EAAqC,GAArC,EAAA,GAAA,KAAA,EAAA,IAAA,CAAA,GAEf,CAFe,UAAA,CAAA,GAAA,EAAA,GAAA,EAAA,GAAA,KAAA,EAAA,IAAA,CAAA,GAAA,KAAA"}
+{"version":3,"file":"apply-fn.types-0g_9eXRy.d.mts","names":[],"sources":["../src/shared/lambda.types.ts","../src/shared/apply-fn.types.ts"],"sourcesContent":[],"mappings":";KACY,kDAAkD,OAAO;;;ACMzD,KAAA,OAAO,CAAA,UAAW,CAAX,EAAA,GAAA,CAAA,GAAqB,CAArB,UAAA,CAAA,GAAA,EAAqC,GAArC,EAAA,GAAA,KAAA,EAAA,IAAA,CAAA,GAEf,CAFe,UAAA,CAAA,GAAA,EAAA,GAAA,EAAA,GAAA,KAAA,EAAA,IAAA,CAAA,GAAA,KAAA"}

package/dist/brand/index.d.mts

@@ -1,2 +1,2 @@
-import { a as Branded, i as BrandKey, n as Brand$1, o as Unbrand, r as BrandError, t as Brand } from "../index-BFhV56qy.mjs";
-export { Brand, BrandError, BrandKey, Brand$1 as BrandType, Branded, Unbrand };
+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-Cydt5ocm.mjs";
+export { Brand, BrandError, BrandKey, BrandRefinement, Brand$1 as BrandType, Branded, Unbrand, is, make, refine, unsafeMake };

package/dist/brand/index.mjs

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

package/dist/{brand-CTaxGuU9.mjs → brand-BqcqFXj5.mjs}

@@ -1,4 +1,4 @@
-import { t as Result } from "./result-C5tPWR60.mjs";
+import { t as Result } from "./result-DhYA-J-M.mjs";
 
 //#region src/brand/brand.ts
 /**
@@ -98,10 +98,10 @@ const is = (validator) => {
 * // { ok: true, value: "user@example.com" }
 *
 * const bad = parseEmail("not-an-email")
-* // { ok: false, error: { __typename: "BrandError", value: "not-an-email", message: "..." } }
+* // { ok: false, error: { _tag: "BrandError", value: "not-an-email", message: "..." } }
 *
 * // With Do computation
-* const computation = gen(function* () {
+* const computation = Fx.gen(function* () {
 *   const email = yield* parseEmail(input)
 *   return email
 * })
@@ -120,7 +120,7 @@ const refine = (validator, errorMessage) => {
 		if (!validator(value)) {
 			const msg = typeof errorMessage === "function" ? errorMessage(value) : errorMessage ?? "Brand validation failed";
 			return Result.err({
-				__typename: "BrandError",
+				_tag: "BrandError",
 				value,
 				message: msg
 			});
@@ -161,5 +161,5 @@ const Brand = {
 };
 
 //#endregion
-export { Brand as t };
-//# sourceMappingURL=brand-CTaxGuU9.mjs.map
+export { unsafeMake as a, refine as i, is as n, make as r, Brand as t };
+//# sourceMappingURL=brand-BqcqFXj5.mjs.map

package/dist/{brand-CTaxGuU9.mjs.map → brand-BqcqFXj5.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"brand-CTaxGuU9.mjs","names":[],"sources":["../src/brand/brand.ts"],"sourcesContent":["import { Result } from \"../result\"\nimport type { Result as ResultType } from \"../result/result.types\"\nimport type { BrandError, Branded, Unbrand, Validator } from \"./brand.types\"\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 * type UserId = Branded<string, \"UserId\">\n *\n * // Trust the value from database\n * const userId = Brand.make<UserId>(row.id)\n *\n * // Or use in a validated factory\n * function createUserId(input: string): UserId {\n *   if (!input.startsWith(\"user_\")) throw new Error(\"Invalid\")\n *   return Brand.make<UserId>(input)\n * }\n * ```\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 * type PositiveNumber = Branded<number, \"PositiveNumber\">\n *\n * // Explicitly unsafe - reader knows no validation\n * const n = Brand.unsafeMake<PositiveNumber>(-5) // No error, but logically wrong\n * ```\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 * type PositiveNumber = Branded<number, \"PositiveNumber\">\n *\n * const isPositive = Brand.is<number, \"PositiveNumber\">(n => n > 0)\n *\n * const value: number = 42\n * if (isPositive(value)) {\n *   // value is now PositiveNumber\n *   acceptPositive(value) // OK\n * }\n * ```\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 Do 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 * type Email = Branded<string, \"Email\">\n *\n * const parseEmail = Brand.refine<Email>(\n *   s => s.includes(\"@\"),\n *   (v) => `Invalid email: ${v}`\n * )\n *\n * // Basic usage\n * const result = parseEmail(\"user@example.com\")\n * // { ok: true, value: \"user@example.com\" }\n *\n * const bad = parseEmail(\"not-an-email\")\n * // { ok: false, error: { __typename: \"BrandError\", value: \"not-an-email\", message: \"...\" } }\n *\n * // With Do computation\n * const computation = gen(function* () {\n *   const email = yield* parseEmail(input)\n *   return email\n * })\n *\n * // With pipe\n * pipe(\n *   userInput,\n *   parseEmail,\n *   Result.map(email => sendTo(email)),\n *   Result.unwrapOr(defaultEmail)\n * )\n * ```\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({ __typename: \"BrandError\" as const, value, message: msg })\n    }\n    return Result.ok(value as B)\n  }\n}\n\n/**\n * Brand namespace containing utilities for nominal typing in TypeScript.\n *\n * Brand types add type-level distinctiveness to primitive types without\n * any runtime overhead. This prevents accidental mixing of semantically\n * different values that share the same structural type.\n *\n * @example\n * ```ts\n * import { Brand } from \"@repo/std\"\n * import type { Branded } from \"@repo/std\"\n *\n * // Define branded types\n * type UserId = Branded<string, \"UserId\">\n * type Email = Branded<string, \"Email\">\n *\n * // Create values\n * const userId = Brand.make<UserId>(\"user-123\")\n * const isValidEmail = Brand.is<Email>(s => s.includes(\"@\"))\n *\n * // Type safety\n * function sendEmail(email: Email) { ... }\n * sendEmail(userId) // Type error! UserId is not Email\n * ```\n */\nexport const Brand = {\n  make,\n  unsafeMake,\n  is,\n  refine,\n} as const\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,QAA4C,UAAyB;AAChF,QAAO;;;;;;;;;;;;;;;;;;AAmBT,MAAa,cAAkD,UAAyB;AACtF,QAAO;;;;;;;;;;;;;;;;;;;;;;;;AAyBT,MAAa,MAA2B,cAAoE;AAC1G,SAAQ,UAAqC,UAAU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6C/D,MAAa,UACX,WACA,iBACmE;AACnE,SAAQ,UAAsB;AAC5B,MAAI,CAAC,UAAU,MAAM,EAAE;GACrB,MAAM,MAAM,OAAO,iBAAiB,aAAa,aAAa,MAAM,GAAI,gBAAgB;AACxF,UAAO,OAAO,IAAI;IAAE,YAAY;IAAuB;IAAO,SAAS;IAAK,CAAC;;AAE/E,SAAO,OAAO,GAAG,MAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BhC,MAAa,QAAQ;CACnB;CACA;CACA;CACA;CACD"}
+{"version":3,"file":"brand-BqcqFXj5.mjs","names":[],"sources":["../src/brand/brand.ts"],"sourcesContent":["import { Result } from \"../result\"\nimport type { Result as ResultType } from \"../result/result.types\"\nimport type { BrandError, Branded, Unbrand, Validator } from \"./brand.types\"\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 * type UserId = Branded<string, \"UserId\">\n *\n * // Trust the value from database\n * const userId = Brand.make<UserId>(row.id)\n *\n * // Or use in a validated factory\n * function createUserId(input: string): UserId {\n *   if (!input.startsWith(\"user_\")) throw new Error(\"Invalid\")\n *   return Brand.make<UserId>(input)\n * }\n * ```\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 * type PositiveNumber = Branded<number, \"PositiveNumber\">\n *\n * // Explicitly unsafe - reader knows no validation\n * const n = Brand.unsafeMake<PositiveNumber>(-5) // No error, but logically wrong\n * ```\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 * type PositiveNumber = Branded<number, \"PositiveNumber\">\n *\n * const isPositive = Brand.is<number, \"PositiveNumber\">(n => n > 0)\n *\n * const value: number = 42\n * if (isPositive(value)) {\n *   // value is now PositiveNumber\n *   acceptPositive(value) // OK\n * }\n * ```\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 Do 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 * type Email = Branded<string, \"Email\">\n *\n * const parseEmail = Brand.refine<Email>(\n *   s => s.includes(\"@\"),\n *   (v) => `Invalid email: ${v}`\n * )\n *\n * // Basic usage\n * const result = parseEmail(\"user@example.com\")\n * // { ok: true, value: \"user@example.com\" }\n *\n * const bad = parseEmail(\"not-an-email\")\n * // { ok: false, error: { _tag: \"BrandError\", value: \"not-an-email\", message: \"...\" } }\n *\n * // With Do computation\n * const computation = Fx.gen(function* () {\n *   const email = yield* parseEmail(input)\n *   return email\n * })\n *\n * // With pipe\n * pipe(\n *   userInput,\n *   parseEmail,\n *   Result.map(email => sendTo(email)),\n *   Result.unwrapOr(defaultEmail)\n * )\n * ```\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/**\n * Brand namespace containing utilities for nominal typing in TypeScript.\n *\n * Brand types add type-level distinctiveness to primitive types without\n * any runtime overhead. This prevents accidental mixing of semantically\n * different values that share the same structural type.\n *\n * @example\n * ```ts\n * import { Brand } from \"@repo/std\"\n * import type { Branded } from \"@repo/std\"\n *\n * // Define branded types\n * type UserId = Branded<string, \"UserId\">\n * type Email = Branded<string, \"Email\">\n *\n * // Create values\n * const userId = Brand.make<UserId>(\"user-123\")\n * const isValidEmail = Brand.is<Email>(s => s.includes(\"@\"))\n *\n * // Type safety\n * function sendEmail(email: Email) { ... }\n * sendEmail(userId) // Type error! UserId is not Email\n * ```\n */\nexport const Brand = {\n  make,\n  unsafeMake,\n  is,\n  refine,\n} as const\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,QAA4C,UAAyB;AAChF,QAAO;;;;;;;;;;;;;;;;;;AAmBT,MAAa,cAAkD,UAAyB;AACtF,QAAO;;;;;;;;;;;;;;;;;;;;;;;;AAyBT,MAAa,MAA2B,cAAoE;AAC1G,SAAQ,UAAqC,UAAU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6C/D,MAAa,UACX,WACA,iBACmE;AACnE,SAAQ,UAAsB;AAC5B,MAAI,CAAC,UAAU,MAAM,EAAE;GACrB,MAAM,MAAM,OAAO,iBAAiB,aAAa,aAAa,MAAM,GAAI,gBAAgB;AACxF,UAAO,OAAO,IAAI;IAAE,MAAM;IAAuB;IAAO,SAAS;IAAK,CAAC;;AAEzE,SAAO,OAAO,GAAG,MAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BhC,MAAa,QAAQ;CACnB;CACA;CACA;CACA;CACD"}

package/dist/chunk-DRYujVrt.mjs

@@ -0,0 +1,18 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll as t };

package/dist/data/index.d.mts

@@ -1,2 +1,2 @@
-import { a as ArrayValue, c as TaggedValue, i as tagged, l as TupleValue, n as tuple, o as StructValue, r as struct, s as TaggedConstructor, t as array } from "../index-BCrD3pEs.mjs";
+import { a as ArrayValue, c as TaggedValue, i as tagged, l as TupleValue, n as tuple, o as StructValue, r as struct, s as TaggedConstructor, t as array } from "../index-EmWRCTY3.mjs";
 export { ArrayValue, StructValue, TaggedConstructor, TaggedValue, TupleValue, array, struct, tagged, tuple };

package/dist/data/index.mjs

@@ -1,3 +1,3 @@
-import { i as tagged, n as tuple, r as struct, t as array } from "../data-DgzWI4R_.mjs";
+import { i as tagged, n as tuple, r as struct, t as array } from "../data-Cg8ySt6-.mjs";
 
 export { array, struct, tagged, tuple };

package/dist/{data-DgzWI4R_.mjs → data-Cg8ySt6-.mjs}

@@ -1,4 +1,4 @@
-import { a as deepEquals, i as createHashMethod, o as deepHash, r as createEqualsMethod } from "./equality-YMebYwm1.mjs";
+import { a as deepEquals, i as createHashMethod, o as deepHash, r as createEqualsMethod } from "./equality-C2l3BIi8.mjs";
 
 //#region src/data/data.tagged.ts
 /**
@@ -7,8 +7,8 @@ import { a as deepEquals, i as createHashMethod, o as deepHash, r as createEqual
 * Unlike record(), this creates values directly without validation.
 * Values are frozen and have structural equality via equals() and hash() methods.
 *
-* @template T - The data shape type (excluding __typename)
-* @param typename - The __typename discriminator value
+* @template T - The data shape type (excluding _tag)
+* @param tag - The _tag discriminator value
 * @returns A constructor function with is(), equals(), and hash() methods
 *
 * @see {@link record} for validated records with schema support
@@ -19,7 +19,7 @@ import { a as deepEquals, i as createHashMethod, o as deepHash, r as createEqual
 * const Person = tagged<{ name: string; age: number }>("Person")
 *
 * const alice = Person({ name: "Alice", age: 30 })
-* // => { __typename: "Person", name: "Alice", age: 30 }
+* // => { _tag: "Person", name: "Alice", age: 30 }
 *
 * Person.equals(alice, Person({ name: "Alice", age: 30 })) // true
 * Person.is(alice) // true
@@ -33,19 +33,19 @@ import { a as deepEquals, i as createHashMethod, o as deepHash, r as createEqual
 * alice.name = "Bob" // TypeError
 * ```
 */
-function tagged(typename) {
+function tagged(tag) {
 	const constructor = (input) => {
 		return Object.freeze({
 			...input,
-			__typename: typename
+			_tag: tag
 		});
 	};
 	constructor.is = (value) => {
-		return typeof value === "object" && value !== null && "__typename" in value && value.__typename === typename;
+		return typeof value === "object" && value !== null && "_tag" in value && value._tag === tag;
 	};
-	constructor.equals = createEqualsMethod(typename);
-	constructor.hash = createHashMethod(typename);
-	constructor.__typename = typename;
+	constructor.equals = createEqualsMethod(tag);
+	constructor.hash = createHashMethod(tag);
+	constructor._tag = tag;
 	return constructor;
 }
 
@@ -54,7 +54,7 @@ function tagged(typename) {
 /**
 * Create a frozen value object with structural equality.
 *
-* Unlike tagged(), struct() does not add a __typename discriminator.
+* Unlike tagged(), struct() does not add a _tag discriminator.
 * Use this for simple value objects that don't need discrimination.
 *
 * The returned object is frozen (immutable) and has non-enumerable
@@ -64,7 +64,7 @@ function tagged(typename) {
 * @param input - The object to wrap
 * @returns A frozen object with equals() and hash() methods
 *
-* @see {@link tagged} for discriminated value objects with __typename
+* @see {@link tagged} for discriminated value objects with _tag
 * @see {@link array} for array value types
 *
 * @example
@@ -241,4 +241,4 @@ function array(items) {
 
 //#endregion
 export { tagged as i, tuple as n, struct as r, array as t };
-//# sourceMappingURL=data-DgzWI4R_.mjs.map
+//# sourceMappingURL=data-Cg8ySt6-.mjs.map

package/dist/data-Cg8ySt6-.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-Cg8ySt6-.mjs","names":[],"sources":["../src/data/data.tagged.ts","../src/data/data.struct.ts","../src/data/data.tuple.ts","../src/data/data.array.ts"],"sourcesContent":["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 record(), 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 record} for validated records 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 { 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 { 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","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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAgB,OAA0C,KAA+C;CAIvG,MAAM,eAAe,UAAqB;AACxC,SAAO,OAAO,OAAO;GAAE,GAAG;GAAO,MAAM;GAAK,CAAC;;AAI/C,aAAY,MAAM,UAAoC;AACpD,SACE,OAAO,UAAU,YACjB,UAAU,QACV,UAAU,SAET,MAAwB,SAAS;;AAKtC,aAAY,SAAS,mBAAkC,IAAI;AAG3D,aAAY,OAAO,iBAAgC,IAAI;AAGvD,aAAY,OAAO;AAEnB,QAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC9BT,SAAgB,OAA0C,OAA0B;CAClF,MAAM,QAAQ,EAAE,GAAG,OAAO;AAG1B,QAAO,eAAe,OAAO,UAAU;EACrC,QAAQ,UAAa,WAAW,OAAO,MAAM;EAC7C,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;AAGF,QAAO,eAAe,OAAO,QAAQ;EACnC,aAAa,SAAS,MAAM;EAC5B,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;AAGF,QAAO,OAAO,OAAO,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACrB7B,SAAgB,MAAoC,GAAG,MAAwB;CAC7E,MAAM,QAAQ,CAAC,GAAG,KAAK;AAGvB,QAAO,eAAe,OAAO,UAAU;EACrC,QAAQ,UAA8B,WAAW,OAAO,MAAM;EAC9D,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;AAGF,QAAO,eAAe,OAAO,QAAQ;EACnC,aAAa,SAAS,MAAM;EAC5B,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;AAGF,QAAO,OAAO,OAAO,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACd7B,SAAgB,MAAS,OAAoC;CAC3D,MAAM,QAAQ,CAAC,GAAG,MAAM;AAGxB,QAAO,eAAe,OAAO,UAAU;EACrC,QAAQ,UAAwB,WAAW,OAAO,MAAM;EACxD,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;AAGF,QAAO,eAAe,OAAO,QAAQ;EACnC,aAAa,SAAS,MAAM;EAC5B,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;CAGF,MAAM,cAAc,MAAM,IAAI,KAAK,MAAM;AACzC,QAAO,eAAe,OAAO,OAAO;EAClC,QAAW,OAAwE;AACjF,UAAO,MAAM,YAAY,GAAG,CAAC;;EAE/B,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;CAGF,MAAM,iBAAiB,MAAM,OAAO,KAAK,MAAM;AAC/C,QAAO,eAAe,OAAO,UAAU;EACrC,QAAQ,OAA8E;AACpF,UAAO,MAAM,eAAe,GAAG,CAAC;;EAElC,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;CAGF,MAAM,gBAAgB,MAAM,MAAM,KAAK,MAAM;AAC7C,QAAO,eAAe,OAAO,SAAS;EACpC,QAAQ,OAAgB,QAAgC;AACtD,UAAO,MAAM,cAAc,OAAO,IAAI,CAAC;;EAEzC,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;CAGF,MAAM,iBAAiB,MAAM,OAAO,KAAK,MAAM;AAC/C,QAAO,eAAe,OAAO,UAAU;EACrC,QAAQ,GAAG,SAAuD;AAEhE,UAAO,MAAM,eAAe,GAAI,KAAe,CAAC;;EAElD,YAAY;EACZ,UAAU;EACV,cAAc;EACf,CAAC;AAGF,QAAO,OAAO,OAAO,MAAM"}

package/dist/discriminator.types-D-UbMmAD.d.mts

@@ -0,0 +1,7 @@
+//#region src/shared/discriminator.types.d.ts
+type Discriminator<Tag extends string = string> = {
+  readonly _tag: Tag;
+};
+//#endregion
+export { Discriminator as t };
+//# sourceMappingURL=discriminator.types-D-UbMmAD.d.mts.map

package/dist/discriminator.types-D-UbMmAD.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discriminator.types-D-UbMmAD.d.mts","names":[],"sources":["../src/shared/discriminator.types.ts"],"sourcesContent":[],"mappings":";KAAY;EAAA,SAAA,IAAA,EAA8D,GAAjD"}

package/dist/either/index.d.mts

@@ -1,2 +1,2 @@
-import { r as Either$1, t as Either } from "../index-BiFc2xWF.mjs";
-export { Either, Either$1 as EitherType };
+import { A as FlatMapReturn, C as unwrapOr, D as BimapReturn, E as AllObjectReturn, F as RightValue, I as TapReturn, M as MapLeftReturn, N as MapReturn, O as Either$1, P as OrElseReturn, S as toResult, T as AllArrayReturn, _ as right, a as flatMap, b as tapLeft, c as fromPredicate, d as isRight, f as left, g as orElse, h as match, i as filter, j as LeftValue, k as FilterReturn, l as fromResult, m as mapLeft, n as all, o as fromNullable, p as map, r as bimap, s as fromOption, t as Either, u as isLeft, v as swap, w as unwrapOrElse, x as toOption, y as tap } from "../index-ClxPiGP9.mjs";
+export { AllArrayReturn, AllObjectReturn, BimapReturn, Either, Either$1 as EitherType, FilterReturn, FlatMapReturn, LeftValue, MapLeftReturn, MapReturn, OrElseReturn, RightValue, TapReturn, all, bimap, filter, flatMap, fromNullable, fromOption, fromPredicate, fromResult, isLeft, isRight, left, map, mapLeft, match, orElse, right, swap, tap, tapLeft, toOption, toResult, unwrapOr, unwrapOrElse };

package/dist/either/index.mjs

@@ -1,3 +1,3 @@
-import { t as Either } from "../either-CnOBUH7a.mjs";
+import { C as unwrapOr, S as toResult, _ as right, a as flatMap, b as tapLeft, c as fromPredicate, d as isRight, f as left, g as orElse, h as match, i as filter, l as fromResult, m as mapLeft, n as all, o as fromNullable, p as map, r as bimap, s as fromOption, t as Either, u as isLeft, v as swap, w as unwrapOrElse, x as toOption, y as tap } from "../either-jkBX8xS1.mjs";
 
-export { Either };
+export { Either, all, bimap, filter, flatMap, fromNullable, fromOption, fromPredicate, fromResult, isLeft, isRight, left, map, mapLeft, match, orElse, right, swap, tap, tapLeft, toOption, toResult, unwrapOr, unwrapOrElse };