@pasquelin/panels 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,153 @@
+# Changelog
+
+All notable changes to `@pasquelin/panels`.
+
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] — 2026-09-01
+
+Two changes to the same idea: **what a half shows is resolved when it is drawn, not written down
+once**. That is what lets a project declare its panels conditionally without losing anything, and
+what makes a second view cost one prop.
+
+### Added
+
+- **Views.** `<Panels view="review">` — a named arrangement. Each view keeps the panels it had
+  open to itself; the lengths stay shared, because a column that changed width on the way to
+  another view reads as another window. Omitted, everything lands in one view and nothing about
+  this is visible. The store gains `view`, `views` and `setView`; the prop is controlled.
+- `DEFAULT_VIEW`, the name a project that never passes one lands in.
+- **`components`**, to draw the chassis' own buttons yourself:
+  `<Panels components={{ IconButton: Mine }}>`. The rail's buttons and the close button were the
+  one part of the chassis a project could not repaint, so a tooltip — or a shortcut hint, or a
+  badge — had nowhere to go but a new prop here. Read once, like `storage`.
+- `shownSpecsIn`, `openOf` and the `Arranged` type, for a project building its own frame on the
+  headless core: `shownIn` hands back ids, and every caller was finding the panel again from them.
+
+### Removed
+
+- **`PanelsState.open` and `PanelsState.settled`.** One map, `views`, now holds every
+  arrangement including the one in front, and having an entry in it IS the record of having been
+  settled. Read the view on screen with `openOf(state)`.
+  Keeping the front view apart cost three hand-written merges and a `delete`, and the invariant
+  they upheld was tenable by nobody: a cold start straight onto a view the stored file had never
+  named took it for settled and drew **an empty chassis** — while reaching the same screen from
+  another view worked. One map makes the two paths agree by construction.
+- **`shownIn`, `zoneDraws` and `zoneTakesRoom` take `Arranged`** — `{ registry, view, views }` —
+  where they took `{ registry, open }`. Passing the whole state still works.
+- **`undraggedSizeOf(zone, spec)`** takes the leading panel rather than a registry and an id.
+- **`readLayout` and `writeLayout` carry `LayoutState`**, which is now `{ views, lengths }`. That
+  type was exported, described persistence, and had stopped being true.
+- **`setView` is no longer on `usePanelsActions`.** Inside React the `view` prop is the one path;
+  it remains on the store for a project driving the chassis from outside React.
+
+### Changed
+
+- **A withdrawn panel no longer empties its half.** It falls back to whatever is still declared
+  for that half, and the choice is remembered: declare the panel again and the half is its once
+  more. Before, hiding a panel behind a right, a route or a connection lost the arrangement for
+  good — while an unknown id read back from storage survived as a half that was neither open nor
+  closed. The two cases now answer the same way.
+- **`settle` opens a half without naming a panel.** `ZoneSlots` gains `null` as a third state —
+  the key absent is a closed half, `null` an open one that named nobody, an id a real choice.
+  Only choices are stored, so an untouched half follows your declarations instead of freezing
+  one screen's answer.
+- **`show` on a panel already drawn only focuses it**, rather than writing its name down.
+- **`register` and `unregister` are replaced by `declare(specs)`**, which posts the panels as a
+  list. The list IS the order the rail stacks them in, so a panel that goes and comes back
+  returns to its place instead of to the end.
+- **Stored layouts are at version 2**, holding one entry per view. A version 1 file is read back
+  as the default view — the upgrade costs nobody their layout.
+- **The `view` prop is reconciled on every render**, not on a dependency change. It was
+  controlled only when some unrelated prop happened to change identity, so a `defaultOpen`
+  written inline and one hoisted into a constant gave opposite contracts.
+- **The layout is written only when the arrangements or the lengths actually moved.** The store
+  notifies on every write — a focus, a measure, each `pointermove` of a drag — and each of those
+  used to re-serialise the whole file.
+
+### Fixed
+
+- **A view named after anything on `Object.prototype`** — `constructor`, `toString`, `__proto__` —
+  was taken for settled and drew an empty chassis, then the first click froze the remaining half
+  closed for good. `in` answers for the prototype chain; `Object.hasOwn` does not.
+- **A stored view named `__proto__` was lost, and took the map's prototype with it.** `JSON.parse`
+  makes it an own property, and assigning it on a plain object fires the setter — so a view named
+  `left` would have inherited an arrangement that was not its own. No global pollution, measured.
+- **`setView` and `reset` now settle on the spot.** Reachable only through a render, a view
+  arrived at from outside React — a native menu, a socket — stayed unsettled, and a `reset` asked
+  for by a button inside the chassis left the frame blank until some ancestor happened to
+  re-render. The reset was not written to disk either, so the arrangement being escaped came back
+  on reload.
+- **A project bringing its own `store` was never handed the stored layout**, and overwrote the
+  file on the first write — losing its arrangement on every launch for having built the store
+  itself.
+- **`view` no longer defaults**, so a project that never passes it keeps `setView` for itself. The
+  prop claimed the view on every render, undoing an imperative call at the next unrelated render
+  of some ancestor.
+- **Replacing a `solo` panel no longer closes the half beside it.** When the solo panel led by
+  fallback rather than by choice, showing anything in that zone rebuilt it from nothing.
+- **A zone's divider is re-clamped even when its own length was never dragged.** `resize` and
+  `resplit` write different keys, so parting a column without ever moving its edge left the
+  divider past the bottom of a shrunken column, squeezing the first half to nothing.
+- **A `defaultOpen` half written `undefined`** was drawn on the first launch and closed after a
+  reload: `JSON` drops the key the three-state semantics rests on.
+- **A band drawing nothing still reserved its height.** Two predicates in `clamps.ts` answered
+  "is this zone open?" from the stored arrangement alone, without the registry — so a half left
+  open on a panel the project no longer declares counted as drawing. The strip held 240 px under
+  an empty band, every drag of the top zone was clamped against those 240, and the focus stayed
+  on a zone that had stopped drawing. The question is now asked of `zoneTakesRoom`, which knows
+  what is declared.
+
+## [0.1.1] — 2026-09-01
+
+Everything here is about what leaves the repository. The library itself did not change.
+
+### Fixed
+
+- **The published types were empty.** `dist/index.d.ts` contained `export { }` — the package
+  typechecked in this repository and gave a consumer nothing at all. Declarations are emitted by
+  `tsc` now, not by a bundler plugin.
+- **`@pasquelin/panels/dockview` did not exist.** `exports` promised the subpath and the build
+  never produced it; importing it failed at install time.
+- **The stylesheet weighed 137 kB.** Dockview's own sheet had been merged into it, so every
+  project paid for tabs it may never open. It belongs to Dockview, and the consumer loads it.
+  Now 5.2 kB.
+- **The types named `zustand`.** It is bundled, so no consumer has that package installed and
+  their typecheck failed with TS2307 on a package that advertises no dependencies. The store's
+  surface is declared directly.
+- **The types named a stylesheet path that does not exist**, failing with TS2882 without
+  `skipLibCheck`. The sheet has its own entry and `index.ts` no longer pulls it in.
+
+### Changed
+
+- Document tabs follow IA Studio's design, rule for rule: only the visible tab carries a
+  background, tabs take the surfaces' radius and are parted by a margin, the title yields and the
+  close button never does, and that button is a disc shown under the pointer.
+
+### Added
+
+- `--pnl-surface` (between the panel and its hovered state) and `--pnl-tab`, which the tab strip
+  needs and the chassis had no equivalent for.
+
+## [0.1.0] — 2026-09-01
+
+First release.
+
+- Five zones — `left`, `right`, `top`, `bottomLeft`, `bottomRight` — each cut in two halves, with
+  icon rails on the edges and a centre that is the project's own.
+- Resize by pointer or keyboard, clamped so the centre keeps its floor whether or not anything
+  was ever dragged.
+- The chassis measures its **container**, never the window, so it can live inside a page that
+  already exists.
+- Layout persisted to `localStorage` by default, or to any adapter.
+- Headless underneath: every component is built on hooks that render nothing, and each piece is
+  exported and replaceable on its own.
+- Every visual value is a CSS custom property, declared at zero specificity so a project's
+  palette always wins.
+- Optional `@pasquelin/panels/dockview` entry point for document tabs.
+- No runtime dependencies.
+
+[0.2.0]: https://github.com/pasquelin/panels/releases/tag/v0.2.0
+[0.1.1]: https://github.com/pasquelin/panels/releases/tag/v0.1.1
+[0.1.0]: https://github.com/pasquelin/panels/releases/tag/v0.1.0

package/README.md

@@ -154,6 +154,19 @@ For coding agents: [`llms.txt`](llms.txt) is the mental model, the API and the t
 page; [`llms-full.txt`](llms-full.txt) is every English chapter concatenated. Both ship with the
 package, and `pnpm llms` regenerates the second from the first plus `docs/`.
 
+## Releasing
+
+`main` is production; `develop` is where work lands. A release is a tag:
+
+```bash
+npm version patch      # or minor / major — bumps, commits, tags
+git push --follow-tags
+```
+
+The tag triggers `release.yml`, which checks that it matches `package.json`, replays
+`pnpm validate`, builds, and publishes to npm with a signed provenance attestation — over OIDC,
+with no token anywhere. See [CHANGELOG.md](CHANGELOG.md) for what shipped.
+
 ## Licence
 
 **MIT** — see [LICENSE](LICENSE).

package/dist/components/Panels.d.ts

@@ -1,5 +1,6 @@
 import { type ReactNode } from 'react';
 import { type PanelsProviderProps } from '../core/context';
+import { type PanelsComponents } from '../core/components';
 import { type PanelsLabels } from './labels';
 export type PanelsProps<Id extends string = string> = Omit<PanelsProviderProps<Id>, 'children'> & {
     /** Above the rails, full width. The project's own — the library imposes no chrome. */
@@ -10,6 +11,11 @@ export type PanelsProps<Id extends string = string> = Omit<PanelsProviderProps<I
     railHeader?: ReactNode;
     /** Words the chassis says. English by default; pass your own already translated. */
     labels?: Partial<PanelsLabels>;
+    /**
+     * Pieces the project draws itself — today the `IconButton` the rail and the panel headers use.
+     * Read ONCE, like `storage`: swapping it under a live chassis would re-render every panel.
+     */
+    components?: Partial<PanelsComponents>;
     /**
      * Forces the palette. Left out, the chassis follows the reader's system setting — which is
      * what a project wants until it offers a switch of its own.
@@ -23,7 +29,7 @@ export type PanelsProps<Id extends string = string> = Omit<PanelsProviderProps<I
  * The chassis: icon rails stuck to the edges, rounded panels laid over the gutter, a free centre,
  * and the project's own header and footer around them.
  */
-export declare function Panels<Id extends string = string>({ header, footer, railHeader, labels, theme, className, children, ...provider }: PanelsProps<Id>): import("react").JSX.Element;
+export declare function Panels<Id extends string = string>({ header, footer, railHeader, labels, theme, className, components, children, ...provider }: PanelsProps<Id>): import("react").JSX.Element;
 export declare namespace Panels {
     var Panel: typeof import("./Panel").Panel;
     var Center: typeof import("./Center").Center;

package/dist/core/clamps.d.ts

@@ -1,4 +1,4 @@
-import { type Lengths, type OpenByZone, type Zone } from './types';
+import { type Lengths, type Zone } from './types';
 /** Smallest a zone may be dragged to before it is worth closing instead. */
 export declare const MIN_SIZE = 140;
 /** Room the centre must keep, whatever the side zones ask for. */
@@ -24,22 +24,24 @@ export declare const OPPOSITE: Record<Zone, Zone>;
 export declare function fitZoneSize(size: number, available: number, opposite: number): number;
 /** Same idea one level down: neither half of a zone may swallow the other. */
 export declare function fitSplit(size: number, available: number): number;
-/** True once either half holds something: an empty zone takes no room at all. */
-export declare function isZoneOpen(open: OpenByZone, zone: Zone): boolean;
-/** The band takes its height as soon as EITHER half holds something: the strip is one strip. */
-export declare function isBandOpen(open: OpenByZone): boolean;
 /**
  * The room a zone currently takes, or zero when it draws nothing. Read while clamping the
  * opposite zone: under-report it and the other side may be dragged over room this one is
  * already drawing in, squeezing the centre past its floor.
+ *
+ * 🛑 `takesRoom` is asked rather than read off `open`, and that is not a style: whether a half
+ * draws depends on the REGISTRY too — one holding a panel the project no longer declares draws
+ * whatever is still declared for it, or nothing. This module has no registry, and the two
+ * predicates it used to carry answered `true` for a half that drew nothing at all: a band
+ * reserving 240 px under an empty strip, and every drag of `top` clamped against those 240.
  */
-export declare function sizeOf(lengths: Lengths, open: OpenByZone, zone: Zone, undragged: (zone: Zone) => number): number;
+export declare function sizeOf(lengths: Lengths, zone: Zone, takesRoom: (zone: Zone) => boolean, undragged: (zone: Zone) => number): number;
 /**
  * Every stored length, re-clamped to a container of this size. Sizes are persisted, so a layout
  * set on a wide screen would otherwise overflow a narrow one — pushing the panels under the
  * rails and squeezing the centre to nothing.
  */
-export declare function fitted(lengths: Lengths, open: OpenByZone, width: number, height: number, undragged: (zone: Zone) => number): Lengths;
+export declare function fitted(lengths: Lengths, width: number, height: number, takesRoom: (zone: Zone) => boolean, undragged: (zone: Zone) => number): Lengths;
 /**
  * The two side zones, bounded so the centre keeps its floor — whether or not either was ever
  * dragged.

package/dist/core/components.d.ts

@@ -0,0 +1,18 @@
+import { type ComponentType } from 'react';
+import { type IconButtonProps } from '../components/IconButton';
+/**
+ * The pieces a project may draw itself, where the chassis would otherwise draw them in the
+ * middle of a rail it owns.
+ *
+ * One entry today, and the shape is what lets there be more without breaking anyone. The
+ * library keeps its promise by NOT growing props for what a design system owns — a tooltip, a
+ * shortcut hint, a badge: those live on the button, and the button is replaceable.
+ */
+export type PanelsComponents = {
+    /** The rail's buttons and the panel header's close button. See `IconButtonProps`. */
+    IconButton: ComponentType<IconButtonProps>;
+};
+export declare const ComponentsProvider: import("react").Provider<PanelsComponents>;
+/** Defaults outside a chassis, so `<Rail>` and `<PanelFrame>` stand on their own. */
+export declare function usePanelsComponents(): PanelsComponents;
+export declare function withDefaults(components: Partial<PanelsComponents> | undefined): PanelsComponents;

package/dist/core/context.d.ts

@@ -1,7 +1,7 @@
 import { type ReactNode } from 'react';
 import { type PanelsState, type PanelsStore } from './store';
 import { type LayoutStorage } from './persistence';
-import type { OpenByZone } from './types';
+import { type OpenByZone } from './types';
 export type PanelsProviderProps<Id extends string> = {
     /**
      * A store built by the project. Pass one to drive the chassis from OUTSIDE React — a socket
@@ -13,11 +13,21 @@ export type PanelsProviderProps<Id extends string> = {
     storageKey?: string;
     /** Where the layout is kept. `localStorage` by default; `null` disables persistence. */
     storage?: LayoutStorage | null;
-    /** Which halves start open, overriding "the first panel declared for that half". */
+    /** Which halves start open, overriding "every half something is declared for". */
     defaultOpen?: OpenByZone<Id>;
+    /**
+     * The view in front. Each view keeps its OWN open panels, so two parts of one application can
+     * arrange their columns differently — and find them as they left them on the way back.
+     *
+     * The lengths are shared on purpose: a column that changed width on the way to another view
+     * reads as another window.
+     *
+     * Left out, everything lands in one view and nothing about this is visible.
+     */
+    view?: string;
     children: ReactNode;
 };
-export declare function PanelsProvider<Id extends string = string>({ store, storageKey, storage, defaultOpen, children, }: PanelsProviderProps<Id>): import("react").JSX.Element;
+export declare function PanelsProvider<Id extends string = string>({ store, storageKey, storage, defaultOpen, view, children, }: PanelsProviderProps<Id>): import("react").JSX.Element;
 /** The store this chassis runs on. Throws outside a provider rather than answering nothing. */
 export declare function usePanelsStore<Id extends string = string>(): PanelsStore<Id>;
 /** A slice of the chassis state, subscribed. */

package/dist/core/hooks/useArrangement.d.ts

@@ -1,21 +1,23 @@
-import { type OpenByZone, type PanelSpec, type Zone } from '../types';
+import { type Arranged } from '../store';
+import { type PanelSpec, type Zone } from '../types';
 /**
- * What every reader of `shownIn` and `zoneDraws` needs: the declared panels, and which half of
- * each zone holds which.
+ * What every reader of `shownIn` and `zoneDraws` needs: the declared panels, and the view whose
+ * arrangement they are about.
  *
- * One hook because four of them had written the same pair of selectors and rebuilt the same
- * object by hand — so the shape those two functions expect could not change without touching
- * four files.
+ * One hook because four of them had written the same selectors and rebuilt the same object by
+ * hand — so the shape those functions expect could not change without touching four files.
  */
-export declare function useArrangement<Id extends string = string>(): {
-    registry: PanelSpec<Id>[];
-    open: OpenByZone<Id>;
-};
+export declare function useArrangement<Id extends string = string>(): Arranged<Id>;
 /** What a zone's two halves actually draw — a `solo` panel silences the other. */
 export declare function useShownIn<Id extends string = string>(zone: Zone): {
     primary?: Id;
     secondary?: Id;
 };
+/** The same answer as specs, for a caller that needs more of the panel than its name. */
+export declare function useShownSpecsIn<Id extends string = string>(zone: Zone): {
+    primary?: PanelSpec<Id>;
+    secondary?: PanelSpec<Id>;
+};
 /** Whether a zone draws at all. An empty one takes neither room nor handle. */
 export declare function useZoneDraws<Id extends string = string>(zone: Zone): boolean;
 /**

package/dist/core/persistence.d.ts

@@ -1,4 +1,4 @@
-import { type Lengths, type OpenByZone } from './types';
+import { type LayoutState } from './types';
 /**
  * Where a layout is kept. `localStorage` by default, so the library works the moment it is
  * installed; a project that stores elsewhere — a file, an API, `electron-store` — passes its own.
@@ -13,18 +13,23 @@ export declare const memoryStorage: () => LayoutStorage;
  * a layout that cannot be saved is not a reason to take the application down.
  */
 export declare const browserStorage: () => LayoutStorage;
-/** Bumped when the stored shape stops being one this build can restore. */
-export declare const LAYOUT_VERSION = 1;
+/**
+ * Bumped when the stored shape stops being one this build can restore.
+ *
+ * 2 keeps the views apart. A version 1 file held one arrangement under `open`, which is read
+ * back as the view in front — nobody loses a layout to the upgrade.
+ */
+export declare const LAYOUT_VERSION = 2;
 /**
  * Reads a stored layout back, dropping anything this build cannot make sense of. Returns
  * `undefined` rather than a partial answer: a half-read layout is worse than none, since the
  * project's own defaults are a deliberate arrangement and a corrupted one is not.
+ *
+ * A view the file does not name is simply absent, which is what tells the store to settle it —
+ * so arriving straight at a view nobody has arranged yet opens its halves.
+ *
+ * `view` is the one starting in front, and it only matters for a version 1 file: that one held a
+ * single arrangement, and this says which view inherits it.
  */
-export declare function readLayout<Id extends string>(storage: LayoutStorage, key: string): {
-    open: OpenByZone<Id>;
-    lengths: Lengths;
-} | undefined;
-export declare function writeLayout<Id extends string>(storage: LayoutStorage, key: string, layout: {
-    open: OpenByZone<Id>;
-    lengths: Lengths;
-}): void;
+export declare function readLayout<Id extends string>(storage: LayoutStorage, key: string, view?: string): LayoutState<Id> | undefined;
+export declare function writeLayout<Id extends string>(storage: LayoutStorage, key: string, layout: LayoutState<Id>): void;

package/dist/core/store.d.ts

@@ -1,9 +1,22 @@
-import { type Lengths, type OpenByZone, type PanelSpec, type Slot, type Zone, type ZoneSlots } from './types';
+import { type Lengths, type OpenByZone, type PanelSpec, type LayoutState, type Slot, type Zone, type ZoneSlots } from './types';
 export type PanelsState<Id extends string = string> = {
-    /** Panels declared by the project, in the order they mounted. The rail reads this. */
+    /** Panels declared by the project, in the order it declares them. The rail reads this. */
     registry: PanelSpec<Id>[];
-    open: OpenByZone<Id>;
+    /** Name of the view in front. One view is all a project needs until it has two. */
+    view: string;
+    /**
+     * Every view's arrangement — which half of which zone holds what — the one in front included.
+     * A view is settled once it has an entry here, which is what `settle` writes and `reset`
+     * clears: no second field can then disagree about which views have been opened.
+     */
+    views: Record<string, OpenByZone<Id>>;
     lengths: Lengths;
+    /**
+     * Halves the project wants open whatever the panels say, as last passed to `settle`. Held so
+     * that a view arriving later — or a `reset` — is settled the same way the first one was,
+     * without waiting for React to hand them over again.
+     */
+    defaults?: OpenByZone<Id>;
     /** Last clicked zone: the one whose rail icon gets accented. */
     focusedZone: Zone | null;
     /**
@@ -11,8 +24,6 @@ export type PanelsState<Id extends string = string> = {
      * by itself days later, on an arrangement nobody remembers making, is not a restoration.
      */
     stashed: Partial<Record<Zone, ZoneSlots<Id>>>;
-    /** Whether the opening arrangement has been settled — see `settle`. */
-    settled: boolean;
     /**
      * The room the zones and the centre share, as last measured. Held in the store rather than
      * read per component: every zone has to be bounded against the SAME number, and against what
@@ -22,10 +33,22 @@ export type PanelsState<Id extends string = string> = {
         width: number;
         height: number;
     };
-    register: (spec: PanelSpec<Id>) => void;
-    unregister: (id: Id) => void;
-    /** Opens each untouched half on the first panel declared for it. Runs once. */
+    /**
+     * The panels the project declares, in the order the rail stacks them. Posted whole rather
+     * than one at a time: the list IS the order, so a panel that goes and comes back — behind a
+     * right, a route, a connection — returns to its place instead of to the end.
+     */
+    declare: (specs: PanelSpec<Id>[]) => void;
+    /**
+     * Opens each untouched half of the view in front, naming no panel. Runs once per view — and
+     * remembers `defaults`, so the views that come later open the same way.
+     */
     settle: (defaults?: OpenByZone<Id>) => void;
+    /**
+     * Brings another view forward, putting the one in front away as it stands. Its panels come
+     * back untouched when it returns; the lengths are shared, so no column changes width.
+     */
+    setView: (view: string) => void;
     show: (id: Id) => void;
     close: (zone: Zone, slot: Slot) => void;
     toggle: (id: Id) => void;
@@ -54,17 +77,50 @@ export type PanelsStore<Id extends string = string> = {
     setState: (partial: Partial<PanelsState<Id>> | ((state: PanelsState<Id>) => Partial<PanelsState<Id>>), replace?: false) => void;
     subscribe: (listener: (state: PanelsState<Id>, previous: PanelsState<Id>) => void) => () => void;
 };
+/**
+ * What the readers below need of the state: the declared panels, and the arrangement of the view
+ * in front. Named because five exported functions take it, and `Pick` written out five times was
+ * five places to edit the day the shape moved.
+ */
+export type Arranged<Id extends string = string> = {
+    registry: PanelSpec<Id>[];
+    view: string;
+    /**
+     * 🛑 Only the entry named by `view` is ever read. Written out rather than `Pick`ed off
+     * `PanelsState`, whose own `views` promises EVERY arrangement: a caller handed this one — the
+     * hooks build it from the view on screen alone — would have read that promise and believed it.
+     */
+    views: Record<string, OpenByZone<Id>>;
+};
+/** The arrangement of the view in front. Empty until that view has been settled. */
+export declare function openOf<Id extends string>(state: Arranged<Id>): OpenByZone<Id>;
+/**
+ * Whether that view has been opened before. 🛑 `hasOwn`, never `in`: `'constructor' in {}` is
+ * TRUE, so a view named after anything on `Object.prototype` was taken for settled and its
+ * chassis drew nothing at all.
+ */
+export declare function isSettled<Id extends string>(state: Arranged<Id>, view: string): boolean;
 /**
  * A panel by its id. Exported because four sites had written this same lookup for want of it,
  * and one of them had already drifted on how it treated `undefined`. It is also the single place
  * to change the day the registry stops being a list and becomes a `Map`.
+ *
+ * Takes `null` as well, which is a half open on no panel in particular — see `ZoneSlots`.
  */
-export declare function specOf<Id extends string>(registry: PanelSpec<Id>[], id: Id | undefined): PanelSpec<Id> | undefined;
+export declare function specOf<Id extends string>(registry: PanelSpec<Id>[], id: Id | null | undefined): PanelSpec<Id> | undefined;
 /**
- * Both halves at once, because one can silence the other: a `solo` panel takes the zone WHOLE.
- * Resolved here rather than in each reader, which would contradict it.
+ * The SPECS both halves draw, because one can silence the other: a `solo` panel takes the zone
+ * WHOLE. Resolved here rather than in each reader, which would contradict it.
+ *
+ * Rendering it as specs and not as ids is what stops the lookup happening twice: every caller
+ * wanted the panel, and each was finding it again from the id this used to hand back.
  */
-export declare function shownIn<Id extends string>(state: Pick<PanelsState<Id>, 'registry' | 'open'>, zone: Zone): {
+export declare function shownSpecsIn<Id extends string>(state: Arranged<Id>, zone: Zone): {
+    primary?: PanelSpec<Id>;
+    secondary?: PanelSpec<Id>;
+};
+/** The same answer as ids, for the callers that only name a panel. */
+export declare function shownIn<Id extends string>(state: Arranged<Id>, zone: Zone): {
     primary?: Id;
     secondary?: Id;
 };
@@ -76,23 +132,26 @@ export declare function shownIn<Id extends string>(state: Pick<PanelsState<Id>,
  * half, the top zone was told nothing faced it whenever `bottomRight` happened to be the closed
  * one — and it could then be dragged over the height `bottomLeft` was already drawing in.
  */
-export declare function zoneTakesRoom<Id extends string>(state: Pick<PanelsState<Id>, 'registry' | 'open'>, zone: Zone): boolean;
+export declare function zoneTakesRoom<Id extends string>(state: Arranged<Id>, zone: Zone): boolean;
 /** Whether the zone draws at all — an empty one takes neither room nor handle. */
-export declare function zoneDraws<Id extends string>(state: Pick<PanelsState<Id>, 'registry' | 'open'>, zone: Zone): boolean;
+export declare function zoneDraws<Id extends string>(state: Arranged<Id>, zone: Zone): boolean;
 /**
  * The size a zone opens at, given the panel leading it. A panel may ask for more than the zone's
  * own default — a conversation at 260 wraps every sentence onto three lines.
  *
- * Takes the LEADING panel rather than resolving it: every caller has already asked `shownIn`,
- * and resolving it again here was a second pass over the registry per zone, per drag frame.
+ * Takes the leading SPEC rather than its id: every caller has already asked `shownSpecsIn`, and
+ * finding the panel again here was a second pass over the registry per zone, per drag frame.
  */
-export declare function undraggedSizeOf<Id extends string>(registry: PanelSpec<Id>[], zone: Zone, leading: Id | undefined): number;
+export declare function undraggedSizeOf<Id extends string>(zone: Zone, leading: PanelSpec<Id> | undefined): number;
 export declare const EMPTY_LENGTHS: Lengths;
 export type CreatePanelsStoreOptions<Id extends string> = {
-    /** Restored layout, if any. Halves it names are taken as chosen and `settle` leaves them be. */
-    initial?: Partial<{
-        open: OpenByZone<Id>;
-        lengths: Lengths;
-    }>;
+    /** The view that starts in front. A project with one view never has to name it. */
+    view?: string;
+    /**
+     * Restored layout, if any. A view it carries is taken as settled and `settle` leaves it be — a
+     * view it does NOT carry is settled on first sight, so arriving straight at one nobody has
+     * arranged yet opens its halves rather than drawing an empty frame.
+     */
+    initial?: Partial<LayoutState<Id>>;
 };
 export declare function createPanelsStore<Id extends string = string>(options?: CreatePanelsStoreOptions<Id>): PanelsStore<Id>;

package/dist/core/types.d.ts

@@ -18,6 +18,11 @@ export declare const ZONES: readonly Zone[];
  */
 export type Slot = 'primary' | 'secondary';
 export declare const SLOTS: readonly Slot[];
+/**
+ * The view a project that never names one lands in. A view is a named arrangement: two parts of
+ * one application each keeping their own open panels, sharing the lengths.
+ */
+export declare const DEFAULT_VIEW = "default";
 /** The band's two halves, in the order they are drawn. */
 export declare const BOTTOM_ZONES: readonly Zone[];
 /** Whether the zone is one of the band's halves, which share a height and a resize handle. */
@@ -64,8 +69,15 @@ export type PanelSpec<Id extends string = string> = {
     /** Takes the zone WHOLE: shown, the other half draws nothing. `primary` only. */
     solo?: boolean;
 };
-/** Which panel each half of each zone currently shows. Absent means the half is closed. */
-export type ZoneSlots<Id extends string = string> = Partial<Record<Slot, Id>>;
+/**
+ * Which panel each half of each zone currently shows. Three states, not two: the key absent is
+ * a CLOSED half, `null` an open one that has named no panel, an id the panel someone chose.
+ *
+ * That middle state is what lets a project change the panels it declares without the halves
+ * following: an unnamed half draws whatever is declared first for it, resolved at render — see
+ * `shownIn`. Stored, it also keeps the arrangement honest, since only a real choice is written.
+ */
+export type ZoneSlots<Id extends string = string> = Partial<Record<Slot, Id | null>>;
 export type OpenByZone<Id extends string = string> = Partial<Record<Zone, ZoneSlots<Id>>>;
 export type SizesByZone = Partial<Record<Zone, number>>;
 /**
@@ -81,8 +93,11 @@ export type Lengths = {
      */
     bandSplit?: number;
 };
-/** The layout as it is stored and restored. This is the whole of what persistence carries. */
+/**
+ * The layout as it is stored and restored. This is the whole of what persistence carries: one
+ * arrangement per view, and the lengths, which every view shares.
+ */
 export type LayoutState<Id extends string = string> = {
-    open: OpenByZone<Id>;
+    views: Record<string, OpenByZone<Id>>;
     lengths: Lengths;
 };