@sincpro/client-framework 0.6.0 → 1.0.0

package/dist/core/domain/services.js

@@ -0,0 +1,28 @@
+/**
+ * The services of the application layer, as sincpro_framework's: a Feature executes one
+ * registered Command; an ApplicationService composes its context's Features.
+ *
+ *     @project.feature(CommandCancelIssue)
+ *     class CancelIssue extends Feature<CommandCancelIssue, ResponseCancelIssue> {
+ *       static readonly serviceName = "CancelIssue";
+ *       async execute(command: CommandCancelIssue) {
+ *         this.logger.info("Cancelling");                 // bound to this run
+ *         return new ResponseCancelIssue(await this.client.cancelIssue(command));
+ *       }
+ *     }
+ *
+ * Context: while a method runs, `this.context`, `this.span`, `this.logger`, `this.featureBus` and
+ * every dependency are that run's (`executeService`). `serviceName` is stable metadata, never
+ * `constructor.name`, which a minifier renames.
+ */
+export class Feature {
+}
+export class ApplicationService extends Feature {
+}
+/** @internal — what a run finds on `this` that no dependency may take. */
+export const RESERVED_MEMBERS = new Set([
+    "featureBus",
+    "context",
+    "span",
+    "logger",
+]);

package/dist/core/entrypoint/bounded-context.d.ts

@@ -0,0 +1,70 @@
+import type { ContextValues } from "../../context/domain/store.js";
+import { type Context } from "../../context/entrypoint/context.js";
+import { type CommandBus } from "../domain/bus.js";
+import type { Answer, AnyCommand, Command, CommandClass, ResponseClass } from "../domain/dto.js";
+import type { ErrorClass, ErrorHandler } from "../domain/errors.js";
+import type { LayerLogger } from "../../observability/domain/logging.js";
+interface Executor<C extends AnyCommand, R> {
+    execute(command: C): R | Promise<R>;
+}
+type ServiceClass<C extends AnyCommand, R> = {
+    new (): Executor<C, R>;
+    readonly serviceName: string;
+};
+/**
+ * A bounded context: the bus of its Commands, as sincpro_framework's `UseFramework`.
+ *
+ *     const project = new BoundedContext<ProjectDependencies>("project");
+ *     project.addDependency("client", clientOf(transport));
+ *     project.feature(CommandCancelIssue)(CancelIssue);          // or @project.feature(...)
+ *     project.addFeatureErrorHandler(toEmptyWhenMissing);
+ *     project.expectErrors(IssueClosed);                         // refused, never reported
+ *     await project.execute(new CommandCancelIssue("x"));        // ResponseCancelIssue
+ *     project.logger.info("Catalog preloaded");
+ *
+ * Context: registrations, dependencies, handlers and expected errors are snapshotted per
+ * generation; a call keeps the generation it started with, and what is added later answers from
+ * the next call — as the backend's `build_root_bus`.
+ */
+export declare class BoundedContext<D extends object = Record<never, never>, C extends object = ContextValues> {
+    readonly name: string;
+    /** Its level of the context: what every use case of it runs with, under the process's. */
+    readonly context: Context<C>;
+    /** Its own logger, named after it: for what it does outside a use case. */
+    readonly logger: LayerLogger;
+    private readonly registrations;
+    private readonly dependencyValues;
+    private readonly handlers;
+    private readonly expected;
+    private revision;
+    private builtRevision;
+    private built;
+    constructor(name: string);
+    get deps(): Readonly<D>;
+    addDependency<K extends keyof D & string>(name: K, dependency: D[K], options?: {
+        replaces: D[K];
+    }): this;
+    feature<T extends AnyCommand>(command: CommandClass<T>): <S extends ServiceClass<NoInfer<T>, Answer<NoInfer<T>>>>(Service: S, decorator?: ClassDecoratorContext<S> | undefined) => S;
+    appService<T extends AnyCommand>(command: CommandClass<T>): <S extends ServiceClass<NoInfer<T>, Answer<NoInfer<T>>>>(Service: S, decorator?: ClassDecoratorContext<S> | undefined) => S;
+    /** Answers a failure that reaches `execute` (or a scope's): after every layer's handlers. */
+    addGlobalErrorHandler(handler: ErrorHandler): this;
+    /** Answers a Feature's failure, wherever it was executed from. */
+    addFeatureErrorHandler(handler: ErrorHandler): this;
+    /** Answers an ApplicationService's failure. */
+    addAppServiceErrorHandler(handler: ErrorHandler): this;
+    /**
+     * Errors of these classes are the business answering, not a fault: the run ends `refused`,
+     * its span is no error and nothing is reported. They are still thrown — or handled.
+     */
+    expectErrors(...types: ErrorClass[]): this;
+    execute<R>(command: Command<R>, _returnType?: ResponseClass<NoInfer<R>>): Promise<R>;
+    scoped(context: Partial<C>): CommandBus;
+    buildRootBus(): void;
+    fresh(): BoundedContext<D, C>;
+    private addErrorHandler;
+    private registrar;
+    private registerService;
+    private generation;
+    private buildGeneration;
+}
+export {};

package/dist/core/entrypoint/bounded-context.js

@@ -0,0 +1,252 @@
+import { contextAt, } from "../../context/entrypoint/context.js";
+import { processContext, processStore, } from "../../context/infrastructure/process.js";
+import { executeTyped, FeatureBus, } from "../domain/bus.js";
+import { ApplicationService, Feature, RESERVED_MEMBERS, } from "../domain/services.js";
+import { handled } from "../services/error-handlers.js";
+import { executeService } from "../services/execution.js";
+import { boundedContextLogger, logHandled, } from "../../observability/services/logging.js";
+function isExecutor(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "execute" in value &&
+        typeof value.execute === "function");
+}
+/**
+ * A bounded context: the bus of its Commands, as sincpro_framework's `UseFramework`.
+ *
+ *     const project = new BoundedContext<ProjectDependencies>("project");
+ *     project.addDependency("client", clientOf(transport));
+ *     project.feature(CommandCancelIssue)(CancelIssue);          // or @project.feature(...)
+ *     project.addFeatureErrorHandler(toEmptyWhenMissing);
+ *     project.expectErrors(IssueClosed);                         // refused, never reported
+ *     await project.execute(new CommandCancelIssue("x"));        // ResponseCancelIssue
+ *     project.logger.info("Catalog preloaded");
+ *
+ * Context: registrations, dependencies, handlers and expected errors are snapshotted per
+ * generation; a call keeps the generation it started with, and what is added later answers from
+ * the next call — as the backend's `build_root_bus`.
+ */
+export class BoundedContext {
+    name;
+    /** Its level of the context: what every use case of it runs with, under the process's. */
+    context;
+    /** Its own logger, named after it: for what it does outside a use case. */
+    logger;
+    registrations = new Map();
+    dependencyValues = new Map();
+    handlers = {
+        global: [],
+        feature: [],
+        application_service: [],
+    };
+    expected = [];
+    revision = 0;
+    builtRevision = -1;
+    built;
+    constructor(name) {
+        this.name = name;
+        if (name.trim() === "" || name.includes("/")) {
+            throw new TypeError("A bounded context needs a nonempty name without '/'");
+        }
+        this.context = contextAt(`bounded_context:${name}`, processStore);
+        this.logger = boundedContextLogger(name);
+    }
+    get deps() {
+        // The dependency interface is erased; the locator checks real registrations.
+        return new Proxy({}, {
+            get: (_target, key) => {
+                if (typeof key !== "string" || !this.dependencyValues.has(key)) {
+                    throw new Error(`Dependency is not registered: ${String(key)}`);
+                }
+                return this.dependencyValues.get(key);
+            },
+            set: () => {
+                throw new Error("Dependencies are read-only; use addDependency");
+            },
+            deleteProperty: () => {
+                throw new Error("Dependencies cannot be deleted");
+            },
+            defineProperty: () => {
+                throw new Error("Dependencies are read-only");
+            },
+            setPrototypeOf: () => {
+                throw new Error("Dependencies are read-only");
+            },
+        });
+    }
+    addDependency(name, dependency, options) {
+        if (RESERVED_MEMBERS.has(name)) {
+            throw new Error(`Reserved dependency name: ${name}`);
+        }
+        const registered = this.dependencyValues.has(name);
+        if (registered && options === undefined) {
+            throw new Error(`Dependency already registered: ${name}`);
+        }
+        if (options && (!registered || this.dependencyValues.get(name) !== options.replaces)) {
+            throw new Error(`Dependency replacement does not match the registration: ${name}`);
+        }
+        this.dependencyValues.set(name, dependency);
+        this.revision++;
+        return this;
+    }
+    feature(command) {
+        return this.registrar(command, "feature");
+    }
+    appService(command) {
+        return this.registrar(command, "application_service");
+    }
+    /** Answers a failure that reaches `execute` (or a scope's): after every layer's handlers. */
+    addGlobalErrorHandler(handler) {
+        return this.addErrorHandler("global", handler);
+    }
+    /** Answers a Feature's failure, wherever it was executed from. */
+    addFeatureErrorHandler(handler) {
+        return this.addErrorHandler("feature", handler);
+    }
+    /** Answers an ApplicationService's failure. */
+    addAppServiceErrorHandler(handler) {
+        return this.addErrorHandler("application_service", handler);
+    }
+    /**
+     * Errors of these classes are the business answering, not a fault: the run ends `refused`,
+     * its span is no error and nothing is reported. They are still thrown — or handled.
+     */
+    expectErrors(...types) {
+        for (const type of types) {
+            if (typeof type !== "function")
+                throw new TypeError("An expected error is a class");
+            if (!this.expected.includes(type))
+                this.expected.push(type);
+        }
+        this.revision++;
+        return this;
+    }
+    execute(command, _returnType) {
+        return executeTyped((one) => this.generation().root(one, {}), command);
+    }
+    scoped(context) {
+        const scope = { ...context };
+        return new FeatureBus((command) => this.generation().root(command, scope));
+    }
+    buildRootBus() {
+        this.generation();
+    }
+    fresh() {
+        const fresh = new BoundedContext(this.name);
+        for (const [command, registration] of this.registrations) {
+            fresh.registrations.set(command, registration);
+        }
+        for (const [name, dependency] of this.dependencyValues) {
+            fresh.dependencyValues.set(name, dependency);
+        }
+        for (const where of ["global", "feature", "application_service"]) {
+            fresh.handlers[where].push(...this.handlers[where]);
+        }
+        fresh.expected.push(...this.expected);
+        fresh.revision = this.revision;
+        return fresh;
+    }
+    addErrorHandler(where, handler) {
+        if (typeof handler !== "function")
+            throw new TypeError("An error handler is a function");
+        this.handlers[where].push(handler);
+        this.revision++;
+        return this;
+    }
+    registrar(command, layer) {
+        return (Service, decorator) => {
+            const register = () => this.registerService(command, Service, layer);
+            // Standard decorators run before static fields have initialized.
+            if (decorator)
+                decorator.addInitializer(register);
+            else
+                register();
+            return Service;
+        };
+    }
+    registerService(command, Service, layer) {
+        const Base = layer === "feature" ? Feature : ApplicationService;
+        if (!(Service.prototype instanceof Base) ||
+            (layer === "feature" && Service.prototype instanceof ApplicationService)) {
+            throw new TypeError(`The service is not an ${layer}`);
+        }
+        if (this.registrations.has(command)) {
+            throw new Error("Command already registered: one executor across both layers");
+        }
+        const name = Service.serviceName;
+        if (typeof name !== "string" || name.trim() === "") {
+            throw new Error("A service needs a nonempty registered name");
+        }
+        if ([...this.registrations.values()].some((registration) => registration.name === name)) {
+            throw new Error(`Service name already registered: ${name}`);
+        }
+        this.registrations.set(command, { name, layer, Service });
+        this.revision++;
+    }
+    generation() {
+        if (this.built && this.builtRevision === this.revision)
+            return this.built;
+        const revision = this.revision;
+        const built = this.buildGeneration();
+        this.built = built;
+        this.builtRevision = revision;
+        return built;
+    }
+    buildGeneration() {
+        const registrations = new Map(this.registrations);
+        const dependencies = new Map(this.dependencyValues);
+        const handlers = {
+            global: [...this.handlers.global],
+            feature: [...this.handlers.feature],
+            application_service: [...this.handlers.application_service],
+        };
+        const expectedTypes = [...this.expected];
+        const expected = (error) => expectedTypes.some((type) => error instanceof type);
+        const instances = new Map();
+        for (const registration of registrations.values()) {
+            const instance = new registration.Service();
+            if (!isExecutor(instance)) {
+                throw new Error(`Registered service is unavailable: ${registration.name}`);
+            }
+            instances.set(registration, instance);
+        }
+        const dispatch = async (command, parent, featureOnly = false, scope = {}) => {
+            // Exact constructor identity: a subclass of a registered Command is another Command.
+            const target = registrations.get(Object.getPrototypeOf(command)?.constructor);
+            if (!target)
+                throw new Error("No executor registered for this command class");
+            if (featureOnly && target.layer !== "feature") {
+                throw new Error("An ApplicationService may compose only Features");
+            }
+            const service = instances.get(target);
+            if (!service) {
+                throw new Error(`Registered service is unavailable: ${target.name}`);
+            }
+            return executeService(service, command, {
+                boundedContext: this.name,
+                name: target.name,
+                layer: target.layer,
+                dependencies,
+                context: () => ({ ...processContext.values, ...this.context.values, ...scope }),
+                ...(parent ? { parent } : {}),
+                featureBus: (execution) => new FeatureBus((child) => dispatch(child, execution, true)),
+                expected,
+                handlers: handlers[target.layer],
+            });
+        };
+        return {
+            root: async (command, scope) => {
+                try {
+                    return await dispatch(command, undefined, false, scope);
+                }
+                catch (error) {
+                    if (handlers.global.length === 0)
+                        throw error;
+                    const answer = await handled(handlers.global, error);
+                    logHandled("bounded_context", { boundedContext: this.name });
+                    return answer;
+                }
+            },
+        };
+    }
+}

package/dist/core/entrypoint/screens.d.ts

@@ -0,0 +1,6 @@
+import type { Transport } from "../../client/domain/transport.js";
+/**
+ * Screen requests enter the same command pipeline as application services. A generated
+ * client injected into a Feature uses its raw transport instead, continuing that execution.
+ */
+export declare function screensTransport(transport: Transport, name?: string): Transport;

package/dist/core/entrypoint/screens.js

@@ -0,0 +1,136 @@
+import { Command } from "../domain/dto.js";
+import { Feature } from "../domain/services.js";
+import { BoundedContext } from "./bounded-context.js";
+class List extends Command {
+    route;
+    criteria;
+    signal;
+    options;
+    constructor(route, criteria, signal, options) {
+        super();
+        this.route = route;
+        this.criteria = criteria;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class Get extends Command {
+    route;
+    signal;
+    options;
+    constructor(route, signal, options) {
+        super();
+        this.route = route;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class Read extends Command {
+    route;
+    signal;
+    options;
+    constructor(route, signal, options) {
+        super();
+        this.route = route;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class Export extends Command {
+    route;
+    signal;
+    options;
+    constructor(route, signal, options) {
+        super();
+        this.route = route;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class Send extends Command {
+    method;
+    route;
+    body;
+    signal;
+    options;
+    constructor(method, route, body, signal, options) {
+        super();
+        this.method = method;
+        this.route = route;
+        this.body = body;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class EntityList extends Feature {
+    static serviceName = "EntityReads.list";
+    execute(dto) {
+        this.span.set({ "http.route": dto.route });
+        return this.transport.list(dto.route, dto.criteria, dto.signal, dto.options);
+    }
+}
+class EntityGet extends Feature {
+    static serviceName = "EntityReads.one";
+    execute(dto) {
+        this.span.set({ "http.route": dto.route });
+        return this.transport.one(dto.route, dto.signal, dto.options);
+    }
+}
+class EntityRead extends Feature {
+    static serviceName = "EntityReads.read";
+    execute(dto) {
+        this.span.set({ "http.route": dto.route });
+        const transport = this.transport;
+        if (!transport.read) {
+            return Promise.reject(new Error(`this transport cannot read ${dto.route}: it has no read()`));
+        }
+        return transport.read(dto.route, dto.signal, dto.options);
+    }
+}
+class EntityExport extends Feature {
+    static serviceName = "EntityReads.download";
+    execute(dto) {
+        this.span.set({ "http.route": dto.route });
+        const transport = this.transport;
+        if (!transport.download) {
+            return Promise.reject(new Error(`this transport cannot download ${dto.route}: it has no download()`));
+        }
+        return transport.download(dto.route, dto.signal, dto.options);
+    }
+}
+class EntitySend extends Feature {
+    static serviceName = "EntityWrites.send";
+    execute(dto) {
+        this.span.set({ "http.method": dto.method, "http.route": dto.route });
+        return this.transport.send(dto.method, dto.route, dto.body, dto.signal, dto.options);
+    }
+}
+const MADE = new WeakSet();
+/**
+ * Screen requests enter the same command pipeline as application services. A generated
+ * client injected into a Feature uses its raw transport instead, continuing that execution.
+ */
+export function screensTransport(transport, name = "screens") {
+    if (MADE.has(transport))
+        return transport;
+    const screens = new BoundedContext(name);
+    screens.addDependency("transport", transport);
+    screens.feature(List)(EntityList);
+    screens.feature(Get)(EntityGet);
+    screens.feature(Read)(EntityRead);
+    screens.feature(Export)(EntityExport);
+    screens.feature(Send)(EntitySend);
+    const through = {
+        list: (route, criteria, signal, options) => screens.execute(new List(route, criteria, signal, options)),
+        one: (route, signal, options) => screens.execute(new Get(route, signal, options)),
+        send: (method, route, body, signal, options) => screens.execute(new Send(method, route, body, signal, options)),
+    };
+    if (transport.read) {
+        through.read = (route, signal, options) => screens.execute(new Read(route, signal, options));
+    }
+    if (transport.download) {
+        through.download = (route, signal, options) => screens.execute(new Export(route, signal, options));
+    }
+    MADE.add(through);
+    return through;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The application core (`./core`): the backend's application abstractions — class Commands and
+ * Responses, Features and ApplicationServices, a bounded context that is their bus, its error
+ * handlers — and the process they run in.
+ *
+ *   domain/          DTOs, the bus, the service bases, the error-handler contract
+ *   services/        the execution pipeline, dependency binding, the handler chain
+ *   entrypoint/      `BoundedContext`, `screensTransport`
+ *   infrastructure/  `configureProcess`, `configureLogger`
+ */
+export { type CommandBus, FeatureBus } from "./domain/bus.js";
+export { Command, DataTransferObject, Response, } from "./domain/dto.js";
+export type { ErrorClass, ErrorHandler } from "./domain/errors.js";
+export { ApplicationService, Feature } from "./domain/services.js";
+export { BoundedContext } from "./entrypoint/bounded-context.js";
+export { screensTransport } from "./entrypoint/screens.js";
+export { configureLogger, configureProcess, type LoggerConfiguration, type ProcessOptions, } from "./infrastructure/process.js";

package/dist/core/index.js

@@ -0,0 +1,16 @@
+/**
+ * The application core (`./core`): the backend's application abstractions — class Commands and
+ * Responses, Features and ApplicationServices, a bounded context that is their bus, its error
+ * handlers — and the process they run in.
+ *
+ *   domain/          DTOs, the bus, the service bases, the error-handler contract
+ *   services/        the execution pipeline, dependency binding, the handler chain
+ *   entrypoint/      `BoundedContext`, `screensTransport`
+ *   infrastructure/  `configureProcess`, `configureLogger`
+ */
+export { FeatureBus } from "./domain/bus.js";
+export { Command, DataTransferObject, Response, } from "./domain/dto.js";
+export { ApplicationService, Feature } from "./domain/services.js";
+export { BoundedContext } from "./entrypoint/bounded-context.js";
+export { screensTransport } from "./entrypoint/screens.js";
+export { configureLogger, configureProcess, } from "./infrastructure/process.js";

package/dist/core/infrastructure/process.d.ts

@@ -0,0 +1,56 @@
+import type { ContextStore } from "../../context/domain/store.js";
+import { type ConsoleLoggerOptions } from "../../observability/adapters/console.js";
+import type { ErrorReporter } from "../../observability/domain/errors.js";
+import type { Logger } from "../../observability/domain/logging.js";
+import { type Outcome, type Tracer } from "../../observability/domain/tracing.js";
+/**
+ * Where logs go: the console by default, any `Logger` otherwise, or nowhere.
+ *
+ *     { mode: "development", level: "info", layers: { adapter: false } }   // the console, filtered
+ *     { mode: "production" }                                               // the console, silent
+ *     { engine: combineLoggers(consoleLogger({ mode }), lokiLogger) }       // the platform's sinks
+ *     { engine: false }                                                    // no logs
+ *
+ * Context: one shape for both doors — `configureProcess({ logger })`, which replaces everything,
+ * and `configureLogger(...)`, which replaces only logging (a debug switch on a phone). `mode`,
+ * `level` and `layers` configure the console engine; a supplied `engine` owns its own policy.
+ */
+export type LoggerConfiguration = Partial<ConsoleLoggerOptions> & {
+    engine?: Logger | false;
+};
+/**
+ * What every bounded context of this process runs with — set once, in `main`, the way
+ * sincpro_framework's process is: who traces, who reports, where logs go, where the context lives.
+ *
+ *     // entrypoints/main.tsx — the platform's pieces, built from the application's settings
+ *     configureProcess({
+ *       tracer: browserTracer({ endpoint: settings.otlp, service: "forge-web" }),
+ *       reporter: glitchtipReporter({ dsn: settings.glitchtip }),
+ *       logger: { mode: settings.production ? "production" : "development" },
+ *       context: memoryContexts(),
+ *     });
+ *
+ * Context: everything is optional, and nothing breaks without it. A process that never configures
+ * runs untraced and unreported, with memory context and development console logging — so a bounded
+ * context is usable the moment it is imported, and `main` adds what it watches with. The bounded
+ * contexts read the process on every call, never at import: `project` may be defined before `main`
+ * runs.
+ *
+ * It replaces everything at once: what is not given goes back to its default — a test calls it
+ * with its own tracer and starts from a clean context.
+ */
+export type ProcessOptions = {
+    /** The platform's (OpenTelemetry in a browser, a queue on a phone, memory in a test). */
+    tracer?: Tracer;
+    /** The platform's (GlitchTip, Sentry, memory in a test). Only what nobody expected reaches it. */
+    reporter?: ErrorReporter;
+    /** Where logs go (`LoggerConfiguration`); the console in development mode by default. */
+    logger?: LoggerConfiguration;
+    /** Where the context lives (`memoryContexts()` by default). */
+    context?: ContextStore;
+    /** How an error ended a use case (`outcomeOf` by default). Only `failed` is reported. */
+    outcomeOf?: (error: unknown) => Outcome;
+};
+export declare function configureProcess(options?: ProcessOptions): void;
+/** Replace logging only; tracing, reporting and the context stay as they are. */
+export declare function configureLogger(options?: LoggerConfiguration): void;

package/dist/core/infrastructure/process.js

@@ -0,0 +1,35 @@
+import { memoryContexts } from "../../context/adapters/memory.js";
+import { replaceProcessStore } from "../../context/infrastructure/process.js";
+import { consoleLogger, } from "../../observability/adapters/console.js";
+import { NO_TRACER, } from "../../observability/domain/tracing.js";
+import { replaceObservability } from "../../observability/infrastructure/registry.js";
+import { outcomeOf } from "../../observability/services/outcome.js";
+function loggingEngine(options) {
+    if (options.engine === false)
+        return undefined;
+    if (options.engine !== undefined) {
+        if (!options.engine || typeof options.engine.log !== "function") {
+            throw new TypeError("Logger engine must implement log(record)");
+        }
+        return options.engine;
+    }
+    return consoleLogger({
+        mode: options.mode ?? "development",
+        ...(options.level ? { level: options.level } : {}),
+        ...(options.layers ? { layers: options.layers } : {}),
+    });
+}
+export function configureProcess(options = {}) {
+    const logger = loggingEngine(options.logger ?? {});
+    replaceObservability({
+        tracer: options.tracer ?? NO_TRACER,
+        reporter: options.reporter,
+        logger,
+        outcomeOf: options.outcomeOf ?? outcomeOf,
+    });
+    replaceProcessStore(options.context ?? memoryContexts());
+}
+/** Replace logging only; tracing, reporting and the context stay as they are. */
+export function configureLogger(options = {}) {
+    replaceObservability({ logger: loggingEngine(options) });
+}

package/dist/core/services/binding.d.ts

@@ -0,0 +1,6 @@
+import { type Execution } from "../../context/domain/execution.js";
+/**
+ * A dependency as the execution should see it: bound when it can be (`BIND`, or a `Transport`),
+ * as it is otherwise.
+ */
+export declare function bindDependency<T>(value: T, execution: Execution): T;

package/dist/core/services/binding.js

@@ -0,0 +1,13 @@
+import { bindTransport, isTransport, } from "../../client/services/propagation.js";
+import { BIND, isBindable, } from "../../context/domain/execution.js";
+/**
+ * A dependency as the execution should see it: bound when it can be (`BIND`, or a `Transport`),
+ * as it is otherwise.
+ */
+export function bindDependency(value, execution) {
+    if (isBindable(value))
+        return value[BIND](execution);
+    if (isTransport(value))
+        return bindTransport(value, execution);
+    return value;
+}

package/dist/core/services/error-handlers.d.ts

@@ -0,0 +1,11 @@
+import type { ErrorHandler } from "../domain/errors.js";
+/**
+ * The answer of a chain of error handlers to `error`, or what its last handler threw.
+ *
+ *     await handled([toEmpty, logAndRethrow], new IssueNotFound())   ->  toEmpty's answer
+ *
+ * 1. Each handler, first-registered-first, receives what the one before it threw.
+ * Final: the first answer; when every handler threw, the last thrown — the original error when
+ *    there is no handler at all.
+ */
+export declare function handled(handlers: readonly ErrorHandler[], error: unknown): Promise<unknown>;