@konitif/workbench 0.284.1

package/dist/application/workspace/subdividePanel.js

@@ -0,0 +1,128 @@
+import { containsPanel } from "../../domain/layout/selectors.js";
+import { getActiveWindow } from "../../domain/workspace/selectors.js";
+import { createPanel, createSplit, createStack } from "../../domain/workspace/factories.js";
+import { canonicalizeLayout } from "./canonicalizeLayout.js";
+import { replaceStackContainingPanel, updateActiveWindowRoot } from "./layoutTree.js";
+import { updateWorkspaceTargetWindow } from "./targetWindow.js";
+const MIN_SUBDIVISION_CUTS = 1;
+const MAX_SUBDIVISION_CUTS = 5;
+const MIN_POINTER_RATIO = 0.12;
+const MAX_POINTER_RATIO = 0.88;
+export function clampSubdivisionCuts(cuts) {
+    return Math.max(MIN_SUBDIVISION_CUTS, Math.min(MAX_SUBDIVISION_CUTS, Math.round(cuts)));
+}
+export function clampSubdivisionPointerRatio(pointerRatio) {
+    return Math.max(MIN_POINTER_RATIO, Math.min(MAX_POINTER_RATIO, Number(pointerRatio.toFixed(4))));
+}
+export function resolveSubdivisionAxis(orientation) {
+    return orientation === 'vertical' ? 'columns' : 'rows';
+}
+export function resolveLayoutOrientationForSubdivision(orientation) {
+    return orientation === 'vertical' ? 'horizontal' : 'vertical';
+}
+export function getSubdivisionSegmentSizes(edge, cuts, pointerRatio) {
+    const safeCuts = clampSubdivisionCuts(cuts);
+    const safePointerRatio = clampSubdivisionPointerRatio(pointerRatio);
+    const segmentCount = safeCuts + 1;
+    void edge;
+    void safePointerRatio;
+    const unit = Number((1 / segmentCount).toFixed(4));
+    const segments = Array.from({ length: segmentCount }, () => unit);
+    const normalizedTotal = Number(segments.reduce((sum, size) => sum + size, 0).toFixed(4));
+    const correction = Number((1 - normalizedTotal).toFixed(4));
+    if (correction !== 0) {
+        segments[segments.length - 1] = Number((segments[segments.length - 1] + correction).toFixed(4));
+    }
+    return segments;
+}
+export function getSubdivisionPreview(orientation, edge, cuts, pointerRatio) {
+    const segmentSizes = getSubdivisionSegmentSizes(edge, cuts, pointerRatio);
+    let cursor = 0;
+    const segmentRanges = segmentSizes.map((size, index) => {
+        const start = cursor * 100;
+        cursor += size;
+        const end = cursor * 100;
+        return {
+            index,
+            start: Number(start.toFixed(3)),
+            end: Number(end.toFixed(3)),
+            center: Number((((start + end) / 2)).toFixed(3))
+        };
+    });
+    return {
+        axis: resolveSubdivisionAxis(orientation),
+        cutCount: clampSubdivisionCuts(cuts),
+        pointerRatio: clampSubdivisionPointerRatio(pointerRatio),
+        linePositions: segmentRanges.slice(0, -1).map((segment) => segment.end),
+        preservedSegmentIndex: resolveSubdivisionPreservedSegmentIndex(edge, cuts, pointerRatio),
+        segmentRanges
+    };
+}
+export function resolveDefaultSubdivisionPreservedSegmentIndex(edge, cuts) {
+    const segmentCount = clampSubdivisionCuts(cuts) + 1;
+    return edge === 'left' || edge === 'top' ? segmentCount - 1 : 0;
+}
+export function resolveSubdivisionPreservedSegmentIndex(edge, cuts, pointerRatio) {
+    const safePointerRatio = clampSubdivisionPointerRatio(pointerRatio);
+    const segmentCount = clampSubdivisionCuts(cuts) + 1;
+    const layoutSegmentIndex = Math.min(segmentCount - 1, Math.floor(safePointerRatio * segmentCount));
+    return edge === 'left' || edge === 'top' ? layoutSegmentIndex : segmentCount - 1 - layoutSegmentIndex;
+}
+export function resolveSubdivisionSegmentPointerRatio(edge, cuts, segmentIndex) {
+    const safeCuts = clampSubdivisionCuts(cuts);
+    const segmentCount = safeCuts + 1;
+    const safeIndex = Math.max(0, Math.min(segmentCount - 1, Math.round(segmentIndex)));
+    const layoutSegmentIndex = edge === 'left' || edge === 'top' ? safeIndex : segmentCount - 1 - safeIndex;
+    return clampSubdivisionPointerRatio((layoutSegmentIndex + 0.5) / segmentCount);
+}
+export function subdividePanel(workspace, input) {
+    let result;
+    const nextWorkspace = updateWorkspaceTargetWindow(workspace, input.panelId, (selected) => {
+        result = subdividePanelInActiveWindow(selected, input);
+        return result.workspace;
+    });
+    return { ...result, workspace: nextWorkspace };
+}
+function subdividePanelInActiveWindow(workspace, input) {
+    const activeWindow = getActiveWindow(workspace);
+    if (!activeWindow || !containsPanel(activeWindow.root, input.panelId)) {
+        return {
+            workspace,
+            createdPanelIds: [],
+            originalPanelId: input.panelId
+        };
+    }
+    const createdPanelIds = [];
+    const orientation = resolveLayoutOrientationForSubdivision(input.orientation);
+    const sizes = getSubdivisionSegmentSizes(input.edge, input.cuts, input.pointerRatio);
+    const preservedSegmentIndex = resolveSubdivisionPreservedSegmentIndex(input.edge, input.cuts, input.pointerRatio);
+    const nextRoot = replaceStackContainingPanel(activeWindow.root, input.panelId, (stack) => {
+        const replacementNodes = sizes.map((_, index) => {
+            const shouldPreserveOriginal = index === preservedSegmentIndex;
+            if (shouldPreserveOriginal) {
+                return stack;
+            }
+            const panel = createPanel('New panel');
+            createdPanelIds.push(panel.id);
+            return createStack([panel]);
+        });
+        return buildSubdivisionTree(orientation, replacementNodes, sizes);
+    });
+    return {
+        workspace: updateActiveWindowRoot(workspace, () => canonicalizeLayout(nextRoot)),
+        createdPanelIds,
+        originalPanelId: input.panelId
+    };
+}
+function buildSubdivisionTree(orientation, nodes, sizes) {
+    if (nodes.length === 1) {
+        return nodes[0];
+    }
+    if (nodes.length === 2) {
+        return createSplit(orientation, [nodes[0], nodes[1]], [sizes[0], sizes[1]]);
+    }
+    const [headNode, ...tailNodes] = nodes;
+    const [headSize, ...tailSizes] = sizes;
+    const tailTotal = tailSizes.reduce((sum, size) => sum + size, 0);
+    return createSplit(orientation, [headNode, buildSubdivisionTree(orientation, tailNodes, tailSizes)], [headSize, tailTotal]);
+}

package/dist/application/workspace/swapPanelArea.d.ts

@@ -0,0 +1,11 @@
+import type { LayoutEdge } from "../../domain/layout/interaction.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+interface SwapPanelAreaInput {
+    panelId: string;
+    edge: LayoutEdge;
+    sourceAreaPanelIds?: readonly string[];
+    siblingAreaPanelIds?: readonly string[];
+}
+export declare function canSwapPanelArea(workspace: Workspace, input: SwapPanelAreaInput): boolean;
+export declare function swapPanelArea(workspace: Workspace, input: SwapPanelAreaInput): Workspace;
+export {};

package/dist/application/workspace/swapPanelArea.js

@@ -0,0 +1,163 @@
+import { containsPanel, listPanels } from "../../domain/layout/selectors.js";
+import { getActiveWindow } from "../../domain/workspace/selectors.js";
+import { canonicalizeLayout } from "./canonicalizeLayout.js";
+import { updateActiveWindowRoot, updateSplitById } from "./layoutTree.js";
+import { selectWorkspaceTargetWindow, updateWorkspaceTargetWindow } from "./targetWindow.js";
+export function canSwapPanelArea(workspace, input) {
+    const activeWindow = getActiveWindow(selectWorkspaceTargetWindow(workspace, input.panelId));
+    if (!activeWindow || !containsPanel(activeWindow.root, input.panelId)) {
+        return false;
+    }
+    return findExplicitSwapCandidate(activeWindow.root, input) !== null || findSwapCandidate(activeWindow.root, input) !== null;
+}
+export function swapPanelArea(workspace, input) {
+    return updateWorkspaceTargetWindow(workspace, input.panelId, (selected) => swapPanelAreaInActiveWindow(selected, input));
+}
+function swapPanelAreaInActiveWindow(workspace, input) {
+    const activeWindow = getActiveWindow(workspace);
+    if (!activeWindow || !containsPanel(activeWindow.root, input.panelId)) {
+        return workspace;
+    }
+    const explicitCandidate = findExplicitSwapCandidate(activeWindow.root, input);
+    if (explicitCandidate) {
+        return updateActiveWindowRoot(workspace, (root) => canonicalizeLayout(swapNodesById(root, explicitCandidate.sourceNodeId, explicitCandidate.siblingNodeId)));
+    }
+    const candidate = findSwapCandidate(activeWindow.root, input);
+    if (!candidate) {
+        return workspace;
+    }
+    return updateActiveWindowRoot(workspace, (root) => canonicalizeLayout(updateSplitById(root, candidate.splitId, (split) => swapSplitChildren(split))));
+}
+function swapSplitChildren(split) {
+    return {
+        ...split,
+        children: [split.children[1], split.children[0]],
+        sizes: [split.sizes[1], split.sizes[0]]
+    };
+}
+function findSwapCandidate(root, input) {
+    const { panelId, edge } = input;
+    const ancestors = findLayoutBranchAncestors(root, panelId);
+    const targetOrientation = edge === 'left' || edge === 'right' ? 'horizontal' : 'vertical';
+    const expectedChildIndex = edge === 'left' || edge === 'top' ? 1 : 0;
+    if (!ancestors) {
+        return null;
+    }
+    for (let index = ancestors.length - 1; index >= 0; index -= 1) {
+        const ancestor = ancestors[index];
+        if (ancestor.orientation === targetOrientation && ancestor.childIndex === expectedChildIndex) {
+            return {
+                splitId: ancestor.splitId
+            };
+        }
+    }
+    return null;
+}
+function findExplicitSwapCandidate(root, input) {
+    if (!input.sourceAreaPanelIds || !input.siblingAreaPanelIds) {
+        return null;
+    }
+    const expectedSourceIds = normalizePanelIdSet(input.sourceAreaPanelIds);
+    const expectedSiblingIds = normalizePanelIdSet(input.siblingAreaPanelIds);
+    if (expectedSourceIds.length === 0 || expectedSiblingIds.length === 0) {
+        return null;
+    }
+    const sourceNode = findNodeByExactPanelSet(root, expectedSourceIds);
+    const siblingNode = findNodeByExactPanelSet(root, expectedSiblingIds);
+    if (!sourceNode ||
+        !siblingNode ||
+        sourceNode.id === siblingNode.id ||
+        containsNodeId(sourceNode, siblingNode.id) ||
+        containsNodeId(siblingNode, sourceNode.id)) {
+        return null;
+    }
+    return {
+        sourceNodeId: sourceNode.id,
+        siblingNodeId: siblingNode.id
+    };
+}
+function findNodeByExactPanelSet(node, expectedPanelIds) {
+    if (matchesPanelIdSet(normalizePanelIdSet(listPanelIds(node)), expectedPanelIds)) {
+        return node;
+    }
+    if (node.kind === 'stack') {
+        return null;
+    }
+    return findNodeByExactPanelSet(node.children[0], expectedPanelIds) ?? findNodeByExactPanelSet(node.children[1], expectedPanelIds);
+}
+function listPanelIds(node) {
+    return listPanels(node).map((panel) => panel.id);
+}
+function normalizePanelIdSet(panelIds) {
+    return Array.from(new Set(panelIds)).sort();
+}
+function matchesPanelIdSet(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((panelId, index) => panelId === right[index]);
+}
+function swapNodesById(root, sourceNodeId, siblingNodeId) {
+    const sourceNode = findNodeById(root, sourceNodeId);
+    const siblingNode = findNodeById(root, siblingNodeId);
+    if (!sourceNode || !siblingNode) {
+        return root;
+    }
+    return replaceNodes(root, sourceNodeId, siblingNodeId, sourceNode, siblingNode);
+}
+function findNodeById(node, nodeId) {
+    if (node.id === nodeId) {
+        return node;
+    }
+    if (node.kind === 'stack') {
+        return null;
+    }
+    return findNodeById(node.children[0], nodeId) ?? findNodeById(node.children[1], nodeId);
+}
+function containsNodeId(node, nodeId) {
+    if (node.id === nodeId) {
+        return true;
+    }
+    if (node.kind === 'stack') {
+        return false;
+    }
+    return containsNodeId(node.children[0], nodeId) || containsNodeId(node.children[1], nodeId);
+}
+function replaceNodes(node, sourceNodeId, siblingNodeId, sourceNode, siblingNode) {
+    if (node.id === sourceNodeId) {
+        return siblingNode;
+    }
+    if (node.id === siblingNodeId) {
+        return sourceNode;
+    }
+    if (node.kind === 'stack') {
+        return node;
+    }
+    return {
+        ...node,
+        children: [
+            replaceNodes(node.children[0], sourceNodeId, siblingNodeId, sourceNode, siblingNode),
+            replaceNodes(node.children[1], sourceNodeId, siblingNodeId, sourceNode, siblingNode)
+        ]
+    };
+}
+function findLayoutBranchAncestors(node, panelId, trail = []) {
+    if (node.kind === 'stack') {
+        return node.children.some((panel) => panel.id === panelId) ? trail : null;
+    }
+    for (let childIndex = 0; childIndex < node.children.length; childIndex = (childIndex + 1)) {
+        const child = node.children[childIndex];
+        const match = findLayoutBranchAncestors(child, panelId, [
+            ...trail,
+            {
+                splitId: node.id,
+                orientation: node.orientation,
+                childIndex
+            }
+        ]);
+        if (match) {
+            return match;
+        }
+    }
+    return null;
+}

package/dist/application/workspace/targetWindow.d.ts

@@ -0,0 +1,4 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+/** Resolve the mutation context from an explicit layout target, not remote focus. */
+export declare function selectWorkspaceTargetWindow(workspace: Workspace, targetId: string | null | undefined): Workspace;
+export declare function updateWorkspaceTargetWindow(workspace: Workspace, targetId: string, update: (selected: Workspace) => Workspace): Workspace;

package/dist/application/workspace/targetWindow.js

@@ -0,0 +1,22 @@
+import { containsPanel, findStack, findSplit } from "../../domain/layout/selectors.js";
+/** Resolve the mutation context from an explicit layout target, not remote focus. */
+export function selectWorkspaceTargetWindow(workspace, targetId) {
+    if (!targetId)
+        return workspace;
+    const owner = workspace.windows.find(({ root }) => containsPanel(root, targetId) || findStack(root, targetId) || findSplit(root, targetId));
+    return owner && owner.id !== workspace.activeWindowId
+        ? { ...workspace, activeWindowId: owner.id }
+        : workspace;
+}
+export function updateWorkspaceTargetWindow(workspace, targetId, update) {
+    const selected = selectWorkspaceTargetWindow(workspace, targetId);
+    const next = update(selected);
+    // A refused/no-op mutation must not change the active window by itself.
+    const unchangedWindows = next.windows.length === selected.windows.length && next.windows.every((window, index) => {
+        const previous = selected.windows[index];
+        return window.id === previous.id && window.root === previous.root && window.title === previous.title;
+    });
+    return unchangedWindows && next.toolInstances === selected.toolInstances
+        ? workspace
+        : next;
+}

package/dist/application/workspace/toolCapabilities.d.ts

@@ -0,0 +1,11 @@
+import type { ToolDefinition } from "../../domain/tool/model.js";
+import type { ToolRuntimeCapabilitySnapshot } from "../../domain/tool/runtime.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+import type { WorkspaceFocus } from "./session.js";
+export interface ResolveToolRuntimeCapabilitySnapshotInput {
+    consumerDefinition: ToolDefinition;
+    registeredDefinitions: readonly ToolDefinition[];
+    workspace: Workspace;
+    focus: WorkspaceFocus;
+}
+export declare function resolveToolRuntimeCapabilitySnapshot(input: ResolveToolRuntimeCapabilitySnapshotInput): ToolRuntimeCapabilitySnapshot;

package/dist/application/workspace/toolCapabilities.js

@@ -0,0 +1,59 @@
+import { isKonitifCapabilityVersionCompatible } from '@konitif/core';
+import { listPanelsInWorkspace } from "../../domain/workspace/selectors.js";
+export function resolveToolRuntimeCapabilitySnapshot(input) {
+    const placementsByToolId = collectToolPlacements(input.workspace);
+    const projections = Object.freeze((input.consumerDefinition.capabilities?.consumes ?? []).map((requirement) => {
+        const declaredProviders = input.registeredDefinitions.flatMap((definition) => (definition.capabilities?.provides ?? [])
+            .filter((provided) => provided.id === requirement.id)
+            .map((provided) => ({ definition, provided })));
+        const compatibleProviders = declaredProviders.filter(({ provided }) => isKonitifCapabilityVersionCompatible(provided.version, requirement.versionRange));
+        const providers = compatibleProviders.map(({ definition, provided }) => {
+            const placements = placementsByToolId.get(definition.id) ?? [];
+            return Object.freeze({
+                toolId: definition.id,
+                capabilityVersion: provided.version,
+                toolVersion: null,
+                availability: resolveProviderAvailability(placements, input.focus),
+                panelIds: Object.freeze(placements.map((placement) => placement.panelId)),
+                toolInstanceIds: Object.freeze(placements.map((placement) => placement.toolInstance.id))
+            });
+        });
+        return Object.freeze({
+            requirement: Object.freeze({ ...requirement }),
+            availability: providers.some((provider) => provider.availability === 'active')
+                ? 'active'
+                : providers.some((provider) => provider.availability === 'mounted')
+                    ? 'mounted'
+                    : providers.length > 0
+                        ? 'available'
+                        : declaredProviders.length > 0
+                            ? 'incompatible'
+                            : 'missing',
+            providers: Object.freeze(providers)
+        });
+    }));
+    const projectionById = new Map(projections.map((projection) => [projection.requirement.id, projection]));
+    return Object.freeze({
+        list: () => projections,
+        get: (capabilityId) => projectionById.get(capabilityId) ?? null
+    });
+}
+function collectToolPlacements(workspace) {
+    const placements = new Map();
+    for (const panel of listPanelsInWorkspace(workspace)) {
+        const toolInstance = panel.toolInstanceId ? workspace.toolInstances[panel.toolInstanceId] : null;
+        if (!toolInstance) {
+            continue;
+        }
+        const entries = placements.get(toolInstance.toolId) ?? [];
+        entries.push({ panelId: panel.id, toolInstance });
+        placements.set(toolInstance.toolId, entries);
+    }
+    return placements;
+}
+function resolveProviderAvailability(placements, focus) {
+    if (placements.some((placement) => placement.toolInstance.id === focus.activeToolInstanceId)) {
+        return 'active';
+    }
+    return placements.length > 0 ? 'mounted' : 'available';
+}

package/dist/application/workspace/toolRuntime.d.ts

@@ -0,0 +1,32 @@
+import type { JsonObject } from "../../domain/shared/json.js";
+import type { ToolRuntimeCapabilitySnapshot, ToolRuntimeContext } from "../../domain/tool/runtime.js";
+import type { RuntimeProjectionSessionPatch } from "../runtime/RuntimeProjectionSessionTypes.js";
+import type { ToolPanelLoadingState, ToolResourceLoadingState, ToolShellStatus } from "../../domain/tool/model.js";
+import type { WorkbenchReadingLevel } from "../../domain/presentation/readingLevel.js";
+import type { WorkspaceFocus } from "./session.js";
+export interface ToolRuntimeHostActions {
+    updateToolState(toolInstanceId: string, nextState: JsonObject): boolean;
+    setToolPanelTitleOverride(panelId: string, toolInstanceId: string, nextTitle: string | null): boolean;
+    setToolShellStatus(toolInstanceId: string, nextStatus: ToolShellStatus | null): boolean;
+    setToolPanelLoading(toolInstanceId: string, nextLoading: ToolPanelLoadingState | null): boolean;
+    setToolResourceLoading(toolInstanceId: string, nextLoading: ToolResourceLoadingState | null): boolean;
+    patchRuntimeProjectionSession?(patch: RuntimeProjectionSessionPatch): boolean;
+    runToolCommand(panelId: string, toolInstanceId: string, commandId: string): boolean;
+    openTool(toolId: string): boolean;
+    canUndoHistory(): boolean;
+    canRedoHistory(): boolean;
+    undoHistory(): boolean;
+    redoHistory(): boolean;
+}
+interface CreateToolRuntimeContextInput {
+    panelId: string;
+    toolInstanceId: string;
+    focus: WorkspaceFocus;
+    hostActions: ToolRuntimeHostActions;
+    layoutEditingEnabled?: boolean;
+    readingLevel?: WorkbenchReadingLevel;
+    capabilities?: ToolRuntimeCapabilitySnapshot;
+    requestCapability?: (capabilityId: string) => boolean;
+}
+export declare function createToolRuntimeContext(input: CreateToolRuntimeContextInput): ToolRuntimeContext;
+export {};

package/dist/application/workspace/toolRuntime.js

@@ -0,0 +1,65 @@
+const EMPTY_TOOL_RUNTIME_CAPABILITY_SNAPSHOT = Object.freeze({
+    list: () => [],
+    get: () => null
+});
+export function createToolRuntimeContext(input) {
+    const capabilitySnapshot = input.capabilities ?? EMPTY_TOOL_RUNTIME_CAPABILITY_SNAPSHOT;
+    return {
+        toolInstanceId: input.toolInstanceId,
+        panelId: input.panelId,
+        readingLevel: input.readingLevel ?? 'casual',
+        session: {
+            activePanelId: input.focus.activePanelId,
+            activeToolInstanceId: input.focus.activeToolInstanceId,
+            isActivePanel: input.focus.activePanelId === input.panelId,
+            isActiveToolInstance: input.focus.activeToolInstanceId === input.toolInstanceId,
+            layoutEditingEnabled: input.layoutEditingEnabled === true
+        },
+        capabilities: Object.freeze({
+            list: capabilitySnapshot.list,
+            get: capabilitySnapshot.get,
+            request(capabilityId) {
+                return (capabilitySnapshot.get(capabilityId) !== null && (input.requestCapability?.(capabilityId) ?? false));
+            }
+        }),
+        setState(nextState) {
+            return input.hostActions.updateToolState(input.toolInstanceId, nextState);
+        },
+        setPanelTitleOverride(nextTitle) {
+            return input.hostActions.setToolPanelTitleOverride(input.panelId, input.toolInstanceId, nextTitle);
+        },
+        setShellStatus(nextStatus) {
+            return input.hostActions.setToolShellStatus(input.toolInstanceId, nextStatus);
+        },
+        setPanelLoading(nextLoading) {
+            return input.hostActions.setToolPanelLoading(input.toolInstanceId, nextLoading);
+        },
+        setResourceLoading(nextLoading) {
+            return input.hostActions.setToolResourceLoading(input.toolInstanceId, nextLoading);
+        },
+        publishRuntimeProjectionSession(patch) {
+            return (input.hostActions.patchRuntimeProjectionSession?.({
+                ...patch,
+                toolInstanceId: input.toolInstanceId
+            }) ?? false);
+        },
+        runCommand(commandId) {
+            return input.hostActions.runToolCommand(input.panelId, input.toolInstanceId, commandId);
+        },
+        openTool(toolId) {
+            return input.hostActions.openTool(toolId);
+        },
+        canUndoHistory() {
+            return input.hostActions.canUndoHistory();
+        },
+        canRedoHistory() {
+            return input.hostActions.canRedoHistory();
+        },
+        undoHistory() {
+            return input.hostActions.undoHistory();
+        },
+        redoHistory() {
+            return input.hostActions.redoHistory();
+        }
+    };
+}

package/dist/application/workspace/updateToolState.d.ts

@@ -0,0 +1,8 @@
+import type { JsonObject } from "../../domain/shared/json.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+interface UpdateToolStateInput {
+    toolInstanceId: string;
+    nextState: JsonObject;
+}
+export declare function updateToolState(workspace: Workspace, input: UpdateToolStateInput): Workspace;
+export {};

package/dist/application/workspace/updateToolState.js

@@ -0,0 +1,20 @@
+import { cloneJsonObject, isJsonObject } from "../../domain/shared/json.js";
+export function updateToolState(workspace, input) {
+    if (!isJsonObject(input.nextState)) {
+        return workspace;
+    }
+    const toolInstance = workspace.toolInstances[input.toolInstanceId];
+    if (!toolInstance) {
+        return workspace;
+    }
+    return {
+        ...workspace,
+        toolInstances: {
+            ...workspace.toolInstances,
+            [input.toolInstanceId]: {
+                ...toolInstance,
+                state: cloneJsonObject(input.nextState)
+            }
+        }
+    };
+}

package/dist/boot/applicationBoot.d.ts

@@ -0,0 +1 @@
+export * from "../application/boot/applicationBoot.js";

package/dist/boot/applicationBoot.js

@@ -0,0 +1,2 @@
+// Compatibility only: application reveal policy is not part of the DAG mechanism.
+export * from "../application/boot/applicationBoot.js";

package/dist/boot/events.d.ts

@@ -0,0 +1,43 @@
+import type { BootExecutionState, BootPhase } from "./types.js";
+export type BootEvent = {
+    type: 'boot:start';
+    executionId: string;
+    state: BootExecutionState;
+} | {
+    type: 'boot:success';
+    executionId: string;
+    state: BootExecutionState;
+} | {
+    type: 'boot:failed';
+    executionId: string;
+    state: BootExecutionState;
+    error: unknown;
+} | {
+    type: 'phase:start';
+    executionId: string;
+    phase: BootPhase;
+} | {
+    type: 'step:start';
+    executionId: string;
+    stepId: string;
+} | {
+    type: 'step:success';
+    executionId: string;
+    stepId: string;
+} | {
+    type: 'step:failed';
+    executionId: string;
+    stepId: string;
+    error: unknown;
+} | {
+    type: 'step:blocked';
+    executionId: string;
+    stepId: string;
+    reason: string;
+};
+export type BootEventSubscriber = (event: BootEvent) => void;
+export interface BootEventBus {
+    subscribe(subscriber: BootEventSubscriber): () => void;
+    emit(event: BootEvent): void;
+}
+export declare function createBootEventBus(): BootEventBus;

package/dist/boot/events.js

@@ -0,0 +1,16 @@
+export function createBootEventBus() {
+    const subscribers = new Set();
+    return {
+        subscribe(subscriber) {
+            subscribers.add(subscriber);
+            return () => {
+                subscribers.delete(subscriber);
+            };
+        },
+        emit(event) {
+            for (const subscriber of subscribers) {
+                subscriber(event);
+            }
+        },
+    };
+}

package/dist/boot/executor.d.ts

@@ -0,0 +1,13 @@
+import { type BootEventBus } from "./events.js";
+import type { BootContext, BootExecutionState, BootGraph } from "./types.js";
+export interface BootExecutor {
+    run(graph: BootGraph, ctx: BootContext): Promise<BootExecutionState>;
+    teardown(ctx: BootContext): Promise<BootExecutionState>;
+    getState(): BootExecutionState;
+}
+export interface CreateBootExecutorOptions {
+    eventBus?: BootEventBus;
+    now?: () => number;
+    createExecutionId?: () => string;
+}
+export declare function createBootExecutor(options?: CreateBootExecutorOptions): BootExecutor;