@konitif/workbench 0.284.1

package/dist/application/physics/PhysicsService.js

@@ -0,0 +1,2 @@
+/** Compatibility export from the physical domain owner. */
+export { PhysicsService } from '@konitif/physics';

package/dist/application/project/ProjectManifest.d.ts

@@ -0,0 +1,15 @@
+import type { WorkbenchProjectApp, WorkbenchProjectLaunchProfile, WorkbenchProjectManifest, WorkbenchProjectRepository, WorkbenchProjectTargetKind } from "../../domain/project/model.js";
+export interface CreateWorkbenchProjectManifestInput {
+    id: string;
+    label: string;
+    apps?: WorkbenchProjectApp[];
+    repositories?: WorkbenchProjectRepository[];
+    launchProfiles?: WorkbenchProjectLaunchProfile[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+export declare function createWorkbenchProjectManifest(input: CreateWorkbenchProjectManifestInput, now?: string): WorkbenchProjectManifest;
+export declare function createDefaultProjectLaunchProfiles(): WorkbenchProjectLaunchProfile[];
+export declare function addProjectRepository(manifest: WorkbenchProjectManifest, repository: WorkbenchProjectRepository, now?: string): WorkbenchProjectManifest;
+export declare function addProjectApp(manifest: WorkbenchProjectManifest, app: WorkbenchProjectApp, now?: string): WorkbenchProjectManifest;
+export declare function resolveProjectDefaultLaunchProfile(manifest: WorkbenchProjectManifest, targetKind: WorkbenchProjectTargetKind | 'self', targetProfileId?: string | null): WorkbenchProjectLaunchProfile | null;

package/dist/application/project/ProjectManifest.js

@@ -0,0 +1,107 @@
+export function createWorkbenchProjectManifest(input, now = new Date().toISOString()) {
+    return {
+        id: input.id,
+        label: input.label,
+        version: 1,
+        apps: dedupeById(input.apps ?? []),
+        repositories: dedupeById(input.repositories ?? []),
+        launchProfiles: dedupeById(input.launchProfiles ?? createDefaultProjectLaunchProfiles()),
+        policies: {
+            allowLocalRepositories: true,
+            allowSandboxRepositories: true,
+            requirePreflight: true
+        },
+        recentSessions: [],
+        observability: {
+            quality: 'medium',
+            persistSnapshots: false,
+            captureStackTraces: true
+        },
+        createdAt: input.createdAt ?? now,
+        updatedAt: input.updatedAt ?? now
+    };
+}
+export function createDefaultProjectLaunchProfiles() {
+    return [
+        {
+            id: 'profile.core-only',
+            label: 'Core-only',
+            kind: 'core-only',
+            targetKind: 'self',
+            defaultFor: 'self',
+            inspectOnly: true,
+            safeMode: true
+        },
+        {
+            id: 'profile.repo-inspect-only',
+            label: 'Repo inspect-only',
+            kind: 'repo-inspect-only',
+            targetKind: 'repository',
+            defaultFor: null,
+            inspectOnly: true,
+            safeMode: true
+        },
+        {
+            id: 'profile.app-safe-mode',
+            label: 'App safe mode',
+            kind: 'app-safe-mode',
+            targetKind: 'app',
+            defaultFor: null,
+            inspectOnly: false,
+            safeMode: true
+        },
+        {
+            id: 'profile.app-full-runtime',
+            label: 'App full runtime',
+            kind: 'app-full-runtime',
+            targetKind: 'app',
+            defaultFor: 'app',
+            inspectOnly: false,
+            safeMode: false
+        },
+        {
+            id: 'profile.sandbox-runtime',
+            label: 'Sandbox runtime',
+            kind: 'sandbox-runtime',
+            targetKind: 'repository',
+            defaultFor: 'repository',
+            inspectOnly: false,
+            safeMode: false
+        },
+        {
+            id: 'profile.recovery-mode',
+            label: 'Recovery mode',
+            kind: 'recovery-mode',
+            targetKind: 'self',
+            defaultFor: null,
+            inspectOnly: true,
+            safeMode: true
+        }
+    ];
+}
+export function addProjectRepository(manifest, repository, now = new Date().toISOString()) {
+    return {
+        ...manifest,
+        repositories: upsertById(manifest.repositories, repository),
+        updatedAt: now
+    };
+}
+export function addProjectApp(manifest, app, now = new Date().toISOString()) {
+    return {
+        ...manifest,
+        apps: upsertById(manifest.apps, app),
+        updatedAt: now
+    };
+}
+export function resolveProjectDefaultLaunchProfile(manifest, targetKind, targetProfileId) {
+    return (manifest.launchProfiles.find((profile) => profile.id === targetProfileId) ??
+        manifest.launchProfiles.find((profile) => profile.defaultFor === targetKind) ??
+        null);
+}
+function dedupeById(items) {
+    return [...new Map(items.map((item) => [item.id, item])).values()];
+}
+function upsertById(items, nextItem) {
+    const nextItems = items.filter((item) => item.id !== nextItem.id);
+    return [...nextItems, nextItem];
+}

package/dist/application/repository/RepositoryPreflightEngine.d.ts

@@ -0,0 +1,6 @@
+import type { LaunchPreflightSummary, LaunchTarget } from "../../domain/launch/model.js";
+import type { RepositoryInspectionInput, RepositoryInspectionSnapshot } from "../../domain/repository/model.js";
+export declare class RepositoryPreflightEngine {
+    inspect(input: RepositoryInspectionInput, now?: string): RepositoryInspectionSnapshot;
+}
+export declare function createRepositoryLaunchPreflightSummary(target: LaunchTarget, report: RepositoryInspectionSnapshot, now?: string): LaunchPreflightSummary;

package/dist/application/repository/RepositoryPreflightEngine.js

@@ -0,0 +1,301 @@
+const CONFIG_FILES = [
+    'package.json',
+    'pnpm-workspace.yaml',
+    'vite.config.ts',
+    'vite.config.js',
+    'svelte.config.js',
+    'svelte.config.ts',
+    'tsconfig.json',
+    'eslint.config.js',
+    'playwright.config.ts',
+    'vitest.config.ts'
+];
+export class RepositoryPreflightEngine {
+    inspect(input, now = new Date().toISOString()) {
+        const root = input.root.trim();
+        const files = new Set((input.files ?? []).map(normalizeRepoPath));
+        const packageManager = detectPackageManager(files);
+        const dependencies = normalizeDependencies(input.packageJson);
+        const frameworks = detectFrameworks(files, dependencies);
+        const buildTools = detectBuildTools(files, dependencies, input.packageJson?.scripts);
+        const scripts = normalizeScripts(input.packageJson?.scripts);
+        const workspaces = normalizeWorkspaces(input.packageJson?.workspaces);
+        const configs = CONFIG_FILES.filter((file) => files.has(file));
+        const summary = createRepositoryInspectionSummary({
+            frameworks,
+            buildTools,
+            scripts,
+            configs,
+            workspaces
+        });
+        const inspectOnly = input.inspectOnly ?? false;
+        const findings = createRepositoryFindings({
+            root,
+            packageManager,
+            hasPackageJson: Boolean(input.packageJson) || files.has('package.json'),
+            scripts,
+            gitDirty: input.git?.dirty ?? false
+        });
+        const hasBlockedFinding = findings.some((finding) => finding.severity === 'blocked');
+        return {
+            id: `repository:${root || 'unresolved'}`,
+            label: input.label?.trim() || deriveRepositoryLabel(root),
+            root,
+            generatedAt: now,
+            packageName: normalizeNullableString(input.packageJson?.name),
+            packageVersion: normalizeNullableString(input.packageJson?.version),
+            packageManager,
+            frameworks,
+            buildTools,
+            scripts,
+            workspaces: workspaces.length > 0 ? { patterns: workspaces } : null,
+            git: input.git
+                ? {
+                    branch: normalizeNullableString(input.git.branch),
+                    commit: normalizeNullableString(input.git.commit),
+                    dirty: input.git.dirty ?? false
+                }
+                : null,
+            configs,
+            summary,
+            findings,
+            inspectOnly,
+            canLaunch: !hasBlockedFinding && !inspectOnly
+        };
+    }
+}
+export function createRepositoryLaunchPreflightSummary(target, report, now = new Date().toISOString()) {
+    const checks = [
+        {
+            id: 'launch.project.target',
+            label: 'Project target',
+            status: report.root ? 'ready' : 'blocked',
+            message: report.root || 'No project root selected.'
+        },
+        {
+            id: 'launch.repository.package-manager',
+            label: 'Package manager',
+            status: report.packageManager === 'unknown' ? 'warning' : 'ready',
+            message: report.packageManager === 'unknown'
+                ? 'No lockfile was detected in the repository projection.'
+                : `${report.packageManager} lockfile detected.`
+        },
+        {
+            id: 'launch.repository.scripts',
+            label: 'Scripts',
+            status: report.scripts.length > 0 ? 'ready' : 'warning',
+            message: report.scripts.length > 0
+                ? `${report.scripts.length} package script(s) available.`
+                : 'No package scripts were provided in the repository projection.'
+        },
+        {
+            id: 'launch.repository.git',
+            label: 'Git state',
+            status: report.git?.dirty ? 'warning' : 'ready',
+            message: report.git
+                ? `${report.git.branch ?? 'detached'}${report.git.dirty ? ' has local changes.' : ' is clean.'}`
+                : 'No git metadata provided.'
+        },
+        {
+            id: 'launch.repository.mode',
+            label: 'Launch mode',
+            status: report.canLaunch ? 'ready' : report.inspectOnly ? 'warning' : 'blocked',
+            message: report.inspectOnly
+                ? 'Repository is configured for inspect-only preflight.'
+                : report.canLaunch
+                    ? 'Repository can enter workspace initialization.'
+                    : 'Repository cannot launch until blocked findings are resolved.'
+        }
+    ];
+    return {
+        target,
+        checks,
+        generatedAt: now,
+        repository: report
+    };
+}
+function detectPackageManager(files) {
+    if (files.has('pnpm-lock.yaml')) {
+        return 'pnpm';
+    }
+    if (files.has('package-lock.json')) {
+        return 'npm';
+    }
+    if (files.has('yarn.lock')) {
+        return 'yarn';
+    }
+    if (files.has('bun.lockb') || files.has('bun.lock')) {
+        return 'bun';
+    }
+    return 'unknown';
+}
+function normalizeScripts(scripts) {
+    return Object.entries(scripts ?? {})
+        .filter((entry) => typeof entry[0] === 'string' && typeof entry[1] === 'string')
+        .map(([name, command]) => ({
+        name,
+        command,
+        kind: classifyScript(name, command)
+    }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+function classifyScript(name, command) {
+    const normalizedName = name.toLowerCase();
+    const normalizedCommand = command.toLowerCase();
+    if (normalizedName.includes('dev') || normalizedCommand.includes(' dev')) {
+        return 'dev';
+    }
+    if (normalizedName.includes('build') || normalizedCommand.includes(' build')) {
+        return 'build';
+    }
+    if (normalizedName.includes('test') || normalizedCommand.includes('vitest') || normalizedCommand.includes('playwright')) {
+        return 'test';
+    }
+    if (normalizedName.includes('lint') || normalizedCommand.includes('eslint')) {
+        return 'lint';
+    }
+    if (normalizedName.includes('format') || normalizedCommand.includes('prettier')) {
+        return 'format';
+    }
+    if (normalizedName.includes('preview') || normalizedCommand.includes(' preview')) {
+        return 'preview';
+    }
+    if (normalizedName.includes('check') || normalizedCommand.includes('svelte-check') || normalizedCommand.includes('tsc')) {
+        return 'check';
+    }
+    return 'other';
+}
+function createRepositoryInspectionSummary(input) {
+    return {
+        primaryFramework: input.frameworks.find((framework) => framework !== 'unknown') ?? 'unknown',
+        primaryBuildTool: input.buildTools.find((tool) => tool !== 'unknown') ?? 'unknown',
+        launchCommand: input.scripts.find((script) => script.kind === 'dev')?.command ??
+            input.scripts.find((script) => script.kind === 'preview')?.command ??
+            input.scripts.find((script) => script.kind === 'build')?.command ??
+            null,
+        testCommand: input.scripts.find((script) => script.kind === 'test')?.command ??
+            input.scripts.find((script) => script.kind === 'check')?.command ??
+            null,
+        scriptKinds: [...new Set(input.scripts.map((script) => script.kind))].sort((left, right) => left.localeCompare(right)),
+        configCount: input.configs.length,
+        workspacePackageCount: input.workspaces.length
+    };
+}
+function normalizeDependencies(packageJson) {
+    return new Set([
+        ...Object.keys(packageJson?.dependencies ?? {}),
+        ...Object.keys(packageJson?.devDependencies ?? {})
+    ]);
+}
+function detectFrameworks(files, dependencies) {
+    const frameworks = [];
+    if (files.has('svelte.config.js') || files.has('svelte.config.ts') || dependencies.has('svelte') || dependencies.has('@sveltejs/kit')) {
+        frameworks.push('svelte');
+    }
+    if (dependencies.has('react') || dependencies.has('react-dom') || dependencies.has('next')) {
+        frameworks.push('react');
+    }
+    if (dependencies.has('vue') || dependencies.has('nuxt')) {
+        frameworks.push('vue');
+    }
+    if (dependencies.has('solid-js')) {
+        frameworks.push('solid');
+    }
+    return frameworks.length > 0 ? frameworks : ['unknown'];
+}
+function detectBuildTools(files, dependencies, scripts) {
+    const tools = new Set();
+    const scriptText = Object.values(scripts ?? {}).join(' ').toLowerCase();
+    if (files.has('vite.config.ts') || files.has('vite.config.js') || dependencies.has('vite') || scriptText.includes('vite')) {
+        tools.add('vite');
+    }
+    if (dependencies.has('@sveltejs/kit') || scriptText.includes('svelte-kit')) {
+        tools.add('sveltekit');
+    }
+    if (dependencies.has('next') || scriptText.includes('next ')) {
+        tools.add('next');
+    }
+    if (dependencies.has('nuxt') || scriptText.includes('nuxt')) {
+        tools.add('nuxt');
+    }
+    if (files.has('vitest.config.ts') || dependencies.has('vitest') || scriptText.includes('vitest')) {
+        tools.add('vitest');
+    }
+    if (files.has('playwright.config.ts') || dependencies.has('@playwright/test') || scriptText.includes('playwright')) {
+        tools.add('playwright');
+    }
+    if (files.has('tsconfig.json') || dependencies.has('typescript') || scriptText.includes('tsc')) {
+        tools.add('typescript');
+    }
+    return tools.size > 0 ? [...tools] : ['unknown'];
+}
+function normalizeWorkspaces(workspaces) {
+    const patterns = Array.isArray(workspaces) ? workspaces : workspaces?.packages ?? [];
+    return patterns
+        .filter((pattern) => typeof pattern === 'string' && pattern.trim().length > 0)
+        .map((pattern) => normalizeRepoPath(pattern))
+        .sort((left, right) => left.localeCompare(right));
+}
+function createRepositoryFindings(input) {
+    const findings = [];
+    if (!input.root) {
+        findings.push({
+            id: 'repo.root.missing',
+            severity: 'blocked',
+            title: 'Repository root missing',
+            message: 'Select a repository root before running preflight.'
+        });
+    }
+    if (!input.hasPackageJson) {
+        findings.push({
+            id: 'repo.package.missing',
+            severity: 'warning',
+            title: 'Package manifest missing',
+            message: 'No package.json was provided in the repository projection.'
+        });
+    }
+    if (input.packageManager === 'unknown') {
+        findings.push({
+            id: 'repo.package-manager.unknown',
+            severity: 'warning',
+            title: 'Package manager unknown',
+            message: 'No known lockfile was detected.'
+        });
+    }
+    if (input.scripts.length === 0) {
+        findings.push({
+            id: 'repo.scripts.empty',
+            severity: 'warning',
+            title: 'No scripts detected',
+            message: 'Preflight cannot infer build or test commands from package scripts.'
+        });
+    }
+    if (input.gitDirty) {
+        findings.push({
+            id: 'repo.git.dirty',
+            severity: 'warning',
+            title: 'Local changes detected',
+            message: 'The repository projection reports uncommitted local changes.'
+        });
+    }
+    if (findings.length === 0) {
+        findings.push({
+            id: 'repo.preflight.ready',
+            severity: 'info',
+            title: 'Repository ready',
+            message: 'Repository projection contains enough metadata for launch planning.'
+        });
+    }
+    return findings;
+}
+function normalizeRepoPath(path) {
+    return path.replace(/\\/g, '/').replace(/^\.\/+/, '').trim();
+}
+function normalizeNullableString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+function deriveRepositoryLabel(root) {
+    const normalized = normalizeRepoPath(root);
+    const segments = normalized.split('/').filter(Boolean);
+    return segments[segments.length - 1] ?? 'Repository';
+}

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

@@ -0,0 +1,9 @@
+import type { WorkbenchRuntimeAppPreviewDescriptor, WorkbenchRuntimeBackendPort, WorkbenchRuntimeProjectionInvalidationResult, WorkbenchRuntimeSharedStatePatch } from "../../domain/runtime/model.js";
+export type RuntimeBackendConnection = {
+    loadProjection<TProjection = unknown>(kind: string, params?: Record<string, string>): Promise<TProjection>;
+    invalidateProjection(kind: string, params?: Record<string, string>): Promise<WorkbenchRuntimeProjectionInvalidationResult>;
+    startAppPreview(root?: string): Promise<WorkbenchRuntimeAppPreviewDescriptor>;
+    listSharedState(): Promise<unknown[]>;
+    patchSharedState(key: string, patch: WorkbenchRuntimeSharedStatePatch): Promise<unknown>;
+};
+export declare function createRuntimeBackendConnection(backend: WorkbenchRuntimeBackendPort | null): RuntimeBackendConnection;

package/dist/application/runtime/RuntimeBackendConnection.js

@@ -0,0 +1,34 @@
+export function createRuntimeBackendConnection(backend) {
+    return {
+        async loadProjection(kind, params) {
+            if (!backend) {
+                throw new Error('Runtime backend is unavailable.');
+            }
+            return backend.getProjection(kind, params);
+        },
+        async invalidateProjection(kind, params) {
+            if (!backend) {
+                throw new Error('Runtime backend is unavailable.');
+            }
+            return backend.invalidateProjection(kind, params);
+        },
+        async startAppPreview(root) {
+            if (!backend?.startAppPreview) {
+                throw new Error('Backend app preview is unavailable.');
+            }
+            return backend.startAppPreview(root);
+        },
+        async listSharedState() {
+            if (!backend?.listSharedState) {
+                return [];
+            }
+            return backend.listSharedState();
+        },
+        async patchSharedState(key, patch) {
+            if (!backend?.patchSharedState) {
+                throw new Error('Backend shared state is unavailable.');
+            }
+            return backend.patchSharedState(key, patch);
+        }
+    };
+}

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

@@ -0,0 +1,8 @@
+import type { WorkbenchRuntimeSubscription } from "../../domain/runtime/model.js";
+export type RuntimeBackendSubscriptionOwner = {
+    replace(subscription: WorkbenchRuntimeSubscription): void;
+    replaceWith(create: () => WorkbenchRuntimeSubscription): void;
+    disconnect(): void;
+    hasActiveSubscription(): boolean;
+};
+export declare function createRuntimeBackendSubscriptionOwner(): RuntimeBackendSubscriptionOwner;

package/dist/application/runtime/RuntimeBackendSubscription.js

@@ -0,0 +1,52 @@
+export function createRuntimeBackendSubscriptionOwner() {
+    // Retain failed cleanup too: a thrown dispose never relinquishes ownership.
+    const owned = new Set();
+    function release(subscription, errors) {
+        try {
+            subscription.dispose();
+            owned.delete(subscription);
+        }
+        catch (error) {
+            errors.push(error);
+        }
+    }
+    function report(errors) {
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1)
+            throw new AggregateError(errors, 'Subscription cleanup failed');
+    }
+    return {
+        replaceWith(create) {
+            const errors = [];
+            for (const subscription of [...owned])
+                release(subscription, errors);
+            report(errors);
+            // No acquisition until every previous release has succeeded.
+            // The factory owns cleanup of any partial acquisition if it throws.
+            owned.add(create());
+        },
+        replace(subscription) {
+            if (owned.has(subscription))
+                return;
+            const errors = [];
+            for (const previous of [...owned])
+                release(previous, errors);
+            owned.add(subscription);
+            // The already-acquired candidate transfers to this owner even on failure.
+            // Reject it by cleanup, retaining it if that cleanup also fails.
+            if (errors.length > 0)
+                release(subscription, errors);
+            report(errors);
+        },
+        disconnect() {
+            const errors = [];
+            for (const subscription of [...owned])
+                release(subscription, errors);
+            report(errors);
+        },
+        hasActiveSubscription() {
+            return owned.size > 0;
+        }
+    };
+}

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

@@ -0,0 +1,20 @@
+import { type RuntimeCheckpoint, type RuntimeCheckpointInput, type RuntimeCheckpointSnapshot } from "../../domain/runtime/checkpoint.js";
+export interface RuntimeCheckpointStoreOptions {
+    maxEntries?: number;
+    now?: () => string;
+}
+export declare class RuntimeCheckpointStore {
+    private readonly maxEntries;
+    private readonly now;
+    private checkpoints;
+    private lastKnownGoodId;
+    constructor(options?: RuntimeCheckpointStoreOptions);
+    save(input: RuntimeCheckpointInput): RuntimeCheckpoint;
+    update(id: string, data: unknown): RuntimeCheckpoint | null;
+    get(id: string): RuntimeCheckpoint | null;
+    list(): RuntimeCheckpoint[];
+    remove(id: string): boolean;
+    markLastKnownGood(id: string): RuntimeCheckpoint | null;
+    restore(id: string): RuntimeCheckpoint | null;
+    createSnapshot(timestamp?: string): RuntimeCheckpointSnapshot;
+}

package/dist/application/runtime/RuntimeCheckpointStore.js

@@ -0,0 +1,65 @@
+import { createRuntimeCheckpoint, createRuntimeCheckpointSnapshot, updateRuntimeCheckpoint } from "../../domain/runtime/checkpoint.js";
+export class RuntimeCheckpointStore {
+    maxEntries;
+    now;
+    checkpoints = [];
+    lastKnownGoodId = null;
+    constructor(options = {}) {
+        this.maxEntries = Math.max(1, Math.floor(options.maxEntries ?? 50));
+        this.now = options.now ?? (() => new Date().toISOString());
+    }
+    save(input) {
+        const checkpoint = createRuntimeCheckpoint(input, this.now());
+        const existing = this.checkpoints.filter((candidate) => candidate.id !== checkpoint.id);
+        this.checkpoints = [checkpoint, ...existing].slice(0, this.maxEntries);
+        if (checkpoint.kind === 'last-known-good') {
+            this.lastKnownGoodId = checkpoint.id;
+        }
+        return checkpoint;
+    }
+    update(id, data) {
+        const checkpoint = this.get(id);
+        if (!checkpoint) {
+            return null;
+        }
+        const updated = updateRuntimeCheckpoint(checkpoint, data, this.now());
+        this.checkpoints = this.checkpoints.map((candidate) => candidate.id === id ? updated : candidate);
+        return updated;
+    }
+    get(id) {
+        return this.checkpoints.find((checkpoint) => checkpoint.id === id) ?? null;
+    }
+    list() {
+        return [...this.checkpoints];
+    }
+    remove(id) {
+        const previousLength = this.checkpoints.length;
+        this.checkpoints = this.checkpoints.filter((checkpoint) => checkpoint.id !== id);
+        if (this.lastKnownGoodId === id) {
+            this.lastKnownGoodId = null;
+        }
+        return this.checkpoints.length !== previousLength;
+    }
+    markLastKnownGood(id) {
+        const checkpoint = this.get(id);
+        if (!checkpoint) {
+            return null;
+        }
+        const lastKnownGood = {
+            ...checkpoint,
+            id: `last-known-good:${checkpoint.id}`,
+            kind: 'last-known-good',
+            label: `Last known good - ${checkpoint.label}`,
+            updatedAt: this.now()
+        };
+        this.checkpoints = [lastKnownGood, ...this.checkpoints].slice(0, this.maxEntries);
+        this.lastKnownGoodId = lastKnownGood.id;
+        return lastKnownGood;
+    }
+    restore(id) {
+        return this.get(id);
+    }
+    createSnapshot(timestamp = this.now()) {
+        return createRuntimeCheckpointSnapshot(this.checkpoints, this.lastKnownGoodId, timestamp);
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { LaunchState } from "../../domain/launch/model.js";
+import type { RuntimeLaunchProgressSnapshot } from "../../domain/runtime/model.js";
+export declare function createRuntimeLaunchProgressSnapshot(state: LaunchState): RuntimeLaunchProgressSnapshot;

package/dist/application/runtime/RuntimeLaunchProgress.js

@@ -0,0 +1,38 @@
+export function createRuntimeLaunchProgressSnapshot(state) {
+    const checks = state.preflight?.checks ?? [];
+    const readyChecks = checks.filter((check) => check.status === 'ready').length;
+    const warningChecks = checks.filter((check) => check.status === 'warning').length;
+    const blockedChecks = checks.filter((check) => check.status === 'blocked').length;
+    if (state.hydration) {
+        return createRuntimeLaunchStepProgressSnapshot(state.phase, state.hydration.status, state.hydration.progress, state.hydration.activeStepId, state.hydration.steps.filter((step) => step.status === 'completed').length, state.hydration.steps.length, readyChecks, warningChecks, blockedChecks);
+    }
+    if (state.initialization) {
+        return createRuntimeLaunchStepProgressSnapshot(state.phase, state.initialization.status, state.initialization.progress, state.initialization.activeStepId, state.initialization.steps.filter((step) => step.status === 'completed' || step.status === 'skipped').length, state.initialization.steps.length, readyChecks, warningChecks, blockedChecks);
+    }
+    if (state.phase === 'RUNNING') {
+        return createRuntimeLaunchStepProgressSnapshot(state.phase, 'running', 100, null, 0, 0, readyChecks, warningChecks, blockedChecks);
+    }
+    if (state.plan) {
+        const plannedSteps = state.plan.steps.filter((step) => step.status === 'planned').length;
+        const blockedSteps = state.plan.steps.filter((step) => step.status === 'blocked').length;
+        const executable = state.plan.canExecute && blockedSteps === 0;
+        return createRuntimeLaunchStepProgressSnapshot(state.phase, executable ? 'planned' : 'blocked', executable ? 100 : 0, null, plannedSteps, state.plan.steps.length, readyChecks, warningChecks, blockedChecks);
+    }
+    if (checks.length > 0) {
+        return createRuntimeLaunchStepProgressSnapshot(state.phase, blockedChecks > 0 ? 'blocked' : warningChecks > 0 ? 'warning' : readyChecks === checks.length ? 'ready' : 'pending', checks.length ? Math.round((readyChecks / checks.length) * 100) : 0, checks.find((check) => check.status === 'pending' || check.status === 'blocked')?.id ?? null, readyChecks, checks.length, readyChecks, warningChecks, blockedChecks);
+    }
+    return createRuntimeLaunchStepProgressSnapshot(state.phase, state.error ? 'error' : state.phase.toLowerCase(), 0, null, 0, 0, 0, 0, 0);
+}
+function createRuntimeLaunchStepProgressSnapshot(phase, status, progress, activeStepId, completedSteps, totalSteps, readyChecks, warningChecks, blockedChecks) {
+    return {
+        phase,
+        status,
+        progress: Math.max(0, Math.min(100, Math.round(progress))),
+        activeStepId,
+        completedSteps,
+        totalSteps,
+        readyChecks,
+        warningChecks,
+        blockedChecks
+    };
+}