@sincpro/client-framework 1.0.0 → 1.2.0

package/dist/client/services/propagation.js

@@ -35,42 +35,71 @@ export function headersOf(execution) {
  *
  * Context: the transport's own headers (`restTransport({ headers })`) are the session's — the
  * token, the tenant — the same for every call; these are the use case's, different for two use
- * cases running at once, so they travel per call (`CallOptions`).
+ * cases running at once, so they travel per call (`CallOptions`). A call that gives no signal of
+ * its own is cancelled with the run.
  */
 export function bindTransport(transport, execution) {
     const own = headersOf(execution);
-    if (Object.keys(own).length === 0)
+    const cancels = execution.signal;
+    if (Object.keys(own).length === 0 && cancels === undefined)
         return transport;
     const call = (options) => ({ ...options, headers: { ...own, ...options?.headers } });
     const bound = {
-        list: (route, criteria, signal, options) => transport.list(route, criteria, signal, call(options)),
-        one: (route, signal, options) => transport.one(route, signal, call(options)),
-        send: (method, route, body, signal, options) => transport.send(method, route, body, signal, call(options)),
+        list: (route, criteria, signal, options) => transport.list(route, criteria, signal ?? cancels, call(options)),
+        one: (route, signal, options) => transport.one(route, signal ?? cancels, call(options)),
+        send: (method, route, body, signal, options) => transport.send(method, route, body, signal ?? cancels, call(options)),
     };
     const read = transport.read;
     if (read !== undefined)
-        bound.read = (route, signal, options) => read.call(transport, route, signal, call(options));
+        bound.read = (route, signal, options) => read.call(transport, route, signal ?? cancels, call(options));
     const download = transport.download;
     if (download !== undefined)
-        bound.download = (route, signal, options) => download.call(transport, route, signal, call(options));
+        bound.download = (route, signal, options) => download.call(transport, route, signal ?? cancels, call(options));
     return bound;
 }
+/**
+ * The operation transport, calling as `execution`: every call carries the run's trace and
+ * context as headers and is cancelled with the run — the caller's own headers and signal still
+ * win.
+ */
+export function bindOperations(transport, execution) {
+    const own = headersOf(execution);
+    const cancels = execution.signal;
+    if (Object.keys(own).length === 0 && cancels === undefined)
+        return transport;
+    return {
+        call: (operation, input, options) => transport.call(operation, input, {
+            ...options,
+            headers: { ...own, ...options?.headers },
+            ...((options?.signal ?? cancels) ? { signal: options?.signal ?? cancels } : {}),
+        }),
+    };
+}
+/** A transport of either kind, bound to `execution`. */
+export function bound(wire, execution) {
+    return (isTransport(wire)
+        ? bindTransport(wire, execution)
+        : bindOperations(wire, execution));
+}
 /**
  * A client made over a transport, made again over the transport bound to each execution it is
- * used in. What a generated `clientOf(transport)` answers, so a Feature that calls
- * `this.client.sendIssue(…)` sends that request with its own trace.
+ * used in. What a generated `clientOf(operations)` answers, so a Feature that calls
+ * `this.client.sendIssue(…)` sends that request with its own trace, context and signal.
  *
- *     export function clientOf(transport: Transport) {
- *       return bindable(transport, (transport) => ({ sendIssue: (body) => transport.send(…) }));
+ *     export function clientOf(operations: OperationTransport) {
+ *       return bindable(operations, (operations) => ({
+ *         sendIssue: (input) => operations.call(operations_.CommandSendIssue, input),
+ *       }));
  *     }
  *
  * Context: it takes the function that makes the client, not the client — rebuilding through
- * `clientOf` itself would make TypeScript infer `clientOf` from its own return.
+ * `clientOf` itself would make TypeScript infer `clientOf` from its own return. A REST
+ * `Transport` binds the same way, for a client written over it by hand.
  */
-export function bindable(transport, make) {
-    const client = make(transport);
+export function bindable(wire, make) {
+    const client = make(wire);
     Object.defineProperty(client, BIND, {
-        value: (execution) => bindable(bindTransport(transport, execution), make),
+        value: (execution) => bindable(bound(wire, execution), make),
         enumerable: false,
     });
     return client;

package/dist/codegen/entrypoint/cli.js

@@ -14,7 +14,7 @@ import { scaffoldFilesOf } from "../services/scaffold.js";
  *
  * - `domain.ts`: the DTOs, only types — and the domain events with `DomainEvent`, their union,
  *   when the contract was exported with them (`export-client-contract --events`);
- * - `client.ts`: every operation (and event) as data, and `clientOf(transport)`;
+ * - `client.ts`: every operation (and event) as data, and `clientOf(operations)` over any wire;
  * - `entities.ts`: an `entity<T, C>()` per model a screen can list;
  * - `contract.json`: the snapshot they were written from, for `metasOf`.
  *
@@ -26,7 +26,7 @@ import { scaffoldFilesOf } from "../services/scaffold.js";
  */
 const USAGE = [
     "usage: sincpro-client generate <contract.json> --out <dir> [--domain <name>] [--base <path>]",
-    "       sincpro-client scaffold <contract.json> --out <dir> [--transport <module>]",
+    "       sincpro-client scaffold <contract.json> --out <dir> [--operations <module>]",
     "       sincpro-client check [--root src] [--tsconfig tsconfig.json]",
 ].join("\n");
 /** JSON with every key sorted: the snapshot reads the same however the server ordered it. */
@@ -53,7 +53,7 @@ function parsed(args) {
         flags.set(flag, value);
     }
     const out = flags.get("--out");
-    const known = new Set(command === "generate" ? ["--out", "--domain", "--base"] : ["--out", "--transport"]);
+    const known = new Set(command === "generate" ? ["--out", "--domain", "--base"] : ["--out", "--operations"]);
     if (out === undefined || [...flags.keys()].some((one) => !known.has(one)))
         return undefined;
     const domain = flags.get("--domain");
@@ -66,12 +66,12 @@ function parsed(args) {
             ...(domain === undefined ? {} : { domain }),
             ...(base === undefined ? {} : { base }),
         },
-        transport: flags.get("--transport"),
+        operations: flags.get("--operations"),
     };
 }
 /** The skeleton, each file only when it is not there: what is there is the application's. */
-function scaffold(metamodel, out, transport) {
-    const files = scaffoldFilesOf(metamodel, transport === undefined ? {} : { transport });
+function scaffold(metamodel, out, operations) {
+    const files = scaffoldFilesOf(metamodel, operations === undefined ? {} : { operations });
     const written = [];
     const kept = [];
     for (const [name, source] of Object.entries(files)) {
@@ -128,7 +128,7 @@ function main(args) {
     }
     const metamodel = JSON.parse(readFileSync(asked.source, "utf8"));
     if (asked.command === "scaffold")
-        return scaffold(metamodel, asked.out, asked.transport);
+        return scaffold(metamodel, asked.out, asked.operations);
     const files = { "domain.ts": domainFileOf(metamodel) };
     if (metamodel.bindings !== undefined) {
         files["client.ts"] = clientFileOf(metamodel, asked.options);

package/dist/codegen/services/client.d.ts

@@ -3,14 +3,13 @@ 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`).
- * 4. When the contract carries them, every domain event as data, by its type's name: its wire
+ * 1. Every operation, by its local name, as data: identity, role, `query`, entities, targets,
+ *    whether it answers bytes, and the binding of each wire that publishes it.
+ * 2. A method per operation, named by `methodOf`: its input — optional when nothing in it is
+ *    required — and the call's options (headers, signal, idempotency key), answering its answer.
+ * 3. When the contract carries them, every domain event as data, by its type's name: its wire
  *    name, and whether the bounded context records it or handles it.
- * Final: `clientOf(transport)`, a method per operation reached, named by `methodOf`; two with
- *    one name are refused, naming both.
+ * Final: `clientOf(transport)` over an `OperationTransport`, bound to each run that uses it; two
+ *    methods with one name are refused, naming both.
  */
 export declare function clientFileOf(metamodel: Metamodel, options?: GenerateOptions): string;

package/dist/codegen/services/client.js

@@ -1,59 +1,31 @@
 import { aliasOf, answerOf, claimed, deprecationOf, docOf, DOMAIN_MODULE, FRAMEWORK, headerOf, identifierOf, localOf, methodOf, recordLiteral, sorted, } from "../domain/names.js";
-import { ownerOf, restOf, WRITES, } from "./rest.js";
+import { restOf, } 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.
+ * one, called by who it is through an `OperationTransport` — so a script, a test, a Feature or a
+ * hook calls the service typed, over whatever wire the application injects.
  *
- * 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.
+ * Context: the generated client names an operation and its input, never a route, a verb or an
+ * RPC method: those are the contract's bindings, in `operations`, and the adapter reads the one of
+ * its wire (`restOperations`, `jsonRpcOperations`, a platform's gRPC). So the same client, and the
+ * Features that use it, run over REST today and JSON-RPC or gRPC tomorrow without regenerating.
+ * Each method takes the operation's input and answers its answer, as the contract types them
+ * (`domain.ts`).
  */
-/** 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 };
+const WIRES = [
+    ["rest", "REST"],
+    ["rpc", "JSON-RPC"],
+    ["grpc", "gRPC"],
+    ["mcp", "MCP"],
+];
+/** The wires that publish an operation, by name. */
+function wiresOf(metamodel, identity) {
+    return WIRES.filter(([wire]) => metamodel.bindings?.[wire]?.[identity] !== undefined).map(([, name]) => name);
 }
-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)`,
-    };
+/** Whether an operation answers bytes as they are produced — an export —, not JSON. */
+function isStreamed(operation) {
+    return (operation.output !== null &&
+        operation.output["x-sincpro-streamed"] !== undefined);
 }
 /** The data of one operation: what it is, and how each wire reaches it. */
 function dataOf(metamodel, identity, operation, rest) {
@@ -64,6 +36,8 @@ function dataOf(metamodel, identity, operation, rest) {
         `    entities: ${JSON.stringify(operation.entities)},`,
         `    targets: ${recordLiteral(operation.targets)},`,
     ];
+    if (isStreamed(operation))
+        lines.push("    streamed: true,");
     if (rest !== undefined)
         lines.push(`    rest: { method: ${JSON.stringify(rest.method)}, path: ${JSON.stringify(rest.path)} },`);
     const rpc = metamodel.bindings?.rpc?.[identity];
@@ -77,121 +51,50 @@ function dataOf(metamodel, identity, operation, rest) {
         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`).
- * 4. When the contract carries them, every domain event as data, by its type's name: its wire
+ * 1. Every operation, by its local name, as data: identity, role, `query`, entities, targets,
+ *    whether it answers bytes, and the binding of each wire that publishes it.
+ * 2. A method per operation, named by `methodOf`: its input — optional when nothing in it is
+ *    required — and the call's options (headers, signal, idempotency key), answering its answer.
+ * 3. When the contract carries them, every domain event as data, by its type's name: its wire
  *    name, and whether the bounded context records it or handles it.
- * Final: `clientOf(transport)`, a method per operation reached, named by `methodOf`; two with
- *    one name are refused, naming both.
+ * Final: `clientOf(transport)` over an `OperationTransport`, bound to each run that uses it; two
+ *    methods 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) {
+    for (const [identity, operation] of sorted(metamodel.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;
-        }
+        data.push(dataOf(metamodel, identity, operation, restOf(metamodel, identity, options)));
         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 wires = wiresOf(metamodel, identity);
+        const doc = docOf([
+            operation.description,
+            deprecationOf(metamodel, operation),
+            wires.length === 0 ? undefined : `Published over ${wires.join(", ")}.`,
+        ], "    ");
+        const optional = (operation.input.required ?? []).length === 0;
+        methods.push([
+            `${doc}    ${method}: (input${optional ? "?" : ""}: dto.${local}, options?: OperationOptions) =>`,
+            `      transport.call<dto.${answerOf(metamodel, identity)}>(operations.${local}, input${optional ? " ?? {}" : ""}, options),`,
+        ].join("\n"));
     }
-    const core = [
-        "bindable",
-        ...(downloads ? ["downloadRoute", "type ExportFormat", "exportRoute"] : []),
-        ...(lists ? ["listRoute"] : []),
-        ...(sends ? ["pathFor"] : []),
-        ...(reads ? ["readRoute"] : []),
-        ...(sends ? ["type SendOptions"] : []),
-        "type Transport",
-        ...(sends ? ["writeRoute"] : []),
-    ];
+    const events = sorted(metamodel.events ?? {}).map(([name, event]) => `  ${identifierOf(event.title)}: { name: ${JSON.stringify(name)}, recorded: ${event.recorded}, handled: ${event.handled} },`);
     const imports = [
-        ...(paged ? ['import type { Criteria } from "@sincpro/criteria";'] : []),
-        `import { ${core.join(", ")} } from "${FRAMEWORK}";`,
+        `import { bindable, type OperationOptions, type OperationTransport } from "${FRAMEWORK}";`,
         "",
         `import type * as dto from "${DOMAIN_MODULE}";`,
     ].join("\n");
-    const events = sorted(metamodel.events ?? {}).map(([name, event]) => `  ${identifierOf(event.title)}: { name: ${JSON.stringify(name)}, recorded: ${event.recorded}, handled: ${event.handled} },`);
     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}`)]),
+        ` * «${aliasOf(metamodel)}» over any wire: a method per operation, called by who it is. The transport`,
+        " * decides how it travels — `restOperations(restTransport(…))`, `jsonRpcOperations(…)`, a",
+        " * platform's —; used by a Feature, each call carries the run's trace, context and signal.",
         " */",
     ].join("\n");
     return `${[
@@ -203,7 +106,6 @@ export function clientFileOf(metamodel, options = {}) {
             : [
                 `/** Every domain event of «${aliasOf(metamodel)}» in the contract, as data: its wire name, and whether it records or handles it. */\nexport const events = {\n${events.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}`,
+        `${client}\nexport function clientOf(transport: OperationTransport) {\n  return bindable(transport, (transport) => ({\n${methods.join("\n")}\n  }));\n}`,
     ].join("\n\n")}\n`;
 }

package/dist/codegen/services/scaffold.d.ts

@@ -8,7 +8,7 @@ import type { Metamodel } from "../domain/metamodel.js";
  *       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                  registers command classes and their services
- *       index.ts                           `export const project` — ready to use
+ *       index.ts                           `export const projectBoundedContext` — 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
@@ -17,8 +17,11 @@ import type { Metamodel } from "../domain/metamodel.js";
  * 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;
+    /**
+     * Where the application exports how it reaches its services (`export const operations`, an
+     * `OperationTransport`: REST, JSON-RPC, a platform's), from the bounded context's folder.
+     * `../common/infrastructure/operations` by default.
+     */
+    operations?: string;
 };
 export declare function scaffoldFilesOf(metamodel: Metamodel, options?: ScaffoldOptions): Record<string, string>;

package/dist/codegen/services/scaffold.js

@@ -1,10 +1,4 @@
 import { aliasOf, FRAMEWORK } from "../domain/names.js";
-/** Names the skeleton's `index.ts` cannot give its constant. */
-const TAKEN = new Set([
-    "transport",
-    "registerServices",
-    ..."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
@@ -20,17 +14,16 @@ const HEADER = (what) => `// ${what} — written once by \`sincpro-client scaffo
 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;
+    // Named for what it is — `projectBoundedContext`, never `project` (an entity?) or `ctx` —:
+    // nobody misreads it, and no word of the language or name `index.ts` imports can take it.
+    const name = `${Name.charAt(0).toLowerCase()}${Name.slice(1)}BoundedContext`;
     const Dependencies = `${Name}Dependencies`;
     const client = metamodel.bindings !== undefined;
-    const transport = options.transport ?? at("..", "common", "infrastructure", "transport");
+    const operations = options.operations ?? at("..", "common", "infrastructure", "operations");
     const dependencies = [
         HEADER(`What the services of «${alias}» can count on`),
         "",
-        `import type { Transport } from "${FRAMEWORK}";`,
+        `import type { OperationTransport } from "${FRAMEWORK}";`,
         `import type { BoundedContext } from "${at(FRAMEWORK, "core")}";`,
         ...(client ? ["", `import { clientOf } from "${at("..", "generated", "client")}";`] : []),
         "",
@@ -44,11 +37,11 @@ export function scaffoldFilesOf(metamodel, options = {}) {
         "}",
         "",
         "export function registerDependencies(",
-        `  bc: BoundedContext<${Dependencies}>,`,
-        `  ${client ? "transport" : "_transport"}: Transport,`,
+        `  boundedContext: BoundedContext<${Dependencies}>,`,
+        `  ${client ? "operations" : "_operations"}: OperationTransport,`,
         ") {",
-        ...(client ? [`  bc.addDependency("client", clientOf(transport));`] : []),
-        "  return bc;",
+        ...(client ? [`  boundedContext.addDependency("client", clientOf(operations));`] : []),
+        "  return boundedContext;",
         "}",
         "",
     ].join("\n");
@@ -60,23 +53,24 @@ export function scaffoldFilesOf(metamodel, options = {}) {
         "  Feature as BaseFeature,",
         "  BoundedContext,",
         "  type Command,",
+        "  type DomainEvent,",
         `} from "${at(FRAMEWORK, "core")}";`,
-        `import type { Transport } from "${FRAMEWORK}";`,
+        `import type { OperationTransport } from "${FRAMEWORK}";`,
         "",
         `import { type ${Dependencies}, registerDependencies } from "${at(".", "dependencies")}";`,
         "",
-        `/** A Feature of «${alias}»: its dependencies typed on \`this\`, and \`this.context\`. */`,
-        "export abstract class Feature<C extends Command<R>, R> extends BaseFeature<C, R> {",
+        `/** A Feature of «${alias}» — of a Command, or a use case of an event: its dependencies typed on \`this\`, and \`this.context\`. */`,
+        "export abstract class Feature<C extends Command<R> | DomainEvent, R> extends BaseFeature<C, R> {",
         ...(client ? [`  declare readonly client: ${Dependencies}["client"];`] : []),
         "}",
         "",
         `/** An ApplicationService of «${alias}»: the same, and \`this.featureBus.execute(dto)\`. */`,
-        "export abstract class ApplicationService<C extends Command<R>, R> extends BaseApplicationService<C, R> {",
+        "export abstract class ApplicationService<C extends Command<R> | DomainEvent, R> extends BaseApplicationService<C, R> {",
         ...(client ? [`  declare readonly client: ${Dependencies}["client"];`] : []),
         "}",
         "",
-        `export function config${Name}BoundedContext(name: string, transport: Transport) {`,
-        `  return registerDependencies(new BoundedContext<${Dependencies}>(name), transport);`,
+        `export function config${Name}BoundedContext(name: string, operations: OperationTransport) {`,
+        `  return registerDependencies(new BoundedContext<${Dependencies}>(name), operations);`,
         "}",
         "",
     ].join("\n");
@@ -90,22 +84,24 @@ export function scaffoldFilesOf(metamodel, options = {}) {
         " * Generated DTO types are remote contracts, not runtime command constructors: import",
         ` * them under their own name — \`import type * as remote from "${at("..", "generated", "domain")}"\` —`,
         " * and let a local Command implement one (`implements remote.CommandCancelIssue`).",
-        " * Register with context.feature(CommandClass)(FeatureClass) or",
-        " * context.appService(CommandClass)(ApplicationServiceClass).",
+        " * Register with boundedContext.feature(CommandClass)(FeatureClass) or",
+        " * boundedContext.appService(CommandClass)(ApplicationServiceClass); the services live in",
+        " * one folder per aggregate (`services/<aggregate>/`), and an entity of that aggregate with",
+        " * use cases of its own in a folder inside it (`services/<aggregate>/<entity>/`).",
         " */",
-        `export function registerServices(_context: BoundedContext<${Dependencies}>): void {}`,
+        `export function registerServices(_boundedContext: BoundedContext<${Dependencies}>): void {}`,
         "",
     ].join("\n");
     const index = [
         HEADER(`«${alias}», ready to use`),
         "",
-        `import { transport } from "${transport}";`,
+        `import { operations } from "${operations}";`,
         "",
         `import { config${Name}BoundedContext } from "${at(".", "infrastructure", "bounded_context")}";`,
         `import { registerServices } from "${at(".", "services")}";`,
         "",
         `/** «${alias}»: \`${name}.execute(new Command(...))\`. */`,
-        `export const ${name} = config${Name}BoundedContext(${JSON.stringify(alias)}, transport);`,
+        `export const ${name} = config${Name}BoundedContext(${JSON.stringify(alias)}, operations);`,
         `registerServices(${name});`,
         "",
     ].join("\n");