@sincpro/client-framework 0.1.0 → 0.3.0

package/dist/adapters/opentelemetry.js

@@ -0,0 +1,68 @@
+import { isSpanContextValid, ROOT_CONTEXT, SpanKind, SpanStatusCode, trace, TraceFlags, } from "@opentelemetry/api";
+/**
+ * The `Tracer` port over OpenTelemetry's API: every use case a span of whatever provider the
+ * platform registered.
+ *
+ *     // a browser (@sincpro/web-framework/telemetry does this), Node, React Native…
+ *     const tracer = openTelemetryTracer(provider.getTracer("forge-web"));
+ *     configureProcess({ tracer });
+ *
+ * Context: only `@opentelemetry/api`, which runs the same on every platform — the provider, its
+ * exporter and where it sends are the platform's (the browser's OTLP over fetch, a phone's
+ * queue, a server's SDK). An optional entry with an optional peer: an application that does not
+ * import it installs nothing and ships nothing.
+ *
+ * The parent is given, never read from OpenTelemetry's context: a run carries its own execution
+ * (`Execution`), so two use cases at once never take each other's span, and no context manager
+ * (Zone.js) is needed. A span nothing records (a sampler said no, no provider registered)
+ * answers no ids — so no `traceparent` claims a trace that does not exist.
+ */
+export function openTelemetryTracer(tracer) {
+    return {
+        start(name, options) {
+            const parent = options.parent;
+            const parentContext = parent !== undefined && parent.traceId !== "" && parent.spanId !== ""
+                ? trace.setSpanContext(ROOT_CONTEXT, {
+                    traceId: parent.traceId,
+                    spanId: parent.spanId,
+                    traceFlags: parent.sampled ? TraceFlags.SAMPLED : TraceFlags.NONE,
+                    isRemote: false,
+                })
+                : ROOT_CONTEXT;
+            const span = tracer.startSpan(name, {
+                kind: SpanKind.INTERNAL,
+                ...(options.attributes ? { attributes: options.attributes } : {}),
+            }, parentContext);
+            const own = span.spanContext();
+            const valid = isSpanContextValid(own);
+            const state = own.traceState?.serialize();
+            return {
+                traceId: valid ? own.traceId : "",
+                spanId: valid ? own.spanId : "",
+                sampled: valid && (own.traceFlags & TraceFlags.SAMPLED) === TraceFlags.SAMPLED,
+                ...(state ? { state } : {}),
+                set: (attributes) => void span.setAttributes(attributes),
+                end: (outcome, error) => close(span, outcome, error),
+            };
+        },
+    };
+}
+/**
+ * How the use case ended, said the way OpenTelemetry reads it: `failed` is an error with its
+ * exception; `refused` and `aborted` are expected answers — said in `sincpro.outcome`, never as
+ * an error, the way the backend leaves a refusal out of its error rate.
+ */
+function close(span, outcome, error) {
+    span.setAttribute("sincpro.outcome", outcome);
+    if (outcome === "failed") {
+        if (error instanceof Error)
+            span.recordException(error);
+        span.setStatus({
+            code: SpanStatusCode.ERROR,
+            ...(error instanceof Error ? { message: error.message } : {}),
+        });
+    }
+    else if (outcome === "ok")
+        span.setStatus({ code: SpanStatusCode.OK });
+    span.end();
+}

package/dist/adapters/sentry.d.ts

@@ -0,0 +1,28 @@
+import type { ErrorReporter } from "../observability/ports.js";
+/**
+ * What this adapter needs of a Sentry-compatible client: its `captureException`. A browser's
+ * `BrowserClient`, Node's, React Native's — and GlitchTip, which speaks Sentry's protocol.
+ */
+export type ExceptionClient = {
+    captureException(error: unknown, hint?: {
+        captureContext?: {
+            tags?: Record<string, string>;
+            contexts?: Record<string, Record<string, unknown>>;
+        };
+    }): unknown;
+};
+/**
+ * The `ErrorReporter` port over a Sentry-compatible client: an unexpected error reported with the
+ * use case it happened in, its trace — the id the backend logged too — and its context.
+ *
+ *     // @sincpro/web-framework/errors builds the browser's client with GlitchTip's DSN
+ *     const reporter = sentryReporter(client);
+ *     configureProcess({ reporter });
+ *
+ * Context: it imports nothing — it takes the client the platform made (with its DSN, release
+ * and data rules), so it costs no dependency and works on every platform. What is reported is
+ * already decided by the process (`outcomeOf`: only `failed`); this only says where it happened.
+ * The context goes as a context, not as tags: a tag is indexed and searched, and an execution's
+ * values are not the place for that.
+ */
+export declare function sentryReporter(client: ExceptionClient): ErrorReporter;

package/dist/adapters/sentry.js

@@ -0,0 +1,36 @@
+/**
+ * The `ErrorReporter` port over a Sentry-compatible client: an unexpected error reported with the
+ * use case it happened in, its trace — the id the backend logged too — and its context.
+ *
+ *     // @sincpro/web-framework/errors builds the browser's client with GlitchTip's DSN
+ *     const reporter = sentryReporter(client);
+ *     configureProcess({ reporter });
+ *
+ * Context: it imports nothing — it takes the client the platform made (with its DSN, release
+ * and data rules), so it costs no dependency and works on every platform. What is reported is
+ * already decided by the process (`outcomeOf`: only `failed`); this only says where it happened.
+ * The context goes as a context, not as tags: a tag is indexed and searched, and an execution's
+ * values are not the place for that.
+ */
+export function sentryReporter(client) {
+    return {
+        report(error, about) {
+            client.captureException(error, {
+                captureContext: {
+                    tags: {
+                        "sincpro.use_case": about.useCase,
+                        ...(about.traceId === "" ? {} : { trace_id: about.traceId }),
+                    },
+                    contexts: {
+                        sincpro: {
+                            use_case: about.useCase,
+                            execution_id: about.executionId,
+                            ...(about.traceId === "" ? {} : { trace_id: about.traceId }),
+                            context: about.context,
+                        },
+                    },
+                },
+            });
+        },
+    };
+}

package/dist/client/memory.js

@@ -1,5 +1,12 @@
 import { TransportError, } from "./transport.js";
 import { answer, answerGroups } from "@sincpro/criteria/engine";
+/**
+ * A deep copy, as over a wire: `structuredClone` where the platform has it, a JSON round trip
+ * where it does not (some React Native engines) — the rows a fake server holds are plain JSON.
+ */
+const copyOf = typeof globalThis.structuredClone === "function"
+    ? (value) => globalThis.structuredClone(value)
+    : (value) => (value === undefined ? value : JSON.parse(JSON.stringify(value)));
 function wait(ms, signal) {
     if (ms <= 0)
         return Promise.resolve();
@@ -46,7 +53,7 @@ export function memoryTransport(tables, options = {}) {
                 ? answerGroups(table.rows, criteria, table.meta)
                 : answer(table.rows, criteria, table.meta);
             // A copy, as over a wire: a screen holding a row must not see the server change it.
-            return { ...page, rows: structuredClone(page.rows) };
+            return { ...page, rows: copyOf(page.rows) };
         },
         async one(route, signal) {
             await check(route, signal);
@@ -66,7 +73,7 @@ export function memoryTransport(tables, options = {}) {
                     detail: `${table.meta.aggregate} ${id} does not exist.`,
                 });
             return {
-                record: structuredClone(record),
+                record: copyOf(record),
                 meta: table.meta,
                 dropped: [],
                 draft: options.draft?.(route) ?? null,
@@ -78,7 +85,7 @@ export function memoryTransport(tables, options = {}) {
             // sincpro_framework's `@idempotency` does with a repeated `Idempotency-Key`.
             const key = sending?.idempotencyKey;
             if (key !== undefined && answered.has(key))
-                return structuredClone(answered.get(key));
+                return copyOf(answered.get(key));
             if (options.handle === undefined)
                 throw new TransportError(route, 404, {
                     kind: "not_found",
@@ -90,9 +97,9 @@ export function memoryTransport(tables, options = {}) {
                     detail: `Nothing answers ${method} ${route}.`,
                 });
             // A deep copy: what the caller sent is not what the server keeps.
-            const answer = await options.handle(method, route, structuredClone(body));
+            const answer = await options.handle(method, route, copyOf(body));
             if (key !== undefined)
-                answered.set(key, structuredClone(answer));
+                answered.set(key, copyOf(answer));
             return answer;
         },
         ...(options.read === undefined
@@ -101,7 +108,7 @@ export function memoryTransport(tables, options = {}) {
                 async read(route, signal) {
                     await check(route, signal);
                     // A copy, as every answer: over a wire nobody holds the server's object.
-                    return structuredClone(await options.read(route));
+                    return copyOf(await options.read(route));
                 },
             }),
     };

package/dist/context/context.d.ts

@@ -0,0 +1,45 @@
+import type { ContextStore, ContextValues } from "./store.js";
+/**
+ * One level of the context: the process's (`processContext`) or a bounded context's
+ * (`project.context`), read and written the same way on every platform.
+ *
+ *     processContext.set({ tenant_id: "acme" });      the company changed — every screen hears it
+ *     processContext.get("tenant_id")                  →  "acme"
+ *     project.context.set({ warehouse_id: 4 });        only what `project` runs
+ *     const stop = processContext.watch(() => redraw());
+ *
+ * Context: sincpro_framework reads its context from a tree — the process, the bounded context,
+ * the scope, the execution — and the nearest wins. A client has the same levels: a use case runs
+ * with the process's values, under them its bounded context's, under them a scope's
+ * (`project.scoped({...})`), read once where the gesture starts and inherited by every Feature
+ * it runs. That snapshot is `this.context` and what travels to the server in `sincpro-context`.
+ *
+ * Where the values live is the platform's (`ContextStore`): this is only the door. `values` is
+ * the same object until something changes it, so a screen can hand it straight to React's
+ * `useSyncExternalStore`, and `watch` is bound — pass it as it is.
+ */
+export type Context<C extends object = ContextValues> = {
+    /** Its values now: the same object until they change. Never change it — `set` does. */
+    readonly values: Readonly<Partial<C>>;
+    get<K extends keyof C & string>(name: K): C[K] | undefined;
+    /** Adds or replaces these names; the others stay. */
+    set(values: Partial<C>): void;
+    /** Removes these names — every name when none is given. */
+    clear(...names: (keyof C & string)[]): void;
+    /** Calls `listener` whenever its values change; answers the way to stop. */
+    watch(listener: () => void): () => void;
+};
+/**
+ * Where a level finds its store: the one in use now, and word when another replaces it — the
+ * process's, which `configureProcess` may change after a screen started listening.
+ */
+export type StoreSource = {
+    current(): ContextStore;
+    replaced(listener: () => void): () => void;
+};
+/**
+ * The level saved under `key` in whatever store `source` holds now — asked again on every call,
+ * so a store the process configures after this level was made is the one used, and whoever
+ * listens moves to it and hears the change.
+ */
+export declare function contextAt<C extends object = ContextValues>(key: string, source: StoreSource): Context<C>;

package/dist/context/context.js

@@ -0,0 +1,70 @@
+const NOTHING = {};
+/**
+ * The level saved under `key` in whatever store `source` holds now — asked again on every call,
+ * so a store the process configures after this level was made is the one used, and whoever
+ * listens moves to it and hears the change.
+ */
+export function contextAt(key, source) {
+    const storeOf = () => source.current();
+    // The values last read, by store and version: a store that answers a new object on every
+    // `load` still gives one object per change.
+    let seen;
+    // Who listens when the store cannot say it changed (`watch` is optional).
+    const listeners = new Set();
+    const read = () => {
+        const store = storeOf();
+        const version = store.version(key);
+        if (seen?.store !== store || seen.version !== version)
+            seen = { store, version, values: store.load(key) ?? NOTHING };
+        return seen.values;
+    };
+    const write = (values) => {
+        const store = storeOf();
+        if (values === undefined)
+            store.delete(key);
+        else
+            store.save(key, values);
+        if (store.watch === undefined)
+            for (const listener of [...listeners])
+                listener();
+    };
+    return {
+        get values() {
+            return read();
+        },
+        get: (name) => read()[name],
+        set: (values) => write({ ...read(), ...values }),
+        clear(...names) {
+            if (names.length === 0)
+                return write(undefined);
+            const kept = { ...read() };
+            for (const name of names)
+                delete kept[name];
+            write(kept);
+        },
+        watch(listener) {
+            let watching;
+            let unwatch;
+            const follow = () => {
+                const store = storeOf();
+                if (store === watching)
+                    return;
+                unwatch?.();
+                watching = store;
+                unwatch = store.watch?.(key, listener);
+            };
+            follow();
+            listeners.add(listener);
+            // Another store is other values: listen to it, and say so.
+            const unreplaced = source.replaced(() => {
+                follow();
+                listener();
+            });
+            return () => {
+                unwatch?.();
+                unreplaced();
+                listeners.delete(listener);
+            };
+        },
+    };
+}

package/dist/context/store.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `ContextStore`: where the context lives — the port each platform implements with its own
+ * technology, so every use case reads the same context the same way.
+ *
+ *     store.save("process", { tenant_id: "acme", lang: "es" });
+ *     store.load("process")      →  { tenant_id: "acme", lang: "es" }     undefined when never saved
+ *     store.version("process")   →  1                                       0 when never saved
+ *     store.watch?.("process", () => …)                                     a change anywhere
+ *
+ * Context: sincpro_framework's `ContextStore` with the same four methods — the process's memory by
+ * default, a Redis when a project says so — and one more, optional, a client needs: `watch`, so
+ * a screen redraws when the tenant changes. The store never decides what the context is: it keeps
+ * values under a key (`process`, `bounded_context:<name>`), and `Context` reads and writes them.
+ *
+ * One per platform, chosen by the application (`configureProcess({ context })`):
+ *
+ * - `memoryContexts()` — this package's default, everywhere.
+ * - a browser: the same, or one over `sessionStorage` to survive a reload, or over the screens'
+ *   own store (Zustand, Redux) so they share one source.
+ * - a phone: MMKV (synchronous), or memory hydrated from AsyncStorage at start and written through.
+ * - a server that renders: one over `AsyncLocalStorage`, so two requests never see each other's.
+ *
+ * Reads are synchronous on purpose: a use case reads its context where a gesture starts, and an
+ * asynchronous store would make every use case wait for it.
+ */
+/** What a context holds: plain values, the way JSON carries them to the server. */
+export type ContextValues = Readonly<Record<string, unknown>>;
+export interface ContextStore {
+    /** What `key` holds, or `undefined` when nothing was saved there. */
+    load(key: string): ContextValues | undefined;
+    /** `values` under `key`, replacing what was there. Each save moves the key's version. */
+    save(key: string, values: ContextValues): void;
+    /** `key` is gone. Its version moves too. */
+    delete(key: string): void;
+    /**
+     * How many times `key` changed — what a reader compares to know it changed. `load` may answer
+     * a new object each time (a store that parses JSON does); the version is what says it is new.
+     */
+    version(key: string): number;
+    /**
+     * Calls `listener` whenever `key` changes, from here or from elsewhere (another tab, a native
+     * module); answers the way to stop. Optional: without it, only the changes made through this
+     * package's `Context` are heard.
+     */
+    watch?(key: string, listener: () => void): () => void;
+}
+/**
+ * The context in this process's memory: the default, on every platform. A test gets a fresh one
+ * from `configureProcess()`.
+ */
+export declare function memoryContexts(): ContextStore;

package/dist/context/store.js

@@ -0,0 +1,59 @@
+/**
+ * `ContextStore`: where the context lives — the port each platform implements with its own
+ * technology, so every use case reads the same context the same way.
+ *
+ *     store.save("process", { tenant_id: "acme", lang: "es" });
+ *     store.load("process")      →  { tenant_id: "acme", lang: "es" }     undefined when never saved
+ *     store.version("process")   →  1                                       0 when never saved
+ *     store.watch?.("process", () => …)                                     a change anywhere
+ *
+ * Context: sincpro_framework's `ContextStore` with the same four methods — the process's memory by
+ * default, a Redis when a project says so — and one more, optional, a client needs: `watch`, so
+ * a screen redraws when the tenant changes. The store never decides what the context is: it keeps
+ * values under a key (`process`, `bounded_context:<name>`), and `Context` reads and writes them.
+ *
+ * One per platform, chosen by the application (`configureProcess({ context })`):
+ *
+ * - `memoryContexts()` — this package's default, everywhere.
+ * - a browser: the same, or one over `sessionStorage` to survive a reload, or over the screens'
+ *   own store (Zustand, Redux) so they share one source.
+ * - a phone: MMKV (synchronous), or memory hydrated from AsyncStorage at start and written through.
+ * - a server that renders: one over `AsyncLocalStorage`, so two requests never see each other's.
+ *
+ * Reads are synchronous on purpose: a use case reads its context where a gesture starts, and an
+ * asynchronous store would make every use case wait for it.
+ */
+/**
+ * The context in this process's memory: the default, on every platform. A test gets a fresh one
+ * from `configureProcess()`.
+ */
+export function memoryContexts() {
+    const held = new Map();
+    const versions = new Map();
+    const listeners = new Map();
+    const changed = (key) => {
+        versions.set(key, (versions.get(key) ?? 0) + 1);
+        for (const listener of [...(listeners.get(key) ?? [])])
+            listener();
+    };
+    return {
+        load: (key) => held.get(key),
+        save(key, values) {
+            // A copy: whoever handed the values may keep changing their object.
+            held.set(key, { ...values });
+            changed(key);
+        },
+        delete(key) {
+            if (!held.delete(key))
+                return;
+            changed(key);
+        },
+        version: (key) => versions.get(key) ?? 0,
+        watch(key, listener) {
+            const own = listeners.get(key) ?? new Set();
+            listeners.set(key, own);
+            own.add(listener);
+            return () => void own.delete(listener);
+        },
+    };
+}

package/dist/index.d.ts

@@ -9,7 +9,9 @@
  *   client/   the seam with a server: the transport and its REST and in-memory implementations,
  *             entities with typed commands, the service's client contract, client-side ids
  *   model/    model definitions: written by hand, read from a JSON Schema, kept once known
- *   services/ Feature and ApplicationService, the runtime they run in, what each run carries
+ *   services/ the bounded context (`UseBoundedContext`), its `Feature` and `ApplicationService`,
+ *             the process they run in (`configureProcess`), what each run carries
+ *   context/  the context: one door (`Context`) over the store each platform plugs
  *   observability/  the ports a platform plugs: a tracer and an error reporter
  *
  * The generator is `@sincpro/client-framework/codegen`, and the in-memory tracer and reporter
@@ -22,10 +24,13 @@ export { type MemoryOptions, type MemoryTable, memoryTransport, } from "./client
 export { type RestOptions, restTransport, urlOf, type VersionDrift, } from "./client/rest.js";
 export { type RetryKeys, retryKeys, unanswered, } from "./client/retry.js";
 export { type CallOptions, type Draft, type Method, type One, readRoute, type SendOptions, type Transport, TransportError, } from "./client/transport.js";
+export { type Context } from "./context/context.js";
+export { type ContextStore, type ContextValues, memoryContexts, } from "./context/store.js";
 export { defineMeta, field, type FieldOptions, type MetaSpec, type Words, } from "./model/meta.js";
 export { type MetaStore, metaStore } from "./model/metas.js";
 export { completeMeta, type JsonSchema, metaFromSchema, type SchemaComponents, } from "./model/schema.js";
 export { type Attributes, type ErrorAbout, type ErrorReporter, NO_TRACER, type Outcome, type Span, type Tracer, } from "./observability/ports.js";
+export { type BoundedContext, UseBoundedContext, } from "./services/bounded-context.js";
 export { BIND, type Bindable, bindable, bindDependency, bindTransport, type Execution, headersOf, } from "./services/execution.js";
-export { ApplicationService, bindServices, Feature, } from "./services/feature.js";
-export { createRuntime, DETACHED, outcomeOf, type Runtime, type RuntimeOptions, } from "./services/runtime.js";
+export { ApplicationService, Feature, type ServiceClasses, type ServiceMethods, type Services, } from "./services/feature.js";
+export { configureProcess, outcomeOf, processContext, type ProcessOptions, } from "./services/process.js";

package/dist/index.js

@@ -9,7 +9,9 @@
  *   client/   the seam with a server: the transport and its REST and in-memory implementations,
  *             entities with typed commands, the service's client contract, client-side ids
  *   model/    model definitions: written by hand, read from a JSON Schema, kept once known
- *   services/ Feature and ApplicationService, the runtime they run in, what each run carries
+ *   services/ the bounded context (`UseBoundedContext`), its `Feature` and `ApplicationService`,
+ *             the process they run in (`configureProcess`), what each run carries
+ *   context/  the context: one door (`Context`) over the store each platform plugs
  *   observability/  the ports a platform plugs: a tracer and an error reporter
  *
  * The generator is `@sincpro/client-framework/codegen`, and the in-memory tracer and reporter
@@ -22,10 +24,13 @@ export { memoryTransport, } from "./client/memory.js";
 export { restTransport, urlOf, } from "./client/rest.js";
 export { retryKeys, unanswered, } from "./client/retry.js";
 export { readRoute, TransportError, } from "./client/transport.js";
+export {} from "./context/context.js";
+export { memoryContexts, } from "./context/store.js";
 export { defineMeta, field, } from "./model/meta.js";
 export { metaStore } from "./model/metas.js";
 export { completeMeta, metaFromSchema, } from "./model/schema.js";
 export { NO_TRACER, } from "./observability/ports.js";
+export { UseBoundedContext, } from "./services/bounded-context.js";
 export { BIND, bindable, bindDependency, bindTransport, headersOf, } from "./services/execution.js";
-export { ApplicationService, bindServices, Feature, } from "./services/feature.js";
-export { createRuntime, DETACHED, outcomeOf, } from "./services/runtime.js";
+export { ApplicationService, Feature, } from "./services/feature.js";
+export { configureProcess, outcomeOf, processContext, } from "./services/process.js";

package/dist/observability/ports.d.ts

@@ -47,13 +47,13 @@ export interface Tracer {
 }
 /** What a report says about where the error happened. */
 export type ErrorAbout = {
-    /** `<domain>/<Feature>`, the span's name. */
+    /** `<bounded context>.<Service>[.<method>]`: the use case's identity, as the backend's. */
     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 (`Runtime` `context`). */
+    /** 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. */

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

@@ -0,0 +1,79 @@
+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>;
+}