@agentshouse/mdruntime 0.1.0-ce5c5bb29be5a → 0.1.0-ce6bc9239a3ee

package/dist/install.d.ts

@@ -0,0 +1,86 @@
+import type { AdapterFailure, Authorization, DiscoveredRoom, NotReady, RetryableRefusal, TypedPath } from './adapter.js';
+import { attachedModel } from './attached-model.js';
+import { type Reads } from './bootstrap.js';
+import type { ChangeSet } from './change-set.js';
+import type { ChangeBatch } from './change.js';
+import type { Log } from './log.js';
+import { type ModelState } from './model.js';
+import type { Installation, RoomCoverage } from './readiness.js';
+import { advancement, type Refresher } from './refresh.js';
+import type { ReplicaRecord } from './replica.js';
+import type { RuntimeSocket } from './socket.js';
+import { type CoveredRoom, type InstallHold, type RoomCommit, type RuntimeStore, type Store, type View, type Work } from './store.js';
+import { type Unconfirmed } from './transfer.js';
+export type Live = () => boolean;
+type Standing = {
+    readonly key: number | null;
+    readonly confirmed: number;
+};
+export type Unheld = {
+    readonly staged: boolean;
+};
+export type Withheld = AdapterFailure | RetryableRefusal | NotReady | Unconfirmed;
+type Settling = {
+    readonly room?: boolean;
+    readonly view?: View;
+    readonly commit?: Pick<RoomCommit, 'published' | 'refreshed'>;
+};
+type Landing = {
+    readonly kind: 'refreshed';
+    readonly from: Standing;
+    readonly remodelled: boolean;
+} | {
+    readonly kind: 'bootstrapped';
+    readonly refreshed: boolean;
+    readonly from: Standing;
+};
+type Refreshed = {
+    kind: 'advanced';
+    record: ReplicaRecord;
+    from: Standing;
+    remodelled: boolean;
+} | Exclude<Awaited<ReturnType<typeof advancement>>, {
+    kind: 'advanced';
+}>;
+export type Installer = {
+    readonly store: Store;
+    readonly socket: RuntimeSocket;
+    readonly journal: Log;
+    readonly roomTypes: Parameters<typeof attachedModel>[1];
+    readonly builtIn: ModelState;
+    readonly typedPaths: readonly TypedPath[];
+    unheldModel(locator: string): ModelState | undefined;
+    recover(): void;
+    queueReadiness(): void;
+    sweep(): void;
+    settle(local: RuntimeStore, locator: string, work: Work, record: ReplicaRecord, queue: readonly ChangeBatch[], settling: Settling): Promise<ChangeSet>;
+    readied(locator: string): void;
+    modelKept(locator: string): void;
+    name(locator: string): Promise<void>;
+    usable(room: DiscoveredRoom): void;
+    publishChangeSet(set: ChangeSet): Promise<void>;
+    unpair(local: RuntimeStore): Promise<void>;
+    statusShown(): Promise<void>;
+    submitLater(locator: string): void;
+};
+type Showing = Pick<Installer, 'store' | 'socket'>;
+export declare function installationOf(store: Store, coverage: readonly RoomCoverage[], held: ReadonlyMap<string, CoveredRoom>): Installation;
+export declare function roomInFlight(store: Store, locator: string): boolean;
+export declare function forgetInstall(store: Store, locator: string): void;
+export declare function caughtUpTo(installer: Installer, locator: string): void;
+export declare function catching(store: Store, locator: string): void;
+export declare function confirmedAgain(store: Store, locator: string): void;
+export declare function standingAt(store: Store, locator: string, held: Pick<ReplicaRecord, 'key'> | undefined): Standing;
+export declare function showing(system: Showing, locator: string, roomVersion: string, held: string | undefined): void;
+export declare function olderThan(system: Showing, locator: string, roomVersion: string, held: string | undefined): boolean;
+export declare function replaced(store: Store, locators: readonly string[]): void;
+export declare function reachedBy({ store, socket }: Installer, locator: string, roomVersion: string): Promise<boolean>;
+export declare function behind({ store, socket }: Installer, room: DiscoveredRoom): Promise<boolean>;
+export declare function writtenAfter({ store, socket }: Installer, locator: string, roomVersion: string, path: string): Promise<boolean>;
+export declare function pullRefresh(installer: Installer, authorized: Authorization, record: ReplicaRecord, liveness: Live, hold: InstallHold, refresh: Refresher): Promise<Refreshed>;
+export declare function pullBootstrap(installer: Installer, authorized: Authorization, room: DiscoveredRoom, local: RuntimeStore, liveness: Live, prior: ReplicaRecord | undefined, from?: Reads, unheld?: Unheld): Promise<import("./bootstrap.js").Bootstrapped | NotReady | import("./adapter.js").RevokedAuthorization | import("./adapter.js").RoomNotReadable | Unconfirmed | {
+    readonly kind: 'transport-uncertainty';
+} | RetryableRefusal | import("./adapter.js").ScopedRefusal>;
+export declare function publish(installer: Installer, local: RuntimeStore, room: DiscoveredRoom, reached: ReplicaRecord, landing: Landing, live: Live): Promise<boolean>;
+export {};
+//# sourceMappingURL=install.d.ts.map

package/dist/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../src/install.ts"],"names":[],"mappings":"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"}

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 { NO_MODEL } from './model.js';
+import { advancement } from './refresh.js';
+import { NO_INSTALL, } from './store.js';
+import { unconfirmed } from './transfer.js';
+import { ROW_WEIGHT } 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 };
+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;
+}
+export function installationOf(store, coverage, held) {
+    const rooms = { done: 0, total: 0 };
+    const bytes = { done: 0, total: 0 };
+    let installing = 0;
+    let downloading = false;
+    for (const { room, state } of coverage) {
+        if (state === 'unadmitted')
+            continue;
+        rooms.total += 1;
+        if (state === 'complete')
+            rooms.done += 1;
+        const install = store.installs.of(room);
+        const underway = state === 'acquiring' || (install.installing && state !== 'complete');
+        if (underway)
+            installing += 1;
+        if (underway && (install.streaming || install.arrived === null))
+            downloading = true;
+        const kept = underway ? NOTHING_HELD.bytes : (held.get(room)?.bytes ?? NOTHING_HELD.bytes);
+        const now = amountOf(install, kept);
+        const earlier = underway ? install.startedOver : null;
+        bytes.done += Math.max(now.done, earlier?.done ?? 0);
+        bytes.total += Math.max(now.total, earlier?.total ?? 0);
+    }
+    const step = installing === 0
+        ? null
+        : downloading
+            ? 'downloading'
+            : bytes.done < bytes.total
+                ? 'writing'
+                : 'replaying';
+    return { step, rooms, bytes };
+}
+export function roomInFlight(store, locator) {
+    const { catching, transfer } = store.installs.of(locator);
+    return catching || transfer !== null;
+}
+function installing(installer, locator) {
+    installer.store.installs.change(locator, (held) => ({ ...held, installing: true }));
+    installer.queueReadiness();
+}
+function installed(installer, locator) {
+    if (!installer.store.installs.of(locator).installing)
+        return;
+    installer.store.installs.change(locator, (held) => ({ ...held, installing: false }));
+    installer.queueReadiness();
+}
+export function forgetInstall(store, locator) {
+    store.installs.change(locator, ({ installing }) => ({ ...NO_INSTALL, installing }));
+}
+export function caughtUpTo(installer, locator) {
+    if (!installer.store.installs.of(locator).catching)
+        return;
+    installer.store.installs.change(locator, (held) => ({ ...held, catching: false }));
+    installer.recover();
+}
+export function catching(store, locator) {
+    store.installs.change(locator, (held) => ({ ...held, catching: true }));
+}
+export function confirmedAgain(store, locator) {
+    store.installs.change(locator, (held) => ({
+        ...held,
+        confirmations: held.confirmations + 1,
+    }));
+}
+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(installer, locator, roomVersion) {
+    const { store } = installer;
+    if (store.installs.of(locator).beyondHorizon)
+        return false;
+    return olderThan(installer, 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(installer, local, locator, key, paths, roomVersion, heldAt) {
+    if (paths.length === 0)
+        return new Set();
+    const { reached } = installer.socket.reads;
+    const behindShown = heldAt === undefined
+        ? await older(installer, locator, roomVersion)
+        : olderThan(installer, 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(installer, answers, held) {
+    const answer = answers?.collection;
+    if (answer === undefined)
+        return held;
+    return { collection: attachedModel(answer, installer.roomTypes) };
+}
+function refreshingOf(installer, local, locator, key, composition, liveness, replaying = false, heldAt) {
+    const { store } = installer;
+    const write = replaying ? store.finishingWrite : store.exclusive;
+    return {
+        turn() {
+            if (replaying)
+                installing(installer, locator);
+        },
+        prior: async (paths) => new Map((await local.entries(key, 'refreshed', paths)).map((entry) => [entry.path, entry])),
+        later: (paths, roomVersion) => writtenLater(installer, 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(installer, authorized, record, liveness, hold, refresh) {
+    if (!liveness())
+        return unconfirmed;
+    const { store, journal } = installer;
+    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(installer, models, kept) : kept), liveness, refreshingOf(installer, local, record.locator, record.key, store.composed(record), liveness, false, record.roomVersion));
+        if (result.kind !== 'advanced') {
+            journal.record(`transfer refresh ${record.locator} ${result.kind}`);
+            return result;
+        }
+        journal.record(`transfer refresh ${record.locator} ${result.record.roomVersion}`);
+        return {
+            kind: 'advanced',
+            record: result.record,
+            from,
+            remodelled: result.record.model !== record.model,
+        };
+    }
+    catch (error) {
+        if (refusedForSpace(error))
+            return unconfirmed;
+        journal.record(`transfer refresh ${record.locator} transport-uncertainty`);
+        throw error;
+    }
+}
+async function abandoned(installer, local, locator) {
+    await local.abandon(locator);
+    installer.store.installs.change(locator, (held) => transferGone(setBack(held)));
+    installer.recover();
+    installer.sweep();
+}
+function staging(installer, local, liveness, unheld) {
+    const { store, socket } = installer;
+    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));
+            installer.queueReadiness();
+            if (done.done)
+                return true;
+        }
+    };
+    return {
+        held: (locator) => store.installs.of(locator).transfer,
+        async turn(locator, step) {
+            installing(installer, 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,
+                    }));
+                    if (!store.installs.arrivalDue(performance.now(), ARRIVAL_REPORT_MS))
+                        return;
+                    installer.queueReadiness();
+                },
+                end() {
+                    if (ended)
+                        return;
+                    ended = true;
+                    if (!store.installs.of(locator).streaming)
+                        return;
+                    store.installs.change(locator, (held) => ({ ...held, streaming: false }));
+                    installer.queueReadiness();
+                },
+            };
+        },
+        streamed: socket.streamed,
+        async stage(record, page, composition) {
+            const { locator } = record;
+            installing(installer, 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,
+            }));
+            if (before.transfer === null)
+                installer.recover();
+            installing(installer, locator);
+            installer.recover();
+            if (owed < store.deriveBytes())
+                return held;
+            return (await derived(locator, key, composition)) ? held : null;
+        },
+        async resume(record, parts, composition) {
+            const { locator } = record;
+            installing(installer, locator);
+            if (!liveness())
+                return null;
+            const prior = unheld === undefined ? await store.record(locator) : undefined;
+            const published = prior !== undefined && prior.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 }));
+            installer.recover();
+            return { record: held, staged: parted };
+        },
+        derive: derived,
+        async refreshing(locator, key, composition) {
+            await store.exclusive(() => local.unrefresh(key));
+            return refreshingOf(installer, local, locator, key, composition, liveness, true);
+        },
+        abandon: (locator) => store.exclusive(async () => {
+            if (liveness())
+                await abandoned(installer, local, locator);
+        }),
+        setAside: async (locator) => {
+            if (!liveness())
+                return;
+            store.installs.change(locator, (held) => transferGone(setBack(held)));
+            installer.recover();
+        },
+        release: (key) => store.exclusive(async () => {
+            await local.release(key);
+            installer.sweep();
+        }),
+    };
+}
+export async function pullBootstrap(installer, authorized, room, local, liveness, prior, from = installer.socket.reads, unheld) {
+    if (!liveness())
+        return unconfirmed;
+    const { store, journal } = installer;
+    if (prior !== undefined) {
+        catching(store, room.locator);
+        installer.recover();
+    }
+    try {
+        const result = await bootstrapRoom(from, authorized, room, { collection: prior?.model ?? installer.unheldModel(room.locator) ?? NO_MODEL }, installer.builtIn, installer.typedPaths, (models, held) => (liveness() ? remodel(installer, models, held) : held), liveness, staging(installer, local, liveness, unheld));
+        const detail = result.kind === 'staged' ? result.record.roomVersion : result.kind;
+        journal.record(`transfer bootstrap ${room.locator} ${detail}`);
+        if (result.kind === 'staged' &&
+            (await older(installer, room.locator, result.record.roomVersion))) {
+            caughtUpTo(installer, room.locator);
+            installed(installer, room.locator);
+            await abandoned(installer, local, room.locator);
+            journal.record(`transfer bootstrap ${room.locator} older than shown`);
+            return { kind: 'transport-uncertainty' };
+        }
+        if (result.kind !== 'staged') {
+            caughtUpTo(installer, room.locator);
+            installed(installer, room.locator);
+        }
+        return result;
+    }
+    catch (error) {
+        caughtUpTo(installer, room.locator);
+        installed(installer, room.locator);
+        if (refusedForSpace(error))
+            return unconfirmed;
+        journal.record(`transfer bootstrap ${room.locator} transport-uncertainty`);
+        throw error;
+    }
+}
+export function publish(installer, local, room, reached, landing, live) {
+    const { store } = installer;
+    const landed = store.exclusive(async () => {
+        if (!live()) {
+            caughtUpTo(installer, room.locator);
+            return true;
+        }
+        const work = await store.work(room.locator);
+        const prior = work.replica;
+        if (!standsAt(store, room.locator, prior?.record, landing.from)) {
+            if (landing.kind === 'refreshed') {
+                await local.unrefresh(reached.key);
+                return false;
+            }
+            caughtUpTo(installer, room.locator);
+            await abandoned(installer, local, room.locator);
+            return false;
+        }
+        const record = landing.kind === 'refreshed' && prior !== undefined
+            ? {
+                ...prior.record,
+                roomVersion: reached.roomVersion,
+                ...(landing.remodelled ? { model: reached.model } : {}),
+            }
+            : reached;
+        let set;
+        try {
+            set = await installer.settle(local, room.locator, work, record, work.queue, landing.kind === 'refreshed'
+                ? {
+                    room: true,
+                    view: 'refreshed',
+                    commit: { refreshed: true },
+                }
+                : {
+                    room: true,
+                    view: landing.refreshed ? 'refreshed' : 'confirmed',
+                    commit: {
+                        published: { from: prior?.record.key ?? null },
+                        ...(landing.refreshed ? { refreshed: true } : {}),
+                    },
+                });
+        }
+        catch (error) {
+            if (!refusedForSpace(error))
+                throw error;
+            caughtUpTo(installer, room.locator);
+            return true;
+        }
+        if (landing.kind === 'bootstrapped') {
+            installer.readied(room.locator);
+            store.installs.change(room.locator, (held) => ({
+                ...transferGone(held),
+                highest: null,
+                beyondHorizon: false,
+                startedOver: null,
+                catching: false,
+            }));
+            installer.modelKept(room.locator);
+            if (prior !== undefined && prior.record.key !== record.key)
+                installer.sweep();
+            void installer.name(room.locator);
+        }
+        installer.usable(room);
+        void installer.publishChangeSet(set);
+        await installer.unpair(local);
+        void installer.statusShown();
+        if (landing.kind === 'bootstrapped' && work.queue.length > 0) {
+            installer.submitLater(room.locator);
+        }
+        return true;
+    });
+    return landing.kind === 'refreshed'
+        ? landed
+        : landed.finally(() => installed(installer, room.locator));
+}

package/dist/job.d.ts

@@ -0,0 +1,33 @@
+type Job = {
+    readonly label: string;
+    readonly kind: 'started' | 'scheduled' | 'ended';
+    readonly state: string;
+    readonly next: string | null;
+};
+export type RunningJob = {
+    readonly name: string;
+    readonly running_since: string;
+};
+export type JobMarker = {
+    readonly said: string;
+    readonly at: string;
+};
+export type OpenJob<At = string | null> = {
+    readonly name: string;
+    readonly started: At;
+};
+export declare function jobOf(said: string): Job;
+export declare function closeLast(open: {
+    readonly key: string;
+}[], key: string): void;
+export declare function markerMoved<Kept extends {
+    readonly key: string;
+}>(open: Kept[], said: string, opened: (job: Job, key: string) => Kept | null): void;
+export declare function openJobs<At>(markers: readonly {
+    readonly said: string;
+    readonly at: At;
+}[]): readonly OpenJob<At>[];
+export declare function jobsRunning(jobs: readonly RunningJob[], now: number): string[];
+export declare function sessionEnded(jobs: readonly RunningJob[], now: number): string;
+export {};
+//# sourceMappingURL=job.d.ts.map

package/dist/job.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job.d.ts","sourceRoot":"","sources":["../src/job.ts"],"names":[],"mappings":"AAAA,KAAK,GAAG,GAAG;IACT,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,WAAW,GAAG,OAAO,CAAC;IACjD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvE,MAAM,MAAM,OAAO,CAAC,EAAE,GAAG,MAAM,GAAG,IAAI,IAAI;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,EAAE,CAAA;CAAE,CAAC;AAQ1F,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CASvC;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAG7E;AAED,wBAAgB,WAAW,CAAC,IAAI,SAAS;IAAE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,EAC/D,IAAI,EAAE,IAAI,EAAE,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,GAC7C,IAAI,CASN;AAED,wBAAgB,QAAQ,CAAC,EAAE,EACzB,OAAO,EAAE,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAA;CAAE,EAAE,GAC7D,SAAS,OAAO,CAAC,EAAE,CAAC,EAAE,CAQxB;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAM9E;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,UAAU,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAI7E"}