@agentshouse/mdruntime 0.1.0-cb2e390ee7b89 → 0.1.0-cb4f25b82f4b6

package/dist/lifecycle.js

@@ -0,0 +1,277 @@
+import { catchUpConversations, receiveConversationEvent, reconcileConversations, } from './conversation.js';
+import { declared } from './declaration.js';
+import { uncaught } from './failure.js';
+import { catching, replaced } from './install.js';
+import { connectionLost } from './locks.js';
+import { fenceLive } from './lost.js';
+import { cachedModels, revoked, settleModels } from './models.js';
+import { refuse } from './refusal.js';
+import { moveTo, recoverReads, rest, SERVICE_MODE_TOPIC, show, submissionDue, transferring, } from './shown.js';
+import { applyRoom, changeAuthority, countAuthorityChange, finishOpening, loadRoom, OPENING_LANE, reload, resynchronize, sync, } from './sync.js';
+const CONVERSATION_LANE = 'conversations';
+const RELOADING = 'reloading';
+function closing(runtime, opened) {
+    const { store, socket } = runtime;
+    return socket.lanes.task(OPENING_LANE, async (live) => {
+        if (!live())
+            return;
+        const local = await store.open();
+        if (!opened && !socket.isOpen())
+            await cachedModels(runtime, local);
+        await rest(runtime, null, live);
+    });
+}
+function closedSocket(runtime, lapsed, lost, opened) {
+    const { socket, presence, conversations } = runtime;
+    const { session } = socket;
+    socket.notifyReady();
+    presence.stopAsking();
+    connectionLost(runtime);
+    if (lost)
+        conversations.lost();
+    if (lapsed) {
+        void refuse(runtime, 'revoked-authorization');
+        return;
+    }
+    session.set({ complete: false });
+    const { streamed, moving } = session.now();
+    if (streamed !== null)
+        streamed.complete = false;
+    moveTo(runtime, {
+        ...moving,
+        state: moving.state === 'synced' ? 'syncing' : moving.state,
+        providerUnreachable: moving.providerUnreachable || (!opened && lost),
+    });
+    void closing(runtime, opened);
+}
+function owedReloads(runtime, expired, held) {
+    const { store, presence } = runtime;
+    const reloading = presence
+        .rooms()
+        .filter((room) => !expired.includes(room.locator) && revoked(held.get(room.locator)?.record.model))
+        .map((room) => room.locator);
+    for (const locator of reloading)
+        catching(store, locator);
+    recoverReads(runtime);
+    return reloading;
+}
+async function reloadNow(runtime, replacing, progress, held, installing) {
+    const { store, socket, presence } = runtime;
+    const { lanes } = socket;
+    const discovered = presence.rooms();
+    const reloaded = discovered.filter((room) => held.has(room.locator) && !installing.has(room.locator) && replacing(room));
+    const acquired = discovered.filter((room) => (!held.has(room.locator) || installing.has(room.locator)) &&
+        room.replica.admission === 'admitted' &&
+        replacing(room));
+    for (const room of reloaded)
+        presence.reload(room.locator, true);
+    try {
+        const local = await store.open();
+        const kept = acquired.length === 0 ? new Set() : (await local.held()).staged;
+        for (const room of reloaded) {
+            void lanes
+                .roomTask(room.locator, (live) => reload(runtime, room, local, progress, live))
+                .then(() => rest(runtime, progress));
+        }
+        for (const room of acquired) {
+            const unheld = installing.has(room.locator) ? undefined : { staged: kept.has(room.locator) };
+            void lanes
+                .roomTask(room.locator, (live) => loadRoom(runtime, room, local, progress, live, unheld))
+                .then(() => rest(runtime, progress));
+        }
+        runtime.retries.succeeded('download', RELOADING);
+    }
+    catch (error) {
+        runtime.retries.failed('download', RELOADING, error);
+        for (const room of reloaded)
+            presence.reload(room.locator, false);
+        progress.reachable = false;
+    }
+}
+function caughtUpRooms(runtime, expired) {
+    const { store, socket, presence } = runtime;
+    const { session } = socket;
+    const progress = session.now().underway;
+    session.set({ underway: null });
+    socket.named();
+    const cycle = progress ?? { complete: true, reachable: true };
+    replaced(store, expired);
+    const installing = store.installs.underway();
+    const held = progress === null ? store.rooms(expired) : store.rooms();
+    const reloading = progress === null
+        ? Promise.resolve([])
+        : held.then((stored) => owedReloads(runtime, expired, stored));
+    const replacing = Promise.all([held, reloading]).then(([stored, owed]) => reloadNow(runtime, (room) => expired.includes(room.locator) || owed.includes(room.locator), cycle, stored, installing));
+    return socket.lanes.task(OPENING_LANE, async (live) => {
+        if (!live())
+            return;
+        if (progress === null) {
+            await replacing;
+            await rest(runtime, cycle, live);
+            return;
+        }
+        try {
+            const local = await store.open();
+            await replacing;
+            if (progress.reachable) {
+                const stored = await held;
+                const owed = await reloading;
+                await settleModels(runtime, new Map(presence
+                    .rooms()
+                    .filter((room) => stored.has(room.locator) &&
+                    !expired.includes(room.locator) &&
+                    !owed.includes(room.locator))
+                    .map((room) => [room.locator, declared(room)])), 'current', local);
+            }
+            runtime.retries.succeeded('download', OPENING_LANE);
+        }
+        catch (error) {
+            runtime.retries.failed('download', OPENING_LANE, error);
+            progress.complete = false;
+            progress.reachable = false;
+        }
+        if (live())
+            await finishOpening(runtime, progress, live);
+    });
+}
+function signalled(runtime, mode) {
+    const { store, socket } = runtime;
+    const { session } = socket;
+    const { closed, serviceMode, haltedRefusal, openSignals } = session.now();
+    if (closed)
+        return;
+    if (mode === 'open')
+        session.set({ openSignals: openSignals + 1 });
+    const releasing = mode === 'open' && (haltedRefusal || serviceMode === 'write-halted');
+    if (mode === 'open')
+        session.set({ haltedRefusal: false });
+    if (mode !== serviceMode) {
+        session.set({ serviceMode: mode });
+        store.readiness.queue();
+        store.tell(SERVICE_MODE_TOPIC, mode);
+    }
+    if (releasing)
+        void submissionDue(runtime);
+}
+async function runCurrency(runtime, live) {
+    const { socket, conversations } = runtime;
+    const { session } = socket;
+    if (session.now().currencyQueued === socket.generation())
+        session.set({ currencyQueued: null });
+    if (!live())
+        return;
+    await reconcileConversations(conversations);
+    if (conversations.current()) {
+        await rest(runtime, null, live);
+        return;
+    }
+    const progress = {
+        complete: false,
+        reachable: !session.now().moving.providerUnreachable,
+    };
+    moveTo(runtime, transferring(runtime));
+    try {
+        await catchUpConversations(conversations, progress);
+        runtime.retries.succeeded('conversations', CONVERSATION_LANE);
+    }
+    catch (error) {
+        runtime.retries.failed('conversations', CONVERSATION_LANE, error);
+        progress.reachable = false;
+    }
+    await rest(runtime, progress, live);
+}
+export function scheduleCurrency(runtime) {
+    const { socket } = runtime;
+    const { session } = socket;
+    if (session.now().currencyQueued === socket.generation() || socket.closed() || socket.stopping())
+        return;
+    session.set({ currencyQueued: socket.generation() });
+    void socket.lanes.task(CONVERSATION_LANE, (live) => runCurrency(runtime, live));
+}
+export function spaceFreed(runtime) {
+    const { store, socket } = runtime;
+    store.prepareAgain();
+    store.readiness.queue();
+    const { closed, authorization } = socket.session.now();
+    if (closed || authorization === undefined)
+        return;
+    if (!socket.streamed)
+        void sync(runtime, 'unstreamed', null);
+    else
+        void resynchronize(runtime);
+}
+export function close({ store, socket, presence, conversations, recovery, liveQueries, figures, }) {
+    if (socket.closed())
+        return;
+    socket.close();
+    presence.close();
+    conversations.close();
+    void recovery.retire();
+    liveQueries.close();
+    figures.close();
+    store.close();
+}
+export async function stop(runtime) {
+    const { store, socket, presence, recovery } = runtime;
+    socket.session.set({ stopping: true });
+    presence.stopAsking();
+    socket.stopReads();
+    await recovery.retire();
+    await socket.lanes.finished();
+    await store.written();
+    close(runtime);
+}
+export function start(runtime, signal) {
+    const { store, socket, presence, conversations, lastAnswers, recovery } = runtime;
+    const closeRuntime = () => close(runtime);
+    socket.observeServiceMode((mode) => signalled(runtime, mode));
+    socket.observeConversations((event) => {
+        if (event.kind === 'list' || event.kind === 'listed' || event.kind === 'unlisted')
+            store.readiness.queue();
+        receiveConversationEvent(conversations, event);
+        if (event.kind !== 'gap' || conversations.current())
+            return;
+        show(runtime);
+        scheduleCurrency(runtime);
+    });
+    signal?.addEventListener('abort', closeRuntime, { once: true });
+    if (signal?.aborted)
+        closeRuntime();
+    socket.observe((event) => {
+        if (event.kind === 'opened') {
+            presence.connectionLive();
+            conversations.reopened();
+            lastAnswers.reopened();
+            recovery.resume();
+        }
+        else if (event.kind === 'discovered') {
+            if (event.missed)
+                countAuthorityChange(runtime);
+            void sync(runtime, 'opened', event.discovery);
+        }
+        else if (event.kind === 'closed') {
+            closedSocket(runtime, event.revoked, event.lost, event.opened);
+        }
+        else if (event.kind === 'caught-up')
+            void caughtUpRooms(runtime, event.expired);
+        else if (event.kind === 'authority-changed') {
+            if (socket.isAnnounced() && socket.isOpen())
+                fenceLive(runtime, event.left);
+            void changeAuthority(runtime, event);
+        }
+        else
+            void applyRoom(runtime, event);
+    });
+    void store
+        .open()
+        .then(async (local) => {
+        if ((await local.facts()).capabilities.length > 0)
+            socket.readyFromStore();
+    })
+        .catch((error) => {
+        socket.readyFromStore();
+        uncaught(error);
+    });
+    if (!socket.streamed)
+        void sync(runtime, 'unstreamed', null);
+}

package/dist/listing.d.ts

@@ -0,0 +1,48 @@
+import type { HeldRooms } from '@agentshouse/mdmodel';
+import type { DiscoveredRoom, HeldRoom, OperationScopes, ProviderRefusal, ReplicaAdmission, RoomDeclaration } from './adapter.js';
+import type { Composition } from './collection.js';
+import { type ModelState, type TypesResult } from './model.js';
+import { type PortReach } from './reach.js';
+import type { ReplicaRecord } from './replica.js';
+import type { Runtime } from './runtime.js';
+import type { Stored } from './store.js';
+export type AppTypedSelection = {
+    roots: readonly string[];
+    model: TypesResult;
+};
+export type AppRoom = {
+    name: string;
+    locator: string;
+    handle: string;
+    operations: OperationScopes;
+    replica: ReplicaAdmission;
+    model: TypesResult;
+    typedSelection: AppTypedSelection | null;
+    providerOwnedPaths: readonly string[];
+    authoredPaths: readonly string[];
+    roomVersion: string | null;
+    documents: number;
+    synchronizationAvailable: boolean;
+    refusal: ProviderRefusal | null;
+    locked: boolean;
+};
+type ListedRoom = Omit<AppRoom, 'documents' | 'locked'>;
+type ListedEntry = ListedRoom & {
+    readonly documents: number;
+};
+export type Listing = ReadonlyMap<string, ListedEntry>;
+export declare function modelIn({ socket, presence }: Runtime, locator: string, stored: Stored | undefined): ModelState;
+export declare function compositionFor(runtime: Runtime, record: ReplicaRecord): Composition;
+export declare function declarationOf({ presence }: Runtime, locator: string, stored: Stored | undefined): {
+    readonly room: RoomDeclaration;
+    readonly available: boolean;
+} | undefined;
+export declare function listedLocators({ presence }: Runtime, held: ReadonlyMap<string, unknown>): string[];
+export declare function patchedListing(runtime: Runtime, changed: ReadonlySet<string>): Promise<Listing | null>;
+export declare function listingNow(runtime: Runtime): Promise<Listing>;
+export declare function shownRooms({ presence }: Runtime, listing: Listing): readonly AppRoom[];
+export declare function roomFacts(runtime: Runtime, reach?: PortReach | null): Promise<HeldRooms>;
+export declare function heldRooms({ store }: Runtime, listed: readonly DiscoveredRoom[]): Promise<HeldRoom[]>;
+export declare function name(runtime: Runtime, locator: string): Promise<void>;
+export {};
+//# sourceMappingURL=listing.d.ts.map

package/dist/listing.d.ts.map

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

package/dist/listing.js

@@ -0,0 +1,139 @@
+import { declared } from './declaration.js';
+import { modelTypes, NO_MODEL } from './model.js';
+import { governs, holds } from './reach.js';
+export function modelIn({ socket, presence }, locator, stored) {
+    if (socket.session.now().refusal?.code === 'revoked-authorization')
+        return { status: 'unavailable', reason: 'revoked' };
+    return stored?.record.model ?? presence.unheldModel(locator) ?? NO_MODEL;
+}
+export function compositionFor(runtime, record) {
+    return runtime.store.composed({
+        ...record,
+        model: modelIn(runtime, record.locator, { record, indexed: true, documents: 0 }),
+    });
+}
+export function declarationOf({ presence }, locator, stored) {
+    const listed = presence.room(locator);
+    const room = stored?.record.declaration ?? (listed === undefined ? undefined : declared(listed));
+    if (room === undefined)
+        return undefined;
+    return {
+        room,
+        available: presence.available(locator, stored?.record.declaration.replica.selection),
+    };
+}
+export function listedLocators({ presence }, held) {
+    const listed = presence.rooms().map(({ locator }) => locator);
+    return [...new Set([...listed, ...held.keys()])];
+}
+function selectionModel({ socket, builtIn }) {
+    return socket.session.now().refusal?.code === 'revoked-authorization'
+        ? { status: 'unavailable', reason: 'revoked' }
+        : builtIn;
+}
+function listedRoom(runtime, locator, stored) {
+    const declaration = declarationOf(runtime, locator, stored);
+    if (declaration === undefined)
+        return undefined;
+    const { room, available } = declaration;
+    const selection = room.typedSelection;
+    return {
+        name: room.name,
+        locator,
+        handle: room.handle,
+        operations: room.operations,
+        replica: room.replica,
+        model: modelTypes(modelIn(runtime, locator, stored)),
+        typedSelection: selection === null
+            ? null
+            : { roots: selection.roots, model: modelTypes(selectionModel(runtime)) },
+        providerOwnedPaths: room.providerOwnedPaths,
+        authoredPaths: room.authoredPaths,
+        roomVersion: stored?.record.roomVersion ?? null,
+        synchronizationAvailable: available,
+        refusal: runtime.presence.refusal(locator),
+        documents: stored?.documents ?? 0,
+    };
+}
+function listingOf(runtime, held) {
+    const listing = new Map();
+    for (const locator of listedLocators(runtime, held)) {
+        const room = listedRoom(runtime, locator, held.get(locator));
+        if (room !== undefined)
+            listing.set(locator, room);
+    }
+    return listing;
+}
+export async function patchedListing(runtime, changed) {
+    const { store } = runtime;
+    const { roomsShown } = store.device.now();
+    if (roomsShown === null)
+        return null;
+    const held = await store.rooms([...changed]);
+    const listing = new Map(roomsShown);
+    for (const locator of changed) {
+        const room = listedRoom(runtime, locator, held.get(locator));
+        if (room === undefined || !listing.has(locator))
+            return null;
+        listing.set(locator, room);
+    }
+    return listing;
+}
+export async function listingNow(runtime) {
+    return listingOf(runtime, await runtime.store.rooms());
+}
+export function shownRooms({ presence }, listing) {
+    const locked = new Set(presence.lockedAmong(new Map([...listing].map(([locator, room]) => [locator, room.replica.offline]))));
+    return structuredClone([...listing.values()].map(({ documents, ...room }) => locked.has(room.locator)
+        ? {
+            ...room,
+            model: modelTypes(NO_MODEL),
+            typedSelection: null,
+            documents: 0,
+            locked: true,
+        }
+        : { ...room, documents, locked: false }));
+}
+export async function roomFacts(runtime, reach = null) {
+    const { store, socket, builtIn } = runtime;
+    const held = await store.rooms();
+    const rooms = [...listingOf(runtime, held).values()]
+        .filter((room) => holds(reach, room.locator))
+        .map((room) => {
+        const governed = governs(reach, room);
+        const attached = [
+            ...(governed.collection ? [modelIn(runtime, room.locator, held.get(room.locator))] : []),
+            ...(governed.selection ? [builtIn] : []),
+        ];
+        return {
+            locator: room.locator,
+            available: attached.every((model) => model.status !== 'unavailable'),
+            types: attached.flatMap((model) => model.status === 'unavailable' ? [] : Object.values(model.types)),
+        };
+    });
+    return { listed: socket.session.now().roomsListed, rooms };
+}
+export async function heldRooms({ store }, listed) {
+    const stored = await store.rooms(listed.map((room) => room.locator));
+    return listed.flatMap((room) => {
+        const record = stored.get(room.locator)?.record;
+        if (record === undefined) {
+            return room.replica.admission === 'admitted'
+                ? [{ locator: room.locator, roomVersion: null }]
+                : [];
+        }
+        if (record.declaration.replica.selection !== room.replica.selection)
+            return [];
+        return [{ locator: room.locator, roomVersion: record.roomVersion }];
+    });
+}
+export async function name(runtime, locator) {
+    const { socket, presence } = runtime;
+    const room = presence.room(locator);
+    if (!socket.streamed || room === undefined || !socket.isOpen() || !socket.isHanded())
+        return;
+    const [held] = await heldRooms(runtime, [room]);
+    if (held === undefined || !socket.isOpen() || !socket.isHanded())
+        return;
+    socket.name(held);
+}

package/dist/live.d.ts

@@ -0,0 +1,23 @@
+import type { ChangeSet } from './change-set.js';
+import { type KeyedResult, type QueryMessage } from './observation.js';
+import type { PendingResult, Plan, QueryCoverage } from './query.js';
+import type { Fail } from './reach.js';
+import type { QueryRoom } from './tables.js';
+export type Cover = {
+    coverage: QueryCoverage;
+    rooms: readonly QueryRoom[];
+} | PendingResult;
+export type Ran = KeyedResult & {
+    readonly current: () => boolean;
+};
+export type Run = (plan: Plan, cover: () => Promise<Cover>) => Promise<Ran>;
+type Listener = (message: QueryMessage) => void;
+export type LiveQueries<H> = {
+    touched(set: ChangeSet): void;
+    recover(): void;
+    watch(plan: Plan, identity: string, cover: (held: H) => Cover, deliver: Listener, failed: Fail): () => void;
+    close(): void;
+};
+export declare function createLiveQueries<H>(run: Run, holding: () => Promise<H>): LiveQueries<H>;
+export {};
+//# sourceMappingURL=live.d.ts.map

package/dist/live.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live.d.ts","sourceRoot":"","sources":["../src/live.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,YAAY,EAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACrE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAGvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,MAAM,KAAK,GAAG;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAA;CAAE,GAAG,aAAa,CAAC;AAE7F,MAAM,MAAM,GAAG,GAAG,WAAW,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAA;CAAE,CAAC;AAEpE,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;AAE5E,KAAK,QAAQ,GAAG,CAAC,OAAO,EAAE,YAAY,KAAK,IAAI,CAAC;AAchD,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAC3B,OAAO,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IAC9B,OAAO,IAAI,IAAI,CAAC;IAChB,KAAK,CACH,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,KAAK,EACzB,OAAO,EAAE,QAAQ,EACjB,MAAM,EAAE,IAAI,GACX,MAAM,IAAI,CAAC;IACd,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AAmCF,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CA2HxF"}

package/dist/live.js

@@ -0,0 +1,165 @@
+import { changeOf, digestOf, } from './observation.js';
+import { uncaught } from './failure.js';
+import { roomOfKey } from './rows.js';
+function narrowed(plan) {
+    return (plan.paths !== null &&
+        plan.hop === null &&
+        plan.backlinks === null &&
+        !(plan.shape.kind === 'documents' && plan.shape.backlinks));
+}
+function reads(plan, locator) {
+    if (plan.locked.includes(locator))
+        return false;
+    if (plan.rooms !== null && !plan.rooms.includes(locator))
+        return false;
+    if (plan.reach === null)
+        return true;
+    return (plan.reach.rooms.includes(locator) ||
+        plan.reach.documents.some((document) => roomOfKey(document) === locator));
+}
+function affected(plan, set) {
+    if (set.rooms.some((locator) => reads(plan, locator)))
+        return true;
+    const paths = narrowed(plan) ? new Set(plan.paths) : null;
+    return set.documents.some(({ locator, path }) => reads(plan, locator) && (paths === null || path === null || paths.has(path)));
+}
+function shown(entry, held) {
+    const cover = entry.cover(held);
+    return JSON.stringify('pending' in cover ? cover : cover.coverage);
+}
+export function createLiveQueries(run, holding) {
+    const entries = new Map();
+    let closed = false;
+    let recovering = false;
+    let recoverAgain = false;
+    function deliver(entry, next) {
+        const previous = entry.digest;
+        entry.digest = digestOf(next);
+        entry.covered = JSON.stringify('pending' in next.result ? next.result : next.result.coverage);
+        const change = previous === undefined ? null : changeOf(previous, next);
+        if (change !== null) {
+            for (const listener of entry.ready)
+                listener(change);
+        }
+        for (const listener of entry.fresh.keys()) {
+            entry.ready.add(listener);
+            listener(next);
+        }
+        entry.fresh.clear();
+    }
+    async function delivered(entry) {
+        const { current, ...next } = await run(entry.plan, async () => entry.cover(await holding()));
+        if (closed || entry.listeners.size === 0)
+            return null;
+        deliver(entry, next);
+        return current;
+    }
+    function schedule(entry) {
+        if (closed || entry.listeners.size === 0)
+            return;
+        if (entry.running) {
+            entry.dirty = true;
+            return;
+        }
+        entry.running = true;
+        void (async () => {
+            try {
+                for (;;) {
+                    entry.dirty = false;
+                    const current = await delivered(entry);
+                    if (current === null)
+                        return;
+                    const held = await holding();
+                    if (entry.fresh.size > 0 || (entry.dirty && !current()))
+                        continue;
+                    if (shown(entry, held) === entry.covered)
+                        break;
+                }
+            }
+            catch (error) {
+                const unanswered = [...entry.fresh.values()];
+                entry.fresh.clear();
+                for (const failed of unanswered)
+                    failed(error);
+            }
+            finally {
+                entry.running = false;
+            }
+        })();
+    }
+    function recovered() {
+        if (recovering) {
+            recoverAgain = true;
+            return;
+        }
+        recovering = true;
+        void (async () => {
+            try {
+                do {
+                    recoverAgain = false;
+                    for (const entry of entries.values()) {
+                        if (entry.running)
+                            entry.dirty = true;
+                    }
+                    const waiting = [...entries.values()].filter((entry) => !entry.running);
+                    if (waiting.length === 0 || closed)
+                        continue;
+                    const held = await holding();
+                    for (const entry of waiting) {
+                        if (entry.running)
+                            continue;
+                        if (entry.digest === undefined || shown(entry, held) !== entry.covered)
+                            schedule(entry);
+                    }
+                } while (recoverAgain && !closed);
+            }
+            catch (error) {
+                uncaught(error);
+            }
+            finally {
+                recovering = false;
+            }
+        })();
+    }
+    return {
+        touched(set) {
+            for (const entry of entries.values()) {
+                if (affected(entry.plan, set))
+                    schedule(entry);
+            }
+        },
+        recover: recovered,
+        watch(plan, identity, cover, listener, failed) {
+            let entry = entries.get(identity);
+            if (entry === undefined) {
+                entry = {
+                    plan,
+                    cover,
+                    listeners: new Set(),
+                    fresh: new Map(),
+                    ready: new Set(),
+                    digest: undefined,
+                    covered: '',
+                    dirty: false,
+                    running: false,
+                };
+                entries.set(identity, entry);
+            }
+            const held = entry;
+            held.listeners.add(listener);
+            held.fresh.set(listener, failed);
+            schedule(held);
+            return () => {
+                held.listeners.delete(listener);
+                held.fresh.delete(listener);
+                held.ready.delete(listener);
+                if (held.listeners.size === 0 && entries.get(identity) === held)
+                    entries.delete(identity);
+            };
+        },
+        close() {
+            closed = true;
+            entries.clear();
+        },
+    };
+}

package/dist/locks.d.ts

@@ -0,0 +1,7 @@
+import type { Runtime } from './runtime.js';
+export declare function locked({ store, presence }: Runtime, locator: string): Promise<boolean>;
+export declare function lockedRooms({ store, presence }: Runtime): Promise<readonly string[]>;
+export declare function relocked(runtime: Runtime, before: readonly string[]): Promise<void>;
+export declare function connectionLost(runtime: Runtime): void;
+export declare function watchLocks({ store }: Runtime, notify: () => void): () => void;
+//# sourceMappingURL=locks.d.ts.map

package/dist/locks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locks.d.ts","sourceRoot":"","sources":["../src/locks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAG5C,wBAAsB,MAAM,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAE5F;AAED,wBAAsB,WAAW,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAK1F;AAED,wBAAsB,QAAQ,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,MAAM,EAAE,iBAKzE;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,QAU9C;AAED,wBAAgB,UAAU,CAAC,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAE7E"}