@agentshouse/mdruntime 0.1.0-cb1f56e16291b → 0.1.0-cb3bb3b233fa1

package/dist/install.js

@@ -0,0 +1,537 @@
+import { attachedModel } from './attached-model.js';
+import { bootstrapRoom } from './bootstrap.js';
+import { refusedForSpace } from './durability.js';
+import { uncaught } from './failure.js';
+import { name } from './listing.js';
+import { NO_MODEL } from './model.js';
+import { settle } from './queue.js';
+import { advancement } from './refresh.js';
+import { recoverReads } from './shown.js';
+import { unconfirmed } from './transfer.js';
+import { ROW_WEIGHT, yielded } from './turn.js';
+// Bytes still arriving are reported at most this often, so readiness is not rebuilt for every chunk the network hands over while a slow link still moves the figure.
+const ARRIVAL_REPORT_MS = 250;
+const NOTHING_HELD = { bytes: 0 };
+export const ERASE_BATCH = 512;
+function transferGone(held) {
+    return {
+        ...held,
+        transfer: null,
+        arrived: null,
+        streaming: false,
+        underived: 0,
+        unindexed: [],
+    };
+}
+function amountOf(held, kept) {
+    if (held.transfer !== null) {
+        const owed = held.unindexed.reduce((sum, part) => sum + part.bytes, 0);
+        return {
+            done: held.transfer.done.bytes - Math.ceil(owed),
+            total: Math.max(held.arrived ?? 0, held.transfer.done.bytes),
+        };
+    }
+    return { done: kept, total: held.arrived ?? kept };
+}
+function setBack(held) {
+    const now = amountOf(held, NOTHING_HELD.bytes);
+    const earlier = held.startedOver;
+    return {
+        ...held,
+        startedOver: {
+            done: Math.max(now.done, earlier?.done ?? 0),
+            total: Math.max(now.total, earlier?.total ?? 0),
+        },
+    };
+}
+function owedIndexes(held, bytes, text) {
+    if (bytes <= 0 || text <= 0)
+        return held;
+    return { ...held, unindexed: [...held.unindexed, { bytes, text }] };
+}
+function built(held, done, text) {
+    const owed = [...held.unindexed];
+    let left = text;
+    while (!done && left > 0 && owed.length > 0) {
+        const [first] = owed;
+        if (left >= first.text) {
+            left -= first.text;
+            owed.shift();
+            continue;
+        }
+        owed[0] = {
+            bytes: (first.bytes * (first.text - left)) / first.text,
+            text: first.text - left,
+        };
+        left = 0;
+    }
+    return { ...held, unindexed: done ? [] : owed };
+}
+function batchEnd(entries, from, bytes) {
+    let end = from;
+    let spent = 0;
+    while (end < entries.length) {
+        const size = (entries[end].content?.length ?? 0) + ROW_WEIGHT;
+        if (spent + size > bytes && end > from)
+            break;
+        spent += size;
+        end += 1;
+    }
+    return end;
+}
+const UNSHARED = {
+    installing: false,
+    downloading: false,
+    bytes: { done: 0, total: 0 },
+};
+export function installShare(store, { room, state }, held) {
+    if (state === 'unadmitted')
+        return UNSHARED;
+    const install = store.installs.of(room);
+    const underway = state === 'acquiring' || (install.installing && state !== 'complete');
+    const kept = underway ? NOTHING_HELD.bytes : (held.get(room)?.bytes ?? NOTHING_HELD.bytes);
+    const now = amountOf(install, kept);
+    const earlier = underway ? install.startedOver : null;
+    return {
+        installing: underway,
+        downloading: underway && (install.streaming || install.arrived === null),
+        bytes: {
+            done: Math.max(now.done, earlier?.done ?? 0),
+            total: Math.max(now.total, earlier?.total ?? 0),
+        },
+    };
+}
+export function installationOf(installing, downloading, bytes) {
+    const step = installing === 0
+        ? null
+        : downloading > 0
+            ? 'downloading'
+            : bytes.done < bytes.total
+                ? 'writing'
+                : 'replaying';
+    return { step, bytes };
+}
+export function roomInFlight(store, locator) {
+    const { catching, transfer } = store.installs.of(locator);
+    return catching || transfer !== null;
+}
+function installing(runtime, locator) {
+    runtime.store.installs.change(locator, (held) => ({ ...held, installing: true }));
+    runtime.store.readiness.queue([locator]);
+}
+function installed(runtime, locator) {
+    if (!runtime.store.installs.of(locator).installing)
+        return;
+    runtime.store.installs.change(locator, (held) => ({ ...held, installing: false }));
+    runtime.store.readiness.queue([locator]);
+}
+export function sweep({ store, socket }) {
+    if (store.device.now().sweeping || socket.closed())
+        return;
+    store.device.set({ sweeping: true });
+    void (async () => {
+        try {
+            while (!socket.closed() && (await store.durably((local) => local.erase(null, ERASE_BATCH)))) {
+                await yielded();
+            }
+        }
+        catch (error) {
+            uncaught(error);
+        }
+        finally {
+            store.device.set({ sweeping: false });
+        }
+    })();
+}
+export function caughtUpTo(runtime, locator) {
+    if (!runtime.store.installs.of(locator).catching)
+        return;
+    runtime.store.installs.change(locator, (held) => ({ ...held, catching: false }));
+    recoverReads(runtime, [locator]);
+}
+export function catching(store, locator) {
+    store.installs.change(locator, (held) => ({ ...held, catching: true }));
+}
+export function standingAt(store, locator, held) {
+    return { key: held?.key ?? null, confirmed: store.installs.of(locator).confirmations };
+}
+function standsAt(store, locator, held, from) {
+    const now = standingAt(store, locator, held);
+    return now.key === from.key && now.confirmed === from.confirmed;
+}
+function shownAt({ store, socket }, locator, held) {
+    const raised = store.installs.of(locator).highest ?? undefined;
+    if (held === undefined || raised === undefined)
+        return held ?? raised;
+    return socket.reads.reached(locator, held, raised) ? held : raised;
+}
+export function showing(system, locator, roomVersion, held) {
+    const at = shownAt(system, locator, held);
+    if (at === undefined || !system.socket.reads.reached(locator, at, roomVersion)) {
+        system.store.installs.change(locator, (room) => ({ ...room, highest: roomVersion }));
+    }
+}
+export function olderThan(system, locator, roomVersion, held) {
+    const { store, socket } = system;
+    if (store.installs.of(locator).beyondHorizon)
+        return false;
+    const at = shownAt(system, locator, held);
+    return (at !== undefined &&
+        socket.reads.reached(locator, at, roomVersion) &&
+        !socket.reads.reached(locator, roomVersion, at));
+}
+async function older(runtime, locator, roomVersion) {
+    const { store } = runtime;
+    if (store.installs.of(locator).beyondHorizon)
+        return false;
+    return olderThan(runtime, locator, roomVersion, (await store.record(locator))?.roomVersion);
+}
+export function replaced(store, locators) {
+    for (const locator of locators) {
+        store.installs.change(locator, (held) => ({ ...held, highest: null, beyondHorizon: true }));
+    }
+}
+export async function reachedBy({ store, socket }, locator, roomVersion) {
+    const held = await store.record(locator);
+    return held !== undefined && socket.reads.reached(locator, held.roomVersion, roomVersion);
+}
+export async function behind({ store, socket }, room) {
+    const held = (await store.record(room.locator))?.roomVersion;
+    return held !== undefined && !socket.reads.reached(room.locator, held, room.roomVersion);
+}
+export async function writtenAfter({ store, socket }, locator, roomVersion, path) {
+    const held = await store.record(locator);
+    if (held === undefined)
+        return false;
+    const [entry] = await (await store.open()).entries(held.key, 'confirmed', [path]);
+    const written = entry?.written ?? undefined;
+    return (written !== undefined &&
+        socket.reads.reached(locator, written, roomVersion) &&
+        !socket.reads.reached(locator, roomVersion, written));
+}
+async function writtenLater(runtime, local, locator, key, paths, roomVersion, heldAt) {
+    if (paths.length === 0)
+        return new Set();
+    const { reached } = runtime.socket.reads;
+    const behindShown = heldAt === undefined
+        ? await older(runtime, locator, roomVersion)
+        : olderThan(runtime, locator, roomVersion, heldAt);
+    if (!behindShown)
+        return new Set();
+    const entries = await local.entries(key, 'confirmed', paths);
+    return new Set(entries.flatMap(({ path, written }) => written !== null &&
+        reached(locator, written, roomVersion) &&
+        !reached(locator, roomVersion, written)
+        ? [path]
+        : []));
+}
+function remodel(runtime, answers, held) {
+    const answer = answers?.collection;
+    if (answer === undefined)
+        return held;
+    return { collection: attachedModel(answer, runtime.roomTypes) };
+}
+function refreshingOf(runtime, local, locator, key, composition, liveness, replaying = false, heldAt) {
+    const { store } = runtime;
+    const write = replaying ? store.finishingWrite : store.exclusive;
+    return {
+        turn() {
+            if (replaying)
+                installing(runtime, locator);
+        },
+        prior: async (paths) => new Map((await local.entries(key, 'refreshed', paths)).map((entry) => [entry.path, entry])),
+        later: (paths, roomVersion) => writtenLater(runtime, local, locator, key, paths, roomVersion, heldAt),
+        async stage(page) {
+            for (let written = 0;;) {
+                const end = batchEnd(page.entries, written, store.stageBytes());
+                const last = end === page.entries.length;
+                const entries = page.entries.slice(written, end);
+                const staged = await write(async () => {
+                    if (!liveness())
+                        return false;
+                    await store.refreshPage(local, key, composition, last
+                        ? { ...page, entries }
+                        : { entries, removals: [], folders: [], folderRemovals: [] });
+                    return true;
+                });
+                if (!staged)
+                    return false;
+                if (last)
+                    return true;
+                written = end;
+            }
+        },
+    };
+}
+export async function pullRefresh(runtime, authorized, record, liveness, hold, refresh) {
+    if (!liveness())
+        return unconfirmed;
+    const { store } = runtime;
+    const from = standingAt(store, record.locator, record);
+    const local = await store.open();
+    try {
+        await store.exclusive(() => local.unrefresh(record.key));
+        const result = await advancement(async (authorization, request) => {
+            hold.release();
+            try {
+                return await refresh(authorization, request);
+            }
+            finally {
+                hold.take();
+            }
+        }, authorized, record, (models, kept) => (liveness() ? remodel(runtime, models, kept) : kept), liveness, refreshingOf(runtime, local, record.locator, record.key, store.composed(record), liveness, false, record.roomVersion));
+        if (result.kind !== 'advanced')
+            return result;
+        return {
+            kind: 'advanced',
+            record: result.record,
+            from,
+            remodelled: result.record.model !== record.model,
+        };
+    }
+    catch (error) {
+        if (refusedForSpace(error))
+            return unconfirmed;
+        throw error;
+    }
+}
+async function abandoned(runtime, local, locator) {
+    await local.abandon(locator);
+    runtime.store.installs.change(locator, (held) => transferGone(setBack(held)));
+    recoverReads(runtime, [locator]);
+    runtime.store.readiness.queue([locator]);
+    sweep(runtime);
+}
+function staging(runtime, local, liveness, unheld) {
+    const { store, socket } = runtime;
+    const derived = async (locator, key, composition) => {
+        store.installs.change(locator, (held) => ({ ...held, underived: 0 }));
+        for (;;) {
+            if (!liveness())
+                return false;
+            const done = await store.finishingWrite(async () => liveness() ? store.rederive(local, key, composition) : null);
+            if (done === null)
+                return false;
+            store.installs.change(locator, (held) => built(held, done.done, done.text));
+            runtime.store.readiness.queue([locator]);
+            if (done.done)
+                return true;
+        }
+    };
+    return {
+        held: (locator) => store.installs.of(locator).transfer,
+        async turn(locator, step) {
+            installing(runtime, locator);
+            return step === 'downloading' ? socket.heldStream() : () => { };
+        },
+        unqueued: socket.unqueued,
+        queued: socket.queued,
+        arriving(locator) {
+            let ended = false;
+            return {
+                at(bytes) {
+                    if (ended)
+                        return;
+                    store.installs.change(locator, (held) => ({
+                        ...held,
+                        arrived: bytes,
+                        streaming: true,
+                    }));
+                    const due = store.installs.arrivalsDue(locator, performance.now(), ARRIVAL_REPORT_MS);
+                    if (due.length > 0)
+                        runtime.store.readiness.queue(due);
+                },
+                end() {
+                    if (ended)
+                        return;
+                    ended = true;
+                    if (!store.installs.of(locator).streaming)
+                        return;
+                    store.installs.change(locator, (held) => ({ ...held, streaming: false }));
+                    runtime.store.readiness.queue([locator]);
+                },
+            };
+        },
+        streamed: socket.streamed,
+        async stage(record, page, composition) {
+            const { locator } = record;
+            installing(runtime, locator);
+            if (!liveness())
+                return null;
+            const key = await store.startingWrite(async () => {
+                if (!liveness())
+                    return null;
+                return local.stage(record, composition, page);
+            });
+            if (key === null || !liveness())
+                return null;
+            const before = store.installs.of(locator);
+            const prior = before.transfer?.done.bytes ?? 0;
+            const held = { ...record, key };
+            const text = page.entries.reduce((sum, entry) => sum + (entry.content?.length ?? 0), 0);
+            const owed = text + before.underived;
+            store.installs.change(locator, (room) => ({
+                ...owedIndexes(room, record.done.bytes - prior, text),
+                transfer: held,
+                underived: owed,
+            }));
+            installing(runtime, locator);
+            recoverReads(runtime, [locator]);
+            if (owed < store.deriveBytes())
+                return held;
+            return (await derived(locator, key, composition)) ? held : null;
+        },
+        async resume(record, parts, composition) {
+            const { locator } = record;
+            installing(runtime, locator);
+            if (!liveness())
+                return null;
+            const prior = unheld === undefined ? await store.record(locator) : undefined;
+            const published = prior !== undefined && prior.declaration.replica.selection === record.selection
+                ? prior.key
+                : null;
+            const kept = unheld?.staged ?? (await local.held()).staged.has(locator);
+            if (published === null && !kept)
+                return { record: null, staged: new Set() };
+            const resumed = await store.startingWrite(async () => {
+                if (!liveness())
+                    return null;
+                return local.resume(record, composition, parts.map((part) => part.id), published);
+            });
+            if (resumed === null || !liveness())
+                return null;
+            const parted = new Set(resumed.staged);
+            if (resumed.key === null)
+                return { record: null, staged: parted };
+            const bytes = parts.reduce((sum, part) => sum + (parted.has(part.id) ? part.bytes : 0), 0);
+            const held = {
+                ...record,
+                transfer: resumed.transfer,
+                key: resumed.key,
+                done: { bytes },
+            };
+            store.installs.change(locator, (room) => ({ ...room, transfer: held }));
+            recoverReads(runtime, [locator]);
+            store.readiness.queue([locator]);
+            return { record: held, staged: parted };
+        },
+        derive: derived,
+        async refreshing(locator, key, composition) {
+            await store.exclusive(() => local.unrefresh(key));
+            return refreshingOf(runtime, local, locator, key, composition, liveness, true);
+        },
+        abandon: (locator) => store.exclusive(async () => {
+            if (liveness())
+                await abandoned(runtime, local, locator);
+        }),
+        setAside: async (locator) => {
+            if (!liveness())
+                return;
+            store.installs.change(locator, (held) => transferGone(setBack(held)));
+            recoverReads(runtime, [locator]);
+            store.readiness.queue([locator]);
+        },
+        release: (key) => store.exclusive(async () => {
+            await local.release(key);
+            sweep(runtime);
+        }),
+    };
+}
+export async function pullBootstrap(runtime, authorized, room, local, liveness, prior, from = runtime.socket.reads, unheld) {
+    if (!liveness())
+        return unconfirmed;
+    const { store } = runtime;
+    if (prior !== undefined) {
+        catching(store, room.locator);
+        recoverReads(runtime, [room.locator]);
+    }
+    try {
+        const result = await bootstrapRoom(from, authorized, room, {
+            collection: prior?.model ?? runtime.presence.unheldModel(room.locator) ?? NO_MODEL,
+        }, runtime.builtIn, runtime.typedPaths, (models, held) => (liveness() ? remodel(runtime, models, held) : held), liveness, staging(runtime, local, liveness, unheld));
+        if (result.kind === 'staged' &&
+            (await older(runtime, room.locator, result.record.roomVersion))) {
+            caughtUpTo(runtime, room.locator);
+            installed(runtime, room.locator);
+            await abandoned(runtime, local, room.locator);
+            return { kind: 'transport-uncertainty' };
+        }
+        if (result.kind !== 'staged') {
+            caughtUpTo(runtime, room.locator);
+            installed(runtime, room.locator);
+        }
+        return result;
+    }
+    catch (error) {
+        caughtUpTo(runtime, room.locator);
+        installed(runtime, room.locator);
+        if (refusedForSpace(error))
+            return unconfirmed;
+        throw error;
+    }
+}
+export function publish(runtime, local, room, reached, landing, live) {
+    const { store } = runtime;
+    let published = true;
+    const landed = settle(runtime, [room.locator], async (held) => {
+        if (!live()) {
+            caughtUpTo(runtime, room.locator);
+            return [];
+        }
+        const prior = held.get(room.locator)?.replica;
+        if (!standsAt(store, room.locator, prior?.record, landing.from)) {
+            published = false;
+            if (landing.kind === 'refreshed') {
+                await local.unrefresh(reached.key);
+                return [];
+            }
+            caughtUpTo(runtime, room.locator);
+            await abandoned(runtime, local, room.locator);
+            return [];
+        }
+        const record = landing.kind === 'refreshed' && prior !== undefined
+            ? {
+                ...prior.record,
+                roomVersion: reached.roomVersion,
+                ...(landing.remodelled ? { model: reached.model } : {}),
+            }
+            : reached;
+        return [
+            {
+                locator: room.locator,
+                record,
+                installed: landing.kind === 'refreshed'
+                    ? { refreshed: true }
+                    : {
+                        published: { from: prior?.record.key ?? null },
+                        ...(landing.refreshed ? { refreshed: true } : {}),
+                    },
+                after() {
+                    runtime.presence.installed(room.locator, landing.kind === 'bootstrapped');
+                    runtime.retries.succeeded('download', room.locator);
+                    store.prepareAgain(room.locator);
+                    if (landing.kind === 'bootstrapped') {
+                        store.installs.change(room.locator, (held) => ({
+                            ...transferGone(held),
+                            highest: null,
+                            beyondHorizon: false,
+                            startedOver: null,
+                            catching: false,
+                        }));
+                        if (prior !== undefined && prior.record.key !== record.key)
+                            sweep(runtime);
+                        void name(runtime, room.locator);
+                    }
+                },
+            },
+        ];
+    }).then(() => published, (error) => {
+        if (!refusedForSpace(error))
+            throw error;
+        caughtUpTo(runtime, room.locator);
+        return published;
+    });
+    return landing.kind === 'refreshed'
+        ? landed
+        : landed.finally(() => installed(runtime, room.locator));
+}

package/dist/lifecycle.d.ts

@@ -0,0 +1,7 @@
+import type { Runtime } from './runtime.js';
+export declare function scheduleCurrency(runtime: Runtime): void;
+export declare function spaceFreed(runtime: Runtime): void;
+export declare function close({ store, socket, presence, conversations, recovery, liveQueries, figures, }: Runtime): void;
+export declare function stop(runtime: Runtime): Promise<void>;
+export declare function start(runtime: Runtime, signal: AbortSignal | undefined): void;
+//# sourceMappingURL=lifecycle.d.ts.map

package/dist/lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../src/lifecycle.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAoO5C,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,QAOhD;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,QAQ1C;AAED,wBAAgB,KAAK,CAAC,EACpB,KAAK,EACL,MAAM,EACN,QAAQ,EACR,aAAa,EACb,QAAQ,EACR,WAAW,EACX,OAAO,GACR,EAAE,OAAO,QAST;AAED,wBAAsB,IAAI,CAAC,OAAO,EAAE,OAAO,iBAS1C;AAED,wBAAgB,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,QA2CtE"}