@agentshouse/mdruntime 0.1.0-cec6690d5712e → 0.1.0-cedd665dffa4c

package/dist/paths.js

@@ -1,3 +1,4 @@
+import { isDocumentPath } from '@agentshouse/mdmodel';
 export function normalize(path) {
     const parts = [];
     for (const part of path.split('/')) {
@@ -22,3 +23,28 @@ export function covered(prefixes, path) {
         return normalized !== null && (normalized === '' || beneath(normalized, path));
     });
 }
+function named(pattern, name) {
+    const star = pattern.indexOf('*');
+    if (star === -1)
+        return pattern === name;
+    const before = pattern.slice(0, star);
+    const after = pattern.slice(star + 1);
+    return (name.length > before.length + after.length && name.startsWith(before) && name.endsWith(after));
+}
+function matched(pattern, path) {
+    if (pattern === '/')
+        return isDocumentPath(path);
+    const wanted = pattern.split('/');
+    const names = path.split('/');
+    const open = wanted.at(-1) === '**';
+    const fixed = open ? wanted.slice(0, -1) : wanted;
+    return ((open ? names.length > fixed.length : names.length === fixed.length) &&
+        fixed.every((one, at) => named(one, names[at])));
+}
+export function authoredAt(patterns, path) {
+    return patterns.some((pattern) => matched(pattern, path));
+}
+export function ancestors(path) {
+    const parts = path.split('/');
+    return parts.slice(1).map((_, at) => parts.slice(0, at + 1).join('/'));
+}

package/dist/preparation.d.ts

@@ -0,0 +1,41 @@
+import { type InstallShare } from './install.js';
+import { type ReadinessChange } from './observation.js';
+import { type PortReach } from './reach.js';
+import { type CodeAvailability, type ConnectionAvailability, type Readiness, type RoomCoverage } from './readiness.js';
+import type { Runtime } from './runtime.js';
+export type ReadinessPort = {
+    readonly target: string;
+    readonly code: CodeAvailability;
+};
+export type ReadinessMessage = Readiness | ReadinessChange;
+export type ReadinessWatch = {
+    readonly port: ReadinessPort;
+    readonly reach: PortReach | null;
+    readonly deliver: (readiness: ReadinessMessage) => void;
+};
+type Share = InstallShare & {
+    readonly coverage: RoomCoverage;
+};
+type Totals = {
+    installing: number;
+    downloading: number;
+    acquiring: number;
+    unsettled: number;
+    done: number;
+    total: number;
+};
+export type ReadinessShowing = {
+    readonly listing: number;
+    readonly roomsListed: boolean;
+    readonly named: ReadonlySet<string> | null;
+    readonly rooms: Map<string, Share>;
+    readonly totals: Totals;
+    shown: string;
+};
+export declare function prepare(runtime: Runtime, locators?: readonly string[]): void;
+export declare function connectionNow(runtime: Runtime): Promise<ConnectionAvailability>;
+export declare function deliverOwedReadiness(runtime: Runtime, owed: readonly ReadinessWatch[], touched: ReadonlySet<string> | null): Promise<void>;
+export declare function watchReadiness({ store }: Runtime, port: ReadinessPort, reach: PortReach | null, deliver: (readiness: ReadinessMessage) => void): () => void;
+export declare function filled(runtime: Runtime): void;
+export {};
+//# sourceMappingURL=preparation.d.ts.map

package/dist/preparation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preparation.d.ts","sourceRoot":"","sources":["../src/preparation.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgC,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAE/E,OAAO,EAKL,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAa,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,EAE3B,KAAK,SAAS,EAEd,KAAK,YAAY,EAElB,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAK5C,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,eAAe,CAAC;AAE3D,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,CAAC,SAAS,EAAE,gBAAgB,KAAK,IAAI,CAAC;CACzD,CAAC;AAEF,KAAK,KAAK,GAAG,YAAY,GAAG;IAAE,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAA;CAAE,CAAC;AAEhE,KAAK,MAAM,GAAG;IACZ,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;IAC3C,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAwCF,wBAAgB,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,GAAE,SAAS,MAAM,EAAO,QA4BzE;AAuDD,wBAAsB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAMrF;AAkMD,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,SAAS,cAAc,EAAE,EAC/B,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,iBAKpC;AAED,wBAAgB,cAAc,CAC5B,EAAE,KAAK,EAAE,EAAE,OAAO,EAClB,IAAI,EAAE,aAAa,EACnB,KAAK,EAAE,SAAS,GAAG,IAAI,EACvB,OAAO,EAAE,CAAC,SAAS,EAAE,gBAAgB,KAAK,IAAI,GAC7C,MAAM,IAAI,CAQZ;AAED,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,QAKtC"}

package/dist/preparation.js

@@ -0,0 +1,314 @@
+import { changeSet } from './change-set.js';
+import { uncaught } from './failure.js';
+import { installationOf, installShare } from './install.js';
+import { listedLocators, listedOrHeld } from './listing.js';
+import { keyedAt, keyedChange, unchanged, } from './observation.js';
+import { planReach } from './reach.js';
+import { COMPLETE_ROOMS, readinessOf, } from './readiness.js';
+import { roomsOfReach } from './rows.js';
+import { recoverReads } from './shown.js';
+import { yielded } from './turn.js';
+async function prepareReplica(runtime, locator) {
+    const { store, socket } = runtime;
+    for (;;) {
+        const held = (await store.rooms([locator])).get(locator);
+        if (held === undefined || socket.closed() || held.indexed)
+            return;
+        const key = held.record.key;
+        const done = await store.exclusive(async () => {
+            const local = await store.open();
+            return store.rederive(local, key, store.composed(held.record));
+        });
+        if (!done.done)
+            continue;
+        if ((await store.rooms([locator])).get(locator)?.record.key !== key)
+            continue;
+        store.changed(changeSet(locator, { documents: null }));
+        recoverReads(runtime, [locator]);
+        store.readiness.queue([locator]);
+        return;
+    }
+}
+async function unprepared({ store }) {
+    const held = (await store.covering()).rooms;
+    const { unpreparedDemand, unpreparable } = store.device.now();
+    return [...unpreparedDemand, ...held.keys()].find((locator) => !(held.get(locator)?.indexed ?? false) && !unpreparable.has(locator));
+}
+function unpreparedBy({ store }, locator) {
+    const { unpreparable } = store.device.now();
+    store.device.set({ unpreparable: new Set([...unpreparable, locator]) });
+    store.readiness.queue([locator]);
+}
+export function prepare(runtime, locators = []) {
+    const { store, socket } = runtime;
+    const { device } = store;
+    if (locators.length > 0) {
+        device.set({ unpreparedDemand: new Set([...device.now().unpreparedDemand, ...locators]) });
+    }
+    if (device.now().preparing)
+        return;
+    device.set({ preparing: true });
+    void (async () => {
+        try {
+            for (let waiting = await unprepared(runtime); waiting !== undefined; waiting = await unprepared(runtime)) {
+                await yielded();
+                if (socket.closed())
+                    return;
+                const demand = new Set(device.now().unpreparedDemand);
+                demand.delete(waiting);
+                device.set({ unpreparedDemand: demand });
+                await prepareReplica(runtime, waiting).catch(() => unpreparedBy(runtime, waiting));
+            }
+        }
+        catch (error) {
+            uncaught(error);
+        }
+        finally {
+            device.set({ preparing: false });
+        }
+    })();
+}
+function requires(runtime, named, held, room) {
+    const listed = listedOrHeld(runtime, held, room);
+    if (named === null)
+        return listed;
+    return named.has(room) && (!runtime.socket.session.now().roomsListed || listed);
+}
+function requiredRooms(runtime, named, held) {
+    return [...(named ?? listedLocators(runtime, held))]
+        .filter((room) => requires(runtime, named, held, room))
+        .sort();
+}
+function roomState({ socket, presence }, locator, held) {
+    if (socket.session.now().roomsListed &&
+        (presence.room(locator) === undefined || !presence.available(locator)))
+        return 'unadmitted';
+    const stored = held.get(locator);
+    if (stored === undefined)
+        return 'acquiring';
+    if (!stored.indexed)
+        return 'preparing';
+    return 'complete';
+}
+function conversationCoverage({ socket, conversations }, reach) {
+    const declaredConversations = reach === null || reach.conversations;
+    if (!declaredConversations || socket.conversations() === undefined)
+        return 'undeclared';
+    if (!conversations.known() || !conversations.current())
+        return 'acquiring';
+    return 'complete';
+}
+function connectionOf({ socket }, lastCompleted) {
+    if (socket.isOpen())
+        return 'connected';
+    if (socket.session.now().moving.providerUnreachable)
+        return 'unreachable';
+    return !socket.streamed && lastCompleted !== null ? 'connected' : 'connecting';
+}
+export async function connectionNow(runtime) {
+    const { store, socket } = runtime;
+    if (socket.isOpen() || socket.session.now().moving.providerUnreachable || socket.streamed) {
+        return connectionOf(runtime, null);
+    }
+    return connectionOf(runtime, (await (await store.open()).facts(['lastCompleted'])).lastCompleted);
+}
+async function readinessHeld({ store }) {
+    const local = await store.open();
+    const [held, facts] = await Promise.all([
+        store.covering(),
+        local.facts(['lastCompleted', 'targets']),
+    ]);
+    return { held: held.rooms, facts };
+}
+function shareOf(runtime, room, held) {
+    const coverage = Object.freeze({ room, state: roomState(runtime, room, held) });
+    return { ...installShare(runtime.store, coverage, held), coverage };
+}
+function sameState(was, now) {
+    return was.coverage.state === now.coverage.state;
+}
+function coverageOf(change) {
+    return {
+        ...change,
+        changed: change.changed.map(([room, share]) => [room, share.coverage]),
+    };
+}
+function counted(totals, share, sign) {
+    const { state } = share.coverage;
+    totals.installing += share.installing ? sign : 0;
+    totals.downloading += share.downloading ? sign : 0;
+    totals.acquiring += state === 'acquiring' ? sign : 0;
+    totals.unsettled += COMPLETE_ROOMS.has(state) ? 0 : sign;
+    totals.done += sign * share.bytes.done;
+    totals.total += sign * share.bytes.total;
+}
+function showingOf(runtime, reach, held) {
+    const planned = planReach(reach);
+    const named = planned === null ? null : roomsOfReach(planned);
+    const totals = { installing: 0, downloading: 0, acquiring: 0, unsettled: 0, done: 0, total: 0 };
+    const rooms = new Map();
+    for (const room of requiredRooms(runtime, named, held)) {
+        const share = shareOf(runtime, room, held);
+        rooms.set(room, share);
+        counted(totals, share, 1);
+    }
+    return {
+        listing: runtime.presence.listing(),
+        roomsListed: runtime.socket.session.now().roomsListed,
+        named,
+        rooms,
+        totals,
+        shown: '',
+    };
+}
+function moved(runtime, showing, held, touched) {
+    const at = new Map();
+    for (const room of touched) {
+        at.set(room, requires(runtime, showing.named, held, room) ? shareOf(runtime, room, held) : null);
+    }
+    const change = keyedAt(showing.rooms, at, sameState);
+    if (change === null || change.removed.length > 0)
+        return null;
+    for (const [room, share] of at) {
+        if (share === null)
+            continue;
+        counted(showing.totals, showing.rooms.get(room), -1);
+        counted(showing.totals, share, 1);
+        showing.rooms.set(room, share);
+    }
+    return change;
+}
+function preparingIn(runtime, showing, rooms) {
+    const { unpreparable } = runtime.store.device.now();
+    const preparing = [...rooms].filter((room) => showing.rooms.get(room)?.coverage.state === 'preparing' && !unpreparable.has(room));
+    if (preparing.length > 0)
+        prepare(runtime, preparing);
+}
+function shownOf(runtime, { port, reach }, { named, totals }, { facts }) {
+    const { store, socket, usableWhenHeld } = runtime;
+    const { persistence, storageLoss, heldWhenOpened } = store.device.now();
+    const { roomsListed } = socket.session.now();
+    return readinessOf({
+        code: port.code,
+        coverage: {
+            listed: named === null ? roomsListed : roomsListed || totals.acquiring === 0,
+            unsettled: totals.unsettled,
+            conversations: conversationCoverage(runtime, reach),
+        },
+        persistence,
+        connection: connectionOf(runtime, facts.lastCompleted),
+        house: socket.session.now().refusal !== null
+            ? 'refused'
+            : socket.writesHeld()
+                ? 'write-halted'
+                : 'open',
+        space: store.space.full() ? 'full' : null,
+        installation: installationOf(totals.installing, totals.downloading, {
+            done: totals.done,
+            total: totals.total,
+        }),
+        lost: storageLoss !== null,
+        established: facts.targets[port.target]?.established === true ||
+            (heldWhenOpened && usableWhenHeld.includes(port.target)),
+    });
+}
+function establish(runtime, name) {
+    const { store } = runtime;
+    const { device } = store;
+    if (device.now().establishing.has(name))
+        return;
+    device.set({ establishing: new Set([...device.now().establishing, name]) });
+    void store
+        .durably(async (local) => {
+        const { targets } = await local.facts(['targets']);
+        await local.fact('targets', { ...targets, [name]: { established: true } });
+    })
+        .then(() => {
+        store.readiness.queue([]);
+        void probeEachMinute(runtime);
+    }, uncaught)
+        .finally(() => {
+        const establishing = new Set(device.now().establishing);
+        establishing.delete(name);
+        device.set({ establishing });
+    });
+}
+function deliverReadiness(runtime, watch, held, touched) {
+    const { readiness } = runtime.store;
+    if (!readiness.held(watch))
+        return;
+    const kept = readiness.kept(watch);
+    const patched = kept === undefined ||
+        touched === null ||
+        kept.listing !== runtime.presence.listing() ||
+        kept.roomsListed !== runtime.socket.session.now().roomsListed
+        ? null
+        : moved(runtime, kept, held.held, touched);
+    const showing = patched === null ? showingOf(runtime, watch.reach, held.held) : kept;
+    preparingIn(runtime, showing, patched === null ? showing.rooms.keys() : touched);
+    const shown = shownOf(runtime, watch, showing, held);
+    if (shown.ready && held.facts.targets[watch.port.target]?.established !== true) {
+        establish(runtime, watch.port.target);
+    }
+    const text = JSON.stringify(shown);
+    const before = kept?.shown;
+    showing.shown = text;
+    readiness.keep(watch, showing);
+    if (kept === undefined) {
+        watch.deliver({
+            ...shown,
+            coverage: {
+                ...shown.coverage,
+                rooms: [...showing.rooms.values()].map(({ coverage }) => coverage),
+            },
+        });
+        return;
+    }
+    const rooms = coverageOf(patched ??
+        keyedChange(kept.rooms, [...showing.rooms.keys()], [...showing.rooms.values()], sameState));
+    if (text === before && unchanged(rooms))
+        return;
+    watch.deliver({ shown, rooms });
+}
+export async function deliverOwedReadiness(runtime, owed, touched) {
+    const held = await readinessHeld(runtime);
+    if (runtime.socket.closed())
+        return;
+    for (const watch of owed)
+        deliverReadiness(runtime, watch, held, touched);
+}
+export function watchReadiness({ store }, port, reach, deliver) {
+    const watch = { port, reach, deliver };
+    const stop = store.readiness.add(watch);
+    void store.open().then(() => store.readiness.owe([watch]), () => store.readiness.owe([watch]));
+    return stop;
+}
+export function filled(runtime) {
+    const { store, socket } = runtime;
+    if (socket.closed() || !store.space.fill())
+        return;
+    store.readiness.queue([]);
+    void probeEachMinute(runtime);
+}
+async function installedTarget({ store }) {
+    if (store.device.now().heldWhenOpened)
+        return true;
+    const { targets } = await (await store.open()).facts(['targets']);
+    return Object.values(targets).some((target) => target.established);
+}
+async function probeEachMinute(runtime) {
+    const { store, socket } = runtime;
+    const { space } = store;
+    const idle = () => !space.full() || space.probing() || socket.closed();
+    if (idle())
+        return;
+    const installed = await installedTarget(runtime).catch((error) => {
+        uncaught(error);
+        return false;
+    });
+    if (!installed)
+        return;
+    if (idle())
+        return;
+    space.probeEachMinute();
+}

package/dist/presence.d.ts

@@ -0,0 +1,58 @@
+import type { DiscoveredRoom, ProviderRefusal, ScopedRefusal } from './adapter.js';
+import type { ModelState } from './model.js';
+type Repairable = {
+    readonly reset: string | undefined;
+};
+type Standing = {
+    readonly stale: boolean;
+    readonly repairable: Repairable | null;
+    readonly repairing: boolean;
+    readonly reloadDue: boolean;
+};
+export declare function lockingMode(mode: string | undefined): boolean;
+type Listing = {
+    readonly whole: boolean;
+    readonly live: boolean;
+};
+export type Presence = {
+    list(found: readonly DiscoveredRoom[], how: Listing): readonly DiscoveredRoom[];
+    room(locator: string): DiscoveredRoom | undefined;
+    rooms(): readonly DiscoveredRoom[];
+    available(locator: string, selection?: string): boolean;
+    refusal(locator: string): ProviderRefusal | null;
+    unheldModel(locator: string): ModelState | null;
+    refused(locator: string, refusal: ScopedRefusal | null): void;
+    readable(locator: string): boolean;
+    modelled(locator: string, model: ModelState | null): void;
+    installed(locator: string, bootstrapped: boolean): void;
+    locked(locator: string, stored: () => Promise<string | null>): Promise<boolean>;
+    lockedAmong(stored: ReadonlyMap<string, {
+        readonly offline: string;
+    }>, locking: ReadonlySet<string>): readonly string[];
+    lockedAs(locator: string, mode: string | undefined): boolean;
+    connectionLost(lapsed: () => void): void;
+    connectionLive(): void;
+    lapse(): void;
+    stood(locator: string, stale: boolean, repairable?: Repairable | null): void;
+    repairing(locator: string, running: boolean): void;
+    reload(locator: string, due: boolean): void;
+    standing(locator: string): Standing;
+    settled(): boolean;
+    repairsOwed(): readonly string[];
+    askAgain(locator: string, ask: () => void): void;
+    stopAsking(locator?: string): void;
+    lose(locator: string, during: number): boolean;
+    writing(locator: string): boolean;
+    unwritten(locator: string): void;
+    lost(locator: string): boolean;
+    losing(): boolean;
+    listing(): number;
+    losses(): number;
+    lostSince(locator: string, losses: number): boolean;
+    liftable(locator: string, discovery: number): boolean;
+    lift(locator: string, discovery: number, unfenced: boolean): void;
+    close(): void;
+};
+export declare function createPresence(notReadyWaitMs: (asked: number) => number): Presence;
+export {};
+//# sourceMappingURL=presence.d.ts.map

package/dist/presence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presence.d.ts","sourceRoot":"","sources":["../src/presence.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,KAAK,UAAU,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEzD,KAAK,QAAQ,GAAG;IACd,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;CAC7B,CAAC;AAUF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAE7D;AAgBD,KAAK,OAAO,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAEnE,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,EAAE,GAAG,EAAE,OAAO,GAAG,SAAS,cAAc,EAAE,CAAC;IAChF,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAAC;IAClD,KAAK,IAAI,SAAS,cAAc,EAAE,CAAC;IACnC,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACxD,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAAC;IACjD,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC;IAChD,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI,GAAG,IAAI,CAAC;IAC9D,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,GAAG,IAAI,CAAC;IAC1D,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,OAAO,GAAG,IAAI,CAAC;IACxD,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAChF,WAAW,CACT,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,EACzD,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAC3B,SAAS,MAAM,EAAE,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;IAC7D,cAAc,CAAC,MAAM,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IACzC,cAAc,IAAI,IAAI,CAAC;IACvB,KAAK,IAAI,IAAI,CAAC;IACd,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,CAAC,EAAE,UAAU,GAAG,IAAI,GAAG,IAAI,CAAC;IAC7E,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACnD,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,QAAQ,CAAC;IACpC,OAAO,IAAI,OAAO,CAAC;IACnB,WAAW,IAAI,SAAS,MAAM,EAAE,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,IAAI,GAAG,IAAI,CAAC;IACjD,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/C,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,MAAM,IAAI,OAAO,CAAC;IAClB,OAAO,IAAI,MAAM,CAAC;IAClB,MAAM,IAAI,MAAM,CAAC;IACjB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IACpD,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC;IACtD,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;IAClE,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AAKF,wBAAgB,cAAc,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,QAAQ,CAqNlF"}

package/dist/presence.js

@@ -0,0 +1,231 @@
+export function lockingMode(mode) {
+    return mode === 'locked';
+}
+const UNANSWERED = {
+    stale: false,
+    repairable: null,
+    repairing: false,
+    reloadDue: false,
+    refusal: null,
+    unreading: false,
+    unreadable: false,
+    unheldModel: null,
+    confirmed: false,
+};
+// A Room that locks offline stays readable this long after the connection drops, so a laptop waking or changing network keeps working while a disconnected device locks soon after.
+const LOCK_GRACE_MS = 120_000;
+export function createPresence(notReadyWaitMs) {
+    const listed = new Map();
+    const lockable = new Set();
+    let listings = 0;
+    const answered = new Map();
+    const marks = new Map();
+    const lastLost = new Map();
+    const unready = new Map();
+    let lossCount = 0;
+    let lockGrace = null;
+    function answer(locator) {
+        return answered.get(locator) ?? UNANSWERED;
+    }
+    function change(locator, next) {
+        answered.set(locator, { ...answer(locator), ...next });
+    }
+    function heard(locator, next) {
+        if (!marks.has(locator))
+            change(locator, next);
+    }
+    function readied(locator) {
+        const held = unready.get(locator);
+        if (held === undefined)
+            return;
+        if (held.timer !== null)
+            clearTimeout(held.timer);
+        unready.delete(locator);
+    }
+    function stopAsking(locator) {
+        for (const held of locator === undefined ? [...unready.keys()] : [locator])
+            readied(held);
+    }
+    function connectionLive() {
+        if (lockGrace !== null)
+            clearTimeout(lockGrace);
+        lockGrace = null;
+    }
+    function readable(locator) {
+        const { unreadable, unreading } = answer(locator);
+        if (!unreadable || marks.has(locator))
+            return false;
+        change(locator, {
+            unreadable: false,
+            ...(unreading ? { refusal: null, unreading: false } : {}),
+        });
+        return true;
+    }
+    function locks(locator, mode) {
+        return lockingMode(mode) && !answer(locator).confirmed && !marks.has(locator);
+    }
+    function liftable(locator, discovery) {
+        const mark = marks.get(locator);
+        return mark === undefined || mark.during < discovery;
+    }
+    return {
+        list(found, { whole, live }) {
+            listings += 1;
+            const kept = found.filter(({ locator }) => !marks.has(locator));
+            if (whole) {
+                listed.clear();
+                lockable.clear();
+            }
+            for (const room of kept) {
+                listed.set(room.locator, room);
+                if (lockingMode(room.replica.offline))
+                    lockable.add(room.locator);
+                else
+                    lockable.delete(room.locator);
+                change(room.locator, {
+                    refusal: null,
+                    unreading: false,
+                    ...(live && room.replica.admission === 'admitted' ? { confirmed: true } : {}),
+                });
+            }
+            return kept;
+        },
+        room: (locator) => listed.get(locator),
+        rooms: () => [...listed.values()],
+        available(locator, selection) {
+            if (marks.has(locator))
+                return false;
+            const room = listed.get(locator);
+            if (room === undefined)
+                return true;
+            return ((selection === undefined || selection === room.replica.selection) &&
+                room.replica.admission === 'admitted' &&
+                !answer(locator).unreadable);
+        },
+        refusal: (locator) => answer(locator).refusal,
+        unheldModel: (locator) => answer(locator).unheldModel,
+        refused(locator, refusal) {
+            if (refusal === null) {
+                heard(locator, { unreadable: true });
+                return;
+            }
+            const unreading = refusal.scope !== 'operation' && refusal.scope !== 'model';
+            heard(locator, {
+                refusal: { code: refusal.code, fields: refusal.fields, retryable: refusal.retryable },
+                unreading,
+                ...(unreading ? { unreadable: true } : {}),
+            });
+        },
+        readable,
+        modelled(locator, model) {
+            heard(locator, { unheldModel: model });
+        },
+        installed(locator, bootstrapped) {
+            if (marks.has(locator))
+                return;
+            if (bootstrapped) {
+                readied(locator);
+                change(locator, { unheldModel: null });
+            }
+            change(locator, { stale: false });
+            readable(locator);
+        },
+        async locked(locator, stored) {
+            if (marks.has(locator) || answer(locator).confirmed)
+                return false;
+            return locks(locator, (await stored()) ?? listed.get(locator)?.replica.offline);
+        },
+        lockedAs: locks,
+        lockedAmong(stored, locking) {
+            return [...new Set([...lockable, ...locking])]
+                .filter((locator) => locks(locator, stored.get(locator)?.offline ?? listed.get(locator)?.replica.offline))
+                .sort();
+        },
+        connectionLost(lapsed) {
+            if (lockGrace !== null)
+                return;
+            lockGrace = setTimeout(() => {
+                lockGrace = null;
+                lapsed();
+            }, LOCK_GRACE_MS);
+        },
+        connectionLive,
+        lapse() {
+            for (const [locator, held] of answered) {
+                if (held.confirmed)
+                    answered.set(locator, { ...held, confirmed: false });
+            }
+        },
+        stood(locator, stale, repairable) {
+            heard(locator, { stale, ...(repairable === undefined ? {} : { repairable }) });
+        },
+        repairing(locator, running) {
+            change(locator, { repairing: running });
+        },
+        reload(locator, due) {
+            change(locator, { reloadDue: due });
+        },
+        standing(locator) {
+            const { stale, repairable, repairing, reloadDue } = answer(locator);
+            return { stale, repairable, repairing, reloadDue };
+        },
+        settled: () => ![...answered].some(([locator, { stale }]) => stale && !marks.has(locator)),
+        repairsOwed: () => [...answered]
+            .filter(([locator, { stale, repairable }]) => stale && repairable !== null && !marks.has(locator))
+            .map(([locator]) => locator),
+        askAgain(locator, ask) {
+            const held = unready.get(locator) ?? { tries: 0, timer: null };
+            unready.set(locator, held);
+            if (held.timer !== null)
+                return;
+            const wait = notReadyWaitMs(held.tries);
+            held.tries += 1;
+            held.timer = setTimeout(() => {
+                held.timer = null;
+                ask();
+            }, wait);
+        },
+        stopAsking,
+        lose(locator, during) {
+            if (marks.has(locator))
+                return false;
+            marks.set(locator, { during, written: false });
+            lastLost.set(locator, ++lossCount);
+            listings += 1;
+            listed.delete(locator);
+            lockable.delete(locator);
+            readied(locator);
+            const { repairing, reloadDue } = answer(locator);
+            answered.set(locator, { ...UNANSWERED, repairing, reloadDue });
+            return true;
+        },
+        writing(locator) {
+            const mark = marks.get(locator);
+            if (mark === undefined || mark.written)
+                return false;
+            marks.set(locator, { ...mark, written: true });
+            return true;
+        },
+        unwritten(locator) {
+            const mark = marks.get(locator);
+            if (mark !== undefined)
+                marks.set(locator, { ...mark, written: false });
+        },
+        lost: (locator) => marks.has(locator),
+        losing: () => marks.size > 0,
+        listing: () => listings,
+        losses: () => lossCount,
+        lostSince: (locator, losses) => marks.has(locator) || (lastLost.get(locator) ?? 0) > losses,
+        liftable,
+        lift(locator, discovery, unfenced) {
+            const mark = marks.get(locator);
+            if (mark !== undefined && liftable(locator, discovery) && (unfenced || !mark.written)) {
+                marks.delete(locator);
+            }
+        },
+        close() {
+            stopAsking();
+            connectionLive();
+        },
+    };
+}