@konitif/workbench 0.284.1

package/dist/boot/projection.js

@@ -0,0 +1,398 @@
+import { BOOT_PHASES, } from "./types.js";
+const STEP_STATUSES = [
+    'pending',
+    'running',
+    'success',
+    'failed',
+    'skipped',
+    'blocked',
+];
+export function createBootExecutionProjection(state, mode = 'normal', lastEvent, events = []) {
+    const steps = Object.values(state.nodes).map((node) => {
+        const { state: stepState } = node;
+        const durationMs = stepState.startedAt !== undefined && stepState.endedAt !== undefined
+            ? stepState.endedAt - stepState.startedAt
+            : undefined;
+        return {
+            id: stepState.id,
+            label: stepState.label,
+            phase: stepState.phase,
+            status: stepState.status,
+            criticality: stepState.criticality,
+            dependencies: stepState.dependencies.map((dependency) => ({ ...dependency })),
+            attempts: node.attempts,
+            warnings: [...node.warnings],
+            metadata: sanitizeMetadata(node.metadata),
+            startedAt: stepState.startedAt,
+            endedAt: stepState.endedAt,
+            durationMs,
+            error: stepState.error === undefined ? undefined : stringifyError(stepState.error),
+        };
+    });
+    const phases = BOOT_PHASES.map((phase) => createPhaseProjection(phase, steps));
+    const status = resolveExecutionStatus(state);
+    const durationMs = state.startedAt !== undefined && state.endedAt !== undefined
+        ? state.endedAt - state.startedAt
+        : undefined;
+    return {
+        executionId: state.executionId,
+        mode,
+        currentPhase: state.phase,
+        failed: state.failed,
+        phase: state.phase,
+        status,
+        startedAt: state.startedAt,
+        endedAt: state.endedAt,
+        durationMs,
+        phases,
+        steps,
+        lastEvent: lastEvent ? sanitizeBootEvent(lastEvent) : undefined,
+        events: events.map((event) => sanitizeBootEvent(event)),
+        errors: state.errors.map((entry) => ({
+            stepId: entry.stepId,
+            error: stringifyError(entry.error),
+        })),
+    };
+}
+export function createBootProjection(state, mode = 'normal', lastEvent, events = []) {
+    const projection = createBootExecutionProjection(state, mode, lastEvent, events);
+    return {
+        executionId: projection.executionId,
+        mode: projection.mode,
+        currentPhase: projection.currentPhase,
+        failed: projection.failed,
+        startedAt: projection.startedAt,
+        endedAt: projection.endedAt,
+        phases: projection.phases,
+        steps: projection.steps,
+        lastEvent: projection.lastEvent,
+        events: projection.events,
+    };
+}
+export function getBootStepDurationMs(step, now = () => Date.now()) {
+    if (step.startedAt !== undefined && step.endedAt !== undefined) {
+        return step.endedAt - step.startedAt;
+    }
+    if (step.startedAt !== undefined && step.status === 'running') {
+        return now() - step.startedAt;
+    }
+    return undefined;
+}
+export const getStepDurationMs = getBootStepDurationMs;
+export function createBootEventTimelineRows(projection, events = projection?.events ?? []) {
+    if (!projection) {
+        return [];
+    }
+    const startedAt = projection.startedAt;
+    const endedAt = projection.endedAt ?? Date.now();
+    const totalDuration = startedAt !== undefined ? Math.max(1, endedAt - startedAt) : 1;
+    const rows = new Map();
+    events.forEach((event, index) => {
+        const step = 'stepId' in event ? projection.steps.find((entry) => entry.id === event.stepId) : undefined;
+        const phase = 'phase' in event
+            ? projection.phases.find((entry) => entry.phase === event.phase)
+            : step
+                ? projection.phases.find((entry) => entry.phase === step.phase)
+                : undefined;
+        const eventTime = resolveBootEventTime(event, projection);
+        const scope = resolveBootEventTimelineScope(event);
+        const scopeId = resolveBootEventTimelineScopeId(event, step, phase);
+        const key = `${scope}:${scopeId}`;
+        const existing = rows.get(key);
+        const kind = resolveBootEventTimelineKind(event);
+        const status = resolveBootEventTimelineStatus(event);
+        const row = existing ?? {
+            id: `${event.executionId}:${key}:${index}`,
+            executionId: event.executionId,
+            scope,
+            scopeId,
+            scopeLabel: resolveBootEventTimelineScopeLabel(scope, scopeId, step, phase),
+            level: resolveBootEventTimelineLevel(scope),
+            name: resolveBootEventTimelineName(event, scopeId),
+            status,
+            kind,
+            eventTypes: [],
+            startTime: undefined,
+            endTime: undefined,
+            durationMs: undefined,
+            startPercent: 0,
+            timelinePercent: 1,
+        };
+        row.eventTypes = [...row.eventTypes, event.type];
+        if (!existing && kind !== 'open') {
+            row.startTime = step?.startedAt ?? phase?.startedAt ?? projection.startedAt ?? eventTime;
+        }
+        if (kind === 'open') {
+            row.startTime = eventTime ?? row.startTime;
+        }
+        else {
+            row.endTime = eventTime ?? step?.endedAt ?? phase?.endedAt ?? projection.endedAt;
+            row.status = status;
+            row.kind = kind;
+        }
+        if (scope === 'phase' && phase && row.kind === 'open') {
+            const inferredPhaseStatus = resolveBootPhaseTimelineStatus(phase);
+            if (inferredPhaseStatus !== 'start') {
+                row.endTime = phase.endedAt ?? row.endTime;
+                row.status = inferredPhaseStatus;
+                row.kind = inferredPhaseStatus === 'success' ? 'close' : 'error';
+            }
+        }
+        const fallbackDuration = step?.durationMs ?? phase?.durationMs;
+        row.durationMs =
+            row.startTime !== undefined && row.endTime !== undefined
+                ? row.endTime - row.startTime
+                : fallbackDuration;
+        const rowStart = row.startTime ?? eventTime;
+        const rowEnd = row.endTime ?? eventTime ?? rowStart;
+        row.startPercent =
+            startedAt !== undefined && rowStart !== undefined
+                ? clampPercent(((rowStart - startedAt) / totalDuration) * 100)
+                : 0;
+        row.timelinePercent =
+            rowStart !== undefined && rowEnd !== undefined
+                ? Math.max(1, Math.min(100 - row.startPercent, ((rowEnd - rowStart) / totalDuration) * 100))
+                : Math.max(1, row.timelinePercent);
+        rows.set(key, row);
+    });
+    return [...rows.values()];
+}
+function createPhaseProjection(phase, allSteps) {
+    const steps = allSteps.filter((step) => step.phase === phase);
+    const counts = Object.fromEntries(STEP_STATUSES.map((status) => [status, 0]));
+    for (const step of steps) {
+        counts[step.status] += 1;
+    }
+    const startedAt = minDefined(steps.map((step) => step.startedAt));
+    const endedAt = maxDefined(steps.map((step) => step.endedAt));
+    return {
+        phase,
+        status: resolvePhaseStatus(steps),
+        steps,
+        counts,
+        startedAt,
+        endedAt,
+        durationMs: startedAt !== undefined && endedAt !== undefined ? endedAt - startedAt : undefined,
+    };
+}
+function resolvePhaseStatus(steps) {
+    if (steps.length === 0) {
+        return 'empty';
+    }
+    if (steps.some((step) => step.status === 'failed')) {
+        return 'failed';
+    }
+    if (steps.some((step) => step.status === 'blocked')) {
+        return 'blocked';
+    }
+    if (steps.some((step) => step.status === 'running')) {
+        return 'running';
+    }
+    if (steps.every((step) => step.status === 'success')) {
+        return 'success';
+    }
+    if (steps.every((step) => step.status === 'skipped')) {
+        return 'skipped';
+    }
+    return 'pending';
+}
+function resolveExecutionStatus(state) {
+    if (state.failed) {
+        return 'failed';
+    }
+    if (state.endedAt !== undefined && state.startedAt !== undefined) {
+        return 'success';
+    }
+    if (state.startedAt !== undefined) {
+        return 'running';
+    }
+    return 'idle';
+}
+function resolveBootEventTime(event, projection) {
+    if (event.type === 'boot:start' || event.type === 'boot:success' || event.type === 'boot:failed') {
+        return event.type === 'boot:start' ? event.state.startedAt : event.state.endedAt;
+    }
+    if ('stepId' in event) {
+        const step = projection.steps.find((entry) => entry.id === event.stepId);
+        if (event.type === 'step:start') {
+            return step?.startedAt;
+        }
+        return step?.endedAt ?? step?.startedAt;
+    }
+    if ('phase' in event) {
+        return projection.phases.find((entry) => entry.phase === event.phase)?.startedAt;
+    }
+    return undefined;
+}
+function resolveBootEventTimelineScope(event) {
+    if ('stepId' in event) {
+        return 'step';
+    }
+    if ('phase' in event) {
+        return 'phase';
+    }
+    return 'boot';
+}
+function resolveBootEventTimelineScopeId(event, step, phase) {
+    if ('stepId' in event) {
+        return event.stepId;
+    }
+    if ('phase' in event) {
+        return event.phase;
+    }
+    return step?.id ?? phase?.phase ?? event.executionId;
+}
+function resolveBootEventTimelineScopeLabel(scope, scopeId, step, phase) {
+    if (scope === 'step') {
+        return `${formatBootPhaseLabel(step?.phase)} / step`;
+    }
+    if (scope === 'phase') {
+        return `${formatBootPhaseLabel(phase?.phase ?? scopeId)} / phase`;
+    }
+    return 'Boot / root';
+}
+function resolveBootEventTimelineLevel(scope) {
+    if (scope === 'boot') {
+        return 0;
+    }
+    if (scope === 'phase') {
+        return 1;
+    }
+    return 2;
+}
+function resolveBootEventTimelineName(event, fallback) {
+    if ('stepId' in event) {
+        return event.stepId;
+    }
+    if ('phase' in event) {
+        return event.phase;
+    }
+    return fallback;
+}
+function resolveBootEventTimelineStatus(event) {
+    if (event.type.endsWith(':start')) {
+        return 'start';
+    }
+    if (event.type.endsWith(':success')) {
+        return 'success';
+    }
+    if (event.type.endsWith(':failed')) {
+        return 'failed';
+    }
+    if (event.type.endsWith(':blocked')) {
+        return 'blocked';
+    }
+    return 'event';
+}
+function resolveBootEventTimelineKind(event) {
+    if (event.type.endsWith(':start')) {
+        return 'open';
+    }
+    if (event.type.endsWith(':success')) {
+        return 'close';
+    }
+    if (event.type.endsWith(':failed') || event.type.endsWith(':blocked')) {
+        return 'error';
+    }
+    return 'event';
+}
+function resolveBootPhaseTimelineStatus(phase) {
+    if (phase.status === 'success' || phase.status === 'skipped') {
+        return 'success';
+    }
+    if (phase.status === 'failed') {
+        return 'failed';
+    }
+    if (phase.status === 'blocked') {
+        return 'blocked';
+    }
+    return 'start';
+}
+function formatBootPhaseLabel(phase) {
+    return phase ? phase.replace(/^\w/, (letter) => letter.toUpperCase()) : 'Unknown';
+}
+function clampPercent(value) {
+    return Math.max(0, Math.min(100, Number.isFinite(value) ? value : 0));
+}
+function sanitizeBootEvent(event) {
+    if (event.type === 'boot:start' || event.type === 'boot:success') {
+        return {
+            ...event,
+            state: sanitizeExecutionState(event.state),
+        };
+    }
+    if (event.type === 'boot:failed') {
+        return {
+            ...event,
+            state: sanitizeExecutionState(event.state),
+            error: stringifyError(event.error),
+        };
+    }
+    if (event.type === 'step:failed') {
+        return {
+            ...event,
+            error: stringifyError(event.error),
+        };
+    }
+    return { ...event };
+}
+function sanitizeExecutionState(state) {
+    return {
+        ...state,
+        steps: Object.fromEntries(Object.entries(state.steps).map(([stepId, step]) => [
+            stepId,
+            {
+                ...step,
+                dependencies: step.dependencies.map((dependency) => ({ ...dependency })),
+                error: step.error === undefined ? undefined : stringifyError(step.error),
+            },
+        ])),
+        nodes: Object.fromEntries(Object.entries(state.nodes).map(([stepId, node]) => [
+            stepId,
+            {
+                ...node,
+                state: {
+                    ...node.state,
+                    dependencies: node.state.dependencies.map((dependency) => ({ ...dependency })),
+                    error: node.state.error === undefined ? undefined : stringifyError(node.state.error),
+                },
+                warnings: [...node.warnings],
+                metadata: sanitizeMetadata(node.metadata),
+            },
+        ])),
+        errors: state.errors.map((entry) => ({
+            stepId: entry.stepId,
+            error: stringifyError(entry.error),
+        })),
+    };
+}
+function sanitizeMetadata(metadata) {
+    try {
+        return JSON.parse(JSON.stringify(metadata));
+    }
+    catch {
+        return Object.fromEntries(Object.entries(metadata).map(([key, value]) => [key, stringifyError(value)]));
+    }
+}
+function stringifyError(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function minDefined(values) {
+    const defined = values.filter((value) => value !== undefined);
+    return defined.length === 0 ? undefined : Math.min(...defined);
+}
+function maxDefined(values) {
+    const defined = values.filter((value) => value !== undefined);
+    return defined.length === 0 ? undefined : Math.max(...defined);
+}

package/dist/boot/types.d.ts

@@ -0,0 +1,80 @@
+export type BootPhase = 'plan' | 'initialize' | 'hydrate' | 'run';
+export declare const BOOT_PHASES: readonly BootPhase[];
+export type BootStepStatus = 'pending' | 'running' | 'success' | 'failed' | 'skipped' | 'blocked';
+export type BootStepCriticality = 'critical' | 'optional';
+export type BootMode = 'normal' | 'safe' | 'recovery' | 'readonly' | 'diagnostic';
+export interface BootContext {
+    mode: BootMode;
+    services: Map<string, unknown>;
+    capabilities: Map<string, unknown>;
+    runtime: Map<string, unknown>;
+    options: Map<string, unknown>;
+}
+export interface CreateBootContextOptions {
+    mode?: BootMode;
+    services?: Iterable<readonly [string, unknown]>;
+    capabilities?: Iterable<readonly [string, unknown]>;
+    runtime?: Iterable<readonly [string, unknown]>;
+    options?: Iterable<readonly [string, unknown]>;
+}
+export declare function createBootContext(options?: CreateBootContextOptions): BootContext;
+export declare function getService<T>(ctx: BootContext, key: string): T;
+export declare function setService(ctx: BootContext, key: string, value: unknown): void;
+export declare function getCapability<T>(ctx: BootContext, key: string): T;
+export declare function setCapability(ctx: BootContext, key: string, value: unknown): void;
+export declare function getRuntimeValue<T>(ctx: BootContext, key: string): T;
+export declare function setRuntimeValue(ctx: BootContext, key: string, value: unknown): void;
+export declare function getBootOption<T>(ctx: BootContext, key: string): T;
+export declare function setBootOption(ctx: BootContext, key: string, value: unknown): void;
+export interface BootDependency {
+    stepId: string;
+    optional?: boolean;
+}
+export interface BootStepResult {
+    warnings?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface BootStep {
+    id: string;
+    label: string;
+    phase: BootPhase;
+    dependsOn?: BootDependency[];
+    criticality?: BootStepCriticality;
+    run(ctx: BootContext): Promise<BootStepResult | void> | BootStepResult | void;
+    rollback?(ctx: BootContext): Promise<BootStepResult | void> | BootStepResult | void;
+    teardown?(ctx: BootContext): Promise<BootStepResult | void> | BootStepResult | void;
+}
+export interface BootGraph {
+    steps: BootStep[];
+}
+export interface BootStepState {
+    id: string;
+    label: string;
+    phase: BootPhase;
+    status: BootStepStatus;
+    criticality: BootStepCriticality;
+    dependencies: BootDependency[];
+    startedAt?: number;
+    endedAt?: number;
+    error?: unknown;
+}
+export interface BootNodeRuntime {
+    state: BootStepState;
+    attempts: number;
+    warnings: string[];
+    metadata: Record<string, unknown>;
+}
+export interface BootExecutionError {
+    stepId?: string;
+    error: unknown;
+}
+export interface BootExecutionState {
+    executionId: string;
+    phase: BootPhase;
+    steps: Record<string, BootStepState>;
+    nodes: Record<string, BootNodeRuntime>;
+    startedAt?: number;
+    endedAt?: number;
+    failed: boolean;
+    errors: BootExecutionError[];
+}

package/dist/boot/types.js

@@ -0,0 +1,46 @@
+export const BOOT_PHASES = ['plan', 'initialize', 'hydrate', 'run'];
+export function createBootContext(options = {}) {
+    return {
+        mode: options.mode ?? 'normal',
+        services: new Map(options.services),
+        capabilities: new Map(options.capabilities),
+        runtime: new Map(options.runtime),
+        options: new Map(options.options),
+    };
+}
+export function getService(ctx, key) {
+    if (!ctx.services.has(key)) {
+        throw new Error(`Boot service "${key}" is not registered.`);
+    }
+    return ctx.services.get(key);
+}
+export function setService(ctx, key, value) {
+    ctx.services.set(key, value);
+}
+export function getCapability(ctx, key) {
+    if (!ctx.capabilities.has(key)) {
+        throw new Error(`Boot capability "${key}" is not registered.`);
+    }
+    return ctx.capabilities.get(key);
+}
+export function setCapability(ctx, key, value) {
+    ctx.capabilities.set(key, value);
+}
+export function getRuntimeValue(ctx, key) {
+    if (!ctx.runtime.has(key)) {
+        throw new Error(`Boot runtime value "${key}" is not registered.`);
+    }
+    return ctx.runtime.get(key);
+}
+export function setRuntimeValue(ctx, key, value) {
+    ctx.runtime.set(key, value);
+}
+export function getBootOption(ctx, key) {
+    if (!ctx.options.has(key)) {
+        throw new Error(`Boot option "${key}" is not registered.`);
+    }
+    return ctx.options.get(key);
+}
+export function setBootOption(ctx, key, value) {
+    ctx.options.set(key, value);
+}

package/dist/domain/composition/dockArrangement.d.ts

@@ -0,0 +1,57 @@
+import type { DockableEntity, DockableEntityKind, DockAxis, DockContainerRuntimeState, DockPlacement } from "./docking.js";
+export declare const DOCK_ARRANGEMENT_SCHEMA_VERSION: 1;
+export type DockArrangementPresentation = 'tabs' | 'stack' | 'split';
+export interface DockArrangementEntityNode {
+    nodeType: 'entity';
+    nodeId: string;
+    entity: DockableEntity;
+}
+export interface DockArrangementGroupNode {
+    nodeType: 'group';
+    nodeId: string;
+    presentation: DockArrangementPresentation;
+    axis: DockAxis;
+    children: DockArrangementNode[];
+    activeChildId: string | null;
+    sizes?: number[];
+}
+export type DockArrangementNode = DockArrangementEntityNode | DockArrangementGroupNode;
+export interface DockArrangement {
+    schemaVersion: typeof DOCK_ARRANGEMENT_SCHEMA_VERSION;
+    root: DockArrangementGroupNode;
+}
+export type DockArrangementIssueCode = 'empty-node-id' | 'duplicate-node-id' | 'empty-entity-id' | 'duplicate-entity' | 'invalid-active-child' | 'invalid-axis' | 'invalid-size-count';
+export interface DockArrangementIssue {
+    code: DockArrangementIssueCode;
+    nodeId: string;
+    entityKey?: string;
+}
+export interface DockArrangementEntityPlacement extends DockPlacement {
+    targetGroupId?: string | null;
+    activate?: boolean;
+}
+export declare function createDockArrangement(input: {
+    id: string;
+    presentation?: DockArrangementPresentation;
+    axis?: DockAxis;
+    entities?: DockableEntity[];
+    activeEntityId?: string | null;
+}): DockArrangement;
+export declare function createDockArrangementEntityNode(entity: DockableEntity): DockArrangementEntityNode | null;
+export declare function createDockArrangementGroup(input: {
+    id: string;
+    presentation: DockArrangementPresentation;
+    axis?: DockAxis;
+    children?: DockArrangementNode[];
+    activeChildId?: string | null;
+    sizes?: number[];
+}): DockArrangementGroupNode;
+export declare function getDockableEntityKey(entity: Pick<DockableEntity, 'id' | 'kind'>): string;
+export declare function listDockArrangementEntities(arrangement: DockArrangement): DockableEntity[];
+export declare function findDockArrangementGroup(arrangement: DockArrangement, groupId: string): DockArrangementGroupNode | null;
+export declare function upsertDockArrangementEntity(arrangement: DockArrangement, entity: DockableEntity, placement?: DockArrangementEntityPlacement): DockArrangement;
+export declare function removeDockArrangementEntity(arrangement: DockArrangement, entity: Pick<DockableEntity, 'id' | 'kind'>): DockArrangement;
+export declare function setDockArrangementActiveEntity(arrangement: DockArrangement, entity: Pick<DockableEntity, 'id' | 'kind'>): DockArrangement;
+export declare function createDockArrangementFromContainerRuntimeState(state: DockContainerRuntimeState, entityKind: DockableEntityKind, presentation?: DockArrangementPresentation): DockArrangement;
+export declare function projectDockArrangementToContainerRuntimeState(arrangement: DockArrangement, fallback: Pick<DockContainerRuntimeState, 'id' | 'kind' | 'isVisible'>): DockContainerRuntimeState;
+export declare function validateDockArrangement(arrangement: DockArrangement): DockArrangementIssue[];