@agentshouse/mdruntime 0.1.0-c698c0ebd65bd → 0.1.0-c6bf34fa9e444

package/dist/sync.js

@@ -0,0 +1,531 @@
+import { submitAll, submitLater } from './acceptance.js';
+import { resendCalls, resendLater } from './actions.js';
+import { applyDiscovery, discoverRooms, malformed, signIn } from './discovery.js';
+import { behind, caughtUpTo, publish, pullBootstrap, pullRefresh, reachedBy, replaced, standingAt, } from './install.js';
+import { heldRooms, listHeld, name, readable } from './listing.js';
+import { declaredAsHeld, keepNaming, retainModel, revoked, scoped } from './models.js';
+import { refuse } from './refusal.js';
+import { emitRooms, moveTo, rest, roomUnreadable, transferring, AUTHORITY_TOPIC } from './shown.js';
+import { unconfirmed } from './transfer.js';
+export const OPENING_LANE = 'opening';
+async function advance(runtime, room, local, authorized, running, unheld) {
+    const { store, socket } = runtime;
+    const live = () => running() && !store.space.full();
+    if (!live())
+        return unconfirmed;
+    const held = unheld === undefined ? await store.record(room.locator) : undefined;
+    if (socket.streamed && (held !== undefined || !store.installs.of(room.locator).beyondHorizon)) {
+        socket.rooms.stand(room.locator, { stale: false });
+        await name(runtime, room.locator);
+        return null;
+    }
+    const refresh = socket.reads.refresh;
+    if (held !== undefined && refresh !== undefined) {
+        const refreshed = await store.ahead((hold) => refreshedRoom(runtime, room, local, authorized, held, live, hold, refresh));
+        if (refreshed === 'behind')
+            return advance(runtime, room, local, authorized, live);
+        if (refreshed !== 'beyond-horizon')
+            return refreshed;
+        if (socket.rooms.standing(room.locator).reloadDue)
+            return unconfirmed;
+        replaced(store, [room.locator]);
+    }
+    const prior = held === undefined ? undefined : await store.record(room.locator);
+    const from = standingAt(store, room.locator, prior);
+    const bootstrapped = await pullBootstrap(runtime, authorized, room, local, live, prior, socket.reads, unheld);
+    if (bootstrapped.kind !== 'staged')
+        return live() ? bootstrapped : unconfirmed;
+    const landing = { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from };
+    if (await publish(runtime, local, room, bootstrapped.record, landing, live)) {
+        return live() ? null : unconfirmed;
+    }
+    return (await reachedBy(runtime, room.locator, bootstrapped.record.roomVersion))
+        ? null
+        : advance(runtime, room, local, authorized, live);
+}
+async function refreshedRoom(runtime, room, local, authorized, held, live, hold, refresh) {
+    const { store, socket } = runtime;
+    const { rooms } = socket;
+    const refreshed = await pullRefresh(runtime, authorized, held, live, hold, refresh);
+    if (!live())
+        return unconfirmed;
+    if (refreshed.kind === 'still-current') {
+        rooms.stand(room.locator, { stale: false });
+        if (rooms.standing(room.locator).unreadable) {
+            rooms.stand(room.locator, { refusal: null });
+            readable(runtime, room);
+            emitRooms(runtime);
+        }
+        return null;
+    }
+    if (refreshed.kind === 'advanced') {
+        const landing = {
+            kind: 'refreshed',
+            from: refreshed.from,
+            remodelled: refreshed.remodelled,
+        };
+        if (!(await publish(runtime, local, room, refreshed.record, landing, live))) {
+            const now = (await store.record(room.locator))?.roomVersion;
+            const reached = now !== undefined && socket.reads.reached(room.locator, now, refreshed.record.roomVersion);
+            return reached ? null : 'behind';
+        }
+        await retainModel(runtime, local, room, null);
+        return null;
+    }
+    return refreshed.kind === 'beyond-horizon' ? 'beyond-horizon' : refreshed;
+}
+export function advanced(runtime, room, local, authorized) {
+    return runtime.socket.lanes.inRoom(room.locator, (live) => advance(runtime, room, local, authorized, live));
+}
+export async function withhold(runtime, withheld, room, local, progress) {
+    const { store, socket, journal } = runtime;
+    const { rooms } = socket;
+    if (withheld.kind === 'unconfirmed' || store.fences.has(room.locator))
+        return;
+    if (withheld.kind === 'not-ready') {
+        progress.complete = false;
+        askAgain(runtime, room.locator);
+        return;
+    }
+    rooms.stand(room.locator, { stale: true });
+    if (withheld.kind === 'transport-uncertainty' || withheld.kind === 'retryable-refusal') {
+        const reset = withheld.kind === 'retryable-refusal' ? withheld.reset : undefined;
+        rooms.stand(room.locator, { repairable: { reset } });
+        repairLater(runtime, room.locator, reset === undefined ? { again: true } : { at: Date.parse(reset) });
+    }
+    else
+        rooms.stand(room.locator, { repairable: null });
+    if (withheld.kind === 'scoped-refusal') {
+        await scoped(runtime, withheld, room, local);
+    }
+    else if (withheld.kind === 'transport-uncertainty') {
+        progress.reachable = false;
+    }
+    else if (withheld.kind === 'retryable-refusal') {
+        journal.record(`refusal ${withheld.kind} ${withheld.code}`);
+    }
+    else if (withheld.kind === 'room-not-readable') {
+        roomUnreadable(runtime, room);
+    }
+    else if (withheld.kind === 'revoked-authorization') {
+        await refuse(runtime, 'revoked-authorization');
+    }
+}
+function askAgain(runtime, locator) {
+    const { store, socket } = runtime;
+    socket.rooms.askAgain(locator, () => {
+        const room = socket.rooms.discovered(locator);
+        if (socket.closed() ||
+            socket.stopping() ||
+            (socket.streamed && !socket.isOpen()) ||
+            room === undefined)
+            return;
+        const progress = { complete: true, reachable: true };
+        void store
+            .open()
+            .then((local) => socket.lanes.roomTask(locator, (live) => loadRoom(runtime, room, local, progress, live)))
+            .then(() => rest(runtime, progress), () => undefined);
+    });
+}
+async function prepareRoom(runtime, room, local, progress, prior) {
+    const { socket, journal } = runtime;
+    const { session } = socket;
+    if (socket.closed() || session.now().authorization === undefined) {
+        progress.complete = false;
+        return false;
+    }
+    if (prior !== undefined && prior.replica.selection !== room.replica.selection) {
+        listHeld(runtime, room.locator);
+        emitRooms(runtime);
+        journal.record(`selection changed ${room.locator}`);
+        progress.complete = false;
+        return false;
+    }
+    if (prior !== undefined && !declaredAsHeld(prior, room)) {
+        await retainModel(runtime, local, room, null);
+    }
+    if (prior !== undefined && (prior.name !== room.name || prior.handle !== room.handle)) {
+        await keepNaming(runtime, local, room);
+    }
+    const { paused, authorization } = session.now();
+    if (paused || authorization === undefined)
+        return false;
+    return room.replica.admission === 'admitted';
+}
+export async function synchronize(runtime, listed, local, progress, attempt, live) {
+    const { store, socket } = runtime;
+    const heldNow = await store.rooms(listed.map(({ locator }) => locator));
+    const prepared = await Promise.allSettled(listed.map((room) => prepareRoom(runtime, room, local, progress, heldNow.get(room.locator)?.record)));
+    if (!live())
+        return;
+    const ready = listed.filter((_, index) => {
+        const outcome = prepared[index];
+        return outcome?.status === 'fulfilled' && outcome.value;
+    });
+    const held = await heldRooms(runtime, ready);
+    if (!live())
+        return;
+    if (attempt === 'opened') {
+        socket.hand(held);
+    }
+    const kept = attempt === 'unstreamed'
+        ? new Set()
+        : new Set((await store.rooms(ready.map(({ locator }) => locator))).keys());
+    for (const room of ready) {
+        if (attempt === 'opened' || kept.has(room.locator)) {
+            if (attempt === 'authorized')
+                await name(runtime, room.locator);
+            continue;
+        }
+        void socket.lanes
+            .roomTask(room.locator, (live) => loadRoom(runtime, room, local, progress, live))
+            .then(() => rest(runtime, progress));
+    }
+    const failed = prepared.find((room) => room.status === 'rejected');
+    if (failed !== undefined)
+        throw failed.reason;
+}
+async function caughtUp(runtime, room, local, progress, live) {
+    const { socket } = runtime;
+    const { authorization } = socket.session.now();
+    if (socket.streamed || authorization === undefined)
+        return;
+    if (!live() || !(await behind(runtime, room)))
+        return;
+    const withheld = await advance(runtime, room, local, authorization, live);
+    if (withheld !== null)
+        await withhold(runtime, withheld, room, local, progress);
+}
+export async function loadRoom(runtime, room, local, progress, live, unheld) {
+    const { store, socket } = runtime;
+    const { authorization } = socket.session.now();
+    if (!live() || authorization === undefined)
+        return;
+    const prior = unheld === undefined ? await store.record(room.locator) : undefined;
+    if (prior !== undefined) {
+        if (!(await prepareRoom(runtime, room, local, progress, prior)))
+            return;
+        if (revoked(prior.model)) {
+            await reload(runtime, room, local, progress, live);
+            return;
+        }
+    }
+    const withheld = await advance(runtime, room, local, authorization, live, unheld);
+    if (withheld !== null) {
+        await withhold(runtime, withheld, room, local, progress);
+        return;
+    }
+    await caughtUp(runtime, room, local, progress, live);
+}
+export async function reload(runtime, room, local, progress, live) {
+    const { store, socket } = runtime;
+    try {
+        if (live())
+            socket.rooms.stand(room.locator, { reloadDue: false });
+        const { authorization } = socket.session.now();
+        if (!live() || authorization === undefined)
+            return;
+        const prior = await store.record(room.locator);
+        const from = standingAt(store, room.locator, prior);
+        const bootstrapped = await pullBootstrap(runtime, authorization, room, local, live, prior);
+        if (bootstrapped.kind !== 'staged') {
+            if (live())
+                await withhold(runtime, bootstrapped, room, local, progress);
+            return;
+        }
+        await publish(runtime, local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from }, live);
+        await caughtUp(runtime, room, local, progress, live);
+    }
+    finally {
+        caughtUpTo(runtime, room.locator);
+    }
+}
+function repairLater(runtime, locator, when) {
+    const { socket, recovery } = runtime;
+    if (!socket.isOpen() || socket.rooms.standing(locator).repairing)
+        return;
+    void recovery.attempt(`repair ${locator}`, (signal) => repairPass(runtime, locator, signal), when);
+}
+async function repairPass(runtime, locator, signal) {
+    const { store, socket } = runtime;
+    const { rooms } = socket;
+    const room = rooms.discovered(locator);
+    if (!socket.isOpen() ||
+        !socket.continuing() ||
+        socket.stopping() ||
+        !rooms.standing(locator).stale)
+        return 'done';
+    if (room === undefined || room.replica.admission !== 'admitted')
+        return 'done';
+    const progress = { complete: true, reachable: true };
+    rooms.stand(locator, { repairing: true });
+    try {
+        const local = await store.open();
+        await socket.lanes.roomTask(locator, async (live) => {
+            const { authorization } = socket.session.now();
+            if (!live() || authorization === undefined)
+                return;
+            const withheld = await advance(runtime, room, local, authorization, live);
+            if (withheld !== null && live())
+                await withhold(runtime, withheld, room, local, progress);
+        });
+    }
+    catch {
+        rooms.stand(locator, { stale: true });
+        progress.reachable = false;
+    }
+    finally {
+        rooms.stand(locator, { repairing: false });
+    }
+    if (signal.aborted)
+        return 'done';
+    await rest(runtime, progress);
+    if (!rooms.standing(locator).stale) {
+        if ((await (await store.open()).order(locator)).length > 0)
+            submitLater(runtime, locator);
+        return 'done';
+    }
+    const { repairable } = rooms.standing(locator);
+    if (repairable === null)
+        return 'done';
+    return repairable.reset === undefined ? 'again' : { at: Date.parse(repairable.reset) };
+}
+export async function finishOpening(runtime, progress, live) {
+    const { socket, conversations, recovery } = runtime;
+    try {
+        if (!live()) {
+            progress.complete = false;
+            return;
+        }
+        await submitAll(runtime);
+        for (const locator of socket.rooms.standingWhere(({ stale, repairable }) => stale && repairable !== null)) {
+            repairLater(runtime, locator, {});
+        }
+        await conversations.reconcile();
+        const reading = { complete: true, reachable: true };
+        await conversations.catchUp(reading);
+        if (progress.reachable && reading.reachable)
+            await conversations.resend(reading);
+        if (progress.reachable) {
+            void recovery.attempt('calls', (signal) => resendCalls(runtime, signal));
+        }
+        if (!reading.reachable) {
+            progress.reachable = false;
+            resendLater(runtime);
+        }
+    }
+    catch {
+        progress.complete = false;
+    }
+    finally {
+        if (live()) {
+            socket.session.set({ complete: progress.complete });
+            await rest(runtime, progress, live);
+        }
+    }
+}
+export function sync(runtime, attempt, found) {
+    const { store, socket } = runtime;
+    const { session } = socket;
+    return socket.lanes.task(OPENING_LANE, async (live) => {
+        if (!live()) {
+            socket.readyFromStore();
+            return;
+        }
+        const progress = { complete: true, reachable: true };
+        session.set({
+            underway: attempt === 'opened' ? progress : null,
+            ...(attempt === 'opened' ? { streamed: progress } : {}),
+            complete: false,
+            recorded: false,
+        });
+        moveTo(runtime, transferring(runtime));
+        try {
+            const local = await store.open();
+            if (!live())
+                return;
+            await socket.authorize();
+            if (!live())
+                return;
+            const listed = await discoverRooms(runtime, local, progress, live, found);
+            if (listed !== null)
+                await synchronize(runtime, listed, local, progress, attempt, live);
+        }
+        catch {
+            progress.complete = false;
+            if (attempt === 'opened' && !socket.isHanded())
+                progress.reachable = false;
+        }
+        finally {
+            socket.notifyReady();
+        }
+        if (!live())
+            return;
+        if (attempt !== 'opened') {
+            await finishOpening(runtime, progress, live);
+            return;
+        }
+        if (socket.isHanded() || socket.closed() || progress.reachable)
+            return;
+        session.set({ underway: null });
+        await rest(runtime, progress, live);
+    });
+}
+export function resynchronize(runtime) {
+    const { store, socket } = runtime;
+    return socket.lanes.task(OPENING_LANE, async (live) => {
+        if (!live() || !socket.isAnnounced())
+            return;
+        const progress = { complete: true, reachable: true };
+        moveTo(runtime, transferring(runtime));
+        try {
+            const local = await store.open();
+            if (!live())
+                return;
+            await synchronize(runtime, socket.rooms.discoveredRooms(), local, progress, 'unstreamed', live);
+        }
+        catch {
+            progress.complete = false;
+        }
+        if (live())
+            await finishOpening(runtime, progress, live);
+    });
+}
+export function countAuthorityChange({ store, socket, lastAnswers }) {
+    const authorityChanges = socket.session.now().authorityChanges + 1;
+    socket.session.set({ authorityChanges });
+    store.tell(AUTHORITY_TOPIC, authorityChanges);
+    lastAnswers.again();
+}
+export function changeAuthority(runtime, change) {
+    const { store, socket, journal } = runtime;
+    const { session } = socket;
+    return socket.lanes.task(OPENING_LANE, async (live) => {
+        if (!live() || !socket.isAnnounced())
+            return;
+        countAuthorityChange(runtime);
+        const progress = { complete: true, reachable: true };
+        moveTo(runtime, transferring(runtime));
+        try {
+            const local = await store.open();
+            if (!live())
+                return;
+            const invalid = malformed(change.rooms);
+            if (invalid !== null) {
+                journal.record(invalid);
+                await refuse(runtime, 'missing-required-guarantee');
+                return;
+            }
+            if (change.member !== undefined)
+                await signIn(runtime, local, change.member);
+            const discoveries = session.now().discoveries + 1;
+            session.set({ discoveries });
+            const listed = await applyDiscovery(runtime, change.rooms, discoveries, change.left);
+            await synchronize(runtime, listed, local, progress, 'authorized', live);
+        }
+        catch {
+            progress.complete = false;
+        }
+        if (!live())
+            return;
+        if (!progress.complete)
+            session.set({ complete: false });
+        await rest(runtime, progress, live);
+    });
+}
+async function installCarried(runtime, room, local, change, live, progress) {
+    const { store, socket } = runtime;
+    const { authorization, underway } = socket.session.now();
+    if (authorization === undefined)
+        return;
+    if (underway === null)
+        moveTo(runtime, transferring(runtime));
+    const prior = await store.record(room.locator);
+    const from = standingAt(store, room.locator, prior);
+    const page = await change.read();
+    const carried = {
+        bootstrap: () => Promise.resolve({
+            kind: 'bootstrap',
+            roomVersion: page.roomVersion,
+            ...(page.models === undefined ? {} : { models: page.models }),
+            documents: page.documents,
+            facts: page.facts,
+            revisions: page.revisions,
+            ...(page.fileIds === undefined ? {} : { fileIds: page.fileIds }),
+            ...(page.created === undefined ? {} : { created: page.created }),
+            changes: page.changes,
+            binaryFiles: page.binaryFiles,
+            ...(page.folders === undefined ? {} : { folders: page.folders }),
+        }),
+        reached: socket.reads.reached,
+    };
+    const bootstrapped = await pullBootstrap(runtime, authorization, room, local, live, prior, carried);
+    if (bootstrapped.kind !== 'staged') {
+        if (live())
+            await withhold(runtime, bootstrapped, room, local, progress);
+        return;
+    }
+    await publish(runtime, local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from }, live);
+}
+export function applyRoom(runtime, change) {
+    const { store, socket } = runtime;
+    const { rooms, session } = socket;
+    const { locator } = change;
+    if (socket.stopping())
+        return Promise.resolve();
+    return socket.lanes
+        .inRoom(locator, async (live) => {
+        await socket.answered(locator);
+        const progress = session.now().underway ?? { complete: true, reachable: true };
+        try {
+            const local = await store.open();
+            for (;;) {
+                if (!live())
+                    return null;
+                const room = rooms.discovered(locator);
+                if (room === undefined || room.replica.admission !== 'admitted')
+                    return null;
+                const held = await store.record(locator);
+                if (held === undefined) {
+                    if (change.from !== null)
+                        return null;
+                    await installCarried(runtime, room, local, change, live, progress);
+                    return progress;
+                }
+                if (held.replica.selection !== room.replica.selection)
+                    return null;
+                const at = held.roomVersion;
+                if (socket.reads.reached(locator, at, change.roomVersion))
+                    return progress;
+                if (change.from === null || !socket.reads.reached(locator, at, change.from)) {
+                    await name(runtime, locator);
+                    return progress;
+                }
+                if (session.now().underway === null)
+                    moveTo(runtime, transferring(runtime));
+                const writing = () => live() && !store.space.full();
+                const refreshed = await store.ahead((hold) => pullRefresh(runtime, session.now().authorization ?? {}, held, writing, hold, () => change.read()));
+                if (refreshed.kind !== 'advanced')
+                    return progress;
+                const landing = {
+                    kind: 'refreshed',
+                    from: refreshed.from,
+                    remodelled: refreshed.remodelled,
+                };
+                if (await publish(runtime, local, room, refreshed.record, landing, writing)) {
+                    rooms.stand(locator, { stale: false });
+                    if (!declaredAsHeld(held, room))
+                        await retainModel(runtime, local, room, null);
+                    return progress;
+                }
+            }
+        }
+        catch {
+            if (!rooms.standing(locator).stale)
+                void name(runtime, locator);
+            rooms.stand(locator, { stale: true });
+            return progress;
+        }
+    })
+        .then((progress) => rest(runtime, progress), () => undefined);
+}