@konitif/workbench 0.284.1

package/dist/domain/runtime/offload.js

@@ -0,0 +1,129 @@
+export function createRuntimeOffloadTask(input, timestamp = new Date().toISOString()) {
+    return {
+        id: input.id ?? `offload:${input.kind}:${timestamp}`,
+        kind: input.kind,
+        label: sanitizeText(input.label, 160),
+        priority: input.priority ?? 'normal',
+        status: 'queued',
+        progress: 0,
+        cancellable: input.cancellable ?? true,
+        createdAt: timestamp,
+        startedAt: null,
+        completedAt: null,
+        error: null,
+        payload: input.payload === undefined ? undefined : sanitizeJson(input.payload)
+    };
+}
+export function startRuntimeOffloadTask(task, timestamp = new Date().toISOString()) {
+    if (task.status !== 'queued') {
+        return task;
+    }
+    return {
+        ...task,
+        status: 'running',
+        startedAt: timestamp,
+        error: null
+    };
+}
+export function updateRuntimeOffloadTaskProgress(task, progress, _timestamp = new Date().toISOString()) {
+    if (task.status !== 'running') {
+        return task;
+    }
+    return {
+        ...task,
+        progress: clampProgress(progress)
+    };
+}
+export function completeRuntimeOffloadTask(task, result = undefined, timestamp = new Date().toISOString()) {
+    if (task.status !== 'running') {
+        return task;
+    }
+    return {
+        ...task,
+        status: 'completed',
+        progress: 100,
+        completedAt: timestamp,
+        error: null,
+        result: result === undefined ? task.result : sanitizeJson(result)
+    };
+}
+export function failRuntimeOffloadTask(task, error, timestamp = new Date().toISOString()) {
+    if (task.status !== 'running' && task.status !== 'queued') {
+        return task;
+    }
+    return {
+        ...task,
+        status: 'failed',
+        completedAt: timestamp,
+        error: sanitizeText(error, 500)
+    };
+}
+export function cancelRuntimeOffloadTask(task, timestamp = new Date().toISOString()) {
+    if (!task.cancellable || task.status === 'completed' || task.status === 'failed' || task.status === 'cancelled') {
+        return task;
+    }
+    return {
+        ...task,
+        status: 'cancelled',
+        completedAt: timestamp,
+        error: null
+    };
+}
+export function createRuntimeOffloadSnapshot(tasks, timestamp = new Date().toISOString()) {
+    const sortedTasks = [...tasks].sort(compareRuntimeOffloadTasks);
+    return {
+        generatedAt: timestamp,
+        activeTaskIds: sortedTasks.filter((task) => task.status === 'running').map((task) => task.id),
+        queue: sortedTasks.filter((task) => task.status === 'queued').map((task) => task.id),
+        tasks: sortedTasks,
+        totals: {
+            queued: sortedTasks.filter((task) => task.status === 'queued').length,
+            running: sortedTasks.filter((task) => task.status === 'running').length,
+            completed: sortedTasks.filter((task) => task.status === 'completed').length,
+            failed: sortedTasks.filter((task) => task.status === 'failed').length,
+            cancelled: sortedTasks.filter((task) => task.status === 'cancelled').length
+        }
+    };
+}
+export function compareRuntimeOffloadTasks(a, b) {
+    const priorityDelta = priorityWeight[b.priority] - priorityWeight[a.priority];
+    if (priorityDelta !== 0 && a.status === b.status && a.status === 'queued') {
+        return priorityDelta;
+    }
+    return a.createdAt.localeCompare(b.createdAt);
+}
+const priorityWeight = {
+    low: 0,
+    normal: 1,
+    high: 2,
+    urgent: 3
+};
+function clampProgress(progress) {
+    return Math.max(0, Math.min(100, Math.round(Number.isFinite(progress) ? progress : 0)));
+}
+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)) {
+        return depth >= 4 ? `[Array(${value.length})]` : 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/domain/runtime/plan.d.ts

@@ -0,0 +1,26 @@
+import type { LaunchPreflightSummary, LaunchProfile, LaunchTarget } from "../launch/model.js";
+export type RuntimePlanStepKind = 'mount-store' | 'start-service' | 'initialize-manager' | 'register-tool' | 'activate-watcher' | 'launch-worker' | 'observability-hook' | 'teardown-hook' | 'rollback-hook';
+export type RuntimePlanStepStatus = 'planned' | 'skipped' | 'blocked';
+export interface RuntimePlanStep {
+    id: string;
+    kind: RuntimePlanStepKind;
+    label: string;
+    status: RuntimePlanStepStatus;
+    critical: boolean;
+    reason: string | null;
+}
+export interface RuntimePlanWarning {
+    id: string;
+    message: string;
+}
+export interface RuntimePlan {
+    id: string;
+    target: LaunchTarget;
+    profile: LaunchProfile;
+    createdAt: string;
+    dryRun: boolean;
+    canExecute: boolean;
+    steps: RuntimePlanStep[];
+    warnings: RuntimePlanWarning[];
+    preflight: LaunchPreflightSummary | null;
+}

package/dist/domain/runtime/plan.js

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

package/dist/domain/runtime/qualityPolicy.d.ts

@@ -0,0 +1,28 @@
+export type RuntimeQualityMode = 'off' | 'low' | 'medium' | 'high';
+export type RuntimeQualityReason = 'requested' | 'hidden-tab' | 'reduced-motion' | 'battery-saver' | 'low-fps' | 'busy-offload' | 'low-concurrency' | 'recovery';
+export interface RuntimeQualityPolicyInput {
+    requestedQuality?: RuntimeQualityMode;
+    reducedMotion?: boolean;
+    batterySaver?: boolean;
+    hidden?: boolean;
+    fps?: number | null;
+    hardwareConcurrency?: number | null;
+    activeOffloadTasks?: number;
+    recovering?: boolean;
+}
+export interface RuntimeQualityPolicy {
+    requestedQuality: RuntimeQualityMode;
+    effectiveQuality: RuntimeQualityMode;
+    shouldAnimate: boolean;
+    reducedMotion: boolean;
+    budgets: {
+        particleCount: number;
+        blurPx: number;
+        ambientFps: number;
+        maxConcurrentOffloadTasks: number;
+        telemetrySampleRate: number;
+    };
+    reasons: RuntimeQualityReason[];
+}
+export declare function createRuntimeQualityPolicy(input?: RuntimeQualityPolicyInput): RuntimeQualityPolicy;
+export declare function shouldThrottleRuntimeQuality(policy: RuntimeQualityPolicy): boolean;

package/dist/domain/runtime/qualityPolicy.js

@@ -0,0 +1,97 @@
+export function createRuntimeQualityPolicy(input = {}) {
+    const requestedQuality = input.requestedQuality ?? 'medium';
+    const reasons = ['requested'];
+    let effectiveQuality = requestedQuality;
+    if (input.hidden) {
+        effectiveQuality = minQuality(effectiveQuality, 'low');
+        reasons.push('hidden-tab');
+    }
+    if (input.reducedMotion) {
+        effectiveQuality = minQuality(effectiveQuality, 'low');
+        reasons.push('reduced-motion');
+    }
+    if (input.batterySaver) {
+        effectiveQuality = minQuality(effectiveQuality, 'low');
+        reasons.push('battery-saver');
+    }
+    if (typeof input.fps === 'number' && Number.isFinite(input.fps) && input.fps > 0 && input.fps < 28) {
+        effectiveQuality = downshiftQuality(effectiveQuality);
+        reasons.push('low-fps');
+    }
+    if ((input.activeOffloadTasks ?? 0) >= 3) {
+        effectiveQuality = minQuality(effectiveQuality, 'medium');
+        reasons.push('busy-offload');
+    }
+    if (typeof input.hardwareConcurrency === 'number' && Number.isFinite(input.hardwareConcurrency) && input.hardwareConcurrency > 0 && input.hardwareConcurrency <= 2) {
+        effectiveQuality = minQuality(effectiveQuality, 'low');
+        reasons.push('low-concurrency');
+    }
+    if (input.recovering) {
+        effectiveQuality = minQuality(effectiveQuality, 'low');
+        reasons.push('recovery');
+    }
+    const budgets = createBudgets(effectiveQuality);
+    const shouldAnimate = effectiveQuality !== 'off' && !input.reducedMotion && !input.hidden;
+    return {
+        requestedQuality,
+        effectiveQuality,
+        shouldAnimate,
+        reducedMotion: input.reducedMotion ?? false,
+        budgets: {
+            ...budgets,
+            maxConcurrentOffloadTasks: Math.max(1, Math.min(budgets.maxConcurrentOffloadTasks, Math.max(1, Math.floor(input.hardwareConcurrency ?? budgets.maxConcurrentOffloadTasks))))
+        },
+        reasons: uniqueReasons(reasons)
+    };
+}
+export function shouldThrottleRuntimeQuality(policy) {
+    return policy.effectiveQuality === 'off' || policy.effectiveQuality === 'low' || policy.reasons.some((reason) => reason !== 'requested');
+}
+const qualityOrder = ['off', 'low', 'medium', 'high'];
+function minQuality(current, cap) {
+    return qualityOrder[Math.min(qualityOrder.indexOf(current), qualityOrder.indexOf(cap))] ?? 'medium';
+}
+function downshiftQuality(current) {
+    const index = qualityOrder.indexOf(current);
+    return qualityOrder[Math.max(0, index - 1)] ?? 'low';
+}
+function createBudgets(quality) {
+    switch (quality) {
+        case 'off':
+            return {
+                particleCount: 0,
+                blurPx: 0,
+                ambientFps: 0,
+                maxConcurrentOffloadTasks: 1,
+                telemetrySampleRate: 0.25
+            };
+        case 'low':
+            return {
+                particleCount: 18,
+                blurPx: 8,
+                ambientFps: 12,
+                maxConcurrentOffloadTasks: 1,
+                telemetrySampleRate: 0.5
+            };
+        case 'high':
+            return {
+                particleCount: 96,
+                blurPx: 24,
+                ambientFps: 60,
+                maxConcurrentOffloadTasks: 4,
+                telemetrySampleRate: 1
+            };
+        case 'medium':
+        default:
+            return {
+                particleCount: 48,
+                blurPx: 16,
+                ambientFps: 30,
+                maxConcurrentOffloadTasks: 2,
+                telemetrySampleRate: 0.75
+            };
+    }
+}
+function uniqueReasons(reasons) {
+    return [...new Set(reasons)];
+}

package/dist/domain/runtime/recovery.d.ts

@@ -0,0 +1,61 @@
+import type { LaunchPhase, LaunchTarget } from "../launch/model.js";
+export type RuntimeRecoveryCause = 'launch-failed' | 'initialization-failed' | 'hydration-failed' | 'suspension-failed' | 'resume-failed' | 'teardown-failed' | 'crash' | 'manual';
+export type RuntimeRecoveryActionKind = 'capture-failed-launch-report' | 'load-last-known-good' | 'disable-tools' | 'disable-plugins' | 'boot-core-only' | 'export-diagnostic-bundle' | 'retry-preflight' | 'retry-safe-mode' | 'return-launch-gate';
+export type RuntimeRecoveryActionStatus = 'pending' | 'running' | 'completed' | 'failed';
+export interface RuntimeFailedLaunchReport {
+    id: string;
+    createdAt: string;
+    phase: LaunchPhase;
+    cause: RuntimeRecoveryCause;
+    target: LaunchTarget | null;
+    error: string;
+}
+export interface RuntimeDiagnosticBundle {
+    id: string;
+    createdAt: string;
+    failedLaunchReportId: string;
+    includedSections: string[];
+    sanitized: boolean;
+}
+export interface RuntimeRecoveryAction {
+    id: string;
+    kind: RuntimeRecoveryActionKind;
+    label: string;
+    status: RuntimeRecoveryActionStatus;
+    startedAt: string | null;
+    completedAt: string | null;
+    message: string | null;
+}
+export interface RuntimeRecoverySnapshot {
+    status: 'idle' | 'running' | 'completed' | 'failed';
+    cause: RuntimeRecoveryCause;
+    activeActionId: string | null;
+    progress: number;
+    report: RuntimeFailedLaunchReport;
+    diagnosticBundle: RuntimeDiagnosticBundle | null;
+    actions: RuntimeRecoveryAction[];
+    startedAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+    error: string | null;
+}
+export interface RuntimeSafeModeSnapshot {
+    active: boolean;
+    reason: string;
+    enteredAt: string;
+    profile: 'core-only';
+    disabledTools: string[];
+    disabledPlugins: string[];
+    failedLaunchReportId: string | null;
+    diagnosticBundleId: string | null;
+}
+export declare function createRuntimeRecoverySnapshot(input: {
+    phase: LaunchPhase;
+    cause: RuntimeRecoveryCause;
+    target: LaunchTarget | null;
+    error: string;
+}, timestamp?: string): RuntimeRecoverySnapshot;
+export declare function completeRuntimeRecoveryAction(snapshot: RuntimeRecoverySnapshot, actionId: string, timestamp?: string, message?: string | null): RuntimeRecoverySnapshot;
+export declare function failRuntimeRecoveryAction(snapshot: RuntimeRecoverySnapshot, actionId: string, error: string, timestamp?: string): RuntimeRecoverySnapshot;
+export declare function createRuntimeSafeModeSnapshot(recovery: RuntimeRecoverySnapshot | null, timestamp?: string, reason?: string): RuntimeSafeModeSnapshot;
+export declare function createRuntimeDiagnosticBundle(failedLaunchReportId: string, timestamp?: string): RuntimeDiagnosticBundle;

package/dist/domain/runtime/recovery.js

@@ -0,0 +1,129 @@
+const RECOVERY_ACTIONS = [
+    { kind: 'capture-failed-launch-report', label: 'Capture failed launch report' },
+    { kind: 'load-last-known-good', label: 'Load last known good config' },
+    { kind: 'disable-tools', label: 'Disable non-critical tools' },
+    { kind: 'disable-plugins', label: 'Disable plugins' },
+    { kind: 'boot-core-only', label: 'Boot core-only runtime' },
+    { kind: 'export-diagnostic-bundle', label: 'Export diagnostic bundle' },
+    { kind: 'retry-preflight', label: 'Retry from preflight' },
+    { kind: 'retry-safe-mode', label: 'Retry from safe mode' },
+    { kind: 'return-launch-gate', label: 'Return to launch gate' }
+];
+export function createRuntimeRecoverySnapshot(input, timestamp = new Date().toISOString()) {
+    const actions = RECOVERY_ACTIONS.map((action) => ({
+        id: `recovery:${action.kind}`,
+        kind: action.kind,
+        label: action.label,
+        status: 'pending',
+        startedAt: null,
+        completedAt: null,
+        message: null
+    }));
+    const firstAction = actions[0] ?? null;
+    return {
+        status: 'running',
+        cause: input.cause,
+        activeActionId: firstAction?.id ?? null,
+        progress: 0,
+        report: {
+            id: `failed-launch:${timestamp}`,
+            createdAt: timestamp,
+            phase: input.phase,
+            cause: input.cause,
+            target: input.target,
+            error: input.error
+        },
+        diagnosticBundle: null,
+        actions: firstAction
+            ? actions.map((action) => action.id === firstAction.id ? { ...action, status: 'running', startedAt: timestamp } : action)
+            : actions,
+        startedAt: timestamp,
+        updatedAt: timestamp,
+        completedAt: null,
+        error: input.error
+    };
+}
+export function completeRuntimeRecoveryAction(snapshot, actionId, timestamp = new Date().toISOString(), message = null) {
+    const actions = snapshot.actions.map((action) => action.id === actionId
+        ? {
+            ...action,
+            status: 'completed',
+            completedAt: timestamp,
+            message
+        }
+        : action);
+    const diagnosticBundle = actions.find((action) => action.id === actionId)?.kind === 'export-diagnostic-bundle'
+        ? createRuntimeDiagnosticBundle(snapshot.report.id, timestamp)
+        : snapshot.diagnosticBundle;
+    const nextPendingAction = actions.find((action) => action.status === 'pending') ?? null;
+    const nextActions = nextPendingAction
+        ? actions.map((action) => action.id === nextPendingAction.id
+            ? {
+                ...action,
+                status: 'running',
+                startedAt: timestamp
+            }
+            : action)
+        : actions;
+    const progress = calculateRecoveryProgress(nextActions);
+    const completed = progress >= 100;
+    return {
+        ...snapshot,
+        status: completed ? 'completed' : 'running',
+        activeActionId: completed ? null : nextPendingAction?.id ?? null,
+        progress,
+        diagnosticBundle,
+        actions: nextActions,
+        updatedAt: timestamp,
+        completedAt: completed ? timestamp : null,
+        error: null
+    };
+}
+export function failRuntimeRecoveryAction(snapshot, actionId, error, timestamp = new Date().toISOString()) {
+    const actions = snapshot.actions.map((action) => action.id === actionId
+        ? {
+            ...action,
+            status: 'failed',
+            completedAt: timestamp,
+            message: error
+        }
+        : action);
+    return {
+        ...snapshot,
+        status: 'failed',
+        activeActionId: null,
+        progress: calculateRecoveryProgress(actions),
+        actions,
+        updatedAt: timestamp,
+        completedAt: timestamp,
+        error
+    };
+}
+export function createRuntimeSafeModeSnapshot(recovery, timestamp = new Date().toISOString(), reason = 'Recovery switched to core-only safe mode.') {
+    return {
+        active: true,
+        reason,
+        enteredAt: timestamp,
+        profile: 'core-only',
+        disabledTools: ['non-critical-tools'],
+        disabledPlugins: ['external-plugins'],
+        failedLaunchReportId: recovery?.report.id ?? null,
+        diagnosticBundleId: recovery?.diagnosticBundle?.id ?? null
+    };
+}
+export function createRuntimeDiagnosticBundle(failedLaunchReportId, timestamp = new Date().toISOString()) {
+    return {
+        id: `diagnostic-bundle:${timestamp}`,
+        createdAt: timestamp,
+        failedLaunchReportId,
+        includedSections: ['launch-state', 'runtime-plan', 'lifecycle', 'debug-events', 'stack-traces'],
+        sanitized: true
+    };
+}
+function calculateRecoveryProgress(actions) {
+    if (actions.length === 0) {
+        return 100;
+    }
+    const resolvedActions = actions.filter((action) => action.status === 'completed').length;
+    return Math.round((resolvedActions / actions.length) * 100);
+}

package/dist/domain/runtime/suspension.d.ts

@@ -0,0 +1,32 @@
+export type RuntimeSuspensionOperation = 'suspend' | 'resume';
+export type RuntimeSuspensionStepStatus = 'pending' | 'running' | 'completed' | 'failed';
+export type RuntimeSuspensionStepKind = 'pause-watchers' | 'pause-workers' | 'freeze-sessions' | 'flush-writes' | 'checkpoint' | 'validate-checkpoint' | 'reconnect-services' | 'resume-watchers' | 'resume-workers' | 'rehydrate-state';
+export interface RuntimeSuspensionStep {
+    id: string;
+    kind: RuntimeSuspensionStepKind;
+    label: string;
+    status: RuntimeSuspensionStepStatus;
+    startedAt: string | null;
+    completedAt: string | null;
+    message: string | null;
+}
+export interface RuntimeSuspensionCheckpoint {
+    id: string;
+    createdAt: string;
+    reason: string;
+}
+export interface RuntimeSuspensionSnapshot {
+    operation: RuntimeSuspensionOperation;
+    status: 'idle' | 'running' | 'completed' | 'failed';
+    activeStepId: string | null;
+    progress: number;
+    checkpoint: RuntimeSuspensionCheckpoint | null;
+    steps: RuntimeSuspensionStep[];
+    startedAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+    error: string | null;
+}
+export declare function createRuntimeSuspensionSnapshot(operation: RuntimeSuspensionOperation, timestamp?: string, _reason?: string, checkpoint?: RuntimeSuspensionCheckpoint | null): RuntimeSuspensionSnapshot;
+export declare function completeRuntimeSuspensionStep(snapshot: RuntimeSuspensionSnapshot, stepId: string, timestamp?: string, message?: string | null): RuntimeSuspensionSnapshot;
+export declare function failRuntimeSuspensionStep(snapshot: RuntimeSuspensionSnapshot, stepId: string, error: string, timestamp?: string): RuntimeSuspensionSnapshot;

package/dist/domain/runtime/suspension.js

@@ -0,0 +1,107 @@
+const SUSPEND_STEPS = [
+    { kind: 'pause-watchers', label: 'Pause watchers' },
+    { kind: 'pause-workers', label: 'Pause workers' },
+    { kind: 'freeze-sessions', label: 'Freeze sessions' },
+    { kind: 'flush-writes', label: 'Flush writes' },
+    { kind: 'checkpoint', label: 'Create checkpoint' }
+];
+const RESUME_STEPS = [
+    { kind: 'validate-checkpoint', label: 'Validate checkpoint' },
+    { kind: 'reconnect-services', label: 'Reconnect services' },
+    { kind: 'rehydrate-state', label: 'Rehydrate state' },
+    { kind: 'resume-watchers', label: 'Resume watchers' },
+    { kind: 'resume-workers', label: 'Resume workers' }
+];
+export function createRuntimeSuspensionSnapshot(operation, timestamp = new Date().toISOString(), _reason = operation === 'suspend' ? 'User requested suspension.' : 'User requested resume.', checkpoint = null) {
+    const steps = (operation === 'suspend' ? SUSPEND_STEPS : RESUME_STEPS).map((step) => ({
+        id: `${operation}:${step.kind}`,
+        kind: step.kind,
+        label: step.label,
+        status: 'pending',
+        startedAt: null,
+        completedAt: null,
+        message: null
+    }));
+    const firstStep = steps[0] ?? null;
+    return {
+        operation,
+        status: 'running',
+        activeStepId: firstStep?.id ?? null,
+        progress: 0,
+        checkpoint,
+        steps: firstStep
+            ? steps.map((step) => step.id === firstStep.id ? { ...step, status: 'running', startedAt: timestamp } : step)
+            : steps,
+        startedAt: timestamp,
+        updatedAt: timestamp,
+        completedAt: null,
+        error: null
+    };
+}
+export function completeRuntimeSuspensionStep(snapshot, stepId, timestamp = new Date().toISOString(), message = null) {
+    const steps = snapshot.steps.map((step) => step.id === stepId
+        ? {
+            ...step,
+            status: 'completed',
+            completedAt: timestamp,
+            message
+        }
+        : step);
+    const nextPendingStep = steps.find((step) => step.status === 'pending') ?? null;
+    const nextSteps = nextPendingStep
+        ? steps.map((step) => step.id === nextPendingStep.id
+            ? {
+                ...step,
+                status: 'running',
+                startedAt: timestamp
+            }
+            : step)
+        : steps;
+    const progress = calculateSuspensionProgress(nextSteps);
+    const completed = progress >= 100;
+    const checkpoint = completed && snapshot.operation === 'suspend'
+        ? {
+            id: `checkpoint:${timestamp}`,
+            createdAt: timestamp,
+            reason: snapshot.checkpoint?.reason ?? 'Runtime suspended.'
+        }
+        : snapshot.checkpoint;
+    return {
+        ...snapshot,
+        status: completed ? 'completed' : 'running',
+        activeStepId: completed ? null : nextPendingStep?.id ?? null,
+        progress,
+        checkpoint,
+        steps: nextSteps,
+        updatedAt: timestamp,
+        completedAt: completed ? timestamp : null,
+        error: null
+    };
+}
+export function failRuntimeSuspensionStep(snapshot, stepId, error, timestamp = new Date().toISOString()) {
+    const steps = snapshot.steps.map((step) => step.id === stepId
+        ? {
+            ...step,
+            status: 'failed',
+            completedAt: timestamp,
+            message: error
+        }
+        : step);
+    return {
+        ...snapshot,
+        status: 'failed',
+        activeStepId: null,
+        progress: calculateSuspensionProgress(steps),
+        steps,
+        updatedAt: timestamp,
+        completedAt: timestamp,
+        error
+    };
+}
+function calculateSuspensionProgress(steps) {
+    if (steps.length === 0) {
+        return 100;
+    }
+    const resolvedSteps = steps.filter((step) => step.status === 'completed').length;
+    return Math.round((resolvedSteps / steps.length) * 100);
+}

package/dist/domain/runtime/teardown.d.ts

@@ -0,0 +1,33 @@
+export type RuntimeTeardownStepStatus = 'pending' | 'running' | 'completed' | 'failed';
+export type RuntimeTeardownStepKind = 'stop-services' | 'dispose-managers' | 'terminate-workers' | 'unsubscribe-stores' | 'flush-logs' | 'persist-final-checkpoint' | 'close-repo-handles' | 'return-launch-gate';
+export interface RuntimeTeardownStep {
+    id: string;
+    kind: RuntimeTeardownStepKind;
+    label: string;
+    status: RuntimeTeardownStepStatus;
+    startedAt: string | null;
+    completedAt: string | null;
+    message: string | null;
+}
+export interface RuntimeTeardownReport {
+    id: string;
+    createdAt: string;
+    reason: string;
+    completedSteps: number;
+    failedStepId: string | null;
+}
+export interface RuntimeTeardownSnapshot {
+    status: 'idle' | 'running' | 'completed' | 'failed';
+    activeStepId: string | null;
+    progress: number;
+    reason: string;
+    report: RuntimeTeardownReport | null;
+    steps: RuntimeTeardownStep[];
+    startedAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+    error: string | null;
+}
+export declare function createRuntimeTeardownSnapshot(timestamp?: string, reason?: string): RuntimeTeardownSnapshot;
+export declare function completeRuntimeTeardownStep(snapshot: RuntimeTeardownSnapshot, stepId: string, timestamp?: string, message?: string | null): RuntimeTeardownSnapshot;
+export declare function failRuntimeTeardownStep(snapshot: RuntimeTeardownSnapshot, stepId: string, error: string, timestamp?: string): RuntimeTeardownSnapshot;