@abot-ai/runtime 1.6.0 → 1.8.0

package/dist/src/web-ui/plugin-removal-error.d.ts

@@ -0,0 +1,7 @@
+import { PluginManagementError } from "./plugin-management-service.js";
+import type { RuntimeSetupActivation } from "./local-runtime/runtime-setup-input.js";
+/** Keep confirmed activation evidence when the later file removal fails. */
+export declare class PluginRemovalActivationError extends PluginManagementError {
+    readonly activation: RuntimeSetupActivation;
+    constructor(error: unknown, activation: RuntimeSetupActivation);
+}

package/dist/src/web-ui/plugin-removal-error.js

@@ -0,0 +1,16 @@
+import { ConfigFileConflictError } from "../runtime/adapters/config-file-transaction.js";
+import { PluginManagementError } from "./plugin-management-service.js";
+/** Keep confirmed activation evidence when the later file removal fails. */
+export class PluginRemovalActivationError extends PluginManagementError {
+    activation;
+    constructor(error, activation) {
+        const known = error instanceof PluginManagementError ||
+            error instanceof ConfigFileConflictError;
+        const status = error instanceof PluginManagementError ? error.statusCode : 500;
+        super(known ? error.code : "plugin_removal_failed", known
+            ? error.message
+            : "Plugin removal could not complete. Refresh plugins before trying again.", error instanceof ConfigFileConflictError ? 409 : status);
+        this.activation = activation;
+        this.cause = error;
+    }
+}

package/dist/src/web-ui/plugin-removal-service.d.ts

@@ -0,0 +1,31 @@
+import type { RuntimeSetupActivation } from "./local-runtime/runtime-setup-input.js";
+import { type PluginManagementOptions } from "./plugin-management-service.js";
+export type PluginRemovalRuntime = {
+    applyConfiguration: (expectedRevision: string) => Promise<RuntimeSetupActivation>;
+    requireInactive: (pluginId: string, capabilityIds: readonly string[]) => void;
+};
+/** Disable, activate at the owner, then remove while configuration writers are fenced. */
+export declare function removeRuntimePlugin(options: PluginManagementOptions & PluginRemovalRuntime, input: unknown): Promise<{
+    removed: boolean;
+    activation: Readonly<{
+        status: "ready" | "restart_required";
+        message?: string;
+    }>;
+    message: string;
+    selection: import("../runtime/plugins/selection.js").PluginSelection;
+    plugins: Array<{
+        id: string;
+        description?: string;
+        version?: string;
+        pluginEnabled: boolean;
+        compatibility: ReturnType<typeof import("../runtime/plugins/platform-compatibility.js").resolvePluginPlatformCompatibility>;
+        removable: boolean;
+        configurable: boolean;
+        capabilities: import("./plugin-management-catalog.js").RuntimePluginCapabilitySnapshot[];
+        capabilityCount: number;
+        selectedCapabilityCount: number;
+        state: "enabled" | "partial" | "disabled";
+        blockedByGlobalPolicy: boolean;
+    }>;
+    application: "restart_required";
+}>;

package/dist/src/web-ui/plugin-removal-service.js

@@ -0,0 +1,109 @@
+import { realpathSync, renameSync } from "node:fs";
+import { mkdtemp, rm, rmdir } from "node:fs/promises";
+import { join } from "node:path";
+import { ABOT_RUNTIME_EXTENSION } from "../plugin-contract/manifest.js";
+import { withConfigFileTransaction } from "../runtime/adapters/config-file-transaction.js";
+import { withFileLock } from "../runtime/adapters/long-term-memory/file-lock.js";
+import { inspectRuntimeConfigFileWithMeta } from "../runtime/config/loader.js";
+import { discoverConfiguredRuntimePluginManifests } from "../runtime/plugins/configured-manifests.js";
+import { evictPluginModules } from "../runtime/plugins/module-cache.js";
+import { installedPluginPackage, installedPluginPackageIdentity, } from "../runtime/plugins/installation/installed-package.js";
+import { normalizePluginSelection, isPluginToolSelected, } from "../runtime/plugins/selection.js";
+import { PluginRemovalActivationError } from "./plugin-removal-error.js";
+import { getRuntimePluginSnapshot, PluginManagementError, setRuntimePluginEnabled, } from "./plugin-management-service.js";
+function removablePackage(rootDir, pluginId, afterSave = false) {
+    const plugin = discoverConfiguredRuntimePluginManifests(rootDir).find((entry) => entry.manifest.name === pluginId);
+    const installed = plugin && installedPluginPackage(rootDir, plugin);
+    if (!plugin || !installed)
+        throw new PluginManagementError(afterSave ? "plugin_changed" : "plugin_not_removable", "Only plugins installed from GitHub in this Runtime can be removed.", 409);
+    return {
+        ...installed,
+        capabilityIds: Object.keys(plugin.manifest.extensions[ABOT_RUNTIME_EXTENSION].capabilities),
+    };
+}
+/** Disable, activate at the owner, then remove while configuration writers are fenced. */
+export async function removeRuntimePlugin(options, input) {
+    const value = input;
+    if (!value ||
+        typeof value !== "object" ||
+        Object.keys(value).some((key) => key !== "pluginId") ||
+        typeof value.pluginId !== "string" ||
+        !value.pluginId.trim())
+        throw new PluginManagementError("invalid_plugin_removal", "Choose an installed plugin to remove.");
+    const pluginId = value.pluginId.trim();
+    const rootDir = realpathSync(options.rootDir);
+    const source = inspectRuntimeConfigFileWithMeta(rootDir, options.configPath);
+    if (!source.exists)
+        throw new PluginManagementError("runtime_setup_required", "Complete Runtime setup before removing plugins.", 409);
+    const configPath = realpathSync(source.path);
+    const canonical = {
+        rootDir,
+        configPath,
+        requireMutationIdle: options.requireMutationIdle,
+    };
+    return withFileLock(join(rootDir, ".abot-plugin-installation"), async () => {
+        const original = removablePackage(rootDir, pluginId);
+        const expectedRevision = await withConfigFileTransaction(configPath, async (transaction) => {
+            await setRuntimePluginEnabled(canonical, { pluginId, enabled: false }, transaction);
+            return transaction.snapshot.revision;
+        });
+        const activation = await options.applyConfiguration(expectedRevision);
+        if (activation.status !== "ready")
+            return {
+                ...getRuntimePluginSnapshot(canonical),
+                removed: false,
+                activation,
+                message: "Plugin disable saved. Files are still installed. " +
+                    (activation.message ?? "Runtime application is required.") +
+                    " Then choose Remove again.",
+            };
+        // Apply takes this same lock; acquire it only after activation has completed.
+        return withConfigFileTransaction(configPath, async (transaction) => {
+            if (transaction.snapshot.revision !== expectedRevision)
+                throw new PluginManagementError("config_changed", "Configuration changed after the plugin disable. Refresh and try Remove again.", 409);
+            const current = removablePackage(rootDir, pluginId, true);
+            if (current.identity !== original.identity)
+                throw new PluginManagementError("plugin_changed", "The installed plugin changed. Refresh and try again.", 409);
+            const saved = inspectRuntimeConfigFileWithMeta(rootDir, configPath);
+            const selection = normalizePluginSelection(saved.config.plugins);
+            if (current.capabilityIds.some((toolName) => isPluginToolSelected({ pluginId, toolName, selection })))
+                throw new PluginManagementError("plugin_selection_changed", "The plugin was enabled again. Refresh and try again.", 409);
+            const staging = await mkdtemp(join(rootDir, ".abot-plugin-removal-"));
+            try {
+                // No asynchronous gap between the loaded-owner check and moving the directory.
+                options.requireInactive(pluginId, current.capabilityIds);
+                const final = removablePackage(rootDir, pluginId, true);
+                if (final.identity !== original.identity)
+                    throw new PluginManagementError("plugin_changed", "The installed plugin changed. Refresh and try again.", 409);
+                renameSync(final.path, join(staging, pluginId));
+            }
+            catch (error) {
+                // Remove only an empty staging directory; never erase an unexpectedly moved object.
+                await rmdir(staging).catch(() => undefined);
+                throw error;
+            }
+            if (installedPluginPackageIdentity(join(staging, pluginId)) !==
+                original.packageIdentity)
+                throw new PluginManagementError("plugin_changed", `The plugin directory changed during removal. Its files were preserved at ${staging}. Refresh before trying again.`, 409);
+            evictPluginModules(original.path);
+            // Preserve deny/allow selectors: deleting the last allow rule would enable other plugins.
+            let cleanupPending = false;
+            try {
+                await rm(staging, { recursive: true, force: true });
+            }
+            catch {
+                cleanupPending = true;
+            }
+            return {
+                ...getRuntimePluginSnapshot(canonical),
+                removed: true,
+                activation,
+                message: cleanupPending
+                    ? `${pluginId} removed from Plugins. Some files could not be deleted from ${staging}.`
+                    : `${pluginId} removed.`,
+            };
+        }).catch((error) => {
+            throw new PluginRemovalActivationError(error, activation);
+        });
+    });
+}

package/dist/src/web-ui/runtime-setup-gateway.d.ts

@@ -3,6 +3,7 @@ import type { RuntimeSetupActivation } from "./local-runtime/runtime-setup-input
 export type RuntimeSetupGatewayRestorePoint = {
     restore(): Promise<void>;
 };
+export type AppliedGatewayConfigurations = readonly (string | null)[];
 /** Owns only a gateway started by this Web/CLI process, never an external service. */
 export declare class RuntimeSetupGateway {
     private readonly options;
@@ -15,7 +16,10 @@ export declare class RuntimeSetupGateway {
     });
     private requireGatewayOpen;
     private configuredBinding;
-    checkActivation(configPath?: string): Promise<RuntimeSetupActivation>;
+    captureConfiguration(configPath?: string): string | null;
+    private matchesAppliedConfiguration;
+    checkActivation(configPath?: string, applied?: AppliedGatewayConfigurations): Promise<RuntimeSetupActivation>;
+    private planActivation;
     private captureGatewayCheckpoint;
     /** Retains the old server's compiled handlers, without rereading saved config. */
     createRestorePoint(): RuntimeSetupGatewayRestorePoint;
@@ -24,6 +28,6 @@ export declare class RuntimeSetupGateway {
     private replaceOwnedGateway;
     private closeGatewayListener;
     private failAfterGatewayCleanup;
-    activate(configPath?: string): Promise<RuntimeSetupActivation>;
+    activate(configPath?: string, applied?: AppliedGatewayConfigurations): Promise<RuntimeSetupActivation>;
     close(): Promise<void>;
 }

package/dist/src/web-ui/runtime-setup-gateway.js

@@ -1,5 +1,6 @@
 import { isLoopbackGateway, hasGatewayListener, } from "./runtime-setup-gateway-address.js";
 import { createModelGatewayServer, } from "../model-gateway/server.js";
+import { captureModelGatewayConfiguration } from "../model-gateway/server/configuration.js";
 import { loadRuntimeConfig } from "../runtime/config.js";
 import { closeHttpServerImmediately } from "../shared/http-server-shutdown.js";
 function listenGateway(server, port, host) {
@@ -35,7 +36,22 @@ export class RuntimeSetupGateway {
         const port = Number(url.port || "80");
         return { url, host, port };
     }
-    async checkActivation(configPath) {
+    captureConfiguration(configPath) {
+        return captureModelGatewayConfiguration({ ...this.options, configPath });
+    }
+    matchesAppliedConfiguration(configPath, applied) {
+        if (this.owned)
+            return false;
+        if (!applied?.length)
+            return false;
+        const candidate = this.captureConfiguration(configPath);
+        return (candidate !== null && applied.every((previous) => previous === candidate));
+    }
+    async checkActivation(configPath, applied) {
+        const plan = await this.planActivation(configPath, applied);
+        return plan.status === "ready" ? { status: "ready" } : plan;
+    }
+    async planActivation(configPath, applied) {
         this.requireGatewayOpen();
         const { url, host, port } = this.configuredBinding(configPath);
         if (!isLoopbackGateway(url)) {
@@ -49,13 +65,14 @@ export class RuntimeSetupGateway {
         const ownedHost = ownsTargetPort ? ownAddress.address : undefined;
         const externalListener = await hasGatewayListener(port, host, ownedHost);
         this.requireGatewayOpen();
-        if (externalListener) {
-            return {
-                status: "restart_required",
-                message: "Configuration saved. An existing model gateway owns this address; restart that gateway to load its new configuration.",
-            };
-        }
-        return { status: "ready" };
+        if (!externalListener)
+            return { status: "ready", retainExternal: false };
+        if (this.matchesAppliedConfiguration(configPath, applied))
+            return { status: "ready", retainExternal: true };
+        return {
+            status: "restart_required",
+            message: "Configuration saved. An existing model gateway owns this address; restart that gateway to load its new configuration.",
+        };
     }
     captureGatewayCheckpoint() {
         this.requireGatewayOpen();
@@ -135,15 +152,18 @@ export class RuntimeSetupGateway {
             this.owned = undefined;
         throw error;
     }
-    activate(configPath) {
+    activate(configPath, applied) {
         return this.runGatewayTransition(async () => {
             const checkpoint = this.captureGatewayCheckpoint();
             this.checkpoint = undefined;
             try {
-                const allowed = await this.checkActivation(configPath);
+                const allowed = await this.planActivation(configPath, applied);
                 this.requireGatewayOpen();
                 if (allowed.status !== "ready")
                     return allowed;
+                // Unchanged requirements do not grant ownership of the external listener.
+                if (allowed.retainExternal)
+                    return { status: "ready" };
                 const { host, port } = this.configuredBinding(configPath);
                 const server = createModelGatewayServer({
                     ...this.options,

package/dist/src/web-ui/server-readiness.d.ts

@@ -0,0 +1,3 @@
+import type { Server } from "node:http";
+/** Resolve the actual bound address, including when the caller requested port 0. */
+export declare function waitForWebUiListening(server: Server, signal: AbortSignal): Promise<string>;

package/dist/src/web-ui/server-readiness.js

@@ -0,0 +1,36 @@
+/** Resolve the actual bound address, including when the caller requested port 0. */
+export function waitForWebUiListening(server, signal) {
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            server.off("listening", listening);
+            server.off("error", failed);
+            signal.removeEventListener("abort", aborted);
+        };
+        const failed = (error) => {
+            cleanup();
+            reject(error);
+        };
+        const aborted = () => failed(new Error("web_ui_closed_before_listening"));
+        const listening = () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                failed(new Error("web_ui_tcp_address_unavailable"));
+                return;
+            }
+            cleanup();
+            const host = address.family === "IPv6" ? `[${address.address}]` : address.address;
+            resolve(`http://${host}:${address.port}/`);
+        };
+        if (signal.aborted) {
+            aborted();
+            return;
+        }
+        if (server.listening) {
+            listening();
+            return;
+        }
+        server.once("listening", listening);
+        server.once("error", failed);
+        signal.addEventListener("abort", aborted, { once: true });
+    });
+}

package/dist/src/web-ui/server.d.ts

@@ -26,6 +26,8 @@ type WebUiServerOptions = {
     checkRuntimeSetupActivation?: (configPath: string) => Promise<RuntimeSetupActivation>;
 };
 type WebUiServerHandle = {
+    ready: () => Promise<string>;
     close: () => Promise<void>;
 };
 export declare function startWebUiServer(overrides?: WebUiServerOptions): WebUiServerHandle;
+export declare function startWebUiServerWithRecovery(overrides?: WebUiServerOptions): Promise<WebUiServerHandle>;

package/dist/src/web-ui/server.js

@@ -9,8 +9,11 @@ import { resolveWebUiEnvironmentConfig, } from "./environment-config.js";
 export { resolveWebUiEnvironmentConfig, } from "./environment-config.js";
 import { closeRuntimeSetupServices } from "./runtime-setup-shutdown.js";
 import { loadDotEnvFile } from "../shared/load-dotenv.js";
+import { waitForWebUiListening } from "./server-readiness.js";
+import { recoverRuntimeSetupEdit, requireRuntimeSetupEditSettled, } from "./local-runtime/runtime-setup-edit-recovery.js";
 import { createWebUiShutdown } from "./server-shutdown.js";
 import { ExternalBridgeWebBackend } from "./external-bridge-backend.js";
+import { WebClientStateRoutes } from "./client-state/routes.js";
 import { LocalRuntimeWebBackend } from "./local-runtime-backend.js";
 import { resolveWebUiAddress } from "./web-ui-address.js";
 import { createLinkPreviewRouteHandler } from "./link-preview/routes.js";
@@ -126,6 +129,12 @@ async function serveStatic(req, res, appDir) {
     sendJson(res, 404, { ok: false, error: "not_found" });
 }
 export function startWebUiServer(overrides = {}) {
+    const startupRoots = new Set([
+        process.cwd(),
+        overrides.rootDir ?? process.cwd(),
+    ]);
+    for (const rootDir of startupRoots)
+        requireRuntimeSetupEditSettled(rootDir);
     const envOptions = getOptionsFromEnv();
     const rootDir = overrides.rootDir ?? envOptions.rootDir;
     const configPath = overrides.configPath ?? envOptions.configPath;
@@ -148,7 +157,8 @@ export function startWebUiServer(overrides = {}) {
         rootDir,
         providerAdapters: options.providerAdapters,
     });
-    const activateSetup = overrides.onRuntimeSetup ?? ((path) => setupGateway.activate(path));
+    const activateSetup = overrides.onRuntimeSetup ??
+        ((path, applied) => setupGateway.activate(path, applied));
     const wss = new WebSocketServer({ noServer: true });
     const localRuntimeBackend = options.backend === "runtime"
         ? new LocalRuntimeWebBackend({
@@ -168,6 +178,9 @@ export function startWebUiServer(overrides = {}) {
                 };
             },
             onRuntimeSetup: activateSetup,
+            captureRuntimeSetupConfiguration: overrides.onRuntimeSetup
+                ? undefined
+                : (path) => setupGateway.captureConfiguration(path),
             createRuntimeSetupRestorePoint: overrides.createRuntimeSetupRestorePoint ??
                 (overrides.onRuntimeSetup
                     ? undefined
@@ -175,7 +188,7 @@ export function startWebUiServer(overrides = {}) {
             checkRuntimeSetupActivation: overrides.checkRuntimeSetupActivation ??
                 (overrides.onRuntimeSetup
                     ? undefined
-                    : (path) => setupGateway.checkActivation(path)),
+                    : (path, applied) => setupGateway.checkActivation(path, applied)),
             ...(options.providerAdapters
                 ? { providerAdapters: options.providerAdapters }
                 : {}),
@@ -202,6 +215,12 @@ export function startWebUiServer(overrides = {}) {
         });
     }
     const handleLinkPreview = createLinkPreviewRouteHandler();
+    const clientState = new WebClientStateRoutes(rootDir, () => {
+        for (const client of wss.clients) {
+            if (client.readyState === 1)
+                client.send(JSON.stringify({ type: "workspace_changed", resources: ["client-state"] }));
+        }
+    });
     const systemHost = localRuntimeBackend
         ? new WebSystemHostService(rootDir, () => localRuntimeBackend.notifyHostConnectionChanged(), (environmentId) => localRuntimeBackend.nativePermissions(environmentId))
         : null;
@@ -213,6 +232,8 @@ export function startWebUiServer(overrides = {}) {
             if (await handleLinkPreview(req, res))
                 return;
             const pathname = new URL(req.url || "/", "http://localhost").pathname;
+            if (await clientState.handle(req, res, pathname))
+                return;
             if (await systemHost?.handleHttp(req, res, pathname))
                 return;
             if (pathname === "/web-config") {
@@ -313,10 +334,15 @@ export function startWebUiServer(overrides = {}) {
     });
     const schedulerStartup = localRuntimeBackend?.start(options.environments.map(({ id }) => id));
     return {
+        ready: () => waitForWebUiListening(server, listenAbort.signal),
         close: createWebUiShutdown(server, wss, schedulerStartup, () => closeRuntimeSetupServices(async () => localRuntimeBackend?.stop(), () => setupGateway.close(), async () => systemHost?.close()), listenAbort),
     };
 }
+export async function startWebUiServerWithRecovery(overrides = {}) {
+    await recoverRuntimeSetupEdit(overrides.rootDir ?? process.cwd());
+    return startWebUiServer(overrides);
+}
 const invokedPath = process.argv[1] ? pathToFileURL(process.argv[1]).href : "";
 if (import.meta.url === invokedPath) {
-    startWebUiServer();
+    await startWebUiServerWithRecovery();
 }

package/dist/src/web-ui/session-read-state/overview.d.ts

@@ -0,0 +1,42 @@
+import type { SessionMetadata } from "../../sessions/metadata/projection.js";
+import type { WebReadState } from "./store.js";
+/** The home dashboard's count and three recent chats must not become page-local. */
+export declare function sessionListOverview(records: SessionMetadata[], archivedIds: unknown, state?: WebReadState): {
+    sessions: ({
+        sessionId: string;
+        readStateStatus: "available";
+        unreadCount: number;
+        hasUnread: boolean;
+        lastReadMessageId: string | null;
+        lastReadAt: number;
+        latestMessageId: string | number | null;
+        latestAssistantMessageId: string | number | null;
+        kind?: import("../../sessions/spark-session.js").SessionKind;
+        project?: import("../../sessions/project-binding.js").SessionProject;
+        id: string;
+        title: string;
+        createdAt: number;
+        updatedAt: number;
+        lastMessagePreview: string;
+        lastMessageAt: number | null;
+    } | {
+        sessionId: string;
+        readStateStatus: "unavailable";
+        unreadCount: null;
+        hasUnread: null;
+        lastReadAt: null;
+        lastReadMessageId: null;
+        kind?: import("../../sessions/spark-session.js").SessionKind;
+        project?: import("../../sessions/project-binding.js").SessionProject;
+        id: string;
+        title: string;
+        createdAt: number;
+        updatedAt: number;
+        lastMessagePreview: string;
+        lastMessageAt: number | null;
+        latestMessageId: string | number | null;
+        latestAssistantMessageId: string | number | null;
+    })[];
+    unreadCount: number;
+    hasUnavailableReadState: boolean;
+};

package/dist/src/web-ui/session-read-state/overview.js

@@ -0,0 +1,16 @@
+import { projectSessionReadState } from "./projection.js";
+import { unavailableSessionReadState } from "./availability.js";
+/** The home dashboard's count and three recent chats must not become page-local. */
+export function sessionListOverview(records, archivedIds, state) {
+    const archived = new Set(Array.isArray(archivedIds) ? archivedIds : []);
+    const visible = records.filter(({ summary }) => !archived.has(summary.id));
+    let unreadCount = 0;
+    const recent = visible.slice(0, 3).map(({ summary, messages }) => ({
+        ...summary,
+        ...(state ? projectSessionReadState(state, summary.id, messages) : unavailableSessionReadState(summary.id)),
+    }));
+    if (state)
+        for (const { summary, messages } of visible)
+            unreadCount += projectSessionReadState(state, summary.id, messages).unreadCount;
+    return { sessions: recent, unreadCount, hasUnavailableReadState: !state };
+}

package/dist/src/web-ui/session-read-state/pagination.d.ts

@@ -0,0 +1,15 @@
+import type { SessionMetadata } from "../../sessions/metadata/projection.js";
+export type SessionPageQuery = {
+    cursor?: string | null;
+    query?: string;
+    archived?: boolean;
+    pinnedSessionIds?: string[];
+    orderedSessionIds?: string[];
+    archivedSessionIds?: string[];
+};
+export declare function sessionMetadataPage(records: SessionMetadata[], input: SessionPageQuery, limit: number): {
+    records: SessionMetadata[];
+    total: number;
+    archivedCount: number;
+    nextCursor: string | null;
+};

package/dist/src/web-ui/session-read-state/pagination.js

@@ -0,0 +1,42 @@
+function compareKeys(left, right) {
+    return left[0] - right[0] || left[1] - right[1] || left[2] - right[2] || left[3].localeCompare(right[3]);
+}
+function readCursor(cursor) {
+    try {
+        const key = JSON.parse(Buffer.from(cursor, "base64url").toString());
+        if (!Array.isArray(key) || key.length !== 4)
+            throw new Error();
+        if (!key.slice(0, 3).every(Number.isFinite) || typeof key[3] !== "string")
+            throw new Error();
+        return key;
+    }
+    catch {
+        throw new Error("session_cursor_invalid");
+    }
+}
+function readIds(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((id) => typeof id === "string");
+}
+export function sessionMetadataPage(records, input, limit) {
+    const archived = new Set(readIds(input.archivedSessionIds));
+    const pinned = new Map(readIds(input.pinnedSessionIds).map((id, index) => [id, index]));
+    const ordered = new Map(readIds(input.orderedSessionIds).map((id, index) => [id, index]));
+    const query = typeof input.query === "string" ? input.query.trim().toLowerCase() : "";
+    const archivedCount = records.filter(({ summary }) => archived.has(summary.id)).length;
+    const entries = records.filter(({ summary }) => archived.has(summary.id) === (input.archived === true))
+        .filter(({ summary }) => [summary.id, summary.title, summary.lastMessagePreview].some((text) => text.toLowerCase().includes(query)))
+        .map((record) => {
+        const { id, updatedAt } = record.summary;
+        const key = [pinned.has(id) ? 0 : 1, pinned.get(id) ?? ordered.get(id) ?? -1, -updatedAt, id];
+        return { record, key };
+    }).sort((left, right) => compareKeys(left.key, right.key));
+    const anchor = input.cursor ? readCursor(input.cursor) : null;
+    const remaining = anchor ? entries.filter(({ key }) => compareKeys(key, anchor) > 0) : entries;
+    const page = remaining.slice(0, limit);
+    return {
+        records: page.map(({ record }) => record), total: entries.length, archivedCount,
+        nextCursor: remaining.length > limit ? Buffer.from(JSON.stringify(page.at(-1).key)).toString("base64url") : null,
+    };
+}

package/dist/src/web-ui/session-read-state/projection.d.ts

@@ -1,11 +1,12 @@
-import type { SessionSnapshotMessage } from "../../sessions/types.js";
+import type { SessionMessageIdentity } from "../../sessions/snapshot.js";
+import type { SessionMessageMetadata } from "../../sessions/metadata/projection.js";
 import type { WebReadState } from "./store.js";
 export type ReadBoundary = {
     readThroughMessageId?: unknown;
     readThroughRequestId?: unknown;
 };
-export declare function advanceReadCursor(state: WebReadState, sessionId: string, messages: SessionSnapshotMessage[], boundary: ReadBoundary, now: number): void;
-export declare function projectSessionReadState(state: WebReadState, sessionId: string, messages: SessionSnapshotMessage[]): {
+export declare function advanceReadCursor(state: WebReadState, sessionId: string, messages: SessionMessageIdentity[], boundary: ReadBoundary, now: number): void;
+export declare function projectSessionReadState(state: WebReadState, sessionId: string, messages: SessionMessageMetadata[]): {
     sessionId: string;
     readStateStatus: "available";
     unreadCount: number;