@toa.io/core 1.0.0-alpha.292 → 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/CHANGELOG.md

@@ -1,43 +0,0 @@
-# Change Log
-
-All notable changes to this project will be documented in this file.
-See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
-
-# [1.0.0-alpha.292](https://github.com/toa-io/toa/compare/v1.0.0-alpha.291...v1.0.0-alpha.292) (2026-09-07)
-
-**Note:** Version bump only for package @toa.io/core
-
-
-
-
-
-# [1.0.0-alpha.291](https://github.com/toa-io/toa/compare/v1.0.0-alpha.290...v1.0.0-alpha.291) (2026-09-07)
-
-**Note:** Version bump only for package @toa.io/core
-
-
-
-
-
-# [1.0.0-alpha.289](https://github.com/toa-io/toa/compare/v1.0.0-alpha.288...v1.0.0-alpha.289) (2026-09-07)
-
-* A deploy moves only what changed, and a component sees none of the runtime's environment (#1073) ([f38e3db](https://github.com/toa-io/toa/commit/f38e3db533f24db866c57bfa1ef294eff1eaf499)), closes [#1073](https://github.com/toa-io/toa/issues/1073) [#1064](https://github.com/toa-io/toa/issues/1064) [#1066](https://github.com/toa-io/toa/issues/1066) [#1067](https://github.com/toa-io/toa/issues/1067) [#1068](https://github.com/toa-io/toa/issues/1068) [#1069](https://github.com/toa-io/toa/issues/1069) [#1071](https://github.com/toa-io/toa/issues/1071) [#1070](https://github.com/toa-io/toa/issues/1070) [#1072](https://github.com/toa-io/toa/issues/1072)
-
-### BREAKING CHANGES
-
-* a component that read `process.env.TOA_*` reads `context` instead;
-  `echo(input)` no longer substitutes from the environment; a bash operation sees no
-  `TOA_*`; images no longer set `USER node` — see migrations/289.md.
-
-
-# [1.0.0-alpha.288](https://github.com/toa-io/toa/compare/v1.0.0-alpha.287...v1.0.0-alpha.288) (2026-09-06)
-
-**Note:** Version bump only for package @toa.io/core
-
-
-
-
-
-# [1.0.0-alpha.287](https://github.com/toa-io/toa/compare/v1.0.0-alpha.286...v1.0.0-alpha.287) (2026-09-06)
-
-**Note:** Version bump only for package @toa.io/core

package/source/assignment.ts

@@ -1,27 +0,0 @@
-import { Operation } from './operation.js'
-import type { Store } from './operation.js'
-import type { Changeset } from './entities/changeset.js'
-
-export class Assignment extends Operation {
-  protected override async acquire(store: Store): Promise<void> {
-    const changeset = this.scope.changeset(store.request.query as any)
-
-    store.scope = changeset
-    store.state = changeset.get()
-  }
-
-  protected override async commit(store: Store): Promise<void> {
-    const { scope, state, reply, request } = store
-
-    if (reply.error !== undefined) return
-
-    const changeset = scope as Changeset
-
-    changeset.set(state)
-
-    const output = await this.scope.apply(changeset, request.input)
-
-    // assignment returns new state by default
-    if (store.reply.output === undefined) store.reply.output = output
-  }
-}

package/source/call.ts

@@ -1,63 +0,0 @@
-import { Readable } from 'node:stream'
-import { current, encode } from 'openspan'
-import { Connector } from './connector.js'
-import type { Transmission } from './transmission.js'
-import type { Request as Contract } from './contract/request.js'
-import type { Request, Source } from './types/request.js'
-
-export class Call extends Connector {
-  readonly #transmitter: Transmission
-  readonly #contract: Contract
-  readonly #source: Source | undefined
-
-  public constructor(transmitter: Transmission, contract: Contract, source?: Source) {
-    super()
-
-    this.#transmitter = transmitter
-    this.#contract = contract
-    this.#source = source
-
-    this.depends(transmitter)
-  }
-
-  public async invoke(request: Request = {}): Promise<any> {
-    // the caller may have attributed the call itself, as the node bridge does
-    if (this.#source !== undefined) request.source ??= this.#source
-
-    this.#contract.fit(request)
-
-    // an operation that takes no input still has to send an explicit null
-    request.input ??= null
-
-    // avoid validation on the recipient's side
-    request.authentic = true
-
-    const context = current()
-
-    if (context !== undefined) request.telemetry = encode(context)
-
-    const reply = await this.#transmitter.request(request)
-
-    if (reply === null) return null
-    else if (reply instanceof Readable) return reply
-    else {
-      if (reply.exception !== undefined) throw reply.exception
-
-      if (reply.error !== undefined) return new RemoteError(reply.error)
-      else return reply.output
-    }
-  }
-
-  public explain(): any {
-    return this.#contract.discovery
-  }
-}
-
-// the remote error as a value: every property it carries, and nothing else enumerable
-class RemoteError extends Error {
-  public constructor(error: object) {
-    super()
-
-    Object.assign(this, error)
-  }
-}

package/source/cascade.ts

@@ -1,32 +0,0 @@
-import { Connector } from './connector.js'
-import type { Algorithm } from './types/bridges.js'
-
-export class Cascade extends Connector {
-  readonly #last: Algorithm
-
-  public constructor(bridges: Algorithm[], preflight?: Connector) {
-    super()
-
-    // this.#bridges = bridges
-    this.#last = bridges[bridges.length - 1]
-
-    if (preflight === undefined) this.depends(bridges)
-    else this.depends(bridges).depends(preflight)
-  }
-
-  public async run(...args: [any, any?]): Promise<any> {
-    // const reply = {}
-    //
-    // for (const bridge of this.#bridges) {
-    //   const partial = await bridge.execute(...args)
-    //
-    //   if (partial.error) return { error: partial.error }
-    //
-    //   merge(reply, partial)
-    // }
-    //
-    // return reply
-
-    return this.#last.execute(...args)
-  }
-}

package/source/component.ts

@@ -1,83 +0,0 @@
-import assert from 'node:assert'
-import { console, current, decode, run, type SpanOptions } from 'openspan'
-import { Connector } from './connector.js'
-import type { Locator } from './locator.js'
-import type { Request } from './types/request.js'
-
-/** What a component holds one of per endpoint: an operation, or the call that stands for it. */
-export interface Invocable extends Connector {
-  invoke: (request: Request) => Promise<any>
-}
-
-export class Component<O extends Invocable = Invocable> extends Connector {
-  public readonly locator: Locator
-
-  protected readonly operations: Record<string, O>
-
-  protected kind: 'server' | 'client' = 'server'
-
-  /** span options per endpoint */
-  readonly #spans: Record<string, SpanOptions> = {}
-
-  public constructor(locator: Locator, operations: Record<string, O>) {
-    super()
-
-    this.locator = locator
-    this.operations = operations
-
-    Object.values(operations).forEach((operation) => this.depends(operation))
-  }
-
-  public async invoke<T = any>(endpoint: string, request?: Request): Promise<T> {
-    if (!(endpoint in this.operations))
-      // `assert.fail`, not `assert.ok`: the message is built only when it is needed
-      assert.fail(`Endpoint '${endpoint}' is not provided by '${this.locator.id}'`)
-
-    // if the request carries no telemetry, the trace starts here
-    const remote = request?.telemetry === undefined ? null : decode(request.telemetry)
-    const task = async (): Promise<any> => this.#process(endpoint, request)
-
-    if (remote === null) return task()
-    else return run(remote, task)
-  }
-
-  async #process(endpoint: string, request?: Request): Promise<any> {
-    return console.span(this.#span(endpoint), async () => {
-      const reply = await this.operations[endpoint].invoke(request as Request)
-
-      if (reply?.exception !== undefined) {
-        const span = current()
-
-        if (span !== undefined) span.status = 'error'
-
-        console.error('Failed to execute operation', {
-          endpoint: `${this.locator.id}.${endpoint}`,
-          exception: reply.exception
-        })
-      }
-
-      return reply
-    })
-  }
-
-  /**
-   * The span of an endpoint never changes, so it is built once. Not in the constructor:
-   * `kind` is a field of the subclass, and those are assigned after this one is built.
-   *
-   */
-  #span(endpoint: string): SpanOptions {
-    let options = this.#spans[endpoint]
-
-    if (options === undefined) {
-      options = { name: `${this.locator.id}.${endpoint}`, kind: this.kind }
-
-      // the server span is emitted by the component itself, while the client span
-      // belongs to the calling service and inherits it from the context
-      if (this.kind === 'server') options.service = this.locator.id
-
-      this.#spans[endpoint] = options
-    }
-
-    return options
-  }
-}

package/source/composition.ts

@@ -1,27 +0,0 @@
-import { console } from 'openspan'
-import { Connector } from './connector.js'
-
-export class Composition extends Connector {
-  // eslint-disable-next-line max-params
-  public constructor(
-    expositions: Connector[],
-    producers: Connector[],
-    receivers: Connector[],
-    tenants: Connector[]
-  ) {
-    super()
-
-    if (expositions.length > 0) this.depends(expositions)
-    if (producers.length > 0) this.depends(producers)
-    if (receivers.length > 0) this.depends(receivers)
-    if (tenants.length > 0) this.depends(tenants)
-  }
-
-  protected override async open(): Promise<void> {
-    console.info('Composition complete')
-  }
-
-  protected override async dispose(): Promise<void> {
-    console.info('Composition shutdown complete')
-  }
-}