@konitif/workbench 0.284.1

package/dist/domain/runtime/lifecycle.js

@@ -0,0 +1,118 @@
+export const RUNTIME_LIFECYCLE_ALLOWED_TRANSITIONS = {
+    BOOT: ['LAUNCH_GATE', 'SAFE_MODE'],
+    LAUNCH_GATE: ['CONTEXT_RESOLVED', 'PREFLIGHT', 'SAFE_MODE'],
+    CONTEXT_RESOLVED: ['LAUNCH_GATE', 'PREFLIGHT', 'SAFE_MODE'],
+    PREFLIGHT: ['CONTEXT_RESOLVED', 'LAUNCH_GATE', 'PLANNED', 'SAFE_MODE'],
+    PLANNED: ['INITIALIZING', 'RECOVERY', 'SAFE_MODE'],
+    INITIALIZING: ['HYDRATING', 'RECOVERY', 'SAFE_MODE'],
+    HYDRATING: ['RUNNING', 'RECOVERY', 'SAFE_MODE'],
+    RUNNING: ['SUSPENDING', 'TEARDOWN', 'RECOVERY'],
+    SUSPENDING: ['SUSPENDED', 'TEARDOWN', 'RECOVERY'],
+    SUSPENDED: ['RESUMING', 'TEARDOWN', 'SAFE_MODE'],
+    RESUMING: ['RUNNING', 'RECOVERY', 'SAFE_MODE'],
+    TEARDOWN: ['LAUNCH_GATE', 'INITIALIZING', 'SAFE_MODE'],
+    RECOVERY: ['LAUNCH_GATE', 'PREFLIGHT', 'INITIALIZING', 'SAFE_MODE'],
+    SAFE_MODE: ['LAUNCH_GATE', 'PREFLIGHT', 'INITIALIZING']
+};
+export const RUNTIME_LIFECYCLE_MACRO_PHASES = {
+    BOOT: 'boot',
+    LAUNCH_GATE: 'launch',
+    CONTEXT_RESOLVED: 'launch',
+    PREFLIGHT: 'planning',
+    PLANNED: 'planning',
+    INITIALIZING: 'initialization',
+    HYDRATING: 'hydration',
+    RUNNING: 'running',
+    SUSPENDING: 'suspension',
+    SUSPENDED: 'suspension',
+    RESUMING: 'suspension',
+    TEARDOWN: 'teardown',
+    RECOVERY: 'recovery',
+    SAFE_MODE: 'recovery'
+};
+export function createRuntimeLifecycleSnapshot(state = 'LAUNCH_GATE', timestamp = new Date().toISOString()) {
+    return {
+        state,
+        previousState: null,
+        transitions: [],
+        errors: [],
+        updatedAt: timestamp
+    };
+}
+export function canTransitionRuntimeLifecycle(from, to) {
+    if (!from || from === to) {
+        return true;
+    }
+    return RUNTIME_LIFECYCLE_ALLOWED_TRANSITIONS[from]?.includes(to) ?? false;
+}
+export function transitionRuntimeLifecycleSnapshot(snapshot, to, input) {
+    const from = snapshot.state;
+    const accepted = canTransitionRuntimeLifecycle(from, to);
+    const transition = {
+        id: input.id,
+        from,
+        to,
+        accepted,
+        timestamp: input.timestamp,
+        message: input.message ?? (accepted ? `Runtime lifecycle moved to ${to}` : `Runtime lifecycle rejected ${from} -> ${to}`)
+    };
+    const maxTransitions = input.maxTransitions ?? 50;
+    const maxErrors = input.maxErrors ?? 20;
+    if (!accepted) {
+        const error = {
+            id: input.id,
+            from,
+            to,
+            timestamp: input.timestamp,
+            message: transition.message
+        };
+        return {
+            ...snapshot,
+            transitions: [transition, ...snapshot.transitions].slice(0, maxTransitions),
+            errors: [error, ...snapshot.errors].slice(0, maxErrors),
+            updatedAt: input.timestamp
+        };
+    }
+    return {
+        state: to,
+        previousState: from,
+        transitions: [transition, ...snapshot.transitions].slice(0, maxTransitions),
+        errors: snapshot.errors.slice(0, maxErrors),
+        updatedAt: input.timestamp
+    };
+}
+export function resolveRuntimeLifecycleMacroPhase(state) {
+    return RUNTIME_LIFECYCLE_MACRO_PHASES[state] ?? 'launch';
+}
+export function resolveRuntimeLifecycleHealth(snapshot) {
+    if (snapshot.errors.length > 0 && snapshot.state !== 'RECOVERY' && snapshot.state !== 'SAFE_MODE') {
+        return 'blocked';
+    }
+    switch (snapshot.state) {
+        case 'BOOT':
+        case 'LAUNCH_GATE':
+        case 'CONTEXT_RESOLVED':
+            return 'idle';
+        case 'RUNNING':
+            return 'healthy';
+        case 'RECOVERY':
+            return 'recovering';
+        case 'SAFE_MODE':
+            return 'safe-mode';
+        default:
+            return 'progressing';
+    }
+}
+export function createRuntimeLifecycleSummary(snapshot) {
+    const latestTransition = snapshot.transitions[0] ?? null;
+    return {
+        state: snapshot.state,
+        previousState: snapshot.previousState,
+        macroPhase: resolveRuntimeLifecycleMacroPhase(snapshot.state),
+        health: resolveRuntimeLifecycleHealth(snapshot),
+        acceptedTransitions: snapshot.transitions.filter((transition) => transition.accepted).length,
+        rejectedTransitions: snapshot.transitions.filter((transition) => !transition.accepted).length,
+        latestTransitionAt: latestTransition?.timestamp ?? null,
+        updatedAt: snapshot.updatedAt
+    };
+}

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

@@ -0,0 +1,252 @@
+import type { JsonValue } from "../shared/json.js";
+import type { LaunchPhase, LaunchPreflightSummary, LaunchState, LaunchTarget } from "../launch/model.js";
+import type { RepositoryCoverageSnapshot, RepositoryInspectionInput } from "../repository/model.js";
+import type { RuntimeLifecycleSnapshot } from "./lifecycle.js";
+import type { RuntimeObservabilitySnapshot } from "./observability.js";
+export type WorkbenchRuntimeConnectionStatus = 'idle' | 'connecting' | 'online' | 'offline' | 'error';
+export type WorkbenchRuntimeProjectionCacheStatus = 'hit' | 'miss' | 'refreshed' | 'bypass' | 'local';
+export type WorkbenchRuntimeDiagnosticSeverity = 'info' | 'warning' | 'error';
+export type WorkbenchRuntimeProjectionSessionStatus = 'opening' | 'open' | 'refreshing' | 'stale' | 'error';
+export type RuntimeProjectionMode = 'self' | 'repository';
+export type RuntimeInspectableStatus = 'active' | 'idle' | 'degraded' | 'error' | 'unknown';
+export type RuntimeDebugEventLevel = 'debug' | 'info' | 'warning' | 'error';
+export type WorkbenchRuntimeEventType = 'runtime.ready' | 'runtime.heartbeat' | 'source.changed' | 'source.watch-error' | 'workspace.project-loaded' | 'projection.catalog' | 'projection.loaded' | 'projection.invalidated' | 'projection.error' | 'shared-state.updated' | 'message';
+export declare const WORKBENCH_RUNTIME_EVENT_TYPES: WorkbenchRuntimeEventType[];
+export interface WorkbenchRuntimeBackendHealth {
+    status: 'ok' | 'degraded' | 'error';
+    service: string;
+    mode: string;
+}
+export interface WorkbenchRuntimeWorkspaceDescriptor {
+    name: string;
+    mode: string;
+    workspaceRoot: string;
+    project?: WorkbenchRuntimeProjectDescriptor | null;
+    repositoryInspection?: RepositoryInspectionInput | null;
+    repositoryCoverage?: RepositoryCoverageSnapshot | null;
+    capabilities: string[];
+    projections: Record<string, string[]>;
+}
+export interface WorkbenchRuntimeAppPreviewDescriptor {
+    status: 'ready';
+    origin: string;
+    url: string;
+    proxyUrl?: string;
+    generatedAt: string;
+    logs?: WorkbenchRuntimeAppPreviewLogEntry[];
+    project: {
+        id: string;
+        label: string;
+        root: string;
+    };
+}
+export interface WorkbenchRuntimeAppPreviewLogEntry {
+    id: string;
+    level: 'debug' | 'info' | 'warning' | 'error';
+    message: string;
+    timestamp: string;
+}
+export interface WorkbenchRuntimeProjectDescriptor {
+    id: string;
+    label: string;
+    root: string;
+    workspaceRoot: string;
+    isWorkspaceProject: boolean;
+    faviconDataUrl?: string | null;
+    primaryLocale?: string | null;
+    locales?: string[];
+    i18n?: {
+        primaryLocale?: string | null;
+        locales?: string[];
+    } | null;
+    componentSources: string[];
+    componentSourceCount: number;
+}
+export interface WorkbenchRuntimeDiagnostic {
+    id: string;
+    severity: WorkbenchRuntimeDiagnosticSeverity;
+    title: string;
+    message: string;
+    sourceFile?: string;
+    recommendation?: string;
+}
+export interface WorkbenchRuntimeProjectionEnvelope<TPayload = unknown> {
+    projectionKind: string;
+    sourceFile: string;
+    version: string;
+    generatedAt: string;
+    cacheStatus: WorkbenchRuntimeProjectionCacheStatus;
+    diagnostics: WorkbenchRuntimeDiagnostic[];
+    payload: TPayload;
+}
+export interface WorkbenchRuntimeProjectionTarget {
+    projectionKind: string;
+    sourceFile: string;
+}
+export interface WorkbenchRuntimeProjectionSessionPatch {
+    target: WorkbenchRuntimeProjectionTarget;
+    status?: WorkbenchRuntimeProjectionSessionStatus;
+    selectedEntityId?: string | null;
+    focusedEntityId?: string | null;
+    lastError?: string | null;
+}
+export interface WorkbenchRuntimeProjectionCatalogEntry {
+    projectionKind: string;
+    version: string;
+    sources: string[];
+}
+export interface RuntimeProjectionMetadata {
+    mode: RuntimeProjectionMode;
+    generatedAt: string;
+    source: string;
+    version: string;
+    repo?: {
+        label: string;
+        root: string;
+        branch?: string | null;
+        commit?: string | null;
+    } | null;
+    build?: {
+        version?: string | null;
+        environment?: string | null;
+        generatedAt?: string | null;
+    } | null;
+}
+export interface RuntimeStoreSnapshot {
+    id: string;
+    label: string;
+    scope: string;
+    status: RuntimeInspectableStatus;
+    value: JsonValue;
+    updatedAt: string;
+    metadata: JsonValue;
+}
+export interface RuntimeServiceSnapshot {
+    id: string;
+    label: string;
+    status: RuntimeInspectableStatus;
+    capabilities: string[];
+    endpoint?: string | null;
+    lastError?: string | null;
+    updatedAt: string;
+    metadata: JsonValue;
+}
+export interface RuntimeManagerSnapshot {
+    id: string;
+    label: string;
+    status: RuntimeInspectableStatus;
+    responsibilities: string[];
+    lastError?: string | null;
+    updatedAt: string;
+    metadata: JsonValue;
+}
+export interface RuntimeDebugEvent {
+    id: string;
+    level: RuntimeDebugEventLevel;
+    type: string;
+    message: string;
+    scope?: string | null;
+    timestamp: string;
+    payload?: JsonValue;
+}
+export interface RuntimeStackTrace {
+    id: string;
+    message: string;
+    scope?: string | null;
+    timestamp: string;
+    frames: string[];
+    cause?: string | null;
+}
+export interface RuntimeLaunchTransition {
+    id: string;
+    phase: LaunchPhase;
+    previousPhase?: LaunchPhase | null;
+    target: LaunchTarget | null;
+    timestamp: string;
+    message: string;
+}
+export interface RuntimeLaunchProgressSnapshot {
+    phase: LaunchPhase;
+    status: string;
+    progress: number;
+    activeStepId: string | null;
+    completedSteps: number;
+    totalSteps: number;
+    readyChecks: number;
+    warningChecks: number;
+    blockedChecks: number;
+}
+export interface RuntimeLaunchSnapshot {
+    phase: LaunchPhase;
+    target: LaunchTarget | null;
+    preflight: LaunchPreflightSummary | null;
+    plan: LaunchState['plan'];
+    initialization: LaunchState['initialization'];
+    hydration: LaunchState['hydration'];
+    progress: RuntimeLaunchProgressSnapshot;
+    state: LaunchState;
+    transitions: RuntimeLaunchTransition[];
+    updatedAt: string;
+}
+export interface WorkbenchRuntimeProjectionInvalidationResult {
+    projectionKind: string;
+    sourceFile: string;
+    invalidated: boolean;
+    requestedAt: string;
+}
+export type WorkbenchRuntimeSharedStateScope = 'product' | 'session' | 'gesture';
+export interface WorkbenchRuntimeSharedStateEntry {
+    key: string;
+    scope: WorkbenchRuntimeSharedStateScope;
+    value: JsonValue;
+    version: number;
+    revision: string;
+    updatedAt: string;
+    originClientId: string | null;
+}
+export interface WorkbenchRuntimeSharedStatePatch {
+    scope?: WorkbenchRuntimeSharedStateScope;
+    value: JsonValue;
+    expectedVersion?: number;
+    originClientId?: string | null;
+}
+export interface WorkbenchRuntimeObservationEvent {
+    type: WorkbenchRuntimeEventType;
+    payload: unknown;
+    receivedAt: string;
+}
+export interface WorkbenchRuntimeSnapshot {
+    status: WorkbenchRuntimeConnectionStatus;
+    backendUrl: string;
+    projectionMode?: RuntimeProjectionMode;
+    metadata?: RuntimeProjectionMetadata;
+    health: WorkbenchRuntimeBackendHealth | null;
+    workspace: WorkbenchRuntimeWorkspaceDescriptor | null;
+    projectionCatalog: WorkbenchRuntimeProjectionCatalogEntry[];
+    stores?: RuntimeStoreSnapshot[];
+    services?: RuntimeServiceSnapshot[];
+    managers?: RuntimeManagerSnapshot[];
+    debugEvents?: RuntimeDebugEvent[];
+    stackTraces?: RuntimeStackTrace[];
+    launch?: RuntimeLaunchSnapshot | null;
+    lifecycle?: RuntimeLifecycleSnapshot | null;
+    observability?: RuntimeObservabilitySnapshot | null;
+    sharedState: WorkbenchRuntimeSharedStateEntry[];
+    events: WorkbenchRuntimeObservationEvent[];
+    lastError: string | null;
+}
+export interface WorkbenchRuntimeSubscription {
+    dispose(): void;
+}
+export interface WorkbenchRuntimeBackendPort {
+    readonly baseUrl: string;
+    getHealth(): Promise<WorkbenchRuntimeBackendHealth>;
+    getWorkspace(): Promise<WorkbenchRuntimeWorkspaceDescriptor>;
+    getProjection<TProjection = unknown>(kind: string, params?: Record<string, string>): Promise<TProjection>;
+    invalidateProjection(kind: string, params?: Record<string, string>): Promise<WorkbenchRuntimeProjectionInvalidationResult>;
+    loadProject?(root: string): Promise<WorkbenchRuntimeWorkspaceDescriptor>;
+    startAppPreview?(root?: string): Promise<WorkbenchRuntimeAppPreviewDescriptor>;
+    listSharedState?(): Promise<WorkbenchRuntimeSharedStateEntry[]>;
+    patchSharedState?(key: string, patch: WorkbenchRuntimeSharedStatePatch): Promise<WorkbenchRuntimeSharedStateEntry>;
+    subscribeToEvents(onEvent: (event: WorkbenchRuntimeObservationEvent) => void, onError: (error: Error) => void): WorkbenchRuntimeSubscription;
+}

package/dist/domain/runtime/model.js

@@ -0,0 +1,13 @@
+export const WORKBENCH_RUNTIME_EVENT_TYPES = [
+    'runtime.ready',
+    'runtime.heartbeat',
+    'source.changed',
+    'source.watch-error',
+    'workspace.project-loaded',
+    'projection.catalog',
+    'projection.loaded',
+    'projection.invalidated',
+    'projection.error',
+    'shared-state.updated',
+    'message'
+];

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

@@ -0,0 +1,142 @@
+import type { JsonValue } from "../shared/json.js";
+import type { RuntimeDebugEvent, RuntimeInspectableStatus, RuntimeStackTrace } from "./model.js";
+export type RuntimeTelemetryLevel = 'debug' | 'info' | 'warning' | 'error';
+export type RuntimeTelemetryTraceType = 'debug-event' | 'stack-trace' | 'performance-marker' | 'health-check' | 'lifecycle' | 'store-mutation' | 'crash';
+export type RuntimeObservedEntityType = 'runtime' | 'backend' | 'store' | 'service' | 'manager' | 'tool';
+export type RuntimeStoreMutationKind = 'register' | 'snapshot' | 'update' | 'dispose';
+export type RuntimeEntityLifecycleKind = 'register' | 'start' | 'ready' | 'degraded' | 'error' | 'dispose';
+export interface RuntimeTelemetryTrace {
+    id: string;
+    type: RuntimeTelemetryTraceType;
+    level: RuntimeTelemetryLevel;
+    scope: string | null;
+    label: string;
+    message: string;
+    timestamp: string;
+    payload?: JsonValue;
+}
+export interface RuntimeStructuredLog {
+    id: string;
+    level: RuntimeTelemetryLevel;
+    scope: string | null;
+    message: string;
+    timestamp: string;
+    payload?: JsonValue;
+}
+export interface RuntimePerformanceMarker {
+    id: string;
+    label: string;
+    scope: string | null;
+    startTime: number;
+    durationMs: number | null;
+    timestamp: string;
+    payload?: JsonValue;
+}
+export interface RuntimeHealthCheck {
+    id: string;
+    targetId: string;
+    targetType: RuntimeObservedEntityType;
+    status: RuntimeInspectableStatus;
+    checkedAt: string;
+    latencyMs: number | null;
+    message: string | null;
+    payload?: JsonValue;
+}
+export interface RuntimeStoreMutationEntry {
+    id: string;
+    storeId: string;
+    kind: RuntimeStoreMutationKind;
+    timestamp: string;
+    value?: JsonValue;
+}
+export interface RuntimeEntityLifecycleEntry {
+    id: string;
+    entityId: string;
+    entityType: Exclude<RuntimeObservedEntityType, 'store' | 'backend'>;
+    kind: RuntimeEntityLifecycleKind;
+    status: RuntimeInspectableStatus;
+    timestamp: string;
+    message: string | null;
+    payload?: JsonValue;
+}
+export interface RuntimeCrashReport {
+    id: string;
+    message: string;
+    scope: string | null;
+    timestamp: string;
+    stackFrames: string[];
+    cause: string | null;
+    payload?: JsonValue;
+}
+export interface RuntimeObservabilitySnapshot {
+    generatedAt: string;
+    traces: RuntimeTelemetryTrace[];
+    logs: RuntimeStructuredLog[];
+    performanceMarkers: RuntimePerformanceMarker[];
+    healthChecks: RuntimeHealthCheck[];
+    storeMutations: RuntimeStoreMutationEntry[];
+    lifecycleEntries: RuntimeEntityLifecycleEntry[];
+    crashReports: RuntimeCrashReport[];
+}
+export interface RuntimeTelemetryTraceInput {
+    id?: string;
+    type: RuntimeTelemetryTraceType;
+    level?: RuntimeTelemetryLevel;
+    scope?: string | null;
+    label?: string;
+    message?: string;
+    timestamp?: string;
+    payload?: unknown;
+}
+export interface RuntimeStructuredLogInput {
+    id?: string;
+    level?: RuntimeTelemetryLevel;
+    scope?: string | null;
+    message: string;
+    timestamp?: string;
+    payload?: unknown;
+}
+export interface RuntimePerformanceMarkerInput {
+    id?: string;
+    label: string;
+    scope?: string | null;
+    startTime?: number;
+    durationMs?: number | null;
+    timestamp?: string;
+    payload?: unknown;
+}
+export interface RuntimeHealthCheckInput {
+    id?: string;
+    targetId: string;
+    targetType: RuntimeObservedEntityType;
+    status: RuntimeInspectableStatus;
+    checkedAt?: string;
+    latencyMs?: number | null;
+    message?: string | null;
+    payload?: unknown;
+}
+export interface RuntimeStoreMutationInput {
+    id?: string;
+    storeId: string;
+    kind: RuntimeStoreMutationKind;
+    timestamp?: string;
+    value?: unknown;
+}
+export interface RuntimeEntityLifecycleInput {
+    id?: string;
+    entityId: string;
+    entityType: Exclude<RuntimeObservedEntityType, 'store' | 'backend'>;
+    kind: RuntimeEntityLifecycleKind;
+    status?: RuntimeInspectableStatus;
+    timestamp?: string;
+    message?: string | null;
+    payload?: unknown;
+}
+export interface RuntimeCrashReportInput {
+    id?: string;
+    message?: string;
+    scope?: string | null;
+    timestamp?: string;
+    payload?: unknown;
+}
+export type RuntimeDebugTraceInput = RuntimeDebugEvent | RuntimeStackTrace;

package/dist/domain/runtime/observability.js

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

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

@@ -0,0 +1,56 @@
+import type { JsonValue } from "../shared/json.js";
+export type RuntimeOffloadTaskKind = 'repo-indexing' | 'static-analysis' | 'embeddings' | 'preview-generation' | 'custom';
+export type RuntimeOffloadTaskPriority = 'low' | 'normal' | 'high' | 'urgent';
+export type RuntimeOffloadTaskStatus = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled';
+export interface RuntimeOffloadTaskInput {
+    id?: string;
+    kind: RuntimeOffloadTaskKind;
+    label: string;
+    priority?: RuntimeOffloadTaskPriority;
+    cancellable?: boolean;
+    payload?: unknown;
+}
+export interface RuntimeOffloadTask {
+    id: string;
+    kind: RuntimeOffloadTaskKind;
+    label: string;
+    priority: RuntimeOffloadTaskPriority;
+    status: RuntimeOffloadTaskStatus;
+    progress: number;
+    cancellable: boolean;
+    createdAt: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    error: string | null;
+    payload?: JsonValue;
+    result?: JsonValue;
+}
+export interface RuntimeOffloadEvent {
+    id: string;
+    taskId: string;
+    kind: 'queued' | 'started' | 'progress' | 'completed' | 'failed' | 'cancelled';
+    timestamp: string;
+    message: string;
+    progress: number;
+}
+export interface RuntimeOffloadSnapshot {
+    generatedAt: string;
+    activeTaskIds: string[];
+    queue: string[];
+    tasks: RuntimeOffloadTask[];
+    totals: {
+        queued: number;
+        running: number;
+        completed: number;
+        failed: number;
+        cancelled: number;
+    };
+}
+export declare function createRuntimeOffloadTask(input: RuntimeOffloadTaskInput, timestamp?: string): RuntimeOffloadTask;
+export declare function startRuntimeOffloadTask(task: RuntimeOffloadTask, timestamp?: string): RuntimeOffloadTask;
+export declare function updateRuntimeOffloadTaskProgress(task: RuntimeOffloadTask, progress: number, _timestamp?: string): RuntimeOffloadTask;
+export declare function completeRuntimeOffloadTask(task: RuntimeOffloadTask, result?: unknown, timestamp?: string): RuntimeOffloadTask;
+export declare function failRuntimeOffloadTask(task: RuntimeOffloadTask, error: string, timestamp?: string): RuntimeOffloadTask;
+export declare function cancelRuntimeOffloadTask(task: RuntimeOffloadTask, timestamp?: string): RuntimeOffloadTask;
+export declare function createRuntimeOffloadSnapshot(tasks: RuntimeOffloadTask[], timestamp?: string): RuntimeOffloadSnapshot;
+export declare function compareRuntimeOffloadTasks(a: RuntimeOffloadTask, b: RuntimeOffloadTask): number;