@sincpro/client-framework 0.5.0 → 1.0.0

package/dist/core/entrypoint/screens.js

@@ -0,0 +1,136 @@
+import { Command } from "../domain/dto.js";
+import { Feature } from "../domain/services.js";
+import { BoundedContext } from "./bounded-context.js";
+class List extends Command {
+    route;
+    criteria;
+    signal;
+    options;
+    constructor(route, criteria, signal, options) {
+        super();
+        this.route = route;
+        this.criteria = criteria;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class Get extends Command {
+    route;
+    signal;
+    options;
+    constructor(route, signal, options) {
+        super();
+        this.route = route;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class Read extends Command {
+    route;
+    signal;
+    options;
+    constructor(route, signal, options) {
+        super();
+        this.route = route;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class Export extends Command {
+    route;
+    signal;
+    options;
+    constructor(route, signal, options) {
+        super();
+        this.route = route;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class Send extends Command {
+    method;
+    route;
+    body;
+    signal;
+    options;
+    constructor(method, route, body, signal, options) {
+        super();
+        this.method = method;
+        this.route = route;
+        this.body = body;
+        this.signal = signal;
+        this.options = options;
+    }
+}
+class EntityList extends Feature {
+    static serviceName = "EntityReads.list";
+    execute(dto) {
+        this.span.set({ "http.route": dto.route });
+        return this.transport.list(dto.route, dto.criteria, dto.signal, dto.options);
+    }
+}
+class EntityGet extends Feature {
+    static serviceName = "EntityReads.one";
+    execute(dto) {
+        this.span.set({ "http.route": dto.route });
+        return this.transport.one(dto.route, dto.signal, dto.options);
+    }
+}
+class EntityRead extends Feature {
+    static serviceName = "EntityReads.read";
+    execute(dto) {
+        this.span.set({ "http.route": dto.route });
+        const transport = this.transport;
+        if (!transport.read) {
+            return Promise.reject(new Error(`this transport cannot read ${dto.route}: it has no read()`));
+        }
+        return transport.read(dto.route, dto.signal, dto.options);
+    }
+}
+class EntityExport extends Feature {
+    static serviceName = "EntityReads.download";
+    execute(dto) {
+        this.span.set({ "http.route": dto.route });
+        const transport = this.transport;
+        if (!transport.download) {
+            return Promise.reject(new Error(`this transport cannot download ${dto.route}: it has no download()`));
+        }
+        return transport.download(dto.route, dto.signal, dto.options);
+    }
+}
+class EntitySend extends Feature {
+    static serviceName = "EntityWrites.send";
+    execute(dto) {
+        this.span.set({ "http.method": dto.method, "http.route": dto.route });
+        return this.transport.send(dto.method, dto.route, dto.body, dto.signal, dto.options);
+    }
+}
+const MADE = new WeakSet();
+/**
+ * Screen requests enter the same command pipeline as application services. A generated
+ * client injected into a Feature uses its raw transport instead, continuing that execution.
+ */
+export function screensTransport(transport, name = "screens") {
+    if (MADE.has(transport))
+        return transport;
+    const screens = new BoundedContext(name);
+    screens.addDependency("transport", transport);
+    screens.feature(List)(EntityList);
+    screens.feature(Get)(EntityGet);
+    screens.feature(Read)(EntityRead);
+    screens.feature(Export)(EntityExport);
+    screens.feature(Send)(EntitySend);
+    const through = {
+        list: (route, criteria, signal, options) => screens.execute(new List(route, criteria, signal, options)),
+        one: (route, signal, options) => screens.execute(new Get(route, signal, options)),
+        send: (method, route, body, signal, options) => screens.execute(new Send(method, route, body, signal, options)),
+    };
+    if (transport.read) {
+        through.read = (route, signal, options) => screens.execute(new Read(route, signal, options));
+    }
+    if (transport.download) {
+        through.download = (route, signal, options) => screens.execute(new Export(route, signal, options));
+    }
+    MADE.add(through);
+    return through;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The application core (`./core`): the backend's application abstractions — class Commands and
+ * Responses, Features and ApplicationServices, a bounded context that is their bus, its error
+ * handlers — and the process they run in.
+ *
+ *   domain/          DTOs, the bus, the service bases, the error-handler contract
+ *   services/        the execution pipeline, dependency binding, the handler chain
+ *   entrypoint/      `BoundedContext`, `screensTransport`
+ *   infrastructure/  `configureProcess`, `configureLogger`
+ */
+export { type CommandBus, FeatureBus } from "./domain/bus.js";
+export { Command, DataTransferObject, Response, } from "./domain/dto.js";
+export type { ErrorClass, ErrorHandler } from "./domain/errors.js";
+export { ApplicationService, Feature } from "./domain/services.js";
+export { BoundedContext } from "./entrypoint/bounded-context.js";
+export { screensTransport } from "./entrypoint/screens.js";
+export { configureLogger, configureProcess, type LoggerConfiguration, type ProcessOptions, } from "./infrastructure/process.js";

package/dist/core/index.js

@@ -0,0 +1,16 @@
+/**
+ * The application core (`./core`): the backend's application abstractions — class Commands and
+ * Responses, Features and ApplicationServices, a bounded context that is their bus, its error
+ * handlers — and the process they run in.
+ *
+ *   domain/          DTOs, the bus, the service bases, the error-handler contract
+ *   services/        the execution pipeline, dependency binding, the handler chain
+ *   entrypoint/      `BoundedContext`, `screensTransport`
+ *   infrastructure/  `configureProcess`, `configureLogger`
+ */
+export { FeatureBus } from "./domain/bus.js";
+export { Command, DataTransferObject, Response, } from "./domain/dto.js";
+export { ApplicationService, Feature } from "./domain/services.js";
+export { BoundedContext } from "./entrypoint/bounded-context.js";
+export { screensTransport } from "./entrypoint/screens.js";
+export { configureLogger, configureProcess, } from "./infrastructure/process.js";

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

@@ -0,0 +1,56 @@
+import type { ContextStore } from "../../context/domain/store.js";
+import { type ConsoleLoggerOptions } from "../../observability/adapters/console.js";
+import type { ErrorReporter } from "../../observability/domain/errors.js";
+import type { Logger } from "../../observability/domain/logging.js";
+import { type Outcome, type Tracer } from "../../observability/domain/tracing.js";
+/**
+ * Where logs go: the console by default, any `Logger` otherwise, or nowhere.
+ *
+ *     { mode: "development", level: "info", layers: { adapter: false } }   // the console, filtered
+ *     { mode: "production" }                                               // the console, silent
+ *     { engine: combineLoggers(consoleLogger({ mode }), lokiLogger) }       // the platform's sinks
+ *     { engine: false }                                                    // no logs
+ *
+ * Context: one shape for both doors — `configureProcess({ logger })`, which replaces everything,
+ * and `configureLogger(...)`, which replaces only logging (a debug switch on a phone). `mode`,
+ * `level` and `layers` configure the console engine; a supplied `engine` owns its own policy.
+ */
+export type LoggerConfiguration = Partial<ConsoleLoggerOptions> & {
+    engine?: Logger | false;
+};
+/**
+ * What every bounded context of this process runs with — set once, in `main`, the way
+ * sincpro_framework's process is: who traces, who reports, where logs go, where the context lives.
+ *
+ *     // entrypoints/main.tsx — the platform's pieces, built from the application's settings
+ *     configureProcess({
+ *       tracer: browserTracer({ endpoint: settings.otlp, service: "forge-web" }),
+ *       reporter: glitchtipReporter({ dsn: settings.glitchtip }),
+ *       logger: { mode: settings.production ? "production" : "development" },
+ *       context: memoryContexts(),
+ *     });
+ *
+ * Context: everything is optional, and nothing breaks without it. A process that never configures
+ * runs untraced and unreported, with memory context and development console logging — so a bounded
+ * context is usable the moment it is imported, and `main` adds what it watches with. The bounded
+ * contexts read the process on every call, never at import: `project` may be defined before `main`
+ * runs.
+ *
+ * It replaces everything at once: what is not given goes back to its default — a test calls it
+ * with its own tracer and starts from a clean context.
+ */
+export type ProcessOptions = {
+    /** The platform's (OpenTelemetry in a browser, a queue on a phone, memory in a test). */
+    tracer?: Tracer;
+    /** The platform's (GlitchTip, Sentry, memory in a test). Only what nobody expected reaches it. */
+    reporter?: ErrorReporter;
+    /** Where logs go (`LoggerConfiguration`); the console in development mode by default. */
+    logger?: LoggerConfiguration;
+    /** Where the context lives (`memoryContexts()` by default). */
+    context?: ContextStore;
+    /** How an error ended a use case (`outcomeOf` by default). Only `failed` is reported. */
+    outcomeOf?: (error: unknown) => Outcome;
+};
+export declare function configureProcess(options?: ProcessOptions): void;
+/** Replace logging only; tracing, reporting and the context stay as they are. */
+export declare function configureLogger(options?: LoggerConfiguration): void;

package/dist/core/infrastructure/process.js

@@ -0,0 +1,35 @@
+import { memoryContexts } from "../../context/adapters/memory.js";
+import { replaceProcessStore } from "../../context/infrastructure/process.js";
+import { consoleLogger, } from "../../observability/adapters/console.js";
+import { NO_TRACER, } from "../../observability/domain/tracing.js";
+import { replaceObservability } from "../../observability/infrastructure/registry.js";
+import { outcomeOf } from "../../observability/services/outcome.js";
+function loggingEngine(options) {
+    if (options.engine === false)
+        return undefined;
+    if (options.engine !== undefined) {
+        if (!options.engine || typeof options.engine.log !== "function") {
+            throw new TypeError("Logger engine must implement log(record)");
+        }
+        return options.engine;
+    }
+    return consoleLogger({
+        mode: options.mode ?? "development",
+        ...(options.level ? { level: options.level } : {}),
+        ...(options.layers ? { layers: options.layers } : {}),
+    });
+}
+export function configureProcess(options = {}) {
+    const logger = loggingEngine(options.logger ?? {});
+    replaceObservability({
+        tracer: options.tracer ?? NO_TRACER,
+        reporter: options.reporter,
+        logger,
+        outcomeOf: options.outcomeOf ?? outcomeOf,
+    });
+    replaceProcessStore(options.context ?? memoryContexts());
+}
+/** Replace logging only; tracing, reporting and the context stay as they are. */
+export function configureLogger(options = {}) {
+    replaceObservability({ logger: loggingEngine(options) });
+}

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

@@ -0,0 +1,6 @@
+import { type Execution } from "../../context/domain/execution.js";
+/**
+ * A dependency as the execution should see it: bound when it can be (`BIND`, or a `Transport`),
+ * as it is otherwise.
+ */
+export declare function bindDependency<T>(value: T, execution: Execution): T;

package/dist/core/services/binding.js

@@ -0,0 +1,13 @@
+import { bindTransport, isTransport, } from "../../client/services/propagation.js";
+import { BIND, isBindable, } from "../../context/domain/execution.js";
+/**
+ * A dependency as the execution should see it: bound when it can be (`BIND`, or a `Transport`),
+ * as it is otherwise.
+ */
+export function bindDependency(value, execution) {
+    if (isBindable(value))
+        return value[BIND](execution);
+    if (isTransport(value))
+        return bindTransport(value, execution);
+    return value;
+}

package/dist/core/services/error-handlers.d.ts

@@ -0,0 +1,11 @@
+import type { ErrorHandler } from "../domain/errors.js";
+/**
+ * The answer of a chain of error handlers to `error`, or what its last handler threw.
+ *
+ *     await handled([toEmpty, logAndRethrow], new IssueNotFound())   ->  toEmpty's answer
+ *
+ * 1. Each handler, first-registered-first, receives what the one before it threw.
+ * Final: the first answer; when every handler threw, the last thrown — the original error when
+ *    there is no handler at all.
+ */
+export declare function handled(handlers: readonly ErrorHandler[], error: unknown): Promise<unknown>;

package/dist/core/services/error-handlers.js

@@ -0,0 +1,21 @@
+/**
+ * The answer of a chain of error handlers to `error`, or what its last handler threw.
+ *
+ *     await handled([toEmpty, logAndRethrow], new IssueNotFound())   ->  toEmpty's answer
+ *
+ * 1. Each handler, first-registered-first, receives what the one before it threw.
+ * Final: the first answer; when every handler threw, the last thrown — the original error when
+ *    there is no handler at all.
+ */
+export async function handled(handlers, error) {
+    let current = error;
+    for (const handler of handlers) {
+        try {
+            return await handler(current);
+        }
+        catch (thrown) {
+            current = thrown;
+        }
+    }
+    throw current;
+}

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

@@ -0,0 +1,35 @@
+import type { Execution } from "../../context/domain/execution.js";
+import type { ContextValues } from "../../context/domain/store.js";
+import type { ErrorHandler } from "../domain/errors.js";
+export interface RuntimeService {
+    execute(command: object): unknown;
+}
+type Layer = "feature" | "application_service";
+export interface ExecutionOptions {
+    readonly boundedContext: string;
+    readonly name: string;
+    readonly layer: Layer;
+    readonly dependencies: ReadonlyMap<string, unknown>;
+    readonly context: () => ContextValues;
+    readonly parent?: Execution;
+    readonly featureBus: (execution: Execution) => object;
+    /** The bounded context's expected errors: they end `refused`, never reported. */
+    readonly expected: (error: unknown) => boolean;
+    /** The bounded context's handlers for this layer: what answers a failure instead of raising it. */
+    readonly handlers: readonly ErrorHandler[];
+}
+/**
+ * One pipeline for every registered Feature and ApplicationService.
+ *
+ * 1. A span `<bounded context>/<serviceName>`, a child of the parent run when there is one, and
+ *    the execution every dependency, `this.logger` and child Feature are bound to.
+ * 2. The service runs, seeing that execution through its own view of the instance.
+ * 3. A failure is observed where it happened: its outcome (expected by the bounded context →
+ *    `refused`, else the process's `outcomeOf`), the span closed with it, its log line and —
+ *    when `failed`, and only once per error along the run — its report.
+ * 4. Then the layer's error handlers answer it, in order; with none, or when the last throws,
+ *    the error reaches the caller.
+ * Final: the service's answer, or its handlers'.
+ */
+export declare function executeService(target: RuntimeService, command: object, options: ExecutionOptions): Promise<unknown>;
+export {};

package/dist/core/services/execution.js

@@ -0,0 +1,137 @@
+import { newEntityId } from "../../common/ids.js";
+import { bindDependency } from "./binding.js";
+import { handled } from "./error-handlers.js";
+import { NO_TRACER, } from "../../observability/domain/tracing.js";
+import { observabilityNow } from "../../observability/infrastructure/registry.js";
+import { executionLogger, logExecution, logHandled, } from "../../observability/services/logging.js";
+import { firstReport } from "../../observability/services/reporting.js";
+const REPORTED_BY_EXECUTION = new WeakMap();
+/** Observability adapters are best-effort; their failures must not replace a business result. */
+function observe(work, fallback) {
+    try {
+        return work();
+    }
+    catch {
+        return fallback;
+    }
+}
+function serviceView(target, options, execution) {
+    const dependencies = new Map();
+    const logger = executionLogger(options.layer, execution);
+    let features;
+    return new Proxy(target, {
+        get(held, property, receiver) {
+            if (property === "context")
+                return execution.context;
+            if (property === "span")
+                return execution.span;
+            if (property === "logger")
+                return logger;
+            if (property === "featureBus" && options.layer === "application_service") {
+                return (features ??= options.featureBus(execution));
+            }
+            if (typeof property === "string" && options.dependencies.has(property)) {
+                if (!dependencies.has(property)) {
+                    dependencies.set(property, bindDependency(options.dependencies.get(property), execution));
+                }
+                return dependencies.get(property);
+            }
+            if (Reflect.has(held, property))
+                return Reflect.get(held, property, receiver);
+            if (typeof property === "string") {
+                throw new Error(`${options.boundedContext}: dependency or member is not registered: ${property}`);
+            }
+            return undefined;
+        },
+        set(held, property, value) {
+            if (property === "context" ||
+                property === "span" ||
+                property === "logger" ||
+                property === "featureBus" ||
+                (typeof property === "string" && options.dependencies.has(property))) {
+                throw new Error(`Execution dependencies and context are read-only: ${String(property)}`);
+            }
+            return Reflect.set(held, property, value);
+        },
+    });
+}
+/**
+ * One pipeline for every registered Feature and ApplicationService.
+ *
+ * 1. A span `<bounded context>/<serviceName>`, a child of the parent run when there is one, and
+ *    the execution every dependency, `this.logger` and child Feature are bound to.
+ * 2. The service runs, seeing that execution through its own view of the instance.
+ * 3. A failure is observed where it happened: its outcome (expected by the bounded context →
+ *    `refused`, else the process's `outcomeOf`), the span closed with it, its log line and —
+ *    when `failed`, and only once per error along the run — its report.
+ * 4. Then the layer's error handlers answer it, in order; with none, or when the last throws,
+ *    the error reaches the caller.
+ * Final: the service's answer, or its handlers'.
+ */
+export async function executeService(target, command, options) {
+    const ports = observabilityNow();
+    const startedAt = Date.now();
+    const useCase = `${options.boundedContext}.${options.name}`;
+    const context = options.parent?.context ?? options.context();
+    const id = newEntityId();
+    const attributes = {
+        "sincpro.use_case": useCase,
+        "sincpro.layer": options.layer,
+        "sincpro.context": options.boundedContext,
+        "sincpro.execution_id": id,
+    };
+    const span = observe(() => ports.tracer.start(`${options.boundedContext}/${options.name}`, {
+        ...(options.parent ? { parent: options.parent.span } : {}),
+        attributes,
+    }), NO_TRACER.start(useCase, {}));
+    const execution = {
+        id,
+        useCase,
+        boundedContext: options.boundedContext,
+        parent: options.parent,
+        span,
+        context,
+    };
+    const reported = options.parent
+        ? (REPORTED_BY_EXECUTION.get(options.parent) ?? new Set())
+        : new Set();
+    REPORTED_BY_EXECUTION.set(execution, reported);
+    logExecution(options.layer, execution);
+    const finish = (error) => {
+        const outcome = error
+            ? observe(() => (options.expected(error.value) ? "refused" : ports.outcomeOf(error.value)), "failed")
+            : "ok";
+        observe(() => span.end(outcome, error?.value), undefined);
+        logExecution(options.layer, execution, {
+            outcome,
+            durationMs: Math.max(0, Date.now() - startedAt),
+        });
+        if (outcome === "failed" && error && ports.reporter && !reported.has(error.value)) {
+            reported.add(error.value);
+            // Mark for reportError outside the call; a different root may report the same Error.
+            firstReport(error.value);
+            observe(() => ports.reporter?.report(error.value, {
+                useCase,
+                traceId: span.traceId,
+                executionId: id,
+                context,
+            }), undefined);
+        }
+    };
+    let answer;
+    try {
+        answer = await Reflect.apply(target.execute, serviceView(target, options, execution), [
+            command,
+        ]);
+    }
+    catch (error) {
+        finish({ value: error });
+        if (options.handlers.length === 0)
+            throw error;
+        const recovered = await handled(options.handlers, error);
+        logHandled(options.layer, { execution });
+        return recovered;
+    }
+    finish();
+    return answer;
+}

package/dist/index.d.ts

@@ -3,43 +3,23 @@
  * service needs, on any platform.
  *
  * Context: one entry, not one per area — the package has no side effects at import
- * (`sideEffects: false`), so an application pays only for what it uses, and a use case, the
- * client it calls and the entity it reads come from the same place.
+ * (`sideEffects: false`), so an application pays only for what it uses. Each module is laid out
+ * as sincpro_framework's are — `domain/` (ports and rules), `adapters/` (their implementations),
+ * `services/`, `infrastructure/`, `entrypoint/` — and says what it offers in its own `index.ts`:
  *
- *   common/   the values of the wire, as the backend writes them: ids, a day and an instant,
- *             `Decimal`, `Money`, and how any value is written and read (`valuesOf`, `rebuilt`)
- *   client/   the seam with a server: the transport and its REST and in-memory implementations,
- *             entities with typed commands, the service's client contract
- *   model/    model definitions: written by hand, read from a JSON Schema, kept once known
- *   services/ the bounded context (`UseBoundedContext`), its `Feature` and `ApplicationService`,
- *             the process they run in (`configureProcess`), what each run carries
- *   context/  the context: one door (`Context`) over the store each platform plugs
- *   observability/  the ports a platform plugs: a tracer and an error reporter
+ *   common/         the values of the wire, as the backend writes them
+ *   context/        the context's levels, where they live, what travels, the execution
+ *   observability/  tracing, error reporting and logging: ports, console, loggers
+ *   client/         the seam with a server: transports, entities, the client contract
+ *   model/          model definitions
+ *   core/           Commands, Features, ApplicationServices, BoundedContext, the process
  *
- * The generator is `@sincpro/client-framework/codegen`, and the in-memory tracer and reporter
+ * The generator is `@sincpro/client-framework/codegen`, and the in-memory observability
  * `@sincpro/client-framework/testing`: neither is part of what an application runs.
  */
-export { type ClientContract, entityKeyOf, kindOf, metasOf, versionsOf, } from "./client/contract.js";
-export { bodyFor, type CommandAnswers, type CommandBodies, type CommandRoute, type Entity, entity, type EntityRef, type EntityRoutes, listRoute, NEW_PARAM, pathFor, PICK_PARAM, QUERY_PARAM, SCOPE_PARAM, scopeOfRef, startingValuesOf, type SummaryFields, type SummaryPart, TRAIL_PARAM, WITH_PARAM, type WriteRoute, writeRoute, } from "./client/entity.js";
-export { type MemoryOptions, type MemoryTable, memoryTransport, } from "./client/memory.js";
-export { type RestOptions, restTransport, urlOf, type VersionDrift, } from "./client/rest.js";
-export { type RetryKeys, retryKeys, unanswered, } from "./client/retry.js";
-export { type CallOptions, type Draft, type Method, type One, readRoute, type SendOptions, type Transport, TransportError, } from "./client/transport.js";
-export { Decimal, type DecimalLike } from "./common/decimal.js";
-export { isEntityId, momentOf, newEntityId } from "./common/ids.js";
-export { Money } from "./common/money.js";
-export { BYTES, type JsonValue, pack, readValues, type Rebuild, rebuilt, unpack, valuesOf, } from "./common/serialization.js";
-export { dayOf, installTimeZone, instantOf, isDay, timeZoneNow, wallTimeOf, } from "./common/time.js";
-export { CONTEXT_HEADER, type ContextCodec, plainCodec, travelling, travels, } from "./context/codec.js";
-export { type Context } from "./context/context.js";
-export { type ContextStore, type ContextValues, memoryContexts, } from "./context/store.js";
-export { defineMeta, field, type FieldOptions, type MetaSpec, type Words, } from "./model/meta.js";
-export { type MetaStore, metaStore } from "./model/metas.js";
-export { completeMeta, type JsonSchema, metaFromSchema, type SchemaComponents, } from "./model/schema.js";
-export { type Attributes, type ErrorAbout, type ErrorReporter, NO_TRACER, type Outcome, type Span, type Tracer, } from "./observability/ports.js";
-export { type BoundedContext, UseBoundedContext, } from "./services/bounded-context.js";
-export { BIND, type Bindable, bindable, bindDependency, bindTransport, type Execution, headersOf, } from "./services/execution.js";
-export { ApplicationService, Feature, type ServiceClasses, type ServiceMethods, type Services, } from "./services/feature.js";
-export { configureProcess, outcomeOf, processContext, type ProcessOptions, } from "./services/process.js";
-export { reportError } from "./services/report.js";
-export { screensTransport } from "./services/screens.js";
+export * from "./client/index.js";
+export * from "./common/index.js";
+export * from "./context/index.js";
+export * from "./core/index.js";
+export * from "./model/index.js";
+export * from "./observability/index.js";

package/dist/index.js

@@ -3,43 +3,23 @@
  * service needs, on any platform.
  *
  * Context: one entry, not one per area — the package has no side effects at import
- * (`sideEffects: false`), so an application pays only for what it uses, and a use case, the
- * client it calls and the entity it reads come from the same place.
+ * (`sideEffects: false`), so an application pays only for what it uses. Each module is laid out
+ * as sincpro_framework's are — `domain/` (ports and rules), `adapters/` (their implementations),
+ * `services/`, `infrastructure/`, `entrypoint/` — and says what it offers in its own `index.ts`:
  *
- *   common/   the values of the wire, as the backend writes them: ids, a day and an instant,
- *             `Decimal`, `Money`, and how any value is written and read (`valuesOf`, `rebuilt`)
- *   client/   the seam with a server: the transport and its REST and in-memory implementations,
- *             entities with typed commands, the service's client contract
- *   model/    model definitions: written by hand, read from a JSON Schema, kept once known
- *   services/ the bounded context (`UseBoundedContext`), its `Feature` and `ApplicationService`,
- *             the process they run in (`configureProcess`), what each run carries
- *   context/  the context: one door (`Context`) over the store each platform plugs
- *   observability/  the ports a platform plugs: a tracer and an error reporter
+ *   common/         the values of the wire, as the backend writes them
+ *   context/        the context's levels, where they live, what travels, the execution
+ *   observability/  tracing, error reporting and logging: ports, console, loggers
+ *   client/         the seam with a server: transports, entities, the client contract
+ *   model/          model definitions
+ *   core/           Commands, Features, ApplicationServices, BoundedContext, the process
  *
- * The generator is `@sincpro/client-framework/codegen`, and the in-memory tracer and reporter
+ * The generator is `@sincpro/client-framework/codegen`, and the in-memory observability
  * `@sincpro/client-framework/testing`: neither is part of what an application runs.
  */
-export { entityKeyOf, kindOf, metasOf, versionsOf, } from "./client/contract.js";
-export { bodyFor, entity, listRoute, NEW_PARAM, pathFor, PICK_PARAM, QUERY_PARAM, SCOPE_PARAM, scopeOfRef, startingValuesOf, TRAIL_PARAM, WITH_PARAM, writeRoute, } from "./client/entity.js";
-export { memoryTransport, } from "./client/memory.js";
-export { restTransport, urlOf, } from "./client/rest.js";
-export { retryKeys, unanswered, } from "./client/retry.js";
-export { readRoute, TransportError, } from "./client/transport.js";
-export { Decimal } from "./common/decimal.js";
-export { isEntityId, momentOf, newEntityId } from "./common/ids.js";
-export { Money } from "./common/money.js";
-export { BYTES, pack, readValues, rebuilt, unpack, valuesOf, } from "./common/serialization.js";
-export { dayOf, installTimeZone, instantOf, isDay, timeZoneNow, wallTimeOf, } from "./common/time.js";
-export { CONTEXT_HEADER, plainCodec, travelling, travels, } from "./context/codec.js";
-export {} from "./context/context.js";
-export { memoryContexts, } from "./context/store.js";
-export { defineMeta, field, } from "./model/meta.js";
-export { metaStore } from "./model/metas.js";
-export { completeMeta, metaFromSchema, } from "./model/schema.js";
-export { NO_TRACER, } from "./observability/ports.js";
-export { UseBoundedContext, } from "./services/bounded-context.js";
-export { BIND, bindable, bindDependency, bindTransport, headersOf, } from "./services/execution.js";
-export { ApplicationService, Feature, } from "./services/feature.js";
-export { configureProcess, outcomeOf, processContext, } from "./services/process.js";
-export { reportError } from "./services/report.js";
-export { screensTransport } from "./services/screens.js";
+export * from "./client/index.js";
+export * from "./common/index.js";
+export * from "./context/index.js";
+export * from "./core/index.js";
+export * from "./model/index.js";
+export * from "./observability/index.js";

package/dist/model/{meta.d.ts → domain/meta.d.ts}

@@ -69,6 +69,7 @@ export declare const field: {
         holds?: Expression | null;
         computes?: import("@sincpro/criteria").Formula | null;
         navigable?: boolean;
+        reference?: boolean;
         total?: string | null;
         many?: boolean;
         relation?: string | null;

package/dist/model/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Model definitions: written by hand (`defineMeta`), read from a JSON Schema, kept once known.
+ *
+ *   domain/          `defineMeta`, `field`
+ *   services/        `metaFromSchema`, `completeMeta`
+ *   infrastructure/  `metaStore`: the definitions already known
+ */
+export { defineMeta, field, type FieldOptions, type MetaSpec, type Words, } from "./domain/meta.js";
+export { type MetaStore, metaStore, } from "./infrastructure/metas.js";
+export { completeMeta, type JsonSchema, metaFromSchema, type SchemaComponents, } from "./services/schema.js";