@statelyai/layout 0.2.0 → 0.3.0

package/src/routing/model.ts

@@ -0,0 +1,218 @@
+import type { GraphEdge } from "@statelyai/graph";
+import { PersistentMap } from "./persistent";
+import { SpatialIndex } from "./spatial";
+import type { Route, RouteBounds, RoutePoint, RoutingSettings, RouteSide } from "./types";
+export interface NodeGeometry {
+  readonly id: string;
+  readonly parentId?: string | null;
+  readonly x?: number;
+  readonly y?: number;
+  readonly width?: number;
+  readonly height?: number;
+  readonly ports?: readonly {
+    readonly name: string;
+    readonly x?: number;
+    readonly y?: number;
+    readonly width?: number;
+    readonly height?: number;
+  }[];
+}
+export interface EdgeGeometry {
+  readonly id: string;
+  readonly sourceId: string;
+  readonly targetId: string;
+  readonly sourcePort?: string;
+  readonly targetPort?: string;
+  readonly x?: number;
+  readonly y?: number;
+  readonly width?: number;
+  readonly height?: number;
+}
+export interface Settings {
+  readonly coordinateSpace: "parent" | "world";
+  readonly clearance: number;
+  readonly radius: number;
+  readonly edgeSpacing: number;
+  readonly bendPenalty: number;
+  readonly crossingPenalty: number;
+  readonly overlapPenalty: number;
+  readonly maxSearchNodes: number;
+  readonly organicIterations: number;
+  readonly edges: NonNullable<RoutingSettings["edges"]>;
+}
+export function settings(input: RoutingSettings = {}): Settings {
+  const result = {
+    coordinateSpace: input.coordinateSpace ?? "parent",
+    clearance: input.clearance ?? 8,
+    radius: input.radius ?? 10,
+    edgeSpacing: input.edgeSpacing ?? 12,
+    bendPenalty: input.bendPenalty ?? 10,
+    crossingPenalty: input.crossingPenalty ?? 80,
+    overlapPenalty: input.overlapPenalty ?? 8,
+    maxSearchNodes: input.maxSearchNodes ?? 4000,
+    organicIterations: input.organicIterations ?? 12,
+    edges: structuredClone(input.edges ?? {}),
+  };
+  for (const [key, value] of Object.entries(result))
+    if (typeof value === "number" && (!Number.isFinite(value) || value < 0))
+      throw new RangeError(`${key} must be finite and non-negative`);
+  if (
+    !Number.isInteger(result.maxSearchNodes) ||
+    result.maxSearchNodes < 1 ||
+    !Number.isInteger(result.organicIterations)
+  )
+    throw new RangeError("Search and iteration budgets must be integers");
+  return freeze(result);
+}
+export function freeze<T>(value: T): T {
+  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+    for (const child of Object.values(value)) freeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+export function nodeGeometry(n: NodeGeometry): NodeGeometry {
+  return freeze({
+    id: n.id,
+    parentId: n.parentId,
+    x: n.x,
+    y: n.y,
+    width: n.width,
+    height: n.height,
+    ports: n.ports?.map((p) => ({
+      name: p.name,
+      x: p.x,
+      y: p.y,
+      width: p.width,
+      height: p.height,
+    })),
+  });
+}
+export function edgeGeometry(e: Partial<GraphEdge<unknown>> & { id: string }): EdgeGeometry {
+  return freeze({
+    id: e.id,
+    sourceId: e.sourceId ?? "",
+    targetId: e.targetId ?? "",
+    sourcePort: e.sourcePort,
+    targetPort: e.targetPort,
+    x: e.x,
+    y: e.y,
+    width: e.width,
+    height: e.height,
+  });
+}
+export function rect(value: {
+  readonly x?: number;
+  readonly y?: number;
+  readonly width?: number;
+  readonly height?: number;
+}): RouteBounds | undefined {
+  const { x, y, width, height } = value;
+  return [x, y, width, height].every((n) => typeof n === "number" && Number.isFinite(n)) &&
+    width! >= 0 &&
+    height! >= 0
+    ? { x: x!, y: y!, width: width!, height: height! }
+    : undefined;
+}
+export interface State {
+  readonly graphId: string;
+  readonly direction: string | undefined;
+  readonly settings: Settings;
+  readonly nodes: PersistentMap<NodeGeometry>;
+  readonly edges: PersistentMap<EdgeGeometry>;
+  readonly children: PersistentMap<PersistentMap<true>>;
+  readonly incident: PersistentMap<PersistentMap<true>>;
+  readonly groups: PersistentMap<PersistentMap<true>>;
+  readonly obstacles: SpatialIndex;
+  readonly routeIndex: SpatialIndex;
+  readonly routes: PersistentMap<Route>;
+}
+export function members(
+  index: PersistentMap<PersistentMap<true>>,
+  key: string,
+  id: string,
+  add: boolean,
+): PersistentMap<PersistentMap<true>> {
+  const current = index.get(key) ?? new PersistentMap<true>(),
+    next = add ? current.set(id, true) : current.delete(id);
+  return next.size ? index.set(key, next) : index.delete(key);
+}
+export function ancestors(id: string, state: Pick<State, "nodes">): string[] {
+  const result: string[] = [],
+    seen = new Set([id]);
+  let parent = state.nodes.get(id)?.parentId;
+  while (parent != null) {
+    if (seen.has(parent)) throw new Error(`Cyclic routing hierarchy at ${parent}`);
+    result.push(parent);
+    seen.add(parent);
+    parent = state.nodes.get(parent)?.parentId;
+  }
+  return result;
+}
+export function worldRect(
+  node: NodeGeometry,
+  state: Pick<State, "nodes" | "settings">,
+): RouteBounds | undefined {
+  const bounds = rect(node);
+  if (!bounds) return;
+  if (state.settings.coordinateSpace === "world") return bounds;
+  let x = bounds.x,
+    y = bounds.y;
+  for (const id of ancestors(node.id, state)) {
+    const parent = state.nodes.get(id),
+      p = parent && rect(parent);
+    if (!p) return;
+    x += p.x;
+    y += p.y;
+  }
+  return { ...bounds, x, y };
+}
+export function labelRect(
+  edge: EdgeGeometry,
+  state: Pick<State, "nodes" | "settings">,
+): RouteBounds | undefined {
+  const bounds = rect(edge);
+  if (!bounds || bounds.width <= 0 || bounds.height <= 0) return;
+  const source = state.nodes.get(edge.sourceId),
+    target = state.nodes.get(edge.targetId);
+  if (
+    state.settings.coordinateSpace === "world" ||
+    !source ||
+    source.parentId == null ||
+    source.parentId !== target?.parentId
+  )
+    return bounds;
+  const parent = state.nodes.get(source.parentId),
+    p = parent && worldRect(parent, state);
+  return p ? { ...bounds, x: bounds.x + p.x, y: bounds.y + p.y } : undefined;
+}
+export const center = (r: RouteBounds): RoutePoint => ({
+  x: r.x + r.width / 2,
+  y: r.y + r.height / 2,
+});
+export function sideToward(a: RoutePoint, b: RoutePoint): RouteSide {
+  return Math.abs(a.x - b.x) >= Math.abs(a.y - b.y)
+    ? b.x >= a.x
+      ? "right"
+      : "left"
+    : b.y >= a.y
+      ? "bottom"
+      : "top";
+}
+export const vector = (side: RouteSide): RoutePoint => ({
+  x: side === "right" ? 1 : side === "left" ? -1 : 0,
+  y: side === "bottom" ? 1 : side === "top" ? -1 : 0,
+});
+export function anchor(bounds: RouteBounds, side: RouteSide): RoutePoint {
+  const c = center(bounds),
+    v = vector(side);
+  return { x: c.x + (v.x * bounds.width) / 2, y: c.y + (v.y * bounds.height) / 2 };
+}
+export function groupKey(edge: EdgeGeometry, style: string, config: Settings): string | undefined {
+  const group = config.edges[edge.id]?.group;
+  if (style === "bus" || style === "bundle" || style === "fan")
+    return group !== undefined
+      ? `group:${group}`
+      : `source:${JSON.stringify([edge.sourceId, edge.sourcePort ?? null])}`;
+  return `pair:${JSON.stringify([edge.sourceId, edge.targetId].sort())}`;
+}

package/src/routing/path.ts

@@ -0,0 +1,324 @@
+import { crossesRect } from "../authoring/routing";
+import type { RouteBounds, RoutePath, RoutePoint, RouteSegment } from "./types";
+
+export const distance = (a: RoutePoint, b: RoutePoint): number => Math.hypot(a.x - b.x, a.y - b.y);
+const lerp = (a: RoutePoint, b: RoutePoint, t: number): RoutePoint => ({
+  x: a.x + (b.x - a.x) * t,
+  y: a.y + (b.y - a.y) * t,
+});
+export function pathFromPoints(points: readonly RoutePoint[]): RoutePath {
+  if (!points.length) throw new RangeError("A path needs at least one point");
+  return {
+    start: { ...points[0]! },
+    segments: points.slice(1).map((to) => ({ kind: "line", to: { ...to } })),
+  };
+}
+function pointLineDistance(p: RoutePoint, a: RoutePoint, b: RoutePoint): number {
+  const squared = (b.x - a.x) ** 2 + (b.y - a.y) ** 2;
+  const t = squared
+    ? Math.max(0, Math.min(1, ((p.x - a.x) * (b.x - a.x) + (p.y - a.y) * (b.y - a.y)) / squared))
+    : 0;
+  return distance(p, lerp(a, b, t));
+}
+type Arc = Extract<RouteSegment, { kind: "arc" }>;
+/** SVG endpoint-to-center conversion, including SVG's radius correction. */
+function arcCenter(start: RoutePoint, arc: Arc) {
+  let rx = Math.abs(arc.rx),
+    ry = Math.abs(arc.ry);
+  if (!rx || !ry || distance(start, arc.to) === 0) return undefined;
+  const phi = (arc.rotation * Math.PI) / 180,
+    c = Math.cos(phi),
+    s = Math.sin(phi);
+  const dx = (start.x - arc.to.x) / 2,
+    dy = (start.y - arc.to.y) / 2;
+  const x = c * dx + s * dy,
+    y = -s * dx + c * dy;
+  const scale = Math.sqrt(Math.max(1, (x * x) / (rx * rx) + (y * y) / (ry * ry)));
+  rx *= scale;
+  ry *= scale;
+  const factor =
+    (arc.largeArc === arc.sweep ? -1 : 1) *
+    Math.sqrt(
+      Math.max(
+        0,
+        (rx * rx * ry * ry - rx * rx * y * y - ry * ry * x * x) /
+          (rx * rx * y * y + ry * ry * x * x),
+      ),
+    );
+  const cx = (factor * rx * y) / ry,
+    cy = (-factor * ry * x) / rx;
+  const center = {
+    x: c * cx - s * cy + (start.x + arc.to.x) / 2,
+    y: s * cx + c * cy + (start.y + arc.to.y) / 2,
+  };
+  const theta = Math.atan2((y - cy) / ry, (x - cx) / rx);
+  let delta = Math.atan2((-y - cy) / ry, (-x - cx) / rx) - theta;
+  if (arc.sweep && delta < 0) delta += 2 * Math.PI;
+  if (!arc.sweep && delta > 0) delta -= 2 * Math.PI;
+  return { rx, ry, c, s, center, theta, delta };
+}
+export interface FlattenPathOptions {
+  readonly tolerance?: number;
+  readonly maxSegments?: number;
+}
+/** Adaptive, bounded-error polyline approximation. Throws rather than silently exceeding tolerance. */
+export function flattenPath(path: RoutePath, options: FlattenPathOptions = {}): RoutePoint[] {
+  const tolerance = options.tolerance ?? 0.5,
+    max = options.maxSegments ?? 65536;
+  if (!(tolerance > 0 && Number.isFinite(tolerance)) || !Number.isInteger(max) || max < 1)
+    throw new RangeError("Invalid flattening tolerance or segment budget");
+  const points: RoutePoint[] = [{ ...path.start }];
+  const add = (point: RoutePoint) => {
+    if (points.length > max) throw new RangeError("Path flattening exceeded maxSegments");
+    points.push({ ...point });
+  };
+  function bezier(controls: readonly RoutePoint[], depth = 0) {
+    const first = controls[0]!,
+      last = controls.at(-1)!;
+    if (controls.slice(1, -1).every((p) => pointLineDistance(p, first, last) <= tolerance)) {
+      add(last);
+      return;
+    }
+    if (depth >= 32) throw new RangeError("Cannot flatten path at requested tolerance");
+    const left = [first],
+      right = [last];
+    let row = [...controls];
+    while (row.length > 1) {
+      row = row.slice(1).map((p, i) => lerp(row[i]!, p, 0.5));
+      left.push(row[0]!);
+      right.unshift(row.at(-1)!);
+    }
+    bezier(left, depth + 1);
+    bezier(right, depth + 1);
+  }
+  let from = path.start;
+  for (const segment of path.segments) {
+    if (segment.kind === "line") add(segment.to);
+    else if (segment.kind === "quadratic") bezier([from, segment.control, segment.to]);
+    else if (segment.kind === "cubic")
+      bezier([from, segment.control1, segment.control2, segment.to]);
+    else {
+      const arc = arcCenter(from, segment);
+      if (!arc) add(segment.to);
+      else {
+        const step = Math.min(
+          Math.PI / 2,
+          2 * Math.acos(Math.max(-1, 1 - tolerance / Math.max(arc.rx, arc.ry))),
+        );
+        const count = Math.max(1, Math.ceil(Math.abs(arc.delta) / step));
+        if (!Number.isFinite(count) || points.length + count > max + 1)
+          throw new RangeError("Path flattening exceeded maxSegments");
+        for (let i = 1; i < count; i++) {
+          const t = arc.theta + (arc.delta * i) / count;
+          add({
+            x: arc.center.x + arc.c * arc.rx * Math.cos(t) - arc.s * arc.ry * Math.sin(t),
+            y: arc.center.y + arc.s * arc.rx * Math.cos(t) + arc.c * arc.ry * Math.sin(t),
+          });
+        }
+        add(segment.to);
+      }
+    }
+    from = segment.to;
+  }
+  return points;
+}
+/** Conservative bounds: control hulls and full ellipse envelopes contain every curve. */
+export function getPathBounds(path: RoutePath): RouteBounds {
+  const points: RoutePoint[] = [path.start];
+  let from = path.start;
+  for (const segment of path.segments) {
+    points.push(segment.to);
+    if (segment.kind === "quadratic") points.push(segment.control);
+    if (segment.kind === "cubic") points.push(segment.control1, segment.control2);
+    if (segment.kind === "arc") {
+      const arc = arcCenter(from, segment);
+      if (arc) {
+        const dx = Math.hypot(arc.rx * arc.c, arc.ry * arc.s),
+          dy = Math.hypot(arc.rx * arc.s, arc.ry * arc.c);
+        points.push(
+          { x: arc.center.x - dx, y: arc.center.y - dy },
+          { x: arc.center.x + dx, y: arc.center.y + dy },
+        );
+      }
+    }
+    from = segment.to;
+  }
+  const xs = points.map((p) => p.x),
+    ys = points.map((p) => p.y);
+  const x = Math.min(...xs),
+    y = Math.min(...ys);
+  return { x, y, width: Math.max(...xs) - x, height: Math.max(...ys) - y };
+}
+export function getPathLength(path: RoutePath, options?: FlattenPathOptions): number {
+  const points = flattenPath(path, options);
+  return points.reduce((sum, p, i) => sum + (i ? distance(points[i - 1]!, p) : 0), 0);
+}
+function locate(path: RoutePath, length: number, options?: FlattenPathOptions) {
+  const points = flattenPath(path, options);
+  let remaining = Math.max(0, length);
+  for (let i = 1; i < points.length; i++) {
+    const a = points[i - 1]!,
+      b = points[i]!,
+      size = distance(a, b);
+    if (size && (remaining <= size || i === points.length - 1))
+      return { a, b, t: Math.min(1, remaining / size) };
+    remaining -= size;
+  }
+  return { a: points.at(-1)!, b: points.at(-1)!, t: 0 };
+}
+export function getPointAtLength(
+  path: RoutePath,
+  length: number,
+  options?: FlattenPathOptions,
+): RoutePoint {
+  const { a, b, t } = locate(path, length, options);
+  return lerp(a, b, t);
+}
+export function getTangentAtLength(
+  path: RoutePath,
+  length: number,
+  options?: FlattenPathOptions,
+): RoutePoint {
+  const { a, b } = locate(path, length, options),
+    d = distance(a, b);
+  return d ? { x: (b.x - a.x) / d, y: (b.y - a.y) / d } : { x: 0, y: 0 };
+}
+/** Round line-to-line corners only; existing curves and path endpoints are retained. */
+export function roundCorners(path: RoutePath, options: { readonly radius: number }): RoutePath {
+  const radius = options.radius;
+  if (!Number.isFinite(radius) || radius < 0)
+    throw new RangeError("radius must be non-negative and finite");
+  if (!radius) return path;
+  const result: RouteSegment[] = [];
+  let previous = path.start;
+  for (let i = 0; i < path.segments.length; i++) {
+    const segment = path.segments[i]!,
+      next = path.segments[i + 1];
+    const corner = segment.to;
+    if (segment.kind === "line" && next?.kind === "line") {
+      const l1 = distance(previous, corner),
+        l2 = distance(corner, next.to);
+      if (l1 > 0 && l2 > 0) {
+        const u = { x: (corner.x - previous.x) / l1, y: (corner.y - previous.y) / l1 },
+          v = { x: (next.to.x - corner.x) / l2, y: (next.to.y - corner.y) / l2 };
+        const angle = Math.acos(Math.max(-1, Math.min(1, u.x * v.x + u.y * v.y)));
+        if (angle > 1e-8 && angle < Math.PI - 1e-8) {
+          const tangent = Math.tan(angle / 2),
+            trim = Math.min(radius * tangent, l1 / 2, l2 / 2),
+            r = trim / tangent;
+          result.push(
+            { kind: "line", to: { x: corner.x - u.x * trim, y: corner.y - u.y * trim } },
+            {
+              kind: "arc",
+              rx: r,
+              ry: r,
+              rotation: 0,
+              largeArc: false,
+              sweep: u.x * v.y - u.y * v.x > 0,
+              to: { x: corner.x + v.x * trim, y: corner.y + v.y * trim },
+            },
+          );
+          previous = corner;
+          continue;
+        }
+      }
+    }
+    result.push(segment);
+    previous = corner;
+  }
+  return { start: path.start, segments: result };
+}
+export function toSvgPath(
+  path: RoutePath,
+  options: { readonly radius?: number; readonly precision?: number } = {},
+): string {
+  const shaped = options.radius ? roundCorners(path, { radius: options.radius }) : path;
+  const precision = options.precision ?? 6;
+  if (!Number.isInteger(precision) || precision < 0 || precision > 15)
+    throw new RangeError("precision must be an integer from 0 to 15");
+  const n = (value: number) => {
+    if (!Number.isFinite(value)) throw new RangeError("Path coordinates must be finite");
+    return String(Number(value.toFixed(precision)));
+  };
+  const p = (point: RoutePoint) => `${n(point.x)} ${n(point.y)}`;
+  return [
+    `M ${p(shaped.start)}`,
+    ...shaped.segments.map((s) => {
+      switch (s.kind) {
+        case "line":
+          return `L ${p(s.to)}`;
+        case "quadratic":
+          return `Q ${p(s.control)} ${p(s.to)}`;
+        case "cubic":
+          return `C ${p(s.control1)} ${p(s.control2)} ${p(s.to)}`;
+        case "arc":
+          return `A ${n(Math.abs(s.rx))} ${n(Math.abs(s.ry))} ${n(s.rotation)} ${Number(s.largeArc)} ${Number(s.sweep)} ${p(s.to)}`;
+      }
+    }),
+  ].join(" ");
+}
+
+/** Test curve geometry, subdividing conservative bounds only where they overlap. */
+export function segmentCrossesRect(
+  start: RoutePoint,
+  segment: RouteSegment,
+  rect: RouteBounds,
+): boolean {
+  const overlaps = (points: readonly RoutePoint[]) => {
+    const xs = points.map((p) => p.x),
+      ys = points.map((p) => p.y);
+    return (
+      Math.min(...xs) < rect.x + rect.width &&
+      Math.max(...xs) > rect.x &&
+      Math.min(...ys) < rect.y + rect.height &&
+      Math.max(...ys) > rect.y
+    );
+  };
+  const inside = (p: RoutePoint) =>
+    p.x > rect.x && p.x < rect.x + rect.width && p.y > rect.y && p.y < rect.y + rect.height;
+  function bezier(controls: readonly RoutePoint[], depth: number): boolean {
+    if (!overlaps(controls)) return false;
+    if (inside(controls[0]!) || inside(controls.at(-1)!)) return true;
+    if (depth === 32) return true; // Unresolved subpixel contact stays conservative.
+    const left = [controls[0]!],
+      right = [controls.at(-1)!];
+    let row = [...controls];
+    while (row.length > 1) {
+      row = row.slice(1).map((p, i) => lerp(row[i]!, p, 0.5));
+      left.push(row[0]!);
+      right.unshift(row.at(-1)!);
+    }
+    return bezier(left, depth + 1) || bezier(right, depth + 1);
+  }
+  if (segment.kind === "line") return crossesRect(start, segment.to, rect);
+  if (segment.kind === "quadratic") return bezier([start, segment.control, segment.to], 0);
+  if (segment.kind === "cubic")
+    return bezier([start, segment.control1, segment.control2, segment.to], 0);
+  const arc = arcCenter(start, segment);
+  if (!arc) return crossesRect(start, segment.to, rect);
+  const point = (t: number): RoutePoint => ({
+    x: arc.center.x + arc.c * arc.rx * Math.cos(t) - arc.s * arc.ry * Math.sin(t),
+    y: arc.center.y + arc.s * arc.rx * Math.cos(t) + arc.c * arc.ry * Math.sin(t),
+  });
+  function interval(a: number, b: number, depth: number): boolean {
+    const points = [point(a), point(b)];
+    // Exact extrema of each rotated ellipse coordinate within this subarc.
+    for (const base of [
+      Math.atan2(-arc!.s * arc!.ry, arc!.c * arc!.rx),
+      Math.atan2(arc!.c * arc!.ry, arc!.s * arc!.rx),
+    ]) {
+      for (let k = Math.ceil((a - base) / Math.PI); base + k * Math.PI < b; k++)
+        points.push(point(base + k * Math.PI));
+    }
+    if (!overlaps(points)) return false;
+    if (inside(points[0]!) || inside(points[1]!)) return true;
+    if (depth === 32) return true;
+    const middle = (a + b) / 2;
+    return interval(a, middle, depth + 1) || interval(middle, b, depth + 1);
+  }
+  return interval(
+    Math.min(arc.theta, arc.theta + arc.delta),
+    Math.max(arc.theta, arc.theta + arc.delta),
+    0,
+  );
+}

package/src/routing/persistent.ts

@@ -0,0 +1,117 @@
+/** Path-copying AVL map. Updating k entries costs O(k log n), never a whole Map copy. */
+interface Node<V> {
+  readonly key: string;
+  readonly value: V;
+  readonly left?: Node<V>;
+  readonly right?: Node<V>;
+  readonly height: number;
+  readonly size: number;
+}
+const height = <V>(n?: Node<V>) => n?.height ?? 0;
+const size = <V>(n?: Node<V>) => n?.size ?? 0;
+function node<V>(key: string, value: V, left?: Node<V>, right?: Node<V>): Node<V> {
+  return {
+    key,
+    value,
+    left,
+    right,
+    height: 1 + Math.max(height(left), height(right)),
+    size: 1 + size(left) + size(right),
+  };
+}
+function balance<V>(n: Node<V>): Node<V> {
+  if (height(n.left) - height(n.right) > 1) {
+    let l = n.left!;
+    if (height(l.right) > height(l.left)) {
+      const r = l.right!;
+      l = node(r.key, r.value, node(l.key, l.value, l.left, r.left), r.right);
+    }
+    return node(l.key, l.value, l.left, node(n.key, n.value, l.right, n.right));
+  }
+  if (height(n.right) - height(n.left) > 1) {
+    let r = n.right!;
+    if (height(r.left) > height(r.right)) {
+      const l = r.left!;
+      r = node(l.key, l.value, l.left, node(r.key, r.value, l.right, r.right));
+    }
+    return node(r.key, r.value, node(n.key, n.value, n.left, r.left), r.right);
+  }
+  return n;
+}
+function put<V>(n: Node<V> | undefined, key: string, value: V): Node<V> {
+  if (!n) return node(key, value);
+  if (key === n.key) return Object.is(value, n.value) ? n : node(key, value, n.left, n.right);
+  return balance(
+    key < n.key
+      ? node(n.key, n.value, put(n.left, key, value), n.right)
+      : node(n.key, n.value, n.left, put(n.right, key, value)),
+  );
+}
+function remove<V>(n: Node<V> | undefined, key: string): Node<V> | undefined {
+  if (!n) return n;
+  if (key < n.key) return balance(node(n.key, n.value, remove(n.left, key), n.right));
+  if (key > n.key) return balance(node(n.key, n.value, n.left, remove(n.right, key)));
+  if (!n.left) return n.right;
+  if (!n.right) return n.left;
+  let successor = n.right;
+  while (successor.left) successor = successor.left;
+  return balance(node(successor.key, successor.value, n.left, remove(n.right, successor.key)));
+}
+function* entries<V>(n?: Node<V>): Generator<[string, V]> {
+  if (!n) return;
+  yield* entries(n.left);
+  yield [n.key, n.value];
+  yield* entries(n.right);
+}
+export class PersistentMap<V> implements ReadonlyMap<string, V> {
+  readonly #root?: Node<V>;
+  constructor(root?: Node<V>) {
+    this.#root = root;
+    Object.freeze(this);
+  }
+  get size() {
+    return size(this.#root);
+  }
+  get [Symbol.toStringTag]() {
+    return "PersistentMap";
+  }
+  get(key: string): V | undefined {
+    let n = this.#root;
+    while (n) {
+      if (key === n.key) return n.value;
+      n = key < n.key ? n.left : n.right;
+    }
+  }
+  has(key: string) {
+    let n = this.#root;
+    while (n) {
+      if (key === n.key) return true;
+      n = key < n.key ? n.left : n.right;
+    }
+    return false;
+  }
+  set(key: string, value: V): PersistentMap<V> {
+    return new PersistentMap(put(this.#root, key, value));
+  }
+  delete(key: string): PersistentMap<V> {
+    return this.has(key) ? new PersistentMap(remove(this.#root, key)) : this;
+  }
+  *entries(): MapIterator<[string, V]> {
+    yield* entries(this.#root);
+  }
+  *keys(): MapIterator<string> {
+    for (const [key] of this) yield key;
+  }
+  *values(): MapIterator<V> {
+    for (const [, value] of this) yield value;
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  forEach(
+    callback: (value: V, key: string, map: ReadonlyMap<string, V>) => void,
+    thisArg?: unknown,
+  ) {
+    for (const [key, value] of this) callback.call(thisArg, value, key, this);
+  }
+}