@agentshouse/mdruntime 0.1.0-c49444f2a8fc6 → 0.1.0-c4d7cf2ec26a6

package/dist/sync.js

@@ -0,0 +1,532 @@
+import { submitAll, submitLater } from './acceptance.js';
+import { resendCalls, resendLater } from './actions.js';
+import { catchUpConversations, reconcileConversations, resendConversations, } from './conversation.js';
+import { applyDiscovery, discoverRooms, malformed, signIn } from './discovery.js';
+import { behind, caughtUpTo, publish, pullBootstrap, pullRefresh, reachedBy, replaced, standingAt, } from './install.js';
+import { heldRooms, listHeld, name, readable } from './listing.js';
+import { declaredAsHeld, keepNaming, retainModel, revoked, scoped } from './models.js';
+import { refuse } from './refusal.js';
+import { emitRooms, moveTo, rest, roomUnreadable, transferring, AUTHORITY_TOPIC } from './shown.js';
+import { unconfirmed } from './transfer.js';
+export const OPENING_LANE = 'opening';
+async function advance(runtime, room, local, authorized, running, unheld) {
+    const { store, socket } = runtime;
+    const live = () => running() && !store.space.full();
+    if (!live())
+        return unconfirmed;
+    const held = unheld === undefined ? await store.record(room.locator) : undefined;
+    if (socket.streamed && (held !== undefined || !store.installs.of(room.locator).beyondHorizon)) {
+        socket.rooms.stand(room.locator, { stale: false });
+        await name(runtime, room.locator);
+        return null;
+    }
+    const refresh = socket.reads.refresh;
+    if (held !== undefined && refresh !== undefined) {
+        const refreshed = await store.ahead((hold) => refreshedRoom(runtime, room, local, authorized, held, live, hold, refresh));
+        if (refreshed === 'behind')
+            return advance(runtime, room, local, authorized, live);
+        if (refreshed !== 'beyond-horizon')
+            return refreshed;
+        if (socket.rooms.standing(room.locator).reloadDue)
+            return unconfirmed;
+        replaced(store, [room.locator]);
+    }
+    const prior = held === undefined ? undefined : await store.record(room.locator);
+    const from = standingAt(store, room.locator, prior);
+    const bootstrapped = await pullBootstrap(runtime, authorized, room, local, live, prior, socket.reads, unheld);
+    if (bootstrapped.kind !== 'staged')
+        return live() ? bootstrapped : unconfirmed;
+    const landing = { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from };
+    if (await publish(runtime, local, room, bootstrapped.record, landing, live)) {
+        return live() ? null : unconfirmed;
+    }
+    return (await reachedBy(runtime, room.locator, bootstrapped.record.roomVersion))
+        ? null
+        : advance(runtime, room, local, authorized, live);
+}
+async function refreshedRoom(runtime, room, local, authorized, held, live, hold, refresh) {
+    const { store, socket } = runtime;
+    const { rooms } = socket;
+    const refreshed = await pullRefresh(runtime, authorized, held, live, hold, refresh);
+    if (!live())
+        return unconfirmed;
+    if (refreshed.kind === 'still-current') {
+        rooms.stand(room.locator, { stale: false });
+        if (rooms.standing(room.locator).unreadable) {
+            rooms.stand(room.locator, { refusal: null });
+            readable(runtime, room);
+            emitRooms(runtime);
+        }
+        return null;
+    }
+    if (refreshed.kind === 'advanced') {
+        const landing = {
+            kind: 'refreshed',
+            from: refreshed.from,
+            remodelled: refreshed.remodelled,
+        };
+        if (!(await publish(runtime, local, room, refreshed.record, landing, live))) {
+            const now = (await store.record(room.locator))?.roomVersion;
+            const reached = now !== undefined && socket.reads.reached(room.locator, now, refreshed.record.roomVersion);
+            return reached ? null : 'behind';
+        }
+        await retainModel(runtime, local, room, null);
+        return null;
+    }
+    return refreshed.kind === 'beyond-horizon' ? 'beyond-horizon' : refreshed;
+}
+export function advanced(runtime, room, local, authorized) {
+    return runtime.socket.lanes.inRoom(room.locator, (live) => advance(runtime, room, local, authorized, live));
+}
+export async function withhold(runtime, withheld, room, local, progress) {
+    const { store, socket, journal } = runtime;
+    const { rooms } = socket;
+    if (withheld.kind === 'unconfirmed' || store.fences.has(room.locator))
+        return;
+    if (withheld.kind === 'not-ready') {
+        progress.complete = false;
+        askAgain(runtime, room.locator);
+        return;
+    }
+    rooms.stand(room.locator, { stale: true });
+    if (withheld.kind === 'transport-uncertainty' || withheld.kind === 'retryable-refusal') {
+        const reset = withheld.kind === 'retryable-refusal' ? withheld.reset : undefined;
+        rooms.stand(room.locator, { repairable: { reset } });
+        repairLater(runtime, room.locator, reset === undefined ? { again: true } : { at: Date.parse(reset) });
+    }
+    else
+        rooms.stand(room.locator, { repairable: null });
+    if (withheld.kind === 'scoped-refusal') {
+        await scoped(runtime, withheld, room, local);
+    }
+    else if (withheld.kind === 'transport-uncertainty') {
+        progress.reachable = false;
+    }
+    else if (withheld.kind === 'retryable-refusal') {
+        journal.record(`refusal ${withheld.kind} ${withheld.code}`);
+    }
+    else if (withheld.kind === 'room-not-readable') {
+        roomUnreadable(runtime, room);
+    }
+    else if (withheld.kind === 'revoked-authorization') {
+        await refuse(runtime, 'revoked-authorization');
+    }
+}
+function askAgain(runtime, locator) {
+    const { store, socket } = runtime;
+    socket.rooms.askAgain(locator, () => {
+        const room = socket.rooms.discovered(locator);
+        if (socket.closed() ||
+            socket.stopping() ||
+            (socket.streamed && !socket.isOpen()) ||
+            room === undefined)
+            return;
+        const progress = { complete: true, reachable: true };
+        void store
+            .open()
+            .then((local) => socket.lanes.roomTask(locator, (live) => loadRoom(runtime, room, local, progress, live)))
+            .then(() => rest(runtime, progress), () => undefined);
+    });
+}
+async function prepareRoom(runtime, room, local, progress, prior) {
+    const { socket, journal } = runtime;
+    const { session } = socket;
+    if (socket.closed() || session.now().authorization === undefined) {
+        progress.complete = false;
+        return false;
+    }
+    if (prior !== undefined && prior.replica.selection !== room.replica.selection) {
+        listHeld(runtime, room.locator);
+        emitRooms(runtime);
+        journal.record(`selection changed ${room.locator}`);
+        progress.complete = false;
+        return false;
+    }
+    if (prior !== undefined && !declaredAsHeld(prior, room)) {
+        await retainModel(runtime, local, room, null);
+    }
+    if (prior !== undefined && (prior.name !== room.name || prior.handle !== room.handle)) {
+        await keepNaming(runtime, local, room);
+    }
+    const { paused, authorization } = session.now();
+    if (paused || authorization === undefined)
+        return false;
+    return room.replica.admission === 'admitted';
+}
+async function synchronize(runtime, listed, local, progress, attempt, live) {
+    const { store, socket } = runtime;
+    const heldNow = await store.rooms(listed.map(({ locator }) => locator));
+    const prepared = await Promise.allSettled(listed.map((room) => prepareRoom(runtime, room, local, progress, heldNow.get(room.locator)?.record)));
+    if (!live())
+        return;
+    const ready = listed.filter((_, index) => {
+        const outcome = prepared[index];
+        return outcome.status === 'fulfilled' && outcome.value;
+    });
+    if (attempt === 'opened') {
+        const held = await heldRooms(runtime, ready);
+        if (!live())
+            return;
+        socket.hand(held);
+    }
+    const kept = attempt === 'authorized'
+        ? new Set((await store.rooms(ready.map(({ locator }) => locator))).keys())
+        : new Set();
+    for (const room of ready) {
+        if (attempt === 'opened' || kept.has(room.locator)) {
+            if (attempt === 'authorized')
+                await name(runtime, room.locator);
+            continue;
+        }
+        void socket.lanes
+            .roomTask(room.locator, (live) => loadRoom(runtime, room, local, progress, live))
+            .then(() => rest(runtime, progress));
+    }
+    const failed = prepared.find((room) => room.status === 'rejected');
+    if (failed !== undefined)
+        throw failed.reason;
+}
+async function caughtUp(runtime, room, local, progress, live) {
+    const { socket } = runtime;
+    const { authorization } = socket.session.now();
+    if (socket.streamed || authorization === undefined)
+        return;
+    if (!live() || !(await behind(runtime, room)))
+        return;
+    const withheld = await advance(runtime, room, local, authorization, live);
+    if (withheld !== null)
+        await withhold(runtime, withheld, room, local, progress);
+}
+export async function loadRoom(runtime, room, local, progress, live, unheld) {
+    const { store, socket } = runtime;
+    const { authorization } = socket.session.now();
+    if (!live() || authorization === undefined)
+        return;
+    const prior = unheld === undefined ? await store.record(room.locator) : undefined;
+    if (prior !== undefined) {
+        if (!(await prepareRoom(runtime, room, local, progress, prior)))
+            return;
+        if (revoked(prior.model)) {
+            await reload(runtime, room, local, progress, live);
+            return;
+        }
+    }
+    const withheld = await advance(runtime, room, local, authorization, live, unheld);
+    if (withheld !== null) {
+        await withhold(runtime, withheld, room, local, progress);
+        return;
+    }
+    await caughtUp(runtime, room, local, progress, live);
+}
+export async function reload(runtime, room, local, progress, live) {
+    const { store, socket } = runtime;
+    try {
+        if (live())
+            socket.rooms.stand(room.locator, { reloadDue: false });
+        const { authorization } = socket.session.now();
+        if (!live() || authorization === undefined)
+            return;
+        const prior = await store.record(room.locator);
+        const from = standingAt(store, room.locator, prior);
+        const bootstrapped = await pullBootstrap(runtime, authorization, room, local, live, prior);
+        if (bootstrapped.kind !== 'staged') {
+            if (live())
+                await withhold(runtime, bootstrapped, room, local, progress);
+            return;
+        }
+        await publish(runtime, local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from }, live);
+        await caughtUp(runtime, room, local, progress, live);
+    }
+    finally {
+        caughtUpTo(runtime, room.locator);
+    }
+}
+function repairLater(runtime, locator, when) {
+    const { socket, recovery } = runtime;
+    if (!socket.isOpen() || socket.rooms.standing(locator).repairing)
+        return;
+    void recovery.attempt(`repair ${locator}`, (signal) => repairPass(runtime, locator, signal), when);
+}
+async function repairPass(runtime, locator, signal) {
+    const { store, socket } = runtime;
+    const { rooms } = socket;
+    const room = rooms.discovered(locator);
+    if (!socket.isOpen() ||
+        !socket.continuing() ||
+        socket.stopping() ||
+        !rooms.standing(locator).stale)
+        return 'done';
+    if (room === undefined || room.replica.admission !== 'admitted')
+        return 'done';
+    const progress = { complete: true, reachable: true };
+    rooms.stand(locator, { repairing: true });
+    try {
+        const local = await store.open();
+        await socket.lanes.roomTask(locator, async (live) => {
+            const { authorization } = socket.session.now();
+            if (!live() || authorization === undefined)
+                return;
+            const withheld = await advance(runtime, room, local, authorization, live);
+            if (withheld !== null && live())
+                await withhold(runtime, withheld, room, local, progress);
+        });
+    }
+    catch {
+        rooms.stand(locator, { stale: true });
+        progress.reachable = false;
+    }
+    finally {
+        rooms.stand(locator, { repairing: false });
+    }
+    if (signal.aborted)
+        return 'done';
+    await rest(runtime, progress);
+    if (!rooms.standing(locator).stale) {
+        if ((await (await store.open()).order(locator)).length > 0)
+            submitLater(runtime, locator);
+        return 'done';
+    }
+    const { repairable } = rooms.standing(locator);
+    if (repairable === null)
+        return 'done';
+    return repairable.reset === undefined ? 'again' : { at: Date.parse(repairable.reset) };
+}
+export async function finishOpening(runtime, progress, live) {
+    const { socket, conversations, recovery } = runtime;
+    try {
+        if (!live()) {
+            progress.complete = false;
+            return;
+        }
+        await submitAll(runtime);
+        for (const locator of socket.rooms.standingWhere(({ stale, repairable }) => stale && repairable !== null)) {
+            repairLater(runtime, locator, {});
+        }
+        await reconcileConversations(conversations);
+        const reading = { complete: true, reachable: true };
+        await catchUpConversations(conversations, reading);
+        if (progress.reachable && reading.reachable)
+            await resendConversations(conversations, reading);
+        if (progress.reachable) {
+            void recovery.attempt('calls', (signal) => resendCalls(runtime, signal));
+        }
+        if (!reading.reachable) {
+            progress.reachable = false;
+            resendLater(runtime);
+        }
+    }
+    catch {
+        progress.complete = false;
+    }
+    finally {
+        if (live()) {
+            socket.session.set({ complete: progress.complete });
+            await rest(runtime, progress, live);
+        }
+    }
+}
+export function sync(runtime, attempt, found) {
+    const { store, socket } = runtime;
+    const { session } = socket;
+    return socket.lanes.task(OPENING_LANE, async (live) => {
+        if (!live()) {
+            socket.readyFromStore();
+            return;
+        }
+        const progress = { complete: true, reachable: true };
+        session.set({
+            underway: attempt === 'opened' ? progress : null,
+            ...(attempt === 'opened' ? { streamed: progress } : {}),
+            complete: false,
+            recorded: false,
+        });
+        moveTo(runtime, transferring(runtime));
+        try {
+            const local = await store.open();
+            if (!live())
+                return;
+            await socket.authorize();
+            if (!live())
+                return;
+            const listed = await discoverRooms(runtime, local, progress, live, found);
+            if (listed !== null)
+                await synchronize(runtime, listed, local, progress, attempt, live);
+        }
+        catch {
+            progress.complete = false;
+            if (attempt === 'opened' && !socket.isHanded())
+                progress.reachable = false;
+        }
+        finally {
+            socket.notifyReady();
+        }
+        if (!live())
+            return;
+        if (attempt !== 'opened') {
+            await finishOpening(runtime, progress, live);
+            return;
+        }
+        if (socket.isHanded() || socket.closed() || progress.reachable)
+            return;
+        session.set({ underway: null });
+        await rest(runtime, progress, live);
+    });
+}
+export function resynchronize(runtime) {
+    const { store, socket } = runtime;
+    return socket.lanes.task(OPENING_LANE, async (live) => {
+        if (!live() || !socket.isAnnounced())
+            return;
+        const progress = { complete: true, reachable: true };
+        moveTo(runtime, transferring(runtime));
+        try {
+            const local = await store.open();
+            if (!live())
+                return;
+            await synchronize(runtime, socket.rooms.discoveredRooms(), local, progress, 'unstreamed', live);
+        }
+        catch {
+            progress.complete = false;
+        }
+        if (live())
+            await finishOpening(runtime, progress, live);
+    });
+}
+export function countAuthorityChange({ store, socket, lastAnswers }) {
+    const authorityChanges = socket.session.now().authorityChanges + 1;
+    socket.session.set({ authorityChanges });
+    store.tell(AUTHORITY_TOPIC, authorityChanges);
+    lastAnswers.again();
+}
+export function changeAuthority(runtime, change) {
+    const { store, socket, journal } = runtime;
+    const { session } = socket;
+    return socket.lanes.task(OPENING_LANE, async (live) => {
+        if (!live() || !socket.isAnnounced())
+            return;
+        countAuthorityChange(runtime);
+        const progress = { complete: true, reachable: true };
+        moveTo(runtime, transferring(runtime));
+        try {
+            const local = await store.open();
+            if (!live())
+                return;
+            const invalid = malformed(change.rooms);
+            if (invalid !== null) {
+                journal.record(invalid);
+                await refuse(runtime, 'missing-required-guarantee');
+                return;
+            }
+            if (change.member !== undefined)
+                await signIn(runtime, local, change.member);
+            const discoveries = session.now().discoveries + 1;
+            session.set({ discoveries });
+            const listed = await applyDiscovery(runtime, change.rooms, discoveries, change.left);
+            await synchronize(runtime, listed, local, progress, 'authorized', live);
+        }
+        catch {
+            progress.complete = false;
+        }
+        if (!live())
+            return;
+        if (!progress.complete)
+            session.set({ complete: false });
+        await rest(runtime, progress, live);
+    });
+}
+async function installCarried(runtime, room, local, change, live, progress) {
+    const { store, socket } = runtime;
+    const { authorization, underway } = socket.session.now();
+    if (authorization === undefined)
+        return;
+    if (underway === null)
+        moveTo(runtime, transferring(runtime));
+    const prior = await store.record(room.locator);
+    const from = standingAt(store, room.locator, prior);
+    const page = await change.read();
+    const carried = {
+        bootstrap: () => Promise.resolve({
+            kind: 'bootstrap',
+            roomVersion: page.roomVersion,
+            ...(page.models === undefined ? {} : { models: page.models }),
+            documents: page.documents,
+            facts: page.facts,
+            revisions: page.revisions,
+            ...(page.fileIds === undefined ? {} : { fileIds: page.fileIds }),
+            ...(page.created === undefined ? {} : { created: page.created }),
+            changes: page.changes,
+            binaryFiles: page.binaryFiles,
+            ...(page.folders === undefined ? {} : { folders: page.folders }),
+        }),
+        reached: socket.reads.reached,
+    };
+    const bootstrapped = await pullBootstrap(runtime, authorization, room, local, live, prior, carried);
+    if (bootstrapped.kind !== 'staged') {
+        if (live())
+            await withhold(runtime, bootstrapped, room, local, progress);
+        return;
+    }
+    await publish(runtime, local, room, bootstrapped.record, { kind: 'bootstrapped', refreshed: bootstrapped.refreshed, from }, live);
+}
+export function applyRoom(runtime, change) {
+    const { store, socket } = runtime;
+    const { rooms, session } = socket;
+    const { locator } = change;
+    if (socket.stopping())
+        return Promise.resolve();
+    return socket.lanes
+        .inRoom(locator, async (live) => {
+        await socket.answered(locator);
+        const progress = session.now().underway ?? { complete: true, reachable: true };
+        try {
+            const local = await store.open();
+            for (;;) {
+                if (!live())
+                    return null;
+                const room = rooms.discovered(locator);
+                if (room === undefined || room.replica.admission !== 'admitted')
+                    return null;
+                const held = await store.record(locator);
+                if (held === undefined) {
+                    if (change.from !== null)
+                        return null;
+                    await installCarried(runtime, room, local, change, live, progress);
+                    return progress;
+                }
+                if (held.replica.selection !== room.replica.selection)
+                    return null;
+                const at = held.roomVersion;
+                if (socket.reads.reached(locator, at, change.roomVersion))
+                    return progress;
+                if (change.from === null || !socket.reads.reached(locator, at, change.from)) {
+                    await name(runtime, locator);
+                    return progress;
+                }
+                if (session.now().underway === null)
+                    moveTo(runtime, transferring(runtime));
+                const writing = () => live() && !store.space.full();
+                const refreshed = await store.ahead((hold) => pullRefresh(runtime, session.now().authorization ?? {}, held, writing, hold, () => change.read()));
+                if (refreshed.kind !== 'advanced')
+                    return progress;
+                const landing = {
+                    kind: 'refreshed',
+                    from: refreshed.from,
+                    remodelled: refreshed.remodelled,
+                };
+                if (await publish(runtime, local, room, refreshed.record, landing, writing)) {
+                    rooms.stand(locator, { stale: false });
+                    if (!declaredAsHeld(held, room))
+                        await retainModel(runtime, local, room, null);
+                    return progress;
+                }
+            }
+        }
+        catch {
+            if (!rooms.standing(locator).stale)
+                void name(runtime, locator);
+            rooms.stand(locator, { stale: true });
+            return progress;
+        }
+    })
+        .then((progress) => rest(runtime, progress), () => undefined);
+}

package/dist/tables.d.ts

@@ -3,11 +3,14 @@ import type { Composed } from './collection.js';
 import type { UnsentWork } from './durability.js';
 import type { JobMarker } from './job.js';
 import { type ConversationWrite, type HeldConversation, type HeldRow, type MessageWindow } from './messages.js';
-import type { Plan } from './query.js';
+import type { GroupTotal, Plan } from './query.js';
+import { type ReadAt } from './reads.js';
+import { type ConversationTally, type RoomTally } from './tallies.js';
 import { type Committed, type Covering, type HeldEntry, type HeldLocators, type HeldRoomRow, type HeldRoomWork, type ReplicaOpened, type Referrer, type Resumed, type RoomCommit, type StoredEntry, type TypedEntry, type View } from './stored.js';
 export type { Committed, Covering, HeldEntry, HeldLocators, HeldRoomRow, HeldRoomWork, OverlayEntry, ReplicaOpened, Referrer, Resumed, RoomCommit, StoredEntry, TypedEntry, View, } from './stored.js';
 export type { QueryAnswer, QueryRoom } from './compile.js';
 export type { ConversationWrite, HeldConversation, HeldRow, MessageWindow } from './messages.js';
+export type { ConversationTally, RoomTally } from './tallies.js';
 export type Value = string | number | bigint | Uint8Array | null;
 export type Row = Readonly<Record<string, Value>>;
 export interface Connection {
@@ -50,7 +53,7 @@ export interface SqliteDatabase {
 export declare function sqliteConnection(engine: SqliteEngine, database: SqliteDatabase): Connection;
 export declare const FILE_PART_BYTES = 1048576;
 export declare const RUNTIME_TABLES: readonly string[];
-export type AuthoredFact = 'holder' | 'binding' | 'generation';
+export type AuthoredFact = 'holder' | 'generation';
 export type StoredFile = {
     readonly key: string;
     readonly blob: Blob;
@@ -113,6 +116,13 @@ export type OpenedFile = {
     readonly byteLength: number;
     readonly mediaType: string;
 };
+export type OpenedRoom = GroupTotal & {
+    readonly room: string;
+};
+export type OpenedHeld = {
+    readonly rooms: readonly OpenedRoom[];
+    readonly cleanable: number;
+};
 type Asked<A, R> = {
     readonly asked: A;
     readonly answer: R;
@@ -217,6 +227,11 @@ export interface RuntimeRequests {
         readonly rooms: readonly QueryRoom[];
         readonly budget: number | null;
     }, QueryAnswer>;
+    readonly 'replica.tallies': Asked<{
+        readonly totals: Plan;
+        readonly rooms: readonly QueryRoom[];
+        readonly since: string;
+    }, readonly RoomTally[]>;
     readonly 'replica.entries': Asked<{
         readonly key: number;
         readonly view: View;
@@ -234,7 +249,6 @@ export interface RuntimeRequests {
     }, readonly Referrer[]>;
     readonly 'replica.folders': Asked<{
         readonly key: number;
-        readonly view: View;
         readonly paths: readonly string[];
     }, readonly string[]>;
     readonly 'replica.typedWithin': Asked<{
@@ -337,6 +351,7 @@ export interface RuntimeRequests {
         readonly key: string;
     }, null>;
     readonly 'opened.clean': Asked<Nothing, number>;
+    readonly 'opened.held': Asked<Nothing, OpenedHeld>;
     readonly 'file.part': Asked<{
         readonly key: string;
         readonly part: number;
@@ -365,10 +380,21 @@ export interface RuntimeRequests {
     readonly 'conversation.jobs': Asked<{
         readonly conversation: string;
     }, readonly JobMarker[]>;
+    readonly 'conversation.tallies': Asked<{
+        readonly conversations: readonly string[] | null;
+        readonly since: string;
+    }, readonly ConversationTally[]>;
     readonly 'conversation.drop': Asked<{
         readonly conversations: readonly string[];
     }, null>;
     readonly 'space.probe': Asked<Nothing, null>;
+    readonly 'read.stored': Asked<ReadAt, string | null>;
+    readonly 'read.keep': Asked<ReadAt & {
+        readonly answer: string;
+    }, null>;
+    readonly 'read.builds': Asked<{
+        readonly build: string;
+    }, null>;
 }
 export type RuntimeKind = keyof RuntimeRequests;
 export type RuntimeRequest<K extends RuntimeKind = RuntimeKind> = {
@@ -383,6 +409,8 @@ export interface RuntimeDatabase {
 export declare function isRuntime(request: {
     readonly kind: string;
 }): request is RuntimeRequest;
-export declare function readsRuntime(request: RuntimeRequest): boolean;
+export declare function readsRuntime(request: {
+    readonly kind: string;
+}): boolean;
 export declare function answerRuntime(connection: Connection, request: RuntimeRequest, spool: FileSpool): unknown;
 //# sourceMappingURL=tables.d.ts.map