@sincpro/client-framework 0.6.0 → 1.0.0

package/dist/observability/domain/tracing.d.ts

@@ -0,0 +1,49 @@
+/**
+ * What a platform plugs for execution traces: one span per use case.
+ *
+ * Context: sincpro_framework opens one span per use case; a client has to do the same, and
+ * continue the backend's trace. The vendor — OpenTelemetry in a browser, a queue on a phone,
+ * 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 it is a port.
+ *
+ * Nothing here may break a use case: a tracer that fails 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`: expected — the server said no and explained why (a validation, a conflict, a
+ *   permission), or the bounded context declared the error expected (`expectErrors`). 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;
+}
+/** Traces nothing: what a use case runs with until a platform plugs a tracer. */
+export declare const NO_TRACER: Tracer;

package/dist/observability/domain/tracing.js

@@ -0,0 +1,20 @@
+/**
+ * What a platform plugs for execution traces: one span per use case.
+ *
+ * Context: sincpro_framework opens one span per use case; a client has to do the same, and
+ * continue the backend's trace. The vendor — OpenTelemetry in a browser, a queue on a phone,
+ * 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 it is a port.
+ *
+ * Nothing here may break a use case: a tracer that fails 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/observability/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Observability: the ports a platform plugs (`Tracer`, `ErrorReporter`, `Logger`), the console
+ * engine logs go to by default, and how code writes and reports.
+ *
+ *   domain/          the ports: tracing, errors, logging
+ *   adapters/        console (default), memory (`./testing`), OpenTelemetry and Sentry (optional
+ *                    entries `./opentelemetry`, `./sentry`)
+ *   infrastructure/  the ports this process runs with (`configureProcess` plugs them)
+ *   services/        the loggers, `reportError`, the default `outcomeOf`
+ */
+export type { ErrorAbout, ErrorReporter, } from "./domain/errors.js";
+export type { LayerLogger, Logger, LogLayer, LogLevel, LogRecord, } from "./domain/logging.js";
+export { type Attributes, NO_TRACER, type Outcome, type Span, type Tracer, } from "./domain/tracing.js";
+export { combineLoggers, logger, loggerAdapter, } from "./services/logging.js";
+export { outcomeOf } from "./services/outcome.js";
+export { reportError } from "./services/reporting.js";

package/dist/observability/index.js

@@ -0,0 +1,4 @@
+export { NO_TRACER, } from "./domain/tracing.js";
+export { combineLoggers, logger, loggerAdapter, } from "./services/logging.js";
+export { outcomeOf } from "./services/outcome.js";
+export { reportError } from "./services/reporting.js";

package/dist/observability/infrastructure/registry.d.ts

@@ -0,0 +1,21 @@
+import type { ErrorReporter } from "../domain/errors.js";
+import type { Logger } from "../domain/logging.js";
+import { type Outcome, type Tracer } from "../domain/tracing.js";
+/**
+ * The observability this process runs with: who traces, who reports, where logs go and how an
+ * error ended a use case — the ports `configureProcess` plugged, read on every call.
+ *
+ * Context: sincpro_framework keeps the same state in its `observability_registry`, outside the
+ * buses, so a test resets everything with one call. Until a process configures, nothing traces,
+ * nothing reports, and logs go to the console in development mode.
+ */
+export type ObservabilityPorts = {
+    readonly tracer: Tracer;
+    readonly reporter: ErrorReporter | undefined;
+    readonly logger: Logger | undefined;
+    readonly outcomeOf: (error: unknown) => Outcome;
+};
+/** What the process observes with now. */
+export declare function observabilityNow(): ObservabilityPorts;
+/** @internal — `configureProcess` and `configureLogger` are the way in. */
+export declare function replaceObservability(ports: Partial<ObservabilityPorts>): void;

package/dist/observability/infrastructure/registry.js

@@ -0,0 +1,18 @@
+import { consoleLogger } from "../adapters/console.js";
+import { NO_TRACER, } from "../domain/tracing.js";
+import { outcomeOf } from "../services/outcome.js";
+const DEFAULTS = {
+    tracer: NO_TRACER,
+    reporter: undefined,
+    logger: consoleLogger({ mode: "development" }),
+    outcomeOf,
+};
+let current = DEFAULTS;
+/** What the process observes with now. */
+export function observabilityNow() {
+    return current;
+}
+/** @internal — `configureProcess` and `configureLogger` are the way in. */
+export function replaceObservability(ports) {
+    current = { ...current, ...ports };
+}

package/dist/observability/services/logging.d.ts

@@ -0,0 +1,27 @@
+import { type Execution } from "../../context/domain/execution.js";
+import type { LayerLogger, Logger, LogLayer } from "../domain/logging.js";
+import type { Outcome } from "../domain/tracing.js";
+/** The infrastructure's logger — the global one: the code that starts and holds the application. */
+export declare const logger: LayerLogger;
+/** The adapters' logger: what talks to a printer, a database, another system. */
+export declare const loggerAdapter: LayerLogger;
+/** @internal — a bounded context's own logger (`project.logger`). */
+export declare function boundedContextLogger(name: string): LayerLogger;
+/** @internal — what a Feature or ApplicationService finds as `this.logger` while it runs. */
+export declare function executionLogger(layer: "feature" | "application_service", execution: Execution): LayerLogger;
+/** Each destination keeps its own policy; one failing sink does not hold back the others. */
+export declare function combineLoggers(...loggers: readonly Logger[]): Logger;
+/** @internal — lifecycle records contain correlation and outcome, never business payloads. */
+export declare function logExecution(layer: "feature" | "application_service", execution: Execution, completed?: {
+    outcome: Outcome;
+    durationMs: number;
+}): void;
+/**
+ * @internal — an error a handler of the bounded context answered instead of raising: said once,
+ * with where it was handled, never with the error itself.
+ */
+export declare function logHandled(layer: LogLayer, correlation: {
+    execution: Execution;
+} | {
+    boundedContext: string;
+}): void;

package/dist/observability/services/logging.js

@@ -0,0 +1,105 @@
+import { BIND } from "../../context/domain/execution.js";
+import { observabilityNow } from "../infrastructure/registry.js";
+const processSink = () => observabilityNow().logger;
+/** Sink failures cannot replace a business outcome or cause unhandled async rejections. */
+function deliver(logger, record) {
+    if (!logger)
+        return;
+    try {
+        const pending = logger.log(record);
+        if (pending)
+            void Promise.resolve(pending).catch(() => { });
+    }
+    catch {
+        // Logging adapters are best-effort, as are tracing and error-reporting adapters.
+    }
+}
+function correlationOf(execution) {
+    return {
+        boundedContext: execution.boundedContext,
+        useCase: execution.useCase,
+        executionId: execution.id,
+        ...(execution.span.traceId ? { traceId: execution.span.traceId } : {}),
+        ...(execution.span.spanId ? { spanId: execution.span.spanId } : {}),
+    };
+}
+function layerLogger(layer, sink, correlation = {}) {
+    const write = (level, message, attributes) => {
+        deliver(sink(), {
+            timestamp: new Date().toISOString(),
+            level,
+            layer,
+            message,
+            ...(attributes ? { attributes: { ...attributes } } : {}),
+            ...correlation,
+        });
+    };
+    const logger = {
+        debug: (message, attributes) => write("debug", message, attributes),
+        info: (message, attributes) => write("info", message, attributes),
+        warn: (message, attributes) => write("warn", message, attributes),
+        error: (message, attributes) => write("error", message, attributes),
+    };
+    Object.defineProperty(logger, BIND, {
+        value: (run) => layerLogger(layer, sink, correlationOf(run)),
+        enumerable: false,
+    });
+    return logger;
+}
+/** The infrastructure's logger — the global one: the code that starts and holds the application. */
+export const logger = layerLogger("infrastructure", processSink);
+/** The adapters' logger: what talks to a printer, a database, another system. */
+export const loggerAdapter = layerLogger("adapter", processSink);
+/** @internal — a bounded context's own logger (`project.logger`). */
+export function boundedContextLogger(name) {
+    return layerLogger("bounded_context", processSink, { boundedContext: name });
+}
+/** @internal — what a Feature or ApplicationService finds as `this.logger` while it runs. */
+export function executionLogger(layer, execution) {
+    return layerLogger(layer, processSink, correlationOf(execution));
+}
+/** Each destination keeps its own policy; one failing sink does not hold back the others. */
+export function combineLoggers(...loggers) {
+    return {
+        log: (record) => {
+            for (const logger of loggers)
+                deliver(logger, record);
+        },
+    };
+}
+/** @internal — lifecycle records contain correlation and outcome, never business payloads. */
+export function logExecution(layer, execution, completed) {
+    const outcome = completed?.outcome;
+    const level = outcome === "failed"
+        ? "error"
+        : outcome === "refused"
+            ? "warn"
+            : completed
+                ? "info"
+                : "debug";
+    deliver(processSink(), {
+        timestamp: new Date().toISOString(),
+        level,
+        layer,
+        event: completed ? "execution.finished" : "execution.started",
+        message: completed ? `Execution ${completed.outcome}` : "Execution started",
+        ...correlationOf(execution),
+        ...(completed ? completed : {}),
+    });
+}
+/**
+ * @internal — an error a handler of the bounded context answered instead of raising: said once,
+ * with where it was handled, never with the error itself.
+ */
+export function logHandled(layer, correlation) {
+    deliver(processSink(), {
+        timestamp: new Date().toISOString(),
+        level: "info",
+        layer,
+        event: "error.handled",
+        message: "Error handled",
+        ...("execution" in correlation
+            ? correlationOf(correlation.execution)
+            : { boundedContext: correlation.boundedContext }),
+    });
+}

package/dist/observability/services/outcome.d.ts

@@ -0,0 +1,12 @@
+import type { Outcome } from "../domain/tracing.js";
+/**
+ * How an error ended a use case, by default.
+ *
+ * Context: the backend reports what nobody expected and only that — a refusal it explained is
+ * the business answering, not a fault. Here the same: a `TransportError` the server answered
+ * with a 4xx is `refused`; a request the caller stopped waiting for is `aborted`; everything
+ * else — a bug, a 5xx, a server nobody could reach — is `failed`, and reported. A bounded
+ * context adds its own expected errors (`expectErrors`); a process replaces this whole
+ * (`configureProcess({ outcomeOf })`).
+ */
+export declare function outcomeOf(error: unknown): Outcome;

package/dist/observability/services/outcome.js

@@ -0,0 +1,20 @@
+import { TransportError } from "../../client/domain/transport.js";
+/**
+ * How an error ended a use case, by default.
+ *
+ * Context: the backend reports what nobody expected and only that — a refusal it explained is
+ * the business answering, not a fault. Here the same: a `TransportError` the server answered
+ * with a 4xx is `refused`; a request the caller stopped waiting for is `aborted`; everything
+ * else — a bug, a 5xx, a server nobody could reach — is `failed`, and reported. A bounded
+ * context adds its own expected errors (`expectErrors`); a process replaces this whole
+ * (`configureProcess({ outcomeOf })`).
+ */
+export function outcomeOf(error) {
+    if (error instanceof TransportError && error.status !== null)
+        return error.status >= 400 && error.status < 500 ? "refused" : "failed";
+    if (error !== null &&
+        typeof error === "object" &&
+        error.name === "AbortError")
+        return "aborted";
+    return "failed";
+}

package/dist/{services/report.js → observability/services/reporting.js}

@@ -1,5 +1,6 @@
-import { newEntityId } from "../common/ids.js";
-import { processContext, processNow } from "./process.js";
+import { newEntityId } from "../../common/ids.js";
+import { processContext } from "../../context/infrastructure/process.js";
+import { observabilityNow } from "../infrastructure/registry.js";
 /**
  * Whether this is the first time this error is reported. A Feature that fails inside an
  * ApplicationService throws through it, and a screen that draws the failure may break on it:
@@ -28,7 +29,7 @@ export function firstReport(error) {
  * ignored: telling about a failure never becomes a second one.
  */
 export function reportError(error, where) {
-    const settings = processNow();
+    const settings = observabilityNow();
     try {
         // What the server explained, or what the caller stopped waiting for, is not a fault here either.
         if (settings.outcomeOf(error) !== "failed")

package/dist/testing/index.d.ts

@@ -1,35 +1,5 @@
-import type { ErrorAbout, ErrorReporter, Outcome, Tracer } from "../observability/ports.js";
 /**
- * A tracer and a reporter that keep what they were told, so a test reads it back.
- *
- *     const tracer = memoryTracer();
- *     configureProcess({ tracer });
- *     await project.CloseIssue.execute(input);
- *     tracer.spans.map((one) => one.name);   // ["project/CloseIssue", "project/Issues.close", …]
- *
- * Context: a use case is proven in Node with nothing of a platform; these are the platform's
- * part, held in memory. Not test doubles of this package — real implementations of its ports.
+ * `@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.
  */
-/** A span as the memory tracer kept it. */
-export type RecordedSpan = {
-    name: string;
-    traceId: string;
-    spanId: string;
-    /** The span it was opened under, when it was. */
-    parentSpanId: string | undefined;
-    attributes: Record<string, string | number | boolean>;
-    /** How it ended; `undefined` while it is open. */
-    outcome: Outcome | undefined;
-    error: unknown;
-};
-export type MemoryTracer = Tracer & {
-    readonly spans: RecordedSpan[];
-};
-export declare function memoryTracer(): MemoryTracer;
-export type MemoryReporter = ErrorReporter & {
-    readonly reports: {
-        error: unknown;
-        about: ErrorAbout;
-    }[];
-};
-export declare function memoryReporter(): MemoryReporter;
+export { type MemoryLogger, memoryLogger, type MemoryReporter, memoryReporter, type MemoryTracer, memoryTracer, type RecordedSpan, } from "../observability/adapters/memory.js";

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.6.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,21 +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/adapters/parquet.d.ts",
-      "default": "./dist/adapters/parquet.js"
+      "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",

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>;
-}