@konitif/workbench 0.284.1

package/dist/application/experiment/ControlledExperimentRecorder.js

@@ -0,0 +1,215 @@
+import { cloneJsonObject } from "../../domain/shared/json.js";
+export class ControlledExperimentRecorder {
+    definition;
+    conditionIds;
+    metricIds;
+    metricIdSet;
+    phaseIds;
+    activeRun = null;
+    constructor(definition) {
+        this.definition = definition;
+        assertDefinition(definition);
+        this.conditionIds = new Set(definition.conditions.map((condition) => condition.id));
+        this.metricIds = definition.metrics.map((metric) => metric.id);
+        this.metricIdSet = new Set(this.metricIds);
+        this.phaseIds = new Set(definition.phases.map((phase) => phase.id));
+    }
+    start(input) {
+        if (this.activeRun) {
+            throw new Error(`Experiment ${this.definition.id} is already recording ${this.activeRun.input.runId}.`);
+        }
+        if (!this.conditionIds.has(input.conditionId)) {
+            throw new Error(`Unknown experiment condition: ${input.conditionId}`);
+        }
+        if (!input.runId.trim() || !Number.isFinite(input.startedAtMs)) {
+            throw new Error('A controlled experiment run requires a stable id and finite start timestamp.');
+        }
+        this.activeRun = {
+            input: {
+                ...input,
+                runId: input.runId.trim(),
+                environment: cloneJsonObject(input.environment)
+            },
+            phaseId: null,
+            sequence: 0,
+            observations: [],
+            phaseMarkers: [],
+            droppedObservationCount: 0
+        };
+    }
+    markPhase(phaseId, observedAtMs, provenance = {}) {
+        const run = this.activeRun;
+        if (!run || !this.phaseIds.has(phaseId) || !Number.isFinite(observedAtMs)) {
+            return false;
+        }
+        run.phaseId = phaseId;
+        run.phaseMarkers.push({
+            sequence: run.sequence++,
+            phaseId,
+            observedAtMs,
+            provenance: cloneJsonObject(provenance)
+        });
+        return true;
+    }
+    record(input) {
+        const run = this.activeRun;
+        if (!run || !Number.isFinite(input.observedAtMs)) {
+            return false;
+        }
+        if (run.observations.length >= this.definition.maxObservations) {
+            run.droppedObservationCount += 1;
+            return false;
+        }
+        run.observations.push({
+            sequence: run.sequence++,
+            observedAtMs: input.observedAtMs,
+            phaseId: run.phaseId,
+            metrics: Object.fromEntries(Object.entries(input.metrics)
+                .filter(([metricId]) => this.metricIdSet.has(metricId))
+                .map(([metricId, value]) => [metricId, normalizeMetricValue(value)])),
+            provenance: cloneJsonObject(input.provenance ?? {})
+        });
+        return true;
+    }
+    stop(input) {
+        const run = this.activeRun;
+        if (!run) {
+            throw new Error(`Experiment ${this.definition.id} is not recording.`);
+        }
+        if (!Number.isFinite(input.endedAtMs)) {
+            throw new Error('A controlled experiment run requires a finite end timestamp.');
+        }
+        const condition = this.definition.conditions.find((candidate) => candidate.id === run.input.conditionId);
+        if (!condition) {
+            throw new Error(`Unknown experiment condition: ${run.input.conditionId}`);
+        }
+        const observations = run.observations.map(cloneObservation);
+        const retentionInvalid = run.droppedObservationCount > 0;
+        const status = input.status === 'cancelled'
+            ? 'cancelled'
+            : retentionInvalid
+                ? 'invalid'
+                : input.status ?? 'completed';
+        const artifact = {
+            schemaVersion: 1,
+            experiment: {
+                id: this.definition.id,
+                version: this.definition.version,
+                title: this.definition.title,
+                hypothesis: this.definition.hypothesis,
+                independentVariable: this.definition.independentVariable,
+                conditions: this.definition.conditions.map(cloneCondition),
+                condition: {
+                    ...condition,
+                    parameters: cloneJsonObject(condition.parameters)
+                },
+                metrics: this.definition.metrics.map((metric) => ({ ...metric })),
+                phases: this.definition.phases.map((phase) => ({ ...phase })),
+                controlledVariables: [...this.definition.controlledVariables]
+            },
+            run: {
+                id: run.input.runId,
+                status,
+                reason: input.reason?.trim() || (retentionInvalid ? 'observation_limit_reached' : null),
+                startedAtMs: run.input.startedAtMs,
+                endedAtMs: input.endedAtMs,
+                durationMs: Math.max(0, input.endedAtMs - run.input.startedAtMs),
+                environment: cloneJsonObject(run.input.environment)
+            },
+            observations,
+            phaseMarkers: run.phaseMarkers.map((marker) => ({
+                ...marker,
+                provenance: cloneJsonObject(marker.provenance)
+            })),
+            metricSummaries: summarizeMetrics(this.metricIds, observations),
+            retention: {
+                maxObservations: this.definition.maxObservations,
+                recordedObservations: observations.length,
+                droppedObservations: run.droppedObservationCount,
+                truncated: run.droppedObservationCount > 0
+            }
+        };
+        this.activeRun = null;
+        return artifact;
+    }
+    isRecording() {
+        return this.activeRun !== null;
+    }
+    snapshot() {
+        const run = this.activeRun;
+        return {
+            recording: run !== null,
+            runId: run?.input.runId ?? null,
+            conditionId: run?.input.conditionId ?? null,
+            phaseId: run?.phaseId ?? null,
+            observationCount: run?.observations.length ?? 0,
+            droppedObservationCount: run?.droppedObservationCount ?? 0
+        };
+    }
+}
+function cloneCondition(condition) {
+    return {
+        ...condition,
+        parameters: cloneJsonObject(condition.parameters)
+    };
+}
+function assertDefinition(definition) {
+    if (!definition.id.trim() || !Number.isInteger(definition.version) || definition.version < 1) {
+        throw new Error('A controlled experiment definition requires a stable id and positive integer version.');
+    }
+    assertUniqueIds('condition', definition.conditions.map((condition) => condition.id));
+    assertUniqueIds('metric', definition.metrics.map((metric) => metric.id));
+    assertUniqueIds('phase', definition.phases.map((phase) => phase.id));
+    if (definition.conditions.length < 2) {
+        throw new Error('A controlled comparison requires at least two conditions.');
+    }
+    if (!Number.isInteger(definition.maxObservations) || definition.maxObservations < 1) {
+        throw new Error('A controlled experiment requires a positive observation retention bound.');
+    }
+}
+function assertUniqueIds(kind, ids) {
+    if (ids.some((id) => !id.trim()) || new Set(ids).size !== ids.length) {
+        throw new Error(`Controlled experiment ${kind} ids must be non-empty and unique.`);
+    }
+}
+function normalizeMetricValue(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function cloneObservation(observation) {
+    return {
+        ...observation,
+        metrics: { ...observation.metrics },
+        provenance: cloneJsonObject(observation.provenance)
+    };
+}
+function summarizeMetrics(metricIds, observations) {
+    return Object.fromEntries(metricIds.map((metricId) => {
+        const values = observations
+            .map((observation) => observation.metrics[metricId])
+            .filter((value) => typeof value === 'number' && Number.isFinite(value));
+        return [metricId, summarizeMetric(values)];
+    }));
+}
+function summarizeMetric(values) {
+    if (values.length === 0) {
+        return { count: 0, minimum: null, maximum: null, mean: null, p01: null, p50: null, p95: null, p99: null };
+    }
+    const sorted = [...values].sort((left, right) => left - right);
+    return {
+        count: sorted.length,
+        minimum: sorted[0] ?? null,
+        maximum: sorted[sorted.length - 1] ?? null,
+        mean: sorted.reduce((total, value) => total + value, 0) / sorted.length,
+        p01: percentile(sorted, 0.01),
+        p50: percentile(sorted, 0.5),
+        p95: percentile(sorted, 0.95),
+        p99: percentile(sorted, 0.99)
+    };
+}
+function percentile(sorted, quantile) {
+    if (sorted.length === 0) {
+        return null;
+    }
+    const index = Math.ceil(Math.min(1, Math.max(0, quantile)) * sorted.length) - 1;
+    return sorted[Math.max(0, index)] ?? null;
+}

package/dist/application/i18n/WorkbenchTranslationRegistry.d.ts

@@ -0,0 +1,19 @@
+import type { TranslationBundle, TranslationLookupOptions, TranslationMatch, TranslationRegistryOptions, WorkbenchLocale } from "../../domain/i18n/model.js";
+export declare class WorkbenchTranslationRegistry {
+    readonly fallbackLocale: WorkbenchLocale;
+    private bundles;
+    private bundleIndexes;
+    private messageIndexes;
+    private resolutionCache;
+    private nextOrder;
+    constructor(options?: TranslationRegistryOptions);
+    registerBundle(bundle: TranslationBundle): boolean;
+    registerBundles(bundles: TranslationBundle[]): boolean;
+    private upsertBundle;
+    listBundles(): TranslationBundle[];
+    resolve(key: string, options?: TranslationLookupOptions): TranslationMatch | null;
+    translate(key: string, options?: TranslationLookupOptions): string;
+    private resolveForLocale;
+    private rebuildMessageIndex;
+}
+export declare function createWorkbenchTranslationRegistry(options?: TranslationRegistryOptions): WorkbenchTranslationRegistry;

package/dist/application/i18n/WorkbenchTranslationRegistry.js

@@ -0,0 +1,179 @@
+function normalizeLocale(locale) {
+    return (locale?.trim() || 'en').toLowerCase();
+}
+function buildLocaleFallbacks(locale, fallbackLocale) {
+    const normalizedLocale = normalizeLocale(locale);
+    const normalizedFallback = normalizeLocale(fallbackLocale);
+    const baseLocale = normalizedLocale.split('-')[0] ?? normalizedLocale;
+    const fallbacks = [normalizedLocale];
+    if (baseLocale && baseLocale !== normalizedLocale) {
+        fallbacks.push(baseLocale);
+    }
+    if (!fallbacks.includes(normalizedFallback)) {
+        fallbacks.push(normalizedFallback);
+    }
+    return fallbacks;
+}
+function interpolateMessage(message, values) {
+    if (!values) {
+        return message;
+    }
+    return message.replace(/\{\{\s*([A-Za-z0-9_.-]+)\s*\}\}/g, (placeholder, name) => {
+        const value = values[name];
+        return value === null || value === undefined ? placeholder : String(value);
+    });
+}
+export class WorkbenchTranslationRegistry {
+    fallbackLocale;
+    bundles = [];
+    bundleIndexes = new Map();
+    messageIndexes = new Map();
+    resolutionCache = new Map();
+    nextOrder = 0;
+    constructor(options = {}) {
+        this.fallbackLocale = normalizeLocale(options.fallbackLocale);
+    }
+    registerBundle(bundle) {
+        const changedLocale = this.upsertBundle(bundle);
+        if (!changedLocale) {
+            return false;
+        }
+        this.rebuildMessageIndex(changedLocale);
+        this.resolutionCache.clear();
+        return true;
+    }
+    registerBundles(bundles) {
+        const changedLocales = new Set();
+        for (const bundle of bundles) {
+            const changedLocale = this.upsertBundle(bundle);
+            if (changedLocale) {
+                changedLocales.add(changedLocale);
+            }
+        }
+        if (changedLocales.size === 0) {
+            return false;
+        }
+        for (const locale of changedLocales) {
+            this.rebuildMessageIndex(locale);
+        }
+        this.resolutionCache.clear();
+        return true;
+    }
+    upsertBundle(bundle) {
+        const normalizedBundle = {
+            ...bundle,
+            locale: normalizeLocale(bundle.locale),
+            namespace: bundle.namespace.trim(),
+            priority: bundle.priority ?? 0,
+            order: this.nextOrder++
+        };
+        const identity = translationBundleIdentity(normalizedBundle);
+        const existingIndex = this.bundleIndexes.get(identity);
+        if (existingIndex !== undefined) {
+            const existing = this.bundles[existingIndex];
+            if (sameTranslationBundle(existing, normalizedBundle)) {
+                return null;
+            }
+            this.bundles[existingIndex] = normalizedBundle;
+        }
+        else {
+            this.bundleIndexes.set(identity, this.bundles.length);
+            this.bundles.push(normalizedBundle);
+        }
+        return normalizedBundle.locale;
+    }
+    listBundles() {
+        return this.bundles.map(({ order: _order, ...bundle }) => bundle);
+    }
+    resolve(key, options = {}) {
+        const trimmedKey = key.trim();
+        if (!trimmedKey) {
+            return null;
+        }
+        for (const locale of buildLocaleFallbacks(options.locale, this.fallbackLocale)) {
+            const match = this.resolveForLocale(trimmedKey, locale);
+            if (match) {
+                return match;
+            }
+        }
+        return null;
+    }
+    translate(key, options = {}) {
+        const match = this.resolve(key, options);
+        const message = match?.value ?? options.default ?? key;
+        return interpolateMessage(message, options.values);
+    }
+    resolveForLocale(key, locale) {
+        const cacheKey = `${locale}\u0000${key}`;
+        if (this.resolutionCache.has(cacheKey)) {
+            return this.resolutionCache.get(cacheKey) ?? null;
+        }
+        const match = this.messageIndexes.get(locale)?.get(key) ?? null;
+        this.resolutionCache.set(cacheKey, match);
+        return match;
+    }
+    rebuildMessageIndex(locale) {
+        const candidates = new Map();
+        for (const bundle of this.bundles) {
+            if (bundle.locale !== locale) {
+                continue;
+            }
+            for (const messageKey of Object.keys(bundle.messages)) {
+                const key = bundle.namespace
+                    ? messageKey
+                        ? `${bundle.namespace}.${messageKey}`
+                        : bundle.namespace
+                    : messageKey;
+                const current = candidates.get(key);
+                if (!current || isHigherPriorityBundle(bundle, current.bundle)) {
+                    candidates.set(key, { bundle, messageKey });
+                }
+            }
+        }
+        const index = new Map();
+        for (const [key, candidate] of candidates) {
+            index.set(key, {
+                key,
+                locale,
+                namespace: candidate.bundle.namespace,
+                messageKey: candidate.messageKey,
+                value: candidate.bundle.messages[candidate.messageKey] ?? key,
+                source: candidate.bundle.source
+            });
+        }
+        this.messageIndexes.set(locale, index);
+    }
+}
+function isHigherPriorityBundle(candidate, current) {
+    return (candidate.priority > current.priority ||
+        (candidate.priority === current.priority &&
+            candidate.namespace.length > current.namespace.length) ||
+        (candidate.priority === current.priority &&
+            candidate.namespace.length === current.namespace.length &&
+            candidate.order > current.order));
+}
+function translationBundleIdentity(bundle) {
+    return [
+        bundle.locale,
+        bundle.namespace,
+        String(bundle.priority),
+        bundle.layer ?? '',
+        bundle.source ?? ''
+    ].join('\u0000');
+}
+function sameTranslationBundle(left, right) {
+    if (left.locale !== right.locale ||
+        left.namespace !== right.namespace ||
+        left.priority !== right.priority ||
+        left.layer !== right.layer ||
+        left.source !== right.source) {
+        return false;
+    }
+    const leftEntries = Object.entries(left.messages);
+    const rightEntries = Object.entries(right.messages);
+    return (leftEntries.length === rightEntries.length &&
+        leftEntries.every(([key, value]) => right.messages[key] === value));
+}
+export function createWorkbenchTranslationRegistry(options) {
+    return new WorkbenchTranslationRegistry(options);
+}

package/dist/application/layout/surfaceCommandRouter.d.ts

@@ -0,0 +1,18 @@
+import type { LayoutSurfaceProjection, LayoutUserActionIntent } from "../../domain/layout/surfaceProjection.js";
+import type { ShellState } from "../../domain/shell/model.js";
+import { type WorkspaceSessionState } from "../workspace/session.js";
+export interface LayoutSurfaceCommandState {
+    shellState?: ShellState;
+    workspaceSession?: WorkspaceSessionState;
+}
+export interface DispatchLayoutSurfaceIntentInput {
+    state: LayoutSurfaceCommandState;
+    intent: LayoutUserActionIntent;
+    projection?: LayoutSurfaceProjection;
+}
+export interface DispatchLayoutSurfaceIntentResult {
+    state: LayoutSurfaceCommandState;
+    handled: boolean;
+    reason?: string;
+}
+export declare function dispatchLayoutSurfaceIntent(input: DispatchLayoutSurfaceIntentInput): DispatchLayoutSurfaceIntentResult;

package/dist/application/layout/surfaceCommandRouter.js

@@ -0,0 +1,247 @@
+import { findPanelInWorkspace, findStackInWorkspace } from "../../domain/workspace/selectors.js";
+import { activateShellWidget, setShellRegionOpen, setShellRegionSize, setShellRegionVisible } from "../shell/state.js";
+import { closePanel } from "../workspace/closePanel.js";
+import { collapseSplitBoundary } from "../workspace/collapseSplitBoundary.js";
+import { createWorkspaceSessionState } from "../workspace/session.js";
+import { dockPanel } from "../workspace/dockPanel.js";
+import { resizeSplitBoundary } from "../workspace/resizeSplitBoundary.js";
+import { focusPanel } from "../workspace/focusPanel.js";
+import { selectWorkspaceTargetWindow } from "../workspace/targetWindow.js";
+import { splitPanel } from "../workspace/splitPanel.js";
+export function dispatchLayoutSurfaceIntent(input) {
+    if (input.intent.surfaceId.startsWith('shell:')) {
+        return dispatchShellLayoutSurfaceIntent(input);
+    }
+    if (input.intent.surfaceId.startsWith('workspace:')) {
+        return dispatchWorkspaceLayoutSurfaceIntent(input);
+    }
+    return {
+        state: input.state,
+        handled: false,
+        reason: `Unsupported layout surface "${input.intent.surfaceId}"`
+    };
+}
+function dispatchShellLayoutSurfaceIntent(input) {
+    const shellState = input.state.shellState;
+    if (!shellState) {
+        return createUnhandledResult(input.state, 'Missing shell state');
+    }
+    const regionId = resolveShellRegionId(input.intent, input.projection);
+    if (!regionId || !shellState.regions[regionId]) {
+        return createUnhandledResult(input.state, 'Unknown shell region');
+    }
+    const region = shellState.regions[regionId];
+    let nextShellState = shellState;
+    switch (input.intent.kind) {
+        case 'activate': {
+            const widgetId = readString(input.intent.metadata, 'widgetId') ?? region.activeWidgetId;
+            nextShellState = widgetId ? activateShellWidget(shellState, regionId, widgetId) : shellState;
+            break;
+        }
+        case 'resize': {
+            const nextSize = resolveNextShellRegionSize(region.size, input.intent.metadata);
+            nextShellState = nextSize === null ? shellState : setShellRegionSize(shellState, regionId, nextSize);
+            break;
+        }
+        case 'toggle-open':
+            nextShellState = setShellRegionOpen(shellState, regionId, !region.isOpen);
+            break;
+        case 'toggle-visibility':
+            nextShellState = setShellRegionVisible(shellState, regionId, !region.isVisible);
+            break;
+        default:
+            return createUnhandledResult(input.state, `Unsupported shell intent "${input.intent.kind}"`);
+    }
+    return {
+        state: {
+            ...input.state,
+            shellState: nextShellState
+        },
+        handled: true
+    };
+}
+function dispatchWorkspaceLayoutSurfaceIntent(input) {
+    let workspaceSession = input.state.workspaceSession;
+    if (!workspaceSession) {
+        return createUnhandledResult(input.state, 'Missing workspace session');
+    }
+    const sourceId = resolveWorkspaceSourceId(input.intent, input.projection);
+    if (!sourceId) {
+        return createUnhandledResult(input.state, 'Unknown workspace target');
+    }
+    const workspace = selectWorkspaceTargetWindow(workspaceSession.workspace, sourceId);
+    workspaceSession = createWorkspaceSessionState(workspace, workspaceSession.focus);
+    let nextSession = workspaceSession;
+    switch (input.intent.kind) {
+        case 'activate':
+            nextSession = activateWorkspaceTarget(workspaceSession, sourceId);
+            break;
+        case 'close':
+            nextSession = updateWorkspaceSession(workspaceSession, closePanel(workspace, { panelId: sourceId }), sourceId);
+            break;
+        case 'collapse':
+            nextSession = updateWorkspaceSession(workspaceSession, collapseSplitBoundary(workspace, {
+                rootSplitId: sourceId,
+                boundaryIndex: readNumber(input.intent.metadata, 'boundaryIndex') ?? 0,
+                removeSide: readRemoveSide(input.intent.metadata) ?? 'end'
+            }));
+            break;
+        case 'dock':
+        case 'move':
+            nextSession = dockWorkspacePanel(workspaceSession, sourceId, input.intent);
+            break;
+        case 'resize': {
+            const deltaRatio = readNumber(input.intent.metadata, 'deltaRatio');
+            if (deltaRatio === null) {
+                return createUnhandledResult(input.state, 'Missing workspace resize deltaRatio');
+            }
+            nextSession = updateWorkspaceSession(workspaceSession, resizeSplitBoundary(workspace, {
+                rootSplitId: sourceId,
+                boundaryIndex: readNumber(input.intent.metadata, 'boundaryIndex') ?? 0,
+                deltaRatio,
+                mode: readResizeMode(input.intent.metadata) ?? 'local'
+            }));
+            break;
+        }
+        case 'split':
+            nextSession = splitWorkspaceTarget(workspaceSession, sourceId, input.intent);
+            break;
+        default:
+            return createUnhandledResult(input.state, `Unsupported workspace intent "${input.intent.kind}"`);
+    }
+    return {
+        state: {
+            ...input.state,
+            workspaceSession: nextSession
+        },
+        handled: true
+    };
+}
+function activateWorkspaceTarget(state, sourceId) {
+    const panel = findPanelInWorkspace(state.workspace, sourceId);
+    if (!panel) {
+        const stack = findStackInWorkspace(state.workspace, sourceId);
+        return stack ? focusPanel(state, stack.activeChildId) : state;
+    }
+    return focusPanel(state, panel.id);
+}
+function splitWorkspaceTarget(state, sourceId, intent) {
+    const targetPanelId = resolveWorkspacePanelId(state.workspace, sourceId);
+    if (!targetPanelId) {
+        return state;
+    }
+    const orientation = intent.orientation ?? readSplitOrientation(intent.metadata) ?? 'horizontal';
+    const nextWorkspace = splitPanel(state.workspace, {
+        panelId: targetPanelId,
+        orientation,
+        side: intent.side
+    });
+    return updateWorkspaceSession(state, nextWorkspace, targetPanelId);
+}
+function dockWorkspacePanel(state, sourceId, intent) {
+    const panelId = readString(intent.metadata, 'panelId') ?? state.focus.activePanelId;
+    const targetStack = findStackInWorkspace(state.workspace, sourceId);
+    const placement = intent.side ?? readDockSide(intent.metadata) ?? 'center';
+    if (!panelId || !targetStack) {
+        return state;
+    }
+    const nextWorkspace = dockPanel(state.workspace, {
+        panelId,
+        target: {
+            kind: 'stack',
+            stackId: targetStack.id,
+            placement
+        }
+    });
+    return updateWorkspaceSession(state, nextWorkspace, panelId);
+}
+function updateWorkspaceSession(state, workspace, preferredPanelId = state.focus.activePanelId) {
+    return createWorkspaceSessionState(workspace, { activePanelId: preferredPanelId ?? undefined });
+}
+function resolveWorkspacePanelId(workspace, sourceId) {
+    const panel = findPanelInWorkspace(workspace, sourceId);
+    if (panel) {
+        return panel.id;
+    }
+    const stack = findStackInWorkspace(workspace, sourceId);
+    return stack?.activeChildId ?? null;
+}
+function resolveShellRegionId(intent, projection) {
+    const projectedRegionId = resolveProjectedMetadataString(intent.targetId, projection, 'regionId');
+    if (isShellRegionId(projectedRegionId)) {
+        return projectedRegionId;
+    }
+    const marker = intent.targetId.includes(':boundary:') ? ':boundary:' : ':region:';
+    const value = readSuffixAfterMarker(intent.targetId, marker);
+    return isShellRegionId(value) ? value : null;
+}
+function resolveWorkspaceSourceId(intent, projection) {
+    const projectedArea = projection?.areas[intent.targetId];
+    if (projectedArea) {
+        return projectedArea.sourceId;
+    }
+    const projectedBoundary = projection?.boundaries[intent.targetId];
+    if (projectedBoundary) {
+        return projectedBoundary.sourceId;
+    }
+    return readSuffixAfterMarker(intent.targetId, ':area:') ?? readSuffixAfterMarker(intent.targetId, ':boundary:');
+}
+function resolveProjectedMetadataString(targetId, projection, key) {
+    const areaValue = readString(projection?.areas[targetId]?.metadata, key);
+    if (areaValue !== null) {
+        return areaValue;
+    }
+    return readString(projection?.boundaries[targetId]?.metadata, key);
+}
+function resolveNextShellRegionSize(currentSize, metadata) {
+    const size = readNumber(metadata, 'size');
+    if (size !== null) {
+        return size;
+    }
+    const delta = readNumber(metadata, 'delta');
+    return delta === null ? null : currentSize + delta;
+}
+function readString(metadata, key) {
+    const value = readMetadataValue(metadata, key);
+    return typeof value === 'string' ? value : null;
+}
+function readNumber(metadata, key) {
+    const value = readMetadataValue(metadata, key);
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function readSplitOrientation(metadata) {
+    const value = readString(metadata, 'orientation');
+    return value === 'horizontal' || value === 'vertical' ? value : null;
+}
+function readDockSide(metadata) {
+    const value = readString(metadata, 'side');
+    return isDockSide(value) ? value : null;
+}
+function readRemoveSide(metadata) {
+    const value = readString(metadata, 'removeSide');
+    return value === 'start' || value === 'end' ? value : null;
+}
+function readResizeMode(metadata) {
+    const value = readString(metadata, 'mode');
+    return value === 'local' || value === 'proportional' ? value : null;
+}
+function readMetadataValue(metadata, key) {
+    return metadata ? metadata[key] : undefined;
+}
+function readSuffixAfterMarker(value, marker) {
+    const markerIndex = value.indexOf(marker);
+    return markerIndex === -1 ? null : value.slice(markerIndex + marker.length) || null;
+}
+function isShellRegionId(value) {
+    return value === 'left' || value === 'right' || value === 'bottom';
+}
+function isDockSide(value) {
+    return value === 'top' || value === 'right' || value === 'bottom' || value === 'left';
+}
+function createUnhandledResult(state, reason) {
+    return {
+        state,
+        handled: false,
+        reason
+    };
+}

package/dist/application/physics/NoopPhysicsBackend.d.ts

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

package/dist/application/physics/NoopPhysicsBackend.js

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

package/dist/application/physics/PhysicsService.d.ts

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