@nicolastoulemont/std 0.1.0

package/dist/index-BCrD3pEs.d.mts

@@ -0,0 +1,222 @@
+import { t as Discriminator } from "./discriminator.types-DCkkrCj4.mjs";
+
+//#region src/data/data.types.d.ts
+
+/**
+ * A tagged value object created by tagged().
+ * Contains the data fields plus a readonly __typename discriminator.
+ */
+type TaggedValue<Typename extends string, T> = Readonly<T> & Discriminator<Typename>;
+/**
+ * A tagged value constructor created by tagged().
+ * Can be called as a function to create values, and has static methods
+ * for type checking, equality comparison, and hashing.
+ */
+type TaggedConstructor<Typename extends string, T> = {
+  /** The __typename discriminator value */
+  readonly __typename: Typename;
+  /** Create a new tagged value */
+  (input: T): TaggedValue<Typename, T>;
+  /** Type guard to check if a value is this tagged type */
+  is(value: unknown): value is TaggedValue<Typename, T>;
+  /** Compare two tagged values for structural equality */
+  equals(a: TaggedValue<Typename, T>, b: TaggedValue<Typename, T>): boolean;
+  /** Compute hash code for a tagged value */
+  hash(value: TaggedValue<Typename, T>): number;
+};
+/**
+ * A struct value object created by struct().
+ * A frozen object with equals() and hash() methods (non-enumerable).
+ */
+type StructValue<T extends Record<string, unknown>> = Readonly<T> & {
+  /** Compare with another object for structural equality */
+  equals(other: T): boolean;
+  /** Compute hash code */
+  hash(): number;
+};
+/**
+ * A tuple value object created by tuple().
+ * A frozen array-like with equals() and hash() methods.
+ */
+type TupleValue<T extends readonly unknown[]> = { readonly [K in keyof T]: T[K] } & {
+  readonly length: T["length"];
+  /** Compare with another tuple for structural equality */
+  equals(other: readonly unknown[]): boolean;
+  /** Compute hash code */
+  hash(): number;
+  [Symbol.iterator](): IterableIterator<T[number]>;
+};
+/**
+ * An array value object created by array().
+ * A frozen array with equals(), hash(), and chainable map/filter methods.
+ *
+ * Note: Does not extend ReadonlyArray to allow custom map/filter return types.
+ */
+type ArrayValue<T> = {
+  readonly [index: number]: T;
+  readonly length: number;
+  /** Compare with another array for structural equality */
+  equals(other: ArrayValue<T> | readonly T[]): boolean;
+  /** Compute hash code */
+  hash(): number;
+  /** Map over elements, returning a new ArrayValue */
+  map<U>(fn: (item: T, index: number, array: readonly T[]) => U): ArrayValue<U>;
+  /** Filter elements, returning a new ArrayValue */
+  filter(fn: (item: T, index: number, array: readonly T[]) => boolean): ArrayValue<T>;
+  [Symbol.iterator](): IterableIterator<T>;
+  forEach(fn: (item: T, index: number, array: readonly T[]) => void): void;
+  find(fn: (item: T, index: number, array: readonly T[]) => boolean): T | undefined;
+  findIndex(fn: (item: T, index: number, array: readonly T[]) => boolean): number;
+  some(fn: (item: T, index: number, array: readonly T[]) => boolean): boolean;
+  every(fn: (item: T, index: number, array: readonly T[]) => boolean): boolean;
+  includes(item: T): boolean;
+  indexOf(item: T): number;
+  reduce<U>(fn: (acc: U, item: T, index: number, array: readonly T[]) => U, initial: U): U;
+  slice(start?: number, end?: number): ArrayValue<T>;
+  concat(...items: readonly (T | readonly T[])[]): ArrayValue<T>;
+  join(separator?: string): string;
+};
+//#endregion
+//#region src/data/data.tagged.d.ts
+/**
+ * Create a tagged value constructor without schema validation.
+ *
+ * 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
+ * @returns A constructor function with is(), equals(), and hash() methods
+ *
+ * @see {@link record} for validated records with schema support
+ * @see {@link struct} for untagged value objects
+ *
+ * @example
+ * ```ts
+ * const Person = tagged<{ name: string; age: number }>("Person")
+ *
+ * const alice = Person({ name: "Alice", age: 30 })
+ * // => { __typename: "Person", name: "Alice", age: 30 }
+ *
+ * Person.equals(alice, Person({ name: "Alice", age: 30 })) // true
+ * Person.is(alice) // true
+ *
+ * // Type guard usage
+ * if (Person.is(unknownValue)) {
+ *   console.log(unknownValue.name) // TypeScript knows it's a Person
+ * }
+ *
+ * // Values are frozen (immutable)
+ * alice.name = "Bob" // TypeError
+ * ```
+ */
+declare function tagged<T extends Record<string, unknown>>(typename: string): TaggedConstructor<typeof typename, T>;
+//#endregion
+//#region src/data/data.struct.d.ts
+/**
+ * Create a frozen value object with structural equality.
+ *
+ * Unlike tagged(), struct() does not add a __typename discriminator.
+ * Use this for simple value objects that don't need discrimination.
+ *
+ * The returned object is frozen (immutable) and has non-enumerable
+ * equals() and hash() methods for structural comparison.
+ *
+ * @template T - The object shape type
+ * @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 array} for array value types
+ *
+ * @example
+ * ```ts
+ * const point = struct({ x: 10, y: 20 })
+ * const point2 = struct({ x: 10, y: 20 })
+ *
+ * point.equals(point2) // true
+ * point.hash() // number
+ *
+ * // Object is frozen
+ * point.x = 5 // TypeError
+ *
+ * // equals/hash are non-enumerable
+ * Object.keys(point) // ["x", "y"]
+ * ```
+ */
+declare function struct<T extends Record<string, unknown>>(input: T): StructValue<T>;
+//#endregion
+//#region src/data/data.tuple.d.ts
+/**
+ * Create a tuple with structural equality.
+ *
+ * The returned tuple is frozen (immutable) and has non-enumerable
+ * equals() and hash() methods for structural comparison.
+ *
+ * @template T - The tuple type as a readonly array of element types
+ * @param args - The tuple elements
+ * @returns A frozen tuple-like array with equals() and hash() methods
+ *
+ * @see {@link array} for variable-length arrays with equality
+ * @see {@link struct} for object value types
+ *
+ * @example
+ * ```ts
+ * const t1 = tuple(1, "hello", true)
+ * const t2 = tuple(1, "hello", true)
+ *
+ * t1.equals(t2) // true
+ * t1.hash() // number
+ *
+ * // Access elements (typed)
+ * t1[0] // number
+ * t1[1] // string
+ * t1[2] // boolean
+ *
+ * // Tuple is frozen
+ * t1[0] = 5 // TypeError
+ * ```
+ */
+declare function tuple<T extends readonly unknown[]>(...args: T): TupleValue<T>;
+//#endregion
+//#region src/data/data.array.d.ts
+/**
+ * Create an array with structural equality.
+ *
+ * The returned array is frozen (immutable) and has non-enumerable
+ * equals() and hash() methods for structural comparison.
+ *
+ * The map() and filter() methods are overridden to return ArrayValue,
+ * enabling method chaining with preserved equality semantics.
+ *
+ * @template T - The element type of the array
+ * @param items - The array elements
+ * @returns A frozen array with equals(), hash(), map(), and filter()
+ *
+ * @see {@link tuple} for fixed-length typed tuples
+ * @see {@link struct} for object value types
+ *
+ * @example
+ * ```ts
+ * const arr1 = array([1, 2, 3])
+ * const arr2 = array([1, 2, 3])
+ *
+ * arr1.equals(arr2) // true
+ * arr1.hash() // number
+ *
+ * // Chainable operations return ArrayValue
+ * arr1.map(x => x * 2) // ArrayValue<number>
+ * arr1.filter(x => x > 1) // ArrayValue<number>
+ *
+ * // Chained equality check
+ * arr1.map(x => x * 2).equals(array([2, 4, 6])) // true
+ *
+ * // Array is frozen
+ * arr1[0] = 5 // TypeError
+ * arr1.push(4) // TypeError
+ * ```
+ */
+declare function array<T>(items: readonly T[]): ArrayValue<T>;
+//#endregion
+export { ArrayValue as a, TaggedValue as c, tagged as i, TupleValue as l, tuple as n, StructValue as o, struct as r, TaggedConstructor as s, array as t };
+//# sourceMappingURL=index-BCrD3pEs.d.mts.map

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

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

package/dist/index-BR7takNf.d.mts

@@ -0,0 +1,186 @@
+//#region src/err/err.types.d.ts
+/**
+ * A tagged error type with a discriminator and optional data.
+ * Uses `__typename` to match the existing pattern from `data/tagged`.
+ *
+ * @template Tag - The error tag (discriminator string)
+ * @template Data - Additional error data (optional)
+ *
+ * @example
+ * ```ts
+ * type NotFoundError = TaggedError<"NotFoundError", { id: string }>
+ * type ValidationError = TaggedError<"ValidationError", { field: string; message: string }>
+ * type UnauthorizedError = TaggedError<"UnauthorizedError"> // No additional data
+ * ```
+ */
+type TaggedError$1<Tag extends string, Data extends object = object> = {
+  readonly __typename: Tag;
+} & Readonly<Data>;
+/**
+ * Type for instances created by the TaggedError class factory.
+ * Extends Error and includes the tag, data, and Yieldable protocol.
+ *
+ * @template Tag - The error tag (discriminator string)
+ * @template Data - Additional error data (optional)
+ */
+type TaggedErrorInstance<Tag extends string, Data extends object = object> = Error & Readonly<Data> & {
+  readonly __typename: Tag;
+  [Symbol.iterator](): Generator<TaggedErrorInstance<Tag, Data>, never, unknown>;
+};
+/**
+ * Type for the class returned by TaggedError factory.
+ * Supports the Effect-style curried syntax: `TaggedError("Tag")<{ data }>` and `TaggedError("Tag")`
+ *
+ * @template Tag - The error tag (discriminator string)
+ */
+type TaggedErrorFactory<Tag extends string> = {
+  new <Data extends object = object>(...args: keyof Data extends never ? [] : [data: Data]): TaggedErrorInstance<Tag, Data>;
+  readonly __typename: Tag;
+};
+/**
+ * Extract the tag from a tagged error type.
+ *
+ * @template E - A TaggedError type
+ *
+ * @example
+ * ```ts
+ * type NotFoundError = TaggedError<"NotFoundError", { id: string }>
+ * type Tag = ErrorTag<NotFoundError> // "NotFoundError"
+ * ```
+ */
+type ErrorTag<E> = E extends TaggedError$1<infer Tag> ? Tag : never;
+/**
+ * Extract the data (excluding __typename) from a tagged error type.
+ *
+ * @template E - A TaggedError type
+ *
+ * @example
+ * ```ts
+ * type NotFoundError = TaggedError<"NotFoundError", { id: string }>
+ * type Data = ErrorData<NotFoundError> // { id: string }
+ * ```
+ */
+type ErrorData<E> = E extends TaggedError$1<string, infer Data> ? Data : never;
+//#endregion
+//#region src/err/err.d.ts
+/**
+ * Helper type to extract data fields from a TaggedError (excluding __typename)
+ */
+type DataOf<E extends TaggedError<string>> = Omit<E, "__typename">;
+/**
+ * Helper type to check if data is empty (only has __typename)
+ */
+type IsEmptyData<Data> = keyof Data extends never ? true : false;
+/**
+ * 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" }
+ * ```
+ */
+
+/**
+ * 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)
+ * }
+ * ```
+ */
+declare function TaggedError<Tag extends string>(tag: Tag): TaggedErrorFactory<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}`)
+ *       }
+ *     }
+ *   })
+ * )
+ * ```
+ */
+declare const Err: {
+  readonly tagged: <E extends TaggedError<string>>(tag: E["__typename"]) => IsEmptyData<DataOf<E>> extends true ? () => E : (data: DataOf<E>) => E;
+  readonly is: <E extends TaggedError<string>>(tag: E["__typename"]) => ((error: unknown) => error is E);
+};
+//#endregion
+export { TaggedError$1 as a, ErrorTag as i, TaggedError as n, TaggedErrorFactory as o, ErrorData as r, TaggedErrorInstance as s, Err as t };
+//# sourceMappingURL=index-BR7takNf.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-BR7takNf.d.mts","names":[],"sources":["../src/err/err.types.ts","../src/err/err.ts"],"sourcesContent":[],"mappings":";;AAcA;;;;;AAWA;;;;;;;;AAGyB,KAdb,aAca,CAAA,YAAA,MAAA,EAAA,aAAA,MAAA,GAAA,MAAA,CAAA,GAAA;EAAS,SAAA,UAAA,EAbX,GAaW;AASlC,CAAA,GArBI,QAqBQ,CArBC,IAqBD,CAAA;;;;;;;;AAkBA,KA9BA,mBA8BwB,CAAA,YAAW,MAAA,EAAA,aAAA,MAAA,GAAA,MAAA,CAAA,GA9BqC,KA8BrC,GA7B7C,QA6B6C,CA7BpC,IA6BoC,CAAA,GAAA;EAanC,SAAA,UAAS,EAzCI,GAyCE;uBAxCF,UAAU,oBAAoB,KAAK;;;AC5BM;;;;;AAU7D,KD2BO,kBC3BI,CAAA,YAAmB,MAAA,CAAA,GAAA;EAkEnB,IAAA,CAAA,aAAW,MAAA,GAAA,MAAA,CAAA,CAAA,GAAA,IAAA,EAAA,MDrCR,ICqCQ,SAAA,KAAA,GAAA,EAAA,GAAA,CAAA,IAAA,EDrCyB,ICqCzB,CAAA,CAAA,EDpCtB,mBCoCsB,CDpCF,GCoCE,EDpCG,ICoCH,CAAA;EAA0B,SAAA,UAAA,EDnC9B,GCmC8B;CAAyB;;;AAqG9E;;;;;;;;;AA3I0E,KDiB9D,QCjB8D,CAAA,CAAA,CAAA,GDiBhD,CCjBgD,SDiBtC,aCjBsC,CAAA,KAAA,IAAA,CAAA,GAAA,GAAA,GAAA,KAAA;;;;;;;;;;;;KD8B9D,eAAe,UAAU;;;AAtDrC;;;KCTK,MDWD,CAAA,UCXkB,WDWlB,CAAA,MAAA,CAAA,CAAA,GCXyC,IDWzC,CCX8C,CDW9C,EAAA,YAAA,CAAA;;AASJ;;KCfK,WDgBM,CAAA,IAAA,CAAA,GAAA,MChBoB,IDgBpB,SAAA,KAAA,GAAA,IAAA,GAAA,KAAA;;;;;;;;AAWX;;;;;;;;AAkBA;AAaA;;;;ACpEkE;;;;;AAKjB;AAuEjD;;;;;AAqGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBArGgB,qCAAqC,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqGjE;8BA7ImB,0BACzB,oBACF,YAAY,OAAO,yBAAyB,WAAW,OAAO,OAAO;0BAwF7C,0BAA0B,kDAAgD"}

package/dist/index-CcPnhWje.d.mts

@@ -0,0 +1,72 @@
+//#region src/predicate/predicate.types.d.ts
+/**
+ * A predicate function that tests a value and returns a boolean.
+ *
+ * @template T - The type of value being tested
+ */
+type Predicate$1<T> = (value: T) => boolean;
+/**
+ * A refinement predicate that narrows type T to subtype U.
+ * This is a type guard - when it returns true, TypeScript knows
+ * the value is of the narrower type U.
+ *
+ * @template T - The base type
+ * @template U - The narrower type (must extend T)
+ *
+ * @example
+ * ```ts
+ * // Built-in refinement
+ * const isString: Refinement<unknown, string> = (v): v is string =>
+ *   typeof v === "string"
+ *
+ * // Usage with filter
+ * const mixed: (string | number)[] = ["a", 1, "b", 2]
+ * const strings: string[] = mixed.filter(isString)
+ * ```
+ */
+type Refinement<T, U extends T> = (value: T) => value is U;
+//#endregion
+//#region src/predicate/predicate.d.ts
+
+/**
+ * Predicate namespace containing composable boolean functions.
+ *
+ * Predicates are functions that test values and return booleans.
+ * This namespace provides combinators to build complex predicates
+ * from simple ones, with support for type guards (refinements).
+ *
+ * @example
+ * ```ts
+ * import { Predicate, pipe } from "@repo/std"
+ *
+ * // Basic predicates
+ * const isPositive = (n: number) => n > 0
+ * const isEven = (n: number) => n % 2 === 0
+ *
+ * // Combine with and/or
+ * const isPositiveEven = Predicate.and(isPositive, isEven)
+ * const isZeroOrNegative = Predicate.or(Predicate.equals(0), Predicate.not(isPositive))
+ *
+ * // Array predicates
+ * const allPositive = Predicate.every(isPositive)
+ * const hasNegative = Predicate.some(Predicate.not(isPositive))
+ *
+ * // Use with filter
+ * [1, 2, 3, 4, 5].filter(isPositiveEven) // [2, 4]
+ * ```
+ */
+declare const Predicate: {
+  readonly not: <T>(predicate: Predicate$1<T>) => Predicate$1<T>;
+  readonly and: <T>(...predicates: readonly Predicate$1<T>[]) => Predicate$1<T>;
+  readonly or: <T>(...predicates: readonly Predicate$1<T>[]) => Predicate$1<T>;
+  readonly every: <T>(predicate: Predicate$1<T>) => Predicate$1<readonly T[]>;
+  readonly some: <T>(predicate: Predicate$1<T>) => Predicate$1<readonly T[]>;
+  readonly none: <T>(predicate: Predicate$1<T>) => Predicate$1<readonly T[]>;
+  readonly andRefinement: <T, U extends T>(...refinements: readonly Refinement<T, U>[]) => Refinement<T, U>;
+  readonly orRefinement: <T, U extends T>(...refinements: readonly Refinement<T, U>[]) => Refinement<T, U>;
+  readonly constant: <T>(value: boolean) => Predicate$1<T>;
+  readonly equals: <T>(expected: T) => Predicate$1<T>;
+};
+//#endregion
+export { Predicate$1 as n, Refinement as r, Predicate as t };
+//# sourceMappingURL=index-CcPnhWje.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-CcPnhWje.d.mts","names":[],"sources":["../src/predicate/predicate.types.ts","../src/predicate/predicate.ts"],"sourcesContent":[],"mappings":";;AAKA;AAqBA;;;AAAgE,KArBpD,WAqBoD,CAAA,CAAA,CAAA,GAAA,CAAA,KAAA,EArB7B,CAqB6B,EAAA,GAAA,OAAA;;;;;AC8QhE;;;;;;;;;;;;;;;AA5L8E,KDlFlE,UCkFkE,CAAA,CAAA,EAAA,UDlF1C,CCkF0C,CAAA,GAAA,CAAA,KAAA,EDlF7B,CCkF6B,EAAA,GAAA,KAAA,IDlFd,CCkFc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4LjE;+BAlRqB,YAAc,OAAK,YAAc;4CA0BpB,YAAc,SAAO,YAAc;2CA8BpC,YAAc,SAAO,YAAc;iCA8B7C,YAAc,OAAK,qBAAuB;gCAsB3C,YAAc,OAAK,qBAAuB;gCAuB1C,YAAc,OAAK,qBAAuB;wCA8BlC,4BAA4B,WAAW,GAAG,SAAO,WAAW,GAAG;uCA8BhE,4BAA4B,WAAW,GAAG,SAAO,WAAW,GAAG;4CA0B5D,YAAc;iCA0BvB,MAAI,YAAc"}

package/dist/index-CtJ8Ks9X.d.mts

@@ -0,0 +1,105 @@
+import { i as Result } from "./result.types-Ce7AEOzj.mjs";
+
+//#region src/brand/brand.types.d.ts
+
+/**
+ * Unique symbol for brand keys to ensure true nominal typing.
+ * Using a symbol prevents collision with actual property keys.
+ */
+declare const BrandSymbol: unique symbol;
+/**
+ * A brand type that adds nominal typing to TypeScript.
+ * The brand exists only at the type level - no runtime cost.
+ *
+ * @template K - The brand key (typically a string literal type)
+ */
+type Brand$1<K extends string> = {
+  readonly [BrandSymbol]: K;
+};
+/**
+ * Create a branded type by intersecting a base type with a brand.
+ * The resulting type is structurally compatible with T but nominally unique.
+ *
+ * @template T - The base type to brand
+ * @template K - The brand key (string literal)
+ *
+ * @example
+ * ```ts
+ * type UserId = Branded<string, "UserId">
+ * type OrderId = Branded<string, "OrderId">
+ *
+ * // UserId and OrderId are incompatible even though both are strings
+ * declare const userId: UserId
+ * declare const orderId: OrderId
+ * userId = orderId // Type error!
+ * ```
+ */
+type Branded<T, K extends string> = T & Brand$1<K>;
+/**
+ * Extract the base type from a branded type.
+ * Useful for working with the underlying value.
+ *
+ * @template B - A branded type
+ */
+type Unbrand<B> = B extends Branded<infer T, string> ? T : B;
+/**
+ * Extract the brand key from a branded type.
+ *
+ * @template B - A branded type
+ */
+type BrandKey<B> = B extends Brand$1<infer K> ? K : never;
+/**
+ * A validation function that checks if a value can be branded.
+ * Returns true if the value passes validation, false otherwise.
+ *
+ * @template T - The base type being validated
+ */
+type Validator<T> = (value: T) => boolean;
+/**
+ * Error type returned when brand validation fails.
+ * Contains the original value and error message for debugging.
+ *
+ * @template T - The type of the value that failed validation
+ */
+type BrandError<T = unknown> = {
+  readonly __typename: "BrandError";
+  readonly value: T;
+  readonly message: string;
+};
+//#endregion
+//#region src/brand/brand.d.ts
+
+/**
+ * Brand namespace containing utilities for nominal typing in TypeScript.
+ *
+ * Brand types add type-level distinctiveness to primitive types without
+ * any runtime overhead. This prevents accidental mixing of semantically
+ * different values that share the same structural type.
+ *
+ * @example
+ * ```ts
+ * import { Brand } from "@repo/std"
+ * import type { Branded } from "@repo/std"
+ *
+ * // Define branded types
+ * type UserId = Branded<string, "UserId">
+ * type Email = Branded<string, "Email">
+ *
+ * // Create values
+ * const userId = Brand.make<UserId>("user-123")
+ * const isValidEmail = Brand.is<Email>(s => s.includes("@"))
+ *
+ * // Type safety
+ * function sendEmail(email: Email) { ... }
+ * sendEmail(userId) // Type error! UserId is not Email
+ * ```
+ */
+declare const Brand: {
+  readonly make: <B extends Branded<unknown, string>>(value: Unbrand<B>) => B;
+  readonly unsafeMake: <B extends Branded<unknown, string>>(value: Unbrand<B>) => B;
+  readonly is: <T, K extends string>(validator: Validator<T>) => ((value: T) => value is Branded<T, K>);
+  readonly refine: <B extends Branded<unknown, string>>(validator: Validator<Unbrand<B>>, errorMessage?: string | ((value: Unbrand<B>) => string)) => ((value: Unbrand<B>) => Result<B, BrandError<Unbrand<B>>>);
+};
+//#endregion
+export { Branded as a, BrandKey as i, Brand$1 as n, Unbrand as o, BrandError as r, Validator as s, Brand as t };
+//# sourceMappingURL=index-CtJ8Ks9X.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-CtJ8Ks9X.d.mts","names":[],"sources":["../src/brand/brand.types.ts","../src/brand/brand.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAYA,cARc,WAQG,EAAA,OACL,MAAA;AAqBZ;;;;;AAQA;AAAyB,KA9Bb,OA8Ba,CAAA,UAAA,MAAA,CAAA,GAAA;EAAU,UA7BvB,WAAA,CA6BuB,EA7BT,CA6BS;CAA+B;;AAOlE;AAQA;AAiBA;;;;ACqFA;;;;;;;;;;;AApF2E,KDzC/D,OCyC+D,CAAA,CAAA,EAAA,UAAA,MAAA,CAAA,GDzChC,CCyCgC,GDzC5B,OCyC4B,CDzCtB,CCyCsB,CAAA;;;;;;;AA+C9D,KDhFD,OCgFC,CAAA,CAAA,CAAA,GDhFY,CCgFZ,SDhFsB,OCgFtB,CAAA,KAAA,EAAA,EAAA,MAAA,CAAA,GAAA,CAAA,GDhFqD,CCgFrD;;;;;;AAE+C,KD3EhD,QC2EgD,CAAA,CAAA,CAAA,GD3ElC,CC2EkC,SD3ExB,OC2EwB,CAAA,KAAA,EAAA,CAAA,GAAA,CAAA,GAAA,KAAA;;;;;;;KDnEhD,uBAAuB;;;;;;;KAiBvB;;kBAEM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCmFL;4BAlIkB,iCAAiC,QAAQ,OAAK;kCAoBxC,iCAAiC,QAAQ,OAAK;gDA0BhC,UAAU,gBAAc,eAAe,QAAQ,GAAG;8BA8CpE,qCACpB,UAAU,QAAQ,sCACI,QAAQ,4BAC/B,QAAQ,OAAO,OAAW,GAAG,WAAW,QAAQ"}