@terrafirmagreg-team/recipe 0.0.0-stage → 1.2.0

package/src/lib/calc/route/router.ts

@@ -0,0 +1,394 @@
+import PF from 'pathfinding';
+import type { Edge } from '@terrafirmagreg-team/ui/lib/canvas/xyflow';
+import type { FlowPoint } from '@terrafirmagreg-team/ui/types/canvas';
+import { createRectBuckets } from './buckets';
+import {
+  CELL,
+  PAD,
+  cellKey,
+  keyX,
+  keyY,
+  portAnchor,
+  toRect,
+  zRoute,
+  type Rect,
+  type RouteNode,
+} from './geometry';
+import { cellsToPolyline, orthoPoints, simplifyCells } from './polyline';
+
+const WINDOW = 160;
+
+const MAX_CELLS = 200_000;
+
+const STUB = 40;
+
+function stubLength(
+  from: FlowPoint,
+  dir: 1 | -1,
+  skip: Rect[],
+  clear: (x0: number, y0: number, x1: number, y1: number) => Iterable<Rect>,
+): number {
+  let max = STUB;
+  const end = from.x + dir * STUB;
+  const x0 = Math.min(from.x, end) - 1;
+  const x1 = Math.max(from.x, end) + 1;
+  for (const rect of clear(x0, from.y - 1, x1, from.y + 1)) {
+    if (skip.includes(rect)) continue;
+    if (from.y < rect.y - PAD || from.y > rect.y + rect.h + PAD) continue;
+    const edge = dir === 1 ? rect.x - PAD : rect.x + rect.w + PAD;
+    const room = (edge - from.x) * dir;
+    if (room < max) max = Math.max(0, room);
+  }
+  return max;
+}
+
+function growWindow(
+  bounds: { x0: number; y0: number; x1: number; y1: number },
+  query: (x0: number, y0: number, x1: number, y1: number) => Iterable<Rect>,
+  pad: number,
+): void {
+  for (let i = 0; i < 4; i += 1) {
+    let grew = false;
+    for (const rect of query(bounds.x0, bounds.y0, bounds.x1, bounds.y1)) {
+      const rx0 = rect.x - pad;
+      const ry0 = rect.y - pad;
+      const rx1 = rect.x + rect.w + pad;
+      const ry1 = rect.y + rect.h + pad;
+      if (rx0 < bounds.x0) { bounds.x0 = rx0; grew = true; }
+      if (ry0 < bounds.y0) { bounds.y0 = ry0; grew = true; }
+      if (rx1 > bounds.x1) { bounds.x1 = rx1; grew = true; }
+      if (ry1 > bounds.y1) { bounds.y1 = ry1; grew = true; }
+    }
+    if (!grew) break;
+  }
+}
+
+function detourRoute(
+  a: FlowPoint,
+  b: FlowPoint,
+  sa: FlowPoint,
+  sb: FlowPoint,
+  skip: Rect[],
+  query: (x0: number, y0: number, x1: number, y1: number) => Iterable<Rect>,
+): FlowPoint[] {
+  const bounds = {
+    x0: Math.min(sa.x, sb.x),
+    y0: Math.min(sa.y, sb.y),
+    x1: Math.max(sa.x, sb.x),
+    y1: Math.max(sa.y, sb.y),
+  };
+  growWindow(bounds, query, PAD);
+  const laneAt = (off: number): FlowPoint[][] => [
+    [sa, { x: bounds.x1 + off, y: sa.y }, { x: bounds.x1 + off, y: sb.y }, sb],
+    [sa, { x: bounds.x0 - off, y: sa.y }, { x: bounds.x0 - off, y: sb.y }, sb],
+    [sa, { x: sa.x, y: bounds.y0 - off }, { x: sb.x, y: bounds.y0 - off }, sb],
+    [sa, { x: sa.x, y: bounds.y1 + off }, { x: sb.x, y: bounds.y1 + off }, sb],
+  ];
+  const clearLane = (lane: FlowPoint[]): number | null => {
+    let len = 0;
+    for (let i = 0; i + 1 < lane.length; i += 1) {
+      const p = lane[i]!;
+      const q = lane[i + 1]!;
+      len += Math.abs(q.x - p.x) + Math.abs(q.y - p.y);
+      const sx0 = Math.min(p.x, q.x) - 1;
+      const sy0 = Math.min(p.y, q.y) - 1;
+      const sx1 = Math.max(p.x, q.x) + 1;
+      const sy1 = Math.max(p.y, q.y) + 1;
+      for (const rect of query(sx0, sy0, sx1, sy1)) {
+        if (skip.includes(rect)) continue;
+        return null;
+      }
+    }
+    return len;
+  };
+  for (let ring = 0; ring < 6; ring += 1) {
+    const off = CELL * (ring === 0 ? 1 : 2 ** (ring + 1));
+    let best: FlowPoint[] | null = null;
+    let bestLen = Infinity;
+    for (const lane of laneAt(off)) {
+      const len = clearLane(lane);
+      if (len !== null && len < bestLen) {
+        bestLen = len;
+        best = lane;
+      }
+    }
+    if (best) return best;
+    growWindow(bounds, query, PAD);
+  }
+  return zRoute(a, b, sa, sb).slice(1, -1);
+}
+
+type Committed = { keys: number[]; x0: number; y0: number; x1: number; y1: number };
+
+type RouteEdge = Pick<Edge, 'id' | 'source' | 'target'> & {
+  sourceHandle?: string | null;
+  targetHandle?: string | null;
+};
+
+type EdgeState = {
+  points: FlowPoint[];
+  a: FlowPoint;
+  b: FlowPoint;
+  committed?: Committed;
+};
+
+const samePoint = (a: FlowPoint, b: FlowPoint) => a.x === b.x && a.y === b.y;
+
+const targetInput = (edge: RouteEdge) => {
+  const handle = edge.targetHandle;
+  const n = handle?.startsWith('in-') ? Number(handle.slice(3)) : 0;
+  return Number.isFinite(n) ? n : 0;
+};
+
+const sourceOut = (edge: RouteEdge) => {
+  const n = /^out-(\d+)$/.exec(edge.sourceHandle ?? '')?.[1];
+  return n != null && Number.isFinite(Number(n)) ? Number(n) : 0;
+};
+
+export function createCircuitRouter(): (
+  nodes: RouteNode[],
+  edges: RouteEdge[],
+) => Map<string, FlowPoint[]> {
+  let prevEdges = new Map<string, EdgeState>();
+
+  return (nodes, edges) => {
+    const out = new Map<string, FlowPoint[]>();
+    const nextEdges = new Map<string, EdgeState>();
+    if (!edges.length) {
+      prevEdges = nextEdges;
+      return out;
+    }
+
+    const byId = new Map(nodes.map((node) => [node.id, node]));
+    const rects = new Map(nodes.map((node) => [node.id, toRect(node)]));
+    const rectsInWindow = createRectBuckets(rects.values());
+
+    const committed: Committed[] = [];
+    const used = new Set<number>();
+    const pending: {
+      edge: RouteEdge;
+      s: RouteNode;
+      t: RouteNode;
+      a: FlowPoint;
+      b: FlowPoint;
+      dist: number;
+    }[] = [];
+
+    for (const edge of edges) {
+      const s = byId.get(edge.source);
+      const t = byId.get(edge.target);
+      if (!s || !t) continue;
+      const a = portAnchor(s, 'src', sourceOut(edge));
+      const b = portAnchor(t, 'tgt', targetInput(edge));
+      const prev = prevEdges.get(edge.id);
+      if (prev && samePoint(prev.a, a) && samePoint(prev.b, b)) {
+        out.set(edge.id, prev.points);
+        nextEdges.set(edge.id, prev);
+        if (prev.committed) {
+          committed.push(prev.committed);
+          for (const key of prev.committed.keys) used.add(key);
+        }
+        continue;
+      }
+      pending.push({
+        edge,
+        s,
+        t,
+        a,
+        b,
+        dist: Math.abs(a.x - b.x) + Math.abs(a.y - b.y),
+      });
+    }
+
+    pending.sort((x, y) => x.dist - y.dist || x.edge.id.localeCompare(y.edge.id));
+
+    const finder = new PF.AStarFinder({
+      diagonalMovement: PF.DiagonalMovement.Never,
+    });
+
+    for (const job of pending) {
+      const { a, b } = job;
+
+      const gap = b.x - a.x;
+      if (gap > 0 && a.y === b.y) {
+        const points = [a, b];
+        out.set(job.edge.id, points);
+        nextEdges.set(job.edge.id, { points, a, b });
+        continue;
+      }
+
+      const sa = {
+        x: a.x + stubLength(a, 1, [rects.get(job.s.id)!], rectsInWindow),
+        y: a.y,
+      };
+      const sb = {
+        x: b.x - stubLength(b, -1, [rects.get(job.t.id)!], rectsInWindow),
+        y: b.y,
+      };
+      const bounds = {
+        x0: Math.min(sa.x, sb.x) - WINDOW,
+        y0: Math.min(sa.y, sb.y) - WINDOW,
+        x1: Math.max(sa.x, sb.x) + WINDOW,
+        y1: Math.max(sa.y, sb.y) + WINDOW,
+      };
+      growWindow(bounds, rectsInWindow, PAD + CELL);
+      const wx0 = bounds.x0;
+      const wy0 = bounds.y0;
+      const wx1 = bounds.x1;
+      const wy1 = bounds.y1;
+      const ox = Math.floor(wx0 / CELL);
+      const oy = Math.floor(wy0 / CELL);
+      const gw = Math.ceil(wx1 / CELL) - ox + 1;
+      const gh = Math.ceil(wy1 / CELL) - oy + 1;
+
+      let cells: number[][] | null = null;
+      let passGrid: InstanceType<typeof PF.Grid> | null = null;
+      if (gw > 0 && gh > 0 && gw * gh <= MAX_CELLS) {
+        const base = new PF.Grid(gw, gh);
+        for (const rect of rectsInWindow(wx0, wy0, wx1, wy1)) {
+          const rx0 = Math.max(0, Math.floor((rect.x - PAD) / CELL) - ox);
+          const ry0 = Math.max(0, Math.floor((rect.y - PAD) / CELL) - oy);
+          const rx1 = Math.min(
+            gw - 1,
+            Math.ceil((rect.x + rect.w + PAD) / CELL) - ox - 1,
+          );
+          const ry1 = Math.min(
+            gh - 1,
+            Math.ceil((rect.y + rect.h + PAD) / CELL) - oy - 1,
+          );
+          for (let cy = ry0; cy <= ry1; cy += 1) {
+            for (let cx = rx0; cx <= rx1; cx += 1) {
+              base.setWalkableAt(cx, cy, false);
+            }
+          }
+        }
+        const sCell = {
+          x: Math.min(gw - 1, Math.max(0, Math.round(sa.x / CELL) - ox)),
+          y: Math.min(gh - 1, Math.max(0, Math.round(sa.y / CELL) - oy)),
+        };
+        const tCell = {
+          x: Math.min(gw - 1, Math.max(0, Math.round(sb.x / CELL) - ox)),
+          y: Math.min(gh - 1, Math.max(0, Math.round(sb.y / CELL) - oy)),
+        };
+        let best: number[][] | null = null;
+        let bestGrid: InstanceType<typeof PF.Grid> | null = null;
+        for (let pass = 0; pass < 2; pass += 1) {
+          const grid = base.clone();
+          if (pass === 0) {
+            for (const c of committed) {
+              if (
+                c.x1 < ox ||
+                c.x0 > ox + gw - 1 ||
+                c.y1 < oy ||
+                c.y0 > oy + gh - 1
+              ) {
+                continue;
+              }
+              for (const key of c.keys) {
+                const cx = keyX(key) - ox;
+                const cy = keyY(key) - oy;
+                if (cx >= 0 && cx < gw && cy >= 0 && cy < gh) {
+                  grid.setWalkableAt(cx, cy, false);
+                }
+              }
+            }
+          }
+          grid.setWalkableAt(sCell.x, sCell.y, true);
+          grid.setWalkableAt(tCell.x, tCell.y, true);
+          const path = finder.findPath(
+            sCell.x,
+            sCell.y,
+            tCell.x,
+            tCell.y,
+            grid,
+          );
+          if (!path.length) continue;
+          const mapped = path.map(([cx, cy]) => [cx + ox, cy + oy]);
+          if (pass === 1) {
+            if (best && best.length <= mapped.length * 1.34) break;
+            best = mapped;
+            bestGrid = grid;
+            break;
+          }
+          best = mapped;
+          bestGrid = grid;
+        }
+        cells = best;
+        passGrid = bestGrid;
+      }
+
+      if (!cells || !passGrid) {
+        const points = orthoPoints([
+          a,
+          ...detourRoute(
+            a,
+            b,
+            sa,
+            sb,
+            [rects.get(job.s.id)!, rects.get(job.t.id)!],
+            rectsInWindow,
+          ),
+          b,
+        ]);
+        out.set(job.edge.id, points);
+        nextEdges.set(job.edge.id, { points, a, b });
+        continue;
+      }
+
+      const g = passGrid;
+      const simple = simplifyCells(
+        cells,
+        (x, y) =>
+          x - ox >= 0 &&
+          x - ox < gw &&
+          y - oy >= 0 &&
+          y - oy < gh &&
+          g.isWalkableAt(x - ox, y - oy),
+      );
+      const polyline = cellsToPolyline(simple, sa, sb);
+      const points = orthoPoints([a, sa, ...polyline, sb, b]);
+      out.set(job.edge.id, points);
+
+      const keys: number[] = [];
+      let cx0 = Infinity;
+      let cy0 = Infinity;
+      let cx1 = -Infinity;
+      let cy1 = -Infinity;
+      const mark = (cx: number, cy: number) => {
+        keys.push(cellKey(cx, cy));
+        cx0 = Math.min(cx0, cx);
+        cy0 = Math.min(cy0, cy);
+        cx1 = Math.max(cx1, cx);
+        cy1 = Math.max(cy1, cy);
+      };
+      for (let i = 0; i < simple.length - 1; i += 1) {
+        const [fx, fy] = simple[i]!;
+        const [tx, ty] = simple[i + 1]!;
+        const dx = Math.sign(tx - fx);
+        const dy = Math.sign(ty - fy);
+        let cx = fx;
+        let cy = fy;
+        mark(cx, cy);
+        while (cx !== tx || cy !== ty) {
+          cx += dx;
+          cy += dy;
+          mark(cx, cy);
+        }
+      }
+      for (const key of keys) used.add(key);
+      const entry: Committed = {
+        keys,
+        x0: cx0 === Infinity ? 0 : cx0,
+        y0: cy0 === Infinity ? 0 : cy0,
+        x1: cx1 === -Infinity ? 0 : cx1,
+        y1: cy1 === -Infinity ? 0 : cy1,
+      };
+      committed.push(entry);
+      nextEdges.set(job.edge.id, { points, a: job.a, b: job.b, committed: entry });
+    }
+
+    prevEdges = nextEdges;
+    return out;
+  };
+}
+

package/src/lib/calc/scheme.ts

@@ -0,0 +1,226 @@
+import type {
+  CalcCard,
+  CalcKind,
+  CalcMaterial,
+  CalcNode,
+  CalcNodeInput,
+  CalcOutput,
+  CalcRecipe,
+  CalcRecipeSummary,
+  CalcWire,
+  TagResolution,
+} from '@terrafirmagreg-team/recipe/types/calc';
+import { mergeAmounts } from './tree/materials';
+
+export type SchemeContext = {
+  recipeMap: Map<string, CalcRecipe>;
+  getRecipesForItem: (materialId: string, kind: CalcKind) => CalcRecipeSummary[];
+  tagMembers: (tagId: string) => TagResolution | undefined;
+  tagSelections: Record<string, string>;
+  recipesResolved: (id: string) => boolean;
+  deadIds: ReadonlySet<string>;
+};
+
+function outputAmount(
+  recipe: CalcRecipe,
+  materialId: string,
+  kind: CalcKind,
+): number {
+  return recipe.outputs
+    .filter((out) => out.id === materialId && out.kind === kind)
+    .reduce((sum, out) => sum + out.amount * (out.chance ?? 1), 0);
+}
+
+function inputMember(
+  input: CalcRecipe['inputs'][number],
+  ctx: SchemeContext,
+): { id?: string; kind: CalcKind } {
+  if (!input.tagId) return { id: input.id, kind: input.kind };
+  const picked = ctx.tagSelections[input.tagId];
+  const resolution = ctx.tagMembers(input.tagId);
+  const members = resolution?.members ?? [];
+  const memberId =
+    picked && members.includes(picked) ? picked : members[0];
+  return { id: memberId, kind: resolution?.kind ?? input.kind };
+}
+
+export function buildScheme({
+  cards,
+  wires,
+  ctx,
+}: {
+  cards: readonly CalcCard[];
+  wires: readonly CalcWire[];
+  ctx: SchemeContext;
+}): { nodes: CalcNode[]; flows: (number | undefined)[] } {
+  const byId = new Map<string, CalcNode>();
+  const nodes = cards.map((card) => {
+    const availableRecipes = ctx.getRecipesForItem(card.materialId, card.kind);
+    const recipe = card.recipeId
+      ? (ctx.recipeMap.get(card.recipeId) ?? null)
+      : null;
+    const resolved = card.recipeId ? !!recipe : true;
+    const out = recipe
+      ? outputAmount(recipe, card.materialId, card.kind)
+      : 1;
+    const produced = card.crafts * out;
+    const outputs: CalcOutput[] = [];
+    const addOutput = (entry: CalcOutput) => {
+      if (!(entry.amount > 0)) return;
+      const same = outputs.find(
+        (o) => o.id === entry.id && o.kind === entry.kind,
+      );
+      if (same) {
+        same.amount += entry.amount;
+        same.remaining += entry.amount;
+      } else {
+        outputs.push(entry);
+      }
+    };
+    addOutput({
+      id: card.materialId,
+      kind: card.kind,
+      amount: produced,
+      allocated: 0,
+      remaining: produced,
+    });
+    for (const o of recipe?.outputs ?? []) {
+      if (o.id === card.materialId && o.kind === card.kind) continue;
+      addOutput({
+        id: o.id,
+        kind: o.kind,
+        amount: o.amount * card.crafts,
+        chance: o.chance,
+        allocated: 0,
+        remaining: o.amount * card.crafts,
+      });
+    }
+    const node: CalcNode = {
+      id: card.id,
+      materialId: card.materialId,
+      kind: card.kind,
+      crafts: card.crafts,
+      produced,
+      allocated: 0,
+      remaining: produced,
+      outputs,
+      recipe,
+      inputs: (recipe?.inputs ?? []).map((entry) => {
+        const member = inputMember(entry, ctx);
+        return {
+          id: member.id,
+          kind: member.kind,
+          amount: entry.catalyst
+            ? entry.amount
+            : entry.amount * card.crafts,
+          catalyst: entry.catalyst,
+          tagId: entry.tagId,
+          wired: false,
+          covered: 0,
+        } satisfies CalcNodeInput;
+      }),
+      availableRecipes,
+      cycle: false,
+      products: false,
+      loading:
+        !ctx.recipesResolved(card.materialId) ||
+        (card.recipeId ? !resolved && !ctx.deadIds.has(card.recipeId) : false),
+    };
+    byId.set(card.id, node);
+    return node;
+  });
+
+  const flows: (number | undefined)[] = new Array(wires.length);
+  const deg = new Map<string, number>();
+  const adj = new Map<string, string[]>();
+  wires.forEach((wire, wireIndex) => {
+    const src = byId.get(wire.from);
+    const dst = byId.get(wire.to);
+    if (!src || !dst || src === dst) return;
+    const input = dst.inputs[wire.input];
+    const atIndex = src.outputs[wire.out ?? 0];
+    const outIndex =
+      input && atIndex && atIndex.id === input.id && atIndex.kind === input.kind
+        ? (wire.out ?? 0)
+        : input
+          ? src.outputs.findIndex(
+              (o) => o.id === input.id && o.kind === input.kind,
+            )
+          : -1;
+    const srcOut = outIndex >= 0 ? src.outputs[outIndex] : undefined;
+    if (!input || !srcOut) return;
+    if (!input.id) return;
+    input.wired = true;
+    const covered = Math.min(
+      Math.max(srcOut.remaining, 0),
+      input.amount - input.covered,
+      wire.amount ?? Infinity,
+    );
+    input.covered += covered;
+    srcOut.allocated += covered;
+    srcOut.remaining -= covered;
+    if (outIndex === 0) {
+      src.allocated += covered;
+      src.remaining -= covered;
+    }
+    flows[wireIndex] = covered;
+    adj.set(wire.from, [...(adj.get(wire.from) ?? []), wire.to]);
+    deg.set(wire.to, (deg.get(wire.to) ?? 0) + 1);
+  });
+
+  const cyclic = (start: string): boolean => {
+    const seen = new Set<string>();
+    const walk = (id: string): boolean => {
+      for (const next of adj.get(id) ?? []) {
+        if (next === start) return true;
+        if (seen.has(next)) continue;
+        seen.add(next);
+        if (walk(next)) return true;
+      }
+      return false;
+    };
+    return walk(start);
+  };
+  for (const node of nodes) node.cycle = cyclic(node.id);
+
+  for (const node of nodes) {
+    node.products = !(adj.get(node.id)?.length);
+  }
+  return { nodes, flows };
+}
+
+export function schemeSummary(nodes: readonly CalcNode[]) {
+  const raw: CalcMaterial[] = [];
+  const catalysts: CalcMaterial[] = [];
+  const surplus: CalcMaterial[] = [];
+  const products: CalcMaterial[] = [];
+  for (const node of nodes) {
+    for (const input of node.inputs) {
+      if (!input.id) continue;
+      if (input.catalyst) {
+        catalysts.push({ id: input.id, kind: input.kind, amount: input.amount });
+        continue;
+      }
+      const deficit = input.amount - input.covered;
+      if (deficit > 0) raw.push({ id: input.id, kind: input.kind, amount: deficit });
+    }
+    if (!node.recipe && node.produced > 0 && !node.products) {
+      raw.push({ id: node.materialId, kind: node.kind, amount: node.produced });
+    }
+    if (node.products && node.produced > 0) {
+      products.push({ id: node.materialId, kind: node.kind, amount: node.produced });
+    }
+    for (const out of node.outputs.slice(node.products ? 1 : 0)) {
+      if (out.remaining > 0) {
+        surplus.push({ id: out.id, kind: out.kind, amount: out.remaining });
+      }
+    }
+  }
+  return {
+    raw: mergeAmounts(raw),
+    catalysts,
+    remainders: mergeAmounts(surplus),
+    products: mergeAmounts(products),
+  };
+}
+

package/src/lib/calc/storage/entry.ts

@@ -0,0 +1,97 @@
+import type { CalculatorState } from '@terrafirmagreg-team/recipe/types/calc';
+
+const MAX_HISTORY = 20;
+
+export type CalcTreeEntry = {
+  id: string;
+
+  name?: string;
+
+  icon?: { id: string; kind: 'item' | 'fluid' };
+  savedAt: number;
+  state: CalculatorState;
+};
+
+export const EMPTY_ENTRIES: CalcTreeEntry[] = [];
+
+export function newCalcEntry(state: CalculatorState, name?: string): CalcTreeEntry {
+  return {
+    id: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+    name,
+    savedAt: Date.now(),
+    state,
+  };
+}
+
+const isCardRow = (row: unknown): boolean =>
+  !!row &&
+  typeof row === 'object' &&
+  typeof (row as { id?: unknown }).id === 'string' &&
+  typeof (row as { materialId?: unknown }).materialId === 'string' &&
+  ((row as { kind?: unknown }).kind === 'item' ||
+    (row as { kind?: unknown }).kind === 'fluid');
+
+const isWireRow = (row: unknown): boolean =>
+  !!row &&
+  typeof row === 'object' &&
+  typeof (row as { from?: unknown }).from === 'string' &&
+  typeof (row as { to?: unknown }).to === 'string' &&
+  typeof (row as { input?: unknown }).input === 'number';
+
+export function isCalcState(value: unknown): value is CalculatorState {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const row = value as Record<string, unknown>;
+  return (
+    Array.isArray(row.cards) &&
+    row.cards.every(isCardRow) &&
+    Array.isArray(row.wires) &&
+    row.wires.every(isWireRow) &&
+    !!row.tagSelections &&
+    typeof row.tagSelections === 'object'
+  );
+}
+
+export function migrateCalcState(state: CalculatorState): CalculatorState {
+  const cards = Array.isArray(state.cards) ? state.cards.filter(isCardRow) : [];
+  const ids = new Set(cards.map((card) => card.id));
+  return {
+    cards,
+    wires: (Array.isArray(state.wires) ? state.wires.filter(isWireRow) : []).filter(
+      (wire) => ids.has(wire.from) && ids.has(wire.to),
+    ),
+    tagSelections: state.tagSelections,
+  };
+}
+
+function isEntry(value: unknown): value is CalcTreeEntry {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const row = value as Record<string, unknown>;
+  const icon = row.icon as Record<string, unknown> | undefined;
+  return (
+    typeof row.id === 'string' &&
+    typeof row.savedAt === 'number' &&
+    isCalcState(row.state) &&
+    (icon === undefined ||
+      (typeof icon === 'object' &&
+        icon !== null &&
+        typeof icon.id === 'string' &&
+        (icon.kind === 'item' || icon.kind === 'fluid')))
+  );
+}
+
+export const isCalcTabs = (v: unknown): v is CalcTreeEntry[] =>
+  Array.isArray(v) && v.every(isEntry);
+export const isCalcHistory = isCalcTabs;
+
+export function capHistory(entries: CalcTreeEntry[]): CalcTreeEntry[] {
+  const seen = new Set<string>();
+  const out: CalcTreeEntry[] = [];
+  for (const entry of [...entries].sort((a, b) => b.savedAt - a.savedAt)) {
+    if (seen.has(entry.id)) continue;
+    seen.add(entry.id);
+    out.push(entry);
+    if (out.length >= MAX_HISTORY) break;
+  }
+  return out;
+}
+