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

package/transpiled/entities/entity.js

@@ -0,0 +1,137 @@
+import { environment } from '@toa.io/generic';
+import { EntityContractException, EntityGuardException } from '../exceptions.js';
+import { newid } from './newid.js';
+export class Entity {
+    deleted = false;
+    #schema;
+    #blank;
+    #guards;
+    #origin = null;
+    #state;
+    #mutable = true;
+    /**
+     * A record makes an entity of what a storage holds; a string, or nothing at all, makes a
+     * blank one under that identity, out of what the component declared a record starts as.
+     *
+     * @param blank what the component declares a record holds before anything is written to it
+     * @param mutable whether the entity may be modified and committed
+     */
+    // eslint-disable-next-line max-params
+    constructor(schema, blank, argument, guards, mutable = true) {
+        this.#schema = schema;
+        this.#blank = blank;
+        this.#guards = guards;
+        if (typeof argument === 'object')
+            this.#acquire(argument, mutable);
+        else
+            this.#write(this.#compose(argument ?? newid()));
+    }
+    get() {
+        return this.#state;
+    }
+    set(value) {
+        if (!this.#mutable)
+            throw new Error('Entity acquired by a read-only operation cannot be modified');
+        this.#guard(value);
+        const error = this.#schema.fit(value);
+        if (error !== null)
+            throw new EntityContractException(error, value);
+        this.#revive(value);
+        this.#write(value);
+    }
+    event(input) {
+        return {
+            origin: this.#origin,
+            state: this.#state,
+            trailers: this.#state.TRAILERS,
+            input
+        };
+    }
+    /**
+     * The origin is the pre-image a commit diffs the new state against. An operation that
+     * cannot commit has nothing to diff, so it takes the record as it came from the storage
+     * instead of paying for a deep copy of every record it read.
+     */
+    #acquire(record, mutable) {
+        this.#mutable = mutable;
+        if (!mutable) {
+            this.#write(record);
+            return;
+        }
+        this.#write(structuredClone(record));
+        this.#origin = record;
+    }
+    /**
+     * A blank is not validated: what the component declared is fitted once, at boot, and the
+     * system properties are the runtime's own. It is copied because every entity the component
+     * makes is written over its own.
+     */
+    #compose(id) {
+        // `REGION` here as well as in `#write`, because a record is validated before it is written
+        // and what is composed is about to be written here: it is this region's
+        return {
+            id,
+            VERSION: 0,
+            DELETED: null,
+            REGION,
+            ...structuredClone(this.#blank)
+        };
+    }
+    #guard(value) {
+        if (this.#guards === undefined)
+            return;
+        for (const guard of this.#guards) {
+            const ok = guard.fit(value, this.#origin);
+            if (ok === false)
+                throw new EntityGuardException(guard.name, value);
+        }
+    }
+    // deletion is only expressed as a new DELETED timestamp,
+    // so committing over a tombstone without touching it means revival
+    #revive(value) {
+        if (this.#origin?.DELETED == null || value.DELETED !== this.#origin.DELETED)
+            return;
+        value.DELETED = null;
+        this.deleted = false;
+    }
+    #write(value) {
+        if (!('TRAILERS' in value))
+            Object.defineProperty(value, 'TRAILERS', {
+                writable: false,
+                configurable: false,
+                enumerable: false,
+                value: {}
+            });
+        /*
+         * The system properties are the runtime's to write, and a record does not always come from
+         * a storage that wrote them: a component may bring its own, and one that answers with an
+         * id and a version has left the rest to whoever asked. Filling them in here is what makes
+         * a record's shape the runtime's guarantee rather than a storage's promise, and what lets
+         * the entity require them.
+         */
+        value.CREATED ??= Date.now();
+        value.UPDATED ??= value.CREATED;
+        value.VERSION ??= 0;
+        value.DELETED ??= null;
+        value.REGION ??= REGION;
+        if (value.DELETED !== null)
+            this.deleted = true;
+        // beside the version and the timestamp, and for the same reason: all three say what the
+        // write did, so all three change only where there is one. A record read here keeps the
+        // region that wrote it, which is not necessarily this one — that is the whole of what it
+        // is for, and stamping it on the way in would answer every read with the wrong region.
+        if (this.#state !== undefined) {
+            value.UPDATED = Date.now();
+            value.VERSION++;
+            value.REGION = REGION;
+        }
+        this.#state = value;
+    }
+}
+/**
+ * The rank of the region this deployment is, from what deployed it. An application that is one
+ * region has none and writes `0`, which is what the first region is and what a record written
+ * before any of this existed is backfilled with.
+ */
+const REGION = Number(environment.get('TOA_REGION') ?? 0);
+//# sourceMappingURL=entity.js.map

package/transpiled/entities/entity.js.map

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

package/transpiled/entities/factory.d.ts

@@ -0,0 +1,27 @@
+import { Entity } from './entity.ts';
+import { EntitySet } from './set.ts';
+import { Changeset } from './changeset.ts';
+import type { Schema } from '@toa.io/schemas';
+import type { Guard } from '../guard.ts';
+import type { Query, Record } from '../types/storages.ts';
+/** The two schemas a component's records are held to, and what a new one starts as. */
+export interface Schemas {
+    /** what a stored record must fit */
+    entity: Schema;
+    /** what a changeset must fit: the same properties, none of them required */
+    changeset: Schema;
+}
+export declare class Factory {
+    #private;
+    constructor(schemas: Schemas, blank: object, guards?: Guard[]);
+    /**
+     * What these values would make of a record, held to what a record must be. It starts from a
+     * blank rather than from the declared properties alone, because what is validated is the
+     * record and a record carries what the runtime writes into every one of them.
+     */
+    fit(values: object): void;
+    init(id?: string): Entity;
+    object(record: Record, mutable?: boolean): Entity;
+    objects(recordset: Record[], init?: string[], mutable?: boolean): EntitySet;
+    changeset(query: Query): Changeset;
+}

package/transpiled/entities/factory.js

@@ -0,0 +1,38 @@
+import { Entity } from './entity.js';
+import { EntitySet } from './set.js';
+import { Changeset } from './changeset.js';
+export class Factory {
+    #schemas;
+    #blank;
+    #guards;
+    constructor(schemas, blank, guards) {
+        this.#schemas = schemas;
+        this.#blank = blank;
+        this.#guards = guards;
+    }
+    /**
+     * What these values would make of a record, held to what a record must be. It starts from a
+     * blank rather than from the declared properties alone, because what is validated is the
+     * record and a record carries what the runtime writes into every one of them.
+     */
+    fit(values) {
+        this.#schemas.entity.validate({ ...this.init().get(), ...values }, 'Entity');
+    }
+    init(id) {
+        return new Entity(this.#schemas.entity, this.#blank, id, this.#guards);
+    }
+    object(record, mutable = true) {
+        return new Entity(this.#schemas.entity, this.#blank, record, this.#guards, mutable);
+    }
+    objects(recordset, init, mutable = true) {
+        const set = recordset.map((record) => this.object(record, mutable));
+        if (init !== undefined)
+            for (const id of init)
+                set.unshift(this.init(id));
+        return new EntitySet(set);
+    }
+    changeset(query) {
+        return new Changeset(this.#schemas.changeset, query);
+    }
+}
+//# sourceMappingURL=factory.js.map

package/transpiled/entities/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../source/entities/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAc1C,MAAM,OAAO,OAAO;IACT,QAAQ,CAAS;IACjB,MAAM,CAAQ;IACd,OAAO,CAAqB;IAErC,YAAmB,OAAgB,EAAE,KAAa,EAAE,MAAgB;QAClE,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAA;QACvB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;QACnB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;IACvB,CAAC;IAED;;;;OAIG;IACI,GAAG,CAAC,MAAc;QACvB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,QAAQ,CAAC,CAAA;IAC9E,CAAC;IAEM,IAAI,CAAC,EAAW;QACrB,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,CAAA;IACxE,CAAC;IAEM,MAAM,CAAC,MAAc,EAAE,OAAO,GAAG,IAAI;QAC1C,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;IACrF,CAAC;IAEM,OAAO,CAAC,SAAmB,EAAE,IAAe,EAAE,OAAO,GAAG,IAAI;QACjE,MAAM,GAAG,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;QAEnE,IAAI,IAAI,KAAK,SAAS;YAAE,KAAK,MAAM,EAAE,IAAI,IAAI;gBAAE,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAA;QAEzE,OAAO,IAAI,SAAS,CAAC,GAAG,CAAC,CAAA;IAC3B,CAAC;IAEM,SAAS,CAAC,KAAY;QAC3B,OAAO,IAAI,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;IACtD,CAAC;CACF"}

package/transpiled/entities/index.d.ts

@@ -0,0 +1,5 @@
+export { derive, newid } from './newid.ts';
+export { Factory } from './factory.ts';
+export { Entity } from './entity.ts';
+export { EntitySet } from './set.ts';
+export { Changeset } from './changeset.ts';

package/transpiled/entities/index.js

@@ -0,0 +1,6 @@
+export { derive, newid } from './newid.js';
+export { Factory } from './factory.js';
+export { Entity } from './entity.js';
+export { EntitySet } from './set.js';
+export { Changeset } from './changeset.js';
+//# sourceMappingURL=index.js.map

package/transpiled/entities/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../source/entities/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACpC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA"}

package/transpiled/entities/newid.d.ts

@@ -0,0 +1,11 @@
+export declare function newid(): string;
+/**
+ * An id that is a function of what it is made of, in the shape `newid` produces, so that an `_id`
+ * is one kind of thing wherever it came from.
+ *
+ * What it is for is a call whose identity must be the same on every run that makes it: the same
+ * duplicate then produces the same identity, and whatever it reaches refuses its own copy. A
+ * name-based uuid is exactly that function: version 5 of RFC 9562, the bytes `uuid.v5` produces,
+ * hashed here with the namespace already parsed, since a call derives one on every call it makes.
+ */
+export declare function derive(...parts: Array<string | number>): string;

package/transpiled/entities/newid.js

@@ -0,0 +1,41 @@
+import { createHash } from 'node:crypto';
+import * as uuid from 'uuid';
+export function newid() {
+    const buf = Buffer.alloc(16);
+    uuid.v7(undefined, buf);
+    return buf.toString('hex');
+}
+/**
+ * An id that is a function of what it is made of, in the shape `newid` produces, so that an `_id`
+ * is one kind of thing wherever it came from.
+ *
+ * What it is for is a call whose identity must be the same on every run that makes it: the same
+ * duplicate then produces the same identity, and whatever it reaches refuses its own copy. A
+ * name-based uuid is exactly that function: version 5 of RFC 9562, the bytes `uuid.v5` produces,
+ * hashed here with the namespace already parsed, since a call derives one on every call it makes.
+ */
+export function derive(...parts) {
+    const hash = createHash('sha1').update(NAMESPACE).update(name(parts), 'utf8').digest();
+    hash[6] = (hash[6] & 0x0f) | 0x50;
+    hash[8] = (hash[8] & 0x3f) | 0x80;
+    return hash.toString('hex', 0, 16);
+}
+/**
+ * Each part behind its own length, so that no two different sets of parts read as one name
+ * whatever a part happens to contain — a separator alone would have `a` and `b:c` name what
+ * `a:b` and `c` do, and this decides whether two calls are one call.
+ */
+function name(parts) {
+    let name = '';
+    for (const part of parts) {
+        const value = String(part);
+        name += value.length + ':' + value;
+    }
+    return name;
+}
+/**
+ * Toa's own, `26bd9bc6-675c-4465-9b42-9e008b20befe`, so that a name derived here collides with
+ * nothing derived elsewhere.
+ */
+const NAMESPACE = Buffer.from('26bd9bc6675c44659b429e008b20befe', 'hex');
+//# sourceMappingURL=newid.js.map

package/transpiled/entities/newid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"newid.js","sourceRoot":"","sources":["../../source/entities/newid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,IAAI,MAAM,MAAM,CAAA;AAE5B,MAAM,UAAU,KAAK;IACnB,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;IAE5B,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,GAAG,CAAC,CAAA;IAEvB,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;AAC5B,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,MAAM,CAAC,GAAG,KAA6B;IACrD,MAAM,IAAI,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,CAAC,MAAM,EAAE,CAAA;IAEtF,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,IAAI,CAAA;IACjC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,IAAI,CAAA;IAEjC,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,CAAA;AACpC,CAAC;AAED;;;;GAIG;AACH,SAAS,IAAI,CAAC,KAA6B;IACzC,IAAI,IAAI,GAAG,EAAE,CAAA;IAEb,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAA;QAE1B,IAAI,IAAI,KAAK,CAAC,MAAM,GAAG,GAAG,GAAG,KAAK,CAAA;IACpC,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;GAGG;AACH,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,kCAAkC,EAAE,KAAK,CAAC,CAAA"}

package/transpiled/entities/set.d.ts

@@ -0,0 +1,10 @@
+import type { Entity } from './entity.ts';
+import type { Record } from '../types/storages.ts';
+import type { Event } from '../types/state.ts';
+export declare class EntitySet {
+    #private;
+    constructor(set: Entity[]);
+    get(): Record[];
+    set(values: Record[]): void;
+    events(input?: object): Event[];
+}

package/transpiled/entities/set.js

@@ -0,0 +1,19 @@
+import { SystemException } from '../exceptions.js';
+export class EntitySet {
+    #set;
+    constructor(set) {
+        this.#set = set;
+    }
+    get() {
+        return this.#set.map((entity) => entity.get());
+    }
+    set(values) {
+        if (values.length !== this.#set.length)
+            throw new SystemException('Objects array must not be modified');
+        values.forEach((value, index) => this.#set[index].set(value));
+    }
+    events(input) {
+        return this.#set.map((entity) => entity.event(input));
+    }
+}
+//# sourceMappingURL=set.js.map

package/transpiled/entities/set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.js","sourceRoot":"","sources":["../../source/entities/set.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAKlD,MAAM,OAAO,SAAS;IACX,IAAI,CAAU;IAEvB,YAAmB,GAAa;QAC9B,IAAI,CAAC,IAAI,GAAG,GAAG,CAAA;IACjB,CAAC;IAEM,GAAG;QACR,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAA;IAChD,CAAC;IAEM,GAAG,CAAC,MAAgB;QACzB,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,CAAC,IAAI,CAAC,MAAM;YACpC,MAAM,IAAI,eAAe,CAAC,oCAAoC,CAAC,CAAA;QAEjE,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAA;IAC/D,CAAC;IAEM,MAAM,CAAC,KAAc;QAC1B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAA;IACvD,CAAC;CACF"}

package/transpiled/event.d.ts

@@ -0,0 +1,20 @@
+import { Connector } from './connector.ts';
+import type { Emitter } from './types/bindings.ts';
+import type { Event as Bridge } from './types/bridges.ts';
+import type { Row } from './types/outbox.ts';
+export interface Definition {
+    conditioned?: boolean;
+    subjective?: boolean;
+    label?: string;
+}
+export interface Raised {
+    payload: unknown;
+}
+export declare class Event extends Connector {
+    #private;
+    /** `emitter` is `null` for an event that is rendered and never published: see `Rendering` */
+    constructor(definition: Definition, emitter: Emitter | null, bridge?: Bridge);
+    /** What the row raises this event with, or `null` where its condition does not hold. */
+    render(row: Row): Promise<Raised | null>;
+    emit(row: Row): Promise<void>;
+}

package/transpiled/event.js

@@ -0,0 +1,65 @@
+import { console, current, encode } from 'openspan';
+import { Connector } from './connector.js';
+import { derive } from './entities/newid.js';
+import * as measure from './measurements.js';
+export class Event extends Connector {
+    #emitter;
+    #bridge;
+    #conditioned;
+    #subjective;
+    #label;
+    /** `emitter` is `null` for an event that is rendered and never published: see `Rendering` */
+    constructor(definition, emitter, bridge) {
+        super();
+        this.#conditioned = definition.conditioned;
+        this.#subjective = definition.subjective;
+        this.#label = definition.label ?? 'event';
+        this.#emitter = emitter;
+        this.#bridge = bridge;
+        if (emitter !== null)
+            this.depends(emitter);
+        if (bridge !== undefined)
+            this.depends(bridge);
+    }
+    /** What the row raises this event with, or `null` where its condition does not hold. */
+    async render(row) {
+        const event = row.event;
+        if (this.#conditioned !== false && (await this.#bridge?.condition(event)) !== true)
+            return null;
+        const payload = this.#subjective === true ? await this.#bridge?.payload(event) : event.state;
+        return { payload };
+    }
+    async emit(row) {
+        const raised = await this.render(row);
+        if (raised !== null) {
+            const { payload } = raised;
+            /*
+             * The row is committed once, so its id is what makes every publication of it one message:
+             * the immediate path, the pump that may run an hour later in another replica, and a
+             * redelivery of what either sent. Derived with the label rather than the row id itself,
+             * because one row is published as several events and a component may consume two of them —
+             * one identity across both would have the second refused as a duplicate of the first.
+             */
+            const message = { payload, id: derive(row.id, this.#label) };
+            // the chain the change was made by, so a receiver of this continues it rather than
+            // starting one; read off the row, because the pump publishes off the operation's path
+            if (row.trail !== undefined)
+                message.trail = row.trail;
+            const options = {
+                name: `${this.#label} publish`,
+                kind: 'producer',
+                attributes: { 'messaging.destination.name': this.#label },
+                measure: { histogram: measure.event.publish, labels: { event: this.#label } }
+            };
+            await console.span(options, async () => {
+                const context = current();
+                if (context !== undefined)
+                    message.telemetry = encode(context);
+                if (this.#emitter === null)
+                    throw new Error(`Event '${this.#label}' is not published`);
+                await this.#emitter.emit(message);
+            });
+        }
+    }
+}
+//# sourceMappingURL=event.js.map

package/transpiled/event.js.map

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

package/transpiled/exceptions.d.ts

@@ -0,0 +1,110 @@
+import type { SchemaError } from '@toa.io/schemas';
+export declare const codes: {
+    System: number;
+    Contract: number;
+    RequestSyntax: number;
+    RequestContract: number;
+    RequestConflict: number;
+    ResponseContract: number;
+    EntityContract: number;
+    EntityGuard: number;
+    QuerySyntax: number;
+    State: number;
+    StateNotFound: number;
+    StatePrecondition: number;
+    StateConcurrency: number;
+    StateInitialization: number;
+    Duplicate: number;
+    /** this call has been made, and what it changed is changed */
+    DuplicateCall: number;
+    /** a stream token names a point of the storage's history it no longer holds */
+    StateHistory: number;
+    Communication: number;
+    Transmission: number;
+    Endpoint: number;
+    /** nothing held the name an addressed call named */
+    Addressee: number;
+    /** the caller stopped waiting, and what it called may still run */
+    Abandoned: number;
+    /** the tree the call was made through has been taken down, and is not coming back */
+    Disposed: number;
+    /** a call to an operation that may change state, made under a request that may only read */
+    Safety: number;
+    /** nothing answered at the address of the component a streamed call was made to */
+    Unreachable: number;
+    /** a chain that came back to where it had been, or went further than a chain goes */
+    Loop: number;
+    /** a component asked for something its manifest does not declare */
+    Misuse: number;
+    /** a run command pauses what nothing takes again: `pause` with no `resume` */
+    Irresumable: number;
+    /** a call to a component nothing this process was given states */
+    Unstated: number;
+};
+export declare class Exception {
+    readonly code: number;
+    readonly message: string;
+    cause?: unknown;
+    /** what a contract exception copies off the schema error it refused with */
+    [key: string]: unknown;
+    constructor(code: number, message: string, cause?: unknown);
+}
+export declare class SystemException extends Exception {
+    readonly stack?: string;
+    constructor(error: Error | string);
+}
+/**
+ * A call refused for where it has been rather than for what it says. Named, and so permanent:
+ * the chain is deterministic, and another attempt reproduces it hop for hop.
+ */
+export declare class LoopException extends Exception {
+    /** the whole chain, so what is set aside can be read without guessing */
+    readonly trail: string[];
+    constructor(message: string, trail: string[]);
+}
+export declare class ContractException extends Exception {
+    constructor(code: number | undefined, error: SchemaError | string | null, cause?: unknown);
+}
+export declare class RequestContractException extends ContractException {
+    constructor(error: SchemaError | string, cause?: unknown);
+}
+export declare class ResponseContractException extends ContractException {
+    constructor(error: SchemaError | string, cause?: unknown);
+}
+export declare class EntityContractException extends ContractException {
+    constructor(error: SchemaError | string, cause?: unknown);
+}
+export declare class EntityGuardException extends ContractException {
+    constructor(name: string, cause?: unknown);
+}
+type Derived = new (message?: string, cause?: unknown) => Exception;
+export declare const RequestSyntaxException: Derived;
+export declare const RequestConflictException: Derived;
+export declare const QuerySyntaxException: Derived;
+export declare const StateException: Derived;
+export declare const StateNotFoundException: Derived;
+export declare const StatePreconditionException: Derived;
+export declare const StateConcurrencyException: Derived;
+export declare const StateInitializationException: Derived;
+export declare const DuplicateException: Derived;
+export declare const DuplicateCallException: Derived;
+export declare const StateHistoryException: Derived;
+export declare const CommunicationException: Derived;
+export declare const TransmissionException: Derived;
+export declare const EndpointException: Derived;
+export declare const AddresseeException: Derived;
+export declare const AbandonedException: Derived;
+export declare const DisposedException: Derived;
+export declare const SafetyException: Derived;
+export declare const UnreachableException: Derived;
+export declare const MisuseException: Derived;
+export declare const IrresumableException: Derived;
+export declare const UnstatedException: Derived;
+export declare const names: Record<string, string>;
+/**
+ * Takes `unknown` because a caller has caught something rather than been handed an `Exception`.
+ * Anything core did not raise — an error from a driver, a rejection with no code at all — is not
+ * on the list, and is therefore worth trying again.
+ */
+export declare function permanent(exception: unknown): boolean;
+export {};