@sincpro/client-framework 0.2.0 → 0.4.0

package/dist/common/serialization.js

@@ -0,0 +1,155 @@
+/**
+ * Any value as JSON values and back — what every message a client sends is written with, as
+ * sincpro_framework's `common/serialization` (`values_of`, `read_values`, `rebuilt`, `pack`,
+ * `unpack`).
+ *
+ *     valuesOf({ total: new Money("12.50", "BOB"), qty: new Decimal("2.500") })
+ *       →  { total: { amount: "12.50", currency: "BOB" }, qty: "2.500" }
+ *     valuesOf(new Uint8Array([104, 105]))          →  { $bytes: "aGk=" }
+ *     readValues('{"photo":{"$bytes":"aGk="}}')      →  { photo: Uint8Array [104, 105] }
+ *     unpack(text, Money)                           →  a Money, or a TypeError naming what is wrong
+ *
+ * Context: the wire has one set of rules, the backend's, and every platform writes and reads it
+ * the same — that is why it lives here and not in each client:
+ *
+ * - a decimal is text (`"10.50"`): a `Decimal`, a `Money`'s amount, a `bigint` — never a float;
+ * - a day is text (`"2026-10-02"`) and stays text: a `Date` is always an instant, written as one;
+ * - an instant is ISO text (`Date` → `toISOString()`);
+ * - bytes are `{"$bytes": "<base64>"}`, so binary is never mistaken for text;
+ * - a value that says how it travels (`toJSON`) is written that way: `Money`, `Decimal`, `Date`;
+ * - a map is an object with text keys; a set or a list, a list.
+ *
+ * Not restrictive, like the backend: reading keeps every key it finds — what a reader does not
+ * know it ignores, never refuses — and a typed read is asked for, never imposed (`rebuilt(values,
+ * Money)`). What JSON cannot write (a function, `NaN`, a cycle) is refused at once, naming where,
+ * rather than sent as `null`.
+ */
+/** The tag bytes travel under. */
+export const BYTES = "$bytes";
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/** Base64 by hand: `btoa` is not on every platform this runs on. */
+function base64Of(bytes) {
+    let text = "";
+    for (let at = 0; at < bytes.length; at += 3) {
+        const [a = 0, b = 0, c = 0] = [bytes[at], bytes[at + 1], bytes[at + 2]];
+        const triple = (a << 16) | (b << 8) | c;
+        const letter = (shift) => ALPHABET.charAt((triple >> shift) & 63);
+        text += letter(18) + letter(12);
+        text += at + 1 < bytes.length ? letter(6) : "=";
+        text += at + 2 < bytes.length ? letter(0) : "=";
+    }
+    return text;
+}
+function bytesOf(text) {
+    const clean = text.replace(/[^A-Za-z0-9+/]/g, "");
+    const bytes = new Uint8Array(Math.floor((clean.length * 3) / 4));
+    let filled = 0;
+    for (let at = 0; at < clean.length; at += 4) {
+        const [a = 0, b = 0, c = 0, d = 0] = [0, 1, 2, 3].map((one) => ALPHABET.indexOf(clean[at + one] ?? "A"));
+        const triple = (a << 18) | (b << 12) | (c << 6) | d;
+        for (const shift of [16, 8, 0])
+            if (filled < bytes.length)
+                bytes[filled++] = (triple >> shift) & 255;
+    }
+    return bytes;
+}
+function isBytes(value) {
+    return (value instanceof Uint8Array || value instanceof ArrayBuffer || value instanceof DataView);
+}
+function asBytes(value) {
+    if (value instanceof Uint8Array)
+        return value;
+    if (value instanceof ArrayBuffer)
+        return new Uint8Array(value);
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+}
+function written(value, where, seen) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (value === undefined)
+        return undefined;
+    if (typeof value === "number") {
+        if (!Number.isFinite(value))
+            throw new TypeError(`${where}: ${value} cannot travel as JSON`);
+        return value;
+    }
+    if (typeof value === "bigint")
+        return value.toString();
+    if (typeof value === "function" || typeof value === "symbol")
+        throw new TypeError(`${where}: a ${typeof value} cannot travel as JSON`);
+    if (isBytes(value))
+        return { [BYTES]: base64Of(asBytes(value)) };
+    const object = value;
+    if (seen.has(object))
+        throw new TypeError(`${where}: a cycle cannot travel as JSON`);
+    seen.add(object);
+    try {
+        const own = object.toJSON;
+        if (typeof own === "function")
+            return written(own.call(object), where, seen);
+        if (object instanceof Map)
+            return Object.fromEntries([...object].flatMap(([key, one]) => {
+                const done = written(one, `${where}.${String(key)}`, seen);
+                return done === undefined ? [] : [[String(key), done]];
+            }));
+        if (object instanceof Set || Array.isArray(object))
+            return [...object].map((one, at) => written(one, `${where}[${at}]`, seen) ?? null);
+        const entries = [];
+        for (const [key, one] of Object.entries(object)) {
+            const done = written(one, `${where}.${key}`, seen);
+            if (done !== undefined)
+                entries.push([key, done]);
+        }
+        return Object.fromEntries(entries);
+    }
+    finally {
+        seen.delete(object);
+    }
+}
+/**
+ * `value` as JSON values, by the wire's rules. `undefined` is left out of an object and written
+ * `null` in a list, as JSON does.
+ */
+export function valuesOf(value) {
+    return written(value, "value", new Set()) ?? null;
+}
+/** One JSON object back as what it stood for: a lone `$bytes` tag is its bytes. */
+function restored(object) {
+    const keys = Object.keys(object);
+    if (keys.length === 1 && keys[0] === BYTES && typeof object[BYTES] === "string")
+        return bytesOf(object[BYTES]);
+    return object;
+}
+function walked(value) {
+    if (Array.isArray(value))
+        return value.map(walked);
+    if (value !== null && typeof value === "object")
+        return restored(Object.fromEntries(Object.entries(value).map(([key, one]) => [key, walked(one)])));
+    return value;
+}
+/** What `valuesOf` wrote, from JSON text or already parsed — each tagged bytes back as bytes. */
+export function readValues(text) {
+    if (typeof text === "string")
+        return JSON.parse(text, (_key, value) => value !== null && typeof value === "object" && !Array.isArray(value)
+            ? restored(value)
+            : value);
+    return walked(text);
+}
+/** `values` read as `of` — `Money`, a DTO's own reader — or as they are without one. */
+export function rebuilt(values, of) {
+    if (of === undefined)
+        return values;
+    // A class is a function too: one that says how to read itself is read that way.
+    const reader = of.fromJSON;
+    if (typeof reader === "function")
+        return reader.call(of, values);
+    return of(values);
+}
+/** `value` as JSON text — see `valuesOf`. */
+export function pack(value) {
+    return JSON.stringify(valuesOf(value));
+}
+/** What `pack` wrote, read as `of` — see `rebuilt`. */
+export function unpack(text, of) {
+    return rebuilt(readValues(text), of);
+}

package/dist/common/time.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A day and an instant, as the server sends them — and the two conversions every client needs:
+ * the server's instant to the wall clock of a zone, and back.
+ *
+ *     installTimeZone("America/La_Paz");                       once, for the company in use
+ *     wallTimeOf("2026-03-12T14:30:00Z", timeZoneNow())   →  "2026-03-12T10:30"
+ *     instantOf("2026-03-12T10:30", timeZoneNow())        →  "2026-03-12T14:30:00.000Z"
+ *
+ * Context: sincpro_framework sends a `datetime` as an instant (`2026-03-12T14:30:00Z`) and a
+ * `date` as a day of the calendar (`2026-03-12`). A person reads and types the wall clock of
+ * where the business is (10:30 in La Paz), on a browser or on a phone alike, so the conversion
+ * is this package's and every platform draws with it. Which zone belongs to whoever is above the
+ * screens — the application, the company the user works in — so it is installed once and every
+ * instant follows it; without it, the platform's own. A day is never converted: turned into an
+ * instant it lands on the day before west of Greenwich.
+ *
+ * Only `Intl.DateTimeFormat` with time zones is asked of the platform: browsers, Node and
+ * Hermes (React Native) have it.
+ */
+/** Install the time zone dates and times are read and written in (IANA: `"America/La_Paz"`);
+ *  `undefined` goes back to the platform's. */
+export declare function installTimeZone(timeZone: string | undefined): void;
+/** The time zone in use. */
+export declare function timeZoneNow(): string;
+/** `"2026-03-12T14:30:00Z"` → `"2026-03-12T10:30"` in `America/La_Paz`: the wall clock there,
+ *  as a date-and-time control reads it. `null` when it is not an instant. */
+export declare function wallTimeOf(instant: string, timeZone: string): string | null;
+/**
+ * `"2026-03-12T10:30"` on the wall clock of `timeZone` → the instant, `"2026-03-12T14:30:00.000Z"`.
+ * `null` when it is not a wall time.
+ *
+ * Context: the offset depends on the instant (daylight saving), so it is asked twice: at the
+ * first guess, and again at the answer when the guess fell on the other side of a change.
+ */
+export declare function instantOf(wall: string, timeZone: string): string | null;
+/** A day of the calendar as the server writes it: `"2026-03-12"` — never an instant. */
+export declare function isDay(text: string): boolean;
+/** The day it is at `instant` on the wall clock of `timeZone`: what «today» means for a company.
+ *  `null` when it is not an instant. */
+export declare function dayOf(instant: string, timeZone: string): string | null;

package/dist/common/time.js

@@ -0,0 +1,93 @@
+/**
+ * A day and an instant, as the server sends them — and the two conversions every client needs:
+ * the server's instant to the wall clock of a zone, and back.
+ *
+ *     installTimeZone("America/La_Paz");                       once, for the company in use
+ *     wallTimeOf("2026-03-12T14:30:00Z", timeZoneNow())   →  "2026-03-12T10:30"
+ *     instantOf("2026-03-12T10:30", timeZoneNow())        →  "2026-03-12T14:30:00.000Z"
+ *
+ * Context: sincpro_framework sends a `datetime` as an instant (`2026-03-12T14:30:00Z`) and a
+ * `date` as a day of the calendar (`2026-03-12`). A person reads and types the wall clock of
+ * where the business is (10:30 in La Paz), on a browser or on a phone alike, so the conversion
+ * is this package's and every platform draws with it. Which zone belongs to whoever is above the
+ * screens — the application, the company the user works in — so it is installed once and every
+ * instant follows it; without it, the platform's own. A day is never converted: turned into an
+ * instant it lands on the day before west of Greenwich.
+ *
+ * Only `Intl.DateTimeFormat` with time zones is asked of the platform: browsers, Node and
+ * Hermes (React Native) have it.
+ */
+let installed;
+/** Install the time zone dates and times are read and written in (IANA: `"America/La_Paz"`);
+ *  `undefined` goes back to the platform's. */
+export function installTimeZone(timeZone) {
+    installed = timeZone;
+}
+/** The time zone in use. */
+export function timeZoneNow() {
+    return installed ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+const clocks = new Map();
+/** One formatter per zone, kept: building one costs far more than using it. */
+function clockOf(timeZone) {
+    let clock = clocks.get(timeZone);
+    if (clock === undefined) {
+        clock = new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            hourCycle: "h23",
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+        });
+        clocks.set(timeZone, clock);
+    }
+    return clock;
+}
+/** The wall clock of `timeZone` at `at` (ms), as the fields of a UTC date: what to compare. */
+function wallAt(at, timeZone) {
+    const parts = Object.fromEntries(clockOf(timeZone)
+        .formatToParts(new Date(at))
+        .map((part) => [part.type, part.value]));
+    return Date.UTC(Number(parts["year"]), Number(parts["month"]) - 1, Number(parts["day"]), Number(parts["hour"]), Number(parts["minute"]), Number(parts["second"]));
+}
+const pad = (n) => String(n).padStart(2, "0");
+/** `"2026-03-12T14:30:00Z"` → `"2026-03-12T10:30"` in `America/La_Paz`: the wall clock there,
+ *  as a date-and-time control reads it. `null` when it is not an instant. */
+export function wallTimeOf(instant, timeZone) {
+    const at = Date.parse(instant);
+    if (Number.isNaN(at))
+        return null;
+    const wall = new Date(wallAt(at, timeZone));
+    return (`${wall.getUTCFullYear()}-${pad(wall.getUTCMonth() + 1)}-${pad(wall.getUTCDate())}` +
+        `T${pad(wall.getUTCHours())}:${pad(wall.getUTCMinutes())}`);
+}
+/**
+ * `"2026-03-12T10:30"` on the wall clock of `timeZone` → the instant, `"2026-03-12T14:30:00.000Z"`.
+ * `null` when it is not a wall time.
+ *
+ * Context: the offset depends on the instant (daylight saving), so it is asked twice: at the
+ * first guess, and again at the answer when the guess fell on the other side of a change.
+ */
+export function instantOf(wall, timeZone) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})/.exec(wall);
+    if (match === null)
+        return null;
+    const [, year, month, day, hour, minute] = match.map(Number);
+    const guess = Date.UTC(year, month - 1, day, hour, minute);
+    const first = guess - (wallAt(guess, timeZone) - guess);
+    const second = guess - (wallAt(first, timeZone) - first);
+    return new Date(second).toISOString();
+}
+const DAY = /^\d{4}-\d{2}-\d{2}$/;
+/** A day of the calendar as the server writes it: `"2026-03-12"` — never an instant. */
+export function isDay(text) {
+    return DAY.test(text) && !Number.isNaN(Date.parse(`${text}T00:00:00Z`));
+}
+/** The day it is at `instant` on the wall clock of `timeZone`: what «today» means for a company.
+ *  `null` when it is not an instant. */
+export function dayOf(instant, timeZone) {
+    return wallTimeOf(instant, timeZone)?.slice(0, 10) ?? null;
+}

package/dist/context/codec.d.ts

@@ -0,0 +1,24 @@
+import type { ContextValues } from "./store.js";
+/**
+ * How a context is written to text and read back: what a `ContextStore` that persists uses
+ * (`sessionStorage`, MMKV), and what travels to the server in `sincpro-context`.
+ *
+ *     plainCodec.dumps({ tenant_id: "acme", company_id: 2, session: socket })
+ *       →  '{"tenant_id":"acme","company_id":2}'
+ *     plainCodec.loads('{"tenant_id":"acme"}')   →  { tenant_id: "acme" }
+ *
+ * Context: sincpro_framework's `ContextCodec`, and its `PlainCodec` — the one for anything outside
+ * the codebase: another language, a browser, a phone. Only the travelling values go — text,
+ * numbers, booleans, `null`, and lists of them; an object, a function or a connection held in the
+ * context stays where it is. Reading never fails a context whole: text that is not a JSON object
+ * reads as an empty one. A project with a schema of its own writes its own codec over this port.
+ */
+export interface ContextCodec {
+    dumps(values: ContextValues): string;
+    loads(text: string): ContextValues;
+}
+/** Whether a value travels: a plain value, or a list of them. */
+export declare function travels(value: unknown): boolean;
+/** The values of `context` that travel; the rest stays in this process. */
+export declare function travelling(context: ContextValues): ContextValues;
+export declare const plainCodec: ContextCodec;

package/dist/context/codec.js

@@ -0,0 +1,28 @@
+function isPlain(value) {
+    return (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value)));
+}
+/** Whether a value travels: a plain value, or a list of them. */
+export function travels(value) {
+    return isPlain(value) || (Array.isArray(value) && value.every(isPlain));
+}
+/** The values of `context` that travel; the rest stays in this process. */
+export function travelling(context) {
+    return Object.fromEntries(Object.entries(context).filter(([, value]) => travels(value)));
+}
+export const plainCodec = {
+    dumps: (values) => JSON.stringify(travelling(values)),
+    loads(text) {
+        try {
+            const found = JSON.parse(text);
+            return found !== null && typeof found === "object" && !Array.isArray(found)
+                ? found
+                : {};
+        }
+        catch {
+            return {};
+        }
+    },
+};

package/dist/context/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

@@ -6,10 +6,14 @@
  * (`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.
  *
+ *   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, client-side ids
+ *             entities with typed commands, the service's client contract
  *   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
@@ -17,15 +21,23 @@
  */
 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 { isEntityId, newEntityId } from "./client/ids.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 { 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, 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";