@konitif/workbench 0.284.1

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

@@ -0,0 +1,149 @@
+import type { JsonObject, JsonValue } from "../shared/json.js";
+export type ControlledExperimentMetricDirection = 'higher' | 'lower' | 'neutral';
+export type ControlledExperimentRunStatus = 'completed' | 'invalid' | 'cancelled';
+export interface ControlledExperimentConditionDefinition {
+    id: string;
+    label: string;
+    parameters: JsonObject;
+}
+export interface ControlledExperimentMetricDefinition {
+    id: string;
+    label: string;
+    unit: string;
+    direction: ControlledExperimentMetricDirection;
+}
+export interface ControlledExperimentPhaseDefinition {
+    id: string;
+    label: string;
+}
+export interface ControlledExperimentDefinition {
+    id: string;
+    version: number;
+    title: string;
+    hypothesis: string;
+    independentVariable: string;
+    conditions: readonly ControlledExperimentConditionDefinition[];
+    metrics: readonly ControlledExperimentMetricDefinition[];
+    phases: readonly ControlledExperimentPhaseDefinition[];
+    controlledVariables: readonly string[];
+    maxObservations: number;
+}
+export interface ControlledExperimentObservationInput {
+    observedAtMs: number;
+    metrics: Readonly<Record<string, number | null | undefined>>;
+    provenance?: JsonObject;
+}
+export interface ControlledExperimentObservation {
+    sequence: number;
+    observedAtMs: number;
+    phaseId: string | null;
+    metrics: Record<string, number | null>;
+    provenance: JsonObject;
+}
+export interface ControlledExperimentPhaseMarker {
+    sequence: number;
+    phaseId: string;
+    observedAtMs: number;
+    provenance: JsonObject;
+}
+export interface ControlledExperimentMetricSummary {
+    count: number;
+    minimum: number | null;
+    maximum: number | null;
+    mean: number | null;
+    p01: number | null;
+    p50: number | null;
+    p95: number | null;
+    p99: number | null;
+}
+export interface ControlledExperimentRunStart {
+    runId: string;
+    conditionId: string;
+    startedAtMs: number;
+    environment: JsonObject;
+}
+export interface ControlledExperimentRunStop {
+    endedAtMs: number;
+    status?: ControlledExperimentRunStatus;
+    reason?: string | null;
+}
+export interface ControlledExperimentRunArtifact {
+    schemaVersion: 1;
+    experiment: {
+        id: string;
+        version: number;
+        title: string;
+        hypothesis: string;
+        independentVariable: string;
+        conditions: readonly ControlledExperimentConditionDefinition[];
+        condition: ControlledExperimentConditionDefinition;
+        metrics: readonly ControlledExperimentMetricDefinition[];
+        phases: readonly ControlledExperimentPhaseDefinition[];
+        controlledVariables: readonly string[];
+    };
+    run: {
+        id: string;
+        status: ControlledExperimentRunStatus;
+        reason: string | null;
+        startedAtMs: number;
+        endedAtMs: number;
+        durationMs: number;
+        environment: JsonObject;
+    };
+    observations: readonly ControlledExperimentObservation[];
+    phaseMarkers: readonly ControlledExperimentPhaseMarker[];
+    metricSummaries: Readonly<Record<string, ControlledExperimentMetricSummary>>;
+    retention: {
+        maxObservations: number;
+        recordedObservations: number;
+        droppedObservations: number;
+        truncated: boolean;
+    };
+}
+export interface ControlledExperimentRecorderSnapshot {
+    recording: boolean;
+    runId: string | null;
+    conditionId: string | null;
+    phaseId: string | null;
+    observationCount: number;
+    droppedObservationCount: number;
+}
+export interface ControlledExperimentCampaignRunDefinition {
+    runId: string;
+    blindId: string;
+    conditionId: string;
+}
+export interface ControlledExperimentEnvironmentRequirement {
+    path: readonly string[];
+    value: JsonValue;
+}
+export interface ControlledExperimentCampaignDefinition {
+    id: string;
+    version: number;
+    experimentId: string;
+    experimentVersion: number;
+    expectedDurationMs: number;
+    durationToleranceMs: number;
+    validRunsRequiredPerCondition: number;
+    requiredPhaseIds: readonly string[];
+    requiredMetricIds: readonly string[];
+    environmentRequirements: readonly ControlledExperimentEnvironmentRequirement[];
+    runs: readonly ControlledExperimentCampaignRunDefinition[];
+}
+export type ControlledExperimentCampaignRunDisposition = 'pending' | 'accepted' | 'rejected';
+export interface ControlledExperimentCampaignRunAssessment {
+    runId: string;
+    blindId: string;
+    conditionId: string;
+    disposition: ControlledExperimentCampaignRunDisposition;
+    reasons: readonly string[];
+    artifactStatus: ControlledExperimentRunStatus | null;
+}
+export interface ControlledExperimentCampaignSnapshot {
+    campaignId: string;
+    campaignVersion: number;
+    readyForReview: boolean;
+    acceptedRunCounts: Readonly<Record<string, number>>;
+    runs: readonly ControlledExperimentCampaignRunAssessment[];
+    nextRun: ControlledExperimentCampaignRunDefinition | null;
+}

package/dist/domain/experiment/model.js

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

package/dist/domain/i18n/languageRegistry.d.ts

@@ -0,0 +1,57 @@
+import type { TranslationLayer, WorkbenchLocale } from "./model.js";
+export type LanguageRegistryStatus = 'covered' | 'partial' | 'missing';
+export interface LanguageRegistryLocaleCoverage {
+    locale: WorkbenchLocale;
+    totalKeys: number;
+    translatedKeys: number;
+    missingKeys: number;
+    coverage: number;
+    status: LanguageRegistryStatus;
+}
+export interface LanguageRegistryNamespaceCoverage {
+    namespace: string;
+    layer: TranslationLayer | 'unknown';
+    source: string;
+    totalKeys: number;
+    locales: Record<WorkbenchLocale, LanguageRegistryLocaleCoverage>;
+}
+export interface LanguageRegistryTranslationValue {
+    status: LanguageRegistryStatus;
+    value?: string;
+    source?: string;
+}
+export interface LanguageRegistryTranslationEntry {
+    id: string;
+    namespace: string;
+    key: string;
+    layer: TranslationLayer | 'unknown';
+    source: string;
+    locales: Record<WorkbenchLocale, LanguageRegistryTranslationValue>;
+}
+export interface LanguageRegistryHistorySnapshot {
+    step: number;
+    generatedAt: 'deterministic';
+    totals: {
+        bundles: number;
+        namespaces: number;
+        keys: number;
+        sources: number;
+    };
+    coverage: Record<WorkbenchLocale, LanguageRegistryLocaleCoverage>;
+}
+export interface LanguageRegistryEvaluation {
+    schemaVersion: 'language-registry.v1';
+    generatedAt: 'deterministic';
+    fallbackLocale: WorkbenchLocale;
+    locales: WorkbenchLocale[];
+    totals: {
+        bundles: number;
+        namespaces: number;
+        keys: number;
+        sources: number;
+    };
+    coverage: LanguageRegistryLocaleCoverage[];
+    namespaces: LanguageRegistryNamespaceCoverage[];
+    entries: LanguageRegistryTranslationEntry[];
+    history: LanguageRegistryHistorySnapshot[];
+}

package/dist/domain/i18n/languageRegistry.js

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

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

@@ -0,0 +1,31 @@
+export type WorkbenchLocale = string;
+export type TranslationLayer = 'core' | 'domain' | 'ui' | 'app' | 'docs' | 'tests' | 'infra' | 'tool' | 'widget';
+export type TranslationValues = Record<string, string | number | boolean | null | undefined>;
+export interface TranslationBundle {
+    locale: WorkbenchLocale;
+    namespace: string;
+    messages: Record<string, string>;
+    layer?: TranslationLayer;
+    source?: string;
+    /**
+     * Higher priority bundles override lower priority bundles for the same locale/key.
+     * Suggested bands: core/ui=0, tool/widget=20, app=40, runtime/session=80.
+     */
+    priority?: number;
+}
+export interface TranslationLookupOptions {
+    locale?: WorkbenchLocale | null;
+    default?: string;
+    values?: TranslationValues;
+}
+export interface TranslationRegistryOptions {
+    fallbackLocale?: WorkbenchLocale;
+}
+export interface TranslationMatch {
+    key: string;
+    locale: WorkbenchLocale;
+    namespace: string;
+    messageKey: string;
+    value: string;
+    source?: string;
+}

package/dist/domain/i18n/model.js

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

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

@@ -0,0 +1,8 @@
+export type WorkbenchIconTone = 'default' | 'action' | 'danger' | 'design' | 'product' | 'runtime' | 'template' | 'shared';
+export interface WorkbenchIconRef {
+    id: string;
+    label?: string;
+    tone?: WorkbenchIconTone;
+    fallback?: string;
+}
+export type WorkbenchIconInput = string | WorkbenchIconRef;

package/dist/domain/icon/model.js

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

package/dist/domain/input/interactionBindings.d.ts

@@ -0,0 +1,2 @@
+/** Compatibility entry; input interpretation is shared by tools independently of a workspace. */
+export * from '@konitif/tools/input';

package/dist/domain/input/interactionBindings.js

@@ -0,0 +1,2 @@
+/** Compatibility entry; input interpretation is shared by tools independently of a workspace. */
+export * from '@konitif/tools/input';

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

@@ -0,0 +1,58 @@
+import type { RuntimeHydrationSnapshot } from "../runtime/hydration.js";
+import type { RuntimeInitializationSnapshot } from "../runtime/initialization.js";
+import type { RuntimePlan } from "../runtime/plan.js";
+import type { RuntimeRecoverySnapshot, RuntimeSafeModeSnapshot } from "../runtime/recovery.js";
+import type { RuntimeSuspensionSnapshot } from "../runtime/suspension.js";
+import type { RuntimeTeardownSnapshot } from "../runtime/teardown.js";
+import type { RepositoryInspectionSnapshot } from "../repository/model.js";
+export type LaunchTargetKind = 'self' | 'project';
+export type LaunchProjectKind = 'app' | 'repository';
+export type LaunchProfile = 'core-only' | 'project-workbench' | 'repo-inspect-only' | 'app-safe-mode' | 'app-full-runtime' | 'sandbox-runtime' | 'recovery-mode';
+export type LaunchPhase = 'BOOT' | 'LAUNCH_GATE' | 'CONTEXT_RESOLVED' | 'PREFLIGHT' | 'PLANNED' | 'INITIALIZING' | 'HYDRATING' | 'RUNNING' | 'SUSPENDING' | 'SUSPENDED' | 'RESUMING' | 'TEARDOWN' | 'RECOVERY' | 'SAFE_MODE';
+export type LaunchScreen = 'gate' | 'dashboard' | 'preflight' | 'initializing' | 'running' | 'safe-mode';
+export declare const LAUNCH_OBSERVABLE_PHASES: readonly ["PREFLIGHT", "PLANNED", "INITIALIZING", "HYDRATING", "RUNNING", "TEARDOWN", "RECOVERY"];
+export type LaunchObservablePhase = (typeof LAUNCH_OBSERVABLE_PHASES)[number];
+export interface LaunchProjectOption {
+    id: string;
+    kind: LaunchProjectKind;
+    label: string;
+    root: string;
+    description?: string | null;
+    icon?: string | null;
+}
+export interface LaunchTarget {
+    kind: LaunchTargetKind;
+    profile: LaunchProfile;
+    project?: LaunchProjectOption | null;
+}
+export interface LaunchPreflightCheck {
+    id: string;
+    label: string;
+    status: 'pending' | 'ready' | 'warning' | 'blocked';
+    message: string;
+}
+export interface LaunchPreflightSummary {
+    target: LaunchTarget;
+    checks: LaunchPreflightCheck[];
+    generatedAt: string;
+    repository: RepositoryInspectionSnapshot | null;
+}
+export interface LaunchState {
+    phase: LaunchPhase;
+    screen: LaunchScreen;
+    target: LaunchTarget | null;
+    preflight: LaunchPreflightSummary | null;
+    plan: RuntimePlan | null;
+    initialization: RuntimeInitializationSnapshot | null;
+    hydration: RuntimeHydrationSnapshot | null;
+    suspension: RuntimeSuspensionSnapshot | null;
+    teardown: RuntimeTeardownSnapshot | null;
+    recovery: RuntimeRecoverySnapshot | null;
+    safeMode: RuntimeSafeModeSnapshot | null;
+    error: string | null;
+}
+export declare function createInitialLaunchState(): LaunchState;
+export declare function transitionLaunchState(state: LaunchState, phase: LaunchPhase, patch?: Partial<LaunchState>): LaunchState;
+export declare function createSelfLaunchTarget(): LaunchTarget;
+export declare function createProjectLaunchTarget(project: LaunchProjectOption, profile?: LaunchProfile): LaunchTarget;
+export declare function createLaunchPreflightSummary(target: LaunchTarget, now?: string): LaunchPreflightSummary;

package/dist/domain/launch/model.js

@@ -0,0 +1,109 @@
+export const LAUNCH_OBSERVABLE_PHASES = [
+    'PREFLIGHT',
+    'PLANNED',
+    'INITIALIZING',
+    'HYDRATING',
+    'RUNNING',
+    'TEARDOWN',
+    'RECOVERY'
+];
+export function createInitialLaunchState() {
+    return {
+        phase: 'LAUNCH_GATE',
+        screen: 'gate',
+        target: null,
+        preflight: null,
+        plan: null,
+        initialization: null,
+        hydration: null,
+        suspension: null,
+        teardown: null,
+        recovery: null,
+        safeMode: null,
+        error: null
+    };
+}
+export function transitionLaunchState(state, phase, patch = {}) {
+    return {
+        ...state,
+        ...patch,
+        phase,
+        screen: patch.screen ?? resolveLaunchScreenForPhase(phase, state.screen)
+    };
+}
+export function createSelfLaunchTarget() {
+    return {
+        kind: 'self',
+        profile: 'core-only',
+        project: null
+    };
+}
+export function createProjectLaunchTarget(project, profile = 'project-workbench') {
+    return {
+        kind: 'project',
+        profile,
+        project
+    };
+}
+export function createLaunchPreflightSummary(target, now = new Date().toISOString()) {
+    const checks = target.kind === 'self'
+        ? [
+            {
+                id: 'launch.self.profile',
+                label: 'Core profile',
+                status: 'ready',
+                message: 'Reduced self-inspection environment selected.'
+            },
+            {
+                id: 'launch.self.runtime',
+                label: 'Runtime',
+                status: 'ready',
+                message: 'Workspace runtime will initialize after confirmation.'
+            }
+        ]
+        : [
+            {
+                id: 'launch.project.target',
+                label: 'Project target',
+                status: target.project?.root ? 'ready' : 'blocked',
+                message: target.project?.root ?? 'No project root selected.'
+            },
+            {
+                id: 'launch.project.scan',
+                label: 'Repository projection',
+                status: 'pending',
+                message: 'Repository metadata will hydrate when an inspection projection is available.'
+            }
+        ];
+    return {
+        target,
+        checks,
+        generatedAt: now,
+        repository: null
+    };
+}
+function resolveLaunchScreenForPhase(phase, fallback) {
+    switch (phase) {
+        case 'BOOT':
+        case 'LAUNCH_GATE':
+        case 'CONTEXT_RESOLVED':
+            return 'gate';
+        case 'PREFLIGHT':
+        case 'PLANNED':
+            return 'preflight';
+        case 'INITIALIZING':
+        case 'HYDRATING':
+            return 'initializing';
+        case 'RUNNING':
+        case 'SUSPENDING':
+        case 'SUSPENDED':
+        case 'RESUMING':
+        case 'TEARDOWN':
+        case 'RECOVERY':
+            return 'running';
+        case 'SAFE_MODE':
+            return 'safe-mode';
+        default:
+            return fallback;
+    }
+}

package/dist/domain/layout/interaction.d.ts

@@ -0,0 +1,90 @@
+import type { SplitOrientation } from "./model.js";
+export type LayoutEdge = 'top' | 'right' | 'bottom' | 'left';
+export type LayoutDockSide = 'top' | 'right' | 'bottom' | 'left';
+export type LayoutDockPlacement = LayoutDockSide | 'center';
+export type LayoutInteractionSourceKind = 'workspace-edge' | 'split-boundary' | 'panel-menu';
+export type LayoutMenuActionId = 'split:vertical' | 'split:horizontal' | 'join-areas' | 'swap-areas';
+export type BoundaryPullSourceKind = 'edge' | 'corner';
+export interface LayoutInteractionAnchor {
+    x: number;
+    y: number;
+}
+export interface LayoutInteractionPointer {
+    x: number;
+    y: number;
+}
+export interface LayoutMenuTarget {
+    id: string;
+    panelId: string;
+    areaId: string;
+    areaPanelIds: readonly string[];
+    edge: LayoutEdge;
+    label: string;
+    joinSide: LayoutDockSide;
+    joinSiblingPanelIds: readonly string[];
+    swapSiblingPanelIds: readonly string[];
+}
+export type LayoutDockTarget = {
+    kind: 'workspace-edge';
+    side: LayoutDockSide;
+} | {
+    kind: 'stack';
+    stackId: string;
+    placement: LayoutDockPlacement;
+    tabIndex?: number | null;
+};
+export type LayoutInteractionState = {
+    mode: 'idle';
+} | {
+    mode: 'split-menu';
+    source: LayoutInteractionSourceKind;
+    panelId: string | null;
+    edge: LayoutEdge;
+    anchor: LayoutInteractionAnchor;
+    targets: LayoutMenuTarget[];
+    initialActionId: LayoutMenuActionId | null;
+} | {
+    mode: 'split-side-pick';
+    panelId: string | null;
+    edge: LayoutEdge;
+    orientation: SplitOrientation;
+    hoveredSide: LayoutDockSide | null;
+} | {
+    mode: 'split-preview';
+    panelId: string | null;
+    edge: LayoutEdge;
+    orientation: SplitOrientation;
+    cuts: number;
+    pointerRatio: number;
+} | {
+    mode: 'boundary-pull';
+    windowId?: string;
+    source: BoundaryPullSourceKind;
+    anchor: LayoutInteractionAnchor;
+    pointer: LayoutInteractionPointer;
+    horizontalEdge: 'left' | 'right' | null;
+    verticalEdge: 'top' | 'bottom' | null;
+    neutralThreshold: number;
+    creationThreshold: number;
+    horizontalDistance: number;
+    verticalDistance: number;
+    horizontalBandRatio: number | null;
+    verticalBandRatio: number | null;
+} | {
+    mode: 'intersection-resize';
+    anchor: LayoutInteractionAnchor;
+    pointer: LayoutInteractionPointer;
+    columnSplitId: string;
+    rowSplitId: string;
+    columnBaseSizes: [number, number];
+    rowBaseSizes: [number, number];
+    columnPreviewSizes: [number, number];
+    rowPreviewSizes: [number, number];
+} | {
+    mode: 'drag-panel';
+    panelId: string;
+    sourceStackId: string;
+    anchor: LayoutInteractionAnchor;
+    pointer: LayoutInteractionPointer;
+    hoveredTarget: LayoutDockTarget | null;
+};

package/dist/domain/layout/interaction.js

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

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

@@ -0,0 +1,28 @@
+import type { PanelNode } from "../panel/model.js";
+export type SplitOrientation = 'horizontal' | 'vertical';
+export type NonEmptyArray<T> = readonly [T, ...T[]];
+/**
+ * Invariants:
+ * - split nodes always have exactly two children
+ * - `sizes` are finite, positive, and normalized by domain helpers
+ */
+export interface SplitNode {
+    id: string;
+    kind: 'split';
+    orientation: SplitOrientation;
+    sizes: [number, number];
+    children: readonly [LayoutNode, LayoutNode];
+}
+/**
+ * Invariants:
+ * - stack nodes always contain at least one panel
+ * - `activeChildId` always points at one of `children`
+ */
+export interface StackNode {
+    id: string;
+    kind: 'stack';
+    activeChildId: string;
+    headerVisible?: boolean;
+    children: NonEmptyArray<PanelNode>;
+}
+export type LayoutNode = SplitNode | StackNode;

package/dist/domain/layout/model.js

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

package/dist/domain/layout/selectors.d.ts

@@ -0,0 +1,12 @@
+import type { LayoutNode, SplitNode, StackNode } from "./model.js";
+import type { PanelNode } from "../panel/model.js";
+export declare function visitLayoutNodes(node: LayoutNode, visitor: (node: LayoutNode) => void): void;
+export declare function findLayoutNode(node: LayoutNode, targetId: string): LayoutNode | undefined;
+export declare function findPanel(node: LayoutNode, panelId: string): PanelNode | undefined;
+export declare function findStack(node: LayoutNode, stackId: string): StackNode | undefined;
+export declare function findSplit(node: LayoutNode, splitId: string): SplitNode | undefined;
+export declare function containsPanel(node: LayoutNode, panelId: string): boolean;
+export declare function findStackContainingPanel(node: LayoutNode, panelId: string): StackNode | undefined;
+export declare function listPanels(node: LayoutNode): PanelNode[];
+export declare function listStacks(node: LayoutNode): StackNode[];
+export declare function listSplits(node: LayoutNode): SplitNode[];

package/dist/domain/layout/selectors.js

@@ -0,0 +1,84 @@
+export function visitLayoutNodes(node, visitor) {
+    visitor(node);
+    if (node.kind === 'split') {
+        for (const child of node.children) {
+            visitLayoutNodes(child, visitor);
+        }
+    }
+}
+export function findLayoutNode(node, targetId) {
+    if (node.id === targetId) {
+        return node;
+    }
+    if (node.kind === 'split') {
+        for (const child of node.children) {
+            const match = findLayoutNode(child, targetId);
+            if (match) {
+                return match;
+            }
+        }
+    }
+    return undefined;
+}
+export function findPanel(node, panelId) {
+    if (node.kind === 'stack') {
+        return node.children.find((panel) => panel.id === panelId);
+    }
+    for (const child of node.children) {
+        const match = findPanel(child, panelId);
+        if (match) {
+            return match;
+        }
+    }
+    return undefined;
+}
+export function findStack(node, stackId) {
+    const match = findLayoutNode(node, stackId);
+    return match?.kind === 'stack' ? match : undefined;
+}
+export function findSplit(node, splitId) {
+    const match = findLayoutNode(node, splitId);
+    return match?.kind === 'split' ? match : undefined;
+}
+export function containsPanel(node, panelId) {
+    return !!findPanel(node, panelId);
+}
+export function findStackContainingPanel(node, panelId) {
+    if (node.kind === 'stack') {
+        return node.children.some((panel) => panel.id === panelId) ? node : undefined;
+    }
+    for (const child of node.children) {
+        const match = findStackContainingPanel(child, panelId);
+        if (match) {
+            return match;
+        }
+    }
+    return undefined;
+}
+export function listPanels(node) {
+    const panels = [];
+    visitLayoutNodes(node, (entry) => {
+        if (entry.kind === 'stack') {
+            panels.push(...entry.children);
+        }
+    });
+    return panels;
+}
+export function listStacks(node) {
+    const stacks = [];
+    visitLayoutNodes(node, (entry) => {
+        if (entry.kind === 'stack') {
+            stacks.push(entry);
+        }
+    });
+    return stacks;
+}
+export function listSplits(node) {
+    const splits = [];
+    visitLayoutNodes(node, (entry) => {
+        if (entry.kind === 'split') {
+            splits.push(entry);
+        }
+    });
+    return splits;
+}