@sincpro/client-framework 0.4.0 → 0.5.0

package/dist/codegen/names.js

@@ -52,6 +52,64 @@ export function localOf(metamodel, identity) {
     const prefix = `${contextOf(metamodel)}.`;
     return identifierOf(identity.startsWith(prefix) ? identity.slice(prefix.length) : identity);
 }
+const ANSWERS = new WeakMap();
+/** The output's own name, when it has one a TypeScript type can take. */
+function titleOf(output) {
+    if (output === null || output.$ref !== undefined)
+        return undefined;
+    const title = output.title;
+    return typeof title === "string" && /^[A-Za-z_$][\w$]*$/.test(title) ? title : undefined;
+}
+function answersOf(metamodel) {
+    const operations = Object.entries(metamodel.operations);
+    const taken = new Set([
+        ...Object.keys(metamodel.models).map(identifierOf),
+        ...Object.keys(metamodel.$defs ?? {}).map(identifierOf),
+    ]);
+    for (const [identity] of operations) {
+        const local = localOf(metamodel, identity);
+        taken.add(local);
+        taken.add(`${local}Answer`);
+    }
+    // A title is one type when every output that carries it is the same schema — the backend
+    // answering two Commands with one Response class; two different schemas under one title are
+    // two types, and neither takes the name.
+    const shapes = new Map();
+    for (const [, operation] of operations) {
+        const title = titleOf(operation.output);
+        if (title === undefined)
+            continue;
+        const seen = shapes.get(title) ?? new Set();
+        seen.add(JSON.stringify(operation.output));
+        shapes.set(title, seen);
+    }
+    const names = new Map();
+    for (const [identity, operation] of operations) {
+        const title = titleOf(operation.output);
+        if (title !== undefined && shapes.get(title)?.size === 1 && !taken.has(title))
+            names.set(identity, title);
+    }
+    return names;
+}
+/**
+ * What an operation's answer is called: the backend's own name for it — its output's title,
+ * `ResponseCancelIssue` — when that name is one type (every output with it is the same schema)
+ * and no other type has it; `<Name>Answer` when the output has no name of its own (a model, a
+ * list) or two different shapes share it. A new operation answering with the same Response keeps
+ * the name: regenerating never renames by itself.
+ *
+ * Context: the ubiquitous language. The backend writes `CommandCancelIssue` → `ResponseCancelIssue`,
+ * and a client that calls it `CommandCancelIssueAnswer` makes a person learn two words for one
+ * thing. The `<Name>Answer` it used to write stays as a deprecated alias of the backend's name.
+ */
+export function answerOf(metamodel, identity) {
+    let known = ANSWERS.get(metamodel);
+    if (known === undefined) {
+        known = answersOf(metamodel);
+        ANSWERS.set(metamodel, known);
+    }
+    return known.get(identity) ?? `${localOf(metamodel, identity)}Answer`;
+}
 /** The method an operation is called by: `CommandSendIssue` → `sendIssue`. */
 export function methodOf(local) {
     const bare = local.replace(/^(Command|Query)(?=[A-Z])/, "");

package/dist/codegen/scaffold.d.ts

@@ -0,0 +1,24 @@
+import type { Metamodel } from "./metamodel.js";
+/**
+ * A bounded context's skeleton, written ONCE beside what is generated — the files that are the
+ * application's from then on:
+ *
+ *     domains/project/
+ *       generated/                         `sincpro-client generate` — regenerated, never edited
+ *       infrastructure/dependencies.ts     what the services can count on: the generated client
+ *       infrastructure/bounded_context.ts  its Feature and ApplicationService, and how it is made
+ *       services/index.ts                  the services, by the name each is reached by
+ *       index.ts                           `export const project` — ready to use
+ *
+ * Context: the layout sincpro_framework gives a service (`dependencies.py`, `framework.py`,
+ * `services/`, `__init__.py`), so a bounded context starts the way every other does and nobody
+ * copies it by hand from another. It is the application's to change: the CLI writes a file only
+ * when it is not there, and never touches one that is — unlike `generated/`, which is written
+ * whole every time.
+ */
+export type ScaffoldOptions = {
+    /** Where the application's transport is exported (`export const transport`), from the
+     *  bounded context's folder. `../common/infrastructure/transport` by default. */
+    transport?: string;
+};
+export declare function scaffoldFilesOf(metamodel: Metamodel, options?: ScaffoldOptions): Record<string, string>;

package/dist/codegen/scaffold.js

@@ -0,0 +1,123 @@
+import { aliasOf, FRAMEWORK } from "./names.js";
+/** Names the skeleton's `index.ts` cannot give its constant. */
+const TAKEN = new Set([
+    "transport",
+    "features",
+    "applicationServices",
+    ..."break case catch class const continue debugger default delete do else enum export extends false finally for function if import in instanceof new null return super switch this throw true try typeof var void while with yield let static implements interface package private protected public await".split(" "),
+]);
+/** `sales-orders` → `SalesOrders`. */
+function pascalOf(alias) {
+    const joined = alias
+        .split(/[^A-Za-z0-9]+/)
+        .filter((one) => one !== "")
+        .map((one) => `${one.charAt(0).toUpperCase()}${one.slice(1)}`)
+        .join("");
+    return joined === "" ? "Context" : /^[0-9]/.test(joined) ? `_${joined}` : joined;
+}
+/** A module the skeleton imports, built in parts — see `FRAMEWORK` (`codegen/names.ts`). */
+const at = (...parts) => parts.join("/");
+const HEADER = (what) => `// ${what} — written once by \`sincpro-client scaffold\`; the application's to change.`;
+export function scaffoldFilesOf(metamodel, options = {}) {
+    const alias = aliasOf(metamodel);
+    const Name = pascalOf(alias);
+    const bare = `${Name.charAt(0).toLowerCase()}${Name.slice(1)}`;
+    // A word the language keeps (`import`, `default`) or a name `index.ts` already imports cannot
+    // be the constant's: it takes the bounded context's word instead.
+    const name = TAKEN.has(bare) ? `${bare}BoundedContext` : bare;
+    const Dependencies = `${Name}Dependencies`;
+    const client = metamodel.bindings !== undefined;
+    const transport = options.transport ?? at("..", "common", "infrastructure", "transport");
+    const dependencies = [
+        HEADER(`What the services of «${alias}» can count on`),
+        "",
+        `import type { Transport, UseBoundedContext } from "${FRAMEWORK}";`,
+        ...(client ? ["", `import { clientOf } from "${at("..", "generated", "client")}";`] : []),
+        "",
+        `/** What every service of «${alias}» finds on \`this\`${client ? ": `this.client`, the service's operations" : ""}. */`,
+        `export interface ${Dependencies} {`,
+        ...(client
+            ? ["  client: ReturnType<typeof clientOf>;"]
+            : [
+                "  /** What the services need: a repository, an adapter, another bounded context. */",
+            ]),
+        "}",
+        "",
+        "export function registerDependencies(",
+        `  bc: UseBoundedContext<${Dependencies}>,`,
+        `  ${client ? "transport" : "_transport"}: Transport,`,
+        ") {",
+        ...(client ? [`  bc.addDependency("client", clientOf(transport));`] : []),
+        "  return bc;",
+        "}",
+        "",
+    ].join("\n");
+    const boundedContext = [
+        HEADER(`How «${alias}» is made`),
+        "",
+        "import {",
+        "  ApplicationService as BaseApplicationService,",
+        "  Feature as BaseFeature,",
+        "  type Transport,",
+        "  UseBoundedContext,",
+        `} from "${FRAMEWORK}";`,
+        "",
+        `import type { ${Name}Features } from "${at("..", "services")}";`,
+        `import { type ${Dependencies}, registerDependencies } from "${at(".", "dependencies")}";`,
+        "",
+        `/** A Feature of «${alias}»: its dependencies typed on \`this\`, and \`this.context\`. */`,
+        `export class Feature extends BaseFeature<${Dependencies}> {}`,
+        "",
+        `/** An ApplicationService of «${alias}»: the same, and \`this.feature.<Name>\` for each Feature. */`,
+        "export class ApplicationService extends BaseApplicationService<",
+        `  ${Dependencies},`,
+        `  ${Name}Features`,
+        "> {}",
+        "",
+        `export function config${Name}BoundedContext(name: string, transport: Transport) {`,
+        `  return registerDependencies(new UseBoundedContext<${Dependencies}>(name), transport);`,
+        "}",
+        "",
+    ].join("\n");
+    const services = [
+        HEADER(`What «${alias}» offers`),
+        "",
+        "/**",
+        ` * Each service by the name it is reached by — \`${name}.Issues.close(…)\`. A Feature groups the`,
+        " * operations of one part of the domain; an ApplicationService composes the Features:",
+        " *",
+        " *     // services/issues.ts",
+        ` *     export class Issues extends Feature {`,
+        " *       close(input: dto.CommandCloseIssue) {",
+        " *         return this.client.closeIssue(input);",
+        " *       }",
+        " *     }",
+        " */",
+        "export const features = {};",
+        "export const applicationServices = {};",
+        "",
+        `export type ${Name}Features = typeof features;`,
+        "",
+    ].join("\n");
+    const index = [
+        HEADER(`«${alias}», ready to use`),
+        "",
+        `import { transport } from "${transport}";`,
+        "",
+        `import { config${Name}BoundedContext } from "${at(".", "infrastructure", "bounded_context")}";`,
+        `import { applicationServices, features } from "${at(".", "services")}";`,
+        "",
+        `/** «${alias}»: \`${name}.<Service>.<method>(…)\` — from a screen, a test, another bounded context. */`,
+        `export const ${name} = config${Name}BoundedContext(${JSON.stringify(alias)}, transport).register({`,
+        "  features,",
+        "  applicationServices,",
+        "});",
+        "",
+    ].join("\n");
+    return {
+        "infrastructure/dependencies.ts": dependencies,
+        "infrastructure/bounded_context.ts": boundedContext,
+        "services/index.ts": services,
+        "index.ts": index,
+    };
+}

package/dist/common/decimal.js

@@ -19,6 +19,12 @@ const TEN = 10n;
 function pow10(exponent) {
     return TEN ** BigInt(exponent);
 }
+/** How many digits after the point a result keeps: a whole number from 0 up. */
+function decimalsGiven(decimals) {
+    if (!Number.isInteger(decimals) || decimals < 0)
+        throw new RangeError(`${decimals} decimals: a decimal keeps 0 or more whole digits after the point`);
+    return decimals;
+}
 /** `units / divisor` rounded half up, away from zero. */
 function halfUp(units, divisor) {
     const quotient = units / divisor;
@@ -97,6 +103,7 @@ export class Decimal {
     }
     /** This over `divisor`, with `decimals` digits after the point, rounded half up. */
     dividedBy(divisor, decimals) {
+        decimalsGiven(decimals);
         const by = Decimal.of(divisor);
         if (by.units === 0n)
             throw new RangeError("a decimal divided by zero");
@@ -106,6 +113,7 @@ export class Decimal {
     }
     /** With `decimals` digits after the point: rounded half up when it had more, padded when fewer. */
     rounded(decimals) {
+        decimalsGiven(decimals);
         if (decimals >= this.scale)
             return Decimal.at(this.units * pow10(decimals - this.scale), decimals);
         return Decimal.at(halfUp(this.units, pow10(this.scale - decimals)), decimals);

package/dist/common/serialization.d.ts

@@ -39,7 +39,11 @@ export type Rebuild<T> = {
  * `null` in a list, as JSON does.
  */
 export declare function valuesOf(value: unknown): JsonValue;
-/** What `valuesOf` wrote, from JSON text or already parsed — each tagged bytes back as bytes. */
+/**
+ * What `valuesOf` wrote, from JSON text or already parsed — each tagged bytes back as bytes. A
+ * string is JSON text: to read values that were written but never sent, go through `pack`
+ * (`readValues(pack(value))`), as the in-memory transport does.
+ */
 export declare function readValues(text: string | unknown): unknown;
 /** `values` read as `of` — `Money`, a DTO's own reader — or as they are without one. */
 export declare function rebuilt<T = unknown>(values: unknown, of?: Rebuild<T>): T;

package/dist/common/serialization.js

@@ -54,8 +54,9 @@ function bytesOf(text) {
     return bytes;
 }
 function isBytes(value) {
-    return (value instanceof Uint8Array || value instanceof ArrayBuffer || value instanceof DataView);
+    return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
 }
+/** Any binary — a `Uint8Array`, another typed array, a `DataView`, a buffer — as its bytes. */
 function asBytes(value) {
     if (value instanceof Uint8Array)
         return value;
@@ -85,8 +86,13 @@ function written(value, where, seen) {
     seen.add(object);
     try {
         const own = object.toJSON;
-        if (typeof own === "function")
-            return written(own.call(object), where, seen);
+        if (typeof own === "function") {
+            const said = own.call(object);
+            // A `toJSON` that answers the object itself says nothing new: it is written as an object.
+            // Still in `seen` while what it said is written: `{ self: this }` is a cycle, not a loop.
+            if (said !== object)
+                return written(said, where, seen);
+        }
         if (object instanceof Map)
             return Object.fromEntries([...object].flatMap(([key, one]) => {
                 const done = written(one, `${where}.${String(key)}`, seen);
@@ -96,6 +102,9 @@ function written(value, where, seen) {
             return [...object].map((one, at) => written(one, `${where}[${at}]`, seen) ?? null);
         const entries = [];
         for (const [key, one] of Object.entries(object)) {
+            // Its own way to travel is not a value of it.
+            if (key === "toJSON" && typeof one === "function")
+                continue;
             const done = written(one, `${where}.${key}`, seen);
             if (done !== undefined)
                 entries.push([key, done]);
@@ -127,7 +136,11 @@ function walked(value) {
         return restored(Object.fromEntries(Object.entries(value).map(([key, one]) => [key, walked(one)])));
     return value;
 }
-/** What `valuesOf` wrote, from JSON text or already parsed — each tagged bytes back as bytes. */
+/**
+ * What `valuesOf` wrote, from JSON text or already parsed — each tagged bytes back as bytes. A
+ * string is JSON text: to read values that were written but never sent, go through `pack`
+ * (`readValues(pack(value))`), as the in-memory transport does.
+ */
 export function readValues(text) {
     if (typeof text === "string")
         return JSON.parse(text, (_key, value) => value !== null && typeof value === "object" && !Array.isArray(value)

package/dist/common/time.d.ts

@@ -33,7 +33,8 @@ export declare function wallTimeOf(instant: string, timeZone: string): string |
  * first guess, and again at the answer when the guess fell on the other side of a change.
  */
 export declare function instantOf(wall: string, timeZone: string): string | null;
-/** A day of the calendar as the server writes it: `"2026-03-12"` — never an instant. */
+/** A day of the calendar as the server writes it: `"2026-03-12"` — never an instant, never a day
+ *  the calendar does not have (`"2026-02-30"`, which `Date` would roll into March). */
 export declare function isDay(text: string): boolean;
 /** The day it is at `instant` on the wall clock of `timeZone`: what «today» means for a company.
  *  `null` when it is not an instant. */

package/dist/common/time.js

@@ -57,6 +57,9 @@ const pad = (n) => String(n).padStart(2, "0");
 /** `"2026-03-12T14:30:00Z"` → `"2026-03-12T10:30"` in `America/La_Paz`: the wall clock there,
  *  as a date-and-time control reads it. `null` when it is not an instant. */
 export function wallTimeOf(instant, timeZone) {
+    // A day alone is not an instant: `Date` would read it as midnight in UTC, the day before here.
+    if (!/T\d{2}:\d{2}/.test(instant))
+        return null;
     const at = Date.parse(instant);
     if (Number.isNaN(at))
         return null;
@@ -82,9 +85,13 @@ export function instantOf(wall, timeZone) {
     return new Date(second).toISOString();
 }
 const DAY = /^\d{4}-\d{2}-\d{2}$/;
-/** A day of the calendar as the server writes it: `"2026-03-12"` — never an instant. */
+/** A day of the calendar as the server writes it: `"2026-03-12"` — never an instant, never a day
+ *  the calendar does not have (`"2026-02-30"`, which `Date` would roll into March). */
 export function isDay(text) {
-    return DAY.test(text) && !Number.isNaN(Date.parse(`${text}T00:00:00Z`));
+    if (!DAY.test(text))
+        return false;
+    const at = Date.parse(`${text}T00:00:00Z`);
+    return !Number.isNaN(at) && new Date(at).toISOString().slice(0, 10) === text;
 }
 /** The day it is at `instant` on the wall clock of `timeZone`: what «today» means for a company.
  *  `null` when it is not an instant. */

package/dist/context/codec.d.ts

@@ -13,6 +13,8 @@ import type { ContextValues } from "./store.js";
  * context stays where it is. Reading never fails a context whole: text that is not a JSON object
  * reads as an empty one. A project with a schema of its own writes its own codec over this port.
  */
+/** The header the context travels in: the one sincpro_framework's entrances read. */
+export declare const CONTEXT_HEADER = "sincpro-context";
 export interface ContextCodec {
     dumps(values: ContextValues): string;
     loads(text: string): ContextValues;

package/dist/context/codec.js

@@ -1,3 +1,19 @@
+/**
+ * How a context is written to text and read back: what a `ContextStore` that persists uses
+ * (`sessionStorage`, MMKV), and what travels to the server in `sincpro-context`.
+ *
+ *     plainCodec.dumps({ tenant_id: "acme", company_id: 2, session: socket })
+ *       →  '{"tenant_id":"acme","company_id":2}'
+ *     plainCodec.loads('{"tenant_id":"acme"}')   →  { tenant_id: "acme" }
+ *
+ * Context: sincpro_framework's `ContextCodec`, and its `PlainCodec` — the one for anything outside
+ * the codebase: another language, a browser, a phone. Only the travelling values go — text,
+ * numbers, booleans, `null`, and lists of them; an object, a function or a connection held in the
+ * context stays where it is. Reading never fails a context whole: text that is not a JSON object
+ * reads as an empty one. A project with a schema of its own writes its own codec over this port.
+ */
+/** The header the context travels in: the one sincpro_framework's entrances read. */
+export const CONTEXT_HEADER = "sincpro-context";
 function isPlain(value) {
     return (value === null ||
         typeof value === "string" ||

package/dist/index.d.ts

@@ -30,7 +30,7 @@ export { isEntityId, momentOf, newEntityId } from "./common/ids.js";
 export { Money } from "./common/money.js";
 export { BYTES, type JsonValue, pack, readValues, type Rebuild, rebuilt, unpack, valuesOf, } from "./common/serialization.js";
 export { dayOf, installTimeZone, instantOf, isDay, timeZoneNow, wallTimeOf, } from "./common/time.js";
-export { type ContextCodec, plainCodec, travelling, travels, } from "./context/codec.js";
+export { CONTEXT_HEADER, type ContextCodec, plainCodec, travelling, travels, } from "./context/codec.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";
@@ -41,3 +41,5 @@ export { type BoundedContext, UseBoundedContext, } from "./services/bounded-cont
 export { BIND, type Bindable, bindable, bindDependency, bindTransport, type Execution, headersOf, } from "./services/execution.js";
 export { ApplicationService, Feature, type ServiceClasses, type ServiceMethods, type Services, } from "./services/feature.js";
 export { configureProcess, outcomeOf, processContext, type ProcessOptions, } from "./services/process.js";
+export { reportError } from "./services/report.js";
+export { screensTransport } from "./services/screens.js";

package/dist/index.js

@@ -30,7 +30,7 @@ export { isEntityId, momentOf, newEntityId } from "./common/ids.js";
 export { Money } from "./common/money.js";
 export { BYTES, pack, readValues, rebuilt, unpack, valuesOf, } from "./common/serialization.js";
 export { dayOf, installTimeZone, instantOf, isDay, timeZoneNow, wallTimeOf, } from "./common/time.js";
-export { plainCodec, travelling, travels, } from "./context/codec.js";
+export { CONTEXT_HEADER, plainCodec, travelling, travels, } from "./context/codec.js";
 export {} from "./context/context.js";
 export { memoryContexts, } from "./context/store.js";
 export { defineMeta, field, } from "./model/meta.js";
@@ -41,3 +41,5 @@ export { UseBoundedContext, } from "./services/bounded-context.js";
 export { BIND, bindable, bindDependency, bindTransport, headersOf, } from "./services/execution.js";
 export { ApplicationService, Feature, } from "./services/feature.js";
 export { configureProcess, outcomeOf, processContext, } from "./services/process.js";
+export { reportError } from "./services/report.js";
+export { screensTransport } from "./services/screens.js";

package/dist/observability/ports.d.ts

@@ -47,7 +47,8 @@ export interface Tracer {
 }
 /** 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. */
+    /** `<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;

package/dist/services/bounded-context.js

@@ -3,10 +3,11 @@ 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"]);
+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. */
@@ -142,6 +143,8 @@ function viewOf(target, binding, execution) {
         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") {
@@ -191,20 +194,6 @@ function contextOf(binding) {
         ...binding.scope,
     };
 }
-/**
- * Whether this is the first run to report this error. A Feature that fails inside an
- * ApplicationService throws through it: the error is reported once, by the run where it
- * happened — its span is the one that says where — and every run around it still ends `failed`.
- */
-const REPORTED = new WeakSet();
-function firstReport(error) {
-    if (error === null || (typeof error !== "object" && typeof error !== "function"))
-        return true;
-    if (REPORTED.has(error))
-        return false;
-    REPORTED.add(error);
-    return true;
-}
 /** What watches a use case never changes what it answers: a tracer or reporter that throws is ignored. */
 function quietly(work, otherwise) {
     try {

package/dist/services/execution.js

@@ -1,4 +1,4 @@
-import { plainCodec, travels } from "../context/codec.js";
+import { CONTEXT_HEADER, plainCodec, travels } from "../context/codec.js";
 /**
  * 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;
@@ -34,7 +34,7 @@ export function headersOf(execution) {
     }
     // Only what travels: an object or a function held in the context stays in this process.
     if (Object.values(context).some(travels))
-        headers["sincpro-context"] = plainCodec.dumps(context);
+        headers[CONTEXT_HEADER] = plainCodec.dumps(context);
     return headers;
 }
 /**

package/dist/services/feature.d.ts

@@ -1,4 +1,5 @@
 import type { ContextValues } from "../context/store.js";
+import type { Span } from "../observability/ports.js";
 /**
  * `Feature` and `ApplicationService`: the two kinds of service a bounded context holds, as in
  * sincpro_framework. Each bounded context gives them its dependencies once, in its own base:
@@ -47,6 +48,8 @@ type Within<D extends object, C extends object> = Readonly<D> & {
      * read once where the gesture started and the same for every Feature it runs.
      */
     readonly context: Readonly<Partial<C>>;
+    /** This run's span: a use case says more about what it ran on (`this.span.set({ … })`). */
+    readonly span: Span;
 };
 /** Service classes by the name a bounded context gives them: `{ Issues, Notices }`. */
 export type ServiceClasses = Readonly<Record<string, new () => object>>;
@@ -55,7 +58,7 @@ export type ServiceClasses = Readonly<Record<string, new () => object>>;
  * methods, without its dependencies, its context or its `_` helpers.
  */
 export type ServiceMethods<I, D> = {
-    readonly [M in keyof I as M extends keyof D | "context" | "feature" | `_${string}` ? never : I[M] extends (...args: never[]) => unknown ? M : never]: I[M];
+    readonly [M in keyof I as M extends keyof D | "context" | "feature" | "span" | `_${string}` ? never : I[M] extends (...args: never[]) => unknown ? M : never]: I[M];
 };
 /** The services of a set of classes, by their names. */
 export type Services<S extends ServiceClasses, D> = {

package/dist/services/report.d.ts

@@ -0,0 +1,15 @@
+export declare function firstReport(error: unknown): boolean;
+/**
+ * Reports what nobody expected that is not a use case — a screen that broke while drawing, a
+ * subscriber, a worker — through the process's reporter, with the process's context.
+ *
+ *     <Composer onViewError={(error, { resource }) => reportError(error, `view ${formatRef(resource)}`)} />
+ *     ErrorUtils.setGlobalHandler((error) => reportError(error, "react-native global"));
+ *
+ * Context: a use case reports its own failures (the bounded context does it for it); what fails
+ * outside one would only reach a console. `where` takes the place of the use case's name in the
+ * report. Only what failed is reported (`outcomeOf`: a refusal the server explained or an abort is
+ * not); an error a use case already reported is not reported again; and a reporter that throws is
+ * ignored: telling about a failure never becomes a second one.
+ */
+export declare function reportError(error: unknown, where: string): void;

package/dist/services/report.js

@@ -0,0 +1,53 @@
+import { newEntityId } from "../common/ids.js";
+import { processContext, processNow } from "./process.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:
+ * the error is reported once, by the first that saw it — its span is the one that says where.
+ */
+const REPORTED = new WeakSet();
+export function firstReport(error) {
+    if (error === null || (typeof error !== "object" && typeof error !== "function"))
+        return true;
+    if (REPORTED.has(error))
+        return false;
+    REPORTED.add(error);
+    return true;
+}
+/**
+ * Reports what nobody expected that is not a use case — a screen that broke while drawing, a
+ * subscriber, a worker — through the process's reporter, with the process's context.
+ *
+ *     <Composer onViewError={(error, { resource }) => reportError(error, `view ${formatRef(resource)}`)} />
+ *     ErrorUtils.setGlobalHandler((error) => reportError(error, "react-native global"));
+ *
+ * Context: a use case reports its own failures (the bounded context does it for it); what fails
+ * outside one would only reach a console. `where` takes the place of the use case's name in the
+ * report. Only what failed is reported (`outcomeOf`: a refusal the server explained or an abort is
+ * not); an error a use case already reported is not reported again; and a reporter that throws is
+ * ignored: telling about a failure never becomes a second one.
+ */
+export function reportError(error, where) {
+    const settings = processNow();
+    try {
+        // What the server explained, or what the caller stopped waiting for, is not a fault here either.
+        if (settings.outcomeOf(error) !== "failed")
+            return;
+    }
+    catch {
+        // An outcome that cannot be told is a failure.
+    }
+    if (!firstReport(error))
+        return;
+    try {
+        settings.reporter?.report(error, {
+            useCase: where,
+            traceId: "",
+            executionId: newEntityId(),
+            context: processContext.values,
+        });
+    }
+    catch {
+        // Ignored, as a reporter that fails inside a use case is.
+    }
+}

package/dist/services/screens.d.ts

@@ -0,0 +1,2 @@
+import type { Transport } from "../client/transport.js";
+export declare function screensTransport(transport: Transport, name?: string): Transport;

package/dist/services/screens.js

@@ -0,0 +1,67 @@
+import { UseBoundedContext } from "./bounded-context.js";
+import { Feature } from "./feature.js";
+/**
+ * What a screen reads of an entity — a page, a record, a read of its own: sincpro_framework's
+ * built-in `EntityReads`, on the client.
+ */
+class EntityReads extends Feature {
+    list(route, criteria, signal, options) {
+        this.span.set({ "http.route": route });
+        return this.transport.list(route, criteria, signal, options);
+    }
+    one(route, signal, options) {
+        this.span.set({ "http.route": route });
+        return this.transport.one(route, signal, options);
+    }
+    read(route, signal, options) {
+        this.span.set({ "http.route": route });
+        const read = this.transport.read;
+        if (read === undefined)
+            return Promise.reject(new Error(`this transport cannot read ${route}: it has no read()`));
+        return read.call(this.transport, route, signal, options);
+    }
+}
+/** What a screen writes — a save, a draft, a preview, a Command: each request a use case. */
+class EntityWrites extends Feature {
+    send(method, route, body, signal, options) {
+        this.span.set({ "http.method": method, "http.route": route });
+        return this.transport.send(method, route, body, signal, options);
+    }
+}
+/**
+ * The transport, every call a use case of a bounded context of its own — `screens` unless named:
+ * what a platform hands the screens it draws.
+ *
+ *     const screens = screensTransport(restTransport({ base: "/v1" }));
+ *     await screens.list("/facturas", criteria);   // span screens/EntityReads.list
+ *
+ * Context: a use case is traced, carries its context and reports what nobody expected; a list a
+ * screen reads through the transport was none of that — no span, no `traceparent` (the backend's
+ * trace started there, with no client in it), no company, and a 500 reported to nobody. Here
+ * each read and write runs as a use case of `screens` — `EntityReads.list`, `.one`, `.read`,
+ * `EntityWrites.send` —, so it gets all three the way any other does: the span (its route said
+ * on it), the trace and the process's context on the request, and a report only when it failed
+ * (a 4xx the server explained is the screen's to show). A bounded context's own dependencies are
+ * never given this: there its use case is the one that runs.
+ */
+/** The transports this made: given one again, it is answered as it is — wrapped twice, each
+ *  request would be two unrelated use cases, and the server would see only the outer's trace. */
+const MADE = new WeakSet();
+export function screensTransport(transport, name = "screens") {
+    if (MADE.has(transport))
+        return transport;
+    const screens = new UseBoundedContext(name)
+        .addDependency("transport", transport)
+        .register({ features: { EntityReads, EntityWrites } });
+    const reads = screens.EntityReads;
+    const writes = screens.EntityWrites;
+    const through = {
+        list: (route, criteria, signal, options) => reads.list(route, criteria, signal, options),
+        one: (route, signal, options) => reads.one(route, signal, options),
+        send: (method, route, body, signal, options) => writes.send(method, route, body, signal, options),
+    };
+    if (transport.read !== undefined)
+        through.read = (route, signal, options) => reads.read(route, signal, options);
+    MADE.add(through);
+    return through;
+}