@agentshouse/mdruntime 0.1.0-cbb8d8acc9d19 → 0.1.0-cbbae1fff01c6

package/dist/preparation.js

@@ -0,0 +1,233 @@
+import { changeSet } from './change-set.js';
+import { uncaught } from './failure.js';
+import { installationOf } from './install.js';
+import { listedLocators } from './listing.js';
+import { planReach } from './reach.js';
+import { readinessOf, } from './readiness.js';
+import { roomOfKey } 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);
+        store.readiness.queue();
+        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, journal }, locator, error) {
+    const { unpreparable } = store.device.now();
+    store.device.set({ unpreparable: new Set([...unpreparable, locator]) });
+    journal.record(`preparation failed ${locator} ${error instanceof Error ? error.name : 'unknown'}`);
+    store.readiness.queue();
+}
+export function prepare(runtime, locators = []) {
+    const { store, socket, journal } = 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((error) => unpreparedBy(runtime, waiting, error));
+            }
+        }
+        catch (error) {
+            journal.record('preparation failed');
+            uncaught(error);
+        }
+        finally {
+            device.set({ preparing: false });
+        }
+    })();
+}
+export function roomsOfReach(reach) {
+    return new Set([...reach.rooms, ...reach.documents.map(roomOfKey)]);
+}
+function requiredRooms(runtime, given, held) {
+    const { roomsListed } = runtime.socket.session.now();
+    const reach = planReach(given);
+    const listed = new Set(listedLocators(runtime, held));
+    if (reach === null)
+        return { listed: roomsListed, rooms: [...listed].sort() };
+    const named = [...roomsOfReach(reach)].sort();
+    if (roomsListed)
+        return { listed: true, rooms: named.filter((room) => listed.has(room)) };
+    return { listed: named.every((room) => held.has(room)), rooms: named };
+}
+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);
+}
+async function readinessHeld({ store }) {
+    const local = await store.open();
+    const [held, facts] = await Promise.all([store.covering(), local.facts()]);
+    return { held: held.rooms, facts };
+}
+function readinessFor(runtime, port, reach, { held, facts }) {
+    const { store, socket, usableWhenHeld } = runtime;
+    const required = requiredRooms(runtime, reach, held);
+    const coverage = required.rooms.map((room) => ({ room, state: roomState(runtime, room, held) }));
+    const { unpreparable } = store.device.now();
+    const preparing = coverage
+        .filter((room) => room.state === 'preparing' && !unpreparable.has(room.room))
+        .map(({ room }) => room);
+    if (preparing.length > 0)
+        prepare(runtime, preparing);
+    const { persistence, storageLoss, heldWhenOpened } = store.device.now();
+    return readinessOf({
+        code: port.code,
+        coverage: {
+            listed: required.listed,
+            rooms: coverage,
+            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(store, coverage, held),
+        lost: storageLoss !== null,
+        established: facts.targets[port.target]?.established === true ||
+            (heldWhenOpened && usableWhenHeld.includes(port.target)),
+    });
+}
+function establish(runtime, name) {
+    const { store, journal } = 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();
+        await local.fact('targets', { ...targets, [name]: { established: true } });
+    })
+        .then(() => {
+        store.readiness.queue();
+        void probeEachMinute(runtime);
+    }, (error) => {
+        journal.record(`target record failed ${name}`);
+        uncaught(error);
+    })
+        .finally(() => {
+        const establishing = new Set(device.now().establishing);
+        establishing.delete(name);
+        device.set({ establishing });
+    });
+}
+function deliverReadiness(runtime, watch, held) {
+    if (!runtime.store.readiness.held(watch))
+        return;
+    const readiness = readinessFor(runtime, watch.port, watch.reach, held);
+    if (readiness.ready && held.facts.targets[watch.port.target]?.established !== true) {
+        establish(runtime, watch.port.target);
+    }
+    if (!runtime.store.readiness.changed(watch, JSON.stringify(readiness)))
+        return;
+    watch.deliver(structuredClone(readiness));
+}
+export async function deliverOwedReadiness(runtime, owed) {
+    const held = await readinessHeld(runtime);
+    if (runtime.socket.closed())
+        return;
+    for (const watch of owed)
+        deliverReadiness(runtime, watch, held);
+}
+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, journal } = runtime;
+    if (socket.closed() || !store.space.fill())
+        return;
+    journal.record('space full');
+    store.readiness.queue();
+    void probeEachMinute(runtime);
+}
+async function installedTarget({ store }) {
+    if (store.device.now().heldWhenOpened)
+        return true;
+    const { targets } = await (await store.open()).facts();
+    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,52 @@
+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;
+};
+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, string>): readonly string[];
+    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;
+    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(): 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":"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"}

package/dist/presence.js

@@ -0,0 +1,220 @@
+const UNANSWERED = {
+    stale: false,
+    repairable: null,
+    repairing: false,
+    reloadDue: false,
+    refusal: null,
+    unreading: false,
+    unreadable: false,
+    unheldModel: null,
+    confirmed: false,
+};
+// A Room the Provider answers not ready is asked again after these waits, the last repeating, so a chunk build that catches up within seconds installs at once and a long one is asked every 15 seconds.
+const NOT_READY_MS = [1_000, 2_000, 3_000, 5_000, 8_000, 11_000, 15_000];
+// 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() {
+    const listed = new Map();
+    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 mode === 'locked' && !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 }) {
+            const kept = found.filter(({ locator }) => !marks.has(locator));
+            if (whole)
+                listed.clear();
+            for (const room of kept) {
+                listed.set(room.locator, room);
+                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);
+        },
+        lockedAmong(stored) {
+            const modes = new Map([...listed].map(([locator, room]) => [locator, room.replica.offline]));
+            for (const [locator, mode] of stored)
+                modes.set(locator, mode);
+            return [...modes]
+                .filter(([locator, mode]) => locks(locator, mode))
+                .map(([locator]) => locator)
+                .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 = NOT_READY_MS[Math.min(held.tries, NOT_READY_MS.length - 1)];
+            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);
+            listed.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),
+        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();
+        },
+    };
+}

package/dist/queries.d.ts

@@ -0,0 +1,16 @@
+import { type FiguresCover } from './figures.js';
+import type { Cover, Ran } from './live.js';
+import { type Plan, type QueryResult } from './query.js';
+import { type Deliver, type Fail, type PortReach } from './reach.js';
+import type { Runtime } from './runtime.js';
+import { type SearchResult } from './search.js';
+import type { QueryRoom } from './store.js';
+export declare function figuresCover(runtime: Runtime): Promise<FiguresCover>;
+export declare function answeredPlan(runtime: Runtime, plan: Plan, cover: () => Promise<Cover>): Promise<Ran>;
+export declare function rowsQuery(runtime: Runtime, plan: Plan): Promise<QueryResult>;
+export declare function planned(runtime: Runtime, input: unknown, reach: PortReach | null): Promise<Plan>;
+export declare function roomTallies(runtime: Runtime, rooms: readonly QueryRoom[], since: string): Promise<readonly import("./tallies.js").RoomTally[]>;
+export declare function watchPlan(runtime: Runtime, plan: Plan, deliver: Deliver, fail: Fail): () => void;
+export declare function watchPlanned(runtime: Runtime, planning: Promise<Plan>, deliver: Deliver, fail: Fail): () => void;
+export declare function searched(runtime: Runtime, input: unknown, reach: PortReach | null): Promise<SearchResult>;
+//# sourceMappingURL=queries.d.ts.map

package/dist/queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../src/queries.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAE9D,OAAO,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAK5C,OAAO,EAIL,KAAK,IAAI,EACT,KAAK,WAAW,EAEjB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAa,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAGhF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAgB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAE9D,OAAO,KAAK,EAAa,SAAS,EAAgB,MAAM,YAAY,CAAC;AAqFrE,wBAAsB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,YAAY,CAAC,CAa1E;AA2ED,wBAAsB,YAAY,CAChC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,GAC1B,OAAO,CAAC,GAAG,CAAC,CAQd;AAQD,wBAAsB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC,CAWlF;AAED,wBAAsB,OAAO,CAC3B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,SAAS,GAAG,IAAI,GACtB,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAsB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,wDAO7F;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,GAAG,MAAM,IAAI,CAchG;AAED,wBAAgB,YAAY,CAC1B,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,EACvB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,IAAI,GACT,MAAM,IAAI,CAeZ;AAED,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,SAAS,GAAG,IAAI,GACtB,OAAO,CAAC,YAAY,CAAC,CAqDvB"}