@agentshouse/mdruntime 0.1.0-c49444f2a8fc6 → 0.1.0-c4c5934c45f21

package/dist/lifecycle.js

@@ -0,0 +1,272 @@
+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';
+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));
+        }
+    }
+    catch {
+        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);
+            }
+        }
+        catch {
+            progress.complete = false;
+            progress.reachable = false;
+        }
+        if (live())
+            await finishOpening(runtime, progress, live);
+    });
+}
+function signalled(runtime, mode) {
+    const { store, socket, journal } = 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();
+        journal.record(`service mode ${mode}`);
+        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()) {
+        show(runtime);
+        return;
+    }
+    const progress = {
+        complete: false,
+        reachable: !session.now().moving.providerUnreachable,
+    };
+    moveTo(runtime, transferring(runtime));
+    try {
+        await catchUpConversations(conversations, progress);
+    }
+    catch {
+        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, journal } = runtime;
+    store.prepareAgain();
+    journal.record('space freed');
+    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.map

@@ -1 +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;AAEvC,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,CA4HxF"}
+{"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

@@ -1,4 +1,5 @@
 import { changeOf, digestOf, } from './observation.js';
+import { uncaught } from './failure.js';
 import { roomOfKey } from './rows.js';
 function narrowed(plan) {
     return (plan.paths !== null &&
@@ -76,7 +77,6 @@ export function createLiveQueries(run, holding) {
                 }
             }
             catch (error) {
-                entry.dirty = false;
                 const unanswered = [...entry.fresh.values()];
                 entry.fresh.clear();
                 for (const failed of unanswered)
@@ -113,8 +113,8 @@ export function createLiveQueries(run, holding) {
                     }
                 } while (recoverAgain && !closed);
             }
-            catch {
-                recoverAgain = false;
+            catch (error) {
+                uncaught(error);
             }
             finally {
                 recovering = false;

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,iBAMzE;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"}

package/dist/locks.js

@@ -0,0 +1,33 @@
+import { uncaught } from './failure.js';
+import { emitRooms, LOCKS_TOPIC } from './shown.js';
+export async function locked({ store, presence }, locator) {
+    return presence.locked(locator, async () => (await store.open()).offline(locator));
+}
+export async function lockedRooms({ store, presence }) {
+    const held = (await store.covering()).rooms;
+    return presence.lockedAmong(new Map([...held].map(([locator, { offline }]) => [locator, offline])));
+}
+export async function relocked(runtime, before) {
+    const after = await lockedRooms(runtime);
+    if (JSON.stringify(after) === JSON.stringify(before))
+        return;
+    runtime.journal.record(`locked ${after.length}`);
+    emitRooms(runtime);
+    runtime.store.tell(LOCKS_TOPIC, undefined);
+}
+export function connectionLost(runtime) {
+    const { socket, presence } = runtime;
+    if (socket.closed())
+        return;
+    presence.connectionLost(() => {
+        if (socket.isOpen() || socket.closed())
+            return;
+        void lockedRooms(runtime).then((before) => {
+            presence.lapse();
+            return relocked(runtime, before);
+        }, uncaught);
+    });
+}
+export function watchLocks({ store }, notify) {
+    return store.watch(LOCKS_TOPIC, notify).stop;
+}

package/dist/log.d.ts

@@ -2,4 +2,5 @@ export declare function createLog(): {
     record(event: string): void;
     export(): string;
 };
+export type Log = ReturnType<typeof createLog>;
 //# sourceMappingURL=log.d.ts.map

package/dist/log.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../src/log.ts"],"names":[],"mappings":"AAEA,wBAAgB,SAAS;IAGrB,MAAM,QAAQ,MAAM;IAIpB,MAAM;EAIT"}
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../src/log.ts"],"names":[],"mappings":"AAEA,wBAAgB,SAAS;IAGrB,MAAM,QAAQ,MAAM;IAIpB,MAAM;EAIT;AAED,MAAM,MAAM,GAAG,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC"}

package/dist/lost.d.ts

@@ -0,0 +1,5 @@
+import type { Runtime } from './runtime.js';
+export declare function eraseFenced({ store }: Runtime, locators: readonly string[]): Promise<void>;
+export declare function fenceLive(runtime: Runtime, locators: readonly string[]): void;
+export declare function loseRooms(runtime: Runtime, locators: readonly string[]): Promise<void>;
+//# sourceMappingURL=lost.d.ts.map

package/dist/lost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lost.d.ts","sourceRoot":"","sources":["../src/lost.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAK5C,wBAAsB,WAAW,CAAC,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,iBAIhF;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,QAOtE;AAED,wBAAsB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,iBA+B5E"}

package/dist/lost.js

@@ -0,0 +1,50 @@
+import { changeSet, mergeChangeSets } from './change-set.js';
+import { ERASE_BATCH } from './install.js';
+import { unpair } from './queue.js';
+import { recoverReads } from './shown.js';
+import { yielded } from './turn.js';
+export async function eraseFenced({ store }, locators) {
+    for (const locator of locators) {
+        while (await store.durably((local) => local.erase(locator, ERASE_BATCH)))
+            await yielded();
+    }
+}
+export function fenceLive(runtime, locators) {
+    const { store, socket, presence, journal } = runtime;
+    for (const locator of new Set(locators)) {
+        if (!presence.lose(locator, socket.session.now().discoveries))
+            continue;
+        store.forget(locator);
+        journal.record(`room lost ${locator}`);
+    }
+}
+export async function loseRooms(runtime, locators) {
+    const { store, presence } = runtime;
+    fenceLive(runtime, locators);
+    const fresh = [...new Set(locators)].filter((locator) => presence.writing(locator));
+    if (fresh.length === 0)
+        return;
+    let held = [];
+    try {
+        await store.durably(async (local) => {
+            held = await local.roomDrafts();
+            await local.fence(fresh);
+        });
+    }
+    catch (error) {
+        for (const locator of fresh)
+            presence.unwritten(locator);
+        throw error;
+    }
+    finally {
+        store.changed(mergeChangeSets(fresh.map((locator) => changeSet(locator, {
+            documents: null,
+            room: true,
+            queue: true,
+            drafts: held.filter((draft) => draft.locator === locator).map(({ path }) => path),
+        }))));
+        recoverReads(runtime);
+    }
+    await unpair(runtime);
+    await eraseFenced(runtime, fresh);
+}

package/dist/media.d.ts

@@ -3,6 +3,6 @@ import { type ShownAnswer } from './outcome.js';
 export declare const ROOM_MEDIA = "room-media";
 type Show = (room: string, path: string, revision?: string) => Promise<ShownAnswer>;
 export declare function shownBy(show: Show, client: MdRuntimeClient): MdRuntimeClient;
-export declare function defineRoomMedia(client: Promise<MdRuntimeClient> | MdRuntimeClient, registry?: CustomElementRegistry): void;
+export declare function defineRoomMedia(client: Promise<MdRuntimeClient> | MdRuntimeClient): void;
 export {};
 //# sourceMappingURL=media.d.ts.map

package/dist/media.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../src/media.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3D,eAAO,MAAM,UAAU,eAAe,CAAC;AAwBvC,KAAK,IAAI,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;AAIpF,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,eAAe,GAAG,eAAe,CAG5E;AAsBD,wBAAgB,eAAe,CAC7B,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,eAAe,EAClD,QAAQ,GAAE,qBAAsC,GAC/C,IAAI,CA0LN"}
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../src/media.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAa,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3D,eAAO,MAAM,UAAU,eAAe,CAAC;AAwBvC,KAAK,IAAI,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,CAAC,CAAC;AAIpF,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,eAAe,GAAG,eAAe,CAG5E;AAsBD,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,eAAe,GAAG,IAAI,CA0LxF"}

package/dist/media.js

@@ -37,8 +37,8 @@ function drawnFor(mediaType) {
         return 'audio';
     return null;
 }
-export function defineRoomMedia(client, registry = customElements) {
-    if (registry.get(ROOM_MEDIA) !== undefined)
+export function defineRoomMedia(client) {
+    if (customElements.get(ROOM_MEDIA) !== undefined)
         return;
     const connected = Promise.resolve(client);
     class RoomMedia extends HTMLElement {
@@ -179,7 +179,7 @@ export function defineRoomMedia(client, registry = customElements) {
                 if (drawn instanceof HTMLMediaElement) {
                     drawn.controls = true;
                     drawn.preload = 'metadata';
-                    if (drawn instanceof HTMLVideoElement)
+                    if (drawn instanceof HTMLVideoElement && 'playsInline' in drawn)
                         drawn.playsInline = true;
                 }
                 drawn.addEventListener(drawn instanceof HTMLImageElement ? 'load' : 'loadedmetadata', () => {
@@ -214,5 +214,5 @@ export function defineRoomMedia(client, registry = customElements) {
             void this.#load();
         }
     }
-    registry.define(ROOM_MEDIA, RoomMedia);
+    customElements.define(ROOM_MEDIA, RoomMedia);
 }