@sincpro/client-framework 0.3.0 → 0.5.0

package/AGENTS.md

@@ -20,17 +20,18 @@ it says what this package is responsible for and what it is not. This file is ho
 
 ## Where things go
 
-| Folder               | What                                                                                        |
-| -------------------- | ------------------------------------------------------------------------------------------- |
-| `src/client/`        | The seam with a server: `Transport`, REST, memory, `entity()`, the client contract, ids     |
-| `src/model/`         | Model definitions: `defineMeta`, from a JSON Schema, the store of known ones                |
-| `src/services/`      | `UseBoundedContext`, `Feature`, `ApplicationService`, the process, the execution            |
-| `src/context/`       | The `ContextStore` port, `memoryContexts`, and `Context` — one level of it                  |
-| `src/observability/` | The ports a platform plugs: `Tracer`, `ErrorReporter`                                       |
-| `src/codegen/`       | The generator and its CLI (`sincpro-client generate`) — the only place Node is allowed      |
-| `src/adapters/`      | Optional entries over a vendor (`./opentelemetry`, `./sentry`): the only place one is named |
-| `src/testing/`       | `memoryTracer`, `memoryReporter` — the ports in memory, for tests                           |
-| `tests/`             | vitest in Node; `tests/support/` holds the fake domains and forge's real contracts          |
+| Folder               | What                                                                                          |
+| -------------------- | --------------------------------------------------------------------------------------------- |
+| `src/common/`        | The values of the wire: ids, a day and an instant, `Decimal`, `Money`, `valuesOf` / `rebuilt` |
+| `src/client/`        | The seam with a server: `Transport`, REST, memory, `entity()`, the client contract            |
+| `src/model/`         | Model definitions: `defineMeta`, from a JSON Schema, the store of known ones                  |
+| `src/services/`      | `UseBoundedContext`, `Feature`, `ApplicationService`, the process, the execution              |
+| `src/context/`       | The `ContextStore` port, `memoryContexts`, and `Context` — one level of it                    |
+| `src/observability/` | The ports a platform plugs: `Tracer`, `ErrorReporter`                                         |
+| `src/codegen/`       | The generator and its CLI (`sincpro-client generate`) — the only place Node is allowed        |
+| `src/adapters/`      | Optional entries over a vendor (`./opentelemetry`, `./sentry`): the only place one is named   |
+| `src/testing/`       | `memoryTracer`, `memoryReporter` — the ports in memory, for tests                             |
+| `tests/`             | vitest in Node; `tests/support/` holds the fake domains and forge's real contracts            |
 
 ## Hard rules (the build enforces them — `make doctor`)
 
@@ -90,6 +91,16 @@ it says what this package is responsible for and what it is not. This file is ho
   an `AbortError` is `aborted`; neither is reported (`outcomeOf`). Change that with
   `ProcessOptions.outcomeOf`, never by catching in a Feature.
 
+- **Only what is transversal comes here.** A value's wire form (a decimal as text, a day never
+  an instant, a money with its currency) is the backend's contract, the same on every platform,
+  so it lives in `src/common/`. How a value is shown to a person, typed in an input, or kept in
+  SQLite or IndexedDB is the platform's — @sincpro/web-framework's or @sincpro/mobile's.
+- **A decimal never becomes a `number`.** It travels as text and is computed with `Decimal` or
+  `Money` (exact, on `BigInt`); `Number(...)` or `parseFloat` on an amount is the float the
+  backend sends text to avoid. And a day is never a `Date`: a `Date` is an instant.
+- **The in-memory server copies by the wire's rules** (`valuesOf` → `readValues`): what it receives
+  and answers is what a real server would — a `Money` as `{ amount, currency }`, a `Date` as text.
+
 ## Before you hand it back
 
 ```bash

package/MANIFESTO.md

@@ -48,10 +48,14 @@ server-side render, in a script and in a test, unchanged.**
    never import each other's insides.
 6. **The client.** The `Transport` port and its implementations (REST, memory), `entity()` with
    typed commands and answers, the service's client contract, model definitions read once from
-   the server, client-side ids (UUID v7) and the server's `Problem`.
-7. **The generator.** From a service's client contract to each domain's types, client and
+   the server and the server's `Problem`.
+7. **The values of the wire.** How every value travels, as the backend writes it — a decimal as
+   text, a money with its currency, a day that is never an instant, bytes tagged, ids as UUID v7 —
+   and the exact arithmetic a client needs on them (`Decimal`, `Money`). Only the wire form and
+   what follows from it: showing a value to a person is each platform's.
+8. **The generator.** From a service's client contract to each domain's types, client and
    entities — generated, never edited, and as platform-neutral as everything else here.
-8. **Testing.** An in-memory transport, tracer and reporter, so a use case is proven in Node with
+9. **Testing.** An in-memory transport, tracer and reporter, so a use case is proven in Node with
    nothing else.
 
 ## What it is not

package/README.md

@@ -179,6 +179,23 @@ await project.Issues.close(input); // span project/Issues.close
 await project.CloseAndNotify.execute(input); // project/CloseAndNotify → its Features under it
 ```
 
+The generator writes this skeleton for you, once, from the service's contract — and never touches
+a file that is already there, because from then on it is yours:
+
+```bash
+sincpro-client generate project.contract.json --out src/domains/project/generated --domain project
+sincpro-client scaffold project.contract.json --out src/domains/project   # dependencies, bases, services, index
+```
+
+And the layers stay layers: `sincpro-client check` resolves every import of the application with
+its own TypeScript and `tsconfig` (aliases included) and fails when a bounded context reaches into
+another's insides, a service imports React or web-ui, `common` imports a bounded context, or the
+entrypoints skip a bounded context's `index.ts` — put it in `make doctor`:
+
+```bash
+sincpro-client check --root src
+```
+
 Every public method is a use case: a span named as the backend names its own
 (`project/Issues.close`, identity `project.Issues.close`), and a report when it fails in a way
 nobody expected. One gesture is one trace, from the click to the database:
@@ -224,6 +241,10 @@ processContext.set({ tenant_id: "acme" }); // every use case runs with it and se
 project.context.set({ warehouse_id: 4 }); // only what «project» runs
 ```
 
+What a screen reads and writes is a use case too when it goes through `screensTransport(transport)`:
+each request is `screens/EntityReads.list`, `…/EntityWrites.send` — traced, with the context on
+it, and reported when it failed.
+
 A service reads it as `this.context` — the process's values, under them its bounded context's,
 under them a scope's, read once where the gesture started — and every request it sends carries
 it in `sincpro-context`. A screen hears it change with `processContext.watch(…)`.
@@ -263,10 +284,44 @@ const tracer = openTelemetryTracer(provider.getTracer("my-app")); // the app's p
 const reporter = sentryReporter(client); // the app's Sentry-compatible client (GlitchTip too)
 ```
 
+What fails outside a use case — a screen that broke while drawing, a subscriber, a worker — goes to
+the same reporter with `reportError(error, where)`: once (an error a use case already reported is
+not sent again), with the process's context.
+
 Nothing is installed or shipped unless it is imported, and without a tracer or a reporter every use
 case runs the same — nothing traces, nothing reports. In a test, `memoryTracer()` and
 `memoryReporter()` (`@sincpro/client-framework/testing`).
 
+## Values on the wire
+
+The backend writes every message with one set of rules, and every client reads and writes them
+the same — so they live here, not in each platform:
+
+| Value       | Travels as                                 | Here                                             |
+| ----------- | ------------------------------------------ | ------------------------------------------------ |
+| a decimal   | text, every digit: `"10.50"`               | `Decimal` — exact, on `BigInt`; rounds half up   |
+| a money     | `{ "amount": "10.50", "currency": "BOB" }` | `Money` — never adds two currencies              |
+| a day       | `"2026-10-02"`, never converted            | `isDay`, `dayOf(instant, zone)` for «today»      |
+| an instant  | ISO text: `"2026-10-02T14:30:00Z"`         | `wallTimeOf` / `instantOf` on the company's zone |
+| an id       | a UUID v7 as 32 hex                        | `newEntityId`, `isEntityId`, `momentOf`          |
+| bytes       | `{ "$bytes": "<base64>" }`                 | `valuesOf` / `readValues`                        |
+| the context | only what travels: text, numbers, lists    | `plainCodec`, `travelling`                       |
+
+```ts
+import { Money, pack, unpack, valuesOf } from "@sincpro/client-framework";
+
+const line = new Money("19.90", "BOB").times("3"); // 59.70 BOB, exact
+const total = Money.total([line, delivery], "BOB").rounded(); // to the currency's decimals
+valuesOf({ total, at: new Date() }); // { total: { amount, currency }, at: "…Z" }
+const answer = unpack(text, Money); // a typed read when asked for — never imposed
+```
+
+Not restrictive, like the backend: reading keeps every key it finds, a typed read is asked for
+(`rebuilt(values, Money)`), any currency code is read, and an application adds its own decimals
+(`Money.decimals["USDT"] = 6`). What JSON cannot write (`NaN`, a function, a cycle) is refused at
+once, naming where. Showing a value to a person — `Intl.NumberFormat`, a date picker — is each
+platform's, never this package's.
+
 ## Where it sits
 
 ```mermaid
@@ -314,6 +369,9 @@ three ports, in its `main`:
 | `ContextStore`  | memory, `sessionStorage`, or the screens' store | MMKV, or memory hydrated from AsyncStorage | `memoryContexts`  |
 | `Transport`     | `restTransport` over `fetch`                    | `restTransport`, or SQLite offline         | `memoryTransport` |
 
+How @sincpro/mobile adopts all of this — what maps to what, the MMKV store, the order to move
+in — is [`docs/MOBILE.md`](docs/MOBILE.md).
+
 A store's reads are synchronous — a use case reads its context where a gesture starts and never
 waits for it — so an asynchronous storage is held in memory and written through.
 

package/dist/client/memory.js

@@ -1,12 +1,15 @@
 import { TransportError, } from "./transport.js";
+import { pack, readValues } from "../common/serialization.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.
+ * A deep copy written and read by the wire's rules (`pack`, `readValues`): what a real server
+ * would have received and answered — a `Money` as `{ amount, currency }`, a `Decimal` as its text,
+ * a `Date` as an instant, bytes as bytes — the same on every platform. `structuredClone` kept a
+ * `Date` a `Date` in a browser and a JSON round trip made it text on a phone; neither is a wire.
  */
-const copyOf = typeof globalThis.structuredClone === "function"
-    ? (value) => globalThis.structuredClone(value)
-    : (value) => (value === undefined ? value : JSON.parse(JSON.stringify(value)));
+const copyOf = (value) => 
+// Through text, as a wire is: an answer that is a string («"2.50"», an instant) stays one.
+value === undefined ? value : readValues(pack(value));
 function wait(ms, signal) {
     if (ms <= 0)
         return Promise.resolve();

package/dist/codegen/check.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The import rules of a Sincpro application, checked — what `sincpro-client check` runs in an
+ * application's `make doctor`, on the web and on a phone alike.
+ *
+ *     src/domains/<bounded context>/{generated,domain,adapters,services,infrastructure,components,entrypoints}
+ *     src/domains/common/            what bounded contexts share
+ *     src/entrypoints/               where the outside comes in
+ *
+ * | Layer             | Never                                                                  |
+ * | ----------------- | ---------------------------------------------------------------------- |
+ * | generated, domain | React, the DOM's libraries (web-ui, composer), its own adapters        |
+ * | adapters          | React, web-ui, composer                                                |
+ * | services          | React, web-ui, composer                                                |
+ * | infrastructure    | its own components                                                     |
+ * | components        | composer, a router                                                     |
+ * | common            | any bounded context                                                    |
+ * | any layer         | another bounded context — but its `index.ts`, from `infrastructure/`   |
+ * | entrypoints/ root | a bounded context's insides — only its `index.ts` (and `common`)       |
+ *
+ * Context: the architecture says these rules are enforced, not recommended; a rule only read in a
+ * page is the first to go under a deadline. Each import is resolved the way the application's
+ * compiler resolves it — its own `tsconfig.json`, its path aliases (`@/domains/…`) — with the
+ * application's TypeScript, so a relative path and an alias are the same import. Nothing here is
+ * a platform's: a React Native app has the same layers (`react-native` counts as React).
+ */
+export type Violation = {
+    /** The importing file, from the root. */
+    file: string;
+    /** What it imports, as written. */
+    imports: string;
+    why: string;
+};
+/** Where a file is in the application's tree. */
+export type Place = {
+    kind: "context";
+    context: string;
+    layer: string | null;
+    index: boolean;
+} | {
+    kind: "entrypoint";
+} | {
+    kind: "other";
+};
+/**
+ * `domains/sales/services/close.ts` → the bounded context `sales`, the layer `services` — wherever
+ * the `domains/` folder is (`src/domains/…`, a workspace's `domains/sales/src/services/…`).
+ */
+export declare function placeOf(path: string): Place;
+/**
+ * Why `from` may not import `specifier`, which resolves to `to` (`null`: a package), or nothing
+ * when it may.
+ */
+export declare function violationOf(from: Place, specifier: string, to: Place | null): string | undefined;
+/** What stops the check before it starts: no root, no config, a config that does not parse. */
+export declare class CheckError extends Error {
+}
+/**
+ * Every import under `root` that breaks a rule, resolved by the application's own TypeScript and
+ * `tsconfig` (its path aliases and its references included). An alias that does not resolve is a
+ * break too — read as a package it would switch every rule off.
+ */
+export declare function checkImports(root: string, options?: {
+    tsconfig?: string;
+}): Promise<Violation[]>;

package/dist/codegen/check.js

@@ -0,0 +1,195 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+const LAYERS = new Set([
+    "generated",
+    "domain",
+    "adapters",
+    "services",
+    "infrastructure",
+    "components",
+    "entrypoints",
+]);
+/**
+ * `domains/sales/services/close.ts` → the bounded context `sales`, the layer `services` — wherever
+ * the `domains/` folder is (`src/domains/…`, a workspace's `domains/sales/src/services/…`).
+ */
+export function placeOf(path) {
+    const parts = path.split(/[\\/]/).filter((one) => one !== "");
+    const start = parts[0] === "src" ? 1 : 0;
+    if (parts[start] === "entrypoints")
+        return { kind: "entrypoint" };
+    const at = parts.indexOf("domains");
+    const context = at === -1 ? undefined : parts[at + 1];
+    if (context === undefined || parts.length < at + 3)
+        return { kind: "other" };
+    // A bounded context that is a package of its own keeps its code under `src/`.
+    const rest = parts.slice(at + 2);
+    const inside = rest[0] === "src" && rest.length > 1 ? rest.slice(1) : rest;
+    const first = inside[0] ?? "";
+    const index = inside.length === 1 && /^index\.(ts|tsx|js|jsx|mts)$/.test(first);
+    return { kind: "context", context, layer: LAYERS.has(first) ? first : null, index };
+}
+const REACT = /^(react|react-dom|react-native)(\/|$)/;
+const DRAWING = /^@sincpro\/(web-ui|web-composer)(\/|$)/;
+const COMPOSER = /^@sincpro\/web-composer(\/|$)/;
+const ROUTER = /^(react-router|react-router-dom|@tanstack\/react-router|next\/navigation|next\/router|expo-router)(\/|$)/;
+/** web-framework draws; only its `core` is plain logic a service may use. */
+const SCREENS = /^@sincpro\/web-framework(?!\/core(\/|$))(\/|$)/;
+const PLAIN = new Set(["generated", "domain", "adapters", "services"]);
+/** Within a bounded context, what each layer never imports of its own. */
+const NEVER_OWN = {
+    generated: ["adapters", "services", "infrastructure", "components", "entrypoints"],
+    domain: ["adapters", "services", "infrastructure", "components", "entrypoints"],
+    adapters: ["services", "components", "entrypoints"],
+    services: ["components", "entrypoints"],
+    infrastructure: ["components", "entrypoints"],
+};
+/**
+ * Why `from` may not import `specifier`, which resolves to `to` (`null`: a package), or nothing
+ * when it may.
+ */
+export function violationOf(from, specifier, to) {
+    if (to === null) {
+        if (from.kind !== "context" || from.layer === null)
+            return undefined;
+        if (PLAIN.has(from.layer) &&
+            (REACT.test(specifier) || DRAWING.test(specifier) || SCREENS.test(specifier)))
+            return `${from.layer}/ is plain logic: it never imports a screen's library (React, web-ui, composer, web-framework but its core)`;
+        if (from.layer === "components" && (COMPOSER.test(specifier) || ROUTER.test(specifier)))
+            return "a component never decides where things open: no composer, no router";
+        return undefined;
+    }
+    // The application's entrypoints compose everything; nothing imports them back.
+    if (to.kind === "entrypoint")
+        return from.kind === "entrypoint"
+            ? undefined
+            : "nothing imports the application's entrypoints";
+    if (to.kind !== "context")
+        return undefined;
+    // Outside the bounded contexts (the entrypoints, `main.tsx`, a `lib/`): only their index.ts.
+    if (from.kind !== "context")
+        return to.context === "common" || to.index
+            ? undefined
+            : `outside a bounded context, it is used through its index.ts, never its insides («${to.context}»)`;
+    if (from.context === "common")
+        return to.context === "common" ? undefined : "common never imports a bounded context";
+    if (to.context === "common")
+        return undefined;
+    if (to.context === from.context) {
+        const never = from.layer === null ? undefined : NEVER_OWN[from.layer];
+        return to.layer !== null && never?.includes(to.layer) === true
+            ? `${from.layer}/ never imports its own ${to.layer}/`
+            : undefined;
+    }
+    if (to.index && from.layer === "infrastructure")
+        return undefined;
+    return to.index
+        ? `another bounded context («${to.context}») is a dependency: added in infrastructure/, never imported here`
+        : `a bounded context never imports another's insides («${to.context}»): only its index.ts, from infrastructure/`;
+}
+function sources(root) {
+    const found = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (entry.name === "node_modules" || entry.name.startsWith("."))
+            continue;
+        const path = join(root, entry.name);
+        if (entry.isDirectory())
+            found.push(...sources(path));
+        else if (/\.(ts|tsx|mts|cts|js|jsx)$/.test(entry.name) && !entry.name.endsWith(".d.ts"))
+            found.push(path);
+    }
+    return found;
+}
+/** What stops the check before it starts: no root, no config, a config that does not parse. */
+export class CheckError extends Error {
+}
+/**
+ * The compiler options the application resolves with: its config's, and those of every config it
+ * references — Vite writes `files: []` in `tsconfig.json` and keeps its aliases in
+ * `tsconfig.app.json`.
+ */
+function optionsOf(ts, path, seen) {
+    if (seen.has(path))
+        return [];
+    seen.add(path);
+    const read = ts.readConfigFile(path, ts.sys.readFile);
+    if (read.error !== undefined)
+        throw new CheckError(`${path}: ${ts.flattenDiagnosticMessageText(read.error.messageText, " ")}`);
+    const parsed = ts.parseJsonConfigFileContent(read.config, ts.sys, dirname(path), undefined, path);
+    // «No inputs were found» is what a config of references only says: not an error here.
+    const broken = parsed.errors.find((one) => one.category === ts.DiagnosticCategory.Error && one.code !== 18003);
+    if (broken !== undefined)
+        throw new CheckError(`${path}: ${ts.flattenDiagnosticMessageText(broken.messageText, " ")}`);
+    return [
+        parsed.options,
+        ...(parsed.projectReferences ?? []).flatMap((one) => optionsOf(ts, ts.resolveProjectReferencePath(one), seen)),
+    ];
+}
+/** A style, an image, a font, data: what a bundler loads and TypeScript does not resolve. */
+const ASSET = /\.(css|scss|sass|less|svg|png|jpe?g|gif|webp|avif|ico|woff2?|ttf|otf|json|md|mdx)(\?.*)?$/;
+/** `@acme/ventas`, `ventas` — a package named whole, never a path inside it. */
+const BARE = /^(@[^/]+\/)?[^/.@][^/]*$/;
+/**
+ * Every import under `root` that breaks a rule, resolved by the application's own TypeScript and
+ * `tsconfig` (its path aliases and its references included). An alias that does not resolve is a
+ * break too — read as a package it would switch every rule off.
+ */
+export async function checkImports(root, options = {}) {
+    if (!existsSync(root))
+        throw new CheckError(`${root} does not exist: say where the application's code is (--root)`);
+    const { default: ts } = await import("typescript");
+    if (options.tsconfig !== undefined && !ts.sys.fileExists(options.tsconfig))
+        throw new CheckError(`${options.tsconfig} does not exist`);
+    const configPath = options.tsconfig ?? ts.findConfigFile(root, ts.sys.fileExists);
+    const compilers = configPath === undefined ? [{}] : optionsOf(ts, configPath, new Set());
+    const aliases = compilers
+        .flatMap((one) => Object.keys(one.paths ?? {}))
+        .map((pattern) => pattern.replace(/\*.*$/, ""))
+        .filter((prefix) => prefix !== "");
+    const own = (path) => {
+        const from = relative(root, path);
+        return !from.startsWith("..") && !from.split(sep).includes("node_modules");
+    };
+    const violations = [];
+    for (const file of sources(root)) {
+        const name = relative(root, file).split(sep).join("/");
+        const from = placeOf(name);
+        for (const { fileName: specifier } of ts.preProcessFile(readFileSync(file, "utf8"), true, true).importedFiles) {
+            if (ASSET.test(specifier))
+                continue;
+            // The first config that finds it inside the application, else any that finds it.
+            let resolved;
+            for (const compiler of compilers) {
+                const found = ts.resolveModuleName(specifier, file, compiler, ts.sys).resolvedModule;
+                if (found === undefined)
+                    continue;
+                resolved ??= found;
+                if (own(found.resolvedFileName)) {
+                    resolved = found;
+                    break;
+                }
+            }
+            if (resolved === undefined && aliases.some((prefix) => specifier.startsWith(prefix))) {
+                violations.push({
+                    file: name,
+                    imports: specifier,
+                    why: "it does not resolve: an alias of the application that no tsconfig finds",
+                });
+                continue;
+            }
+            const inside = resolved !== undefined && own(resolved.resolvedFileName);
+            let to = inside
+                ? placeOf(relative(root, resolved.resolvedFileName).split(sep).join("/"))
+                : specifier.startsWith(".")
+                    ? { kind: "other" }
+                    : null;
+            // A bounded context that is a package, named whole (`@acme/ventas`): its index.
+            if (to?.kind === "context" && BARE.test(specifier))
+                to = { ...to, index: true };
+            const why = violationOf(from, specifier, to);
+            if (why !== undefined)
+                violations.push({ file: name, imports: specifier, why });
+        }
+    }
+    return violations;
+}

package/dist/codegen/cli.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { CheckError, checkImports } from "./check.js";
 import { clientFileOf } from "./client.js";
 import { domainFileOf } from "./domain.js";
 import { entitiesFileOf } from "./entities.js";
 import { aliasOf } from "./names.js";
+import { scaffoldFilesOf } from "./scaffold.js";
 /**
  * `sincpro-client generate <contract.json> --out <dir> [--domain <name>] [--base <path>]` — what an
  * application's `make client` runs, once per bounded context, over the client contract
@@ -21,7 +23,11 @@ import { aliasOf } from "./names.js";
  * verify-client` regenerates and fails on any difference. The folder is the generator's: keep
  * it out of the application's prettier and eslint, or a formatter rewrites what was generated.
  */
-const USAGE = "usage: sincpro-client generate <contract.json> --out <dir> [--domain <name>] [--base <path>]";
+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 check [--root src] [--tsconfig tsconfig.json]",
+].join("\n");
 /** JSON with every key sorted: the snapshot reads the same however the server ordered it. */
 function canonical(value) {
     if (Array.isArray(value))
@@ -35,7 +41,7 @@ function canonical(value) {
 /** The command, its source and its flags — or `undefined` when they do not read as usage says. */
 function parsed(args) {
     const [command, source, ...rest] = args;
-    if (command !== "generate" || source === undefined)
+    if ((command !== "generate" && command !== "scaffold") || source === undefined)
         return undefined;
     const flags = new Map();
     for (let at = 0; at < rest.length; at += 2) {
@@ -46,20 +52,73 @@ function parsed(args) {
         flags.set(flag, value);
     }
     const out = flags.get("--out");
-    const known = new Set(["--out", "--domain", "--base"]);
+    const known = new Set(command === "generate" ? ["--out", "--domain", "--base"] : ["--out", "--transport"]);
     if (out === undefined || [...flags.keys()].some((one) => !known.has(one)))
         return undefined;
     const domain = flags.get("--domain");
     const base = flags.get("--base");
     return {
+        command,
         source,
         out,
         options: {
             ...(domain === undefined ? {} : { domain }),
             ...(base === undefined ? {} : { base }),
         },
+        transport: flags.get("--transport"),
     };
 }
+/** 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 });
+    const written = [];
+    const kept = [];
+    for (const [name, source] of Object.entries(files)) {
+        const path = join(out, name);
+        if (existsSync(path)) {
+            kept.push(name);
+            continue;
+        }
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, source);
+        written.push(name);
+    }
+    console.log(`✓ ${aliasOf(metamodel)} → ${out}: written ${written.join(", ") || "nothing"}${kept.length === 0 ? "" : `; kept, already yours: ${kept.join(", ")}`}`);
+    return 0;
+}
+/** The import rules (`codegen/check.ts`): every break said, and a failing exit when any. */
+async function check(args) {
+    const flags = new Map();
+    for (let at = 0; at < args.length; at += 2) {
+        const flag = args[at];
+        const value = args[at + 1];
+        if (flag === undefined ||
+            value === undefined ||
+            !["--root", "--tsconfig"].includes(flag)) {
+            console.error(USAGE);
+            return 2;
+        }
+        flags.set(flag, value);
+    }
+    const root = flags.get("--root") ?? "src";
+    const tsconfig = flags.get("--tsconfig");
+    let found;
+    try {
+        found = await checkImports(root, tsconfig === undefined ? {} : { tsconfig });
+    }
+    catch (error) {
+        if (!(error instanceof CheckError))
+            throw error;
+        console.error(`✘ ${error.message}`);
+        return 2;
+    }
+    for (const one of found)
+        console.error(`✘ ${root}/${one.file} imports "${one.imports}": ${one.why}`);
+    if (found.length > 0)
+        return 1;
+    console.log(`✓ ${root}: every import keeps the layers`);
+    return 0;
+}
 function main(args) {
     const asked = parsed(args);
     if (asked === undefined) {
@@ -67,6 +126,8 @@ function main(args) {
         return 2;
     }
     const metamodel = JSON.parse(readFileSync(asked.source, "utf8"));
+    if (asked.command === "scaffold")
+        return scaffold(metamodel, asked.out, asked.transport);
     const files = { "domain.ts": domainFileOf(metamodel) };
     if (metamodel.bindings !== undefined) {
         files["client.ts"] = clientFileOf(metamodel, asked.options);
@@ -79,4 +140,10 @@ function main(args) {
     console.log(`✓ ${aliasOf(metamodel)} → ${asked.out} (${Object.keys(files).join(", ")})`);
     return 0;
 }
-process.exitCode = main(process.argv.slice(2));
+const args = process.argv.slice(2);
+if (args[0] === "check")
+    void check(args.slice(1)).then((code) => {
+        process.exitCode = code;
+    });
+else
+    process.exitCode = main(args);

package/dist/codegen/client.js

@@ -1,4 +1,4 @@
-import { aliasOf, claimed, deprecationOf, docOf, DOMAIN_MODULE, FRAMEWORK, headerOf, identifierOf, localOf, methodOf, recordLiteral, sorted, } from "./names.js";
+import { aliasOf, answerOf, claimed, deprecationOf, docOf, DOMAIN_MODULE, FRAMEWORK, headerOf, identifierOf, localOf, methodOf, recordLiteral, sorted, } from "./names.js";
 import { ownerOf, restOf, WRITES, } from "./rest.js";
 /**
  * The client of a bounded context as TypeScript: every operation as data, and a method for each
@@ -71,7 +71,7 @@ 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, method, call, rest, doc) {
+function methodSourceOf(local, answer, method, call, rest, doc) {
     if (call.kind === "list") {
         const entity = `dto.${identifierOf(call.entity)}`;
         const params = paramsOf(call);
@@ -80,7 +80,7 @@ function methodSourceOf(local, method, call, rest, doc) {
     }
     if (call.kind === "read") {
         const params = paramsOf(call);
-        return `${doc}    ${method}: (${params.signature}) =>\n      readRoute<dto.${local}Answer>(transport, ${params.route(rest.path)}),`;
+        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)}");
@@ -91,7 +91,7 @@ function methodSourceOf(local, method, call, rest, doc) {
         : "undefined";
     return [
         `${doc}    ${method}: (body: dto.${local}, options?: SendOptions) =>`,
-        `      transport.send<dto.${local}Answer>(`,
+        `      transport.send<dto.${answer}>(`,
         `        ${JSON.stringify(rest.method)},`,
         `        pathFor(routes.${method}, ${id}, body),`,
         `        body,`,
@@ -134,7 +134,7 @@ export function clientFileOf(metamodel, options = {}) {
         const method = methodOf(local);
         claim(method, `operation ${identity}`);
         const doc = docOf([operation.description, deprecationOf(metamodel, operation)], "    ");
-        methods.push(methodSourceOf(local, method, call, rest, doc));
+        methods.push(methodSourceOf(local, answerOf(metamodel, identity), method, call, rest, doc));
         if (call.kind === "list" || call.kind === "read") {
             paged ||= call.kind === "list";
             reads ||= call.kind === "read";

package/dist/codegen/domain.d.ts

@@ -4,7 +4,8 @@ import type { Metamodel } from "./metamodel.js";
  *
  * 1. The models, by name: an entity's contract, a related model by its own name.
  * 2. Each operation, by its local name (its identity without `<context>.`): its input as
- *    `<Name>` and its answer as `<Name>Answer`.
+ *    `<Name>` and its answer by the backend's own name for it (`answerOf`: `ResponseX`), with
+ *    `<Name>Answer` kept as a deprecated alias — or as `<Name>Answer` when it has no name.
  * 3. The shared definitions those reach — and the ones those reach, until none is new —, but
  *    never one a package of the stack already types (`Criteria`).
  * Final: a header that says where it came from and not to edit it, the imports, then models,