@skygraph/core 0.0.0-placeholder.0 → 0.5.0

package/dist/index.cjs

@@ -0,0 +1,3860 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CALENDAR_PREFIX: () => CALENDAR_PREFIX,
+  FORM_META_PREFIX: () => FORM_META_PREFIX,
+  GRAPH_PREFIX: () => GRAPH_PREFIX,
+  TABLE_PREFIX: () => TABLE_PREFIX,
+  TREE_PREFIX: () => TREE_PREFIX,
+  aabbFromOBB: () => aabbFromOBB,
+  computeAggregate: () => computeAggregate,
+  createCalendar: () => createCalendar,
+  createCore: () => createCore,
+  createForm: () => createForm,
+  createGraph: () => createGraph,
+  createHistory: () => createHistory,
+  createMeasureCache: () => createMeasureCache,
+  createTable: () => createTable,
+  createTree: () => createTree,
+  createTypedCore: () => createTypedCore,
+  createVirtual: () => createVirtual,
+  detectConflicts: () => detectConflicts,
+  floatingAnchor: () => floatingAnchor,
+  freezeMiddleware: () => freezeMiddleware,
+  getBezierPath: () => getBezierPath,
+  getEdgePosition: () => getEdgePosition,
+  getNodeIntersection: () => getNodeIntersection,
+  inferSide: () => inferSide,
+  isAvailable: () => isAvailable,
+  listReservedPrefixes: () => listReservedPrefixes,
+  loggerMiddleware: () => loggerMiddleware,
+  matchesColumnFilter: () => matchesColumnFilter,
+  matchesOperator: () => matchesOperator,
+  nearestSide: () => nearestSide,
+  obbContainsPoint: () => obbContainsPoint,
+  obbCorners: () => obbCorners,
+  persistenceMiddleware: () => persistenceMiddleware,
+  pointsToPath: () => pointsToPath,
+  pointsToRoundedPath: () => pointsToRoundedPath,
+  reservePrefix: () => reservePrefix,
+  resolveEdgeEndpoint: () => resolveEdgeEndpoint,
+  resolveOperator: () => resolveOperator,
+  routeOrthogonal: () => routeOrthogonal,
+  validationMiddleware: () => validationMiddleware
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/runtime/Node.ts
+function createNode(id, value) {
+  return { id, value, version: 0 };
+}
+
+// src/runtime/Store.ts
+var Store = class {
+  nodes = /* @__PURE__ */ new Map();
+  has(path) {
+    return this.nodes.has(path);
+  }
+  get(path) {
+    return this.nodes.get(path)?.value;
+  }
+  getNode(path) {
+    return this.nodes.get(path);
+  }
+  set(path, value) {
+    let node = this.nodes.get(path);
+    if (node) {
+      node.value = value;
+      node.version++;
+      return node;
+    }
+    node = createNode(path, value);
+    this.nodes.set(path, node);
+    return node;
+  }
+  delete(path) {
+    return this.nodes.delete(path);
+  }
+  paths() {
+    return this.nodes.keys();
+  }
+  size() {
+    return this.nodes.size;
+  }
+};
+
+// src/runtime/SubscriptionEngine.ts
+var SubscriptionEngine = class {
+  listeners = /* @__PURE__ */ new Map();
+  subscribe(path, cb) {
+    let set = this.listeners.get(path);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(path, set);
+    }
+    set.add(cb);
+    return () => {
+      set.delete(cb);
+      if (set.size === 0) {
+        this.listeners.delete(path);
+      }
+    };
+  }
+  notify(path, value) {
+    const set = this.listeners.get(path);
+    if (!set) return;
+    for (const cb of set) {
+      cb(value);
+    }
+  }
+  notifyMany(changes) {
+    for (const [path, value] of changes) {
+      this.notify(path, value);
+    }
+  }
+  hasListeners(path) {
+    const set = this.listeners.get(path);
+    return set !== void 0 && set.size > 0;
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/runtime/Batch.ts
+var Batch = class {
+  depth = 0;
+  pending = /* @__PURE__ */ new Map();
+  get isActive() {
+    return this.depth > 0;
+  }
+  start() {
+    this.depth++;
+  }
+  end() {
+    this.depth--;
+    if (this.depth > 0) return null;
+    if (this.pending.size === 0) return null;
+    const changes = new Map(this.pending);
+    this.pending.clear();
+    return changes;
+  }
+  enqueue(path, value) {
+    this.pending.set(path, value);
+  }
+};
+
+// src/runtime/Transaction.ts
+var Transaction = class {
+  active = false;
+  staged = [];
+  get isActive() {
+    return this.active;
+  }
+  start() {
+    if (this.active) {
+      throw new Error("SkyGraph: nested transactions are not supported");
+    }
+    this.active = true;
+    this.staged = [];
+  }
+  /** STAGE: record a write without mutating the store */
+  stage(path, value, prevValue) {
+    this.staged.push({ path, value, prevValue });
+  }
+  /**
+   * RESOLVE + COMMIT: drop unchanged values, apply the rest to store.
+   * Returns the map of actually changed paths and their new values.
+   */
+  commit(store) {
+    const changes = /* @__PURE__ */ new Map();
+    for (const write of this.staged) {
+      if (Object.is(write.value, write.prevValue)) continue;
+      store.set(write.path, write.value);
+      changes.set(write.path, write.value);
+    }
+    this.active = false;
+    this.staged = [];
+    return changes;
+  }
+  getStaged() {
+    return this.staged;
+  }
+  complete() {
+    this.active = false;
+    this.staged = [];
+  }
+  rollback() {
+    this.active = false;
+    this.staged = [];
+  }
+};
+
+// src/runtime/CycleDetector.ts
+var CycleDetector = class {
+  graph = /* @__PURE__ */ new Map();
+  addEdge(from, to) {
+    let deps = this.graph.get(from);
+    if (!deps) {
+      deps = /* @__PURE__ */ new Set();
+      this.graph.set(from, deps);
+    }
+    deps.add(to);
+    if (this.hasCycle(to, /* @__PURE__ */ new Set([from]))) {
+      deps.delete(to);
+      if (deps.size === 0) this.graph.delete(from);
+      throw new Error(
+        `SkyGraph: circular dependency detected: ${from} -> ${to}`
+      );
+    }
+  }
+  removeNode(id) {
+    this.graph.delete(id);
+    for (const deps of this.graph.values()) {
+      deps.delete(id);
+    }
+  }
+  getDependents(id) {
+    const targets = this.graph.get(id);
+    return targets ? [...targets] : [];
+  }
+  hasCycle(node, visited) {
+    if (visited.has(node)) return true;
+    const deps = this.graph.get(node);
+    if (!deps) return false;
+    visited.add(node);
+    for (const dep of deps) {
+      if (this.hasCycle(dep, new Set(visited))) return true;
+    }
+    return false;
+  }
+};
+
+// src/runtime/ComputedEngine.ts
+var ComputedEngine = class {
+  computedNodes = /* @__PURE__ */ new Map();
+  cycleDetector = new CycleDetector();
+  register(target, deps, fn) {
+    if (this.computedNodes.has(target)) {
+      this.remove(target);
+    }
+    for (const dep of deps) {
+      this.cycleDetector.addEdge(dep, target);
+    }
+    this.computedNodes.set(target, { target, deps, fn });
+  }
+  remove(target) {
+    this.computedNodes.delete(target);
+    this.cycleDetector.removeNode(target);
+  }
+  isComputed(path) {
+    return this.computedNodes.has(path);
+  }
+  /**
+   * Like propagate, but returns both new and old values for middleware support.
+   * Does NOT write to the store — the caller handles that via dispatchWrite.
+   */
+  propagateRaw(changedPaths, store) {
+    const result = /* @__PURE__ */ new Map();
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [...changedPaths];
+    while (queue.length > 0) {
+      const path = queue.shift();
+      if (visited.has(path)) continue;
+      visited.add(path);
+      const dependents = this.cycleDetector.getDependents(path);
+      for (const depTarget of dependents) {
+        const computed = this.computedNodes.get(depTarget);
+        if (!computed) continue;
+        const depValues = computed.deps.map((d) => {
+          const pending = result.get(d);
+          return pending ? pending.value : store.get(d);
+        });
+        const newValue = computed.fn(...depValues);
+        const oldValue = result.has(depTarget) ? result.get(depTarget).oldValue : store.get(depTarget);
+        if (!Object.is(newValue, oldValue)) {
+          result.set(depTarget, { value: newValue, oldValue });
+          queue.push(depTarget);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Initialize all computed values based on current store state.
+   */
+  initializeAll(store) {
+    for (const computed of this.computedNodes.values()) {
+      const depValues = computed.deps.map((d) => store.get(d));
+      const value = computed.fn(...depValues);
+      store.set(computed.target, value);
+    }
+  }
+};
+
+// src/Core.ts
+var CoreImpl = class {
+  store = new Store();
+  subscriptions = new SubscriptionEngine();
+  batch_ = new Batch();
+  transaction_ = new Transaction();
+  computed_ = new ComputedEngine();
+  middlewares = [];
+  // ── Middleware ──
+  use(middleware) {
+    this.middlewares.push(middleware);
+    return () => {
+      const idx = this.middlewares.indexOf(middleware);
+      if (idx !== -1) this.middlewares.splice(idx, 1);
+    };
+  }
+  dispatchWrite(event) {
+    let idx = 0;
+    const chain = (ev) => {
+      if (idx < this.middlewares.length) {
+        const mw = this.middlewares[idx++];
+        mw(ev, chain);
+      } else {
+        this.commitWrite(ev);
+      }
+    };
+    chain(event);
+  }
+  commitWrite(event) {
+    this.store.set(event.path, event.value);
+  }
+  // ── Public API ──
+  get(path) {
+    return this.store.get(path);
+  }
+  set(path, value) {
+    if (this.transaction_.isActive) {
+      this.transaction_.stage(path, value, this.store.get(path));
+      return;
+    }
+    const oldValue = this.store.get(path);
+    if (Object.is(oldValue, value)) return;
+    this.dispatchWrite({ path, value, oldValue, source: "user" });
+    const computedChanges = this.propagateComputed(/* @__PURE__ */ new Set([path]));
+    if (this.batch_.isActive) {
+      this.batch_.enqueue(path, value);
+      for (const [cp, cv] of computedChanges) {
+        this.batch_.enqueue(cp, cv);
+      }
+      return;
+    }
+    this.subscriptions.notify(path, value);
+    this.subscriptions.notifyMany(computedChanges);
+  }
+  subscribe(path, cb) {
+    return this.subscriptions.subscribe(path, cb);
+  }
+  batch(fn) {
+    this.batch_.start();
+    try {
+      fn();
+    } finally {
+      const changes = this.batch_.end();
+      if (changes) {
+        this.subscriptions.notifyMany(changes);
+      }
+    }
+  }
+  transaction(fn) {
+    this.batch_.start();
+    this.transaction_.start();
+    try {
+      fn();
+      const staged = this.transaction_.getStaged();
+      const approved = [];
+      const origCommit = this.commitWrite.bind(this);
+      this.commitWrite = (ev) => {
+        approved.push({ path: ev.path, value: ev.value });
+      };
+      try {
+        for (const write of staged) {
+          if (Object.is(write.value, write.prevValue)) continue;
+          this.dispatchWrite({
+            path: write.path,
+            value: write.value,
+            oldValue: write.prevValue,
+            source: "transaction"
+          });
+        }
+      } finally {
+        this.commitWrite = origCommit;
+      }
+      const changes = /* @__PURE__ */ new Map();
+      for (const { path, value } of approved) {
+        this.store.set(path, value);
+        changes.set(path, value);
+      }
+      this.transaction_.complete();
+      const computedChanges = this.propagateComputed(new Set(changes.keys()));
+      for (const [path, value] of changes) {
+        this.batch_.enqueue(path, value);
+      }
+      for (const [path, value] of computedChanges) {
+        this.batch_.enqueue(path, value);
+      }
+    } catch (e) {
+      this.transaction_.rollback();
+      throw e;
+    } finally {
+      const batchedChanges = this.batch_.end();
+      if (batchedChanges) {
+        this.subscriptions.notifyMany(batchedChanges);
+      }
+    }
+  }
+  computed(target, deps, fn) {
+    this.computed_.register(target, deps, fn);
+    const depValues = deps.map((d) => this.store.get(d));
+    const value = fn(...depValues);
+    const oldValue = this.store.get(target);
+    this.dispatchWrite({
+      path: target,
+      value,
+      oldValue,
+      source: "computed"
+    });
+    if (!Object.is(oldValue, value)) {
+      this.subscriptions.notify(target, value);
+    }
+  }
+  // ── Snapshot / Restore ──
+  snapshot() {
+    const result = {};
+    for (const path of this.store.paths()) {
+      result[path] = this.store.get(path);
+    }
+    return result;
+  }
+  restore(snap2) {
+    this.batch_.start();
+    try {
+      for (const [path, value] of Object.entries(snap2)) {
+        const oldValue = this.store.get(path);
+        if (!Object.is(oldValue, value)) {
+          this.dispatchWrite({ path, value, oldValue, source: "restore" });
+          this.batch_.enqueue(path, value);
+        }
+      }
+    } finally {
+      const changes = this.batch_.end();
+      if (changes) {
+        this.subscriptions.notifyMany(changes);
+      }
+    }
+  }
+  // ── Internal helpers ──
+  propagateComputed(changedPaths) {
+    const rawChanges = this.computed_.propagateRaw(changedPaths, this.store);
+    const dispatched = /* @__PURE__ */ new Map();
+    for (const [path, { value, oldValue }] of rawChanges) {
+      this.dispatchWrite({ path, value, oldValue, source: "computed" });
+      dispatched.set(path, value);
+    }
+    return dispatched;
+  }
+};
+function createCore() {
+  return new CoreImpl();
+}
+
+// src/middleware/logger.ts
+function loggerMiddleware(options = {}) {
+  const log = options.log ?? ((msg, ev) => console.log(msg, ev.path, ev.value));
+  const filter = options.filter;
+  return (event, next) => {
+    if (filter && !filter(event)) {
+      next(event);
+      return;
+    }
+    log(`[skygraph:${event.source}]`, event);
+    next(event);
+  };
+}
+
+// src/middleware/freeze.ts
+function freezeMiddleware(frozenPaths) {
+  return (event, next) => {
+    for (const prefix of frozenPaths) {
+      if (event.path === prefix || event.path.startsWith(prefix + ".")) {
+        return;
+      }
+    }
+    next(event);
+  };
+}
+
+// src/middleware/persistence.ts
+function persistenceMiddleware(options = {}) {
+  const storageKey = options.key ?? "skygraph:state";
+  const storage = options.storage ?? (typeof localStorage !== "undefined" ? localStorage : null);
+  const paths = options.paths;
+  const debounceMs = options.debounce ?? 100;
+  let pending = {};
+  let timer = null;
+  function flush() {
+    if (!storage) return;
+    const existing = storage.getItem(storageKey);
+    let data = {};
+    if (existing) {
+      try {
+        data = JSON.parse(existing);
+      } catch {
+      }
+    }
+    Object.assign(data, pending);
+    storage.setItem(storageKey, JSON.stringify(data));
+    pending = {};
+    timer = null;
+  }
+  return (event, next) => {
+    next(event);
+    if (paths && !paths.some((p) => event.path === p || event.path.startsWith(p + "."))) {
+      return;
+    }
+    pending[event.path] = event.value;
+    if (timer === null) {
+      timer = setTimeout(flush, debounceMs);
+    }
+  };
+}
+
+// src/middleware/validation.ts
+function validationMiddleware(optionsOrValidators) {
+  const isOptions = "validators" in optionsOrValidators;
+  const validators = isOptions ? optionsOrValidators.validators : optionsOrValidators;
+  const onReject = isOptions ? optionsOrValidators.onReject : void 0;
+  return (event, next) => {
+    const validator = validators[event.path];
+    if (validator) {
+      const result = validator(event);
+      if (result === false || typeof result === "string") {
+        onReject?.(event, typeof result === "string" ? result : "Validation failed");
+        return;
+      }
+    }
+    next(event);
+  };
+}
+
+// src/plugins/history.ts
+function createHistory(core, options = {}) {
+  const maxEntries = options.maxEntries ?? 100;
+  const groupWindow = options.groupWindow ?? 0;
+  const filter = options.filter;
+  const entries = [];
+  let cursor = -1;
+  let travelling = false;
+  let groupTimer = null;
+  let pendingPatches = [];
+  function flushGroup() {
+    if (pendingPatches.length === 0) return;
+    const entry = {
+      timestamp: Date.now(),
+      patches: [...pendingPatches]
+    };
+    pendingPatches = [];
+    if (cursor < entries.length - 1) {
+      entries.splice(cursor + 1);
+    }
+    entries.push(entry);
+    cursor++;
+    if (entries.length > maxEntries) {
+      entries.shift();
+      cursor--;
+    }
+    groupTimer = null;
+  }
+  const middleware = (event, next) => {
+    next(event);
+    if (travelling) return;
+    if (event.source === "computed") return;
+    if (filter && !filter(event)) return;
+    pendingPatches.push({
+      path: event.path,
+      value: event.value,
+      oldValue: event.oldValue
+    });
+    if (groupWindow > 0) {
+      if (groupTimer === null) {
+        groupTimer = setTimeout(flushGroup, groupWindow);
+      }
+    } else {
+      flushGroup();
+    }
+  };
+  const unsub = core.use(middleware);
+  function applyPatches(patches, direction) {
+    travelling = true;
+    try {
+      core.batch(() => {
+        if (direction === "undo") {
+          for (let i = patches.length - 1; i >= 0; i--) {
+            core.set(patches[i].path, patches[i].oldValue);
+          }
+        } else {
+          for (const patch of patches) {
+            core.set(patch.path, patch.value);
+          }
+        }
+      });
+    } finally {
+      travelling = false;
+    }
+  }
+  return {
+    get entries() {
+      return entries;
+    },
+    get cursor() {
+      return cursor;
+    },
+    get canUndo() {
+      return cursor >= 0;
+    },
+    get canRedo() {
+      return cursor < entries.length - 1;
+    },
+    undo() {
+      if (cursor < 0) return;
+      flushGroup();
+      applyPatches(entries[cursor].patches, "undo");
+      cursor--;
+    },
+    redo() {
+      if (cursor >= entries.length - 1) return;
+      flushGroup();
+      cursor++;
+      applyPatches(entries[cursor].patches, "redo");
+    },
+    jumpTo(index) {
+      if (index < -1 || index >= entries.length) return;
+      flushGroup();
+      while (cursor > index) {
+        applyPatches(entries[cursor].patches, "undo");
+        cursor--;
+      }
+      while (cursor < index) {
+        cursor++;
+        applyPatches(entries[cursor].patches, "redo");
+      }
+    },
+    clear() {
+      entries.length = 0;
+      cursor = -1;
+      pendingPatches = [];
+      if (groupTimer !== null) {
+        clearTimeout(groupTimer);
+        groupTimer = null;
+      }
+    },
+    destroy() {
+      this.clear();
+      unsub();
+    }
+  };
+}
+
+// src/engines/virtual/measure.ts
+function createMeasureCache(options) {
+  let itemCount = options.itemCount;
+  let estimate = options.estimate;
+  const measured = /* @__PURE__ */ new Map();
+  let offsets = null;
+  let cachedTotal = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  const getEstimate = (index) => typeof estimate === "number" ? estimate : estimate(index);
+  const getItemSize = (index) => {
+    const m = measured.get(index);
+    return m !== void 0 ? m : getEstimate(index);
+  };
+  const rebuildOffsets = () => {
+    if (offsets && offsets.length === itemCount) return;
+    const arr = new Array(itemCount);
+    let acc = 0;
+    for (let i = 0; i < itemCount; i++) {
+      arr[i] = acc;
+      acc += getItemSize(i);
+    }
+    offsets = arr;
+    cachedTotal = acc;
+  };
+  const getTotalHeight = () => {
+    rebuildOffsets();
+    return cachedTotal;
+  };
+  const getItemOffset = (index) => {
+    if (index <= 0) return 0;
+    if (index >= itemCount) return getTotalHeight();
+    rebuildOffsets();
+    return offsets[index];
+  };
+  const getItemAtOffset = (offset) => {
+    if (itemCount === 0) return 0;
+    rebuildOffsets();
+    let lo = 0;
+    let hi = itemCount - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >>> 1;
+      if (offsets[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo;
+  };
+  const invalidate = (event) => {
+    offsets = null;
+    for (const l of listeners) l(event);
+  };
+  return {
+    get itemCount() {
+      return itemCount;
+    },
+    get measuredCount() {
+      return measured.size;
+    },
+    setItemCount(count) {
+      if (count === itemCount) return;
+      if (count < itemCount && measured.size > 0) {
+        for (const k of [...measured.keys()]) {
+          if (k >= count) measured.delete(k);
+        }
+      }
+      itemCount = count;
+      invalidate("resize");
+    },
+    setEstimate(e) {
+      estimate = e;
+      invalidate("reset");
+    },
+    setMeasuredHeight(index, height) {
+      if (index < 0 || index >= itemCount) return false;
+      if (!Number.isFinite(height) || height < 0) return false;
+      const prev = measured.get(index);
+      if (prev === height) return false;
+      measured.set(index, height);
+      invalidate("measure");
+      return true;
+    },
+    clearMeasured(index) {
+      const had = measured.delete(index);
+      if (had) invalidate("measure");
+      return had;
+    },
+    reset() {
+      if (measured.size === 0) return;
+      measured.clear();
+      invalidate("reset");
+    },
+    hasMeasured(index) {
+      return measured.has(index);
+    },
+    getMeasuredHeight(index) {
+      return measured.get(index);
+    },
+    getEstimatedSize: getEstimate,
+    getItemSize,
+    getItemOffset,
+    getItemAtOffset,
+    getTotalHeight,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+
+// src/engines/virtual/index.ts
+function createVirtual(options) {
+  let itemCount = options.itemCount;
+  let itemHeight = options.itemHeight;
+  const overscan = options.overscan ?? 5;
+  let cache = null;
+  const listeners = /* @__PURE__ */ new Set();
+  const ensureCache = () => {
+    if (cache) return cache;
+    cache = createMeasureCache({ itemCount, estimate: itemHeight });
+    cache.subscribe((event) => {
+      for (const l of listeners) l(event);
+    });
+    return cache;
+  };
+  const isFastPath = () => typeof itemHeight === "number" && (cache === null || cache.measuredCount === 0);
+  const getEstimate = (index) => typeof itemHeight === "number" ? itemHeight : itemHeight(index);
+  const getItemSize = (index) => {
+    if (cache) return cache.getItemSize(index);
+    return getEstimate(index);
+  };
+  const getTotalHeight = () => {
+    if (isFastPath()) return itemCount * itemHeight;
+    return ensureCache().getTotalHeight();
+  };
+  const getItemOffset = (index) => {
+    if (index <= 0) return 0;
+    if (index >= itemCount) return getTotalHeight();
+    if (isFastPath()) return index * itemHeight;
+    return ensureCache().getItemOffset(index);
+  };
+  const getItemAtOffset = (offset) => {
+    if (itemCount === 0) return 0;
+    if (isFastPath()) {
+      const h = itemHeight;
+      return Math.min(Math.floor(offset / h), itemCount - 1);
+    }
+    return ensureCache().getItemAtOffset(offset);
+  };
+  const getRange = (scrollTop, viewportHeight) => {
+    if (itemCount === 0) {
+      return { startIndex: 0, endIndex: 0, offsetTop: 0, totalHeight: 0, visibleItems: [] };
+    }
+    const total = getTotalHeight();
+    const rawStart = getItemAtOffset(scrollTop);
+    const startIndex = Math.max(0, rawStart - overscan);
+    let endIndex = rawStart;
+    let accHeight = getItemOffset(rawStart) + getItemSize(rawStart);
+    const bottomEdge = scrollTop + viewportHeight;
+    while (endIndex < itemCount - 1 && accHeight < bottomEdge) {
+      endIndex++;
+      accHeight += getItemSize(endIndex);
+    }
+    endIndex = Math.min(itemCount - 1, endIndex + overscan);
+    const visibleItems = [];
+    for (let i = startIndex; i <= endIndex; i++) {
+      visibleItems.push({
+        index: i,
+        offsetTop: getItemOffset(i),
+        height: getItemSize(i)
+      });
+    }
+    return {
+      startIndex,
+      endIndex,
+      offsetTop: getItemOffset(startIndex),
+      totalHeight: total,
+      visibleItems
+    };
+  };
+  const scrollToIndex = (index, viewportHeight, align = "start") => {
+    const clamped = Math.max(0, Math.min(index, itemCount - 1));
+    const offset = getItemOffset(clamped);
+    const h = getItemSize(clamped);
+    switch (align) {
+      case "center":
+        return Math.max(0, offset - viewportHeight / 2 + h / 2);
+      case "end":
+        return Math.max(0, offset - viewportHeight + h);
+      default:
+        return offset;
+    }
+  };
+  const emit = (event) => {
+    for (const l of listeners) l(event);
+  };
+  return {
+    get itemCount() {
+      return itemCount;
+    },
+    get totalHeight() {
+      return getTotalHeight();
+    },
+    get measuredCount() {
+      return cache?.measuredCount ?? 0;
+    },
+    setItemCount(count) {
+      if (count === itemCount) return;
+      itemCount = count;
+      if (cache) {
+        cache.setItemCount(count);
+      } else {
+        emit("resize");
+      }
+    },
+    setItemHeight(height) {
+      itemHeight = height;
+      if (cache) {
+        cache.setEstimate(height);
+      } else {
+        emit("reset");
+      }
+    },
+    setMeasuredHeight(index, height) {
+      return ensureCache().setMeasuredHeight(index, height);
+    },
+    clearMeasuredHeight(index) {
+      if (!cache) return false;
+      return cache.clearMeasured(index);
+    },
+    resetMeasurements() {
+      if (cache) cache.reset();
+    },
+    hasMeasured(index) {
+      return cache ? cache.hasMeasured(index) : false;
+    },
+    getEstimatedSize: getEstimate,
+    getItemSize,
+    getRange,
+    getItemOffset,
+    getItemAtOffset,
+    scrollToIndex,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+
+// src/typed.ts
+function createTypedCore(core) {
+  return {
+    get: core.get.bind(core),
+    set: core.set.bind(core),
+    subscribe: core.subscribe.bind(core),
+    batch: core.batch.bind(core),
+    transaction: core.transaction.bind(core),
+    computed: core.computed.bind(core),
+    raw: core
+  };
+}
+
+// src/engines/namespaces.ts
+var reserved = /* @__PURE__ */ new Map();
+function reservePrefix(engine, prefix) {
+  if (!prefix.startsWith("$") || !prefix.endsWith(".")) {
+    throw new Error(
+      `[skygraph] engine "${engine}" tried to reserve invalid prefix "${prefix}". Engine prefixes must start with "$" and end with ".".`
+    );
+  }
+  const existing = reserved.get(prefix);
+  if (existing !== void 0 && existing !== engine) {
+    throw new Error(
+      `[skygraph] prefix "${prefix}" is already owned by engine "${existing}", cannot reserve it for "${engine}". Pick a different prefix or update the registry.`
+    );
+  }
+  reserved.set(prefix, engine);
+  return prefix;
+}
+function listReservedPrefixes() {
+  return new Map(reserved);
+}
+var FORM_META_PREFIX = reservePrefix("form", "$meta.");
+var TABLE_PREFIX = reservePrefix("table", "$table.");
+var TREE_PREFIX = reservePrefix("tree", "$tree.");
+var GRAPH_PREFIX = reservePrefix("graph", "$graph.");
+var CALENDAR_PREFIX = reservePrefix("calendar", "$calendar.");
+
+// src/engines/form/FormEngine.ts
+function metaPath(name, field) {
+  return `${FORM_META_PREFIX}${name}.${field}`;
+}
+function interpolateMessage(template, vars) {
+  return template.replace(/\$\{(\w+)\}/g, (_, key2) => {
+    return vars[key2] != null ? String(vars[key2]) : "";
+  });
+}
+function compileRule(rule, templates, fieldLabel) {
+  if (typeof rule === "function") return rule;
+  const obj = rule;
+  const vars = { label: fieldLabel ?? "Field" };
+  return (value, getFieldValue) => {
+    if (obj.required) {
+      if (value === void 0 || value === null || value === "") {
+        const tpl = templates?.required ?? obj.message;
+        return tpl ? interpolateMessage(tpl, vars) : obj.message ?? "This field is required";
+      }
+    }
+    if (value === void 0 || value === null || value === "") return null;
+    if (obj.type) {
+      switch (obj.type) {
+        case "string":
+          if (typeof value !== "string") return obj.message ?? "Must be a string";
+          break;
+        case "number":
+          if (typeof value !== "number" || isNaN(value)) return obj.message ?? "Must be a number";
+          break;
+        case "email":
+          if (typeof value !== "string" || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
+            return obj.message ?? "Invalid email";
+          break;
+        case "url":
+          try {
+            new URL(value);
+          } catch {
+            return obj.message ?? "Invalid URL";
+          }
+          break;
+        case "boolean":
+          if (typeof value !== "boolean") return obj.message ?? "Must be a boolean";
+          break;
+      }
+    }
+    if (obj.min !== void 0) {
+      vars.min = obj.min;
+      if (typeof value === "string" && value.length < obj.min) {
+        const tpl = templates?.min ?? obj.message;
+        return tpl ? interpolateMessage(tpl, vars) : obj.message ?? `Minimum ${obj.min} characters`;
+      }
+      if (typeof value === "number" && value < obj.min)
+        return obj.message ?? `Minimum value is ${obj.min}`;
+    }
+    if (obj.max !== void 0) {
+      vars.max = obj.max;
+      if (typeof value === "string" && value.length > obj.max) {
+        const tpl = templates?.max ?? obj.message;
+        return tpl ? interpolateMessage(tpl, vars) : obj.message ?? `Maximum ${obj.max} characters`;
+      }
+      if (typeof value === "number" && value > obj.max)
+        return obj.message ?? `Maximum value is ${obj.max}`;
+    }
+    if (obj.pattern) {
+      if (typeof value === "string" && !obj.pattern.test(value))
+        return obj.message ?? "Invalid format";
+    }
+    if (obj.validator) {
+      return obj.validator(value, getFieldValue);
+    }
+    return null;
+  };
+}
+function computeStatus(meta) {
+  if (meta.validating) return "validating";
+  if (meta.errors.length > 0) return "error";
+  if (meta.warnings.length > 0) return "warning";
+  return void 0;
+}
+function createForm(core, options) {
+  const fields = /* @__PURE__ */ new Map();
+  const depMap = /* @__PURE__ */ new Map();
+  const debounceTimers = /* @__PURE__ */ new Map();
+  const preservedValues = /* @__PURE__ */ new Map();
+  let isSubmitting = false;
+  if (options?.defaultValues) {
+    for (const [key2, value] of Object.entries(options.defaultValues)) {
+      core.set(key2, value);
+    }
+  }
+  function setMeta(name, meta) {
+    for (const [key2, value] of Object.entries(meta)) {
+      core.set(metaPath(name, key2), value);
+    }
+  }
+  function getMeta(name) {
+    const errors = core.get(metaPath(name, "errors")) ?? [];
+    const warnings = core.get(metaPath(name, "warnings")) ?? [];
+    const validating = core.get(metaPath(name, "validating")) ?? false;
+    const touched = core.get(metaPath(name, "touched")) ?? false;
+    const dirty = core.get(metaPath(name, "dirty")) ?? false;
+    return {
+      touched,
+      dirty,
+      errors,
+      warnings,
+      validating,
+      status: computeStatus({ errors, warnings, validating }),
+      error: errors[0] ?? null
+    };
+  }
+  function initMeta(name) {
+    setMeta(name, {
+      touched: false,
+      dirty: false,
+      errors: [],
+      warnings: [],
+      validating: false
+    });
+  }
+  const getFieldValue = (fieldName) => core.get(fieldName);
+  function fireValuesChange(changedName) {
+    if (!options?.onValuesChange) return;
+    const changed = { [changedName]: core.get(changedName) };
+    const all = {};
+    for (const n of fields.keys()) all[n] = core.get(n);
+    options.onValuesChange(changed, all);
+  }
+  function fireFieldsChange(changedName) {
+    if (!options?.onFieldsChange) return;
+    const meta = getMeta(changedName);
+    options.onFieldsChange([{
+      name: changedName,
+      value: core.get(changedName),
+      errors: meta.errors
+    }]);
+  }
+  async function runValidation(name) {
+    const record = fields.get(name);
+    if (!record) return [];
+    const value = core.get(name);
+    const validateFirst = record.options.validateFirst ?? options?.validateFirst ?? false;
+    record.abortController?.abort();
+    const controller = new AbortController();
+    record.abortController = controller;
+    const errors = [];
+    for (const rule of record.rules) {
+      if (controller.signal.aborted) return [];
+      const result = rule.fn(value, getFieldValue);
+      if (result instanceof Promise) {
+        setMeta(name, { validating: true });
+        try {
+          const asyncResult = await result;
+          if (controller.signal.aborted) return [];
+          if (asyncResult) {
+            errors.push(asyncResult);
+            if (validateFirst) break;
+          }
+        } catch {
+          if (controller.signal.aborted) return [];
+          errors.push("Validation failed");
+          if (validateFirst) break;
+        }
+      } else if (result) {
+        errors.push(result);
+        if (validateFirst) break;
+      }
+    }
+    const warnings = [];
+    for (const rule of record.warningRules) {
+      if (controller.signal.aborted) return [];
+      const result = rule.fn(value, getFieldValue);
+      if (result instanceof Promise) {
+        try {
+          const asyncResult = await result;
+          if (controller.signal.aborted) return [];
+          if (asyncResult) warnings.push(asyncResult);
+        } catch {
+        }
+      } else if (result) {
+        warnings.push(result);
+      }
+    }
+    if (!controller.signal.aborted) {
+      setMeta(name, { errors, warnings, validating: false });
+      fireFieldsChange(name);
+    }
+    return errors;
+  }
+  async function validateDependents(name) {
+    for (const [target, deps] of depMap) {
+      if (deps.includes(name)) {
+        await runValidation(target);
+      }
+    }
+  }
+  const form = {
+    register(name, fieldOptions) {
+      const opts = fieldOptions ?? {};
+      const templates = options?.validateMessages;
+      const label = opts.label;
+      fields.set(name, {
+        rules: opts.rules ? opts.rules.map((r) => ({ original: r, fn: compileRule(r, templates, label) })) : [],
+        warningRules: opts.warningRules ? opts.warningRules.map((r) => ({ original: r, fn: compileRule(r, templates, label) })) : [],
+        options: opts,
+        abortController: null
+      });
+      if (preservedValues.has(name)) {
+        core.set(name, preservedValues.get(name));
+        preservedValues.delete(name);
+      } else if (opts.defaultValue !== void 0 && core.get(name) === void 0) {
+        core.set(name, opts.defaultValue);
+      }
+      if (opts.dependencies) {
+        depMap.set(name, [...opts.dependencies]);
+      }
+      core.batch(() => {
+        initMeta(name);
+      });
+    },
+    unregister(name) {
+      const record = fields.get(name);
+      if (!record) return;
+      record.abortController?.abort();
+      const timer = debounceTimers.get(name);
+      if (timer) {
+        clearTimeout(timer);
+        debounceTimers.delete(name);
+      }
+      if (record.options.preserve) {
+        preservedValues.set(name, core.get(name));
+      }
+      fields.delete(name);
+      depMap.delete(name);
+    },
+    setValue(name, value) {
+      core.transaction(() => {
+        core.set(name, value);
+        setMeta(name, { dirty: true, touched: true });
+      });
+      fireValuesChange(name);
+      const mode = fields.get(name)?.options.validateOn ?? options?.validateOn ?? "change";
+      if (mode === "change") {
+        const debounceMs = options?.asyncDebounceMs;
+        if (debounceMs && debounceMs > 0) {
+          const existing = debounceTimers.get(name);
+          if (existing) clearTimeout(existing);
+          debounceTimers.set(
+            name,
+            setTimeout(() => {
+              debounceTimers.delete(name);
+              runValidation(name).then(() => validateDependents(name));
+            }, debounceMs)
+          );
+        } else {
+          runValidation(name).then(() => validateDependents(name));
+        }
+      }
+    },
+    getValue(name) {
+      return core.get(name);
+    },
+    onFieldBlur(name) {
+      setMeta(name, { touched: true });
+      const mode = fields.get(name)?.options.validateOn ?? options?.validateOn ?? "change";
+      if (mode === "blur") {
+        runValidation(name).then(() => validateDependents(name));
+      }
+    },
+    setFieldsValue(values) {
+      core.batch(() => {
+        for (const [name, value] of Object.entries(values)) {
+          core.set(name, value);
+          if (fields.has(name)) {
+            setMeta(name, { dirty: true, touched: true });
+          }
+        }
+      });
+      for (const name of Object.keys(values)) {
+        fireValuesChange(name);
+      }
+    },
+    getFieldsValue() {
+      const values = {};
+      for (const name of fields.keys()) {
+        values[name] = core.get(name);
+      }
+      return values;
+    },
+    getFieldState(name) {
+      return getMeta(name);
+    },
+    getFormState() {
+      let isDirty = false;
+      let isValid = true;
+      let isValidating = false;
+      for (const name of fields.keys()) {
+        const meta = getMeta(name);
+        if (meta.dirty) isDirty = true;
+        if (meta.errors.length > 0) isValid = false;
+        if (meta.validating) isValidating = true;
+      }
+      return { isDirty, isValid, isSubmitting, isValidating };
+    },
+    addRule(name, rule) {
+      const record = fields.get(name);
+      if (!record) return;
+      record.rules.push({
+        original: rule,
+        fn: compileRule(rule, options?.validateMessages, record.options.label)
+      });
+    },
+    removeRule(name, rule) {
+      const record = fields.get(name);
+      if (!record) return;
+      const idx = record.rules.findIndex((r) => r.original === rule);
+      if (idx !== -1) record.rules.splice(idx, 1);
+    },
+    depends(target, deps) {
+      depMap.set(target, [...deps]);
+    },
+    async validate(name) {
+      const errors = {};
+      const warnings = {};
+      if (name) {
+        const errs = await runValidation(name);
+        if (errs.length > 0) errors[name] = errs;
+        const meta = getMeta(name);
+        if (meta.warnings.length > 0) warnings[name] = meta.warnings;
+      } else {
+        const promises = [];
+        for (const fieldName of fields.keys()) {
+          promises.push(
+            runValidation(fieldName).then((errs) => {
+              if (errs.length > 0) errors[fieldName] = errs;
+              const meta = getMeta(fieldName);
+              if (meta.warnings.length > 0) warnings[fieldName] = meta.warnings;
+            })
+          );
+        }
+        await Promise.all(promises);
+      }
+      return { valid: Object.keys(errors).length === 0, errors, warnings };
+    },
+    async submit(handler) {
+      isSubmitting = true;
+      core.batch(() => {
+        for (const name of fields.keys()) {
+          setMeta(name, { touched: true });
+        }
+      });
+      const result = await form.validate();
+      if (!result.valid) {
+        isSubmitting = false;
+        return;
+      }
+      const values = {};
+      for (const name of fields.keys()) {
+        values[name] = core.get(name);
+      }
+      try {
+        await handler(values);
+      } finally {
+        isSubmitting = false;
+      }
+    },
+    reset(values) {
+      core.batch(() => {
+        for (const [name, record] of fields) {
+          record.abortController?.abort();
+          record.abortController = null;
+          const resetValue = values?.[name] ?? options?.defaultValues?.[name] ?? record.options.defaultValue ?? void 0;
+          core.set(name, resetValue);
+          initMeta(name);
+        }
+      });
+      preservedValues.clear();
+    },
+    getFieldNames() {
+      return [...fields.keys()];
+    },
+    // Manual error/warning control
+    setFieldError(name, errs) {
+      const arr = typeof errs === "string" ? [errs] : errs;
+      setMeta(name, { errors: arr });
+      fireFieldsChange(name);
+    },
+    setFieldWarning(name, warns) {
+      const arr = typeof warns === "string" ? [warns] : warns;
+      setMeta(name, { warnings: arr });
+    },
+    clearFieldErrors(name) {
+      setMeta(name, { errors: [], warnings: [] });
+      fireFieldsChange(name);
+    },
+    getFieldErrors(name) {
+      return getMeta(name).errors;
+    },
+    getFieldWarnings(name) {
+      return getMeta(name).warnings;
+    },
+    isFieldTouched(name) {
+      return getMeta(name).touched;
+    },
+    isFieldValidating(name) {
+      return getMeta(name).validating;
+    },
+    // List operations
+    getListValue(name) {
+      const val = core.get(name);
+      return Array.isArray(val) ? val : [];
+    },
+    listAdd(name, defaultValue, insertIndex) {
+      const current = form.getListValue(name);
+      if (insertIndex !== void 0 && insertIndex >= 0 && insertIndex <= current.length) {
+        const next = [...current];
+        next.splice(insertIndex, 0, defaultValue ?? null);
+        core.set(name, next);
+      } else {
+        core.set(name, [...current, defaultValue ?? null]);
+      }
+    },
+    listRemove(name, index) {
+      const current = form.getListValue(name);
+      if (Array.isArray(index)) {
+        const indices = new Set(index);
+        core.set(name, current.filter((_, i) => !indices.has(i)));
+      } else {
+        core.set(name, current.filter((_, i) => i !== index));
+      }
+    },
+    listMove(name, from, to) {
+      const current = [...form.getListValue(name)];
+      if (from < 0 || from >= current.length || to < 0 || to >= current.length) return;
+      const [item] = current.splice(from, 1);
+      current.splice(to, 0, item);
+      core.set(name, current);
+    },
+    listReplace(name, values) {
+      core.set(name, [...values]);
+    }
+  };
+  return form;
+}
+
+// src/engines/graph/history.ts
+var HISTORY_LIMIT = 100;
+function createHistory2(limit = HISTORY_LIMIT) {
+  const undoStack = [];
+  const redoStack = [];
+  function trim(stack) {
+    while (stack.length > limit) stack.shift();
+  }
+  return {
+    push(entry) {
+      undoStack.push(entry);
+      trim(undoStack);
+    },
+    popUndo() {
+      return undoStack.pop();
+    },
+    pushRedo(entry) {
+      redoStack.push(entry);
+      trim(redoStack);
+    },
+    popRedo() {
+      return redoStack.pop();
+    },
+    clearRedo() {
+      redoStack.length = 0;
+    },
+    canUndo() {
+      return undoStack.length > 0;
+    },
+    canRedo() {
+      return redoStack.length > 0;
+    },
+    clear() {
+      undoStack.length = 0;
+      redoStack.length = 0;
+    },
+    relabelTop(label) {
+      const top = undoStack[undoStack.length - 1];
+      if (!top) return;
+      undoStack[undoStack.length - 1] = { snapshot: top.snapshot, label };
+    },
+    topLabel() {
+      return undoStack[undoStack.length - 1]?.label;
+    },
+    size() {
+      return { undo: undoStack.length, redo: redoStack.length };
+    }
+  };
+}
+
+// src/engines/graph/GraphEngine.ts
+var engineCounter = 0;
+var DEFAULT_OUTLINE = { kind: "rect", w: 100, h: 60 };
+var DEFAULT_TRANSFORM = { x: 0, y: 0 };
+var DEFAULT_ANCHOR_POLICY = { kind: "perEdge", k: 1 };
+function createGraph(core, options) {
+  const engineId = `g${engineCounter++}${options?.name ? `-${options.name}` : ""}`;
+  const prefix = GRAPH_PREFIX;
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const edgesByNode = /* @__PURE__ */ new Map();
+  let nodeCounter = 0;
+  let edgeCounter = 0;
+  const localSubscribers = /* @__PURE__ */ new Set();
+  function publishSnapshot() {
+    core.set(`${prefix}snapshot.${engineId}`, {
+      nodes: Array.from(nodes.values()),
+      edges: Array.from(edges.values())
+    });
+    for (const cb of localSubscribers) cb();
+  }
+  function subscribeLocal(cb) {
+    localSubscribers.add(cb);
+    return () => {
+      localSubscribers.delete(cb);
+    };
+  }
+  publishSnapshot();
+  const history = createHistory2(HISTORY_LIMIT);
+  let transactionDepth = 0;
+  let pendingEntry = null;
+  let isRestoring = false;
+  function _captureState() {
+    return {
+      nodes: Array.from(nodes.values()),
+      edges: Array.from(edges.values()),
+      nodeCounter,
+      edgeCounter
+    };
+  }
+  function _restoreState(snapshot) {
+    nodes.clear();
+    edges.clear();
+    edgesByNode.clear();
+    for (const n of snapshot.nodes) {
+      nodes.set(n.id, n);
+      edgesByNode.set(n.id, /* @__PURE__ */ new Set());
+    }
+    for (const e of snapshot.edges) {
+      edges.set(e.id, e);
+      ensureBucket(endpointNode(e.from)).add(e.id);
+      ensureBucket(endpointNode(e.to)).add(e.id);
+    }
+    nodeCounter = snapshot.nodeCounter;
+    edgeCounter = snapshot.edgeCounter;
+  }
+  function _withHistory(fn, label) {
+    if (isRestoring) return fn();
+    const wasOuter = transactionDepth === 0;
+    if (wasOuter) {
+      pendingEntry = { snapshot: _captureState(), label };
+    } else if (label !== void 0 && pendingEntry && pendingEntry.label === void 0) {
+      pendingEntry = { snapshot: pendingEntry.snapshot, label };
+    }
+    transactionDepth++;
+    try {
+      return fn();
+    } finally {
+      transactionDepth--;
+      if (transactionDepth === 0 && wasOuter) {
+        if (pendingEntry !== null) {
+          history.push(pendingEntry);
+          history.clearRedo();
+        }
+        pendingEntry = null;
+      }
+    }
+  }
+  function newNodeId() {
+    return `${engineId}-n${nodeCounter++}`;
+  }
+  function newEdgeId() {
+    return `${engineId}-e${edgeCounter++}`;
+  }
+  function ensureBucket(nodeId) {
+    let bucket = edgesByNode.get(nodeId);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      edgesByNode.set(nodeId, bucket);
+    }
+    return bucket;
+  }
+  function endpointNode(ep) {
+    return ep.node;
+  }
+  function bumpRevision(node) {
+    return { ...node, geomRevision: node.geomRevision + 1 };
+  }
+  function _addNodeImpl(init = {}) {
+    const id = init.id ?? newNodeId();
+    if (nodes.has(id)) {
+      throw new Error(`[skygraph/graph] node id "${id}" already exists`);
+    }
+    const node = {
+      id,
+      parentId: init.parentId ?? null,
+      transform: init.transform ?? { ...DEFAULT_TRANSFORM },
+      outline: init.outline ?? DEFAULT_OUTLINE,
+      anchorPolicy: init.anchorPolicy ?? DEFAULT_ANCHOR_POLICY,
+      data: init.data,
+      geomRevision: 0
+    };
+    nodes.set(id, node);
+    edgesByNode.set(id, /* @__PURE__ */ new Set());
+    publishSnapshot();
+    return id;
+  }
+  function addNode(init = {}) {
+    return _withHistory(() => _addNodeImpl(init));
+  }
+  function _removeNodeImpl(id) {
+    if (!nodes.has(id)) return;
+    const incident = edgesByNode.get(id);
+    if (incident) {
+      for (const eid of incident) removeEdge(eid);
+    }
+    for (const [otherId, n] of nodes) {
+      if (n.parentId === id) {
+        nodes.set(otherId, { ...n, parentId: null });
+      }
+    }
+    nodes.delete(id);
+    edgesByNode.delete(id);
+    publishSnapshot();
+  }
+  function removeNode(id) {
+    _withHistory(() => _removeNodeImpl(id));
+  }
+  function _updateNodeImpl(id, patch) {
+    const node = nodes.get(id);
+    if (!node) {
+      throw new Error(`[skygraph/graph] node "${id}" not found`);
+    }
+    const next = {
+      ...node,
+      transform: patch.transform ? { ...node.transform, ...patch.transform } : node.transform,
+      outline: patch.outline ?? node.outline,
+      anchorPolicy: patch.anchorPolicy ?? node.anchorPolicy,
+      data: patch.data === void 0 ? node.data : patch.data
+    };
+    const geomChanged = patch.transform !== void 0 || patch.outline !== void 0 || patch.anchorPolicy !== void 0;
+    nodes.set(id, geomChanged ? bumpRevision(next) : next);
+    publishSnapshot();
+  }
+  function updateNode(id, patch) {
+    _withHistory(() => _updateNodeImpl(id, patch));
+  }
+  function moveNode(id, x, y) {
+    _withHistory(() => _updateNodeImpl(id, { transform: { x, y } }));
+  }
+  function _setParentImpl(id, parentId) {
+    const node = nodes.get(id);
+    if (!node) {
+      throw new Error(`[skygraph/graph] node "${id}" not found`);
+    }
+    if (parentId !== null && !nodes.has(parentId)) {
+      throw new Error(`[skygraph/graph] parent node "${parentId}" not found`);
+    }
+    if (parentId === id) {
+      throw new Error(`[skygraph/graph] node cannot be its own parent ("${id}")`);
+    }
+    let cursor = parentId;
+    while (cursor !== null) {
+      if (cursor === id) {
+        throw new Error(`[skygraph/graph] setParent would create a cycle ("${id}" \u2192 "${parentId}")`);
+      }
+      cursor = nodes.get(cursor)?.parentId ?? null;
+    }
+    nodes.set(id, { ...node, parentId });
+    publishSnapshot();
+  }
+  function setParent(id, parentId) {
+    _withHistory(() => _setParentImpl(id, parentId));
+  }
+  function _addEdgeImpl(init) {
+    const id = init.id ?? newEdgeId();
+    if (edges.has(id)) {
+      throw new Error(`[skygraph/graph] edge id "${id}" already exists`);
+    }
+    const fromId = endpointNode(init.from);
+    const toId = endpointNode(init.to);
+    if (!nodes.has(fromId)) {
+      throw new Error(`[skygraph/graph] addEdge: from-node "${fromId}" not found`);
+    }
+    if (!nodes.has(toId)) {
+      throw new Error(`[skygraph/graph] addEdge: to-node "${toId}" not found`);
+    }
+    const edge = {
+      id,
+      from: init.from,
+      to: init.to,
+      routing: init.routing ?? "straight",
+      waypoints: init.waypoints,
+      data: init.data
+    };
+    edges.set(id, edge);
+    ensureBucket(fromId).add(id);
+    ensureBucket(toId).add(id);
+    publishSnapshot();
+    return id;
+  }
+  function addEdge(init) {
+    return _withHistory(() => _addEdgeImpl(init));
+  }
+  function _removeEdgeImpl(id) {
+    const edge = edges.get(id);
+    if (!edge) return;
+    edgesByNode.get(endpointNode(edge.from))?.delete(id);
+    edgesByNode.get(endpointNode(edge.to))?.delete(id);
+    edges.delete(id);
+    publishSnapshot();
+  }
+  function removeEdge(id) {
+    _withHistory(() => _removeEdgeImpl(id));
+  }
+  function getNode(id) {
+    return nodes.get(id);
+  }
+  function getEdge(id) {
+    return edges.get(id);
+  }
+  function getState() {
+    const byNode = /* @__PURE__ */ new Map();
+    for (const [nid, set] of edgesByNode) byNode.set(nid, Array.from(set));
+    return {
+      nodes: new Map(nodes),
+      edges: new Map(edges),
+      edgesByNode: byNode
+    };
+  }
+  function childrenOf(id) {
+    const out = [];
+    for (const n of nodes.values()) {
+      if (n.parentId === id) out.push(n.id);
+    }
+    return out;
+  }
+  function edgesOf(id) {
+    return Array.from(edgesByNode.get(id) ?? []);
+  }
+  function rectCornerId(corner) {
+    return corner;
+  }
+  function rectAnchors(w, h, policy) {
+    const corners = [
+      { id: rectCornerId("nw"), s: 0, point: [0, 0] },
+      { id: rectCornerId("ne"), s: 0.25, point: [w, 0] },
+      { id: rectCornerId("se"), s: 0.5, point: [w, h] },
+      { id: rectCornerId("sw"), s: 0.75, point: [0, h] }
+    ];
+    if (policy.kind === "manual") {
+      return policy.anchors.map((a) => ({
+        id: a.id,
+        s: a.s,
+        point: pointOnRectPerimeter(w, h, a.s)
+      }));
+    }
+    const k = policy.kind === "perEdge" ? Math.max(0, Math.floor(policy.k)) : null;
+    const density = policy.kind === "byLength" ? policy.density : null;
+    const out = [...corners];
+    const edgesGeom = [
+      { start: 0, end: 0.25 },
+      // top
+      { start: 0.25, end: 0.5 },
+      // right
+      { start: 0.5, end: 0.75 },
+      // bottom
+      { start: 0.75, end: 1 }
+      // left
+    ];
+    edgesGeom.forEach((edge, edgeIdx) => {
+      let count = 0;
+      if (k !== null) count = k;
+      if (density !== null) {
+        const len = edgeIdx % 2 === 0 ? w : h;
+        count = Math.max(0, Math.floor(len / density) - 1);
+      }
+      for (let i = 1; i <= count; i++) {
+        const t = i / (count + 1);
+        const s = edge.start + (edge.end - edge.start) * t;
+        out.push({
+          id: `edge${edgeIdx}-${i}of${count}`,
+          s,
+          point: pointOnRectPerimeter(w, h, s)
+        });
+      }
+    });
+    out.sort((a, b) => a.s - b.s);
+    return out;
+  }
+  function pointOnRectPerimeter(w, h, s) {
+    const ss = (s % 1 + 1) % 1;
+    if (ss < 0.25) return [w * (ss / 0.25), 0];
+    if (ss < 0.5) return [w, h * ((ss - 0.25) / 0.25)];
+    if (ss < 0.75) return [w * (1 - (ss - 0.5) / 0.25), h];
+    return [0, h * (1 - (ss - 0.75) / 0.25)];
+  }
+  function polygonAnchors(verts, policy) {
+    if (verts.length === 0) return [];
+    const segLengths = [];
+    let total = 0;
+    for (let i = 0; i < verts.length; i++) {
+      const a = verts[i];
+      const b = verts[(i + 1) % verts.length];
+      const dx = b[0] - a[0];
+      const dy = b[1] - a[1];
+      const len = Math.hypot(dx, dy);
+      segLengths.push(len);
+      total += len;
+    }
+    const cumS = [0];
+    for (let i = 0; i < segLengths.length; i++) {
+      cumS.push(cumS[i] + segLengths[i] / total);
+    }
+    function pointAt(s) {
+      const ss = (s % 1 + 1) % 1;
+      let i = 0;
+      while (i < cumS.length - 1 && cumS[i + 1] <= ss) i++;
+      const a = verts[i % verts.length];
+      const b = verts[(i + 1) % verts.length];
+      const segS0 = cumS[i];
+      const segS1 = cumS[i + 1];
+      const t = segS1 === segS0 ? 0 : (ss - segS0) / (segS1 - segS0);
+      return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+    }
+    if (policy.kind === "manual") {
+      return policy.anchors.map((a) => ({ id: a.id, s: a.s, point: pointAt(a.s) }));
+    }
+    const out = [];
+    for (let i = 0; i < verts.length; i++) {
+      out.push({
+        id: `v${i}`,
+        s: cumS[i],
+        point: [verts[i][0], verts[i][1]]
+      });
+    }
+    const k = policy.kind === "perEdge" ? Math.max(0, Math.floor(policy.k)) : null;
+    const density = policy.kind === "byLength" ? policy.density : null;
+    for (let i = 0; i < verts.length; i++) {
+      const segLen = segLengths[i];
+      let count = 0;
+      if (k !== null) count = k;
+      if (density !== null) count = Math.max(0, Math.floor(segLen / density) - 1);
+      const s0 = cumS[i];
+      const s1 = cumS[i + 1];
+      for (let j = 1; j <= count; j++) {
+        const t = j / (count + 1);
+        const s = s0 + (s1 - s0) * t;
+        out.push({ id: `v${i}-${j}of${count}`, s, point: pointAt(s) });
+      }
+    }
+    out.sort((a, b) => a.s - b.s);
+    return out;
+  }
+  function ellipseAnchors(rx, ry, policy) {
+    function pointAt(s) {
+      const angle = (s % 1 + 1) % 1 * Math.PI * 2;
+      return [rx * Math.cos(angle), ry * Math.sin(angle)];
+    }
+    if (policy.kind === "manual") {
+      return policy.anchors.map((a) => ({ id: a.id, s: a.s, point: pointAt(a.s) }));
+    }
+    const k = policy.kind === "perEdge" ? Math.max(1, Math.floor(policy.k)) : null;
+    const totalSamples = k !== null ? Math.max(4, k * 4) : Math.max(4, Math.floor(2 * Math.PI * Math.max(rx, ry) / policy.density));
+    const out = [];
+    for (let i = 0; i < totalSamples; i++) {
+      const s = i / totalSamples;
+      out.push({ id: `el${i}of${totalSamples}`, s, point: pointAt(s) });
+    }
+    return out;
+  }
+  function anchorsOf(id) {
+    const node = nodes.get(id);
+    if (!node) return [];
+    const o = node.outline;
+    if (o.kind === "rect") return rectAnchors(o.w, o.h, node.anchorPolicy);
+    if (o.kind === "polygon") return polygonAnchors(o.verts, node.anchorPolicy);
+    if (o.kind === "ellipse") return ellipseAnchors(o.rx, o.ry, node.anchorPolicy);
+    if (o.kind === "path") return polygonAnchors(o.flatten, node.anchorPolicy);
+    return [];
+  }
+  function localBounds(node) {
+    const o = node.outline;
+    if (o.kind === "rect") return { x0: 0, y0: 0, x1: o.w, y1: o.h };
+    if (o.kind === "ellipse") return { x0: -o.rx, y0: -o.ry, x1: o.rx, y1: o.ry };
+    const verts = o.kind === "polygon" ? o.verts : o.flatten;
+    if (verts.length === 0) return { x0: 0, y0: 0, x1: 0, y1: 0 };
+    let x0 = verts[0][0];
+    let x1 = verts[0][0];
+    let y0 = verts[0][1];
+    let y1 = verts[0][1];
+    for (const [x, y] of verts) {
+      if (x < x0) x0 = x;
+      if (x > x1) x1 = x;
+      if (y < y0) y0 = y;
+      if (y > y1) y1 = y;
+    }
+    return { x0, y0, x1, y1 };
+  }
+  function worldOriginOf(id) {
+    let cursor = id;
+    let x = 0;
+    let y = 0;
+    let scale = 1;
+    while (cursor !== null) {
+      const n = nodes.get(cursor);
+      if (!n) break;
+      const s = n.transform.scale ?? 1;
+      x = n.transform.x + x * s;
+      y = n.transform.y + y * s;
+      scale *= s;
+      cursor = n.parentId;
+    }
+    return { x, y, scale };
+  }
+  function boundsOf(id) {
+    const node = nodes.get(id);
+    if (!node) return { x: 0, y: 0, w: 0, h: 0 };
+    const lb = localBounds(node);
+    const origin = worldOriginOf(id);
+    const w = (lb.x1 - lb.x0) * origin.scale;
+    const h = (lb.y1 - lb.y0) * origin.scale;
+    return {
+      x: origin.x + lb.x0 * origin.scale,
+      y: origin.y + lb.y0 * origin.scale,
+      w,
+      h
+    };
+  }
+  function getNodeOBB(id) {
+    const node = nodes.get(id);
+    if (!node) return { center: [0, 0], halfWidth: 0, halfHeight: 0, angle: 0 };
+    const lb = localBounds(node);
+    const origin = worldOriginOf(id);
+    const localCx = (lb.x0 + lb.x1) / 2;
+    const localCy = (lb.y0 + lb.y1) / 2;
+    const halfWidth = Math.abs((lb.x1 - lb.x0) / 2 * origin.scale);
+    const halfHeight = Math.abs((lb.y1 - lb.y0) / 2 * origin.scale);
+    let angle = 0;
+    let cursor = id;
+    while (cursor !== null) {
+      const n = nodes.get(cursor);
+      if (!n) break;
+      angle += n.transform.rot ?? 0;
+      cursor = n.parentId;
+    }
+    const center = [
+      origin.x + localCx * origin.scale,
+      origin.y + localCy * origin.scale
+    ];
+    return { center, halfWidth, halfHeight, angle };
+  }
+  function clear() {
+    nodes.clear();
+    edges.clear();
+    edgesByNode.clear();
+    nodeCounter = 0;
+    edgeCounter = 0;
+    history.clear();
+    pendingEntry = null;
+    transactionDepth = 0;
+    isRestoring = false;
+    publishSnapshot();
+  }
+  function transaction(fn, label) {
+    _withHistory(fn, label);
+  }
+  function pushHistory(label) {
+    if (transactionDepth > 0) {
+      if (pendingEntry !== null) {
+        history.push({ snapshot: pendingEntry.snapshot, label: pendingEntry.label ?? label });
+        history.clearRedo();
+      }
+      pendingEntry = { snapshot: _captureState(), label: void 0 };
+      return;
+    }
+    history.relabelTop(label);
+  }
+  function undo() {
+    if (!history.canUndo()) return false;
+    const entry = history.popUndo();
+    history.pushRedo({ snapshot: _captureState(), label: entry.label });
+    isRestoring = true;
+    try {
+      _restoreState(entry.snapshot);
+    } finally {
+      isRestoring = false;
+    }
+    publishSnapshot();
+    return true;
+  }
+  function redo() {
+    if (!history.canRedo()) return false;
+    const entry = history.popRedo();
+    history.push({ snapshot: _captureState(), label: entry.label });
+    isRestoring = true;
+    try {
+      _restoreState(entry.snapshot);
+    } finally {
+      isRestoring = false;
+    }
+    publishSnapshot();
+    return true;
+  }
+  function canUndo() {
+    return history.canUndo();
+  }
+  function canRedo() {
+    return history.canRedo();
+  }
+  function clearHistory() {
+    history.clear();
+  }
+  return {
+    addNode,
+    removeNode,
+    updateNode,
+    moveNode,
+    setParent,
+    addEdge,
+    removeEdge,
+    getNode,
+    getEdge,
+    getState,
+    childrenOf,
+    edgesOf,
+    anchorsOf,
+    boundsOf,
+    getNodeOBB,
+    subscribe: subscribeLocal,
+    transaction,
+    pushHistory,
+    undo,
+    redo,
+    canUndo,
+    canRedo,
+    clearHistory,
+    clear
+  };
+}
+
+// src/engines/graph/router.ts
+function routeOrthogonal(start, end, options) {
+  const opts = typeof options === "string" ? { preferred: options } : options ?? {};
+  const gridSize = opts.gridSize ?? 10;
+  const stubLength = opts.stubLength ?? Math.max(20, gridSize);
+  const stepPosition = opts.stepPosition ?? 0.5;
+  let sExit = null;
+  let sStub = null;
+  let sCorner = null;
+  let sSide = null;
+  if (opts.sourceBounds) {
+    const exitInfo = exitOnNearestSide(opts.sourceBounds, end, start);
+    sExit = exitInfo.point;
+    sSide = exitInfo.side;
+    sStub = extrudePoint(exitInfo.point, exitInfo.side, stubLength);
+    sCorner = orthoBridge(start, sExit, exitInfo.side);
+  }
+  let tExit = null;
+  let tStub = null;
+  let tCorner = null;
+  let tSide = null;
+  if (opts.targetBounds) {
+    const enterInfo = exitOnNearestSide(opts.targetBounds, start, end);
+    tExit = enterInfo.point;
+    tSide = enterInfo.side;
+    tStub = extrudePoint(enterInfo.point, enterInfo.side, stubLength);
+    tCorner = orthoBridge(end, tExit, enterInfo.side);
+  }
+  const coreStart = sStub ?? start;
+  const coreEnd = tStub ?? end;
+  const obstacles = opts.obstacles ?? [];
+  const filteredObstacles = obstacles.length > 0 && (opts.sourceBounds || opts.targetBounds) ? obstacles.filter((o) => o !== opts.sourceBounds && o !== opts.targetBounds) : obstacles;
+  let core;
+  if (filteredObstacles.length === 0) {
+    if (sSide && tSide) {
+      core = smoothStepRoute(coreStart, sSide, coreEnd, tSide, stepPosition);
+    } else {
+      const snap2 = opts.snap ?? gridSize;
+      core = lRoute(coreStart, coreEnd, opts.preferred ?? "auto", snap2);
+    }
+  } else {
+    const inflate = opts.inflate ?? 0;
+    const maxNodes = opts.maxNodes ?? 5e3;
+    const aStar = aStarRoute(coreStart, coreEnd, filteredObstacles, gridSize, inflate, maxNodes);
+    core = aStar ?? lRoute(coreStart, coreEnd, opts.preferred ?? "auto", opts.snap ?? gridSize);
+  }
+  const points = [];
+  pushIfDistinct(points, start);
+  if (sCorner && !pointsEqual(sCorner, start)) pushIfDistinct(points, sCorner);
+  if (sExit && !pointsEqual(sExit, points[points.length - 1])) pushIfDistinct(points, sExit);
+  if (sStub && !pointsEqual(sStub, points[points.length - 1])) pushIfDistinct(points, sStub);
+  for (let i = 0; i < core.length; i++) {
+    const p = core[i];
+    if (i === 0 && sStub && pointsEqual(p, sStub)) continue;
+    if (i === core.length - 1 && tStub && pointsEqual(p, tStub)) continue;
+    pushIfDistinct(points, p);
+  }
+  if (tStub && !pointsEqual(tStub, points[points.length - 1])) pushIfDistinct(points, tStub);
+  if (tExit && !pointsEqual(tExit, points[points.length - 1])) pushIfDistinct(points, tExit);
+  if (tCorner && !pointsEqual(tCorner, points[points.length - 1])) pushIfDistinct(points, tCorner);
+  if (!pointsEqual(end, points[points.length - 1])) pushIfDistinct(points, end);
+  return compressCollinear(points);
+}
+function smoothStepRoute(coreStart, sSide, coreEnd, tSide, stepPosition) {
+  const [sx, sy] = coreStart;
+  const [tx, ty] = coreEnd;
+  const sAxis = sideAxis(sSide);
+  const tAxis = sideAxis(tSide);
+  const sDir = sideDir(sSide);
+  const tDir = sideDir(tSide);
+  if (sAxis === tAxis) {
+    if (sDir + tDir === 0) {
+      if (sAxis === "x") {
+        const cx = sx + (tx - sx) * stepPosition;
+        return [
+          [sx, sy],
+          [cx, sy],
+          [cx, ty],
+          [tx, ty]
+        ];
+      }
+      const cy = sy + (ty - sy) * stepPosition;
+      return [
+        [sx, sy],
+        [sx, cy],
+        [tx, cy],
+        [tx, ty]
+      ];
+    }
+    if (sAxis === "x") {
+      const extX = sDir > 0 ? Math.max(sx, tx) : Math.min(sx, tx);
+      return [
+        [sx, sy],
+        [extX, sy],
+        [extX, ty],
+        [tx, ty]
+      ];
+    }
+    const extY = sDir > 0 ? Math.max(sy, ty) : Math.min(sy, ty);
+    return [
+      [sx, sy],
+      [sx, extY],
+      [tx, extY],
+      [tx, ty]
+    ];
+  }
+  if (sAxis === "x") {
+    return [
+      [sx, sy],
+      [tx, sy],
+      [tx, ty]
+    ];
+  }
+  return [
+    [sx, sy],
+    [sx, ty],
+    [tx, ty]
+  ];
+}
+function sideAxis(s) {
+  return s === "left" || s === "right" ? "x" : "y";
+}
+function sideDir(s) {
+  return s === "right" || s === "bottom" ? 1 : -1;
+}
+function pointsToPath(points) {
+  if (points.length === 0) return "";
+  const [head, ...rest] = points;
+  return `M ${head[0]} ${head[1]} ${rest.map((p) => `L ${p[0]} ${p[1]}`).join(" ")}`;
+}
+function pointsToRoundedPath(points, radius) {
+  if (points.length === 0) return "";
+  if (points.length < 3 || radius <= 0) return pointsToPath(points);
+  let d = `M ${points[0][0]} ${points[0][1]}`;
+  for (let i = 1; i < points.length - 1; i++) {
+    const a = points[i - 1];
+    const b = points[i];
+    const c = points[i + 1];
+    const lenAB = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    const lenBC = Math.hypot(c[0] - b[0], c[1] - b[1]);
+    const r = Math.min(radius, lenAB / 2, lenBC / 2);
+    const ux = (b[0] - a[0]) / (lenAB || 1);
+    const uy = (b[1] - a[1]) / (lenAB || 1);
+    const vx = (c[0] - b[0]) / (lenBC || 1);
+    const vy = (c[1] - b[1]) / (lenBC || 1);
+    const cross = ux * vy - uy * vx;
+    if (r < 0.5 || Math.abs(cross) < 1e-9) {
+      d += ` L ${b[0]} ${b[1]}`;
+      continue;
+    }
+    const p1x = b[0] - ux * r;
+    const p1y = b[1] - uy * r;
+    const p2x = b[0] + vx * r;
+    const p2y = b[1] + vy * r;
+    d += ` L ${p1x} ${p1y} Q ${b[0]} ${b[1]} ${p2x} ${p2y}`;
+  }
+  const tail = points[points.length - 1];
+  d += ` L ${tail[0]} ${tail[1]}`;
+  return d;
+}
+function controlOffset(distance, curvature) {
+  if (distance >= 0) return 0.5 * distance;
+  return curvature * 25 * Math.sqrt(-distance);
+}
+function controlPoint(side, x1, y1, x2, y2, curvature) {
+  switch (side) {
+    case "left":
+      return [x1 - controlOffset(x1 - x2, curvature), y1];
+    case "right":
+      return [x1 + controlOffset(x2 - x1, curvature), y1];
+    case "top":
+      return [x1, y1 - controlOffset(y1 - y2, curvature)];
+    case "bottom":
+      return [x1, y1 + controlOffset(y2 - y1, curvature)];
+  }
+}
+function getBezierPath(opts) {
+  const curvature = opts.curvature ?? 0.25;
+  const [sx, sy] = opts.source;
+  const [tx, ty] = opts.target;
+  const [c1x, c1y] = controlPoint(opts.sourceSide, sx, sy, tx, ty, curvature);
+  const [c2x, c2y] = controlPoint(opts.targetSide, tx, ty, sx, sy, curvature);
+  return `M ${sx} ${sy} C ${c1x} ${c1y} ${c2x} ${c2y} ${tx} ${ty}`;
+}
+function floatingAnchor(box, opposite) {
+  const cx = box.x + box.w / 2;
+  const cy = box.y + box.h / 2;
+  const dx = opposite[0] - cx;
+  const dy = opposite[1] - cy;
+  if (dx === 0 && dy === 0) {
+    return { point: [box.x + box.w, cy], side: "right" };
+  }
+  const hw = box.w / 2;
+  const hh = box.h / 2;
+  const tx = dx === 0 ? Infinity : hw / Math.abs(dx);
+  const ty = dy === 0 ? Infinity : hh / Math.abs(dy);
+  if (tx < ty) {
+    const sign2 = dx > 0 ? 1 : -1;
+    return {
+      point: [cx + sign2 * hw, cy + sign2 * (hw / Math.abs(dx)) * dy],
+      side: sign2 > 0 ? "right" : "left"
+    };
+  }
+  const sign = dy > 0 ? 1 : -1;
+  return {
+    point: [cx + sign * (hh / Math.abs(dy)) * dx, cy + sign * hh],
+    side: sign > 0 ? "bottom" : "top"
+  };
+}
+function nearestSide(box, target) {
+  const cx = box.x + box.w / 2;
+  const cy = box.y + box.h / 2;
+  const dx = target[0] - cx;
+  const dy = target[1] - cy;
+  if (Math.abs(dx) >= Math.abs(dy)) return dx >= 0 ? "right" : "left";
+  return dy >= 0 ? "bottom" : "top";
+}
+function getNodeIntersection(intersectionBox, targetCenter) {
+  const w = intersectionBox.w / 2;
+  const h = intersectionBox.h / 2;
+  const x2 = intersectionBox.x + w;
+  const y2 = intersectionBox.y + h;
+  if (w === 0 || h === 0) return [x2, y2];
+  const x1 = targetCenter[0];
+  const y1 = targetCenter[1];
+  const xx1 = (x1 - x2) / (2 * w) - (y1 - y2) / (2 * h);
+  const yy1 = (x1 - x2) / (2 * w) + (y1 - y2) / (2 * h);
+  const denom = Math.abs(xx1) + Math.abs(yy1);
+  if (denom === 0) {
+    return [intersectionBox.x + intersectionBox.w, y2];
+  }
+  const a = 1 / denom;
+  const xx3 = a * xx1;
+  const yy3 = a * yy1;
+  const x = w * (xx3 + yy3) + x2;
+  const y = h * (-xx3 + yy3) + y2;
+  return [x, y];
+}
+function getEdgePosition(box, intersectionPoint) {
+  const nx = Math.round(box.x);
+  const ny = Math.round(box.y);
+  const px = Math.round(intersectionPoint[0]);
+  const py = Math.round(intersectionPoint[1]);
+  if (px <= nx + 1) return "left";
+  if (px >= nx + box.w - 1) return "right";
+  if (py <= ny + 1) return "top";
+  if (py >= ny + box.h - 1) return "bottom";
+  return "top";
+}
+function resolveEdgeEndpoint(sourceBox, targetBox, padding = 0) {
+  const targetCenter = [targetBox.x + targetBox.w / 2, targetBox.y + targetBox.h / 2];
+  const raw = getNodeIntersection(sourceBox, targetCenter);
+  const side = getEdgePosition(sourceBox, raw);
+  if (padding === 0) return { point: raw, side };
+  let point = raw;
+  switch (side) {
+    case "right":
+      point = [raw[0] + padding, raw[1]];
+      break;
+    case "left":
+      point = [raw[0] - padding, raw[1]];
+      break;
+    case "bottom":
+      point = [raw[0], raw[1] + padding];
+      break;
+    case "top":
+      point = [raw[0], raw[1] - padding];
+      break;
+  }
+  return { point, side };
+}
+function inferSide(box, anchor, opposite, tolerance = 1) {
+  const onLeft = Math.abs(anchor[0] - box.x) <= tolerance;
+  const onRight = Math.abs(anchor[0] - (box.x + box.w)) <= tolerance;
+  const onTop = Math.abs(anchor[1] - box.y) <= tolerance;
+  const onBottom = Math.abs(anchor[1] - (box.y + box.h)) <= tolerance;
+  const horizontalHit = onLeft || onRight;
+  const verticalHit = onTop || onBottom;
+  if (horizontalHit && verticalHit) {
+    const cx = box.x + box.w / 2;
+    const cy = box.y + box.h / 2;
+    const dx = opposite[0] - cx;
+    const dy = opposite[1] - cy;
+    if (Math.abs(dx) >= Math.abs(dy)) {
+      return { side: onRight ? "right" : "left", confident: true };
+    }
+    return { side: onBottom ? "bottom" : "top", confident: true };
+  }
+  if (onLeft) return { side: "left", confident: true };
+  if (onRight) return { side: "right", confident: true };
+  if (onTop) return { side: "top", confident: true };
+  if (onBottom) return { side: "bottom", confident: true };
+  return { side: nearestSide(box, opposite), confident: false };
+}
+function exitOnNearestSide(box, target, anchor) {
+  const cx = box.x + box.w / 2;
+  const cy = box.y + box.h / 2;
+  if (anchor) {
+    const tolerance = 1;
+    const onLeft = Math.abs(anchor[0] - box.x) <= tolerance;
+    const onRight = Math.abs(anchor[0] - (box.x + box.w)) <= tolerance;
+    const onTop = Math.abs(anchor[1] - box.y) <= tolerance;
+    const onBottom = Math.abs(anchor[1] - (box.y + box.h)) <= tolerance;
+    const horizontalHit = onLeft || onRight;
+    const verticalHit = onTop || onBottom;
+    if (horizontalHit && verticalHit) {
+      const dx2 = target[0] - cx;
+      const dy2 = target[1] - cy;
+      if (Math.abs(dx2) >= Math.abs(dy2)) {
+        return onRight ? { point: [box.x + box.w, cy], side: "right" } : { point: [box.x, cy], side: "left" };
+      }
+      return onBottom ? { point: [cx, box.y + box.h], side: "bottom" } : { point: [cx, box.y], side: "top" };
+    }
+    if (onRight) return { point: [box.x + box.w, cy], side: "right" };
+    if (onLeft) return { point: [box.x, cy], side: "left" };
+    if (onBottom) return { point: [cx, box.y + box.h], side: "bottom" };
+    if (onTop) return { point: [cx, box.y], side: "top" };
+  }
+  const dx = target[0] - cx;
+  const dy = target[1] - cy;
+  if (Math.abs(dx) >= Math.abs(dy)) {
+    if (dx >= 0) return { point: [box.x + box.w, cy], side: "right" };
+    return { point: [box.x, cy], side: "left" };
+  }
+  if (dy >= 0) return { point: [cx, box.y + box.h], side: "bottom" };
+  return { point: [cx, box.y], side: "top" };
+}
+function extrudePoint(point, side, distance) {
+  switch (side) {
+    case "top":
+      return [point[0], point[1] - distance];
+    case "right":
+      return [point[0] + distance, point[1]];
+    case "bottom":
+      return [point[0], point[1] + distance];
+    case "left":
+      return [point[0] - distance, point[1]];
+  }
+}
+function orthoBridge(start, exit, side) {
+  switch (side) {
+    case "right":
+    case "left":
+      return [exit[0], start[1]];
+    case "top":
+    case "bottom":
+      return [start[0], exit[1]];
+  }
+}
+function pointsEqual(a, b) {
+  return a[0] === b[0] && a[1] === b[1];
+}
+function pushIfDistinct(arr, p) {
+  if (arr.length === 0) {
+    arr.push(p);
+    return;
+  }
+  const last = arr[arr.length - 1];
+  if (!pointsEqual(last, p)) arr.push(p);
+}
+function compressCollinear(points) {
+  if (points.length <= 2) return points.slice();
+  const out = [points[0], points[1]];
+  for (let i = 2; i < points.length; i++) {
+    const cur = points[i];
+    const a = out[out.length - 2];
+    const b = out[out.length - 1];
+    const dx1 = b[0] - a[0];
+    const dy1 = b[1] - a[1];
+    const dx2 = cur[0] - b[0];
+    const dy2 = cur[1] - b[1];
+    const cross = dx1 * dy2 - dy1 * dx2;
+    if (cross === 0 && Math.sign(dx1) === Math.sign(dx2) && Math.sign(dy1) === Math.sign(dy2)) {
+      out[out.length - 1] = cur;
+    } else {
+      out.push(cur);
+    }
+  }
+  return out;
+}
+function lRoute(start, end, preferred, _snapStep) {
+  const [sx, sy] = start;
+  const [ex, ey] = end;
+  if (sx === ex || sy === ey) return [start, end];
+  const dx = Math.abs(ex - sx);
+  const dy = Math.abs(ey - sy);
+  const useHV = preferred === "hv" ? true : preferred === "vh" ? false : dx >= dy;
+  if (useHV) return [start, [ex, sy], end];
+  return [start, [sx, ey], end];
+}
+function inflateObstacles(obstacles, pad) {
+  return obstacles.map((o) => ({
+    x0: o.x - pad,
+    y0: o.y - pad,
+    x1: o.x + o.w + pad,
+    y1: o.y + o.h + pad
+  }));
+}
+function pointBlocked(x, y, rects) {
+  for (const r of rects) {
+    if (x > r.x0 && x < r.x1 && y > r.y0 && y < r.y1) return true;
+  }
+  return false;
+}
+function snap(value, step) {
+  return Math.round(value / step) * step;
+}
+function key(x, y) {
+  return `${x},${y}`;
+}
+function manhattan(ax, ay, bx, by) {
+  return Math.abs(ax - bx) + Math.abs(ay - by);
+}
+function reconstruct(cameFrom, endKey) {
+  const reversed = [];
+  let cursor = endKey;
+  while (cursor !== void 0) {
+    const [xs, ys] = cursor.split(",");
+    reversed.push([Number(xs), Number(ys)]);
+    cursor = cameFrom.get(cursor);
+  }
+  reversed.reverse();
+  const out = [];
+  for (let i = 0; i < reversed.length; i++) {
+    const cur = reversed[i];
+    if (out.length < 2) {
+      out.push(cur);
+      continue;
+    }
+    const a = out[out.length - 2];
+    const b = out[out.length - 1];
+    const dx1 = b[0] - a[0];
+    const dy1 = b[1] - a[1];
+    const dx2 = cur[0] - b[0];
+    const dy2 = cur[1] - b[1];
+    if (Math.sign(dx1) === Math.sign(dx2) && Math.sign(dy1) === Math.sign(dy2)) {
+      out[out.length - 1] = cur;
+    } else {
+      out.push(cur);
+    }
+  }
+  return out;
+}
+var MinHeap = class {
+  data = [];
+  get size() {
+    return this.data.length;
+  }
+  push(entry) {
+    this.data.push(entry);
+    this.bubbleUp(this.data.length - 1);
+  }
+  pop() {
+    if (this.data.length === 0) return void 0;
+    const head = this.data[0];
+    const tail = this.data.pop();
+    if (this.data.length > 0) {
+      this.data[0] = tail;
+      this.bubbleDown(0);
+    }
+    return head;
+  }
+  bubbleUp(i) {
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      if (this.data[i].f < this.data[parent].f) {
+        const tmp = this.data[i];
+        this.data[i] = this.data[parent];
+        this.data[parent] = tmp;
+        i = parent;
+      } else {
+        return;
+      }
+    }
+  }
+  bubbleDown(i) {
+    const n = this.data.length;
+    while (true) {
+      const l = i * 2 + 1;
+      const r = l + 1;
+      let smallest = i;
+      if (l < n && this.data[l].f < this.data[smallest].f) smallest = l;
+      if (r < n && this.data[r].f < this.data[smallest].f) smallest = r;
+      if (smallest === i) return;
+      const tmp = this.data[i];
+      this.data[i] = this.data[smallest];
+      this.data[smallest] = tmp;
+      i = smallest;
+    }
+  }
+};
+function aStarRoute(start, end, obstacles, gridSize, inflate, maxNodes) {
+  const rects = inflateObstacles(obstacles, inflate);
+  const sx = snap(start[0], gridSize);
+  const sy = snap(start[1], gridSize);
+  const ex = snap(end[0], gridSize);
+  const ey = snap(end[1], gridSize);
+  if (pointBlocked(sx, sy, rects) || pointBlocked(ex, ey, rects)) return null;
+  const startKey = key(sx, sy);
+  const endKey = key(ex, ey);
+  const gScore = /* @__PURE__ */ new Map([[startKey, 0]]);
+  const cameFrom = /* @__PURE__ */ new Map();
+  const cameDir = /* @__PURE__ */ new Map([[startKey, null]]);
+  const open = new MinHeap();
+  open.push({ k: startKey, x: sx, y: sy, f: manhattan(sx, sy, ex, ey) });
+  const TURN_PENALTY = gridSize;
+  let expansions = 0;
+  while (open.size > 0) {
+    if (expansions++ > maxNodes) return null;
+    const current = open.pop();
+    const bestG = gScore.get(current.k) ?? Infinity;
+    const expectedF = bestG + manhattan(current.x, current.y, ex, ey);
+    if (current.f > expectedF) continue;
+    if (current.k === endKey) {
+      const path = reconstruct(cameFrom, endKey);
+      if (path.length > 0) {
+        path[0] = start;
+        path[path.length - 1] = end;
+      }
+      return path;
+    }
+    const incomingDir = cameDir.get(current.k) ?? null;
+    const neighbours = [
+      [gridSize, 0, "h"],
+      [-gridSize, 0, "h"],
+      [0, gridSize, "v"],
+      [0, -gridSize, "v"]
+    ];
+    for (const [dx, dy, dir] of neighbours) {
+      const nx = current.x + dx;
+      const ny = current.y + dy;
+      if (pointBlocked(nx, ny, rects)) continue;
+      const turn = incomingDir !== null && incomingDir !== dir;
+      const tentativeG = bestG + gridSize + (turn ? TURN_PENALTY : 0);
+      const nk = key(nx, ny);
+      const prevG = gScore.get(nk) ?? Infinity;
+      if (tentativeG < prevG) {
+        cameFrom.set(nk, current.k);
+        cameDir.set(nk, dir);
+        gScore.set(nk, tentativeG);
+        const f = tentativeG + manhattan(nx, ny, ex, ey);
+        open.push({ k: nk, x: nx, y: ny, f });
+      }
+    }
+  }
+  return null;
+}
+
+// src/engines/graph/obb.ts
+function obbCorners(obb) {
+  const cos = Math.cos(obb.angle);
+  const sin = Math.sin(obb.angle);
+  const { halfWidth: hw, halfHeight: hh } = obb;
+  const [cx, cy] = obb.center;
+  const lx = [-hw, hw, hw, -hw];
+  const ly = [-hh, -hh, hh, hh];
+  const out = [];
+  for (let i = 0; i < 4; i++) {
+    const x = lx[i];
+    const y = ly[i];
+    out.push([cx + x * cos - y * sin, cy + x * sin + y * cos]);
+  }
+  return out;
+}
+function aabbFromOBB(obb) {
+  const corners = obbCorners(obb);
+  let x0 = corners[0][0];
+  let x1 = corners[0][0];
+  let y0 = corners[0][1];
+  let y1 = corners[0][1];
+  for (let i = 1; i < 4; i++) {
+    const [x, y] = corners[i];
+    if (x < x0) x0 = x;
+    if (x > x1) x1 = x;
+    if (y < y0) y0 = y;
+    if (y > y1) y1 = y;
+  }
+  return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };
+}
+function obbContainsPoint(obb, p) {
+  const cos = Math.cos(-obb.angle);
+  const sin = Math.sin(-obb.angle);
+  const dx = p[0] - obb.center[0];
+  const dy = p[1] - obb.center[1];
+  const lx = dx * cos - dy * sin;
+  const ly = dx * sin + dy * cos;
+  return Math.abs(lx) <= obb.halfWidth && Math.abs(ly) <= obb.halfHeight;
+}
+
+// src/engines/table/filter.ts
+function resolveOperator(filter) {
+  const adv = filter;
+  if (adv.op != null) return adv.op;
+  const col = filter;
+  if (col.operator != null) return col.operator;
+  return Array.isArray(filter.value) ? "in" : "eq";
+}
+function isEmptyValue(val) {
+  return val == null || val === "";
+}
+function asNumberPair(a, b) {
+  const na = typeof a === "number" ? a : Number(a);
+  const nb = typeof b === "number" ? b : Number(b);
+  if (Number.isNaN(na) || Number.isNaN(nb)) return null;
+  return [na, nb];
+}
+function matchesOperator(val, op, filterValue) {
+  switch (op) {
+    case "eq":
+      return val === filterValue;
+    case "neq":
+      return val !== filterValue;
+    case "lt":
+    case "lte":
+    case "gt":
+    case "gte": {
+      const pair = asNumberPair(val, filterValue);
+      if (!pair) return false;
+      const [a, b] = pair;
+      if (op === "lt") return a < b;
+      if (op === "lte") return a <= b;
+      if (op === "gt") return a > b;
+      return a >= b;
+    }
+    case "between": {
+      if (!Array.isArray(filterValue) || filterValue.length !== 2) return false;
+      const minPair = asNumberPair(val, filterValue[0]);
+      const maxPair = asNumberPair(val, filterValue[1]);
+      if (!minPair || !maxPair) return false;
+      return minPair[0] >= minPair[1] && maxPair[0] <= maxPair[1];
+    }
+    case "in":
+      return Array.isArray(filterValue) && filterValue.includes(val);
+    case "notIn":
+      return Array.isArray(filterValue) && !filterValue.includes(val);
+    case "contains":
+      if (typeof val !== "string") return false;
+      return val.toLowerCase().includes(String(filterValue ?? "").toLowerCase());
+    case "startsWith":
+      if (typeof val !== "string") return false;
+      return val.toLowerCase().startsWith(String(filterValue ?? "").toLowerCase());
+    case "endsWith":
+      if (typeof val !== "string") return false;
+      return val.toLowerCase().endsWith(String(filterValue ?? "").toLowerCase());
+    case "isEmpty":
+      return isEmptyValue(val);
+    case "isNotEmpty":
+      return !isEmptyValue(val);
+  }
+}
+function matchesColumnFilter(row, filter) {
+  const op = resolveOperator(filter);
+  return matchesOperator(row[filter.column], op, filter.value);
+}
+function computeAggregate(values, type) {
+  if (typeof type === "function") return type(values);
+  if (type === "count") return values.length;
+  const nums = [];
+  for (const v of values) {
+    if (v == null || v === "") continue;
+    const n = typeof v === "number" ? v : Number(v);
+    if (!Number.isNaN(n)) nums.push(n);
+  }
+  if (nums.length === 0) return null;
+  switch (type) {
+    case "sum":
+      return nums.reduce((a, b) => a + b, 0);
+    case "avg":
+      return nums.reduce((a, b) => a + b, 0) / nums.length;
+    case "min":
+      return Math.min(...nums);
+    case "max":
+      return Math.max(...nums);
+  }
+}
+
+// src/engines/table/TableEngine.ts
+function statePath(tableId, key2) {
+  return `${TABLE_PREFIX}${tableId}.state.${key2}`;
+}
+var tableCounter = 0;
+function createTable(core, options) {
+  const tableId = `t${tableCounter++}`;
+  let currentPageSize = options?.pageSize ?? 50;
+  let order = [];
+  let filteredOrder = [];
+  let sorts = [];
+  let filters = [];
+  let customFilterFn = null;
+  let page = 1;
+  let pinnedLeft = [];
+  let pinnedRight = [];
+  let columnWidths = {};
+  let groupByField = null;
+  let columnAggregates = [];
+  let groups = [];
+  const dataById = /* @__PURE__ */ new Map();
+  const keysById = /* @__PURE__ */ new Map();
+  function getRowData(id) {
+    const stored = dataById.get(id);
+    if (!stored) return void 0;
+    if (options?.columns) {
+      const filtered = {};
+      for (const col of options.columns) {
+        filtered[col] = stored[col];
+      }
+      return filtered;
+    }
+    return stored;
+  }
+  function matchesFilters(rowData) {
+    if (customFilterFn && !customFilterFn(rowData)) return false;
+    for (const f of filters) {
+      if (!matchesColumnFilter(rowData, f)) return false;
+    }
+    return true;
+  }
+  function compareBySort(a, b) {
+    const aData = getRowData(a);
+    const bData = getRowData(b);
+    for (const s of sorts) {
+      const aVal = aData?.[s.column];
+      const bVal = bData?.[s.column];
+      if (aVal === bVal) continue;
+      if (aVal === void 0 || aVal === null) return 1;
+      if (bVal === void 0 || bVal === null) return -1;
+      const cmp = aVal < bVal ? -1 : 1;
+      return s.direction === "asc" ? cmp : -cmp;
+    }
+    return 0;
+  }
+  function recomputeFiltered() {
+    if (filters.length === 0 && !customFilterFn) {
+      filteredOrder = [...order];
+    } else {
+      filteredOrder = order.filter((id) => {
+        const data = getRowData(id);
+        return data ? matchesFilters(data) : false;
+      });
+    }
+    if (sorts.length > 0) {
+      filteredOrder.sort(compareBySort);
+    }
+    const totalPages = Math.max(1, Math.ceil(filteredOrder.length / currentPageSize));
+    if (page > totalPages) page = totalPages;
+    recomputeGroups();
+    publishState();
+  }
+  function recomputeGroups() {
+    if (!groupByField) {
+      groups = [];
+      return;
+    }
+    const map = /* @__PURE__ */ new Map();
+    const orderKeys = [];
+    for (const id of filteredOrder) {
+      const data = getRowData(id);
+      if (!data) continue;
+      const raw = data[groupByField];
+      const key2 = raw == null ? "__null__" : String(raw);
+      if (!map.has(key2)) {
+        map.set(key2, { value: raw, rows: [] });
+        orderKeys.push(key2);
+      }
+      map.get(key2).rows.push(id);
+    }
+    groups = orderKeys.map((key2) => {
+      const { value, rows } = map.get(key2);
+      const aggregates = {};
+      for (const agg of columnAggregates) {
+        const values = rows.map((id) => dataById.get(id)?.[agg.column]);
+        aggregates[agg.column] = computeAggregate(values, agg.type);
+      }
+      return { key: key2, value, rows, aggregates };
+    });
+  }
+  function publishState() {
+    const totalPages = Math.max(1, Math.ceil(filteredOrder.length / currentPageSize));
+    core.set(statePath(tableId, "totalRows"), order.length);
+    core.set(statePath(tableId, "filteredRows"), filteredOrder.length);
+    core.set(statePath(tableId, "page"), page);
+    core.set(statePath(tableId, "pageSize"), currentPageSize);
+    core.set(statePath(tableId, "totalPages"), totalPages);
+    core.set(statePath(tableId, "groupBy"), groupByField);
+    core.set(statePath(tableId, "groupCount"), groups.length);
+  }
+  function getColumnKeys() {
+    if (options?.columns) return options.columns;
+    if (order.length === 0) return [];
+    const firstId = order[0];
+    return keysById.get(firstId) ?? [];
+  }
+  function toColumnFilter(column, filter) {
+    const adv = filter;
+    if (adv.op != null) {
+      return { column, operator: adv.op, value: adv.value };
+    }
+    const cf = filter;
+    return { column, operator: cf.operator, value: cf.value };
+  }
+  const table = {
+    addRow(id, data) {
+      dataById.set(id, data);
+      keysById.set(id, Object.keys(data));
+      order.push(id);
+      recomputeFiltered();
+    },
+    addRows(rows) {
+      for (const row of rows) {
+        dataById.set(row.id, row.data);
+        keysById.set(row.id, Object.keys(row.data));
+        order.push(row.id);
+      }
+      recomputeFiltered();
+    },
+    removeRow(id) {
+      const idx = order.indexOf(id);
+      if (idx === -1) return;
+      order.splice(idx, 1);
+      dataById.delete(id);
+      keysById.delete(id);
+      recomputeFiltered();
+    },
+    updateCell(id, column, value) {
+      const row = dataById.get(id);
+      if (!row) return;
+      row[column] = value;
+      const keys = keysById.get(id);
+      if (keys && !keys.includes(column)) {
+        keys.push(column);
+      }
+      recomputeFiltered();
+    },
+    getRow(id) {
+      return getRowData(id);
+    },
+    getCell(id, column) {
+      return dataById.get(id)?.[column];
+    },
+    getVisibleRows() {
+      const start = (page - 1) * currentPageSize;
+      const end = start + currentPageSize;
+      const slice = filteredOrder.slice(start, end);
+      const out = new Array(slice.length);
+      for (let i = 0; i < slice.length; i++) {
+        const id = slice[i];
+        out[i] = { id, data: getRowData(id) ?? {} };
+      }
+      return out;
+    },
+    getAllRowIds() {
+      return [...order];
+    },
+    getAllRows() {
+      const out = new Array(filteredOrder.length);
+      for (let i = 0; i < filteredOrder.length; i++) {
+        const id = filteredOrder[i];
+        out[i] = { id, data: getRowData(id) ?? {} };
+      }
+      return out;
+    },
+    setSort(column, direction, append) {
+      if (append) {
+        sorts = sorts.filter((s) => s.column !== column);
+        sorts.push({ column, direction });
+      } else {
+        sorts = [{ column, direction }];
+      }
+      recomputeFiltered();
+    },
+    setSorts(newSorts) {
+      sorts = [...newSorts];
+      recomputeFiltered();
+    },
+    clearSort() {
+      sorts = [];
+      recomputeFiltered();
+    },
+    addFilter(filter) {
+      filters = filters.filter((f) => f.column !== filter.column);
+      filters.push(filter);
+      page = 1;
+      recomputeFiltered();
+    },
+    removeFilter(column) {
+      filters = filters.filter((f) => f.column !== column);
+      recomputeFiltered();
+    },
+    clearFilters() {
+      filters = [];
+      customFilterFn = null;
+      recomputeFiltered();
+    },
+    setFilterFn(fn) {
+      customFilterFn = fn;
+      recomputeFiltered();
+    },
+    setColumnFilter(column, filter) {
+      filters = filters.filter((f) => f.column !== column);
+      if (filter !== null) {
+        filters.push(toColumnFilter(column, filter));
+      }
+      page = 1;
+      recomputeFiltered();
+    },
+    setPage(p) {
+      const totalPages = Math.max(1, Math.ceil(filteredOrder.length / currentPageSize));
+      page = Math.max(1, Math.min(p, totalPages));
+      publishState();
+    },
+    setPageSize(size) {
+      currentPageSize = size;
+      page = 1;
+      recomputeFiltered();
+    },
+    nextPage() {
+      table.setPage(page + 1);
+    },
+    prevPage() {
+      table.setPage(page - 1);
+    },
+    moveRow(fromIndex, toIndex) {
+      if (fromIndex < 0 || fromIndex >= order.length) return;
+      if (toIndex < 0 || toIndex >= order.length) return;
+      if (fromIndex === toIndex) return;
+      const [item] = order.splice(fromIndex, 1);
+      order.splice(toIndex, 0, item);
+      recomputeFiltered();
+    },
+    pinColumn(column, side) {
+      pinnedLeft = pinnedLeft.filter((c) => c !== column);
+      pinnedRight = pinnedRight.filter((c) => c !== column);
+      if (side === "left") pinnedLeft.push(column);
+      else if (side === "right") pinnedRight.push(column);
+      core.set(statePath(tableId, "pinnedLeft"), [...pinnedLeft]);
+      core.set(statePath(tableId, "pinnedRight"), [...pinnedRight]);
+    },
+    getPinnedColumns() {
+      return { left: [...pinnedLeft], right: [...pinnedRight] };
+    },
+    clearPinned() {
+      pinnedLeft = [];
+      pinnedRight = [];
+      core.set(statePath(tableId, "pinnedLeft"), []);
+      core.set(statePath(tableId, "pinnedRight"), []);
+    },
+    setColumnWidth(column, width) {
+      columnWidths = { ...columnWidths, [column]: width };
+      core.set(statePath(tableId, "columnWidths"), { ...columnWidths });
+    },
+    getColumnWidth(column) {
+      return columnWidths[column];
+    },
+    getColumnWidths() {
+      return { ...columnWidths };
+    },
+    clearColumnWidths() {
+      columnWidths = {};
+      core.set(statePath(tableId, "columnWidths"), {});
+    },
+    moveRows(ids, toIndex) {
+      const items = ids.map((id) => {
+        const idx = order.indexOf(id);
+        return { id, idx };
+      }).filter((x) => x.idx !== -1);
+      if (items.length === 0) return;
+      const idsSet = new Set(ids);
+      const remaining = order.filter((id) => !idsSet.has(id));
+      const clamped = Math.max(0, Math.min(toIndex, remaining.length));
+      remaining.splice(clamped, 0, ...items.map((x) => x.id));
+      order = remaining;
+      recomputeFiltered();
+    },
+    getExportData(exportOptions) {
+      const cols = exportOptions?.columns ?? getColumnKeys();
+      const result = [];
+      if (exportOptions?.headers !== false) {
+        result.push(cols);
+      }
+      const sourceIds = exportOptions?.allRows ? filteredOrder : filteredOrder.slice(
+        (page - 1) * currentPageSize,
+        (page - 1) * currentPageSize + currentPageSize
+      );
+      for (const id of sourceIds) {
+        const data = getRowData(id);
+        if (!data) continue;
+        result.push(
+          cols.map((col) => {
+            const v = data[col];
+            return v == null ? "" : String(v);
+          })
+        );
+      }
+      return result;
+    },
+    getTableState() {
+      const totalPages = Math.max(1, Math.ceil(filteredOrder.length / currentPageSize));
+      return {
+        totalRows: order.length,
+        filteredRows: filteredOrder.length,
+        page,
+        pageSize: currentPageSize,
+        totalPages,
+        sorts: [...sorts],
+        sort: sorts.length > 0 ? sorts[0] : null,
+        filters: [...filters],
+        groupBy: groupByField,
+        groupCount: groups.length
+      };
+    },
+    groupBy(field, aggregates) {
+      groupByField = field ?? null;
+      columnAggregates = aggregates ? [...aggregates] : [];
+      recomputeGroups();
+      publishState();
+    },
+    clearGroupBy() {
+      groupByField = null;
+      columnAggregates = [];
+      groups = [];
+      publishState();
+    },
+    getGroupBy() {
+      return groupByField;
+    },
+    getGroups() {
+      return groups.map((g) => ({
+        key: g.key,
+        value: g.value,
+        rows: [...g.rows],
+        aggregates: { ...g.aggregates }
+      }));
+    },
+    getEstimatedRowHeight(id) {
+      const fn = options?.estimateRowHeight;
+      if (!fn) return null;
+      const data = getRowData(id);
+      if (!data) return null;
+      const v = fn(data, id);
+      return Number.isFinite(v) ? v : null;
+    },
+    reset() {
+      order = [];
+      filteredOrder = [];
+      sorts = [];
+      filters = [];
+      customFilterFn = null;
+      page = 1;
+      pinnedLeft = [];
+      pinnedRight = [];
+      columnWidths = {};
+      groupByField = null;
+      columnAggregates = [];
+      groups = [];
+      dataById.clear();
+      keysById.clear();
+      core.set(statePath(tableId, "columnWidths"), {});
+      publishState();
+    }
+  };
+  core.set(statePath(tableId, "columnWidths"), {});
+  publishState();
+  return table;
+}
+
+// src/engines/tree/TreeEngine.ts
+var treeCounter = 0;
+function createTree(core, options) {
+  const treeId = `tr${treeCounter++}`;
+  const fn = {
+    key: options?.fieldNames?.key ?? "key",
+    title: options?.fieldNames?.title ?? "title",
+    children: options?.fieldNames?.children ?? "children"
+  };
+  const checkStrictly = options?.checkStrictly ?? false;
+  let nodes = [];
+  let nodeMap = /* @__PURE__ */ new Map();
+  let expandedKeys = new Set(options?.defaultExpandedKeys ?? []);
+  let checkedKeys = new Set(options?.defaultCheckedKeys ?? []);
+  let halfCheckedKeys = /* @__PURE__ */ new Set();
+  let selectedKeys = new Set(options?.defaultSelectedKeys ?? []);
+  let loadedKeys = /* @__PURE__ */ new Set();
+  let loadingKeys = /* @__PURE__ */ new Set();
+  let filteredKeys = null;
+  function getKey(node) {
+    return node[fn.key];
+  }
+  function getChildren(node) {
+    return node[fn.children];
+  }
+  function buildMap(data) {
+    nodeMap = /* @__PURE__ */ new Map();
+    function walk(list, parentKey, depth) {
+      for (const n of list) {
+        const k = getKey(n);
+        const children = getChildren(n);
+        const childKeys = [];
+        const isLeaf = n.isLeaf === true || (!children || children.length === 0);
+        if (children && children.length > 0) {
+          for (const ch of children) childKeys.push(getKey(ch));
+        }
+        nodeMap.set(k, { node: n, key: k, depth, parentKey, childKeys, isLeaf });
+        if (children && children.length > 0) {
+          walk(children, k, depth + 1);
+        }
+      }
+    }
+    walk(data, null, 0);
+  }
+  function getAllDescendantKeys(key2) {
+    const result = [];
+    const internal = nodeMap.get(key2);
+    if (!internal) return result;
+    for (const ck of internal.childKeys) {
+      result.push(ck);
+      result.push(...getAllDescendantKeys(ck));
+    }
+    return result;
+  }
+  function getAllAncestorKeys(key2) {
+    const result = [];
+    let current = nodeMap.get(key2);
+    while (current && current.parentKey !== null) {
+      result.push(current.parentKey);
+      current = nodeMap.get(current.parentKey);
+    }
+    return result;
+  }
+  function recomputeHalfChecked() {
+    if (checkStrictly) {
+      halfCheckedKeys = /* @__PURE__ */ new Set();
+      return;
+    }
+    const half = /* @__PURE__ */ new Set();
+    for (const [key2, internal] of nodeMap) {
+      if (internal.childKeys.length === 0) continue;
+      if (checkedKeys.has(key2)) continue;
+      const allDescendants = getAllDescendantKeys(key2);
+      const someChecked = allDescendants.some((dk) => checkedKeys.has(dk));
+      if (someChecked) half.add(key2);
+    }
+    halfCheckedKeys = half;
+  }
+  function cascadeCheck(key2, checked) {
+    if (checkStrictly) {
+      if (checked) checkedKeys.add(key2);
+      else checkedKeys.delete(key2);
+      return;
+    }
+    const internal = nodeMap.get(key2);
+    if (!internal) return;
+    if (checked) {
+      checkedKeys.add(key2);
+      const descendants = getAllDescendantKeys(key2);
+      for (const dk of descendants) {
+        const dn = nodeMap.get(dk);
+        if (dn && !dn.node.disabled && !dn.node.disableCheckbox) {
+          checkedKeys.add(dk);
+        }
+      }
+    } else {
+      checkedKeys.delete(key2);
+      const descendants = getAllDescendantKeys(key2);
+      for (const dk of descendants) {
+        checkedKeys.delete(dk);
+      }
+    }
+    const ancestors = getAllAncestorKeys(key2);
+    for (const ak of ancestors) {
+      const an = nodeMap.get(ak);
+      if (!an) continue;
+      const allChildren = getAllDescendantKeys(ak);
+      const enabledChildren = allChildren.filter((ck) => {
+        const cn = nodeMap.get(ck);
+        return cn && !cn.node.disabled && !cn.node.disableCheckbox;
+      });
+      const allChecked = enabledChildren.length > 0 && enabledChildren.every((ck) => checkedKeys.has(ck));
+      if (allChecked) {
+        checkedKeys.add(ak);
+      } else {
+        checkedKeys.delete(ak);
+      }
+    }
+    recomputeHalfChecked();
+  }
+  function removeFromTree(data, targetKey) {
+    let removed = null;
+    const remaining = data.filter((n) => {
+      if (getKey(n) === targetKey) {
+        removed = n;
+        return false;
+      }
+      return true;
+    });
+    if (!removed) {
+      for (const n of remaining) {
+        const children = getChildren(n);
+        if (children && children.length > 0) {
+          const result = removeFromTree(children, targetKey);
+          if (result.removed) {
+            ;
+            n[fn.children] = result.remaining;
+            return { remaining, removed: result.removed };
+          }
+        }
+      }
+    }
+    return { remaining, removed };
+  }
+  function insertIntoTree(data, targetKey, node, position) {
+    if (position === 0) {
+      return data.map((n) => {
+        if (getKey(n) === targetKey) {
+          const children2 = getChildren(n) ?? [];
+          n[fn.children] = [...children2, node];
+          return n;
+        }
+        const children = getChildren(n);
+        if (children && children.length > 0) {
+          ;
+          n[fn.children] = insertIntoTree(children, targetKey, node, position);
+        }
+        return n;
+      });
+    }
+    const result = [];
+    for (const n of data) {
+      if (getKey(n) === targetKey) {
+        if (position === -1) {
+          result.push(node, n);
+        } else {
+          result.push(n, node);
+        }
+      } else {
+        const children = getChildren(n);
+        if (children && children.length > 0) {
+          ;
+          n[fn.children] = insertIntoTree(children, targetKey, node, position);
+        }
+        result.push(n);
+      }
+    }
+    return result;
+  }
+  function publishState() {
+    const path = (k) => `${TREE_PREFIX}${treeId}.${k}`;
+    core.batch(() => {
+      core.set(path("expandedKeys"), [...expandedKeys]);
+      core.set(path("checkedKeys"), [...checkedKeys]);
+      core.set(path("halfCheckedKeys"), [...halfCheckedKeys]);
+      core.set(path("selectedKeys"), [...selectedKeys]);
+      core.set(path("loadedKeys"), [...loadedKeys]);
+      core.set(path("loadingKeys"), [...loadingKeys]);
+    });
+  }
+  function initDefaults() {
+    if (options?.defaultExpandAll) {
+      for (const [key2, internal] of nodeMap) {
+        if (!internal.isLeaf) expandedKeys.add(key2);
+      }
+    }
+    if (options?.defaultCheckedKeys && !checkStrictly) {
+      for (const key2 of options.defaultCheckedKeys) {
+        cascadeCheck(key2, true);
+      }
+    }
+    recomputeHalfChecked();
+    publishState();
+  }
+  const engine = {
+    setData(data) {
+      nodes = data;
+      buildMap(data);
+      initDefaults();
+    },
+    getData() {
+      return nodes;
+    },
+    // Expand
+    expand(key2) {
+      expandedKeys.add(key2);
+      publishState();
+    },
+    collapse(key2) {
+      expandedKeys.delete(key2);
+      publishState();
+    },
+    toggleExpand(key2) {
+      if (expandedKeys.has(key2)) expandedKeys.delete(key2);
+      else expandedKeys.add(key2);
+      publishState();
+    },
+    setExpandedKeys(keys) {
+      expandedKeys = new Set(keys);
+      publishState();
+    },
+    expandAll() {
+      for (const [key2, internal] of nodeMap) {
+        if (!internal.isLeaf) expandedKeys.add(key2);
+      }
+      publishState();
+    },
+    collapseAll() {
+      expandedKeys = /* @__PURE__ */ new Set();
+      publishState();
+    },
+    // Check
+    check(key2) {
+      cascadeCheck(key2, true);
+      publishState();
+    },
+    uncheck(key2) {
+      cascadeCheck(key2, false);
+      publishState();
+    },
+    toggleCheck(key2) {
+      const checked = !checkedKeys.has(key2);
+      cascadeCheck(key2, checked);
+      publishState();
+    },
+    setCheckedKeys(keys) {
+      checkedKeys = new Set(keys);
+      recomputeHalfChecked();
+      publishState();
+    },
+    // Select
+    select(key2, multiple) {
+      if (multiple) {
+        if (selectedKeys.has(key2)) selectedKeys.delete(key2);
+        else selectedKeys.add(key2);
+      } else {
+        selectedKeys = /* @__PURE__ */ new Set([key2]);
+      }
+      publishState();
+    },
+    deselect(key2) {
+      selectedKeys.delete(key2);
+      publishState();
+    },
+    setSelectedKeys(keys) {
+      selectedKeys = new Set(keys);
+      publishState();
+    },
+    // Async loading
+    markLoading(key2) {
+      loadingKeys.add(key2);
+      publishState();
+    },
+    markLoaded(key2) {
+      loadingKeys.delete(key2);
+      loadedKeys.add(key2);
+      publishState();
+    },
+    addChildren(parentKey, children) {
+      const internal = nodeMap.get(parentKey);
+      if (!internal) return;
+      internal.node[fn.children] = children;
+      buildMap(nodes);
+      publishState();
+    },
+    // Drag & drop
+    moveNode(dragKey, dropKey, position) {
+      if (dragKey === dropKey) return null;
+      const ancestors = getAllAncestorKeys(dropKey);
+      if (ancestors.includes(dragKey)) return null;
+      const { remaining, removed } = removeFromTree(nodes, dragKey);
+      if (!removed) return null;
+      nodes = insertIntoTree(remaining, dropKey, removed, position);
+      buildMap(nodes);
+      publishState();
+      return nodes;
+    },
+    // Filter
+    filterNodes(predicate) {
+      if (!predicate) {
+        filteredKeys = null;
+        return;
+      }
+      const matched = /* @__PURE__ */ new Set();
+      for (const [key2, internal] of nodeMap) {
+        if (predicate(internal.node)) {
+          matched.add(key2);
+          const ancestors = getAllAncestorKeys(key2);
+          for (const ak of ancestors) matched.add(ak);
+        }
+      }
+      filteredKeys = matched;
+    },
+    getFilteredKeys() {
+      return filteredKeys ? [...filteredKeys] : null;
+    },
+    // Query
+    getNode(key2) {
+      return nodeMap.get(key2)?.node;
+    },
+    getParentKey(key2) {
+      return nodeMap.get(key2)?.parentKey ?? null;
+    },
+    getChildKeys(key2) {
+      return nodeMap.get(key2)?.childKeys ?? [];
+    },
+    getAllKeys() {
+      return [...nodeMap.keys()];
+    },
+    getLeafKeys() {
+      const result = [];
+      for (const [key2, internal] of nodeMap) {
+        if (internal.isLeaf) result.push(key2);
+      }
+      return result;
+    },
+    getState() {
+      return {
+        expandedKeys: [...expandedKeys],
+        checkedKeys: [...checkedKeys],
+        halfCheckedKeys: [...halfCheckedKeys],
+        selectedKeys: [...selectedKeys],
+        loadedKeys: [...loadedKeys],
+        loadingKeys: [...loadingKeys]
+      };
+    },
+    getFlatNodes() {
+      const result = [];
+      function walk(list, parentKey, depth) {
+        for (const n of list) {
+          const k = getKey(n);
+          if (filteredKeys && !filteredKeys.has(k)) continue;
+          const children = getChildren(n);
+          const isLeaf = n.isLeaf === true || (!children || children.length === 0);
+          result.push({ node: n, key: k, depth, isLeaf, parentKey });
+          if (!isLeaf && expandedKeys.has(k) && children && children.length > 0) {
+            walk(children, k, depth + 1);
+          }
+        }
+      }
+      walk(nodes, null, 0);
+      return result;
+    },
+    reset() {
+      nodes = [];
+      nodeMap = /* @__PURE__ */ new Map();
+      expandedKeys = /* @__PURE__ */ new Set();
+      checkedKeys = /* @__PURE__ */ new Set();
+      halfCheckedKeys = /* @__PURE__ */ new Set();
+      selectedKeys = /* @__PURE__ */ new Set();
+      loadedKeys = /* @__PURE__ */ new Set();
+      loadingKeys = /* @__PURE__ */ new Set();
+      filteredKeys = null;
+      publishState();
+    }
+  };
+  return engine;
+}
+
+// src/engines/calendar/availability.ts
+var DAY_MS = 864e5;
+function parseHHMM(s, fallback) {
+  if (s === void 0) return fallback;
+  const m = /^(\d{1,2}):(\d{2})$/.exec(s);
+  if (!m) return fallback;
+  const h = Number(m[1]);
+  const mm = Number(m[2]);
+  if (!Number.isFinite(h) || !Number.isFinite(mm)) return fallback;
+  if (h < 0 || h > 24 || mm < 0 || mm >= 60) return fallback;
+  return h * 36e5 + mm * 6e4;
+}
+function rulesFor(resourceId, rules) {
+  return rules.filter((r) => r.resourceId === resourceId);
+}
+function dayBucket(t) {
+  const d = new Date(t);
+  const dayStart = Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+  const dayOfWeek = new Date(dayStart).getUTCDay();
+  return { dayStart, dayOfWeek };
+}
+function isAvailable(resource, range, rules) {
+  if (range.end <= range.start) return true;
+  const own = rulesFor(resource.id, rules);
+  if (own.length === 0) return true;
+  let cursor = range.start;
+  while (cursor < range.end) {
+    const { dayStart, dayOfWeek } = dayBucket(cursor);
+    const dayEnd = dayStart + DAY_MS;
+    const sliceEnd = Math.min(range.end, dayEnd);
+    const dayRules = own.filter(
+      (r) => r.dayOfWeek === void 0 || r.dayOfWeek === dayOfWeek
+    );
+    if (dayRules.length === 0) return false;
+    const intervals = dayRules.map((r) => {
+      const fromMs = parseHHMM(r.from, 0);
+      const toMs = parseHHMM(r.to, DAY_MS);
+      return { from: dayStart + fromMs, to: dayStart + toMs };
+    }).filter((w) => w.to > w.from).sort((a, b) => a.from - b.from);
+    if (intervals.length === 0) return false;
+    const merged = [];
+    for (const w of intervals) {
+      const last = merged[merged.length - 1];
+      if (last && w.from <= last.to) {
+        last.to = Math.max(last.to, w.to);
+      } else {
+        merged.push({ ...w });
+      }
+    }
+    let needed = cursor;
+    for (const w of merged) {
+      if (w.from > needed) return false;
+      if (w.to >= sliceEnd) {
+        needed = sliceEnd;
+        break;
+      }
+      needed = Math.max(needed, w.to);
+    }
+    if (needed < sliceEnd) return false;
+    cursor = sliceEnd;
+  }
+  return true;
+}
+
+// src/engines/calendar/conflicts.ts
+var DAY_MS2 = 864e5;
+var STEP_MS = {
+  day: DAY_MS2,
+  week: 7 * DAY_MS2,
+  month: 30 * DAY_MS2
+};
+function makeId(reason, ids) {
+  return `${reason}:${[...ids].sort().join(",")}`;
+}
+function pushConflict(out, reason, ids) {
+  if (ids.length === 0) return;
+  const sorted = [...ids].sort();
+  const id = makeId(reason, sorted);
+  if (out.has(id)) return;
+  out.set(id, { id, reason, assignmentIds: sorted });
+}
+function detectConflicts(state, opts = {}) {
+  const scale = opts.scale ?? "day";
+  const step = STEP_MS[scale];
+  const rules = opts.rules ?? [];
+  const conflicts = /* @__PURE__ */ new Map();
+  const byResource = /* @__PURE__ */ new Map();
+  for (const a of state.assignments) {
+    let bucket = byResource.get(a.resourceId);
+    if (!bucket) {
+      bucket = [];
+      byResource.set(a.resourceId, bucket);
+    }
+    bucket.push(a);
+  }
+  for (const list of byResource.values()) {
+    const sorted = [...list].sort((x, y) => x.start - y.start);
+    for (let i = 0; i < sorted.length; i++) {
+      const a = sorted[i];
+      for (let j = i + 1; j < sorted.length; j++) {
+        const b = sorted[j];
+        if (b.start >= a.end) break;
+        pushConflict(conflicts, "overlap", [a.id, b.id]);
+      }
+    }
+  }
+  const resourceById = /* @__PURE__ */ new Map();
+  for (const r of state.resources) resourceById.set(r.id, r);
+  for (const [rid, list] of byResource) {
+    const resource = resourceById.get(rid);
+    if (!resource || resource.capacityPerSlot === void 0) continue;
+    const cap = Math.max(0, Math.floor(resource.capacityPerSlot));
+    const slotMap = /* @__PURE__ */ new Map();
+    for (const a of list) {
+      const lo = Math.floor(a.start / step) * step;
+      const hi = Math.ceil(a.end / step) * step;
+      for (let s = lo; s < hi; s += step) {
+        let bucket = slotMap.get(s);
+        if (!bucket) {
+          bucket = [];
+          slotMap.set(s, bucket);
+        }
+        bucket.push(a.id);
+      }
+    }
+    for (const ids of slotMap.values()) {
+      if (ids.length > cap) {
+        pushConflict(conflicts, "over-capacity", ids);
+      }
+    }
+  }
+  if (rules.length > 0) {
+    for (const a of state.assignments) {
+      const r = resourceById.get(a.resourceId);
+      if (!r) continue;
+      if (!isAvailable(r, { start: a.start, end: a.end }, rules)) {
+        pushConflict(conflicts, "outside-availability", [a.id]);
+      }
+    }
+  }
+  return [...conflicts.values()];
+}
+
+// src/engines/calendar/CalendarEngine.ts
+var calendarCounter = 0;
+function createCalendar(core, options) {
+  const engineId = `c${calendarCounter++}${options?.name ? `-${options.name}` : ""}`;
+  const prefix = CALENDAR_PREFIX;
+  const resources = /* @__PURE__ */ new Map();
+  const assignments = /* @__PURE__ */ new Map();
+  let rules = options?.rules ? [...options.rules] : [];
+  let scale = options?.scale ?? "day";
+  let conflicts = [];
+  const localSubscribers = /* @__PURE__ */ new Set();
+  function publish() {
+    const resList = [...resources.values()];
+    const assignList = [...assignments.values()];
+    core.batch(() => {
+      core.set(`${prefix}${engineId}.resources`, resList);
+      core.set(`${prefix}${engineId}.assignments`, assignList);
+      core.set(`${prefix}${engineId}.conflicts`, conflicts);
+      core.set(`${prefix}${engineId}.view`, { scale });
+    });
+    for (const cb of localSubscribers) cb();
+  }
+  function recompute() {
+    conflicts = detectConflicts(
+      { resources: [...resources.values()], assignments: [...assignments.values()] },
+      { scale, rules }
+    );
+    const involved = /* @__PURE__ */ new Set();
+    for (const c of conflicts) for (const id of c.assignmentIds) involved.add(id);
+    for (const [id, a] of assignments) {
+      const isConflicting = involved.has(id);
+      if (isConflicting && a.status !== "conflict") {
+        assignments.set(id, { ...a, status: "conflict" });
+      } else if (!isConflicting && a.status === "conflict") {
+        assignments.set(id, { ...a, status: "tentative" });
+      }
+    }
+  }
+  function commitAndPublish() {
+    recompute();
+    publish();
+  }
+  function subscribe(cb) {
+    localSubscribers.add(cb);
+    return () => {
+      localSubscribers.delete(cb);
+    };
+  }
+  function addResource(resource) {
+    if (resources.has(resource.id)) {
+      throw new Error(
+        `[skygraph/calendar] resource id "${resource.id}" already exists`
+      );
+    }
+    resources.set(resource.id, { ...resource });
+    commitAndPublish();
+  }
+  function removeResource(id) {
+    if (!resources.has(id)) return;
+    resources.delete(id);
+    for (const [aid, a] of assignments) {
+      if (a.resourceId === id) assignments.delete(aid);
+    }
+    commitAndPublish();
+  }
+  function updateResource(id, patch) {
+    const r = resources.get(id);
+    if (!r) throw new Error(`[skygraph/calendar] resource "${id}" not found`);
+    resources.set(id, { ...r, ...patch, id });
+    commitAndPublish();
+  }
+  function getResource(id) {
+    return resources.get(id);
+  }
+  function getResources() {
+    return [...resources.values()];
+  }
+  function addAssignment(assignment) {
+    if (assignments.has(assignment.id)) {
+      throw new Error(
+        `[skygraph/calendar] assignment id "${assignment.id}" already exists`
+      );
+    }
+    if (!resources.has(assignment.resourceId)) {
+      throw new Error(
+        `[skygraph/calendar] addAssignment: resource "${assignment.resourceId}" not found`
+      );
+    }
+    if (assignment.end <= assignment.start) {
+      throw new Error(
+        `[skygraph/calendar] addAssignment: end (${assignment.end}) must be greater than start (${assignment.start})`
+      );
+    }
+    assignments.set(assignment.id, { ...assignment });
+    commitAndPublish();
+  }
+  function updateAssignment(id, patch) {
+    const a = assignments.get(id);
+    if (!a) throw new Error(`[skygraph/calendar] assignment "${id}" not found`);
+    const next = { ...a, ...patch, id };
+    if (next.end <= next.start) {
+      throw new Error(
+        `[skygraph/calendar] updateAssignment: end (${next.end}) must be greater than start (${next.start})`
+      );
+    }
+    if (!resources.has(next.resourceId)) {
+      throw new Error(
+        `[skygraph/calendar] updateAssignment: resource "${next.resourceId}" not found`
+      );
+    }
+    assignments.set(id, next);
+    commitAndPublish();
+  }
+  function removeAssignment(id) {
+    if (!assignments.has(id)) return;
+    assignments.delete(id);
+    commitAndPublish();
+  }
+  function moveAssignment(id, deltaMs) {
+    const a = assignments.get(id);
+    if (!a) throw new Error(`[skygraph/calendar] assignment "${id}" not found`);
+    if (deltaMs === 0) return;
+    assignments.set(id, { ...a, start: a.start + deltaMs, end: a.end + deltaMs });
+    commitAndPublish();
+  }
+  function resizeAssignment(id, side, deltaMs) {
+    const a = assignments.get(id);
+    if (!a) throw new Error(`[skygraph/calendar] assignment "${id}" not found`);
+    if (deltaMs === 0) return;
+    let next;
+    if (side === "end") {
+      const nextEnd = Math.max(a.start + 1, a.end + deltaMs);
+      next = { ...a, end: nextEnd };
+    } else {
+      const nextStart = Math.min(a.end - 1, a.start + deltaMs);
+      next = { ...a, start: nextStart };
+    }
+    assignments.set(id, next);
+    commitAndPublish();
+  }
+  function getAssignment(id) {
+    return assignments.get(id);
+  }
+  function getAssignments() {
+    return [...assignments.values()];
+  }
+  function setRules(next) {
+    rules = [...next];
+    commitAndPublish();
+  }
+  function getRules() {
+    return [...rules];
+  }
+  function getConflicts() {
+    return [...conflicts];
+  }
+  function setScale(next) {
+    if (next === scale) return;
+    scale = next;
+    commitAndPublish();
+  }
+  function getScale() {
+    return scale;
+  }
+  function getState() {
+    return {
+      resources: [...resources.values()],
+      assignments: [...assignments.values()],
+      conflicts: [...conflicts]
+    };
+  }
+  function clear() {
+    resources.clear();
+    assignments.clear();
+    rules = [];
+    conflicts = [];
+    publish();
+  }
+  publish();
+  return {
+    id: engineId,
+    addResource,
+    removeResource,
+    updateResource,
+    getResource,
+    getResources,
+    addAssignment,
+    updateAssignment,
+    removeAssignment,
+    moveAssignment,
+    resizeAssignment,
+    getAssignment,
+    getAssignments,
+    setRules,
+    getRules,
+    getConflicts,
+    setScale,
+    getScale,
+    getState,
+    subscribe,
+    clear
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CALENDAR_PREFIX,
+  FORM_META_PREFIX,
+  GRAPH_PREFIX,
+  TABLE_PREFIX,
+  TREE_PREFIX,
+  aabbFromOBB,
+  computeAggregate,
+  createCalendar,
+  createCore,
+  createForm,
+  createGraph,
+  createHistory,
+  createMeasureCache,
+  createTable,
+  createTree,
+  createTypedCore,
+  createVirtual,
+  detectConflicts,
+  floatingAnchor,
+  freezeMiddleware,
+  getBezierPath,
+  getEdgePosition,
+  getNodeIntersection,
+  inferSide,
+  isAvailable,
+  listReservedPrefixes,
+  loggerMiddleware,
+  matchesColumnFilter,
+  matchesOperator,
+  nearestSide,
+  obbContainsPoint,
+  obbCorners,
+  persistenceMiddleware,
+  pointsToPath,
+  pointsToRoundedPath,
+  reservePrefix,
+  resolveEdgeEndpoint,
+  resolveOperator,
+  routeOrthogonal,
+  validationMiddleware
+});
+//# sourceMappingURL=index.cjs.map