@konitif/workbench 0.284.1

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

@@ -0,0 +1,48 @@
+import type { LaunchState } from "../../domain/launch/model.js";
+import type { RuntimeDebugEventLevel, RuntimeLaunchSnapshot, RuntimeLaunchTransition, RuntimeLaunchProgressSnapshot } from "../../domain/runtime/model.js";
+import type { RuntimeStoreMutationInput } from "../../domain/runtime/observability.js";
+export interface RuntimeLaunchTransitionRecordInput {
+    id: string;
+    message: string;
+    previousPhase: LaunchState['phase'] | null;
+    state: LaunchState;
+    timestamp: string;
+}
+export interface RuntimeLaunchSnapshotFromStateInput {
+    state: LaunchState;
+    timestamp: string;
+    transitions: RuntimeLaunchTransition[];
+}
+export interface RuntimeLaunchStoreMutationValueInput {
+    previousPhase: LaunchState['phase'] | null;
+    progress: RuntimeLaunchProgressSnapshot;
+    state: LaunchState;
+}
+export interface RuntimeLaunchStoreMutationInput {
+    id: string;
+    previousPhase: LaunchState['phase'] | null;
+    progress: RuntimeLaunchProgressSnapshot;
+    state: LaunchState;
+    timestamp: string;
+}
+export interface RuntimeLaunchPhaseDebugEventInput {
+    id?: string;
+    level?: RuntimeDebugEventLevel;
+    type: string;
+    message?: string;
+    scope?: string | null;
+    payload?: unknown;
+    timestamp?: string;
+}
+export interface RuntimeLaunchPhaseDebugEventInputOptions {
+    launchSnapshot: RuntimeLaunchSnapshot;
+    previousPhase: LaunchState['phase'] | null;
+    state: LaunchState;
+    timestamp: string;
+    transition: RuntimeLaunchTransition;
+}
+export declare function createRuntimeLaunchTransitionRecord(input: RuntimeLaunchTransitionRecordInput): RuntimeLaunchTransition;
+export declare function createRuntimeLaunchSnapshotFromState(input: RuntimeLaunchSnapshotFromStateInput): RuntimeLaunchSnapshot;
+export declare function createRuntimeLaunchStoreMutationValue(input: RuntimeLaunchStoreMutationValueInput): NonNullable<RuntimeStoreMutationInput['value']>;
+export declare function createRuntimeLaunchStoreMutationInput(input: RuntimeLaunchStoreMutationInput): RuntimeStoreMutationInput;
+export declare function createRuntimeLaunchPhaseDebugEventInput(input: RuntimeLaunchPhaseDebugEventInputOptions): RuntimeLaunchPhaseDebugEventInput;

package/dist/application/runtime/RuntimeLaunchStateSnapshot.js

@@ -0,0 +1,73 @@
+import { createRuntimeLaunchProgressSnapshot } from "./RuntimeLaunchProgress.js";
+import { sanitizeRuntimeJson } from "./WorkbenchRuntimeSanitizers.js";
+export function createRuntimeLaunchTransitionRecord(input) {
+    return {
+        id: input.id,
+        phase: input.state.phase,
+        previousPhase: input.previousPhase,
+        target: input.state.target
+            ? sanitizeRuntimeJson(input.state.target)
+            : null,
+        timestamp: input.timestamp,
+        message: input.message
+    };
+}
+export function createRuntimeLaunchSnapshotFromState(input) {
+    return {
+        phase: input.state.phase,
+        target: input.state.target
+            ? sanitizeRuntimeJson(input.state.target)
+            : null,
+        preflight: input.state.preflight
+            ? sanitizeRuntimeJson(input.state.preflight)
+            : null,
+        plan: input.state.plan ? sanitizeRuntimeJson(input.state.plan) : null,
+        initialization: input.state.initialization
+            ? sanitizeRuntimeJson(input.state.initialization)
+            : null,
+        hydration: input.state.hydration
+            ? sanitizeRuntimeJson(input.state.hydration)
+            : null,
+        progress: createRuntimeLaunchProgressSnapshot(input.state),
+        state: sanitizeRuntimeJson(input.state),
+        transitions: input.transitions,
+        updatedAt: input.timestamp
+    };
+}
+export function createRuntimeLaunchStoreMutationValue(input) {
+    return {
+        phase: input.state.phase,
+        previousPhase: input.previousPhase,
+        targetKind: input.state.target?.kind ?? null,
+        profile: input.state.target?.profile ?? null,
+        progress: input.progress,
+        error: input.state.error
+    };
+}
+export function createRuntimeLaunchStoreMutationInput(input) {
+    return {
+        id: input.id,
+        storeId: 'launch.state',
+        kind: input.previousPhase ? 'update' : 'snapshot',
+        timestamp: input.timestamp,
+        value: createRuntimeLaunchStoreMutationValue(input)
+    };
+}
+export function createRuntimeLaunchPhaseDebugEventInput(input) {
+    return {
+        id: input.transition.id,
+        level: input.state.phase === 'RECOVERY' || input.state.phase === 'SAFE_MODE' ? 'warning' : 'info',
+        type: 'launch.phase.changed',
+        message: input.transition.message,
+        scope: 'launch',
+        timestamp: input.timestamp,
+        payload: {
+            phase: input.state.phase,
+            previousPhase: input.previousPhase,
+            target: input.state.target,
+            preflight: input.state.preflight,
+            progress: input.launchSnapshot.progress,
+            error: input.state.error
+        }
+    };
+}

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

@@ -0,0 +1,28 @@
+import type { RuntimeDebugEvent, RuntimeStackTrace } from "../../domain/runtime/model.js";
+import type { RuntimeCrashReport, RuntimeCrashReportInput, RuntimeEntityLifecycleEntry, RuntimeEntityLifecycleInput, RuntimeHealthCheck, RuntimeHealthCheckInput, RuntimeObservabilitySnapshot, RuntimePerformanceMarker, RuntimePerformanceMarkerInput, RuntimeStoreMutationEntry, RuntimeStoreMutationInput, RuntimeStructuredLog, RuntimeStructuredLogInput, RuntimeTelemetryTrace, RuntimeTelemetryTraceInput } from "../../domain/runtime/observability.js";
+export interface RuntimeObservabilityHubOptions {
+    maxEntries?: number;
+}
+export declare class RuntimeObservabilityHub {
+    private readonly maxEntries;
+    private traces;
+    private logs;
+    private performanceMarkers;
+    private healthChecks;
+    private storeMutations;
+    private lifecycleEntries;
+    private crashReports;
+    private sequence;
+    constructor(options?: RuntimeObservabilityHubOptions);
+    createSnapshot(timestamp?: string): RuntimeObservabilitySnapshot;
+    recordTrace(input: RuntimeTelemetryTraceInput): RuntimeTelemetryTrace;
+    recordDebugEvent(event: RuntimeDebugEvent): RuntimeTelemetryTrace;
+    recordStackTrace(trace: RuntimeStackTrace): RuntimeTelemetryTrace;
+    recordLog(input: RuntimeStructuredLogInput): RuntimeStructuredLog;
+    recordPerformanceMarker(input: RuntimePerformanceMarkerInput): RuntimePerformanceMarker;
+    recordHealthCheck(input: RuntimeHealthCheckInput): RuntimeHealthCheck;
+    recordStoreMutation(input: RuntimeStoreMutationInput): RuntimeStoreMutationEntry;
+    recordEntityLifecycle(input: RuntimeEntityLifecycleInput): RuntimeEntityLifecycleEntry;
+    captureCrashReport(error: Error | string, input?: RuntimeCrashReportInput): RuntimeCrashReport;
+    private createId;
+}

package/dist/application/runtime/RuntimeObservabilityHub.js

@@ -0,0 +1,262 @@
+export class RuntimeObservabilityHub {
+    maxEntries;
+    traces = [];
+    logs = [];
+    performanceMarkers = [];
+    healthChecks = [];
+    storeMutations = [];
+    lifecycleEntries = [];
+    crashReports = [];
+    sequence = 0;
+    constructor(options = {}) {
+        this.maxEntries = options.maxEntries ?? 100;
+    }
+    createSnapshot(timestamp = new Date().toISOString()) {
+        return {
+            generatedAt: timestamp,
+            traces: [...this.traces],
+            logs: [...this.logs],
+            performanceMarkers: [...this.performanceMarkers],
+            healthChecks: [...this.healthChecks],
+            storeMutations: [...this.storeMutations],
+            lifecycleEntries: [...this.lifecycleEntries],
+            crashReports: [...this.crashReports]
+        };
+    }
+    recordTrace(input) {
+        const trace = {
+            id: input.id ?? this.createId('trace'),
+            type: input.type,
+            level: input.level ?? 'info',
+            scope: normalizeNullableText(input.scope, 160),
+            label: sanitizeText(input.label ?? input.type, 160),
+            message: sanitizeText(input.message ?? input.label ?? input.type, 500),
+            timestamp: input.timestamp ?? new Date().toISOString(),
+            payload: input.payload === undefined ? undefined : sanitizeJson(input.payload)
+        };
+        this.traces = prependRing(this.traces, trace, this.maxEntries);
+        return trace;
+    }
+    recordDebugEvent(event) {
+        return this.recordTrace({
+            id: event.id,
+            type: 'debug-event',
+            level: event.level,
+            scope: event.scope,
+            label: event.type,
+            message: event.message,
+            timestamp: event.timestamp,
+            payload: event.payload
+        });
+    }
+    recordStackTrace(trace) {
+        return this.recordTrace({
+            id: trace.id,
+            type: 'stack-trace',
+            level: 'error',
+            scope: trace.scope,
+            label: trace.message,
+            message: trace.message,
+            timestamp: trace.timestamp,
+            payload: {
+                frames: trace.frames,
+                cause: trace.cause
+            }
+        });
+    }
+    recordLog(input) {
+        const log = {
+            id: input.id ?? this.createId('log'),
+            level: input.level ?? 'info',
+            scope: normalizeNullableText(input.scope, 160),
+            message: sanitizeText(input.message, 500),
+            timestamp: input.timestamp ?? new Date().toISOString(),
+            payload: input.payload === undefined ? undefined : sanitizeJson(input.payload)
+        };
+        this.logs = prependRing(this.logs, log, this.maxEntries);
+        this.recordTrace({
+            id: log.id,
+            type: 'debug-event',
+            level: log.level,
+            scope: log.scope,
+            label: 'structured log',
+            message: log.message,
+            timestamp: log.timestamp,
+            payload: log.payload
+        });
+        return log;
+    }
+    recordPerformanceMarker(input) {
+        const marker = {
+            id: input.id ?? this.createId('perf'),
+            label: sanitizeText(input.label, 160),
+            scope: normalizeNullableText(input.scope, 160),
+            startTime: normalizeFiniteNumber(input.startTime) ?? 0,
+            durationMs: normalizeFiniteNumber(input.durationMs),
+            timestamp: input.timestamp ?? new Date().toISOString(),
+            payload: input.payload === undefined ? undefined : sanitizeJson(input.payload)
+        };
+        this.performanceMarkers = prependRing(this.performanceMarkers, marker, this.maxEntries);
+        this.recordTrace({
+            id: marker.id,
+            type: 'performance-marker',
+            level: 'debug',
+            scope: marker.scope,
+            label: marker.label,
+            message: marker.durationMs === null ? marker.label : `${marker.label} ${marker.durationMs}ms`,
+            timestamp: marker.timestamp,
+            payload: marker.payload
+        });
+        return marker;
+    }
+    recordHealthCheck(input) {
+        const healthCheck = {
+            id: input.id ?? this.createId('health'),
+            targetId: sanitizeText(input.targetId, 160),
+            targetType: input.targetType,
+            status: normalizeStatus(input.status),
+            checkedAt: input.checkedAt ?? new Date().toISOString(),
+            latencyMs: normalizeFiniteNumber(input.latencyMs),
+            message: normalizeNullableText(input.message, 500),
+            payload: input.payload === undefined ? undefined : sanitizeJson(input.payload)
+        };
+        this.healthChecks = prependRing(this.healthChecks, healthCheck, this.maxEntries);
+        this.recordTrace({
+            id: healthCheck.id,
+            type: 'health-check',
+            level: healthCheck.status === 'error' ? 'error' : healthCheck.status === 'degraded' ? 'warning' : 'info',
+            scope: healthCheck.targetType,
+            label: healthCheck.targetId,
+            message: healthCheck.message ?? `Health ${healthCheck.status}`,
+            timestamp: healthCheck.checkedAt,
+            payload: healthCheck.payload
+        });
+        return healthCheck;
+    }
+    recordStoreMutation(input) {
+        const mutation = {
+            id: input.id ?? this.createId('store'),
+            storeId: sanitizeText(input.storeId, 160),
+            kind: input.kind,
+            timestamp: input.timestamp ?? new Date().toISOString(),
+            value: input.value === undefined ? undefined : sanitizeJson(input.value)
+        };
+        this.storeMutations = prependRing(this.storeMutations, mutation, this.maxEntries);
+        this.recordTrace({
+            id: mutation.id,
+            type: 'store-mutation',
+            level: 'debug',
+            scope: 'store',
+            label: mutation.storeId,
+            message: `Store ${mutation.kind}`,
+            timestamp: mutation.timestamp,
+            payload: mutation.value
+        });
+        return mutation;
+    }
+    recordEntityLifecycle(input) {
+        const entry = {
+            id: input.id ?? this.createId('lifecycle'),
+            entityId: sanitizeText(input.entityId, 160),
+            entityType: input.entityType,
+            kind: input.kind,
+            status: normalizeStatus(input.status ?? (input.kind === 'error' ? 'error' : 'active')),
+            timestamp: input.timestamp ?? new Date().toISOString(),
+            message: normalizeNullableText(input.message, 500),
+            payload: input.payload === undefined ? undefined : sanitizeJson(input.payload)
+        };
+        this.lifecycleEntries = prependRing(this.lifecycleEntries, entry, this.maxEntries);
+        this.recordTrace({
+            id: entry.id,
+            type: 'lifecycle',
+            level: entry.status === 'error' ? 'error' : entry.status === 'degraded' ? 'warning' : 'info',
+            scope: entry.entityType,
+            label: entry.entityId,
+            message: entry.message ?? `${entry.entityType} ${entry.kind}`,
+            timestamp: entry.timestamp,
+            payload: entry.payload
+        });
+        return entry;
+    }
+    captureCrashReport(error, input = {}) {
+        const resolvedError = error instanceof Error ? error : null;
+        const stackSource = resolvedError?.stack ?? (typeof error === 'string' ? error : '');
+        const cause = resolvedError && 'cause' in resolvedError ? resolvedError.cause : null;
+        const report = {
+            id: input.id ?? this.createId('crash'),
+            message: sanitizeText(input.message ?? resolvedError?.message ?? String(error), 500),
+            scope: normalizeNullableText(input.scope, 160),
+            timestamp: input.timestamp ?? new Date().toISOString(),
+            stackFrames: stackSource
+                .split('\n')
+                .map((frame) => sanitizeText(frame.trim(), 500))
+                .filter(Boolean)
+                .slice(0, 24),
+            cause: cause instanceof Error ? sanitizeText(cause.message, 500) : null,
+            payload: input.payload === undefined ? undefined : sanitizeJson(input.payload)
+        };
+        this.crashReports = prependRing(this.crashReports, report, this.maxEntries);
+        this.recordTrace({
+            id: report.id,
+            type: 'crash',
+            level: 'error',
+            scope: report.scope,
+            label: 'crash report',
+            message: report.message,
+            timestamp: report.timestamp,
+            payload: {
+                cause: report.cause,
+                frames: report.stackFrames,
+                context: report.payload
+            }
+        });
+        return report;
+    }
+    createId(prefix) {
+        this.sequence += 1;
+        return `${prefix}:${this.sequence}`;
+    }
+}
+function prependRing(items, item, maxEntries) {
+    return [item, ...items].slice(0, maxEntries);
+}
+function normalizeStatus(status) {
+    return status === 'active' || status === 'idle' || status === 'degraded' || status === 'error' || status === 'unknown'
+        ? status
+        : 'unknown';
+}
+function normalizeFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function normalizeNullableText(value, maxLength) {
+    return typeof value === 'string' ? sanitizeText(value, maxLength) : null;
+}
+function sanitizeText(value, maxLength = 2000) {
+    return value.length <= maxLength ? value : `${value.slice(0, maxLength - 1)}...`;
+}
+function sanitizeJson(value, depth = 0) {
+    if (value === null || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return sanitizeText(value);
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (Array.isArray(value)) {
+        if (depth >= 4) {
+            return `[Array(${value.length})]`;
+        }
+        return value.slice(0, 50).map((entry) => sanitizeJson(entry, depth + 1));
+    }
+    if (value && typeof value === 'object') {
+        if (depth >= 4) {
+            return '[Object]';
+        }
+        return Object.fromEntries(Object.entries(value)
+            .slice(0, 50)
+            .map(([key, entry]) => [sanitizeText(key, 120), sanitizeJson(entry, depth + 1)]));
+    }
+    return null;
+}

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

@@ -0,0 +1,15 @@
+import type { WorkbenchRuntimeObservationEvent, WorkbenchRuntimeProjectionCatalogEntry, WorkbenchRuntimeSharedStateEntry } from "../../domain/runtime/model.js";
+export interface RuntimeObservationEventReducerInput {
+    projectionCatalog: WorkbenchRuntimeProjectionCatalogEntry[];
+    sharedState: WorkbenchRuntimeSharedStateEntry[];
+    events: WorkbenchRuntimeObservationEvent[];
+    event: WorkbenchRuntimeObservationEvent;
+    maxEvents: number;
+}
+export interface RuntimeObservationEventReducerPatch {
+    projectionCatalog: WorkbenchRuntimeProjectionCatalogEntry[];
+    sharedState: WorkbenchRuntimeSharedStateEntry[];
+    events: WorkbenchRuntimeObservationEvent[];
+}
+export declare function appendRuntimeObservationEvent(events: WorkbenchRuntimeObservationEvent[], event: WorkbenchRuntimeObservationEvent, maxEvents: number): WorkbenchRuntimeObservationEvent[];
+export declare function applyRuntimeObservationEvent(input: RuntimeObservationEventReducerInput): RuntimeObservationEventReducerPatch;

package/dist/application/runtime/RuntimeObservationEvents.js

@@ -0,0 +1,18 @@
+import { normalizeProjectionCatalogFromEvent } from "./RuntimeProjectionCatalog.js";
+import { upsertSharedStateEntryFromEvent } from "./RuntimeSharedState.js";
+export function appendRuntimeObservationEvent(events, event, maxEvents) {
+    return [event, ...events].slice(0, maxEvents);
+}
+export function applyRuntimeObservationEvent(input) {
+    const projectionCatalog = input.event.type === 'projection.catalog'
+        ? normalizeProjectionCatalogFromEvent(input.event.payload, input.projectionCatalog)
+        : input.projectionCatalog;
+    const sharedState = input.event.type === 'shared-state.updated'
+        ? upsertSharedStateEntryFromEvent(input.sharedState, input.event.payload)
+        : input.sharedState;
+    return {
+        projectionCatalog,
+        sharedState,
+        events: appendRuntimeObservationEvent(input.events, input.event, input.maxEvents)
+    };
+}

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

@@ -0,0 +1,24 @@
+import { type RuntimeOffloadEvent, type RuntimeOffloadSnapshot, type RuntimeOffloadTask, type RuntimeOffloadTaskInput } from "../../domain/runtime/offload.js";
+export interface RuntimeOffloadManagerOptions {
+    maxConcurrentTasks?: number;
+    now?: () => string;
+    onEvent?: (event: RuntimeOffloadEvent) => void;
+}
+export declare class RuntimeOffloadManager {
+    private readonly maxConcurrentTasks;
+    private readonly now;
+    private readonly onEvent;
+    private tasks;
+    private sequence;
+    constructor(options?: RuntimeOffloadManagerOptions);
+    enqueue(input: RuntimeOffloadTaskInput): RuntimeOffloadTask;
+    startNext(): RuntimeOffloadTask | null;
+    updateProgress(taskId: string, progress: number): RuntimeOffloadTask | null;
+    complete(taskId: string, result?: unknown): RuntimeOffloadTask | null;
+    fail(taskId: string, error: string): RuntimeOffloadTask | null;
+    cancel(taskId: string): RuntimeOffloadTask | null;
+    createSnapshot(timestamp?: string): RuntimeOffloadSnapshot;
+    private findTask;
+    private replaceTask;
+    private emit;
+}

package/dist/application/runtime/RuntimeOffloadManager.js

@@ -0,0 +1,96 @@
+import { cancelRuntimeOffloadTask, completeRuntimeOffloadTask, createRuntimeOffloadSnapshot, createRuntimeOffloadTask, failRuntimeOffloadTask, startRuntimeOffloadTask, updateRuntimeOffloadTaskProgress } from "../../domain/runtime/offload.js";
+export class RuntimeOffloadManager {
+    maxConcurrentTasks;
+    now;
+    onEvent;
+    tasks = [];
+    sequence = 0;
+    constructor(options = {}) {
+        this.maxConcurrentTasks = Math.max(1, Math.floor(options.maxConcurrentTasks ?? 1));
+        this.now = options.now ?? (() => new Date().toISOString());
+        this.onEvent = options.onEvent ?? null;
+    }
+    enqueue(input) {
+        const task = createRuntimeOffloadTask(input, this.now());
+        this.tasks = [...this.tasks, task];
+        this.emit(task, 'queued', `${task.label} queued`);
+        return task;
+    }
+    startNext() {
+        const runningCount = this.tasks.filter((task) => task.status === 'running').length;
+        if (runningCount >= this.maxConcurrentTasks) {
+            return null;
+        }
+        const nextTask = createRuntimeOffloadSnapshot(this.tasks, this.now()).tasks.find((task) => task.status === 'queued') ?? null;
+        if (!nextTask) {
+            return null;
+        }
+        const startedTask = startRuntimeOffloadTask(nextTask, this.now());
+        this.replaceTask(startedTask);
+        this.emit(startedTask, 'started', `${startedTask.label} started`);
+        return startedTask;
+    }
+    updateProgress(taskId, progress) {
+        const task = this.findTask(taskId);
+        if (!task) {
+            return null;
+        }
+        const updatedTask = updateRuntimeOffloadTaskProgress(task, progress, this.now());
+        this.replaceTask(updatedTask);
+        this.emit(updatedTask, 'progress', `${updatedTask.label} ${updatedTask.progress}%`);
+        return updatedTask;
+    }
+    complete(taskId, result) {
+        const task = this.findTask(taskId);
+        if (!task) {
+            return null;
+        }
+        const completedTask = completeRuntimeOffloadTask(task, result, this.now());
+        this.replaceTask(completedTask);
+        this.emit(completedTask, 'completed', `${completedTask.label} completed`);
+        this.startNext();
+        return completedTask;
+    }
+    fail(taskId, error) {
+        const task = this.findTask(taskId);
+        if (!task) {
+            return null;
+        }
+        const failedTask = failRuntimeOffloadTask(task, error, this.now());
+        this.replaceTask(failedTask);
+        this.emit(failedTask, 'failed', error);
+        this.startNext();
+        return failedTask;
+    }
+    cancel(taskId) {
+        const task = this.findTask(taskId);
+        if (!task) {
+            return null;
+        }
+        const cancelledTask = cancelRuntimeOffloadTask(task, this.now());
+        this.replaceTask(cancelledTask);
+        this.emit(cancelledTask, 'cancelled', `${cancelledTask.label} cancelled`);
+        this.startNext();
+        return cancelledTask;
+    }
+    createSnapshot(timestamp = this.now()) {
+        return createRuntimeOffloadSnapshot(this.tasks, timestamp);
+    }
+    findTask(taskId) {
+        return this.tasks.find((task) => task.id === taskId) ?? null;
+    }
+    replaceTask(task) {
+        this.tasks = this.tasks.map((candidate) => candidate.id === task.id ? task : candidate);
+    }
+    emit(task, kind, message) {
+        this.sequence += 1;
+        this.onEvent?.({
+            id: `offload-event:${this.sequence}`,
+            taskId: task.id,
+            kind,
+            timestamp: this.now(),
+            message,
+            progress: task.progress
+        });
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { LaunchPreflightSummary, LaunchTarget } from "../../domain/launch/model.js";
+import type { RuntimePlan } from "../../domain/runtime/plan.js";
+export interface CreateRuntimePlanInput {
+    target: LaunchTarget;
+    preflight?: LaunchPreflightSummary | null;
+    dryRun?: boolean;
+    now?: string;
+}
+export declare class RuntimePlanEngine {
+    createPlan(input: CreateRuntimePlanInput): RuntimePlan;
+}

package/dist/application/runtime/RuntimePlanEngine.js

@@ -0,0 +1,67 @@
+export class RuntimePlanEngine {
+    createPlan(input) {
+        const timestamp = input.now ?? new Date().toISOString();
+        const blockedChecks = (input.preflight?.checks ?? []).filter((check) => check.status === 'blocked');
+        const warningChecks = (input.preflight?.checks ?? []).filter((check) => check.status === 'warning');
+        const steps = createStepsForTarget(input.target, blockedChecks);
+        return {
+            id: `runtime-plan:${input.target.kind}:${input.target.profile}:${timestamp}`,
+            target: input.target,
+            profile: input.target.profile,
+            createdAt: timestamp,
+            dryRun: input.dryRun ?? false,
+            canExecute: blockedChecks.length === 0 && steps.every((step) => step.status !== 'blocked'),
+            steps,
+            warnings: createWarnings([...blockedChecks, ...warningChecks]),
+            preflight: input.preflight ?? null
+        };
+    }
+}
+function createStepsForTarget(target, blockedChecks) {
+    const hasBlockedPreflight = blockedChecks.length > 0;
+    const baseSteps = [
+        createStep('runtime.observability', 'observability-hook', 'Attach observability hooks', !hasBlockedPreflight),
+        createStep('runtime.teardown', 'teardown-hook', 'Register teardown hooks', !hasBlockedPreflight),
+        createStep('runtime.rollback', 'rollback-hook', 'Register rollback hooks', !hasBlockedPreflight)
+    ];
+    if (target.kind === 'self' || target.profile === 'core-only' || target.profile === 'recovery-mode') {
+        return [
+            ...baseSteps,
+            createStep('tool.runtime-inspector', 'register-tool', 'Register Runtime Inspector', !hasBlockedPreflight),
+            createStep('manager.core-observability', 'initialize-manager', 'Initialize core observability manager', !hasBlockedPreflight)
+        ];
+    }
+    if (target.profile === 'repo-inspect-only') {
+        return [
+            ...baseSteps,
+            createStep('service.repo-inspection', 'start-service', 'Start repository inspection service', !hasBlockedPreflight),
+            createStep('worker.repo-index', 'launch-worker', 'Launch repository indexing worker', !hasBlockedPreflight),
+            createStep('tool.runtime-inspector', 'register-tool', 'Register Runtime Inspector', !hasBlockedPreflight)
+        ];
+    }
+    return [
+        ...baseSteps,
+        createStep('store.workspace', 'mount-store', 'Mount workspace stores', !hasBlockedPreflight),
+        createStep('service.runtime-api', 'start-service', 'Start runtime API services', !hasBlockedPreflight),
+        createStep('manager.workspace', 'initialize-manager', 'Initialize workspace managers', !hasBlockedPreflight),
+        createStep('tool.registry', 'register-tool', 'Register workspace tools', !hasBlockedPreflight),
+        createStep('watcher.workspace', 'activate-watcher', 'Activate workspace watchers', !hasBlockedPreflight),
+        createStep('worker.background', 'launch-worker', 'Launch background workers', !hasBlockedPreflight)
+    ];
+}
+function createStep(id, kind, label, enabled) {
+    return {
+        id,
+        kind,
+        label,
+        status: enabled ? 'planned' : 'blocked',
+        critical: kind !== 'activate-watcher' && kind !== 'launch-worker',
+        reason: enabled ? null : 'Blocked by preflight.'
+    };
+}
+function createWarnings(checks) {
+    return checks.map((check) => ({
+        id: check.id,
+        message: `${check.label}: ${check.message}`
+    }));
+}

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

@@ -0,0 +1,5 @@
+import type { WorkbenchRuntimeProjectionCatalogEntry, WorkbenchRuntimeSnapshot } from "../../domain/runtime/model.js";
+export declare function normalizeProjectionCatalogFromWorkspace(workspace: WorkbenchRuntimeSnapshot['workspace']): WorkbenchRuntimeProjectionCatalogEntry[];
+export declare function normalizeProjectionCatalogFromEvent(payload: unknown, fallback: WorkbenchRuntimeProjectionCatalogEntry[]): WorkbenchRuntimeProjectionCatalogEntry[];
+export declare function normalizeProjectionCatalogEntry(value: unknown): WorkbenchRuntimeProjectionCatalogEntry | null;
+export declare function compareProjectionCatalogEntries(left: WorkbenchRuntimeProjectionCatalogEntry, right: WorkbenchRuntimeProjectionCatalogEntry): number;