@agentshouse/mdruntime 0.1.0-cb2e390ee7b89 → 0.1.0-cb3bb3b233fa1

package/dist/lifecycle.js

@@ -0,0 +1,282 @@
+import { catchUpConversations, receiveConversationEvent, reconcileConversations, } from './conversation.js';
+import { declared } from './declaration.js';
+import { uncaught } from './failure.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 { roomsListed } from './room-list.js';
+import { moveTo, recoverReads, rest, SERVICE_MODE_TOPIC, show, submissionDue, transferring, } from './shown.js';
+import { applyRoom, changeAuthority, countAuthorityChange, finishOpening, loadRoom, OPENING_LANE, reload, resynchronize, sync, } from './sync.js';
+const CONVERSATION_LANE = 'conversations';
+const RELOADING = 'reloading';
+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, presence, conversations } = runtime;
+    const { session } = socket;
+    socket.notifyReady();
+    presence.stopAsking();
+    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, presence } = runtime;
+    const reloading = presence
+        .rooms()
+        .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, reloading);
+    return reloading;
+}
+async function reloadNow(runtime, among, replacing, progress, held, installing) {
+    const { store, socket, presence } = runtime;
+    const { lanes } = socket;
+    const discovered = among === null ? presence.rooms() : among.flatMap((locator) => presence.room(locator) ?? []);
+    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)
+        presence.reload(room.locator, 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));
+        }
+        runtime.retries.succeeded('download', RELOADING);
+    }
+    catch (error) {
+        runtime.retries.failed('download', RELOADING, error);
+        for (const room of reloaded)
+            presence.reload(room.locator, false);
+        progress.reachable = false;
+    }
+}
+function caughtUpRooms(runtime, expired) {
+    const { store, socket, presence } = 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 among = progress === null ? expired : null;
+    const installing = store.installs.underway(among);
+    const held = among === null ? store.rooms() : store.rooms(among);
+    const reloading = progress === null
+        ? Promise.resolve([])
+        : held.then((stored) => owedReloads(runtime, expired, stored));
+    const replacing = Promise.all([held, reloading]).then(([stored, owed]) => reloadNow(runtime, among, (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, new Map(presence
+                    .rooms()
+                    .filter((room) => stored.has(room.locator) &&
+                    !expired.includes(room.locator) &&
+                    !owed.includes(room.locator))
+                    .map((room) => [room.locator, declared(room)])), 'current', local);
+            }
+            runtime.retries.succeeded('download', OPENING_LANE);
+        }
+        catch (error) {
+            runtime.retries.failed('download', OPENING_LANE, error);
+            progress.complete = false;
+            progress.reachable = false;
+        }
+        if (live())
+            await finishOpening(runtime, progress, live);
+    });
+}
+function signalled(runtime, mode) {
+    const { store, socket } = 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([]);
+        store.tell(SERVICE_MODE_TOPIC, mode);
+    }
+    if (releasing)
+        void submissionDue(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 reconcileConversations(conversations);
+    if (conversations.current()) {
+        await rest(runtime, null, live);
+        return;
+    }
+    const progress = {
+        complete: false,
+        reachable: !session.now().moving.providerUnreachable,
+    };
+    moveTo(runtime, transferring(runtime));
+    try {
+        await catchUpConversations(conversations, progress);
+        runtime.retries.succeeded('conversations', CONVERSATION_LANE);
+    }
+    catch (error) {
+        runtime.retries.failed('conversations', CONVERSATION_LANE, error);
+        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 } = runtime;
+    store.prepareAgain();
+    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, presence, conversations, recovery, liveQueries, figures, }) {
+    if (socket.closed())
+        return;
+    socket.close();
+    presence.close();
+    conversations.close();
+    void recovery.retire();
+    liveQueries.close();
+    figures.close();
+    store.close();
+}
+export async function stop(runtime) {
+    const { store, socket, presence, recovery } = runtime;
+    socket.session.set({ stopping: true });
+    presence.stopAsking();
+    socket.stopReads();
+    await recovery.retire();
+    await socket.lanes.finished();
+    await store.written();
+    close(runtime);
+}
+export function start(runtime, signal) {
+    const { store, socket, presence, 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([]);
+        receiveConversationEvent(conversations, 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') {
+            presence.connectionLive();
+            conversations.reopened();
+            lastAnswers.reopened();
+            recovery.resume();
+        }
+        else if (event.kind === 'discovered') {
+            const listed = roomsListed(runtime, event.discovery.roomList);
+            if (event.missed)
+                countAuthorityChange(runtime, listed);
+            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 === 'reported')
+            lastAnswers.again();
+        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((error) => {
+        socket.readyFromStore();
+        uncaught(error);
+    });
+    if (!socket.streamed)
+        void sync(runtime, 'unstreamed', null);
+}

package/dist/listing.d.ts

@@ -0,0 +1,52 @@
+import type { HeldRooms } from '@agentshouse/mdmodel';
+import type { DiscoveredRoom, HeldRoom, OperationScopes, ProviderRefusal, ReplicaAdmission, RoomDeclaration } from './adapter.js';
+import type { Composition } from './collection.js';
+import type { KeyedChange } from './observation.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 { 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[];
+    authoredPaths: readonly string[];
+    roomVersion: string | null;
+    documents: number;
+    synchronizationAvailable: boolean;
+    refusal: ProviderRefusal | null;
+    locked: boolean;
+};
+type ListedRoom = Omit<AppRoom, 'documents' | 'locked'>;
+export type ListedEntry = ListedRoom & {
+    readonly documents: number;
+};
+export type Listing = ReadonlyMap<string, ListedEntry>;
+export type RoomsChange = KeyedChange<string, AppRoom>;
+export declare function modelIn({ socket, presence }: Runtime, locator: string, stored: Stored | undefined): ModelState;
+export declare function compositionFor(runtime: Runtime, record: ReplicaRecord): Composition;
+export declare function declarationOf({ presence }: Runtime, locator: string, stored: Stored | undefined): {
+    readonly room: RoomDeclaration;
+    readonly available: boolean;
+} | undefined;
+export declare function listedLocators({ presence }: Runtime, held: ReadonlyMap<string, unknown>): string[];
+export declare function listedOrHeld({ presence }: Runtime, held: ReadonlyMap<string, unknown>, locator: string): boolean;
+export declare function listedEntries(runtime: Runtime, touched: readonly string[]): Promise<readonly ListedEntry[] | null>;
+export declare function listingNow(runtime: Runtime): Promise<Listing>;
+export declare function shownRooms(runtime: Runtime, listing: Listing): readonly AppRoom[];
+export declare function shownChange(runtime: Runtime, entries: readonly ListedEntry[]): RoomsChange;
+export declare function roomFacts(runtime: Runtime, reach?: PortReach | null): Promise<HeldRooms>;
+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,152 @@
+import { declared } from './declaration.js';
+import { modelTypes, NO_MODEL } from './model.js';
+import { governs, holds } from './reach.js';
+export function modelIn({ socket, presence }, locator, stored) {
+    if (socket.session.now().refusal?.code === 'revoked-authorization')
+        return { status: 'unavailable', reason: 'revoked' };
+    return stored?.record.model ?? presence.unheldModel(locator) ?? 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({ presence }, locator, stored) {
+    const listed = presence.room(locator);
+    const room = stored?.record.declaration ?? (listed === undefined ? undefined : declared(listed));
+    if (room === undefined)
+        return undefined;
+    return {
+        room,
+        available: presence.available(locator, stored?.record.declaration.replica.selection),
+    };
+}
+export function listedLocators({ presence }, held) {
+    const listed = presence.rooms().map(({ locator }) => locator);
+    return [...new Set([...listed, ...held.keys()])];
+}
+export function listedOrHeld({ presence }, held, locator) {
+    return presence.room(locator) !== undefined || held.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;
+    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,
+        authoredPaths: room.authoredPaths,
+        roomVersion: stored?.record.roomVersion ?? null,
+        synchronizationAvailable: available,
+        refusal: runtime.presence.refusal(locator),
+        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 listedEntries(runtime, touched) {
+    const { store } = runtime;
+    if (store.roomsShown.now() === null)
+        return null;
+    if (touched.length === 0)
+        return [];
+    const held = await store.rooms(touched);
+    const entries = [];
+    for (const locator of touched) {
+        const room = listedRoom(runtime, locator, held.get(locator));
+        if (room === undefined || store.roomsShown.now()?.has(locator) !== true)
+            return null;
+        entries.push(room);
+    }
+    return entries;
+}
+export async function listingNow(runtime) {
+    return listingOf(runtime, await runtime.store.rooms());
+}
+function shownRoom({ presence }, { documents, ...room }) {
+    return presence.lockedAs(room.locator, room.replica.offline)
+        ? {
+            ...room,
+            model: modelTypes(NO_MODEL),
+            typedSelection: null,
+            documents: 0,
+            locked: true,
+        }
+        : { ...room, documents, locked: false };
+}
+export function shownRooms(runtime, listing) {
+    return structuredClone([...listing.values()].map((entry) => shownRoom(runtime, entry)));
+}
+export function shownChange(runtime, entries) {
+    return {
+        changed: structuredClone(entries.map((entry) => [entry.locator, shownRoom(runtime, entry)])),
+        removed: [],
+        order: null,
+    };
+}
+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 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.declaration.replica.selection !== room.replica.selection)
+            return [];
+        return [{ locator: room.locator, roomVersion: record.roomVersion }];
+    });
+}
+export async function name(runtime, locator) {
+    const { socket, presence } = runtime;
+    const room = presence.room(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,25 @@
+import type { ChangeSet } from './change-set.js';
+import { type KeyedResult, type QueryMessage } from './observation.js';
+import type { PendingResult, PendingRoom, 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>;
+export type PendingAt<H> = (held: H, rooms: readonly string[]) => ReadonlyMap<string, PendingRoom | null> | null;
+type Listener = (message: QueryMessage) => void;
+export type LiveQueries<H> = {
+    touched(set: ChangeSet): void;
+    recover(locators?: readonly string[]): void;
+    watch(plan: Plan, identity: string, cover: (held: H) => Cover, pendingAt: PendingAt<H>, deliver: Listener, failed: Fail): () => void;
+    close(): void;
+};
+export declare function readerOf(plan: Plan): (locator: string) => boolean;
+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,EAQL,KAAK,WAAW,EAChB,KAAK,YAAY,EAClB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAClF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAGvC,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,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CACzB,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,SAAS,MAAM,EAAE,KACrB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;AAEpD,KAAK,QAAQ,GAAG,CAAC,OAAO,EAAE,YAAY,KAAK,IAAI,CAAC;AAiBhD,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAC3B,OAAO,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IAC9B,OAAO,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAC5C,KAAK,CACH,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,KAAK,EACzB,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EACvB,OAAO,EAAE,QAAQ,EACjB,MAAM,EAAE,IAAI,GACX,MAAM,IAAI,CAAC;IACd,KAAK,IAAI,IAAI,CAAC;CACf,CAAC;AAWF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAQjE;AAeD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CA4JxF"}