@sincpro/client-framework 0.5.0 → 1.0.0

package/dist/testing/index.js

@@ -1,37 +1,5 @@
-function hex(bytes) {
-    return Array.from(globalThis.crypto.getRandomValues(new Uint8Array(bytes)), (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-export function memoryTracer() {
-    const spans = [];
-    return {
-        spans,
-        start(name, options) {
-            const recorded = {
-                name,
-                traceId: options.parent?.traceId || hex(16),
-                spanId: hex(8),
-                parentSpanId: options.parent?.spanId || undefined,
-                attributes: { ...options.attributes },
-                outcome: undefined,
-                error: undefined,
-            };
-            spans.push(recorded);
-            return {
-                traceId: recorded.traceId,
-                spanId: recorded.spanId,
-                sampled: true,
-                set: (attributes) => void Object.assign(recorded.attributes, attributes),
-                end: (outcome, error) => {
-                    if (recorded.outcome !== undefined)
-                        return;
-                    recorded.outcome = outcome;
-                    recorded.error = error;
-                },
-            };
-        },
-    };
-}
-export function memoryReporter() {
-    const reports = [];
-    return { reports, report: (error, about) => void reports.push({ error, about }) };
-}
+/**
+ * `@sincpro/client-framework/testing`: the observability ports in memory, so a use case is
+ * proven in Node with nothing of a platform. Not part of what an application runs.
+ */
+export { memoryLogger, memoryReporter, memoryTracer, } from "../observability/adapters/memory.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sincpro/client-framework",
-  "version": "0.5.0",
+  "version": "1.0.0",
   "description": "The client side of sincpro_framework, for every platform: Feature and ApplicationService traced and reported by default, applications made of domains, and the typed client generated from a service's contract. No React, no DOM.",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,6 +10,10 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "default": "./dist/core/index.js"
+    },
     "./codegen": {
       "types": "./dist/codegen/index.d.ts",
       "default": "./dist/codegen/index.js"
@@ -18,17 +22,25 @@
       "types": "./dist/testing/index.d.ts",
       "default": "./dist/testing/index.js"
     },
+    "./console": {
+      "types": "./dist/observability/adapters/console.d.ts",
+      "default": "./dist/observability/adapters/console.js"
+    },
     "./opentelemetry": {
-      "types": "./dist/adapters/opentelemetry.d.ts",
-      "default": "./dist/adapters/opentelemetry.js"
+      "types": "./dist/observability/adapters/opentelemetry.d.ts",
+      "default": "./dist/observability/adapters/opentelemetry.js"
     },
     "./sentry": {
-      "types": "./dist/adapters/sentry.d.ts",
-      "default": "./dist/adapters/sentry.js"
+      "types": "./dist/observability/adapters/sentry.d.ts",
+      "default": "./dist/observability/adapters/sentry.js"
+    },
+    "./parquet": {
+      "types": "./dist/client/adapters/parquet.d.ts",
+      "default": "./dist/client/adapters/parquet.js"
     }
   },
   "bin": {
-    "sincpro-client": "./dist/codegen/cli.js"
+    "sincpro-client": "./dist/codegen/entrypoint/cli.js"
   },
   "files": [
     "dist",
@@ -68,13 +80,17 @@
   },
   "peerDependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@sincpro/criteria": "^2.0.0",
+    "@sincpro/criteria": "^2.1.0",
+    "hyparquet": "^1.32.0",
     "typescript": ">=5.5 <7"
   },
   "peerDependenciesMeta": {
     "@opentelemetry/api": {
       "optional": true
     },
+    "hyparquet": {
+      "optional": true
+    },
     "typescript": {
       "optional": true
     }
@@ -83,11 +99,12 @@
     "@eslint/js": "^10.0.1",
     "@opentelemetry/api": "1.10.0",
     "@opentelemetry/sdk-trace": "3.1.0",
-    "@sincpro/criteria": "^2.0.0",
+    "@sincpro/criteria": "^2.1.0",
     "@types/node": "^26.6.6",
     "eslint": "^10.14.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-simple-import-sort": "^14.0.0",
+    "hyparquet": "^1.32.0",
     "prettier": "^3.9.10",
     "tsc-alias": "^1.9.9",
     "typescript": "~6.0.3",

package/dist/codegen/domain.d.ts

@@ -1,15 +0,0 @@
-import type { Metamodel } from "./metamodel.js";
-/**
- * The TypeScript of every DTO of `metamodel`, as the text of one file.
- *
- * 1. The models, by name: an entity's contract, a related model by its own name.
- * 2. Each operation, by its local name (its identity without `<context>.`): its input as
- *    `<Name>` and its answer by the backend's own name for it (`answerOf`: `ResponseX`), with
- *    `<Name>Answer` kept as a deprecated alias — or as `<Name>Answer` when it has no name.
- * 3. The shared definitions those reach — and the ones those reach, until none is new —, but
- *    never one a package of the stack already types (`Criteria`).
- * Final: a header that says where it came from and not to edit it, the imports, then models,
- *    definitions and operations, each sorted by name; two of them with one TypeScript name are
- *    refused, naming both.
- */
-export declare function domainFileOf(metamodel: Metamodel): string;

package/dist/observability/ports.d.ts

@@ -1,65 +0,0 @@
-/**
- * What a platform plugs so every use case is traced and every unexpected error reported.
- *
- * Context: sincpro_framework opens one span per use case and reports what nobody expected; a
- * client has to do the same, and continue the backend's trace. The vendor — OpenTelemetry in a
- * browser, a queue on a phone, GlitchTip, memory in a test — is the platform's, so this package
- * defines the contract and calls it, and bundles none. Two implementations at least (a
- * platform's and a test's) are why these are ports.
- *
- * Nothing here may break a use case: a tracer or a reporter that throws is ignored, and the use
- * case answers as it would have.
- */
-/** What is said about a span: plain values only, the way OpenTelemetry takes them. */
-export type Attributes = Readonly<Record<string, string | number | boolean>>;
-/**
- * How a use case ended.
- *
- * - `ok`: it answered.
- * - `refused`: the server said no and explained why — a validation, a conflict, a permission.
- *   Expected; never reported.
- * - `aborted`: whoever asked stopped waiting (a screen that closed). Never reported.
- * - `failed`: anything else — a bug, a server that broke, a server nobody could reach. Reported.
- */
-export type Outcome = "ok" | "refused" | "aborted" | "failed";
-/** One span: a use case, open while it runs. */
-export interface Span {
-    /** 32 hex — the id the server continues and a person quotes as a support code. Empty when
-     *  nothing traces. */
-    readonly traceId: string;
-    /** 16 hex. Empty when nothing traces. */
-    readonly spanId: string;
-    /** Whether this trace is kept: the server follows the same decision. */
-    readonly sampled: boolean;
-    /** Vendor state that travels beside the trace (`tracestate`), when there is any. */
-    readonly state?: string;
-    /** Says more about the use case while it runs. */
-    set(attributes: Attributes): void;
-    /** Closes it, once. `error` is what it failed or was refused with. */
-    end(outcome: Outcome, error?: unknown): void;
-}
-/** Opens spans. One per platform; `NO_TRACER` when nothing traces. */
-export interface Tracer {
-    start(name: string, options: {
-        parent?: Span;
-        attributes?: Attributes;
-    }): Span;
-}
-/** What a report says about where the error happened. */
-export type ErrorAbout = {
-    /** `<bounded context>.<Service>[.<method>]`: the use case's identity, as the backend's — or,
-     *  for what failed outside one (`reportError`), where it happened (`view project:issue/acme-3`). */
-    useCase: string;
-    /** The trace the error belongs to — the same id the server logged, when it got that far. */
-    traceId: string;
-    /** The execution's own id. */
-    executionId: string;
-    /** What the use case ran with: the process's context, its bounded context's, its scope's. */
-    context: Readonly<Record<string, unknown>>;
-};
-/** Reports what nobody expected. One per platform; none when nothing reports. */
-export interface ErrorReporter {
-    report(error: unknown, about: ErrorAbout): void;
-}
-/** Traces nothing: what a use case runs with until a platform plugs a tracer. */
-export declare const NO_TRACER: Tracer;

package/dist/observability/ports.js

@@ -1,21 +0,0 @@
-/**
- * What a platform plugs so every use case is traced and every unexpected error reported.
- *
- * Context: sincpro_framework opens one span per use case and reports what nobody expected; a
- * client has to do the same, and continue the backend's trace. The vendor — OpenTelemetry in a
- * browser, a queue on a phone, GlitchTip, memory in a test — is the platform's, so this package
- * defines the contract and calls it, and bundles none. Two implementations at least (a
- * platform's and a test's) are why these are ports.
- *
- * Nothing here may break a use case: a tracer or a reporter that throws is ignored, and the use
- * case answers as it would have.
- */
-const EMPTY_SPAN = {
-    traceId: "",
-    spanId: "",
-    sampled: false,
-    set: () => undefined,
-    end: () => undefined,
-};
-/** Traces nothing: what a use case runs with until a platform plugs a tracer. */
-export const NO_TRACER = { start: () => EMPTY_SPAN };

package/dist/services/bounded-context.d.ts

@@ -1,79 +0,0 @@
-import { type Context } from "../context/context.js";
-import type { ContextValues } from "../context/store.js";
-import { type ServiceClasses, type Services } from "./feature.js";
-/**
- * A bounded context: its dependencies, its services, and the one object everything else uses
- * them through — set up the way sincpro_framework sets one up.
- *
- *     // domains/project/infrastructure/dependencies.ts      ← what the services can count on
- *     export interface ProjectDependencies {
- *       client: ProjectClient;
- *       session: Session;
- *     }
- *     export function registerDependencies(bc: UseBoundedContext<ProjectDependencies>) {
- *       bc.addDependency("client", clientOf(transport));
- *       bc.addDependency("session", session);
- *       return bc;
- *     }
- *
- *     // domains/project/infrastructure/bounded_context.ts
- *     export class Feature extends BaseFeature<ProjectDependencies> {}
- *     export class ApplicationService extends BaseApplicationService<ProjectDependencies, ProjectFeatures> {}
- *     export function configProjectBoundedContext(name: string) {
- *       return registerDependencies(new UseBoundedContext<ProjectDependencies>(name));
- *     }
- *
- *     // domains/project/index.ts
- *     export const project = configProjectBoundedContext("project").register({
- *       features,                                  // { Issues, Notices }
- *       applicationServices,                       // { CloseAndNotify }
- *     });
- *
- *     // anywhere — a screen, another bounded context's adapter, a test
- *     await project.Issues.close(input);           // span "project/Issues.close"
- *     await project.CloseAndNotify.execute(input); // span "project/CloseAndNotify", its Features under it
- *
- * Context: sincpro_framework's `UseFramework` (being renamed to bounded context) with
- * `add_dependency`, and `project(Command(...))` written as a property: a service is reached by
- * the name it is registered under, so its span is named by that name — a production build renames
- * classes, never the keys of an object — and the type of `project` is the services it holds.
- *
- * `project` is light and never frozen. It holds references: the classes, the dependencies, and
- * one instance of each service, made the first time it is asked for and shared by everything
- * derived from it. Each call makes a small view of that instance — a few pointers — that carries
- * the call's trace. A screen or a test that needs its own variant derives one, with everything
- * else shared:
- *
- *     project.with({ client: fake })               other dependencies — a test, a demo
- *     project.scoped({ company_id: 2 })            more context for what runs through it — a window
- *
- * A service is a singleton of its bounded context: what a method writes on `this` stays for the
- * next call and for the call running beside it, as in sincpro_framework. What belongs to one
- * request goes in its arguments or its context, never on `this`.
- */
-export type BoundedContext<D extends object, C extends object, F extends ServiceClasses, A extends ServiceClasses> = Services<F, D> & Services<A, D> & {
-    readonly name: string;
-    /** This bounded context's level of the context: under the process's, over a scope's. */
-    readonly context: Context<C>;
-    /** The same bounded context with other dependencies — the rest, and the services, shared. */
-    with(dependencies: Partial<D>): BoundedContext<D, C, F, A>;
-    /** The same bounded context with more context for what runs through it. */
-    scoped(context: Partial<C>): BoundedContext<D, C, F, A>;
-};
-export declare class UseBoundedContext<D extends object, C extends object = ContextValues> {
-    #private;
-    readonly name: string;
-    /** This bounded context's level of the context, saved in the process's store. */
-    readonly context: Context<C>;
-    constructor(name: string);
-    /** `value` is what every service of this bounded context finds at `this.<name>`. */
-    addDependency<K extends keyof D & string>(name: K, value: D[K]): this;
-    /**
-     * The object the bounded context is used through: each service under its name. A dependency
-     * added after this is seen too — the services read them on every call.
-     */
-    register<F extends ServiceClasses, A extends ServiceClasses = Record<never, never>>(services: {
-        features: F;
-        applicationServices?: A;
-    }): BoundedContext<D, C, F, A>;
-}

package/dist/services/bounded-context.js

@@ -1,261 +0,0 @@
-import { newEntityId } from "../common/ids.js";
-import { contextAt } from "../context/context.js";
-import { bindDependency } from "./execution.js";
-import { composes, isApplicationServiceClass, isFeatureClass, methodsOf, } from "./feature.js";
-import { processContext, processNow, processStore, } from "./process.js";
-import { firstReport } from "./report.js";
-/** Names `project` answers itself: no service is registered under them. */
-const RESERVED = new Set(["name", "context", "with", "scoped"]);
-/** Names a run answers on `this` itself: no dependency is added under them. */
-const ANSWERED = new Set(["context", "feature", "span"]);
-export class UseBoundedContext {
-    name;
-    /** This bounded context's level of the context, saved in the process's store. */
-    context;
-    #dependencies = {};
-    constructor(name) {
-        if (name === "" || name.includes("/"))
-            throw new Error(`"${name}" is not a bounded context's name — it names its spans: "${name}/Issues.close"`);
-        this.name = name;
-        this.context = contextAt(`bounded_context:${name}`, processStore);
-    }
-    /** `value` is what every service of this bounded context finds at `this.<name>`. */
-    addDependency(name, value) {
-        if (ANSWERED.has(name))
-            throw new Error(`${this.name}: a dependency cannot be called "${name}" — every service answers this.${name} itself`);
-        this.#dependencies[name] = value;
-        return this;
-    }
-    /**
-     * The object the bounded context is used through: each service under its name. A dependency
-     * added after this is seen too — the services read them on every call.
-     */
-    register(services) {
-        const classes = new Map();
-        const add = (key, service) => {
-            if (RESERVED.has(key))
-                throw new Error(`${this.name}: no service can be called "${key}" — it is the bounded context's own`);
-            if (classes.has(key))
-                throw new Error(`${this.name}: two services are called "${key}"`);
-            classes.set(key, service);
-        };
-        for (const [key, service] of Object.entries(services.features)) {
-            if (typeof service !== "function" || !isFeatureClass(service))
-                throw new Error(`${this.name}: "${key}" is not a Feature — an ApplicationService goes in applicationServices`);
-            add(key, service);
-        }
-        for (const [key, service] of Object.entries(services.applicationServices ?? {})) {
-            if (typeof service !== "function" || !isApplicationServiceClass(service))
-                throw new Error(`${this.name}: "${key}" is not an ApplicationService — a Feature goes in features`);
-            add(key, service);
-        }
-        const registry = {
-            name: this.name,
-            dependencies: this.#dependencies,
-            classes,
-            features: new Set(Object.keys(services.features)),
-            instances: new Map(),
-            context: this.context,
-        };
-        return assemble({ registry, overrides: {}, scope: {} });
-    }
-}
-function assemble(binding) {
-    const { registry } = binding;
-    const held = {};
-    Object.defineProperties(held, {
-        name: { value: registry.name, enumerable: true },
-        context: { value: registry.context, enumerable: true },
-        with: {
-            value: (dependencies) => assemble({ ...binding, overrides: { ...binding.overrides, ...dependencies } }),
-        },
-        scoped: {
-            value: (values) => assemble({ ...binding, scope: { ...binding.scope, ...values } }),
-        },
-    });
-    // Each service is made and wrapped the first time it is asked for, then kept on this object.
-    for (const key of registry.classes.keys())
-        Object.defineProperty(held, key, {
-            configurable: true,
-            enumerable: true,
-            get() {
-                const service = intercepted(key, binding, undefined);
-                Object.defineProperty(held, key, { value: service, enumerable: true });
-                return service;
-            },
-        });
-    return held;
-}
-function instanceOf(registry, key) {
-    const known = registry.instances.get(key);
-    if (known !== undefined)
-        return known;
-    const Service = registry.classes.get(key);
-    if (Service === undefined)
-        throw new Error(`${registry.name}: no service is called "${key}"`);
-    const made = new Service();
-    registry.instances.set(key, made);
-    return made;
-}
-/**
- * A service as its holder sees it: each public method runs in an execution of its own — a child
- * of `parent` when an ApplicationService runs it. A method is the same function every time it is
- * read, so a screen can keep it (`useService(project.Issues.close)`).
- */
-function intercepted(key, binding, parent) {
-    const target = instanceOf(binding.registry, key);
-    const traced = methodsOf(target);
-    const methods = new Map();
-    return new Proxy(target, {
-        get(held, property) {
-            const value = Reflect.get(held, property, held);
-            if (typeof property !== "string" ||
-                typeof value !== "function" ||
-                !traced.has(property))
-                return value;
-            let method = methods.get(property);
-            if (method === undefined) {
-                const body = value;
-                method = (...args) => run(held, key, property, body, args, binding, parent);
-                methods.set(property, method);
-            }
-            return method;
-        },
-    });
-}
-function dependencyOf(binding, name) {
-    if (Object.hasOwn(binding.overrides, name))
-        return { found: true, value: binding.overrides[name] };
-    if (Object.hasOwn(binding.registry.dependencies, name))
-        return { found: true, value: binding.registry.dependencies[name] };
-    return { found: false, value: undefined };
-}
-/**
- * The run's own view of the instance: its context, its dependencies bound to this execution
- * (each bound the first time it is read), and — for an ApplicationService — its Features as
- * children of this run. Anything else is the instance's.
- */
-function viewOf(target, binding, execution) {
-    const bound = new Map();
-    let features;
-    const isComposer = composes(target);
-    return new Proxy(target, {
-        get(held, property, receiver) {
-            if (property === "context")
-                return execution.context;
-            if (property === "span")
-                return execution.span;
-            if (property === "feature" && isComposer)
-                return (features ??= featuresOf(binding, execution));
-            if (typeof property === "string") {
-                if (bound.has(property))
-                    return bound.get(property);
-                const dependency = dependencyOf(binding, property);
-                if (dependency.found) {
-                    const value = bindDependency(dependency.value, execution);
-                    bound.set(property, value);
-                    return value;
-                }
-            }
-            return Reflect.get(held, property, receiver);
-        },
-        set(held, property, value) {
-            if (ANSWERED.has(String(property)))
-                return false;
-            if (typeof property === "string" && dependencyOf(binding, property).found)
-                return false;
-            // What a method writes on `this` lands on the instance — it is the bounded context's.
-            return Reflect.set(held, property, value);
-        },
-    });
-}
-/** An ApplicationService's `this.feature`: each Feature, asked by name, a child of the run. */
-function featuresOf(binding, execution) {
-    const children = new Map();
-    return new Proxy({}, {
-        get(_, property) {
-            if (typeof property !== "string" || !binding.registry.features.has(property))
-                return undefined;
-            let child = children.get(property);
-            if (child === undefined) {
-                child = intercepted(property, binding, execution);
-                children.set(property, child);
-            }
-            return child;
-        },
-    });
-}
-const NOTHING = {};
-/** What a gesture runs with: the process's context, under it the bounded context's, its scope's. */
-function contextOf(binding) {
-    return {
-        ...processContext.values,
-        ...binding.registry.context.values,
-        ...binding.scope,
-    };
-}
-/** What watches a use case never changes what it answers: a tracer or reporter that throws is ignored. */
-function quietly(work, otherwise) {
-    try {
-        return work();
-    }
-    catch {
-        return otherwise;
-    }
-}
-const NO_SPAN = {
-    traceId: "",
-    spanId: "",
-    sampled: false,
-    set: () => undefined,
-    end: () => undefined,
-};
-function run(target, key, method, body, args, binding, parent) {
-    const settings = processNow();
-    const boundedContext = binding.registry.name;
-    // As sincpro_framework names a use case: the span `context/Name`, the identity `context.Name`.
-    const identity = method === "execute" ? key : `${key}.${method}`;
-    const useCase = `${boundedContext}.${identity}`;
-    const context = parent?.context ?? quietly(() => contextOf(binding), NOTHING);
-    const id = newEntityId();
-    const attributes = {
-        "sincpro.use_case": useCase,
-        "sincpro.layer": composes(target) ? "application_service" : "feature",
-        "sincpro.context": boundedContext,
-        "sincpro.execution_id": id,
-    };
-    const span = quietly(() => settings.tracer.start(`${boundedContext}/${identity}`, {
-        ...(parent === undefined ? {} : { parent: parent.span }),
-        attributes,
-    }), NO_SPAN);
-    const execution = { id, useCase, boundedContext, parent, span, context };
-    const finish = (failed, error) => {
-        const outcome = failed ? quietly(() => settings.outcomeOf(error), "failed") : "ok";
-        quietly(() => span.end(outcome, error), undefined);
-        if (outcome === "failed" && firstReport(error))
-            quietly(() => settings.reporter?.report(error, {
-                useCase,
-                traceId: span.traceId,
-                executionId: id,
-                context,
-            }), undefined);
-    };
-    let answer;
-    try {
-        answer = body.apply(viewOf(target, binding, execution), args);
-    }
-    catch (error) {
-        finish(true, error);
-        throw error;
-    }
-    if (answer instanceof Promise)
-        return answer.then((value) => {
-            finish(false);
-            return value;
-        }, (error) => {
-            finish(true, error);
-            throw error;
-        });
-    finish(false);
-    return answer;
-}

package/dist/services/execution.d.ts

@@ -1,63 +0,0 @@
-import type { Transport } from "../client/transport.js";
-import type { Span } from "../observability/ports.js";
-/**
- * One run of a use case: its span, what it runs with, and who ran it.
- *
- * Context: sincpro_framework keeps the running use case in a context variable; a browser has
- * nothing like it that survives an `await` (AsyncContext is a proposal, Zone.js patches the
- * world), and a global stack mixes the parents of two use cases running at once — which a
- * screen with several windows does all the time. So an execution is a value, handed to what
- * the use case calls: its Features (`this.feature`) and its dependencies (`BIND`).
- */
-export type Execution = {
-    /** UUID v7, as 32 hex: this run. */
-    readonly id: string;
-    /** `<bounded context>.<Service>[.<method>]` — the use case's identity, as the backend names its own. */
-    readonly useCase: string;
-    /** The bounded context the use case belongs to. */
-    readonly boundedContext: string;
-    /** The run that executed this one: an ApplicationService, for its Features. */
-    readonly parent: Execution | undefined;
-    readonly span: Span;
-    /** What it runs with, read once where the gesture started and inherited by every child. */
-    readonly context: Readonly<Record<string, unknown>>;
-};
-/**
- * A dependency that has something to say about the execution it is used in: given that
- * execution, it answers itself bound to it. The transport and every generated client are;
- * any other dependency of a bounded context is handed as it is.
- */
-export declare const BIND: unique symbol;
-export type Bindable<T> = {
-    [BIND]: (execution: Execution) => T;
-};
-/**
- * What every request of an execution carries: its trace (`traceparent`, W3C) and its context
- * (`sincpro-context`, the header sincpro_framework's entrances read, written with `plainCodec`).
- * Nothing when there is no trace and no context that travels.
- */
-export declare function headersOf(execution: Execution): Record<string, string>;
-/**
- * The transport, writing the execution's headers on every call — the caller's own headers of a
- * call still win.
- *
- * Context: the transport's own headers (`restTransport({ headers })`) are the session's — the
- * token, the tenant — the same for every call; these are the use case's, different for two use
- * cases running at once, so they travel per call (`CallOptions`).
- */
-export declare function bindTransport(transport: Transport, execution: Execution): Transport;
-/**
- * A client made over a transport, made again over the transport bound to each execution it is
- * used in. What a generated `clientOf(transport)` answers, so a Feature that calls
- * `this.client.sendIssue(…)` sends that request with its own trace.
- *
- *     export function clientOf(transport: Transport) {
- *       return bindable(transport, (transport) => ({ sendIssue: (body) => transport.send(…) }));
- *     }
- *
- * Context: it takes the function that makes the client, not the client — rebuilding through
- * `clientOf` itself would make TypeScript infer `clientOf` from its own return.
- */
-export declare function bindable<T extends object>(transport: Transport, make: (transport: Transport) => T): T;
-/** A dependency as the execution should see it: bound when it can be, as it is otherwise. */
-export declare function bindDependency<T>(value: T, execution: Execution): T;