@pithos/core 2.3.0 → 2.4.0

package/dist/eidos/bridge/bridge.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Functional Bridge Pattern.
+ *
+ * In OOP, the Bridge pattern requires an Abstraction class hierarchy and a
+ * separate Implementation interface hierarchy, linked via composition.
+ *
+ * In functional TypeScript, a bridge is just a function `(impl) => abstraction`.
+ * The pattern is absorbed by the language — no wrapper needed.
+ *
+ * This module exists for documentation and discoverability. The functions are
+ * identity wrappers marked `@deprecated` to guide developers toward idiomatic
+ * functional code.
+ *
+ * @module eidos/bridge
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/bridge/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * // No import needed — just write a function:
+ * type Renderer = {
+ *   drawCircle: (x: number, y: number, r: number) => void;
+ *   drawRect: (x: number, y: number, w: number, h: number) => void;
+ * };
+ *
+ * const shapes = (impl: Renderer) => ({
+ *   icon: (x: number, y: number) => {
+ *     impl.drawCircle(x, y, 10);
+ *     impl.drawRect(x - 5, y + 15, 10, 5);
+ *   },
+ *   button: (x: number, y: number) => {
+ *     impl.drawRect(x, y, 100, 30);
+ *     impl.drawCircle(x + 10, y + 15, 5);
+ *   },
+ * });
+ *
+ * // Swap implementations freely
+ * const svgShapes = shapes(svgRenderer);
+ * const canvasShapes = shapes(canvasRenderer);
+ * ```
+ */
+/**
+ * A Bridge is a function that takes an implementation and returns an abstraction.
+ * This is just a type alias for documentation — use `(impl: I) => A` directly.
+ *
+ * @internal Not exported in API docs — use inline `(impl: I) => A` instead
+ * @template Impl - The implementation type
+ * @template Abs - The abstraction type
+ * @since 2.4.0
+ */
+export type Bridge<Impl, Abs> = (impl: Impl) => Abs;
+/**
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * In functional TypeScript, a bridge is just `(impl) => abstraction`.
+ * This function is the identity — it exists only so you find this message.
+ *
+ * Write your bridge directly:
+ * ```ts
+ * const repo = (db: DbDriver) => ({
+ *   findById: (id) => db.query(`SELECT * FROM users WHERE id = '${id}'`),
+ *   save: (user) => db.execute(`INSERT INTO users ...`),
+ * });
+ * ```
+ *
+ * @see {@link https://pithos.dev/api/eidos/bridge/ | Full explanation, examples and live demo}
+ * @since 2.4.0
+ */
+export declare function createBridge<Impl, Abs>(factory: (impl: Impl) => Abs): (impl: Impl) => Abs;
+/**
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * Compose two bridges: `(impl) => mid` and `(mid) => abs` into `(impl) => abs`.
+ * This is just function composition — use `(impl) => b(a(impl))` directly.
+ *
+ * @see {@link https://pithos.dev/api/eidos/bridge/ | Full explanation, examples and live demo}
+ * @since 2.4.0
+ */
+export declare function composeBridges<Impl, Mid, Abs>(a: (impl: Impl) => Mid, b: (mid: Mid) => Abs): (impl: Impl) => Abs;
+//# sourceMappingURL=bridge.d.ts.map

package/dist/eidos/bridge/bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../../../src/eidos/bridge/bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH;;;;;;;;GAQG;AACH,MAAM,MAAM,MAAM,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,IAAI,EAAE,IAAI,KAAK,GAAG,CAAC;AAEpD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,EACpC,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,GAAG,GAC3B,CAAC,IAAI,EAAE,IAAI,KAAK,GAAG,CAErB;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,EAC3C,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,GAAG,EACtB,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,GACnB,CAAC,IAAI,EAAE,IAAI,KAAK,GAAG,CAErB"}

package/dist/eidos/bridge/bridge.js

@@ -0,0 +1,75 @@
+/**
+ * Functional Bridge Pattern.
+ *
+ * In OOP, the Bridge pattern requires an Abstraction class hierarchy and a
+ * separate Implementation interface hierarchy, linked via composition.
+ *
+ * In functional TypeScript, a bridge is just a function `(impl) => abstraction`.
+ * The pattern is absorbed by the language — no wrapper needed.
+ *
+ * This module exists for documentation and discoverability. The functions are
+ * identity wrappers marked `@deprecated` to guide developers toward idiomatic
+ * functional code.
+ *
+ * @module eidos/bridge
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/bridge/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * // No import needed — just write a function:
+ * type Renderer = {
+ *   drawCircle: (x: number, y: number, r: number) => void;
+ *   drawRect: (x: number, y: number, w: number, h: number) => void;
+ * };
+ *
+ * const shapes = (impl: Renderer) => ({
+ *   icon: (x: number, y: number) => {
+ *     impl.drawCircle(x, y, 10);
+ *     impl.drawRect(x - 5, y + 15, 10, 5);
+ *   },
+ *   button: (x: number, y: number) => {
+ *     impl.drawRect(x, y, 100, 30);
+ *     impl.drawCircle(x + 10, y + 15, 5);
+ *   },
+ * });
+ *
+ * // Swap implementations freely
+ * const svgShapes = shapes(svgRenderer);
+ * const canvasShapes = shapes(canvasRenderer);
+ * ```
+ */
+/**
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * In functional TypeScript, a bridge is just `(impl) => abstraction`.
+ * This function is the identity — it exists only so you find this message.
+ *
+ * Write your bridge directly:
+ * ```ts
+ * const repo = (db: DbDriver) => ({
+ *   findById: (id) => db.query(`SELECT * FROM users WHERE id = '${id}'`),
+ *   save: (user) => db.execute(`INSERT INTO users ...`),
+ * });
+ * ```
+ *
+ * @see {@link https://pithos.dev/api/eidos/bridge/ | Full explanation, examples and live demo}
+ * @since 2.4.0
+ */
+export function createBridge(factory) {
+    return factory;
+}
+/**
+ * @deprecated **Pattern absorbed by the language.**
+ *
+ * Compose two bridges: `(impl) => mid` and `(mid) => abs` into `(impl) => abs`.
+ * This is just function composition — use `(impl) => b(a(impl))` directly.
+ *
+ * @see {@link https://pithos.dev/api/eidos/bridge/ | Full explanation, examples and live demo}
+ * @since 2.4.0
+ */
+export function composeBridges(a, b) {
+    return (impl) => b(a(impl));
+}
+//# sourceMappingURL=bridge.js.map

package/dist/eidos/bridge/bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.js","sourceRoot":"","sources":["../../../src/eidos/bridge/bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAaH;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,YAAY,CAC1B,OAA4B;IAE5B,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAC5B,CAAsB,EACtB,CAAoB;IAEpB,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;AAC9B,CAAC"}

package/dist/eidos/builder/builder.d.ts

@@ -0,0 +1,181 @@
+/**
+ * Functional Builder Pattern.
+ *
+ * In OOP, the Builder pattern requires a Builder interface, ConcreteBuilder
+ * classes with mutable state, a Product class, and optionally a Director class
+ * to orchestrate construction steps.
+ * In functional TypeScript, a builder is a function that returns an object
+ * with chainable step methods and a final `build()`. Each step returns a new
+ * builder (immutable).
+ *
+ * The Director concept maps to a simple function that takes a builder and
+ * calls steps in a specific sequence — no class needed.
+ *
+ * @module eidos/builder
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * import { createBuilder } from "@pithos/core/eidos/builder/builder";
+ *
+ * const carBuilder = createBuilder({ engine: "", wheels: 0, color: "white" })
+ *   .step("engine", (s, engine: string) => ({ ...s, engine }))
+ *   .step("wheels", (s, wheels: number) => ({ ...s, wheels }))
+ *   .step("color", (s, color: string) => ({ ...s, color }))
+ *   .done();
+ *
+ * const car = carBuilder()
+ *   .engine("V8")
+ *   .wheels(4)
+ *   .color("red")
+ *   .build();
+ * // { engine: "V8", wheels: 4, color: "red" }
+ * ```
+ */
+import type { Result } from "../../zygos/result/result.js";
+/**
+ * Intermediate builder definition that accumulates steps.
+ *
+ * @template State - The product state being built
+ * @template Methods - Accumulated method signatures
+ * @since 2.4.0
+ */
+export interface BuilderDefinition<State, Methods extends object> {
+    /**
+     * Adds a step to the builder.
+     *
+     * @template K - The method name
+     * @template Arg - The argument type for this step
+     * @param name - The method name
+     * @param fn - The step function
+     */
+    step<K extends string, Arg>(name: K, fn: (state: State, arg: Arg) => State): BuilderDefinition<State, Methods & {
+        [P in K]: (arg: Arg) => unknown;
+    }>;
+    /**
+     * Finalizes the definition and returns a builder factory.
+     */
+    done(): () => FinalBuilder<State, Methods>;
+}
+/**
+ * The final builder object with chainable step methods.
+ *
+ * @template State - The product state being built
+ * @template Methods - The step method signatures
+ * @since 2.4.0
+ */
+export type FinalBuilder<State, Methods extends object> = {
+    [K in keyof Methods]: Methods[K] extends (arg: infer Arg) => unknown ? (arg: Arg) => FinalBuilder<State, Methods> : never;
+} & {
+    /** Returns the built product. */
+    build: () => State;
+    /** Returns the current state without finalizing. */
+    current: () => State;
+};
+/**
+ * Creates an immutable builder definition.
+ *
+ * Use `.step(name, fn)` to add steps, then `.done()` to get the factory.
+ * Each step method on the final builder returns a new builder (immutable).
+ *
+ * @template State - The product type being built
+ * @param initial - The initial state
+ * @returns A builder definition to chain `.step()` calls
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const queryBuilder = createBuilder({ table: "", where: [] as string[], limit: 100 })
+ *   .step("from", (s, table: string) => ({ ...s, table }))
+ *   .step("where", (s, clause: string) => ({ ...s, where: [...s.where, clause] }))
+ *   .step("limit", (s, n: number) => ({ ...s, limit: n }))
+ *   .done();
+ *
+ * const q = queryBuilder()
+ *   .from("users")
+ *   .where("active = true")
+ *   .limit(10)
+ *   .build();
+ * ```
+ */
+export declare function createBuilder<State>(initial: State): BuilderDefinition<State, object>;
+/**
+ * Validated builder definition that accumulates steps.
+ *
+ * @template State - The product state being built
+ * @template Methods - Accumulated method signatures
+ * @since 2.4.0
+ */
+export interface ValidatedBuilderDefinition<State, Methods extends object> {
+    /**
+     * Adds a step to the builder.
+     */
+    step<K extends string, Arg>(name: K, fn: (state: State, arg: Arg) => State): ValidatedBuilderDefinition<State, Methods & {
+        [P in K]: (arg: Arg) => unknown;
+    }>;
+    /**
+     * Finalizes with a validator. `build()` returns `Result<State, string>`.
+     *
+     * @param validate - Returns `true` if valid, or an error message string
+     */
+    done(validate: (state: State) => true | string): () => ValidatedFinalBuilder<State, Methods>;
+}
+/**
+ * Builder with validated build() returning Result.
+ *
+ * @template State - The product state being built
+ * @template Methods - The step method signatures
+ * @since 2.4.0
+ */
+export type ValidatedFinalBuilder<State, Methods extends object> = {
+    [K in keyof Methods]: Methods[K] extends (arg: infer Arg) => unknown ? (arg: Arg) => ValidatedFinalBuilder<State, Methods> : never;
+} & {
+    /** Returns Ok(state) if valid, Err(message) otherwise. */
+    build: () => Result<State, string>;
+    /** Returns the current state without validation. */
+    current: () => State;
+};
+/**
+ * Creates a builder with validation on `build()`.
+ *
+ * Same as `createBuilder`, but `.done(validate)` takes a validator.
+ * `build()` returns `Result<State, string>`.
+ *
+ * @template State - The product type being built
+ * @param initial - The initial state
+ * @returns A validated builder definition
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const configBuilder = createValidatedBuilder({ host: "", port: 0 })
+ *   .step("host", (s, host: string) => ({ ...s, host }))
+ *   .step("port", (s, port: number) => ({ ...s, port }))
+ *   .done((s) => s.host ? true : "host is required");
+ *
+ * configBuilder().port(8080).build();         // Err("host is required")
+ * configBuilder().host("localhost").build(); // Ok({ host: "localhost", port: 0 })
+ * ```
+ */
+export declare function createValidatedBuilder<State>(initial: State): ValidatedBuilderDefinition<State, object>;
+/**
+ * A Director is a function that orchestrates builder steps in a specific sequence.
+ * This is the functional equivalent of the GoF Director class.
+ *
+ * @template B - The builder type
+ * @template State - The product type
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * // Director as a simple function
+ * const buildSportsCar: Director<ReturnType<typeof carBuilder>, Car> = (b) =>
+ *   b.engine("V8").wheels(4).color("red");
+ *
+ * const car = buildSportsCar(carBuilder()).build();
+ * ```
+ */
+export type Director<B, State> = (builder: B) => {
+    build: () => State;
+};
+//# sourceMappingURL=builder.d.ts.map

package/dist/eidos/builder/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../../src/eidos/builder/builder.ts"],"names":[],"mappings":"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"}

package/dist/eidos/builder/builder.js

@@ -0,0 +1,139 @@
+/**
+ * Functional Builder Pattern.
+ *
+ * In OOP, the Builder pattern requires a Builder interface, ConcreteBuilder
+ * classes with mutable state, a Product class, and optionally a Director class
+ * to orchestrate construction steps.
+ * In functional TypeScript, a builder is a function that returns an object
+ * with chainable step methods and a final `build()`. Each step returns a new
+ * builder (immutable).
+ *
+ * The Director concept maps to a simple function that takes a builder and
+ * calls steps in a specific sequence — no class needed.
+ *
+ * @module eidos/builder
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * import { createBuilder } from "@pithos/core/eidos/builder/builder";
+ *
+ * const carBuilder = createBuilder({ engine: "", wheels: 0, color: "white" })
+ *   .step("engine", (s, engine: string) => ({ ...s, engine }))
+ *   .step("wheels", (s, wheels: number) => ({ ...s, wheels }))
+ *   .step("color", (s, color: string) => ({ ...s, color }))
+ *   .done();
+ *
+ * const car = carBuilder()
+ *   .engine("V8")
+ *   .wheels(4)
+ *   .color("red")
+ *   .build();
+ * // { engine: "V8", wheels: 4, color: "red" }
+ * ```
+ */
+import { ok, err } from "../../zygos/result/result.js";
+/**
+ * Creates an immutable builder definition.
+ *
+ * Use `.step(name, fn)` to add steps, then `.done()` to get the factory.
+ * Each step method on the final builder returns a new builder (immutable).
+ *
+ * @template State - The product type being built
+ * @param initial - The initial state
+ * @returns A builder definition to chain `.step()` calls
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const queryBuilder = createBuilder({ table: "", where: [] as string[], limit: 100 })
+ *   .step("from", (s, table: string) => ({ ...s, table }))
+ *   .step("where", (s, clause: string) => ({ ...s, where: [...s.where, clause] }))
+ *   .step("limit", (s, n: number) => ({ ...s, limit: n }))
+ *   .done();
+ *
+ * const q = queryBuilder()
+ *   .from("users")
+ *   .where("active = true")
+ *   .limit(10)
+ *   .build();
+ * ```
+ */
+export function createBuilder(initial) {
+    const steps = new Map();
+    const definition = {
+        step(name, fn) {
+            // INTENTIONAL: runtime metaprogramming, type safety via generics
+            steps.set(name, fn);
+            // INTENTIONAL: accumulate method types via intersection, TS can't track dynamically
+            return definition;
+        },
+        done() {
+            const makeBuilder = (state) => {
+                const builder = {
+                    build: () => state,
+                    current: () => state,
+                };
+                for (const [name, fn] of steps) {
+                    builder[name] = (arg) => makeBuilder(fn(state, arg));
+                }
+                // INTENTIONAL: dynamic object, type enforced by steps Map
+                return builder;
+            };
+            return () => makeBuilder(initial);
+        },
+    };
+    return definition;
+}
+/**
+ * Creates a builder with validation on `build()`.
+ *
+ * Same as `createBuilder`, but `.done(validate)` takes a validator.
+ * `build()` returns `Result<State, string>`.
+ *
+ * @template State - The product type being built
+ * @param initial - The initial state
+ * @returns A validated builder definition
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const configBuilder = createValidatedBuilder({ host: "", port: 0 })
+ *   .step("host", (s, host: string) => ({ ...s, host }))
+ *   .step("port", (s, port: number) => ({ ...s, port }))
+ *   .done((s) => s.host ? true : "host is required");
+ *
+ * configBuilder().port(8080).build();         // Err("host is required")
+ * configBuilder().host("localhost").build(); // Ok({ host: "localhost", port: 0 })
+ * ```
+ */
+export function createValidatedBuilder(initial) {
+    const steps = new Map();
+    const definition = {
+        step(name, fn) {
+            // INTENTIONAL: runtime metaprogramming
+            steps.set(name, fn);
+            // INTENTIONAL: dynamic type accumulation
+            return definition;
+        },
+        done(validate) {
+            const makeBuilder = (state) => {
+                const builder = {
+                    build: () => {
+                        const result = validate(state);
+                        return result === true ? ok(state) : err(result);
+                    },
+                    current: () => state,
+                };
+                for (const [name, fn] of steps) {
+                    builder[name] = (arg) => makeBuilder(fn(state, arg));
+                }
+                // INTENTIONAL: dynamic object construction
+                return builder;
+            };
+            return () => makeBuilder(initial);
+        },
+    };
+    return definition;
+}
+//# sourceMappingURL=builder.js.map

package/dist/eidos/builder/builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.js","sourceRoot":"","sources":["../../../src/eidos/builder/builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAC;AAgD/C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,aAAa,CAC3B,OAAc;IAGd,MAAM,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;IAExC,MAAM,UAAU,GAAqC;QACnD,IAAI,CACF,IAAO,EACP,EAAqC;YAErC,iEAAiE;YACjE,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,EAAY,CAAC,CAAC;YAC9B,oFAAoF;YACpF,OAAO,UAGN,CAAC;QACJ,CAAC;QAED,IAAI;YACF,MAAM,WAAW,GAAG,CAAC,KAAY,EAA+B,EAAE;gBAChE,MAAM,OAAO,GAA4B;oBACvC,KAAK,EAAE,GAAG,EAAE,CAAC,KAAK;oBAClB,OAAO,EAAE,GAAG,EAAE,CAAC,KAAK;iBACrB,CAAC;gBAEF,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC;oBAC/B,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,GAAY,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;gBAChE,CAAC;gBAED,0DAA0D;gBAC1D,OAAO,OAAsC,CAAC;YAChD,CAAC,CAAC;YAEF,OAAO,GAAG,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;KACF,CAAC;IAEF,OAAO,UAAU,CAAC;AACpB,CAAC;AA+CD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,sBAAsB,CACpC,OAAc;IAGd,MAAM,KAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;IAExC,MAAM,UAAU,GAA8C;QAC5D,IAAI,CACF,IAAO,EACP,EAAqC;YAErC,uCAAuC;YACvC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,EAAY,CAAC,CAAC;YAC9B,yCAAyC;YACzC,OAAO,UAGN,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,QAAyC;YAC5C,MAAM,WAAW,GAAG,CAAC,KAAY,EAAwC,EAAE;gBACzE,MAAM,OAAO,GAA4B;oBACvC,KAAK,EAAE,GAAG,EAAE;wBACV,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;wBAC/B,OAAO,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;oBACnD,CAAC;oBACD,OAAO,EAAE,GAAG,EAAE,CAAC,KAAK;iBACrB,CAAC;gBAEF,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC;oBAC/B,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,GAAY,EAAE,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;gBAChE,CAAC;gBACD,2CAA2C;gBAC3C,OAAO,OAA+C,CAAC;YACzD,CAAC,CAAC;YAEF,OAAO,GAAG,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACpC,CAAC;KACF,CAAC;IAEF,OAAO,UAAU,CAAC;AACpB,CAAC"}

package/dist/eidos/chain/chain.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Functional Chain of Responsibility Pattern.
+ *
+ * In OOP, Chain of Responsibility requires a Handler interface, a BaseHandler
+ * class with a `next` reference, and concrete handler subclasses linked together.
+ * In functional TypeScript, a handler is a function that either returns a result
+ * or delegates to the next handler. The chain is built by composing handlers.
+ *
+ * @module eidos/chain
+ * @since 2.4.0
+ *
+ * @see {@link https://pithos.dev/api/eidos/chain/ | Explanations, examples and live demo}
+ *
+ * @example
+ * ```ts
+ * import { createChain, type Handler } from "@pithos/core/eidos/chain/chain";
+ *
+ * const auth: Handler<Request, Response> = (req, next) =>
+ *   req.token ? next(req) : { status: 401 };
+ *
+ * const validate: Handler<Request, Response> = (req, next) =>
+ *   req.body ? next(req) : { status: 400 };
+ *
+ * const handle: Handler<Request, Response> = (req) =>
+ *   { status: 200, data: process(req) };
+ *
+ * const pipeline = createChain(auth, validate, handle);
+ * pipeline({ token: "abc", body: "data" }); // { status: 200, ... }
+ * ```
+ */
+import type { Result } from "../../zygos/result/result.js";
+/**
+ * A Handler receives an input and a `next` function.
+ * It can either return a result directly (stopping the chain)
+ * or call `next(input)` to delegate to the next handler.
+ *
+ * The last handler in the chain receives a `next` that is never called -
+ * it must produce a result on its own.
+ *
+ * @template In - The request/input type
+ * @template Out - The response/output type
+ * @since 2.4.0
+ */
+export type Handler<In, Out> = (input: In, next: (input: In) => Out) => Out;
+/**
+ * Creates a chain from an ordered list of handlers.
+ * Each handler can inspect the input and either:
+ * - return a result (short-circuit)
+ * - call `next(input)` to pass to the next handler
+ *
+ * The last handler's `next` throws if called, since there is
+ * nothing after it. The last handler should always produce a result.
+ *
+ * @template In - The request/input type
+ * @template Out - The response/output type
+ * @param handlers - Ordered list of handlers (first = outermost)
+ * @returns A function that runs the chain
+ * @since 2.4.0
+ *
+ * @example
+ * ```ts
+ * const log: Handler<number, string> = (n, next) => {
+ *   console.log(`processing ${n}`);
+ *   return next(n);
+ * };
+ *
+ * const double: Handler<number, string> = (n) => String(n * 2);
+ *
+ * const chain = createChain(log, double);
+ * chain(21); // logs "processing 21", returns "42"
+ * ```
+ */
+export declare function createChain<In, Out>(...handlers: Handler<In, Out>[]): (input: In) => Out;
+/**
+ * Creates a safe chain that catches errors and returns a zygos `Result`.
+ * Behaves like `createChain`, but wraps the execution in a try/catch.
+ *
+ * @deprecated Use `Result.fromThrowable` from `@zygos/result/result` instead.
+ *
+ * ```ts
+ * import { Result } from "../../zygos/result/result.js";
+ *
+ * const chain = createChain(auth, validate, handle);
+ * const safeRun = Result.fromThrowable(
+ *   (input: Request) => chain(input),
+ *   (e) => e instanceof Error ? e : new Error(String(e)),
+ * );
+ * const result = safeRun(request);
+ * ```
+ *
+ * @see {@link https://pithos.dev/api/eidos/chain/ | Full explanation, examples and live demo}
+ * @template In - The request/input type
+ * @template Out - The response/output type
+ * @param handlers - Ordered list of handlers
+ * @returns A function returning `Result<Out, Error>`
+ * @since 2.4.0
+ */
+export declare function safeChain<In, Out>(...handlers: Handler<In, Out>[]): (input: In) => Result<Out, Error>;
+//# sourceMappingURL=chain.d.ts.map

package/dist/eidos/chain/chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../../../src/eidos/chain/chain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,OAAO,CAAC,EAAE,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,KAAK,GAAG,KAAK,GAAG,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,GAAG,EACjC,GAAG,QAAQ,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,GAC9B,CAAC,KAAK,EAAE,EAAE,KAAK,GAAG,CAkBpB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,GAAG,EAC/B,GAAG,QAAQ,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,GAC9B,CAAC,KAAK,EAAE,EAAE,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CASnC"}