@nicolastoulemont/std 0.1.0

package/dist/equality/index.d.mts

@@ -0,0 +1,86 @@
+import { t as Discriminator } from "../discriminator.types-DCkkrCj4.mjs";
+
+//#region src/equality/equality.d.ts
+
+/**
+ * Compute a 32-bit hash code for any value using an FNV-1a inspired algorithm.
+ *
+ * Handles: primitives, null, undefined, Date, arrays, and plain objects.
+ * Object keys are sorted for deterministic hashing regardless of insertion order.
+ *
+ * @param value - The value to hash (any type)
+ * @returns A 32-bit unsigned integer hash code
+ *
+ * @example
+ * ```ts
+ * deepHash({ a: 1, b: 2 }) // deterministic number
+ * deepHash({ b: 2, a: 1 }) // same number (keys sorted)
+ * deepHash([1, 2, 3]) === deepHash([1, 2, 3]) // true
+ * ```
+ */
+declare function deepHash(value: unknown): number;
+/**
+ * Deep structural equality comparison for two values.
+ *
+ * Compares by value rather than reference. Handles:
+ * - Primitives (===)
+ * - null and undefined
+ * - Date objects (by timestamp)
+ * - Arrays (element-wise, same length required)
+ * - Plain objects (key-value pairs, same keys required)
+ *
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @returns true if values are structurally equal
+ *
+ * @example
+ * ```ts
+ * deepEquals({ x: 1 }, { x: 1 }) // true
+ * deepEquals([1, 2], [1, 2]) // true
+ * deepEquals(new Date(0), new Date(0)) // true
+ * deepEquals({ a: 1 }, { a: 1, b: 2 }) // false (different keys)
+ * ```
+ */
+declare function deepEquals(a: unknown, b: unknown): boolean;
+/**
+ * Create an equals method for a specific record type.
+ *
+ * Returns a function that compares two values of the same record type.
+ * Returns false if either value doesn't have the expected __typename.
+ *
+ * @template Typename - The discriminator string literal type
+ * @template T - The record's data type (excluding __typename)
+ * @param __typename - The expected __typename discriminator value
+ * @returns A binary equality function for the record type
+ *
+ * @example
+ * ```ts
+ * const equalsPoint = createEqualsMethod<'Point', { x: number; y: number }>('Point')
+ * equalsPoint(
+ *   { __typename: 'Point', x: 1, y: 2 },
+ *   { __typename: 'Point', x: 1, y: 2 }
+ * ) // true
+ * ```
+ */
+declare function createEqualsMethod<Typename extends string, T>(__typename: Typename): (a: T & Discriminator<Typename>, b: T & Discriminator<Typename>) => boolean;
+/**
+ * Create a hash method for a specific record type.
+ *
+ * Returns a function that computes a hash code for values of the record type.
+ * Returns 0 if the value doesn't have the expected __typename.
+ *
+ * @template Typename - The discriminator string literal type
+ * @template T - The record's data type (excluding __typename)
+ * @param __typename - The expected __typename discriminator value
+ * @returns A unary hash function for the record type
+ *
+ * @example
+ * ```ts
+ * const hashPoint = createHashMethod<'Point', { x: number; y: number }>('Point')
+ * hashPoint({ __typename: 'Point', x: 1, y: 2 }) // number
+ * ```
+ */
+declare function createHashMethod<Typename extends string, T>(__typename: Typename): (value: T & Discriminator<Typename>) => number;
+//#endregion
+export { createEqualsMethod, createHashMethod, deepEquals, deepHash };
+//# sourceMappingURL=index.d.mts.map

package/dist/equality/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/equality/equality.ts"],"sourcesContent":[],"mappings":";;;;;;AAyBA;AA4FA;AAgEA;;;;;;;;;AA2BA;;;AAE6B,iBAzLb,QAAA,CAyLa,KAAA,EAAA,OAAA,CAAA,EAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;iBA7Fb,UAAA;;;;;;;;;;;;;;;;;;;;;iBAgEA,2DACF,eACP,IAAI,cAAc,cAAc,IAAI,cAAc;;;;;;;;;;;;;;;;;;iBAyBzC,yDACF,mBACH,IAAI,cAAc"}

package/dist/equality/index.mjs

@@ -0,0 +1,3 @@
+import { a as deepEquals, i as createHashMethod, o as deepHash, r as createEqualsMethod } from "../equality-YMebYwm1.mjs";
+
+export { createEqualsMethod, createHashMethod, deepEquals, deepHash };

package/dist/equality-YMebYwm1.mjs

@@ -0,0 +1,201 @@
+//#region src/equality/equality.ts
+const FNV_OFFSET = 2166136261;
+const FNV_PRIME = 16777619;
+/**
+* Compute a 32-bit hash code for any value using an FNV-1a inspired algorithm.
+*
+* Handles: primitives, null, undefined, Date, arrays, and plain objects.
+* Object keys are sorted for deterministic hashing regardless of insertion order.
+*
+* @param value - The value to hash (any type)
+* @returns A 32-bit unsigned integer hash code
+*
+* @example
+* ```ts
+* deepHash({ a: 1, b: 2 }) // deterministic number
+* deepHash({ b: 2, a: 1 }) // same number (keys sorted)
+* deepHash([1, 2, 3]) === deepHash([1, 2, 3]) // true
+* ```
+*/
+function deepHash(value) {
+	let hash = FNV_OFFSET;
+	if (value === null) return hash ^ 1853189228;
+	if (value === void 0) return hash ^ 1970168933;
+	switch (typeof value) {
+		case "boolean": return hash ^ (value ? 1 : 0);
+		case "number":
+			if (Number.isNaN(value)) return hash ^ 5136718;
+			if (!Number.isFinite(value)) return hash ^ (value > 0 ? 4812390 : 759787110);
+			return hash ^ (value | 0) ^ (value * 1e6 | 0);
+		case "string":
+			for (let i = 0; i < value.length; i++) {
+				hash ^= value.codePointAt(i);
+				hash = Math.imul(hash, FNV_PRIME);
+			}
+			return hash >>> 0;
+		case "object": {
+			if (value instanceof Date) return hash ^ deepHash(value.getTime());
+			if (Array.isArray(value)) {
+				hash ^= 23389;
+				for (let i = 0; i < value.length; i++) {
+					hash ^= deepHash(value[i]);
+					hash = Math.imul(hash, FNV_PRIME);
+				}
+				return hash >>> 0;
+			}
+			hash ^= 31613;
+			const obj = value;
+			const keys = Object.keys(obj).toSorted();
+			for (const key of keys) {
+				hash ^= deepHash(key);
+				hash = Math.imul(hash, FNV_PRIME);
+				hash ^= deepHash(obj[key]);
+				hash = Math.imul(hash, FNV_PRIME);
+			}
+			return hash >>> 0;
+		}
+		default: return hash;
+	}
+}
+/**
+* Deep structural equality comparison for two values.
+*
+* Compares by value rather than reference. Handles:
+* - Primitives (===)
+* - null and undefined
+* - Date objects (by timestamp)
+* - Arrays (element-wise, same length required)
+* - Plain objects (key-value pairs, same keys required)
+*
+* @param a - First value to compare
+* @param b - Second value to compare
+* @returns true if values are structurally equal
+*
+* @example
+* ```ts
+* deepEquals({ x: 1 }, { x: 1 }) // true
+* deepEquals([1, 2], [1, 2]) // true
+* deepEquals(new Date(0), new Date(0)) // true
+* deepEquals({ a: 1 }, { a: 1, b: 2 }) // false (different keys)
+* ```
+*/
+function deepEquals(a, b) {
+	if (a === b) return true;
+	if (typeof a !== typeof b) return false;
+	if (a === null || b === null) return false;
+	if (typeof a !== "object") return false;
+	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		return a.every((item, index) => deepEquals(item, b[index]));
+	}
+	if (Array.isArray(a) !== Array.isArray(b)) return false;
+	const aObj = a;
+	const bObj = b;
+	const aKeys = Object.keys(aObj);
+	const bKeys = Object.keys(bObj);
+	if (aKeys.length !== bKeys.length) return false;
+	return aKeys.every((key) => deepEquals(aObj[key], bObj[key]));
+}
+/**
+* Create an equals method for a specific record type.
+*
+* Returns a function that compares two values of the same record type.
+* Returns false if either value doesn't have the expected __typename.
+*
+* @template Typename - The discriminator string literal type
+* @template T - The record's data type (excluding __typename)
+* @param __typename - The expected __typename discriminator value
+* @returns A binary equality function for the record type
+*
+* @example
+* ```ts
+* const equalsPoint = createEqualsMethod<'Point', { x: number; y: number }>('Point')
+* equalsPoint(
+*   { __typename: 'Point', x: 1, y: 2 },
+*   { __typename: 'Point', x: 1, y: 2 }
+* ) // true
+* ```
+*/
+function createEqualsMethod(__typename) {
+	return (a, b) => {
+		if (a === b) return true;
+		if (a.__typename !== __typename || b.__typename !== __typename) return false;
+		return deepEquals(a, b);
+	};
+}
+/**
+* Create a hash method for a specific record type.
+*
+* Returns a function that computes a hash code for values of the record type.
+* Returns 0 if the value doesn't have the expected __typename.
+*
+* @template Typename - The discriminator string literal type
+* @template T - The record's data type (excluding __typename)
+* @param __typename - The expected __typename discriminator value
+* @returns A unary hash function for the record type
+*
+* @example
+* ```ts
+* const hashPoint = createHashMethod<'Point', { x: number; y: number }>('Point')
+* hashPoint({ __typename: 'Point', x: 1, y: 2 }) // number
+* ```
+*/
+function createHashMethod(__typename) {
+	return (value) => {
+		if (value.__typename !== __typename) return 0;
+		return deepHash(value);
+	};
+}
+/**
+* Create an equals method for an ADT (any variant).
+*
+* Returns a function that compares two ADT values for structural equality.
+* Values must have the same __typename and be a known variant.
+*
+* @template T - The ADT type (union of all variants with __typename)
+* @param typenames - Array of valid __typename values for this ADT
+* @returns A binary equality function for any variant of the ADT
+*
+* @example
+* ```ts
+* const equalsShape = createADTEqualsMethod<Circle | Square>(['Circle', 'Square'])
+* equalsShape(circle1, circle2) // true if structurally equal
+* equalsShape(circle, square) // false (different __typename)
+* ```
+*/
+function createADTEqualsMethod(typenames) {
+	return (a, b) => {
+		if (a === b) return true;
+		if (a.__typename !== b.__typename) return false;
+		if (!typenames.includes(a.__typename)) return false;
+		return deepEquals(a, b);
+	};
+}
+/**
+* Create a hash method for an ADT (any variant).
+*
+* Returns a function that computes a hash code for any variant of the ADT.
+* Returns 0 if the value's __typename is not a known variant.
+*
+* @template T - The ADT type (union of all variants with __typename)
+* @param typenames - Array of valid __typename values for this ADT
+* @returns A unary hash function for any variant of the ADT
+*
+* @example
+* ```ts
+* const hashShape = createADTHashMethod<Circle | Square>(['Circle', 'Square'])
+* hashShape(circle) // number
+* hashShape(square) // number
+* ```
+*/
+function createADTHashMethod(typenames) {
+	return (value) => {
+		if (!typenames.includes(value.__typename)) return 0;
+		return deepHash(value);
+	};
+}
+
+//#endregion
+export { deepEquals as a, createHashMethod as i, createADTHashMethod as n, deepHash as o, createEqualsMethod as r, createADTEqualsMethod as t };
+//# sourceMappingURL=equality-YMebYwm1.mjs.map

package/dist/equality-YMebYwm1.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"equality-YMebYwm1.mjs","names":[],"sources":["../src/equality/equality.ts"],"sourcesContent":["import type { Discriminator } from \"../shared/discriminator.types\"\n\n// ============================================================================\n// Hashing (FNV-1a inspired algorithm)\n// ============================================================================\n\nconst FNV_OFFSET = 2166136261\nconst FNV_PRIME = 16777619\n\n/**\n * Compute a 32-bit hash code for any value using an FNV-1a inspired algorithm.\n *\n * Handles: primitives, null, undefined, Date, arrays, and plain objects.\n * Object keys are sorted for deterministic hashing regardless of insertion order.\n *\n * @param value - The value to hash (any type)\n * @returns A 32-bit unsigned integer hash code\n *\n * @example\n * ```ts\n * deepHash({ a: 1, b: 2 }) // deterministic number\n * deepHash({ b: 2, a: 1 }) // same number (keys sorted)\n * deepHash([1, 2, 3]) === deepHash([1, 2, 3]) // true\n * ```\n */\nexport function deepHash(value: unknown): number {\n  let hash = FNV_OFFSET\n\n  // \"null\" as hex\n  if (value === null) return hash ^ 0x6e756c6c\n  // \"unde\" as hex\n  if (value === undefined) return hash ^ 0x756e6465\n\n  /* oxlint-disable unicorn/prefer-math-trunc, no-case-declarations, switch-exhaustiveness-check -- Bitwise ops are intentional for FNV-1a hash: | 0 truncates to signed 32-bit, >>> 0 converts to unsigned 32-bit (Math.trunc cannot do this). Default case handles function, symbol, bigint. */\n  switch (typeof value) {\n    case \"boolean\":\n      return hash ^ (value ? 1 : 0)\n\n    case \"number\": {\n      // Handle special cases: \"NaN\" as hex\n      if (Number.isNaN(value)) return hash ^ 0x4e614e\n      if (!Number.isFinite(value)) return hash ^ (value > 0 ? 0x496e66 : 0x2d496e66)\n      // Mix the number bits into hash\n      return hash ^ (value | 0) ^ ((value * 1000000) | 0)\n    }\n\n    case \"string\":\n      for (let i = 0; i < value.length; i++) {\n        hash ^= value.codePointAt(i)!\n        hash = Math.imul(hash, FNV_PRIME)\n      }\n      // Convert to unsigned 32-bit\n      return hash >>> 0\n\n    case \"object\": {\n      if (value instanceof Date) {\n        return hash ^ deepHash(value.getTime())\n      }\n\n      if (Array.isArray(value)) {\n        // \"[]\" as hex\n        hash ^= 0x5b5d\n        for (let i = 0; i < value.length; i++) {\n          hash ^= deepHash(value[i])\n          hash = Math.imul(hash, FNV_PRIME)\n        }\n        return hash >>> 0\n      }\n\n      // Plain object: \"{}\" as hex\n      hash ^= 0x7b7d\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for object iteration\n      const obj = value as Record<string, unknown>\n      // Sort keys for consistency\n      const keys = Object.keys(obj).toSorted()\n      for (const key of keys) {\n        hash ^= deepHash(key)\n        hash = Math.imul(hash, FNV_PRIME)\n        hash ^= deepHash(obj[key])\n        hash = Math.imul(hash, FNV_PRIME)\n      }\n      return hash >>> 0\n    }\n\n    default:\n      // Handles: function, symbol, bigint\n      return hash\n  }\n  /* oxlint-enable unicorn/prefer-math-trunc, no-case-declarations */\n}\n\n// ============================================================================\n// Equality\n// ============================================================================\n\n/**\n * Deep structural equality comparison for two values.\n *\n * Compares by value rather than reference. Handles:\n * - Primitives (===)\n * - null and undefined\n * - Date objects (by timestamp)\n * - Arrays (element-wise, same length required)\n * - Plain objects (key-value pairs, same keys required)\n *\n * @param a - First value to compare\n * @param b - Second value to compare\n * @returns true if values are structurally equal\n *\n * @example\n * ```ts\n * deepEquals({ x: 1 }, { x: 1 }) // true\n * deepEquals([1, 2], [1, 2]) // true\n * deepEquals(new Date(0), new Date(0)) // true\n * deepEquals({ a: 1 }, { a: 1, b: 2 }) // false (different keys)\n * ```\n */\nexport function deepEquals(a: unknown, b: unknown): boolean {\n  // Same reference or both null/undefined\n  if (a === b) return true\n\n  // Different types\n  if (typeof a !== typeof b) return false\n\n  // Handle null\n  if (a === null || b === null) return false\n\n  // Primitives (already checked === above)\n  if (typeof a !== \"object\") return false\n\n  // Date comparison\n  if (a instanceof Date && b instanceof Date) {\n    return a.getTime() === b.getTime()\n  }\n\n  // Array comparison\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return false\n    return a.every((item, index) => deepEquals(item, b[index]))\n  }\n\n  // Plain object comparison\n  if (Array.isArray(a) !== Array.isArray(b)) return false\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for object comparison\n  const aObj = a as Record<string, unknown>\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for object comparison\n  const bObj = b as Record<string, unknown>\n\n  const aKeys = Object.keys(aObj)\n  const bKeys = Object.keys(bObj)\n\n  if (aKeys.length !== bKeys.length) return false\n\n  return aKeys.every((key) => deepEquals(aObj[key], bObj[key]))\n}\n\n// ============================================================================\n// Factory Functions\n// ============================================================================\n\n/**\n * Create an equals method for a specific record type.\n *\n * Returns a function that compares two values of the same record type.\n * Returns false if either value doesn't have the expected __typename.\n *\n * @template Typename - The discriminator string literal type\n * @template T - The record's data type (excluding __typename)\n * @param __typename - The expected __typename discriminator value\n * @returns A binary equality function for the record type\n *\n * @example\n * ```ts\n * const equalsPoint = createEqualsMethod<'Point', { x: number; y: number }>('Point')\n * equalsPoint(\n *   { __typename: 'Point', x: 1, y: 2 },\n *   { __typename: 'Point', x: 1, y: 2 }\n * ) // true\n * ```\n */\nexport function createEqualsMethod<Typename extends string, T>(\n  __typename: Typename,\n): (a: T & Discriminator<Typename>, b: T & Discriminator<Typename>) => boolean {\n  return (a, b) => {\n    if (a === b) return true\n    if (a.__typename !== __typename || b.__typename !== __typename) return false\n    return deepEquals(a, b)\n  }\n}\n\n/**\n * Create a hash method for a specific record type.\n *\n * Returns a function that computes a hash code for values of the record type.\n * Returns 0 if the value doesn't have the expected __typename.\n *\n * @template Typename - The discriminator string literal type\n * @template T - The record's data type (excluding __typename)\n * @param __typename - The expected __typename discriminator value\n * @returns A unary hash function for the record type\n *\n * @example\n * ```ts\n * const hashPoint = createHashMethod<'Point', { x: number; y: number }>('Point')\n * hashPoint({ __typename: 'Point', x: 1, y: 2 }) // number\n * ```\n */\nexport function createHashMethod<Typename extends string, T>(\n  __typename: Typename,\n): (value: T & Discriminator<Typename>) => number {\n  return (value) => {\n    if (value.__typename !== __typename) return 0\n    return deepHash(value)\n  }\n}\n\n/**\n * Create an equals method for an ADT (any variant).\n *\n * Returns a function that compares two ADT values for structural equality.\n * Values must have the same __typename and be a known variant.\n *\n * @template T - The ADT type (union of all variants with __typename)\n * @param typenames - Array of valid __typename values for this ADT\n * @returns A binary equality function for any variant of the ADT\n *\n * @example\n * ```ts\n * const equalsShape = createADTEqualsMethod<Circle | Square>(['Circle', 'Square'])\n * equalsShape(circle1, circle2) // true if structurally equal\n * equalsShape(circle, square) // false (different __typename)\n * ```\n */\nexport function createADTEqualsMethod<T extends { readonly __typename: string }>(\n  typenames: string[],\n): (a: T, b: T) => boolean {\n  return (a, b) => {\n    if (a === b) return true\n    if (a.__typename !== b.__typename) return false\n    if (!typenames.includes(a.__typename)) return false\n    return deepEquals(a, b)\n  }\n}\n\n/**\n * Create a hash method for an ADT (any variant).\n *\n * Returns a function that computes a hash code for any variant of the ADT.\n * Returns 0 if the value's __typename is not a known variant.\n *\n * @template T - The ADT type (union of all variants with __typename)\n * @param typenames - Array of valid __typename values for this ADT\n * @returns A unary hash function for any variant of the ADT\n *\n * @example\n * ```ts\n * const hashShape = createADTHashMethod<Circle | Square>(['Circle', 'Square'])\n * hashShape(circle) // number\n * hashShape(square) // number\n * ```\n */\nexport function createADTHashMethod<T extends { readonly __typename: string }>(\n  typenames: string[],\n): (value: T) => number {\n  return (value) => {\n    if (!typenames.includes(value.__typename)) return 0\n    return deepHash(value)\n  }\n}\n"],"mappings":"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"}

package/dist/err/index.d.mts

@@ -0,0 +1,2 @@
+import { a as TaggedError$1, i as ErrorTag, n as TaggedError, o as TaggedErrorFactory, r as ErrorData, s as TaggedErrorInstance, t as Err } from "../index-BR7takNf.mjs";
+export { Err, ErrorData, ErrorTag, TaggedError, TaggedErrorFactory, TaggedErrorInstance, TaggedError$1 as TaggedErrorType };

package/dist/err/index.mjs

@@ -0,0 +1,3 @@
+import { n as TaggedError, t as Err } from "../err-BqQApH9r.mjs";
+
+export { Err, TaggedError };

package/dist/err-BqQApH9r.mjs

@@ -0,0 +1,169 @@
+//#region src/err/err.ts
+/**
+* Create a constructor function for a tagged error type.
+* If the error has no additional data, returns a function that takes no arguments.
+* If the error has data, returns a function that requires the data object.
+*
+* @template E - The tagged error type
+* @param tag - The error tag (must match E's __typename)
+* @returns A constructor function for the error type
+*
+* @example
+* ```ts
+* // Error with data
+* type NotFoundError = TaggedError<"NotFoundError", { resourceId: string }>
+* const NotFound = Err.tagged<NotFoundError>("NotFoundError")
+* const err = NotFound({ resourceId: "user-123" })
+* // { __typename: "NotFoundError", resourceId: "user-123" }
+*
+* // Error without data
+* type UnauthorizedError = TaggedError<"UnauthorizedError">
+* const Unauthorized = Err.tagged<UnauthorizedError>("UnauthorizedError")
+* const err = Unauthorized()
+* // { __typename: "UnauthorizedError" }
+* ```
+*/
+const tagged = (tag) => {
+	return ((data) => ({
+		__typename: tag,
+		...data
+	}));
+};
+/**
+* Create a class-based tagged error type (Effect-style syntax).
+* Returns a class that can be extended to create custom error types.
+* Errors are native Error objects with proper stack traces and instanceof support.
+* Implements Yieldable protocol so errors can be directly yielded in Do computations.
+*
+* @template Tag - The error tag (discriminator string)
+* @param tag - The error tag
+* @returns A class that can be extended with custom data
+*
+* @example
+* ```ts
+* // Error with data
+* class NotFoundError extends TaggedError("NotFoundError")<{ id: string }> {}
+* const err = new NotFoundError({ id: "123" })
+* err.id // "123"
+* err.__typename // "NotFoundError"
+* err.stack // Error stack trace
+*
+* // Error without data
+* class UnauthorizedError extends TaggedError("UnauthorizedError") {}
+* const err2 = new UnauthorizedError()
+*
+* // Direct yielding in Do computation
+* const program = gen(function* () {
+*   yield* new NotFoundError({ id: "123" })  // Short-circuits with error
+* })
+*
+* // instanceof checks work
+* if (err instanceof NotFoundError) {
+*   console.log(err.id)
+* }
+* ```
+*/
+function TaggedError(tag) {
+	return class TaggedErrorImpl extends Error {
+		static __typename = tag;
+		__typename = tag;
+		constructor(...args) {
+			super(tag);
+			this.name = tag;
+			const data = args[0];
+			if (data) Object.assign(this, data);
+			Object.setPrototypeOf(this, new.target.prototype);
+		}
+		*[Symbol.iterator]() {
+			yield this;
+			throw new Error("Unreachable: Do should short-circuit on error");
+		}
+	};
+}
+/**
+* Create a type guard for a tagged error type.
+* Returns a curried function that checks if a value is the specified error type.
+*
+* @template E - The tagged error type to check for
+* @param tag - The error tag to match
+* @returns A type guard function
+*
+* @example
+* ```ts
+* type NotFoundError = TaggedError<"NotFoundError", { id: string }>
+*
+* const error: unknown = getError()
+*
+* if (Err.is<NotFoundError>("NotFoundError")(error)) {
+*   console.log(error.id) // TypeScript knows error is NotFoundError
+* }
+*
+* // Works with union error types
+* type AppError = NotFoundError | ValidationError | DbError
+*
+* function handleError(error: AppError) {
+*   if (Err.is<NotFoundError>("NotFoundError")(error)) {
+*     // Handle not found
+*   } else if (Err.is<ValidationError>("ValidationError")(error)) {
+*     // Handle validation error
+*   }
+* }
+* ```
+*/
+const is = (tag) => {
+	return (error) => typeof error === "object" && error !== null && "__typename" in error && error.__typename === tag;
+};
+/**
+* Err namespace containing utilities for creating and checking tagged errors.
+*
+* Tagged errors are plain objects with a `__typename` discriminator field,
+* making them serializable and easy to pattern match.
+*
+* @example
+* ```ts
+* import { Err, Result, Do } from "@repo/std"
+* import type { TaggedError } from "@repo/std"
+*
+* // Define error types
+* type NotFoundError = TaggedError<"NotFoundError", { resourceId: string }>
+* type ValidationError = TaggedError<"ValidationError", { field: string; message: string }>
+*
+* // Create constructors
+* const NotFound = Err.tagged<NotFoundError>("NotFoundError")
+* const Validation = Err.tagged<ValidationError>("ValidationError")
+*
+* // Use with Result
+* function findUser(id: string): Result<User, NotFoundError> {
+*   const user = db.find(id)
+*   if (!user) return Result.err(NotFound({ resourceId: id }))
+*   return Result.ok(user)
+* }
+*
+* // Use with Do computation
+* const program = gen(function* () {
+*   const user = yield* findUser("123")
+*   return user
+* })
+*
+* // Pattern match on error types
+* pipe(
+*   program.run(),
+*   Result.match({
+*     ok: (user) => console.log(user),
+*     err: (error) => {
+*       if (Err.is<NotFoundError>("NotFoundError")(error)) {
+*         console.log(`Not found: ${error.resourceId}`)
+*       }
+*     }
+*   })
+* )
+* ```
+*/
+const Err = {
+	tagged,
+	is
+};
+
+//#endregion
+export { TaggedError as n, Err as t };
+//# sourceMappingURL=err-BqQApH9r.mjs.map

package/dist/err-BqQApH9r.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"err-BqQApH9r.mjs","names":[],"sources":["../src/err/err.ts"],"sourcesContent":["import type { TaggedError, TaggedErrorFactory } from \"./err.types\"\n\n/**\n * Helper type to extract data fields from a TaggedError (excluding __typename)\n */\ntype DataOf<E extends TaggedError<string>> = Omit<E, \"__typename\">\n\n/**\n * Helper type to check if data is empty (only has __typename)\n */\ntype IsEmptyData<Data> = keyof Data extends never ? true : false\n\n/**\n * Create a constructor function for a tagged error type.\n * If the error has no additional data, returns a function that takes no arguments.\n * If the error has data, returns a function that requires the data object.\n *\n * @template E - The tagged error type\n * @param tag - The error tag (must match E's __typename)\n * @returns A constructor function for the error type\n *\n * @example\n * ```ts\n * // Error with data\n * type NotFoundError = TaggedError<\"NotFoundError\", { resourceId: string }>\n * const NotFound = Err.tagged<NotFoundError>(\"NotFoundError\")\n * const err = NotFound({ resourceId: \"user-123\" })\n * // { __typename: \"NotFoundError\", resourceId: \"user-123\" }\n *\n * // Error without data\n * type UnauthorizedError = TaggedError<\"UnauthorizedError\">\n * const Unauthorized = Err.tagged<UnauthorizedError>(\"UnauthorizedError\")\n * const err = Unauthorized()\n * // { __typename: \"UnauthorizedError\" }\n * ```\n */\nexport const tagged: <E extends TaggedError<string>>(\n  tag: E[\"__typename\"],\n) => IsEmptyData<DataOf<E>> extends true ? () => E : (data: DataOf<E>) => E = (tag) => {\n  return ((data?: object) => ({ __typename: tag, ...data })) as never\n}\n\n/**\n * Create a class-based tagged error type (Effect-style syntax).\n * Returns a class that can be extended to create custom error types.\n * Errors are native Error objects with proper stack traces and instanceof support.\n * Implements Yieldable protocol so errors can be directly yielded in Do computations.\n *\n * @template Tag - The error tag (discriminator string)\n * @param tag - The error tag\n * @returns A class that can be extended with custom data\n *\n * @example\n * ```ts\n * // Error with data\n * class NotFoundError extends TaggedError(\"NotFoundError\")<{ id: string }> {}\n * const err = new NotFoundError({ id: \"123\" })\n * err.id // \"123\"\n * err.__typename // \"NotFoundError\"\n * err.stack // Error stack trace\n *\n * // Error without data\n * class UnauthorizedError extends TaggedError(\"UnauthorizedError\") {}\n * const err2 = new UnauthorizedError()\n *\n * // Direct yielding in Do computation\n * const program = gen(function* () {\n *   yield* new NotFoundError({ id: \"123\" })  // Short-circuits with error\n * })\n *\n * // instanceof checks work\n * if (err instanceof NotFoundError) {\n *   console.log(err.id)\n * }\n * ```\n */\nexport function TaggedError<Tag extends string>(tag: Tag): TaggedErrorFactory<Tag> {\n  return class TaggedErrorImpl<Data extends object = object> extends Error {\n    static readonly __typename: Tag = tag\n    readonly __typename: Tag = tag\n\n    constructor(...args: keyof Data extends never ? [] : [data: Data]) {\n      super(tag)\n      this.name = tag\n      const data = args[0]\n      if (data) Object.assign(this, data)\n      Object.setPrototypeOf(this, new.target.prototype)\n    }\n\n    *[Symbol.iterator](): Generator<this, never, unknown> {\n      yield this\n      throw new Error(\"Unreachable: Do should short-circuit on error\")\n    }\n  } as unknown as TaggedErrorFactory<Tag>\n}\n\n/**\n * Create a type guard for a tagged error type.\n * Returns a curried function that checks if a value is the specified error type.\n *\n * @template E - The tagged error type to check for\n * @param tag - The error tag to match\n * @returns A type guard function\n *\n * @example\n * ```ts\n * type NotFoundError = TaggedError<\"NotFoundError\", { id: string }>\n *\n * const error: unknown = getError()\n *\n * if (Err.is<NotFoundError>(\"NotFoundError\")(error)) {\n *   console.log(error.id) // TypeScript knows error is NotFoundError\n * }\n *\n * // Works with union error types\n * type AppError = NotFoundError | ValidationError | DbError\n *\n * function handleError(error: AppError) {\n *   if (Err.is<NotFoundError>(\"NotFoundError\")(error)) {\n *     // Handle not found\n *   } else if (Err.is<ValidationError>(\"ValidationError\")(error)) {\n *     // Handle validation error\n *   }\n * }\n * ```\n */\nexport const is = <E extends TaggedError<string>>(tag: E[\"__typename\"]): ((error: unknown) => error is E) => {\n  return (error: unknown): error is E =>\n    typeof error === \"object\" && error !== null && \"__typename\" in error && error.__typename === tag\n}\n\n/**\n * Err namespace containing utilities for creating and checking tagged errors.\n *\n * Tagged errors are plain objects with a `__typename` discriminator field,\n * making them serializable and easy to pattern match.\n *\n * @example\n * ```ts\n * import { Err, Result, Do } from \"@repo/std\"\n * import type { TaggedError } from \"@repo/std\"\n *\n * // Define error types\n * type NotFoundError = TaggedError<\"NotFoundError\", { resourceId: string }>\n * type ValidationError = TaggedError<\"ValidationError\", { field: string; message: string }>\n *\n * // Create constructors\n * const NotFound = Err.tagged<NotFoundError>(\"NotFoundError\")\n * const Validation = Err.tagged<ValidationError>(\"ValidationError\")\n *\n * // Use with Result\n * function findUser(id: string): Result<User, NotFoundError> {\n *   const user = db.find(id)\n *   if (!user) return Result.err(NotFound({ resourceId: id }))\n *   return Result.ok(user)\n * }\n *\n * // Use with Do computation\n * const program = gen(function* () {\n *   const user = yield* findUser(\"123\")\n *   return user\n * })\n *\n * // Pattern match on error types\n * pipe(\n *   program.run(),\n *   Result.match({\n *     ok: (user) => console.log(user),\n *     err: (error) => {\n *       if (Err.is<NotFoundError>(\"NotFoundError\")(error)) {\n *         console.log(`Not found: ${error.resourceId}`)\n *       }\n *     }\n *   })\n * )\n * ```\n */\nexport const Err = {\n  tagged,\n  is,\n} as const\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,MAAa,UAEkE,QAAQ;AACrF,UAAS,UAAmB;EAAE,YAAY;EAAK,GAAG;EAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqC1D,SAAgB,YAAgC,KAAmC;AACjF,QAAO,MAAM,wBAAsD,MAAM;EACvE,OAAgB,aAAkB;EAClC,AAAS,aAAkB;EAE3B,YAAY,GAAG,MAAoD;AACjE,SAAM,IAAI;AACV,QAAK,OAAO;GACZ,MAAM,OAAO,KAAK;AAClB,OAAI,KAAM,QAAO,OAAO,MAAM,KAAK;AACnC,UAAO,eAAe,MAAM,IAAI,OAAO,UAAU;;EAGnD,EAAE,OAAO,YAA6C;AACpD,SAAM;AACN,SAAM,IAAI,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCtE,MAAa,MAAqC,QAA2D;AAC3G,SAAQ,UACN,OAAO,UAAU,YAAY,UAAU,QAAQ,gBAAgB,SAAS,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDjG,MAAa,MAAM;CACjB;CACA;CACD"}

package/dist/flow/index.d.mts

@@ -0,0 +1,2 @@
+import { t as flow } from "../index-tkgTLCoq.mjs";
+export { flow };

package/dist/flow/index.mjs

@@ -0,0 +1,3 @@
+import { t as flow } from "../flow-pRdnqmMY.mjs";
+
+export { flow };

package/dist/flow-pRdnqmMY.mjs

@@ -0,0 +1,21 @@
+import { t as isPromise } from "./is-promise-BEl3eGZg.mjs";
+
+//#region src/flow/flow.ts
+function flow(...fns) {
+	return ((...args) => {
+		let nextArgs = args;
+		for (let i = 0; i < fns.length; i++) {
+			const [result] = nextArgs = [fns[i]?.(...nextArgs)];
+			if (isPromise(result)) return resolveAsync(result, fns.slice(i + 1));
+		}
+		return nextArgs[0];
+	});
+}
+const resolveAsync = async (result, funs) => {
+	for (const fun of funs) result = fun(await result);
+	return await result;
+};
+
+//#endregion
+export { flow as t };
+//# sourceMappingURL=flow-pRdnqmMY.mjs.map

package/dist/flow-pRdnqmMY.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-pRdnqmMY.mjs","names":[],"sources":["../src/flow/flow.ts"],"sourcesContent":["import { isPromise } from \"../shared/is-promise\"\nimport type { λ } from \"../shared/lambda.types\"\nimport type { FlowdFun } from \"./flow.types\"\n\n/**\n * Given a list of functions returns a function that will execute the given\n * functions one after another, always passing the result of the previous\n * function as an argument to the next function.\n *\n * If one of the given functions returns a promise, the promise will be resolved\n * before being passed to the next function.\n *\n * Type inference: This function provides automatic type inference for chains of\n * 1-15 functions. Each function's parameter type is automatically inferred from\n * the previous function's return type. For chains longer than 15 functions,\n * types must be explicitly specified.\n *\n * Async support: Functions can return Promises. The runtime automatically awaits\n * Promises before passing values to subsequent functions, and parameter types\n * use `Awaited<T>` to reflect this behavior. The final return type will be\n * Promise<T> if any function returns a Promise.\n *\n * @see {@link pipe} for immediate execution with an initial value\n *\n * @example\n * ```typescript\n * const join = (...chars: string[]) => chars.join('')\n * flow(join, parseInt)('1', '2', '3')  // -> 123\n *\n * const square = (n: number) => n ** 2\n *\n * // this is equivalent to: square(square(square(2)))\n * flow(square, square, square)(2)  // -> 256\n *\n * // Type inference in action\n * const fn = flow(\n *   (n: number) => n * 2,      // First function must be typed\n *   (n) => n + 1,               // n: number (inferred!)\n *   (n) => n.toString()         // n: number (inferred!)\n * )\n *\n * // also works with promises:\n * // fetchNumber :: async () => Promise<number>\n * flow(fetchNumber, n => n.toString())  // async () => Promise<string>\n * ```\n */\n// 1 function\nexport function flow<A extends unknown[], B>(f1: (...args: A) => B): FlowdFun<[typeof f1]>\n// 2 functions\nexport function flow<A extends unknown[], B, C>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n): FlowdFun<[typeof f1, typeof f2]>\n// 3 functions\nexport function flow<A extends unknown[], B, C, D>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n): FlowdFun<[typeof f1, typeof f2, typeof f3]>\n// 4 functions\nexport function flow<A extends unknown[], B, C, D, E>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4]>\n// 5 functions\nexport function flow<A extends unknown[], B, C, D, E, F>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5]>\n// 6 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6]>\n// 7 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7]>\n// 8 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8]>\n// 9 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9]>\n// 10 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n): FlowdFun<\n  [typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10]\n>\n// 11 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n  ]\n>\n// 12 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n  ]\n>\n// 13 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n  ]\n>\n// 14 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n  ]\n>\n// 15 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n  f15: (arg: Awaited<O>) => P,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n    typeof f15,\n  ]\n>\n// Implementation signature (fallback for 16+ functions)\nexport function flow<Fns extends [λ, ...λ[]]>(...fns: Fns): FlowdFun<Fns> {\n  // oxlint-disable-next-line\n  return ((...args) => {\n    // oxlint-disable-next-line\n    let nextArgs: unknown[] = args\n\n    for (let i = 0; i < fns.length; i++) {\n      // oxlint-disable-next-line\n      const [result] = (nextArgs = [fns[i]?.(...nextArgs)])\n      if (isPromise(result)) return resolveAsync(result, fns.slice(i + 1))\n    }\n\n    return nextArgs[0]\n  }) as FlowdFun<Fns>\n}\n\nconst resolveAsync = async (result: unknown, funs: λ[]) => {\n  // oxlint-disable-next-line\n  for (const fun of funs) result = fun(await result)\n  return await result\n}\n"],"mappings":";;;AAoSA,SAAgB,KAA8B,GAAG,KAAyB;AAExE,UAAS,GAAG,SAAS;EAEnB,IAAI,WAAsB;AAE1B,OAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;GAEnC,MAAM,CAAC,UAAW,WAAW,CAAC,IAAI,KAAK,GAAG,SAAS,CAAC;AACpD,OAAI,UAAU,OAAO,CAAE,QAAO,aAAa,QAAQ,IAAI,MAAM,IAAI,EAAE,CAAC;;AAGtE,SAAO,SAAS;;;AAIpB,MAAM,eAAe,OAAO,QAAiB,SAAc;AAEzD,MAAK,MAAM,OAAO,KAAM,UAAS,IAAI,MAAM,OAAO;AAClD,QAAO,MAAM"}

package/dist/gen/index.d.mts

@@ -0,0 +1,3 @@
+import { _ as YieldableError, d as AsyncComputation, f as AsyncGenGenerator, g as Yieldable, h as SyncComputation, m as GenGenerator, p as Computation, v as YieldableValue } from "../result.types-Ce7AEOzj.mjs";
+import { t as gen } from "../index-DPVT0yK4.mjs";
+export { AsyncComputation, AsyncGenGenerator, Computation, GenGenerator, SyncComputation, Yieldable, YieldableError, YieldableValue, gen };

package/dist/gen/index.mjs

@@ -0,0 +1,3 @@
+import { t as gen } from "../gen-YfMC9sDT.mjs";
+
+export { gen };

package/dist/gen-YfMC9sDT.mjs

@@ -0,0 +1,42 @@
+import { n as err, r as ok } from "./result-C5tPWR60.mjs";
+
+//#region src/gen/gen.ts
+/**
+* Implementation of unified gen function.
+* Detects sync vs async generator and returns appropriate computation type.
+*/
+function gen(generatorFn) {
+	const runSync = () => {
+		const gen$1 = generatorFn();
+		if (Symbol.asyncIterator in gen$1) throw new Error("Cannot run sync on async generator. This should not happen if types are correct.");
+		const next = gen$1.next();
+		if (next.done !== true) return err(next.value);
+		return ok(next.value);
+	};
+	const runAsync = async () => {
+		const gen$1 = generatorFn();
+		if (Symbol.asyncIterator in gen$1) {
+			const next = await gen$1.next();
+			if (next.done !== true) return err(next.value);
+			return ok(next.value);
+		}
+		return runSync();
+	};
+	const testGen = generatorFn();
+	if (Symbol.asyncIterator in testGen) return { run: runAsync };
+	return {
+		run: runSync,
+		*[Symbol.iterator]() {
+			const result = runSync();
+			if (!result.ok) {
+				yield result.error;
+				throw new Error("Unreachable: Do should short-circuit on error");
+			}
+			return result.value;
+		}
+	};
+}
+
+//#endregion
+export { gen as t };
+//# sourceMappingURL=gen-YfMC9sDT.mjs.map

package/dist/gen-YfMC9sDT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"gen-YfMC9sDT.mjs","names":["gen"],"sources":["../src/gen/gen.ts"],"sourcesContent":["import { ok, err } from \"../result/result\"\nimport type { Result } from \"../result/result.types\"\nimport type { SyncComputation, AsyncComputation, GenGenerator, AsyncGenGenerator } from \"./gen.types\"\n\n/**\n * Create a computation from a sync generator function.\n * Returns a SyncComputation where run() returns Result directly (no Promise).\n *\n * @template A - The success value type\n * @template E - The error type\n * @param generatorFn - A function that returns a sync generator\n * @returns SyncComputation<A, E>\n *\n * @see {@link run} for immediate execution without storing the computation\n *\n * @example\n * ```ts\n * const result = gen(function* () {\n *   const a = yield* Result.yield(divide(10, 2))\n *   const b = yield* Result.yield(divide(a, 2))\n *   return b\n * }).run()\n * // Type: Result<number, \"DivisionByZero\">\n * ```\n */\nexport function gen<A, E>(generatorFn: () => GenGenerator<A, E>): SyncComputation<A, E>\n\n/**\n * Create a computation from an async generator function.\n * Returns an AsyncComputation where run() returns Promise<Result>.\n *\n * @template A - The success value type\n * @template E - The error type\n * @param generatorFn - A function that returns an async generator\n * @returns AsyncComputation<A, E>\n *\n * @see {@link run} for immediate execution without storing the computation\n *\n * @example\n * ```ts\n * const result = await gen(async function* () {\n *   const data = yield* Result.yield(await fetchData(1))\n *   return data\n * }).run()\n * // Type: Promise<Result<string, \"NetworkError\">>\n * ```\n */\nexport function gen<A, E>(generatorFn: () => AsyncGenGenerator<A, E>): AsyncComputation<A, E>\n\n/**\n * Implementation of unified gen function.\n * Detects sync vs async generator and returns appropriate computation type.\n */\nexport function gen<A, E>(\n  generatorFn: () => GenGenerator<A, E> | AsyncGenGenerator<A, E>,\n): SyncComputation<A, E> | AsyncComputation<A, E> {\n  // Helper to run sync generator\n  const runSync = (): Result<A, E> => {\n    const gen = generatorFn()\n\n    // Detect async generator at runtime (safety check)\n    if (Symbol.asyncIterator in gen) {\n      throw new Error(\"Cannot run sync on async generator. This should not happen if types are correct.\")\n    }\n\n    const syncGen = gen\n    const next = syncGen.next()\n\n    // If not done, an error was yielded (short-circuit)\n    if (next.done !== true) {\n      return err(next.value)\n    }\n\n    return ok(next.value)\n  }\n\n  // Helper to run async generator\n  const runAsync = async (): Promise<Result<A, E>> => {\n    const gen = generatorFn()\n\n    if (Symbol.asyncIterator in gen) {\n      // Async generator path\n      const asyncGen = gen\n      const next = await asyncGen.next()\n\n      if (next.done !== true) {\n        return err(next.value)\n      }\n      return ok(next.value)\n    }\n    // Sync generator can also use run() - just runs synchronously\n    return runSync()\n  }\n\n  // Check if we're dealing with async generator\n  // We need to call it once to check the type\n  const testGen = generatorFn()\n  const isAsync = Symbol.asyncIterator in testGen\n\n  if (isAsync) {\n    // Return AsyncComputation (no Symbol.iterator - can't be yielded in sync context)\n    return {\n      run: runAsync,\n    } as AsyncComputation<A, E>\n  }\n  // Return SyncComputation (with Symbol.iterator for nesting)\n  return {\n    run: runSync,\n    *[Symbol.iterator](): Generator<E, A, unknown> {\n      const result = runSync()\n      if (!result.ok) {\n        yield result.error\n        // This line is never reached because outer Do stops iteration on first yield\n        // But TypeScript needs a return statement for the A type\n        throw new Error(\"Unreachable: Do should short-circuit on error\")\n      }\n      return result.value\n    },\n  } as SyncComputation<A, E>\n}\n"],"mappings":";;;;;;;AAqDA,SAAgB,IACd,aACgD;CAEhD,MAAM,gBAA8B;EAClC,MAAMA,QAAM,aAAa;AAGzB,MAAI,OAAO,iBAAiBA,MAC1B,OAAM,IAAI,MAAM,mFAAmF;EAIrG,MAAM,OADUA,MACK,MAAM;AAG3B,MAAI,KAAK,SAAS,KAChB,QAAO,IAAI,KAAK,MAAM;AAGxB,SAAO,GAAG,KAAK,MAAM;;CAIvB,MAAM,WAAW,YAAmC;EAClD,MAAMA,QAAM,aAAa;AAEzB,MAAI,OAAO,iBAAiBA,OAAK;GAG/B,MAAM,OAAO,MADIA,MACW,MAAM;AAElC,OAAI,KAAK,SAAS,KAChB,QAAO,IAAI,KAAK,MAAM;AAExB,UAAO,GAAG,KAAK,MAAM;;AAGvB,SAAO,SAAS;;CAKlB,MAAM,UAAU,aAAa;AAG7B,KAFgB,OAAO,iBAAiB,QAItC,QAAO,EACL,KAAK,UACN;AAGH,QAAO;EACL,KAAK;EACL,EAAE,OAAO,YAAsC;GAC7C,MAAM,SAAS,SAAS;AACxB,OAAI,CAAC,OAAO,IAAI;AACd,UAAM,OAAO;AAGb,UAAM,IAAI,MAAM,gDAAgD;;AAElE,UAAO,OAAO;;EAEjB"}