@n-uf/placement 26.11.8 → 26.11.10

package/dist/panels.js

@@ -1,16 +1,26 @@
 import {
+  readPanels,
+  storePanels
+} from "./chunk-7R5H2ABL.js";
+import {
+  BAND_SIZE,
   COLUMN_REACH,
   DEFAULT_PANELS_OPTIONS,
+  EDGES,
   FLOAT_HEIGHT,
   FLOAT_MIN,
   IDENTITY_VIEW,
   RAIL_EDGE,
   SIDES,
+  activate,
+  bandHeight,
+  bandSize,
   close,
   columnWidth,
   createPanels,
   defOf,
   dock,
+  dockBand,
   float,
   floatSize,
   focus,
@@ -26,146 +36,37 @@ import {
   panelTargets,
   pin,
   placeRank,
+  resizeBand,
   resizeColumn,
   resizeFloat,
   samePlaces,
+  showTabs,
   tick,
   toPage,
   toView,
   toggleFold,
   whereIs
-} from "./chunk-QR7MGDX6.js";
+} from "./chunk-PJD5HKYX.js";
 import "./chunk-QMTNB2C3.js";
-
-// src/panels/store.ts
-function storePanels(state) {
-  const sides = Object.fromEntries(SIDES.map((s) => [s, state.sides[s].map((c) => ({ panels: [...c.panels], width: c.width }))]));
-  return {
-    v: 1,
-    sides,
-    floats: state.floats.map((f) => ({ id: f.id, rect: { x: f.rect.x, y: f.rect.y, width: f.rect.width, height: f.rect.height }, pinned: !!f.pinned })),
-    folded: [...state.folded],
-    kept: [...state.kept],
-    closed: [...state.closed],
-    clock: Object.fromEntries(Object.entries(state.clock).map(([k, c]) => [k, { opened: c.opened, used: c.used }]))
-  };
-}
-var isObject = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
-var finite = (x) => typeof x === "number" && Number.isFinite(x);
-function readPanels(data, defs) {
-  try {
-    return read(data, defs);
-  } catch (e) {
-    return { ok: false, error: `unreadable: ${e instanceof Error ? e.message : typeof e}` };
-  }
-}
-function read(data, defs) {
-  if (!isObject(data)) return { ok: false, error: "not an object" };
-  if (data.v !== 1) return { ok: false, error: `unknown version ${typeof data.v === "number" || typeof data.v === "string" ? String(data.v) : typeof data.v} (this reads version 1)` };
-  if (!isObject(data.sides)) return { ok: false, error: "sides is missing" };
-  const dropped = [];
-  const drop = (what) => {
-    if (!dropped.includes(what)) dropped.push(what);
-  };
-  const seen = /* @__PURE__ */ new Set();
-  const take = (x) => {
-    if (typeof x !== "string") {
-      drop(`a ${typeof x} where an id goes`);
-      return null;
-    }
-    if (defs && !defOf(defs, x) || seen.has(x)) {
-      drop(x);
-      return null;
-    }
-    seen.add(x);
-    return x;
-  };
-  const extra = (o, known, prefix) => {
-    for (const k of Object.keys(o)) if (!known.includes(k)) drop(`${prefix}${k}`);
-  };
-  extra(data, ["v", "sides", "floats", "folded", "kept", "closed", "clock"], "");
-  extra(data.sides, SIDES, "sides.");
-  const sides = { left: [], right: [] };
-  for (const side of SIDES) {
-    const cols = data.sides[side];
-    if (cols === void 0) continue;
-    if (!Array.isArray(cols)) {
-      drop(`sides.${side}`);
-      continue;
-    }
-    for (const c of cols) {
-      if (!isObject(c) || !Array.isArray(c.panels)) {
-        drop(`a column on the ${side}`);
-        continue;
-      }
-      extra(c, ["panels", "width"], "column.");
-      const panels = c.panels.map(take).filter((x) => x !== null);
-      if (panels.length === 0) continue;
-      const ds = defs ? panels.map((id) => defOf(defs, id)) : [];
-      const lo = Math.max(0, ...ds.map((d) => d.width.min));
-      const hi = Math.max(lo, Math.min(...ds.map((d) => d.width.max)));
-      const natural = ds.length ? Math.max(...ds.map((d) => d.width.natural)) : 0;
-      const width = finite(c.width) ? c.width : natural;
-      sides[side].push({ panels, width: defs ? Math.min(Math.max(width, lo), hi) : Math.max(0, width) });
-    }
-  }
-  const floats = [];
-  for (const f of Array.isArray(data.floats) ? data.floats : []) {
-    const r = isObject(f) ? f.rect : void 0;
-    if (!isObject(f) || !isObject(r) || !finite(r.x) || !finite(r.y) || !finite(r.width) || !finite(r.height)) {
-      drop(isObject(f) && typeof f.id === "string" ? f.id : "a float");
-      continue;
-    }
-    extra(f, ["id", "rect", "pinned"], "float.");
-    const id = take(f.id);
-    if (id === null) continue;
-    const min = defs ? floatSize(defOf(defs, id)).min : { width: 0, height: 0 };
-    floats.push({ id, rect: { x: r.x, y: r.y, width: Math.max(min.width, r.width), height: Math.max(min.height, r.height) }, ...f.pinned === true ? { pinned: true } : {} });
-  }
-  if (data.floats !== void 0 && !Array.isArray(data.floats)) drop("floats");
-  const placed = (key) => {
-    const x = data[key];
-    if (x === void 0) return [];
-    if (!Array.isArray(x)) {
-      drop(key);
-      return [];
-    }
-    const out = [];
-    for (const id of x) {
-      if (typeof id === "string" && seen.has(id)) {
-        if (!out.includes(id)) out.push(id);
-      } else drop(typeof id === "string" ? id : `a ${typeof id} in ${key}`);
-    }
-    return out;
-  };
-  const floating = new Set(floats.map((f) => f.id));
-  const kept = placed("kept").filter((id) => {
-    if (floating.has(id)) drop(id);
-    return !floating.has(id);
-  });
-  const clock = {};
-  if (isObject(data.clock)) {
-    for (const id of Object.keys(data.clock)) if (!seen.has(id)) drop(`clock.${id}`);
-    for (const id of seen) {
-      const c = data.clock[id];
-      clock[id] = isObject(c) && finite(c.opened) && finite(c.used) ? { opened: c.opened, used: c.used } : { opened: 0, used: 0 };
-    }
-  }
-  return { ok: true, state: { sides, floats, folded: placed("folded"), kept, closed: placed("closed"), clock }, dropped };
-}
 export {
+  BAND_SIZE,
   COLUMN_REACH,
   DEFAULT_PANELS_OPTIONS,
+  EDGES,
   FLOAT_HEIGHT,
   FLOAT_MIN,
   IDENTITY_VIEW,
   RAIL_EDGE,
   SIDES,
+  activate,
+  bandHeight,
+  bandSize,
   close,
   columnWidth,
   createPanels,
   defOf,
   dock,
+  dockBand,
   float,
   floatSize,
   focus,
@@ -182,9 +83,11 @@ export {
   pin,
   placeRank,
   readPanels,
+  resizeBand,
   resizeColumn,
   resizeFloat,
   samePlaces,
+  showTabs,
   storePanels,
   tick,
   toPage,

package/dist/panels.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/panels/store.ts"],"sourcesContent":["/**\n * The panels' stored form: `storePanels(state)` gives plain JSON-safe data (`{ v: 1, … }`); `readPanels(data, defs?)`\n * reads parsed data back and never throws. As with the toolbar's `readArrangement`: anything but an object of\n * version 1 is `{ ok: false, error }`. Inside one, it is lenient: an unknown id (with `defs`), a repeated one or a\n * malformed entry is dropped and listed in `dropped`; widths and float sizes are clamped to the defs. A panel the\n * consumer has but the stored state lacks is no error: the consumer places it (`open` with a place, say).\n *\n * Version 1 only gains optional fields. A field this reader doesn't know (a newer writer's, say) is no error either:\n * it is skipped and reported in `dropped` (`\"<field>\"` at the top, `\"sides.<key>\"`, `\"column.<field>\"`,\n * `\"float.<field>\"`; a clock entry for a panel that isn't placed as `\"clock.<id>\"`), so a consumer can tell that\n * something was left out.\n */\nimport type { Rect } from \"../geometry\";\nimport { SIDES, defOf, floatSize, type Clock, type Column, type FloatAt, type PanelDef, type PanelsState, type Side } from \"./model\";\n\nexport interface StoredPanels {\n  readonly v: 1;\n  readonly sides: Record<Side, { panels: string[]; width: number }[]>;\n  readonly floats: { id: string; rect: Rect; pinned: boolean }[];\n  readonly folded: string[];\n  readonly kept: string[];\n  readonly closed: string[];\n  readonly clock: Record<string, Clock>;\n}\n\nexport type PanelsRead = { readonly ok: true; readonly state: PanelsState; readonly dropped: readonly string[] } | { readonly ok: false; readonly error: string };\n\nexport function storePanels(state: PanelsState): StoredPanels {\n  const sides = Object.fromEntries(SIDES.map((s) => [s, state.sides[s].map((c) => ({ panels: [...c.panels], width: c.width }))])) as StoredPanels[\"sides\"];\n  return {\n    v: 1,\n    sides,\n    floats: state.floats.map((f) => ({ id: f.id, rect: { x: f.rect.x, y: f.rect.y, width: f.rect.width, height: f.rect.height }, pinned: !!f.pinned })),\n    folded: [...state.folded],\n    kept: [...state.kept],\n    closed: [...state.closed],\n    clock: Object.fromEntries(Object.entries(state.clock).map(([k, c]) => [k, { opened: c.opened, used: c.used }])),\n  };\n}\n\nconst isObject = (x: unknown): x is Record<string, unknown> => typeof x === \"object\" && x !== null && !Array.isArray(x);\nconst finite = (x: unknown): x is number => typeof x === \"number\" && Number.isFinite(x);\n\nexport function readPanels(data: unknown, defs?: readonly PanelDef[]): PanelsRead {\n  try {\n    return read(data, defs);\n  } catch (e) {\n    // A getter that throws, a proxy: still no throw.\n    return { ok: false, error: `unreadable: ${e instanceof Error ? e.message : typeof e}` };\n  }\n}\n\nfunction read(data: unknown, defs?: readonly PanelDef[]): PanelsRead {\n  if (!isObject(data)) return { ok: false, error: \"not an object\" };\n  // Named without serialising it: a BigInt or a circular value must not throw.\n  if (data.v !== 1) return { ok: false, error: `unknown version ${typeof data.v === \"number\" || typeof data.v === \"string\" ? String(data.v) : typeof data.v} (this reads version 1)` };\n  if (!isObject(data.sides)) return { ok: false, error: \"sides is missing\" };\n  const dropped: string[] = [];\n  const drop = (what: string): void => {\n    if (!dropped.includes(what)) dropped.push(what);\n  };\n  const seen = new Set<string>();\n  // An id the consumer has, not placed yet.\n  const take = (x: unknown): string | null => {\n    if (typeof x !== \"string\") {\n      drop(`a ${typeof x} where an id goes`);\n      return null;\n    }\n    if ((defs && !defOf(defs, x)) || seen.has(x)) {\n      drop(x);\n      return null;\n    }\n    seen.add(x);\n    return x;\n  };\n  // Fields this version doesn't know: skipped, and reported.\n  const extra = (o: Record<string, unknown>, known: readonly string[], prefix: string): void => {\n    for (const k of Object.keys(o)) if (!known.includes(k)) drop(`${prefix}${k}`);\n  };\n  extra(data, [\"v\", \"sides\", \"floats\", \"folded\", \"kept\", \"closed\", \"clock\"], \"\");\n  extra(data.sides, SIDES, \"sides.\");\n  const sides = { left: [] as Column[], right: [] as Column[] };\n  for (const side of SIDES) {\n    const cols = data.sides[side];\n    if (cols === undefined) continue;\n    if (!Array.isArray(cols)) {\n      drop(`sides.${side}`);\n      continue;\n    }\n    for (const c of cols as unknown[]) {\n      if (!isObject(c) || !Array.isArray(c.panels)) {\n        drop(`a column on the ${side}`);\n        continue;\n      }\n      extra(c, [\"panels\", \"width\"], \"column.\");\n      const panels = (c.panels as unknown[]).map(take).filter((x): x is string => x !== null);\n      if (panels.length === 0) continue;\n      const ds = defs ? panels.map((id) => defOf(defs, id)!) : [];\n      const lo = Math.max(0, ...ds.map((d) => d.width.min));\n      const hi = Math.max(lo, Math.min(...ds.map((d) => d.width.max)));\n      const natural = ds.length ? Math.max(...ds.map((d) => d.width.natural)) : 0;\n      const width = finite(c.width) ? c.width : natural;\n      sides[side].push({ panels, width: defs ? Math.min(Math.max(width, lo), hi) : Math.max(0, width) });\n    }\n  }\n  const floats: FloatAt[] = [];\n  for (const f of Array.isArray(data.floats) ? (data.floats as unknown[]) : []) {\n    const r = isObject(f) ? f.rect : undefined;\n    if (!isObject(f) || !isObject(r) || !finite(r.x) || !finite(r.y) || !finite(r.width) || !finite(r.height)) {\n      drop(isObject(f) && typeof f.id === \"string\" ? f.id : \"a float\");\n      continue;\n    }\n    extra(f, [\"id\", \"rect\", \"pinned\"], \"float.\");\n    const id = take(f.id);\n    if (id === null) continue;\n    const min = defs ? floatSize(defOf(defs, id)).min : { width: 0, height: 0 };\n    floats.push({ id, rect: { x: r.x, y: r.y, width: Math.max(min.width, r.width), height: Math.max(min.height, r.height) }, ...(f.pinned === true ? { pinned: true } : {}) });\n  }\n  if (data.floats !== undefined && !Array.isArray(data.floats)) drop(\"floats\");\n  // The lists keep only ids that are placed (a closed panel keeps its place).\n  const placed = (key: \"folded\" | \"kept\" | \"closed\"): string[] => {\n    const x = data[key];\n    if (x === undefined) return [];\n    if (!Array.isArray(x)) {\n      drop(key);\n      return [];\n    }\n    const out: string[] = [];\n    for (const id of x as unknown[]) {\n      if (typeof id === \"string\" && seen.has(id)) {\n        if (!out.includes(id)) out.push(id);\n      } else drop(typeof id === \"string\" ? id : `a ${typeof id} in ${key}`);\n    }\n    return out;\n  };\n  const floating = new Set(floats.map((f) => f.id));\n  // Only a docked panel is kept open.\n  const kept = placed(\"kept\").filter((id) => {\n    if (floating.has(id)) drop(id);\n    return !floating.has(id);\n  });\n  const clock: Record<string, Clock> = {};\n  if (isObject(data.clock)) {\n    for (const id of Object.keys(data.clock)) if (!seen.has(id)) drop(`clock.${id}`);\n    for (const id of seen) {\n      const c = data.clock[id];\n      clock[id] = isObject(c) && finite(c.opened) && finite(c.used) ? { opened: c.opened, used: c.used } : { opened: 0, used: 0 };\n    }\n  }\n  return { ok: true, state: { sides, floats, folded: placed(\"folded\"), kept, closed: placed(\"closed\"), clock }, dropped };\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/{targets-DqhZf3XZ.d.ts → targets-CLV69zMw.d.ts}

@@ -4,13 +4,32 @@ import { S as Size, R as Rect, P as Point } from './geometry-mL-GTRti.js';
  * The panels model: plain data and the pure changes on it.
  *
  * Panels have string ids. Each side holds full-height columns (outer edge first), each column one or more panels
- * top to bottom and its own width. A panel may instead float, in page space (it moves with the page) or pinned in
+ * top to bottom and its own width. Opt-in, the top and bottom edges hold a band each: its panels side by side, left to
+ * right, sharing its width, at its own height. A panel may instead float, in page space (it moves with the page) or pinned in
  * view space (it stays put). A logical clock per panel (opened, used) is what give-way reads; every change here that
  * counts as a use moves it on. Nothing here reads a host clock: the next tick is one past the latest in the state.
  */
 
 type Side = "left" | "right";
 declare const SIDES: readonly Side[];
+/** A band's edge: a horizontal dock along the stage's top or bottom (opt-in, `PanelsOptions.bands`). */
+type Edge = "top" | "bottom";
+declare const EDGES: readonly Edge[];
+/** Where a panel may dock: a side's columns or an edge's band. */
+type Place = Side | Edge;
+/** A band's height limits and natural height when a def gives none. */
+declare const BAND_SIZE: {
+    readonly min: number;
+    readonly max: number;
+    readonly natural: number;
+};
+/** How an edge's band lies: "reserved" shortens the pages, "overlay" lies over them; between the columns, or full width. */
+interface BandOption {
+    readonly mode: "reserved" | "overlay";
+    readonly span: "between" | "full";
+}
+/** Room kept clear along the pages' edges, px. */
+type Reserve = Readonly<Partial<Record<"top" | "right" | "bottom" | "left", number>>>;
 /**
  * What a consumer says about a panel: its width limits docked, its size limits floating, and where it may go. No
  * words: names and titles are the consumer's.
@@ -23,20 +42,41 @@ interface PanelDef {
         readonly max: number;
         readonly natural: number;
     };
+    /**
+     * Its height as a section of a stack column (opt-in): it gets its natural height, the column's last open section
+     * takes the rest, and when the column is short sections fold to bars by give-way. Without it a section shares the
+     * column's height equally with the others, as before.
+     */
+    readonly height?: {
+        readonly min: number;
+        readonly natural: number;
+    };
     /** A float's size limits and natural size (default: its natural width, 360 px tall, no smaller than 160 × 120). */
     readonly float?: {
         readonly min: Size;
         readonly natural: Size;
     };
-    /** Where it may dock (default: both sides). */
-    readonly sides?: readonly Side[];
+    /** Where it may dock (default: both sides, and every edge that has a band). */
+    readonly sides?: readonly Place[];
+    /** A band's height limits and natural height (default `BAND_SIZE`: min 120, max 480, natural 200). */
+    readonly band?: {
+        readonly min: number;
+        readonly max: number;
+        readonly natural: number;
+    };
     /** May it float (default: yes). */
     readonly floats?: boolean;
 }
-/** A full-height column: its panels top to bottom, and its stored width (the layout clamps it to its panels' limits). */
+/**
+ * A full-height column: its panels top to bottom, and its stored width (the layout clamps it to its panels' limits).
+ * `show` "tabs" shows one panel at a time under a strip of tabs: `active` (default, or when `active` isn't one of
+ * them: the first panel in the column that isn't closed).
+ */
 interface Column {
     readonly panels: readonly string[];
     readonly width: number;
+    readonly show?: "stack" | "tabs";
+    readonly active?: string;
 }
 /** A floating panel: `rect` in page space, or in view space when `pinned`. */
 interface FloatAt {
@@ -44,6 +84,11 @@ interface FloatAt {
     readonly rect: Rect;
     readonly pinned?: boolean;
 }
+/** A band: its panels left to right, sharing its width, and its stored height (the layout clamps it to their limits). */
+interface Band {
+    readonly panels: readonly string[];
+    readonly height: number;
+}
 /** Logical times: when a panel was last opened, and last used (opened, focused, moved or unfolded). */
 interface Clock {
     readonly opened: number;
@@ -61,6 +106,8 @@ interface PanelsState {
     /** Not shown at all (they keep their place, for when they open again). */
     readonly closed: readonly string[];
     readonly clock: Readonly<Record<string, Clock>>;
+    /** Each edge's band (absent: no band panels). An emptied band goes from the state. */
+    readonly bands?: Readonly<Partial<Record<Edge, Band>>>;
 }
 /** The page's offset and scale in the view: a page point p shows at `x + p.x * scale`, `y + p.y * scale`. */
 interface View {
@@ -100,16 +147,28 @@ interface PanelsOptions {
     /** A rail segment's height, and the gap above the first one (defaults 36 and 4). */
     readonly segment: number;
     readonly railInset: number;
+    /** A tabbed column's strip height (default 28). */
+    readonly tabs: number;
+    /** Which edges have a band, and how it lies (default: none). */
+    readonly bands: Readonly<Partial<Record<Edge, BandOption>>>;
+    /** The pages' minimum height; only bands give way to it (default 240). */
+    readonly pagesMinHeight: number;
+    /** Room kept clear at the pages' edges for a toolbar the app draws, px (default: none). */
+    readonly reserve: Reserve;
 }
 declare const DEFAULT_PANELS_OPTIONS: PanelsOptions;
 /** A float's size when its def gives none: this tall, and never smaller than FLOAT_MIN. */
 declare const FLOAT_HEIGHT = 360;
 declare const FLOAT_MIN: Size;
-/** Where a panel is: a column (side and index), floating, or nowhere. */
+/** Where a panel is: a column (side and index), a band (edge and index, left to right), floating, or nowhere. */
 type Where = {
     readonly kind: "column";
     readonly side: Side;
     readonly index: number;
+} | {
+    readonly kind: "band";
+    readonly edge: Edge;
+    readonly index: number;
 } | {
     readonly kind: "float";
     readonly float: FloatAt;
@@ -125,15 +184,26 @@ declare function floatSize(def: PanelDef | undefined): {
     min: Size;
     natural: Size;
 };
+/** A band's height limits and natural height from a def (`BAND_SIZE` when it gives none). */
+declare const bandSize: (def: PanelDef | undefined) => {
+    min: number;
+    max: number;
+    natural: number;
+};
+/** A band's height as the layout takes it: its stored height clamped to its panels' limits (the largest min, the smallest max). */
+declare function bandHeight(defs: readonly PanelDef[] | undefined, band: Band): number;
 /**
  * A panel's own width, for a new column made for it: the width of the column it is in, clamped to its own limits;
- * floating or nowhere, its natural width.
+ * in a band, floating or nowhere, its natural width.
  */
 declare function ownWidth(defs: readonly PanelDef[], state: PanelsState, id: string): number;
 interface PanelsStart {
     /** Each side's columns from the outer edge inward, each a list of panel ids top to bottom. */
     readonly left?: readonly (readonly string[])[];
     readonly right?: readonly (readonly string[])[];
+    /** Each edge's band, its panels left to right (it takes the tallest natural band height, within their limits). */
+    readonly top?: readonly string[];
+    readonly bottom?: readonly string[];
     /** Floating panels: where (page space, or view space when pinned); the size defaults to the def's natural size. */
     readonly floats?: readonly {
         readonly id: string;
@@ -149,32 +219,54 @@ interface PanelsStart {
 }
 /**
  * A state from a plain start: each column as wide as the widest natural width of its panels (within their limits),
- * each float its natural size. The clock counts up in the order the panels are listed (left, right, floats), so the
- * last one listed is the newest.
+ * each float its natural size. The clock counts up in the order the panels are listed (left, right, top, bottom,
+ * floats), so the last one listed is the newest.
  */
 declare function createPanels(defs: readonly PanelDef[], start: PanelsStart): PanelsState;
-/** The state with `id` taken out of its column (an emptied column goes) or the floats. Nothing else changes. */
+/**
+ * The state with `id` taken out of its column (an emptied column goes), its band (an emptied band goes, and its height
+ * is forgotten) or the floats. Nothing else changes.
+ */
 declare function liftPanel(state: PanelsState, id: string): PanelsState;
 /**
  * Open a panel: it shows again where it was, and it is the newest opened and used. A panel placed nowhere goes into
- * a new innermost column on `at.side`, `at.width` wide; without `at` it stays placed nowhere.
+ * a new innermost column on `at.side`, `at.width` wide, or with `at.edge` at the right end of that edge's band (a new
+ * band is `at.height` tall, default `BAND_SIZE.natural`; the layout clamps it); without `at` it stays placed nowhere.
+ * In a tabbed column it becomes the tab that shows, as a drop into the column does.
  */
 declare function open(state: PanelsState, id: string, at?: {
     readonly side: Side;
     readonly width: number;
+} | {
+    readonly edge: Edge;
+    readonly height?: number;
 }): PanelsState;
 /** Close a panel: it isn't shown, keeps its place, and is no longer kept open. */
 declare const close: (state: PanelsState, id: string) => PanelsState;
 /** Focus a panel: it is the newest used; a float comes to the top. */
 declare function focus(state: PanelsState, id: string): PanelsState;
-/** Fold a panel to its title bar by hand, or unfold it (unfolding is a use). */
+/**
+ * Fold a panel to its title bar by hand, or unfold it (unfolding is a use). A band folds as a whole: on a band panel
+ * all its panels go into `folded`, or (when every shown panel of the band is folded) all come out.
+ */
 declare function toggleFold(state: PanelsState, id: string): PanelsState;
-/** Keep a docked panel open (its column gives way last), or stop keeping it. A floating panel isn't kept. */
+/** Keep a docked panel open (its column or band gives way last), or stop keeping it. A floating panel isn't kept. */
 declare function keep(state: PanelsState, id: string, on: boolean): PanelsState;
+/**
+ * Dock a panel in the band on `edge`, at `index` (0 the leftmost; past the end, the rightmost). A new band takes the
+ * panel's natural band height (with `defs`; else `BAND_SIZE.natural`). It shows (a band folded by hand unfolds), it is
+ * the newest used, and it keeps whether it is kept open.
+ */
+declare function dockBand(state: PanelsState, id: string, edge: Edge, index: number, defs?: readonly PanelDef[]): PanelsState;
+/** Store a band's height (the layout clamps it to its panels' limits). Resizing is a use, as for a column. */
+declare function resizeBand(state: PanelsState, edge: Edge, height: number): PanelsState;
 interface DockOptions {
     /** Stack into the column at `index` (at its bottom) instead of making a new column there. */
     readonly into?: boolean;
-    /** A new column's width (default: the width of the column the panel leaves, else 0, which the layout clamps to the minimum). */
+    /**
+     * A new column's width (default: the width of the column the panel leaves, else 0, which the layout clamps to the
+     * minimum; from a band, pass `ownWidth` for its natural width, as the drop targets do).
+     */
     readonly width?: number;
 }
 /**
@@ -183,6 +275,10 @@ interface DockOptions {
  * keeps whether it is kept open.
  */
 declare function dock(state: PanelsState, id: string, side: Side, index: number, options?: DockOptions): PanelsState;
+/** Show a column's panels as tabs (one at a time under a strip), or as a stack again. */
+declare function showTabs(state: PanelsState, side: Side, index: number, on: boolean): PanelsState;
+/** Make a docked panel the one its column shows (its tab), and the newest used. */
+declare function activate(state: PanelsState, id: string): PanelsState;
 /**
  * Float a panel at `rect` (page space; view space when pinned). A float stays pinned or not unless `pinned` says;
  * a docked panel floats unpinned. It shows, it is the newest used and on top, and it is no longer kept open.
@@ -243,17 +339,18 @@ declare function samePlaces(a: PanelsState, b: PanelsState, defs?: readonly Pane
  */
 
 /**
- * Where a panel is, structurally: an open part of a column, a folded title bar (in a column, riding on one, or a
- * folded float), a segment of a rail (the panel itself isn't laid out), or a float.
+ * Where a panel is, structurally: an open part of a column, an open part of a band, a folded title bar (in a column,
+ * riding on one, in a folded band, or a folded float), a segment of a rail (the panel itself isn't laid out), or a
+ * float.
  */
-type PanelKind = "column" | "bar" | "segment" | "float";
+type PanelKind = "column" | "band" | "bar" | "segment" | "float";
 interface PlacedPanel {
     /** Stage px; for a segment, the segment's rect in its rail. */
     readonly rect: Rect;
     readonly kind: PanelKind;
-    /** Columns and rails 0, floats 10 and up (a later float on top). */
+    /** Columns, rails and reserved bands 0, overlay bands 5, floats 10 and up (a later float on top). */
     readonly layer: number;
-    /** In a rail: there is no panel to lay out, only its segment. */
+    /** Not drawn as a panel: in a rail (only its segment shows), or a tab that isn't showing (only its `tab`). */
     readonly hidden: boolean;
     /** Folded by hand (a bar, or a segment of a column folded by hand), or by give-way (a segment). */
     readonly folded: null | "hand" | "auto";
@@ -268,9 +365,36 @@ interface PlacedPanel {
     readonly column?: number;
     /** A riding bar: the index of the column it rides on (`options.fold` "ride"). */
     readonly rides?: number;
+    /** In a tabbed column: its tab's rect in the strip (panel order, equal widths). */
+    readonly tab?: Rect;
     /** A float the clamp moved or resized. */
     readonly clamped?: boolean;
+    /** In a band: its edge and its index in the state's band (left to right). */
+    readonly edge?: Edge;
+    readonly index?: number;
+}
+/** A band as laid out. */
+interface PlacedBand {
+    readonly edge: Edge;
+    /** The band's rect (a bar when folded). */
+    readonly rect: Rect;
+    /** Its stored height clamped to its panels' limits, and those limits. */
+    readonly height: number;
+    readonly min: number;
+    readonly max: number;
+    /** null: open; "hand": its panels folded by hand; "auto": folded by give-way. */
+    readonly folded: null | "hand" | "auto";
+    /** Shrunk by give-way below its height. */
+    readonly shrunk: boolean;
+    /** It holds a kept panel. */
+    readonly kept: boolean;
+    readonly mode: "reserved" | "overlay";
+    readonly span: "between" | "full";
+    /** The shown panels, left to right. */
+    readonly panels: readonly string[];
 }
+/** A reserve's edge. */
+type ReserveEdge = "top" | "right" | "bottom" | "left";
 interface PlacedColumn {
     readonly side: Side;
     /** The column's index in the state. */
@@ -291,6 +415,11 @@ interface PlacedColumn {
     readonly panels: readonly string[];
     /** Riding: the index of the column its bars ride on; its rect is the bars'. */
     readonly rides?: number;
+    /** How it shows its panels (default "stack"). */
+    readonly show?: "stack" | "tabs";
+    /** Tabbed and laid out: its strip of tabs, and the panel it shows. */
+    readonly strip?: Rect;
+    readonly active?: string;
 }
 interface PlacedRail {
     readonly side: Side;
@@ -300,8 +429,8 @@ interface PlacedRail {
         readonly rect: Rect;
     }[];
 }
-type PanelsNoteCode = "column-shrunk" | "column-folded" | "kept-folded" | "pages-under-min" | "float-clamped" | "float-resized";
-/** One note on a layout: a code and its data. */
+type PanelsNoteCode = "column-shrunk" | "column-folded" | "kept-folded" | "section-folded" | "pages-under-min" | "float-clamped" | "float-resized" | "band-shrunk" | "band-folded" | "band-off" | "pages-short";
+/** One note on a layout: a code and its data. `kept-folded` carries `side` and `column` for a column, `edge` for a band. */
 type PanelsNote = {
     readonly code: "column-shrunk";
     readonly side: Side;
@@ -310,7 +439,7 @@ type PanelsNote = {
     readonly from: number;
     readonly to: number;
 } | {
-    readonly code: "column-folded" | "kept-folded";
+    readonly code: "column-folded" | "kept-folded" | "section-folded";
     readonly side: Side;
     readonly column: number;
     readonly items: readonly string[];
@@ -321,6 +450,20 @@ type PanelsNote = {
 } | {
     readonly code: "float-clamped" | "float-resized";
     readonly items: readonly string[];
+} | {
+    readonly code: "band-shrunk";
+    readonly edge: Edge;
+    readonly items: readonly string[];
+    readonly from: number;
+    readonly to: number;
+} | {
+    readonly code: "band-folded" | "kept-folded" | "band-off";
+    readonly edge: Edge;
+    readonly items: readonly string[];
+} | {
+    readonly code: "pages-short";
+    readonly height: number;
+    readonly min: number;
 };
 interface PanelsLayout {
     readonly items: Map<string, PlacedPanel>;
@@ -330,6 +473,10 @@ interface PanelsLayout {
     readonly notes: readonly PanelsNote[];
     /** What is left for the documents. */
     readonly pages: Rect;
+    /** The bands laid out (an enabled edge with shown panels). */
+    readonly bands: Readonly<Partial<Record<Edge, PlacedBand>>>;
+    /** The room kept clear along the pages' edges (an edge with a reserve over 0). */
+    readonly reserved: Readonly<Partial<Record<ReserveEdge, Rect>>>;
 }
 /** The order columns give way in: unkept before kept, then the policy (oldest or newest), outer first, left first. */
 declare function giveWayOrder<C extends {
@@ -363,12 +510,15 @@ interface Target {
  * - `into:<side>:<i>` (2): a column's area: the panel stacks at its bottom.
  * - `rail:<side>` (1): the side's rail, or its outer edge: the panel docks folded.
  * - `float` (3, free): anywhere; it floats where it is let go, kept in the view as the float option says.
+ * - `band:<edge>:<i>` (2), for each edge with a band (`options.bands`): the slots between a band's panels and at both
+ *   ends (the band's area split at its panels' middles). `band:<edge>` (2): an empty enabled edge, a strip `2 × bar`
+ *   tall along it inside the pages' area.
  *
  * A place the panel may not take (its def's `sides` and `floats`, and `allows`) is no target, and neither is its own
  * place (a drop there changes nothing). Targets carry a structured `place`, never words: the consumer names them.
  */
 
-/** Where a drop puts a panel. `index` is a column index in the state with the panel lifted out. */
+/** Where a drop puts a panel. `index` is a column (or band panel) index in the state with the panel lifted out. */
 type PanelPlace = {
     readonly kind: "column";
     readonly side: Side;
@@ -380,6 +530,10 @@ type PanelPlace = {
 } | {
     readonly kind: "rail";
     readonly side: Side;
+} | {
+    readonly kind: "band";
+    readonly edge: Edge;
+    readonly index: number;
 } | {
     readonly kind: "float";
 };
@@ -405,7 +559,10 @@ interface PanelTargetInput {
 /** How far a column band reaches on each side of its line, px; how wide a side's edge takes a rail drop when it has no rail. */
 declare const COLUMN_REACH = 22;
 declare const RAIL_EDGE = 10;
-/** A place's rank in reading order: the left side outer to inner, the right side inner to outer, floating last. */
+/**
+ * A place's rank in reading order: the left side outer to inner, the right side inner to outer, then the top band and
+ * the bottom band left to right, floating last.
+ */
 declare function placeRank(place: PanelPlace): number;
 /** Where a panel is now, as a place (a float, a column of its own, or stacked in one); null when placed nowhere. */
 declare function homePlace(state: PanelsState, id: string): PanelPlace | null;
@@ -451,4 +608,4 @@ interface PanelStopsOptions {
 /** The panel's places in reading order, for the arrow keys and a "Move to" menu (`keyboardStops` calls this). */
 declare function panelStops(targets: readonly PanelTarget[], options?: PanelStopsOptions): PanelStop[];
 
-export { resizeFloat as $, dock as A, float as B, type Clock as C, DEFAULT_PANELS_OPTIONS as D, floatSize as E, FLOAT_HEIGHT as F, type GiveWay as G, focus as H, IDENTITY_VIEW as I, giveWayOrder as J, homePlace as K, keep as L, layoutPanels as M, liftPanel as N, open as O, type PanelsState as P, ownWidth as Q, RAIL_EDGE as R, type Side as S, panelDrop as T, panelStops as U, type View as V, type Where as W, panelTargets as X, pin as Y, placeRank as Z, resizeColumn as _, type PanelDef as a, samePlaces as a0, tick as a1, toPage as a2, toView as a3, toggleFold as a4, whereIs as a5, type Target as a6, COLUMN_REACH as b, type Column as c, type DockOptions as d, FLOAT_MIN as e, type FloatAt as f, type PanelDrop as g, type PanelKind as h, type PanelPlace as i, type PanelStop as j, type PanelStopsOptions as k, type PanelTarget as l, type PanelTargetInput as m, type PanelsLayout as n, type PanelsNote as o, type PanelsNoteCode as p, type PanelsOptions as q, type PanelsStart as r, type PlacedColumn as s, type PlacedPanel as t, type PlacedRail as u, SIDES as v, close as w, columnWidth as x, createPanels as y, defOf as z };
+export { floatSize as $, type PlacedPanel as A, BAND_SIZE as B, type Clock as C, DEFAULT_PANELS_OPTIONS as D, type Edge as E, FLOAT_HEIGHT as F, type GiveWay as G, type PlacedRail as H, IDENTITY_VIEW as I, type Reserve as J, type ReserveEdge as K, SIDES as L, activate as M, bandHeight as N, bandSize as O, type PanelsOptions as P, close as Q, RAIL_EDGE as R, type Side as S, columnWidth as T, createPanels as U, type View as V, type Where as W, defOf as X, dock as Y, dockBand as Z, float as _, type PanelDef as a, focus as a0, giveWayOrder as a1, homePlace as a2, keep as a3, liftPanel as a4, open as a5, ownWidth as a6, panelStops as a7, panelTargets as a8, pin as a9, placeRank as aa, resizeBand as ab, resizeColumn as ac, resizeFloat as ad, samePlaces as ae, showTabs as af, tick as ag, toPage as ah, toView as ai, toggleFold as aj, whereIs as ak, type Target as al, type PanelsState as b, type PanelTargetInput as c, type PanelTarget as d, type PanelDrop as e, type PanelsLayout as f, type Band as g, type BandOption as h, COLUMN_REACH as i, type Column as j, type DockOptions as k, layoutPanels as l, EDGES as m, FLOAT_MIN as n, type FloatAt as o, panelDrop as p, type PanelKind as q, type PanelPlace as r, type PanelStop as s, type PanelStopsOptions as t, type PanelsNote as u, type PanelsNoteCode as v, type PanelsStart as w, type Place as x, type PlacedBand as y, type PlacedColumn as z };

package/dist/targets.d.ts

@@ -1,4 +1,4 @@
-import { a6 as Target, l as PanelTarget, k as PanelStopsOptions, j as PanelStop } from './targets-DqhZf3XZ.js';
+import { al as Target, d as PanelTarget, t as PanelStopsOptions, s as PanelStop } from './targets-CLV69zMw.js';
 import { R as Rect, P as Point, S as Size } from './geometry-mL-GTRti.js';
 import { D as DeskState, g as Layout, a as Construction, O as Options } from './constructions-VDK_mwmz.js';
 import { Place, Arrangement, HostId, HostSpec, GroupSize } from './toolbar.js';

package/dist/targets.js

@@ -38,7 +38,7 @@ import {
 } from "./chunk-WLMJ6JGO.js";
 import {
   panelStops
-} from "./chunk-QR7MGDX6.js";
+} from "./chunk-PJD5HKYX.js";
 import {
   centre,
   overlap,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@n-uf/placement",
-  "version": "26.11.8",
+  "version": "26.11.10",
   "description": "Where things go: desk docks, rails and palettes, panel columns, toolbar groups, and the drop targets for each. Pure state in, rects out. No DOM, no framework, no motion.",
   "keywords": [
     "layout",
@@ -48,6 +48,10 @@
       "types": "./dist/panels.d.ts",
       "default": "./dist/panels.js"
     },
+    "./desk": {
+      "types": "./dist/desk.d.ts",
+      "default": "./dist/desk.js"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {