@nvidia-elements/core 2.22.5 → 2.23.0

package/dist/workspace/utils/geometry/allocation.utils.d.ts

@@ -0,0 +1,40 @@
+import type { Rect } from '@nvidia-elements/core/internal';
+import type { WorkspaceGroup, WorkspaceNode, WorkspaceSplit } from '../model/layout.utils.js';
+export interface WorkspacePlacedGroup {
+    key: string;
+    group: WorkspaceGroup;
+    rect: Rect;
+}
+export interface WorkspacePlacedRegion {
+    key: string;
+    node: WorkspaceNode;
+    rect: Rect;
+}
+export interface WorkspaceBoundary {
+    key: string;
+    branch: WorkspaceSplit;
+    index: number;
+    rect: Rect;
+    sizes: number[];
+    minima: number[];
+    value: number;
+    min: number;
+    max: number;
+}
+interface PlacementInput {
+    root: WorkspaceNode | null;
+    rect: Rect;
+    minimum: (node: WorkspaceNode) => {
+        width: number;
+        height: number;
+    };
+    policy: 'stop' | 'propagate';
+    gap: number;
+}
+/** Allocates geometry without configuring or moving application panels. */
+export declare function allocateWorkspace(input: PlacementInput): {
+    groups: WorkspacePlacedGroup[];
+    boundaries: WorkspaceBoundary[];
+    regions: WorkspacePlacedRegion[];
+};
+export {};

package/dist/workspace/utils/geometry/allocation.utils.js

@@ -0,0 +1,73 @@
+import { fitSizes as e } from "./partition.utils.js";
+// src/workspace/utils/geometry/allocation.utils.ts
+function t(t) {
+	let r = [], i = [], a = [], o = (s, c, l) => {
+		if (i.push({
+			key: l,
+			node: s,
+			rect: c
+		}), s.type === "group") {
+			r.push({
+				key: l,
+				group: s,
+				rect: c
+			});
+			return;
+		}
+		let u = s.axis === "horizontal", d = s.children.map((e) => t.minimum(e)[u ? "width" : "height"]), f = e(s.weights, d, (u ? c.width : c.height) - t.gap * (s.children.length - 1)), p = 0;
+		s.children.forEach((e, r) => {
+			let i = f[r];
+			o(e, u ? {
+				...c,
+				x: c.x + p,
+				width: i
+			} : {
+				...c,
+				y: c.y + p,
+				height: i
+			}, `${l}.${r}`), p += i, r < s.children.length - 1 && (a.push(n({
+				node: s,
+				rect: c,
+				path: l,
+				index: r,
+				offset: p,
+				sizes: f,
+				minima: d,
+				policy: t.policy,
+				gap: t.gap
+			})), p += t.gap);
+		});
+	};
+	return t.root && o(t.root, t.rect, "root"), {
+		groups: r,
+		boundaries: a,
+		regions: i
+	};
+}
+function n(e) {
+	let { node: t, rect: n, path: r, index: i, offset: a, sizes: o, minima: s, policy: c } = e, l = t.axis === "horizontal", u = c === "stop" ? [i + 1] : o.map((e, t) => t).slice(i + 1), d = c === "stop" ? [i] : o.map((e, t) => t).slice(0, i + 1), f = o.slice(0, i + 1).reduce((e, t) => e + t, 0), p = o.reduce((e, t) => e + t, 0), m = d.reduce((e, t) => e + o[t] - s[t], 0), h = u.reduce((e, t) => e + o[t] - s[t], 0);
+	return {
+		key: `${r}:${i}`,
+		branch: t,
+		index: i,
+		rect: l ? {
+			x: n.x + a,
+			y: n.y,
+			width: e.gap,
+			height: n.height
+		} : {
+			x: n.x,
+			y: n.y + a,
+			width: n.width,
+			height: e.gap
+		},
+		sizes: o,
+		minima: s,
+		value: l ? f : p - f,
+		min: l ? f - m : p - f - h,
+		max: l ? f + h : p - f + m
+	};
+}
+export { t as allocateWorkspace };
+
+//# sourceMappingURL=allocation.utils.js.map

package/dist/workspace/utils/geometry/allocation.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"allocation.utils.js","names":["allocateWorkspace","groups","regions","boundaries","place","path","node","horizontal","minima","input","child","sizes","fitSizes","rect","offset","size","index","boundary","after","policy","i","before","prefix","a","b","total","negative","sum","positive"],"sources":["../../../../src/workspace/utils/geometry/allocation.utils.ts"],"sourcesContent":["// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Rect } from '@nvidia-elements/core/internal';\n\nimport { fitSizes } from './partition.utils.js';\n\nimport type { WorkspaceGroup, WorkspaceNode, WorkspaceSplit } from '../model/layout.utils.js';\n\nexport interface WorkspacePlacedGroup {\n  key: string;\n  group: WorkspaceGroup;\n  rect: Rect;\n}\n\nexport interface WorkspacePlacedRegion {\n  key: string;\n  node: WorkspaceNode;\n  rect: Rect;\n}\n\nexport interface WorkspaceBoundary {\n  key: string;\n  branch: WorkspaceSplit;\n  index: number;\n  rect: Rect;\n  sizes: number[];\n  minima: number[];\n  value: number;\n  min: number;\n  max: number;\n}\n\ninterface PlacementInput {\n  root: WorkspaceNode | null;\n  rect: Rect;\n  minimum: (node: WorkspaceNode) => { width: number; height: number };\n  policy: 'stop' | 'propagate';\n  gap: number;\n}\n\n/** Allocates geometry without configuring or moving application panels. */\nexport function allocateWorkspace(input: PlacementInput) {\n  const groups: WorkspacePlacedGroup[] = [];\n  const regions: WorkspacePlacedRegion[] = [];\n  const boundaries: WorkspaceBoundary[] = [];\n  const place = (node: WorkspaceNode, rect: Rect, path: string) => {\n    regions.push({ key: path, node, rect });\n    if (node.type === 'group') {\n      groups.push({ key: path, group: node, rect });\n      return;\n    }\n    const horizontal = node.axis === 'horizontal';\n    const minima = node.children.map(child => input.minimum(child)[horizontal ? 'width' : 'height']);\n    const sizes = fitSizes(\n      node.weights,\n      minima,\n      (horizontal ? rect.width : rect.height) - input.gap * (node.children.length - 1)\n    );\n    let offset = 0;\n    node.children.forEach((child, index) => {\n      const size = sizes[index]!;\n      place(\n        child,\n        horizontal ? { ...rect, x: rect.x + offset, width: size } : { ...rect, y: rect.y + offset, height: size },\n        `${path}.${index}`\n      );\n      offset += size;\n      if (index < node.children.length - 1) {\n        boundaries.push(\n          boundary({ node, rect, path, index, offset, sizes, minima, policy: input.policy, gap: input.gap })\n        );\n        offset += input.gap;\n      }\n    });\n  };\n  if (input.root) {\n    place(input.root, input.rect, 'root');\n  }\n  return { groups, boundaries, regions };\n}\n\nfunction boundary(input: {\n  node: WorkspaceSplit;\n  rect: Rect;\n  path: string;\n  index: number;\n  offset: number;\n  sizes: number[];\n  minima: number[];\n  policy: PlacementInput['policy'];\n  gap: number;\n}): WorkspaceBoundary {\n  const { node, rect, path, index, offset, sizes, minima, policy } = input;\n  const horizontal = node.axis === 'horizontal';\n  const after = policy === 'stop' ? [index + 1] : sizes.map((_, i) => i).slice(index + 1);\n  const before = policy === 'stop' ? [index] : sizes.map((_, i) => i).slice(0, index + 1);\n  const prefix = sizes.slice(0, index + 1).reduce((a, b) => a + b, 0);\n  const total = sizes.reduce((a, b) => a + b, 0);\n  const negative = before.reduce((sum, i) => sum + sizes[i]! - minima[i]!, 0);\n  const positive = after.reduce((sum, i) => sum + sizes[i]! - minima[i]!, 0);\n  return {\n    key: `${path}:${index}`,\n    branch: node,\n    index,\n    rect: horizontal\n      ? { x: rect.x + offset, y: rect.y, width: input.gap, height: rect.height }\n      : { x: rect.x, y: rect.y + offset, width: rect.width, height: input.gap },\n    sizes,\n    minima,\n    value: horizontal ? prefix : total - prefix,\n    min: horizontal ? prefix - negative : total - prefix - positive,\n    max: horizontal ? prefix + positive : total - prefix + negative\n  };\n}\n"],"mappings":";;AA0CA,SAAgBA,EAAkB,GAAuB;CACvD,IAAMC,IAAiC,CAAC,GAClCC,IAAmC,CAAC,GACpCC,IAAkC,CAAC,GACnCC,KAAS,GAAqB,GAAY,MAAiB;EAE/D,IADAF,EAAQ,KAAK;GAAE,KAAKG;GAAM;GAAM;EAAK,CAAC,GAClCC,EAAK,SAAS,SAAS;GACzB,EAAO,KAAK;IAAE,KAAKD;IAAM,OAAOC;IAAM;GAAK,CAAC;GAC5C;EACF;EACA,IAAMC,IAAaD,EAAK,SAAS,cAC3BE,IAASF,EAAK,SAAS,KAAI,MAASG,EAAM,QAAQC,CAAK,CAAC,CAACH,IAAa,UAAU,SAAS,GACzFI,IAAQC,EACZN,EAAK,SACLE,IACCD,IAAaM,EAAK,QAAQA,EAAK,UAAUJ,EAAM,OAAOH,EAAK,SAAS,SAAS,EAChF,GACIQ,IAAS;EACb,EAAK,SAAS,SAAS,GAAO,MAAU;GACtC,IAAMC,IAAOJ,EAAMK;GAOnB,AANAZ,EACEM,GACAH,IAAa;IAAE,GAAGM;IAAM,GAAGA,EAAK,IAAIC;IAAQ,OAAOC;GAAK,IAAI;IAAE,GAAGF;IAAM,GAAGA,EAAK,IAAIC;IAAQ,QAAQC;GAAK,GACxG,GAAGV,EAAK,GAAGW,GACb,GACA,KAAUD,GACNC,IAAQV,EAAK,SAAS,SAAS,MACjCH,EAAW,KACTc,EAAS;IAAE;IAAM;IAAM;IAAM;IAAO;IAAQ;IAAO;IAAQ,QAAQR,EAAM;IAAQ,KAAKA,EAAM;GAAI,CAAC,CACnG,GACA,KAAUA,EAAM;EAEpB,CAAC;CACH;CAIA,OAHIA,EAAM,QACRL,EAAMK,EAAM,MAAMA,EAAM,MAAM,MAAM,GAE/B;EAAE;EAAQ;EAAY;CAAQ;AACvC;AAEA,SAASQ,EAAS,GAUI;CACpB,IAAM,EAAE,SAAM,SAAM,SAAM,UAAO,WAAQ,UAAO,WAAQ,cAAWR,GAC7DF,IAAaD,EAAK,SAAS,cAC3BY,IAAQC,MAAW,SAAS,CAACH,IAAQ,CAAC,IAAIL,EAAM,KAAK,GAAG,MAAMS,CAAC,CAAC,CAAC,MAAMJ,IAAQ,CAAC,GAChFK,IAASF,MAAW,SAAS,CAACH,CAAK,IAAIL,EAAM,KAAK,GAAG,MAAMS,CAAC,CAAC,CAAC,MAAM,GAAGJ,IAAQ,CAAC,GAChFM,IAASX,EAAM,MAAM,GAAGK,IAAQ,CAAC,CAAC,CAAC,QAAQ,GAAG,MAAMO,IAAIC,GAAG,CAAC,GAC5DC,IAAQd,EAAM,QAAQ,GAAG,MAAMY,IAAIC,GAAG,CAAC,GACvCE,IAAWL,EAAO,QAAQ,GAAK,MAAMM,IAAMhB,EAAMS,KAAMZ,EAAOY,IAAK,CAAC,GACpEQ,IAAWV,EAAM,QAAQ,GAAK,MAAMS,IAAMhB,EAAMS,KAAMZ,EAAOY,IAAK,CAAC;CACzE,OAAO;EACL,KAAK,GAAGf,EAAK,GAAGW;EAChB,QAAQV;EACR;EACA,MAAMC,IACF;GAAE,GAAGM,EAAK,IAAIC;GAAQ,GAAGD,EAAK;GAAG,OAAOJ,EAAM;GAAK,QAAQI,EAAK;EAAO,IACvE;GAAE,GAAGA,EAAK;GAAG,GAAGA,EAAK,IAAIC;GAAQ,OAAOD,EAAK;GAAO,QAAQJ,EAAM;EAAI;EAC1E;EACA;EACA,OAAOF,IAAae,IAASG,IAAQH;EACrC,KAAKf,IAAae,IAASI,IAAWD,IAAQH,IAASM;EACvD,KAAKrB,IAAae,IAASM,IAAWH,IAAQH,IAASI;CACzD;AACF"}

package/dist/workspace/utils/geometry/partition.utils.d.ts

@@ -0,0 +1,10 @@
+interface ResizeOptions {
+    boundary: number;
+    delta: number;
+    policy: 'stop' | 'propagate';
+}
+/** Fits preferred proportions without rewriting them when constraints intervene. */
+export declare function fitSizes(weights: readonly number[], minima: readonly number[], available: number): number[];
+/** Exchanges adjacent space, optionally consuming farther neighbors at limits. */
+export declare function resizeSizes(sizes: readonly number[], minima: readonly number[], options: ResizeOptions): number[];
+export {};

package/dist/workspace/utils/geometry/partition.utils.js

@@ -0,0 +1,40 @@
+// src/workspace/utils/geometry/partition.utils.ts
+function e(e, t) {
+	if (e.length !== t.length || !e.every((e) => Number.isFinite(e) && e > 0) || !t.every((e) => Number.isFinite(e) && e >= 0)) throw TypeError("Invalid split sizes");
+	if (!Number.isFinite(e.reduce((e, t) => e + t, 0)) || !Number.isFinite(t.reduce((e, t) => e + t, 0))) throw TypeError("Split size total exceeds the supported range");
+}
+function t(e, { boundary: t, delta: n, policy: r }) {
+	if (r === "stop") return [n > 0 ? t + 1 : t];
+	let i = e.map((e, t) => t);
+	return n > 0 ? i.slice(t + 1) : i.slice(0, t + 1).reverse();
+}
+function n(t, n, r) {
+	if (e(t, n), !Number.isFinite(r)) throw TypeError("Invalid available extent");
+	let i = Math.max(r, n.reduce((e, t) => e + t, 0)), a = t.map(() => 0), o = new Set(t.map((e, t) => t)), s = i;
+	for (; o.size;) {
+		let e = [...o].reduce((e, n) => e + t[n], 0), r = [...o].filter((r) => s * t[r] / e < n[r]);
+		if (!r.length) {
+			o.forEach((n) => {
+				a[n] = s * t[n] / e;
+			});
+			break;
+		}
+		r.forEach((e) => {
+			a[e] = n[e], s -= n[e], o.delete(e);
+		});
+	}
+	return a;
+}
+function r(n, r, i) {
+	e(n, r);
+	let { boundary: a, delta: o } = i;
+	if (!Number.isInteger(a) || a < 0 || a >= n.length - 1 || !Number.isFinite(o)) throw TypeError("Invalid split boundary");
+	let s = [...n], c = o > 0 ? a : a + 1, l = t(n, i), u = Math.abs(o);
+	return l.forEach((e) => {
+		let t = Math.min(u, Math.max(0, s[e] - r[e]));
+		s[e] -= t, s[c] += t, u -= t;
+	}), s;
+}
+export { n as fitSizes, r as resizeSizes };
+
+//# sourceMappingURL=partition.utils.js.map

package/dist/workspace/utils/geometry/partition.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"partition.utils.js","names":["assertValidSizes","values","minima","value","sum","resizeDonors","policy","delta","boundary","indices","sizes","i","fitSizes","weights","available","extent","a","b","result","pending","remaining","total","constrained","resizeSizes","options","receiving","donors","amount"],"sources":["../../../../src/workspace/utils/geometry/partition.utils.ts"],"sourcesContent":["// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n// SPDX-License-Identifier: Apache-2.0\n\ninterface ResizeOptions {\n  boundary: number;\n  delta: number;\n  policy: 'stop' | 'propagate';\n}\n\nfunction assertValidSizes(values: readonly number[], minima: readonly number[]) {\n  if (\n    values.length !== minima.length ||\n    !values.every(value => Number.isFinite(value) && value > 0) ||\n    !minima.every(value => Number.isFinite(value) && value >= 0)\n  ) {\n    throw new TypeError('Invalid split sizes');\n  }\n  if (\n    !Number.isFinite(values.reduce((sum, value) => sum + value, 0)) ||\n    !Number.isFinite(minima.reduce((sum, value) => sum + value, 0))\n  ) {\n    throw new TypeError('Split size total exceeds the supported range');\n  }\n}\n\nfunction resizeDonors(sizes: readonly number[], { boundary, delta, policy }: ResizeOptions) {\n  if (policy === 'stop') return [delta > 0 ? boundary + 1 : boundary];\n  const indices = sizes.map((_, i) => i);\n  if (delta > 0) return indices.slice(boundary + 1);\n  return indices.slice(0, boundary + 1).reverse();\n}\n\n/** Fits preferred proportions without rewriting them when constraints intervene. */\nexport function fitSizes(weights: readonly number[], minima: readonly number[], available: number): number[] {\n  assertValidSizes(weights, minima);\n  if (!Number.isFinite(available)) throw new TypeError('Invalid available extent');\n  const extent = Math.max(\n    available,\n    minima.reduce((a, b) => a + b, 0)\n  );\n  const result = weights.map(() => 0);\n  const pending = new Set(weights.map((_, i) => i));\n  let remaining = extent;\n  while (pending.size) {\n    const total = [...pending].reduce((sum, i) => sum + weights[i]!, 0);\n    const constrained = [...pending].filter(i => (remaining * weights[i]!) / total < minima[i]!);\n    if (!constrained.length) {\n      pending.forEach(i => {\n        result[i] = (remaining * weights[i]!) / total;\n      });\n      break;\n    }\n    constrained.forEach(i => {\n      result[i] = minima[i]!;\n      remaining -= minima[i]!;\n      pending.delete(i);\n    });\n  }\n  return result;\n}\n\n/** Exchanges adjacent space, optionally consuming farther neighbors at limits. */\nexport function resizeSizes(sizes: readonly number[], minima: readonly number[], options: ResizeOptions): number[] {\n  assertValidSizes(sizes, minima);\n  const { boundary, delta } = options;\n  if (!Number.isInteger(boundary) || boundary < 0 || boundary >= sizes.length - 1 || !Number.isFinite(delta))\n    throw new TypeError('Invalid split boundary');\n  const result = [...sizes];\n  const receiving = delta > 0 ? boundary : boundary + 1;\n  const donors = resizeDonors(sizes, options);\n  let remaining = Math.abs(delta);\n  donors.forEach(i => {\n    const amount = Math.min(remaining, Math.max(0, result[i]! - minima[i]!));\n    result[i]! -= amount;\n    result[receiving]! += amount;\n    remaining -= amount;\n  });\n  return result;\n}\n"],"mappings":";AASA,SAASA,EAAiB,GAA2B,GAA2B;CAC9E,IACEC,EAAO,WAAWC,EAAO,UACzB,CAACD,EAAO,OAAM,MAAS,OAAO,SAASE,CAAK,KAAKA,IAAQ,CAAC,KAC1D,CAACD,EAAO,OAAM,MAAS,OAAO,SAASC,CAAK,KAAKA,KAAS,CAAC,GAE3D,MAAU,UAAU,qBAAqB;CAE3C,IACE,CAAC,OAAO,SAASF,EAAO,QAAQ,GAAK,MAAUG,IAAMD,GAAO,CAAC,CAAC,KAC9D,CAAC,OAAO,SAASD,EAAO,QAAQ,GAAK,MAAUE,IAAMD,GAAO,CAAC,CAAC,GAE9D,MAAU,UAAU,8CAA8C;AAEtE;AAEA,SAASE,EAAa,GAA0B,EAAE,aAAU,UAAO,aAAyB;CAC1F,IAAIC,MAAW,QAAQ,OAAO,CAACC,IAAQ,IAAIC,IAAW,IAAIA,CAAQ;CAClE,IAAMC,IAAUC,EAAM,KAAK,GAAG,MAAMC,CAAC;CAErC,OADIJ,IAAQ,IAAUE,EAAQ,MAAMD,IAAW,CAAC,IACzCC,EAAQ,MAAM,GAAGD,IAAW,CAAC,CAAC,CAAC,QAAQ;AAChD;AAGA,SAAgBI,EAAS,GAA4B,GAA2B,GAA6B;CAE3G,IADAZ,EAAiBa,GAASX,CAAM,GAC5B,CAAC,OAAO,SAASY,CAAS,GAAG,MAAU,UAAU,0BAA0B;CAC/E,IAAMC,IAAS,KAAK,IAClBD,GACAZ,EAAO,QAAQ,GAAG,MAAMc,IAAIC,GAAG,CAAC,CAClC,GACMC,IAASL,EAAQ,UAAU,CAAC,GAC5BM,IAAU,IAAI,IAAIN,EAAQ,KAAK,GAAG,MAAMF,CAAC,CAAC,GAC5CS,IAAYL;CAChB,OAAOI,EAAQ,OAAM;EACnB,IAAME,IAAQ,CAAC,GAAGF,CAAO,CAAC,CAAC,QAAQ,GAAK,MAAMf,IAAMS,EAAQF,IAAK,CAAC,GAC5DW,IAAc,CAAC,GAAGH,CAAO,CAAC,CAAC,QAAO,MAAMC,IAAYP,EAAQF,KAAOU,IAAQnB,EAAOS,EAAG;EAC3F,IAAI,CAACW,EAAY,QAAQ;GACvB,EAAQ,SAAQ,MAAK;IACnB,EAAOX,KAAMS,IAAYP,EAAQF,KAAOU;GAC1C,CAAC;GACD;EACF;EACA,EAAY,SAAQ,MAAK;GAGvB,AAFA,EAAOV,KAAKT,EAAOS,IACnB,KAAaT,EAAOS,IACpBQ,EAAQ,OAAOR,CAAC;EAClB,CAAC;CACH;CACA,OAAOO;AACT;AAGA,SAAgBK,EAAY,GAA0B,GAA2B,GAAkC;CACjH,EAAiBb,GAAOR,CAAM;CAC9B,IAAM,EAAE,aAAU,aAAUsB;CAC5B,IAAI,CAAC,OAAO,UAAUhB,CAAQ,KAAKA,IAAW,KAAKA,KAAYE,EAAM,SAAS,KAAK,CAAC,OAAO,SAASH,CAAK,GACvG,MAAU,UAAU,wBAAwB;CAC9C,IAAMW,IAAS,CAAC,GAAGR,CAAK,GAClBe,IAAYlB,IAAQ,IAAIC,IAAWA,IAAW,GAC9CkB,IAASrB,EAAaK,GAAOc,CAAO,GACtCJ,IAAY,KAAK,IAAIb,CAAK;CAO9B,OANAmB,EAAO,SAAQ,MAAK;EAClB,IAAMC,IAAS,KAAK,IAAIP,GAAW,KAAK,IAAI,GAAGF,EAAOP,KAAMT,EAAOS,EAAG,CAAC;EAGvE,AAFA,EAAOA,MAAOgB,GACd,EAAOF,MAAeE,GACtB,KAAaA;CACf,CAAC,GACMT;AACT"}

package/dist/workspace/utils/geometry/sizing.utils.d.ts

@@ -0,0 +1,35 @@
+import type { Dimensions } from '@nvidia-elements/core/internal';
+import type { WorkspaceNode } from '../model/layout.utils.js';
+export interface WorkspaceRequirements {
+    gap: number;
+    panels: ReadonlyMap<string, Dimensions>;
+    chrome: Dimensions;
+}
+/** Combines explicit panel requirements with one operable header, independent of tab count. */
+export declare function getMinimumWorkspaceDimensions(node: WorkspaceNode | null, requirements: WorkspaceRequirements): Dimensions;
+/** Admits a change when it does not increase minimum overflow on either axis. */
+export declare function admitsWorkspaceMove(input: {
+    current: WorkspaceNode | null;
+    candidate: WorkspaceNode | null;
+    viewport: Dimensions;
+    requirements: WorkspaceRequirements;
+}): boolean;
+/** Reads supplied panel constraints without changing the conservative operable-header floor. */
+export declare function getWorkspaceRequirements(input: {
+    measurements: {
+        gap: number;
+        gripWidth: number;
+        tabWidth: number;
+        groupActionWidth?: number;
+        headerHeight: number;
+        panels?: Record<string, {
+            suffixWidth: number;
+            footerHeight: number;
+        }>;
+    };
+    panels: {
+        id: string;
+        minWidth: number;
+        minHeight: number;
+    }[];
+}): WorkspaceRequirements;

package/dist/workspace/utils/geometry/sizing.utils.js

@@ -0,0 +1,42 @@
+// src/workspace/utils/geometry/sizing.utils.ts
+function e(t, n) {
+	if (!t) return {
+		width: 0,
+		height: 0
+	};
+	if (t.type === "group") {
+		let e = t.panels.flatMap((e) => {
+			let t = n.panels.get(e);
+			return t ? [t] : [];
+		});
+		return {
+			width: Math.max(n.chrome.width, ...e.map((e) => e.width)),
+			height: Math.max(n.chrome.height, ...e.map((e) => e.height))
+		};
+	}
+	let r = t.children.map((t) => e(t, n)), i = n.gap * (r.length - 1);
+	return {
+		width: t.axis === "horizontal" ? r.reduce((e, t) => e + t.width, i) : Math.max(...r.map((e) => e.width)),
+		height: t.axis === "vertical" ? r.reduce((e, t) => e + t.height, i) : Math.max(...r.map((e) => e.height))
+	};
+}
+function t(t) {
+	let n = e(t.current, t.requirements), r = e(t.candidate, t.requirements);
+	return ["width", "height"].every((e) => Math.max(0, r[e] - t.viewport[e]) <= Math.max(0, n[e] - t.viewport[e]));
+}
+function n(e) {
+	return {
+		gap: e.measurements.gap,
+		chrome: {
+			width: e.measurements.gripWidth + e.measurements.tabWidth + (e.measurements.groupActionWidth ?? 0),
+			height: e.measurements.headerHeight
+		},
+		panels: new Map(e.panels.map((t) => [t.id, {
+			width: Math.max(Number.isFinite(t.minWidth) ? Math.max(0, t.minWidth) : 0, e.measurements.gripWidth + e.measurements.tabWidth + (e.measurements.groupActionWidth ?? 0) + (e.measurements.panels?.[t.id]?.suffixWidth ?? 0)),
+			height: Math.max(Number.isFinite(t.minHeight) ? Math.max(0, t.minHeight) : 0, e.measurements.headerHeight + (e.measurements.panels?.[t.id]?.footerHeight ?? 0))
+		}]))
+	};
+}
+export { t as admitsWorkspaceMove, e as getMinimumWorkspaceDimensions, n as getWorkspaceRequirements };
+
+//# sourceMappingURL=sizing.utils.js.map

package/dist/workspace/utils/geometry/sizing.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sizing.utils.js","names":["getMinimumWorkspaceDimensions","node","panels","panel","requirements","id","children","child","gap","sum","admitsWorkspaceMove","current","input","candidate","axis","getWorkspaceRequirements"],"sources":["../../../../src/workspace/utils/geometry/sizing.utils.ts"],"sourcesContent":["// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Dimensions } from '@nvidia-elements/core/internal';\n\nimport type { WorkspaceNode } from '../model/layout.utils.js';\n\nexport interface WorkspaceRequirements {\n  gap: number;\n  panels: ReadonlyMap<string, Dimensions>;\n  chrome: Dimensions;\n}\n\n/** Combines explicit panel requirements with one operable header, independent of tab count. */\nexport function getMinimumWorkspaceDimensions(\n  node: WorkspaceNode | null,\n  requirements: WorkspaceRequirements\n): Dimensions {\n  if (!node) return { width: 0, height: 0 };\n  if (node.type === 'group') {\n    const panels = node.panels.flatMap(id => {\n      const panel = requirements.panels.get(id);\n      return panel ? [panel] : [];\n    });\n    return {\n      width: Math.max(requirements.chrome.width, ...panels.map(panel => panel.width)),\n      height: Math.max(requirements.chrome.height, ...panels.map(panel => panel.height))\n    };\n  }\n  const children = node.children.map(child => getMinimumWorkspaceDimensions(child, requirements));\n  const gap = requirements.gap * (children.length - 1);\n  return {\n    width:\n      node.axis === 'horizontal'\n        ? children.reduce((sum, child) => sum + child.width, gap)\n        : Math.max(...children.map(child => child.width)),\n    height:\n      node.axis === 'vertical'\n        ? children.reduce((sum, child) => sum + child.height, gap)\n        : Math.max(...children.map(child => child.height))\n  };\n}\n\n/** Admits a change when it does not increase minimum overflow on either axis. */\nexport function admitsWorkspaceMove(input: {\n  current: WorkspaceNode | null;\n  candidate: WorkspaceNode | null;\n  viewport: Dimensions;\n  requirements: WorkspaceRequirements;\n}) {\n  const current = getMinimumWorkspaceDimensions(input.current, input.requirements);\n  const candidate = getMinimumWorkspaceDimensions(input.candidate, input.requirements);\n  return (['width', 'height'] as const).every(\n    axis => Math.max(0, candidate[axis] - input.viewport[axis]) <= Math.max(0, current[axis] - input.viewport[axis])\n  );\n}\n\n/** Reads supplied panel constraints without changing the conservative operable-header floor. */\nexport function getWorkspaceRequirements(input: {\n  measurements: {\n    gap: number;\n    gripWidth: number;\n    tabWidth: number;\n    groupActionWidth?: number;\n    headerHeight: number;\n    panels?: Record<string, { suffixWidth: number; footerHeight: number }>;\n  };\n  panels: { id: string; minWidth: number; minHeight: number }[];\n}): WorkspaceRequirements {\n  return {\n    gap: input.measurements.gap,\n    chrome: {\n      width: input.measurements.gripWidth + input.measurements.tabWidth + (input.measurements.groupActionWidth ?? 0),\n      height: input.measurements.headerHeight\n    },\n    panels: new Map(\n      input.panels.map(panel => [\n        panel.id,\n        {\n          width: Math.max(\n            Number.isFinite(panel.minWidth) ? Math.max(0, panel.minWidth) : 0,\n            input.measurements.gripWidth +\n              input.measurements.tabWidth +\n              (input.measurements.groupActionWidth ?? 0) +\n              (input.measurements.panels?.[panel.id]?.suffixWidth ?? 0)\n          ),\n          height: Math.max(\n            Number.isFinite(panel.minHeight) ? Math.max(0, panel.minHeight) : 0,\n            input.measurements.headerHeight + (input.measurements.panels?.[panel.id]?.footerHeight ?? 0)\n          )\n        }\n      ])\n    )\n  };\n}\n"],"mappings":";AAcA,SAAgBA,EACd,GACA,GACY;CACZ,IAAI,CAACC,GAAM,OAAO;EAAE,OAAO;EAAG,QAAQ;CAAE;CACxC,IAAIA,EAAK,SAAS,SAAS;EACzB,IAAMC,IAASD,EAAK,OAAO,SAAQ,MAAM;GACvC,IAAME,IAAQC,EAAa,OAAO,IAAIC,CAAE;GACxC,OAAOF,IAAQ,CAACA,CAAK,IAAI,CAAC;EAC5B,CAAC;EACD,OAAO;GACL,OAAO,KAAK,IAAIC,EAAa,OAAO,OAAO,GAAGF,EAAO,KAAI,MAASC,EAAM,KAAK,CAAC;GAC9E,QAAQ,KAAK,IAAIC,EAAa,OAAO,QAAQ,GAAGF,EAAO,KAAI,MAASC,EAAM,MAAM,CAAC;EACnF;CACF;CACA,IAAMG,IAAWL,EAAK,SAAS,KAAI,MAASD,EAA8BO,GAAOH,CAAY,CAAC,GACxFI,IAAMJ,EAAa,OAAOE,EAAS,SAAS;CAClD,OAAO;EACL,OACEL,EAAK,SAAS,eACVK,EAAS,QAAQ,GAAK,MAAUG,IAAMF,EAAM,OAAOC,CAAG,IACtD,KAAK,IAAI,GAAGF,EAAS,KAAI,MAASC,EAAM,KAAK,CAAC;EACpD,QACEN,EAAK,SAAS,aACVK,EAAS,QAAQ,GAAK,MAAUG,IAAMF,EAAM,QAAQC,CAAG,IACvD,KAAK,IAAI,GAAGF,EAAS,KAAI,MAASC,EAAM,MAAM,CAAC;CACvD;AACF;AAGA,SAAgBG,EAAoB,GAKjC;CACD,IAAMC,IAAUX,EAA8BY,EAAM,SAASA,EAAM,YAAY,GACzEC,IAAYb,EAA8BY,EAAM,WAAWA,EAAM,YAAY;CACnF,OAAQ,CAAC,SAAS,QAAQ,CAAC,CAAW,OACpC,MAAQ,KAAK,IAAI,GAAGC,EAAUC,KAAQF,EAAM,SAASE,EAAK,KAAK,KAAK,IAAI,GAAGH,EAAQG,KAAQF,EAAM,SAASE,EAAK,CACjH;AACF;AAGA,SAAgBC,EAAyB,GAUf;CACxB,OAAO;EACL,KAAKH,EAAM,aAAa;EACxB,QAAQ;GACN,OAAOA,EAAM,aAAa,YAAYA,EAAM,aAAa,YAAYA,EAAM,aAAa,oBAAoB;GAC5G,QAAQA,EAAM,aAAa;EAC7B;EACA,QAAQ,IAAI,IACVA,EAAM,OAAO,KAAI,MAAS,CACxBT,EAAM,IACN;GACE,OAAO,KAAK,IACV,OAAO,SAASA,EAAM,QAAQ,IAAI,KAAK,IAAI,GAAGA,EAAM,QAAQ,IAAI,GAChES,EAAM,aAAa,YACjBA,EAAM,aAAa,YAClBA,EAAM,aAAa,oBAAoB,MACvCA,EAAM,aAAa,SAAST,EAAM,GAAG,EAAE,eAAe,EAC3D;GACA,QAAQ,KAAK,IACX,OAAO,SAASA,EAAM,SAAS,IAAI,KAAK,IAAI,GAAGA,EAAM,SAAS,IAAI,GAClES,EAAM,aAAa,gBAAgBA,EAAM,aAAa,SAAST,EAAM,GAAG,EAAE,gBAAgB,EAC5F;EACF,CACF,CAAC,CACH;CACF;AACF"}

package/dist/workspace/utils/interaction/boundary.utils.d.ts

@@ -0,0 +1,40 @@
+import type { Point, Rect } from '@nvidia-elements/core/internal';
+import { getCurrentInsertionSeam } from './insertion-offers.utils.js';
+import type { WorkspaceDropIntent } from './drag-preview.utils.js';
+import type { WorkspaceInsertionOffer } from './insertion-offers.utils.js';
+type Side = 'left' | 'right' | 'top' | 'bottom';
+interface BoundaryInput {
+    offers: WorkspaceInsertionOffer[];
+    bounds: Rect;
+    point: Point;
+    current?: WorkspaceDropIntent;
+    headers: Rect[];
+    geometry?: Parameters<typeof getCurrentInsertionSeam>[1];
+}
+/** Separates a mathematical boundary selection from its clipped, inward-only cue. */
+export declare function getBoundaryPlacementOffers(input: BoundaryInput): {
+    offers: {
+        kind: 'order' | 'insert';
+        owner: string;
+        boundary?: 'start' | 'end';
+        scope: NonNullable<ReturnType<typeof import("../placement/group-insertion.utils.js").describePlacementSlot>>;
+        plan: import("../placement/planner.utils.js").WorkspacePlacementPlan;
+        hitRect?: Rect;
+        scopeRect: Rect;
+        destination: import("../model/operations.utils.js").WorkspaceDestination;
+        rect: Rect;
+    }[];
+    hit: {
+        kind: 'order' | 'insert';
+        owner: string;
+        boundary?: 'start' | 'end';
+        scope: NonNullable<ReturnType<typeof import("../placement/group-insertion.utils.js").describePlacementSlot>>;
+        plan: import("../placement/planner.utils.js").WorkspacePlacementPlan;
+        hitRect?: Rect;
+        scopeRect: Rect;
+        destination: import("../model/operations.utils.js").WorkspaceDestination;
+        rect: Rect;
+    } | undefined;
+};
+export declare function getBoundarySide(bounds: Rect, point: Point, current?: Side): Side;
+export {};

package/dist/workspace/utils/interaction/boundary.utils.js

@@ -0,0 +1,91 @@
+import { getCurrentInsertionSeam as e, partitionPlacementOffers as t, placementOwnsChrome as n } from "./insertion-offers.utils.js";
+// src/workspace/utils/interaction/boundary.utils.ts
+var r = [
+	"left",
+	"right",
+	"top",
+	"bottom"
+];
+function i(e) {
+	let { offers: n, bounds: r, point: i, current: l } = e, u = n.filter((e) => e.owner === "root" && e.boundary), d = s(r, i, l && l.kind !== "invalid" && l.kind !== "tab" ? l.destination.position : void 0), f = u.find((e) => e.destination.position === d), p = f && c(r, i)[d] <= 6 ? f : void 0, m = t(n.filter((e) => !u.includes(e))).flatMap((t) => o({
+		input: e,
+		roots: u,
+		offer: t
+	})), h = u.filter((e) => e.destination.position === d).flatMap((e) => {
+		let t = a(r, d);
+		return t.width && t.height ? [{
+			...e,
+			rect: t
+		}] : [];
+	});
+	return {
+		offers: [...h, ...m],
+		hit: p ? h.find((e) => e.scope.key === p.scope.key) : void 0
+	};
+}
+function a(e, t) {
+	return t === "left" || t === "right" ? {
+		x: t === "left" ? e.x : e.x + e.width - 6,
+		y: e.y,
+		width: 6,
+		height: e.height
+	} : {
+		x: e.x,
+		y: t === "top" ? e.y : e.y + e.height - 6,
+		width: e.width,
+		height: 6
+	};
+}
+function o({ input: t, roots: r, offer: i }) {
+	let a = t.offers.find((e) => e.scope.key === i.scope.key), o = t.geometry ? e(a, t.geometry) ?? a.rect : a.rect, s = i.destination.position, c = s === "left" || s === "right", d = { ...i.rect };
+	return r.some((e) => e.destination.position === s) && l(d, t.bounds, s) && (c ? d.x += s === "left" ? 6 : -6 : d.y += s === "top" ? 6 : -6), n(i) ? [{
+		...i,
+		rect: a.rect,
+		hitRect: d
+	}] : u(d, t.headers, c).map((e) => ({
+		...i,
+		rect: o,
+		hitRect: e
+	}));
+}
+function s(e, t, n) {
+	let i = c(e, t), a = Math.min(...Object.values(i)), o = r.filter((e) => i[e] === a);
+	return n && o.includes(n) ? n : o[0];
+}
+function c(e, t) {
+	return {
+		left: t.x - e.x,
+		right: e.x + e.width - t.x,
+		top: t.y - e.y,
+		bottom: e.y + e.height - t.y
+	};
+}
+function l(e, t, n) {
+	switch (n) {
+		case "left": return Math.abs(e.x - t.x) < 1;
+		case "right": return Math.abs(e.x + e.width - t.x - t.width) < 1;
+		case "top": return Math.abs(e.y - t.y) < 1;
+		case "bottom":
+		case "tab": return Math.abs(e.y + e.height - t.y - t.height) < 1;
+	}
+}
+function u(e, t, n = e.width === 12) {
+	let r = [e];
+	for (let e of t) r = r.flatMap((t) => d(t, e, n));
+	return r;
+}
+function d(e, t, n) {
+	if (e.x >= t.x + t.width || e.x + e.width <= t.x || e.y >= t.y + t.height || e.y + e.height <= t.y) return [e];
+	let r = n ? "y" : "x", i = n ? "height" : "width", a = t[r] - e[r], o = e[r] + e[i] - t[r] - t[i], s = [];
+	return a > 0 && s.push({
+		...e,
+		[i]: a
+	}), o > 0 && s.push({
+		...e,
+		[r]: t[r] + t[i],
+		[i]: o
+	}), s;
+}
+export { i as getBoundaryPlacementOffers, s as getBoundarySide };
+
+//# sourceMappingURL=boundary.utils.js.map

package/dist/workspace/utils/interaction/boundary.utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boundary.utils.js","names":["sides","getBoundaryPlacementOffers","input","roots","offers","offer","side","getBoundarySide","bounds","point","current","root","hit","edgeDistances","local","partitionPlacementOffers","localGeometry","painted","rect","boundaryPaint","paint","original","paintRect","getCurrentInsertionSeam","position","vertical","touches","placementOwnsChrome","protectChrome","distances","minimum","tied","fragments","header","headers","subtractHeaderFromFragment","fragment","start","extent","before","after"],"sources":["../../../../src/workspace/utils/interaction/boundary.utils.ts"],"sourcesContent":["// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Point, Rect } from '@nvidia-elements/core/internal';\n\nimport { getCurrentInsertionSeam, partitionPlacementOffers, placementOwnsChrome } from './insertion-offers.utils.js';\n\nimport type { WorkspaceDropIntent } from './drag-preview.utils.js';\nimport type { WorkspaceInsertionOffer } from './insertion-offers.utils.js';\n\ntype Side = 'left' | 'right' | 'top' | 'bottom';\n\nconst sides: Side[] = ['left', 'right', 'top', 'bottom'];\n\ninterface BoundaryInput {\n  offers: WorkspaceInsertionOffer[];\n  bounds: Rect;\n  point: Point;\n  current?: WorkspaceDropIntent;\n  headers: Rect[];\n  geometry?: Parameters<typeof getCurrentInsertionSeam>[1];\n}\n\n/** Separates a mathematical boundary selection from its clipped, inward-only cue. */\nexport function getBoundaryPlacementOffers(input: BoundaryInput) {\n  const { offers, bounds, point, current } = input;\n  const roots = offers.filter(offer => offer.owner === 'root' && offer.boundary);\n  const side = getBoundarySide(\n    bounds,\n    point,\n    current && current.kind !== 'invalid' && current.kind !== 'tab' ? current.destination.position : undefined\n  );\n  const root = roots.find(offer => offer.destination.position === side);\n  const hit = root && edgeDistances(bounds, point)[side] <= 6 ? root : undefined;\n  const local = partitionPlacementOffers(offers.filter(offer => !roots.includes(offer))).flatMap(offer =>\n    localGeometry({ input, roots, offer })\n  );\n  const painted = roots\n    .filter(offer => offer.destination.position === side)\n    .flatMap(offer => {\n      const rect = boundaryPaint(bounds, side);\n      return rect.width && rect.height ? [{ ...offer, rect }] : [];\n    });\n  return {\n    offers: [...painted, ...local],\n    hit: hit ? painted.find(offer => offer.scope.key === hit.scope.key) : undefined\n  };\n}\n\nfunction boundaryPaint(bounds: Rect, side: Side): Rect {\n  if (side === 'left' || side === 'right') {\n    const x = side === 'left' ? bounds.x : bounds.x + bounds.width - 6;\n    return { x, y: bounds.y, width: 6, height: bounds.height };\n  }\n\n  const x = bounds.x;\n  const y = side === 'top' ? bounds.y : bounds.y + bounds.height - 6;\n  return { x, y, width: bounds.width, height: 6 };\n}\n\nfunction localGeometry({\n  input,\n  roots,\n  offer\n}: {\n  input: BoundaryInput;\n  roots: WorkspaceInsertionOffer[];\n  offer: WorkspaceInsertionOffer;\n}) {\n  const paint = input.offers.find(original => original.scope.key === offer.scope.key)!;\n  const paintRect = input.geometry ? (getCurrentInsertionSeam(paint, input.geometry) ?? paint.rect) : paint.rect;\n  const position = offer.destination.position;\n  const vertical = position === 'left' || position === 'right';\n  const rect = { ...offer.rect };\n  if (roots.some(root => root.destination.position === position) && touches(rect, input.bounds, position)) {\n    if (vertical) {\n      rect.x += position === 'left' ? 6 : -6;\n    } else {\n      rect.y += position === 'top' ? 6 : -6;\n    }\n  }\n  if (placementOwnsChrome(offer)) return [{ ...offer, rect: paint.rect, hitRect: rect }];\n  return protectChrome(rect, input.headers, vertical).map(hitRect => ({\n    ...offer,\n    rect: paintRect,\n    hitRect\n  }));\n}\n\nexport function getBoundarySide(bounds: Rect, point: Point, current?: Side): Side {\n  const distances = edgeDistances(bounds, point);\n  const minimum = Math.min(...Object.values(distances));\n  const tied = sides.filter(side => distances[side] === minimum);\n  return current && tied.includes(current) ? current : tied[0]!;\n}\n\nfunction edgeDistances(bounds: Rect, point: Point) {\n  return {\n    left: point.x - bounds.x,\n    right: bounds.x + bounds.width - point.x,\n    top: point.y - bounds.y,\n    bottom: bounds.y + bounds.height - point.y\n  };\n}\n\nfunction touches(rect: Rect, bounds: Rect, side: WorkspaceInsertionOffer['destination']['position']) {\n  switch (side) {\n    case 'left':\n      return Math.abs(rect.x - bounds.x) < 1;\n    case 'right':\n      return Math.abs(rect.x + rect.width - bounds.x - bounds.width) < 1;\n    case 'top':\n      return Math.abs(rect.y - bounds.y) < 1;\n    case 'bottom':\n    case 'tab':\n      return Math.abs(rect.y + rect.height - bounds.y - bounds.height) < 1;\n  }\n}\n\nfunction protectChrome(rect: Rect, headers: Rect[], vertical = rect.width === 12): Rect[] {\n  let fragments = [rect];\n  for (const header of headers) {\n    fragments = fragments.flatMap(fragment => subtractHeaderFromFragment(fragment, header, vertical));\n  }\n  return fragments;\n}\n\nfunction subtractHeaderFromFragment(fragment: Rect, header: Rect, vertical: boolean): Rect[] {\n  if (\n    fragment.x >= header.x + header.width ||\n    fragment.x + fragment.width <= header.x ||\n    fragment.y >= header.y + header.height ||\n    fragment.y + fragment.height <= header.y\n  ) {\n    return [fragment];\n  }\n  const start = vertical ? 'y' : 'x';\n  const extent = vertical ? 'height' : 'width';\n  const before = header[start] - fragment[start];\n  const after = fragment[start] + fragment[extent] - header[start] - header[extent];\n  const fragments: Rect[] = [];\n  if (before > 0) {\n    fragments.push({ ...fragment, [extent]: before });\n  }\n  if (after > 0) {\n    fragments.push({ ...fragment, [start]: header[start] + header[extent], [extent]: after });\n  }\n  return fragments;\n}\n"],"mappings":"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"}

package/dist/workspace/utils/interaction/command.utils.d.ts

@@ -0,0 +1,74 @@
+import type { WorkspaceDropIntent } from './drag-preview.utils.js';
+import type { WorkspaceLayout } from '../model/layout.utils.js';
+import type { WorkspacePanel } from '../../panel/panel.js';
+export type WorkspaceSide = 'left' | 'right' | 'top' | 'bottom';
+/** A placement supplied on the invoker's `placement` property for `--place`.
+ * Source defaults to one panel; `group` carries its entire current group, including closed members.
+ * An arrangement target identifies the enclosing split of the target panel, before source removal.
+ */
+export type WorkspacePlacement = {
+    source?: 'panel' | 'group';
+} & ({
+    operation: 'split';
+    target: string;
+    position: WorkspaceSide;
+} | {
+    operation: 'join';
+    target: string;
+    index?: number;
+} | {
+    operation: 'reorder';
+    target: string;
+    position: 'before' | 'after';
+} | {
+    operation: 'insert';
+    scope: 'arrangement';
+    target: string;
+    position: WorkspaceSide;
+} | {
+    operation: 'insert';
+    scope: 'workspace';
+    position: WorkspaceSide;
+});
+export type WorkspacePlacementIntent = Exclude<WorkspaceDropIntent, {
+    kind: 'invalid';
+}>;
+/** Identifies a supplied panel and optional placement without requiring an invoker element. */
+export interface WorkspaceCommandContext {
+    value?: string | null;
+    placement?: WorkspacePlacement;
+}
+export interface WorkspaceCommandSource extends HTMLElement, WorkspaceCommandContext {
+    disabled?: boolean;
+    readOnly?: boolean;
+}
+export type WorkspaceCommandEvent = Event & {
+    command?: string;
+    source?: WorkspaceCommandSource | null;
+};
+interface WorkspaceCommandAvailability {
+    command: string;
+    context: WorkspaceCommandContext;
+    layout?: WorkspaceLayout;
+    available: string[];
+    closable: boolean;
+    rearrangeable: boolean;
+    placementAvailable(source: string[], intent: WorkspacePlacementIntent): boolean;
+    canEnterFullscreen(anchor: string): boolean;
+    canExitFullscreen(): boolean;
+    isFullscreenGroup(anchor: string): boolean;
+}
+export declare function findWorkspaceCommandPanel(host: HTMLElement, panels: WorkspacePanel[], event: WorkspaceCommandEvent): WorkspacePanel | undefined;
+export declare function isWorkspaceCommandAvailable(input: WorkspaceCommandAvailability): boolean;
+export declare function isWorkspacePlacement(value: unknown): value is WorkspacePlacement;
+/** Resolves panel IDs to placement operations without exposing region paths. */
+export declare function resolveWorkspacePlacement(input: {
+    layout: WorkspaceLayout;
+    available: string[];
+    anchor: string;
+    placement: WorkspacePlacement;
+}): {
+    source: string[];
+    intent: WorkspacePlacementIntent;
+} | undefined;
+export {};