@agentshouse/mdruntime 0.1.0-ce531b51ff088 → 0.1.0-ce6bc9239a3ee

package/README.md

@@ -12,22 +12,23 @@ npm install @agentshouse/mdruntime
 
 ## Entries
 
-| Entry                           | For                                                |
-| ------------------------------- | -------------------------------------------------- |
-| `@agentshouse/mdruntime/client` | App code: `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 |
+| 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`                                      |
 
 ## Usage
 
-App code imports only the client entry and connects on the port its host hands
-it:
+App code takes the client its host hands it; in House the App bridge hands it:
 
 ```ts
-import { connectMdRuntime } from '@agentshouse/mdruntime/client';
+import { houseBridge } from '@agentshouse/app-bridge';
 
-const runtime = connectMdRuntime(port);
+const runtime = await houseBridge().runtime;
 const rooms = await runtime.rooms();
 const notes = await runtime.query({ types: ['note'], select: 'all', limit: 20 });
 ```
@@ -36,8 +37,20 @@ const notes = await runtime.query({ types: ['note'], select: 'all', limit: 20 })
 `storage-loss` when unsynchronized Room Drafts and Pending Changes were lost.
 The host supplies the user-facing wording.
 
-The rules an App's agent follows, including Local Query, Local Search, Room
-Draft and Save, are in [`AGENTS.md`](AGENTS.md).
+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:
+
+```ts
+const chat = await window.houseBridge.chat.mount(element, { width: '1/3', showChats: true });
+element.style.setProperty('--chat-accent', '#2a6cf0');
+chat.update({ width: 'full', showChats: true });
+chat.unmount();
+```
+
+The rules an App's agent follows, including Local Query, search, Room
+Draft, Save and the Chat, are the `apps/` pages of House's Guide, which House's
+`guide/open` opens.
 
 ## License
 

package/dist/acceptance.d.ts

@@ -0,0 +1,26 @@
+import type { Authorization, DiscoveredRoom } from './adapter.js';
+import { type Withheld } from './install.js';
+import type { Recovery } from './recovery.js';
+import { type Saver } from './saves.js';
+import type { CycleProgress } from './status.js';
+import type { RuntimeStore } from './store.js';
+export type Accepting = Saver & {
+    readonly recovery: Recovery;
+    stopping(): boolean;
+    paused(): boolean;
+    continuing(): boolean;
+    discovered(locator: string): DiscoveredRoom | undefined;
+    readable(room: DiscoveredRoom): void;
+    unreadable(room: DiscoveredRoom): void;
+    advanced(room: DiscoveredRoom, local: RuntimeStore, authorized: Authorization): Promise<Withheld | null>;
+    withhold(withheld: Withheld, room: DiscoveredRoom, local: RuntimeStore, progress: CycleProgress): Promise<void>;
+    writesHeld(): boolean;
+    openSignals(): number;
+    haltedSince(opens: number): boolean;
+    rest(progress: CycleProgress): Promise<void>;
+    statusShown(): Promise<void>;
+};
+export declare function unpair(accepting: Accepting, local: RuntimeStore): Promise<void>;
+export declare function submitLater(accepting: Accepting, locator: string): void;
+export declare function submitAll(accepting: Accepting): Promise<void>;
+//# sourceMappingURL=acceptance.d.ts.map

package/dist/acceptance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acceptance.d.ts","sourceRoot":"","sources":["../src/acceptance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAkB,MAAM,cAAc,CAAC;AAIlF,OAAO,EAAsB,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAC;AAEjE,OAAO,KAAK,EAAa,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzD,OAAO,EAUL,KAAK,KAAK,EAEX,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAe,MAAM,YAAY,CAAC;AAI5D,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG;IAC9B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,IAAI,OAAO,CAAC;IACpB,MAAM,IAAI,OAAO,CAAC;IAClB,UAAU,IAAI,OAAO,CAAC;IACtB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAAC;IACxD,QAAQ,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAAC;IACrC,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAAC;IACvC,QAAQ,CACN,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,YAAY,EACnB,UAAU,EAAE,aAAa,GACxB,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAC;IAC5B,QAAQ,CACN,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,YAAY,EACnB,QAAQ,EAAE,aAAa,GACtB,OAAO,CAAC,IAAI,CAAC,CAAC;IACjB,UAAU,IAAI,OAAO,CAAC;IACtB,WAAW,IAAI,MAAM,CAAC;IACtB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IACpC,IAAI,CAAC,QAAQ,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAAC;AAoOF,wBAAsB,MAAM,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBrF;AAgOD,wBAAgB,WAAW,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,QAKhE;AA4BD,wBAAsB,SAAS,CAAC,SAAS,EAAE,SAAS,iBAMnD"}

package/dist/acceptance.js

@@ -0,0 +1,384 @@
+import { changeSet } from './change-set.js';
+import { leaving as leavingIn, partnerOf } from './change.js';
+import { runtimeError } from './failure.js';
+import { olderThan, showing } from './install.js';
+import { landed, returnedPaths, returning, slicing, touchedBy } from './replica.js';
+import { batchFile, landedWhole, settle, settlement, sliceAt, together, unpairing, withdrawable, } from './saves.js';
+import { unconfirmed } from './transfer.js';
+import { stepped } from './turn.js';
+function pendingKey(locator, id) {
+    return `${locator}\u0000${id}`;
+}
+async function mark(accepting, local, locator, batch, submission, lost) {
+    const { store, continuing, publishChangeSet, statusShown } = accepting;
+    const partner = partnerOf(batch, locator);
+    for (const held of partner === null ? [locator] : [locator, partner]) {
+        const { state, room } = await local.pending(held, batch.id);
+        if (!continuing() ||
+            state === undefined ||
+            (JSON.stringify(state.submission) === JSON.stringify(submission) && state.lost === lost)) {
+            continue;
+        }
+        await local.submit(held, batch.id, submission, lost);
+        if (store.fences.has(held))
+            continue;
+        if (room)
+            publishChangeSet(changeSet(held, { queue: true }));
+    }
+    statusShown();
+}
+async function keepUpload({ store, continuing }, local, locator, identifier, upload) {
+    if (!continuing())
+        throw new Error('connection refused');
+    await local.keepUpload(locator, identifier, upload);
+    if (store.fences.has(locator))
+        throw runtimeError('unknown-room', `Unknown Room ${locator}`);
+    if (!continuing())
+        throw new Error('connection refused');
+}
+function leaving(batch, result) {
+    return {
+        batch,
+        returned: {
+            kind: result.kind,
+            code: result.code,
+            fields: result.fields,
+            retryable: result.retryable,
+        },
+    };
+}
+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 settling(acceptance) {
+    return acceptance !== null && 'apply' in acceptance;
+}
+function failureOf(acceptance) {
+    return settling(acceptance) ? null : acceptance;
+}
+async function acceptance(accepting, room, local, submitted, accepted) {
+    const { store, socket } = accepting;
+    if (!accepting.continuing())
+        return unconfirmed;
+    const work = await store.work(room.locator);
+    const current = work.replica;
+    if (current === undefined || !current.queue.some((batch) => batch.id === submitted.id)) {
+        return null;
+    }
+    const held = current.record.roomVersion;
+    logAccepted(accepting, room.locator, submitted, accepted);
+    let record = current.record;
+    let changes;
+    if (!socket.reads.reached(room.locator, held, accepted.roomVersion) &&
+        !olderThan(accepting, room.locator, accepted.roomVersion, held)) {
+        const paths = [...returnedPaths(submitted, accepted)];
+        const confirmedLayer = await stepped(slicing(await local.entries(record.key, 'confirmed', paths), paths));
+        const back = await stepped(returning(confirmedLayer, submitted, accepted, accepted.roomVersion, store.composed(record)));
+        record = {
+            ...record,
+            roomVersion: socket.follows(room.locator, held, accepted.roomVersion)
+                ? accepted.roomVersion
+                : held,
+        };
+        changes = back;
+    }
+    const settled = await settlement(accepting, local, room.locator, work, record, current.queue.filter((batch) => batch.id !== submitted.id), { room: true, ...(changes === undefined ? {} : { changes }) });
+    const reached = record.roomVersion;
+    return {
+        ...settled,
+        apply(answer) {
+            const set = settled.apply(answer);
+            showing(accepting, room.locator, accepted.roomVersion, reached);
+            accepting.readable(room);
+            return set;
+        },
+    };
+}
+async function adoptedTogether(accepting, local, acceptances) {
+    const settlements = acceptances.filter(settling);
+    if (settlements.length > 0) {
+        const set = await together(accepting, local, settlements);
+        void accepting.statusShown();
+        void accepting.publishChangeSet(set);
+    }
+    await unpair(accepting, local);
+}
+async function adopted(accepting, room, local, submitted, accepted) {
+    const failed = await accepting.store.exclusive(async () => {
+        const adopting = await acceptance(accepting, room, local, submitted, accepted);
+        await adoptedTogether(accepting, local, [adopting]);
+        return failureOf(adopting);
+    });
+    return failed === null;
+}
+async function adoptedMove(accepting, room, partner, local, submitted, accepted) {
+    const { store } = accepting;
+    const other = accepting.discovered(partner);
+    const failed = await store.exclusive(async () => {
+        const left = await acceptance(accepting, room, local, submitted, accepted);
+        const arriving = (await store.replica(partner))?.queue.find((batch) => batch.id === submitted.id);
+        const arrived = other === undefined || arriving === undefined || accepted.destination === undefined
+            ? null
+            : await acceptance(accepting, other, local, arriving, {
+                kind: 'accepted',
+                ...accepted.destination,
+            });
+        await adoptedTogether(accepting, local, [left, arrived]);
+        return failureOf(left);
+    });
+    submitLater(accepting, partner);
+    return failed === null;
+}
+async function behindIn({ store }, locator, batch) {
+    const local = await store.open();
+    const [order, { room }] = await Promise.all([
+        local.order(locator),
+        local.pending(locator, batch.id),
+    ]);
+    return room ? order.indexOf(batch.id) > 0 : order.length > 0;
+}
+async function unpaired(local, skipped) {
+    const { queued, moving } = await local.moving();
+    for (const { locator, batch, state } of moving) {
+        const partner = partnerOf(batch, locator);
+        if (partner === null || skipped.has(pendingKey(locator, batch.id)))
+            continue;
+        if (queued.get(partner)?.includes(batch.id) === true)
+            continue;
+        if (!leavingIn(batch, locator) || withdrawable(new Map([[batch.id, state]]))(batch)) {
+            return { locator, batch };
+        }
+    }
+    return null;
+}
+export async function unpair(accepting, local) {
+    const { continuing, publishChangeSet } = accepting;
+    const handled = new Set();
+    for (let held = await unpaired(local, handled); held !== null && continuing(); held = await unpaired(local, handled)) {
+        const { locator, batch } = held;
+        handled.add(pendingKey(locator, batch.id));
+        publishChangeSet(await together(accepting, local, [await unpairing(accepting, local, locator, [batch])]));
+    }
+    if (handled.size === 0)
+        return;
+    accepting.statusShown();
+}
+async function submitRoom(accepting, room, local, authorized, progress, signal) {
+    const { store, socket, journal, continuing, writesHeld, advanced, withhold } = accepting;
+    while (continuing() && accepting.authorized() !== undefined && !signal.aborted) {
+        const headId = (await local.order(room.locator)).find((id) => store.landed.of(room.locator, id) === undefined);
+        if (headId === undefined)
+            return 'done';
+        const [head, pending] = await Promise.all([
+            local.batch(room.locator, headId),
+            local.pending(room.locator, headId),
+        ]);
+        if (head === null || !pending.room)
+            return 'done';
+        const { state } = pending;
+        const partner = partnerOf(head, room.locator);
+        if (partner !== null && !leavingIn(head, room.locator)) {
+            submitLater(accepting, partner);
+            return 'done';
+        }
+        if (partner !== null && (await behindIn(accepting, partner, head))) {
+            progress.complete = false;
+            return 'done';
+        }
+        const { submission, lost: earlier } = state ?? {
+            submission: { state: 'waiting' },
+            lost: false,
+        };
+        if (submission.state === 'reset' && Date.now() < Date.parse(submission.reset)) {
+            progress.complete = false;
+            return { at: Date.parse(submission.reset) };
+        }
+        if (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(accepting, local, room.locator, head, { state: 'submitted' }, lost));
+        if (accepting.paused() || store.fences.has(room.locator))
+            return 'done';
+        if (signal.aborted || writesHeld()) {
+            await store.exclusive(() => mark(accepting, 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 = accepting.openSignals();
+        const answeredHere = socket.awaitingAnswer(room.locator);
+        const answeredThere = partner === null ? () => { } : socket.awaitingAnswer(partner);
+        const answered = () => {
+            answeredHere();
+            answeredThere();
+        };
+        try {
+            result = await socket.mutate(authorized, {
+                locator: room.locator,
+                changeBatch: head,
+                file: batchFile(store, head),
+                ...(state?.upload === undefined ? {} : { upload: state.upload }),
+            }, (upload) => store.exclusive(() => keepUpload(accepting, local, room.locator, head.id, upload)));
+        }
+        catch {
+            answered();
+            progress.complete = false;
+            if (continuing())
+                progress.reachable = false;
+            return 'again';
+        }
+        if (signal.aborted) {
+            answered();
+            return 'done';
+        }
+        if (result.kind !== 'accepted' || !continuing())
+            answered();
+        if (!continuing())
+            return 'done';
+        if (result.kind === 'transport-uncertainty') {
+            progress.complete = false;
+            progress.reachable = false;
+            return 'again';
+        }
+        if (result.kind === 'room-not-readable') {
+            progress.complete = false;
+            accepting.unreadable(accepting.discovered(result.locator) ?? room);
+            return 'done';
+        }
+        if (result.kind === 'revoked-authorization') {
+            await accepting.refuse('revoked-authorization');
+            return 'done';
+        }
+        if (result.kind === 'scoped-refusal') {
+            await accepting.scoped(result, room, local);
+            progress.complete = false;
+            return 'done';
+        }
+        if (result.kind === 'write-halted') {
+            journal.record(`outcome ${room.locator} ${head.id} write-halted`);
+            await store.exclusive(() => mark(accepting, local, room.locator, head, { state: 'waiting' }, lost));
+            if (!accepting.haltedSince(opensBefore))
+                continue;
+            progress.complete = false;
+            return 'done';
+        }
+        const other = partner === null ? undefined : accepting.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}`);
+        }
+        if (result.kind === 'retryable-refusal') {
+            const reset = result.reset;
+            progress.complete = false;
+            await store.exclusive(() => mark(accepting, local, room.locator, head, reset === undefined ? { state: 'waiting' } : { state: 'reset', reset }, lost));
+            return reset === undefined ? 'again' : { at: Date.parse(reset) };
+        }
+        if (result.kind === 'conflicted' || result.kind === 'rejected') {
+            const left = leaving(head, result);
+            const refreshed = async () => ({
+                there: other === undefined ? null : await advanced(other, local, authorized),
+                here: await advanced(room, local, authorized),
+            });
+            const judged = result.kind === 'conflicted' && other !== undefined ? await refreshed() : null;
+            if (judged !== null && (judged.there !== null || judged.here !== null)) {
+                await store.exclusive(() => mark(accepting, local, room.locator, head, { state: 'waiting' }, lost));
+                if (other !== undefined && judged.there !== null) {
+                    await withhold(judged.there, other, local, progress);
+                }
+                if (judged.here !== null)
+                    await withhold(judged.here, room, local, progress);
+                return 'done';
+            }
+            await store.exclusive(async () => {
+                if (!continuing())
+                    return;
+                const work = await store.work(room.locator);
+                const current = work.replica;
+                if (current === undefined || !current.queue.some((batch) => batch.id === head.id)) {
+                    return;
+                }
+                const confirmedLayer = await sliceAt(store, current.record, 'confirmed', [head]);
+                const held = result.kind === 'conflicted' &&
+                    (await landedWhole(store, room.locator, head, confirmedLayer, result.affected));
+                if (held &&
+                    result.kind === 'conflicted' &&
+                    partner === null &&
+                    !landed(head, confirmedLayer)) {
+                    store.landed.hold(room.locator, head.id, Object.fromEntries([...touchedBy([head])].map((path) => [path, confirmedLayer.revisions[path]])));
+                    return;
+                }
+                accepting.publishChangeSet(await settle(accepting, local, room.locator, work, current.record, current.queue.filter((batch) => batch.id !== head.id), { leaving: [held ? { ...left, returned: null } : left] }));
+                await unpair(accepting, local);
+                accepting.statusShown();
+            });
+            const { there, here } = judged ?? (await refreshed());
+            if (other !== undefined && there !== null)
+                await withhold(there, other, local, progress);
+            if (here !== null) {
+                await withhold(here, room, local, progress);
+                return 'done';
+            }
+            continue;
+        }
+        const kept = await (partner === null
+            ? adopted(accepting, room, local, head, result)
+            : adoptedMove(accepting, room, partner, local, head, result)).finally(answered);
+        if (!kept) {
+            progress.complete = false;
+            return 'done';
+        }
+    }
+    return 'done';
+}
+export function submitLater(accepting, locator) {
+    if (accepting.localSaves)
+        return;
+    void accepting.recovery.attempt(`submit ${locator}`, (signal) => submitPass(accepting, locator, signal));
+}
+async function submitPass(accepting, locator, signal) {
+    const { store, socket } = accepting;
+    const room = accepting.discovered(locator);
+    if (accepting.closed() || accepting.stopping() || accepting.paused() || room === undefined) {
+        return 'done';
+    }
+    const progress = { complete: true, reachable: true };
+    let next;
+    try {
+        await accepting.ensureAuthorization();
+        const authorization = accepting.authorized();
+        if (authorization === undefined)
+            return 'done';
+        next = await submitRoom(accepting, room, await store.open(), authorization, progress, signal);
+    }
+    catch {
+        progress.reachable = false;
+        next = 'again';
+    }
+    if (signal.aborted)
+        return 'done';
+    await accepting.rest(progress);
+    return next === 'again' && !socket.isOpen() ? 'done' : next;
+}
+export async function submitAll(accepting) {
+    const { store } = accepting;
+    if (accepting.localSaves)
+        return;
+    for (const locator of await (await store.open()).queued()) {
+        if (!store.fences.has(locator))
+            submitLater(accepting, locator);
+    }
+}