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

package/transpiled/contract/reply.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply.js","sourceRoot":"","sources":["../../source/contract/reply.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,EAAE,yBAAyB,EAAE,MAAM,kBAAkB,CAAA;AAI5D,MAAM,OAAO,KAAM,SAAQ,QAAQ;IAC1B,MAAM,CAAU,SAAS,GAC9B,yBAA+C,CAAA;IAE1C,MAAM,CAAC,MAAM,CAAC,MAAmB,EAAE,MAA+B;QACvE,MAAM,MAAM,GAAe;YACzB,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE,EAAE;YACd,oBAAoB,EAAE,KAAK;SAC5B,CAAA;QAED,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB;;;;;eAKG;YACH,MAAM,GAAG,eAAe,CAAC,MAAM,CAAC,CAAA;YAEhC,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ;gBAAE,MAAM,CAAC,oBAAoB,GAAG,IAAI,CAAA;iBAC3D,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,IAAI,MAAM,CAAC,KAAK,EAAE,IAAI,KAAK,QAAQ;gBACjE,MAAM,CAAC,KAAK,CAAC,oBAAoB,GAAG,IAAI,CAAA;YAE1C,MAAM,CAAC,UAAU,CAAC,MAAM,GAAG,MAAM,CAAA;QACnC,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,UAAU,CAAC,KAAK;YACrB,MAAM,KAAK,SAAS;gBAClB,CAAC,CAAC,KAAK;gBACP,CAAC,CAAC;oBACE,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACV,IAAI,EAAE;4BACJ,IAAI,EAAE,MAAM;yBACb;wBACD,OAAO,EAAE;4BACP,IAAI,EAAE,QAAQ;yBACf;qBACF;oBACD,QAAQ,EAAE,CAAC,MAAM,CAAC;iBACnB,CAAA;QAEP,OAAO,MAAM,CAAA;IACf,CAAC;CACF"}

package/transpiled/contract/request.d.ts

@@ -0,0 +1,49 @@
+import { Contract } from './contract.ts';
+import type { Schema } from '@toa.io/schemas';
+import type { Refusal } from './contract.ts';
+import type { JSONSchema } from './schemas.ts';
+/** What an operation states about itself, and answers when asked to explain. */
+export interface Explanation {
+    description?: string;
+    /**
+     * Whether the same call arriving twice changes state once. Said, because a caller cannot tell
+     * it from an answer that says nothing, and what it changes is whether a retry is safe to make.
+     */
+    once?: boolean;
+    /**
+     * Whether a call to it names the process it goes to. Said, because the caller is the one who
+     * has to name one, and a call that names none is refused.
+     */
+    stateful?: boolean;
+    /**
+     * The input property that carries a stream, where the operation takes one. Said, because a
+     * caller has to put one there, and a call that carries none is refused.
+     */
+    stream?: string;
+    input?: JSONSchema | null;
+    output?: JSONSchema | null;
+    errors?: Array<string | number>;
+}
+export interface Definition extends Explanation {
+    type?: string;
+    scope?: string;
+    query?: boolean;
+}
+/** What the operation works on, as the manifest declares it. */
+export interface Entity {
+    properties: Record<string, JSONSchema>;
+    required?: string[];
+    /**
+     * Whether its system properties are the ones the runtime gives every entity, in which case a
+     * contract leaves them out and whoever reads one puts them back.
+     */
+    system?: boolean;
+}
+export declare class Request extends Contract {
+    readonly discovery: Explanation;
+    static Exception: Refusal;
+    constructor(schema: Schema, definition: Definition, entity?: Entity);
+    static schema(definition: Definition, entity?: {
+        properties: Record<string, JSONSchema>;
+    }): JSONSchema;
+}

package/transpiled/contract/request.js

@@ -0,0 +1,152 @@
+import * as schemas from './schemas.js';
+import { RequestContractException } from '../exceptions.js';
+import { Contract } from './contract.js';
+export class Request extends Contract {
+    discovery = {};
+    static Exception = RequestContractException;
+    constructor(schema, definition, entity) {
+        super(schema);
+        for (const key of [
+            'description',
+            'once',
+            'stateful',
+            'stream',
+            'input',
+            'output',
+            'errors'
+        ])
+            if (definition[key] !== undefined)
+                this.discovery[key] = definition[key];
+        // how long a call is remembered is the operation's to keep, not the caller's to plan by
+        if (this.discovery.once !== undefined)
+            this.discovery.once = this.discovery.once !== false;
+        /*
+         * An operation that states no output states an empty schema, which every reply fits —
+         * and which says nothing to whoever reads it. What its type answers does, so that is
+         * said here instead. Here and not in the definition, because the definition is what a
+         * reply is held to: a projection is a lawful answer, and describing one is not the same
+         * as requiring it.
+         */
+        if (empty(this.discovery.output)) {
+            const answered = answers(definition, entity);
+            if (answered !== undefined)
+                this.discovery.output = answered;
+        }
+    }
+    static schema(definition, entity) {
+        // `source` is not among these: the framework stamps it and whoever reads it takes the keys
+        // it knows, so holding it to a schema would only fail calls from a peer that stamps one more
+        const schema = {
+            type: 'object',
+            properties: {
+                /*
+                 * Listed, and not required. `additionalProperties` already admits it, and a callee skips
+                 * this contract altogether for an `authentic` request — which every request from a `Call`
+                 * is — so requiring it would refuse nothing on the side where a missing identity matters,
+                 * and would refuse every request built by hand on the side where it never is. An
+                 * operation that declares `once` raises on a request without one instead.
+                 */
+                id: { type: 'string' },
+                authentic: { type: 'boolean' },
+                task: { type: 'boolean' },
+                // whether the call may reach only a safe operation, which every operation admits
+                readonly: { type: 'boolean' },
+                // what a caller receives of the output, which every operation admits
+                output: { type: 'array', uniqueItems: true, items: { type: 'string' } }
+            },
+            additionalProperties: true
+        };
+        const required = [];
+        if (definition.stream !== undefined) {
+            schema.properties.input = streamed(definition.input ?? { type: 'object' }, definition.stream);
+            required.push('input');
+        }
+        else if (definition.input !== undefined) {
+            schema.properties.input = definition.input;
+            required.push('input');
+        }
+        else
+            schema.properties.input = { type: 'null' };
+        if (entity === undefined)
+            definition.query = false;
+        if (definition.query === true)
+            required.push('query');
+        if (definition.query === false)
+            schema.properties.query = { type: 'null' };
+        if (definition.query !== false) {
+            const query = structuredClone(schemas.query);
+            query.properties.id = entity?.properties.id;
+            if (definition.type === 'observation')
+                delete query.properties.version;
+            else
+                delete query.properties.projection;
+            if (definition.scope === 'stream') {
+                // a window of a stream is read after the one before it, and ordered by what never moves
+                delete query.properties.omit;
+                query.if = { anyOf: [{ required: ['limit'] }, { required: ['token'] }] };
+                query.then = { properties: { sort: { items: { pattern: UNMOVING } } } };
+            }
+            else {
+                delete query.properties.token;
+                delete query.properties.stop;
+                if (definition.type !== 'observation' || definition.scope !== 'entries') {
+                    delete query.properties.omit;
+                    delete query.properties.limit;
+                }
+                else if (query.required === undefined)
+                    query.required = ['limit'];
+                else
+                    query.required.push('limit');
+            }
+            schema.properties.query = query;
+        }
+        if (required.length > 0)
+            schema.required = required;
+        return schema;
+    }
+}
+/**
+ * The input of an operation that takes a stream: the input it declared, with the property that
+ * carries one admitted and required. What that property holds is described by nothing — a stream
+ * is no value with a schema — so what a caller is held to is that it is there.
+ */
+function streamed(input, property) {
+    const properties = { ...input.properties, [property]: {} };
+    const required = input.required === undefined ? [property] : [...input.required, property];
+    return { ...input, properties, required };
+}
+/**
+ * What an operation of this type answers, where it did not say.
+ *
+ * A transition, an observation and an assignment work on the Entity Object, so that is what
+ * they answer — a set of them where the scope is a set. A computation neither uses the scope
+ * nor produces one, and an effect answers whatever it computed, so neither is guessed at.
+ * A stream is not a value with a schema, and is not one either.
+ *
+ * What the entity requires is said as well. It is a description and nothing is held to it —
+ * an operation answering a projection says so by declaring its own output — and a shape
+ * whose every property reads as optional says less than it knows.
+ */
+function answers(definition, entity) {
+    if (entity === undefined || !ENTITY.has(definition.type))
+        return undefined;
+    const object = {
+        type: 'object',
+        properties: entity.properties,
+        ...(entity.required === undefined ? {} : { required: entity.required })
+    };
+    if (definition.scope === 'entries')
+        return { type: 'array', items: object };
+    return definition.scope === 'entry' || definition.scope === 'changeset'
+        ? object
+        : undefined;
+}
+/** The types whose subject is the Entity Object; see `documentation/design.md`. */
+const ENTITY = new Set(['transition', 'observation', 'assignment']);
+/** A schema that states nothing, which is what an operation saying nothing normalizes to. */
+function empty(schema) {
+    return schema === undefined || schema === null || Object.keys(schema).length === 0;
+}
+/** What a window of a stream may be ordered by: what an entry never changes. */
+const UNMOVING = '^(?:id|CREATED)(?::(?:asc|desc))?$';
+//# sourceMappingURL=request.js.map

package/transpiled/contract/request.js.map

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

package/transpiled/contract/schemas.d.ts

@@ -0,0 +1,4 @@
+/** A JSON Schema, loose because it is handed to a validator and edited by the contracts. */
+export type JSONSchema = Record<string, any>;
+export declare const query: JSONSchema;
+export declare const error: JSONSchema;

package/transpiled/contract/schemas.js

@@ -0,0 +1,38 @@
+export const query = {
+    type: 'object',
+    properties: {
+        id: { type: 'string' },
+        ids: { type: 'array', uniqueItems: true, minItems: 1, items: { type: 'string' } },
+        version: { type: 'integer', minimum: 0 },
+        criteria: { type: 'string' },
+        search: { type: 'string' },
+        sample: { type: 'number' },
+        omit: { type: 'integer', minimum: 0 },
+        limit: { type: 'integer', minimum: 0 },
+        sort: {
+            type: 'array',
+            uniqueItems: true,
+            minItems: 1,
+            items: { type: 'string', pattern: '^\\w{1,32}(?::(?:asc|desc))?$' }
+        },
+        projection: {
+            type: 'array',
+            uniqueItems: true,
+            minItems: 1,
+            items: { type: 'string', not: { const: 'id' } }
+        },
+        deleted: { type: 'boolean' },
+        token: { type: 'string', minLength: 1 },
+        stop: { type: 'boolean' }
+    },
+    additionalProperties: false
+};
+export const error = {
+    type: 'object',
+    properties: {
+        code: { anyOf: [{ type: 'integer' }, { type: 'string' }] },
+        message: { type: 'string' }
+    },
+    required: ['code']
+};
+//# sourceMappingURL=schemas.js.map

package/transpiled/contract/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../source/contract/schemas.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,MAAM,KAAK,GAAe;IAC/B,IAAI,EAAE,QAAQ;IACd,UAAU,EAAE;QACV,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QACtB,GAAG,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;QACjF,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE;QACxC,QAAQ,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QAC5B,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QAC1B,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;QAC1B,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE;QACrC,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE;QACtC,IAAI,EAAE;YACJ,IAAI,EAAE,OAAO;YACb,WAAW,EAAE,IAAI;YACjB,QAAQ,EAAE,CAAC;YACX,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,+BAA+B,EAAE;SACpE;QACD,UAAU,EAAE;YACV,IAAI,EAAE,OAAO;YACb,WAAW,EAAE,IAAI;YACjB,QAAQ,EAAE,CAAC;YACX,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE;SAChD;QACD,OAAO,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;QAC5B,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,CAAC,EAAE;QACvC,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;KAC1B;IACD,oBAAoB,EAAE,KAAK;CAC5B,CAAA;AAED,MAAM,CAAC,MAAM,KAAK,GAAe;IAC/B,IAAI,EAAE,QAAQ;IACd,UAAU,EAAE;QACV,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE;QAC1D,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;KAC5B;IACD,QAAQ,EAAE,CAAC,MAAM,CAAC;CACnB,CAAA"}

package/transpiled/contract/system.d.ts

@@ -0,0 +1,33 @@
+import type { Entity } from './request.ts';
+import type { JSONSchema } from './schemas.ts';
+/**
+ * What the root prototype gives every entity, as `runtime/prototype/manifest.toa.yaml` declares
+ * it. Held here because a contract is read where that package is not — a gateway reads one of a
+ * component it does not have — and kept the same as the prototype by a test in `@toa.io/norm`,
+ * which has both.
+ *
+ * `id` is apart from the rest: a component may declare its own, and the rest it may not.
+ */
+export declare const ID: JSONSchema;
+export declare const SYSTEM: Record<string, JSONSchema>;
+/**
+ * Whether one declaration is the other. Compared as written rather than by walking it: a
+ * component cannot have written a system property itself — a manifest that redeclares one is
+ * refused — so what is there came from the prototype and is identical to it. A comparison that
+ * says no costs the property being written out, and nothing else.
+ */
+export declare function same(one: unknown, other: unknown): boolean;
+/**
+ * The entity without what the runtime gives it, saying that it did. An entity a component
+ * declares itself — one whose prototype is `null` — may give four of them, or five, or the same
+ * names with other schemas, so it is stated as it stands and says nothing.
+ */
+export declare function pack(entity: Entity): Entity;
+/**
+ * The entity as the component declared it, which is what anything reading one is given.
+ *
+ * What is put back is a copy of it. An entity's schemas were its own before a contract left any
+ * of them out, and whoever holds one edits it — a route takes a property out of what it
+ * describes — so two components sharing one object is not a thing to start doing here.
+ */
+export declare function unpack(entity: Entity): Entity;

package/transpiled/contract/system.js

@@ -0,0 +1,76 @@
+/**
+ * What the root prototype gives every entity, as `runtime/prototype/manifest.toa.yaml` declares
+ * it. Held here because a contract is read where that package is not — a gateway reads one of a
+ * component it does not have — and kept the same as the prototype by a test in `@toa.io/norm`,
+ * which has both.
+ *
+ * `id` is apart from the rest: a component may declare its own, and the rest it may not.
+ */
+export const ID = { type: 'string', pattern: '^[a-fA-F0-9]{32}$' };
+export const SYSTEM = {
+    VERSION: { type: 'integer', minimum: 0 },
+    CREATED: { type: 'integer', format: 'epoch-millis' },
+    UPDATED: { type: 'integer', format: 'epoch-millis' },
+    DELETED: { type: 'integer', format: 'epoch-millis', nullable: true },
+    REGION: { type: 'integer', minimum: 0 }
+};
+/** What the prototype requires, which is every property it gives. */
+const REQUIRED = ['id', ...Object.keys(SYSTEM)];
+/**
+ * Whether one declaration is the other. Compared as written rather than by walking it: a
+ * component cannot have written a system property itself — a manifest that redeclares one is
+ * refused — so what is there came from the prototype and is identical to it. A comparison that
+ * says no costs the property being written out, and nothing else.
+ */
+export function same(one, other) {
+    return JSON.stringify(one) === JSON.stringify(other);
+}
+/**
+ * The entity without what the runtime gives it, saying that it did. An entity a component
+ * declares itself — one whose prototype is `null` — may give four of them, or five, or the same
+ * names with other schemas, so it is stated as it stands and says nothing.
+ */
+export function pack(entity) {
+    if (!given(entity))
+        return entity;
+    const properties = {};
+    for (const [name, property] of Object.entries(entity.properties))
+        if (!(name in SYSTEM) && !(name === 'id' && same(property, ID)))
+            properties[name] = property;
+    const required = (entity.required ?? []).filter((name) => !REQUIRED.includes(name));
+    return {
+        properties,
+        ...(required.length === 0 ? {} : { required }),
+        system: true
+    };
+}
+/**
+ * The entity as the component declared it, which is what anything reading one is given.
+ *
+ * What is put back is a copy of it. An entity's schemas were its own before a contract left any
+ * of them out, and whoever holds one edits it — a route takes a property out of what it
+ * describes — so two components sharing one object is not a thing to start doing here.
+ */
+export function unpack(entity) {
+    if (entity.system !== true)
+        return entity;
+    const declared = {
+        ...entity,
+        properties: {
+            ...entity.properties,
+            ...(entity.properties.id === undefined ? { id: structuredClone(ID) } : {}),
+            ...structuredClone(SYSTEM)
+        },
+        required: [...(entity.required ?? []), ...REQUIRED]
+    };
+    delete declared.system;
+    return declared;
+}
+/** Whether what the prototype gives is what this entity carries, which is what may be left out. */
+function given(entity) {
+    for (const [name, property] of Object.entries(SYSTEM))
+        if (!same(entity.properties[name], property))
+            return false;
+    return REQUIRED.every((name) => entity.required?.includes(name) === true);
+}
+//# sourceMappingURL=system.js.map

package/transpiled/contract/system.js.map

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

package/transpiled/deliveries.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The messages this process has taken and not yet finished with.
+ *
+ * A binding counts one in for as long as it holds a delivery, and that is exactly what its own
+ * teardown waits for: a connection cannot close while a message it dispatched is still being
+ * handled, and a handler waiting on a call of its own holds it there. So this answers, for the
+ * process as a whole, whether a teardown has anything left to wait on.
+ *
+ * It is not `toa.call.inflight`, which counts the other side — callers waiting. That number is
+ * non-zero for a call a gateway made, which blocks no teardown, and zero for a handler held open
+ * by a database commit, which blocks one.
+ *
+ * Ambient, like the instance name and the invocation chain, and for the same reason: a process
+ * may carry two copies of this module, and a count kept in one of them answers for half a
+ * process.
+ */
+/** One more delivery is being handled. */
+export declare function taken(): void;
+/** One fewer: the handler has returned, however it returned. */
+export declare function done(): void;
+/** How many this process is handling now. */
+export declare function inflight(): number;

package/transpiled/deliveries.js

@@ -0,0 +1,31 @@
+/**
+ * The messages this process has taken and not yet finished with.
+ *
+ * A binding counts one in for as long as it holds a delivery, and that is exactly what its own
+ * teardown waits for: a connection cannot close while a message it dispatched is still being
+ * handled, and a handler waiting on a call of its own holds it there. So this answers, for the
+ * process as a whole, whether a teardown has anything left to wait on.
+ *
+ * It is not `toa.call.inflight`, which counts the other side — callers waiting. That number is
+ * non-zero for a call a gateway made, which blocks no teardown, and zero for a handler held open
+ * by a database commit, which blocks one.
+ *
+ * Ambient, like the instance name and the invocation chain, and for the same reason: a process
+ * may carry two copies of this module, and a count kept in one of them answers for half a
+ * process.
+ */
+const KEY = Symbol.for('toa.core.deliveries');
+const store = (globalThis[KEY] ??= { count: 0 });
+/** One more delivery is being handled. */
+export function taken() {
+    store.count++;
+}
+/** One fewer: the handler has returned, however it returned. */
+export function done() {
+    store.count--;
+}
+/** How many this process is handling now. */
+export function inflight() {
+    return store.count;
+}
+//# sourceMappingURL=deliveries.js.map

package/transpiled/deliveries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deliveries.js","sourceRoot":"","sources":["../source/deliveries.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,qBAAqB,CAAC,CAAA;AAI7C,MAAM,KAAK,GAAG,CAAE,UAAoB,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAA;AAE3D,0CAA0C;AAC1C,MAAM,UAAU,KAAK;IACnB,KAAK,CAAC,KAAK,EAAE,CAAA;AACf,CAAC;AAED,gEAAgE;AAChE,MAAM,UAAU,IAAI;IAClB,KAAK,CAAC,KAAK,EAAE,CAAA;AACf,CAAC;AAED,6CAA6C;AAC7C,MAAM,UAAU,QAAQ;IACtB,OAAO,KAAK,CAAC,KAAK,CAAA;AACpB,CAAC"}

package/transpiled/effect.d.ts

@@ -0,0 +1,7 @@
+import { Observation } from './observation.ts';
+import type { Store } from './operation.ts';
+export declare class Effect extends Observation {
+    /** an effect reads for what it does next, which a projected read would leave short */
+    protected projects: boolean;
+    protected acquire(store: Store): Promise<void>;
+}

package/transpiled/effect.js

@@ -0,0 +1,13 @@
+import { Observation } from './observation.js';
+export class Effect extends Observation {
+    /** an effect reads for what it does next, which a projected read would leave short */
+    projects = false;
+    async acquire(store) {
+        const { query, entity, input } = store.request;
+        if (entity === undefined)
+            return super.acquire(store);
+        store.scope = await this.scope.ensure(query, entity, input);
+        store.state = store.scope.get();
+    }
+}
+//# sourceMappingURL=effect.js.map

package/transpiled/effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.js","sourceRoot":"","sources":["../source/effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAI9C,MAAM,OAAO,MAAO,SAAQ,WAAW;IACrC,sFAAsF;IACnE,QAAQ,GAAY,KAAK,CAAA;IAEzB,KAAK,CAAC,OAAO,CAAC,KAAY;QAC3C,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC,OAAO,CAAA;QAE9C,IAAI,MAAM,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAErD,KAAK,CAAC,KAAK,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,KAAY,EAAE,MAAM,EAAE,KAAK,CAAC,CAAA;QAClE,KAAK,CAAC,KAAK,GAAI,KAAK,CAAC,KAAgB,CAAC,GAAG,EAAE,CAAA;IAC7C,CAAC;CACF"}

package/transpiled/emission.d.ts

@@ -0,0 +1,10 @@
+import { Connector } from './connector.ts';
+import type { Event } from './event.ts';
+import type { Row } from './types/outbox.ts';
+export declare class Emission extends Connector {
+    #private;
+    /** what a row is outstanding for while this has not published it */
+    readonly name = "events";
+    constructor(events: Event[]);
+    emit(row: Row): Promise<void>;
+}

package/transpiled/emission.js

@@ -0,0 +1,16 @@
+import { Connector } from './connector.js';
+export class Emission extends Connector {
+    /** what a row is outstanding for while this has not published it */
+    name = 'events';
+    #events;
+    constructor(events) {
+        super();
+        this.#events = events;
+        this.depends(events);
+    }
+    async emit(row) {
+        const emission = this.#events.map((e) => e.emit(row));
+        await Promise.all(emission);
+    }
+}
+//# sourceMappingURL=emission.js.map

package/transpiled/emission.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emission.js","sourceRoot":"","sources":["../source/emission.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAI1C,MAAM,OAAO,QAAS,SAAQ,SAAS;IACrC,oEAAoE;IACpD,IAAI,GAAG,QAAQ,CAAA;IAEtB,OAAO,CAAS;IAEzB,YAAmB,MAAe;QAChC,KAAK,EAAE,CAAA;QAEP,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;QAErB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;IACtB,CAAC;IAEM,KAAK,CAAC,IAAI,CAAC,GAAQ;QACxB,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAA;QAErD,MAAM,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;IAC7B,CAAC;CACF"}

package/transpiled/encoded.d.ts

@@ -0,0 +1,16 @@
+/**
+ * An output a component encoded, which its caller passes on as it is: the bytes of what the
+ * operation answered, and what they are encoded in. A caller that writes them somewhere — the
+ * gateway writing a response body — spends nothing on reading them.
+ */
+export declare class Encoded {
+    readonly bytes: Buffer;
+    readonly type: string;
+    constructor(bytes: Buffer, type?: string);
+    /**
+     * Whether a value is an `Encoded`, whichever copy of this package made it. A process may load
+     * the package more than once — the gateway image installs it beside the runtime and again beside
+     * the extension — and what one copy made is no instance of the other copy's class.
+     */
+    static is(value: unknown): value is Encoded;
+}

package/transpiled/encoded.js

@@ -0,0 +1,25 @@
+/** What marks an `Encoded` in every copy of this package, which its class does not: see `is`. */
+const KEY = Symbol.for('toa.core.encoded');
+/**
+ * An output a component encoded, which its caller passes on as it is: the bytes of what the
+ * operation answered, and what they are encoded in. A caller that writes them somewhere — the
+ * gateway writing a response body — spends nothing on reading them.
+ */
+export class Encoded {
+    bytes;
+    type;
+    constructor(bytes, type = 'application/json') {
+        this.bytes = bytes;
+        this.type = type;
+        Object.defineProperty(this, KEY, { value: true });
+    }
+    /**
+     * Whether a value is an `Encoded`, whichever copy of this package made it. A process may load
+     * the package more than once — the gateway image installs it beside the runtime and again beside
+     * the extension — and what one copy made is no instance of the other copy's class.
+     */
+    static is(value) {
+        return typeof value === 'object' && value !== null && KEY in value;
+    }
+}
+//# sourceMappingURL=encoded.js.map

package/transpiled/encoded.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encoded.js","sourceRoot":"","sources":["../source/encoded.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAA;AAE1C;;;;GAIG;AACH,MAAM,OAAO,OAAO;IACF,KAAK,CAAQ;IACb,IAAI,CAAQ;IAE5B,YAAmB,KAAa,EAAE,IAAI,GAAW,kBAAkB;QACjE,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAClB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAEhB,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;IACnD,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,EAAE,CAAC,KAAc;QAC7B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,CAAA;IACpE,CAAC;CACF"}

package/transpiled/entities/changeset.d.ts

@@ -0,0 +1,10 @@
+import type { Schema } from '@toa.io/schemas';
+import type { Query, Record } from '../types/storages.ts';
+export declare class Changeset {
+    #private;
+    readonly query: Query;
+    constructor(schema: Schema, query: Query);
+    get(): object;
+    set(value: Record): void;
+    export(): object;
+}

package/transpiled/entities/changeset.js

@@ -0,0 +1,27 @@
+import { EntityContractException } from '../exceptions.js';
+export class Changeset {
+    query;
+    /** the changeset schema: the entity's properties, none of them required */
+    #schema;
+    #state;
+    constructor(schema, query) {
+        this.query = query;
+        this.#schema = schema;
+        this.#state = {};
+    }
+    get() {
+        return this.#state;
+    }
+    set(value) {
+        const error = this.#schema.fit(value);
+        if (error !== null)
+            throw new EntityContractException(error, value);
+        delete value.VERSION;
+        value.UPDATED = Date.now();
+        this.#state = value;
+    }
+    export() {
+        return this.#state;
+    }
+}
+//# sourceMappingURL=changeset.js.map

package/transpiled/entities/changeset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"changeset.js","sourceRoot":"","sources":["../../source/entities/changeset.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAA;AAI1D,MAAM,OAAO,SAAS;IACJ,KAAK,CAAO;IAE5B,2EAA2E;IAClE,OAAO,CAAQ;IACxB,MAAM,CAAiB;IAEvB,YAAmB,MAAc,EAAE,KAAY;QAC7C,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAElB,IAAI,CAAC,OAAO,GAAG,MAAM,CAAA;QACrB,IAAI,CAAC,MAAM,GAAG,EAAE,CAAA;IAClB,CAAC;IAEM,GAAG;QACR,OAAO,IAAI,CAAC,MAAM,CAAA;IACpB,CAAC;IAEM,GAAG,CAAC,KAAa;QACtB,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QAErC,IAAI,KAAK,KAAK,IAAI;YAAE,MAAM,IAAI,uBAAuB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;QAEnE,OAAQ,KAAyB,CAAC,OAAO,CAAA;QACzC,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;QAE1B,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;IACrB,CAAC;IAEM,MAAM;QACX,OAAO,IAAI,CAAC,MAAM,CAAA;IACpB,CAAC;CACF"}

package/transpiled/entities/entity.d.ts

@@ -0,0 +1,19 @@
+import type { Schema } from '@toa.io/schemas';
+import type { Guard } from '../guard.ts';
+import type { Record } from '../types/storages.ts';
+import type { Event } from '../types/state.ts';
+export declare class Entity {
+    #private;
+    deleted: boolean;
+    /**
+     * 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
+     */
+    constructor(schema: Schema, blank: object, argument?: Record | string, guards?: Guard[], mutable?: boolean);
+    get(): Record;
+    set(value: Record): void;
+    event(input?: object): Event;
+}