@dsh-workbench/shared 0.2.9 → 0.2.11

package/dist/components/icons.js

@@ -32,6 +32,19 @@ export function IconModules({ size = 16 }) {
         h("rect", { x: "2.5", y: "8.9", width: "4.6", height: "4.6", rx: "1.2", stroke: "currentColor", strokeWidth: "1.2" }),
         h("rect", { x: "8.9", y: "8.9", width: "4.6", height: "4.6", rx: "1.2", stroke: "currentColor", strokeWidth: "1.2" })));
 }
+export function IconModuleMark({ size = 16 }) {
+    return (h(Shell, { size: size, viewBox: "0 0 24 24" },
+        h("defs", null,
+            h("linearGradient", { id: "workbench-module-mark", x1: "0%", y1: "0%", x2: "100%", y2: "100%" },
+                h("stop", { offset: "0%", stopColor: "#3b82f6" }),
+                h("stop", { offset: "55%", stopColor: "#8b5cf6" }),
+                h("stop", { offset: "100%", stopColor: "#14b8a6" }))),
+        h("rect", { width: 24, height: 24, rx: 7, fill: "url(#workbench-module-mark)" }),
+        h("rect", { x: "4.6", y: "4.6", width: "6.2", height: "6.2", rx: "1.9", fill: "#ffffff" }),
+        h("rect", { x: "13.2", y: "4.6", width: "6.2", height: "6.2", rx: "1.9", fill: "#ffffff", fillOpacity: 0.78 }),
+        h("rect", { x: "4.6", y: "13.2", width: "6.2", height: "6.2", rx: "1.9", fill: "#ffffff", fillOpacity: 0.78 }),
+        h("rect", { x: "13.2", y: "13.2", width: "6.2", height: "6.2", rx: "1.9", fill: "#ffffff" })));
+}
 export function IconPanelScreen({ size = 16 }) {
     return (h("svg", { width: size, height: size, viewBox: "0 0 1024 1024", fill: "currentColor", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": "true", style: { display: 'block', overflow: 'hidden' } },
         h("path", { d: "M939 112c17.673 0 32 14.327 32 32v554.667c0 17.673-14.327 32-32 32l-394.5-0.001v96c0 3.74-0.642 7.331-1.82 10.668H768.4c17.673 0 32 14.326 32 32 0 17.496-14.042 31.712-31.47 31.995l-0.53 0.004H256.6c-17.673 0-32-14.327-32-32 0-17.496 14.042-31.713 31.47-31.995l0.53-0.005h225.721a31.923 31.923 0 0 1-1.817-10.137l-0.004-0.53v-96H86c-17.496 0-31.713-14.041-31.996-31.47l-0.004-0.53V144c0-17.673 14.327-32 32-32z m-32 64H118v490.666h789V176zM341.9 432c17.496 0 31.713 14.042 31.996 31.47l0.004 0.53v85.333c0 17.673-14.327 32-32 32-17.496 0-31.713-14.041-31.996-31.47l-0.004-0.53V464c0-17.673 14.327-32 32-32z m170.6-85.333c17.496 0 31.713 14.041 31.996 31.47l0.004 0.53v170.666c0 17.673-14.327 32-32 32-17.496 0-31.713-14.041-31.996-31.47l-0.004-0.53V378.667c0-17.673 14.327-32 32-32z m170.6-85.334c17.496 0 31.713 14.042 31.996 31.471l0.004 0.53v256c0 17.672-14.327 32-32 32-17.496 0-31.713-14.042-31.996-31.471l-0.004-0.53v-256c0-17.673 14.327-32 32-32z" })));

package/dist/host/__tests__/fakes.d.ts

@@ -0,0 +1,41 @@
+import type { DshShell } from '../../api/dsh.js';
+import type { Opencli } from '../../host/opencli.js';
+export interface ShellCall {
+    command: string;
+    workdir?: string;
+    timeoutMs?: number;
+    onExpiry?: string;
+    stdoutMaxBytes?: number;
+}
+export interface ShellReply {
+    stdout?: string;
+    stderr?: string;
+    exitCode?: number | null;
+    timedOut?: boolean;
+    aborted?: boolean;
+    failWith?: Error;
+}
+export declare function createFakeShell(replies?: ShellReply[] | ((call: ShellCall, index: number) => ShellReply)): {
+    shell: DshShell;
+    calls: ShellCall[];
+    peak: () => number;
+    commands: () => string[];
+};
+export interface OpencliCall {
+    args: readonly string[];
+    key?: string;
+    workdir?: string;
+    refresh?: boolean;
+}
+export declare function createFakeOpencli(replies?: Array<unknown | Error> | ((call: OpencliCall, index: number) => unknown | Error)): {
+    opencli: Opencli;
+    calls: OpencliCall[];
+    keys: () => (string | undefined)[];
+};
+export declare function createFakeLogger(): {
+    logger: {
+        info: () => void;
+        warn: (message: string) => void;
+    };
+    warnings: string[];
+};

package/dist/host/__tests__/fakes.js

@@ -0,0 +1,76 @@
+import { setTimeout as delay } from 'node:timers/promises';
+const tick = () => delay(0);
+export function createFakeShell(replies = []) {
+    const calls = [];
+    let running = 0;
+    let peak = 0;
+    const replyAt = (index) => typeof replies === 'function' ? replies(calls[index], index) : (replies[index] ?? {});
+    const shell = {
+        resolve(request) {
+            calls.push(request);
+            return request;
+        },
+        async execute() {
+            const index = calls.length - 1;
+            const reply = replyAt(index);
+            if (reply.failWith !== undefined)
+                throw reply.failWith;
+            running += 1;
+            peak = Math.max(peak, running);
+            return {
+                async result() {
+                    await tick();
+                    running -= 1;
+                    return {
+                        exitCode: reply.exitCode ?? 0,
+                        timedOut: reply.timedOut ?? false,
+                        aborted: reply.aborted ?? false,
+                        stdout: { text: reply.stdout ?? '', truncated: false },
+                        stderr: { text: reply.stderr ?? '', truncated: false },
+                    };
+                },
+            };
+        },
+    };
+    return {
+        shell,
+        calls,
+        peak: () => peak,
+        commands: () => calls.map((call) => call.command),
+    };
+}
+export function createFakeOpencli(replies = []) {
+    const calls = [];
+    const opencli = {
+        async json(args, options = {}) {
+            const call = {
+                args,
+                ...(options.key === undefined ? {} : { key: options.key }),
+                ...(options.workdir === undefined ? {} : { workdir: options.workdir }),
+            };
+            calls.push(call);
+            const index = calls.length - 1;
+            const reply = typeof replies === 'function' ? replies(call, index) : (replies[index] ?? []);
+            if (reply instanceof Error)
+                throw reply;
+            return { value: reply, at: Date.now() };
+        },
+    };
+    return {
+        opencli,
+        calls,
+        keys: () => calls.map((call) => call.key),
+    };
+}
+export function createFakeLogger() {
+    const warnings = [];
+    return {
+        logger: {
+            info: () => { },
+            warn: (message) => {
+                warnings.push(message);
+            },
+        },
+        warnings,
+    };
+}

package/dist/host/__tests__/preflight-fixtures.d.ts

@@ -0,0 +1,19 @@
+import { createFakeShell } from './fakes';
+export declare const GOOD_BRIDGE_REPORT: string;
+export declare const ALL_OK: {
+    stdout: string;
+}[];
+export declare const STALE_DAEMON_BRIDGE: string;
+export declare const BROKEN_BRIDGE: string;
+export declare function build(replies: Parameters<typeof createFakeShell>[0], install?: () => Promise<{
+    ok: boolean;
+    detail: string;
+}>, warmReads?: () => readonly (readonly string[])[]): {
+    fake: {
+        shell: import("../..").DshShell;
+        calls: import("./fakes").ShellCall[];
+        peak: () => number;
+        commands: () => string[];
+    };
+    preflight: import("../preflight").Preflight;
+};

package/dist/host/__tests__/preflight-fixtures.js

@@ -0,0 +1,47 @@
+import { createPreflight } from '../preflight';
+import { createFakeShell } from './fakes';
+export const GOOD_BRIDGE_REPORT = [
+    'opencli v1.8.7 doctor (node v24.15.0)',
+    '',
+    '[OK] Daemon: running on port 19825 (v1.8.7)',
+    '[OK] Extension: connected (v1.0.24)',
+    '[OK] Connectivity: connected in 0.0s',
+    '',
+    'Everything looks good!',
+].join('\n');
+export const ALL_OK = [{ stdout: '1.8.8\n' }, { stdout: GOOD_BRIDGE_REPORT }];
+export const STALE_DAEMON_BRIDGE = [
+    'opencli v1.8.7 doctor (node v24.15.0)',
+    '',
+    '[STALE] Daemon: running on port 19825 (v1.8.8 != CLI v1.8.7)',
+    '[OK] Extension: connected (v1.0.24)',
+    '[OK] Connectivity: connected in 0.0s',
+    '',
+    'Issues:',
+    '  • Stale daemon detected: daemon v1.8.8 != CLI v1.8.7.',
+    '  Run: opencli daemon restart',
+].join('\n');
+export const BROKEN_BRIDGE = [
+    'opencli v1.8.7 doctor (node v24.15.0)',
+    '',
+    '[MISSING] Daemon: not running',
+    '[MISSING] Extension: not connected',
+    '[FAIL] Connectivity: failed (daemon not reachable)',
+    '',
+    'Issues:',
+    "  • Daemon is not running. It should start automatically when you run an opencli browser command.",
+    '  • Daemon is running but the Chrome/Chromium extension is not connected.',
+    'If the extension is not installed:',
+    '  1. Download from https://github.com/jackwener/opencli/releases',
+    '  2. Open chrome://extensions/ → Enable Developer Mode',
+    '  3. Click "Load unpacked" → select the extension folder',
+].join('\n');
+export function build(replies, install, warmReads) {
+    const fake = createFakeShell(replies);
+    const preflight = createPreflight({
+        shell: fake.shell,
+        ...(install === undefined ? {} : { install }),
+        ...(warmReads === undefined ? {} : { warmReads }),
+    });
+    return { fake, preflight };
+}

package/dist/host/context-inject.d.ts

@@ -0,0 +1,24 @@
+import { type ContextRef } from '@dsh-workbench/shared';
+import type { ContextRenderer } from './unit-face';
+export declare const CONTEXT_SOURCE_KIND = "workbench";
+export interface ScannableMessage {
+    readonly source?: {
+        readonly kind?: string;
+    };
+    readonly content?: readonly {
+        readonly type?: string;
+        readonly text?: string;
+    }[];
+}
+export type { ContextRenderer };
+export declare function collectContextRefs(messages: readonly ScannableMessage[]): ContextRef[];
+export declare function buildContextMessage(text: string, summary: string): unknown;
+export interface ContextInjector {
+    inject(messages: readonly ScannableMessage[], agent: unknown): Promise<unknown | undefined>;
+}
+export declare function createContextInjector(options: {
+    renderers: ReadonlyMap<string, ContextRenderer>;
+    logger?: {
+        warn?(message: string): void;
+    } | undefined;
+}): ContextInjector;

package/dist/host/context-inject.js

@@ -0,0 +1,74 @@
+import { randomUUID } from 'node:crypto';
+import { encodeRef, parseMarkers } from '@dsh-workbench/shared';
+export const CONTEXT_SOURCE_KIND = 'workbench';
+export function collectContextRefs(messages) {
+    const seen = new Set();
+    const refs = [];
+    for (const message of messages) {
+        if (message.source?.kind !== 'user')
+            continue;
+        for (const block of message.content ?? []) {
+            if (block.type !== 'text' || typeof block.text !== 'string')
+                continue;
+            for (const ref of parseMarkers(block.text)) {
+                const key = encodeRef(ref);
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                refs.push(ref);
+            }
+        }
+    }
+    return refs;
+}
+export function buildContextMessage(text, summary) {
+    return {
+        role: 'user',
+        id: randomUUID(),
+        content: [{ type: 'text', text }],
+        source: { kind: CONTEXT_SOURCE_KIND, form: 'notice', summary },
+    };
+}
+export function createContextInjector(options) {
+    const done = new WeakMap();
+    return {
+        async inject(messages, agent) {
+            const refs = collectContextRefs(messages);
+            if (refs.length === 0)
+                return undefined;
+            const key = typeof agent === 'object' && agent !== null ? agent : undefined;
+            const seen = key === undefined ? undefined : (done.get(key) ?? new Set());
+            if (key !== undefined && seen !== undefined)
+                done.set(key, seen);
+            const fresh = [];
+            for (const ref of refs) {
+                const encoded = encodeRef(ref);
+                if (seen?.has(encoded) === true)
+                    continue;
+                seen?.add(encoded);
+                fresh.push(ref);
+            }
+            if (fresh.length === 0)
+                return undefined;
+            const texts = [];
+            for (const ref of fresh) {
+                const render = options.renderers.get(ref.kind);
+                if (render === undefined)
+                    continue;
+                let text;
+                try {
+                    text = await render(ref);
+                }
+                catch (error) {
+                    options.logger?.warn?.(`[dsh-workbench] 渲染对话引用失败：${String(error)}`);
+                    text = `工作台面板引用了一条内容（${encodeRef(ref)}），但当前渲染不出来（项目未选中或数据源不可用）。`;
+                }
+                if (text !== '')
+                    texts.push(text);
+            }
+            if (texts.length === 0)
+                return undefined;
+            return buildContextMessage(texts.join('\n\n'), `工作台引用：${fresh.length} 条`);
+        },
+    };
+}

package/dist/host/events.d.ts

@@ -0,0 +1,9 @@
+import type { DshHostContext, DshRequest, DshResponse } from '@dsh-workbench/shared';
+import type { FactLog } from './facts';
+export interface FactStream {
+    handler(req: DshRequest, res: DshResponse): void;
+    closeAll(): void;
+    size(): number;
+}
+export declare function createFactStream(log: FactLog): FactStream;
+export declare function registerFactStream(ctx: DshHostContext, log: FactLog): () => void;

package/dist/host/events.js

@@ -0,0 +1,70 @@
+import { EVENTS_PATH } from '@dsh-workbench/shared';
+const HEARTBEAT_MS = 25_000;
+function frame(payload) {
+    return `data: ${JSON.stringify(payload)}\n\n`;
+}
+export function createFactStream(log) {
+    const connections = new Set();
+    const cleanups = new Map();
+    const drop = (res) => {
+        cleanups.get(res)?.();
+        cleanups.delete(res);
+        connections.delete(res);
+    };
+    return {
+        size: () => connections.size,
+        closeAll() {
+            for (const res of [...connections]) {
+                drop(res);
+                res.end?.();
+            }
+        },
+        handler(req, res) {
+            if (req.method !== undefined && req.method !== 'GET') {
+                res.statusCode = 405;
+                res.end();
+                return;
+            }
+            const url = req.url ?? '/';
+            const cut = url.indexOf('?');
+            const since = Number(new URLSearchParams(cut === -1 ? '' : url.slice(cut + 1)).get('since') ?? 0) || 0;
+            const opening = log.since(since);
+            if (typeof res.write !== 'function') {
+                res.statusCode = 200;
+                res.setHeader('content-type', 'application/json; charset=utf-8');
+                res.end(JSON.stringify({ ok: true, ...opening }));
+                return;
+            }
+            const headers = {
+                'content-type': 'text/event-stream; charset=utf-8',
+                'cache-control': 'no-store, no-transform',
+                connection: 'keep-alive',
+            };
+            if (typeof res.writeHead === 'function')
+                res.writeHead(200, headers);
+            else {
+                res.statusCode = 200;
+                for (const [name, value] of Object.entries(headers))
+                    res.setHeader(name, value);
+            }
+            res.write(': connected\n\n');
+            res.write(frame({ type: 'sync', ...opening }));
+            connections.add(res);
+            const timer = setInterval(() => res.write?.(': ping\n\n'), HEARTBEAT_MS);
+            const unsubscribe = log.subscribe((change) => res.write?.(frame({ type: 'bump', ...change })));
+            cleanups.set(res, () => {
+                clearInterval(timer);
+                unsubscribe();
+            });
+            res.on?.('close', () => drop(res));
+        },
+    };
+}
+export function registerFactStream(ctx, log) {
+    const stream = createFactStream(log);
+    const unregister = ctx.webServer.register({ kind: 'exact', path: EVENTS_PATH, handler: stream.handler });
+    return () => {
+        stream.closeAll();
+        unregister();
+    };
+}

package/dist/host/mount-units.d.ts

@@ -0,0 +1,52 @@
+import type { DshHostContext } from '@dsh-workbench/shared';
+import type { UnitManifest } from '@dsh-workbench/shared';
+import { type RouteTable } from './http';
+import type { ContextRenderer, UnitHostFace, UnitMountDeps, UnitMountResult, UnitCall } from './unit-face';
+import { type UnitReadiness } from './unit-readiness';
+export interface MountedUnit {
+    readonly face: UnitHostFace;
+    readonly result: UnitMountResult;
+    readonly readiness: UnitReadiness;
+}
+export interface UnitsPlan {
+    readonly mounted: readonly MountedUnit[];
+    readonly routes: RouteTable;
+    readonly gate: UnitMountResult['gate'];
+    readonly prefs: ReadonlyArray<{
+        readonly resource: string;
+        readonly unit: string;
+        handle(payload: unknown): unknown;
+    }>;
+    readonly actions: ReadonlyArray<{
+        readonly resource: string;
+        readonly unit: string;
+        handle(payload: unknown): unknown;
+    }>;
+    readonly provision: UnitMountResult['provision'];
+    readonly contextRenderers: ReadonlyMap<string, ContextRenderer>;
+    readonly owners: ReadonlyMap<string, string>;
+    readonly routesOfUnit: ReadonlyMap<string, readonly string[]>;
+    readonly factsOf: ReadonlyMap<string, (call: UnitCall) => readonly string[] | undefined>;
+    readonly skipped: ReadonlyArray<{
+        readonly id: string;
+        readonly missing: readonly string[];
+    }>;
+    readonly warmReads: () => readonly (readonly string[])[];
+    readonly disposeLongTasks: () => void;
+}
+export declare function mountUnits(faces: readonly UnitHostFace[], deps: {
+    ctx: DshHostContext;
+    logger?: {
+        info?(m: string): void;
+        warn?(m: string): void;
+    } | undefined;
+    manifests: () => readonly UnitManifest[];
+    opencliCommand?: string;
+    probe?: UnitMountDeps['probe'];
+    store?: UnitMountDeps['store'];
+    values?: UnitMountDeps['values'];
+    longTasks?: {
+        readonly scope: string;
+        readonly bump: (facts: readonly string[]) => void;
+    } | undefined;
+}): UnitsPlan;

package/dist/host/mount-units.js

@@ -0,0 +1,186 @@
+import { runsRouteOf } from '@dsh-workbench/shared';
+import { param } from './http';
+import { createLongTaskHost } from './long-task';
+import { unitReadiness } from './unit-readiness';
+import { createWorkspaceStore } from './workspace-store';
+function withRunsRoute(result, unit) {
+    const runs = result.longTasks;
+    if (runs === undefined)
+        return result;
+    return {
+        ...result,
+        routes: {
+            ...result.routes,
+            [runsRouteOf(unit)]: (search) => {
+                const path = (param(search, 'path') ?? '').trim();
+                return { ok: true, runs: path === '' ? [] : runs.current(path) };
+            },
+        },
+    };
+}
+function collectRoutes(mounted) {
+    const routes = {};
+    const owner = new Map();
+    const routesOfUnit = new Map();
+    for (const item of mounted) {
+        const unit = item.face.manifest.id;
+        for (const [key, handler] of Object.entries(item.result.routes)) {
+            if (key !== unit && !key.startsWith(`${unit}/`)) {
+                throw new Error(`路由名要住在自己那一格的命名空间里（${unit} 或 ${unit}/…）：${key} 不属于 ${unit} —— ` +
+                    `装 / 升 / 卸时点名不到它，那个模块的数据会停在旧值`);
+            }
+            const previous = owner.get(key);
+            if (previous !== undefined) {
+                throw new Error(`路由名冲突：${key} 由套件 ${previous} 与 ${unit} 同时声明`);
+            }
+            owner.set(key, unit);
+            routes[key] = handler;
+            const own = routesOfUnit.get(unit);
+            if (own === undefined)
+                routesOfUnit.set(unit, [key]);
+            else
+                own.push(key);
+        }
+    }
+    return { routes, owners: owner, routesOfUnit };
+}
+function pickGate(mounted) {
+    const providers = mounted.filter((item) => item.result.gate !== undefined);
+    if (providers.length > 1) {
+        throw new Error(`启停闸门只能有一个提供者，现在是：${providers.map((item) => item.face.manifest.id).join('、')}`);
+    }
+    return providers[0]?.result.gate;
+}
+function pickProvision(mounted) {
+    const providers = mounted.filter((item) => item.result.provision !== undefined);
+    if (providers.length > 1) {
+        throw new Error(`机器供给只能有一个提供者，现在是：${providers.map((item) => item.face.manifest.id).join('、')}`);
+    }
+    return providers[0]?.result.provision;
+}
+function collectPrefs(mounted) {
+    const owner = new Map();
+    const prefs = [];
+    for (const item of mounted) {
+        const entry = item.result.prefs;
+        if (entry === undefined)
+            continue;
+        const previous = owner.get(entry.resource);
+        if (previous !== undefined) {
+            throw new Error(`偏好资源名冲突：${entry.resource} 由套件 ${previous} 与 ${item.face.manifest.id} 同时声明`);
+        }
+        owner.set(entry.resource, item.face.manifest.id);
+        prefs.push({ ...entry, unit: item.face.manifest.id });
+    }
+    return prefs;
+}
+function collectActions(mounted) {
+    const owner = new Map();
+    const actions = [];
+    for (const item of mounted) {
+        for (const entry of item.result.actions ?? []) {
+            const previous = owner.get(entry.resource);
+            if (previous !== undefined) {
+                throw new Error(`动作资源名冲突：${entry.resource} 由套件 ${previous} 与 ${item.face.manifest.id} 同时声明`);
+            }
+            owner.set(entry.resource, item.face.manifest.id);
+            actions.push({ ...entry, unit: item.face.manifest.id });
+        }
+    }
+    return actions;
+}
+function collectWarmReads(mounted) {
+    const declarations = mounted
+        .map((item) => item.result.warmReads)
+        .filter((declare) => declare !== undefined);
+    return () => {
+        const seen = new Set();
+        const reads = [];
+        for (const read of declarations.flatMap((declare) => declare())) {
+            const key = read.join(' ');
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            reads.push(read);
+        }
+        return reads;
+    };
+}
+function collectContextRenderers(mounted) {
+    const table = new Map();
+    const owner = new Map();
+    for (const item of mounted) {
+        const context = item.result.context;
+        if (context === undefined)
+            continue;
+        for (const kind of context.kinds) {
+            const previous = owner.get(kind);
+            if (previous !== undefined) {
+                throw new Error(`对话引用的 kind 冲突：${kind} 由套件 ${previous} 与 ${item.face.manifest.id} 同时认领`);
+            }
+            owner.set(kind, item.face.manifest.id);
+            table.set(kind, (ref) => context.render(ref));
+        }
+    }
+    return table;
+}
+export function mountUnits(faces, deps) {
+    const store = deps.store ?? createWorkspaceStore({ root: null });
+    const mounted = [];
+    const skipped = [];
+    const longTaskDisposers = [];
+    for (const face of faces) {
+        const readiness = unitReadiness(face.manifest, (dep) => deps.ctx.get(dep));
+        if (!readiness.canMount) {
+            skipped.push({ id: face.manifest.id, missing: readiness.missingHard });
+            continue;
+        }
+        const unit = face.manifest.id;
+        const longTasks = deps.longTasks === undefined
+            ? undefined
+            : createLongTaskHost({ scope: deps.longTasks.scope, unit, bump: deps.longTasks.bump });
+        if (longTasks !== undefined)
+            longTaskDisposers.push(longTasks.dispose);
+        const result = face.mount({
+            ctx: deps.ctx,
+            logger: deps.logger,
+            manifests: deps.manifests,
+            ...(deps.opencliCommand === undefined ? {} : { opencliCommand: deps.opencliCommand }),
+            ...(deps.probe === undefined ? {} : { probe: deps.probe }),
+            ...(deps.values === undefined ? {} : { values: deps.values }),
+            ...(longTasks === undefined ? {} : { longTasks: longTasks.host }),
+            store,
+        });
+        mounted.push({ face, readiness, result: withRunsRoute(result, unit) });
+    }
+    const collected = collectRoutes(mounted);
+    const prefs = collectPrefs(mounted);
+    const actions = collectActions(mounted);
+    const owners = new Map(collected.owners);
+    for (const entry of [...prefs, ...actions])
+        owners.set(entry.resource, entry.unit);
+    const factsOf = new Map();
+    for (const item of mounted) {
+        const declare = item.result.factsOf;
+        if (declare !== undefined)
+            factsOf.set(item.face.manifest.id, declare);
+    }
+    return {
+        mounted,
+        routes: collected.routes,
+        owners,
+        routesOfUnit: collected.routesOfUnit,
+        factsOf,
+        gate: pickGate(mounted),
+        prefs,
+        actions,
+        provision: pickProvision(mounted),
+        contextRenderers: collectContextRenderers(mounted),
+        skipped,
+        warmReads: collectWarmReads(mounted),
+        disposeLongTasks: () => {
+            for (const dispose of longTaskDisposers.splice(0))
+                dispose();
+        },
+    };
+}