@konitif/workbench-runtime 0.284.1

package/LICENSE.md

@@ -0,0 +1,22 @@
+# Licence — @konitif/workbench-runtime
+
+SPDX-License-Identifier: PolyForm-Noncommercial-1.0.0
+
+The original KONITIF / Workbench code in this v0.x package is made available
+under the PolyForm Noncommercial License 1.0.0:
+https://polyformproject.org/licenses/noncommercial/1.0.0
+
+This notice incorporates the standard terms by reference; it is not a modified
+version of the licence. This is source-available software, not OSI open source.
+Third-party components retain their own licences and notices.
+
+Uses outside the standard licence's permitted purposes require a separate
+written licence. A public repository or npm download grants no additional
+commercial rights. Any free professional authorization must be explicit,
+nominative and limited to the agreed products; none is granted by this notice.
+
+The KONITIF name, logo and official identity belong to Maxime Mouflard.
+Descriptive reference is permitted. No third-party version may claim to be
+official, certified or approved without authorization. This trademark notice
+is separate from the software licence and does not amend its terms.
+

package/README.md

@@ -0,0 +1,60 @@
+# @konitif/workbench-runtime
+
+Public runtime orchestration for a KONITIF Workbench. It connects Workbench contracts to reactive application state without owning product semantics.
+
+Products compose this runtime and provide their own tools, widgets, persistence adapters and policies.
+
+## Autonomous distribution
+
+Run `npm run build`, `npm test` and `npm run verify:package` from this
+repository. The build emits ESM and declarations into `dist`; the verifier
+packs that compiled allowlist, checks its exact contents and consumes both
+public entries outside the source tree. No lifecycle script performs an
+installation or publication.
+
+The package depends on the published Workbench authority rather than a workspace
+locator. Only the archive retained by the release verifier may be published.
+
+## Explicit runtime entry
+
+```ts
+import {
+  createWorkbenchStoreRuntime,
+  type CreateWorkbenchStoreRuntimeOptions,
+} from '@konitif/workbench-runtime/runtime';
+```
+
+This entry requires all six host ports: `workspacePersistence`,
+`shellPersistence`, `focusPersistence`, `workspaceSync`, `hostEvents` and
+`detachedWindows`. Only the last two accept `null`, explicitly disabling those
+capabilities. Missing ports are rejected before providers are read.
+
+Port types are exported from the same entry. Workspace contracts remain owned
+by `@konitif/workbench/workspace-contracts`. The runtime owns its subscriptions,
+not the supplied shared providers; call `flushPersistence()` before `dispose()`
+if pending state must be saved. Disposal does not close native windows.
+
+The root entry retains `createWorkbenchStore` and its browser defaults for
+compatibility. The explicit entry selects no browser defaults, but still uses
+Svelte stores, global debounce timers and the existing identity generator.
+
+The npm distribution exposes compiled Node-compatible ESM and NodeNext
+declarations. Repository sources remain TypeScript and are not included in the
+archive.
+
+## Host notifications
+
+`createWorkbenchStore` accepts an optional `hostEvents` provider:
+
+- Omitted: browser `pagehide`, `beforeunload`, hidden visibility and `storage` notifications.
+- `null`: no subscriptions to those host events, even in a browser.
+- `WorkbenchHostEvents`: explicit provider returning an unsubscribe function for each subscription.
+
+The provider calls `onPersistenceBoundary()` or `onStorageChange({ key, newValue })`.
+It does not own workspace state or perform persistence. The coordinator filters
+storage notifications, reloads through its persistence ports and validates the
+workspace. Disposal unsubscribes without destroying a shared provider; it does
+not implicitly flush pending saves. Call `flushPersistence()` first when needed.
+
+This option does not disable `workspaceSync`, detached-window controls or default
+storage adapters. Supply those ports separately for a non-browser host.

package/dist/boot/createDemoWorkbenchBootGraph.d.ts

@@ -0,0 +1,9 @@
+import type { BootGraph } from '@konitif/workbench';
+export interface DemoWorkbenchBootGraphOptions {
+    stepDelayMs?: number;
+    delayMs?: number;
+    failStepId?: string;
+    failCritical?: boolean;
+}
+export type CreateDemoWorkbenchBootGraphOptions = DemoWorkbenchBootGraphOptions;
+export declare function createDemoWorkbenchBootGraph(options?: DemoWorkbenchBootGraphOptions): BootGraph;

package/dist/boot/createDemoWorkbenchBootGraph.js

@@ -0,0 +1,180 @@
+const DEMO_BOOT_STEPS = [
+    {
+        id: 'plan.validate-runtime-plan',
+        label: 'Validate runtime plan',
+        phase: 'plan',
+    },
+    {
+        id: 'plan.validate-boot-graph',
+        label: 'Validate boot graph',
+        phase: 'plan',
+        dependsOn: ['plan.validate-runtime-plan'],
+    },
+    {
+        id: 'initialize.persistence',
+        label: 'Initialize persistence',
+        phase: 'initialize',
+        dependsOn: ['plan.validate-boot-graph'],
+    },
+    {
+        id: 'initialize.workspace',
+        label: 'Initialize workspace',
+        phase: 'initialize',
+        dependsOn: ['initialize.persistence'],
+    },
+    {
+        id: 'initialize.shell',
+        label: 'Initialize shell',
+        phase: 'initialize',
+        dependsOn: ['initialize.workspace'],
+    },
+    {
+        id: 'initialize.layout-interactions',
+        label: 'Initialize layout interactions',
+        phase: 'initialize',
+        dependsOn: ['initialize.shell'],
+    },
+    {
+        id: 'initialize.observability',
+        label: 'Initialize observability',
+        phase: 'initialize',
+        dependsOn: ['initialize.layout-interactions'],
+    },
+    {
+        id: 'hydrate.workspace',
+        label: 'Hydrate workspace',
+        phase: 'hydrate',
+        dependsOn: ['initialize.workspace', 'initialize.observability'],
+    },
+    {
+        id: 'hydrate.shell',
+        label: 'Hydrate shell',
+        phase: 'hydrate',
+        dependsOn: ['hydrate.workspace', 'initialize.shell'],
+    },
+    {
+        id: 'hydrate.layout',
+        label: 'Hydrate layout',
+        phase: 'hydrate',
+        dependsOn: ['hydrate.shell', 'initialize.layout-interactions'],
+    },
+    {
+        id: 'hydrate.sessions',
+        label: 'Hydrate sessions',
+        phase: 'hydrate',
+        dependsOn: ['hydrate.layout'],
+    },
+    {
+        id: 'hydrate.projections',
+        label: 'Hydrate projections',
+        phase: 'hydrate',
+        dependsOn: ['hydrate.sessions', 'initialize.observability'],
+    },
+    {
+        id: 'run.history',
+        label: 'Attach history',
+        phase: 'run',
+        dependsOn: ['hydrate.shell'],
+    },
+    {
+        id: 'run.sync',
+        label: 'Attach sync',
+        phase: 'run',
+        dependsOn: ['hydrate.projections'],
+    },
+    {
+        id: 'run.persistence-subscriptions',
+        label: 'Attach persistence subscriptions',
+        phase: 'run',
+        dependsOn: ['run.history', 'initialize.persistence'],
+    },
+    {
+        id: 'run.runtime-inspector',
+        label: 'Register runtime inspector',
+        phase: 'run',
+        dependsOn: ['run.sync', 'initialize.observability'],
+    },
+    {
+        id: 'run.expose-store',
+        label: 'Expose workbench store',
+        phase: 'run',
+        dependsOn: ['run.persistence-subscriptions', 'run.runtime-inspector'],
+    },
+];
+export function createDemoWorkbenchBootGraph(options = {}) {
+    const delayMs = options.stepDelayMs ?? options.delayMs ?? 120;
+    const optionalFailureDependents = options.failStepId && options.failCritical === false
+        ? collectTransitiveDependents(options.failStepId)
+        : new Set();
+    return {
+        steps: DEMO_BOOT_STEPS.map((definition) => createDemoBootStep(definition, {
+            delayMs,
+            failStepId: options.failStepId,
+            failCritical: options.failCritical ?? true,
+            optionalFailureDependents,
+        })),
+    };
+}
+function createDemoBootStep(definition, options) {
+    const shouldFail = definition.id === options.failStepId;
+    const criticality = shouldFail && !options.failCritical
+        ? 'optional'
+        : options.optionalFailureDependents.has(definition.id)
+            ? 'optional'
+            : 'critical';
+    return {
+        id: definition.id,
+        label: definition.label,
+        phase: definition.phase,
+        criticality,
+        dependsOn: definition.dependsOn?.map((stepId) => ({ stepId })),
+        async run() {
+            await delay(options.delayMs);
+            if (shouldFail) {
+                throw new Error(`Simulated boot failure at ${definition.id}.`);
+            }
+            return {
+                metadata: {
+                    simulated: true,
+                    phase: definition.phase,
+                    ...(definition.metadata ?? {}),
+                },
+            };
+        },
+        async rollback() {
+            await delay(Math.max(0, Math.min(options.delayMs, 40)));
+            return {
+                metadata: {
+                    rollback: true,
+                    simulated: true,
+                    phase: definition.phase,
+                },
+            };
+        },
+    };
+}
+function collectTransitiveDependents(rootStepId) {
+    const dependents = new Set();
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const definition of DEMO_BOOT_STEPS) {
+            if (definition.id === rootStepId || dependents.has(definition.id)) {
+                continue;
+            }
+            const dependencies = definition.dependsOn ?? [];
+            const dependsOnFailedRoot = dependencies.includes(rootStepId);
+            const dependsOnFailedDependent = dependencies.some((stepId) => dependents.has(stepId));
+            if (dependsOnFailedRoot || dependsOnFailedDependent) {
+                dependents.add(definition.id);
+                changed = true;
+            }
+        }
+    }
+    return dependents;
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/boot/createLegacyWorkbenchBootGraph.d.ts

@@ -0,0 +1,34 @@
+import { type BootContext, type BootGraph, type BootMode, type BootStepResult, type RuntimePlan, type RuntimePlanStep } from '@konitif/workbench';
+export declare const LEGACY_WORKBENCH_BOOT_SNAPSHOT_OPTION = "legacyWorkbench.snapshot";
+export interface LegacyWorkbenchBootSnapshot {
+    targetKind: string;
+    targetLabel: string;
+    profile: string;
+    projectRoot?: string | null;
+    projectKind?: string | null;
+    shellRoute?: string | null;
+    workspaceMode?: string | null;
+    source?: string | null;
+}
+export interface LegacyWorkbenchBootGraphOptions {
+    stepDelayMs?: number;
+    delayMs?: number;
+    snapshot?: LegacyWorkbenchBootSnapshot;
+    runtimeStepHandlers?: LegacyRuntimePlanStepHandlers;
+}
+export interface LegacyRuntimePlanStepHandlerInput {
+    snapshot: LegacyWorkbenchBootSnapshot;
+    plan: RuntimePlan;
+    step: RuntimePlanStep;
+}
+export type LegacyRuntimePlanStepHandler = (ctx: BootContext, input: LegacyRuntimePlanStepHandlerInput) => BootStepResult | void | Promise<BootStepResult | void>;
+export interface LegacyRuntimePlanStepLifecycleHandler {
+    run?: LegacyRuntimePlanStepHandler;
+    rollback?: LegacyRuntimePlanStepHandler;
+    teardown?: LegacyRuntimePlanStepHandler;
+}
+export type LegacyRuntimePlanStepHandlerDefinition = LegacyRuntimePlanStepHandler | LegacyRuntimePlanStepLifecycleHandler;
+export type LegacyRuntimePlanStepHandlers = Partial<Record<string, LegacyRuntimePlanStepHandlerDefinition>>;
+export declare function createLegacyWorkbenchBootGraph(options?: LegacyWorkbenchBootGraphOptions): BootGraph;
+export declare function createLegacyWorkbenchBootContextOptions(snapshot: LegacyWorkbenchBootSnapshot): Iterable<readonly [string, unknown]>;
+export declare function resolveLegacyWorkbenchBootMode(snapshot: LegacyWorkbenchBootSnapshot): BootMode;

package/dist/boot/createLegacyWorkbenchBootGraph.js

@@ -0,0 +1,321 @@
+import { RuntimePlanEngine, createLaunchPreflightSummary, createProjectLaunchTarget, createSelfLaunchTarget, getBootOption, getRuntimeValue, setCapability, setRuntimeValue, } from '@konitif/workbench';
+export const LEGACY_WORKBENCH_BOOT_SNAPSHOT_OPTION = 'legacyWorkbench.snapshot';
+const LEGACY_BOOT_PLAN_STEPS = [
+    {
+        id: 'plan.resolve-launch-target',
+        label: 'Resolve launch target',
+        phase: 'plan',
+        run(ctx) {
+            const snapshot = readLegacyWorkbenchBootSnapshot(ctx);
+            setRuntimeValue(ctx, 'launch.target', snapshot);
+            return {
+                metadata: {
+                    observed: true,
+                    targetKind: snapshot.targetKind,
+                    targetLabel: snapshot.targetLabel,
+                    profile: snapshot.profile,
+                    projectRoot: snapshot.projectRoot ?? null,
+                    source: snapshot.source ?? 'legacy-workbench',
+                },
+            };
+        },
+    },
+    {
+        id: 'plan.create-runtime-plan',
+        label: 'Create runtime plan',
+        phase: 'plan',
+        dependsOn: ['plan.resolve-launch-target'],
+        run(ctx) {
+            const snapshot = readLegacyWorkbenchBootSnapshot(ctx);
+            const plan = createLegacyRuntimePlan(snapshot);
+            setRuntimeValue(ctx, 'runtime.plan', plan);
+            return {
+                metadata: {
+                    runtimePlanId: plan.id,
+                    profile: plan.profile,
+                    canExecute: plan.canExecute,
+                    stepCount: plan.steps.length,
+                    warningCount: plan.warnings.length,
+                    targetKind: plan.target.kind,
+                },
+                warnings: plan.canExecute ? [] : ['Runtime plan is blocked by preflight.'],
+            };
+        },
+    },
+];
+const LEGACY_BOOT_HYDRATE_SHELL_STEP = {
+    id: 'hydrate.capture-workspace-shell',
+    label: 'Capture workspace shell context',
+    phase: 'hydrate',
+    run(ctx) {
+        const snapshot = readLegacyWorkbenchBootSnapshot(ctx);
+        setRuntimeValue(ctx, 'workspace.shell', {
+            shellRoute: snapshot.shellRoute ?? 'workspace',
+            workspaceMode: snapshot.workspaceMode ?? 'studio',
+        });
+        return {
+            metadata: {
+                shellRoute: snapshot.shellRoute ?? 'workspace',
+                workspaceMode: snapshot.workspaceMode ?? 'studio',
+                persistence: 'external',
+            },
+        };
+    },
+};
+const LEGACY_BOOT_RUN_STEPS = [
+    {
+        id: 'run.expose-legacy-runtime',
+        label: 'Expose legacy runtime projection',
+        phase: 'run',
+        run(ctx) {
+            const plan = getRuntimeValue(ctx, 'runtime.plan');
+            setRuntimeValue(ctx, 'legacy.runtime.ready', true);
+            setCapability(ctx, 'legacy.workbench-store.delegated', true);
+            return {
+                metadata: {
+                    observable: true,
+                    delegatedTo: 'createWorkbenchStore',
+                    nextMigrationTarget: 'store factory ownership',
+                    runtimePlanId: plan.id,
+                    runtimeStepCount: plan.steps.length,
+                },
+            };
+        },
+    },
+];
+export function createLegacyWorkbenchBootGraph(options = {}) {
+    const delayMs = options.stepDelayMs ?? options.delayMs ?? 70;
+    const graphPlan = createLegacyRuntimePlan(sanitizeLegacyWorkbenchBootSnapshot(options.snapshot ?? createFallbackLegacyWorkbenchBootSnapshot()), 'legacy-boot-graph');
+    const runtimePlanSteps = createRuntimePlanBootStepDefinitions(graphPlan.steps, sanitizeLegacyWorkbenchBootSnapshot(options.snapshot ?? createFallbackLegacyWorkbenchBootSnapshot()), options.runtimeStepHandlers ?? {});
+    const hydrateShellStep = {
+        ...LEGACY_BOOT_HYDRATE_SHELL_STEP,
+        dependsOn: [resolveLastStepId(runtimePlanSteps.initialize, 'plan.create-runtime-plan')],
+    };
+    const firstRunStep = runtimePlanSteps.run[0];
+    if (firstRunStep && !firstRunStep.dependsOn?.length) {
+        firstRunStep.dependsOn = [resolveLastStepId(runtimePlanSteps.hydrate, hydrateShellStep.id)];
+    }
+    const runSteps = LEGACY_BOOT_RUN_STEPS.map((step) => ({
+        ...step,
+        dependsOn: [resolveLastStepId([...runtimePlanSteps.hydrate, ...runtimePlanSteps.run], hydrateShellStep.id)],
+    }));
+    const definitions = [
+        ...LEGACY_BOOT_PLAN_STEPS,
+        ...runtimePlanSteps.initialize,
+        hydrateShellStep,
+        ...runtimePlanSteps.hydrate,
+        ...runtimePlanSteps.run,
+        ...runSteps,
+    ];
+    return {
+        steps: definitions.map((definition) => createLegacyBootStep(definition, delayMs)),
+    };
+}
+export function createLegacyWorkbenchBootContextOptions(snapshot) {
+    return [[LEGACY_WORKBENCH_BOOT_SNAPSHOT_OPTION, sanitizeLegacyWorkbenchBootSnapshot(snapshot)]];
+}
+export function resolveLegacyWorkbenchBootMode(snapshot) {
+    return snapshot.targetKind === 'self' ? 'readonly' : 'normal';
+}
+function createLegacyBootStep(definition, delayMs) {
+    return {
+        id: definition.id,
+        label: definition.label,
+        phase: definition.phase,
+        criticality: 'critical',
+        dependsOn: definition.dependsOn?.map((stepId) => ({ stepId })),
+        async run(ctx) {
+            await delay(delayMs);
+            return definition.run(ctx);
+        },
+        async rollback(ctx) {
+            if (!definition.rollback) {
+                return undefined;
+            }
+            await delay(Math.max(0, Math.min(delayMs, 40)));
+            return definition.rollback(ctx);
+        },
+        async teardown(ctx) {
+            if (!definition.teardown) {
+                return undefined;
+            }
+            await delay(Math.max(0, Math.min(delayMs, 40)));
+            return definition.teardown(ctx);
+        },
+    };
+}
+function readLegacyWorkbenchBootSnapshot(ctx) {
+    return sanitizeLegacyWorkbenchBootSnapshot(getBootOption(ctx, LEGACY_WORKBENCH_BOOT_SNAPSHOT_OPTION));
+}
+function sanitizeLegacyWorkbenchBootSnapshot(snapshot) {
+    return {
+        targetKind: snapshot.targetKind || 'unknown',
+        targetLabel: snapshot.targetLabel || 'Unknown target',
+        profile: snapshot.profile || 'unknown',
+        projectRoot: snapshot.projectRoot || null,
+        projectKind: snapshot.projectKind || null,
+        shellRoute: snapshot.shellRoute || null,
+        workspaceMode: snapshot.workspaceMode || null,
+        source: snapshot.source || null,
+    };
+}
+function createFallbackLegacyWorkbenchBootSnapshot() {
+    return {
+        targetKind: 'unknown',
+        targetLabel: 'Unknown target',
+        profile: 'project-workbench',
+        projectRoot: 'legacy-workbench',
+        projectKind: 'repository',
+        source: 'legacy-workbench',
+    };
+}
+function createLegacyRuntimePlan(snapshot, now = new Date().toISOString()) {
+    const target = createLaunchTargetFromLegacySnapshot(snapshot);
+    return new RuntimePlanEngine().createPlan({
+        target,
+        preflight: createLaunchPreflightSummary(target),
+        now,
+    });
+}
+function createLaunchTargetFromLegacySnapshot(snapshot) {
+    if (snapshot.targetKind === 'self') {
+        return createSelfLaunchTarget();
+    }
+    const projectRoot = snapshot.projectRoot || snapshot.targetLabel || 'legacy-workbench';
+    const project = {
+        id: createLegacyProjectId(projectRoot),
+        kind: resolveLegacyProjectKind(snapshot.projectKind),
+        label: snapshot.targetLabel || createProjectLabel(projectRoot),
+        root: projectRoot,
+        description: snapshot.source ? `Legacy boot source: ${snapshot.source}` : null,
+    };
+    return createProjectLaunchTarget(project, resolveLegacyLaunchProfile(snapshot.profile));
+}
+function createRuntimePlanBootStepDefinitions(steps, snapshot, handlers) {
+    const grouped = {
+        initialize: [],
+        hydrate: [],
+        run: [],
+    };
+    const dependenciesByPhase = {
+        initialize: 'plan.create-runtime-plan',
+        hydrate: 'hydrate.capture-workspace-shell',
+        run: '',
+    };
+    for (const step of steps) {
+        const phase = resolveRuntimePlanBootPhase(step.kind);
+        const definition = createRuntimePlanBootStepDefinition(step, phase, dependenciesByPhase[phase], snapshot, handlers);
+        grouped[phase].push(definition);
+        dependenciesByPhase[phase] = definition.id;
+    }
+    return grouped;
+}
+function createRuntimePlanBootStepDefinition(step, phase, dependencyId, snapshot, handlers) {
+    return {
+        id: `runtime-plan.${step.id}`,
+        label: step.label,
+        phase,
+        dependsOn: dependencyId ? [dependencyId] : undefined,
+        async run(ctx) {
+            const plan = getRuntimeValue(ctx, 'runtime.plan');
+            const runtimeStep = plan.steps.find((entry) => entry.id === step.id) ?? step;
+            const handler = resolveLegacyRuntimePlanStepHandler(handlers[runtimeStep.id], 'run');
+            if (runtimeStep.status === 'blocked') {
+                throw new Error(runtimeStep.reason ?? `Runtime plan step "${runtimeStep.id}" is blocked.`);
+            }
+            const handlerResult = await handler?.(ctx, { snapshot, plan, step: runtimeStep });
+            setRuntimeValue(ctx, `runtime.plan.step.${runtimeStep.id}`, 'success');
+            return {
+                metadata: {
+                    runtimePlanId: plan.id,
+                    planStepId: runtimeStep.id,
+                    kind: runtimeStep.kind,
+                    critical: runtimeStep.critical,
+                    profile: plan.profile,
+                    status: runtimeStep.status,
+                    ...(handlerResult?.metadata ?? {}),
+                },
+                warnings: [
+                    ...(runtimeStep.status === 'skipped' && runtimeStep.reason ? [runtimeStep.reason] : []),
+                    ...(handlerResult?.warnings ?? []),
+                ],
+            };
+        },
+        async rollback(ctx) {
+            const plan = getRuntimeValue(ctx, 'runtime.plan');
+            const runtimeStep = plan.steps.find((entry) => entry.id === step.id) ?? step;
+            const handler = resolveLegacyRuntimePlanStepHandler(handlers[runtimeStep.id], 'rollback');
+            const handlerResult = await handler?.(ctx, { snapshot, plan, step: runtimeStep });
+            return {
+                metadata: {
+                    rollback: true,
+                    runtimePlanId: plan.id,
+                    planStepId: runtimeStep.id,
+                    ...(handlerResult?.metadata ?? {}),
+                },
+                warnings: handlerResult?.warnings ?? [],
+            };
+        },
+        async teardown(ctx) {
+            const plan = getRuntimeValue(ctx, 'runtime.plan');
+            const runtimeStep = plan.steps.find((entry) => entry.id === step.id) ?? step;
+            const handler = resolveLegacyRuntimePlanStepHandler(handlers[runtimeStep.id], 'teardown');
+            const handlerResult = await handler?.(ctx, { snapshot, plan, step: runtimeStep });
+            return {
+                metadata: {
+                    teardown: true,
+                    runtimePlanId: plan.id,
+                    planStepId: runtimeStep.id,
+                    ...(handlerResult?.metadata ?? {}),
+                },
+                warnings: handlerResult?.warnings ?? [],
+            };
+        },
+    };
+}
+function resolveLegacyRuntimePlanStepHandler(handler, lifecycle) {
+    if (typeof handler === 'function') {
+        return lifecycle === 'run' ? handler : undefined;
+    }
+    return handler?.[lifecycle];
+}
+function resolveRuntimePlanBootPhase(kind) {
+    if (kind === 'activate-watcher' || kind === 'launch-worker') {
+        return 'run';
+    }
+    if (kind === 'start-service' || kind === 'initialize-manager' || kind === 'register-tool') {
+        return 'hydrate';
+    }
+    return 'initialize';
+}
+function resolveLastStepId(steps, fallback) {
+    return steps[steps.length - 1]?.id ?? fallback;
+}
+function resolveLegacyLaunchProfile(profile) {
+    if (profile === 'core-only' ||
+        profile === 'project-workbench' ||
+        profile === 'repo-inspect-only' ||
+        profile === 'app-safe-mode' ||
+        profile === 'app-full-runtime' ||
+        profile === 'sandbox-runtime' ||
+        profile === 'recovery-mode') {
+        return profile;
+    }
+    return 'project-workbench';
+}
+function resolveLegacyProjectKind(kind) {
+    return kind === 'app' ? 'app' : 'repository';
+}
+function createLegacyProjectId(root) {
+    const normalizedRoot = root.replace(/[^a-z0-9]+/gi, '.').replace(/^\.+|\.+$/g, '').toLowerCase();
+    return `legacy.${normalizedRoot || 'workbench'}`;
+}
+function createProjectLabel(root) {
+    const normalizedRoot = root.replace(/\\/g, '/').replace(/\/+$/, '');
+    return normalizedRoot.split('/').filter(Boolean).pop() ?? 'Legacy project';
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/boot/createWorkbenchBootSession.d.ts

@@ -0,0 +1,23 @@
+import { type BootContext, type BootEvent, type BootEventBus, type BootExecutionState, type BootExecutor, type BootGraph, type BootMode, type BootProjection } from '@konitif/workbench';
+import { type DemoWorkbenchBootGraphOptions } from "./createDemoWorkbenchBootGraph.js";
+export interface CreateWorkbenchBootSessionOptions {
+    mode?: BootMode;
+    graph?: BootGraph;
+    demoGraph?: DemoWorkbenchBootGraphOptions;
+    context?: BootContext;
+    eventBus?: BootEventBus;
+    createExecutionId?: () => string;
+    now?: () => number;
+    eventHistoryLimit?: number;
+}
+export interface WorkbenchBootSession {
+    graph: BootGraph;
+    context: BootContext;
+    executor: BootExecutor;
+    getProjection(): BootProjection;
+    getEventHistory(): BootEvent[];
+    subscribe(listener: (projection: BootProjection) => void): () => void;
+    start(): Promise<BootExecutionState>;
+    teardown(): Promise<BootExecutionState>;
+}
+export declare function createWorkbenchBootSession(options?: CreateWorkbenchBootSessionOptions): WorkbenchBootSession;