@toa.io/core 1.0.0-alpha.293 → 1.0.0-alpha.299

package/transpiled/trail.js

@@ -0,0 +1,98 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { environment } from '@toa.io/generic';
+import { LoopException } from './exceptions.js';
+/**
+ * The chain of hops the invocation running now passed through, and the rule that refuses one
+ * that has come back to where it had been.
+ *
+ * Ambient, like the trace context and for the same reason: an algorithm's `context` is built
+ * once per operation at boot and shared by every invocation of it, so nothing per-invocation
+ * can be handed to it. It is not the trace context's own store, which `console.span` replaces
+ * on every span and does not enter at all when the trace is unsampled — a chain that
+ * disappears under sampling is a breaker that stops breaking in production.
+ *
+ * One writer, `Component.invoke`, where the hop is appended; two readers, `Call.invoke`, which
+ * puts it on the request it is about to send, and `Outbox.row`, which writes it onto the row so
+ * it outlives the operation that caused it.
+ */
+// as openspan holds its own: a process may carry two copies of this module, and a chain that
+// is empty because the writer sat in the other one is a breaker that never fires
+const KEY = Symbol.for('toa.core.trail');
+const storage = (globalThis[KEY] ??= new AsyncLocalStorage());
+/**
+ * What the environment says, read where a component is built rather than once for the process,
+ * as the outbox reads its own — so a composition booted after a variable was set sees it.
+ *
+ * `TOA_TRAIL_REPEATS=0` refuses nothing: the chain is still stamped, carried and bounded. It is
+ * the off switch, and it exists because this refuses calls an application may be making today —
+ * a handshake written as `a > b > a > b > a` is three occurrences of one hop. A breaker with no
+ * way to open it is itself the outage.
+ */
+export function limits() {
+    return {
+        repeats: number('TOA_TRAIL_REPEATS', 3),
+        depth: number('TOA_TRAIL_DEPTH', 32)
+    };
+}
+/** The chain that led to the invocation running now, where there is one. */
+export function current() {
+    return storage.getStore();
+}
+/** Runs `task` as the hop the chain now ends with. */
+export async function follow(hops, task) {
+    return storage.run(hops, task);
+}
+/**
+ * The chain this hop makes, or a raise where it is one hop too many: a hop already taken
+ * `repeats` times is a cycle, and a chain past `depth` is one nothing meant to make. Both are
+ * permanent, so what hits one is set aside rather than tried again into the same loop.
+ *
+ * The chain is copied rather than appended to, which is what makes it a path down the call
+ * tree rather than a log of everything that happened — an operation calling one endpoint fifty
+ * times makes fifty chains of one hop, not one chain of fifty.
+ */
+export function extend(inbound, hop, limits) {
+    const hops = clip(received(inbound), limits.depth);
+    const trail = [...hops, hop];
+    if (limits.repeats === 0)
+        return trail;
+    if (trail.length > limits.depth)
+        throw new LoopException(`Call chain is ${trail.length} hops deep`, trail);
+    let seen = 0;
+    for (const passed of hops)
+        if (passed === hop)
+            seen++;
+    if (seen + 1 >= limits.repeats)
+        throw new LoopException(`'${hop}' is hop ${seen + 1} of this chain`, trail);
+    return trail;
+}
+/**
+ * How an event is named in a chain. The sigil is what tells it from an operation: the two are
+ * the same shape, a component may declare one of each under a single name, and `sync` is both
+ * the event every component inherits and an ordinary name for an operation.
+ *
+ * What an operator rewires to break a cycle is the subscription rather than the operation, so a
+ * chain that named only operations would not say how a component was re-entered.
+ */
+export function event(destination) {
+    return '~' + destination;
+}
+/**
+ * What came off the wire, as a chain and nothing else. Neither the request contract nor a
+ * message validates this — a request is not validated at all once it is `authentic` — so a
+ * malformed one would otherwise become a `TypeError` where a named exception was contracted
+ * for. Bounding it is `extend`'s, one hop later, which is the only place the limits are known.
+ */
+export function received(value) {
+    return Array.isArray(value) ? value.filter((hop) => typeof hop === 'string') : [];
+}
+// with the hop being appended that is one past the cap, which is enough to be refused; the
+// rest is a message buying memory, and where the rule is off it is what bounds the chain
+function clip(hops, depth) {
+    return hops.length > depth ? hops.slice(0, depth) : hops;
+}
+function number(variable, fallback) {
+    const declared = Number(environment.get(variable));
+    return Number.isNaN(declared) || declared < 0 ? fallback : declared;
+}
+//# sourceMappingURL=trail.js.map

package/transpiled/trail.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trail.js","sourceRoot":"","sources":["../source/trail.ts"],"names":[],"mappings":"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"}

package/transpiled/types/bindings.d.ts

@@ -39,4 +39,26 @@ export interface Factory {
     /** `group` is absent for an exclusive subscription */
     receiver?(locator: Locator, label: string, group: string | undefined, receiver: Receiver): Connector;
     broadcast?(name: string, group?: string): Broadcast;
+    /**
+     * A channel is a name the caller picks, from which the binding derives whatever its
+     * transport needs, and `uris` are the brokers to carry it over — so a second broker set
+     * costs the binding no configuration and no variable of its own.
+     */
+    outbound?(channel: string, uris: string[]): Outbound;
+    /** what arrives on `channel` under `label` */
+    inbound?(channel: string, uris: string[], label: string, sink: Inbound): Connector;
+}
+/**
+ * Publishes to a channel, addressed by label. It forwards messages and nothing else: what
+ * `send` is handed is what is published, with no envelope, no field and no header of the
+ * binding's own, and none stripped — because a message shape is often somebody else's
+ * contract, and an extension shipping changes into another system must be able to send
+ * exactly what that system accepts.
+ */
+export interface Outbound extends Connector {
+    send(label: string, message: object): Promise<void>;
+}
+/** What a binding hands a message to. */
+export interface Inbound {
+    accept(message: object): Promise<void>;
 }

package/transpiled/types/extensions.d.ts

@@ -5,9 +5,10 @@ import type { Remote } from '../remote.js';
 import type { Receiver } from './receiver.js';
 import type { Context } from '../context.js';
 import type { Storage } from './storages.js';
-import type { Broadcast, Emitter } from './bindings.js';
+import type { Broadcast, Emitter, Inbound, Outbound } from './bindings.js';
 import type { Atom } from './atomicity.js';
 import type { Source } from './request.js';
+import type { Destination } from './outbox.js';
 /**
  * What the process hosting an extension provides to it: the counterpart of a component's
  * context. What is returned is a connector the extension depends on.
@@ -23,6 +24,10 @@ export interface Host {
     receive(label: string, receiver: Receiver): Promise<Connector>;
     /** what the replicas of one group decide together */
     atom(group: string): Atom;
+    /** where this deployment publishes a channel, over the brokers named */
+    outbound(binding: string, channel: string, uris: string[]): Promise<Outbound>;
+    /** what arrives on a channel under one label */
+    inbound(binding: string, channel: string, uris: string[], label: string, sink: Inbound): Promise<Connector>;
 }
 /**
  * `Manifest` is a type parameter rather than an import: `@toa.io/norm` depends on core, so
@@ -31,12 +36,18 @@ export interface Host {
 export interface Factory<Manifest = unknown> {
     tenant?(locator: Locator, declaration: any, manifest: Manifest): Connector | Promise<Connector>;
     aspect?(locator: Locator, declaration: any): Aspect | Aspect[];
+    /**
+     * Where a committed state change of this component goes, beside its own events. Read before
+     * the storage is made, because one of these is what gives a component an outbox when it
+     * declares no event at all.
+     */
+    destination?(locator: Locator, declaration: any, manifest: Manifest): Destination | Promise<Destination> | undefined;
     /** what the extension runs as a process of its own; `null` where it is off here */
     service?(): Connector | null | Promise<Connector | null>;
     component?(component: Component): Component;
     context?(context: Context): Context;
     manage?(composition: Connector): Connector;
-    storage?(storage: Storage): Storage;
+    storage?(storage: Storage, locator: Locator): Storage;
     emitter?(emitter: Emitter, label: string, locator: Locator): Emitter;
     receiver?(receiver: Receiver, locator: Locator): Receiver;
 }

package/transpiled/types/message.d.ts

@@ -2,4 +2,9 @@ export interface Message<T = any> {
     payload: T;
     /** W3C traceparent */
     telemetry?: string;
+    /**
+     * The hops that led to the state change this is about, so a receiver of it continues the
+     * chain rather than starting one. See `core/source/trail.ts`.
+     */
+    trail?: string[];
 }

package/transpiled/types/outbox.d.ts

@@ -1,3 +1,4 @@
+import type { Connector } from '../connector.js';
 import type { Event } from './state.js';
 /**
  * The intent to publish, committed with the state change it belongs to. Everything about it
@@ -8,21 +9,46 @@ export interface Row {
     id: string;
     /** which replica pumps this row; carries no other meaning, and no ordering */
     lane: number;
+    /** settled for every destination */
     published: boolean;
     /** not before this */
     pending: number;
+    /** the destinations it has not been sent to yet, by name */
+    outstanding: string[];
+    /**
+     * The hops that led to the change. Written onto the row rather than left in scope, because
+     * the pump publishes off the operation's path — possibly in another replica, an hour later.
+     * Absent on a row written before this existed, which reads as a chain that starts there.
+     */
+    trail?: string[];
     /** an assignment's images are absent until the storage fills them in */
     event: Event;
 }
+/**
+ * Somewhere a committed state change goes. A component's `Emission` is one, under the name
+ * `events`; an extension may contribute others, and each is published and settled on its own,
+ * so one that is down delays nothing but itself.
+ */
+export interface Destination extends Connector {
+    /** what a row is outstanding for, as the row records it */
+    readonly name: string;
+    /** the row, not its event: what goes on the wire is the chain it carries too */
+    emit(row: Row): Promise<void>;
+}
 /**
  * The read side of an outbox. What writes a row is the storage's own: it happens inside the
  * transaction the storage opened, which core never reaches into.
  */
 export interface Storage {
     /**
-     * One page of what is due, still unpublished, and in one of the given lanes, in the order
-     * the rows were written. `after` continues from the last id of the page before.
+     * One page of what is due, not settled for every destination, and in one of the given lanes,
+     * in the order the rows were written. `after` continues from the last id of the page before.
      */
     pending(lanes: number[], now: number, limit: number, after?: string): Promise<Row[]>;
-    settle(ids: string[]): Promise<void>;
+    /**
+     * Takes `destinations` out of what those rows are outstanding for, and marks published the
+     * ones left outstanding for nothing. Several destinations at once, because the ordinary case
+     * is all of them landing in one window, and that is then one write.
+     */
+    settle(ids: string[], destinations: string[]): Promise<void>;
 }

package/transpiled/types/request.d.ts

@@ -38,6 +38,11 @@ export interface Request<Input = any, Entity = any> {
     /** W3C traceparent */
     telemetry?: string;
     source?: Source;
+    /**
+     * The hops this call passed through, oldest first. Stamped by the framework; a call that has
+     * been where it is going already is refused rather than made. See `core/source/trail.ts`.
+     */
+    trail?: string[];
 }
 /**
  * An error an operation declares and returns. A call resolves to it rather than throwing:

package/transpiled/types/storages.d.ts

@@ -19,6 +19,8 @@ export interface Record {
     UPDATED?: number;
     /** a tombstone's timestamp; `null` on a live record */
     DELETED?: number | null;
+    /** the rank of the region that last wrote it; `0` where there is one region */
+    REGION?: number;
     [key: string]: any;
 }
 /** Everything a request query carried that was not a selector. */
@@ -81,6 +83,24 @@ export interface Storage extends Connector {
      * starting with a structure nothing has made.
      */
     readonly migrates?: boolean;
+    /**
+     * Writes `record` as it stands — its `VERSION`, its timestamps, its `REGION` and whatever
+     * else it carries — where what it would replace precedes it: a lower `VERSION`, or the same
+     * `VERSION` written by a region this one outranks. `false` where it does not: nothing is
+     * written, and that is not an error.
+     *
+     * Both sides of the comparison are on the two records, so this takes nothing else. What it
+     * is for is a record that was written somewhere else and has to land here as it was, which
+     * is neither a transition nor an assignment: it is not the writer's version to increment,
+     * nor its timestamps to set.
+     */
+    converge?(record: Record): Promise<boolean>;
+    /**
+     * Whether this storage converges. Absent is what a storage that does not says, and a
+     * component of a context that converges stands down rather than running where it would
+     * never take a record from another region.
+     */
+    readonly converges?: boolean;
 }
 /**
  * The subset of a component's entity declaration a storage reads. Structural, so that core

package/transpiled/outbox/index.d.ts

@@ -1 +0,0 @@
-export { Outbox, LANES } from './outbox.js';

package/transpiled/outbox/index.js

@@ -1,2 +0,0 @@
-export { Outbox, LANES } from './outbox.js';
-//# sourceMappingURL=index.js.map

package/transpiled/outbox/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../source/outbox/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA"}

package/transpiled/outbox/outbox.js

@@ -1,268 +0,0 @@
-import { console } from 'openspan';
-import { Connector } from '../connector.js';
-import { newid } from '../entities/newid.js';
-import { environment } from '@toa.io/generic';
-/**
- * Owns the intent to publish. A row is built before the write so that the storage can commit
- * it in the same transaction as the entity; publication then happens off the operation's path,
- * and anything that fails to publish is recovered from the row.
- *
- * The mechanism is a safety net: in a healthy system the row is written, published within
- * milliseconds by the same process, and marked published on that process's next tick.
- *
- * A storage that cannot commit a row atomically has no outbox, and this degrades to the
- * inline emission it replaces.
- */
-export class Outbox extends Connector {
-    #emission;
-    #storage;
-    #atom;
-    #gap;
-    #interval;
-    #batch;
-    #defer;
-    /** ids this process has published, held until a cycle marks them */
-    #published = new Set();
-    /** in-flight publications, awaited (with a bound) on close */
-    #inflight = new Set();
-    /** rows this replica is publishing right now, so a cycle does not pick them up again */
-    #publishing = new Set();
-    #timer;
-    #off;
-    #pumping = false;
-    #closing = false;
-    // eslint-disable-next-line max-params
-    constructor(emission, storage, atom, options = {}) {
-        super();
-        this.#emission = emission;
-        this.#storage = storage;
-        this.#atom = atom;
-        this.#interval = number('TOA_OUTBOX_INTERVAL', options.interval, INTERVAL);
-        this.#batch = number('TOA_OUTBOX_BATCH', options.batch, BATCH);
-        this.#gap = options.gap ?? this.#interval * K;
-        this.#defer = environment.get('TOA_OUTBOX_DEFER') === '1';
-        this.depends(emission);
-        this.depends(atom);
-        if (storage !== undefined)
-            this.depends(storage);
-    }
-    /** whether the storage can commit a row atomically with the entity */
-    get durable() {
-        return this.#storage?.outbox !== undefined;
-    }
-    /**
-     * An assignment's images are the write's own, so it hands over an event with neither, and
-     * the storage fills them in.
-     */
-    row(event) {
-        return {
-            id: newid(),
-            lane: this.#lane(),
-            published: false,
-            pending: Date.now() + this.#gap,
-            event: event
-        };
-    }
-    /**
-     * Hands a committed row over. Awaited by the caller only on the legacy path — with an
-     * outbox this returns at once and the broker leaves the operation's path.
-     */
-    publish(row) {
-        // without a durable outbox this is the inline path, and the caller awaits the emission
-        if (!this.durable)
-            return this.#emission.emit(row.event);
-        /*
-         * A publication started while the pump is closing would outlive the emitters it needs,
-         * and `comq` waits on a connection that is going rather than failing. The row is already
-         * durable, so leaving it is exactly what it is for.
-         */
-        if (this.#closing ||
-            this.#defer ||
-            this.#inflight.size >= INFLIGHT ||
-            this.#published.size >= PUBLISHED)
-            return;
-        void this.#publish(row);
-    }
-    async open() {
-        if (!this.durable)
-            return;
-        if (this.#defer)
-            console.warn('Outbox immediate publication is deferred; events are published by the pump only');
-        this.#timer = setInterval(() => {
-            this.#tick();
-        }, this.#interval);
-        this.#timer.unref();
-        /*
-         * A lane changing hands is exactly when rows stranded in it become this replica's to
-         * publish, and the cycle would not notice for up to an interval. Being told costs a cycle
-         * that finds nothing in the usual case, where the claim arrives once and never changes.
-         */
-        this.#off = this.#atom.onassigned(() => {
-            this.#tick();
-        });
-    }
-    async close() {
-        this.#closing = true;
-        this.#off?.();
-        if (this.#timer !== undefined)
-            clearInterval(this.#timer);
-        await this.#drain();
-        await this.#mark();
-    }
-    /**
-     * Publishes one row and swallows the failure: the row stays unpublished and comes back on a
-     * later cycle, which is the whole point of having written it.
-     *
-     * There is no timeout here on purpose. A publication is a confirmed write to a durable
-     * exchange, and `comq` waits for the broker to come back rather than failing — abandoning
-     * it would not stop it, it would only mean the row is published twice once it lands. What
-     * bounds this instead is the in-flight cap and the drain on close.
-     *
-     */
-    async #publish(row) {
-        this.#publishing.add(row.id);
-        const publishing = this.#emission.emit(row.event);
-        this.#inflight.add(publishing);
-        try {
-            await publishing;
-            this.#published.add(row.id);
-        }
-        catch (error) {
-            console.warn('Event publication failed', { row: row.id, error });
-        }
-        finally {
-            this.#inflight.delete(publishing);
-            this.#publishing.delete(row.id);
-        }
-    }
-    /**
-     * `comq` retries a publish for as long as the broker is down rather than rejecting, so an
-     * unbounded drain outlives any grace period.
-     *
-     */
-    async #drain() {
-        if (this.#inflight.size === 0)
-            return;
-        await Promise.race([Promise.allSettled([...this.#inflight]), delay(DRAIN)]);
-    }
-    /**
-     * Reads what is due, publishes it, and marks everything this process has sent — what it just
-     * published and what the immediate path published since the last cycle. One cycle at a time.
-     *
-     */
-    #tick() {
-        if (this.#pumping)
-            return;
-        this.#pumping = true;
-        void this.#pump().finally(() => (this.#pumping = false));
-    }
-    async #pump() {
-        let page;
-        let after;
-        do {
-            page = await this.#read(after);
-            if (page.length === 0)
-                break;
-            // so a page is never read twice
-            after = page[page.length - 1]?.id;
-            /*
-             * A row is unpublished in the database until a cycle marks it, so a page includes what
-             * this replica is sending right now and what a failed marking left behind. Only this
-             * process knows either.
-             */
-            const rows = page.filter((row) => !this.#published.has(row.id) && !this.#publishing.has(row.id));
-            if (rows.length > 0) {
-                console.info('Outbox recovering unpublished events', { count: rows.length });
-                // every row is given its chance; what the broker refused stays unpublished and comes
-                // back on a later cycle
-                await Promise.allSettled(rows.map(async (row) => this.#publish(row)));
-            }
-            // a full page is a page that may have been cut short
-        } while (page.length === this.#batch);
-        await this.#mark();
-    }
-    /**
-     * One page of what is due. In a healthy system the first one is empty, every cycle — a row is
-     * due only if the process that wrote it failed to publish or died before marking it.
-     *
-     * Reading is suspended, not stopped, while this replica does not know which lanes are its
-     * own: the cycle keeps running and keeps marking, and reading resumes as soon as an
-     * assignment arrives. Reading without an assignment would be a different guarantee, where
-     * every replica publishes every stranded row.
-     *
-     * @param after the last id of the page before, so a page is never read twice
-     */
-    async #read(after) {
-        const lanes = this.#atom.slots(LANES);
-        if (lanes === null || lanes.length === 0)
-            return [];
-        return this.#storage
-            .outbox.pending(lanes, Date.now(), this.#batch, after)
-            .catch((error) => {
-            console.warn('Outbox read failed', { error });
-            return [];
-        });
-    }
-    /**
-     * One batched write for many events, which is why the ids are held in memory rather than
-     * marked one by one. Ids that fail to be marked are kept and retried; a row that is never
-     * marked is simply published again, which is within the contract.
-     *
-     */
-    async #mark() {
-        if (this.#published.size === 0)
-            return;
-        const ids = [...this.#published];
-        try {
-            await this.#storage.outbox.settle(ids);
-            for (const id of ids)
-                this.#published.delete(id);
-        }
-        catch (error) {
-            console.warn('Outbox marking failed', { count: ids.length, error });
-        }
-    }
-    /**
-     * A lane this replica currently owns, so that in steady state it settles its own rows
-     * before it ever reads them. Any lane at all when it owns none: the row still has to be
-     * written, and whoever ends up owning that lane will pump it.
-     *
-     */
-    #lane() {
-        const owned = this.#atom.slots(LANES);
-        return owned === null || owned.length === 0
-            ? Math.floor(Math.random() * LANES)
-            : owned[Math.floor(Math.random() * owned.length)];
-    }
-}
-function number(variable, declared, fallback) {
-    if (declared !== undefined)
-        return declared;
-    const value = Number(environment.get(variable));
-    return Number.isNaN(value) || value <= 0 ? fallback : value;
-}
-async function delay(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms).unref();
-    });
-}
-/**
- * Constant, never configuration: rows carry their lane, so lowering this would leave rows in
- * lanes nobody reads any more. It is also the ceiling on replicas of one component, and a
- * power of two so that the common replica counts divide evenly.
- */
-export const LANES = 128;
-/** one cycle reads, publishes and marks; in steady state it finds nothing to read */
-const INTERVAL = 5000;
-/**
- * `gap = interval * K`. Not a steady-state necessity — a replica writes into a lane it owns
- * and marks what it published — but a guard for when a lane changes hands between the write
- * and the settle. Two cycles of separation, plus one of margin.
- */
-const K = 3;
-/** how many rows one read brings back; the pump reads on while a page comes back full */
-const BATCH = 200;
-const DRAIN = 10_000;
-const INFLIGHT = 1000;
-const PUBLISHED = 10_000;
-//# sourceMappingURL=outbox.js.map

package/transpiled/outbox/outbox.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"outbox.js","sourceRoot":"","sources":["../../source/outbox/outbox.ts"],"names":[],"mappings":"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"}