@agentshouse/mdruntime 0.1.0-c2aaa9c0e3ca4 → 0.1.0-c2af3ddcc243b

package/dist/seed.d.ts

@@ -0,0 +1,25 @@
+import type { Cover } from './live.js';
+import { type KeyedResult } from './observation.js';
+import type { Plan, QueryRows } from './query.js';
+import type { Deliver } from './reach.js';
+import type { Runtime } from './runtime.js';
+import type { HeldCover, Store } from './store.js';
+export type EntrySeed = {
+    readonly at: Readonly<Record<string, string>>;
+    readonly queries: readonly {
+        readonly query: unknown;
+        readonly rows: QueryRows;
+    }[];
+};
+export type Seeded = {
+    readonly rows: QueryRows;
+    readonly at: Readonly<Record<string, string>>;
+};
+type SeededWatch = (coverOf: (cover: Cover, held: HeldCover) => Cover, deliver: (message: unknown) => void) => () => void;
+export declare function entrySeedOf(value: unknown): EntrySeed | null;
+export declare function seededResult(seed: Seeded): KeyedResult;
+export declare function seedApplies(runtime: Runtime, plan: Plan, held: HeldCover): Seeded | null;
+export declare function keepEntrySeed(store: Store, entry: EntrySeed): void;
+export declare function watchSeeded(runtime: Runtime, plan: Plan, deliver: Deliver, watch: SeededWatch): () => void;
+export {};
+//# sourceMappingURL=seed.d.ts.map

package/dist/seed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed.d.ts","sourceRoot":"","sources":["../src/seed.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EAAS,KAAK,WAAW,EAAqB,MAAM,kBAAkB,CAAC;AAC9E,OAAO,KAAK,EAAE,IAAI,EAA4C,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnD,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9C,QAAQ,CAAC,OAAO,EAAE,SAAS;QAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;KAAE,EAAE,CAAC;CACpF,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,CAAC;AAEjG,KAAK,WAAW,GAAG,CACjB,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,KAAK,KAAK,EACjD,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,KAChC,MAAM,IAAI,CAAC;AA0ChB,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAe5D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAmBtD;AA+BD,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,IAAI,CAOxF;AAYD,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAMlE;AAED,wBAAgB,WAAW,CACzB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,WAAW,GACjB,MAAM,IAAI,CA4BZ"}

package/dist/seed.js

@@ -0,0 +1,145 @@
+import { queryKey } from '@agentshouse/mdmodel';
+import { whole } from './observation.js';
+import { documentKey } from './rows.js';
+const seedTopic = (key) => `seed\u0000${key}`;
+function plain(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function windowOf(value) {
+    const { next, total } = value;
+    if (next !== undefined && typeof next !== 'string')
+        return null;
+    if (total !== undefined && !Number.isSafeInteger(total))
+        return null;
+    return {
+        ...(next === undefined ? {} : { next }),
+        ...(total === undefined ? {} : { total: total }),
+    };
+}
+function rowsOf(value) {
+    if (!plain(value))
+        return null;
+    const window = windowOf(value);
+    if (window === null)
+        return null;
+    if (Array.isArray(value.groups)) {
+        const groups = value.groups;
+        return groups.every((group) => plain(group) && Array.isArray(group.key) && typeof group.count === 'number')
+            ? { groups: groups, ...window }
+            : null;
+    }
+    if (!Array.isArray(value.documents))
+        return null;
+    const documents = value.documents;
+    return documents.every((document) => plain(document) && typeof document.room === 'string' && typeof document.path === 'string')
+        ? { documents: documents, ...window }
+        : null;
+}
+export function entrySeedOf(value) {
+    if (!plain(value) || !plain(value.at) || !Array.isArray(value.queries))
+        return null;
+    const at = {};
+    for (const [room, version] of Object.entries(value.at)) {
+        if (typeof version !== 'string')
+            return null;
+        at[room] = version;
+    }
+    const queries = [];
+    for (const entry of value.queries) {
+        if (!plain(entry) || !plain(entry.query))
+            return null;
+        const rows = rowsOf(entry.rows);
+        if (rows === null)
+            return null;
+        queries.push({ query: entry.query, rows });
+    }
+    return { at, queries };
+}
+export function seededResult(seed) {
+    const coverage = {
+        rooms: Object.entries(seed.at).map(([room, generation]) => ({
+            room,
+            generation,
+            current: false,
+        })),
+        overlay: [],
+    };
+    if ('groups' in seed.rows) {
+        return {
+            result: { ...seed.rows, coverage },
+            keys: seed.rows.groups.map((_group, index) => index),
+        };
+    }
+    return {
+        result: { ...seed.rows, coverage },
+        keys: seed.rows.documents.map((document) => documentKey(document.room, document.path)),
+    };
+}
+function seedRoomHeld({ socket }, room, version, held) {
+    const stored = held.rooms.get(room);
+    return (stored !== undefined &&
+        stored.indexed &&
+        socket.reads.reached(room, stored.roomVersion, version));
+}
+function seedHeld(runtime, at, held) {
+    const { socket, presence } = runtime;
+    return Object.entries(at).every(([room, version]) => (socket.session.now().roomsListed &&
+        presence.room(room) === undefined &&
+        !held.rooms.has(room)) ||
+        seedRoomHeld(runtime, room, version, held));
+}
+export function seedApplies(runtime, plan, held) {
+    const { seeds } = runtime.store;
+    const seed = seeds.of(plan.key);
+    if (seed === undefined)
+        return null;
+    if (!seedHeld(runtime, seed.at, held))
+        return seed;
+    seeds.drop(plan.key);
+    return null;
+}
+function seedBehind(runtime, plan, cover, held) {
+    const seed = seedApplies(runtime, plan, held);
+    if (seed === null || 'pending' in cover)
+        return cover;
+    return {
+        pending: Object.entries(seed.at)
+            .filter(([room, version]) => !seedRoomHeld(runtime, room, version, held))
+            .map(([room]) => ({ room, awaits: 'acquisition' })),
+    };
+}
+export function keepEntrySeed(store, entry) {
+    for (const { query, rows } of entry.queries) {
+        const key = queryKey(query);
+        store.seeds.keep(key, { rows, at: entry.at });
+        for (const watcher of store.watching(seedTopic(key)))
+            watcher.answer(null);
+    }
+}
+export function watchSeeded(runtime, plan, deliver, watch) {
+    const { store } = runtime;
+    let seeded = false;
+    let pending = true;
+    const shown = () => {
+        const seed = store.seeds.of(plan.key);
+        if (seed === undefined || seeded || !pending)
+            return;
+        seeded = true;
+        deliver(seededResult(seed));
+    };
+    const watcher = store.watch(seedTopic(plan.key), shown);
+    const stop = watch((cover, held) => seedBehind(runtime, plan, cover, held), (message) => {
+        const answered = message;
+        pending = whole(answered) && 'pending' in answered.result;
+        if (pending && store.seeds.of(plan.key) !== undefined) {
+            shown();
+            return;
+        }
+        seeded = false;
+        deliver(message);
+    });
+    return () => {
+        watcher.stop();
+        stop();
+    };
+}

package/dist/shared.d.ts

@@ -0,0 +1,10 @@
+export type Paths<V> = Readonly<Record<string, V>>;
+export declare function guarding<V>(values: Paths<V>, handler: ProxyHandler<Paths<V>>): Paths<V>;
+export declare function entriesIn<V>(map: Paths<V>): Generator<readonly [string, V]>;
+export declare function sortedKeys(map: Paths<unknown>): Generator<number, readonly string[], void>;
+export declare function sorting(keys: Iterable<string>): Generator<number, readonly string[], void>;
+export declare function patching<V>(base: Paths<V>, set: Iterable<readonly [string, V]>, removed?: Iterable<string>): Generator<number, Paths<V>, void>;
+export declare function drafted<V>(base: Paths<V>): Record<string, V>;
+export declare function settled<V>(draft: Record<string, V>): Paths<V>;
+export declare function settling<V>(draft: Record<string, V>): Generator<number, Paths<V>, void>;
+//# sourceMappingURL=shared.d.ts.map

package/dist/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;AA8LnD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAIvF;AAED,wBAAiB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAQ5E;AAqCD,wBAAiB,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,CAAC,CAE3F;AAED,wBAAiB,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,CAAC,CAoB3F;AAED,wBAAiB,QAAQ,CAAC,CAAC,EACzB,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,EACd,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EACnC,OAAO,GAAE,QAAQ,CAAC,MAAM,CAAM,GAC7B,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAgBnC;AAMD,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAiD5D;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAE7D;AAED,wBAAiB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAUxF"}

package/dist/shared.js

@@ -0,0 +1,339 @@
+import { finished, ROW_WEIGHT } from './turn.js';
+const BITS = 5;
+const MASK = (1 << BITS) - 1;
+const roots = new WeakMap();
+function hashOf(key) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < key.length; index += 1) {
+        hash ^= key.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}
+function isLeaf(node) {
+    return 'key' in node;
+}
+function isCollision(node) {
+    return 'leaves' in node;
+}
+function fragment(hash, shift) {
+    return (hash >>> shift) & MASK;
+}
+function count(bits) {
+    let left = bits - ((bits >>> 1) & 0x55555555);
+    left = (left & 0x33333333) + ((left >>> 2) & 0x33333333);
+    return (((left + (left >>> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24;
+}
+function slot(bitmap, bit) {
+    return count(bitmap & (bit - 1));
+}
+function lookup(root, key) {
+    const hash = hashOf(key);
+    let node = root.node;
+    let shift = 0;
+    while (node !== undefined) {
+        if (isLeaf(node))
+            return node.key === key ? node : undefined;
+        if (isCollision(node))
+            return node.leaves.find((leaf) => leaf.key === key);
+        const bit = 1 << fragment(hash, shift);
+        if ((node.bitmap & bit) === 0)
+            return undefined;
+        node = node.children[slot(node.bitmap, bit)];
+        shift += BITS;
+    }
+    return undefined;
+}
+function branchOf(node, shift) {
+    return { bitmap: 1 << fragment(node.hash, shift), children: [node] };
+}
+function joined(left, right, shift) {
+    if (left.hash === right.hash) {
+        const leaves = isCollision(left) ? left.leaves : [left];
+        return { hash: right.hash, leaves: [...leaves, right] };
+    }
+    return put(branchOf(left, shift), right, shift);
+}
+function put(node, leaf, shift) {
+    if (node === undefined)
+        return leaf;
+    if (isLeaf(node)) {
+        if (node.key !== leaf.key)
+            return joined(node, leaf, shift);
+        return node.value === leaf.value ? node : leaf;
+    }
+    if (isCollision(node)) {
+        if (node.hash !== leaf.hash)
+            return joined(node, leaf, shift);
+        const at = node.leaves.findIndex((held) => held.key === leaf.key);
+        if (at === -1)
+            return { hash: node.hash, leaves: [...node.leaves, leaf] };
+        if (node.leaves[at].value === leaf.value)
+            return node;
+        return {
+            hash: node.hash,
+            leaves: node.leaves.map((held, index) => (index === at ? leaf : held)),
+        };
+    }
+    const bit = 1 << fragment(leaf.hash, shift);
+    const at = slot(node.bitmap, bit);
+    if ((node.bitmap & bit) === 0) {
+        return {
+            bitmap: node.bitmap | bit,
+            children: [...node.children.slice(0, at), leaf, ...node.children.slice(at)],
+        };
+    }
+    const child = node.children[at];
+    const next = put(child, leaf, shift + BITS);
+    if (next === child)
+        return node;
+    return {
+        bitmap: node.bitmap,
+        children: node.children.map((held, index) => (index === at ? next : held)),
+    };
+}
+function lone(node) {
+    if (node.children.length !== 1)
+        return null;
+    const [only] = node.children;
+    return isLeaf(only) || isCollision(only) ? only : null;
+}
+function taken(node, hash, key, shift) {
+    if (isLeaf(node))
+        return undefined;
+    if (isCollision(node)) {
+        const leaves = node.leaves.filter((leaf) => leaf.key !== key);
+        return leaves.length === 1 ? leaves[0] : { hash: node.hash, leaves };
+    }
+    const bit = 1 << fragment(hash, shift);
+    const at = slot(node.bitmap, bit);
+    const child = node.children[at];
+    const next = taken(child, hash, key, shift + BITS);
+    if (next === undefined) {
+        if (node.children.length === 1)
+            return undefined;
+        const rest = {
+            bitmap: node.bitmap & ~bit,
+            children: node.children.filter((_, index) => index !== at),
+        };
+        return lone(rest) ?? rest;
+    }
+    const replaced = {
+        bitmap: node.bitmap,
+        children: node.children.map((held, index) => (index === at ? next : held)),
+    };
+    return lone(replaced) ?? replaced;
+}
+function* leavesOf(node) {
+    if (node === undefined)
+        return;
+    if (isLeaf(node)) {
+        yield node;
+        return;
+    }
+    if (isCollision(node)) {
+        yield* node.leaves;
+        return;
+    }
+    for (const child of node.children)
+        yield* leavesOf(child);
+}
+function facade(root) {
+    let keys;
+    const target = {};
+    const map = new Proxy(target, {
+        get(held, property, receiver) {
+            if (typeof property === 'string') {
+                const leaf = lookup(root, property);
+                if (leaf !== undefined)
+                    return leaf.value;
+            }
+            return Reflect.get(held, property, receiver);
+        },
+        has(held, property) {
+            return ((typeof property === 'string' && lookup(root, property) !== undefined) ||
+                Reflect.has(held, property));
+        },
+        ownKeys() {
+            keys ??= [...leavesOf(root.node)].map((leaf) => leaf.key);
+            return keys;
+        },
+        getOwnPropertyDescriptor(_held, property) {
+            if (typeof property !== 'string')
+                return undefined;
+            const leaf = lookup(root, property);
+            if (leaf === undefined)
+                return undefined;
+            return { value: leaf.value, writable: false, enumerable: true, configurable: true };
+        },
+        set: () => false,
+        defineProperty: () => false,
+        deleteProperty: () => false,
+    });
+    roots.set(map, root);
+    return map;
+}
+const guarded = new WeakMap();
+export function guarding(values, handler) {
+    const map = new Proxy(values, handler);
+    guarded.set(map, values);
+    return map;
+}
+export function* entriesIn(map) {
+    const root = roots.get(map);
+    if (root === undefined) {
+        const values = guarded.get(map) ?? map;
+        for (const key of Object.keys(values))
+            yield [key, values[key]];
+        return;
+    }
+    for (const leaf of leavesOf(root.node))
+        yield [leaf.key, leaf.value];
+}
+function* rooted(map) {
+    const held = roots.get(map);
+    if (held !== undefined)
+        return held;
+    let node;
+    for (const [key, value] of entriesIn(map)) {
+        node = put(node, { key, hash: hashOf(key), value }, 0);
+        yield ROW_WEIGHT;
+    }
+    return { node };
+}
+const RUN = 1 << 10;
+function* merged(left, right) {
+    const into = [];
+    let at = 0;
+    let from = 0;
+    while (at < left.length || from < right.length) {
+        into.push(from === right.length || (at < left.length && left[at] < right[from])
+            ? left[at++]
+            : right[from++]);
+        yield ROW_WEIGHT;
+    }
+    return into;
+}
+function* pathsOf(map) {
+    for (const [key] of entriesIn(map))
+        yield key;
+}
+export function* sortedKeys(map) {
+    return yield* sorting(pathsOf(map));
+}
+export function* sorting(keys) {
+    let runs = [];
+    let run = [];
+    for (const key of keys) {
+        run.push(key);
+        yield ROW_WEIGHT;
+        if (run.length === RUN) {
+            runs.push(run.sort());
+            run = [];
+        }
+    }
+    if (run.length > 0)
+        runs.push(run.sort());
+    while (runs.length > 1) {
+        const next = [];
+        for (let at = 0; at < runs.length; at += 2) {
+            next.push(at + 1 === runs.length ? runs[at] : yield* merged(runs[at], runs[at + 1]));
+        }
+        runs = next;
+    }
+    return runs[0] ?? [];
+}
+export function* patching(base, set, removed = []) {
+    const root = yield* rooted(base);
+    let node = root.node;
+    for (const key of removed) {
+        if (node === undefined)
+            break;
+        const before = lookup({ node }, key);
+        if (before === undefined)
+            continue;
+        node = taken(node, before.hash, key, 0);
+        yield ROW_WEIGHT;
+    }
+    for (const [key, value] of set) {
+        node = put(node, { key, hash: hashOf(key), value }, 0);
+        yield ROW_WEIGHT;
+    }
+    if (node === root.node && roots.has(base))
+        return base;
+    return facade({ node });
+}
+const drafts = new WeakMap();
+const GONE = Symbol('gone');
+export function drafted(base) {
+    const written = new Map();
+    const read = (key) => {
+        const held = written.get(key);
+        if (held === GONE)
+            return undefined;
+        return held ?? (Object.hasOwn(base, key) ? base[key] : undefined);
+    };
+    const draft = new Proxy({}, {
+        get(held, property, receiver) {
+            if (typeof property === 'string') {
+                const value = read(property);
+                if (value !== undefined)
+                    return value;
+            }
+            return Reflect.get(held, property, receiver);
+        },
+        has(held, property) {
+            return ((typeof property === 'string' && read(property) !== undefined) ||
+                Reflect.has(held, property));
+        },
+        ownKeys() {
+            const keys = new Set(Object.keys(base));
+            for (const [key, value] of written) {
+                if (value === GONE)
+                    keys.delete(key);
+                else
+                    keys.add(key);
+            }
+            return [...keys];
+        },
+        getOwnPropertyDescriptor(_held, property) {
+            if (typeof property !== 'string')
+                return undefined;
+            const value = read(property);
+            if (value === undefined)
+                return undefined;
+            return { value, writable: true, enumerable: true, configurable: true };
+        },
+        set(_held, property, value) {
+            if (typeof property !== 'string')
+                return false;
+            written.set(property, value);
+            return true;
+        },
+        deleteProperty(_held, property) {
+            if (typeof property !== 'string')
+                return false;
+            written.set(property, GONE);
+            return true;
+        },
+        defineProperty: () => false,
+    });
+    drafts.set(draft, { base, written });
+    return draft;
+}
+export function settled(draft) {
+    return finished(settling(draft));
+}
+export function* settling(draft) {
+    const held = drafts.get(draft);
+    const set = [];
+    const removed = [];
+    for (const [key, value] of held.written) {
+        if (value === GONE)
+            removed.push(key);
+        else
+            set.push([key, value]);
+        yield ROW_WEIGHT;
+    }
+    return yield* patching(held.base, set, removed);
+}

package/dist/shown.d.ts

@@ -0,0 +1,33 @@
+import type { Member } from './adapter.js';
+import { type ChangeSet } from './change-set.js';
+import type { QueueEntry } from './outcome.js';
+import type { Runtime } from './runtime.js';
+import type { Live, Moving } from './socket.js';
+import { type CycleProgress } from './status.js';
+export declare const ROOMS_TOPIC = "rooms";
+export declare const STATUS_TOPIC = "sync-status";
+export declare const REFUSAL_TOPIC = "connection-refusal";
+export declare const STORAGE_LOSS_TOPIC = "storage-loss";
+export declare const SERVICE_MODE_TOPIC = "service-mode";
+export declare const MEMBER_TOPIC = "member";
+export declare const AUTHORITY_TOPIC = "authority-changes";
+export declare const LOCKS_TOPIC = "locks";
+export declare const queueTopic: (locator: string) => string;
+export declare function recoverReads({ liveQueries, figures }: Runtime): void;
+export declare function emitRooms(runtime: Runtime, changed?: readonly string[]): Promise<void>;
+export declare function emitKnownRooms(runtime: Runtime): void;
+export declare function emitRefusal(runtime: Runtime): void;
+export declare function storageLossNow({ store }: Runtime): string | null;
+export declare function emitStorageLoss(runtime: Runtime): void;
+export declare function emitMember({ store }: Runtime, member: Member | null): void;
+export declare function show(runtime: Runtime): Promise<void>;
+export declare function moveTo(runtime: Runtime, next: Moving): Promise<void>;
+export declare function statusShown(runtime: Runtime): Promise<void>;
+export declare function transferring({ socket }: Runtime): Moving;
+export declare function pendingShown(runtime: Runtime): Promise<void>;
+export declare function entriesOf(runtime: Runtime, locator: string): Promise<readonly QueueEntry[]>;
+export declare function publishChangeSet(runtime: Runtime, set: ChangeSet): Promise<void>;
+export declare function submissionDue(runtime: Runtime, locators?: readonly string[]): Promise<void>;
+export declare function roomUnreadable(runtime: Runtime, locator: string): void;
+export declare function rest(runtime: Runtime, progress: CycleProgress | null, live?: Live): Promise<void>;
+//# sourceMappingURL=shown.d.ts.map

package/dist/shown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shown.d.ts","sourceRoot":"","sources":["../src/shown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C,OAAO,EAA8B,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI7E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAA6B,KAAK,aAAa,EAAmB,MAAM,aAAa,CAAC;AAiB7F,eAAO,MAAM,WAAW,UAAU,CAAC;AAEnC,eAAO,MAAM,YAAY,gBAAgB,CAAC;AAE1C,eAAO,MAAM,aAAa,uBAAuB,CAAC;AAElD,eAAO,MAAM,kBAAkB,iBAAiB,CAAC;AAEjD,eAAO,MAAM,kBAAkB,iBAAiB,CAAC;AAEjD,eAAO,MAAM,YAAY,WAAW,CAAC;AAErC,eAAO,MAAM,eAAe,sBAAsB,CAAC;AAEnD,eAAO,MAAM,WAAW,UAAU,CAAC;AAEnC,eAAO,MAAM,UAAU,YAAa,MAAM,WAA4B,CAAC;AAqCvE,wBAAgB,YAAY,CAAC,EAAE,WAAW,EAAE,OAAO,EAAE,EAAE,OAAO,QAG7D;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAMtF;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,QAI9C;AA6ED,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,QAK3C;AAED,wBAAgB,cAAc,CAAC,EAAE,KAAK,EAAE,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAGhE;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,QAG/C;AAED,wBAAgB,UAAU,CAAC,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,QAEnE;AAsBD,wBAAgB,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAepD;AAED,wBAAgB,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAIpE;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAE3D;AAED,wBAAgB,YAAY,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,GAAG,MAAM,CAExD;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAK5D;AAYD,wBAAsB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,UAAU,EAAE,CAAC,CAGjG;AAcD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBhF;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAOjG;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,QAG/D;AAED,wBAAsB,IAAI,CACxB,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,aAAa,GAAG,IAAI,EAC9B,IAAI,GAAE,IAAqC,iBA6B5C"}