@agentshouse/mdruntime 0.1.0-cdb8840578a20 → 0.1.0-cdded6c080913

package/dist/lifecycle.js

@@ -0,0 +1,267 @@
+import { submitAll } from './acceptance.js';
+import { catching, replaced } from './install.js';
+import { connectionLost } from './locks.js';
+import { fenceLive } from './lost.js';
+import { cachedModels, revoked, settleModels } from './models.js';
+import { refuse } from './refusal.js';
+import { moveTo, recoverReads, rest, SERVICE_MODE_TOPIC, show, transferring } from './shown.js';
+import { applyRoom, changeAuthority, countAuthorityChange, finishOpening, loadRoom, OPENING_LANE, reload, resynchronize, sync, } from './sync.js';
+const CONVERSATION_LANE = 'conversations';
+function closing(runtime, opened) {
+    const { store, socket } = runtime;
+    return socket.lanes.task(OPENING_LANE, async (live) => {
+        if (!live())
+            return;
+        const local = await store.open();
+        if (!opened && !socket.isOpen())
+            await cachedModels(runtime, local);
+        await rest(runtime, null, live);
+    });
+}
+function closedSocket(runtime, lapsed, lost, opened) {
+    const { socket, conversations } = runtime;
+    const { session } = socket;
+    socket.notifyReady();
+    socket.rooms.unreadied();
+    connectionLost(runtime);
+    if (lost)
+        conversations.lost();
+    if (lapsed) {
+        void refuse(runtime, 'revoked-authorization');
+        return;
+    }
+    session.set({ complete: false });
+    const { streamed, moving } = session.now();
+    if (streamed !== null)
+        streamed.complete = false;
+    moveTo(runtime, {
+        ...moving,
+        state: moving.state === 'synced' ? 'syncing' : moving.state,
+        providerUnreachable: moving.providerUnreachable || (!opened && lost),
+    });
+    void closing(runtime, opened);
+}
+function owedReloads(runtime, expired, held) {
+    const { store, socket } = runtime;
+    const reloading = socket.rooms
+        .discoveredRooms()
+        .filter((room) => !expired.includes(room.locator) && revoked(held.get(room.locator)?.record.model))
+        .map((room) => room.locator);
+    for (const locator of reloading)
+        catching(store, locator);
+    recoverReads(runtime);
+    return reloading;
+}
+async function reloadNow(runtime, replacing, progress, held, installing) {
+    const { store, socket } = runtime;
+    const { rooms, lanes } = socket;
+    const discovered = rooms.discoveredRooms();
+    const reloaded = discovered.filter((room) => held.has(room.locator) && !installing.has(room.locator) && replacing(room));
+    const acquired = discovered.filter((room) => (!held.has(room.locator) || installing.has(room.locator)) &&
+        room.replica.admission === 'admitted' &&
+        replacing(room));
+    for (const room of reloaded)
+        rooms.stand(room.locator, { reloadDue: true });
+    try {
+        const local = await store.open();
+        const kept = acquired.length === 0 ? new Set() : (await local.held()).staged;
+        for (const room of reloaded) {
+            void lanes
+                .roomTask(room.locator, (live) => reload(runtime, room, local, progress, live))
+                .then(() => rest(runtime, progress));
+        }
+        for (const room of acquired) {
+            const unheld = installing.has(room.locator) ? undefined : { staged: kept.has(room.locator) };
+            void lanes
+                .roomTask(room.locator, (live) => loadRoom(runtime, room, local, progress, live, unheld))
+                .then(() => rest(runtime, progress));
+        }
+    }
+    catch {
+        for (const room of reloaded)
+            rooms.stand(room.locator, { reloadDue: false });
+        progress.reachable = false;
+    }
+}
+function caughtUpRooms(runtime, expired) {
+    const { store, socket } = runtime;
+    const { session } = socket;
+    const progress = session.now().underway;
+    session.set({ underway: null });
+    socket.named();
+    const cycle = progress ?? { complete: true, reachable: true };
+    replaced(store, expired);
+    const installing = store.installs.underway();
+    const held = progress === null ? store.rooms(expired) : store.rooms();
+    const reloading = progress === null
+        ? Promise.resolve([])
+        : held.then((stored) => owedReloads(runtime, expired, stored));
+    const replacing = Promise.all([held, reloading]).then(([stored, owed]) => reloadNow(runtime, (room) => expired.includes(room.locator) || owed.includes(room.locator), cycle, stored, installing));
+    return socket.lanes.task(OPENING_LANE, async (live) => {
+        if (!live())
+            return;
+        if (progress === null) {
+            await replacing;
+            await rest(runtime, cycle, live);
+            return;
+        }
+        try {
+            const local = await store.open();
+            await replacing;
+            if (progress.reachable) {
+                const stored = await held;
+                const owed = await reloading;
+                await settleModels(runtime, socket.rooms
+                    .discoveredRooms()
+                    .filter((room) => stored.has(room.locator) &&
+                    !expired.includes(room.locator) &&
+                    !owed.includes(room.locator)), 'current', local);
+            }
+        }
+        catch {
+            progress.complete = false;
+            progress.reachable = false;
+        }
+        if (live())
+            await finishOpening(runtime, progress, live);
+    });
+}
+function signalled(runtime, mode) {
+    const { store, socket, journal } = runtime;
+    const { session } = socket;
+    const { closed, serviceMode, haltedRefusal, openSignals } = session.now();
+    if (closed)
+        return;
+    if (mode === 'open')
+        session.set({ openSignals: openSignals + 1 });
+    const releasing = mode === 'open' && (haltedRefusal || serviceMode === 'write-halted');
+    if (mode === 'open')
+        session.set({ haltedRefusal: false });
+    if (mode !== serviceMode) {
+        session.set({ serviceMode: mode });
+        store.readiness.queue();
+        journal.record(`service mode ${mode}`);
+        store.tell(SERVICE_MODE_TOPIC, mode);
+    }
+    if (releasing)
+        submitAll(runtime);
+}
+async function runCurrency(runtime, live) {
+    const { socket, conversations } = runtime;
+    const { session } = socket;
+    if (session.now().currencyQueued === socket.generation())
+        session.set({ currencyQueued: null });
+    if (!live())
+        return;
+    await conversations.reconcile();
+    if (conversations.current()) {
+        show(runtime);
+        return;
+    }
+    const progress = {
+        complete: false,
+        reachable: !session.now().moving.providerUnreachable,
+    };
+    moveTo(runtime, transferring(runtime));
+    try {
+        await conversations.catchUp(progress);
+    }
+    catch {
+        progress.reachable = false;
+    }
+    await rest(runtime, progress, live);
+}
+export function scheduleCurrency(runtime) {
+    const { socket } = runtime;
+    const { session } = socket;
+    if (session.now().currencyQueued === socket.generation() || socket.closed() || socket.stopping())
+        return;
+    session.set({ currencyQueued: socket.generation() });
+    void socket.lanes.task(CONVERSATION_LANE, (live) => runCurrency(runtime, live));
+}
+export function spaceFreed(runtime) {
+    const { store, socket, journal } = runtime;
+    socket.rooms.standAll({ unpreparable: false });
+    journal.record('space freed');
+    store.readiness.queue();
+    const { closed, authorization } = socket.session.now();
+    if (closed || authorization === undefined)
+        return;
+    if (!socket.streamed)
+        void sync(runtime, 'unstreamed', null);
+    else
+        void resynchronize(runtime);
+}
+export function close({ store, socket, conversations, recovery, liveQueries, figures }) {
+    if (socket.closed())
+        return;
+    socket.close();
+    conversations.close();
+    void recovery.retire();
+    liveQueries.close();
+    figures.close();
+    store.close();
+}
+export async function stop(runtime) {
+    const { store, socket, recovery } = runtime;
+    socket.session.set({ stopping: true });
+    socket.rooms.unreadied();
+    socket.stopReads();
+    await recovery.retire();
+    await socket.lanes.finished();
+    await store.written();
+    close(runtime);
+}
+export function start(runtime, signal) {
+    const { store, socket, conversations, lastAnswers, recovery } = runtime;
+    const closeRuntime = () => close(runtime);
+    socket.observeServiceMode((mode) => signalled(runtime, mode));
+    socket.observeConversations((event) => {
+        if (event.kind === 'list' || event.kind === 'listed' || event.kind === 'unlisted')
+            store.readiness.queue();
+        conversations.receive(event);
+        if (event.kind !== 'gap' || conversations.current())
+            return;
+        show(runtime);
+        scheduleCurrency(runtime);
+    });
+    signal?.addEventListener('abort', closeRuntime, { once: true });
+    if (signal?.aborted)
+        closeRuntime();
+    socket.observe((event) => {
+        if (event.kind === 'opened') {
+            socket.rooms.connectionLive();
+            conversations.reopened();
+            lastAnswers.reopened();
+            recovery.resume();
+        }
+        else if (event.kind === 'discovered') {
+            if (event.missed)
+                countAuthorityChange(runtime);
+            void sync(runtime, 'opened', event.discovery);
+        }
+        else if (event.kind === 'closed') {
+            closedSocket(runtime, event.revoked, event.lost, event.opened);
+        }
+        else if (event.kind === 'caught-up')
+            void caughtUpRooms(runtime, event.expired);
+        else if (event.kind === 'authority-changed') {
+            if (socket.isAnnounced() && socket.isOpen())
+                fenceLive(runtime, event.left);
+            void changeAuthority(runtime, event);
+        }
+        else
+            void applyRoom(runtime, event);
+    });
+    void store
+        .open()
+        .then(async (local) => {
+        if ((await local.facts()).capabilities.length > 0)
+            socket.readyFromStore();
+    })
+        .catch(() => {
+        socket.readyFromStore();
+    });
+    if (!socket.streamed)
+        void sync(runtime, 'unstreamed', null);
+}

package/dist/listing.d.ts

@@ -0,0 +1,53 @@
+import type { HeldRooms } from '@agentshouse/mdmodel';
+import type { DiscoveredRoom, HeldRoom, OperationScopes, ProviderRefusal, ReplicaAdmission } from './adapter.js';
+import type { Composition } from './collection.js';
+import { type ModelState, type TypesResult } from './model.js';
+import { type PortReach } from './reach.js';
+import type { ReplicaRecord } from './replica.js';
+import type { Runtime } from './runtime.js';
+import type { RoomDeclaration } from './socket.js';
+import type { Stored } from './store.js';
+export type AppTypedSelection = {
+    roots: readonly string[];
+    model: TypesResult;
+};
+export type AppRoom = {
+    name: string;
+    locator: string;
+    handle: string;
+    operations: OperationScopes;
+    replica: ReplicaAdmission;
+    model: TypesResult;
+    typedSelection: AppTypedSelection | null;
+    providerOwnedPaths: readonly string[];
+    roomVersion: string | null;
+    documents: number;
+    synchronizationAvailable: boolean;
+    refusal: ProviderRefusal | null;
+    locked: boolean;
+};
+type ListedRoom = Omit<AppRoom, 'documents' | 'locked'>;
+type ListedEntry = ListedRoom & {
+    readonly documents: number;
+};
+export type Listing = ReadonlyMap<string, ListedEntry>;
+export declare function modelIn({ socket }: Runtime, locator: string, stored: Stored | undefined): ModelState;
+export declare function compositionFor(runtime: Runtime, record: ReplicaRecord): Composition;
+export declare function declarationOf({ socket }: Runtime, locator: string, stored: Stored | undefined): {
+    readonly room: RoomDeclaration;
+    readonly available: boolean;
+} | undefined;
+export declare function listedLocators({ store, socket }: Runtime, held: ReadonlyMap<string, unknown>): string[];
+export declare function patchedListing(runtime: Runtime, changed: ReadonlySet<string>): Promise<Listing | null>;
+export declare function listingNow(runtime: Runtime): Promise<Listing>;
+export declare function shownRooms(runtime: Runtime, listing: Listing): readonly AppRoom[];
+export declare function roomFacts(runtime: Runtime, reach?: PortReach | null): Promise<HeldRooms>;
+export declare function list({ store, socket }: Runtime, room: RoomDeclaration, synchronizationAvailable: boolean): void;
+export declare function listHeld({ store, socket }: Runtime, locator: string): void;
+export declare function admitted({ socket }: Runtime, room: RoomDeclaration): boolean;
+export declare function readable(runtime: Runtime, room: DiscoveredRoom): void;
+export declare function usable(runtime: Runtime, room: DiscoveredRoom): void;
+export declare function heldRooms({ store }: Runtime, listed: readonly DiscoveredRoom[]): Promise<HeldRoom[]>;
+export declare function name(runtime: Runtime, locator: string): Promise<void>;
+export {};
+//# sourceMappingURL=listing.d.ts.map

package/dist/listing.d.ts.map

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

package/dist/listing.js

@@ -0,0 +1,175 @@
+import { modelTypes, NO_MODEL } from './model.js';
+import { governs, holds } from './reach.js';
+export function modelIn({ socket }, locator, stored) {
+    if (socket.session.now().refusal?.code === 'revoked-authorization')
+        return { status: 'unavailable', reason: 'revoked' };
+    return stored?.record.model ?? socket.rooms.standing(locator).unheldModel ?? NO_MODEL;
+}
+export function compositionFor(runtime, record) {
+    return runtime.store.composed({
+        ...record,
+        model: modelIn(runtime, record.locator, { record, indexed: true, documents: 0 }),
+    });
+}
+export function declarationOf({ socket }, locator, stored) {
+    const held = socket.rooms.declared(locator);
+    const room = stored?.record ?? held?.room ?? socket.rooms.discovered(locator);
+    return room === undefined ? undefined : { room, available: held?.available ?? true };
+}
+export function listedLocators({ store, socket }, held) {
+    const declared = socket.rooms.declarations();
+    return [
+        ...declared.keys(),
+        ...[...held.keys()].filter((locator) => !declared.has(locator)),
+    ].filter((locator) => !store.fences.has(locator));
+}
+function selectionModel({ socket, builtIn }) {
+    return socket.session.now().refusal?.code === 'revoked-authorization'
+        ? { status: 'unavailable', reason: 'revoked' }
+        : builtIn;
+}
+function listedRoom(runtime, locator, stored) {
+    const declaration = declarationOf(runtime, locator, stored);
+    if (declaration === undefined)
+        return undefined;
+    const { room, available } = declaration;
+    const selection = room.typedSelection ?? null;
+    return {
+        name: room.name,
+        locator,
+        handle: room.handle,
+        operations: room.operations,
+        replica: room.replica,
+        model: modelTypes(modelIn(runtime, locator, stored)),
+        typedSelection: selection === null
+            ? null
+            : { roots: selection.roots, model: modelTypes(selectionModel(runtime)) },
+        providerOwnedPaths: room.providerOwnedPaths,
+        roomVersion: stored?.record.roomVersion ?? null,
+        synchronizationAvailable: available,
+        refusal: runtime.socket.rooms.standing(locator).refusal,
+        documents: stored?.documents ?? 0,
+    };
+}
+function listingOf(runtime, held) {
+    const listing = new Map();
+    for (const locator of listedLocators(runtime, held)) {
+        const room = listedRoom(runtime, locator, held.get(locator));
+        if (room !== undefined)
+            listing.set(locator, room);
+    }
+    return listing;
+}
+export async function patchedListing(runtime, changed) {
+    const { store } = runtime;
+    const { roomsShown } = store.device.now();
+    if (roomsShown === null)
+        return null;
+    const held = await store.rooms([...changed]);
+    const listing = new Map(roomsShown);
+    for (const locator of changed) {
+        const room = store.fences.has(locator)
+            ? undefined
+            : listedRoom(runtime, locator, held.get(locator));
+        if (room === undefined || !listing.has(locator))
+            return null;
+        listing.set(locator, room);
+    }
+    return listing;
+}
+export async function listingNow(runtime) {
+    return listingOf(runtime, await runtime.store.rooms());
+}
+function lockedIn({ socket }, listing, locator) {
+    return (listing.get(locator)?.replica.offline === 'locked' && !socket.rooms.standing(locator).confirmed);
+}
+export function shownRooms(runtime, listing) {
+    return structuredClone([...listing.values()].map(({ documents, ...room }) => lockedIn(runtime, listing, room.locator)
+        ? {
+            ...room,
+            model: modelTypes(NO_MODEL),
+            typedSelection: null,
+            documents: 0,
+            locked: true,
+        }
+        : { ...room, documents, locked: false }));
+}
+export async function roomFacts(runtime, reach = null) {
+    const { store, socket, builtIn } = runtime;
+    const held = await store.rooms();
+    const rooms = [...listingOf(runtime, held).values()]
+        .filter((room) => holds(reach, room.locator))
+        .map((room) => {
+        const governed = governs(reach, room);
+        const attached = [
+            ...(governed.collection ? [modelIn(runtime, room.locator, held.get(room.locator))] : []),
+            ...(governed.selection ? [builtIn] : []),
+        ];
+        return {
+            locator: room.locator,
+            available: attached.every((model) => model.status !== 'unavailable'),
+            types: attached.flatMap((model) => model.status === 'unavailable' ? [] : Object.values(model.types)),
+        };
+    });
+    return { listed: socket.session.now().roomsListed, rooms };
+}
+export function list({ store, socket }, room, synchronizationAvailable) {
+    if (store.fences.has(room.locator))
+        return;
+    socket.rooms.declare(room.locator, {
+        room: {
+            name: room.name,
+            locator: room.locator,
+            handle: room.handle,
+            operations: room.operations,
+            replica: room.replica,
+            typedSelection: room.typedSelection ?? null,
+            providerOwnedPaths: room.providerOwnedPaths,
+        },
+        available: synchronizationAvailable,
+    });
+}
+export function listHeld({ store, socket }, locator) {
+    if (store.fences.has(locator))
+        return;
+    socket.rooms.declare(locator, { room: null, available: false });
+}
+export function admitted({ socket }, room) {
+    return room.replica.admission === 'admitted' && !socket.rooms.standing(room.locator).unreadable;
+}
+export function readable(runtime, room) {
+    runtime.socket.rooms.stand(room.locator, { unreadable: false });
+    list(runtime, room, true);
+}
+export function usable(runtime, room) {
+    const { rooms } = runtime.socket;
+    rooms.stand(room.locator, { stale: false, unpreparable: false });
+    if (rooms.standing(room.locator).unreadable) {
+        rooms.stand(room.locator, { unreadable: false, refusal: null });
+    }
+    list(runtime, room, true);
+}
+export async function heldRooms({ store }, listed) {
+    const stored = await store.rooms(listed.map((room) => room.locator));
+    return listed.flatMap((room) => {
+        const record = stored.get(room.locator)?.record;
+        if (record === undefined) {
+            return room.replica.admission === 'admitted'
+                ? [{ locator: room.locator, roomVersion: null }]
+                : [];
+        }
+        if (record.replica.selection !== room.replica.selection)
+            return [];
+        return [{ locator: room.locator, roomVersion: record.roomVersion }];
+    });
+}
+export async function name(runtime, locator) {
+    const { socket } = runtime;
+    const room = socket.rooms.discovered(locator);
+    if (!socket.streamed || room === undefined || !socket.isOpen() || !socket.isHanded())
+        return;
+    const [held] = await heldRooms(runtime, [room]);
+    if (held === undefined || !socket.isOpen() || !socket.isHanded())
+        return;
+    socket.name(held);
+}

package/dist/live.d.ts

@@ -0,0 +1,23 @@
+import type { ChangeSet } from './change-set.js';
+import { type KeyedResult, type QueryMessage } from './observation.js';
+import type { PendingResult, Plan, QueryCoverage } from './query.js';
+import type { Fail } from './reach.js';
+import type { QueryRoom } from './tables.js';
+export type Cover = {
+    coverage: QueryCoverage;
+    rooms: readonly QueryRoom[];
+} | PendingResult;
+export type Ran = KeyedResult & {
+    readonly current: () => boolean;
+};
+export type Run = (plan: Plan, cover: () => Promise<Cover>) => Promise<Ran>;
+type Listener = (message: QueryMessage) => void;
+export type LiveQueries<H> = {
+    touched(set: ChangeSet): void;
+    recover(): void;
+    watch(plan: Plan, identity: string, cover: (held: H) => Cover, deliver: Listener, failed: Fail): () => void;
+    close(): void;
+};
+export declare function createLiveQueries<H>(run: Run, holding: () => Promise<H>): LiveQueries<H>;
+export {};
+//# sourceMappingURL=live.d.ts.map

package/dist/live.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live.d.ts","sourceRoot":"","sources":["../src/live.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,YAAY,EAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACrE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,MAAM,KAAK,GAAG;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAA;CAAE,GAAG,aAAa,CAAC;AAE7F,MAAM,MAAM,GAAG,GAAG,WAAW,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAA;CAAE,CAAC;AAEpE,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC,GAAG,CAAC,CAAC;AAE5E,KAAK,QAAQ,GAAG,CAAC,OAAO,EAAE,YAAY,KAAK,IAAI,CAAC;AAchD,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAC3B,OAAO,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IAC9B,OAAO,IAAI,IAAI,CAAC;IAChB,KAAK,CACH,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,KAAK,EACzB,OAAO,EAAE,QAAQ,EACjB,MAAM,EAAE,IAAI,GACX,MAAM,IAAI,CAAC;IACd,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AAmCF,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CA4HxF"}