@agentshouse/mdruntime 0.1.0-cf08ada271a7f → 0.1.0-cf0c43fc48aad

package/README.md

@@ -12,14 +12,14 @@ npm install @agentshouse/mdruntime
 
 ## Entries
 
-| Entry                           | For                                                                                            |
-| ------------------------------- | ---------------------------------------------------------------------------------------------- |
-| `@agentshouse/mdruntime/client` | The host's client: `connectMdRuntime(port)`                                                    |
-| `@agentshouse/mdruntime/host`   | The host that serves a Runtime: `serveMdRuntime`                                               |
-| `@agentshouse/mdruntime`        | Shared types                                                                                   |
-| `@agentshouse/mdruntime/memory` | Tests: `createMemoryAdapter`, an in-memory Adapter                                             |
-| `@agentshouse/mdruntime/tables` | The host's database: the Authored store's and opened files' tables, `answerRuntime`            |
-| `@agentshouse/mdruntime/react`  | React over the client: `useObserve`, `useSave`; `useReading`, a reader of an expectation store |
+| Entry                           | For                                                                                                                                 |
+| ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
+| `@agentshouse/mdruntime/client` | The host's client: `connectMdRuntime(port)`                                                                                         |
+| `@agentshouse/mdruntime/host`   | The host that serves a Runtime: `serveMdRuntime`                                                                                    |
+| `@agentshouse/mdruntime`        | Shared types                                                                                                                        |
+| `@agentshouse/mdruntime/memory` | Tests: `createMemoryAdapter`, an in-memory Adapter                                                                                  |
+| `@agentshouse/mdruntime/tables` | The host's database: the Authored store's and opened files' tables, `answerRuntime`                                                 |
+| `@agentshouse/mdruntime/react`  | React over the client: `useObserve`, `useSave`; `useExpected`, a reader of an expectation store; `useLane`, a reader of an act lane |
 
 ## Usage
 
@@ -38,13 +38,13 @@ const notes = await runtime.query({ types: ['note'], select: 'all', limit: 20 })
 The host supplies the user-facing wording.
 
 In House the bridge object the page holds as `window.houseBridge` places the Chat, which
-House serves with the page: install and bundle nothing for it. Mount it in an element,
-themed by CSS custom properties on that element, docked at a third of the window:
+House serves with the page: install and bundle nothing for it. Mount it in an element it
+fills, on one chat, themed by CSS custom properties on that element:
 
 ```ts
-const chat = await window.houseBridge.chat.mount(element, { width: '1/3', showChats: true });
+const chat = await window.houseBridge.chat.mount(element, { conversation });
 element.style.setProperty('--chat-accent', '#2a6cf0');
-chat.update({ width: 'full', showChats: true });
+chat.update({ conversation: null, agent });
 chat.unmount();
 ```
 

package/dist/acceptance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"acceptance.d.ts","sourceRoot":"","sources":["../src/acceptance.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAiX5C,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,QAK5D"}
+{"version":3,"file":"acceptance.d.ts","sourceRoot":"","sources":["../src/acceptance.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AA0V5C,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,QAK5D"}

package/dist/acceptance.js

@@ -1,8 +1,8 @@
+import { refusalError } from './failure.js';
 import { changeSet } from './change-set.js';
 import { declared } from './declaration.js';
 import { leaving as leavingIn, partnerOf } from './change.js';
 import { olderThan, showing } from './install.js';
-import { readable } from './listing.js';
 import { scoped } from './models.js';
 import { answered, settle } from './queue.js';
 import { refuse } from './refusal.js';
@@ -13,7 +13,7 @@ import { advanced, withhold } from './sync.js';
 import { unconfirmed } from './transfer.js';
 import { stepped } from './turn.js';
 async function mark(runtime, local, locator, batch, submission, lost) {
-    const { store, socket } = runtime;
+    const { store, socket, presence } = runtime;
     const partner = partnerOf(batch, locator);
     for (const held of partner === null ? [locator] : [locator, partner]) {
         const { state, room } = await local.pending(held, batch.id);
@@ -23,27 +23,22 @@ async function mark(runtime, local, locator, batch, submission, lost) {
             continue;
         }
         await local.submit(held, batch.id, submission, lost);
-        if (store.fences.has(held))
+        if (presence.lost(held))
             continue;
         if (room)
             store.changed(changeSet(held, { queue: true }));
     }
     statusShown(runtime);
 }
-async function keepUpload({ store, socket }, local, locator, identifier, upload) {
+async function keepUpload({ socket, presence }, local, locator, identifier, upload) {
     if (!socket.continuing())
         throw new Error();
     await local.keepUpload(locator, identifier, upload);
-    if (store.fences.has(locator))
+    if (presence.lost(locator))
         throw new Error();
     if (!socket.continuing())
         throw new Error();
 }
-function logAccepted({ journal }, locator, submitted, accepted) {
-    journal.record(`outcome ${locator} ${submitted.id} accepted ${accepted.roomVersion}` +
-        (accepted.author === undefined ? '' : ` author ${accepted.author}`) +
-        (accepted.time === undefined ? '' : ` time ${accepted.time}`));
-}
 function restands(adoptions) {
     return adoptions.flatMap((one) => (one === null || !('record' in one) ? [] : [one]));
 }
@@ -55,7 +50,6 @@ async function adoption(runtime, room, current, local, submitted, accepted) {
         return null;
     }
     const held = current.record.roomVersion;
-    logAccepted(runtime, room.locator, submitted, accepted);
     let record = current.record;
     let adopted;
     if (!socket.reads.reached(room.locator, held, accepted.roomVersion) &&
@@ -78,7 +72,7 @@ async function adoption(runtime, room, current, local, submitted, accepted) {
         ...(adopted === undefined ? {} : { adopted }),
         after() {
             showing(runtime, room.locator, accepted.roomVersion, reached);
-            readable(runtime, room);
+            runtime.presence.readable(room.locator);
         },
     };
 }
@@ -92,7 +86,7 @@ async function adopted(runtime, room, local, submitted, accepted) {
     return kept;
 }
 async function adoptedMove(runtime, room, partner, local, submitted, accepted) {
-    const other = runtime.socket.rooms.discovered(partner);
+    const other = runtime.presence.room(partner);
     let kept = true;
     await settle(runtime, [room.locator, partner], async (held) => {
         const left = await adoption(runtime, room, held.get(room.locator)?.replica, local, submitted, accepted);
@@ -119,7 +113,7 @@ async function behindIn({ store }, locator, batch) {
     return room ? order.indexOf(batch.id) > 0 : order.length > 0;
 }
 async function submitRoom(runtime, room, local, authorized, progress, signal) {
-    const { store, socket, journal } = runtime;
+    const { store, socket, presence } = runtime;
     while (socket.continuing() &&
         socket.session.now().authorization !== undefined &&
         !signal.aborted) {
@@ -152,21 +146,18 @@ async function submitRoom(runtime, room, local, authorized, progress, signal) {
         }
         if (socket.writesHeld()) {
             progress.complete = false;
-            journal.record(`submission ${room.locator} ${head.id} held`);
             return 'done';
         }
         const lost = earlier || submission.state === 'submitted';
         let result;
-        journal.record(`submission ${room.locator} ${head.id}`);
         await store.exclusive(() => mark(runtime, local, room.locator, head, { state: 'submitted' }, lost));
-        if (socket.session.now().paused || store.fences.has(room.locator))
+        if (socket.session.now().paused || presence.lost(room.locator))
             return 'done';
         if (signal.aborted || socket.writesHeld()) {
             await store.exclusive(() => mark(runtime, local, room.locator, head, submission, earlier));
             if (signal.aborted)
                 return 'done';
             progress.complete = false;
-            journal.record(`submission ${room.locator} ${head.id} held`);
             return 'done';
         }
         const opensBefore = socket.session.now().openSignals;
@@ -184,7 +175,8 @@ async function submitRoom(runtime, room, local, authorized, progress, signal) {
                 ...(state?.upload === undefined ? {} : { upload: state.upload }),
             }, (upload) => store.exclusive(() => keepUpload(runtime, local, room.locator, head.id, upload)));
         }
-        catch {
+        catch (error) {
+            runtime.retries.failed('sending', submitting(room.locator), error);
             heard();
             progress.complete = false;
             if (socket.continuing())
@@ -199,14 +191,17 @@ async function submitRoom(runtime, room, local, authorized, progress, signal) {
             heard();
         if (!socket.continuing())
             return 'done';
+        if (result.kind === 'accepted')
+            runtime.retries.succeeded('sending', submitting(room.locator));
         if (result.kind === 'transport-uncertainty') {
+            runtime.retries.uncertain('sending', submitting(room.locator), result);
             progress.complete = false;
             progress.reachable = false;
             return 'again';
         }
         if (result.kind === 'room-not-readable') {
             progress.complete = false;
-            roomUnreadable(runtime, socket.rooms.discovered(result.locator) ?? room);
+            roomUnreadable(runtime, (presence.room(result.locator) ?? room).locator);
             return 'done';
         }
         if (result.kind === 'revoked-authorization') {
@@ -219,24 +214,15 @@ async function submitRoom(runtime, room, local, authorized, progress, signal) {
             return 'done';
         }
         if (result.kind === 'write-halted') {
-            journal.record(`outcome ${room.locator} ${head.id} write-halted`);
             await store.exclusive(() => mark(runtime, local, room.locator, head, { state: 'waiting' }, lost));
             if (!socket.haltedSince(opensBefore))
                 continue;
             progress.complete = false;
             return 'done';
         }
-        const other = partner === null ? undefined : socket.rooms.discovered(partner);
-        if (result.kind === 'conflicted' ||
-            result.kind === 'rejected' ||
-            result.kind === 'retryable-refusal') {
-            journal.record(`outcome ${room.locator} ${head.id} ${result.kind}` +
-                (result.kind === 'conflicted' && result.roomVersion !== undefined
-                    ? ` ${result.roomVersion}`
-                    : ''));
-            journal.record(`refusal ${result.kind} ${result.code}`);
-        }
+        const other = partner === null ? undefined : presence.room(partner);
         if (result.kind === 'retryable-refusal') {
+            runtime.retries.failed('sending', submitting(room.locator), refusalError(result));
             const reset = result.reset;
             progress.complete = false;
             await store.exclusive(() => mark(runtime, local, room.locator, head, reset === undefined ? { state: 'waiting' } : { state: 'reset', reset }, lost));
@@ -278,14 +264,17 @@ async function submitRoom(runtime, room, local, authorized, progress, signal) {
     }
     return 'done';
 }
+function submitting(locator) {
+    return `submit ${locator}`;
+}
 export function submitLater(runtime, locator) {
     if (runtime.localSaves)
         return;
-    void runtime.recovery.attempt(`submit ${locator}`, (signal) => submitPass(runtime, locator, signal));
+    void runtime.recovery.attempt(submitting(locator), (signal) => submitPass(runtime, locator, signal));
 }
 async function submitPass(runtime, locator, signal) {
-    const { store, socket } = runtime;
-    const room = socket.rooms.discovered(locator);
+    const { store, socket, presence } = runtime;
+    const room = presence.room(locator);
     if (!socket.continuing() || socket.stopping() || room === undefined) {
         return 'done';
     }
@@ -298,7 +287,8 @@ async function submitPass(runtime, locator, signal) {
             return 'done';
         next = await submitRoom(runtime, room, await store.open(), authorization, progress, signal);
     }
-    catch {
+    catch (error) {
+        runtime.retries.failed('sending', submitting(locator), error);
         progress.reachable = false;
         next = 'again';
     }

package/dist/act-lanes.d.ts

@@ -0,0 +1,30 @@
+import { type Expected, type Expecting } from './expectation.js';
+export type Ended = 'accepted' | 'refused' | 'unanswered' | 'unsent';
+export type Send<O> = {
+    (name: string, input: unknown, sending: (operation: string) => Promise<O>): Promise<O>;
+    expect(expected: Expected): void;
+};
+export type LaneShown<O> = {
+    readonly busy: boolean;
+    readonly drawn: boolean;
+    readonly ended: O | null;
+};
+export type Lane<O> = {
+    run(steps: (send: Send<O>) => Promise<O>, expected?: Expected): Promise<O>;
+    shown(): LaneShown<O>;
+    subscribe(listener: () => void): () => void;
+    forget(): void;
+};
+export type Acting<O> = {
+    open(): Lane<O>;
+};
+export type ActingRules<O> = {
+    readonly store: Pick<Expecting, 'begin' | 'expect' | 'drop'>;
+    readonly uncertain: O;
+    ending(outcome: O): Ended;
+    acted?(): void;
+    mint?(): string;
+    settles?(operation: string): Promise<boolean>;
+};
+export declare function acting<O>(rules: ActingRules<O>): Acting<O>;
+//# sourceMappingURL=act-lanes.d.ts.map

package/dist/act-lanes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"act-lanes.d.ts","sourceRoot":"","sources":["../src/act-lanes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAG/E,MAAM,MAAM,KAAK,GAAG,UAAU,GAAG,SAAS,GAAG,YAAY,GAAG,QAAQ,CAAC;AAErE,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI;IACpB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACvF,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IACzB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI;IACpB,GAAG,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC3E,KAAK,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC;IACtB,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAC5C,MAAM,IAAI,IAAI,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI;IACtB,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAC3B,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC,CAAC;IAC7D,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC;IACtB,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,KAAK,CAAC;IAC1B,KAAK,CAAC,IAAI,IAAI,CAAC;IACf,IAAI,CAAC,IAAI,MAAM,CAAC;IAChB,OAAO,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC/C,CAAC;AAUF,wBAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CA6N1D"}

package/dist/act-lanes.js

@@ -0,0 +1,225 @@
+import { expectedList } from './expectation.js';
+import { changeBatchIdentity } from './identity.js';
+const IDLE = { busy: false, drawn: false, ended: null };
+export function acting(rules) {
+    const { store, uncertain, ending, settles } = rules;
+    const mint = rules.mint ?? (() => changeBatchIdentity());
+    const identities = new Map();
+    const waiting = new Map();
+    const settling = new Map();
+    const blobs = new WeakMap();
+    let counted = 0;
+    let touches = 0;
+    const requestOf = (name, input) => {
+        const carried = [];
+        const json = JSON.stringify(input, (_key, value) => {
+            if (!(value instanceof Blob))
+                return value;
+            let one = blobs.get(value);
+            if (one === undefined) {
+                counted += 1;
+                one = counted;
+                blobs.set(value, one);
+            }
+            carried.push(one);
+            return null;
+        });
+        return `${name}\u0000${json}\u0000${carried.join(',')}`;
+    };
+    const identityOf = (request) => {
+        const held = identities.get(request);
+        if (held !== undefined)
+            return held;
+        const fresh = { operation: mint(), touched: 0, flying: 0 };
+        identities.set(request, fresh);
+        return fresh;
+    };
+    const settled = (act, ended, calls) => {
+        const released = new Map();
+        for (const { request, identity, ended: answered } of calls) {
+            const heard = answered === 'accepted' || answered === 'refused';
+            if (ended === 'accepted' && heard)
+                released.set(request, identity.touched);
+            else {
+                touches += 1;
+                identity.touched = touches;
+                identities.set(request, identity);
+            }
+        }
+        if (ended === 'refused' || ended === 'unsent')
+            store.drop(act);
+        for (const { request, ended: answered } of calls) {
+            const earlier = waiting.get(request);
+            if (answered === 'unsent' && earlier !== undefined)
+                continue;
+            if (earlier !== undefined && earlier !== act)
+                store.drop(earlier);
+            if (ended === 'unanswered')
+                waiting.set(request, act);
+            else
+                waiting.delete(request);
+        }
+        if (ended === 'accepted' || calls.some((one) => one.ended === 'accepted'))
+            rules.acted?.();
+        return released;
+    };
+    const release = (released) => {
+        for (const [request, touched] of released) {
+            const held = identities.get(request);
+            if (held !== undefined && held.touched === touched && held.flying === 0) {
+                identities.delete(request);
+            }
+        }
+    };
+    return {
+        open() {
+            const listeners = new Set();
+            const releasing = new Map();
+            let tail = Promise.resolve();
+            let pressed = 0;
+            let drawing = 0;
+            let ended = null;
+            let held = null;
+            let presses = 0;
+            let shown = IDLE;
+            const show = () => {
+                const busy = pressed > 0;
+                const drawn = drawing > 0;
+                if (shown.busy === busy && shown.drawn === drawn && shown.ended === ended)
+                    return;
+                shown = { busy, drawn, ended };
+                for (const listener of listeners)
+                    listener();
+            };
+            const awaiting = (outcome, operations, heard, again) => new Promise((resolve) => {
+                const forgotten = () => {
+                    for (const operation of operations)
+                        if (settling.get(operation) === record)
+                            settling.delete(operation);
+                };
+                const record = {
+                    supersede() {
+                        if (held !== record)
+                            return;
+                        held = null;
+                        forgotten();
+                        resolve(outcome);
+                    },
+                };
+                held = record;
+                for (const operation of operations)
+                    settling.set(operation, record);
+                const answers = operations.map((operation) => heard(operation).then((answered) => {
+                    if (!answered)
+                        record.supersede();
+                    return answered;
+                }));
+                void Promise.all(answers).then(() => {
+                    if (held !== record)
+                        return;
+                    held = null;
+                    forgotten();
+                    resolve(again());
+                }, () => record.supersede());
+            });
+            const attempt = (steps, expected, press) => {
+                const act = store.begin();
+                let drew = false;
+                const expect = (more) => {
+                    if (expectedList(more).length === 0)
+                        return;
+                    store.expect(act, more);
+                    if (drew)
+                        return;
+                    drew = true;
+                    drawing += 1;
+                    show();
+                };
+                pressed += 1;
+                expect(expected);
+                show();
+                const calls = [];
+                const send = Object.assign(async (name, input, sending) => {
+                    const request = requestOf(name, input);
+                    const identity = identityOf(request);
+                    settling.get(identity.operation)?.supersede();
+                    const called = { request, identity, ended: null };
+                    calls.push(called);
+                    touches += 1;
+                    identity.touched = touches;
+                    identity.flying += 1;
+                    let outcome;
+                    try {
+                        outcome = await sending(identity.operation);
+                    }
+                    catch {
+                        outcome = uncertain;
+                    }
+                    finally {
+                        identity.flying -= 1;
+                    }
+                    called.ended = ending(outcome);
+                    return outcome;
+                }, { expect });
+                const end = (outcome, how) => {
+                    for (const [request, touched] of settled(act, how, calls))
+                        releasing.set(request, touched);
+                    pressed -= 1;
+                    if (drew)
+                        drawing -= 1;
+                    ended = outcome;
+                    if (pressed === 0) {
+                        release(releasing);
+                        releasing.clear();
+                    }
+                    show();
+                };
+                const turn = tail.then(async () => {
+                    ended = null;
+                    show();
+                    let outcome;
+                    try {
+                        outcome = await steps(send);
+                    }
+                    catch (error) {
+                        end(uncertain, 'unanswered');
+                        throw error;
+                    }
+                    const how = ending(outcome);
+                    end(outcome, how);
+                    return { outcome, how };
+                });
+                tail = turn.catch(() => undefined);
+                return turn.then(({ outcome, how }) => {
+                    const lost = calls.flatMap(({ identity, ended: answered }) => answered === 'unanswered' ? [identity.operation] : []);
+                    if (how !== 'unanswered' || lost.length === 0 || settles === undefined)
+                        return outcome;
+                    if (press !== presses)
+                        return outcome;
+                    return awaiting(outcome, lost, settles, () => attempt(steps, expected, press));
+                });
+            };
+            const run = (steps, expected = null) => {
+                held?.supersede();
+                presses += 1;
+                return attempt(steps, expected, presses);
+            };
+            return {
+                run,
+                shown: () => shown,
+                subscribe(listener) {
+                    listeners.add(listener);
+                    return () => {
+                        listeners.delete(listener);
+                    };
+                },
+                forget() {
+                    if (pressed > 0 || ended === null)
+                        return;
+                    ended = null;
+                    show();
+                },
+            };
+        },
+    };
+}

package/dist/actions.d.ts

@@ -1,6 +1,7 @@
 import type { ConversationHistoryRequest } from './adapter.js';
 import { type CallResult, type HistoryAnswer, type Resolution } from './outcome.js';
 import type { Attempted } from './recovery.js';
+import type { Attempt } from './retried.js';
 import type { Runtime } from './runtime.js';
 export type HistoryQuery = {
     revision?: string;
@@ -12,9 +13,14 @@ export declare function located(runtime: Runtime, room: string, path: string, de
     path: string;
 } | null>;
 export declare function resolveReference(runtime: Runtime, room: string, path: string, destination: string): Promise<Resolution>;
-export declare function invokeAction(runtime: Runtime, name: string, input: unknown, dispatching?: () => Promise<void>): Promise<CallResult>;
+export type Invoked = {
+    readonly dispatching?: () => Promise<void>;
+    readonly attempt?: Attempt;
+};
+export declare function invokeAction(runtime: Runtime, name: string, input: unknown, { dispatching, attempt }?: Invoked): Promise<CallResult>;
 export declare function readConversationHistory(runtime: Runtime, request: ConversationHistoryRequest): Promise<CallResult>;
-export declare function called(runtime: Runtime, name: string, input: unknown): Promise<CallResult>;
+export declare function called(runtime: Runtime, name: string, input: unknown, attempt?: Attempt): Promise<CallResult>;
+export declare function answeredCall(runtime: Runtime, operation: string): Promise<boolean>;
 export declare function resendCalls(runtime: Runtime, signal: AbortSignal): Promise<Attempted>;
 export declare function resendLater(runtime: Runtime): void;
 //# sourceMappingURL=actions.d.ts.map

package/dist/actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAK/D,OAAO,EAUL,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,UAAU,EAChB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAG5C,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAOF,wBAAsB,WAAW,CAC/B,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,YAAiB,GACvB,OAAO,CAAC,aAAa,CAAC,CAqCxB;AAED,wBAAsB,OAAO,CAC3B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAShD;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,UAAU,CAAC,CAuBrB;AAwBD,wBAAsB,YAAY,CAChC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAChC,OAAO,CAAC,UAAU,CAAC,CA6BrB;AAED,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,UAAU,CAAC,CAiBrB;AAuCD,wBAAsB,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,CAKhG;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAiB3F;AAiBD,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,QAG3C"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAM/D,OAAO,EAWL,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,UAAU,EAChB,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAG5C,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAOF,wBAAsB,WAAW,CAC/B,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,YAAiB,GACvB,OAAO,CAAC,aAAa,CAAC,CA+BxB;AAED,wBAAsB,OAAO,CAC3B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAShD;AAED,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,UAAU,CAAC,CAuBrB;AAwBD,MAAM,MAAM,OAAO,GAAG;IACpB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,wBAAsB,YAAY,CAChC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,EAAE,WAAW,EAAE,OAAO,EAAE,GAAE,OAAY,GACrC,OAAO,CAAC,UAAU,CAAC,CA6BrB;AAED,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,UAAU,CAAC,CAerB;AA4GD,wBAAsB,MAAM,CAC1B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,UAAU,CAAC,CAKrB;AAED,wBAAsB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAaxF;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC,CAe3F;AAiBD,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,QAG3C"}