@agentshouse/mdruntime 0.1.0-c069136dcb4e8 → 0.1.0-c076b00ebf42a

package/dist/overlay.js

@@ -1,4 +1,5 @@
-import { apply, frontmatterValue, parse, serialize, } from '@agentshouse/mdmodel';
+import { apply, create, documentValue, parse, serialize, TYPE_FIELD, } from '@agentshouse/mdmodel';
+import { definitionsAt } from './collection.js';
 import { drafted, entriesIn, settling } from './shared.js';
 import { ROW_WEIGHT } from './turn.js';
 export function* acceptedBinaries(files) {
@@ -24,7 +25,6 @@ export function sameChange(left, right) {
         left.author?.id === right.author?.id &&
         left.author?.name === right.author?.name);
 }
-const EMPTY_FRONTMATTER = '---\n---\n';
 function isPart(change) {
     return change.kind === 'field' || change.kind === 'section' || change.kind === 'preamble';
 }
@@ -53,16 +53,27 @@ function* priorsOf(preconditions) {
         preamble: (path) => preambles.get(path) ?? '',
     };
 }
-function compose(fields, sections) {
-    const body = Object.entries(sections)
-        .map(([name, value]) => `\n## ${name}\n${value}`)
-        .join('');
-    const skeleton = `${EMPTY_FRONTMATTER}${body}`;
-    const opened = parse(skeleton);
-    if (!opened.ok)
-        return skeleton;
-    const next = apply(opened.document, Object.entries(fields).flatMap(([name, value]) => frontmatterValue(value) ? [{ kind: 'field', name, value, prior: undefined }] : []));
-    return serialize(next.outcome === 'applied' ? next.document : opened.document);
+export function composed(path, fields, sections, composition) {
+    const declared = fields[TYPE_FIELD];
+    const type = typeof declared === 'string' && declared !== '' ? declared : undefined;
+    const definition = definitionsAt(composition, path)(type);
+    return apply(create(type, definition), [
+        ...Object.entries(fields).flatMap(([name, value]) => (name !== TYPE_FIELD || type === undefined) && documentValue(value)
+            ? [{ kind: 'field', name, value, prior: undefined }]
+            : []),
+        ...Object.entries(sections).map(([name, value]) => ({
+            kind: 'section',
+            name,
+            value,
+            prior: undefined,
+        })),
+    ], definition);
+}
+export function compose(path, fields, sections, composition) {
+    const next = composed(path, fields, sections, composition);
+    if (next.outcome !== 'applied')
+        throw new Error(`the creation of ${path} writes no document`);
+    return serialize(next.document);
 }
 function edited(change, priors) {
     if (change.kind === 'field')
@@ -81,17 +92,19 @@ function edited(change, priors) {
         prior: priors.section(change.path, change.name),
     };
 }
-function edit(staged, changes, priors) {
+function edit(staged, changes, priors, composition) {
     const path = changes[0].path;
     delete staged.revisions[path];
     const text = staged.documents[path];
     if (text === undefined)
         return changes.length;
-    const parsed = parse(text, path);
+    const definitions = definitionsAt(composition, path);
+    const parsed = parse(text, path, definitions);
     if (!parsed.ok)
         return changes.length;
+    const definition = definitions(parsed.document.type);
     const wanted = changes.map((change) => edited(change, priors));
-    const first = apply(parsed.document, wanted);
+    const first = apply(parsed.document, wanted, definition);
     if (first.outcome === 'refuse')
         return changes.length;
     if (first.outcome === 'applied') {
@@ -100,7 +113,7 @@ function edit(staged, changes, priors) {
     }
     const stale = new Set(first.stale);
     const kept = wanted.filter((_, at) => !stale.has(at));
-    const rest = apply(parsed.document, kept);
+    const rest = apply(parsed.document, kept, definition);
     if (rest.outcome !== 'applied')
         return changes.length;
     staged.documents[path] = serialize(rest.document);
@@ -125,16 +138,21 @@ function relocate(staged, from, to) {
 function moveHead(heads, from, to) {
     const revision = heads.revisions[from];
     const fileId = heads.fileIds[from];
+    const created = heads.created[from];
     const change = heads.changes[from];
     delete heads.revisions[from];
     delete heads.fileIds[from];
+    delete heads.created[from];
     delete heads.changes[from];
     delete heads.fileIds[to];
+    delete heads.created[to];
     delete heads.changes[to];
     if (revision !== undefined)
         heads.revisions[to] = revision;
     if (fileId !== undefined)
         heads.fileIds[to] = fileId;
+    if (created !== undefined)
+        heads.created[to] = created;
     if (change !== undefined)
         heads.changes[to] = change;
 }
@@ -142,14 +160,18 @@ function erase(staged, path) {
     delete staged.documents[path];
     delete staged.revisions[path];
     delete staged.fileIds[path];
+    delete staged.created[path];
     delete staged.changes[path];
     delete staged.binaries[path];
 }
-function stage(staged, change) {
+function stage(staged, change, composition) {
     if (change.kind === 'create') {
         staged.documents[change.path] =
-            'content' in change ? change.content : compose(change.fields, change.sections);
+            'content' in change
+                ? change.content
+                : compose(change.path, change.fields, change.sections, composition);
         delete staged.fileIds[change.path];
+        delete staged.created[change.path];
         delete staged.changes[change.path];
         return true;
     }
@@ -194,15 +216,18 @@ function arrive(heads, change) {
         heads.revisions[change.path] = change.revision;
     if (change.fileId !== undefined)
         heads.fileIds[change.path] = change.fileId;
+    if (change.created !== undefined)
+        heads.created[change.path] = change.created;
     if (change.change !== undefined)
         heads.changes[change.path] = change.change;
 }
-export function* overlaying(base, queue, unapplied) {
+export function* overlaying(base, queue, composition, unapplied) {
     const staged = {
         documents: drafted(base.documents),
         binaries: drafted(base.binaries),
         revisions: drafted(base.revisions),
         fileIds: drafted(base.fileIds),
+        created: drafted(base.created),
         changes: drafted(base.changes),
     };
     for (const batch of queue) {
@@ -210,7 +235,7 @@ export function* overlaying(base, queue, unapplied) {
         for (let index = 0; index < batch.changes.length; index += 1) {
             const change = batch.changes[index];
             if (!isPart(change)) {
-                if (!stage(staged, change))
+                if (!stage(staged, change, composition))
                     unapplied?.();
                 yield ROW_WEIGHT;
                 continue;
@@ -224,7 +249,7 @@ export function* overlaying(base, queue, unapplied) {
                 index += 1;
             }
             const text = staged.documents[change.path] ?? '';
-            for (let left = edit(staged, run, priors); left > 0; left -= 1)
+            for (let left = edit(staged, run, priors, composition); left > 0; left -= 1)
                 unapplied?.();
             yield ROW_WEIGHT + text.length;
         }
@@ -234,6 +259,7 @@ export function* overlaying(base, queue, unapplied) {
         binaries: yield* settling(staged.binaries),
         revisions: yield* settling(staged.revisions),
         fileIds: yield* settling(staged.fileIds),
+        created: yield* settling(staged.created),
         changes: yield* settling(staged.changes),
     };
 }

package/dist/page-metadata.d.ts

@@ -0,0 +1,8 @@
+export declare const PAGE_METADATA_WORDS: {
+    readonly heading: 'Page metadata';
+    readonly app: 'App';
+    readonly address: 'Address';
+    readonly queries: 'Local Queries';
+};
+export declare function pageMetadataBlock(app: string, address: string, queries: readonly unknown[]): string;
+//# sourceMappingURL=page-metadata.d.ts.map

package/dist/page-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-metadata.d.ts","sourceRoot":"","sources":["../src/page-metadata.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;aAC9B,OAAO,EAAE,eAAe;aACxB,GAAG,EAAE,KAAK;aACV,OAAO,EAAE,SAAS;aAClB,OAAO,EAAE,eAAe;CAChB,CAAC;AAIX,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,SAAS,OAAO,EAAE,GAC1B,MAAM,CAUR"}

package/dist/page-metadata.js

@@ -0,0 +1,19 @@
+import { queryKey } from '@agentshouse/mdmodel';
+export const PAGE_METADATA_WORDS = {
+    heading: 'Page metadata',
+    app: 'App',
+    address: 'Address',
+    queries: 'Local Queries',
+};
+const PAGE_METADATA_QUERIES = 10;
+export function pageMetadataBlock(app, address, queries) {
+    const held = [...new Set(queries.map(queryKey))];
+    return [
+        PAGE_METADATA_WORDS.heading,
+        `${PAGE_METADATA_WORDS.app}: ${app}`,
+        `${PAGE_METADATA_WORDS.address}: ${address}`,
+        ...(held.length === 0 || held.length > PAGE_METADATA_QUERIES
+            ? []
+            : [`${PAGE_METADATA_WORDS.queries}:`, ...held]),
+    ].join('\n');
+}

package/dist/parts.d.ts

@@ -0,0 +1,4 @@
+import { type Part } from '@agentshouse/session-content';
+export declare function currentStep(parts: readonly Part[]): string | null;
+export declare function runningLine(parts: readonly Part[]): string | null;
+//# sourceMappingURL=parts.d.ts.map

package/dist/parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parts.d.ts","sourceRoot":"","sources":["../src/parts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,IAAI,EAAE,MAAM,8BAA8B,CAAC;AAGhE,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,MAAM,GAAG,IAAI,CAGjE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,MAAM,GAAG,IAAI,CAKjE"}

package/dist/parts.js

@@ -0,0 +1,13 @@
+import { isOwn } from '@agentshouse/session-content';
+import { excerpt } from './read.js';
+export function currentStep(parts) {
+    const call = [...parts].reverse().find((part) => part.type === 'call');
+    return call?.type === 'call' && call.line !== '' ? call.line : null;
+}
+export function runningLine(parts) {
+    const own = parts.filter(isOwn);
+    const note = [...own].reverse().find((part) => part.type === 'text' && part.text.trim() !== '');
+    if (note?.type === 'text')
+        return excerpt(note.text);
+    return currentStep(own);
+}

package/dist/paths.d.ts

@@ -1,5 +1,6 @@
 export declare function normalize(path: string): string | null;
 export declare function beneath(prefix: string, path: string): boolean;
 export declare function covered(prefixes: readonly string[], path: string): boolean;
+export declare function authoredAt(patterns: readonly string[], path: string): boolean;
 export declare function ancestors(path: string): readonly string[];
 //# sourceMappingURL=paths.d.ts.map

package/dist/paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYrD;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED,wBAAgB,OAAO,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAK1E;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAGzD"}
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../src/paths.ts"],"names":[],"mappings":"AAEA,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYrD;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED,wBAAgB,OAAO,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAK1E;AAwBD,wBAAgB,UAAU,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7E;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAGzD"}

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,6 +23,27 @@ 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();
+}