@konitif/workbench 0.285.0 → 0.285.2

package/README.md

@@ -16,6 +16,7 @@ npm install @konitif/workbench
 - Runtime lifecycle, checkpoint, recovery and observability contracts.
 - Project preflight and repository-quality contracts.
 - Explicit workspace persistence, synchronization and surface ports.
+- Content-addressed workspace usage bundles with strict host-context admission.
 
 ## Authority boundary
 
@@ -25,6 +26,11 @@ Widgets and tools retain their own definitions; Workbench admits and hosts them.
 Physical implementations remain in `@konitif/physics` and are only exposed here
 through a compatibility entry.
 
+Workspace presets remain authored source. A usage bundle records an immutable,
+content-addressed projection of a preset and its workspace, shell and focus
+fragments. Admission rejects altered content, incomplete fragments, incompatible
+host contexts and identity/revision conflicts.
+
 ## Quick start
 
 ```ts

package/dist/application/launch/catalogShareReference.d.ts

@@ -0,0 +1,25 @@
+export interface WorkbenchCatalogShareReference {
+    schemaVersion: 1;
+    kind: 'workbench.catalog-reference';
+    element: {
+        kind: 'tool' | 'widget' | 'resource';
+        id: string;
+    };
+    package: {
+        name: string;
+        version: string;
+    };
+    source: {
+        status: 'publisher-page' | 'reference-only';
+        url?: string;
+    };
+    privateSource: boolean;
+}
+export declare function serializeWorkbenchCatalogShareReference(reference: WorkbenchCatalogShareReference): string;
+export declare function parseWorkbenchCatalogShareReference(source: string): {
+    ok: true;
+    reference: WorkbenchCatalogShareReference;
+} | {
+    ok: false;
+    message: string;
+};

package/dist/application/launch/catalogShareReference.js

@@ -0,0 +1,53 @@
+export function serializeWorkbenchCatalogShareReference(reference) {
+    const validated = validateReference(reference);
+    if (!validated.ok)
+        throw new Error(validated.message);
+    return JSON.stringify(reference);
+}
+export function parseWorkbenchCatalogShareReference(source) {
+    try {
+        return validateReference(JSON.parse(source));
+    }
+    catch {
+        return { ok: false, message: 'Catalog share reference is not valid JSON.' };
+    }
+}
+function validateReference(value) {
+    const candidate = value;
+    if (!candidate || candidate.schemaVersion !== 1 || candidate.kind !== 'workbench.catalog-reference') {
+        return { ok: false, message: 'Catalog share reference schema is unsupported.' };
+    }
+    if (!candidate.element || !isNonEmpty(candidate.element.id) || !['tool', 'widget', 'resource'].includes(candidate.element.kind)) {
+        return { ok: false, message: 'Catalog share reference element is invalid.' };
+    }
+    if (!candidate.package || !isNonEmpty(candidate.package.name) || !isNonEmpty(candidate.package.version)) {
+        return { ok: false, message: 'Catalog share reference package identity or version is missing.' };
+    }
+    if (!candidate.source || !['publisher-page', 'reference-only'].includes(candidate.source.status)) {
+        return { ok: false, message: 'Catalog share reference origin is missing.' };
+    }
+    if (candidate.source.status === 'publisher-page') {
+        if (!candidate.source.url || !isSafePublisherUrl(candidate.source.url)) {
+            return { ok: false, message: 'Catalog publisher page must be an HTTPS URL without embedded credentials.' };
+        }
+    }
+    else if (candidate.source.url !== undefined) {
+        return { ok: false, message: 'Reference-only catalog shares cannot claim a publisher URL.' };
+    }
+    if (typeof candidate.privateSource !== 'boolean') {
+        return { ok: false, message: 'Catalog share reference privacy is missing.' };
+    }
+    return { ok: true, reference: candidate };
+}
+function isSafePublisherUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'https:' && !url.username && !url.password;
+    }
+    catch {
+        return false;
+    }
+}
+function isNonEmpty(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}

package/dist/application/launch/workbenchLaunchPolicy.d.ts

@@ -0,0 +1,100 @@
+export type WorkbenchLaunchMode = 'direct' | 'dashboard';
+export type WorkbenchLaunchModeResolution = {
+    ok: true;
+    mode: WorkbenchLaunchMode;
+} | {
+    ok: false;
+    code: 'workbench-launch.invalid-mode';
+    message: string;
+};
+export interface WorkbenchDashboardPreview {
+    kind: 'layout' | 'image';
+    label: string;
+    src?: string;
+    alt?: string;
+}
+export interface WorkbenchDashboardEntry<Selection = unknown> {
+    id: string;
+    title: string;
+    eyebrow: string;
+    description: string;
+    actionLabel: string;
+    selection: Selection;
+    detail?: string;
+    preview?: WorkbenchDashboardPreview;
+}
+export interface WorkbenchLibrarySourceDescriptor {
+    id: string;
+    label: string;
+    kind: 'local' | 'remote';
+    status: 'available' | 'not-configured';
+}
+export interface WorkbenchLibraryItem {
+    id: string;
+    sourceId: string;
+    kind: 'tool' | 'widget' | 'resource';
+    title: string;
+    description: string;
+    versions?: {
+        local?: string | null;
+        localProvenance?: string | null;
+        published?: {
+            status: 'verified' | 'not-configured' | 'unavailable';
+            version?: string | null;
+            channel?: 'npm' | 'github' | 'repository' | 'other';
+            publisher?: string | null;
+            sourceUrl?: string | null;
+            reason?: string | null;
+            acquisition: {
+                status: 'available' | 'unavailable';
+                reason?: string | null;
+            };
+        };
+        hostApplication?: {
+            label: string;
+            version: string;
+        };
+    };
+    icon?: {
+        src: string;
+        alt: string;
+    };
+    illustration?: {
+        src: string;
+        alt: string;
+    };
+    metadata?: Readonly<Record<string, string>>;
+    details?: {
+        description?: string;
+        dependencies?: readonly import("../../domain/catalog/presentation.js").WorkbenchCatalogDependency[];
+        diagram?: import("../../domain/catalog/presentation.js").WorkbenchCatalogDiagram;
+    };
+    share?: {
+        kind: 'catalog-reference';
+        reference: string;
+        publisherUrl?: string | null;
+        limitation: string;
+        privateSource: boolean;
+    };
+}
+export interface WorkbenchLaunchAdmissionIssue {
+    id: string;
+    title: string;
+    description: string;
+    requiredVersion?: string;
+    availableVersions?: string[];
+    acquisition: {
+        status: 'available' | 'unavailable';
+        actionLabel?: string;
+        reason?: string;
+    };
+}
+export interface WorkbenchLaunchAdmissionBlocker {
+    title: string;
+    description: string;
+    issues: WorkbenchLaunchAdmissionIssue[];
+}
+export declare function resolveWorkbenchLaunchMode(input: {
+    requestedMode?: string | readonly string[] | null;
+    configuredDefault?: WorkbenchLaunchMode;
+}): WorkbenchLaunchModeResolution;

package/dist/application/launch/workbenchLaunchPolicy.js

@@ -0,0 +1,20 @@
+export function resolveWorkbenchLaunchMode(input) {
+    const requestedMode = input.requestedMode;
+    if (requestedMode === null || requestedMode === undefined) {
+        return { ok: true, mode: input.configuredDefault ?? 'direct' };
+    }
+    if (typeof requestedMode !== 'string' || requestedMode !== requestedMode.trim() || requestedMode.length === 0) {
+        return invalidMode();
+    }
+    if (requestedMode !== 'direct' && requestedMode !== 'dashboard') {
+        return invalidMode();
+    }
+    return { ok: true, mode: requestedMode };
+}
+function invalidMode() {
+    return {
+        ok: false,
+        code: 'workbench-launch.invalid-mode',
+        message: 'Workbench launch mode must be either "direct" or "dashboard".'
+    };
+}

package/dist/application/shell/state.d.ts

@@ -7,6 +7,7 @@ export declare function resolveShellRegionAxis(region: ShellRegionState): ShellR
 export declare function isShellRegionWidgetVisible(region: ShellRegionState, widgetId: string): boolean;
 export declare function listVisibleShellRegionWidgetIds(region: ShellRegionState): string[];
 export declare function setShellRegionArrangement(shellState: ShellState, regionId: ShellRegionId, presentation: ShellRegionPresentation, axis?: ShellRegionAxis): ShellState;
+export declare function setShellRegionWidgetProportions(shellState: ShellState, regionId: ShellRegionId, proportions: Record<string, number>): ShellState;
 export declare function createShellState(widgetCatalog: ShellWidgetCatalogPort, options?: {
     openRegionIds?: ShellRegionId[];
 }): ShellState;

package/dist/application/shell/state.js

@@ -38,6 +38,16 @@ export function setShellRegionArrangement(shellState, regionId, presentation, ax
         axis: nextAxis
     });
 }
+export function setShellRegionWidgetProportions(shellState, regionId, proportions) {
+    const region = shellState.regions[regionId];
+    if (!region)
+        return shellState;
+    const widgetProportions = Object.fromEntries(region.widgetIds.flatMap(id => {
+        const value = proportions[id];
+        return typeof value === 'number' && Number.isFinite(value) && value > 0 ? [[id, value]] : [];
+    }));
+    return updateShellRegion(shellState, regionId, { ...region, widgetProportions });
+}
 export function createShellState(widgetCatalog, options = {}) {
     return {
         regions: {

package/dist/application/tool/experienceToolSelection.d.ts

@@ -0,0 +1,15 @@
+import { InMemoryToolRegistry } from "../../infrastructure/tools/InMemoryToolRegistry.js";
+import type { ToolDefinition } from "../../domain/tool/model.js";
+export declare class WorkbenchExperienceToolSelection {
+    private readonly availableRegistry;
+    readonly registry: InMemoryToolRegistry;
+    constructor(availableRegistry: InMemoryToolRegistry, initialToolIds?: readonly string[]);
+    listAvailable(): ToolDefinition[];
+    listSelected(): ToolDefinition[];
+    isSelected(toolId: string): boolean;
+    select(toolId: string): boolean;
+    selectAll(toolIds: readonly string[]): boolean;
+    replaceWith(toolIds: readonly string[]): boolean;
+    deselect(toolId: string): boolean;
+}
+export declare function createWorkbenchExperienceToolSelection(availableRegistry: InMemoryToolRegistry, initialToolIds?: readonly string[]): WorkbenchExperienceToolSelection;

package/dist/application/tool/experienceToolSelection.js

@@ -0,0 +1,59 @@
+import { InMemoryToolRegistry } from "../../infrastructure/tools/InMemoryToolRegistry.js";
+export class WorkbenchExperienceToolSelection {
+    availableRegistry;
+    registry = new InMemoryToolRegistry();
+    constructor(availableRegistry, initialToolIds = []) {
+        this.availableRegistry = availableRegistry;
+        for (const toolId of initialToolIds)
+            this.select(toolId);
+    }
+    listAvailable() {
+        return this.availableRegistry.list().map(entry => entry.definition);
+    }
+    listSelected() {
+        return this.registry.list().map(entry => entry.definition);
+    }
+    isSelected(toolId) {
+        return Boolean(this.registry.get(toolId));
+    }
+    select(toolId) {
+        if (this.registry.get(toolId))
+            return true;
+        const entry = this.availableRegistry.get(toolId);
+        if (!entry)
+            return false;
+        this.registry.register(cloneRegistration(entry));
+        return true;
+    }
+    selectAll(toolIds) {
+        const uniqueToolIds = [...new Set(toolIds)];
+        if (uniqueToolIds.some(toolId => !this.registry.get(toolId) && !this.availableRegistry.get(toolId))) {
+            return false;
+        }
+        for (const toolId of uniqueToolIds)
+            this.select(toolId);
+        return true;
+    }
+    replaceWith(toolIds) {
+        const uniqueToolIds = [...new Set(toolIds)];
+        if (uniqueToolIds.some(toolId => !this.availableRegistry.get(toolId)))
+            return false;
+        const requested = new Set(uniqueToolIds);
+        for (const tool of this.listSelected()) {
+            if (!requested.has(tool.id))
+                this.registry.unregister(tool.id);
+        }
+        for (const toolId of uniqueToolIds)
+            this.select(toolId);
+        return true;
+    }
+    deselect(toolId) {
+        return this.registry.unregister(toolId);
+    }
+}
+export function createWorkbenchExperienceToolSelection(availableRegistry, initialToolIds = []) {
+    return new WorkbenchExperienceToolSelection(availableRegistry, initialToolIds);
+}
+function cloneRegistration(entry) {
+    return { ...entry };
+}

package/dist/application/widgets/createWorkbenchWidgetAdapter.d.ts

@@ -1,9 +1,10 @@
 import type { WorkbenchWidgetDefinition } from "../../domain/widget/model.js";
 import type { RegisteredWorkbenchWidget, RegisteredWorkbenchWidgetComponentLoader } from "../../infrastructure/widgets/InMemoryWorkbenchWidgetRegistry.js";
 import { type WidgetDefinitionCatalog } from '@konitif/widgets';
+export type WorkbenchWidgetDefinitionCatalogPort = Pick<WidgetDefinitionCatalog, 'getDefinition'>;
 export type WorkbenchWidgetHosting = Pick<WorkbenchWidgetDefinition, 'icon' | 'supportedSurfaces' | 'presentation'>;
 /** Candidate bridge; neither registers nor loads, and owns no placement state. */
-export declare function createWorkbenchWidgetAdapter(catalog: WidgetDefinitionCatalog, widgetId: string, load: RegisteredWorkbenchWidgetComponentLoader): Readonly<{
+export declare function createWorkbenchWidgetAdapter(catalog: WorkbenchWidgetDefinitionCatalogPort, widgetId: string, load: RegisteredWorkbenchWidgetComponentLoader): Readonly<{
     source: import("@konitif/widgets").WidgetDefinition;
     project(host?: WorkbenchWidgetHosting): RegisteredWorkbenchWidget;
 }>;

package/dist/application/widgets/createWorkbenchWidgetAdapter.js

@@ -1,6 +1,9 @@
 import { bindWidgetImplementation } from '@konitif/widgets';
 /** Candidate bridge; neither registers nor loads, and owns no placement state. */
 export function createWorkbenchWidgetAdapter(catalog, widgetId, load) {
+    // Widgets currently gives its catalog nominal identity through a private Map,
+    // while this bridge only needs the public lookup capability. Keep the
+    // cross-version boundary structural and contain the nominal cast here.
     const binding = bindWidgetImplementation(catalog, widgetId, load);
     return Object.freeze({
         source: binding.definition,

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

@@ -13,6 +13,9 @@ export type WorkspaceCommand = {
     type: 'open-tool-in-new-tab';
     panelId: string;
     toolId: string;
+} | {
+    type: 'unassign-tool';
+    toolId: string;
 } | {
     type: 'split-panel-horizontal';
 } | {

package/dist/application/workspace/commands.js

@@ -14,6 +14,7 @@ import { swapPanelArea } from "./swapPanelArea.js";
 import { createPanel } from "../../domain/workspace/factories.js";
 import { updateActiveWindowRoot, updateStackById } from "./layoutTree.js";
 import { createWorkspaceSessionState, getFocusedPanel } from "./session.js";
+import { unassignTool } from "./unassignTool.js";
 /**
  * Command handling owns focus transitions so Svelte components only emit user intent.
  */
@@ -41,6 +42,8 @@ export function dispatchWorkspaceCommand(state, command, context) {
             return openToolInPanel(normalizedState, command.panelId, command.toolId, context.toolCatalog);
         case 'open-tool-in-new-tab':
             return openToolInNewTab(normalizedState, command.panelId, command.toolId, context.toolCatalog);
+        case 'unassign-tool':
+            return createWorkspaceSessionState(unassignTool(normalizedState.workspace, command.toolId), normalizedState.focus);
         case 'run-tool-shell-command':
             return runFocusedToolShellCommand(normalizedState, command, context.toolCatalog);
         case 'split-panel-horizontal':

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

@@ -0,0 +1,22 @@
+import type { ToolInstance } from "../../domain/tool/model.js";
+import type { WorkspaceSessionState } from "../../domain/workspace/session.js";
+export interface ParkedWorkspaceTool {
+    schemaVersion: 1;
+    toolId: string;
+    instances: Record<string, ToolInstance>;
+    panelBindings: Array<{
+        panelId: string;
+        title: string;
+        toolInstanceId: string;
+    }>;
+    activePanelId: string | null;
+}
+export declare function parkWorkspaceTool(session: WorkspaceSessionState, toolId: string): {
+    session: WorkspaceSessionState;
+    parked: ParkedWorkspaceTool | null;
+};
+export declare function restoreParkedWorkspaceTool(session: WorkspaceSessionState, parked: ParkedWorkspaceTool): {
+    session: WorkspaceSessionState;
+    restored: boolean;
+};
+export declare function isParkedWorkspaceTool(value: unknown): value is ParkedWorkspaceTool;

package/dist/application/workspace/parkedTool.js

@@ -0,0 +1,87 @@
+import { findPanelInWorkspace, listPanelsInWorkspace } from "../../domain/workspace/selectors.js";
+import { createWorkspaceSessionState } from "./session.js";
+import { updatePanelById } from "./layoutTree.js";
+import { unassignTool } from "./unassignTool.js";
+export function parkWorkspaceTool(session, toolId) {
+    const instances = Object.fromEntries(Object.entries(session.workspace.toolInstances)
+        .filter(([, instance]) => instance.toolId === toolId)
+        .map(([instanceId, instance]) => [instanceId, structuredClone(instance)]));
+    const instanceIds = new Set(Object.keys(instances));
+    if (instanceIds.size === 0)
+        return { session, parked: null };
+    const panelBindings = listPanelsInWorkspace(session.workspace)
+        .filter(panel => panel.toolInstanceId !== null && instanceIds.has(panel.toolInstanceId))
+        .map(panel => ({ panelId: panel.id, title: panel.title, toolInstanceId: panel.toolInstanceId }));
+    const workspace = unassignTool(session.workspace, toolId);
+    return {
+        session: createWorkspaceSessionState(workspace, { activePanelId: session.focus.activePanelId }),
+        parked: {
+            schemaVersion: 1,
+            toolId,
+            instances,
+            panelBindings,
+            activePanelId: instanceIds.has(session.focus.activeToolInstanceId ?? '')
+                ? session.focus.activePanelId
+                : null
+        }
+    };
+}
+export function restoreParkedWorkspaceTool(session, parked) {
+    if (!isParkedWorkspaceTool(parked))
+        return { session, restored: false };
+    const instanceIds = new Set(Object.keys(parked.instances));
+    const panelsAreAvailable = parked.panelBindings.every(binding => {
+        const panel = findPanelInWorkspace(session.workspace, binding.panelId);
+        return panel && (panel.toolInstanceId === null || panel.toolInstanceId === binding.toolInstanceId);
+    });
+    const instancesAreAvailable = [...instanceIds].every(instanceId => {
+        const current = session.workspace.toolInstances[instanceId];
+        return !current;
+    });
+    if (!panelsAreAvailable || !instancesAreAvailable)
+        return { session, restored: false };
+    let windows = session.workspace.windows;
+    for (const binding of parked.panelBindings) {
+        windows = windows.map(window => ({
+            ...window,
+            root: updatePanelById(window.root, binding.panelId, panel => ({
+                ...panel,
+                title: binding.title,
+                toolInstanceId: binding.toolInstanceId
+            }))
+        }));
+    }
+    const workspace = {
+        ...session.workspace,
+        windows,
+        toolInstances: {
+            ...session.workspace.toolInstances,
+            ...structuredClone(parked.instances)
+        }
+    };
+    return {
+        session: createWorkspaceSessionState(workspace, {
+            activePanelId: parked.activePanelId ?? session.focus.activePanelId
+        }),
+        restored: true
+    };
+}
+export function isParkedWorkspaceTool(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const candidate = value;
+    if (candidate.schemaVersion !== 1 || typeof candidate.toolId !== 'string' || !candidate.toolId)
+        return false;
+    if (!candidate.instances || typeof candidate.instances !== 'object' || Array.isArray(candidate.instances))
+        return false;
+    if (!Array.isArray(candidate.panelBindings))
+        return false;
+    const instances = candidate.instances;
+    if (Object.entries(instances).some(([id, instance]) => !instance || instance.id !== id || instance.toolId !== candidate.toolId ||
+        !instance.state || typeof instance.state !== 'object' || Array.isArray(instance.state)))
+        return false;
+    if (candidate.panelBindings.some(binding => !binding || typeof binding.panelId !== 'string' || typeof binding.title !== 'string' ||
+        typeof binding.toolInstanceId !== 'string' || !instances[binding.toolInstanceId]))
+        return false;
+    return candidate.activePanelId === null || typeof candidate.activePanelId === 'string';
+}

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

@@ -0,0 +1,36 @@
+import type { ShellWidgetCatalogPort } from "../../domain/shell/model.js";
+import type { ToolCatalogPort } from "../../domain/tool/model.js";
+import { type WorkspacePresetArtifact, type WorkspacePresetCompatibilityRequest, type WorkspacePresetDiagnostic } from "./presetArtifacts.js";
+export interface WorkspacePresetSelectionRequest<Origin extends string = string> {
+    kind: 'workspace-preset-source';
+    origin: Origin;
+    presetId: string;
+    expectedVersion: string | null;
+}
+export interface WorkspacePresetSelectionCandidates {
+    sources: readonly WorkspacePresetArtifact[];
+    toolCatalog: ToolCatalogPort;
+    shellWidgetCatalog: ShellWidgetCatalogPort;
+}
+export interface ResolvedWorkspacePresetSelection<Origin extends string = string> {
+    kind: 'workspace-preset-source';
+    request: WorkspacePresetSelectionRequest<Origin>;
+    source: WorkspacePresetArtifact;
+    toolCatalog: ToolCatalogPort;
+    shellWidgetCatalog: ShellWidgetCatalogPort;
+}
+export type WorkspacePresetSelectionFailureCode = 'workspace-preset-selection.invalid-request' | 'workspace-preset-selection.unknown' | 'workspace-preset-selection.ambiguous' | 'workspace-preset-selection.version-incompatible' | 'workspace-preset-selection.incompatible';
+export type WorkspacePresetSelectionResult<Origin extends string = string> = {
+    ok: true;
+    selection: ResolvedWorkspacePresetSelection<Origin>;
+} | {
+    ok: false;
+    code: WorkspacePresetSelectionFailureCode;
+    message: string;
+    diagnostics: WorkspacePresetDiagnostic[];
+};
+export declare function resolveWorkspacePresetSelection<Origin extends string>(input: {
+    request: WorkspacePresetSelectionRequest<Origin>;
+    candidates: WorkspacePresetSelectionCandidates;
+    compatibilityRequest?: WorkspacePresetCompatibilityRequest;
+}): WorkspacePresetSelectionResult<Origin>;

package/dist/application/workspace/presetSelection.js

@@ -0,0 +1,44 @@
+import { evaluateWorkspacePresetCompatibility } from "./presetArtifacts.js";
+export function resolveWorkspacePresetSelection(input) {
+    const { request, candidates } = input;
+    if (!request.presetId || request.presetId.trim() !== request.presetId) {
+        return failure('workspace-preset-selection.invalid-request', 'Workspace preset selection requires a normalized preset id.');
+    }
+    if (request.expectedVersion !== null &&
+        (!request.expectedVersion || request.expectedVersion.trim() !== request.expectedVersion)) {
+        return failure('workspace-preset-selection.invalid-request', 'Workspace preset selection contains an invalid expected version.');
+    }
+    const matchingSources = candidates.sources.filter(candidate => candidate.id === request.presetId);
+    if (matchingSources.length === 0) {
+        return failure('workspace-preset-selection.unknown', `Workspace preset "${request.presetId}" is unknown.`);
+    }
+    if (matchingSources.length > 1) {
+        return failure('workspace-preset-selection.ambiguous', `Workspace preset identity "${request.presetId}" is ambiguous.`);
+    }
+    const source = matchingSources[0];
+    if (request.expectedVersion !== null && source.version !== request.expectedVersion) {
+        return failure('workspace-preset-selection.version-incompatible', `Workspace preset "${request.presetId}" resolved to ${source.version}, not ${request.expectedVersion}.`);
+    }
+    const diagnostics = evaluateWorkspacePresetCompatibility(source, input.compatibilityRequest ?? {});
+    if (diagnostics.length > 0) {
+        return {
+            ok: false,
+            code: 'workspace-preset-selection.incompatible',
+            message: diagnostics.map(diagnostic => diagnostic.message).join(' '),
+            diagnostics
+        };
+    }
+    return {
+        ok: true,
+        selection: {
+            kind: 'workspace-preset-source',
+            request,
+            source,
+            toolCatalog: candidates.toolCatalog,
+            shellWidgetCatalog: candidates.shellWidgetCatalog
+        }
+    };
+}
+function failure(code, message) {
+    return { ok: false, code, message, diagnostics: [] };
+}

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

@@ -0,0 +1,2 @@
+import type { Workspace } from "../../domain/workspace/model.js";
+export declare function unassignTool(workspace: Workspace, toolId: string): Workspace;

package/dist/application/workspace/unassignTool.js

@@ -0,0 +1,24 @@
+import { listPanelsInWorkspace } from "../../domain/workspace/selectors.js";
+import { pruneUnusedToolInstances } from "./finalizeWorkspace.js";
+import { updatePanelById } from "./layoutTree.js";
+export function unassignTool(workspace, toolId) {
+    const instanceIds = new Set(Object.values(workspace.toolInstances)
+        .filter(instance => instance.toolId === toolId)
+        .map(instance => instance.id));
+    if (instanceIds.size === 0)
+        return workspace;
+    let windows = workspace.windows;
+    for (const panel of listPanelsInWorkspace(workspace)) {
+        if (!panel.toolInstanceId || !instanceIds.has(panel.toolInstanceId))
+            continue;
+        windows = windows.map(window => ({
+            ...window,
+            root: updatePanelById(window.root, panel.id, current => ({
+                ...current,
+                title: 'Welcome',
+                toolInstanceId: null
+            }))
+        }));
+    }
+    return pruneUnusedToolInstances({ ...workspace, windows }, instanceIds);
+}

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

@@ -0,0 +1,58 @@
+import { type WorkspacePresetArtifact } from "./presetArtifacts.js";
+import type { Workspace } from "../../domain/workspace/model.js";
+import type { WorkspaceFocus } from "../../domain/workspace/session.js";
+import type { ShellState } from "../../domain/shell/model.js";
+export interface WorkspaceUsageContext {
+    fixtureSchemaVersion: string;
+    projectSchemaVersion: string;
+    hostContract: string;
+}
+export interface WorkspaceUsageSnapshot {
+    schema: 'konitif.workspace-usage';
+    schemaVersion: 1;
+    source: {
+        presetId: string;
+        revision: string;
+        contentId: string;
+    };
+    context: WorkspaceUsageContext;
+    fragments: Record<string, string>;
+    parentSnapshotId: string | null;
+}
+export interface WorkspaceUsageFragments {
+    workspace: Workspace;
+    shell: ShellState;
+    focus: WorkspaceFocus;
+    [name: string]: unknown;
+}
+export interface WorkspaceUsageBundle {
+    snapshotId: string;
+    snapshot: WorkspaceUsageSnapshot;
+    source: WorkspacePresetArtifact;
+    fragments: WorkspaceUsageFragments;
+}
+export interface WorkspaceUsageDiagnostic {
+    code: 'usage.invalid-shape' | 'usage.invalid-content' | 'usage.incomplete-fragments' | 'usage.incompatible-context' | 'usage.source-conflict' | 'usage.invalid-state';
+    path: string;
+    message: string;
+}
+export type WorkspaceUsageResult = {
+    ok: true;
+    bundle: WorkspaceUsageBundle;
+    diagnostics: [];
+} | {
+    ok: false;
+    diagnostics: WorkspaceUsageDiagnostic[];
+};
+export interface WorkspaceUsageContentPort {
+    sha256(canonicalJson: string): Promise<string>;
+}
+export declare function serializeWorkspaceUsageContent(value: unknown): string;
+export declare function createWorkspaceUsageBundle(input: {
+    source: WorkspacePresetArtifact;
+    context: WorkspaceUsageContext;
+    fragments: WorkspaceUsageFragments;
+    parentSnapshotId: string | null;
+}, content: WorkspaceUsageContentPort): Promise<WorkspaceUsageResult>;
+export declare function admitWorkspaceUsageBundle(value: unknown, context: WorkspaceUsageContext, content: WorkspaceUsageContentPort): Promise<WorkspaceUsageResult>;
+export declare function compareWorkspaceUsageSource(previous: WorkspaceUsageSnapshot, next: WorkspaceUsageSnapshot): WorkspaceUsageDiagnostic[];

package/dist/application/workspace/usageSnapshots.js

@@ -0,0 +1,103 @@
+import { validateWorkspacePresetArtifact, evaluateWorkspacePresetCompatibility } from "./presetArtifacts.js";
+export function serializeWorkspaceUsageContent(value) {
+    const ancestors = new Set();
+    function encode(entry) {
+        if (entry === null || typeof entry === 'boolean' || typeof entry === 'string')
+            return JSON.stringify(entry);
+        if (typeof entry === 'number' && Number.isFinite(entry))
+            return JSON.stringify(entry);
+        if (typeof entry !== 'object' || ancestors.has(entry))
+            throw new TypeError('Usage content must be finite acyclic JSON.');
+        if (!Array.isArray(entry) && Object.getPrototypeOf(entry) !== Object.prototype && Object.getPrototypeOf(entry) !== null) {
+            throw new TypeError('Usage objects must be plain JSON records.');
+        }
+        ancestors.add(entry);
+        const text = Array.isArray(entry)
+            ? `[${Array.from({ length: entry.length }, (_, index) => {
+                const descriptor = Object.getOwnPropertyDescriptor(entry, String(index));
+                if (!descriptor || !('value' in descriptor))
+                    throw new TypeError('Usage arrays must contain data indices, not accessors or holes.');
+                return encode(descriptor.value);
+            }).join(',')}]`
+            : `{${Object.keys(entry).sort().map(key => {
+                const descriptor = Object.getOwnPropertyDescriptor(entry, key);
+                if (!('value' in descriptor))
+                    throw new TypeError('Usage content must not contain accessors.');
+                return `${JSON.stringify(key)}:${encode(descriptor.value)}`;
+            }).join(',')}}`;
+        ancestors.delete(entry);
+        return text;
+    }
+    return encode(value);
+}
+export async function createWorkspaceUsageBundle(input, content) {
+    try {
+        const frozen = JSON.parse(serializeWorkspaceUsageContent(input));
+        const references = {};
+        for (const name of Object.keys(frozen.fragments).sort()) {
+            Object.defineProperty(references, name, { value: await content.sha256(serializeWorkspaceUsageContent(frozen.fragments[name])), enumerable: true });
+        }
+        const snapshot = {
+            schema: 'konitif.workspace-usage', schemaVersion: 1,
+            source: { presetId: frozen.source.id, revision: frozen.source.version, contentId: await content.sha256(serializeWorkspaceUsageContent(frozen.source)) },
+            context: frozen.context, fragments: references, parentSnapshotId: frozen.parentSnapshotId
+        };
+        return admitWorkspaceUsageBundle({ snapshotId: await content.sha256(serializeWorkspaceUsageContent(snapshot)), snapshot, source: frozen.source, fragments: frozen.fragments }, frozen.context, content);
+    }
+    catch (error) {
+        return refused('usage.invalid-content', '$', String(error));
+    }
+}
+export async function admitWorkspaceUsageBundle(value, context, content) {
+    try {
+        const bundle = JSON.parse(serializeWorkspaceUsageContent(value));
+        const snapshot = bundle?.snapshot;
+        if (!snapshot || snapshot.schema !== 'konitif.workspace-usage' || snapshot.schemaVersion !== 1 ||
+            !isContentId(bundle.snapshotId) || !snapshot.source || !isContentId(snapshot.source.contentId) ||
+            !isRecord(snapshot.context) || !isRecord(snapshot.fragments) || !isRecord(bundle.fragments) ||
+            !(snapshot.parentSnapshotId === null || isContentId(snapshot.parentSnapshotId)))
+            return refused('usage.invalid-shape', '$', 'Invalid usage snapshot or content reference.');
+        if (Object.keys(snapshot.context).sort().join(',') !== 'fixtureSchemaVersion,hostContract,projectSchemaVersion' ||
+            Object.values(snapshot.context).some(entry => typeof entry !== 'string' || !entry) ||
+            serializeWorkspaceUsageContent(snapshot.context) !== serializeWorkspaceUsageContent(context))
+            return refused('usage.incompatible-context', '$.snapshot.context', 'Usage context does not match this host.');
+        if (Object.keys(snapshot.fragments).sort().join('\n') !== Object.keys(bundle.fragments).sort().join('\n') ||
+            ['workspace', 'shell', 'focus'].some(name => !Object.prototype.hasOwnProperty.call(bundle.fragments, name)) ||
+            Object.keys(snapshot.fragments).some(name => !/^[a-zA-Z][a-zA-Z0-9.-]*$/.test(name) || !isContentId(snapshot.fragments[name])))
+            return refused('usage.incomplete-fragments', '$.fragments', 'All declared fragments, including workspace, shell and focus, are required.');
+        if (await content.sha256(serializeWorkspaceUsageContent(snapshot)) !== bundle.snapshotId)
+            return refused('usage.invalid-content', '$.snapshotId', 'Snapshot content identity mismatch.');
+        if (await content.sha256(serializeWorkspaceUsageContent(bundle.source)) !== snapshot.source.contentId)
+            return refused('usage.invalid-content', '$.source', 'Source content identity mismatch.');
+        if (bundle.source.id !== snapshot.source.presetId || bundle.source.version !== snapshot.source.revision)
+            return refused('usage.source-conflict', '$.snapshot.source', 'Source authored identity and revision must match their immutable reference.');
+        const sourceIssues = validateWorkspacePresetArtifact(bundle.source);
+        if (sourceIssues.length || evaluateWorkspacePresetCompatibility(bundle.source, context).length)
+            return refused('usage.invalid-state', '$.source', 'Invalid or incompatible authored preset.');
+        for (const name of Object.keys(snapshot.fragments)) {
+            if (await content.sha256(serializeWorkspaceUsageContent(bundle.fragments[name])) !== snapshot.fragments[name])
+                return refused('usage.invalid-content', `$.fragments.${name}`, 'Fragment content identity mismatch.');
+        }
+        const stateIssues = validateWorkspacePresetArtifact({ ...bundle.source, workspaceSession: { workspace: bundle.fragments.workspace, focus: bundle.fragments.focus }, shellState: bundle.fragments.shell });
+        if (stateIssues.length)
+            return refused('usage.invalid-state', '$.fragments', stateIssues.map(issue => `${issue.path}: ${issue.message}`).join('; '));
+        return { ok: true, bundle, diagnostics: [] };
+    }
+    catch (error) {
+        return refused('usage.invalid-content', '$', String(error));
+    }
+}
+export function compareWorkspaceUsageSource(previous, next) {
+    return previous.source.presetId === next.source.presetId && previous.source.revision === next.source.revision && previous.source.contentId !== next.source.contentId
+        ? [{ code: 'usage.source-conflict', path: '$.source', message: 'An authored identity/revision must not be rebound to different content.' }]
+        : [];
+}
+function isContentId(value) {
+    return typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function refused(code, path, message) {
+    return { ok: false, diagnostics: [{ code, path, message }] };
+}

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

@@ -0,0 +1,32 @@
+import type { ShellWidgetCatalogPort } from "../../domain/shell/model.js";
+import type { ToolCatalogPort, ToolDefinition } from "../../domain/tool/model.js";
+import type { WorkspacePresetArtifact } from "./presetArtifacts.js";
+export type WorkspacePresetCatalogAdmissionIssue = {
+    code: 'workspace-preset-admission.missing-tool';
+    subjectId: string;
+    message: string;
+} | {
+    code: 'workspace-preset-admission.missing-widget';
+    subjectId: string;
+    message: string;
+} | {
+    code: 'workspace-preset-admission.missing-capability' | 'workspace-preset-admission.incompatible-capability';
+    subjectId: string;
+    consumerToolId: string;
+    versionRange: string;
+    availableVersions: string[];
+    message: string;
+};
+export type WorkspacePresetCatalogAdmission = {
+    ok: true;
+    issues: [];
+} | {
+    ok: false;
+    issues: WorkspacePresetCatalogAdmissionIssue[];
+};
+export declare function evaluateWorkspacePresetCatalogAdmission(input: {
+    source: WorkspacePresetArtifact;
+    toolCatalog: ToolCatalogPort;
+    shellWidgetCatalog: ShellWidgetCatalogPort;
+    availableToolDefinitions?: readonly ToolDefinition[];
+}): WorkspacePresetCatalogAdmission;

package/dist/application/workspace/workspacePresetCatalogAdmission.js

@@ -0,0 +1,58 @@
+import { isKonitifCapabilityVersionCompatible } from '@konitif/core';
+export function evaluateWorkspacePresetCatalogAdmission(input) {
+    const issues = [];
+    const requiredToolIds = unique(Object.values(input.source.workspaceSession.workspace.toolInstances).map(instance => instance.toolId));
+    const requiredWidgetIds = unique(Object.values(input.source.shellState.regions).flatMap(region => region.widgetIds));
+    const requiredDefinitions = requiredToolIds.flatMap(toolId => {
+        const definition = input.toolCatalog.getDefinition(toolId);
+        if (!definition) {
+            issues.push({
+                code: 'workspace-preset-admission.missing-tool',
+                subjectId: toolId,
+                message: `Required tool "${toolId}" is not available in the admitted catalog.`
+            });
+            return [];
+        }
+        return [definition];
+    });
+    for (const widgetId of requiredWidgetIds) {
+        if (!input.shellWidgetCatalog.getDefinition(widgetId)) {
+            issues.push({
+                code: 'workspace-preset-admission.missing-widget',
+                subjectId: widgetId,
+                message: `Required widget "${widgetId}" is not available in the admitted catalog.`
+            });
+        }
+    }
+    const availableDefinitions = input.availableToolDefinitions ?? requiredDefinitions;
+    for (const consumer of requiredDefinitions) {
+        for (const requirement of consumer.capabilities?.consumes ?? []) {
+            if (requirement.mode !== 'required')
+                continue;
+            const providers = availableDefinitions.flatMap(definition => (definition.capabilities?.provides ?? [])
+                .filter(capability => capability.id === requirement.id)
+                .map(capability => ({ definition, capability })));
+            if (providers.some(provider => isKonitifCapabilityVersionCompatible(provider.capability.version, requirement.versionRange))) {
+                continue;
+            }
+            const availableVersions = unique(providers.map(provider => provider.capability.version));
+            const incompatible = availableVersions.length > 0;
+            issues.push({
+                code: incompatible
+                    ? 'workspace-preset-admission.incompatible-capability'
+                    : 'workspace-preset-admission.missing-capability',
+                subjectId: requirement.id,
+                consumerToolId: consumer.id,
+                versionRange: requirement.versionRange,
+                availableVersions,
+                message: incompatible
+                    ? `Tool "${consumer.id}" requires ${requirement.id}@${requirement.versionRange}; available versions are ${availableVersions.join(', ')}.`
+                    : `Tool "${consumer.id}" requires ${requirement.id}@${requirement.versionRange}; no provider is available.`
+            });
+        }
+    }
+    return issues.length === 0 ? { ok: true, issues: [] } : { ok: false, issues };
+}
+function unique(values) {
+    return [...new Set(values)];
+}

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

@@ -0,0 +1,41 @@
+export interface WorkbenchCatalogMedia {
+    src: string;
+    alt: string;
+    mediaType: 'image/svg+xml' | 'image/png' | 'image/webp' | 'image/jpeg';
+}
+export interface WorkbenchCatalogDependency {
+    packageName: string;
+    versionRange: string;
+    scope: 'runtime' | 'peer' | 'optional' | 'development';
+    family: 'konitif' | 'product' | 'external';
+    sourceUrl?: string;
+}
+export interface WorkbenchCatalogDiagramNode {
+    id: string;
+    label: string;
+    description: string;
+    tone?: 'projection' | 'runtime' | 'observation';
+}
+export interface WorkbenchCatalogDiagramEdge {
+    from: string;
+    to: string;
+}
+export interface WorkbenchCatalogDiagram {
+    id: string;
+    title: string;
+    kind: string;
+    summary: string;
+    sourcePackage: string;
+    nodes: readonly WorkbenchCatalogDiagramNode[];
+    edges: readonly WorkbenchCatalogDiagramEdge[];
+    caption: string;
+}
+export interface WorkbenchCatalogPresentation {
+    summary?: string;
+    icon?: WorkbenchCatalogMedia;
+    illustration?: WorkbenchCatalogMedia;
+    metadata?: Readonly<Record<string, string>>;
+    detailedDescription?: string;
+    dependencies?: readonly WorkbenchCatalogDependency[];
+    diagram?: WorkbenchCatalogDiagram;
+}

package/dist/domain/catalog/presentation.js

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

package/dist/domain/catalog/version.d.ts

@@ -0,0 +1,7 @@
+export interface WorkbenchCatalogElementVersion {
+    value: string;
+    authority: {
+        kind: 'package-manifest';
+        packageName: string;
+    };
+}

package/dist/domain/catalog/version.js

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

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

@@ -1,4 +1,6 @@
 import type { WorkbenchIconInput } from "../icon/model.js";
+import type { WorkbenchCatalogElementVersion } from "../catalog/version.js";
+import type { WorkbenchCatalogPresentation } from "../catalog/presentation.js";
 export type ShellRegionId = 'left' | 'right' | 'bottom';
 export type ShellRegionPresentation = 'tabs' | 'stack';
 export type ShellRegionAxis = 'horizontal' | 'vertical';
@@ -13,6 +15,8 @@ export interface ShellRegionState {
     hiddenWidgetIds?: string[];
     presentation?: ShellRegionPresentation;
     axis?: ShellRegionAxis;
+    /** Relative track sizes, keyed by widget identity. */
+    widgetProportions?: Record<string, number>;
 }
 export interface ShellState {
     regions: Record<ShellRegionId, ShellRegionState>;
@@ -23,6 +27,8 @@ export interface ShellWidgetPlacement {
 }
 export interface ShellWidgetDefinition {
     id: string;
+    version?: WorkbenchCatalogElementVersion;
+    catalogPresentation?: WorkbenchCatalogPresentation;
     capabilityId?: string | null;
     title: string;
     icon?: WorkbenchIconInput;

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

@@ -1,6 +1,8 @@
 import type { JsonObject } from "../shared/json.js";
 import type { KonitifToolCapabilities } from '@konitif/core';
+import type { WorkbenchCatalogPresentation } from "../catalog/presentation.js";
 import type { WorkbenchIconInput } from "../icon/model.js";
+import type { WorkbenchCatalogElementVersion } from "../catalog/version.js";
 import type { ShellRegionId } from "../shell/model.js";
 import type { WorkbenchReadingLevel, WorkbenchReadingLevelPresentation } from "../presentation/readingLevel.js";
 export type ToolOpeningPolicy = {
@@ -117,6 +119,8 @@ export interface ToolFullscreenCompanionChromePolicy {
 export interface ToolFullscreenCompanionBehaviorPolicy {
     pinned?: boolean;
     draggable?: boolean;
+    /** Allow the host's anchored, presentation-only resize handles. */
+    resizable?: boolean;
     collapsible?: boolean;
     passthroughWhenCollapsed?: boolean;
 }
@@ -137,6 +141,8 @@ export interface ToolFullscreenCompanionDefinition {
 }
 export interface ToolDefinition {
     id: string;
+    version?: WorkbenchCatalogElementVersion;
+    catalogPresentation?: WorkbenchCatalogPresentation;
     title: string;
     icon?: WorkbenchIconInput;
     /**

package/dist/hosting.d.ts

@@ -8,6 +8,7 @@ export { exportWorkspaceSnapshot, importWorkspaceSnapshot } from "./application/
 export { listPanelsInWorkspace } from "./domain/workspace/selectors.js";
 export { validateWorkspace } from "./domain/workspace/validation.js";
 export { InMemoryToolRegistry } from "./infrastructure/tools/InMemoryToolRegistry.js";
+export type { RegisteredToolComponentLoader } from "./infrastructure/tools/InMemoryToolRegistry.js";
 export type { Workspace } from "./domain/workspace/model.js";
 export type { WorkspacePersistencePort } from "./domain/workspace/persistence.js";
 export type { ToolDefinition, ToolInstance, ToolCatalogPort } from "./domain/tool/model.js";

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 export * from "./boot/index.js";
+export * from "./application/launch/workbenchLaunchPolicy.js";
+export * from "./application/launch/catalogShareReference.js";
 export * from "./application/widgets/createWorkbenchWidgetAdapter.js";
+export * from "./application/tool/experienceToolSelection.js";
 export * from "./stage/index.js";
 export * from "./application/shell/state.js";
 export * from "./application/layout/surfaceCommandRouter.js";
@@ -18,6 +21,7 @@ export * from "./application/workspace/layoutInteraction.js";
 export * from "./application/workspace/openTool.js";
 export * from "./application/workspace/presets.js";
 export * from "./application/workspace/presetArtifacts.js";
+export * from "./application/workspace/presetSelection.js";
 export * from "./application/workspace/resizeSplit.js";
 export * from "./application/workspace/resizeSplitBoundary.js";
 export * from "./application/workspace/runToolShellCommand.js";
@@ -36,6 +40,11 @@ export * from "./application/workspace/swapPanelArea.js";
 export * from "./application/workspace/toolRuntime.js";
 export * from "./application/workspace/toolCapabilities.js";
 export * from "./application/workspace/updateToolState.js";
+export * from "./application/workspace/unassignTool.js";
+export * from "./application/workspace/parkedTool.js";
+export * from "./application/workspace/workspacePresetCatalogAdmission.js";
+export * from "./domain/catalog/version.js";
+export * from "./domain/catalog/presentation.js";
 export * from "./application/project/ProjectManifest.js";
 export * from "./application/runtime/WorkbenchRuntimeCore.js";
 export * from "./application/runtime/RuntimeObservabilityHub.js";
@@ -109,3 +118,4 @@ export * from "./infrastructure/workbenches/InMemoryWorkbenchRegistry.js";
 export * from "./infrastructure/widgets/InMemoryShellWidgetRegistry.js";
 export * from "./infrastructure/widgets/InMemoryWorkbenchWidgetRegistry.js";
 export * from "./temporal/index.js";
+export * from "./application/workspace/usageSnapshots.js";

package/dist/index.js

@@ -1,5 +1,8 @@
 export * from "./boot/index.js";
+export * from "./application/launch/workbenchLaunchPolicy.js";
+export * from "./application/launch/catalogShareReference.js";
 export * from "./application/widgets/createWorkbenchWidgetAdapter.js";
+export * from "./application/tool/experienceToolSelection.js";
 export * from "./stage/index.js";
 export * from "./application/shell/state.js";
 export * from "./application/layout/surfaceCommandRouter.js";
@@ -18,6 +21,7 @@ export * from "./application/workspace/layoutInteraction.js";
 export * from "./application/workspace/openTool.js";
 export * from "./application/workspace/presets.js";
 export * from "./application/workspace/presetArtifacts.js";
+export * from "./application/workspace/presetSelection.js";
 export * from "./application/workspace/resizeSplit.js";
 export * from "./application/workspace/resizeSplitBoundary.js";
 export * from "./application/workspace/runToolShellCommand.js";
@@ -36,6 +40,11 @@ export * from "./application/workspace/swapPanelArea.js";
 export * from "./application/workspace/toolRuntime.js";
 export * from "./application/workspace/toolCapabilities.js";
 export * from "./application/workspace/updateToolState.js";
+export * from "./application/workspace/unassignTool.js";
+export * from "./application/workspace/parkedTool.js";
+export * from "./application/workspace/workspacePresetCatalogAdmission.js";
+export * from "./domain/catalog/version.js";
+export * from "./domain/catalog/presentation.js";
 export * from "./application/project/ProjectManifest.js";
 export * from "./application/runtime/WorkbenchRuntimeCore.js";
 export * from "./application/runtime/RuntimeObservabilityHub.js";
@@ -109,3 +118,4 @@ export * from "./infrastructure/workbenches/InMemoryWorkbenchRegistry.js";
 export * from "./infrastructure/widgets/InMemoryShellWidgetRegistry.js";
 export * from "./infrastructure/widgets/InMemoryWorkbenchWidgetRegistry.js";
 export * from "./temporal/index.js";
+export * from "./application/workspace/usageSnapshots.js";

package/dist/infrastructure/tools/InMemoryToolRegistry.d.ts

@@ -41,6 +41,7 @@ export declare class InMemoryToolRegistry implements ToolCatalogPort {
     register(entry: RegisteredTool): void;
     get(toolId: string): RegisteredTool | undefined;
     getDefinition(toolId: string): ToolDefinition | undefined;
+    unregister(toolId: string): boolean;
     list(): RegisteredTool[];
     listDiagnostics(): ToolRegistryDuplicateDiagnostic[];
 }

package/dist/infrastructure/tools/InMemoryToolRegistry.js

@@ -51,6 +51,17 @@ export class InMemoryToolRegistry {
     getDefinition(toolId) {
         return this.entries.get(toolId)?.definition;
     }
+    unregister(toolId) {
+        if (!this.entries.delete(toolId))
+            return false;
+        this.registrationOrders.delete(toolId);
+        this.revision += 1;
+        for (const listener of [...this.revisionListeners]) {
+            if (this.revisionListeners.has(listener))
+                listener(this.revision);
+        }
+        return true;
+    }
     list() {
         return [...this.entries.values()];
     }

package/dist/workspace-contracts.d.ts

@@ -1,4 +1,4 @@
-export { setShellRegionArrangement, createShellState, setShellRegionVisible, setShellRegionOpen, setShellRegionSize, activateShellWidget, setShellRegionWidgetVisible, addShellWidgetToRegion, moveShellWidgetToRegion, removeShellWidgetFromRegion } from "./application/shell/state.js";
+export { setShellRegionArrangement, setShellRegionWidgetProportions, createShellState, setShellRegionVisible, setShellRegionOpen, setShellRegionSize, activateShellWidget, setShellRegionWidgetVisible, addShellWidgetToRegion, moveShellWidgetToRegion, removeShellWidgetFromRegion } from "./application/shell/state.js";
 export { collapseSplit } from "./application/workspace/collapseSplit.js";
 export { collapseSplitBoundary } from "./application/workspace/collapseSplitBoundary.js";
 export { dispatchWorkspaceCommand, type WorkspaceCommand } from "./application/workspace/commands.js";
@@ -34,3 +34,20 @@ export { type Workspace } from "./domain/workspace/model.js";
 export { type WorkspacePersistencePort } from "./domain/workspace/persistence.js";
 export { findPanelInWorkspace, getPreferredFocusedPanelId } from "./domain/workspace/selectors.js";
 export { validateWorkspace } from "./domain/workspace/validation.js";
+export * from "./application/workspace/presetArtifacts.js";
+export * from "./application/workspace/presetSelection.js";
+export * from "./application/workspace/usageSnapshots.js";
+export * from "./application/launch/workbenchLaunchPolicy.js";
+export * from "./application/tool/experienceToolSelection.js";
+export * from "./application/workspace/unassignTool.js";
+export * from "./application/workspace/parkedTool.js";
+export * from "./application/workspace/workspacePresetCatalogAdmission.js";
+export type { WorkbenchCatalogElementVersion } from "./domain/catalog/version.js";
+export type { WorkbenchCatalogMedia, WorkbenchCatalogPresentation } from "./domain/catalog/presentation.js";
+export { createPanel, createStack, createSplit, createWorkspaceWindow, createWorkspaceShell } from "./domain/workspace/factories.js";
+export { cloneJsonObject } from "./domain/shared/json.js";
+export { createInitialToolShellState } from "./domain/tool/shell.js";
+export { patchWorkbenchToolDockVisibilityState } from "./domain/widget/toolDock.js";
+export type { ToolDefinition, ToolInstance, ToolCatalogPort } from "./domain/tool/model.js";
+export type { ShellWidgetCatalogPort } from "./domain/shell/model.js";
+export { InMemoryToolRegistry } from "./infrastructure/tools/InMemoryToolRegistry.js";

package/dist/workspace-contracts.js

@@ -1,6 +1,6 @@
 // Explicit workspace contracts for state orchestration. No host adapters.
 // Reexports preserve the authority and identity of the existing implementations.
-export { setShellRegionArrangement, createShellState, setShellRegionVisible, setShellRegionOpen, setShellRegionSize, activateShellWidget, setShellRegionWidgetVisible, addShellWidgetToRegion, moveShellWidgetToRegion, removeShellWidgetFromRegion } from "./application/shell/state.js";
+export { setShellRegionArrangement, setShellRegionWidgetProportions, createShellState, setShellRegionVisible, setShellRegionOpen, setShellRegionSize, activateShellWidget, setShellRegionWidgetVisible, addShellWidgetToRegion, moveShellWidgetToRegion, removeShellWidgetFromRegion } from "./application/shell/state.js";
 export { collapseSplit } from "./application/workspace/collapseSplit.js";
 export { collapseSplitBoundary } from "./application/workspace/collapseSplitBoundary.js";
 export { dispatchWorkspaceCommand } from "./application/workspace/commands.js";
@@ -26,3 +26,17 @@ export { updateToolState } from "./application/workspace/updateToolState.js";
 export { normalizeToolShellStatus, normalizeToolPanelLoadingState, normalizeToolResourceLoadingState } from "./domain/tool/runtime.js";
 export { findPanelInWorkspace, getPreferredFocusedPanelId } from "./domain/workspace/selectors.js";
 export { validateWorkspace } from "./domain/workspace/validation.js";
+export * from "./application/workspace/presetArtifacts.js";
+export * from "./application/workspace/presetSelection.js";
+export * from "./application/workspace/usageSnapshots.js";
+export * from "./application/launch/workbenchLaunchPolicy.js";
+export * from "./application/tool/experienceToolSelection.js";
+export * from "./application/workspace/unassignTool.js";
+export * from "./application/workspace/parkedTool.js";
+export * from "./application/workspace/workspacePresetCatalogAdmission.js";
+// Authored seed construction uses the same factories as the complete Workbench.
+export { createPanel, createStack, createSplit, createWorkspaceWindow, createWorkspaceShell } from "./domain/workspace/factories.js";
+export { cloneJsonObject } from "./domain/shared/json.js";
+export { createInitialToolShellState } from "./domain/tool/shell.js";
+export { patchWorkbenchToolDockVisibilityState } from "./domain/widget/toolDock.js";
+export { InMemoryToolRegistry } from "./infrastructure/tools/InMemoryToolRegistry.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@konitif/workbench",
   "license": "PolyForm-Noncommercial-1.0.0",
-  "version": "0.285.0",
+  "version": "0.285.2",
   "description": "Workspace composition, docking, registries and hosting contracts for KONITIF.",
   "repository": {
     "type": "git",