@konitif/workbench 0.284.1

package/dist/application/runtime/RuntimeProjectionCatalog.js

@@ -0,0 +1,48 @@
+export function normalizeProjectionCatalogFromWorkspace(workspace) {
+    if (!workspace) {
+        return [];
+    }
+    return Object.entries(workspace.projections)
+        .map(([projectionKind, sources]) => ({
+        projectionKind,
+        version: 'workspace-catalog',
+        sources: Array.isArray(sources) ? [...sources] : []
+    }))
+        .sort(compareProjectionCatalogEntries);
+}
+export function normalizeProjectionCatalogFromEvent(payload, fallback) {
+    if (!payload || typeof payload !== 'object') {
+        return fallback;
+    }
+    const eventPayload = payload;
+    const projectors = Array.isArray(eventPayload.projectors) ? eventPayload.projectors : null;
+    if (projectors) {
+        return projectors
+            .map(normalizeProjectionCatalogEntry)
+            .filter((entry) => Boolean(entry))
+            .sort(compareProjectionCatalogEntries);
+    }
+    const entry = normalizeProjectionCatalogEntry(eventPayload);
+    return entry ? [entry] : fallback;
+}
+export function normalizeProjectionCatalogEntry(value) {
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    const payload = value;
+    const projectionKind = typeof payload.projectionKind === 'string' ? payload.projectionKind : null;
+    const version = typeof payload.version === 'string' ? payload.version : 'runtime-catalog';
+    const sources = Array.isArray(payload.sources)
+        ? payload.sources.filter((source) => typeof source === 'string')
+        : [];
+    return projectionKind
+        ? {
+            projectionKind,
+            version,
+            sources
+        }
+        : null;
+}
+export function compareProjectionCatalogEntries(left, right) {
+    return left.projectionKind.localeCompare(right.projectionKind);
+}

package/dist/application/runtime/RuntimeProjectionSession.d.ts

@@ -0,0 +1,5 @@
+export { RUNTIME_PROJECTION_SESSION_SHARED_STATE_PREFIX, createRuntimeProjectionSessionKey, createRuntimeProjectionSessionSharedStateKey, isRuntimeProjectionSessionSharedStateKey } from "./RuntimeProjectionSessionKeys.js";
+export { createRuntimeProjectionSessionPatchFromEntry, normalizeRuntimeProjectionSessionEntry, serializeRuntimeProjectionSessionEntry } from "./RuntimeProjectionSessionSerialization.js";
+export { mergeRuntimeProjectionSessionSharedStateEntries } from "./RuntimeProjectionSessionSharedState.js";
+export { createRuntimeProjectionSessionState, getActiveRuntimeProjectionSessionEntry, listRuntimeProjectionSessionEntries, patchRuntimeProjectionSessionEntry, removeRuntimeProjectionSessionToolInstance, upsertRuntimeProjectionSessionEntry } from "./RuntimeProjectionSessionReducers.js";
+export type { RuntimeProjectionSessionEntry, RuntimeProjectionSessionOpenInput, RuntimeProjectionSessionPatch, RuntimeProjectionSessionSharedStateMergeResult, RuntimeProjectionSessionState, RuntimeProjectionSessionStatus } from "./RuntimeProjectionSessionTypes.js";

package/dist/application/runtime/RuntimeProjectionSession.js

@@ -0,0 +1,4 @@
+export { RUNTIME_PROJECTION_SESSION_SHARED_STATE_PREFIX, createRuntimeProjectionSessionKey, createRuntimeProjectionSessionSharedStateKey, isRuntimeProjectionSessionSharedStateKey } from "./RuntimeProjectionSessionKeys.js";
+export { createRuntimeProjectionSessionPatchFromEntry, normalizeRuntimeProjectionSessionEntry, serializeRuntimeProjectionSessionEntry } from "./RuntimeProjectionSessionSerialization.js";
+export { mergeRuntimeProjectionSessionSharedStateEntries } from "./RuntimeProjectionSessionSharedState.js";
+export { createRuntimeProjectionSessionState, getActiveRuntimeProjectionSessionEntry, listRuntimeProjectionSessionEntries, patchRuntimeProjectionSessionEntry, removeRuntimeProjectionSessionToolInstance, upsertRuntimeProjectionSessionEntry } from "./RuntimeProjectionSessionReducers.js";

package/dist/application/runtime/RuntimeProjectionSessionKeys.d.ts

@@ -0,0 +1,5 @@
+import type { WorkbenchRuntimeProjectionTarget } from "../../domain/runtime/model.js";
+export declare const RUNTIME_PROJECTION_SESSION_SHARED_STATE_PREFIX = "runtime.projection-session:";
+export declare function createRuntimeProjectionSessionKey(target: WorkbenchRuntimeProjectionTarget): string;
+export declare function createRuntimeProjectionSessionSharedStateKey(target: WorkbenchRuntimeProjectionTarget): string;
+export declare function isRuntimeProjectionSessionSharedStateKey(key: string): boolean;

package/dist/application/runtime/RuntimeProjectionSessionKeys.js

@@ -0,0 +1,10 @@
+export const RUNTIME_PROJECTION_SESSION_SHARED_STATE_PREFIX = 'runtime.projection-session:';
+export function createRuntimeProjectionSessionKey(target) {
+    return `${target.projectionKind}:${target.sourceFile}`;
+}
+export function createRuntimeProjectionSessionSharedStateKey(target) {
+    return `${RUNTIME_PROJECTION_SESSION_SHARED_STATE_PREFIX}${createRuntimeProjectionSessionKey(target)}`;
+}
+export function isRuntimeProjectionSessionSharedStateKey(key) {
+    return key.startsWith(RUNTIME_PROJECTION_SESSION_SHARED_STATE_PREFIX);
+}

package/dist/application/runtime/RuntimeProjectionSessionReducers.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeProjectionSessionEntry, RuntimeProjectionSessionOpenInput, RuntimeProjectionSessionPatch, RuntimeProjectionSessionState } from "./RuntimeProjectionSessionTypes.js";
+export declare function createRuntimeProjectionSessionState(entries?: RuntimeProjectionSessionEntry[], activeKey?: string | null): RuntimeProjectionSessionState;
+export declare function upsertRuntimeProjectionSessionEntry(state: RuntimeProjectionSessionState, input: RuntimeProjectionSessionOpenInput): RuntimeProjectionSessionState;
+export declare function patchRuntimeProjectionSessionEntry(state: RuntimeProjectionSessionState, patch: RuntimeProjectionSessionPatch): RuntimeProjectionSessionState;
+export declare function removeRuntimeProjectionSessionToolInstance(state: RuntimeProjectionSessionState, toolInstanceId: string): RuntimeProjectionSessionState;
+export declare function listRuntimeProjectionSessionEntries(state: RuntimeProjectionSessionState): RuntimeProjectionSessionEntry[];
+export declare function getActiveRuntimeProjectionSessionEntry(state: RuntimeProjectionSessionState): RuntimeProjectionSessionEntry | null;

package/dist/application/runtime/RuntimeProjectionSessionReducers.js

@@ -0,0 +1,101 @@
+import { createRuntimeProjectionSessionKey } from "./RuntimeProjectionSessionKeys.js";
+export function createRuntimeProjectionSessionState(entries = [], activeKey = null) {
+    const entriesByKey = Object.fromEntries(entries.map((entry) => [entry.key, cloneRuntimeProjectionSessionEntry(entry)]));
+    const fallbackActiveKey = activeKey && entriesByKey[activeKey] ? activeKey : entries[0]?.key ?? null;
+    return {
+        activeKey: fallbackActiveKey,
+        entries: entriesByKey
+    };
+}
+export function upsertRuntimeProjectionSessionEntry(state, input) {
+    const key = createRuntimeProjectionSessionKey(input.target);
+    const now = input.now ?? new Date().toISOString();
+    const previous = state.entries[key] ?? null;
+    const toolInstanceIds = input.toolInstanceId
+        ? appendUnique(previous?.toolInstanceIds ?? [], input.toolInstanceId)
+        : previous?.toolInstanceIds ?? [];
+    return {
+        activeKey: key,
+        entries: {
+            ...state.entries,
+            [key]: {
+                key,
+                target: { ...input.target },
+                viewerId: input.viewerId,
+                viewerTitle: input.viewerTitle ?? previous?.viewerTitle ?? input.viewerId,
+                toolInstanceIds,
+                status: input.status ?? 'open',
+                selectedEntityId: previous?.selectedEntityId ?? null,
+                focusedEntityId: previous?.focusedEntityId ?? null,
+                openedAt: previous?.openedAt ?? now,
+                updatedAt: now,
+                lastError: null
+            }
+        }
+    };
+}
+export function patchRuntimeProjectionSessionEntry(state, patch) {
+    const key = createRuntimeProjectionSessionKey(patch.target);
+    const previous = state.entries[key];
+    if (!previous) {
+        return state;
+    }
+    const now = patch.now ?? new Date().toISOString();
+    const nextToolInstanceIds = patch.toolInstanceId
+        ? appendUnique(previous.toolInstanceIds, patch.toolInstanceId)
+        : previous.toolInstanceIds;
+    return {
+        ...state,
+        activeKey: state.activeKey ?? key,
+        entries: {
+            ...state.entries,
+            [key]: {
+                ...previous,
+                viewerId: patch.viewerId ?? previous.viewerId,
+                toolInstanceIds: nextToolInstanceIds,
+                status: patch.status ?? previous.status,
+                selectedEntityId: patch.selectedEntityId === undefined ? previous.selectedEntityId : patch.selectedEntityId,
+                focusedEntityId: patch.focusedEntityId === undefined ? previous.focusedEntityId : patch.focusedEntityId,
+                updatedAt: now,
+                lastError: patch.lastError === undefined ? previous.lastError : patch.lastError
+            }
+        }
+    };
+}
+export function removeRuntimeProjectionSessionToolInstance(state, toolInstanceId) {
+    const nextEntries = {};
+    for (const [key, entry] of Object.entries(state.entries)) {
+        const nextToolInstanceIds = entry.toolInstanceIds.filter((id) => id !== toolInstanceId);
+        if (nextToolInstanceIds.length > 0) {
+            nextEntries[key] = {
+                ...entry,
+                toolInstanceIds: nextToolInstanceIds
+            };
+        }
+    }
+    const activeKey = state.activeKey && nextEntries[state.activeKey] ? state.activeKey : Object.keys(nextEntries)[0] ?? null;
+    return {
+        activeKey,
+        entries: nextEntries
+    };
+}
+export function listRuntimeProjectionSessionEntries(state) {
+    return Object.values(state.entries)
+        .map(cloneRuntimeProjectionSessionEntry)
+        .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt));
+}
+export function getActiveRuntimeProjectionSessionEntry(state) {
+    return state.activeKey && state.entries[state.activeKey]
+        ? cloneRuntimeProjectionSessionEntry(state.entries[state.activeKey])
+        : null;
+}
+function cloneRuntimeProjectionSessionEntry(entry) {
+    return {
+        ...entry,
+        target: { ...entry.target },
+        toolInstanceIds: [...entry.toolInstanceIds]
+    };
+}
+function appendUnique(values, nextValue) {
+    return values.includes(nextValue) ? values : [...values, nextValue];
+}

package/dist/application/runtime/RuntimeProjectionSessionSerialization.d.ts

@@ -0,0 +1,5 @@
+import type { JsonObject } from "../../domain/shared/json.js";
+import type { RuntimeProjectionSessionEntry, RuntimeProjectionSessionPatch } from "./RuntimeProjectionSessionTypes.js";
+export declare function serializeRuntimeProjectionSessionEntry(entry: RuntimeProjectionSessionEntry): JsonObject;
+export declare function createRuntimeProjectionSessionPatchFromEntry(entry: RuntimeProjectionSessionEntry): RuntimeProjectionSessionPatch;
+export declare function normalizeRuntimeProjectionSessionEntry(input: unknown): RuntimeProjectionSessionEntry | null;

package/dist/application/runtime/RuntimeProjectionSessionSerialization.js

@@ -0,0 +1,89 @@
+import { createRuntimeProjectionSessionKey } from "./RuntimeProjectionSessionKeys.js";
+export function serializeRuntimeProjectionSessionEntry(entry) {
+    return {
+        key: entry.key,
+        target: {
+            projectionKind: entry.target.projectionKind,
+            sourceFile: entry.target.sourceFile
+        },
+        viewerId: entry.viewerId,
+        viewerTitle: entry.viewerTitle,
+        toolInstanceIds: [...entry.toolInstanceIds],
+        status: entry.status,
+        selectedEntityId: entry.selectedEntityId,
+        focusedEntityId: entry.focusedEntityId,
+        openedAt: entry.openedAt,
+        updatedAt: entry.updatedAt,
+        lastError: entry.lastError
+    };
+}
+export function createRuntimeProjectionSessionPatchFromEntry(entry) {
+    return {
+        target: {
+            projectionKind: entry.target.projectionKind,
+            sourceFile: entry.target.sourceFile
+        },
+        viewerId: entry.viewerId,
+        status: entry.status,
+        selectedEntityId: entry.selectedEntityId,
+        focusedEntityId: entry.focusedEntityId,
+        lastError: entry.lastError,
+        now: entry.updatedAt
+    };
+}
+export function normalizeRuntimeProjectionSessionEntry(input) {
+    if (!input || typeof input !== 'object') {
+        return null;
+    }
+    const record = input;
+    const target = normalizeRuntimeProjectionSessionTarget(record.target);
+    if (!target) {
+        return null;
+    }
+    const key = typeof record.key === 'string' ? record.key : createRuntimeProjectionSessionKey(target);
+    const viewerId = typeof record.viewerId === 'string' ? record.viewerId : null;
+    if (key !== createRuntimeProjectionSessionKey(target) || !viewerId) {
+        return null;
+    }
+    return {
+        key,
+        target,
+        viewerId,
+        viewerTitle: typeof record.viewerTitle === 'string' ? record.viewerTitle : viewerId,
+        toolInstanceIds: Array.isArray(record.toolInstanceIds)
+            ? record.toolInstanceIds.filter((id) => typeof id === 'string')
+            : [],
+        status: normalizeRuntimeProjectionSessionStatus(record.status),
+        selectedEntityId: normalizeNullableString(record.selectedEntityId),
+        focusedEntityId: normalizeNullableString(record.focusedEntityId),
+        openedAt: typeof record.openedAt === 'string' ? record.openedAt : '',
+        updatedAt: typeof record.updatedAt === 'string' ? record.updatedAt : '',
+        lastError: normalizeNullableString(record.lastError)
+    };
+}
+function normalizeRuntimeProjectionSessionTarget(input) {
+    if (!input || typeof input !== 'object') {
+        return null;
+    }
+    const record = input;
+    const projectionKind = typeof record.projectionKind === 'string' ? record.projectionKind : null;
+    const sourceFile = typeof record.sourceFile === 'string' ? record.sourceFile : null;
+    return projectionKind && sourceFile
+        ? {
+            projectionKind,
+            sourceFile
+        }
+        : null;
+}
+function normalizeRuntimeProjectionSessionStatus(input) {
+    return input === 'opening' ||
+        input === 'open' ||
+        input === 'refreshing' ||
+        input === 'stale' ||
+        input === 'error'
+        ? input
+        : 'open';
+}
+function normalizeNullableString(input) {
+    return typeof input === 'string' ? input : null;
+}

package/dist/application/runtime/RuntimeProjectionSessionSharedState.d.ts

@@ -0,0 +1,3 @@
+import type { WorkbenchRuntimeSharedStateEntry } from "../../domain/runtime/model.js";
+import type { RuntimeProjectionSessionSharedStateMergeResult, RuntimeProjectionSessionState } from "./RuntimeProjectionSessionTypes.js";
+export declare function mergeRuntimeProjectionSessionSharedStateEntries(state: RuntimeProjectionSessionState, sharedStateEntries: WorkbenchRuntimeSharedStateEntry[]): RuntimeProjectionSessionSharedStateMergeResult;

package/dist/application/runtime/RuntimeProjectionSessionSharedState.js

@@ -0,0 +1,53 @@
+import { createRuntimeProjectionSessionSharedStateKey, isRuntimeProjectionSessionSharedStateKey } from "./RuntimeProjectionSessionKeys.js";
+import { normalizeRuntimeProjectionSessionEntry, serializeRuntimeProjectionSessionEntry } from "./RuntimeProjectionSessionSerialization.js";
+export function mergeRuntimeProjectionSessionSharedStateEntries(state, sharedStateEntries) {
+    let nextState = state;
+    const signatures = {};
+    const changedEntries = [];
+    let changed = false;
+    for (const sharedStateEntry of sharedStateEntries) {
+        if (sharedStateEntry.scope !== 'session' ||
+            !isRuntimeProjectionSessionSharedStateKey(sharedStateEntry.key)) {
+            continue;
+        }
+        const entry = normalizeRuntimeProjectionSessionEntry(sharedStateEntry.value);
+        if (!entry || createRuntimeProjectionSessionSharedStateKey(entry.target) !== sharedStateEntry.key) {
+            continue;
+        }
+        signatures[entry.key] = JSON.stringify(serializeRuntimeProjectionSessionEntry(entry));
+        const previous = nextState.entries[entry.key] ?? null;
+        if (previous && compareRuntimeProjectionSessionUpdatedAt(previous.updatedAt, entry.updatedAt) >= 0) {
+            continue;
+        }
+        nextState = {
+            activeKey: nextState.activeKey ?? entry.key,
+            entries: {
+                ...nextState.entries,
+                [entry.key]: cloneRuntimeProjectionSessionEntry(entry)
+            }
+        };
+        changedEntries.push(cloneRuntimeProjectionSessionEntry(entry));
+        changed = true;
+    }
+    return {
+        state: nextState,
+        signatures,
+        changedEntries,
+        changed
+    };
+}
+function cloneRuntimeProjectionSessionEntry(entry) {
+    return {
+        ...entry,
+        target: { ...entry.target },
+        toolInstanceIds: [...entry.toolInstanceIds]
+    };
+}
+function compareRuntimeProjectionSessionUpdatedAt(left, right) {
+    const leftTime = Date.parse(left);
+    const rightTime = Date.parse(right);
+    if (Number.isFinite(leftTime) && Number.isFinite(rightTime)) {
+        return leftTime - rightTime;
+    }
+    return left.localeCompare(right);
+}

package/dist/application/runtime/RuntimeProjectionSessionTypes.d.ts

@@ -0,0 +1,38 @@
+import type { WorkbenchRuntimeProjectionSessionPatch, WorkbenchRuntimeProjectionSessionStatus, WorkbenchRuntimeProjectionTarget } from "../../domain/runtime/model.js";
+export type RuntimeProjectionSessionStatus = WorkbenchRuntimeProjectionSessionStatus;
+export interface RuntimeProjectionSessionEntry {
+    key: string;
+    target: WorkbenchRuntimeProjectionTarget;
+    viewerId: string;
+    viewerTitle: string;
+    toolInstanceIds: string[];
+    status: RuntimeProjectionSessionStatus;
+    selectedEntityId: string | null;
+    focusedEntityId: string | null;
+    openedAt: string;
+    updatedAt: string;
+    lastError: string | null;
+}
+export interface RuntimeProjectionSessionState {
+    activeKey: string | null;
+    entries: Record<string, RuntimeProjectionSessionEntry>;
+}
+export interface RuntimeProjectionSessionOpenInput {
+    target: WorkbenchRuntimeProjectionTarget;
+    viewerId: string;
+    viewerTitle?: string;
+    toolInstanceId?: string | null;
+    status?: RuntimeProjectionSessionStatus;
+    now?: string;
+}
+export interface RuntimeProjectionSessionPatch extends WorkbenchRuntimeProjectionSessionPatch {
+    viewerId?: string | null;
+    toolInstanceId?: string | null;
+    now?: string;
+}
+export interface RuntimeProjectionSessionSharedStateMergeResult {
+    state: RuntimeProjectionSessionState;
+    signatures: Record<string, string>;
+    changedEntries: RuntimeProjectionSessionEntry[];
+    changed: boolean;
+}

package/dist/application/runtime/RuntimeProjectionSessionTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/application/runtime/RuntimeProjectionViewerSessionSync.d.ts

@@ -0,0 +1,29 @@
+import type { WorkbenchRuntimeSharedStateEntry } from "../../domain/runtime/model.js";
+import type { JsonObject } from "../../domain/shared/json.js";
+import type { ToolInstance } from "../../domain/tool/model.js";
+import type { InMemorySurfaceViewerRegistry } from "../../infrastructure/surfaces/InMemorySurfaceViewerRegistry.js";
+import type { RuntimeProjectionSessionPatch, RuntimeProjectionSessionState } from "./RuntimeProjectionSessionTypes.js";
+export { createRuntimeProjectionSharedStateSignature, filterRuntimeProjectionSharedStateEntriesByOrigin } from "./RuntimeProjectionViewerSessionUpdates.js";
+export interface RuntimeProjectionViewerSessionSyncInput {
+    surfaceViewerRegistry: InMemorySurfaceViewerRegistry;
+    toolInstances: Record<string, ToolInstance>;
+    patch: RuntimeProjectionSessionPatch;
+}
+export interface RuntimeProjectionViewerSessionUpdate {
+    toolInstanceId: string;
+    nextState: JsonObject;
+}
+export interface RuntimeProjectionSharedStateViewerSessionSyncInput {
+    surfaceViewerRegistry: InMemorySurfaceViewerRegistry;
+    toolInstances: Record<string, ToolInstance>;
+    sessionState: RuntimeProjectionSessionState;
+    sharedStateEntries: WorkbenchRuntimeSharedStateEntry[];
+}
+export interface RuntimeProjectionSharedStateViewerSessionSyncResult {
+    sessionState: RuntimeProjectionSessionState;
+    signatures: Record<string, string>;
+    viewerUpdates: RuntimeProjectionViewerSessionUpdate[];
+    changed: boolean;
+}
+export declare function collectRuntimeProjectionViewerSessionUpdates(input: RuntimeProjectionViewerSessionSyncInput): RuntimeProjectionViewerSessionUpdate[];
+export declare function collectRuntimeProjectionSharedStateViewerSessionUpdates(input: RuntimeProjectionSharedStateViewerSessionSyncInput): RuntimeProjectionSharedStateViewerSessionSyncResult;

package/dist/application/runtime/RuntimeProjectionViewerSessionSync.js

@@ -0,0 +1,39 @@
+import { collectRuntimeProjectionSharedStateViewerSessionUpdatePlan, collectRuntimeProjectionViewerSessionUpdateRequests } from "./RuntimeProjectionViewerSessionUpdates.js";
+export { createRuntimeProjectionSharedStateSignature, filterRuntimeProjectionSharedStateEntriesByOrigin } from "./RuntimeProjectionViewerSessionUpdates.js";
+export function collectRuntimeProjectionViewerSessionUpdates(input) {
+    const updates = [];
+    for (const request of collectRuntimeProjectionViewerSessionUpdateRequests(input)) {
+        const viewer = input.surfaceViewerRegistry.get(request.toolId);
+        if (!viewer?.applyRuntimeProjectionSession ||
+            !viewer.definition.projectionKinds.includes(request.patch.target.projectionKind)) {
+            continue;
+        }
+        const nextState = viewer.applyRuntimeProjectionSession({
+            toolInstanceId: request.toolInstanceId,
+            toolInstance: request.toolInstance,
+            viewer: viewer.definition,
+            patch: request.patch
+        });
+        if (nextState) {
+            updates.push({
+                toolInstanceId: request.toolInstanceId,
+                nextState
+            });
+        }
+    }
+    return updates;
+}
+export function collectRuntimeProjectionSharedStateViewerSessionUpdates(input) {
+    const updatePlan = collectRuntimeProjectionSharedStateViewerSessionUpdatePlan(input);
+    const viewerUpdates = updatePlan.patches.flatMap((patch) => collectRuntimeProjectionViewerSessionUpdates({
+        surfaceViewerRegistry: input.surfaceViewerRegistry,
+        toolInstances: input.toolInstances,
+        patch
+    }));
+    return {
+        sessionState: updatePlan.sessionState,
+        signatures: updatePlan.signatures,
+        viewerUpdates,
+        changed: updatePlan.changed
+    };
+}

package/dist/application/runtime/RuntimeProjectionViewerSessionUpdates.d.ts

@@ -0,0 +1,27 @@
+import type { WorkbenchRuntimeSharedStateEntry } from "../../domain/runtime/model.js";
+import type { ToolInstance } from "../../domain/tool/model.js";
+import type { RuntimeProjectionSessionPatch, RuntimeProjectionSessionState } from "./RuntimeProjectionSessionTypes.js";
+export interface RuntimeProjectionViewerSessionUpdateRequestInput {
+    toolInstances: Record<string, ToolInstance>;
+    patch: RuntimeProjectionSessionPatch;
+}
+export interface RuntimeProjectionViewerSessionUpdateRequest {
+    toolInstanceId: string;
+    toolId: string;
+    toolInstance: ToolInstance;
+    patch: RuntimeProjectionSessionPatch;
+}
+export interface RuntimeProjectionSharedStateViewerSessionUpdatePlanInput {
+    sessionState: RuntimeProjectionSessionState;
+    sharedStateEntries: WorkbenchRuntimeSharedStateEntry[];
+}
+export interface RuntimeProjectionSharedStateViewerSessionUpdatePlan {
+    sessionState: RuntimeProjectionSessionState;
+    signatures: Record<string, string>;
+    patches: RuntimeProjectionSessionPatch[];
+    changed: boolean;
+}
+export declare function collectRuntimeProjectionViewerSessionUpdateRequests(input: RuntimeProjectionViewerSessionUpdateRequestInput): RuntimeProjectionViewerSessionUpdateRequest[];
+export declare function collectRuntimeProjectionSharedStateViewerSessionUpdatePlan(input: RuntimeProjectionSharedStateViewerSessionUpdatePlanInput): RuntimeProjectionSharedStateViewerSessionUpdatePlan;
+export declare function createRuntimeProjectionSharedStateSignature(entries: WorkbenchRuntimeSharedStateEntry[]): string;
+export declare function filterRuntimeProjectionSharedStateEntriesByOrigin(entries: WorkbenchRuntimeSharedStateEntry[], originClientId: string | null): WorkbenchRuntimeSharedStateEntry[];

package/dist/application/runtime/RuntimeProjectionViewerSessionUpdates.js

@@ -0,0 +1,38 @@
+import { isRuntimeProjectionSessionSharedStateKey } from "./RuntimeProjectionSessionKeys.js";
+import { createRuntimeProjectionSessionPatchFromEntry } from "./RuntimeProjectionSessionSerialization.js";
+import { mergeRuntimeProjectionSessionSharedStateEntries } from "./RuntimeProjectionSessionSharedState.js";
+export function collectRuntimeProjectionViewerSessionUpdateRequests(input) {
+    const requests = [];
+    for (const [toolInstanceId, toolInstance] of Object.entries(input.toolInstances)) {
+        if (toolInstanceId === input.patch.toolInstanceId || !toolInstance.toolId) {
+            continue;
+        }
+        requests.push({
+            toolInstanceId,
+            toolId: toolInstance.toolId,
+            toolInstance,
+            patch: input.patch
+        });
+    }
+    return requests;
+}
+export function collectRuntimeProjectionSharedStateViewerSessionUpdatePlan(input) {
+    const mergeResult = mergeRuntimeProjectionSessionSharedStateEntries(input.sessionState, input.sharedStateEntries);
+    return {
+        sessionState: mergeResult.state,
+        signatures: mergeResult.signatures,
+        patches: mergeResult.changedEntries.map(createRuntimeProjectionSessionPatchFromEntry),
+        changed: mergeResult.changed
+    };
+}
+export function createRuntimeProjectionSharedStateSignature(entries) {
+    return entries
+        .filter((entry) => isRuntimeProjectionSessionSharedStateKey(entry.key))
+        .map((entry) => `${entry.key}:${entry.revision}:${entry.originClientId ?? ''}`)
+        .join('|');
+}
+export function filterRuntimeProjectionSharedStateEntriesByOrigin(entries, originClientId) {
+    return originClientId
+        ? entries.filter((entry) => entry.originClientId !== originClientId)
+        : entries;
+}

package/dist/application/runtime/RuntimeRegistryOwner.d.ts

@@ -0,0 +1,20 @@
+import type { RuntimeManagerSnapshot, RuntimeServiceSnapshot, RuntimeStoreSnapshot, WorkbenchRuntimeSubscription } from "../../domain/runtime/model.js";
+import type { RuntimeManagerRegistration, RuntimeServiceRegistration, RuntimeStoreRegistration } from "./RuntimeRegistryTypes.js";
+export interface RuntimeRegistryOwnerCallbacks {
+    onChanged?: () => void;
+    onManagerDisposed?: (registration: RuntimeManagerRegistration) => void;
+    onManagerRegistered?: (registration: RuntimeManagerRegistration) => void;
+    onServiceDisposed?: (registration: RuntimeServiceRegistration) => void;
+    onServiceRegistered?: (registration: RuntimeServiceRegistration) => void;
+    onStoreDisposed?: (registration: RuntimeStoreRegistration) => void;
+    onStoreRegistered?: (registration: RuntimeStoreRegistration) => void;
+}
+export interface RuntimeRegistryOwner {
+    getManagerSnapshots(): RuntimeManagerSnapshot[];
+    getServiceSnapshots(): RuntimeServiceSnapshot[];
+    getStoreSnapshots(): RuntimeStoreSnapshot[];
+    registerManager(registration: RuntimeManagerRegistration): WorkbenchRuntimeSubscription;
+    registerService(registration: RuntimeServiceRegistration): WorkbenchRuntimeSubscription;
+    registerStore(registration: RuntimeStoreRegistration): WorkbenchRuntimeSubscription;
+}
+export declare function createRuntimeRegistryOwner(callbacks?: RuntimeRegistryOwnerCallbacks): RuntimeRegistryOwner;

package/dist/application/runtime/RuntimeRegistryOwner.js

@@ -0,0 +1,71 @@
+import { createRuntimeManagerSnapshot, createRuntimeServiceSnapshot, createRuntimeStoreSnapshot } from "./RuntimeRegistrySnapshots.js";
+export function createRuntimeRegistryOwner(callbacks = {}) {
+    const stores = new Map();
+    const services = new Map();
+    const managers = new Map();
+    return {
+        getManagerSnapshots() {
+            return [...managers.values()].map((registration) => createRuntimeManagerSnapshot(registration));
+        },
+        getServiceSnapshots() {
+            return [...services.values()].map((registration) => createRuntimeServiceSnapshot(registration));
+        },
+        getStoreSnapshots() {
+            return [...stores.values()].map((registration) => createRuntimeStoreSnapshot(registration));
+        },
+        registerManager(registration) {
+            let disposed = false;
+            managers.set(registration.id, registration);
+            callbacks.onManagerRegistered?.(registration);
+            callbacks.onChanged?.();
+            return {
+                dispose: () => {
+                    if (disposed || managers.get(registration.id) !== registration) {
+                        disposed = true;
+                        return;
+                    }
+                    disposed = true;
+                    managers.delete(registration.id);
+                    callbacks.onManagerDisposed?.(registration);
+                    callbacks.onChanged?.();
+                }
+            };
+        },
+        registerService(registration) {
+            let disposed = false;
+            services.set(registration.id, registration);
+            callbacks.onServiceRegistered?.(registration);
+            callbacks.onChanged?.();
+            return {
+                dispose: () => {
+                    if (disposed || services.get(registration.id) !== registration) {
+                        disposed = true;
+                        return;
+                    }
+                    disposed = true;
+                    services.delete(registration.id);
+                    callbacks.onServiceDisposed?.(registration);
+                    callbacks.onChanged?.();
+                }
+            };
+        },
+        registerStore(registration) {
+            let disposed = false;
+            stores.set(registration.id, registration);
+            callbacks.onStoreRegistered?.(registration);
+            callbacks.onChanged?.();
+            return {
+                dispose: () => {
+                    if (disposed || stores.get(registration.id) !== registration) {
+                        disposed = true;
+                        return;
+                    }
+                    disposed = true;
+                    stores.delete(registration.id);
+                    callbacks.onStoreDisposed?.(registration);
+                    callbacks.onChanged?.();
+                }
+            };
+        }
+    };
+}

package/dist/application/runtime/RuntimeRegistrySnapshots.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimeManagerSnapshot, RuntimeServiceSnapshot, RuntimeStoreSnapshot } from "../../domain/runtime/model.js";
+import type { RuntimeManagerRegistration, RuntimeServiceRegistration, RuntimeStoreRegistration } from "./RuntimeRegistryTypes.js";
+export declare function createRuntimeStoreSnapshot(registration: RuntimeStoreRegistration): RuntimeStoreSnapshot;
+export declare function createRuntimeServiceSnapshot(registration: RuntimeServiceRegistration): RuntimeServiceSnapshot;
+export declare function createRuntimeManagerSnapshot(registration: RuntimeManagerRegistration): RuntimeManagerSnapshot;
+export declare function safeReadRuntimeValue(read: (() => unknown) | undefined, fallback: unknown): unknown;