@sincpro/client-framework 0.3.0 → 0.4.0

package/AGENTS.md

@@ -20,17 +20,18 @@ it says what this package is responsible for and what it is not. This file is ho
 
 ## Where things go
 
-| Folder               | What                                                                                        |
-| -------------------- | ------------------------------------------------------------------------------------------- |
-| `src/client/`        | The seam with a server: `Transport`, REST, memory, `entity()`, the client contract, ids     |
-| `src/model/`         | Model definitions: `defineMeta`, from a JSON Schema, the store of known ones                |
-| `src/services/`      | `UseBoundedContext`, `Feature`, `ApplicationService`, the process, the execution            |
-| `src/context/`       | The `ContextStore` port, `memoryContexts`, and `Context` — one level of it                  |
-| `src/observability/` | The ports a platform plugs: `Tracer`, `ErrorReporter`                                       |
-| `src/codegen/`       | The generator and its CLI (`sincpro-client generate`) — the only place Node is allowed      |
-| `src/adapters/`      | Optional entries over a vendor (`./opentelemetry`, `./sentry`): the only place one is named |
-| `src/testing/`       | `memoryTracer`, `memoryReporter` — the ports in memory, for tests                           |
-| `tests/`             | vitest in Node; `tests/support/` holds the fake domains and forge's real contracts          |
+| Folder               | What                                                                                          |
+| -------------------- | --------------------------------------------------------------------------------------------- |
+| `src/common/`        | The values of the wire: ids, a day and an instant, `Decimal`, `Money`, `valuesOf` / `rebuilt` |
+| `src/client/`        | The seam with a server: `Transport`, REST, memory, `entity()`, the client contract            |
+| `src/model/`         | Model definitions: `defineMeta`, from a JSON Schema, the store of known ones                  |
+| `src/services/`      | `UseBoundedContext`, `Feature`, `ApplicationService`, the process, the execution              |
+| `src/context/`       | The `ContextStore` port, `memoryContexts`, and `Context` — one level of it                    |
+| `src/observability/` | The ports a platform plugs: `Tracer`, `ErrorReporter`                                         |
+| `src/codegen/`       | The generator and its CLI (`sincpro-client generate`) — the only place Node is allowed        |
+| `src/adapters/`      | Optional entries over a vendor (`./opentelemetry`, `./sentry`): the only place one is named   |
+| `src/testing/`       | `memoryTracer`, `memoryReporter` — the ports in memory, for tests                             |
+| `tests/`             | vitest in Node; `tests/support/` holds the fake domains and forge's real contracts            |
 
 ## Hard rules (the build enforces them — `make doctor`)
 
@@ -90,6 +91,16 @@ it says what this package is responsible for and what it is not. This file is ho
   an `AbortError` is `aborted`; neither is reported (`outcomeOf`). Change that with
   `ProcessOptions.outcomeOf`, never by catching in a Feature.
 
+- **Only what is transversal comes here.** A value's wire form (a decimal as text, a day never
+  an instant, a money with its currency) is the backend's contract, the same on every platform,
+  so it lives in `src/common/`. How a value is shown to a person, typed in an input, or kept in
+  SQLite or IndexedDB is the platform's — @sincpro/web-framework's or @sincpro/mobile's.
+- **A decimal never becomes a `number`.** It travels as text and is computed with `Decimal` or
+  `Money` (exact, on `BigInt`); `Number(...)` or `parseFloat` on an amount is the float the
+  backend sends text to avoid. And a day is never a `Date`: a `Date` is an instant.
+- **The in-memory server copies by the wire's rules** (`valuesOf` → `readValues`): what it receives
+  and answers is what a real server would — a `Money` as `{ amount, currency }`, a `Date` as text.
+
 ## Before you hand it back
 
 ```bash

package/MANIFESTO.md

@@ -48,10 +48,14 @@ server-side render, in a script and in a test, unchanged.**
    never import each other's insides.
 6. **The client.** The `Transport` port and its implementations (REST, memory), `entity()` with
    typed commands and answers, the service's client contract, model definitions read once from
-   the server, client-side ids (UUID v7) and the server's `Problem`.
-7. **The generator.** From a service's client contract to each domain's types, client and
+   the server and the server's `Problem`.
+7. **The values of the wire.** How every value travels, as the backend writes it — a decimal as
+   text, a money with its currency, a day that is never an instant, bytes tagged, ids as UUID v7 —
+   and the exact arithmetic a client needs on them (`Decimal`, `Money`). Only the wire form and
+   what follows from it: showing a value to a person is each platform's.
+8. **The generator.** From a service's client contract to each domain's types, client and
    entities — generated, never edited, and as platform-neutral as everything else here.
-8. **Testing.** An in-memory transport, tracer and reporter, so a use case is proven in Node with
+9. **Testing.** An in-memory transport, tracer and reporter, so a use case is proven in Node with
    nothing else.
 
 ## What it is not

package/README.md

@@ -267,6 +267,36 @@ Nothing is installed or shipped unless it is imported, and without a tracer or a
 case runs the same — nothing traces, nothing reports. In a test, `memoryTracer()` and
 `memoryReporter()` (`@sincpro/client-framework/testing`).
 
+## Values on the wire
+
+The backend writes every message with one set of rules, and every client reads and writes them
+the same — so they live here, not in each platform:
+
+| Value       | Travels as                                 | Here                                             |
+| ----------- | ------------------------------------------ | ------------------------------------------------ |
+| a decimal   | text, every digit: `"10.50"`               | `Decimal` — exact, on `BigInt`; rounds half up   |
+| a money     | `{ "amount": "10.50", "currency": "BOB" }` | `Money` — never adds two currencies              |
+| a day       | `"2026-10-02"`, never converted            | `isDay`, `dayOf(instant, zone)` for «today»      |
+| an instant  | ISO text: `"2026-10-02T14:30:00Z"`         | `wallTimeOf` / `instantOf` on the company's zone |
+| an id       | a UUID v7 as 32 hex                        | `newEntityId`, `isEntityId`, `momentOf`          |
+| bytes       | `{ "$bytes": "<base64>" }`                 | `valuesOf` / `readValues`                        |
+| the context | only what travels: text, numbers, lists    | `plainCodec`, `travelling`                       |
+
+```ts
+import { Money, pack, unpack, valuesOf } from "@sincpro/client-framework";
+
+const line = new Money("19.90", "BOB").times("3"); // 59.70 BOB, exact
+const total = Money.total([line, delivery], "BOB").rounded(); // to the currency's decimals
+valuesOf({ total, at: new Date() }); // { total: { amount, currency }, at: "…Z" }
+const answer = unpack(text, Money); // a typed read when asked for — never imposed
+```
+
+Not restrictive, like the backend: reading keeps every key it finds, a typed read is asked for
+(`rebuilt(values, Money)`), any currency code is read, and an application adds its own decimals
+(`Money.decimals["USDT"] = 6`). What JSON cannot write (`NaN`, a function, a cycle) is refused at
+once, naming where. Showing a value to a person — `Intl.NumberFormat`, a date picker — is each
+platform's, never this package's.
+
 ## Where it sits
 
 ```mermaid

package/dist/client/memory.js

@@ -1,12 +1,13 @@
 import { TransportError, } from "./transport.js";
+import { readValues, valuesOf } from "../common/serialization.js";
 import { answer, answerGroups } from "@sincpro/criteria/engine";
 /**
- * A deep copy, as over a wire: `structuredClone` where the platform has it, a JSON round trip
- * where it does not (some React Native engines) — the rows a fake server holds are plain JSON.
+ * A deep copy written and read by the wire's rules (`valuesOf`, `readValues`): what a real server
+ * would have received and answered — a `Money` as `{ amount, currency }`, a `Decimal` as its text,
+ * a `Date` as an instant, bytes as bytes — the same on every platform. `structuredClone` kept a
+ * `Date` a `Date` in a browser and a JSON round trip made it text on a phone; neither is a wire.
  */
-const copyOf = typeof globalThis.structuredClone === "function"
-    ? (value) => globalThis.structuredClone(value)
-    : (value) => (value === undefined ? value : JSON.parse(JSON.stringify(value)));
+const copyOf = (value) => value === undefined ? value : readValues(valuesOf(value));
 function wait(ms, signal) {
     if (ms <= 0)
         return Promise.resolve();

package/dist/common/decimal.d.ts

@@ -0,0 +1,49 @@
+/**
+ * An exact decimal — what sincpro_framework's `Decimal` is on the wire: text, every digit kept.
+ *
+ *     new Decimal("10.50").plus("0.25")             →  10.75
+ *     new Decimal("2.500").times("19.90")           →  49.75000
+ *     new Decimal("10").dividedBy("3", 2)           →  3.33        half up, as the backend rounds
+ *     JSON.stringify({ qty: new Decimal("2.500") })  →  {"qty":"2.500"}
+ *
+ * Context: the backend sends a decimal as text (`"10.50"`) so no client reads it as a float —
+ * `0.1 + 0.2` is `0.30000000000000004` in every JavaScript engine, and an invoice cannot be. A
+ * client that adds, multiplies or rounds an amount (a cart, a line, a discount) does it here,
+ * on `BigInt`, which browsers, Node and Hermes have; it depends on nothing. It never rounds by
+ * accident: `plus`, `minus` and `times` are exact, and only `rounded` and `dividedBy` round —
+ * half up, away from zero, the backend's `ROUND_HALF_UP`. Formatting it for a person is the
+ * platform's (`Intl.NumberFormat`), never this.
+ */
+export type DecimalLike = Decimal | string | number | bigint;
+export declare class Decimal {
+    /** The digits, as an integer: `10.50` is `1050n` at scale 2. */
+    readonly units: bigint;
+    /** How many of the digits are after the point. */
+    readonly scale: number;
+    /**
+     * A decimal from its text (`"10.50"`, `"-0.5"`, `"1e3"`), a number — taken by its digits,
+     * `0.1` is `"0.1"` — or a whole `bigint`. Anything else is refused, naming it.
+     */
+    constructor(value: DecimalLike);
+    static of(value: DecimalLike): Decimal;
+    private static at;
+    /** Both at the larger scale, so their units compare and add. */
+    private static aligned;
+    plus(other: DecimalLike): Decimal;
+    minus(other: DecimalLike): Decimal;
+    times(factor: DecimalLike): Decimal;
+    /** This over `divisor`, with `decimals` digits after the point, rounded half up. */
+    dividedBy(divisor: DecimalLike, decimals: number): Decimal;
+    /** With `decimals` digits after the point: rounded half up when it had more, padded when fewer. */
+    rounded(decimals: number): Decimal;
+    negated(): Decimal;
+    /** `-1`, `0` or `1`: `10.5` and `10.50` are the same amount. */
+    compare(other: DecimalLike): -1 | 0 | 1;
+    equals(other: DecimalLike): boolean;
+    get isZero(): boolean;
+    get isNegative(): boolean;
+    get isPositive(): boolean;
+    /** The text the wire carries: every digit, the scale kept (`"10.50"`, never `"10.5"`). */
+    toString(): string;
+    toJSON(): string;
+}

package/dist/common/decimal.js

@@ -0,0 +1,146 @@
+/**
+ * An exact decimal — what sincpro_framework's `Decimal` is on the wire: text, every digit kept.
+ *
+ *     new Decimal("10.50").plus("0.25")             →  10.75
+ *     new Decimal("2.500").times("19.90")           →  49.75000
+ *     new Decimal("10").dividedBy("3", 2)           →  3.33        half up, as the backend rounds
+ *     JSON.stringify({ qty: new Decimal("2.500") })  →  {"qty":"2.500"}
+ *
+ * Context: the backend sends a decimal as text (`"10.50"`) so no client reads it as a float —
+ * `0.1 + 0.2` is `0.30000000000000004` in every JavaScript engine, and an invoice cannot be. A
+ * client that adds, multiplies or rounds an amount (a cart, a line, a discount) does it here,
+ * on `BigInt`, which browsers, Node and Hermes have; it depends on nothing. It never rounds by
+ * accident: `plus`, `minus` and `times` are exact, and only `rounded` and `dividedBy` round —
+ * half up, away from zero, the backend's `ROUND_HALF_UP`. Formatting it for a person is the
+ * platform's (`Intl.NumberFormat`), never this.
+ */
+const NUMBER = /^([+-]?)(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d{1,4}))?$/;
+const TEN = 10n;
+function pow10(exponent) {
+    return TEN ** BigInt(exponent);
+}
+/** `units / divisor` rounded half up, away from zero. */
+function halfUp(units, divisor) {
+    const quotient = units / divisor;
+    const rest = units % divisor;
+    const twice = (rest < 0n ? -rest : rest) * 2n;
+    const whole = divisor < 0n ? -divisor : divisor;
+    if (twice < whole)
+        return quotient;
+    return units < 0n !== divisor < 0n ? quotient - 1n : quotient + 1n;
+}
+export class Decimal {
+    /** The digits, as an integer: `10.50` is `1050n` at scale 2. */
+    units;
+    /** How many of the digits are after the point. */
+    scale;
+    /**
+     * A decimal from its text (`"10.50"`, `"-0.5"`, `"1e3"`), a number — taken by its digits,
+     * `0.1` is `"0.1"` — or a whole `bigint`. Anything else is refused, naming it.
+     */
+    constructor(value) {
+        if (value instanceof Decimal) {
+            this.units = value.units;
+            this.scale = value.scale;
+            return;
+        }
+        if (typeof value === "bigint") {
+            this.units = value;
+            this.scale = 0;
+            return;
+        }
+        if (typeof value === "number" && !Number.isFinite(value))
+            throw new TypeError(`${value} is not a decimal`);
+        const text = typeof value === "number" ? String(value) : String(value).trim();
+        const match = NUMBER.exec(text);
+        const [, sign = "", whole = "", fraction = "", exponent = "0"] = match ?? [];
+        if (match === null || whole + fraction === "")
+            throw new TypeError(`"${text}" is not a decimal`);
+        let digits = whole + fraction;
+        let scale = fraction.length - Number(exponent);
+        if (scale < 0) {
+            digits += "0".repeat(-scale);
+            scale = 0;
+        }
+        this.units = BigInt(digits) * (sign === "-" ? -1n : 1n);
+        this.scale = scale;
+    }
+    static of(value) {
+        return value instanceof Decimal ? value : new Decimal(value);
+    }
+    static at(units, scale) {
+        const made = Object.create(Decimal.prototype);
+        made.units = units;
+        made.scale = scale;
+        return made;
+    }
+    /** Both at the larger scale, so their units compare and add. */
+    static aligned(one, other) {
+        const scale = Math.max(one.scale, other.scale);
+        return [
+            one.units * pow10(scale - one.scale),
+            other.units * pow10(scale - other.scale),
+            scale,
+        ];
+    }
+    plus(other) {
+        const [one, two, scale] = Decimal.aligned(this, Decimal.of(other));
+        return Decimal.at(one + two, scale);
+    }
+    minus(other) {
+        const [one, two, scale] = Decimal.aligned(this, Decimal.of(other));
+        return Decimal.at(one - two, scale);
+    }
+    times(factor) {
+        const by = Decimal.of(factor);
+        return Decimal.at(this.units * by.units, this.scale + by.scale);
+    }
+    /** This over `divisor`, with `decimals` digits after the point, rounded half up. */
+    dividedBy(divisor, decimals) {
+        const by = Decimal.of(divisor);
+        if (by.units === 0n)
+            throw new RangeError("a decimal divided by zero");
+        const numerator = this.units * pow10(by.scale + decimals);
+        const denominator = by.units * pow10(this.scale);
+        return Decimal.at(halfUp(numerator, denominator), decimals);
+    }
+    /** With `decimals` digits after the point: rounded half up when it had more, padded when fewer. */
+    rounded(decimals) {
+        if (decimals >= this.scale)
+            return Decimal.at(this.units * pow10(decimals - this.scale), decimals);
+        return Decimal.at(halfUp(this.units, pow10(this.scale - decimals)), decimals);
+    }
+    negated() {
+        return Decimal.at(-this.units, this.scale);
+    }
+    /** `-1`, `0` or `1`: `10.5` and `10.50` are the same amount. */
+    compare(other) {
+        const [one, two] = Decimal.aligned(this, Decimal.of(other));
+        return one < two ? -1 : one > two ? 1 : 0;
+    }
+    equals(other) {
+        return this.compare(other) === 0;
+    }
+    get isZero() {
+        return this.units === 0n;
+    }
+    get isNegative() {
+        return this.units < 0n;
+    }
+    get isPositive() {
+        return this.units > 0n;
+    }
+    /** The text the wire carries: every digit, the scale kept (`"10.50"`, never `"10.5"`). */
+    toString() {
+        const negative = this.units < 0n;
+        const digits = (negative ? -this.units : this.units)
+            .toString()
+            .padStart(this.scale + 1, "0");
+        const whole = digits.slice(0, digits.length - this.scale);
+        const fraction = digits.slice(digits.length - this.scale);
+        return `${negative ? "-" : ""}${whole}${this.scale > 0 ? `.${fraction}` : ""}`;
+    }
+    toJSON() {
+        return this.toString();
+    }
+}

package/dist/{client → common}/ids.d.ts

@@ -15,3 +15,10 @@
 export declare function newEntityId(now?: number): string;
 /** A key that is a UUID v7 as sincpro_framework writes it: 32 hex, version 7, variant `10`. */
 export declare function isEntityId(text: string): boolean;
+/**
+ * When a UUID v7 was minted, read off its leading 48 bits — sincpro_framework's `moment_of`;
+ * `null` for a key that is not one (a project's own format, a UUID v4).
+ *
+ *     momentOf(newEntityId())   →  "2026-11-06T22:41:07.512Z", the moment it was minted
+ */
+export declare function momentOf(identity: string): string | null;

package/dist/{client → common}/ids.js

@@ -50,3 +50,15 @@ export function newEntityId(now = Date.now()) {
 export function isEntityId(text) {
     return /^[0-9a-f]{12}7[0-9a-f]{3}[89ab][0-9a-f]{15}$/.test(text);
 }
+/**
+ * When a UUID v7 was minted, read off its leading 48 bits — sincpro_framework's `moment_of`;
+ * `null` for a key that is not one (a project's own format, a UUID v4).
+ *
+ *     momentOf(newEntityId())   →  "2026-11-06T22:41:07.512Z", the moment it was minted
+ */
+export function momentOf(identity) {
+    const hex = identity.replaceAll("-", "").toLowerCase();
+    if (!isEntityId(hex))
+        return null;
+    return new Date(Number.parseInt(hex.slice(0, 12), 16)).toISOString();
+}

package/dist/common/money.d.ts

@@ -0,0 +1,74 @@
+import { Decimal, type DecimalLike } from "./decimal.js";
+/**
+ * An amount and its currency, as sincpro_framework's `Money` travels: `{"amount": "10.50",
+ * "currency": "BOB"}`.
+ *
+ *     const line = new Money("19.90", "BOB").times("3");            →  59.70 BOB
+ *     const total = Money.total([line, delivery], "BOB");
+ *     total.rounded().toJSON()                                       →  { amount: "69.70", currency: "BOB" }
+ *     Money.fromJSON(answer.total)                                   ←  what the server sent
+ *
+ * Context: an amount never travels without its currency, never as a float and never rounds by
+ * accident — the backend's three rules, kept here so a cart, a POS line or a portal's quote adds
+ * the way the invoice will. Adding two currencies is refused; `total` sums one, `totals` each.
+ * The arithmetic is `Decimal`'s, exact; `rounded()` rounds to the currency's decimals (ISO 4217:
+ * `BOB` 2, `JPY` 0, `KWD` 3), and `isZero` / `isNegative` read it at those decimals, as an
+ * accountant does.
+ *
+ * Not restrictive: any code is read (a crypto, a loyalty point), and its decimals are 2 unless
+ * `Money.decimals` says otherwise — an application adds its own (`Money.decimals["USDT"] = 6`).
+ * Showing it to a person is the platform's (`Intl.NumberFormat` with `style: "currency"`).
+ */
+export declare class Money {
+    /** Decimals by currency where they are not 2: ISO 4217's, and what an application adds. */
+    static readonly decimals: Record<string, number>;
+    /** The amount as the wire carries it: every digit, the scale kept (`"10.50"`). */
+    readonly amount: string;
+    /** The currency's code, upper case (`"BOB"`). */
+    readonly currency: string;
+    constructor(amount: DecimalLike, currency: string);
+    /**
+     * What the server sent — `{ amount, currency }`, the amount as text or as a JSON number taken
+     * by its digits. Anything else is refused, naming what is wrong.
+     */
+    static fromJSON(value: unknown): Money;
+    /** Whether `value` has the shape of a money on the wire: `{ amount, currency }`. */
+    static isMoney(value: unknown): value is {
+        amount: string | number;
+        currency: string;
+    };
+    /** The decimals `currency` is counted in: 2 unless `Money.decimals` says otherwise. */
+    static decimalsOf(currency: string): number;
+    /** The sum of `items`, all in `currency` — zero when there are none. Another currency is refused. */
+    static total(items: Iterable<Money>, currency: string): Money;
+    /** The sums by currency, each currency's own. */
+    static totals(items: Iterable<Money>): Readonly<Record<string, Money>>;
+    /** The amount as an exact decimal. */
+    get value(): Decimal;
+    /** The decimals this currency is counted in. */
+    get decimals(): number;
+    private same;
+    plus(other: Money): Money;
+    minus(other: Money): Money;
+    /** Times a quantity, a rate or a percentage as a fraction: exact, never rounded. */
+    times(factor: DecimalLike): Money;
+    /** Over `divisor`, rounded half up to the currency's decimals (or `decimals`). */
+    dividedBy(divisor: DecimalLike, decimals?: number): Money;
+    /** Rounded half up to the currency's decimals (or `decimals`): what an invoice shows. */
+    rounded(decimals?: number): Money;
+    negated(): Money;
+    /** `-1`, `0` or `1`, in the same currency. */
+    compare(other: Money): -1 | 0 | 1;
+    /** The same currency and the same amount: `10.5 BOB` equals `10.50 BOB`. */
+    equals(other: Money): boolean;
+    /** Zero at the currency's decimals: `0.004 BOB` is. */
+    get isZero(): boolean;
+    get isNegative(): boolean;
+    get isPositive(): boolean;
+    toJSON(): {
+        amount: string;
+        currency: string;
+    };
+    /** `"10.50 BOB"` — for a log or a test; a person reads it through `Intl.NumberFormat`. */
+    toString(): string;
+}

package/dist/common/money.js

@@ -0,0 +1,168 @@
+import { Decimal } from "./decimal.js";
+/**
+ * An amount and its currency, as sincpro_framework's `Money` travels: `{"amount": "10.50",
+ * "currency": "BOB"}`.
+ *
+ *     const line = new Money("19.90", "BOB").times("3");            →  59.70 BOB
+ *     const total = Money.total([line, delivery], "BOB");
+ *     total.rounded().toJSON()                                       →  { amount: "69.70", currency: "BOB" }
+ *     Money.fromJSON(answer.total)                                   ←  what the server sent
+ *
+ * Context: an amount never travels without its currency, never as a float and never rounds by
+ * accident — the backend's three rules, kept here so a cart, a POS line or a portal's quote adds
+ * the way the invoice will. Adding two currencies is refused; `total` sums one, `totals` each.
+ * The arithmetic is `Decimal`'s, exact; `rounded()` rounds to the currency's decimals (ISO 4217:
+ * `BOB` 2, `JPY` 0, `KWD` 3), and `isZero` / `isNegative` read it at those decimals, as an
+ * accountant does.
+ *
+ * Not restrictive: any code is read (a crypto, a loyalty point), and its decimals are 2 unless
+ * `Money.decimals` says otherwise — an application adds its own (`Money.decimals["USDT"] = 6`).
+ * Showing it to a person is the platform's (`Intl.NumberFormat` with `style: "currency"`).
+ */
+export class Money {
+    /** Decimals by currency where they are not 2: ISO 4217's, and what an application adds. */
+    static decimals = {
+        BHD: 3,
+        BIF: 0,
+        BTC: 8,
+        CLF: 4,
+        CLP: 0,
+        DJF: 0,
+        GNF: 0,
+        IQD: 3,
+        ISK: 0,
+        JOD: 3,
+        JPY: 0,
+        KMF: 0,
+        KRW: 0,
+        KWD: 3,
+        LYD: 3,
+        OMR: 3,
+        PYG: 0,
+        RWF: 0,
+        TND: 3,
+        UGX: 0,
+        UYI: 0,
+        VND: 0,
+        VUV: 0,
+        XAF: 0,
+        XOF: 0,
+        XPF: 0,
+    };
+    /** The amount as the wire carries it: every digit, the scale kept (`"10.50"`). */
+    amount;
+    /** The currency's code, upper case (`"BOB"`). */
+    currency;
+    constructor(amount, currency) {
+        const code = currency.trim().toUpperCase();
+        if (!/^[A-Z][A-Z0-9]{1,9}$/.test(code))
+            throw new TypeError(`"${currency}" is not a currency code`);
+        this.amount = Decimal.of(amount).toString();
+        this.currency = code;
+    }
+    /**
+     * What the server sent — `{ amount, currency }`, the amount as text or as a JSON number taken
+     * by its digits. Anything else is refused, naming what is wrong.
+     */
+    static fromJSON(value) {
+        if (value instanceof Money)
+            return value;
+        if (value === null || typeof value !== "object")
+            throw new TypeError(`${JSON.stringify(value)} is not a money: { amount, currency }`);
+        const { amount, currency } = value;
+        if (typeof currency !== "string")
+            throw new TypeError(`a money without its currency: ${JSON.stringify(value)}`);
+        if (typeof amount !== "string" && typeof amount !== "number")
+            throw new TypeError(`a money without its amount: ${JSON.stringify(value)}`);
+        return new Money(amount, currency);
+    }
+    /** Whether `value` has the shape of a money on the wire: `{ amount, currency }`. */
+    static isMoney(value) {
+        if (value instanceof Money)
+            return true;
+        if (value === null || typeof value !== "object")
+            return false;
+        const { amount, currency } = value;
+        return (typeof currency === "string" &&
+            (typeof amount === "string" || typeof amount === "number"));
+    }
+    /** The decimals `currency` is counted in: 2 unless `Money.decimals` says otherwise. */
+    static decimalsOf(currency) {
+        return Money.decimals[currency.toUpperCase()] ?? 2;
+    }
+    /** The sum of `items`, all in `currency` — zero when there are none. Another currency is refused. */
+    static total(items, currency) {
+        let sum = new Money("0", currency);
+        for (const item of items)
+            sum = sum.plus(item);
+        return sum;
+    }
+    /** The sums by currency, each currency's own. */
+    static totals(items) {
+        const sums = {};
+        for (const item of items) {
+            const held = sums[item.currency];
+            sums[item.currency] = held === undefined ? item : held.plus(item);
+        }
+        return sums;
+    }
+    /** The amount as an exact decimal. */
+    get value() {
+        return new Decimal(this.amount);
+    }
+    /** The decimals this currency is counted in. */
+    get decimals() {
+        return Money.decimalsOf(this.currency);
+    }
+    same(other) {
+        if (other.currency !== this.currency)
+            throw new TypeError(`${other.currency} cannot be added to ${this.currency} — sum each currency apart (Money.totals)`);
+        return other;
+    }
+    plus(other) {
+        return new Money(this.value.plus(this.same(other).amount), this.currency);
+    }
+    minus(other) {
+        return new Money(this.value.minus(this.same(other).amount), this.currency);
+    }
+    /** Times a quantity, a rate or a percentage as a fraction: exact, never rounded. */
+    times(factor) {
+        return new Money(this.value.times(factor), this.currency);
+    }
+    /** Over `divisor`, rounded half up to the currency's decimals (or `decimals`). */
+    dividedBy(divisor, decimals = this.decimals) {
+        return new Money(this.value.dividedBy(divisor, decimals), this.currency);
+    }
+    /** Rounded half up to the currency's decimals (or `decimals`): what an invoice shows. */
+    rounded(decimals = this.decimals) {
+        return new Money(this.value.rounded(decimals), this.currency);
+    }
+    negated() {
+        return new Money(this.value.negated(), this.currency);
+    }
+    /** `-1`, `0` or `1`, in the same currency. */
+    compare(other) {
+        return this.value.compare(this.same(other).amount);
+    }
+    /** The same currency and the same amount: `10.5 BOB` equals `10.50 BOB`. */
+    equals(other) {
+        return other.currency === this.currency && this.value.equals(other.amount);
+    }
+    /** Zero at the currency's decimals: `0.004 BOB` is. */
+    get isZero() {
+        return this.rounded().value.isZero;
+    }
+    get isNegative() {
+        return this.rounded().value.isNegative;
+    }
+    get isPositive() {
+        return this.rounded().value.isPositive;
+    }
+    toJSON() {
+        return { amount: this.amount, currency: this.currency };
+    }
+    /** `"10.50 BOB"` — for a log or a test; a person reads it through `Intl.NumberFormat`. */
+    toString() {
+        return `${this.amount} ${this.currency}`;
+    }
+}

package/dist/common/serialization.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 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`.
+ */
+/** A value JSON writes as it is. */
+export type JsonValue = null | boolean | number | string | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** The tag bytes travel under. */
+export declare const BYTES = "$bytes";
+/** What `rebuilt` reads values as: a class with `fromJSON` (`Money`), or a function. */
+export type Rebuild<T> = {
+    fromJSON(values: unknown): T;
+} | ((values: unknown) => T);
+/**
+ * `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 declare function valuesOf(value: unknown): JsonValue;
+/** What `valuesOf` wrote, from JSON text or already parsed — each tagged bytes back as bytes. */
+export declare function readValues(text: string | unknown): unknown;
+/** `values` read as `of` — `Money`, a DTO's own reader — or as they are without one. */
+export declare function rebuilt<T = unknown>(values: unknown, of?: Rebuild<T>): T;
+/** `value` as JSON text — see `valuesOf`. */
+export declare function pack(value: unknown): string;
+/** What `pack` wrote, read as `of` — see `rebuilt`. */
+export declare function unpack<T = unknown>(text: string, of?: Rebuild<T>): T;

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/index.d.ts

@@ -6,8 +6,10 @@
  * (`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/ the bounded context (`UseBoundedContext`), its `Feature` and `ApplicationService`,
  *             the process they run in (`configureProcess`), what each run carries
@@ -19,11 +21,16 @@
  */
 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";

package/dist/index.js

@@ -6,8 +6,10 @@
  * (`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/ the bounded context (`UseBoundedContext`), its `Feature` and `ApplicationService`,
  *             the process they run in (`configureProcess`), what each run carries
@@ -19,11 +21,16 @@
  */
 export { entityKeyOf, kindOf, metasOf, versionsOf, } from "./client/contract.js";
 export { bodyFor, entity, listRoute, NEW_PARAM, pathFor, PICK_PARAM, QUERY_PARAM, SCOPE_PARAM, scopeOfRef, startingValuesOf, TRAIL_PARAM, WITH_PARAM, writeRoute, } from "./client/entity.js";
-export { isEntityId, newEntityId } from "./client/ids.js";
 export { memoryTransport, } from "./client/memory.js";
 export { restTransport, urlOf, } from "./client/rest.js";
 export { retryKeys, unanswered, } from "./client/retry.js";
 export { readRoute, TransportError, } from "./client/transport.js";
+export { Decimal } from "./common/decimal.js";
+export { isEntityId, momentOf, newEntityId } from "./common/ids.js";
+export { Money } from "./common/money.js";
+export { BYTES, pack, readValues, rebuilt, unpack, valuesOf, } from "./common/serialization.js";
+export { dayOf, installTimeZone, instantOf, isDay, timeZoneNow, wallTimeOf, } from "./common/time.js";
+export { plainCodec, travelling, travels, } from "./context/codec.js";
 export {} from "./context/context.js";
 export { memoryContexts, } from "./context/store.js";
 export { defineMeta, field, } from "./model/meta.js";

package/dist/services/bounded-context.js

@@ -1,4 +1,4 @@
-import { newEntityId } from "../client/ids.js";
+import { newEntityId } from "../common/ids.js";
 import { contextAt } from "../context/context.js";
 import { bindDependency } from "./execution.js";
 import { composes, isApplicationServiceClass, isFeatureClass, methodsOf, } from "./feature.js";

package/dist/services/execution.d.ts

@@ -33,8 +33,8 @@ export type Bindable<T> = {
 };
 /**
  * What every request of an execution carries: its trace (`traceparent`, W3C) and its context
- * (`sincpro-context`, the header sincpro_framework's entrances read). Nothing when there is no
- * trace and no context.
+ * (`sincpro-context`, the header sincpro_framework's entrances read, written with `plainCodec`).
+ * Nothing when there is no trace and no context that travels.
  */
 export declare function headersOf(execution: Execution): Record<string, string>;
 /**

package/dist/services/execution.js

@@ -1,3 +1,4 @@
+import { plainCodec, travels } from "../context/codec.js";
 /**
  * A dependency that has something to say about the execution it is used in: given that
  * execution, it answers itself bound to it. The transport and every generated client are;
@@ -19,8 +20,8 @@ function isTransport(value) {
 }
 /**
  * What every request of an execution carries: its trace (`traceparent`, W3C) and its context
- * (`sincpro-context`, the header sincpro_framework's entrances read). Nothing when there is no
- * trace and no context.
+ * (`sincpro-context`, the header sincpro_framework's entrances read, written with `plainCodec`).
+ * Nothing when there is no trace and no context that travels.
  */
 export function headersOf(execution) {
     const headers = {};
@@ -31,8 +32,9 @@ export function headersOf(execution) {
         if (span.state)
             headers["tracestate"] = span.state;
     }
-    if (Object.keys(context).length > 0)
-        headers["sincpro-context"] = JSON.stringify(context);
+    // Only what travels: an object or a function held in the context stays in this process.
+    if (Object.values(context).some(travels))
+        headers["sincpro-context"] = plainCodec.dumps(context);
     return headers;
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sincpro/client-framework",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "The client side of sincpro_framework, for every platform: Feature and ApplicationService traced and reported by default, applications made of domains, and the typed client generated from a service's contract. No React, no DOM.",
   "type": "module",
   "main": "./dist/index.js",