@konitif/workbench 0.284.1

package/dist/domain/runtime/teardown.js

@@ -0,0 +1,109 @@
+const TEARDOWN_STEPS = [
+    { kind: 'stop-services', label: 'Stop services' },
+    { kind: 'dispose-managers', label: 'Dispose managers' },
+    { kind: 'terminate-workers', label: 'Terminate workers' },
+    { kind: 'unsubscribe-stores', label: 'Unsubscribe stores' },
+    { kind: 'flush-logs', label: 'Flush logs' },
+    { kind: 'persist-final-checkpoint', label: 'Persist final checkpoint' },
+    { kind: 'close-repo-handles', label: 'Close repository handles' },
+    { kind: 'return-launch-gate', label: 'Return launch gate' }
+];
+export function createRuntimeTeardownSnapshot(timestamp = new Date().toISOString(), reason = 'User requested teardown.') {
+    const steps = TEARDOWN_STEPS.map((step) => ({
+        id: `teardown:${step.kind}`,
+        kind: step.kind,
+        label: step.label,
+        status: 'pending',
+        startedAt: null,
+        completedAt: null,
+        message: null
+    }));
+    const firstStep = steps[0] ?? null;
+    return {
+        status: 'running',
+        activeStepId: firstStep?.id ?? null,
+        progress: 0,
+        reason,
+        report: null,
+        steps: firstStep
+            ? steps.map((step) => step.id === firstStep.id ? { ...step, status: 'running', startedAt: timestamp } : step)
+            : steps,
+        startedAt: timestamp,
+        updatedAt: timestamp,
+        completedAt: null,
+        error: null
+    };
+}
+export function completeRuntimeTeardownStep(snapshot, stepId, timestamp = new Date().toISOString(), message = null) {
+    const steps = snapshot.steps.map((step) => step.id === stepId
+        ? {
+            ...step,
+            status: 'completed',
+            completedAt: timestamp,
+            message
+        }
+        : step);
+    const nextPendingStep = steps.find((step) => step.status === 'pending') ?? null;
+    const nextSteps = nextPendingStep
+        ? steps.map((step) => step.id === nextPendingStep.id
+            ? {
+                ...step,
+                status: 'running',
+                startedAt: timestamp
+            }
+            : step)
+        : steps;
+    const progress = calculateTeardownProgress(nextSteps);
+    const completed = progress >= 100;
+    const report = completed
+        ? createTeardownReport(snapshot.reason, nextSteps, timestamp, null)
+        : snapshot.report;
+    return {
+        ...snapshot,
+        status: completed ? 'completed' : 'running',
+        activeStepId: completed ? null : nextPendingStep?.id ?? null,
+        progress,
+        report,
+        steps: nextSteps,
+        updatedAt: timestamp,
+        completedAt: completed ? timestamp : null,
+        error: null
+    };
+}
+export function failRuntimeTeardownStep(snapshot, stepId, error, timestamp = new Date().toISOString()) {
+    const steps = snapshot.steps.map((step) => step.id === stepId
+        ? {
+            ...step,
+            status: 'failed',
+            completedAt: timestamp,
+            message: error
+        }
+        : step);
+    return {
+        ...snapshot,
+        status: 'failed',
+        activeStepId: null,
+        progress: calculateTeardownProgress(steps),
+        report: createTeardownReport(snapshot.reason, steps, timestamp, stepId),
+        steps,
+        updatedAt: timestamp,
+        completedAt: timestamp,
+        error
+    };
+}
+function createTeardownReport(reason, steps, timestamp, failedStepId) {
+    return {
+        id: `teardown-report:${timestamp}`,
+        createdAt: timestamp,
+        reason,
+        completedSteps: steps.filter((step) => step.status === 'completed').length,
+        failedStepId
+    };
+}
+function calculateTeardownProgress(steps) {
+    if (steps.length === 0) {
+        return 100;
+    }
+    const resolvedSteps = steps.filter((step) => step.status === 'completed').length;
+    return Math.round((resolvedSteps / steps.length) * 100);
+}

package/dist/domain/shared/id.d.ts

@@ -0,0 +1 @@
+export declare function createId(prefix: string): string;

package/dist/domain/shared/id.js

@@ -0,0 +1,5 @@
+let sequence = 0;
+export function createId(prefix) {
+    sequence += 1;
+    return `${prefix}-${Date.now().toString(36)}-${sequence.toString(36)}`;
+}

package/dist/domain/shared/json.d.ts

@@ -0,0 +1,9 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+export type JsonArray = JsonValue[];
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export declare function isJsonValue(value: unknown): value is JsonValue;
+export declare function isJsonObject(value: unknown): value is JsonObject;
+export declare function cloneJsonObject<T extends JsonObject>(value: T): T;

package/dist/domain/shared/json.js

@@ -0,0 +1,24 @@
+export function isJsonValue(value) {
+    if (value === null) {
+        return true;
+    }
+    switch (typeof value) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+            return Number.isFinite(value) || typeof value !== 'number';
+        case 'object':
+            if (Array.isArray(value)) {
+                return value.every((entry) => isJsonValue(entry));
+            }
+            return Object.values(value).every((entry) => isJsonValue(entry));
+        default:
+            return false;
+    }
+}
+export function isJsonObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value) && isJsonValue(value);
+}
+export function cloneJsonObject(value) {
+    return JSON.parse(JSON.stringify(value));
+}

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

@@ -0,0 +1,40 @@
+import type { WorkbenchIconInput } from "../icon/model.js";
+export type ShellRegionId = 'left' | 'right' | 'bottom';
+export type ShellRegionPresentation = 'tabs' | 'stack';
+export type ShellRegionAxis = 'horizontal' | 'vertical';
+export type ShellWidgetScope = 'global' | 'contextual';
+export interface ShellRegionState {
+    id: ShellRegionId;
+    isVisible: boolean;
+    isOpen: boolean;
+    size: number;
+    activeWidgetId: string | null;
+    widgetIds: string[];
+    hiddenWidgetIds?: string[];
+    presentation?: ShellRegionPresentation;
+    axis?: ShellRegionAxis;
+}
+export interface ShellState {
+    regions: Record<ShellRegionId, ShellRegionState>;
+}
+export interface ShellWidgetPlacement {
+    beforeWidgetId?: string | null;
+    afterWidgetId?: string | null;
+}
+export interface ShellWidgetDefinition {
+    id: string;
+    capabilityId?: string | null;
+    title: string;
+    icon?: WorkbenchIconInput;
+    description: string;
+    defaultRegion: ShellRegionId;
+    scope: ShellWidgetScope;
+    contextToolIds?: string[];
+    hidePanelHeader?: boolean;
+    initiallyConnected?: boolean;
+}
+export interface ShellWidgetCatalogPort {
+    getDefinition(widgetId: string): ShellWidgetDefinition | undefined;
+    list?(): ShellWidgetDefinition[];
+}
+export type ShellWidgetCatalog = ShellWidgetCatalogPort;

package/dist/domain/shell/model.js

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

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

@@ -0,0 +1,76 @@
+import type { DesignSystemThemeSession } from "../design-system/themeSession.js";
+import type { JsonObject } from "../shared/json.js";
+import type { ToolCatalogPort } from "../tool/model.js";
+import type { Workspace } from "../workspace/model.js";
+import type { WorkspaceFocus } from "../workspace/session.js";
+import type { WorkbenchReadingLevel } from "../presentation/readingLevel.js";
+import type { ShellRegionId, ShellWidgetDefinition } from "./model.js";
+export interface ShellWidgetSessionInfo {
+    activePanelId: string | null;
+    activePanelTitle: string | null;
+    activeToolInstanceId: string | null;
+    activeToolId: string | null;
+    activeToolTitle: string | null;
+}
+export interface ShellWidgetDesignSystemEntity {
+    id: string;
+    kind: string;
+    title: string;
+    summary: string;
+    status: string;
+    source: string;
+    designNodeIds: string[];
+    tokens: string[];
+    cssVariables: string[];
+    widgetIds: string[];
+    toolIds: string[];
+    runtimeProjectionKinds: string[];
+    capabilities: string[];
+}
+export interface ShellWidgetDesignSystemRelation {
+    id: string;
+    from: string;
+    to: string;
+    kind: string;
+}
+export interface ShellWidgetDesignSystemContext {
+    themeSession: DesignSystemThemeSession | null;
+    entities: ShellWidgetDesignSystemEntity[];
+    relations: ShellWidgetDesignSystemRelation[];
+    totals: {
+        entities: number;
+        widgets: number;
+        tools: number;
+        panels: number;
+        runtimeProjections: number;
+        undoBridges: number;
+    };
+}
+export interface ShellWidgetRuntimeContext {
+    regionId: ShellRegionId;
+    widgetId: string;
+    workspace: Workspace;
+    focus: WorkspaceFocus;
+    session: Readonly<ShellWidgetSessionInfo>;
+    designSystem: Readonly<ShellWidgetDesignSystemContext> | null;
+    /** Reading projection inherited from the active Tool when one exists. */
+    readingLevel: WorkbenchReadingLevel;
+    setActiveToolState(nextState: JsonObject): boolean;
+    setToolState(toolInstanceId: string, nextState: JsonObject): boolean;
+}
+export interface HostedShellWidgetProps {
+    definition: ShellWidgetDefinition;
+    runtime: ShellWidgetRuntimeContext;
+}
+interface CreateShellWidgetRuntimeContextInput {
+    regionId: ShellRegionId;
+    widgetId: string;
+    workspace: Workspace;
+    focus: WorkspaceFocus;
+    toolCatalog: ToolCatalogPort;
+    designSystem?: ShellWidgetDesignSystemContext | null;
+    updateToolState?: (toolInstanceId: string, nextState: JsonObject) => boolean;
+    inheritedReadingLevel?: WorkbenchReadingLevel;
+}
+export declare function createShellWidgetRuntimeContext(input: CreateShellWidgetRuntimeContextInput): ShellWidgetRuntimeContext;
+export {};

package/dist/domain/shell/runtime.js

@@ -0,0 +1,40 @@
+import { findPanelInWorkspace } from "../workspace/selectors.js";
+import { resolveToolReadingLevel } from "../tool/shell.js";
+export function createShellWidgetRuntimeContext(input) {
+    const focusedPanel = input.focus.activePanelId
+        ? findPanelInWorkspace(input.workspace, input.focus.activePanelId)
+        : undefined;
+    const focusedToolInstance = input.focus.activeToolInstanceId
+        ? input.workspace.toolInstances[input.focus.activeToolInstanceId]
+        : undefined;
+    const focusedToolDefinition = focusedToolInstance
+        ? input.toolCatalog.getDefinition(focusedToolInstance.toolId)
+        : undefined;
+    return {
+        regionId: input.regionId,
+        widgetId: input.widgetId,
+        workspace: input.workspace,
+        focus: input.focus,
+        session: createShellWidgetSessionInfo(focusedPanel, focusedToolInstance, focusedToolDefinition),
+        designSystem: input.designSystem ?? null,
+        readingLevel: focusedToolInstance && focusedToolDefinition
+            ? resolveToolReadingLevel(focusedToolDefinition, focusedToolInstance, input.inheritedReadingLevel)
+            : input.inheritedReadingLevel ?? 'casual',
+        setActiveToolState(nextState) {
+            const toolInstanceId = input.focus.activeToolInstanceId;
+            return toolInstanceId ? input.updateToolState?.(toolInstanceId, nextState) ?? false : false;
+        },
+        setToolState(toolInstanceId, nextState) {
+            return toolInstanceId ? input.updateToolState?.(toolInstanceId, nextState) ?? false : false;
+        }
+    };
+}
+function createShellWidgetSessionInfo(panel, toolInstance, toolDefinition) {
+    return {
+        activePanelId: panel?.id ?? null,
+        activePanelTitle: panel?.title ?? null,
+        activeToolInstanceId: toolInstance?.id ?? null,
+        activeToolId: toolInstance?.toolId ?? null,
+        activeToolTitle: toolDefinition?.title ?? null
+    };
+}

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

@@ -0,0 +1,97 @@
+export type ToolSurfaceKind = 'dom' | 'canvas-2d' | 'scene-3d';
+export type EmbeddableSurfacePlacement = 'tool' | 'widget' | 'sideDock';
+export type EmbeddableSurfaceCapability = 'compact' | 'richList' | 'grid' | 'previewFooter' | 'dragSource' | 'dropTarget' | 'import' | 'multiSelect' | (string & {});
+export interface EmbeddableSurfaceContribution {
+    id: string;
+    ownerToolId?: string;
+    supportedPlacements: EmbeddableSurfacePlacement[];
+    capabilities: EmbeddableSurfaceCapability[];
+}
+export interface EmbeddableSurfaceHostRequest {
+    placement: EmbeddableSurfacePlacement;
+    requiredCapabilities?: EmbeddableSurfaceCapability[];
+}
+export type ToolSurfaceCapability = 'inspect.selection' | 'inspect.diagnostics' | 'inspect.bounds' | 'viewport.pan' | 'viewport.zoom' | 'viewport.fit' | 'viewport.orbit' | 'render.static' | 'render.interactive' | (string & {});
+export type ToolSurfaceViewerCapability = ToolSurfaceCapability;
+export interface ToolSurfaceDefinition {
+    id: string;
+    toolId: string;
+    kind: ToolSurfaceKind;
+    title: string;
+    summary: string;
+    capabilities: ToolSurfaceCapability[];
+    projectionKinds: string[];
+}
+export declare function canHostEmbeddableSurface(contribution: EmbeddableSurfaceContribution, request: EmbeddableSurfaceHostRequest): boolean;
+export declare function resolveEmbeddableSurfaceCapabilities(contribution: EmbeddableSurfaceContribution, requestedCapabilities: readonly EmbeddableSurfaceCapability[]): EmbeddableSurfaceCapability[];
+export interface ToolSurfaceViewerDefinition {
+    id: string;
+    title: string;
+    version: string;
+    summary: string;
+    surfaceKinds: ToolSurfaceKind[];
+    projectionKinds: string[];
+    capabilities: ToolSurfaceCapability[];
+    priority?: number;
+}
+export interface ToolSurfaceViewerCompatibilityInput {
+    surfaceKind: ToolSurfaceKind;
+    projectionKind: string;
+    requiredCapabilities?: ToolSurfaceCapability[];
+}
+export interface ToolSurfaceViewerCatalogPort {
+    getDefinition(viewerId: string): ToolSurfaceViewerDefinition | undefined;
+    list(): ToolSurfaceViewerDefinition[];
+    listCompatible(input: ToolSurfaceViewerCompatibilityInput): ToolSurfaceViewerDefinition[];
+}
+export type SurfaceViewerCatalogPort = ToolSurfaceViewerCatalogPort;
+export type ToolSurfaceViewerCatalog = ToolSurfaceViewerCatalogPort;
+export type ProjectionSurfaceKind = 'web_development' | 'tauri_development' | 'tauri_release' | 'tauri_installed' | 'desktop_internal_qa' | 'unknown';
+export type ProjectionSurfaceHostKind = 'browser' | 'tauri' | 'unknown';
+export type ProjectionSurfaceDiagnosticProfile = 'none' | 'desktop_internal_qa';
+export type ProjectionSurfaceSupportStatus = 'supported' | 'supported_with_warnings' | 'blocked' | 'failed' | 'not_applicable' | 'unknown';
+export interface ProjectionSurfaceCapabilities {
+    pointer: ProjectionSurfaceSupportStatus;
+    keyboard: ProjectionSurfaceSupportStatus;
+    contextMenu: ProjectionSurfaceSupportStatus;
+    portalRoot: ProjectionSurfaceSupportStatus;
+    nativeWindow: ProjectionSurfaceSupportStatus;
+}
+export interface ProjectionSurfaceDiagnostic {
+    severity: 'info' | 'warning' | 'error';
+    code: string;
+    message: string;
+}
+export interface ProjectionSurfaceDescriptor {
+    kind: ProjectionSurfaceKind;
+    hostKind: ProjectionSurfaceHostKind;
+    webviewKind: 'browser' | 'webview2' | 'unknown';
+    inputCapabilities: ProjectionSurfaceCapabilities;
+    nativeWindowCapabilities: ProjectionSurfaceCapabilities;
+    portalRootId: string;
+    applicationRootId: string;
+    bootRootId: string;
+    diagnosticProfile: ProjectionSurfaceDiagnosticProfile;
+    viewport: {
+        width: number;
+        height: number;
+        devicePixelRatio: number;
+        zoomFactor: number | null;
+    };
+    focusState: 'focused' | 'blurred' | 'unknown';
+    diagnostics: ProjectionSurfaceDiagnostic[];
+}
+export declare const WORKBENCH_PORTAL_ROOT_ID = "workbench-portal-root";
+export declare function createProjectionSurfaceDescriptor(input?: {
+    kind?: ProjectionSurfaceKind | null;
+    hostKind?: ProjectionSurfaceHostKind | null;
+    webviewKind?: ProjectionSurfaceDescriptor['webviewKind'] | null;
+    diagnosticProfile?: ProjectionSurfaceDiagnosticProfile | null;
+    applicationRootId?: string | null;
+    bootRootId?: string | null;
+    viewport?: Partial<ProjectionSurfaceDescriptor['viewport']> | null;
+    focusState?: ProjectionSurfaceDescriptor['focusState'] | null;
+    hasPortalRoot?: boolean;
+    diagnostics?: ProjectionSurfaceDiagnostic[];
+}): ProjectionSurfaceDescriptor;
+export declare function resolveProjectionSurfaceKind(hostKind: ProjectionSurfaceHostKind, isDevelopment: boolean, isInstalled: boolean): ProjectionSurfaceKind;

package/dist/domain/surface/model.js

@@ -0,0 +1,71 @@
+export function canHostEmbeddableSurface(contribution, request) {
+    if (!contribution.supportedPlacements.includes(request.placement)) {
+        return false;
+    }
+    const availableCapabilities = new Set(contribution.capabilities);
+    return (request.requiredCapabilities ?? []).every((capability) => availableCapabilities.has(capability));
+}
+export function resolveEmbeddableSurfaceCapabilities(contribution, requestedCapabilities) {
+    const availableCapabilities = new Set(contribution.capabilities);
+    return requestedCapabilities.filter((capability) => availableCapabilities.has(capability));
+}
+export const WORKBENCH_PORTAL_ROOT_ID = 'workbench-portal-root';
+export function createProjectionSurfaceDescriptor(input = {}) {
+    const hostKind = input.hostKind ?? 'unknown';
+    const kind = input.kind ?? resolveProjectionSurfaceKind(hostKind, false, false);
+    const hasPortalRoot = input.hasPortalRoot ?? false;
+    const portalStatus = hasPortalRoot ? 'supported' : 'supported_with_warnings';
+    const diagnostics = [...(input.diagnostics ?? [])];
+    if (!hasPortalRoot) {
+        diagnostics.push({
+            severity: 'warning',
+            code: 'projection-surface.portal-root-unobserved',
+            message: 'Workbench portal root was not observed for this surface.'
+        });
+    }
+    return {
+        kind,
+        hostKind,
+        webviewKind: input.webviewKind ?? 'unknown',
+        inputCapabilities: {
+            pointer: 'supported',
+            keyboard: 'supported',
+            contextMenu: 'supported_with_warnings',
+            portalRoot: portalStatus,
+            nativeWindow: hostKind === 'tauri' ? 'supported' : 'not_applicable'
+        },
+        nativeWindowCapabilities: {
+            pointer: hostKind === 'tauri' ? 'supported' : 'not_applicable',
+            keyboard: hostKind === 'tauri' ? 'supported' : 'not_applicable',
+            contextMenu: hostKind === 'tauri' ? 'supported_with_warnings' : 'not_applicable',
+            portalRoot: portalStatus,
+            nativeWindow: hostKind === 'tauri' ? 'supported' : 'not_applicable'
+        },
+        portalRootId: WORKBENCH_PORTAL_ROOT_ID,
+        applicationRootId: input.applicationRootId ?? 'app',
+        bootRootId: input.bootRootId ?? 'workbench-boot-surface',
+        diagnosticProfile: input.diagnosticProfile ?? 'none',
+        viewport: {
+            width: Math.max(0, input.viewport?.width ?? 0),
+            height: Math.max(0, input.viewport?.height ?? 0),
+            devicePixelRatio: Math.max(0, input.viewport?.devicePixelRatio ?? 1),
+            zoomFactor: typeof input.viewport?.zoomFactor === 'number'
+                ? Math.max(0, input.viewport.zoomFactor)
+                : null
+        },
+        focusState: input.focusState ?? 'unknown',
+        diagnostics
+    };
+}
+export function resolveProjectionSurfaceKind(hostKind, isDevelopment, isInstalled) {
+    if (hostKind === 'browser') {
+        return 'web_development';
+    }
+    if (hostKind === 'tauri') {
+        if (isDevelopment) {
+            return 'tauri_development';
+        }
+        return isInstalled ? 'tauri_installed' : 'tauri_release';
+    }
+    return 'unknown';
+}

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

@@ -0,0 +1,95 @@
+import type { JsonObject, JsonValue } from "../shared/json.js";
+export type TemporalScalar = number | string;
+export type TemporalUnit = 'step' | 'frame' | 'second' | 'millisecond' | 'timestamp' | 'revision' | (string & {});
+export type TemporalItemShape = 'instant' | 'segment' | 'range';
+export type TemporalCapability = 'viewport.pan' | 'viewport.zoom' | 'viewport.fit' | 'playback.discrete' | 'playback.continuous' | 'selection.item' | 'selection.range' | 'lanes.group' | 'markers' | 'inspect.payload' | 'inspect.artifacts' | 'diff.snapshot' | (string & {});
+export interface TemporalRange {
+    start: TemporalScalar;
+    end: TemporalScalar;
+    unit: TemporalUnit;
+}
+export interface TemporalCursor {
+    value: TemporalScalar;
+    unit: TemporalUnit;
+    itemId?: string | null;
+}
+export interface TemporalLane {
+    id: string;
+    title: string;
+    summary?: string;
+    groupId?: string | null;
+    order?: number;
+    color?: string;
+    metadata?: JsonObject;
+}
+export interface TemporalMarker {
+    id: string;
+    value: TemporalScalar;
+    unit: TemporalUnit;
+    title: string;
+    kind?: string;
+    metadata?: JsonObject;
+}
+export interface TemporalArtifactRef {
+    kind: 'doc' | 'source' | 'test' | 'schema' | 'fixture' | 'runtime' | 'event' | 'commit' | (string & {});
+    path?: string;
+    ref?: string;
+    label?: string;
+}
+export interface TemporalItem {
+    id: string;
+    laneId: string;
+    kind: string;
+    shape: TemporalItemShape;
+    start: TemporalScalar;
+    end?: TemporalScalar;
+    unit: TemporalUnit;
+    title: string;
+    summary?: string;
+    status?: string;
+    source?: TemporalArtifactRef;
+    artifacts?: TemporalArtifactRef[];
+    payload?: JsonValue;
+    metadata?: JsonObject;
+}
+export interface TemporalDiagnostic {
+    id: string;
+    severity: 'info' | 'warning' | 'error';
+    message: string;
+    itemId?: string;
+}
+export interface TemporalProjection {
+    id: string;
+    dialect: string;
+    title: string;
+    summary?: string;
+    range: TemporalRange;
+    cursor?: TemporalCursor;
+    lanes: TemporalLane[];
+    items: TemporalItem[];
+    markers?: TemporalMarker[];
+    diagnostics?: TemporalDiagnostic[];
+    metadata?: JsonObject;
+}
+export interface TemporalDialectDefinition {
+    id: string;
+    title: string;
+    version: string;
+    summary: string;
+    unit: TemporalUnit;
+    itemKinds: string[];
+    capabilities: TemporalCapability[];
+    projectionKinds?: string[];
+}
+export interface TemporalDialectCompatibilityInput {
+    dialect?: string;
+    unit?: TemporalUnit;
+    projectionKind?: string;
+    requiredCapabilities?: TemporalCapability[];
+}
+export interface TemporalDialectCatalog {
+    getDefinition(dialectId: string): TemporalDialectDefinition | undefined;
+    list(): TemporalDialectDefinition[];
+    listCompatible(input: TemporalDialectCompatibilityInput): TemporalDialectDefinition[];
+}
+export declare function validateTemporalProjection(projection: TemporalProjection, dialect?: TemporalDialectDefinition): TemporalDiagnostic[];

package/dist/domain/temporal/model.js

@@ -0,0 +1,45 @@
+export function validateTemporalProjection(projection, dialect) {
+    const laneIds = new Set(projection.lanes.map((lane) => lane.id));
+    const diagnostics = [];
+    if (dialect && projection.dialect !== dialect.id) {
+        diagnostics.push({
+            id: 'temporal.dialect.mismatch',
+            severity: 'error',
+            message: `Projection dialect "${projection.dialect}" does not match dialect "${dialect.id}".`
+        });
+    }
+    if (projection.range.unit && projection.cursor && projection.cursor.unit !== projection.range.unit) {
+        diagnostics.push({
+            id: 'temporal.cursor.unit-mismatch',
+            severity: 'warning',
+            message: `Cursor unit "${projection.cursor.unit}" differs from range unit "${projection.range.unit}".`
+        });
+    }
+    for (const item of projection.items) {
+        if (!laneIds.has(item.laneId)) {
+            diagnostics.push({
+                id: `temporal.item.${item.id}.missing-lane`,
+                severity: 'error',
+                itemId: item.id,
+                message: `Temporal item "${item.id}" references missing lane "${item.laneId}".`
+            });
+        }
+        if (item.shape !== 'instant' && item.end === undefined) {
+            diagnostics.push({
+                id: `temporal.item.${item.id}.missing-end`,
+                severity: 'warning',
+                itemId: item.id,
+                message: `Temporal ${item.shape} item "${item.id}" should declare an end value.`
+            });
+        }
+        if (dialect && !dialect.itemKinds.includes(item.kind)) {
+            diagnostics.push({
+                id: `temporal.item.${item.id}.unknown-kind`,
+                severity: 'warning',
+                itemId: item.id,
+                message: `Temporal item "${item.id}" uses kind "${item.kind}" outside dialect "${dialect.id}".`
+            });
+        }
+    }
+    return diagnostics;
+}

package/dist/domain/tool/internalTab.d.ts

@@ -0,0 +1,11 @@
+import type { JsonObject } from "../shared/json.js";
+/**
+ * Canonical Tool-instance state key for a Tool-owned internal tab.
+ *
+ * Panel tabs remain owned by the Workbench layout. Tabs rendered inside a
+ * Tool are instead part of that Tool's serializable projection and must never
+ * be promoted to global shell state or persisted through a parallel store.
+ */
+export declare const TOOL_INTERNAL_TAB_STATE_KEY = "activeInternalTab";
+export declare function resolveToolInternalTab<TTab extends string>(state: JsonObject | null | undefined, supportedTabs: readonly TTab[], fallback: TTab): TTab;
+export declare function withToolInternalTab(state: JsonObject | null | undefined, activeTab: string): JsonObject;

package/dist/domain/tool/internalTab.js

@@ -0,0 +1,20 @@
+/**
+ * Canonical Tool-instance state key for a Tool-owned internal tab.
+ *
+ * Panel tabs remain owned by the Workbench layout. Tabs rendered inside a
+ * Tool are instead part of that Tool's serializable projection and must never
+ * be promoted to global shell state or persisted through a parallel store.
+ */
+export const TOOL_INTERNAL_TAB_STATE_KEY = 'activeInternalTab';
+export function resolveToolInternalTab(state, supportedTabs, fallback) {
+    const candidate = state?.[TOOL_INTERNAL_TAB_STATE_KEY];
+    return typeof candidate === 'string' && supportedTabs.includes(candidate)
+        ? candidate
+        : fallback;
+}
+export function withToolInternalTab(state, activeTab) {
+    return {
+        ...(state ?? {}),
+        [TOOL_INTERNAL_TAB_STATE_KEY]: activeTab
+    };
+}