@sincpro/client-framework 0.2.0 → 0.3.0

package/dist/context/context.d.ts

@@ -0,0 +1,45 @@
+import type { ContextStore, ContextValues } from "./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.
+ *
+ *     processContext.set({ tenant_id: "acme" });      the company changed — every screen hears it
+ *     processContext.get("tenant_id")                  →  "acme"
+ *     project.context.set({ warehouse_id: 4 });        only what `project` runs
+ *     const stop = processContext.watch(() => redraw());
+ *
+ * Context: sincpro_framework reads its context from a tree — the process, the bounded context,
+ * the scope, the execution — and the nearest wins. A client has the same levels: a use case runs
+ * with the process's values, under them its bounded context's, under them a scope's
+ * (`project.scoped({...})`), read once where the gesture starts and inherited by every Feature
+ * it runs. That snapshot is `this.context` and what travels to the server in `sincpro-context`.
+ *
+ * Where the values live is the platform's (`ContextStore`): this is only the door. `values` is
+ * the same object until something changes it, so a screen can hand it straight to React's
+ * `useSyncExternalStore`, and `watch` is bound — pass it as it is.
+ */
+export type Context<C extends object = ContextValues> = {
+    /** Its values now: the same object until they change. Never change it — `set` does. */
+    readonly values: Readonly<Partial<C>>;
+    get<K extends keyof C & string>(name: K): C[K] | undefined;
+    /** Adds or replaces these names; the others stay. */
+    set(values: Partial<C>): void;
+    /** Removes these names — every name when none is given. */
+    clear(...names: (keyof C & string)[]): void;
+    /** Calls `listener` whenever its values change; answers the way to stop. */
+    watch(listener: () => void): () => void;
+};
+/**
+ * Where a level finds its store: the one in use now, and word when another replaces it — the
+ * process's, which `configureProcess` may change after a screen started listening.
+ */
+export type StoreSource = {
+    current(): ContextStore;
+    replaced(listener: () => void): () => void;
+};
+/**
+ * The level saved under `key` in whatever store `source` holds now — asked again on every call,
+ * so a store the process configures after this level was made is the one used, and whoever
+ * listens moves to it and hears the change.
+ */
+export declare function contextAt<C extends object = ContextValues>(key: string, source: StoreSource): Context<C>;

package/dist/context/context.js

@@ -0,0 +1,70 @@
+const NOTHING = {};
+/**
+ * The level saved under `key` in whatever store `source` holds now — asked again on every call,
+ * so a store the process configures after this level was made is the one used, and whoever
+ * listens moves to it and hears the change.
+ */
+export function contextAt(key, source) {
+    const storeOf = () => source.current();
+    // The values last read, by store and version: a store that answers a new object on every
+    // `load` still gives one object per change.
+    let seen;
+    // Who listens when the store cannot say it changed (`watch` is optional).
+    const listeners = new Set();
+    const read = () => {
+        const store = storeOf();
+        const version = store.version(key);
+        if (seen?.store !== store || seen.version !== version)
+            seen = { store, version, values: store.load(key) ?? NOTHING };
+        return seen.values;
+    };
+    const write = (values) => {
+        const store = storeOf();
+        if (values === undefined)
+            store.delete(key);
+        else
+            store.save(key, values);
+        if (store.watch === undefined)
+            for (const listener of [...listeners])
+                listener();
+    };
+    return {
+        get values() {
+            return read();
+        },
+        get: (name) => read()[name],
+        set: (values) => write({ ...read(), ...values }),
+        clear(...names) {
+            if (names.length === 0)
+                return write(undefined);
+            const kept = { ...read() };
+            for (const name of names)
+                delete kept[name];
+            write(kept);
+        },
+        watch(listener) {
+            let watching;
+            let unwatch;
+            const follow = () => {
+                const store = storeOf();
+                if (store === watching)
+                    return;
+                unwatch?.();
+                watching = store;
+                unwatch = store.watch?.(key, listener);
+            };
+            follow();
+            listeners.add(listener);
+            // Another store is other values: listen to it, and say so.
+            const unreplaced = source.replaced(() => {
+                follow();
+                listener();
+            });
+            return () => {
+                unwatch?.();
+                unreplaced();
+                listeners.delete(listener);
+            };
+        },
+    };
+}

package/dist/context/store.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `ContextStore`: where the context lives — the port each platform implements with its own
+ * technology, so every use case reads the same context the same way.
+ *
+ *     store.save("process", { tenant_id: "acme", lang: "es" });
+ *     store.load("process")      →  { tenant_id: "acme", lang: "es" }     undefined when never saved
+ *     store.version("process")   →  1                                       0 when never saved
+ *     store.watch?.("process", () => …)                                     a change anywhere
+ *
+ * Context: sincpro_framework's `ContextStore` with the same four methods — the process's memory by
+ * default, a Redis when a project says so — and one more, optional, a client needs: `watch`, so
+ * a screen redraws when the tenant changes. The store never decides what the context is: it keeps
+ * values under a key (`process`, `bounded_context:<name>`), and `Context` reads and writes them.
+ *
+ * One per platform, chosen by the application (`configureProcess({ context })`):
+ *
+ * - `memoryContexts()` — this package's default, everywhere.
+ * - a browser: the same, or one over `sessionStorage` to survive a reload, or over the screens'
+ *   own store (Zustand, Redux) so they share one source.
+ * - a phone: MMKV (synchronous), or memory hydrated from AsyncStorage at start and written through.
+ * - a server that renders: one over `AsyncLocalStorage`, so two requests never see each other's.
+ *
+ * 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.
+ */
+/** What a context holds: plain values, the way JSON carries them to the server. */
+export type ContextValues = Readonly<Record<string, unknown>>;
+export interface ContextStore {
+    /** What `key` holds, or `undefined` when nothing was saved there. */
+    load(key: string): ContextValues | undefined;
+    /** `values` under `key`, replacing what was there. Each save moves the key's version. */
+    save(key: string, values: ContextValues): void;
+    /** `key` is gone. Its version moves too. */
+    delete(key: string): void;
+    /**
+     * How many times `key` changed — what a reader compares to know it changed. `load` may answer
+     * a new object each time (a store that parses JSON does); the version is what says it is new.
+     */
+    version(key: string): number;
+    /**
+     * Calls `listener` whenever `key` changes, from here or from elsewhere (another tab, a native
+     * module); answers the way to stop. Optional: without it, only the changes made through this
+     * package's `Context` are heard.
+     */
+    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

@@ -0,0 +1,59 @@
+/**
+ * `ContextStore`: where the context lives — the port each platform implements with its own
+ * technology, so every use case reads the same context the same way.
+ *
+ *     store.save("process", { tenant_id: "acme", lang: "es" });
+ *     store.load("process")      →  { tenant_id: "acme", lang: "es" }     undefined when never saved
+ *     store.version("process")   →  1                                       0 when never saved
+ *     store.watch?.("process", () => …)                                     a change anywhere
+ *
+ * Context: sincpro_framework's `ContextStore` with the same four methods — the process's memory by
+ * default, a Redis when a project says so — and one more, optional, a client needs: `watch`, so
+ * a screen redraws when the tenant changes. The store never decides what the context is: it keeps
+ * values under a key (`process`, `bounded_context:<name>`), and `Context` reads and writes them.
+ *
+ * One per platform, chosen by the application (`configureProcess({ context })`):
+ *
+ * - `memoryContexts()` — this package's default, everywhere.
+ * - a browser: the same, or one over `sessionStorage` to survive a reload, or over the screens'
+ *   own store (Zustand, Redux) so they share one source.
+ * - a phone: MMKV (synchronous), or memory hydrated from AsyncStorage at start and written through.
+ * - a server that renders: one over `AsyncLocalStorage`, so two requests never see each other's.
+ *
+ * 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);
+        },
+    };
+}

package/dist/index.d.ts

@@ -9,7 +9,9 @@
  *   client/   the seam with a server: the transport and its REST and in-memory implementations,
  *             entities with typed commands, the service's client contract, client-side ids
  *   model/    model definitions: written by hand, read from a JSON Schema, kept once known
- *   services/ Feature and ApplicationService, the runtime they run in, what each run carries
+ *   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
  *
  * The generator is `@sincpro/client-framework/codegen`, and the in-memory tracer and reporter
@@ -22,10 +24,13 @@ export { type MemoryOptions, type MemoryTable, memoryTransport, } from "./client
 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 { 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, bindServices, Feature, } from "./services/feature.js";
-export { createRuntime, DETACHED, outcomeOf, type Runtime, type RuntimeOptions, } from "./services/runtime.js";
+export { ApplicationService, Feature, type ServiceClasses, type ServiceMethods, type Services, } from "./services/feature.js";
+export { configureProcess, outcomeOf, processContext, type ProcessOptions, } from "./services/process.js";

package/dist/index.js

@@ -9,7 +9,9 @@
  *   client/   the seam with a server: the transport and its REST and in-memory implementations,
  *             entities with typed commands, the service's client contract, client-side ids
  *   model/    model definitions: written by hand, read from a JSON Schema, kept once known
- *   services/ Feature and ApplicationService, the runtime they run in, what each run carries
+ *   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
  *
  * The generator is `@sincpro/client-framework/codegen`, and the in-memory tracer and reporter
@@ -22,10 +24,13 @@ 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 {} 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, bindServices, Feature, } from "./services/feature.js";
-export { createRuntime, DETACHED, outcomeOf, } from "./services/runtime.js";
+export { ApplicationService, Feature, } from "./services/feature.js";
+export { configureProcess, outcomeOf, processContext, } from "./services/process.js";

package/dist/observability/ports.d.ts

@@ -47,13 +47,13 @@ export interface Tracer {
 }
 /** What a report says about where the error happened. */
 export type ErrorAbout = {
-    /** `<domain>/<Feature>`, the span's name. */
+    /** `<bounded context>.<Service>[.<method>]`: the use case's identity, as the backend's. */
     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 (`Runtime` `context`). */
+    /** 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. */

package/dist/services/bounded-context.d.ts

@@ -0,0 +1,79 @@
+import { type Context } from "../context/context.js";
+import type { ContextValues } from "../context/store.js";
+import { type ServiceClasses, type Services } from "./feature.js";
+/**
+ * A bounded context: its dependencies, its services, and the one object everything else uses
+ * them through — set up the way sincpro_framework sets one up.
+ *
+ *     // domains/project/infrastructure/dependencies.ts      ← what the services can count on
+ *     export interface ProjectDependencies {
+ *       client: ProjectClient;
+ *       session: Session;
+ *     }
+ *     export function registerDependencies(bc: UseBoundedContext<ProjectDependencies>) {
+ *       bc.addDependency("client", clientOf(transport));
+ *       bc.addDependency("session", session);
+ *       return bc;
+ *     }
+ *
+ *     // domains/project/infrastructure/bounded_context.ts
+ *     export class Feature extends BaseFeature<ProjectDependencies> {}
+ *     export class ApplicationService extends BaseApplicationService<ProjectDependencies, ProjectFeatures> {}
+ *     export function configProjectBoundedContext(name: string) {
+ *       return registerDependencies(new UseBoundedContext<ProjectDependencies>(name));
+ *     }
+ *
+ *     // domains/project/index.ts
+ *     export const project = configProjectBoundedContext("project").register({
+ *       features,                                  // { Issues, Notices }
+ *       applicationServices,                       // { CloseAndNotify }
+ *     });
+ *
+ *     // anywhere — a screen, another bounded context's adapter, a test
+ *     await project.Issues.close(input);           // span "project/Issues.close"
+ *     await project.CloseAndNotify.execute(input); // span "project/CloseAndNotify", its Features under it
+ *
+ * Context: sincpro_framework's `UseFramework` (being renamed to bounded context) with
+ * `add_dependency`, and `project(Command(...))` written as a property: a service is reached by
+ * the name it is registered under, so its span is named by that name — a production build renames
+ * classes, never the keys of an object — and the type of `project` is the services it holds.
+ *
+ * `project` is light and never frozen. It holds references: the classes, the dependencies, and
+ * one instance of each service, made the first time it is asked for and shared by everything
+ * derived from it. Each call makes a small view of that instance — a few pointers — that carries
+ * the call's trace. A screen or a test that needs its own variant derives one, with everything
+ * else shared:
+ *
+ *     project.with({ client: fake })               other dependencies — a test, a demo
+ *     project.scoped({ company_id: 2 })            more context for what runs through it — a window
+ *
+ * A service is a singleton of its bounded context: what a method writes on `this` stays for the
+ * next call and for the call running beside it, as in sincpro_framework. What belongs to one
+ * request goes in its arguments or its context, never on `this`.
+ */
+export type BoundedContext<D extends object, C extends object, F extends ServiceClasses, A extends ServiceClasses> = Services<F, D> & Services<A, D> & {
+    readonly name: string;
+    /** This bounded context's level of the context: under the process's, over a scope's. */
+    readonly context: Context<C>;
+    /** The same bounded context with other dependencies — the rest, and the services, shared. */
+    with(dependencies: Partial<D>): BoundedContext<D, C, F, A>;
+    /** The same bounded context with more context for what runs through it. */
+    scoped(context: Partial<C>): BoundedContext<D, C, F, A>;
+};
+export declare class UseBoundedContext<D extends object, C extends object = ContextValues> {
+    #private;
+    readonly name: string;
+    /** This bounded context's level of the context, saved in the process's store. */
+    readonly context: Context<C>;
+    constructor(name: string);
+    /** `value` is what every service of this bounded context finds at `this.<name>`. */
+    addDependency<K extends keyof D & string>(name: K, value: D[K]): this;
+    /**
+     * The object the bounded context is used through: each service under its name. A dependency
+     * added after this is seen too — the services read them on every call.
+     */
+    register<F extends ServiceClasses, A extends ServiceClasses = Record<never, never>>(services: {
+        features: F;
+        applicationServices?: A;
+    }): BoundedContext<D, C, F, A>;
+}

package/dist/services/bounded-context.js

@@ -0,0 +1,272 @@
+import { newEntityId } from "../client/ids.js";
+import { contextAt } from "../context/context.js";
+import { bindDependency } from "./execution.js";
+import { composes, isApplicationServiceClass, isFeatureClass, methodsOf, } from "./feature.js";
+import { processContext, processNow, processStore, } from "./process.js";
+/** Names `project` answers itself: no service is registered under them. */
+const RESERVED = new Set(["name", "context", "with", "scoped"]);
+/** Names a run answers on `this` itself: no dependency is added under them. */
+const ANSWERED = new Set(["context", "feature"]);
+export class UseBoundedContext {
+    name;
+    /** This bounded context's level of the context, saved in the process's store. */
+    context;
+    #dependencies = {};
+    constructor(name) {
+        if (name === "" || name.includes("/"))
+            throw new Error(`"${name}" is not a bounded context's name — it names its spans: "${name}/Issues.close"`);
+        this.name = name;
+        this.context = contextAt(`bounded_context:${name}`, processStore);
+    }
+    /** `value` is what every service of this bounded context finds at `this.<name>`. */
+    addDependency(name, value) {
+        if (ANSWERED.has(name))
+            throw new Error(`${this.name}: a dependency cannot be called "${name}" — every service answers this.${name} itself`);
+        this.#dependencies[name] = value;
+        return this;
+    }
+    /**
+     * The object the bounded context is used through: each service under its name. A dependency
+     * added after this is seen too — the services read them on every call.
+     */
+    register(services) {
+        const classes = new Map();
+        const add = (key, service) => {
+            if (RESERVED.has(key))
+                throw new Error(`${this.name}: no service can be called "${key}" — it is the bounded context's own`);
+            if (classes.has(key))
+                throw new Error(`${this.name}: two services are called "${key}"`);
+            classes.set(key, service);
+        };
+        for (const [key, service] of Object.entries(services.features)) {
+            if (typeof service !== "function" || !isFeatureClass(service))
+                throw new Error(`${this.name}: "${key}" is not a Feature — an ApplicationService goes in applicationServices`);
+            add(key, service);
+        }
+        for (const [key, service] of Object.entries(services.applicationServices ?? {})) {
+            if (typeof service !== "function" || !isApplicationServiceClass(service))
+                throw new Error(`${this.name}: "${key}" is not an ApplicationService — a Feature goes in features`);
+            add(key, service);
+        }
+        const registry = {
+            name: this.name,
+            dependencies: this.#dependencies,
+            classes,
+            features: new Set(Object.keys(services.features)),
+            instances: new Map(),
+            context: this.context,
+        };
+        return assemble({ registry, overrides: {}, scope: {} });
+    }
+}
+function assemble(binding) {
+    const { registry } = binding;
+    const held = {};
+    Object.defineProperties(held, {
+        name: { value: registry.name, enumerable: true },
+        context: { value: registry.context, enumerable: true },
+        with: {
+            value: (dependencies) => assemble({ ...binding, overrides: { ...binding.overrides, ...dependencies } }),
+        },
+        scoped: {
+            value: (values) => assemble({ ...binding, scope: { ...binding.scope, ...values } }),
+        },
+    });
+    // Each service is made and wrapped the first time it is asked for, then kept on this object.
+    for (const key of registry.classes.keys())
+        Object.defineProperty(held, key, {
+            configurable: true,
+            enumerable: true,
+            get() {
+                const service = intercepted(key, binding, undefined);
+                Object.defineProperty(held, key, { value: service, enumerable: true });
+                return service;
+            },
+        });
+    return held;
+}
+function instanceOf(registry, key) {
+    const known = registry.instances.get(key);
+    if (known !== undefined)
+        return known;
+    const Service = registry.classes.get(key);
+    if (Service === undefined)
+        throw new Error(`${registry.name}: no service is called "${key}"`);
+    const made = new Service();
+    registry.instances.set(key, made);
+    return made;
+}
+/**
+ * A service as its holder sees it: each public method runs in an execution of its own — a child
+ * of `parent` when an ApplicationService runs it. A method is the same function every time it is
+ * read, so a screen can keep it (`useService(project.Issues.close)`).
+ */
+function intercepted(key, binding, parent) {
+    const target = instanceOf(binding.registry, key);
+    const traced = methodsOf(target);
+    const methods = new Map();
+    return new Proxy(target, {
+        get(held, property) {
+            const value = Reflect.get(held, property, held);
+            if (typeof property !== "string" ||
+                typeof value !== "function" ||
+                !traced.has(property))
+                return value;
+            let method = methods.get(property);
+            if (method === undefined) {
+                const body = value;
+                method = (...args) => run(held, key, property, body, args, binding, parent);
+                methods.set(property, method);
+            }
+            return method;
+        },
+    });
+}
+function dependencyOf(binding, name) {
+    if (Object.hasOwn(binding.overrides, name))
+        return { found: true, value: binding.overrides[name] };
+    if (Object.hasOwn(binding.registry.dependencies, name))
+        return { found: true, value: binding.registry.dependencies[name] };
+    return { found: false, value: undefined };
+}
+/**
+ * The run's own view of the instance: its context, its dependencies bound to this execution
+ * (each bound the first time it is read), and — for an ApplicationService — its Features as
+ * children of this run. Anything else is the instance's.
+ */
+function viewOf(target, binding, execution) {
+    const bound = new Map();
+    let features;
+    const isComposer = composes(target);
+    return new Proxy(target, {
+        get(held, property, receiver) {
+            if (property === "context")
+                return execution.context;
+            if (property === "feature" && isComposer)
+                return (features ??= featuresOf(binding, execution));
+            if (typeof property === "string") {
+                if (bound.has(property))
+                    return bound.get(property);
+                const dependency = dependencyOf(binding, property);
+                if (dependency.found) {
+                    const value = bindDependency(dependency.value, execution);
+                    bound.set(property, value);
+                    return value;
+                }
+            }
+            return Reflect.get(held, property, receiver);
+        },
+        set(held, property, value) {
+            if (ANSWERED.has(String(property)))
+                return false;
+            if (typeof property === "string" && dependencyOf(binding, property).found)
+                return false;
+            // What a method writes on `this` lands on the instance — it is the bounded context's.
+            return Reflect.set(held, property, value);
+        },
+    });
+}
+/** An ApplicationService's `this.feature`: each Feature, asked by name, a child of the run. */
+function featuresOf(binding, execution) {
+    const children = new Map();
+    return new Proxy({}, {
+        get(_, property) {
+            if (typeof property !== "string" || !binding.registry.features.has(property))
+                return undefined;
+            let child = children.get(property);
+            if (child === undefined) {
+                child = intercepted(property, binding, execution);
+                children.set(property, child);
+            }
+            return child;
+        },
+    });
+}
+const NOTHING = {};
+/** What a gesture runs with: the process's context, under it the bounded context's, its scope's. */
+function contextOf(binding) {
+    return {
+        ...processContext.values,
+        ...binding.registry.context.values,
+        ...binding.scope,
+    };
+}
+/**
+ * Whether this is the first run to report this error. A Feature that fails inside an
+ * ApplicationService throws through it: the error is reported once, by the run where it
+ * happened — its span is the one that says where — and every run around it still ends `failed`.
+ */
+const REPORTED = new WeakSet();
+function firstReport(error) {
+    if (error === null || (typeof error !== "object" && typeof error !== "function"))
+        return true;
+    if (REPORTED.has(error))
+        return false;
+    REPORTED.add(error);
+    return true;
+}
+/** What watches a use case never changes what it answers: a tracer or reporter that throws is ignored. */
+function quietly(work, otherwise) {
+    try {
+        return work();
+    }
+    catch {
+        return otherwise;
+    }
+}
+const NO_SPAN = {
+    traceId: "",
+    spanId: "",
+    sampled: false,
+    set: () => undefined,
+    end: () => undefined,
+};
+function run(target, key, method, body, args, binding, parent) {
+    const settings = processNow();
+    const boundedContext = binding.registry.name;
+    // As sincpro_framework names a use case: the span `context/Name`, the identity `context.Name`.
+    const identity = method === "execute" ? key : `${key}.${method}`;
+    const useCase = `${boundedContext}.${identity}`;
+    const context = parent?.context ?? quietly(() => contextOf(binding), NOTHING);
+    const id = newEntityId();
+    const attributes = {
+        "sincpro.use_case": useCase,
+        "sincpro.layer": composes(target) ? "application_service" : "feature",
+        "sincpro.context": boundedContext,
+        "sincpro.execution_id": id,
+    };
+    const span = quietly(() => settings.tracer.start(`${boundedContext}/${identity}`, {
+        ...(parent === undefined ? {} : { parent: parent.span }),
+        attributes,
+    }), NO_SPAN);
+    const execution = { id, useCase, boundedContext, parent, span, context };
+    const finish = (failed, error) => {
+        const outcome = failed ? quietly(() => settings.outcomeOf(error), "failed") : "ok";
+        quietly(() => span.end(outcome, error), undefined);
+        if (outcome === "failed" && firstReport(error))
+            quietly(() => settings.reporter?.report(error, {
+                useCase,
+                traceId: span.traceId,
+                executionId: id,
+                context,
+            }), undefined);
+    };
+    let answer;
+    try {
+        answer = body.apply(viewOf(target, binding, execution), args);
+    }
+    catch (error) {
+        finish(true, error);
+        throw error;
+    }
+    if (answer instanceof Promise)
+        return answer.then((value) => {
+            finish(false);
+            return value;
+        }, (error) => {
+            finish(true, error);
+            throw error;
+        });
+    finish(false);
+    return answer;
+}