@sincpro/client-framework 0.6.0 → 1.1.0

package/dist/observability/services/outcome.js

@@ -0,0 +1,17 @@
+import { failureOf } from "../../common/failures.js";
+/**
+ * How an error ended a use case, by default — read off the failure it is (`failureOf`).
+ *
+ * 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 failure that is the caller's answer (a
+ * 4xx, an error that declares a kind such as `domain` or `not_found`) is `refused`; a request
+ * the caller stopped waiting for is `aborted`; a fault — 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) {
+    const failure = failureOf(error);
+    if (failure.aborted)
+        return "aborted";
+    return failure.fault ? "failed" : "refused";
+}

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.1.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/client.d.ts

@@ -1,14 +0,0 @@
-import type { Metamodel } from "./metamodel.js";
-import { type GenerateOptions } from "./rest.js";
-/**
- * The TypeScript of the client of `metamodel`, as the text of one file next to its `domain.ts`.
- *
- * 1. Every operation, by its local name, as data: identity, role, `query`, entities, targets
- *    and the binding of each wire that publishes it.
- * 2. Per operation REST reaches, how a transport calls it (`callOf`): a page, a record, a write
- *    — or none, said in the client's own doc.
- * 3. The routes of the writes, read once (`writeRoute`).
- * Final: `clientOf(transport)`, a method per operation reached, named by `methodOf`; two with
- *    one name are refused, naming both.
- */
-export declare function clientFileOf(metamodel: Metamodel, options?: GenerateOptions): string;

package/dist/codegen/client.js

@@ -1,201 +0,0 @@
-import { aliasOf, answerOf, claimed, deprecationOf, docOf, DOMAIN_MODULE, FRAMEWORK, headerOf, identifierOf, localOf, methodOf, recordLiteral, sorted, } from "./names.js";
-import { ownerOf, restOf, WRITES, } from "./rest.js";
-/**
- * The client of a bounded context as TypeScript: every operation as data, and a method for each
- * one REST reaches the way a `Transport` sends — over `@sincpro/client-framework`, so a script,
- * a test or a hook of its own calls the service typed, with no screen.
- *
- * Context: a method only writes down the route the contract published and hands the call to the
- * transport, which keeps the rules — the `Idempotency-Key`, the `Problem`, the model's version.
- * A GET is a page (`list`), one record (`one`), a file (`export`: `downloadRoute`, its bytes as
- * they arrive), or — a Query of the context's own, `GET /me` — a read of its answer as it came
- * (`readRoute`, over a transport that has `read`). A GET's
- * keys in its path are required parameters; every other field is an optional one.
- */
-/** A search's fields a page asks with, not the screen: the criteria, and its cursor inside it. */
-const PAGED = new Set(["criteria", "cursor"]);
-/** An export's fields its method takes apart: the criteria and the format. */
-const EXPORTED = new Set(["criteria", "cursor", "format"]);
-/** A GET's parameters: the path's keys, and the rest of its input but what a page asks with. */
-function askedOf(operation, rest, paged, apart = PAGED) {
-    const path = [...rest.fields].sort();
-    const query = Object.keys(operation.input.properties ?? {})
-        .filter((one) => !path.includes(one) && !(paged && apart.has(one)))
-        .sort();
-    return { path, query };
-}
-function callOf(metamodel, operation, rest) {
-    if (rest === undefined)
-        return { kind: "none", why: "REST does not publish it" };
-    if (WRITES.has(rest.method))
-        return { kind: "send" };
-    const owner = ownerOf(metamodel, operation);
-    if (operation.role === "search" && owner !== undefined && owner in metamodel.models)
-        return { kind: "list", entity: owner, ...askedOf(operation, rest, true) };
-    // An export answers bytes, never JSON: it is downloaded.
-    if (operation.role === "export" && owner !== undefined && owner in metamodel.models)
-        return { kind: "download", entity: owner, ...askedOf(operation, rest, true, EXPORTED) };
-    const field = owner === undefined ? undefined : operation.targets[owner];
-    const record = rest.fields.length === 1 && rest.fields[0] === field;
-    if (operation.role === "get" && owner !== undefined && field !== undefined && record)
-        return { kind: "one", entity: owner, field };
-    // Any other GET — a Query of the context's own, `GET /me` — is read as it answers.
-    return { kind: "read", ...askedOf(operation, rest, false) };
-}
-/** A parameter list's TypeScript: the path's keys required, the rest optional, all as text. */
-function paramsOf(asked) {
-    const union = (names) => names.map((one) => JSON.stringify(one)).join(" | ");
-    if (asked.path.length === 0 && asked.query.length === 0)
-        return { signature: "", route: (path) => JSON.stringify(path) };
-    const required = asked.path.length === 0 ? "" : `Readonly<Record<${union(asked.path)}, string>>`;
-    const optional = asked.query.length === 0 ? "" : `Partial<Record<${union(asked.query)}, string>>`;
-    const type = [required, optional].filter((one) => one !== "").join(" & ");
-    return {
-        signature: `params${asked.path.length === 0 ? "?" : ""}: ${type}`,
-        route: (path) => `listRoute(${JSON.stringify(path)}, params)`,
-    };
-}
-/** The data of one operation: what it is, and how each wire reaches it. */
-function dataOf(metamodel, identity, operation, rest) {
-    const lines = [
-        `    identity: ${JSON.stringify(identity)},`,
-        `    role: ${JSON.stringify(operation.role)},`,
-        `    query: ${operation.query},`,
-        `    entities: ${JSON.stringify(operation.entities)},`,
-        `    targets: ${recordLiteral(operation.targets)},`,
-    ];
-    if (rest !== undefined)
-        lines.push(`    rest: { method: ${JSON.stringify(rest.method)}, path: ${JSON.stringify(rest.path)} },`);
-    const rpc = metamodel.bindings?.rpc?.[identity];
-    if (rpc !== undefined)
-        lines.push(`    rpc: { method: ${JSON.stringify(rpc.method)} },`);
-    const grpc = metamodel.bindings?.grpc?.[identity];
-    if (grpc !== undefined)
-        lines.push(`    grpc: { method: ${JSON.stringify(grpc.method)} },`);
-    const mcp = metamodel.bindings?.mcp?.[identity];
-    if (mcp !== undefined)
-        lines.push(`    mcp: { tool: ${JSON.stringify(mcp.tool)} },`);
-    return `  ${localOf(metamodel, identity)}: {\n${lines.join("\n")}\n  },`;
-}
-function methodSourceOf(local, answer, method, call, rest, doc) {
-    if (call.kind === "list") {
-        const entity = `dto.${identifierOf(call.entity)}`;
-        const params = paramsOf(call);
-        const signature = params.signature === "" ? "" : `, ${params.signature}`;
-        return `${doc}    ${method}: (criteria: Criteria<${entity}>${signature}) =>\n      transport.list<${entity}>(${params.route(rest.path)}, criteria),`;
-    }
-    if (call.kind === "download") {
-        const entity = `dto.${identifierOf(call.entity)}`;
-        const params = paramsOf(call);
-        // The path's keys are required, so they come first: a required parameter never follows an
-        // optional one.
-        const keys = params.signature === "" ? "" : `${params.signature.replace("params?:", "params:")}, `;
-        const given = params.signature === "" ? "" : ", params";
-        return `${doc}    ${method}: (${keys}criteria?: Criteria<${entity}>, format?: ExportFormat) =>\n      downloadRoute(transport, exportRoute(${JSON.stringify(rest.path)}, criteria, format${given})),`;
-    }
-    if (call.kind === "read") {
-        const params = paramsOf(call);
-        return `${doc}    ${method}: (${params.signature}) =>\n      readRoute<dto.${answer}>(transport, ${params.route(rest.path)}),`;
-    }
-    if (call.kind === "one") {
-        const path = rest.path.replace(`{${call.field}}`, "${encodeURIComponent(id)}");
-        return `${doc}    ${method}: (id: string) =>\n      transport.one<dto.${identifierOf(call.entity)}>(\`${path}\`),`;
-    }
-    const id = rest.fields.includes("id")
-        ? "body.id === undefined ? undefined : String(body.id)"
-        : "undefined";
-    return [
-        `${doc}    ${method}: (body: dto.${local}, options?: SendOptions) =>`,
-        `      transport.send<dto.${answer}>(`,
-        `        ${JSON.stringify(rest.method)},`,
-        `        pathFor(routes.${method}, ${id}, body),`,
-        `        body,`,
-        `        undefined,`,
-        `        options,`,
-        `      ),`,
-    ].join("\n");
-}
-/**
- * The TypeScript of the client of `metamodel`, as the text of one file next to its `domain.ts`.
- *
- * 1. Every operation, by its local name, as data: identity, role, `query`, entities, targets
- *    and the binding of each wire that publishes it.
- * 2. Per operation REST reaches, how a transport calls it (`callOf`): a page, a record, a write
- *    — or none, said in the client's own doc.
- * 3. The routes of the writes, read once (`writeRoute`).
- * Final: `clientOf(transport)`, a method per operation reached, named by `methodOf`; two with
- *    one name are refused, naming both.
- */
-export function clientFileOf(metamodel, options = {}) {
-    const claim = claimed();
-    const operations = sorted(metamodel.operations);
-    const data = [];
-    const routes = [];
-    const methods = [];
-    const unreached = [];
-    let lists = false;
-    let paged = false;
-    let reads = false;
-    let sends = false;
-    let downloads = false;
-    for (const [identity, operation] of operations) {
-        const local = localOf(metamodel, identity);
-        const rest = restOf(metamodel, identity, options);
-        data.push(dataOf(metamodel, identity, operation, rest));
-        const call = callOf(metamodel, operation, rest);
-        if (call.kind === "none" || rest === undefined) {
-            unreached.push(`\`${local}\`: ${call.kind === "none" ? call.why : ""}.`);
-            continue;
-        }
-        const method = methodOf(local);
-        claim(method, `operation ${identity}`);
-        const doc = docOf([operation.description, deprecationOf(metamodel, operation)], "    ");
-        methods.push(methodSourceOf(local, answerOf(metamodel, identity), method, call, rest, doc));
-        if (call.kind === "download") {
-            downloads = true;
-            paged = true;
-        }
-        if (call.kind === "list" || call.kind === "read") {
-            paged ||= call.kind === "list";
-            reads ||= call.kind === "read";
-            lists ||= call.path.length + call.query.length > 0;
-        }
-        if (call.kind === "send") {
-            sends = true;
-            routes.push(`  ${method}: writeRoute(${JSON.stringify(`${rest.method} ${rest.path}`)}),`);
-        }
-    }
-    const core = [
-        "bindable",
-        ...(downloads ? ["downloadRoute", "type ExportFormat", "exportRoute"] : []),
-        ...(lists ? ["listRoute"] : []),
-        ...(sends ? ["pathFor"] : []),
-        ...(reads ? ["readRoute"] : []),
-        ...(sends ? ["type SendOptions"] : []),
-        "type Transport",
-        ...(sends ? ["writeRoute"] : []),
-    ];
-    const imports = [
-        ...(paged ? ['import type { Criteria } from "@sincpro/criteria";'] : []),
-        `import { ${core.join(", ")} } from "${FRAMEWORK}";`,
-        "",
-        `import type * as dto from "${DOMAIN_MODULE}";`,
-    ].join("\n");
-    const client = [
-        "/**",
-        ` * «${aliasOf(metamodel)}» over a transport: a method for each operation REST reaches as a`,
-        " * page, a record, a read of its own or a write. Used by a Feature, each request carries the",
-        " * trace and the context of the use case that sent it (`bindable`).",
-        ...(unreached.length === 0
-            ? []
-            : [" *", " * Without a method here:", ...unreached.map((one) => ` * - ${one}`)]),
-        " */",
-    ].join("\n");
-    return `${[
-        headerOf("The client", metamodel),
-        imports,
-        `/** Every operation of «${aliasOf(metamodel)}», as data: what it is, and how each wire reaches it. */\nexport const operations = {\n${data.join("\n")}\n} as const;`,
-        ...(routes.length === 0 ? [] : [`const routes = {\n${routes.join("\n")}\n};`]),
-        `${client}\nexport function clientOf(transport: Transport) {\n  return bindable(transport, (transport) => ({\n${methods.join("\n")}\n  }));\n}`,
-    ].join("\n\n")}\n`;
-}

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