@toa.io/core 1.0.0-alpha.32 → 1.0.0-alpha.321

package/transpiled/types/bindings.d.ts

@@ -0,0 +1,82 @@
+import type { Readable } from 'node:stream';
+import type { Connector } from '../connector.ts';
+import type { Locator } from '../locator.ts';
+import type { Component } from '../component.ts';
+import type { Receiver } from './receiver.ts';
+import type { Message } from './message.ts';
+import type { Reply, Request } from './request.ts';
+/** What a binding module exports beside its factory. */
+export interface Properties {
+    /** delivers asynchronously; an event's binding must */
+    async?: boolean;
+    /** in-process: its producers are connected first and torn down last */
+    local?: boolean;
+    /** carries a call whose input holds a stream; an endpoint that takes one is offered to no other */
+    streams?: boolean;
+}
+/**
+ * How a call is carried, as its caller settled it. None of it is part of the request, and none of
+ * it is sent as part of one.
+ */
+export interface Terms {
+    /** the process an addressed call goes to */
+    instance?: string;
+    /** milliseconds the caller of an addressed call waits */
+    timeout?: number;
+    /** aborts when the caller stops waiting */
+    signal?: AbortSignal;
+}
+export interface Consumer extends Connector {
+    /**
+     * `false` says this binding does not carry the endpoint, and the transmission tries the
+     * next one. A `Readable` is a streamed reply.
+     */
+    request(request: Request, terms?: Terms): Promise<Reply | Readable | false>;
+    /**
+     * Absent where the binding cannot enqueue — a transmission skips a binding that offers
+     * no `task` rather than failing over it.
+     */
+    task?(request: Request): Promise<void>;
+}
+export interface Emitter extends Connector {
+    emit(message: Message): Promise<void>;
+}
+export interface Broadcast<L extends string = string> extends Connector {
+    transmit<T>(label: L, payload: T): Promise<void>;
+    receive<T>(label: L, callback: (payload: T) => void | Promise<void>): Promise<void>;
+}
+export interface Factory {
+    /**
+     * `stateful` are the endpoints among `endpoints` that take addressed calls only, and
+     * `streamed` those that take one of their input properties as a stream.
+     */
+    producer(locator: Locator, endpoints: string[], component: Component, stateful?: string[], streamed?: string[]): Connector;
+    consumer(locator: Locator, endpoint: string): Consumer;
+    /** only the binding an event declares is asked for one */
+    emitter?(locator: Locator, label: string): Emitter;
+    /** `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/bindings.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bindings.js.map

package/transpiled/types/bindings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bindings.js","sourceRoot":"","sources":["../../source/types/bindings.ts"],"names":[],"mappings":""}

package/transpiled/types/bridges.d.ts

@@ -0,0 +1,41 @@
+import type { Readable } from 'node:stream';
+import type { Connector } from '../connector.ts';
+import type { Context } from '../context.ts';
+import type { Event as StateEvent } from './state.ts';
+import type { Reply, Request } from './request.ts';
+/**
+ * What runs one endpoint. `mount` and `unmount` are the component author's, called by the
+ * bridge as it opens and closes; core only ever asks for `execute`.
+ */
+export interface Algorithm extends Connector {
+    execute(input: any, scope?: object | object[]): Promise<Reply | Readable>;
+}
+export interface Event extends Connector {
+    condition(event: StateEvent): Promise<boolean>;
+    payload(event: StateEvent): Promise<object>;
+}
+export interface Receiver extends Connector {
+    condition(payload: object): Promise<boolean>;
+    /** the trailing arguments are what the receiver declaration named */
+    request(payload: object, ...args: unknown[]): Promise<Request>;
+}
+/** Runs on every change to an entity's state, before the contract is applied. */
+export interface Guard {
+    fit(state: object, origin: object | null): boolean;
+}
+/** Connectors whose lifecycle moments are the component's. */
+export interface RunCommands {
+    preflight?: Connector;
+    settle?: Connector;
+    ready?: Connector;
+    dispose?: Connector;
+    /** what the component pauses while the process is halted, and takes again after */
+    quiescence?: Connector;
+}
+export interface Factory {
+    algorithm(path: string, endpoint: string, context: Context): Algorithm | Promise<Algorithm>;
+    event?(path: string, label: string, context: Context): Event | Promise<Event>;
+    receiver?(path: string, label: string): Receiver | Promise<Receiver>;
+    guard?(path: string, name: string, context: Context): Guard | Promise<Guard>;
+    rc?(path: string, context: Context): Promise<RunCommands | undefined>;
+}

package/transpiled/types/bridges.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bridges.js.map

package/transpiled/types/bridges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridges.js","sourceRoot":"","sources":["../../source/types/bridges.ts"],"names":[],"mappings":""}

package/transpiled/types/extensions.d.ts

@@ -0,0 +1,121 @@
+import type { Connector } from '../connector.ts';
+import type { Gate } from '../gate.ts';
+import type { Locator } from '../locator.ts';
+import type { Component } from '../component.ts';
+import type { Contract } from '../contract/component.ts';
+import type { Remote } from '../remote.ts';
+import type { Receiver } from './receiver.ts';
+import type { Context } from '../context.ts';
+import type { Storage } from './storages.ts';
+import type { Broadcast, Emitter, Inbound, Outbound } from './bindings.ts';
+import type { Atom } from './atomicity.ts';
+import type { Source } from './request.ts';
+import type { Destination } from './outbox.ts';
+/**
+ * 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.
+ */
+export interface Host {
+    /** a component of the context, by locator */
+    /**
+     * @param contract what the component provides, where the caller has it; absent, what the
+     *   process's map states.
+     */
+    remote(locator: Locator, source?: Source, contract?: Contract): Promise<Remote>;
+    /** a channel of the messaging binding */
+    broadcast<L extends string = string>(channel: string, group?: string): Promise<Broadcast<L>>;
+    /** components to run inside the extension's own process */
+    composition(paths: string[]): Promise<Connector>;
+    /** a consumer of an event of the context, `namespace.component.event` */
+    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>;
+    /**
+     * A part of this tree a halt takes down and builds again. What is not behind one of these
+     * outlives a halt: the readiness probe does, and so does whatever answers on a port the
+     * process was already listening on.
+     */
+    gate(build: () => Promise<Connector>): Gate;
+    /**
+     * Stops what this process does of its own accord — its gateway, its clocks, its run
+     * commands — and holds open everything it has. Nothing closes, so this is reversible.
+     */
+    quiesce(): Promise<void>;
+    /** Undoes a quiesce: the process works again, having been rebuilt by nothing. */
+    cancel(): Promise<void>;
+    /** Stops this process for `seconds`, then builds it again. */
+    stop(seconds: number): void;
+}
+/**
+ * `Manifest` is a type parameter rather than an import: `@toa.io/norm` depends on core, so
+ * core cannot name its types.
+ */
+export interface Factory<Manifest = unknown> {
+    /**
+     * What the package offers for each declaration it claims beside its main one: a manifest key
+     * that resolves to `package#key` is answered by `keys[key]`, and never by this.
+     */
+    keys?: Record<string, Factory<Manifest>>;
+    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>;
+    /**
+     * What the extension keeps in every process, whatever that process runs — the counterpart of
+     * `tenant` for a process rather than a component. Asked of every extension the process has
+     * loaded, and the predefined ones are loaded by every process for this.
+     *
+     * `null` where the extension keeps nothing here.
+     */
+    resident?(host: Host): Resident | null | Promise<Resident | null>;
+    component?(component: Component): Component;
+    context?(context: Context): Context;
+    manage?(composition: Connector): Connector;
+    storage?(storage: Storage, locator: Locator): Storage;
+    emitter?(emitter: Emitter, label: string, locator: Locator): Emitter;
+    receiver?(receiver: Receiver, locator: Locator): Receiver;
+}
+/**
+ * A connector that lives as long as the process, whatever the process runs.
+ *
+ * It connects before what the process was built with and goes after it, which is what makes it
+ * the place for something that answers for the process rather than for anything in it — the
+ * readiness probe is the one this was written for.
+ *
+ * It outlives a halt. One that must not says so by being a `Host.gate`, which is a connector
+ * like any other: the gate stays, what it holds does not.
+ */
+export interface Resident extends Connector {
+    /** Everything the process was built with has connected. */
+    complete?: () => Promise<void>;
+}
+export interface Aspect extends Connector {
+    /** the key it takes on the context; a duplicate is a boot error */
+    readonly name: string;
+    invoke(...args: any[]): any;
+}
+/**
+ * What an extension puts on a component's context, as the extension states it. How it is
+ * presented there is the bridge's — a bash bridge has no context to put anything on — and
+ * what is declared here is the key and what it holds.
+ */
+export interface Contribution {
+    /** the key on the context */
+    name: string;
+    /** what the key holds, as TypeScript */
+    type?: string;
+    /** what `type` names, by the module it comes from */
+    imports?: Record<string, string[]>;
+    /** a JSON Schema to read the type from instead, where a component states one */
+    schema?: object;
+}

package/transpiled/types/extensions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=extensions.js.map

package/transpiled/types/extensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extensions.js","sourceRoot":"","sources":["../../source/types/extensions.ts"],"names":[],"mappings":""}

package/transpiled/types/inbox.d.ts

@@ -0,0 +1,27 @@
+/**
+ * What a call was, kept so that the same call arriving again is refused rather than made twice.
+ *
+ * Everything about it is core's, as the outbox row is: core builds it and hands it to the write,
+ * and the storage commits it in the transaction the entity is committed in. Written only for a
+ * call that changed something — an operation that refused, or that raised, leaves nothing, and a
+ * call that arrives again after one of those is made again and refuses again.
+ */
+export interface Call {
+    /** the identity of the request, which is the key it is refused on */
+    id: string;
+    /** what the call answered, so that a duplicate of it is answered rather than refused */
+    reply: object;
+    /**
+     * Seconds the call is remembered, where its operation states them. Absent, the storage keeps
+     * it for the deployment's window.
+     */
+    retention?: number;
+}
+/**
+ * The read side of an inbox. What writes a record is the storage's own: it happens inside the
+ * transaction the storage opened, which core never reaches into.
+ */
+export interface Inbox {
+    /** what the call under this identity answered, or `null` where it was never made */
+    recall(id: string): Promise<object | null>;
+}

package/transpiled/types/inbox.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=inbox.js.map

package/transpiled/types/inbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox.js","sourceRoot":"","sources":["../../source/types/inbox.ts"],"names":[],"mappings":""}

package/transpiled/types/index.d.ts

@@ -0,0 +1,14 @@
+export * as atomicity from './atomicity.ts';
+export * as bindings from './bindings.ts';
+export * as bridges from './bridges.ts';
+export * as extensions from './extensions.ts';
+export * as operations from './operations.ts';
+export * as inbox from './inbox.ts';
+export * as outbox from './outbox.ts';
+export * as storages from './storages.ts';
+export type { Contribution } from './extensions.ts';
+export type { Event } from './state.ts';
+export type { Message } from './message.ts';
+export type { Receiver } from './receiver.ts';
+export type { Call, Guard, Observation, Transition } from './operations.ts';
+export type { Envelope, Maybe, Options, Query, Reply, RemoteError, Request, Source } from './request.ts';

package/transpiled/types/index.js

@@ -0,0 +1,9 @@
+export * as atomicity from './atomicity.js';
+export * as bindings from './bindings.js';
+export * as bridges from './bridges.js';
+export * as extensions from './extensions.js';
+export * as operations from './operations.js';
+export * as inbox from './inbox.js';
+export * as outbox from './outbox.js';
+export * as storages from './storages.js';
+//# sourceMappingURL=index.js.map

package/transpiled/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../source/types/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AACnC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA"}

package/transpiled/types/message.d.ts

@@ -0,0 +1,16 @@
+export interface Message<T = any> {
+    payload: T;
+    /**
+     * What this message is, so that a receiver's state change happens once however many times it
+     * arrives. Derived from the outbox row it was published from, which is committed once, so the
+     * immediate path, the pump and a redelivery all carry the one identity.
+     */
+    id?: string;
+    /** 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/message.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=message.js.map

package/transpiled/types/message.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"message.js","sourceRoot":"","sources":["../../source/types/message.ts"],"names":[],"mappings":""}

package/transpiled/types/operations.d.ts

@@ -0,0 +1,15 @@
+import type { Request } from './request.ts';
+export type type = 'transition' | 'observation' | 'assignment' | 'computation' | 'effect' | 'unmanaged';
+export type scope = 'entry' | 'entries' | 'changeset' | 'stream' | 'none';
+/**
+ * How an endpoint is called. What it resolves to is what the operation declares — `toa types`
+ * writes that per operation, and these are what a hand-written context says instead.
+ */
+export type Call<Output = any, Input = any> = (request: Request<Input>) => Promise<Output>;
+export type Observation<Output = any, Input = never, Entity = unknown> = (request: Request<Input, Entity>) => Promise<Output extends unknown[] ? Output : Output | null>;
+export type Transition<Output = any, Input = never, Entity = unknown> = (request: Request<Input, Entity>) => Promise<Output | null>;
+/**
+ * Runs on every change to an entity's state, before the contract is applied. `false` refuses
+ * the change as `EntityGuard`.
+ */
+export type Guard<T, C = unknown> = (state: T, origin: T | null, context: C) => boolean;

package/transpiled/types/operations.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=operations.js.map

package/transpiled/types/operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.js","sourceRoot":"","sources":["../../source/types/operations.ts"],"names":[],"mappings":""}

package/transpiled/types/outbox.d.ts

@@ -0,0 +1,93 @@
+import type { Connector } from '../connector.ts';
+import type { Event } from './state.ts';
+/**
+ * The intent to publish, committed with the state change it belongs to. Everything about it
+ * is core's: the storage writes it and, where the images are the write's own, fills
+ * `event.origin` and `event.state` in.
+ */
+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 events of the component this renders a row into, by their labels. A destination that
+     * names them is given a `Rendering` of them before it connects: the payload each would be
+     * published with, by the component's own condition and payload.
+     */
+    readonly renders?: string[];
+    rendering?: Rendering;
+    /**
+     * What this would write for the row, where what it writes to is kept by each region for
+     * itself and converges nowhere: serializable, and needing nothing of this region to be
+     * written in another. `undefined` where it would write nothing. A destination that has this
+     * and `import` is regional.
+     */
+    export?(row: Row): Promise<unknown>;
+    /** Writes what the destination of the same name exported in another region. */
+    import?(portable: unknown): Promise<void>;
+    /**
+     * Whether this carries a change to other regions. A destination that does is given
+     * `regional` before it connects: what the component's regional destinations export.
+     */
+    readonly carries?: boolean;
+    regional?: Regional;
+}
+/**
+ * The component's regional destinations, as a carrier sees them: what they export for a row,
+ * by their names, and the import of what arrives, without knowing what any of them is.
+ */
+export interface Regional {
+    /** `undefined` where none of them exported anything */
+    export(row: Row): Promise<Record<string, unknown> | undefined>;
+    /** each part to the destination of its name; a name this component has none of is dropped */
+    import(carried: Record<string, unknown>): Promise<void>;
+}
+/** What a row makes of the component's events: the payload of each that it raises. */
+export interface Rendering {
+    /** `null` where the event's condition does not hold for the row */
+    render(label: string, row: Row): Promise<{
+        payload: unknown;
+    } | null>;
+}
+/**
+ * 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, 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[]>;
+    /**
+     * 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/outbox.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=outbox.js.map

package/transpiled/types/outbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outbox.js","sourceRoot":"","sources":["../../source/types/outbox.ts"],"names":[],"mappings":""}

package/transpiled/types/receiver.d.ts

@@ -0,0 +1,9 @@
+import type { Connector } from '../connector.ts';
+import type { Message } from './message.ts';
+/**
+ * What consumes an event of the context. Core ships one, and an extension may put its own
+ * in its place, so what a binding is handed is this rather than core's class.
+ */
+export interface Receiver extends Connector {
+    receive(message: Message): Promise<void>;
+}

package/transpiled/types/receiver.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=receiver.js.map

package/transpiled/types/receiver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"receiver.js","sourceRoot":"","sources":["../../source/types/receiver.ts"],"names":[],"mappings":""}

package/transpiled/types/request.d.ts

@@ -0,0 +1,119 @@
+import type { Exception } from '../exceptions.ts';
+/**
+ * What a call asks for. `Entity` is the record it is about, which narrows the projection;
+ * left out, any name is accepted.
+ */
+export interface Query<Entity = any> {
+    id?: string;
+    ids?: string[];
+    criteria?: string;
+    search?: string;
+    sample?: number;
+    omit?: number;
+    limit?: number;
+    sort?: string[];
+    projection?: Array<string & keyof Entity>;
+    version?: number;
+    deleted?: boolean;
+    token?: string;
+    stop?: boolean;
+}
+/** Origin of a call. Stamped by the framework; whoever reads it takes the keys it knows. */
+export type Source = {
+    namespace: string;
+    component: string;
+    operation: string;
+} | {
+    namespace: string;
+    component: string;
+    event: string;
+} | {
+    service: string;
+};
+/**
+ * What a caller asks for, and what a caller may say about it — the identity of the call, where the
+ * caller has one to give, and whatever of the envelope whoever hands it over already knows. A
+ * receiver stamps the identity and the chain off the message the call came from.
+ */
+export interface Request<Input = any, Entity = any> {
+    input?: Input;
+    query?: Query<Entity>;
+    /** What the operation acquires, where the caller supplies it rather than the storage. */
+    entity?: Entity;
+    task?: boolean;
+    /**
+     * The process a call to a stateful operation goes to: that process's `context.instance`. Named
+     * for a stateful operation, and for no other.
+     */
+    instance?: string;
+    /**
+     * What this call is, so that the same call arriving twice is written once. Left out, the caller
+     * stamps one: derived from the call it is itself serving, where there is one, and minted where
+     * there is not. See `core/source/entities/newid.ts` and the inbox.
+     */
+    id?: 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[];
+    /**
+     * The properties of the output this caller receives, of each object the operation answers. An
+     * empty list receives none of it, and a request that names none receives the output whole.
+     */
+    output?: string[];
+    /**
+     * Whether this caller reads an output encoded rather than as values: a gateway writing it as a
+     * response body spends nothing on reading it. What answers one encodes it once.
+     */
+    encoded?: boolean;
+    /**
+     * Whether this call, and every call made under it, may reach only a safe operation. Stamped by
+     * the framework and carried down the chain; set and never cleared, so a call made under one is
+     * readonly whatever it says of itself. See `core/source/safety.ts`.
+     */
+    readonly?: boolean;
+    /** the sender validated against the contract, so the recipient does not */
+    authentic?: boolean;
+    /** W3C traceparent */
+    telemetry?: string;
+}
+/**
+ * How a caller waits for an addressed call, given beside the request: neither is part of what the
+ * call asks, and neither is sent with it. An ordinary call waits for as long as its reply takes, and
+ * is refused if it names either.
+ */
+export interface Options {
+    /** Milliseconds the caller waits for the reply. Without one, the context's default. */
+    timeout?: number;
+    /** Ends the wait when it aborts, within the timeout. */
+    signal?: AbortSignal;
+}
+/**
+ * What an operation receives: the request, in the envelope the framework put it in. The one
+ * difference from what a caller may hand over is that the identity is settled, which is why an
+ * operation may rely on it and a caller need not supply it.
+ *
+ * The envelope is the framework's own object rather than the caller's written over, because a
+ * caller may hand one object to several calls — `id` alone makes that fatal, as two calls cannot
+ * share an identity — and because what a caller wrote and what the runtime added are then two
+ * things rather than one.
+ */
+export interface Envelope<Input = any, Entity = any> extends Request<Input, Entity> {
+    id: string;
+}
+/**
+ * An error an operation declares and returns. A call resolves to it rather than throwing:
+ * only an exception is thrown.
+ */
+export interface RemoteError<Code extends string = string> extends Error {
+    code: Code;
+}
+/** What an operation returns where it may refuse: the value, or the error it refused with. */
+export type Maybe<T> = T | Error;
+export interface Reply {
+    output?: any;
+    error?: object;
+    exception?: Exception;
+}

package/transpiled/types/request.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=request.js.map

package/transpiled/types/request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.js","sourceRoot":"","sources":["../../source/types/request.ts"],"names":[],"mappings":""}

package/transpiled/types/state.d.ts

@@ -0,0 +1,9 @@
+/** What a commit publishes: the images of one state change. */
+export interface Event<State = object, Trailers = object> {
+    /** the pre-image; null when the entity did not exist before */
+    origin: State | null;
+    state: State;
+    /** out-of-band values an algorithm wrote into `state.TRAILERS`; must be serializable */
+    trailers?: Trailers;
+    input?: object;
+}

package/transpiled/types/state.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=state.js.map

package/transpiled/types/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.js","sourceRoot":"","sources":["../../source/types/state.ts"],"names":[],"mappings":""}