@synnaxlabs/client 0.56.2 → 0.57.0

package/src/panel/actions.gen.ts

@@ -0,0 +1,267 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+// Code generated by Oracle. DO NOT EDIT.
+import { spatial, zod } from "@synnaxlabs/x";
+import { type Draft } from "immer";
+import { z } from "zod";
+
+import { actions } from "@/actions";
+import { ontology } from "@/ontology";
+import { keyZ, type Panel, panelZ, tabKeyZ, tabZ, viewZ } from "@/panel/types.gen";
+
+/**
+ * Create replaces the document with the given created state. Emitted by the Core on
+ * create so remote caches ingest new documents; clients never dispatch it.
+ */
+export const createPayloadZ = z.object({
+  panel: panelZ,
+});
+
+export type CreatePayload = z.infer<typeof createPayloadZ>;
+
+/** Rename renames the panel. */
+export const renamePayloadZ = z.object({
+  name: z.string(),
+});
+
+export type RenamePayload = z.infer<typeof renamePayloadZ>;
+
+/**
+ * InsertTabs inserts tabs into a leaf in order, starting at the given index and
+ * appending when index is absent or past the leaf's end. The destination leaf is
+ * resolved from target_tab (the leaf holding that tab) when set, otherwise from the
+ * target_leaf path-derived key, otherwise the first leaf in traversal order. Both are
+ * hints: a target that no longer resolves to a leaf falls back to the first leaf
+ * instead of failing, so a placement invalidated between the gesture and the dispatch
+ * still opens the tabs. The fallback drops location too, leaving a leaf the caller
+ * never pointed at unsplit. When location is an edge, the resolved leaf is split once
+ * at that location and every tab is inserted into the new empty leaf; a center location
+ * places the tabs directly in the resolved leaf, equivalent to absent. The split is
+ * deferred to the first tab that lands, so a batch whose every tab is skipped leaves no
+ * empty pane behind. A tab whose key is already in the tree has its content refreshed
+ * and keeps its position unless the payload carries an explicit placement, in which
+ * case it is relocated with the rest. Inserting a resource tab whose resource already
+ * backs a different tab is skipped, as is a view tab of a type already backing a tab
+ * when singleton is set: each may back at most one tab per panel, and callers select
+ * the existing tab instead. Skipping one tab does not stop the others.
+ */
+export const insertTabsPayloadZ = z.object({
+  tabs: tabZ.array().default(() => []),
+  targetLeaf: z.int32().optional(),
+  targetTab: tabKeyZ.optional(),
+  index: z.int32().optional(),
+  location: spatial.locationZ.optional(),
+  singleton: z.boolean().optional(),
+});
+
+export type InsertTabsPayload = z.infer<typeof insertTabsPayloadZ>;
+
+/**
+ * RemoveTab removes the tab with the given key. If the containing leaf becomes empty
+ * and has a sibling, the reducer collapses the parent split.
+ */
+export const removeTabPayloadZ = z.object({
+  key: tabKeyZ,
+});
+
+export type RemoveTabPayload = z.infer<typeof removeTabPayloadZ>;
+
+/**
+ * MoveTab moves a tab to a position within the panel. When location is an edge, the
+ * target leaf is first split at that location and the tab moves into the new empty
+ * leaf; moving a leaf's only tab to an edge of its own leaf is a no-op. A center
+ * location places the tab directly in the target leaf, equivalent to absent.
+ * Cross-panel moves are RemoveTab on the source plus InsertTabs on the destination (two
+ * dispatches; not atomic).
+ */
+export const moveTabPayloadZ = z.object({
+  key: tabKeyZ,
+  targetLeaf: z.int32(),
+  index: z.int32().optional(),
+  location: spatial.locationZ.optional(),
+});
+
+export type MoveTabPayload = z.infer<typeof moveTabPayloadZ>;
+
+/**
+ * SplitTab splits the tab with the given key off its leaf into a new sibling pane,
+ * moving the tab into it. direction x places the new pane to the right, y to the
+ * bottom. The tab must share its leaf with at least one other tab; splitting the only
+ * tab in a leaf is a no-op.
+ */
+export const splitTabPayloadZ = z.object({
+  key: tabKeyZ,
+  direction: spatial.directionZ,
+});
+
+export type SplitTabPayload = z.infer<typeof splitTabPayloadZ>;
+
+/** ResizeSplit adjusts the size ratio of a split node. size in [0, 1]. */
+export const resizeSplitPayloadZ = z.object({
+  split: z.int32(),
+  size: spatial.decimalZ,
+});
+
+export type ResizeSplitPayload = z.infer<typeof resizeSplitPayloadZ>;
+
+/**
+ * SetTabResource sets the visualization resource displayed by the tab with the given
+ * key, swapping it in place without changing the tab's identity or position. Clears any
+ * view set on the tab. A no-op when the resource already backs another tab in the
+ * panel. Used to fill a freshly inserted selector tab once the user picks a
+ * visualization.
+ */
+export const setTabResourcePayloadZ = z.object({
+  key: tabKeyZ,
+  resource: ontology.idZ,
+});
+
+export type SetTabResourcePayload = z.infer<typeof setTabResourcePayloadZ>;
+
+/**
+ * SetTabView sets the inline view displayed by the tab with the given key, swapping it
+ * in place without changing the tab's identity or position. Clears any resource set on
+ * the tab.
+ */
+export const setTabViewPayloadZ = z.object({
+  key: tabKeyZ,
+  view: viewZ,
+});
+
+export type SetTabViewPayload = z.infer<typeof setTabViewPayloadZ>;
+
+export const actionZ = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("create"), create: createPayloadZ }),
+  z.object({ type: z.literal("rename"), rename: renamePayloadZ }),
+  z.object({ type: z.literal("insert_tabs"), insertTabs: insertTabsPayloadZ }),
+  z.object({ type: z.literal("remove_tab"), removeTab: removeTabPayloadZ }),
+  z.object({ type: z.literal("move_tab"), moveTab: moveTabPayloadZ }),
+  z.object({ type: z.literal("split_tab"), splitTab: splitTabPayloadZ }),
+  z.object({ type: z.literal("resize_split"), resizeSplit: resizeSplitPayloadZ }),
+  z.object({
+    type: z.literal("set_tab_resource"),
+    setTabResource: setTabResourcePayloadZ,
+  }),
+  z.object({ type: z.literal("set_tab_view"), setTabView: setTabViewPayloadZ }),
+]);
+
+export type Action = z.infer<typeof actionZ>;
+
+export const create = (payload: z.input<typeof createPayloadZ>): Action => ({
+  type: "create",
+  create: zod.parse(createPayloadZ, payload, {
+    label: "panel create action payload",
+  }),
+});
+
+export const rename = (payload: z.input<typeof renamePayloadZ>): Action => ({
+  type: "rename",
+  rename: zod.parse(renamePayloadZ, payload, {
+    label: "panel rename action payload",
+  }),
+});
+
+export const insertTabs = (payload: z.input<typeof insertTabsPayloadZ>): Action => ({
+  type: "insert_tabs",
+  insertTabs: zod.parse(insertTabsPayloadZ, payload, {
+    label: "panel insert_tabs action payload",
+  }),
+});
+
+export const removeTab = (payload: z.input<typeof removeTabPayloadZ>): Action => ({
+  type: "remove_tab",
+  removeTab: zod.parse(removeTabPayloadZ, payload, {
+    label: "panel remove_tab action payload",
+  }),
+});
+
+export const moveTab = (payload: z.input<typeof moveTabPayloadZ>): Action => ({
+  type: "move_tab",
+  moveTab: zod.parse(moveTabPayloadZ, payload, {
+    label: "panel move_tab action payload",
+  }),
+});
+
+export const splitTab = (payload: z.input<typeof splitTabPayloadZ>): Action => ({
+  type: "split_tab",
+  splitTab: zod.parse(splitTabPayloadZ, payload, {
+    label: "panel split_tab action payload",
+  }),
+});
+
+export const resizeSplit = (payload: z.input<typeof resizeSplitPayloadZ>): Action => ({
+  type: "resize_split",
+  resizeSplit: zod.parse(resizeSplitPayloadZ, payload, {
+    label: "panel resize_split action payload",
+  }),
+});
+
+export const setTabResource = (
+  payload: z.input<typeof setTabResourcePayloadZ>,
+): Action => ({
+  type: "set_tab_resource",
+  setTabResource: zod.parse(setTabResourcePayloadZ, payload, {
+    label: "panel set_tab_resource action payload",
+  }),
+});
+
+export const setTabView = (payload: z.input<typeof setTabViewPayloadZ>): Action => ({
+  type: "set_tab_view",
+  setTabView: zod.parse(setTabViewPayloadZ, payload, {
+    label: "panel set_tab_view action payload",
+  }),
+});
+
+export type HandlerResult = actions.HandlerResult<Action>;
+
+export type ReduceAllResult = actions.ReduceAllResult<Panel, Action>;
+
+export interface Handlers {
+  create: (state: Draft<Panel>, payload: CreatePayload) => HandlerResult;
+  rename: (state: Draft<Panel>, payload: RenamePayload) => HandlerResult;
+  insertTabs: (state: Draft<Panel>, payload: InsertTabsPayload) => HandlerResult;
+  removeTab: (state: Draft<Panel>, payload: RemoveTabPayload) => HandlerResult;
+  moveTab: (state: Draft<Panel>, payload: MoveTabPayload) => HandlerResult;
+  splitTab: (state: Draft<Panel>, payload: SplitTabPayload) => HandlerResult;
+  resizeSplit: (state: Draft<Panel>, payload: ResizeSplitPayload) => HandlerResult;
+  setTabResource: (
+    state: Draft<Panel>,
+    payload: SetTabResourcePayload,
+  ) => HandlerResult;
+  setTabView: (state: Draft<Panel>, payload: SetTabViewPayload) => HandlerResult;
+}
+
+export const createReduceAll = (handlers: Handlers) =>
+  actions.createReduceAll<Panel, Action>((state, action) => {
+    switch (action.type) {
+      case "create":
+        return handlers.create(state, action.create);
+      case "rename":
+        return handlers.rename(state, action.rename);
+      case "insert_tabs":
+        return handlers.insertTabs(state, action.insertTabs);
+      case "remove_tab":
+        return handlers.removeTab(state, action.removeTab);
+      case "move_tab":
+        return handlers.moveTab(state, action.moveTab);
+      case "split_tab":
+        return handlers.splitTab(state, action.splitTab);
+      case "resize_split":
+        return handlers.resizeSplit(state, action.resizeSplit);
+      case "set_tab_resource":
+        return handlers.setTabResource(state, action.setTabResource);
+      case "set_tab_view":
+        return handlers.setTabView(state, action.setTabView);
+    }
+  });
+
+export const scopedActionZ = actions.scopedZ(keyZ, actionZ);
+
+export const dispatchReqZ = actions.dispatchReqZ(keyZ, actionZ);

package/src/panel/actions.ts

@@ -0,0 +1,357 @@
+// Copyright 2026 Synnax Labs, Inc.
+//
+// Use of this software is governed by the Business Source License included in the file
+// licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with the Business Source
+// License, use of this software will be governed by the Apache License, Version 2.0,
+// included in the file licenses/APL.txt.
+
+import { type spatial } from "@synnaxlabs/x";
+import { type Draft } from "immer";
+
+import {
+  type Action,
+  createReduceAll,
+  type HandlerResult,
+  type Handlers,
+  type InsertTabsPayload,
+} from "@/panel/actions.gen";
+import {
+  findNode,
+  findTab,
+  findTabByResource,
+  findTabByType,
+  firstLeafPath,
+  ROOT_NODE_KEY,
+  tabLeafPath,
+} from "@/panel/tree";
+import { type LeafNode, type Node, type Panel, type Tab } from "@/panel/types.gen";
+
+const NO_OP: HandlerResult = { inverse: [], targets: [] };
+
+const walkLeaf = (root: Draft<Node>, pathKey: number): Draft<LeafNode> | null => {
+  const n = findNode(root, pathKey);
+  if (n == null || n.variant !== "leaf") return null;
+  return n;
+};
+
+// replaceNodeAt swaps the node at the given path key for next, assigning through
+// the parent split (or the panel root for ROOT_PATH). Returns false when the
+// path does not resolve to a node.
+const replaceNodeAt = (state: Draft<Panel>, pathKey: number, next: Node): boolean => {
+  if (pathKey === ROOT_NODE_KEY) {
+    state.root = next;
+    return true;
+  }
+  const parent = findNode(state.root, pathKey >> 1);
+  if (parent == null || parent.variant !== "split") return false;
+  if ((pathKey & 1) === 1) parent.last = next;
+  else parent.first = next;
+  return true;
+};
+
+// removeTab mirrors removeTab in core/pkg/service/panel/tree.go, removing a tab
+// and leaving any emptied leaf in place. Collapsing empty leaves is the caller's
+// responsibility (collapseEmptyLeaves), deferred so that a split-then-move
+// sequence (MoveTab with an edge location, or SplitTab) can target the freshly
+// created empty sibling before the tree is tidied.
+const removeTab = (n: Draft<Node>, key: string): Tab | null => {
+  if (n.variant === "leaf") {
+    const idx = n.tabs.findIndex((t) => t.key === key);
+    if (idx < 0) return null;
+    const [removed] = n.tabs.splice(idx, 1);
+    return removed ?? null;
+  }
+  return removeTab(n.first, key) ?? removeTab(n.last, key);
+};
+
+const isEmptyLeaf = (n: Draft<Node>): boolean =>
+  n.variant === "leaf" && n.tabs.length === 0;
+
+// collapseEmptyLeaves mirrors collapseEmptyLeaves in core/pkg/service/panel/tree.go,
+// rewriting the tree bottom-up: every split with exactly one empty-leaf side is
+// replaced by its surviving sibling subtree.
+const collapseEmptyLeaves = (state: Draft<Panel>): void => {
+  state.root = collapseNode(state.root);
+};
+
+const collapseNode = (n: Draft<Node>): Draft<Node> => {
+  if (n.variant !== "split") return n;
+  n.first = collapseNode(n.first);
+  n.last = collapseNode(n.last);
+  const firstEmpty = isEmptyLeaf(n.first);
+  const lastEmpty = isEmptyLeaf(n.last);
+  if (firstEmpty && !lastEmpty) return n.last;
+  if (lastEmpty && !firstEmpty) return n.first;
+  return n;
+};
+
+// directionAndSideForLocation maps a spatial.Location onto the (direction, side)
+// pair that places a new empty leaf on that side of the original. Returns null
+// for locations that do not divide the area in two (e.g., "center").
+const directionAndSideForLocation = (
+  loc: spatial.Location,
+): { direction: spatial.Direction; side: spatial.Order } | null => {
+  switch (loc) {
+    case "left":
+      return { direction: "x", side: "first" };
+    case "right":
+      return { direction: "x", side: "last" };
+    case "top":
+      return { direction: "y", side: "first" };
+    case "bottom":
+      return { direction: "y", side: "last" };
+    default:
+      return null;
+  }
+};
+
+// splitLeafAt mirrors splitLeafAt + splitLeafForPlacement in
+// core/pkg/service/panel/tree.go, replacing the leaf at the given path with a
+// split holding the original leaf and a new empty sibling on the given side.
+// Returns the path key of the new empty leaf, or null when the path does not
+// resolve to a leaf or the location cannot produce a split.
+const splitLeafAt = (
+  state: Draft<Panel>,
+  leafPath: number,
+  loc: spatial.Location,
+  size: number,
+): number | null => {
+  const node = findNode(state.root, leafPath);
+  if (node == null || node.variant !== "leaf") return null;
+  const ds = directionAndSideForLocation(loc);
+  if (ds == null) return null;
+  const empty: Node = { variant: "leaf", tabs: [] };
+  const split: Node = {
+    variant: "split",
+    direction: ds.direction,
+    size,
+    first: ds.side === "first" ? empty : node,
+    last: ds.side === "first" ? node : empty,
+  };
+  if (!replaceNodeAt(state, leafPath, split)) return null;
+  return ds.side === "first" ? leafPath * 2 : leafPath * 2 + 1;
+};
+
+// replaceTab swaps the tab with the given key for next in place, keeping its
+// position within its leaf. Returns false when no tab matches the key.
+const replaceTab = (n: Draft<Node>, key: string, next: Tab): boolean => {
+  if (n.variant === "leaf") {
+    const idx = n.tabs.findIndex((t) => t.key === key);
+    if (idx < 0) return false;
+    n.tabs[idx] = next;
+    return true;
+  }
+  return replaceTab(n.first, key, next) || replaceTab(n.last, key, next);
+};
+
+// resolveTargetLeaf resolves the destination leaf from the payload's addressing
+// hints, in priority order: the leaf holding targetTab, the targetLeaf path key,
+// then the first leaf in traversal order. `stale` reports that a hint was given and
+// no longer resolves, which drops the location along with it: the tabs still land,
+// but a leaf the caller never pointed at is not split.
+const resolveTargetLeaf = (
+  root: Draft<Node>,
+  payload: InsertTabsPayload,
+): { leaf: number | undefined; stale: boolean } => {
+  const { targetTab, targetLeaf } = payload;
+  if (targetTab != null) {
+    const path = tabLeafPath(root, targetTab);
+    if (path != null) return { leaf: path, stale: false };
+  }
+  if (targetLeaf != null && findNode(root, targetLeaf)?.variant === "leaf")
+    return { leaf: targetLeaf, stale: false };
+  return {
+    leaf: firstLeafPath(root),
+    stale: targetTab != null || targetLeaf != null,
+  };
+};
+
+const handlers: Handlers = {
+  create: (state, payload) => {
+    Object.assign(state, payload.panel);
+    return { inverse: [], targets: [payload.panel.key] };
+  },
+
+  rename: (state, payload) => {
+    state.name = payload.name;
+    return { inverse: [], targets: [state.key] };
+  },
+
+  // insertTabs upserts each tab in order into one destination leaf. A tab whose key is
+  // already in the tree always has its content refreshed; it keeps its current position
+  // unless the caller gives an explicit placement (targetTab, targetLeaf, location, or
+  // index), in which case it is relocated with the rest. A tab that would put a second
+  // tab behind the same resource, or a second singleton view behind the same type, is
+  // skipped; the rest of the batch still lands, and callers select the existing tab
+  // instead. Mirrors InsertTabsPayload.Handle in core/pkg/service/panel/actions.go.
+  insertTabs: (state, payload) => {
+    const placementGiven =
+      payload.targetTab != null ||
+      payload.targetLeaf != null ||
+      payload.location != null ||
+      payload.index != null;
+    const resolved = resolveTargetLeaf(state.root, payload);
+    let targetLeaf = resolved.leaf;
+    if (targetLeaf == null) return NO_OP;
+    // The edge split is deferred to the first tab that actually lands, so a batch
+    // whose every tab is a duplicate leaves no empty pane behind.
+    let pendingSplit =
+      !resolved.stale && payload.location != null && payload.location !== "center"
+        ? payload.location
+        : undefined;
+    let index = payload.index;
+    const targets: string[] = [];
+    for (const tab of payload.tabs) {
+      if (tab.variant === "resource") {
+        const existing = findTabByResource(state.root, tab.resource);
+        if (existing != null && existing.key !== tab.key) continue;
+      }
+      if (payload.singleton && tab.variant === "view") {
+        const existing = findTabByType(state.root, tab.type);
+        if (existing != null && existing.key !== tab.key) continue;
+      }
+      const exists = findTab(state.root, tab.key) != null;
+      if (exists && !placementGiven) {
+        replaceTab(state.root, tab.key, tab);
+        targets.push(tab.key);
+        continue;
+      }
+      if (pendingSplit != null) {
+        targetLeaf = splitLeafAt(state, targetLeaf, pendingSplit, 0.5) ?? targetLeaf;
+        pendingSplit = undefined;
+      }
+      const leaf = walkLeaf(state.root, targetLeaf);
+      if (leaf == null) break;
+      if (exists) removeTab(state.root, tab.key);
+      // An index past the leaf's end is a drop position invalidated between the
+      // gesture and the dispatch. It clamps to the end, as moveTab does.
+      const at =
+        index != null && index >= 0 && index <= leaf.tabs.length
+          ? index
+          : leaf.tabs.length;
+      leaf.tabs.splice(at, 0, tab);
+      if (index != null) index = at + 1;
+      targets.push(tab.key);
+    }
+    if (targets.length === 0) return NO_OP;
+    collapseEmptyLeaves(state);
+    return { inverse: [], targets };
+  },
+
+  removeTab: (state, payload) => {
+    const removed = removeTab(state.root, payload.key);
+    if (removed == null) return NO_OP;
+    collapseEmptyLeaves(state);
+    return { inverse: [], targets: [payload.key] };
+  },
+
+  // The target leaf is resolved before the remove, and empty-leaf collapse is
+  // deferred until after the insert, so the destination may be a leaf the
+  // source's removal would otherwise collapse away (e.g. the empty sibling
+  // created by the preceding edge split).
+  moveTab: (state, payload) => {
+    const srcLeaf = tabLeafPath(state.root, payload.key);
+    const srcNode = srcLeaf != null ? findNode(state.root, srcLeaf) : undefined;
+    const srcIdx =
+      srcNode?.variant === "leaf"
+        ? srcNode.tabs.findIndex((t) => t.key === payload.key)
+        : -1;
+    let targetLeaf = payload.targetLeaf;
+    if (payload.location != null && payload.location !== "center") {
+      const current = walkLeaf(state.root, targetLeaf);
+      if (current == null) return NO_OP;
+      // Moving a leaf's only tab to an edge of its own leaf is degenerate: the
+      // result would be the tab beside an empty pane.
+      if (current.tabs.length === 1 && current.tabs[0].key === payload.key)
+        return NO_OP;
+      const placed = splitLeafAt(state, targetLeaf, payload.location, 0.5);
+      if (placed == null) return NO_OP;
+      targetLeaf = placed;
+    }
+    const target = walkLeaf(state.root, targetLeaf);
+    if (target == null) return NO_OP;
+    const removed = removeTab(state.root, payload.key);
+    if (removed == null) return NO_OP;
+    let idx = payload.index ?? target.tabs.length;
+    // The index counts the moved tab as still present, so a same-leaf move
+    // decrements it past the tab's own slot to stay valid after the remove.
+    if (payload.index != null && srcLeaf === targetLeaf && srcIdx < idx) idx--;
+    if (idx < 0 || idx > target.tabs.length) target.tabs.push(removed);
+    else target.tabs.splice(idx, 0, removed);
+    collapseEmptyLeaves(state);
+    return { inverse: [], targets: [payload.key] };
+  },
+
+  // splitTab resolves the tab's own leaf, splits it on the direction-mapped edge (x ->
+  // right, y -> bottom), and moves the tab into the new sibling pane. A leaf holding a
+  // single tab is a no-op (the result would be the tab beside an empty pane).
+  splitTab: (state, payload) => {
+    const leafPath = tabLeafPath(state.root, payload.key);
+    if (leafPath == null) return NO_OP;
+    const source = walkLeaf(state.root, leafPath);
+    if (source == null || source.tabs.length < 2) return NO_OP;
+    const location = payload.direction === "y" ? "bottom" : "right";
+    const placed = splitLeafAt(state, leafPath, location, 0.5);
+    if (placed == null) return NO_OP;
+    const removed = removeTab(state.root, payload.key);
+    if (removed == null) return NO_OP;
+    const target = walkLeaf(state.root, placed);
+    if (target == null) return NO_OP;
+    target.tabs.splice(0, 0, removed);
+    collapseEmptyLeaves(state);
+    return { inverse: [], targets: [payload.key] };
+  },
+
+  resizeSplit: (state, payload) => {
+    const node = findNode(state.root, payload.split);
+    if (node == null || node.variant !== "split") return NO_OP;
+    // An equal size must not touch the draft: the dispatch substrate detects
+    // no-op vectors by reference equality and skips the server send.
+    if (node.size === payload.size) return NO_OP;
+    node.size = payload.size;
+    return { inverse: [], targets: [String(payload.split)] };
+  },
+
+  // setTabResource swaps the tab's content to the resource in place, clearing any view.
+  // A no-op when the resource already backs a different tab: a resource may back at
+  // most one tab per panel, and callers select the existing tab instead.
+  setTabResource: (state, payload) => {
+    const existing = findTabByResource(state.root, payload.resource);
+    if (existing != null && existing.key !== payload.key) return NO_OP;
+    const next: Tab = {
+      variant: "resource",
+      key: payload.key,
+      resource: payload.resource,
+    };
+    if (!replaceTab(state.root, payload.key, next)) return NO_OP;
+    return { inverse: [], targets: [payload.key] };
+  },
+
+  // setTabView swaps the tab's content to the inline view in place, clearing
+  // any resource.
+  setTabView: (state, payload) => {
+    const next: Tab = { variant: "view", key: payload.key, ...payload.view };
+    if (!replaceTab(state.root, payload.key, next)) return NO_OP;
+    return { inverse: [], targets: [payload.key] };
+  },
+};
+
+export const reduceAll = createReduceAll(handlers);
+
+// createOf hands the dispatch controller the document carried by a create
+// action so frames for never-cached documents ingest instead of drop.
+export const createOf = (action: Action) =>
+  action.type === "create" ? action.create.panel : undefined;
+
+export const kindOf = (actions: Action[]): string => {
+  if (actions.length === 0) return "default";
+  // Drag-resize streams ResizeSplit; coalesce them into a single undoable per
+  // gesture so one ⌘Z reverses the entire drag.
+  if (actions.every((a) => a.type === "resize_split")) return "resize";
+  // Same for cross-leaf drags that produce a stream of MoveTab.
+  if (actions.every((a) => a.type === "move_tab")) return "move";
+  if (actions.length === 1) return actions[0].type;
+  return "transaction";
+};