@toa.io/core 1.0.0-alpha.29 → 1.0.0-alpha.291

package/transpiled/transmission.js

@@ -0,0 +1,30 @@
+import { Connector } from './connector.js';
+import { TransmissionException } from './exceptions.js';
+export class Transmission extends Connector {
+    #bindings;
+    constructor(bindings) {
+        super();
+        this.#bindings = bindings;
+        this.depends(bindings);
+    }
+    async request(request) {
+        let reply = false;
+        let i = 0;
+        while (reply === false && i < this.#bindings.length) {
+            const binding = this.#bindings[i];
+            i++;
+            if (request?.task === true) {
+                if (binding.task === undefined)
+                    continue;
+                await binding.task(request);
+                reply = null;
+            }
+            else
+                reply = await binding.request(request);
+        }
+        if (reply === false)
+            throw new TransmissionException(`All (${this.#bindings.length}) bindings rejected.`);
+        return reply;
+    }
+}
+//# sourceMappingURL=transmission.js.map

package/transpiled/transmission.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transmission.js","sourceRoot":"","sources":["../source/transmission.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AAIvD,MAAM,OAAO,YAAa,SAAQ,SAAS;IAChC,SAAS,CAAY;IAE9B,YAAmB,QAAoB;QACrC,KAAK,EAAE,CAAA;QAEP,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAA;QACzB,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;IACxB,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,OAAgB;QACnC,IAAI,KAAK,GAAQ,KAAK,CAAA;QACtB,IAAI,CAAC,GAAG,CAAC,CAAA;QAET,OAAO,KAAK,KAAK,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;YACpD,MAAM,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;YAEjC,CAAC,EAAE,CAAA;YAEH,IAAI,OAAO,EAAE,IAAI,KAAK,IAAI,EAAE,CAAC;gBAC3B,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS;oBAAE,SAAQ;gBAExC,MAAM,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;gBAC3B,KAAK,GAAG,IAAI,CAAA;YACd,CAAC;;gBAAM,KAAK,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;QAC/C,CAAC;QAED,IAAI,KAAK,KAAK,KAAK;YACjB,MAAM,IAAI,qBAAqB,CAAC,QAAQ,IAAI,CAAC,SAAS,CAAC,MAAM,sBAAsB,CAAC,CAAA;QAEtF,OAAO,KAAK,CAAA;IACd,CAAC;CACF"}

package/transpiled/types/atomicity.d.ts

@@ -0,0 +1,56 @@
+import type { Connector } from '../connector.js';
+/** Which of the group this replica is, and how many of them there are. */
+export interface Assignment {
+    i: number;
+    n: number;
+}
+/**
+ * What one group of replicas decides together, in one place. The decisions here are the ones
+ * processes cannot arrange by talking to each other: they need a single arbiter and a step
+ * indivisible from its point of view.
+ */
+export interface Atom extends Connector {
+    /**
+     * An exclusive claim on slots of `0..total`: while this replica holds one, no other
+     * replica of the group does. Answered from memory, so it costs nothing to ask.
+     *
+     * `null` while this replica owns nothing — after a restart, during a rollout, or while
+     * coordination is unreachable. Whoever asks must be able to stand down: acting on a claim
+     * that cannot be supported is a different guarantee, not a degraded one.
+     */
+    slots(total: number): number[] | null;
+    /**
+     * Calls `listener` with the assignment this replica holds, and again whenever it changes —
+     * one arrived, was lost, or the group resized. Answers with what removes the listener
+     * again.
+     *
+     * A change and not a heartbeat: a group that stays as it is never calls back. It is called
+     * once as it is added, with the claim as it stands.
+     */
+    onassigned(listener: (assignment: Assignment | null) => void): () => void;
+    /**
+     * Debt the group has run up under each key, in milliseconds. Every call adds its own deltas
+     * and reads back where the group stands, so a replica reports what it alone has spent and
+     * still decides on what all of them have.
+     *
+     * Rejects where there is nothing to arbitrate through.
+     */
+    meter(keys: string[], deltas: number[]): Promise<number[]>;
+    /**
+     * Runs `routine` holding `keys`, and while it holds them no other replica of the group
+     * does. Waits for as long as it takes to acquire them.
+     *
+     * The lease is extended for as long as the routine runs. An extension that fails aborts the
+     * signal the routine is given, which is the only way it learns it no longer holds what it
+     * is working under.
+     *
+     * Rejects where there is nothing to arbitrate through.
+     */
+    lock<T>(keys: string | string[], routine: (signal: AbortSignal, context: unknown) => Promise<T>): Promise<T>;
+}
+export interface Factory {
+    /** @param group what the replicas deciding together have in common */
+    atom(group: string, options?: {
+        interval?: number;
+    }): Atom;
+}

package/transpiled/types/atomicity.js

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

package/transpiled/types/atomicity.js.map

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

package/transpiled/types/bindings.d.ts

@@ -0,0 +1,42 @@
+import type { Readable } from 'node:stream';
+import type { Connector } from '../connector.js';
+import type { Locator } from '../locator.js';
+import type { Component } from '../component.js';
+import type { Receiver } from './receiver.js';
+import type { Message } from './message.js';
+import type { Reply, Request } from './request.js';
+/** 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;
+}
+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): 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 {
+    producer(locator: Locator, endpoints: string[], component: Component): 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;
+}

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,38 @@
+import type { Readable } from 'node:stream';
+import type { Connector } from '../connector.js';
+import type { Context } from '../context.js';
+import type { Event as StateEvent } from './state.js';
+import type { Reply, Request } from './request.js';
+/**
+ * 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;
+    dispose?: 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,62 @@
+import type { Connector } from '../connector.js';
+import type { Locator } from '../locator.js';
+import type { Component } from '../component.js';
+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 { Atom } from './atomicity.js';
+import type { Source } from './request.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.
+ */
+export interface Host {
+    /** a component of the context, by locator */
+    remote(locator: Locator, source?: Source): 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;
+}
+/**
+ * `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> {
+    tenant?(locator: Locator, declaration: any, manifest: Manifest): Connector | Promise<Connector>;
+    aspect?(locator: Locator, declaration: any): Aspect | Aspect[];
+    /** 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;
+    emitter?(emitter: Emitter, label: string, locator: Locator): Emitter;
+    receiver?(receiver: Receiver, locator: Locator): Receiver;
+}
+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/index.d.ts

@@ -0,0 +1,13 @@
+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 outbox from './outbox.js';
+export * as storages from './storages.js';
+export type { Contribution } from './extensions.js';
+export type { Event } from './state.js';
+export type { Message } from './message.js';
+export type { Receiver } from './receiver.js';
+export type { Call, Guard, Observation, Transition } from './operations.js';
+export type { Maybe, Query, Reply, RemoteError, Request, Source } from './request.js';

package/transpiled/types/index.js

@@ -0,0 +1,8 @@
+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 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,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA"}

package/transpiled/types/message.d.ts

@@ -0,0 +1,5 @@
+export interface Message<T = any> {
+    payload: T;
+    /** W3C traceparent */
+    telemetry?: 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.js';
+export type type = 'transition' | 'observation' | 'assignment' | 'computation' | 'effect' | 'unmanaged';
+export type scope = 'object' | 'objects' | '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,28 @@
+import type { Event } from './state.js';
+/**
+ * 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;
+    published: boolean;
+    /** not before this */
+    pending: number;
+    /** an assignment's images are absent until the storage fills them in */
+    event: Event;
+}
+/**
+ * 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.
+     */
+    pending(lanes: number[], now: number, limit: number, after?: string): Promise<Row[]>;
+    settle(ids: 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.js';
+import type { Message } from './message.js';
+/**
+ * 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,55 @@
+import type { Exception } from '../exceptions.js';
+/**
+ * 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;
+}
+/** 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;
+};
+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;
+    authentic?: boolean;
+    task?: boolean;
+    /** W3C traceparent */
+    telemetry?: string;
+    source?: Source;
+}
+/**
+ * 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":""}

package/transpiled/types/storages.d.ts

@@ -0,0 +1,111 @@
+import type { Readable } from 'node:stream';
+import type { Connector } from '../connector.js';
+import type { Locator } from '../locator.js';
+import type { Row, Storage as Outbox } from './outbox.js';
+/** the RSQL tree `@rsql/parser` produces; a storage translates it into its own dialect */
+export interface Node {
+    type: 'LOGIC' | 'COMPARISON' | 'SELECTOR' | 'VALUE';
+    left?: Node;
+    right?: Node;
+    operator?: string;
+    selector?: string;
+    value?: unknown;
+}
+/** What a storage stores. `id` is the key; the upper-cased names are core's. */
+export interface Record {
+    id: string;
+    VERSION: number;
+    CREATED?: number;
+    UPDATED?: number;
+    /** a tombstone's timestamp; `null` on a live record */
+    DELETED?: number | null;
+    [key: string]: any;
+}
+/** Everything a request query carried that was not a selector. */
+export interface Options {
+    omit?: number;
+    limit?: number;
+    /** normalised by `query/options.ts` from `'name:asc'` into pairs */
+    sort?: Array<[property: string, direction: string]>;
+    /** always includes `VERSION`, `CREATED`, `UPDATED`, `DELETED` */
+    projection?: string[];
+    sample?: number;
+    /** include tombstones; without it an observation answers `null` over one */
+    deleted?: boolean;
+}
+/** What core hands a storage, written by `Query.parse`. */
+export interface Query {
+    id?: string;
+    /** many identities at once; `State.objects` inits whichever of them are missing */
+    ids?: string[];
+    version?: number;
+    criteria?: Node;
+    search?: string;
+    options?: Options;
+}
+/**
+ * What core requires of a storage. Every member but `outbox` is called unguarded, so a
+ * storage that leaves one out throws where an operation needs it — a storage may serve
+ * only some scopes, and says so by failing rather than by declaring less.
+ */
+export interface Storage extends Connector {
+    /** scope `object` */
+    get(query: Query): Promise<Record | null>;
+    /** scope `objects` */
+    find(query: Query): Promise<Record[]>;
+    /** scope `stream` */
+    stream(query?: Query): Promise<Readable>;
+    /**
+     * A transition's commit. `false` is a lost compare-and-swap, not an error. Where `row` is
+     * given, it is committed in the same transaction as the record or not at all.
+     */
+    store(record: Record, row?: Row): Promise<boolean>;
+    /** a transition over `objects` */
+    massStore(records: Record[], rows?: Row[]): Promise<boolean>;
+    /** an assignment; `null` where the query matched nothing */
+    upsert(query: Query, changeset: object, row?: Row): Promise<Record | null>;
+    /** get-or-create, in one indivisible step */
+    ensure(query: Query | undefined, properties: object, record: Record, row?: Row): Promise<Record>;
+    /** the driver's own handle, which an unmanaged operation is given as its state */
+    readonly raw: unknown;
+    /**
+     * Present only where a row can be committed atomically with the entity. Its absence is
+     * what makes the runtime publish inline, so a storage that cannot do this must not offer
+     * it: a row written outside the transaction would be a second write with a crash window
+     * in front of it, which is the defect the outbox exists to close.
+     */
+    readonly outbox?: Outbox;
+    /**
+     * Whether this storage applies `entity.migrations`. Absent is what a storage that does not
+     * says, and a component declaring migrations against one is refused at boot rather than
+     * starting with a structure nothing has made.
+     */
+    readonly migrates?: boolean;
+}
+/**
+ * The subset of a component's entity declaration a storage reads. Structural, so that core
+ * names no type of `@toa.io/norm`, which depends on core.
+ */
+export interface Entity {
+    associated?: boolean;
+    custom?: boolean;
+    /** in the order they are applied; what a step is belongs to the storage that reads it */
+    migrations?: Migration[];
+}
+/**
+ * One file of a `migrations` directory, named after it — the component's own, or a prototype's,
+ * which every descendant applies to its collection ahead of its own.
+ */
+export interface Migration {
+    id: string;
+    steps: unknown[];
+    /** the prototype it is inherited from; absent on the component's own */
+    prototype?: string;
+}
+export interface StorageOptions {
+    /** whether the component publishes anything, and so needs a place to commit a row */
+    outbox?: boolean;
+}
+export interface Factory {
+    storage(locator: Locator, entity: Entity, options?: StorageOptions): Storage;
+}

package/transpiled/types/storages.js

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

package/transpiled/types/storages.js.map

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

package/transpiled/unmanaged.d.ts

@@ -0,0 +1,5 @@
+import { Operation } from './operation.js';
+import type { Store } from './operation.js';
+export declare class Unmanaged extends Operation {
+    protected acquire(store: Store): Promise<void>;
+}

package/transpiled/unmanaged.js

@@ -0,0 +1,7 @@
+import { Operation } from './operation.js';
+export class Unmanaged extends Operation {
+    async acquire(store) {
+        store.state = this.scope.storage.raw;
+    }
+}
+//# sourceMappingURL=unmanaged.js.map

package/transpiled/unmanaged.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unmanaged.js","sourceRoot":"","sources":["../source/unmanaged.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAG1C,MAAM,OAAO,SAAU,SAAQ,SAAS;IACnB,KAAK,CAAC,OAAO,CAAC,KAAY;QAC3C,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAA;IACtC,CAAC;CACF"}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./transpiled",
+    "rootDir": "./source"
+  },
+  "include": [
+    "source"
+  ]
+}