@sincpro/client-framework 0.5.0 → 1.0.0

package/dist/model/index.js

@@ -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, } from "./domain/meta.js";
+export { metaStore, } from "./infrastructure/metas.js";
+export { completeMeta, metaFromSchema, } from "./services/schema.js";

package/dist/model/{metas.d.ts → infrastructure/metas.d.ts}

@@ -3,7 +3,7 @@ import type { Meta } from "@sincpro/criteria";
  * The model definitions already known, by entity key (`"billing:invoice"`).
  *
  * Context: sincpro_framework publishes each model once, in the discovery document the
- * transport reads (`core/discovery`); an answer carries only its version. This keeps the
+ * transport reads (`client/services/discovery`); an answer carries only its version. This keeps the
  * definitions ACROSS readings, so the second list of the same entity, the record opened from it
  * and the select that points at it draw their labels before the rows arrive.
  *

package/dist/model/{schema.d.ts → services/schema.d.ts}

@@ -3,7 +3,7 @@ import type { Meta } from "@sincpro/criteria";
  * A model definition read from a JSON Schema — what an OpenAPI document holds.
  *
  * Context: a model a READ answers is published by sincpro_framework as its contract — JSON
- * Schema with `x-sincpro` — and read by the transport (`metaFromContract`, `core/discovery`).
+ * Schema with `x-sincpro` — and read by the transport (`metaFromContract`, `client/services/discovery`).
  * What has no `x-sincpro` is a plain JSON Schema: a COMMAND's body, a value object it carries.
  *
  * So this reads such a component schema into a `Meta` — the form of a Command, a value object —

package/dist/model/{schema.js → services/schema.js}

@@ -1,4 +1,4 @@
-import { field } from "./meta.js";
+import { field } from "../domain/meta.js";
 const UNKNOWN = {
     type: "unknown",
     kind: "scalar",

package/dist/observability/adapters/console.d.ts

@@ -0,0 +1,12 @@
+import type { Logger, LogLayer, LogLevel } from "../domain/logging.js";
+export type ConsoleLoggerOptions = {
+    mode: "development" | "production";
+    /** Development INFO/DEBUG threshold. WARN/ERROR are never hidden by layer/level masks. */
+    level?: LogLevel;
+    layers?: Partial<Record<LogLayer, boolean>>;
+};
+/**
+ * Built-in console engine: silent in production, configurable
+ * development layers, and WARN/ERROR preserved. Other sinks are filtered independently.
+ */
+export declare function consoleLogger(options: ConsoleLoggerOptions): Logger;

package/dist/observability/adapters/console.js

@@ -0,0 +1,35 @@
+const RANK = { debug: 0, info: 1, warn: 2, error: 3 };
+/**
+ * Built-in console engine: silent in production, configurable
+ * development layers, and WARN/ERROR preserved. Other sinks are filtered independently.
+ */
+export function consoleLogger(options) {
+    const mode = options.mode;
+    if (mode !== "development" && mode !== "production") {
+        throw new TypeError("Console logger mode must be development or production");
+    }
+    const level = options.level ?? "debug";
+    if (!Object.hasOwn(RANK, level)) {
+        throw new TypeError("Console logger level must be debug, info, warn or error");
+    }
+    const layers = { ...options.layers };
+    return {
+        log(record) {
+            if (mode === "production")
+                return;
+            if (record.level !== "warn" && record.level !== "error") {
+                if (layers[record.layer] === false || RANK[record.level] < RANK[level])
+                    return;
+            }
+            const prefix = `${record.timestamp} [${record.layer}] ${record.level.toUpperCase()}`;
+            const method = record.level === "debug"
+                ? console.debug
+                : record.level === "warn"
+                    ? console.warn
+                    : record.level === "error"
+                        ? console.error
+                        : console.log;
+            method.call(console, prefix, record.message, record);
+        },
+    };
+}

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

@@ -0,0 +1,41 @@
+import type { ErrorAbout, ErrorReporter } from "../domain/errors.js";
+import type { Logger, LogRecord } from "../domain/logging.js";
+import type { Outcome, Tracer } from "../domain/tracing.js";
+/**
+ * Observability adapters that keep what they were told, so a test reads it back.
+ *
+ *     const tracer = memoryTracer();
+ *     configureProcess({ tracer });
+ *     await project.execute(new CommandCloseIssue("issue-1"));
+ *     tracer.spans.map((one) => one.name);   // ["project/CloseIssue", "project/Store", …]
+ *
+ * Context: a use case is proven in Node with nothing of a platform; these are the platform's
+ * part, held in memory. Not test doubles of this package — real implementations of its ports.
+ */
+/** A span as the memory tracer kept it. */
+export type RecordedSpan = {
+    name: string;
+    traceId: string;
+    spanId: string;
+    /** The span it was opened under, when it was. */
+    parentSpanId: string | undefined;
+    attributes: Record<string, string | number | boolean>;
+    /** How it ended; `undefined` while it is open. */
+    outcome: Outcome | undefined;
+    error: unknown;
+};
+export type MemoryTracer = Tracer & {
+    readonly spans: RecordedSpan[];
+};
+export declare function memoryTracer(): MemoryTracer;
+export type MemoryReporter = ErrorReporter & {
+    readonly reports: {
+        error: unknown;
+        about: ErrorAbout;
+    }[];
+};
+export declare function memoryReporter(): MemoryReporter;
+export type MemoryLogger = Logger & {
+    readonly records: LogRecord[];
+};
+export declare function memoryLogger(): MemoryLogger;

package/dist/observability/adapters/memory.js

@@ -0,0 +1,49 @@
+function hex(bytes) {
+    return Array.from(globalThis.crypto.getRandomValues(new Uint8Array(bytes)), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+export function memoryTracer() {
+    const spans = [];
+    return {
+        spans,
+        start(name, options) {
+            const recorded = {
+                name,
+                traceId: options.parent?.traceId || hex(16),
+                spanId: hex(8),
+                parentSpanId: options.parent?.spanId || undefined,
+                attributes: { ...options.attributes },
+                outcome: undefined,
+                error: undefined,
+            };
+            spans.push(recorded);
+            return {
+                traceId: recorded.traceId,
+                spanId: recorded.spanId,
+                sampled: true,
+                set: (attributes) => void Object.assign(recorded.attributes, attributes),
+                end: (outcome, error) => {
+                    if (recorded.outcome !== undefined)
+                        return;
+                    recorded.outcome = outcome;
+                    recorded.error = error;
+                },
+            };
+        },
+    };
+}
+export function memoryReporter() {
+    const reports = [];
+    return { reports, report: (error, about) => void reports.push({ error, about }) };
+}
+export function memoryLogger() {
+    const records = [];
+    return {
+        records,
+        log(record) {
+            records.push({
+                ...record,
+                ...(record.attributes ? { attributes: { ...record.attributes } } : {}),
+            });
+        },
+    };
+}

package/dist/{adapters → observability/adapters}/opentelemetry.d.ts

@@ -1,5 +1,5 @@
 import { type Tracer as OtelTracer } from "@opentelemetry/api";
-import type { Tracer } from "../observability/ports.js";
+import type { Tracer } from "../domain/tracing.js";
 /**
  * The `Tracer` port over OpenTelemetry's API: every use case a span of whatever provider the
  * platform registered.

package/dist/{adapters → observability/adapters}/sentry.d.ts

@@ -1,4 +1,4 @@
-import type { ErrorReporter } from "../observability/ports.js";
+import type { ErrorReporter } from "../domain/errors.js";
 /**
  * What this adapter needs of a Sentry-compatible client: its `captureException`. A browser's
  * `BrowserClient`, Node's, React Native's — and GlitchTip, which speaks Sentry's protocol.

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

@@ -0,0 +1,23 @@
+/**
+ * What a platform plugs to report what nobody expected.
+ *
+ * Context: the backend reports each unexpected failure once, with the use case and the trace it
+ * belongs to; GlitchTip, Sentry or memory in a test receive it here. A reporter that fails is
+ * ignored: telling about a failure never becomes a second one.
+ */
+/** What a report says about where the error happened. */
+export type ErrorAbout = {
+    /** `<bounded context>.<Service>`: the use case's identity, as the backend's — or, for what
+     *  failed outside one (`reportError`), where it happened (`view project:issue/acme-3`). */
+    useCase: string;
+    /** The trace the error belongs to — the same id the server logged, when it got that far. */
+    traceId: string;
+    /** The execution's own id. */
+    executionId: string;
+    /** What the use case ran with: the process's context, its bounded context's, its scope's. */
+    context: Readonly<Record<string, unknown>>;
+};
+/** Reports what nobody expected. One per platform; none when nothing reports. */
+export interface ErrorReporter {
+    report(error: unknown, about: ErrorAbout): void;
+}

package/dist/observability/domain/errors.js

@@ -0,0 +1,8 @@
+/**
+ * What a platform plugs to report what nobody expected.
+ *
+ * Context: the backend reports each unexpected failure once, with the use case and the trace it
+ * belongs to; GlitchTip, Sentry or memory in a test receive it here. A reporter that fails is
+ * ignored: telling about a failure never becomes a second one.
+ */
+export {};

package/dist/observability/domain/logging.d.ts

@@ -0,0 +1,42 @@
+import type { Attributes, Outcome } from "./tracing.js";
+/**
+ * What a platform plugs to receive structured logs: a sink (`Logger`) that owns filtering and
+ * delivery — the console by default, Loki, a phone's queue, memory in a test.
+ *
+ * Context: a line says which layer wrote it, the way sincpro_framework's architecture names
+ * them: the application layer (a bounded context and its ApplicationServices and Features,
+ * through `project.logger` and `this.logger`), its adapters (`loggerAdapter`) and the
+ * infrastructure around them (`logger`). A line written inside a use case carries that
+ * execution's identity; nothing writes a DTO, a response, an error body or the session's
+ * context on its own.
+ */
+export type LogLevel = "debug" | "info" | "warn" | "error";
+/** The layer a line comes from. */
+export type LogLayer = "infrastructure" | "adapter" | "bounded_context" | "application_service" | "feature";
+/** Structured logging never implicitly includes a DTO, response, error body or session context. */
+export type LogRecord = {
+    readonly timestamp: string;
+    readonly level: LogLevel;
+    readonly layer: LogLayer;
+    readonly message: string;
+    readonly attributes?: Attributes;
+    readonly event?: "execution.started" | "execution.finished" | "error.handled";
+    readonly boundedContext?: string;
+    readonly useCase?: string;
+    readonly executionId?: string;
+    readonly traceId?: string;
+    readonly spanId?: string;
+    readonly outcome?: Outcome;
+    readonly durationMs?: number;
+};
+/** A sink owns filtering and delivery. Logging is best-effort and never awaited by business work. */
+export interface Logger {
+    log(record: LogRecord): void | Promise<void>;
+}
+/** How code writes a line: the logger of a layer, of a bounded context, or of a run. */
+export interface LayerLogger {
+    debug(message: string, attributes?: Attributes): void;
+    info(message: string, attributes?: Attributes): void;
+    warn(message: string, attributes?: Attributes): void;
+    error(message: string, attributes?: Attributes): void;
+}

package/dist/observability/domain/logging.js

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

package/dist/observability/domain/tracing.d.ts

@@ -0,0 +1,49 @@
+/**
+ * What a platform plugs for execution traces: one span per use case.
+ *
+ * Context: sincpro_framework opens one span per use case; a client has to do the same, and
+ * continue the backend's trace. The vendor — OpenTelemetry in a browser, a queue on a phone,
+ * memory in a test — is the platform's, so this package defines the contract and calls it, and
+ * bundles none. Two implementations at least (a platform's and a test's) are why it is a port.
+ *
+ * Nothing here may break a use case: a tracer that fails is ignored, and the use case answers as
+ * it would have.
+ */
+/** What is said about a span: plain values only, the way OpenTelemetry takes them. */
+export type Attributes = Readonly<Record<string, string | number | boolean>>;
+/**
+ * How a use case ended.
+ *
+ * - `ok`: it answered.
+ * - `refused`: expected — the server said no and explained why (a validation, a conflict, a
+ *   permission), or the bounded context declared the error expected (`expectErrors`). Never
+ *   reported.
+ * - `aborted`: whoever asked stopped waiting (a screen that closed). Never reported.
+ * - `failed`: anything else — a bug, a server that broke, a server nobody could reach. Reported.
+ */
+export type Outcome = "ok" | "refused" | "aborted" | "failed";
+/** One span: a use case, open while it runs. */
+export interface Span {
+    /** 32 hex — the id the server continues and a person quotes as a support code. Empty when
+     *  nothing traces. */
+    readonly traceId: string;
+    /** 16 hex. Empty when nothing traces. */
+    readonly spanId: string;
+    /** Whether this trace is kept: the server follows the same decision. */
+    readonly sampled: boolean;
+    /** Vendor state that travels beside the trace (`tracestate`), when there is any. */
+    readonly state?: string;
+    /** Says more about the use case while it runs. */
+    set(attributes: Attributes): void;
+    /** Closes it, once. `error` is what it failed or was refused with. */
+    end(outcome: Outcome, error?: unknown): void;
+}
+/** Opens spans. One per platform; `NO_TRACER` when nothing traces. */
+export interface Tracer {
+    start(name: string, options: {
+        parent?: Span;
+        attributes?: Attributes;
+    }): Span;
+}
+/** Traces nothing: what a use case runs with until a platform plugs a tracer. */
+export declare const NO_TRACER: Tracer;

package/dist/observability/domain/tracing.js

@@ -0,0 +1,20 @@
+/**
+ * What a platform plugs for execution traces: one span per use case.
+ *
+ * Context: sincpro_framework opens one span per use case; a client has to do the same, and
+ * continue the backend's trace. The vendor — OpenTelemetry in a browser, a queue on a phone,
+ * memory in a test — is the platform's, so this package defines the contract and calls it, and
+ * bundles none. Two implementations at least (a platform's and a test's) are why it is a port.
+ *
+ * Nothing here may break a use case: a tracer that fails is ignored, and the use case answers as
+ * it would have.
+ */
+const EMPTY_SPAN = {
+    traceId: "",
+    spanId: "",
+    sampled: false,
+    set: () => undefined,
+    end: () => undefined,
+};
+/** Traces nothing: what a use case runs with until a platform plugs a tracer. */
+export const NO_TRACER = { start: () => EMPTY_SPAN };

package/dist/observability/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Observability: the ports a platform plugs (`Tracer`, `ErrorReporter`, `Logger`), the console
+ * engine logs go to by default, and how code writes and reports.
+ *
+ *   domain/          the ports: tracing, errors, logging
+ *   adapters/        console (default), memory (`./testing`), OpenTelemetry and Sentry (optional
+ *                    entries `./opentelemetry`, `./sentry`)
+ *   infrastructure/  the ports this process runs with (`configureProcess` plugs them)
+ *   services/        the loggers, `reportError`, the default `outcomeOf`
+ */
+export type { ErrorAbout, ErrorReporter, } from "./domain/errors.js";
+export type { LayerLogger, Logger, LogLayer, LogLevel, LogRecord, } from "./domain/logging.js";
+export { type Attributes, NO_TRACER, type Outcome, type Span, type Tracer, } from "./domain/tracing.js";
+export { combineLoggers, logger, loggerAdapter, } from "./services/logging.js";
+export { outcomeOf } from "./services/outcome.js";
+export { reportError } from "./services/reporting.js";

package/dist/observability/index.js

@@ -0,0 +1,4 @@
+export { NO_TRACER, } from "./domain/tracing.js";
+export { combineLoggers, logger, loggerAdapter, } from "./services/logging.js";
+export { outcomeOf } from "./services/outcome.js";
+export { reportError } from "./services/reporting.js";

package/dist/observability/infrastructure/registry.d.ts

@@ -0,0 +1,21 @@
+import type { ErrorReporter } from "../domain/errors.js";
+import type { Logger } from "../domain/logging.js";
+import { type Outcome, type Tracer } from "../domain/tracing.js";
+/**
+ * The observability this process runs with: who traces, who reports, where logs go and how an
+ * error ended a use case — the ports `configureProcess` plugged, read on every call.
+ *
+ * Context: sincpro_framework keeps the same state in its `observability_registry`, outside the
+ * buses, so a test resets everything with one call. Until a process configures, nothing traces,
+ * nothing reports, and logs go to the console in development mode.
+ */
+export type ObservabilityPorts = {
+    readonly tracer: Tracer;
+    readonly reporter: ErrorReporter | undefined;
+    readonly logger: Logger | undefined;
+    readonly outcomeOf: (error: unknown) => Outcome;
+};
+/** What the process observes with now. */
+export declare function observabilityNow(): ObservabilityPorts;
+/** @internal — `configureProcess` and `configureLogger` are the way in. */
+export declare function replaceObservability(ports: Partial<ObservabilityPorts>): void;

package/dist/observability/infrastructure/registry.js

@@ -0,0 +1,18 @@
+import { consoleLogger } from "../adapters/console.js";
+import { NO_TRACER, } from "../domain/tracing.js";
+import { outcomeOf } from "../services/outcome.js";
+const DEFAULTS = {
+    tracer: NO_TRACER,
+    reporter: undefined,
+    logger: consoleLogger({ mode: "development" }),
+    outcomeOf,
+};
+let current = DEFAULTS;
+/** What the process observes with now. */
+export function observabilityNow() {
+    return current;
+}
+/** @internal — `configureProcess` and `configureLogger` are the way in. */
+export function replaceObservability(ports) {
+    current = { ...current, ...ports };
+}

package/dist/observability/services/logging.d.ts

@@ -0,0 +1,27 @@
+import { type Execution } from "../../context/domain/execution.js";
+import type { LayerLogger, Logger, LogLayer } from "../domain/logging.js";
+import type { Outcome } from "../domain/tracing.js";
+/** The infrastructure's logger — the global one: the code that starts and holds the application. */
+export declare const logger: LayerLogger;
+/** The adapters' logger: what talks to a printer, a database, another system. */
+export declare const loggerAdapter: LayerLogger;
+/** @internal — a bounded context's own logger (`project.logger`). */
+export declare function boundedContextLogger(name: string): LayerLogger;
+/** @internal — what a Feature or ApplicationService finds as `this.logger` while it runs. */
+export declare function executionLogger(layer: "feature" | "application_service", execution: Execution): LayerLogger;
+/** Each destination keeps its own policy; one failing sink does not hold back the others. */
+export declare function combineLoggers(...loggers: readonly Logger[]): Logger;
+/** @internal — lifecycle records contain correlation and outcome, never business payloads. */
+export declare function logExecution(layer: "feature" | "application_service", execution: Execution, completed?: {
+    outcome: Outcome;
+    durationMs: number;
+}): void;
+/**
+ * @internal — an error a handler of the bounded context answered instead of raising: said once,
+ * with where it was handled, never with the error itself.
+ */
+export declare function logHandled(layer: LogLayer, correlation: {
+    execution: Execution;
+} | {
+    boundedContext: string;
+}): void;

package/dist/observability/services/logging.js

@@ -0,0 +1,105 @@
+import { BIND } from "../../context/domain/execution.js";
+import { observabilityNow } from "../infrastructure/registry.js";
+const processSink = () => observabilityNow().logger;
+/** Sink failures cannot replace a business outcome or cause unhandled async rejections. */
+function deliver(logger, record) {
+    if (!logger)
+        return;
+    try {
+        const pending = logger.log(record);
+        if (pending)
+            void Promise.resolve(pending).catch(() => { });
+    }
+    catch {
+        // Logging adapters are best-effort, as are tracing and error-reporting adapters.
+    }
+}
+function correlationOf(execution) {
+    return {
+        boundedContext: execution.boundedContext,
+        useCase: execution.useCase,
+        executionId: execution.id,
+        ...(execution.span.traceId ? { traceId: execution.span.traceId } : {}),
+        ...(execution.span.spanId ? { spanId: execution.span.spanId } : {}),
+    };
+}
+function layerLogger(layer, sink, correlation = {}) {
+    const write = (level, message, attributes) => {
+        deliver(sink(), {
+            timestamp: new Date().toISOString(),
+            level,
+            layer,
+            message,
+            ...(attributes ? { attributes: { ...attributes } } : {}),
+            ...correlation,
+        });
+    };
+    const logger = {
+        debug: (message, attributes) => write("debug", message, attributes),
+        info: (message, attributes) => write("info", message, attributes),
+        warn: (message, attributes) => write("warn", message, attributes),
+        error: (message, attributes) => write("error", message, attributes),
+    };
+    Object.defineProperty(logger, BIND, {
+        value: (run) => layerLogger(layer, sink, correlationOf(run)),
+        enumerable: false,
+    });
+    return logger;
+}
+/** The infrastructure's logger — the global one: the code that starts and holds the application. */
+export const logger = layerLogger("infrastructure", processSink);
+/** The adapters' logger: what talks to a printer, a database, another system. */
+export const loggerAdapter = layerLogger("adapter", processSink);
+/** @internal — a bounded context's own logger (`project.logger`). */
+export function boundedContextLogger(name) {
+    return layerLogger("bounded_context", processSink, { boundedContext: name });
+}
+/** @internal — what a Feature or ApplicationService finds as `this.logger` while it runs. */
+export function executionLogger(layer, execution) {
+    return layerLogger(layer, processSink, correlationOf(execution));
+}
+/** Each destination keeps its own policy; one failing sink does not hold back the others. */
+export function combineLoggers(...loggers) {
+    return {
+        log: (record) => {
+            for (const logger of loggers)
+                deliver(logger, record);
+        },
+    };
+}
+/** @internal — lifecycle records contain correlation and outcome, never business payloads. */
+export function logExecution(layer, execution, completed) {
+    const outcome = completed?.outcome;
+    const level = outcome === "failed"
+        ? "error"
+        : outcome === "refused"
+            ? "warn"
+            : completed
+                ? "info"
+                : "debug";
+    deliver(processSink(), {
+        timestamp: new Date().toISOString(),
+        level,
+        layer,
+        event: completed ? "execution.finished" : "execution.started",
+        message: completed ? `Execution ${completed.outcome}` : "Execution started",
+        ...correlationOf(execution),
+        ...(completed ? completed : {}),
+    });
+}
+/**
+ * @internal — an error a handler of the bounded context answered instead of raising: said once,
+ * with where it was handled, never with the error itself.
+ */
+export function logHandled(layer, correlation) {
+    deliver(processSink(), {
+        timestamp: new Date().toISOString(),
+        level: "info",
+        layer,
+        event: "error.handled",
+        message: "Error handled",
+        ...("execution" in correlation
+            ? correlationOf(correlation.execution)
+            : { boundedContext: correlation.boundedContext }),
+    });
+}

package/dist/observability/services/outcome.d.ts

@@ -0,0 +1,12 @@
+import type { Outcome } from "../domain/tracing.js";
+/**
+ * How an error ended a use case, by default.
+ *
+ * Context: the backend reports what nobody expected and only that — a refusal it explained is
+ * the business answering, not a fault. Here the same: a `TransportError` the server answered
+ * with a 4xx is `refused`; a request the caller stopped waiting for is `aborted`; everything
+ * else — a bug, a 5xx, a server nobody could reach — is `failed`, and reported. A bounded
+ * context adds its own expected errors (`expectErrors`); a process replaces this whole
+ * (`configureProcess({ outcomeOf })`).
+ */
+export declare function outcomeOf(error: unknown): Outcome;

package/dist/observability/services/outcome.js

@@ -0,0 +1,20 @@
+import { TransportError } from "../../client/domain/transport.js";
+/**
+ * How an error ended a use case, by default.
+ *
+ * Context: the backend reports what nobody expected and only that — a refusal it explained is
+ * the business answering, not a fault. Here the same: a `TransportError` the server answered
+ * with a 4xx is `refused`; a request the caller stopped waiting for is `aborted`; everything
+ * else — a bug, a 5xx, a server nobody could reach — is `failed`, and reported. A bounded
+ * context adds its own expected errors (`expectErrors`); a process replaces this whole
+ * (`configureProcess({ outcomeOf })`).
+ */
+export function outcomeOf(error) {
+    if (error instanceof TransportError && error.status !== null)
+        return error.status >= 400 && error.status < 500 ? "refused" : "failed";
+    if (error !== null &&
+        typeof error === "object" &&
+        error.name === "AbortError")
+        return "aborted";
+    return "failed";
+}

package/dist/{services/report.js → observability/services/reporting.js}

@@ -1,5 +1,6 @@
-import { newEntityId } from "../common/ids.js";
-import { processContext, processNow } from "./process.js";
+import { newEntityId } from "../../common/ids.js";
+import { processContext } from "../../context/infrastructure/process.js";
+import { observabilityNow } from "../infrastructure/registry.js";
 /**
  * Whether this is the first time this error is reported. A Feature that fails inside an
  * ApplicationService throws through it, and a screen that draws the failure may break on it:
@@ -28,7 +29,7 @@ export function firstReport(error) {
  * ignored: telling about a failure never becomes a second one.
  */
 export function reportError(error, where) {
-    const settings = processNow();
+    const settings = observabilityNow();
     try {
         // What the server explained, or what the caller stopped waiting for, is not a fault here either.
         if (settings.outcomeOf(error) !== "failed")

package/dist/testing/index.d.ts

@@ -1,35 +1,5 @@
-import type { ErrorAbout, ErrorReporter, Outcome, Tracer } from "../observability/ports.js";
 /**
- * A tracer and a reporter that keep what they were told, so a test reads it back.
- *
- *     const tracer = memoryTracer();
- *     configureProcess({ tracer });
- *     await project.CloseIssue.execute(input);
- *     tracer.spans.map((one) => one.name);   // ["project/CloseIssue", "project/Issues.close", …]
- *
- * Context: a use case is proven in Node with nothing of a platform; these are the platform's
- * part, held in memory. Not test doubles of this package — real implementations of its ports.
+ * `@sincpro/client-framework/testing`: the observability ports in memory, so a use case is
+ * proven in Node with nothing of a platform. Not part of what an application runs.
  */
-/** A span as the memory tracer kept it. */
-export type RecordedSpan = {
-    name: string;
-    traceId: string;
-    spanId: string;
-    /** The span it was opened under, when it was. */
-    parentSpanId: string | undefined;
-    attributes: Record<string, string | number | boolean>;
-    /** How it ended; `undefined` while it is open. */
-    outcome: Outcome | undefined;
-    error: unknown;
-};
-export type MemoryTracer = Tracer & {
-    readonly spans: RecordedSpan[];
-};
-export declare function memoryTracer(): MemoryTracer;
-export type MemoryReporter = ErrorReporter & {
-    readonly reports: {
-        error: unknown;
-        about: ErrorAbout;
-    }[];
-};
-export declare function memoryReporter(): MemoryReporter;
+export { type MemoryLogger, memoryLogger, type MemoryReporter, memoryReporter, type MemoryTracer, memoryTracer, type RecordedSpan, } from "../observability/adapters/memory.js";