@sincpro/client-framework 0.6.0 → 1.0.0

package/dist/codegen/{entities.js → services/entities.js}

@@ -1,5 +1,5 @@
-import { entityKeyOf } from "../client/contract.js";
-import { aliasOf, answerOf, claimed, DOMAIN_MODULE, FRAMEWORK, headerOf, identifierOf, isEntity, localOf, methodOf, pluralOf, sorted, } from "./names.js";
+import { entityKeyOf } from "../../client/domain/contract.js";
+import { aliasOf, answerOf, claimed, DOMAIN_MODULE, FRAMEWORK, headerOf, identifierOf, isEntity, localOf, methodOf, pluralOf, sorted, } from "../domain/names.js";
 import { ownerOf, restOf, WRITES, } from "./rest.js";
 /** The one operation of `role` for `entity` a transport can call, by `own` when there are many. */
 function oneOf(candidates, role) {
@@ -90,6 +90,19 @@ function entitySourceOf(metamodel, model, domain, options, claim) {
         const route = `${write.found.rest.method} ${recordPath(write.found.rest, field)}`;
         routes.push(`  ${role}: ${JSON.stringify(route)},`);
     }
+    // A record's events (sincpro_framework's `DomainEvents`): its history, read by the record's key.
+    const events = oneOf(reads("events", isGet), "events");
+    if (events !== undefined) {
+        if ("missing" in events)
+            missing.push(`history: ${events.missing}`);
+        else {
+            const field = events.found.operation.targets[model];
+            if (field !== undefined && events.found.rest.fields.length === 1)
+                routes.push(`  history: ${JSON.stringify(recordPath(events.found.rest, field))},`);
+            else
+                missing.push(`history: \`${events.found.local}\` is at ${events.found.rest.path}`);
+        }
+    }
     const exported = oneOf(reads("export", isGet), "export");
     if (exported !== undefined) {
         if ("missing" in exported)
@@ -142,8 +155,9 @@ function entitySourceOf(metamodel, model, domain, options, claim) {
  *
  * 1. Per model, by name: the one `search` a transport reads for it (`own` when there are
  *    several) — none, and the model gets no entity, said in the file's own doc.
- * 2. Its `get`, `edit` and `preview` the same way, the record's field written `{id}`, and its
- *    `export` — every record of a criteria as a file — by its path.
+ * 2. Its `get`, `edit` and `preview` the same way, the record's field written `{id}`; its
+ *    `events` — a record's `DomainEvents` — as `history`, the same way; and its `export` — every
+ *    record of a criteria as a file — by its path.
  * 3. Every write of role `command` that concerns it: with `target` when its body names the
  *    record, as it is when it creates one; its body typed without that field.
  * Final: an `entity<T, C>()` per model listed, keyed `<domain>:<kind>`, and `entities`, all of

package/dist/codegen/{rest.d.ts → services/rest.d.ts}

@@ -1,4 +1,4 @@
-import type { Metamodel, Operation } from "./metamodel.js";
+import type { Metamodel, Operation } from "../domain/metamodel.js";
 /**
  * How REST reaches each operation of a contract, as the generated client and entities write it.
  *

package/dist/codegen/{scaffold.d.ts → services/scaffold.d.ts}

@@ -1,4 +1,4 @@
-import type { Metamodel } from "./metamodel.js";
+import type { Metamodel } from "../domain/metamodel.js";
 /**
  * A bounded context's skeleton, written ONCE beside what is generated — the files that are the
  * application's from then on:
@@ -7,7 +7,7 @@ import type { Metamodel } from "./metamodel.js";
  *       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
+ *       services/index.ts                  registers command classes and their services
  *       index.ts                           `export const project` — ready to use
  *
  * Context: the layout sincpro_framework gives a service (`dependencies.py`, `framework.py`,

package/dist/codegen/{scaffold.js → services/scaffold.js}

@@ -1,9 +1,8 @@
-import { aliasOf, FRAMEWORK } from "./names.js";
+import { aliasOf, FRAMEWORK } from "../domain/names.js";
 /** Names the skeleton's `index.ts` cannot give its constant. */
 const TAKEN = new Set([
     "transport",
-    "features",
-    "applicationServices",
+    "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`. */
@@ -31,7 +30,8 @@ export function scaffoldFilesOf(metamodel, options = {}) {
     const dependencies = [
         HEADER(`What the services of «${alias}» can count on`),
         "",
-        `import type { Transport, UseBoundedContext } from "${FRAMEWORK}";`,
+        `import type { Transport } from "${FRAMEWORK}";`,
+        `import type { BoundedContext } from "${at(FRAMEWORK, "core")}";`,
         ...(client ? ["", `import { clientOf } from "${at("..", "generated", "client")}";`] : []),
         "",
         `/** What every service of «${alias}» finds on \`this\`${client ? ": `this.client`, the service's operations" : ""}. */`,
@@ -44,7 +44,7 @@ export function scaffoldFilesOf(metamodel, options = {}) {
         "}",
         "",
         "export function registerDependencies(",
-        `  bc: UseBoundedContext<${Dependencies}>,`,
+        `  bc: BoundedContext<${Dependencies}>,`,
         `  ${client ? "transport" : "_transport"}: Transport,`,
         ") {",
         ...(client ? [`  bc.addDependency("client", clientOf(transport));`] : []),
@@ -58,45 +58,42 @@ export function scaffoldFilesOf(metamodel, options = {}) {
         "import {",
         "  ApplicationService as BaseApplicationService,",
         "  Feature as BaseFeature,",
-        "  type Transport,",
-        "  UseBoundedContext,",
-        `} from "${FRAMEWORK}";`,
+        "  BoundedContext,",
+        "  type Command,",
+        `} from "${at(FRAMEWORK, "core")}";`,
+        `import type { Transport } 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}> {}`,
+        "export abstract class Feature<C extends Command<R>, R> extends BaseFeature<C, R> {",
+        ...(client ? [`  declare readonly client: ${Dependencies}["client"];`] : []),
+        "}",
         "",
-        `/** An ApplicationService of «${alias}»: the same, and \`this.feature.<Name>\` for each Feature. */`,
-        "export class ApplicationService extends BaseApplicationService<",
-        `  ${Dependencies},`,
-        `  ${Name}Features`,
-        "> {}",
+        `/** An ApplicationService of «${alias}»: the same, and \`this.featureBus.execute(dto)\`. */`,
+        "export abstract class ApplicationService<C extends Command<R>, R> extends BaseApplicationService<C, R> {",
+        ...(client ? [`  declare readonly client: ${Dependencies}["client"];`] : []),
+        "}",
         "",
         `export function config${Name}BoundedContext(name: string, transport: Transport) {`,
-        `  return registerDependencies(new UseBoundedContext<${Dependencies}>(name), transport);`,
+        `  return registerDependencies(new BoundedContext<${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 = {};",
+        `import type { BoundedContext } from "${at(FRAMEWORK, "core")}";`,
+        `import type { ${Dependencies} } from "${at("..", "infrastructure", "dependencies")}";`,
         "",
-        `export type ${Name}Features = typeof features;`,
+        "/** Register local Command classes with their Features and ApplicationServices.",
+        " * 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).",
+        " */",
+        `export function registerServices(_context: BoundedContext<${Dependencies}>): void {}`,
         "",
     ].join("\n");
     const index = [
@@ -105,13 +102,11 @@ export function scaffoldFilesOf(metamodel, options = {}) {
         `import { transport } from "${transport}";`,
         "",
         `import { config${Name}BoundedContext } from "${at(".", "infrastructure", "bounded_context")}";`,
-        `import { applicationServices, features } from "${at(".", "services")}";`,
+        `import { registerServices } 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,",
-        "});",
+        `/** «${alias}»: \`${name}.execute(new Command(...))\`. */`,
+        `export const ${name} = config${Name}BoundedContext(${JSON.stringify(alias)}, transport);`,
+        `registerServices(${name});`,
         "",
     ].join("\n");
     return {

package/dist/common/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The values of the wire, as the backend writes them: ids, a day and an instant, `Decimal`,
+ * `Money`, a to-many as a page of its records, and how any value is written and read.
+ */
+export { collectionOf, type EntityCollection, type HeldCollection, isCollection, isPartial, relatedCriteria, type RelationKeys, totalOf, } from "./collection.js";
+export { Decimal, type DecimalLike } from "./decimal.js";
+export { isEntityId, momentOf, newEntityId } from "./ids.js";
+export { Money } from "./money.js";
+export { BYTES, type JsonValue, pack, readValues, type Rebuild, rebuilt, unpack, valuesOf, } from "./serialization.js";
+export { dayOf, installTimeZone, instantOf, isDay, timeZoneNow, wallTimeOf, } from "./time.js";

package/dist/common/index.js

@@ -0,0 +1,10 @@
+/**
+ * The values of the wire, as the backend writes them: ids, a day and an instant, `Decimal`,
+ * `Money`, a to-many as a page of its records, and how any value is written and read.
+ */
+export { collectionOf, isCollection, isPartial, relatedCriteria, totalOf, } from "./collection.js";
+export { Decimal } from "./decimal.js";
+export { isEntityId, momentOf, newEntityId } from "./ids.js";
+export { Money } from "./money.js";
+export { BYTES, pack, readValues, rebuilt, unpack, valuesOf, } from "./serialization.js";
+export { dayOf, installTimeZone, instantOf, isDay, timeZoneNow, wallTimeOf, } from "./time.js";

package/dist/context/adapters/memory.d.ts

@@ -0,0 +1,6 @@
+import type { ContextStore } from "../domain/store.js";
+/**
+ * The context in this process's memory: the default, on every platform. A test gets a fresh one
+ * from `configureProcess()`.
+ */
+export declare function memoryContexts(): ContextStore;

package/dist/context/adapters/memory.js

@@ -0,0 +1,34 @@
+/**
+ * The context in this process's memory: the default, on every platform. A test gets a fresh one
+ * from `configureProcess()`.
+ */
+export function memoryContexts() {
+    const held = new Map();
+    const versions = new Map();
+    const listeners = new Map();
+    const changed = (key) => {
+        versions.set(key, (versions.get(key) ?? 0) + 1);
+        for (const listener of [...(listeners.get(key) ?? [])])
+            listener();
+    };
+    return {
+        load: (key) => held.get(key),
+        save(key, values) {
+            // A copy: whoever handed the values may keep changing their object.
+            held.set(key, { ...values });
+            changed(key);
+        },
+        delete(key) {
+            if (!held.delete(key))
+                return;
+            changed(key);
+        },
+        version: (key) => versions.get(key) ?? 0,
+        watch(key, listener) {
+            const own = listeners.get(key) ?? new Set();
+            listeners.set(key, own);
+            own.add(listener);
+            return () => void own.delete(listener);
+        },
+    };
+}

package/dist/context/adapters/plain-codec.d.ts

@@ -0,0 +1,3 @@
+import { type ContextCodec } from "../domain/codec.js";
+/** The codec for anything outside the codebase: only the values that travel, as JSON. */
+export declare const plainCodec: ContextCodec;

package/dist/context/adapters/plain-codec.js

@@ -0,0 +1,16 @@
+import { travelling, } from "../domain/codec.js";
+/** The codec for anything outside the codebase: only the values that travel, as JSON. */
+export const plainCodec = {
+    dumps: (values) => JSON.stringify(travelling(values)),
+    loads(text) {
+        try {
+            const found = JSON.parse(text);
+            return found !== null && typeof found === "object" && !Array.isArray(found)
+                ? found
+                : {};
+        }
+        catch {
+            return {};
+        }
+    },
+};

package/dist/context/{codec.d.ts → domain/codec.d.ts}

@@ -23,4 +23,3 @@ export interface ContextCodec {
 export declare function travels(value: unknown): boolean;
 /** The values of `context` that travel; the rest stays in this process. */
 export declare function travelling(context: ContextValues): ContextValues;
-export declare const plainCodec: ContextCodec;

package/dist/context/{codec.js → domain/codec.js}

@@ -28,17 +28,3 @@ export function travels(value) {
 export function travelling(context) {
     return Object.fromEntries(Object.entries(context).filter(([, value]) => travels(value)));
 }
-export const plainCodec = {
-    dumps: (values) => JSON.stringify(travelling(values)),
-    loads(text) {
-        try {
-            const found = JSON.parse(text);
-            return found !== null && typeof found === "object" && !Array.isArray(found)
-                ? found
-                : {};
-        }
-        catch {
-            return {};
-        }
-    },
-};

package/dist/context/domain/execution.d.ts

@@ -0,0 +1,33 @@
+import type { Span } from "../../observability/domain/tracing.js";
+/**
+ * One run of a use case: its span, what it runs with, and who ran it.
+ *
+ * Context: sincpro_framework keeps the running use case in a context variable; a browser has
+ * nothing like it that survives an `await` (AsyncContext is a proposal, Zone.js patches the
+ * world), and a global stack mixes the parents of two use cases running at once — which a
+ * screen with several windows does all the time. So an execution is a value, handed to what
+ * the use case calls: the Features its `featureBus` runs, and its dependencies (`BIND`).
+ */
+export type Execution = {
+    /** UUID v7, as 32 hex: this run. */
+    readonly id: string;
+    /** `<bounded context>.<Service>` — the use case's identity, as the backend names its own. */
+    readonly useCase: string;
+    /** The bounded context the use case belongs to. */
+    readonly boundedContext: string;
+    /** The run that executed this one: an ApplicationService, for its Features. */
+    readonly parent: Execution | undefined;
+    readonly span: Span;
+    /** What it runs with, read once where the gesture started and inherited by every child. */
+    readonly context: Readonly<Record<string, unknown>>;
+};
+/**
+ * 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, every generated client and the
+ * predefined loggers are; any other dependency of a bounded context is handed as it is.
+ */
+export declare const BIND: unique symbol;
+export type Bindable<T> = {
+    [BIND]: (execution: Execution) => T;
+};
+export declare function isBindable<T>(value: T): value is T & Bindable<T>;

package/dist/context/domain/execution.js

@@ -0,0 +1,11 @@
+/**
+ * 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, every generated client and the
+ * predefined loggers are; any other dependency of a bounded context is handed as it is.
+ */
+export const BIND = Symbol.for("sincpro.client-framework.bind");
+export function isBindable(value) {
+    return (value !== null &&
+        (typeof value === "object" || typeof value === "function") &&
+        typeof value[BIND] === "function");
+}

package/dist/context/{store.d.ts → domain/store.d.ts}

@@ -44,8 +44,3 @@ export interface ContextStore {
      */
     watch?(key: string, listener: () => void): () => void;
 }
-/**
- * The context in this process's memory: the default, on every platform. A test gets a fresh one
- * from `configureProcess()`.
- */
-export declare function memoryContexts(): ContextStore;

package/dist/context/{store.js → domain/store.js}

@@ -23,37 +23,4 @@
  * Reads are synchronous on purpose: a use case reads its context where a gesture starts, and an
  * asynchronous store would make every use case wait for it.
  */
-/**
- * The context in this process's memory: the default, on every platform. A test gets a fresh one
- * from `configureProcess()`.
- */
-export function memoryContexts() {
-    const held = new Map();
-    const versions = new Map();
-    const listeners = new Map();
-    const changed = (key) => {
-        versions.set(key, (versions.get(key) ?? 0) + 1);
-        for (const listener of [...(listeners.get(key) ?? [])])
-            listener();
-    };
-    return {
-        load: (key) => held.get(key),
-        save(key, values) {
-            // A copy: whoever handed the values may keep changing their object.
-            held.set(key, { ...values });
-            changed(key);
-        },
-        delete(key) {
-            if (!held.delete(key))
-                return;
-            changed(key);
-        },
-        version: (key) => versions.get(key) ?? 0,
-        watch(key, listener) {
-            const own = listeners.get(key) ?? new Set();
-            listeners.set(key, own);
-            own.add(listener);
-            return () => void own.delete(listener);
-        },
-    };
-}
+export {};

package/dist/context/{context.d.ts → entrypoint/context.d.ts}

@@ -1,4 +1,4 @@
-import type { ContextStore, ContextValues } from "./store.js";
+import type { ContextStore, ContextValues } from "../domain/store.js";
 /**
  * One level of the context: the process's (`processContext`) or a bounded context's
  * (`project.context`), read and written the same way on every platform.

package/dist/context/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The context: the levels a call sees (the process, its bounded context, a scope), where they
+ * live (`ContextStore`, a port each platform implements), what travels with a request, and the
+ * execution a run carries.
+ *
+ *   domain/          the ports and rules: `ContextStore`, `ContextCodec`, what travels, `Execution`
+ *   adapters/        the implementations this package gives: memory, the plain codec
+ *   entrypoint/      `Context`: one door over a level
+ *   infrastructure/  the process's store and its level (`processContext`)
+ */
+export { memoryContexts } from "./adapters/memory.js";
+export { plainCodec } from "./adapters/plain-codec.js";
+export { CONTEXT_HEADER, type ContextCodec, travelling, travels, } from "./domain/codec.js";
+export { BIND, type Bindable, type Execution, } from "./domain/execution.js";
+export type { ContextStore, ContextValues, } from "./domain/store.js";
+export type { Context } from "./entrypoint/context.js";
+export { processContext } from "./infrastructure/process.js";

package/dist/context/index.js

@@ -0,0 +1,15 @@
+/**
+ * The context: the levels a call sees (the process, its bounded context, a scope), where they
+ * live (`ContextStore`, a port each platform implements), what travels with a request, and the
+ * execution a run carries.
+ *
+ *   domain/          the ports and rules: `ContextStore`, `ContextCodec`, what travels, `Execution`
+ *   adapters/        the implementations this package gives: memory, the plain codec
+ *   entrypoint/      `Context`: one door over a level
+ *   infrastructure/  the process's store and its level (`processContext`)
+ */
+export { memoryContexts } from "./adapters/memory.js";
+export { plainCodec } from "./adapters/plain-codec.js";
+export { CONTEXT_HEADER, travelling, travels, } from "./domain/codec.js";
+export { BIND, } from "./domain/execution.js";
+export { processContext } from "./infrastructure/process.js";

package/dist/context/infrastructure/process.d.ts

@@ -0,0 +1,13 @@
+import type { ContextStore } from "../domain/store.js";
+import { type Context, type StoreSource } from "../entrypoint/context.js";
+/** @internal — `configureProcess` is the way in. */
+export declare function replaceProcessStore(store: ContextStore): void;
+/** The process's store as every level of the context reads it — the process's and each bounded context's. */
+export declare const processStore: StoreSource;
+/**
+ * The process's level of the context: what every use case of every bounded context runs with —
+ * the tenant, the company, the language.
+ *
+ *     processContext.set({ tenant_id: "acme" });
+ */
+export declare const processContext: Context;

package/dist/context/infrastructure/process.js

@@ -0,0 +1,35 @@
+import { memoryContexts } from "../adapters/memory.js";
+import { contextAt, } from "../entrypoint/context.js";
+/**
+ * Where this process keeps its context: the store `configureProcess` chose (`memoryContexts()`
+ * until it chooses), read on every call, never at import.
+ *
+ * Context: a level made before `main` configures the process (`project` is defined when its
+ * module loads) still reads the store chosen later; whoever listens moves to the new store and
+ * hears the change.
+ */
+let current = memoryContexts();
+const replacing = new Set();
+/** @internal — `configureProcess` is the way in. */
+export function replaceProcessStore(store) {
+    const before = current;
+    current = store;
+    if (current !== before)
+        for (const listener of [...replacing])
+            listener();
+}
+/** The process's store as every level of the context reads it — the process's and each bounded context's. */
+export const processStore = {
+    current: () => current,
+    replaced(listener) {
+        replacing.add(listener);
+        return () => void replacing.delete(listener);
+    },
+};
+/**
+ * The process's level of the context: what every use case of every bounded context runs with —
+ * the tenant, the company, the language.
+ *
+ *     processContext.set({ tenant_id: "acme" });
+ */
+export const processContext = contextAt("process", processStore);

package/dist/core/domain/bus.d.ts

@@ -0,0 +1,18 @@
+import type { AnyCommand, Command, ResponseClass } from "./dto.js";
+/** What executes a Command: the bounded context, a scope of it, an ApplicationService's features. */
+export interface CommandBus {
+    execute<R>(command: Command<R>, returnType?: ResponseClass<NoInfer<R>>): Promise<R>;
+}
+/** @internal — how a bus hands a Command to its generation. */
+export type Dispatch = (command: AnyCommand) => Promise<unknown>;
+/** @internal — the heterogeneous registry erases the type; registration checks the association. */
+export declare function executeTyped<R>(dispatch: Dispatch, command: Command<R>): Promise<R>;
+/**
+ * What an ApplicationService composes its context's Features through (`this.featureBus`): the
+ * same pipeline, as a child of the running execution, and Features only.
+ */
+export declare class FeatureBus implements CommandBus {
+    private readonly dispatch;
+    constructor(dispatch: Dispatch);
+    execute<R>(command: Command<R>, _returnType?: ResponseClass<NoInfer<R>>): Promise<R>;
+}

package/dist/core/domain/bus.js

@@ -0,0 +1,18 @@
+/** @internal — the heterogeneous registry erases the type; registration checks the association. */
+export async function executeTyped(dispatch, command) {
+    // As with Python's return_type, this does not validate the returned data at runtime.
+    return (await dispatch(command));
+}
+/**
+ * What an ApplicationService composes its context's Features through (`this.featureBus`): the
+ * same pipeline, as a child of the running execution, and Features only.
+ */
+export class FeatureBus {
+    dispatch;
+    constructor(dispatch) {
+        this.dispatch = dispatch;
+    }
+    execute(command, _returnType) {
+        return executeTyped(this.dispatch, command);
+    }
+}

package/dist/core/domain/dto.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The DTOs of the application layer, as sincpro_framework's `DataTransferObject`: a Command asks
+ * for work and names, by its type, the Response it answers.
+ *
+ *     class CommandCancelIssue extends Command<ResponseCancelIssue> {
+ *       constructor(readonly issue_id: string) { super(); }
+ *     }
+ *     const answer = await project.execute(new CommandCancelIssue("x"));   // ResponseCancelIssue
+ *
+ * Context: the backend asks `bus(dto, ResponseType)` for the type; here the Command carries it, so
+ * `execute` infers it with no second argument. The association is type-only: absent from a
+ * serialized DTO, not a runtime validator. A generated DTO is a remote contract (a type), not one
+ * of these: a local Command may implement it.
+ */
+export declare abstract class DataTransferObject {
+    protected readonly dtoBrand: void;
+}
+export declare abstract class Response extends DataTransferObject {
+}
+declare const responseType: unique symbol;
+export declare abstract class Command<R> extends DataTransferObject {
+    /** Type-only association: absent from serialized DTOs and not a runtime validator. */
+    readonly [responseType]: R;
+}
+export type AnyCommand = Command<unknown>;
+/** What a Command answers. */
+export type Answer<C extends AnyCommand> = C[typeof responseType];
+/** A Command's class: what a service is registered for, by exact constructor identity. */
+export type CommandClass<C extends AnyCommand> = abstract new (...args: never[]) => C;
+/** A Response's class: the backend's `return_type`, accepted for the same reading. */
+export type ResponseClass<R> = abstract new (...args: never[]) => R;
+export {};

package/dist/core/domain/dto.js

@@ -0,0 +1,20 @@
+/**
+ * The DTOs of the application layer, as sincpro_framework's `DataTransferObject`: a Command asks
+ * for work and names, by its type, the Response it answers.
+ *
+ *     class CommandCancelIssue extends Command<ResponseCancelIssue> {
+ *       constructor(readonly issue_id: string) { super(); }
+ *     }
+ *     const answer = await project.execute(new CommandCancelIssue("x"));   // ResponseCancelIssue
+ *
+ * Context: the backend asks `bus(dto, ResponseType)` for the type; here the Command carries it, so
+ * `execute` infers it with no second argument. The association is type-only: absent from a
+ * serialized DTO, not a runtime validator. A generated DTO is a remote contract (a type), not one
+ * of these: a local Command may implement it.
+ */
+export class DataTransferObject {
+}
+export class Response extends DataTransferObject {
+}
+export class Command extends DataTransferObject {
+}

package/dist/core/domain/errors.d.ts

@@ -0,0 +1,18 @@
+/**
+ * What answers a use case's failure instead of raising it — sincpro_framework's error handlers.
+ *
+ *     project.addFeatureErrorHandler((error) => {
+ *       if (error instanceof IssueNotFound) return new ResponseEmpty();   // the answer
+ *       throw error;                                                     // the next handler
+ *     });
+ *
+ * Context: three chains per bounded context — global (around `project.execute`), feature and
+ * application service —, each run first-registered-first. A handler that throws hands what it
+ * threw to the next; the last one's throw reaches the caller. The failure was already recorded
+ * where it happened (its span, its log line and, when unexpected, its report): a handler decides
+ * the answer, not whether it is observed. A handler that only watches must end with `throw`:
+ * what it returns is the answer.
+ */
+export type ErrorHandler = (error: unknown) => unknown;
+/** An error's class, as `expectErrors` names it. */
+export type ErrorClass = abstract new (...args: never[]) => unknown;

package/dist/core/domain/errors.js

@@ -0,0 +1 @@
+export {};

package/dist/core/domain/services.d.ts

@@ -0,0 +1,37 @@
+import type { ContextValues } from "../../context/domain/store.js";
+import type { FeatureBus } from "./bus.js";
+import type { Command } from "./dto.js";
+import type { LayerLogger } from "../../observability/domain/logging.js";
+import type { Span } from "../../observability/domain/tracing.js";
+/**
+ * The services of the application layer, as sincpro_framework's: a Feature executes one
+ * registered Command; an ApplicationService composes its context's Features.
+ *
+ *     @project.feature(CommandCancelIssue)
+ *     class CancelIssue extends Feature<CommandCancelIssue, ResponseCancelIssue> {
+ *       static readonly serviceName = "CancelIssue";
+ *       async execute(command: CommandCancelIssue) {
+ *         this.logger.info("Cancelling");                 // bound to this run
+ *         return new ResponseCancelIssue(await this.client.cancelIssue(command));
+ *       }
+ *     }
+ *
+ * Context: while a method runs, `this.context`, `this.span`, `this.logger`, `this.featureBus` and
+ * every dependency are that run's (`executeService`). `serviceName` is stable metadata, never
+ * `constructor.name`, which a minifier renames.
+ */
+export declare abstract class Feature<C extends Command<R>, R, Context extends object = ContextValues> {
+    /** What this run reads: the process's context, its bounded context's, its scope's. */
+    readonly context: Readonly<Partial<Context>>;
+    /** This run's span: `this.span.set({...})` says more about the use case. */
+    readonly span: Span;
+    /** This run's logger: every line carries its use case, execution and trace. */
+    readonly logger: LayerLogger;
+    abstract execute(command: C): R | Promise<R>;
+}
+export declare abstract class ApplicationService<C extends Command<R>, R, Context extends object = ContextValues> extends Feature<C, R, Context> {
+    /** The context's Features, run as children of this execution. */
+    protected readonly featureBus: FeatureBus;
+}
+/** @internal — what a run finds on `this` that no dependency may take. */
+export declare const RESERVED_MEMBERS: ReadonlySet<string>;