@konitif/workbench 0.284.1

package/dist/infrastructure/audio/WorkbenchAudioManager.js

@@ -0,0 +1,100 @@
+export class WorkbenchAudioManager {
+    audioContext;
+    channels = new Map();
+    masterGainNode;
+    masterVolume;
+    masterMuted;
+    constructor(audioContext, options = {}) {
+        this.audioContext = audioContext;
+        this.masterGainNode = audioContext.createGain();
+        this.masterGainNode.connect(audioContext.destination);
+        this.masterVolume = this.normalizeGainValue(options.masterVolume, 1);
+        this.masterMuted = options.masterMuted ?? false;
+        this.applyGainValue(this.masterGainNode, this.masterMuted ? 0 : this.masterVolume);
+    }
+    get masterGain() {
+        return this.masterGainNode;
+    }
+    get masterVolumeValue() {
+        return this.masterVolume;
+    }
+    get isMasterMuted() {
+        return this.masterMuted;
+    }
+    getChannelIds() {
+        return [...this.channels.keys()];
+    }
+    ensureChannel(id, options = {}) {
+        const existingChannel = this.channels.get(id);
+        if (existingChannel) {
+            const nextVolume = this.normalizeGainValue(options.volume, existingChannel.volume);
+            const nextMuted = options.muted ?? existingChannel.muted;
+            if (nextVolume !== existingChannel.volume || nextMuted !== existingChannel.muted) {
+                existingChannel.volume = nextVolume;
+                existingChannel.muted = nextMuted;
+                this.applyGainValue(existingChannel.gainNode, nextMuted ? 0 : nextVolume);
+            }
+            return existingChannel;
+        }
+        const gainNode = this.audioContext.createGain();
+        gainNode.connect(this.masterGainNode);
+        const channel = {
+            id,
+            gainNode,
+            volume: this.normalizeGainValue(options.volume, 1),
+            muted: options.muted ?? false
+        };
+        this.applyGainValue(channel.gainNode, channel.muted ? 0 : channel.volume);
+        this.channels.set(id, channel);
+        return channel;
+    }
+    getChannel(id) {
+        return this.channels.get(id) ?? null;
+    }
+    connect(node, channelId) {
+        const channel = this.ensureChannel(channelId);
+        node.connect(channel.gainNode);
+        return node;
+    }
+    setChannelVolume(channelId, volume) {
+        const channel = this.ensureChannel(channelId);
+        channel.volume = this.normalizeGainValue(volume, channel.volume);
+        this.applyGainValue(channel.gainNode, channel.muted ? 0 : channel.volume);
+        return channel;
+    }
+    setChannelMuted(channelId, muted) {
+        const channel = this.ensureChannel(channelId);
+        channel.muted = muted;
+        this.applyGainValue(channel.gainNode, muted ? 0 : channel.volume);
+        return channel;
+    }
+    setMasterVolume(volume) {
+        this.masterVolume = this.normalizeGainValue(volume, this.masterVolume);
+        this.applyGainValue(this.masterGainNode, this.masterMuted ? 0 : this.masterVolume);
+    }
+    setMasterMuted(muted) {
+        this.masterMuted = muted;
+        this.applyGainValue(this.masterGainNode, muted ? 0 : this.masterVolume);
+    }
+    dispose() {
+        for (const channel of this.channels.values()) {
+            channel.gainNode.disconnect();
+        }
+        this.channels.clear();
+        this.masterGainNode.disconnect();
+    }
+    applyGainValue(gainNode, value) {
+        const nextValue = this.normalizeGainValue(value, 1);
+        if (typeof gainNode.gain.setValueAtTime === 'function') {
+            gainNode.gain.setValueAtTime(nextValue, this.audioContext.currentTime);
+            return;
+        }
+        gainNode.gain.value = nextValue;
+    }
+    normalizeGainValue(value, fallback) {
+        if (typeof value !== 'number' || !Number.isFinite(value)) {
+            return fallback;
+        }
+        return Math.max(0, value);
+    }
+}

package/dist/infrastructure/backend/HttpWorkbenchBackendClient.d.ts

@@ -0,0 +1,30 @@
+import type { WorkbenchRuntimeBackendHealth, WorkbenchRuntimeAppPreviewDescriptor, WorkbenchRuntimeBackendPort, WorkbenchRuntimeObservationEvent, WorkbenchRuntimeProjectionInvalidationResult, WorkbenchRuntimeSharedStateEntry, WorkbenchRuntimeSharedStatePatch, WorkbenchRuntimeSubscription, WorkbenchRuntimeWorkspaceDescriptor } from "../../domain/runtime/model.js";
+export interface HttpWorkbenchBackendClientOptions {
+    baseUrl?: string;
+    resolveBaseUrl?: () => string;
+    fetcher?: typeof fetch;
+    eventSourceFactory?: (url: string) => EventSource;
+    lifecycleEventTarget?: Pick<EventTarget, 'addEventListener' | 'removeEventListener'>;
+    now?: () => string;
+}
+export declare class HttpWorkbenchBackendClient implements WorkbenchRuntimeBackendPort {
+    private readonly configuredBaseUrl;
+    private readonly baseUrlResolver?;
+    private readonly fetcher;
+    private readonly eventSourceFactory?;
+    private readonly lifecycleEventTarget?;
+    private readonly now;
+    constructor(options?: HttpWorkbenchBackendClientOptions);
+    get baseUrl(): string;
+    getHealth(): Promise<WorkbenchRuntimeBackendHealth>;
+    getWorkspace(): Promise<WorkbenchRuntimeWorkspaceDescriptor>;
+    getProjection<TProjection = unknown>(kind: string, params?: Record<string, string>): Promise<TProjection>;
+    invalidateProjection(kind: string, params?: Record<string, string>): Promise<WorkbenchRuntimeProjectionInvalidationResult>;
+    loadProject(root: string): Promise<WorkbenchRuntimeWorkspaceDescriptor>;
+    startAppPreview(root?: string): Promise<WorkbenchRuntimeAppPreviewDescriptor>;
+    listSharedState(): Promise<WorkbenchRuntimeSharedStateEntry[]>;
+    patchSharedState(key: string, patch: WorkbenchRuntimeSharedStatePatch): Promise<WorkbenchRuntimeSharedStateEntry>;
+    subscribeToEvents(onEvent: (event: WorkbenchRuntimeObservationEvent) => void, onError: (error: Error) => void): WorkbenchRuntimeSubscription;
+    private getJson;
+    private postJson;
+}

package/dist/infrastructure/backend/HttpWorkbenchBackendClient.js

@@ -0,0 +1,314 @@
+import { WORKBENCH_RUNTIME_EVENT_TYPES } from "../../domain/runtime/model.js";
+export class HttpWorkbenchBackendClient {
+    configuredBaseUrl;
+    baseUrlResolver;
+    fetcher;
+    eventSourceFactory;
+    lifecycleEventTarget;
+    now;
+    constructor(options = {}) {
+        this.configuredBaseUrl = normalizeBaseUrl(options.baseUrl ?? 'http://127.0.0.1:5179');
+        this.baseUrlResolver = options.resolveBaseUrl;
+        this.fetcher = options.fetcher ?? globalThis.fetch.bind(globalThis);
+        this.eventSourceFactory = options.eventSourceFactory;
+        this.lifecycleEventTarget = options.lifecycleEventTarget;
+        this.now = options.now ?? (() => new Date().toISOString());
+    }
+    get baseUrl() {
+        return normalizeBaseUrl(this.baseUrlResolver?.() ?? this.configuredBaseUrl);
+    }
+    async getHealth() {
+        const payload = await this.getJson('/health');
+        return {
+            status: payload.status,
+            service: payload.service,
+            mode: payload.mode
+        };
+    }
+    async getWorkspace() {
+        const payload = await this.getJson('/api/workspace');
+        return normalizeWorkspaceDescriptor(payload);
+    }
+    async getProjection(kind, params = {}) {
+        const searchParams = new URLSearchParams(params);
+        const query = searchParams.size > 0 ? `?${searchParams.toString()}` : '';
+        return this.getJson(`/api/projections/${encodeURIComponent(kind)}${query}`);
+    }
+    async invalidateProjection(kind, params = {}) {
+        const searchParams = new URLSearchParams(params);
+        const query = searchParams.size > 0 ? `?${searchParams.toString()}` : '';
+        return this.postJson(`/api/projections/${encodeURIComponent(kind)}/invalidate${query}`);
+    }
+    async loadProject(root) {
+        const payload = await this.postJson('/api/workspace/project', { root });
+        return normalizeWorkspaceDescriptor(payload);
+    }
+    async startAppPreview(root) {
+        const searchParams = new URLSearchParams();
+        if (root) {
+            searchParams.set('root', root);
+        }
+        const query = searchParams.size > 0 ? `?${searchParams.toString()}` : '';
+        return this.getJson(`/api/app-preview${query}`);
+    }
+    async listSharedState() {
+        return this.getJson('/api/shared-state');
+    }
+    async patchSharedState(key, patch) {
+        return this.postJson(`/api/shared-state/${encodeURIComponent(key)}`, patch);
+    }
+    subscribeToEvents(onEvent, onError) {
+        const factory = this.eventSourceFactory ?? resolveEventSourceFactory();
+        if (!factory) {
+            onError(new Error('EventSource is not available in this runtime.'));
+            return { dispose: () => { } };
+        }
+        const eventSource = factory(`${this.baseUrl}/events`);
+        const lifecycleEventTarget = this.lifecycleEventTarget ?? resolveLifecycleEventTarget();
+        let closedByClient = false;
+        let cleanupCompleted = false;
+        const listeners = WORKBENCH_RUNTIME_EVENT_TYPES.map((eventType) => {
+            const listener = (event) => {
+                if (closedByClient) {
+                    return;
+                }
+                onEvent({
+                    type: eventType,
+                    payload: parseEventPayload(event.data),
+                    receivedAt: this.now()
+                });
+            };
+            eventSource.addEventListener(eventType, listener);
+            return { eventType, listener };
+        });
+        const closeEventSource = () => {
+            if (cleanupCompleted) {
+                return;
+            }
+            closedByClient = true;
+            for (const { eventType, listener } of listeners) {
+                eventSource.removeEventListener(eventType, listener);
+            }
+            lifecycleEventTarget?.removeEventListener('pagehide', closeEventSource);
+            lifecycleEventTarget?.removeEventListener('beforeunload', closeEventSource);
+            eventSource.close();
+            // Suppress events from the first attempt, but only acknowledge cleanup
+            // after it succeeds. A throwing close remains explicitly retryable.
+            cleanupCompleted = true;
+        };
+        lifecycleEventTarget?.addEventListener('pagehide', closeEventSource);
+        lifecycleEventTarget?.addEventListener('beforeunload', closeEventSource);
+        eventSource.onerror = () => {
+            if (closedByClient || eventSource.readyState === 2) {
+                return;
+            }
+            onError(new Error(`Lost connection to ${this.baseUrl}/events`));
+        };
+        return {
+            dispose: () => {
+                closeEventSource();
+            }
+        };
+    }
+    async getJson(path) {
+        const response = await this.fetcher(`${this.baseUrl}${path}`, {
+            headers: {
+                accept: 'application/json'
+            }
+        });
+        if (!response.ok) {
+            throw new Error(await createBackendRequestErrorMessage(response));
+        }
+        return (await response.json());
+    }
+    async postJson(path, body) {
+        const response = await this.fetcher(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: {
+                accept: 'application/json',
+                ...(body === undefined ? {} : { 'content-type': 'application/json' })
+            },
+            ...(body === undefined ? {} : { body: JSON.stringify(body) })
+        });
+        if (!response.ok) {
+            throw new Error(await createBackendRequestErrorMessage(response));
+        }
+        return (await response.json());
+    }
+}
+function normalizeWorkspaceDescriptor(payload) {
+    return {
+        name: payload.name ?? 'workbench-backend',
+        mode: payload.mode ?? 'development',
+        workspaceRoot: payload.workspaceRoot ?? '',
+        project: normalizeWorkspaceProject(payload.project),
+        repositoryInspection: normalizeRepositoryInspectionInput(payload.repositoryInspection),
+        repositoryCoverage: normalizeRepositoryCoverageSnapshot(payload.repositoryCoverage),
+        capabilities: Array.isArray(payload.capabilities) ? payload.capabilities : [],
+        projections: normalizeWorkspaceProjections(payload.projections)
+    };
+}
+async function createBackendRequestErrorMessage(response) {
+    let message = `${response.status} ${response.statusText}`;
+    try {
+        const payload = await response.clone().json();
+        const payloadMessage = typeof payload.message === 'string' ? payload.message : null;
+        const payloadError = typeof payload.error === 'string' ? payload.error : null;
+        message = payloadMessage ?? payloadError ?? message;
+    }
+    catch {
+        // Fall back to the status line when the backend does not return JSON.
+    }
+    return `Backend request failed: ${message}`;
+}
+function normalizeWorkspaceProjections(value) {
+    if (!value || typeof value !== 'object') {
+        return {};
+    }
+    const projections = {};
+    for (const [projectionKind, sources] of Object.entries(value)) {
+        projections[projectionKind] = Array.isArray(sources)
+            ? sources.filter((source) => typeof source === 'string')
+            : [];
+    }
+    return projections;
+}
+function normalizeWorkspaceProject(value) {
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    const payload = value;
+    const id = typeof payload.id === 'string' ? payload.id : null;
+    const label = typeof payload.label === 'string' ? payload.label : null;
+    const root = typeof payload.root === 'string' ? payload.root : null;
+    const workspaceRoot = typeof payload.workspaceRoot === 'string' ? payload.workspaceRoot : '';
+    const faviconDataUrl = typeof payload.faviconDataUrl === 'string' ? payload.faviconDataUrl : null;
+    const i18n = payload.i18n && typeof payload.i18n === 'object' && !Array.isArray(payload.i18n)
+        ? payload.i18n
+        : null;
+    const primaryLocale = typeof payload.primaryLocale === 'string'
+        ? payload.primaryLocale
+        : typeof i18n?.primaryLocale === 'string'
+            ? i18n.primaryLocale
+            : null;
+    const payloadLocales = normalizeLocaleList(payload.locales);
+    const i18nLocales = normalizeLocaleList(i18n?.locales);
+    const locales = payloadLocales.length > 0 ? payloadLocales : i18nLocales;
+    const componentSources = Array.isArray(payload.componentSources)
+        ? payload.componentSources.filter((source) => typeof source === 'string')
+        : [];
+    const componentSourceCount = typeof payload.componentSourceCount === 'number' && Number.isFinite(payload.componentSourceCount)
+        ? payload.componentSourceCount
+        : componentSources.length;
+    return id && label && root
+        ? {
+            id,
+            label,
+            root,
+            workspaceRoot,
+            isWorkspaceProject: payload.isWorkspaceProject === true,
+            faviconDataUrl,
+            primaryLocale,
+            locales,
+            i18n: primaryLocale || locales.length > 0 ? { primaryLocale, locales } : null,
+            componentSources,
+            componentSourceCount
+        }
+        : null;
+}
+function normalizeLocaleList(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return [
+        ...new Set(value
+            .filter((locale) => typeof locale === 'string' && locale.trim().length > 0)
+            .map((locale) => locale.trim()))
+    ];
+}
+function normalizeRepositoryInspectionInput(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const payload = value;
+    const root = typeof payload.root === 'string' ? payload.root : '';
+    if (!root) {
+        return null;
+    }
+    return {
+        label: typeof payload.label === 'string' ? payload.label : null,
+        root,
+        files: Array.isArray(payload.files)
+            ? payload.files.filter((file) => typeof file === 'string')
+            : [],
+        packageJson: normalizeRepositoryPackageJson(payload.packageJson),
+        git: null,
+        inspectOnly: payload.inspectOnly === true
+    };
+}
+function normalizeRepositoryCoverageSnapshot(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const payload = value;
+    return typeof payload.projectRoot === 'string' && typeof payload.projectLabel === 'string'
+        ? payload
+        : null;
+}
+function normalizeRepositoryPackageJson(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return null;
+    }
+    const payload = value;
+    return {
+        name: typeof payload.name === 'string' ? payload.name : undefined,
+        version: typeof payload.version === 'string' ? payload.version : undefined,
+        scripts: normalizeStringRecord(payload.scripts),
+        workspaces: normalizePackageWorkspaces(payload.workspaces),
+        dependencies: normalizeStringRecord(payload.dependencies),
+        devDependencies: normalizeStringRecord(payload.devDependencies)
+    };
+}
+function normalizeStringRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const entries = Object.entries(value)
+        .filter((entry) => typeof entry[1] === 'string');
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function normalizePackageWorkspaces(value) {
+    if (Array.isArray(value)) {
+        return value.filter((entry) => typeof entry === 'string');
+    }
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const packages = value.packages;
+    return Array.isArray(packages)
+        ? { packages: packages.filter((entry) => typeof entry === 'string') }
+        : undefined;
+}
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.replace(/\/+$/, '');
+}
+function parseEventPayload(data) {
+    if (!data) {
+        return null;
+    }
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return data;
+    }
+}
+function resolveEventSourceFactory() {
+    if (typeof EventSource === 'undefined') {
+        return undefined;
+    }
+    return (url) => new EventSource(url);
+}
+function resolveLifecycleEventTarget() {
+    return typeof window === 'undefined' ? undefined : window;
+}

package/dist/infrastructure/persistence/LocalWorkspacePersistence.d.ts

@@ -0,0 +1,8 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+import type { WorkspacePersistencePort } from "../../domain/workspace/persistence.js";
+export declare class LocalWorkspacePersistence implements WorkspacePersistencePort {
+    private readonly storageKey;
+    constructor(storageKey: string);
+    load(): Workspace | null;
+    save(workspace: Workspace): void;
+}

package/dist/infrastructure/persistence/LocalWorkspacePersistence.js

@@ -0,0 +1,29 @@
+import { parseWorkspaceSnapshot } from "../../domain/workspace/validation.js";
+export class LocalWorkspacePersistence {
+    storageKey;
+    constructor(storageKey) {
+        this.storageKey = storageKey;
+    }
+    load() {
+        if (typeof localStorage === 'undefined') {
+            return null;
+        }
+        const rawWorkspace = localStorage.getItem(this.storageKey);
+        if (!rawWorkspace) {
+            return null;
+        }
+        try {
+            const parsedWorkspace = JSON.parse(rawWorkspace);
+            return parseWorkspaceSnapshot(parsedWorkspace);
+        }
+        catch {
+            return null;
+        }
+    }
+    save(workspace) {
+        if (typeof localStorage === 'undefined') {
+            return;
+        }
+        localStorage.setItem(this.storageKey, JSON.stringify(workspace));
+    }
+}

package/dist/infrastructure/surfaces/InMemorySurfaceViewerRegistry.d.ts

@@ -0,0 +1,58 @@
+import type { WorkbenchRuntimeProjectionSessionPatch } from "../../domain/runtime/model.js";
+import type { JsonObject } from "../../domain/shared/json.js";
+import type { ToolSurfaceViewerCatalogPort, ToolSurfaceViewerCompatibilityInput, ToolSurfaceViewerDefinition } from "../../domain/surface/model.js";
+import type { ToolInstance } from "../../domain/tool/model.js";
+export type RegisteredSurfaceViewerComponent = unknown;
+export type RegisteredSurfaceViewerComponentModule = {
+    default: RegisteredSurfaceViewerComponent;
+};
+export type RegisteredSurfaceViewerComponentLoader = () => Promise<RegisteredSurfaceViewerComponent | RegisteredSurfaceViewerComponentModule>;
+export interface RegisteredSurfaceViewerSessionAdapterInput {
+    toolInstanceId: string;
+    toolInstance: ToolInstance;
+    viewer: ToolSurfaceViewerDefinition;
+    patch: WorkbenchRuntimeProjectionSessionPatch & {
+        toolInstanceId?: string | null;
+    };
+}
+export type RegisteredSurfaceViewerSessionAdapter = (input: RegisteredSurfaceViewerSessionAdapterInput) => JsonObject | null;
+export interface RegisteredSurfaceViewer {
+    definition: ToolSurfaceViewerDefinition;
+    component?: RegisteredSurfaceViewerComponent;
+    loadComponent?: RegisteredSurfaceViewerComponentLoader;
+    applyRuntimeProjectionSession?: RegisteredSurfaceViewerSessionAdapter;
+}
+export type SurfaceViewerRegistryDuplicateResolutionPolicy = 'first-registration-wins';
+export interface SurfaceViewerRegistryEntryMetadata {
+    id: string;
+    title: string;
+    version: string;
+    summary: string;
+    surfaceKinds: string[];
+    projectionKinds: string[];
+    componentMode: 'component' | 'loader' | 'component-and-loader';
+}
+export interface SurfaceViewerRegistryDuplicateDiagnostic {
+    kind: 'duplicate-id';
+    registryKind: 'surface-viewer';
+    duplicateId: string;
+    existing: SurfaceViewerRegistryEntryMetadata;
+    incoming: SurfaceViewerRegistryEntryMetadata;
+    existingRegistrationOrder: number;
+    incomingRegistrationOrder: number;
+    resolutionPolicy: SurfaceViewerRegistryDuplicateResolutionPolicy;
+}
+export declare class InMemorySurfaceViewerRegistry implements ToolSurfaceViewerCatalogPort {
+    private readonly entries;
+    private readonly registrationOrders;
+    private readonly duplicateDiagnostics;
+    private nextRegistrationOrder;
+    register(entry: RegisteredSurfaceViewer): void;
+    get(viewerId: string): RegisteredSurfaceViewer | undefined;
+    getDefinition(viewerId: string): ToolSurfaceViewerDefinition | undefined;
+    list(): ToolSurfaceViewerDefinition[];
+    listRegistered(): RegisteredSurfaceViewer[];
+    listCompatible(input: ToolSurfaceViewerCompatibilityInput): ToolSurfaceViewerDefinition[];
+    listRegisteredCompatible(input: ToolSurfaceViewerCompatibilityInput): RegisteredSurfaceViewer[];
+    listDiagnostics(): SurfaceViewerRegistryDuplicateDiagnostic[];
+}

package/dist/infrastructure/surfaces/InMemorySurfaceViewerRegistry.js

@@ -0,0 +1,121 @@
+export class InMemorySurfaceViewerRegistry {
+    entries = new Map();
+    registrationOrders = new Map();
+    duplicateDiagnostics = [];
+    nextRegistrationOrder = 0;
+    register(entry) {
+        if (!entry.component && !entry.loadComponent) {
+            throw new Error(`Surface viewer "${entry.definition.id}" must register a component or component loader.`);
+        }
+        const incomingRegistrationOrder = ++this.nextRegistrationOrder;
+        const existingEntry = this.entries.get(entry.definition.id);
+        if (existingEntry) {
+            this.duplicateDiagnostics.push({
+                kind: 'duplicate-id',
+                registryKind: 'surface-viewer',
+                duplicateId: entry.definition.id,
+                existing: createSurfaceViewerRegistryEntryMetadata(existingEntry),
+                incoming: createSurfaceViewerRegistryEntryMetadata(entry),
+                existingRegistrationOrder: this.registrationOrders.get(entry.definition.id) ?? 0,
+                incomingRegistrationOrder,
+                resolutionPolicy: 'first-registration-wins'
+            });
+            return;
+        }
+        this.entries.set(entry.definition.id, cloneRegisteredSurfaceViewer(entry));
+        this.registrationOrders.set(entry.definition.id, incomingRegistrationOrder);
+    }
+    get(viewerId) {
+        const entry = this.entries.get(viewerId);
+        return entry ? cloneRegisteredSurfaceViewer(entry) : undefined;
+    }
+    getDefinition(viewerId) {
+        const entry = this.entries.get(viewerId);
+        return entry ? cloneSurfaceViewerDefinition(entry.definition) : undefined;
+    }
+    list() {
+        return [...this.entries.values()]
+            .map((entry) => cloneSurfaceViewerDefinition(entry.definition))
+            .sort(compareSurfaceViewers);
+    }
+    listRegistered() {
+        return [...this.entries.values()]
+            .map((entry) => cloneRegisteredSurfaceViewer(entry))
+            .sort((left, right) => compareSurfaceViewers(left.definition, right.definition));
+    }
+    listCompatible(input) {
+        return this.listRegisteredCompatible(input).map((entry) => cloneSurfaceViewerDefinition(entry.definition));
+    }
+    listRegisteredCompatible(input) {
+        return [...this.entries.values()]
+            .filter((entry) => isCompatibleSurfaceViewer(entry.definition, input))
+            .map((entry) => cloneRegisteredSurfaceViewer(entry))
+            .sort((left, right) => compareSurfaceViewers(left.definition, right.definition));
+    }
+    listDiagnostics() {
+        return this.duplicateDiagnostics.map(cloneSurfaceViewerRegistryDuplicateDiagnostic);
+    }
+}
+function createSurfaceViewerRegistryEntryMetadata(entry) {
+    return {
+        id: entry.definition.id,
+        title: entry.definition.title,
+        version: entry.definition.version,
+        summary: entry.definition.summary,
+        surfaceKinds: [...entry.definition.surfaceKinds],
+        projectionKinds: [...entry.definition.projectionKinds],
+        componentMode: resolveSurfaceViewerComponentMode(entry)
+    };
+}
+function resolveSurfaceViewerComponentMode(entry) {
+    if (entry.component && entry.loadComponent) {
+        return 'component-and-loader';
+    }
+    return entry.component ? 'component' : 'loader';
+}
+function cloneSurfaceViewerRegistryDuplicateDiagnostic(diagnostic) {
+    return {
+        ...diagnostic,
+        existing: {
+            ...diagnostic.existing,
+            surfaceKinds: [...diagnostic.existing.surfaceKinds],
+            projectionKinds: [...diagnostic.existing.projectionKinds]
+        },
+        incoming: {
+            ...diagnostic.incoming,
+            surfaceKinds: [...diagnostic.incoming.surfaceKinds],
+            projectionKinds: [...diagnostic.incoming.projectionKinds]
+        }
+    };
+}
+function isCompatibleSurfaceViewer(definition, input) {
+    const requiredCapabilities = input.requiredCapabilities ?? [];
+    return (definition.surfaceKinds.includes(input.surfaceKind) &&
+        definition.projectionKinds.includes(input.projectionKind) &&
+        requiredCapabilities.every((capability) => definition.capabilities.includes(capability)));
+}
+function compareSurfaceViewers(left, right) {
+    const priorityDelta = (right.priority ?? 0) - (left.priority ?? 0);
+    if (priorityDelta !== 0) {
+        return priorityDelta;
+    }
+    const titleDelta = left.title.localeCompare(right.title);
+    if (titleDelta !== 0) {
+        return titleDelta;
+    }
+    return left.id.localeCompare(right.id);
+}
+function cloneRegisteredSurfaceViewer(entry) {
+    return {
+        ...entry,
+        definition: cloneSurfaceViewerDefinition(entry.definition)
+    };
+}
+function cloneSurfaceViewerDefinition(definition) {
+    return {
+        ...definition,
+        surfaceKinds: [...definition.surfaceKinds],
+        projectionKinds: [...definition.projectionKinds],
+        capabilities: [...definition.capabilities]
+    };
+}

package/dist/infrastructure/temporal/InMemoryTemporalDialectRegistry.d.ts

@@ -0,0 +1,8 @@
+import type { TemporalDialectCatalog, TemporalDialectCompatibilityInput, TemporalDialectDefinition } from "../../domain/temporal/model.js";
+export declare class InMemoryTemporalDialectRegistry implements TemporalDialectCatalog {
+    private readonly entries;
+    register(definition: TemporalDialectDefinition): void;
+    getDefinition(dialectId: string): TemporalDialectDefinition | undefined;
+    list(): TemporalDialectDefinition[];
+    listCompatible(input: TemporalDialectCompatibilityInput): TemporalDialectDefinition[];
+}