@konitif/workbench 0.284.1

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

@@ -0,0 +1,56 @@
+import type { LayoutDockSide } from "./interaction.js";
+import type { SplitOrientation } from "./model.js";
+import type { JsonObject } from "../shared/json.js";
+import type { ShellState } from "../shell/model.js";
+import type { Workspace } from "../workspace/model.js";
+export type LayoutSurfaceKind = 'shell' | 'workspace';
+export type LayoutSurfaceAreaRole = 'root' | 'region' | 'split' | 'stack' | 'panel';
+export type LayoutSurfaceActionKind = 'activate' | 'collapse' | 'close' | 'dock' | 'move' | 'resize' | 'split' | 'toggle-open' | 'toggle-visibility';
+export interface LayoutSurfaceActionProjection {
+    kind: LayoutSurfaceActionKind;
+    targetId: string;
+    label: string;
+    metadata?: JsonObject;
+}
+export interface LayoutSurfaceAreaProjection {
+    id: string;
+    sourceId: string;
+    surfaceId: string;
+    role: LayoutSurfaceAreaRole;
+    title: string;
+    parentId: string | null;
+    childIds: string[];
+    isActive: boolean;
+    isVisible: boolean;
+    isOpen: boolean;
+    actions: LayoutSurfaceActionProjection[];
+    metadata?: JsonObject;
+}
+export interface LayoutSurfaceBoundaryProjection {
+    id: string;
+    sourceId: string;
+    surfaceId: string;
+    orientation: SplitOrientation;
+    areaIds: [string, string];
+    actions: LayoutSurfaceActionProjection[];
+    metadata?: JsonObject;
+}
+export interface LayoutSurfaceProjection {
+    id: string;
+    kind: LayoutSurfaceKind;
+    title: string;
+    rootAreaId: string;
+    areas: Record<string, LayoutSurfaceAreaProjection>;
+    boundaries: Record<string, LayoutSurfaceBoundaryProjection>;
+}
+export interface LayoutUserActionIntent {
+    kind: LayoutSurfaceActionKind;
+    surfaceId: string;
+    targetId: string;
+    side?: LayoutDockSide;
+    orientation?: SplitOrientation;
+    metadata?: JsonObject;
+}
+export declare function createShellLayoutSurfaceProjection(shellState: ShellState): LayoutSurfaceProjection;
+export declare function createWorkspaceLayoutSurfaceProjection(workspace: Workspace, windowId?: string): LayoutSurfaceProjection;
+export declare function createLayoutSurfaceAction(kind: LayoutSurfaceActionKind, targetId: string, label: string, metadata?: JsonObject): LayoutSurfaceActionProjection;

package/dist/domain/layout/surfaceProjection.js

@@ -0,0 +1,249 @@
+const shellRegionOrder = ['left', 'right', 'bottom'];
+export function createShellLayoutSurfaceProjection(shellState) {
+    const surfaceId = 'shell:core';
+    const rootAreaId = `${surfaceId}:root`;
+    const areas = {};
+    const boundaries = {};
+    const childIds = shellRegionOrder.map((regionId) => createShellRegionAreaId(surfaceId, regionId));
+    areas[rootAreaId] = {
+        id: rootAreaId,
+        sourceId: 'shell',
+        surfaceId,
+        role: 'root',
+        title: 'Core shell',
+        parentId: null,
+        childIds,
+        isActive: true,
+        isVisible: true,
+        isOpen: true,
+        actions: [],
+        metadata: {
+            regionIds: shellRegionOrder
+        }
+    };
+    for (const regionId of shellRegionOrder) {
+        const region = shellState.regions[regionId];
+        const areaId = createShellRegionAreaId(surfaceId, regionId);
+        const boundaryId = `${surfaceId}:boundary:${regionId}`;
+        areas[areaId] = {
+            id: areaId,
+            sourceId: regionId,
+            surfaceId,
+            role: 'region',
+            title: `${regionId} region`,
+            parentId: rootAreaId,
+            childIds: [],
+            isActive: region.isOpen,
+            isVisible: region.isVisible,
+            isOpen: region.isOpen,
+            actions: [
+                createLayoutSurfaceAction('toggle-open', areaId, 'Toggle region'),
+                createLayoutSurfaceAction('toggle-visibility', areaId, 'Toggle visibility'),
+                createLayoutSurfaceAction('resize', boundaryId, 'Resize region')
+            ],
+            metadata: {
+                activeWidgetId: region.activeWidgetId,
+                regionId,
+                size: region.size,
+                widgetIds: [...region.widgetIds]
+            }
+        };
+        boundaries[boundaryId] = {
+            id: boundaryId,
+            sourceId: regionId,
+            surfaceId,
+            orientation: regionId === 'bottom' ? 'vertical' : 'horizontal',
+            areaIds: [rootAreaId, areaId],
+            actions: [createLayoutSurfaceAction('resize', boundaryId, 'Resize region')],
+            metadata: {
+                regionId
+            }
+        };
+    }
+    return {
+        id: surfaceId,
+        kind: 'shell',
+        title: 'Core shell',
+        rootAreaId,
+        areas,
+        boundaries
+    };
+}
+export function createWorkspaceLayoutSurfaceProjection(workspace, windowId = workspace.activeWindowId) {
+    const activeWindow = resolveWorkspaceWindow(workspace, windowId);
+    const surfaceId = `workspace:${workspace.id}:${activeWindow?.id ?? 'missing-window'}`;
+    const areas = {};
+    const boundaries = {};
+    if (!activeWindow) {
+        const rootAreaId = `${surfaceId}:root`;
+        areas[rootAreaId] = {
+            id: rootAreaId,
+            sourceId: workspace.id,
+            surfaceId,
+            role: 'root',
+            title: 'Workspace',
+            parentId: null,
+            childIds: [],
+            isActive: false,
+            isVisible: true,
+            isOpen: true,
+            actions: [],
+            metadata: {
+                activeWindowId: workspace.activeWindowId
+            }
+        };
+        return {
+            id: surfaceId,
+            kind: 'workspace',
+            title: 'Workspace',
+            rootAreaId,
+            areas,
+            boundaries
+        };
+    }
+    const rootAreaId = projectWorkspaceLayoutNode({
+        node: activeWindow.root,
+        surfaceId,
+        parentId: null,
+        workspace,
+        areas,
+        boundaries
+    });
+    return {
+        id: surfaceId,
+        kind: 'workspace',
+        title: activeWindow.title,
+        rootAreaId,
+        areas,
+        boundaries
+    };
+}
+export function createLayoutSurfaceAction(kind, targetId, label, metadata) {
+    return {
+        kind,
+        targetId,
+        label,
+        ...(metadata ? { metadata } : {})
+    };
+}
+function resolveWorkspaceWindow(workspace, windowId) {
+    return workspace.windows.find((entry) => entry.id === windowId) ?? workspace.windows[0];
+}
+function projectWorkspaceLayoutNode(input) {
+    if (input.node.kind === 'split') {
+        return projectWorkspaceSplit(input.node, input);
+    }
+    return projectWorkspaceStack(input.node, input);
+}
+function projectWorkspaceSplit(split, input) {
+    const areaId = createWorkspaceAreaId(input.surfaceId, split.id);
+    const childIds = split.children.map((child) => projectWorkspaceLayoutNode({
+        ...input,
+        node: child,
+        parentId: areaId
+    }));
+    const boundaryId = `${input.surfaceId}:boundary:${split.id}`;
+    input.areas[areaId] = {
+        id: areaId,
+        sourceId: split.id,
+        surfaceId: input.surfaceId,
+        role: 'split',
+        title: `${split.orientation} split`,
+        parentId: input.parentId,
+        childIds,
+        isActive: false,
+        isVisible: true,
+        isOpen: true,
+        actions: [
+            createLayoutSurfaceAction('resize', boundaryId, 'Resize split'),
+            createLayoutSurfaceAction('collapse', boundaryId, 'Collapse split')
+        ],
+        metadata: {
+            orientation: split.orientation,
+            sizes: [...split.sizes]
+        }
+    };
+    input.boundaries[boundaryId] = {
+        id: boundaryId,
+        sourceId: split.id,
+        surfaceId: input.surfaceId,
+        orientation: split.orientation,
+        areaIds: childIds,
+        actions: [
+            createLayoutSurfaceAction('resize', boundaryId, 'Resize split'),
+            createLayoutSurfaceAction('collapse', boundaryId, 'Collapse split')
+        ],
+        metadata: {
+            splitId: split.id,
+            sizes: [...split.sizes]
+        }
+    };
+    return areaId;
+}
+function projectWorkspaceStack(stack, input) {
+    const areaId = createWorkspaceAreaId(input.surfaceId, stack.id);
+    const childIds = stack.children.map((panel) => projectWorkspacePanel(panel, {
+        ...input,
+        parentId: areaId,
+        activePanelId: stack.activeChildId
+    }));
+    input.areas[areaId] = {
+        id: areaId,
+        sourceId: stack.id,
+        surfaceId: input.surfaceId,
+        role: 'stack',
+        title: 'Panel stack',
+        parentId: input.parentId,
+        childIds,
+        isActive: true,
+        isVisible: true,
+        isOpen: true,
+        actions: [
+            createLayoutSurfaceAction('activate', areaId, 'Activate stack'),
+            createLayoutSurfaceAction('dock', areaId, 'Dock panel'),
+            createLayoutSurfaceAction('split', areaId, 'Split stack'),
+            createLayoutSurfaceAction('move', areaId, 'Move stack')
+        ],
+        metadata: {
+            activeChildId: stack.activeChildId,
+            headerVisible: stack.headerVisible ?? true,
+            panelIds: stack.children.map((panel) => panel.id)
+        }
+    };
+    return areaId;
+}
+function projectWorkspacePanel(panel, input) {
+    const areaId = createWorkspaceAreaId(input.surfaceId, panel.id);
+    const toolInstance = panel.toolInstanceId ? input.workspace.toolInstances[panel.toolInstanceId] : undefined;
+    input.areas[areaId] = {
+        id: areaId,
+        sourceId: panel.id,
+        surfaceId: input.surfaceId,
+        role: 'panel',
+        title: panel.title,
+        parentId: input.parentId,
+        childIds: [],
+        isActive: input.activePanelId === panel.id,
+        isVisible: input.workspace.fullscreenPanelId ? input.workspace.fullscreenPanelId === panel.id : true,
+        isOpen: true,
+        actions: [
+            createLayoutSurfaceAction('activate', areaId, 'Activate panel'),
+            createLayoutSurfaceAction('dock', areaId, 'Dock panel'),
+            createLayoutSurfaceAction('move', areaId, 'Move panel'),
+            createLayoutSurfaceAction('split', areaId, 'Split panel'),
+            createLayoutSurfaceAction('close', areaId, 'Close panel')
+        ],
+        metadata: {
+            showFullscreenToggle: panel.showFullscreenToggle ?? true,
+            toolId: toolInstance?.toolId ?? null,
+            toolInstanceId: panel.toolInstanceId
+        }
+    };
+    return areaId;
+}
+function createShellRegionAreaId(surfaceId, regionId) {
+    return `${surfaceId}:region:${regionId}`;
+}
+function createWorkspaceAreaId(surfaceId, sourceId) {
+    return `${surfaceId}:area:${sourceId}`;
+}

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

@@ -0,0 +1,9 @@
+import type { LayoutNode } from "./model.js";
+export declare const LAYOUT_MIN_SPLIT_SIZE = 0.02;
+export interface LayoutValidationIssue {
+    path: string;
+    message: string;
+}
+export declare function normalizeSplitSizes([left, right]: [number, number]): [number, number];
+export declare function isNormalizedSplitSizes([left, right]: [number, number]): boolean;
+export declare function validateLayout(node: LayoutNode): LayoutValidationIssue[];

package/dist/domain/layout/validation.js

@@ -0,0 +1,71 @@
+import { listSplits, listStacks } from "./selectors.js";
+export const LAYOUT_MIN_SPLIT_SIZE = 0.02;
+export function normalizeSplitSizes([left, right]) {
+    const safeLeft = Number.isFinite(left) ? left : 1;
+    const safeRight = Number.isFinite(right) ? right : 1;
+    const total = safeLeft + safeRight;
+    if (!Number.isFinite(total) || total <= 0) {
+        return [0.5, 0.5];
+    }
+    const normalizedLeft = safeLeft / total;
+    const normalizedRight = safeRight / total;
+    if (normalizedLeft < LAYOUT_MIN_SPLIT_SIZE) {
+        return [LAYOUT_MIN_SPLIT_SIZE, 1 - LAYOUT_MIN_SPLIT_SIZE];
+    }
+    if (normalizedRight < LAYOUT_MIN_SPLIT_SIZE) {
+        return [1 - LAYOUT_MIN_SPLIT_SIZE, LAYOUT_MIN_SPLIT_SIZE];
+    }
+    return [normalizedLeft, normalizedRight];
+}
+export function isNormalizedSplitSizes([left, right]) {
+    if (!Number.isFinite(left) || !Number.isFinite(right)) {
+        return false;
+    }
+    if (left < LAYOUT_MIN_SPLIT_SIZE || right < LAYOUT_MIN_SPLIT_SIZE) {
+        return false;
+    }
+    return Math.abs(left + right - 1) < 0.0001;
+}
+export function validateLayout(node) {
+    const issues = [];
+    const panelIds = new Set();
+    const stackIds = new Set();
+    const splitIds = new Set();
+    for (const stack of listStacks(node)) {
+        if (stackIds.has(stack.id)) {
+            issues.push({ path: stack.id, message: 'Duplicate stack id.' });
+        }
+        stackIds.add(stack.id);
+        if (!stack.children.length) {
+            issues.push({ path: stack.id, message: 'Stack must contain at least one panel.' });
+        }
+        if (!stack.children.some((panel) => panel.id === stack.activeChildId)) {
+            issues.push({ path: stack.id, message: 'Stack activeChildId must reference a child panel.' });
+        }
+        for (const panel of stack.children) {
+            if (panelIds.has(panel.id)) {
+                issues.push({ path: panel.id, message: 'Duplicate panel id.' });
+            }
+            panelIds.add(panel.id);
+            if (!panel.title.trim()) {
+                issues.push({ path: panel.id, message: 'Panel title must not be empty.' });
+            }
+            if (panel.toolInstanceId !== null && typeof panel.toolInstanceId !== 'string') {
+                issues.push({ path: panel.id, message: 'Panel toolInstanceId must be a string or null.' });
+            }
+            if (panel.showFullscreenToggle !== undefined && typeof panel.showFullscreenToggle !== 'boolean') {
+                issues.push({ path: panel.id, message: 'Panel showFullscreenToggle must be a boolean when provided.' });
+            }
+        }
+    }
+    for (const split of listSplits(node)) {
+        if (splitIds.has(split.id)) {
+            issues.push({ path: split.id, message: 'Duplicate split id.' });
+        }
+        splitIds.add(split.id);
+        if (!isNormalizedSplitSizes(split.sizes)) {
+            issues.push({ path: split.id, message: 'Split sizes must be finite, clamped, and normalized.' });
+        }
+    }
+    return issues;
+}

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

@@ -0,0 +1,9 @@
+export interface PanelNode {
+    id: string;
+    /**
+     * Panels own their display title so layout snapshots stay serializable even when a tool definition changes later.
+     */
+    title: string;
+    toolInstanceId: string | null;
+    showFullscreenToggle?: boolean;
+}

package/dist/domain/panel/model.js

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

package/dist/domain/physics/colliderGeometry.d.ts

@@ -0,0 +1,2 @@
+/** Compatibility entry; canonical geometry belongs to the physics package. */
+export type { PhysicsColliderProxy, PhysicsColliderProxyShape } from '@konitif/physics';

package/dist/domain/physics/colliderGeometry.js

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

package/dist/domain/physics/contracts.d.ts

@@ -0,0 +1,2 @@
+/** Compatibility export from the physical domain owner. */
+export type * from '@konitif/physics';

package/dist/domain/physics/contracts.js

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

package/dist/domain/physics/kinematicBinding.d.ts

@@ -0,0 +1,22 @@
+/** Bidirectional coordinate/joint correspondence, not only display settings. */
+export type PhysicsCoordinateFrame = 'viewer-y-up' | 'mujoco-z-up' | 'z-up' | 'custom';
+export type PhysicsJointMappingMode = 'direct' | 'mimic' | 'fixed' | 'visual-only' | 'physics-only';
+/** @deprecated Historical compatibility shape; source providers own authored correspondences. */
+export interface PhysicsJointMapping {
+    mode: PhysicsJointMappingMode;
+    visualJointName?: string;
+    physicsJointName?: string;
+    sourceJointName?: string;
+    scale?: number;
+    sign?: number;
+    offset?: number;
+    lowerLimit?: number | null;
+    upperLimit?: number | null;
+    label?: string;
+}
+/** @deprecated Historical compatibility shape, not workspace authority. */
+export interface PhysicsKinematicBinding {
+    coordinateFrame?: PhysicsCoordinateFrame | string;
+    sceneYawRadians?: number;
+    jointMappings?: PhysicsJointMapping[];
+}

package/dist/domain/physics/kinematicBinding.js

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

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

@@ -0,0 +1,4 @@
+/** Compatibility entry point. New internal boundaries can import their specific contract module. */
+export type * from "./contracts.js";
+export type * from "./visualAlignment.js";
+export type * from "./mujoco.js";

package/dist/domain/physics/model.js

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

package/dist/domain/physics/mujoco.d.ts

@@ -0,0 +1,5 @@
+/** @deprecated Compatibility shape only. Module locations belong to the consuming MuJoCo adapter. */
+export interface MujocoPhysicsInitOptions {
+    moduleUrl?: string;
+    moduleUrlCandidates?: string[];
+}

package/dist/domain/physics/mujoco.js

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

package/dist/domain/physics/observationProfile.d.ts

@@ -0,0 +1,2 @@
+/** Compatibility entry; canonical observation scope belongs to physics. */
+export type { PhysicsObservationProfile } from '@konitif/physics';

package/dist/domain/physics/observationProfile.js

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

package/dist/domain/physics/presentationBinding.d.ts

@@ -0,0 +1,6 @@
+/** @deprecated Historical visual binding shape. Source providers own these declarations. */
+export interface PhysicsPresentationBinding {
+    visualRootBodyName?: string;
+    bodyVisualObjectNames?: Record<string, string[]>;
+    debugHiddenBodyNames?: string[];
+}

package/dist/domain/physics/presentationBinding.js

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

package/dist/domain/physics/simulationProfile.d.ts

@@ -0,0 +1,2 @@
+/** Compatibility entry; canonical simulation inputs belong to physics. */
+export type { PhysicsSimulationProfile } from '@konitif/physics';

package/dist/domain/physics/simulationProfile.js

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

package/dist/domain/physics/visualAlignment.d.ts

@@ -0,0 +1,17 @@
+import type { PhysicsPresentationBinding } from './presentationBinding.js';
+import type { PhysicsKinematicBinding } from './kinematicBinding.js';
+import type { PhysicsSimulationProfile } from './simulationProfile.js';
+import type { PhysicsObservationProfile } from './observationProfile.js';
+export type * from './presentationBinding.js';
+export type * from './kinematicBinding.js';
+export type * from './simulationProfile.js';
+export type * from './observationProfile.js';
+export type * from './colliderGeometry.js';
+/**
+ * Legacy aggregate retained for source compatibility and existing metadata.
+ * The name is historical: these fields also affect commands and simulation.
+ * Runtime adapters retain their existing fallbacks (notably COM to visual root).
+ * @deprecated Historical source encoding; not a Workbench-owned model.
+ */
+export interface PhysicsVisualAlignmentProfile extends PhysicsPresentationBinding, PhysicsKinematicBinding, PhysicsSimulationProfile, PhysicsObservationProfile {
+}

package/dist/domain/physics/visualAlignment.js

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

package/dist/domain/presentation/readingLevel.d.ts

@@ -0,0 +1,12 @@
+export declare const WORKBENCH_READING_LEVELS: readonly ["casual", "advanced", "expert"];
+export declare const DEFAULT_WORKBENCH_READING_LEVEL: WorkbenchReadingLevel;
+export type WorkbenchReadingLevel = (typeof WORKBENCH_READING_LEVELS)[number];
+export interface WorkbenchReadingLevelPresentation {
+    /** Optional authored override of the inherited user preference. */
+    defaultLevel?: WorkbenchReadingLevel;
+    availableLevels?: readonly WorkbenchReadingLevel[];
+}
+export declare function isWorkbenchReadingLevel(value: unknown): value is WorkbenchReadingLevel;
+export declare function normalizeWorkbenchReadingLevels(presentation: WorkbenchReadingLevelPresentation | null | undefined): WorkbenchReadingLevel[];
+export declare function resolveWorkbenchReadingLevel(value: unknown, presentation: WorkbenchReadingLevelPresentation | null | undefined, inheritedDefault?: WorkbenchReadingLevel): WorkbenchReadingLevel;
+export declare function isAudienceVisibleAtReadingLevel(audience: WorkbenchReadingLevel, readingLevel: WorkbenchReadingLevel): boolean;

package/dist/domain/presentation/readingLevel.js

@@ -0,0 +1,29 @@
+export const WORKBENCH_READING_LEVELS = ['casual', 'advanced', 'expert'];
+export const DEFAULT_WORKBENCH_READING_LEVEL = 'casual';
+export function isWorkbenchReadingLevel(value) {
+    return typeof value === 'string' && WORKBENCH_READING_LEVELS.includes(value);
+}
+export function normalizeWorkbenchReadingLevels(presentation) {
+    if (!presentation)
+        return [];
+    const requested = presentation.availableLevels ?? WORKBENCH_READING_LEVELS;
+    const normalized = WORKBENCH_READING_LEVELS.filter((level) => requested.includes(level));
+    if (presentation.defaultLevel && !normalized.includes(presentation.defaultLevel)) {
+        normalized.push(presentation.defaultLevel);
+        normalized.sort((left, right) => WORKBENCH_READING_LEVELS.indexOf(left) - WORKBENCH_READING_LEVELS.indexOf(right));
+    }
+    return normalized;
+}
+export function resolveWorkbenchReadingLevel(value, presentation, inheritedDefault = DEFAULT_WORKBENCH_READING_LEVEL) {
+    const availableLevels = normalizeWorkbenchReadingLevels(presentation);
+    const requestedFallback = presentation?.defaultLevel ?? inheritedDefault;
+    const fallback = availableLevels.length === 0 || availableLevels.includes(requestedFallback)
+        ? requestedFallback
+        : availableLevels[0] ?? DEFAULT_WORKBENCH_READING_LEVEL;
+    return isWorkbenchReadingLevel(value) && (availableLevels.length === 0 || availableLevels.includes(value))
+        ? value
+        : fallback;
+}
+export function isAudienceVisibleAtReadingLevel(audience, readingLevel) {
+    return WORKBENCH_READING_LEVELS.indexOf(audience) <= WORKBENCH_READING_LEVELS.indexOf(readingLevel);
+}

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

@@ -0,0 +1,55 @@
+export type WorkbenchProjectTargetKind = 'app' | 'repository';
+export type WorkbenchProjectLaunchProfileKind = 'core-only' | 'repo-inspect-only' | 'app-safe-mode' | 'app-full-runtime' | 'sandbox-runtime' | 'recovery-mode';
+export interface WorkbenchProjectRepository {
+    id: string;
+    label: string;
+    root: string;
+    defaultLaunchProfileId?: string | null;
+}
+export interface WorkbenchProjectApp {
+    id: string;
+    label: string;
+    root: string;
+    repositoryId?: string | null;
+    defaultLaunchProfileId?: string | null;
+    faviconDataUrl?: string | null;
+}
+export interface WorkbenchProjectLaunchProfile {
+    id: string;
+    label: string;
+    kind: WorkbenchProjectLaunchProfileKind;
+    targetKind: WorkbenchProjectTargetKind | 'self';
+    defaultFor?: WorkbenchProjectTargetKind | 'self' | null;
+    inspectOnly: boolean;
+    safeMode: boolean;
+}
+export interface WorkbenchProjectPolicies {
+    allowLocalRepositories: boolean;
+    allowSandboxRepositories: boolean;
+    requirePreflight: boolean;
+}
+export interface WorkbenchProjectObservabilityPreferences {
+    quality: 'off' | 'low' | 'medium' | 'high';
+    persistSnapshots: boolean;
+    captureStackTraces: boolean;
+}
+export interface WorkbenchProjectRecentSession {
+    id: string;
+    targetId: string;
+    targetKind: WorkbenchProjectTargetKind | 'self';
+    profileId: string;
+    updatedAt: string;
+}
+export interface WorkbenchProjectManifest {
+    id: string;
+    label: string;
+    version: 1;
+    apps: WorkbenchProjectApp[];
+    repositories: WorkbenchProjectRepository[];
+    launchProfiles: WorkbenchProjectLaunchProfile[];
+    policies: WorkbenchProjectPolicies;
+    recentSessions: WorkbenchProjectRecentSession[];
+    observability: WorkbenchProjectObservabilityPreferences;
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/domain/project/model.js

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