@prometheus-ags/entity-graph-core 3.2.0 → 4.0.0

package/dist/index.cjs

@@ -1,4199 +0,0 @@
-'use strict';
-
-var vanilla = require('zustand/vanilla');
-var middleware = require('zustand/middleware');
-var immer = require('zustand/middleware/immer');
-
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/errors.ts
-var TerminalError = class _TerminalError extends Error {
-  kind = "terminal";
-  status;
-  constructor(message, opts = {}) {
-    super(message, { cause: opts.cause });
-    this.name = "TerminalError";
-    this.status = opts.status;
-    if (typeof Error.captureStackTrace === "function") {
-      Error.captureStackTrace(this, _TerminalError);
-    }
-  }
-};
-var TransientError = class _TransientError extends Error {
-  kind = "transient";
-  status;
-  constructor(message, opts = {}) {
-    super(message, { cause: opts.cause });
-    this.name = "TransientError";
-    this.status = opts.status;
-    if (typeof Error.captureStackTrace === "function") {
-      Error.captureStackTrace(this, _TransientError);
-    }
-  }
-};
-function toEntityError(err) {
-  if (err instanceof TerminalError) return err;
-  if (err instanceof TransientError) return err;
-  if (err && typeof err === "object" && "name" in err && err.name === "AbortError") {
-    return new TerminalError("Aborted", { cause: err });
-  }
-  if (err && typeof err === "object" && "status" in err) {
-    const status = Number(err.status);
-    const message2 = err && typeof err === "object" && "message" in err ? String(err.message ?? `HTTP ${status}`) : `HTTP ${status}`;
-    if (Number.isFinite(status) && status >= 400 && status < 500) {
-      return new TerminalError(message2, { status, cause: err });
-    }
-    if (Number.isFinite(status) && status >= 500) {
-      return new TransientError(message2, { status, cause: err });
-    }
-  }
-  const message = err instanceof Error ? err.message : String(err);
-  return new TransientError(message, { cause: err });
-}
-
-// src/transport/registry.ts
-var transports = /* @__PURE__ */ new Map();
-function registerEntityTransport(type, transport) {
-  transports.set(type, transport);
-}
-function getEntityTransport(type) {
-  const t = transports.get(type);
-  if (!t) {
-    throw new Error(
-      `[entity-management] No transport registered for entity type "${type}". Call registerEntityTransport("${type}", ...) at app boot.`
-    );
-  }
-  return t;
-}
-function __resetEntityTransports() {
-  transports.clear();
-}
-function getRegisteredEntityTypes() {
-  return Array.from(transports.keys());
-}
-
-// src/active-store.ts
-var moduleActiveStore = null;
-var asyncScope = null;
-var asyncScopeAttempted = false;
-function isNodeLike() {
-  return typeof process !== "undefined" && typeof process.versions?.node === "string";
-}
-function resolveAsyncScope() {
-  if (asyncScopeAttempted) return asyncScope;
-  asyncScopeAttempted = true;
-  if (!isNodeLike()) return null;
-  try {
-    const req = typeof module !== "undefined" && typeof module.require === "function" ? module.require : typeof __require === "function" ? __require : null;
-    if (!req) return null;
-    const { AsyncLocalStorage } = req("node:async_hooks");
-    asyncScope = new AsyncLocalStorage();
-  } catch {
-    asyncScope = null;
-  }
-  return asyncScope;
-}
-async function prepareGraphStoreScope() {
-  if (asyncScope) return true;
-  if (!isNodeLike()) {
-    asyncScopeAttempted = true;
-    return false;
-  }
-  if (resolveAsyncScope()) return true;
-  try {
-    const specifier = "node:async_hooks";
-    const mod = await import(
-      /* @vite-ignore */
-      specifier
-    );
-    asyncScope = new mod.AsyncLocalStorage();
-    asyncScopeAttempted = true;
-    return true;
-  } catch {
-    asyncScopeAttempted = true;
-    return false;
-  }
-}
-function setActiveGraphStore(store) {
-  const previous = moduleActiveStore;
-  moduleActiveStore = store;
-  return () => {
-    moduleActiveStore = previous;
-  };
-}
-var warnedUnscopedFallback = false;
-function warnUnscopedRequestFallback() {
-  if (warnedUnscopedFallback || !isNodeLike()) return;
-  warnedUnscopedFallback = true;
-  console.warn(
-    "[entity-graph-core] runWithGraphStore() could not load node:async_hooks, so it fell back to a module-level store. Concurrent requests will NOT be isolated. Await prepareGraphStoreScope() once during server startup."
-  );
-}
-function runWithGraphStore(store, fn) {
-  const scope = resolveAsyncScope();
-  if (!scope) {
-    warnUnscopedRequestFallback();
-    const restore = setActiveGraphStore(store);
-    try {
-      return fn();
-    } finally {
-      restore();
-    }
-  }
-  return scope.run(store, fn);
-}
-function resolveActiveGraphStore(fallback) {
-  const scoped = resolveAsyncScope()?.getStore();
-  if (scoped) return scoped;
-  return moduleActiveStore ?? fallback;
-}
-function __resetActiveGraphStore() {
-  moduleActiveStore = null;
-  asyncScope = null;
-  asyncScopeAttempted = false;
-  warnedUnscopedFallback = false;
-}
-
-// src/view/prisma-compile.ts
-function nestWhereField(parts, leaf) {
-  if (parts.length === 0) return {};
-  if (parts.length === 1) return { [parts[0]]: leaf };
-  return { [parts[0]]: nestWhereField(parts.slice(1), leaf) };
-}
-function clauseToPrismaLeaf(c) {
-  switch (c.op) {
-    case "eq":
-      return { equals: c.value };
-    case "neq":
-      return { not: c.value };
-    case "gt":
-      return { gt: c.value };
-    case "gte":
-      return { gte: c.value };
-    case "lt":
-      return { lt: c.value };
-    case "lte":
-      return { lte: c.value };
-    case "contains":
-      return { contains: c.value, mode: "insensitive" };
-    case "startsWith":
-      return { startsWith: c.value, mode: "insensitive" };
-    case "endsWith":
-      return { endsWith: c.value, mode: "insensitive" };
-    case "in":
-      return { in: c.value };
-    case "nin":
-      return { notIn: c.value };
-    case "arrayContains":
-      return { has: c.value };
-    case "between":
-    case "arrayOverlaps":
-    case "matches":
-    case "custom":
-    default:
-      return null;
-  }
-}
-function clauseToPrismaEntry(c) {
-  const parts = c.field.split(".").filter(Boolean);
-  if (parts.length === 0) return null;
-  if (c.op === "isNull") {
-    const equalsNull = c.value === void 0 || c.value === true;
-    return nestWhereField(parts, equalsNull ? null : { not: null });
-  }
-  if (c.op === "isNotNull") {
-    return nestWhereField(parts, { not: null });
-  }
-  const leaf = clauseToPrismaLeaf(c);
-  if (leaf === null) return null;
-  return nestWhereField(parts, leaf);
-}
-function groupToPrismaWhere(g) {
-  const parts = [];
-  for (const item of g.clauses) {
-    if ("logic" in item) {
-      const nested = groupToPrismaWhere(item);
-      if (Object.keys(nested).length > 0) parts.push(nested);
-    } else {
-      const entry = clauseToPrismaEntry(item);
-      if (entry) parts.push(entry);
-    }
-  }
-  if (parts.length === 0) return {};
-  if (parts.length === 1) return parts[0];
-  return g.logic === "or" ? { OR: parts } : { AND: parts };
-}
-function toPrismaWhere(filter) {
-  if (Array.isArray(filter)) {
-    const parts = [];
-    for (const item of filter) {
-      const entry = clauseToPrismaEntry(item);
-      if (entry) parts.push(entry);
-    }
-    if (parts.length === 0) return {};
-    if (parts.length === 1) return parts[0];
-    return { AND: parts };
-  }
-  return groupToPrismaWhere(filter);
-}
-function toPrismaOrderBy(sort) {
-  return sort.map((s) => ({ [s.field]: s.direction }));
-}
-
-// src/view/types.ts
-function toRestParams(view) {
-  const params = {};
-  if (view.filter) {
-    const clauses = flattenClauses(view.filter);
-    for (const c of clauses) {
-      if (c.op === "custom") continue;
-      const key = c.op === "eq" ? c.field : `${c.field}[${c.op}]`;
-      params[key] = Array.isArray(c.value) ? c.value.join(",") : String(c.value ?? "");
-    }
-  }
-  if (view.sort) params["sort"] = view.sort.map((s) => `${s.direction === "desc" ? "-" : ""}${s.field}`).join(",");
-  if (view.search?.query) params["q"] = view.search.query;
-  return params;
-}
-function toSQLClauses(view) {
-  const params = [];
-  let paramIdx = 1;
-  function clauseToSQL(c) {
-    const col = `"${c.field}"`;
-    switch (c.op) {
-      case "eq":
-        params.push(c.value);
-        return `${col} = $${paramIdx++}`;
-      case "neq":
-        params.push(c.value);
-        return `${col} != $${paramIdx++}`;
-      case "gt":
-        params.push(c.value);
-        return `${col} > $${paramIdx++}`;
-      case "gte":
-        params.push(c.value);
-        return `${col} >= $${paramIdx++}`;
-      case "lt":
-        params.push(c.value);
-        return `${col} < $${paramIdx++}`;
-      case "lte":
-        params.push(c.value);
-        return `${col} <= $${paramIdx++}`;
-      case "in":
-        params.push(c.value);
-        return `${col} = ANY($${paramIdx++})`;
-      case "nin":
-        params.push(c.value);
-        return `${col} != ALL($${paramIdx++})`;
-      case "isNull":
-        return `${col} IS NULL`;
-      case "isNotNull":
-        return `${col} IS NOT NULL`;
-      case "contains":
-        params.push(`%${c.value}%`);
-        return `${col} ILIKE $${paramIdx++}`;
-      case "startsWith":
-        params.push(`${c.value}%`);
-        return `${col} ILIKE $${paramIdx++}`;
-      case "between": {
-        const [lo, hi] = c.value;
-        params.push(lo, hi);
-        return `${col} BETWEEN $${paramIdx++} AND $${paramIdx++}`;
-      }
-      case "arrayContains":
-        params.push(c.value);
-        return `$${paramIdx++} = ANY(${col})`;
-      default:
-        return "TRUE";
-    }
-  }
-  function groupToSQL(g) {
-    const parts = g.clauses.map((c) => "logic" in c ? `(${groupToSQL(c)})` : clauseToSQL(c));
-    return parts.join(` ${g.logic.toUpperCase()} `);
-  }
-  let where = "TRUE";
-  if (view.filter) {
-    if (Array.isArray(view.filter)) where = view.filter.map(clauseToSQL).join(" AND ") || "TRUE";
-    else where = groupToSQL(view.filter) || "TRUE";
-  }
-  if (view.search?.query) {
-    params.push(`%${view.search.query}%`);
-    where += ` AND (${view.search.fields.map((f) => `"${f}"`).join(" || ' ' || ")}) ILIKE $${paramIdx++}`;
-  }
-  const orderBy = view.sort ? view.sort.map((s) => `"${s.field}" ${s.direction.toUpperCase()}${s.nulls ? ` NULLS ${s.nulls.toUpperCase()}` : ""}`).join(", ") : "";
-  return { where, orderBy, params };
-}
-function toGraphQLVariables(view) {
-  const result = {};
-  if (view.filter) {
-    const clauses = flattenClauses(view.filter);
-    const where = {};
-    for (const c of clauses) {
-      if (c.op === "custom") continue;
-      where[c.field] = { [`_${c.op}`]: c.value };
-    }
-    if (Object.keys(where).length) result.where = where;
-  }
-  if (view.sort) result.orderBy = view.sort.map((s) => ({ [s.field]: s.direction === "desc" ? "desc_nulls_last" : "asc_nulls_last" }));
-  if (view.search?.query) result.search = view.search.query;
-  return result;
-}
-function flattenClauses(filter) {
-  if (Array.isArray(filter)) return filter;
-  function walk(g) {
-    return g.clauses.flatMap((c) => "logic" in c ? walk(c) : [c]);
-  }
-  return walk(filter);
-}
-function hasCustomPredicates(filter) {
-  return flattenClauses(filter).some((c) => c.op === "custom");
-}
-
-// src/transport/rest.ts
-function makeRestTransport(opts) {
-  const {
-    supabase,
-    table,
-    select = "*",
-    identify = (row) => String(row.id),
-    authoritative = false,
-    staleTime,
-    searchColumns = [],
-    defaultLimit = 200
-  } = opts;
-  return {
-    identify,
-    authoritative,
-    staleTime,
-    async list(q) {
-      const limit = q.limit ?? defaultLimit;
-      const offset = typeof q.cursor === "number" ? q.cursor : 0;
-      let builder = supabase.from(table).select(select, { count: offset === 0 ? "exact" : void 0 });
-      if (q.filter) builder = applyFilter(builder, q.filter);
-      if (q.search && searchColumns.length > 0) {
-        const escaped = q.search.replace(/[%,()]/g, "");
-        const orClause = searchColumns.map((c) => `${c}.ilike.*${escaped}*`).join(",");
-        builder = builder.or(orClause);
-      }
-      if (q.sort) {
-        for (const s of q.sort) {
-          builder = builder.order(s.field, {
-            ascending: s.direction === "asc",
-            nullsFirst: s.nulls === "first"
-          });
-        }
-      }
-      builder = builder.range(offset, offset + limit - 1);
-      if (q.signal && builder.abortSignal) builder = builder.abortSignal(q.signal);
-      const result = await builder;
-      if (result.error) {
-        throw mapPostgrestError(result.error, result.status);
-      }
-      const rows = result.data ?? [];
-      const total = typeof result.count === "number" ? result.count : null;
-      const nextCursor = rows.length === limit ? offset + limit : null;
-      return { rows, total, nextCursor };
-    }
-  };
-}
-function applyFilter(builder, filter) {
-  if (!Array.isArray(filter) && filter.logic === "or") {
-    const parts = filter.clauses.filter((c) => !("logic" in c)).map((c) => clauseToOrFragment(c)).filter((s) => !!s);
-    if (parts.length > 0) return builder.or(parts.join(","));
-    return builder;
-  }
-  const clauses = flattenClauses(filter);
-  let b = builder;
-  for (const c of clauses) {
-    b = applyClause(b, c);
-  }
-  return b;
-}
-function applyClause(builder, c) {
-  switch (c.op) {
-    case "eq":
-      return builder.eq(c.field, c.value);
-    case "neq":
-      return builder.neq(c.field, c.value);
-    case "gt":
-      return builder.gt(c.field, c.value);
-    case "gte":
-      return builder.gte(c.field, c.value);
-    case "lt":
-      return builder.lt(c.field, c.value);
-    case "lte":
-      return builder.lte(c.field, c.value);
-    case "in":
-      return builder.in(c.field, c.value);
-    case "isNull":
-      return builder.is(c.field, null);
-    case "isNotNull":
-      return builder.neq(c.field, null);
-    case "contains":
-      return builder.ilike(c.field, `%${String(c.value)}%`);
-    case "startsWith":
-      return builder.ilike(c.field, `${String(c.value)}%`);
-    case "endsWith":
-      return builder.ilike(c.field, `%${String(c.value)}`);
-    case "matches":
-      return builder.ilike(c.field, String(c.value));
-    case "custom":
-      return builder;
-    // local-only predicate; skip on server
-    default:
-      return builder;
-  }
-}
-function clauseToOrFragment(c) {
-  const v = encodeURIComponent(String(c.value ?? ""));
-  switch (c.op) {
-    case "eq":
-      return `${c.field}.eq.${v}`;
-    case "neq":
-      return `${c.field}.neq.${v}`;
-    case "gt":
-      return `${c.field}.gt.${v}`;
-    case "gte":
-      return `${c.field}.gte.${v}`;
-    case "lt":
-      return `${c.field}.lt.${v}`;
-    case "lte":
-      return `${c.field}.lte.${v}`;
-    case "isNull":
-      return `${c.field}.is.null`;
-    case "isNotNull":
-      return `${c.field}.not.is.null`;
-    case "contains":
-      return `${c.field}.ilike.*${v}*`;
-    case "startsWith":
-      return `${c.field}.ilike.${v}*`;
-    case "endsWith":
-      return `${c.field}.ilike.*${v}`;
-    default:
-      return null;
-  }
-}
-function mapPostgrestError(error, status) {
-  if (error instanceof TerminalError || error instanceof TransientError) return error;
-  const message = error && typeof error === "object" && "message" in error ? String(error.message ?? "Unknown REST error") : String(error);
-  if (typeof status === "number") {
-    if (status >= 400 && status < 500) {
-      return new TerminalError(message, { status, cause: error });
-    }
-    if (status >= 500) {
-      return new TransientError(message, { status, cause: error });
-    }
-  }
-  const code = error && typeof error === "object" && "code" in error ? String(error.code ?? "") : "";
-  if (code === "42P01" || code === "PGRST116" || code === "PGRST106") {
-    return new TerminalError(message, { cause: error });
-  }
-  return toEntityError(error);
-}
-
-// src/merge/lww.ts
-var lwwStrategy = (prev, next) => {
-  return prev ? { ...prev, ...next } : { ...next };
-};
-
-// src/merge/registry.ts
-var byType = /* @__PURE__ */ new Map();
-var globalDefault = null;
-function registerMergeStrategy(type, strategy) {
-  byType.set(type, strategy);
-}
-function setDefaultMergeStrategy(strategy) {
-  globalDefault = strategy;
-}
-function getMergeStrategy(type) {
-  return byType.get(type) ?? globalDefault ?? lwwStrategy;
-}
-function hasMergeStrategy(type) {
-  return byType.has(type) || globalDefault !== null;
-}
-
-// src/view/evaluator.ts
-function matchesFilter(entity, filter) {
-  if (Array.isArray(filter)) return filter.every((clause) => matchesClause(entity, clause));
-  return matchesGroup(entity, filter);
-}
-function matchesGroup(entity, group) {
-  const { logic, clauses } = group;
-  if (logic === "and") return clauses.every((c) => "logic" in c ? matchesGroup(entity, c) : matchesClause(entity, c));
-  return clauses.some((c) => "logic" in c ? matchesGroup(entity, c) : matchesClause(entity, c));
-}
-function matchesClause(entity, clause) {
-  const { field, op, value, predicate } = clause;
-  const fv = getNestedValue(entity, field);
-  switch (op) {
-    case "eq":
-      return fv === value;
-    case "neq":
-      return fv !== value;
-    case "gt":
-      return fv > value;
-    case "gte":
-      return fv >= value;
-    case "lt":
-      return fv < value;
-    case "lte":
-      return fv <= value;
-    case "in":
-      return Array.isArray(value) && value.includes(fv);
-    case "nin":
-      return Array.isArray(value) && !value.includes(fv);
-    case "isNull":
-      return fv == null;
-    case "isNotNull":
-      return fv != null;
-    case "contains":
-      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().includes(value.toLowerCase());
-    case "startsWith":
-      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().startsWith(value.toLowerCase());
-    case "endsWith":
-      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().endsWith(value.toLowerCase());
-    case "between": {
-      const [lo, hi] = value;
-      return fv >= lo && fv <= hi;
-    }
-    case "arrayContains":
-      return Array.isArray(fv) && fv.includes(value);
-    case "arrayOverlaps":
-      return Array.isArray(fv) && Array.isArray(value) && value.some((v) => fv.includes(v));
-    case "matches":
-      return typeof fv === "string" && new RegExp(value).test(fv);
-    case "custom":
-      return predicate ? predicate(fv, entity) : true;
-    default:
-      return true;
-  }
-}
-function matchesSearch(entity, query, fields) {
-  if (!query.trim()) return true;
-  const lq = query.toLowerCase();
-  return fields.some((field) => {
-    const v = getNestedValue(entity, field);
-    return typeof v === "string" && v.toLowerCase().includes(lq);
-  });
-}
-function compareEntities(a, b, sort) {
-  for (const clause of sort) {
-    const r = compareByClause(a, b, clause);
-    if (r !== 0) return r;
-  }
-  return 0;
-}
-function compareByClause(a, b, clause) {
-  const { field, direction, nulls = "last", comparator } = clause;
-  const av = getNestedValue(a, field);
-  const bv = getNestedValue(b, field);
-  const aNull = av == null;
-  const bNull = bv == null;
-  if (aNull && bNull) return 0;
-  if (aNull) return nulls === "first" ? -1 : 1;
-  if (bNull) return nulls === "first" ? 1 : -1;
-  let cmp;
-  if (comparator) cmp = comparator(av, bv);
-  else if (typeof av === "string" && typeof bv === "string") cmp = av.localeCompare(bv, void 0, { sensitivity: "base", numeric: true });
-  else if (typeof av === "number" && typeof bv === "number") cmp = av - bv;
-  else cmp = String(av).localeCompare(String(bv));
-  return direction === "desc" ? -cmp : cmp;
-}
-function findInsertionIndex(entity, sortedIds, getEntity, sort) {
-  let lo = 0;
-  let hi = sortedIds.length;
-  while (lo < hi) {
-    const mid = lo + hi >>> 1;
-    const me = getEntity(sortedIds[mid]);
-    if (!me) {
-      lo = mid + 1;
-      continue;
-    }
-    if (compareEntities(entity, me, sort) <= 0) hi = mid;
-    else lo = mid + 1;
-  }
-  return lo;
-}
-function applyView(ids, getEntity, filter, sort, search) {
-  let entries = [];
-  for (const id of ids) {
-    const entity = getEntity(id);
-    if (!entity) continue;
-    entries.push({ id, entity });
-  }
-  if (filter && entries.length > 0) entries = entries.filter(({ entity }) => matchesFilter(entity, filter));
-  if (search?.query) entries = entries.filter(({ entity }) => matchesSearch(entity, search.query, search.fields));
-  if (sort && sort.length > 0) entries.sort((a, b) => compareEntities(a.entity, b.entity, sort));
-  return entries.map((e) => e.id);
-}
-function checkCompleteness(loadedCount, total, hasNextPage) {
-  if (!hasNextPage && total !== null && loadedCount >= total) return { isComplete: true, reason: "all-loaded" };
-  if (hasNextPage) return { isComplete: false, reason: "has-more-pages" };
-  return { isComplete: true, reason: "no-more-pages" };
-}
-function getNestedValue(obj, path) {
-  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current == null || typeof current !== "object") return void 0;
-    current = current[part];
-  }
-  return current;
-}
-
-// src/graph.ts
-var EMPTY_IDS = [];
-var EMPTY_ENTITY_STATE = {
-  isFetching: false,
-  lastFetched: null,
-  error: null,
-  stale: false
-};
-var EMPTY_SYNC_METADATA = {
-  synced: true,
-  origin: "server",
-  updatedAt: null
-};
-var EMPTY_LIST_STATE = {
-  ids: EMPTY_IDS,
-  total: null,
-  nextCursor: null,
-  prevCursor: null,
-  hasNextPage: false,
-  hasPrevPage: false,
-  isFetching: false,
-  isFetchingMore: false,
-  error: null,
-  lastError: null,
-  lastFetched: null,
-  stale: false,
-  currentPage: null,
-  pageSize: null
-};
-function defaultEntityState() {
-  return { ...EMPTY_ENTITY_STATE };
-}
-function defaultSyncMetadata() {
-  return { ...EMPTY_SYNC_METADATA };
-}
-function defaultListState() {
-  return { ...EMPTY_LIST_STATE, ids: [] };
-}
-function ek(type, id) {
-  return `${type}:${id}`;
-}
-var snapshotCache = /* @__PURE__ */ new Map();
-function readCachedEntitySnapshot(type, id, base, patch, metadata) {
-  const key = ek(type, id);
-  const cached = snapshotCache.get(key);
-  if (cached && cached.base === base && cached.patch === patch && cached.metadata === metadata) {
-    return cached.snapshot;
-  }
-  const snapshot = {
-    ...patch ? { ...base, ...patch } : base,
-    $synced: metadata.synced,
-    $origin: metadata.origin,
-    $updatedAt: metadata.updatedAt
-  };
-  snapshotCache.set(key, { base, patch, metadata, snapshot });
-  return snapshot;
-}
-function createGraphStore() {
-  return vanilla.createStore()(
-    middleware.subscribeWithSelector(
-      immer.immer((set, get) => ({
-        entities: {},
-        patches: {},
-        entityStates: {},
-        syncMetadata: {},
-        lists: {},
-        upsertEntity: (type, id, data) => set((s) => {
-          if (!s.entities[type]) s.entities[type] = {};
-          const key = ek(type, id);
-          const strategy = getMergeStrategy(type);
-          const ctx = { type, id, origin: s.syncMetadata[key]?.origin ?? "server", updatedAt: Date.now() };
-          s.entities[type][id] = strategy(s.entities[type][id], data, ctx);
-          if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
-        }),
-        upsertEntities: (type, entries) => set((s) => {
-          if (!s.entities[type]) s.entities[type] = {};
-          const strategy = getMergeStrategy(type);
-          for (const { id, data } of entries) {
-            const key = ek(type, id);
-            const ctx = { type, id, origin: s.syncMetadata[key]?.origin ?? "server", updatedAt: Date.now() };
-            s.entities[type][id] = strategy(s.entities[type][id], data, ctx);
-            if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
-          }
-        }),
-        ingestFetchedList: (type, entries, options = {}) => set((s) => {
-          const fetchedAt = Date.now();
-          const ids = entries.map(({ id }) => id);
-          const batches = [
-            { type, entries },
-            ...options.sideBatches ?? []
-          ];
-          const origins = /* @__PURE__ */ new Map();
-          for (const batch of batches) {
-            if (!s.entities[batch.type]) s.entities[batch.type] = {};
-            for (const { id } of batch.entries) {
-              const key = ek(batch.type, id);
-              if (!origins.has(key)) {
-                origins.set(key, s.syncMetadata[key]?.origin ?? "server");
-              }
-            }
-          }
-          for (const batch of batches) {
-            const strategy = getMergeStrategy(batch.type);
-            for (const { id, data } of batch.entries) {
-              const key = ek(batch.type, id);
-              const ctx = {
-                type: batch.type,
-                id,
-                origin: origins.get(key) ?? "server",
-                updatedAt: fetchedAt
-              };
-              s.entities[batch.type][id] = strategy(s.entities[batch.type][id], data, ctx);
-            }
-          }
-          const completed = /* @__PURE__ */ new Set();
-          for (const batch of batches) {
-            for (const { id } of batch.entries) {
-              const key = ek(batch.type, id);
-              if (completed.has(key)) continue;
-              completed.add(key);
-              if (!s.entityStates[key]) s.entityStates[key] = defaultEntityState();
-              s.entityStates[key].lastFetched = fetchedAt;
-              s.entityStates[key].isFetching = false;
-              s.entityStates[key].error = null;
-              s.entityStates[key].stale = false;
-              s.syncMetadata[key] = {
-                ...s.syncMetadata[key] ?? defaultSyncMetadata(),
-                synced: true,
-                origin: "server",
-                updatedAt: fetchedAt
-              };
-            }
-          }
-          const readDraftEntity = (id) => {
-            const base = s.entities[type]?.[id];
-            if (!base) return null;
-            const patch = s.patches[type]?.[id];
-            const metadata = s.syncMetadata[ek(type, id)] ?? defaultSyncMetadata();
-            return {
-              ...base,
-              ...patch ?? {},
-              $synced: metadata.synced,
-              $origin: metadata.origin,
-              $updatedAt: metadata.updatedAt
-            };
-          };
-          for (const target of options.lists ?? []) {
-            const existing = s.lists[target.key] ?? defaultListState();
-            const targetIds = target.ids ?? ids;
-            const nextIds = target.mode === "append" ? Array.from(/* @__PURE__ */ new Set([...existing.ids, ...targetIds])) : targetIds;
-            s.lists[target.key] = {
-              ...existing,
-              ...target.meta ?? {},
-              ids: nextIds,
-              isFetching: false,
-              isFetchingMore: false,
-              error: null,
-              lastError: null,
-              stale: false,
-              lastFetched: fetchedAt
-            };
-          }
-          for (const projection of options.projections ?? []) {
-            const existing = s.lists[projection.key] ?? defaultListState();
-            const nextIds = [...existing.ids];
-            const { filter, sort, search } = projection.view;
-            for (const id of new Set(ids)) {
-              if (nextIds.includes(id)) continue;
-              const entity = readDraftEntity(id);
-              if (!entity) continue;
-              const matches = (!filter || matchesFilter(entity, filter)) && (!search?.query || matchesSearch(entity, search.query, search.fields));
-              if (!matches) continue;
-              if (sort && sort.length > 0) {
-                const index = findInsertionIndex(entity, nextIds, readDraftEntity, sort);
-                nextIds.splice(index, 0, id);
-              } else {
-                nextIds.unshift(id);
-              }
-            }
-            s.lists[projection.key] = projection.completeFetch ? {
-              ...existing,
-              ids: nextIds,
-              isFetching: false,
-              isFetchingMore: false,
-              error: null,
-              lastError: null,
-              stale: false,
-              lastFetched: fetchedAt
-            } : { ...existing, ids: nextIds };
-          }
-          for (const key of options.finishListFetches ?? []) {
-            if (!s.lists[key]) s.lists[key] = defaultListState();
-            s.lists[key].isFetching = false;
-          }
-        }),
-        replaceEntity: (type, id, data) => set((s) => {
-          if (!s.entities[type]) s.entities[type] = {};
-          s.entities[type][id] = data;
-          const key = ek(type, id);
-          if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
-        }),
-        removeEntity: (type, id) => set((s) => {
-          delete s.entities[type]?.[id];
-          delete s.patches[type]?.[id];
-          delete s.entityStates[ek(type, id)];
-          delete s.syncMetadata[ek(type, id)];
-        }),
-        patchEntity: (type, id, patch) => set((s) => {
-          if (!s.patches[type]) s.patches[type] = {};
-          s.patches[type][id] = { ...s.patches[type][id] ?? {}, ...patch };
-        }),
-        unpatchEntity: (type, id, keys) => set((s) => {
-          const p = s.patches[type]?.[id];
-          if (!p) return;
-          for (const k of keys) delete p[k];
-        }),
-        clearPatch: (type, id) => set((s) => {
-          delete s.patches[type]?.[id];
-        }),
-        setEntityFetching: (type, id, fetching) => set((s) => {
-          const k = ek(type, id);
-          if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
-          s.entityStates[k].isFetching = fetching;
-        }),
-        setEntityError: (type, id, error) => set((s) => {
-          const k = ek(type, id);
-          if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
-          s.entityStates[k].error = error;
-          s.entityStates[k].isFetching = false;
-        }),
-        setEntityFetched: (type, id) => set((s) => {
-          const k = ek(type, id);
-          if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
-          s.entityStates[k].lastFetched = Date.now();
-          s.entityStates[k].isFetching = false;
-          s.entityStates[k].error = null;
-          s.entityStates[k].stale = false;
-          s.syncMetadata[k] = { ...s.syncMetadata[k] ?? defaultSyncMetadata(), synced: true, origin: "server", updatedAt: Date.now() };
-        }),
-        setEntityStale: (type, id, stale) => set((s) => {
-          const k = ek(type, id);
-          if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
-          s.entityStates[k].stale = stale;
-        }),
-        setEntitySyncMetadata: (type, id, metadata) => set((s) => {
-          const k = ek(type, id);
-          s.syncMetadata[k] = { ...s.syncMetadata[k] ?? defaultSyncMetadata(), ...metadata };
-        }),
-        clearEntitySyncMetadata: (type, id) => set((s) => {
-          delete s.syncMetadata[ek(type, id)];
-        }),
-        setListResult: (key, ids, meta) => set((s) => {
-          const ex = s.lists[key] ?? defaultListState();
-          s.lists[key] = { ...ex, ...meta, ids, isFetching: false, isFetchingMore: false, error: null, lastError: null, stale: false, lastFetched: Date.now() };
-        }),
-        appendListResult: (key, ids, meta) => set((s) => {
-          const ex = s.lists[key] ?? defaultListState();
-          s.lists[key] = { ...ex, ...meta, ids: Array.from(/* @__PURE__ */ new Set([...ex.ids, ...ids])), isFetching: false, isFetchingMore: false, error: null, lastError: null, stale: false, lastFetched: Date.now() };
-        }),
-        prependListResult: (key, ids, meta) => set((s) => {
-          const ex = s.lists[key] ?? defaultListState();
-          s.lists[key] = { ...ex, ...meta ?? {}, ids: Array.from(/* @__PURE__ */ new Set([...ids, ...ex.ids])), isFetching: false, isFetchingMore: false, error: null, lastError: null, stale: false, lastFetched: Date.now() };
-        }),
-        removeIdFromAllLists: (_type, id) => set((s) => {
-          for (const key of Object.keys(s.lists)) {
-            const list = s.lists[key];
-            const idx = list.ids.indexOf(id);
-            if (idx !== -1) {
-              list.ids.splice(idx, 1);
-              if (list.total !== null) list.total -= 1;
-            }
-          }
-        }),
-        insertIdInList: (key, id, position) => set((s) => {
-          if (!s.lists[key]) s.lists[key] = defaultListState();
-          const ids = s.lists[key].ids;
-          const ex = ids.indexOf(id);
-          if (ex !== -1) ids.splice(ex, 1);
-          if (position === "start") ids.unshift(id);
-          else if (position === "end") ids.push(id);
-          else ids.splice(position, 0, id);
-        }),
-        setListFetching: (key, fetching) => set((s) => {
-          if (!s.lists[key]) s.lists[key] = defaultListState();
-          s.lists[key].isFetching = fetching;
-        }),
-        setListFetchingMore: (key, fetchingMore) => set((s) => {
-          if (!s.lists[key]) s.lists[key] = defaultListState();
-          s.lists[key].isFetchingMore = fetchingMore;
-        }),
-        setListError: (key, error, typed) => set((s) => {
-          if (!s.lists[key]) s.lists[key] = defaultListState();
-          s.lists[key].error = error;
-          s.lists[key].lastError = typed ?? (error === null ? null : s.lists[key].lastError);
-          s.lists[key].isFetching = false;
-          s.lists[key].isFetchingMore = false;
-          s.lists[key].lastFetched = Date.now();
-          s.lists[key].stale = false;
-        }),
-        setListStale: (key, stale) => set((s) => {
-          if (!s.lists[key]) s.lists[key] = defaultListState();
-          s.lists[key].stale = stale;
-        }),
-        invalidateEntity: (type, id) => set((s) => {
-          if (id) {
-            const k = ek(type, id);
-            if (s.entityStates[k]) s.entityStates[k].stale = true;
-          } else {
-            for (const k of Object.keys(s.entityStates)) if (k.startsWith(`${type}:`)) s.entityStates[k].stale = true;
-          }
-        }),
-        invalidateLists: (matcher) => set((s) => {
-          const pred = typeof matcher === "string" ? (k) => k.startsWith(matcher) : matcher;
-          for (const key of Object.keys(s.lists)) if (pred(key)) s.lists[key].stale = true;
-        }),
-        invalidateType: (type) => {
-          get().invalidateEntity(type);
-          get().invalidateLists(type);
-        },
-        readEntity: (type, id) => {
-          const s = get();
-          const base = s.entities[type]?.[id];
-          if (!base) return null;
-          const patch = s.patches[type]?.[id];
-          return patch ? { ...base, ...patch } : base;
-        },
-        readEntitySnapshot: (type, id) => {
-          const s = get();
-          const base = s.entities[type]?.[id];
-          if (!base) {
-            snapshotCache.delete(ek(type, id));
-            return null;
-          }
-          const patch = s.patches[type]?.[id];
-          const metadata = s.syncMetadata[ek(type, id)] ?? EMPTY_SYNC_METADATA;
-          return readCachedEntitySnapshot(
-            type,
-            id,
-            base,
-            patch,
-            metadata
-          );
-        }
-      }))
-    )
-  );
-}
-var graphStore = createGraphStore();
-var useGraphStore = graphStore;
-
-// src/object-path.ts
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function getValueAtPath(source, path) {
-  if (!path) return source;
-  const segments = path.split(".").filter(Boolean);
-  let current = source;
-  for (const segment of segments) {
-    if (!isObject(current) && !Array.isArray(current)) return void 0;
-    current = current[segment];
-  }
-  return current;
-}
-function setValueAtPath(source, path, value) {
-  const segments = path.split(".").filter(Boolean);
-  if (segments.length === 0) return source;
-  const clone2 = structuredClone(source);
-  let current = clone2;
-  for (let index = 0; index < segments.length - 1; index += 1) {
-    const segment = segments[index];
-    const next = current[segment];
-    if (!isObject(next)) current[segment] = {};
-    current = current[segment];
-  }
-  current[segments[segments.length - 1]] = value;
-  return clone2;
-}
-function collectDirtyPaths(current, original, prefix = "", acc = /* @__PURE__ */ new Set()) {
-  if (isObject(current) && isObject(original)) {
-    const keys = /* @__PURE__ */ new Set([...Object.keys(current), ...Object.keys(original)]);
-    for (const key of keys) {
-      const nextPrefix = prefix ? `${prefix}.${key}` : key;
-      collectDirtyPaths(current[key], original[key], nextPrefix, acc);
-    }
-    return acc;
-  }
-  if (JSON.stringify(current) !== JSON.stringify(original) && prefix) acc.add(prefix);
-  return acc;
-}
-
-// src/merge/loro.ts
-var ROOT_MAP = "entity";
-var LORO_MODULE_SPECIFIER = "loro-crdt";
-var docs = /* @__PURE__ */ new Map();
-function ek2(type, id) {
-  return `${type}:${id}`;
-}
-async function createLoroMergeStrategy(loadLoro) {
-  let mod;
-  try {
-    const loaded = loadLoro ? await loadLoro() : await import(
-      /* @vite-ignore */
-      LORO_MODULE_SPECIFIER
-    );
-    if (typeof loaded.LoroDoc !== "function") {
-      throw new TypeError("loro-crdt did not export a LoroDoc constructor");
-    }
-    mod = loaded;
-  } catch (cause) {
-    throw new Error(
-      "[merge/loro] createLoroMergeStrategy requires the optional peer dependency 'loro-crdt'. Install it with `pnpm add loro-crdt`.",
-      { cause }
-    );
-  }
-  const { LoroDoc } = mod;
-  return (prev, next, ctx) => {
-    const key = ek2(ctx.type, ctx.id);
-    let doc = docs.get(key);
-    if (!doc) {
-      doc = new LoroDoc();
-      docs.set(key, doc);
-      if (prev) {
-        const seed = doc.getMap(ROOT_MAP);
-        for (const [k, v] of Object.entries(prev)) seed.set(k, v);
-      }
-    }
-    const map = doc.getMap(ROOT_MAP);
-    for (const [k, v] of Object.entries(next)) map.set(k, v);
-    const root = doc.toJSON()[ROOT_MAP];
-    return root && typeof root === "object" ? root : { ...next };
-  };
-}
-
-// src/graph-query.ts
-function queryOnce(opts) {
-  const store = useGraphStore.getState();
-  const ids = resolveCandidateIds(store, opts);
-  let rows = ids.map((id) => store.readEntitySnapshot(opts.type, id)).filter((row) => row !== null);
-  if (opts.where) rows = rows.filter(opts.where);
-  if (opts.sort) rows = [...rows].sort(opts.sort);
-  const projected = rows.map((row) => applySelection(projectRow(row, opts.include, store), opts.select));
-  if (opts.id) return projected[0] ?? null;
-  return projected;
-}
-var selectGraph = queryOnce;
-function resolveCandidateIds(store, opts) {
-  if (opts.id) return [opts.id];
-  if (opts.ids) return opts.ids;
-  if (opts.listKey) return store.lists[opts.listKey]?.ids ?? [];
-  return Object.keys(store.entities[opts.type] ?? {});
-}
-function projectRow(row, include, store) {
-  if (!include) return row;
-  const projected = { ...row };
-  for (const [key, relation] of Object.entries(include)) {
-    const related = resolveRelation(row, relation, store);
-    projected[key] = related;
-  }
-  return projected;
-}
-function resolveRelation(entity, relation, store) {
-  const include = relation.include;
-  switch (relation.via.kind) {
-    case "field": {
-      const relatedId = entity[relation.via.field];
-      if (typeof relatedId !== "string") return null;
-      const related = store.readEntitySnapshot(relation.type, relatedId);
-      return related ? projectRow(related, include, store) : null;
-    }
-    case "array": {
-      const ids = entity[relation.via.field];
-      if (!Array.isArray(ids)) return [];
-      return ids.map((id) => typeof id === "string" ? store.readEntitySnapshot(relation.type, id) : null).filter((row) => row !== null).map((row) => projectRow(row, include, store));
-    }
-    case "list": {
-      const key = typeof relation.via.key === "function" ? relation.via.key(entity) : relation.via.key;
-      if (!key) return [];
-      const ids = store.lists[key]?.ids ?? [];
-      return ids.map((id) => store.readEntitySnapshot(relation.type, id)).filter((row) => row !== null).map((row) => projectRow(row, include, store));
-    }
-    case "resolver": {
-      const resolved = relation.via.resolve(entity, store);
-      if (Array.isArray(resolved)) {
-        return resolved.map((id) => store.readEntitySnapshot(relation.type, id)).filter((row) => row !== null).map((row) => projectRow(row, include, store));
-      }
-      if (typeof resolved !== "string") return null;
-      const related = store.readEntitySnapshot(relation.type, resolved);
-      return related ? projectRow(related, include, store) : null;
-    }
-  }
-}
-function applySelection(row, select) {
-  if (!select) return row;
-  if (typeof select === "function") {
-    const result = select(row);
-    return result && typeof result === "object" ? result : { value: result };
-  }
-  const picked = {};
-  for (const key of select) {
-    if (key in row) picked[key] = row[key];
-  }
-  return picked;
-}
-
-// src/legacy-devtools.ts
-var listeners = /* @__PURE__ */ new Set();
-function publish(event) {
-  if (listeners.size === 0) return;
-  for (const listener of [...listeners]) {
-    try {
-      listener(event);
-    } catch {
-      console.warn("[engine] devtools subscriber threw");
-    }
-  }
-}
-function subscribeLegacyDevtoolsEvent(listener) {
-  listeners.add(listener);
-  return () => listeners.delete(listener);
-}
-function emitLegacyDevtoolsEvent(event) {
-  publish(event);
-}
-
-// src/graph-actions.ts
-var graphActionListeners = /* @__PURE__ */ new Set();
-var graphActionReplayers = /* @__PURE__ */ new Map();
-function createGraphTransaction(storeApi = graphStore) {
-  const baseline = cloneGraphData(storeApi.getState());
-  let closed = false;
-  const tx = {
-    upsertEntity(type, id, data) {
-      storeApi.getState().upsertEntity(type, id, data);
-      if (typeof process === "undefined" || process.env.NODE_ENV !== "production") {
-        emitLegacyDevtoolsEvent({ kind: "upsert", type, id, data, at: (/* @__PURE__ */ new Date()).toISOString() });
-      }
-      return tx;
-    },
-    replaceEntity(type, id, data) {
-      storeApi.getState().replaceEntity(type, id, data);
-      return tx;
-    },
-    removeEntity(type, id) {
-      storeApi.getState().removeEntity(type, id);
-      return tx;
-    },
-    patchEntity(type, id, patch) {
-      storeApi.getState().patchEntity(type, id, patch);
-      if (typeof process === "undefined" || process.env.NODE_ENV !== "production") {
-        emitLegacyDevtoolsEvent({ kind: "patch", type, id, patch, at: (/* @__PURE__ */ new Date()).toISOString() });
-      }
-      return tx;
-    },
-    clearPatch(type, id) {
-      storeApi.getState().clearPatch(type, id);
-      if (typeof process === "undefined" || process.env.NODE_ENV !== "production") {
-        emitLegacyDevtoolsEvent({ kind: "clearPatch", type, id, at: (/* @__PURE__ */ new Date()).toISOString() });
-      }
-      return tx;
-    },
-    insertIdInList(key, id, position) {
-      storeApi.getState().insertIdInList(key, id, position);
-      return tx;
-    },
-    removeIdFromAllLists(type, id) {
-      storeApi.getState().removeIdFromAllLists(type, id);
-      return tx;
-    },
-    setEntitySyncMetadata(type, id, metadata) {
-      storeApi.getState().setEntitySyncMetadata(type, id, metadata);
-      return tx;
-    },
-    markEntityPending(type, id, origin = "optimistic") {
-      storeApi.getState().setEntitySyncMetadata(type, id, {
-        synced: false,
-        origin,
-        updatedAt: Date.now()
-      });
-      return tx;
-    },
-    markEntitySynced(type, id, origin = "server") {
-      storeApi.getState().setEntitySyncMetadata(type, id, {
-        synced: true,
-        origin,
-        updatedAt: Date.now()
-      });
-      return tx;
-    },
-    commit() {
-      closed = true;
-    },
-    rollback() {
-      if (closed) return;
-      storeApi.setState(cloneGraphData(baseline));
-      closed = true;
-    },
-    snapshot() {
-      return cloneGraphData(storeApi.getState());
-    }
-  };
-  return tx;
-}
-function createGraphAction(opts) {
-  if (opts.key) {
-    graphActionReplayers.set(opts.key, async (record, storeApi) => {
-      const tx = createGraphTransaction(storeApi);
-      try {
-        const result = await opts.run(tx, record.input);
-        tx.commit();
-        return result;
-      } catch (error) {
-        tx.rollback();
-        throw error;
-      }
-    });
-  }
-  return async (input) => {
-    const tx = createGraphTransaction();
-    const record = opts.key ? {
-      id: `${opts.key}:${Date.now()}`,
-      key: opts.key,
-      input: structuredClone(input),
-      enqueuedAt: (/* @__PURE__ */ new Date()).toISOString()
-    } : null;
-    try {
-      if (record) emitGraphActionEvent({ type: "enqueued", record });
-      opts.optimistic?.(tx, input);
-      const result = await opts.run(tx, input);
-      opts.onSuccess?.(result, input, tx);
-      tx.commit();
-      if (record) emitGraphActionEvent({ type: "settled", record });
-      return result;
-    } catch (error) {
-      tx.rollback();
-      const normalized = error instanceof Error ? error : new Error(String(error));
-      if (record) emitGraphActionEvent({ type: "settled", record });
-      opts.onError?.(normalized, input);
-      throw normalized;
-    }
-  };
-}
-function subscribeGraphActionEvents(listener) {
-  graphActionListeners.add(listener);
-  return () => graphActionListeners.delete(listener);
-}
-async function replayRegisteredGraphAction(record, storeApi = graphStore) {
-  const replayer = graphActionReplayers.get(record.key);
-  if (!replayer) throw new Error(`No graph action registered for key "${record.key}"`);
-  return replayer(record, storeApi);
-}
-function cloneGraphData(source = graphStore.getState()) {
-  return {
-    entities: structuredClone(source.entities),
-    patches: structuredClone(source.patches),
-    entityStates: structuredClone(source.entityStates),
-    syncMetadata: structuredClone(source.syncMetadata),
-    lists: structuredClone(source.lists)
-  };
-}
-function emitGraphActionEvent(event) {
-  for (const listener of graphActionListeners) listener(event);
-}
-
-// src/graph-effects.ts
-function createGraphEffect(opts) {
-  const getKey = opts.getKey ?? defaultGetKey;
-  const isEqual = opts.isEqual ?? defaultIsEqual;
-  let initialized = false;
-  let previous = /* @__PURE__ */ new Map();
-  const evaluate = () => {
-    const nextValues = normalizeQueryResult(opts.query());
-    const next = /* @__PURE__ */ new Map();
-    nextValues.forEach((value, index) => {
-      next.set(getKey(value, index), value);
-    });
-    if (!initialized) {
-      initialized = true;
-      previous = next;
-      if (opts.skipInitial) return;
-    }
-    for (const [key, value] of next.entries()) {
-      const previousValue = previous.get(key);
-      if (previousValue === void 0) {
-        opts.onEnter?.({ key, value });
-        continue;
-      }
-      if (!isEqual(previousValue, value)) {
-        opts.onUpdate?.({ key, value, previousValue });
-      }
-    }
-    for (const [key, previousValue] of previous.entries()) {
-      if (!next.has(key)) opts.onExit?.({ key, previousValue });
-    }
-    previous = next;
-  };
-  evaluate();
-  const unsubscribe = useGraphStore.subscribe(() => {
-    evaluate();
-  });
-  return {
-    dispose: () => {
-      unsubscribe();
-    }
-  };
-}
-function normalizeQueryResult(value) {
-  if (value == null) return [];
-  return Array.isArray(value) ? value : [value];
-}
-function defaultGetKey(value, index) {
-  if (value && typeof value === "object") {
-    const record = value;
-    if (typeof record.id === "string") return record.id;
-    if (typeof record.$key === "string") return record.$key;
-  }
-  return String(index);
-}
-function defaultIsEqual(previousValue, nextValue) {
-  return JSON.stringify(previousValue) === JSON.stringify(nextValue);
-}
-
-// src/schema.ts
-var schemaRegistry = /* @__PURE__ */ new Map();
-function registerEntityJsonSchema(config) {
-  schemaRegistry.set(registryKey(config.entityType, config.field, config.schemaId), config);
-}
-function registerRuntimeSchema(config) {
-  registerEntityJsonSchema(config);
-}
-function getEntityJsonSchema(opts) {
-  const exact = schemaRegistry.get(registryKey(opts.entityType, opts.field, opts.schemaId));
-  if (exact) return exact;
-  if (opts.field) {
-    const byField = schemaRegistry.get(registryKey(opts.entityType, opts.field));
-    if (byField) return byField;
-  }
-  if (opts.schemaId) {
-    const byId = schemaRegistry.get(registryKey(opts.entityType, void 0, opts.schemaId));
-    if (byId) return byId;
-  }
-  for (const schema of schemaRegistry.values()) {
-    if (schema.entityType !== opts.entityType) continue;
-    if (opts.field && schema.field !== opts.field) continue;
-    return schema;
-  }
-  return null;
-}
-function exportGraphSnapshotWithSchemas(opts) {
-  return JSON.stringify(
-    {
-      scope: opts.scope,
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      data: opts.data,
-      schemas: opts.schemas.filter(Boolean)
-    },
-    null,
-    opts.pretty === false ? 0 : 2
-  );
-}
-function escapeHtml(input) {
-  return input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
-}
-function renderMarkdownToHtml(value) {
-  const escaped = escapeHtml(value);
-  const blocks = escaped.split(/\n{2,}/).map((b) => b.trim()).filter(Boolean);
-  return blocks.map((block) => renderMarkdownBlock(block)).join("");
-}
-function inferSchemaFieldType(schema) {
-  const forced = schema["x-field-type"];
-  if (forced === "markdown") return "markdown";
-  if (schema.format === "markdown") return "markdown";
-  if (schema.enum) return "enum";
-  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
-  switch (type) {
-    case "boolean":
-      return "boolean";
-    case "integer":
-    case "number":
-      return "number";
-    case "string":
-      if (schema.format === "email") return "email";
-      if (schema.format === "uri" || schema.format === "url") return "url";
-      if (schema.format === "date" || schema.format === "date-time") return "date";
-      return "text";
-    case "array":
-    case "object":
-      return "json";
-    default:
-      return "text";
-  }
-}
-function registryKey(entityType, field, schemaId) {
-  return `${entityType}::${field ?? "*"}::${schemaId ?? "*"}`;
-}
-function humanizeFieldName(value) {
-  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
-}
-function renderMarkdownBlock(block) {
-  if (block.startsWith("# ")) return `<h1>${renderInlineMarkdown(block.slice(2))}</h1>`;
-  if (block.startsWith("## ")) return `<h2>${renderInlineMarkdown(block.slice(3))}</h2>`;
-  return `<p>${renderInlineMarkdown(block).replaceAll("\n", "<br/>")}</p>`;
-}
-function renderInlineMarkdown(block) {
-  return block.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
-}
-
-// src/ai-interop.ts
-function exportGraphSnapshot(opts) {
-  const payload = {
-    scope: opts.scope,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    data: opts.data
-  };
-  return JSON.stringify(payload, null, opts.pretty === false ? 0 : 2);
-}
-function createGraphTool(handler) {
-  return (input) => handler(input, {
-    store: useGraphStore.getState(),
-    queryOnce,
-    exportGraphSnapshot
-  });
-}
-function createSchemaGraphTool(handler) {
-  return (input) => handler(input, {
-    store: useGraphStore.getState(),
-    queryOnce,
-    exportGraphSnapshot,
-    getEntityJsonSchema,
-    exportGraphSnapshotWithSchemas
-  });
-}
-var DEFAULT_STORAGE_KEY = "prometheus:graph";
-var graphSyncStatusStore = vanilla.createStore()((set) => ({
-  status: {
-    phase: "idle",
-    isOnline: true,
-    isSynced: true,
-    pendingActions: 0,
-    lastHydratedAt: null,
-    lastPersistedAt: null,
-    storageKey: null,
-    error: null
-  },
-  setStatus: (status) => set((state) => ({
-    status: {
-      ...state.status,
-      ...status
-    }
-  }))
-}));
-var pendingActions = /* @__PURE__ */ new Map();
-function getGraphSyncStatus() {
-  return graphSyncStatusStore.getState().status;
-}
-async function persistGraphToStorage(opts) {
-  const storeApi = opts.store ?? graphStore;
-  const payload = {
-    version: 1,
-    snapshot: cloneGraphSnapshot(storeApi),
-    pendingActions: opts.pendingActions ?? Array.from(pendingActions.values())
-  };
-  const json = JSON.stringify(payload);
-  await opts.storage.set(opts.key, json);
-  const persistedAt = (/* @__PURE__ */ new Date()).toISOString();
-  graphSyncStatusStore.getState().setStatus({
-    lastPersistedAt: persistedAt,
-    storageKey: opts.key,
-    pendingActions: payload.pendingActions.length
-  });
-  return {
-    ok: true,
-    key: opts.key,
-    bytes: json.length,
-    persistedAt
-  };
-}
-async function hydrateGraphFromStorage(opts) {
-  const storeApi = opts.store ?? graphStore;
-  const raw = await opts.storage.get(opts.key);
-  if (!raw) {
-    return {
-      ok: false,
-      key: opts.key,
-      hydratedAt: null,
-      entityCounts: {},
-      error: "No persisted graph snapshot found"
-    };
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    storeApi.setState(parsed.snapshot);
-    pendingActions.clear();
-    for (const action of parsed.pendingActions ?? []) pendingActions.set(action.id, action);
-    const hydratedAt = (/* @__PURE__ */ new Date()).toISOString();
-    graphSyncStatusStore.getState().setStatus({
-      lastHydratedAt: hydratedAt,
-      storageKey: opts.key,
-      pendingActions: pendingActions.size,
-      error: null
-    });
-    return {
-      ok: true,
-      key: opts.key,
-      hydratedAt,
-      entityCounts: Object.fromEntries(
-        Object.entries(parsed.snapshot.entities).map(([type, entities]) => [type, Object.keys(entities).length])
-      ),
-      pendingActions: Array.from(pendingActions.values())
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    graphSyncStatusStore.getState().setStatus({
-      phase: "error",
-      error: message,
-      storageKey: opts.key
-    });
-    return {
-      ok: false,
-      key: opts.key,
-      hydratedAt: null,
-      entityCounts: {},
-      error: message
-    };
-  }
-}
-function startLocalFirstGraph(opts) {
-  const storeApi = opts.store ?? graphStore;
-  const key = opts.key ?? DEFAULT_STORAGE_KEY;
-  const persistDebounceMs = opts.persistDebounceMs ?? 50;
-  const statusStore = graphSyncStatusStore.getState();
-  statusStore.setStatus({
-    phase: "hydrating",
-    storageKey: key,
-    isOnline: opts.onlineSource?.getIsOnline() ?? getDefaultOnlineSource().getIsOnline(),
-    isSynced: pendingActions.size === 0,
-    error: null
-  });
-  let persistTimer = null;
-  const schedulePersist = () => {
-    if (persistTimer) clearTimeout(persistTimer);
-    persistTimer = setTimeout(() => {
-      void persistGraphToStorage({ storage: opts.storage, key, store: storeApi });
-    }, persistDebounceMs);
-  };
-  const graphUnsub = storeApi.subscribe(() => {
-    schedulePersist();
-  });
-  const actionUnsub = subscribeGraphActionEvents((event) => {
-    if (event.type === "enqueued") pendingActions.set(event.record.id, event.record);
-    if (event.type === "settled") pendingActions.delete(event.record.id);
-    graphSyncStatusStore.getState().setStatus({
-      pendingActions: pendingActions.size,
-      isSynced: pendingActions.size === 0
-    });
-    schedulePersist();
-  });
-  const onlineSource = opts.onlineSource ?? getDefaultOnlineSource();
-  const onlineUnsub = onlineSource.subscribe((online) => {
-    graphSyncStatusStore.getState().setStatus({
-      isOnline: online,
-      phase: online ? "ready" : "offline"
-    });
-  });
-  const ready = (async () => {
-    const hydrated = await hydrateGraphFromStorage({ storage: opts.storage, key, store: storeApi });
-    if (opts.replayPendingActions && hydrated.ok && pendingActions.size > 0) {
-      graphSyncStatusStore.getState().setStatus({
-        phase: "syncing",
-        isSynced: false
-      });
-      const policy = resolveRetryPolicy(opts.retryPolicy);
-      for (const action of Array.from(pendingActions.values())) {
-        await replayActionWithRetry(action, policy, storeApi);
-        pendingActions.delete(action.id);
-      }
-      await persistGraphToStorage({ storage: opts.storage, key, store: storeApi });
-    }
-    const online = onlineSource.getIsOnline();
-    graphSyncStatusStore.getState().setStatus({
-      phase: online ? "ready" : "offline",
-      isOnline: online,
-      isSynced: pendingActions.size === 0,
-      pendingActions: pendingActions.size
-    });
-  })();
-  return {
-    ready,
-    dispose() {
-      graphUnsub();
-      actionUnsub();
-      onlineUnsub();
-      if (persistTimer) clearTimeout(persistTimer);
-    },
-    async persistNow() {
-      await persistGraphToStorage({ storage: opts.storage, key, store: storeApi });
-    },
-    hydrate() {
-      return hydrateGraphFromStorage({ storage: opts.storage, key, store: storeApi });
-    },
-    getStatus() {
-      return graphSyncStatusStore.getState().status;
-    }
-  };
-}
-function cloneGraphSnapshot(storeApi) {
-  const state = storeApi.getState();
-  return {
-    entities: structuredClone(state.entities),
-    patches: structuredClone(state.patches),
-    entityStates: structuredClone(state.entityStates),
-    syncMetadata: structuredClone(state.syncMetadata),
-    lists: structuredClone(state.lists)
-  };
-}
-function resolveRetryPolicy(policy) {
-  return {
-    maxAttempts: policy?.maxAttempts ?? 5,
-    initialDelayMs: policy?.initialDelayMs ?? 500,
-    maxDelayMs: policy?.maxDelayMs ?? 3e4,
-    backoffFactor: policy?.backoffFactor ?? 2,
-    jitter: policy?.jitter ?? "equal",
-    poisonHandler: policy?.poisonHandler
-  };
-}
-function computeDelay(policy, attempt) {
-  const base = Math.min(
-    policy.initialDelayMs * Math.pow(policy.backoffFactor, Math.max(0, attempt - 1)),
-    policy.maxDelayMs
-  );
-  switch (policy.jitter) {
-    case "none":
-      return base;
-    case "full":
-      return Math.random() * base;
-    case "equal":
-    default:
-      return base / 2 + Math.random() * (base / 2);
-  }
-}
-function sleep(ms) {
-  if (ms <= 0) return Promise.resolve();
-  return new Promise((r) => setTimeout(r, ms));
-}
-async function replayActionWithRetry(action, policy, storeApi = graphStore) {
-  let lastError = null;
-  for (let attempt = 1; attempt <= policy.maxAttempts; attempt++) {
-    try {
-      await replayRegisteredGraphAction(action, storeApi);
-      return { ok: true };
-    } catch (error) {
-      lastError = error;
-      if (attempt >= policy.maxAttempts) break;
-      await sleep(computeDelay(policy, attempt));
-    }
-  }
-  try {
-    await policy.poisonHandler?.(action, lastError);
-  } catch {
-  }
-  return { ok: false, poisoned: true, error: lastError };
-}
-function getDefaultOnlineSource() {
-  if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
-    return {
-      getIsOnline: () => window.navigator.onLine,
-      subscribe: (listener) => {
-        const onlineHandler = () => listener(true);
-        const offlineHandler = () => listener(false);
-        window.addEventListener("online", onlineHandler);
-        window.addEventListener("offline", offlineHandler);
-        return () => {
-          window.removeEventListener("online", onlineHandler);
-          window.removeEventListener("offline", offlineHandler);
-        };
-      }
-    };
-  }
-  return {
-    getIsOnline: () => true,
-    subscribe: () => () => {
-    }
-  };
-}
-
-// src/engine.ts
-function serializeKey(key) {
-  return JSON.stringify(key, (_, v) => v && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort()) : v);
-}
-function sleep2(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-var inflightByStore = /* @__PURE__ */ new WeakMap();
-function inflightFor(store) {
-  let inflight = inflightByStore.get(store);
-  if (!inflight) {
-    inflight = /* @__PURE__ */ new Map();
-    inflightByStore.set(store, inflight);
-  }
-  return inflight;
-}
-function dedupe(key, fn, store = graphStore) {
-  const inflight = inflightFor(store);
-  if (inflight.has(key)) return inflight.get(key);
-  const p = fn().finally(() => inflight.delete(key));
-  inflight.set(key, p);
-  return p;
-}
-var globalSubscriberStatsListeners = /* @__PURE__ */ new Set();
-var subscriberStatsListenersByStore = /* @__PURE__ */ new WeakMap();
-function subscriberStatsListenersFor(store) {
-  let listeners2 = subscriberStatsListenersByStore.get(store);
-  if (!listeners2) {
-    listeners2 = /* @__PURE__ */ new Set();
-    subscriberStatsListenersByStore.set(store, listeners2);
-  }
-  return listeners2;
-}
-function emitSubscriberStatsChange(store) {
-  for (const cb of /* @__PURE__ */ new Set([
-    ...globalSubscriberStatsListeners,
-    ...subscriberStatsListenersFor(store)
-  ])) cb();
-}
-var subscribersByStore = /* @__PURE__ */ new WeakMap();
-function subscribersFor(store) {
-  let subscribers = subscribersByStore.get(store);
-  if (!subscribers) {
-    subscribers = /* @__PURE__ */ new Map();
-    subscribersByStore.set(store, subscribers);
-  }
-  return subscribers;
-}
-function registerSubscriber(key, store = graphStore) {
-  const subscribers = subscribersFor(store);
-  const token = Symbol(key);
-  if (!subscribers.has(key)) subscribers.set(key, /* @__PURE__ */ new Set());
-  subscribers.get(key).add(token);
-  emitSubscriberStatsChange(store);
-  return token;
-}
-function unregisterSubscriber(key, token, store = graphStore) {
-  const subscribers = subscribersFor(store);
-  const set = subscribers.get(key);
-  if (!set) return;
-  set.delete(token);
-  if (set.size === 0) subscribers.delete(key);
-  emitSubscriberStatsChange(store);
-}
-function hasSubscribers(key, store = graphStore) {
-  return (subscribersFor(store).get(key)?.size ?? 0) > 0;
-}
-var DEFAULT_OPTIONS = {
-  defaultStaleTime: 3e4,
-  defaultGcTime: 3e5,
-  gcInterval: 6e4,
-  maxRetries: 3,
-  retryBaseDelay: 1e3,
-  revalidateOnFocus: true,
-  revalidateOnReconnect: true
-};
-var engineOptions = { ...DEFAULT_OPTIONS };
-function subscribeSubscriberStats(onChange, store) {
-  const listeners2 = store ? subscriberStatsListenersFor(store) : globalSubscriberStatsListeners;
-  listeners2.add(onChange);
-  return () => listeners2.delete(onChange);
-}
-function getActiveSubscriberCount(store = graphStore) {
-  let n = 0;
-  for (const set of subscribersFor(store).values()) n += set.size;
-  return n;
-}
-function subscribeDevtoolsEvent(cb) {
-  return subscribeLegacyDevtoolsEvent(cb);
-}
-var gcIntervalsByStore = /* @__PURE__ */ new Map();
-function runGarbageCollection(storeApi = graphStore) {
-  const store = storeApi.getState();
-  const { defaultGcTime: gcTime } = getEngineOptions();
-  const now = Date.now();
-  const toRemove = [];
-  for (const type of Object.keys(store.entities)) {
-    const bucket = store.entities[type];
-    if (!bucket) continue;
-    for (const id of Object.keys(bucket)) {
-      const key = `${type}:${id}`;
-      if (hasSubscribers(key, storeApi)) continue;
-      const patch = store.patches[type]?.[id];
-      if (patch !== void 0 && Object.keys(patch).length > 0) continue;
-      const entityState = store.entityStates[key];
-      if (entityState?.isFetching) continue;
-      const lastFetched = entityState?.lastFetched;
-      if (lastFetched == null) continue;
-      if (now - lastFetched <= gcTime) continue;
-      toRemove.push({ type, id });
-    }
-  }
-  for (const { type, id } of toRemove) {
-    store.removeEntity(type, id);
-    store.removeIdFromAllLists(type, id);
-  }
-}
-function stopGarbageCollector(storeApi = graphStore) {
-  const intervalId = gcIntervalsByStore.get(storeApi);
-  if (intervalId != null && typeof clearInterval !== "undefined") {
-    clearInterval(intervalId);
-    gcIntervalsByStore.delete(storeApi);
-  }
-}
-function startGarbageCollector(storeApi = graphStore) {
-  stopGarbageCollector(storeApi);
-  if (typeof window === "undefined" || typeof setInterval === "undefined") return () => {
-  };
-  const intervalId = setInterval(
-    () => runGarbageCollection(storeApi),
-    getEngineOptions().gcInterval
-  );
-  gcIntervalsByStore.set(storeApi, intervalId);
-  return () => stopGarbageCollector(storeApi);
-}
-function restartGarbageCollector(storeApi = graphStore) {
-  startGarbageCollector(storeApi);
-}
-function configureEngine(opts) {
-  engineOptions = { ...DEFAULT_OPTIONS, ...opts };
-  const activeStores = [...gcIntervalsByStore.keys()];
-  if (activeStores.length === 0) restartGarbageCollector();
-  else for (const storeApi of activeStores) restartGarbageCollector(storeApi);
-}
-function getEngineOptions() {
-  return engineOptions;
-}
-async function fetchEntity(opts, engineOpts, storeApi = graphStore) {
-  const { type, id, fetch, normalize, sideEffects, idField = "id" } = opts;
-  if (!id) return;
-  storeApi.getState().setEntityFetching(type, id, true);
-  const attempt = async (retries) => {
-    try {
-      const raw = await fetch(id);
-      const normalized = normalize(raw);
-      const resolvedId = normalized[idField] ?? id;
-      storeApi.getState().upsertEntity(type, resolvedId, normalized);
-      storeApi.getState().setEntityFetched(type, resolvedId);
-      if (sideEffects) sideEffects(raw, storeApi);
-      opts.onSuccess?.(normalized);
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      if (retries < engineOpts.maxRetries) {
-        await sleep2(engineOpts.retryBaseDelay * Math.pow(2, retries));
-        return attempt(retries + 1);
-      }
-      storeApi.getState().setEntityError(type, id, error.message);
-      opts.onError?.(error);
-    }
-  };
-  await dedupe(`${type}:${id}`, () => attempt(0), storeApi);
-}
-async function fetchList(opts, params, engineOpts, isLoadMore = false, storeApi = graphStore) {
-  const { type, queryKey, fetch, normalize, sideEffects, mode = "replace" } = opts;
-  const key = serializeKey(queryKey);
-  const store = storeApi.getState();
-  if (!fetch || !normalize) return;
-  if (isLoadMore) store.setListFetchingMore(key, true);
-  else store.setListFetching(key, true);
-  const attempt = async (retries) => {
-    try {
-      const response = await fetch(params);
-      const normalized = response.items.map(normalize);
-      const meta = { total: response.total ?? null, nextCursor: response.nextCursor ?? null, prevCursor: response.prevCursor ?? null, hasNextPage: response.hasNextPage ?? !!response.nextCursor, hasPrevPage: response.hasPrevPage ?? !!response.prevCursor, currentPage: response.page ?? null, pageSize: response.pageSize ?? null };
-      storeApi.getState().ingestFetchedList(
-        type,
-        normalized.map(({ id, data }) => ({ id, data })),
-        { lists: [{ key, mode: mode === "append" && isLoadMore ? "append" : "replace", meta }] }
-      );
-      if (sideEffects) sideEffects(response.items, storeApi);
-      opts.onSuccess?.(response);
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      if (retries < engineOpts.maxRetries) {
-        await sleep2(engineOpts.retryBaseDelay * Math.pow(2, retries));
-        return attempt(retries + 1);
-      }
-      storeApi.getState().setListError(key, error.message);
-      opts.onError?.(error);
-    }
-  };
-  await dedupe(isLoadMore ? `${key}:more` : key, () => attempt(0), storeApi);
-}
-var globalListenerAttachments = /* @__PURE__ */ new WeakMap();
-function releaseGlobalListenerAttachment(storeApi, attachment) {
-  let released = false;
-  return () => {
-    if (released) return;
-    released = true;
-    const current = globalListenerAttachments.get(storeApi);
-    if (current !== attachment) return;
-    current.references -= 1;
-    if (current.references > 0) return;
-    current.dispose();
-    globalListenerAttachments.delete(storeApi);
-  };
-}
-function attachGlobalListeners(storeApi = graphStore) {
-  if (typeof window === "undefined") return () => {
-  };
-  const existing = globalListenerAttachments.get(storeApi);
-  if (existing) {
-    existing.references += 1;
-    return releaseGlobalListenerAttachment(storeApi, existing);
-  }
-  const stopGc = startGarbageCollector(storeApi);
-  const revalidateAll = () => {
-    const state = storeApi.getState();
-    for (const key of subscribersFor(storeApi).keys()) {
-      if (!hasSubscribers(key, storeApi)) continue;
-      const colonIdx = key.indexOf(":");
-      if (colonIdx === -1) continue;
-      const type = key.slice(0, colonIdx);
-      const id = key.slice(colonIdx + 1);
-      state.setEntityStale(type, id, true);
-    }
-  };
-  const revalidateWhenVisible = () => {
-    if (document.visibilityState === "visible") revalidateAll();
-  };
-  const revalidateOnFocus = engineOptions.revalidateOnFocus;
-  const revalidateOnReconnect = engineOptions.revalidateOnReconnect;
-  if (revalidateOnFocus) {
-    window.addEventListener("visibilitychange", revalidateWhenVisible);
-    window.addEventListener("focus", revalidateAll);
-  }
-  if (revalidateOnReconnect) window.addEventListener("online", revalidateAll);
-  const attachment = {
-    references: 1,
-    dispose: () => {
-      if (revalidateOnFocus) {
-        window.removeEventListener("visibilitychange", revalidateWhenVisible);
-        window.removeEventListener("focus", revalidateAll);
-      }
-      if (revalidateOnReconnect) {
-        window.removeEventListener("online", revalidateAll);
-      }
-      stopGc();
-    }
-  };
-  globalListenerAttachments.set(storeApi, attachment);
-  return releaseGlobalListenerAttachment(storeApi, attachment);
-}
-
-// src/devtools-event-bus.ts
-var _busInjectMap = /* @__PURE__ */ new WeakMap();
-var registries = /* @__PURE__ */ new Map();
-function __resetStoreRegistry() {
-  registries.clear();
-}
-function createDevtoolsEventBus(opts) {
-  const bufferSize = opts?.bufferSize ?? 500;
-  const threshold = opts?.coalesceBurstThreshold ?? 10;
-  const buffer = bufferSize > 0 ? new Array(bufferSize) : [];
-  let head = 0;
-  let count = 0;
-  function writeToBuffer(event) {
-    if (bufferSize === 0) return;
-    buffer[head] = event;
-    head = (head + 1) % bufferSize;
-    if (count < bufferSize) count++;
-  }
-  function getBuffer() {
-    if (count === 0) return [];
-    if (count < bufferSize) return buffer.slice(0, count);
-    return [...buffer.slice(head), ...buffer.slice(0, head)];
-  }
-  const subscribers = /* @__PURE__ */ new Set();
-  function dispatchToSubscribers(event) {
-    const snap = [...subscribers];
-    for (const cb of snap) {
-      try {
-        cb(event);
-      } catch (err) {
-        console.warn("[devtools-event-bus] subscriber threw:", err);
-      }
-    }
-  }
-  function dispatchOne(event) {
-    writeToBuffer(event);
-    dispatchToSubscribers(event);
-  }
-  let pendingBurst = [];
-  let dispatchedCount = 0;
-  let flushScheduled = false;
-  let destroyed = false;
-  function flush() {
-    if (pendingBurst.length === 0) {
-      flushScheduled = false;
-      return;
-    }
-    const burst = pendingBurst;
-    const alreadySent = dispatchedCount;
-    pendingBurst = [];
-    dispatchedCount = 0;
-    flushScheduled = false;
-    const remaining = burst.slice(alreadySent);
-    if (remaining.length === 0) return;
-    if (threshold === 0 || burst.length <= threshold) {
-      for (const ev of remaining) dispatchOne(ev);
-    } else {
-      const individualSlots = Math.max(0, threshold - alreadySent);
-      const toDispatchIndividually = remaining.slice(0, individualSlots);
-      const toCoalesce = remaining.slice(individualSlots);
-      for (const ev of toDispatchIndividually) dispatchOne(ev);
-      if (toCoalesce.length > 0) {
-        dispatchOne({
-          kind: "list",
-          key: "burst-coalesce",
-          idCount: toCoalesce.length,
-          at: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
-    }
-  }
-  function handleEngineEvent(event) {
-    if (destroyed) return;
-    if (threshold === 0) {
-      dispatchOne(event);
-      return;
-    }
-    pendingBurst.push(event);
-    if (pendingBurst.length <= threshold) {
-      dispatchOne(event);
-      dispatchedCount++;
-    } else {
-      if (!flushScheduled) {
-        flushScheduled = true;
-        Promise.resolve().then(() => flush());
-      }
-    }
-  }
-  const unsubscribeEngine = subscribeDevtoolsEvent(handleEngineEvent);
-  const bus = {
-    subscribe(cb) {
-      if (destroyed) return () => {
-      };
-      const snapshot = getBuffer();
-      for (const ev of snapshot) {
-        try {
-          cb(ev);
-        } catch (err) {
-          console.warn("[devtools-event-bus] subscriber threw during replay:", err);
-        }
-      }
-      subscribers.add(cb);
-      return () => {
-        subscribers.delete(cb);
-      };
-    },
-    getBuffer,
-    flush,
-    inject(event) {
-      handleEngineEvent(event);
-    },
-    destroy() {
-      if (destroyed) return;
-      destroyed = true;
-      unsubscribeEngine();
-      subscribers.clear();
-      pendingBurst = [];
-      dispatchedCount = 0;
-      flushScheduled = false;
-      const registry = registries.get(bus);
-      if (registry) {
-        for (const entry of registry.values()) {
-          if (!entry.active) continue;
-          entry.active = false;
-          try {
-            entry.unsubscribeSrc();
-          } catch {
-          }
-        }
-      }
-      registries.delete(bus);
-      _busInjectMap.delete(bus);
-    }
-  };
-  _busInjectMap.set(bus, handleEngineEvent);
-  return bus;
-}
-function registerStore(bus, source, name) {
-  let registry = registries.get(bus);
-  if (!registry) {
-    registry = /* @__PURE__ */ new Map();
-    registries.set(bus, registry);
-  }
-  if (registry.get(name)?.active === true) {
-    throw new Error(
-      `[devtools-store-registry] Store name "${name}" is already registered and active`
-    );
-  }
-  const inject = _busInjectMap.get(bus);
-  if (!inject) {
-    throw new Error(
-      `[devtools-store-registry] Bus is destroyed or was not created by createDevtoolsEventBus`
-    );
-  }
-  const unsubscribeSrc = source(inject);
-  const entry = { name, active: true, bus, unsubscribeSrc };
-  registry.set(name, entry);
-  return () => {
-    if (!entry.active) return;
-    entry.active = false;
-    unsubscribeSrc();
-  };
-}
-function getRegisteredStores(bus) {
-  const entries = bus ? [...registries.get(bus)?.values() ?? []] : [...registries.values()].flatMap((registry) => [...registry.values()]);
-  return entries.map((entry) => ({ name: entry.name, active: entry.active }));
-}
-
-// src/devtools-compatibility-bridge.ts
-var BRIDGE_KEY = /* @__PURE__ */ Symbol.for("prometheus.entity-graph.devtools.compatibility.v1");
-var bridgeHost = globalThis;
-var existingBridge = bridgeHost[BRIDGE_KEY];
-var bridgeState = existingBridge?.version === 1 ? existingBridge : { version: 1, entries: /* @__PURE__ */ new WeakMap(), factory: null };
-bridgeHost[BRIDGE_KEY] = bridgeState;
-function getOrCreateEntry(store) {
-  let entry = bridgeState.entries.get(store);
-  if (!entry) {
-    entry = {
-      delegate: null,
-      listeners: /* @__PURE__ */ new Set(),
-      unsubscribeDelegate: null,
-      compatibilityDetach: null
-    };
-    bridgeState.entries.set(store, entry);
-  }
-  return entry;
-}
-function ensureDelegate(store, entry) {
-  const factory = bridgeState.factory;
-  if (entry.delegate || entry.compatibilityDetach || !factory) return;
-  entry.compatibilityDetach = factory(store);
-}
-function getGraphDevtoolsCompatibilityDelegate(store) {
-  const entry = getOrCreateEntry(store);
-  ensureDelegate(store, entry);
-  return entry.delegate;
-}
-function subscribeGraphDevtoolsCompatibility(store, listener) {
-  const entry = getOrCreateEntry(store);
-  entry.listeners.add(listener);
-  ensureDelegate(store, entry);
-  return () => {
-    entry.listeners.delete(listener);
-    if (entry.listeners.size === 0 && entry.delegate === null) bridgeState.entries.delete(store);
-  };
-}
-
-// src/devtools-time-travel.ts
-function configureTimeTravel(opts, storeApi = graphStore) {
-  if (opts.capacity && opts.capacity > 0) {
-    getGraphDevtoolsCompatibilityDelegate(storeApi)?.configure(opts.capacity);
-  }
-}
-function recordGraphSnapshot(label, storeApi = graphStore) {
-  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.capture(label) ?? -1;
-}
-function restoreGraphSnapshot(index, storeApi = graphStore) {
-  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.restoreByIndex(index) ?? false;
-}
-function restoreGraphSnapshotBySeq(seq, storeApi = graphStore) {
-  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.restoreByCursor(seq) ?? false;
-}
-function stepTimeTravel(delta, storeApi = graphStore) {
-  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.step(delta) ?? false;
-}
-function getTimeTravelState(storeApi = graphStore) {
-  return getGraphDevtoolsCompatibilityDelegate(storeApi)?.getState() ?? {
-    snapshots: [],
-    cursor: null,
-    capacity: 50
-  };
-}
-function subscribeTimeTravel(cb, storeApi = graphStore) {
-  return subscribeGraphDevtoolsCompatibility(storeApi, cb);
-}
-
-// src/view/incremental.ts
-var IncrementalView = class {
-  opts;
-  ids = [];
-  members = /* @__PURE__ */ new Set();
-  constructor(opts) {
-    this.opts = opts;
-  }
-  /** Whether an entity qualifies for this view (filter + search). */
-  qualifies(entity) {
-    if (!entity) return false;
-    if (this.opts.filter && !matchesFilter(entity, this.opts.filter)) return false;
-    if (this.opts.search?.query && !matchesSearch(entity, this.opts.search.query, this.opts.search.fields)) return false;
-    return true;
-  }
-  /** Comparator over ids using the configured sort (stable, id tiebreak). */
-  cmp(aId, bId) {
-    const a = this.opts.getEntity(aId);
-    const b = this.opts.getEntity(bId);
-    if (!a || !b) return 0;
-    if (this.opts.sort && this.opts.sort.length > 0) {
-      const r = compareEntities(a, b, this.opts.sort);
-      if (r !== 0) return r;
-    }
-    return aId < bId ? -1 : aId > bId ? 1 : 0;
-  }
-  /** Binary-search the insertion index for `id` among current `ids`. */
-  insertionIndex(id) {
-    let lo = 0;
-    let hi = this.ids.length;
-    while (lo < hi) {
-      const mid = lo + hi >>> 1;
-      if (this.cmp(this.ids[mid], id) < 0) lo = mid + 1;
-      else hi = mid;
-    }
-    return lo;
-  }
-  /** Build the initial sorted result from a full id set. */
-  seed(ids) {
-    const kept = [];
-    this.members.clear();
-    for (const id of ids) {
-      if (this.qualifies(this.opts.getEntity(id))) {
-        kept.push(id);
-        this.members.add(id);
-      }
-    }
-    if (this.opts.sort && this.opts.sort.length > 0) {
-      kept.sort((a, b) => this.cmp(a, b));
-    }
-    this.ids = kept;
-  }
-  /**
-   * Update the view for ONE entity that changed/was added/removed.
-   * Returns true if the result order changed.
-   *
-   * O(log n) to locate; the array splice is O(n) memory-move but performs no
-   * filter/sort over the whole set — the differentiator from full re-derivation.
-   */
-  applyChange(id) {
-    const entity = this.opts.getEntity(id);
-    const wasMember = this.members.has(id);
-    const isMember = this.qualifies(entity);
-    if (!wasMember && !isMember) return false;
-    if (wasMember && !isMember) {
-      const idx2 = this.ids.indexOf(id);
-      if (idx2 !== -1) this.ids.splice(idx2, 1);
-      this.members.delete(id);
-      return true;
-    }
-    if (!wasMember && isMember) {
-      const idx2 = this.insertionIndex(id);
-      this.ids.splice(idx2, 0, id);
-      this.members.add(id);
-      return true;
-    }
-    const cur = this.ids.indexOf(id);
-    if (cur !== -1) this.ids.splice(cur, 1);
-    const idx = this.insertionIndex(id);
-    this.ids.splice(idx, 0, id);
-    return cur !== idx;
-  }
-  /** Current ordered id list. */
-  result() {
-    return this.ids;
-  }
-  /** Current member count. */
-  size() {
-    return this.ids.length;
-  }
-};
-
-// src/crud/relations.ts
-var schemaRegistry2 = /* @__PURE__ */ new Map();
-function registerSchema(schema) {
-  schemaRegistry2.set(schema.type, schema);
-}
-function getSchema(type) {
-  return schemaRegistry2.get(type) ?? null;
-}
-function cascadeInvalidation(ctx, storeApi = graphStore) {
-  const schema = schemaRegistry2.get(ctx.type);
-  if (!schema) return;
-  const store = storeApi.getState();
-  if (schema.globalListKeys) for (const key of schema.globalListKeys) store.invalidateLists(key);
-  if (!schema.relations) return;
-  for (const [, relation] of Object.entries(schema.relations)) {
-    switch (relation.cardinality) {
-      case "belongsTo": {
-        const prevFk = ctx.previous?.[relation.foreignKey];
-        const nextFk = ctx.next?.[relation.foreignKey];
-        if (prevFk && prevFk !== nextFk && relation.invalidateTargetLists) for (const kp of relation.invalidateTargetLists) store.invalidateLists((k) => k.startsWith(kp) && k.includes(prevFk));
-        if (nextFk && relation.invalidateTargetLists) for (const kp of relation.invalidateTargetLists) store.invalidateLists((k) => k.startsWith(kp) && k.includes(nextFk));
-        if (prevFk) store.invalidateEntity(relation.targetType, prevFk);
-        if (nextFk) store.invalidateEntity(relation.targetType, nextFk);
-        break;
-      }
-      case "hasMany":
-        store.invalidateLists(serializeKey(relation.listKeyPrefix(ctx.id)));
-        break;
-      case "manyToMany": {
-        const prevIds = ctx.previous?.[relation.localArrayField ?? ""];
-        const nextIds = ctx.next?.[relation.localArrayField ?? ""];
-        for (const relatedId of /* @__PURE__ */ new Set([...prevIds ?? [], ...nextIds ?? []])) store.invalidateLists(serializeKey(relation.listKeyPrefix(relatedId)));
-        break;
-      }
-    }
-  }
-  for (const [, otherSchema] of schemaRegistry2) {
-    if (!otherSchema.relations) continue;
-    for (const [, rel] of Object.entries(otherSchema.relations)) {
-      if (rel.targetType !== ctx.type) continue;
-      if (rel.cardinality === "hasMany") store.invalidateLists(serializeKey(rel.listKeyPrefix(ctx.id)));
-    }
-  }
-}
-function readRelations(type, entity, storeApi = graphStore) {
-  const schema = schemaRegistry2.get(type);
-  if (!schema?.relations) return {};
-  const store = storeApi.getState();
-  const result = {};
-  for (const [name, relation] of Object.entries(schema.relations)) {
-    switch (relation.cardinality) {
-      case "belongsTo": {
-        const fkValue = entity[relation.foreignKey];
-        result[name] = fkValue ? store.readEntity(relation.targetType, fkValue) : null;
-        break;
-      }
-      case "hasMany": {
-        const listKey = serializeKey(relation.listKeyPrefix(entity.id));
-        const listState = store.lists[listKey];
-        result[name] = listState ? listState.ids.map((id) => store.readEntity(relation.targetType, id)).filter(Boolean) : [];
-        break;
-      }
-      case "manyToMany": {
-        const ids = entity[relation.localArrayField ?? ""];
-        result[name] = ids ? ids.map((id) => store.readEntity(relation.targetType, id)).filter(Boolean) : [];
-        break;
-      }
-    }
-  }
-  return result;
-}
-
-// src/agent/json-patch.ts
-function unescape(token) {
-  return token.replace(/~1/g, "/").replace(/~0/g, "~");
-}
-function parsePointer(pointer) {
-  if (pointer === "") return [];
-  if (pointer[0] !== "/") throw new Error(`Invalid JSON Pointer: "${pointer}"`);
-  return pointer.slice(1).split("/").map(unescape);
-}
-function isObject2(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function clone(v) {
-  return structuredClone(v);
-}
-function getAt(doc, segs) {
-  let cur = doc;
-  for (const s of segs) {
-    if (Array.isArray(cur)) cur = cur[Number(s)];
-    else if (isObject2(cur)) cur = cur[s];
-    else return void 0;
-  }
-  return cur;
-}
-function setAt(doc, segs, value, mode) {
-  if (segs.length === 0) return value;
-  const root = clone(doc);
-  let cur = root;
-  for (let i = 0; i < segs.length - 1; i++) {
-    const s = segs[i];
-    const next = Array.isArray(cur) ? cur[Number(s)] : isObject2(cur) ? cur[s] : void 0;
-    if (next === void 0 || next === null) {
-      const created = {};
-      if (Array.isArray(cur)) cur[Number(s)] = created;
-      else if (isObject2(cur)) cur[s] = created;
-      cur = created;
-    } else {
-      cur = next;
-    }
-  }
-  const last = segs[segs.length - 1];
-  if (Array.isArray(cur)) {
-    const idx = last === "-" ? cur.length : Number(last);
-    if (mode === "add") cur.splice(idx, 0, value);
-    else cur[idx] = value;
-  } else if (isObject2(cur)) {
-    cur[last] = value;
-  }
-  return root;
-}
-function removeAt(doc, segs) {
-  if (segs.length === 0) return void 0;
-  const root = clone(doc);
-  let cur = root;
-  for (let i = 0; i < segs.length - 1; i++) {
-    const s = segs[i];
-    cur = Array.isArray(cur) ? cur[Number(s)] : isObject2(cur) ? cur[s] : void 0;
-    if (cur === void 0) return root;
-  }
-  const last = segs[segs.length - 1];
-  if (Array.isArray(cur)) cur.splice(Number(last), 1);
-  else if (isObject2(cur)) delete cur[last];
-  return root;
-}
-function applyJsonPatch(doc, ops) {
-  let current = doc;
-  for (const op of ops) {
-    const segs = parsePointer(op.path);
-    switch (op.op) {
-      case "add":
-        current = setAt(current, segs, op.value, "add");
-        break;
-      case "replace":
-        current = setAt(current, segs, op.value, "replace");
-        break;
-      case "remove":
-        current = removeAt(current, segs);
-        break;
-      case "move": {
-        const fromSegs = parsePointer(op.from ?? "");
-        const moved = getAt(current, fromSegs);
-        current = removeAt(current, fromSegs);
-        current = setAt(current, segs, moved, "add");
-        break;
-      }
-      case "copy": {
-        const fromSegs = parsePointer(op.from ?? "");
-        const copied = clone(getAt(current, fromSegs));
-        current = setAt(current, segs, copied, "add");
-        break;
-      }
-      case "test": {
-        const actual = getAt(current, segs);
-        if (JSON.stringify(actual) !== JSON.stringify(op.value)) {
-          throw new Error(`JSON Patch test failed at "${op.path}"`);
-        }
-        break;
-      }
-      default:
-        throw new Error(`Unsupported JSON Patch op: ${op.op}`);
-    }
-  }
-  return current;
-}
-
-// src/agent/ag-ui-bridge.ts
-function isObject3(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function getAtPointer(state, pointer) {
-  if (pointer === "" || pointer === "/") return state;
-  const segs = pointer.slice(1).split("/").map((s) => s.replace(/~1/g, "/").replace(/~0/g, "~"));
-  let cur = state;
-  for (const s of segs) {
-    if (Array.isArray(cur)) cur = cur[Number(s)];
-    else if (isObject3(cur)) cur = cur[s];
-    else return void 0;
-  }
-  return cur;
-}
-function writeEntity(mapping, id, obj) {
-  const store = useGraphStore.getState();
-  if ((mapping.write ?? "upsert") === "replace") {
-    store.replaceEntity(mapping.entityType, id, obj);
-  } else {
-    store.upsertEntity(mapping.entityType, id, obj);
-  }
-}
-function projectState(state, mappings) {
-  for (const mapping of mappings) {
-    const slice = getAtPointer(state, mapping.pointer);
-    if (slice === void 0) continue;
-    if (mapping.kind === "single") {
-      if (!isObject3(slice)) continue;
-      const id = mapping.constantId ?? String(slice[mapping.idField ?? "id"] ?? "");
-      if (!id) continue;
-      writeEntity(mapping, id, slice);
-    } else {
-      const items = [];
-      if (Array.isArray(slice)) {
-        for (const item of slice) {
-          if (isObject3(item)) {
-            const id = String(item[mapping.idField ?? "id"] ?? "");
-            if (id) items.push([id, item]);
-          }
-        }
-      } else if (isObject3(slice)) {
-        for (const [key, item] of Object.entries(slice)) {
-          if (isObject3(item)) {
-            const id = String(item[mapping.idField ?? "id"] ?? key);
-            items.push([id, item]);
-          }
-        }
-      }
-      for (const [id, obj] of items) writeEntity(mapping, id, obj);
-    }
-  }
-}
-function applyAgUiSnapshot(event, options) {
-  if (!isObject3(event.snapshot)) return;
-  projectState(event.snapshot, options.mappings);
-}
-function applyAgUiDelta(event, options, currentState) {
-  const base = currentState ?? reconstructState(options.mappings);
-  const next = applyJsonPatch(base, event.delta);
-  if (isObject3(next)) projectState(next, options.mappings);
-}
-function reconstructState(mappings) {
-  const store = useGraphStore.getState();
-  const state = {};
-  for (const mapping of mappings) {
-    const key = mapping.pointer.replace(/^\//, "").split("/")[0];
-    if (!key) continue;
-    const bucket = store.entities[mapping.entityType] ?? {};
-    if (mapping.kind === "single") {
-      const id = mapping.constantId;
-      if (id && bucket[id]) state[key] = bucket[id];
-    } else {
-      state[key] = Object.values(bucket);
-    }
-  }
-  return state;
-}
-
-// src/adapters/realtime-manager.ts
-var RealtimeManager = class {
-  adapters = /* @__PURE__ */ new Map();
-  pendingChanges = [];
-  pendingListKeys = /* @__PURE__ */ new Set();
-  flushTimer = null;
-  opts;
-  store;
-  constructor(opts = {}) {
-    this.store = opts.store ?? graphStore;
-    this.opts = {
-      flushInterval: opts.flushInterval ?? 16,
-      onStatusChange: opts.onStatusChange ?? (() => {
-      }),
-      onChangeReceived: opts.onChangeReceived ?? (() => {
-      })
-    };
-  }
-  register(adapter, channels, normalize) {
-    const existing = this.adapters.get(adapter.name);
-    const registered = existing ?? { adapter, unsubscribes: [] };
-    if (!existing) this.adapters.set(adapter.name, registered);
-    if (adapter.onStatusChange) {
-      registered.unsubscribes.push(adapter.onStatusChange((s) => this.opts.onStatusChange(adapter.name, s)));
-    }
-    for (const channel of channels) {
-      const unsub = adapter.subscribe(
-        { label: `${adapter.name}/${channel.type}`, replayOnConnect: true },
-        (cs) => this.handleChangeset(adapter.name, cs, normalize)
-      );
-      registered.unsubscribes.push(unsub);
-    }
-    return () => this.unregister(adapter.name);
-  }
-  unregister(name) {
-    const r = this.adapters.get(name);
-    if (!r) return;
-    for (const u of r.unsubscribes) u();
-    this.adapters.delete(name);
-  }
-  unregisterAll() {
-    for (const n of this.adapters.keys()) this.unregister(n);
-  }
-  handleChangeset(name, cs, normalize) {
-    for (const rawChange of cs.changes) {
-      const change = normalize ? normalize(rawChange) : rawChange;
-      if (!change) continue;
-      this.opts.onChangeReceived(name, change);
-      this.pendingChanges.push(change);
-    }
-    if (cs.affectedListKeys) for (const k of cs.affectedListKeys) this.pendingListKeys.add(k);
-    this.scheduleFlush();
-  }
-  scheduleFlush() {
-    if (this.opts.flushInterval === 0) {
-      this.flush();
-      return;
-    }
-    if (this.flushTimer !== null) return;
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = null;
-      this.flush();
-    }, this.opts.flushInterval);
-  }
-  flush() {
-    if (this.pendingChanges.length === 0 && this.pendingListKeys.size === 0) return;
-    const changes = this.pendingChanges.splice(0);
-    const listKeys = new Set(this.pendingListKeys);
-    this.pendingListKeys.clear();
-    const store = this.store.getState();
-    for (const change of coalesceChanges(changes)) {
-      switch (change.op) {
-        case "insert":
-        case "upsert":
-          if (change.data) {
-            store.upsertEntity(change.type, change.id, change.data);
-            store.setEntityFetched(change.type, change.id);
-          }
-          break;
-        case "update":
-          if (change.patch) {
-            if (store.entities[change.type]?.[change.id]) store.upsertEntity(change.type, change.id, change.patch);
-            else store.invalidateEntity(change.type, change.id);
-          } else if (change.data) {
-            store.upsertEntity(change.type, change.id, change.data);
-            store.setEntityFetched(change.type, change.id);
-          }
-          break;
-        case "delete":
-          store.removeEntity(change.type, change.id);
-          store.removeIdFromAllLists(change.type, change.id);
-          break;
-      }
-    }
-    for (const key of listKeys) store.invalidateLists(key);
-  }
-  forceFlush() {
-    if (this.flushTimer !== null) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-    this.flush();
-  }
-};
-function coalesceChanges(changes) {
-  const byKey = /* @__PURE__ */ new Map();
-  for (const c of changes) {
-    const key = `${c.type}:${c.id}`;
-    const existing = byKey.get(key);
-    if (!existing) {
-      byKey.set(key, { ...c });
-      continue;
-    }
-    if (c.op === "delete") {
-      byKey.set(key, c);
-      continue;
-    }
-    if (existing.op === "delete") continue;
-    if (existing.op === "update" && c.op === "update") {
-      byKey.set(key, {
-        ...existing,
-        patch: { ...existing.patch ?? {}, ...c.patch ?? {} }
-      });
-      continue;
-    }
-    byKey.set(key, { ...existing, op: "upsert", data: c.data ?? existing.data, patch: c.patch ? { ...existing.patch ?? {}, ...c.patch } : existing.patch });
-  }
-  return Array.from(byKey.values());
-}
-var _manager = null;
-function getRealtimeManager(opts) {
-  if (!_manager) _manager = new RealtimeManager(opts);
-  return _manager;
-}
-function resetRealtimeManager() {
-  _manager?.unregisterAll();
-  _manager = null;
-}
-
-// src/adapters/realtime-adapters.ts
-function createWebSocketAdapter(opts) {
-  const {
-    url,
-    parseMessage,
-    protocols,
-    reconnectBaseDelay = 1e3,
-    maxReconnectAttempts = Infinity,
-    pingInterval = 3e4,
-    pingMessage = '{"type":"ping"}'
-  } = opts;
-  const statusCbs = /* @__PURE__ */ new Set();
-  const handlers = /* @__PURE__ */ new Set();
-  let ws = null;
-  let attempts = 0;
-  let reconnTimer = null;
-  let pingTimer = null;
-  let stopped = false;
-  const emit = (s) => {
-    for (const cb of statusCbs) cb(s);
-  };
-  function connect() {
-    if (stopped) return;
-    const u = typeof url === "function" ? url() : url;
-    emit("connecting");
-    ws = new WebSocket(u, protocols);
-    ws.onopen = () => {
-      attempts = 0;
-      emit("connected");
-      if (pingInterval > 0)
-        pingTimer = setInterval(() => {
-          if (ws?.readyState === 1) ws.send(pingMessage);
-        }, pingInterval);
-    };
-    ws.onmessage = (ev) => {
-      let parsed;
-      try {
-        parsed = JSON.parse(ev.data);
-      } catch {
-        return;
-      }
-      const changes = parseMessage ? parseMessage(parsed) : defaultParse(parsed);
-      if (!changes?.length) return;
-      for (const h of handlers) h({ changes, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-    };
-    ws.onclose = () => {
-      emit("disconnected");
-      clearInterval(pingTimer);
-      if (!stopped && attempts < maxReconnectAttempts)
-        reconnTimer = setTimeout(connect, reconnectBaseDelay * Math.pow(2, Math.min(attempts++, 6)));
-    };
-    ws.onerror = () => {
-      emit("error");
-      ws?.close();
-    };
-  }
-  return {
-    name: "websocket",
-    subscribe(_cfg, handler) {
-      handlers.add(handler);
-      if (!ws || ws.readyState === WebSocket.CLOSED) connect();
-      return () => {
-        handlers.delete(handler);
-        if (handlers.size === 0) {
-          stopped = true;
-          clearTimeout(reconnTimer);
-          clearInterval(pingTimer);
-          ws?.close();
-          ws = null;
-        }
-      };
-    },
-    onStatusChange: (cb) => {
-      statusCbs.add(cb);
-      return () => statusCbs.delete(cb);
-    }
-  };
-}
-function defaultParse(data) {
-  if (!data || typeof data !== "object") return null;
-  const d = data;
-  if (d.op && d.type && d.id) return [d];
-  if (Array.isArray(d.changes)) return d.changes;
-  return null;
-}
-function createSupabaseRealtimeAdapter(client, opts = {}) {
-  const {
-    tableTypeMap = {},
-    extractId = (r) => String(r.id),
-    schema = "public"
-  } = opts;
-  const statusCbs = /* @__PURE__ */ new Set();
-  function resolveType(table) {
-    return tableTypeMap[table] ?? table.charAt(0).toUpperCase() + table.slice(1);
-  }
-  function payloadToChange(p) {
-    const type = resolveType(p.table);
-    if (p.eventType === "DELETE") {
-      const id2 = extractId(p.old);
-      return id2 ? { op: "delete", type, id: id2 } : null;
-    }
-    const id = extractId(p.new);
-    if (!id) return null;
-    return { op: p.eventType === "INSERT" ? "insert" : "upsert", type, id, data: p.new };
-  }
-  return {
-    name: "supabase-realtime",
-    /**
-     * Generic subscribe is a no-op for Supabase. Use `subscribeChannel()` instead,
-     * which accepts a `ChannelConfig` with Supabase-specific table/filter parameters.
-     */
-    subscribe(_cfg, _handler) {
-      return () => {
-      };
-    },
-    onStatusChange: (cb) => {
-      statusCbs.add(cb);
-      return () => statusCbs.delete(cb);
-    },
-    subscribeChannel(config) {
-      const tableName = Object.entries(tableTypeMap).find(([, t]) => t === config.type)?.[0] ?? config.type.toLowerCase();
-      const filterStr = config.id ? `id=eq.${config.id}` : config.filter ? Object.entries(config.filter).map(([k, v]) => `${k}=eq.${v}`).join(",") : void 0;
-      const channel = client.channel(`entity-store:${config.type}:${config.id ?? "all"}`).on("postgres_changes", { event: "*", schema, table: tableName, ...filterStr ? { filter: filterStr } : {} }, (payload) => {
-        const change = payloadToChange(payload);
-        if (!change) return;
-        config._handler?.({ changes: [change], timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-      }).subscribe((status) => {
-        const s = status === "SUBSCRIBED" ? "connected" : status === "CHANNEL_ERROR" ? "error" : status === "CLOSED" ? "disconnected" : "connecting";
-        for (const cb of statusCbs) cb(s);
-      });
-      return () => {
-        channel.unsubscribe();
-      };
-    }
-  };
-}
-function createConvexAdapter(opts) {
-  const { client, channels } = opts;
-  const statusCbs = /* @__PURE__ */ new Set();
-  const snapshots = /* @__PURE__ */ new Map();
-  function diffSnapshot(type, prev, next, extractId, normalize) {
-    const changes = [];
-    const nextIds = /* @__PURE__ */ new Set();
-    for (const record of next) {
-      const id = extractId(record);
-      nextIds.add(id);
-      const data = normalize ? normalize(record) : record;
-      changes.push({ op: prev.has(id) ? "upsert" : "insert", type, id, data });
-      prev.set(id, record);
-    }
-    for (const [id] of prev) {
-      if (!nextIds.has(id)) {
-        changes.push({ op: "delete", type, id });
-        prev.delete(id);
-      }
-    }
-    return changes;
-  }
-  return {
-    name: "convex",
-    subscribe(_cfg, handler) {
-      const unsubs = [];
-      for (const ch of channels) {
-        const { type, query, args = {}, normalize } = ch;
-        const extractId = ch.extractId ?? ((r) => String(
-          r._id ?? r.id
-        ));
-        if (!snapshots.has(type)) snapshots.set(type, /* @__PURE__ */ new Map());
-        const snap = snapshots.get(type);
-        unsubs.push(
-          client.onUpdate(query, args, (records) => {
-            const changes = diffSnapshot(type, snap, records, extractId, normalize);
-            if (changes.length > 0)
-              handler({ changes, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-          })
-        );
-      }
-      for (const cb of statusCbs) cb("connected");
-      return () => {
-        for (const u of unsubs) u();
-        for (const cb of statusCbs) cb("disconnected");
-      };
-    },
-    onStatusChange: (cb) => {
-      statusCbs.add(cb);
-      return () => statusCbs.delete(cb);
-    }
-  };
-}
-function createGraphQLSubscriptionAdapter(opts) {
-  const {
-    client,
-    subscriptions,
-    extractId = (n) => String(n.id),
-    normalize
-  } = opts;
-  const statusCbs = /* @__PURE__ */ new Set();
-  function payloadToChange(type, p) {
-    const gqlType = p.type ?? "updated";
-    if (gqlType === "deleted") {
-      const id2 = p.id ?? (p.node ? extractId(p.node, type) : null);
-      return id2 ? { op: "delete", type, id: id2 } : null;
-    }
-    if (!p.node) return null;
-    const id = extractId(p.node, type);
-    const data = normalize ? normalize(p.node, type) : stripTypename(p.node);
-    const op = gqlType === "created" ? "insert" : "upsert";
-    return { op, type, id, data };
-  }
-  return {
-    name: "graphql-subscription",
-    subscribe(_cfg, handler) {
-      const unsubs = [];
-      for (const sub of subscriptions) {
-        const { type, document: document2, variables, getPayload } = sub;
-        unsubs.push(
-          client.subscribe(
-            { query: document2, variables },
-            {
-              next: ({ data }) => {
-                const raw = getPayload(data);
-                if (!raw) return;
-                const payloads = Array.isArray(raw) ? raw : [raw];
-                const changes = payloads.map((p) => payloadToChange(type, p)).filter((c) => c !== null);
-                if (changes.length > 0)
-                  handler({ changes, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-              },
-              error: (e) => {
-                console.error(`[GQLSub] ${type}:`, e);
-                for (const cb of statusCbs) cb("error");
-              },
-              complete: () => {
-                for (const cb of statusCbs) cb("disconnected");
-              }
-            }
-          )
-        );
-      }
-      for (const cb of statusCbs) cb("connected");
-      return () => {
-        for (const u of unsubs) u();
-      };
-    },
-    onStatusChange: (cb) => {
-      statusCbs.add(cb);
-      return () => statusCbs.delete(cb);
-    }
-  };
-}
-function stripTypename(obj) {
-  const result = {};
-  for (const [k, v] of Object.entries(obj)) {
-    if (k === "__typename") continue;
-    result[k] = v && typeof v === "object" && !Array.isArray(v) ? stripTypename(v) : v;
-  }
-  return result;
-}
-
-// src/adapters/surreal-live.ts
-function createSurrealLiveAdapter(opts) {
-  return new SurrealLiveAdapter(opts);
-}
-var DEFAULT_INITIAL_DELAY = 500;
-var DEFAULT_MAX_DELAY = 3e4;
-var DEFAULT_CONNECTED_SETTLE = 3e4;
-var DEFAULT_CHECKPOINT_FIELD = "updated_at";
-var DEFAULT_PERMANENT_PATTERNS = [
-  /authentication/i,
-  /unauthor/i,
-  /namespace/i,
-  /unknown\s+table/i,
-  /permission/i
-];
-var STATUS_PRIORITY = ["error", "disconnected", "connecting", "connected"];
-var SurrealLiveAdapter = class {
-  name;
-  opts;
-  channels = /* @__PURE__ */ new Map();
-  channelStates = /* @__PURE__ */ new Map();
-  statusCallbacks = /* @__PURE__ */ new Set();
-  _status = "connecting";
-  constructor(rawOpts) {
-    this.opts = {
-      name: rawOpts.name ?? "surreal-live",
-      surreal: rawOpts.surreal,
-      tables: rawOpts.tables,
-      initialQueryStrategy: rawOpts.initialQueryStrategy ?? "select-then-live",
-      initialDelayMs: rawOpts.initialDelayMs ?? DEFAULT_INITIAL_DELAY,
-      maxDelayMs: rawOpts.maxDelayMs ?? DEFAULT_MAX_DELAY,
-      connectedSettleMs: rawOpts.connectedSettleMs ?? DEFAULT_CONNECTED_SETTLE,
-      checkpointField: rawOpts.checkpointField ?? DEFAULT_CHECKPOINT_FIELD,
-      permanentErrorPatterns: rawOpts.permanentErrorPatterns ?? DEFAULT_PERMANENT_PATTERNS,
-      checkpointStore: rawOpts.checkpointStore,
-      listKeyResolver: rawOpts.listKeyResolver
-    };
-    this.name = this.opts.name;
-  }
-  subscribe(config, handler) {
-    const channelConfig = this._resolveChannelConfig(config);
-    const key = this._channelKey(config, channelConfig);
-    const channel = new SurrealChannel(this, config, channelConfig, key, handler);
-    this.channels.set(key, channel);
-    this.channelStates.set(key, "connecting");
-    this._recomputeStatus();
-    channel.start().catch(() => {
-    });
-    return () => {
-      const ch = this.channels.get(key);
-      if (!ch) return;
-      this.channels.delete(key);
-      this.channelStates.delete(key);
-      void ch.stop();
-      this._recomputeStatus();
-    };
-  }
-  onStatusChange = (cb) => {
-    this.statusCallbacks.add(cb);
-    return () => {
-      this.statusCallbacks.delete(cb);
-    };
-  };
-  // ─── package-private helpers used by SurrealChannel ───────────────────────
-  _setChannelStatus(key, status) {
-    if (this.channelStates.get(key) === status) return;
-    this.channelStates.set(key, status);
-    this._recomputeStatus();
-  }
-  _getOpts() {
-    return this.opts;
-  }
-  _recomputeStatus() {
-    const states = [...this.channelStates.values()];
-    const aggregate = states.length === 0 ? "connecting" : STATUS_PRIORITY.find((s) => states.includes(s)) ?? "connecting";
-    if (aggregate === this._status) return;
-    this._status = aggregate;
-    for (const cb of this.statusCallbacks) cb(aggregate);
-  }
-  _resolveChannelConfig(config) {
-    const labelType = config.label?.split("/").pop();
-    const match = this.opts.tables.find((t) => t.type === labelType) ?? this.opts.tables[0];
-    if (!match) {
-      throw new Error(
-        `[surreal-live] no tables configured; pass at least one SurrealTableConfig to createSurrealLiveAdapter`
-      );
-    }
-    return {
-      type: match.type
-    };
-  }
-  _channelKey(config, channelConfig) {
-    const label = config.label ?? `${this.name}/${channelConfig.type}`;
-    return label;
-  }
-};
-var SurrealChannel = class {
-  constructor(adapter, config, channelConfig, key, handler) {
-    this.adapter = adapter;
-    this.config = config;
-    this.channelConfig = channelConfig;
-    this.key = key;
-    this.handler = handler;
-  }
-  liveUuid = null;
-  buffer = [];
-  seedComplete = false;
-  attempt = 0;
-  connectedSettleTimer = null;
-  reconnectTimer = null;
-  aborted = false;
-  status = "connecting";
-  async start() {
-    if (this.aborted) return;
-    this._setStatus("connecting");
-    try {
-      await this._openLive();
-      const opts = this.adapter._getOpts();
-      if (opts.initialQueryStrategy !== "live-only") {
-        await this._runSeed();
-      }
-      this.seedComplete = true;
-      const buffered = this.buffer.splice(0);
-      for (const action of buffered) this._handleAction(action);
-      this._setStatus("connected");
-      this._armConnectedSettle();
-    } catch (err) {
-      this._scheduleReconnect(err);
-    }
-  }
-  async stop() {
-    this.aborted = true;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.connectedSettleTimer) {
-      clearTimeout(this.connectedSettleTimer);
-      this.connectedSettleTimer = null;
-    }
-    if (this.liveUuid) {
-      const uuid = this.liveUuid;
-      this.liveUuid = null;
-      try {
-        await this.adapter._getOpts().surreal.kill(uuid);
-      } catch {
-      }
-    }
-  }
-  // ─── private ──────────────────────────────────────────────────────────────
-  _table() {
-    const t = this.adapter._getOpts().tables.find((x) => x.type === this.channelConfig.type);
-    return t?.table ?? this.channelConfig.type;
-  }
-  _idField() {
-    const t = this.adapter._getOpts().tables.find((x) => x.type === this.channelConfig.type);
-    return t?.idField ?? "id";
-  }
-  async _openLive() {
-    if (this.aborted) return;
-    const surreal = this.adapter._getOpts().surreal;
-    this.liveUuid = await surreal.live(this._table(), (action) => {
-      this._onLiveAction(action);
-    });
-  }
-  _onLiveAction(action) {
-    if (this.aborted) return;
-    if (!this.seedComplete) {
-      this.buffer.push(action);
-      return;
-    }
-    this._handleAction(action);
-  }
-  _handleAction(action) {
-    const op = mapAction(action.action);
-    if (op === "close") {
-      this._scheduleReconnect(new Error("SurrealDB live query closed"));
-      return;
-    }
-    if (op === null) {
-      console.warn(`[surreal-live] unknown action "${action.action}"; skipping`);
-      return;
-    }
-    const allowed = this.channelConfig.operations;
-    if (allowed && !allowed.includes(op)) return;
-    const change = this._rowToChange(op, action.result);
-    if (!change) return;
-    const changeset = {
-      changes: [change],
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      affectedListKeys: this._resolveListKeys([change])
-    };
-    this.handler(changeset);
-    void this._persistCheckpoint(change);
-  }
-  async _runSeed() {
-    const surreal = this.adapter._getOpts().surreal;
-    const table = this._table();
-    const sql = `SELECT * FROM ${table}`;
-    const rows = await surreal.query(sql) ?? [];
-    const changes = [];
-    for (const row of rows) {
-      const change = this._rowToChange("insert", row);
-      if (change) changes.push(change);
-    }
-    const changeset = {
-      changes,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      affectedListKeys: this._resolveListKeys(changes)
-    };
-    this.handler(changeset);
-    for (const change of changes) void this._persistCheckpoint(change);
-  }
-  _rowToChange(op, row) {
-    if (!row && op !== "delete") return null;
-    const idValue = row?.[this._idField()];
-    if (idValue == null) {
-      console.warn(`[surreal-live] action ${op} missing id field "${this._idField()}"; skipping`);
-      return null;
-    }
-    const id = String(idValue);
-    const base = {
-      op,
-      type: this.channelConfig.type,
-      id
-    };
-    if (op === "delete") return base;
-    return { ...base, data: row };
-  }
-  _resolveListKeys(changes) {
-    const resolver = this.adapter._getOpts().listKeyResolver;
-    if (!resolver) return void 0;
-    const acc = /* @__PURE__ */ new Set();
-    for (const change of changes) {
-      const keys = resolver(change);
-      if (!keys) continue;
-      for (const k of keys) acc.add(k);
-    }
-    return acc.size === 0 ? void 0 : [...acc];
-  }
-  async _persistCheckpoint(change) {
-    const opts = this.adapter._getOpts();
-    if (!opts.checkpointStore) return;
-    const value = change.data?.[opts.checkpointField];
-    if (value == null) return;
-    try {
-      await opts.checkpointStore.set(this.key, String(value));
-    } catch {
-    }
-  }
-  async _replayFromCheckpoint() {
-    const opts = this.adapter._getOpts();
-    if (!opts.checkpointStore) return;
-    const stored = await opts.checkpointStore.get(this.key);
-    if (!stored) return;
-    const sql = `SELECT * FROM ${this._table()} WHERE ${opts.checkpointField} > $stored ORDER BY ${opts.checkpointField} ASC`;
-    const rows = await opts.surreal.query(sql, { stored }) ?? [];
-    if (rows.length === 0) return;
-    const changes = [];
-    for (const row of rows) {
-      const change = this._rowToChange("update", row);
-      if (change) changes.push(change);
-    }
-    if (changes.length === 0) return;
-    const changeset = {
-      changes,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      affectedListKeys: this._resolveListKeys(changes)
-    };
-    this.handler(changeset);
-    for (const change of changes) void this._persistCheckpoint(change);
-  }
-  _scheduleReconnect(reason) {
-    if (this.aborted) return;
-    if (this._isPermanent(reason)) {
-      this._setStatus("error");
-      return;
-    }
-    this._setStatus("disconnected");
-    this.attempt += 1;
-    const opts = this.adapter._getOpts();
-    const exp = Math.min(this.attempt - 1, 6);
-    const base = Math.min(opts.initialDelayMs * 2 ** exp, opts.maxDelayMs);
-    const jitter = base * 0.25 * (Math.random() * 2 - 1);
-    const delay = Math.max(0, Math.round(base + jitter));
-    this._setStatus("connecting");
-    this.reconnectTimer = setTimeout(async () => {
-      if (this.aborted) return;
-      try {
-        await this._openLive();
-        if (opts.checkpointStore) await this._replayFromCheckpoint();
-        this._setStatus("connected");
-        this._armConnectedSettle();
-      } catch (err) {
-        this._scheduleReconnect(err);
-      }
-    }, delay);
-  }
-  _isPermanent(reason) {
-    const msg = reason instanceof Error ? reason.message : String(reason ?? "");
-    const patterns = this.adapter._getOpts().permanentErrorPatterns;
-    return patterns.some((re) => re.test(msg));
-  }
-  _armConnectedSettle() {
-    if (this.connectedSettleTimer) clearTimeout(this.connectedSettleTimer);
-    this.connectedSettleTimer = setTimeout(() => {
-      this.attempt = 0;
-    }, this.adapter._getOpts().connectedSettleMs);
-  }
-  _setStatus(status) {
-    if (this.status === status) return;
-    this.status = status;
-    this.adapter._setChannelStatus(this.key, status);
-  }
-};
-function mapAction(action) {
-  switch ((action ?? "").toUpperCase()) {
-    case "CREATE":
-      return "insert";
-    case "UPDATE":
-      return "update";
-    case "DELETE":
-      return "delete";
-    case "CLOSE":
-      return "close";
-    default:
-      return null;
-  }
-}
-
-// src/adapters/flint.ts
-function checkpointKey(channelId, consumerId) {
-  return `flint:${channelId}:${consumerId}`;
-}
-function createFlintAdapter(options) {
-  const {
-    client,
-    channelId,
-    consumerId,
-    entityType,
-    checkpoints,
-    resolveOp = () => "upsert"
-  } = options;
-  const name = options.name ?? `flint:${channelId}`;
-  const statusListeners = /* @__PURE__ */ new Set();
-  function emitStatus(s) {
-    for (const cb of statusListeners) cb(s);
-  }
-  return {
-    name,
-    subscribe(_config, handler) {
-      let cancelled = false;
-      emitStatus("connecting");
-      (async () => {
-        const key = checkpointKey(channelId, consumerId);
-        const lastSeen = checkpoints ? await checkpoints.get(key) : void 0;
-        const query = {
-          channelId,
-          consumerId,
-          ...entityType !== void 0 ? { entityType } : {},
-          ...lastSeen !== void 0 ? { fromOffset: lastSeen + 1n } : {}
-        };
-        try {
-          emitStatus("connected");
-          for await (const event of client.watchEntities(query)) {
-            if (cancelled) break;
-            if (entityType !== void 0 && event.entityType !== entityType) continue;
-            const change = {
-              op: resolveOp(event),
-              type: event.entityType,
-              id: event.entityId,
-              data: event.data
-            };
-            const changeset = {
-              changes: [change],
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            };
-            handler(changeset);
-            if (checkpoints) await checkpoints.set(key, event.offset);
-          }
-          if (!cancelled) emitStatus("disconnected");
-        } catch {
-          if (!cancelled) emitStatus("error");
-        }
-      })();
-      return () => {
-        cancelled = true;
-        emitStatus("disconnected");
-      };
-    },
-    onStatusChange(cb) {
-      statusListeners.add(cb);
-      return () => statusListeners.delete(cb);
-    }
-  };
-}
-async function publishFlintMutation(client, record) {
-  await client.mutateEntity(record);
-}
-
-// src/adapters/electricsql.ts
-function createElectricAdapter(opts) {
-  const { pglite, tables, onSynced } = opts;
-  const statusCbs = /* @__PURE__ */ new Set();
-  const syncedCbs = /* @__PURE__ */ new Set();
-  const syncedTables = /* @__PURE__ */ new Set();
-  let globalHandler = null;
-  function checkAllSynced() {
-    if (tables.every((t) => syncedTables.has(t.table))) {
-      onSynced?.();
-      for (const cb of syncedCbs) cb();
-    }
-  }
-  function toChange(tc, msg) {
-    const { type, idColumn = "id", normalize } = tc;
-    const op = msg.headers.operation;
-    const raw = msg.value;
-    const id = String(raw[idColumn]);
-    if (!id) return null;
-    const data = normalize ? normalize(raw) : raw;
-    if (op === "delete") return { op: "delete", type, id };
-    return { op: op === "insert" ? "insert" : "upsert", type, id, data };
-  }
-  const shapeUnsubs = [];
-  for (const tc of tables) {
-    shapeUnsubs.push(tc.shapeStream.subscribe((msgs) => {
-      if (!globalHandler) return;
-      const changes = msgs.map((m) => toChange(tc, m)).filter((c) => c !== null);
-      if (changes.length > 0) globalHandler({ changes, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
-      if (tc.shapeStream.isUpToDate) {
-        syncedTables.add(tc.table);
-        checkAllSynced();
-      }
-    }, (e) => {
-      console.error(`[Electric] ${tc.table}:`, e);
-      for (const cb of statusCbs) cb("error");
-    }));
-  }
-  void (async () => {
-    for (const tc of tables) {
-      await pglite.listen(`entity_store_${tc.table}`, (payload) => {
-        if (!globalHandler) return;
-        try {
-          const parsed = JSON.parse(payload);
-          const change = toChange(tc, { headers: { operation: parsed.op }, offset: "", key: String(parsed.row[tc.idColumn ?? "id"]), value: parsed.row });
-          if (change) globalHandler({ changes: [change] });
-        } catch {
-        }
-      });
-    }
-  })();
-  return {
-    name: "electricsql",
-    subscribe(_cfg, handler) {
-      globalHandler = handler;
-      for (const cb of statusCbs) cb("connected");
-      return () => {
-        globalHandler = null;
-        for (const u of shapeUnsubs) u();
-      };
-    },
-    onStatusChange(cb) {
-      statusCbs.add(cb);
-      return () => statusCbs.delete(cb);
-    },
-    async query(sql, params) {
-      const r = await pglite.query(sql, params);
-      return { rows: r.rows };
-    },
-    async execute(sql, _params) {
-      await pglite.exec(sql);
-    },
-    isSynced() {
-      return tables.every((t) => syncedTables.has(t.table));
-    },
-    onSyncComplete(cb) {
-      if (this.isSynced()) {
-        cb();
-        return () => {
-        };
-      }
-      syncedCbs.add(cb);
-      return () => syncedCbs.delete(cb);
-    }
-  };
-}
-
-// src/adapters/electricsql-tenant.ts
-var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function assertUuid(companyId) {
-  if (typeof companyId !== "string" || !UUID_RE.test(companyId)) {
-    throw new Error(
-      `tenant-scoped adapter: companyId must be a UUID, received "${companyId}".`
-    );
-  }
-}
-function assertSafeColumn(column) {
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(column)) {
-    throw new Error(`tenant-scoped adapter: unsafe tenantColumn "${column}".`);
-  }
-}
-function buildTenantWhere(tenantColumn, companyId, tableLabel) {
-  if (typeof tenantColumn === "undefined") {
-    throw new Error(
-      `shape "${tableLabel}" lacks tenantColumn \u2014 tenant-scoped adapter refuses to attach unscoped shapes.`
-    );
-  }
-  assertUuid(companyId);
-  if (tenantColumn === null) {
-    return `id = '${companyId}'`;
-  }
-  assertSafeColumn(tenantColumn);
-  return `${tenantColumn} = '${companyId}'`;
-}
-function createTenantScopedElectricAdapter(opts) {
-  const { pglite, tenantClaim, tables, onSynced } = opts;
-  assertUuid(tenantClaim.companyId);
-  const wired = tables.map((tc) => {
-    const where = buildTenantWhere(tc.tenantColumn, tenantClaim.companyId, tc.table);
-    const shapeStream = tc.shapeStreamFactory({ table: tc.table, where, tenantClaim });
-    return {
-      type: tc.type,
-      table: tc.table,
-      where,
-      idColumn: tc.primaryKey?.[0] ?? "id",
-      normalize: tc.normalize,
-      shapeStream
-    };
-  });
-  return createElectricAdapter({ pglite, tables: wired, onSynced });
-}
-
-// src/adapters/pglite-persistence.ts
-var DEFAULT_TABLE = "_graph_snapshot";
-async function createPGlitePersistenceAdapter(pglite, options = {}) {
-  const tableName = options.tableName ?? DEFAULT_TABLE;
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(tableName)) {
-    throw new Error(`createPGlitePersistenceAdapter: invalid tableName "${tableName}"`);
-  }
-  await pglite.exec(
-    `CREATE TABLE IF NOT EXISTS ${tableName} (
-       key        TEXT        PRIMARY KEY,
-       value      TEXT        NOT NULL,
-       updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
-     )`
-  );
-  return {
-    async get(key) {
-      const result = await pglite.query(
-        `SELECT value FROM ${tableName} WHERE key = $1`,
-        [key]
-      );
-      const row = result.rows[0];
-      return row?.value ?? null;
-    },
-    async set(key, value) {
-      await pglite.query(
-        `INSERT INTO ${tableName} (key, value, updated_at)
-         VALUES ($1, $2, now())
-         ON CONFLICT (key) DO UPDATE
-           SET value = EXCLUDED.value,
-               updated_at = now()`,
-        [key, value]
-      );
-    },
-    async remove(key) {
-      await pglite.query(`DELETE FROM ${tableName} WHERE key = $1`, [key]);
-    }
-  };
-}
-
-// src/adapters/tauri-sql-persistence.ts
-var DEFAULT_TABLE2 = "_graph_snapshot";
-async function createTauriSqlPersistenceAdapter(db, options = {}) {
-  const tableName = options.tableName ?? DEFAULT_TABLE2;
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(tableName)) {
-    throw new Error(`createTauriSqlPersistenceAdapter: invalid tableName "${tableName}"`);
-  }
-  await db.execute(
-    `CREATE TABLE IF NOT EXISTS ${tableName} (
-       key        TEXT PRIMARY KEY,
-       value      TEXT NOT NULL,
-       updated_at INTEGER NOT NULL
-     )`
-  );
-  return {
-    async get(key) {
-      const rows = await db.select(
-        `SELECT value FROM ${tableName} WHERE key = ?`,
-        [key]
-      );
-      return rows[0]?.value ?? null;
-    },
-    async set(key, value) {
-      await db.execute(
-        `INSERT INTO ${tableName} (key, value, updated_at)
-         VALUES (?, ?, ?)
-         ON CONFLICT (key) DO UPDATE
-           SET value = excluded.value,
-               updated_at = excluded.updated_at`,
-        [key, value, Date.now()]
-      );
-    },
-    async remove(key) {
-      await db.execute(`DELETE FROM ${tableName} WHERE key = ?`, [key]);
-    }
-  };
-}
-
-// src/schema-from-sql.ts
-function parseCreateTable(sql) {
-  const headerMatch = sql.match(
-    /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["]?([A-Za-z_][A-Za-z0-9_]*)["]?\s*\(([\s\S]*)\)\s*;?\s*$/im
-  );
-  if (!headerMatch) {
-    throw new Error("parseCreateTable: could not locate a CREATE TABLE block");
-  }
-  const tableName = headerMatch[1];
-  const body = headerMatch[2];
-  const columns = [];
-  for (const rawLine of splitTopLevelCommas(body)) {
-    const line = rawLine.trim();
-    if (!line) continue;
-    if (/^(?:PRIMARY\s+KEY|FOREIGN\s+KEY|UNIQUE|CHECK|CONSTRAINT|LIKE|EXCLUDE)\b/i.test(line)) {
-      continue;
-    }
-    const colMatch = line.match(/^["]?([A-Za-z_][A-Za-z0-9_]*)["]?\s+([A-Za-z][A-Za-z0-9_]*(?:\s*\([^)]*\))?(?:\s*\[\s*\])?)([\s\S]*)$/);
-    if (!colMatch) continue;
-    const name = colMatch[1];
-    const sqlType = colMatch[2].replace(/\s+/g, "").toUpperCase();
-    const rest = colMatch[3].toUpperCase();
-    const notNull = /\bNOT\s+NULL\b/.test(rest);
-    const hasDefault = /\bDEFAULT\b/.test(rest);
-    columns.push({ name, sqlType, notNull, hasDefault });
-  }
-  return { tableName, columns };
-}
-function splitTopLevelCommas(body) {
-  const parts = [];
-  let depth = 0;
-  let current = "";
-  for (const ch of body) {
-    if (ch === "(") depth++;
-    else if (ch === ")") depth--;
-    if (ch === "," && depth === 0) {
-      parts.push(current);
-      current = "";
-    } else {
-      current += ch;
-    }
-  }
-  if (current.trim()) parts.push(current);
-  return parts;
-}
-function sqlTypeToJsonSchema(sqlType) {
-  const t = sqlType.replace(/\s+/g, "").toUpperCase();
-  if (/^TEXT\[\]$/.test(t)) {
-    return { schema: { type: "array", items: { type: "string" } } };
-  }
-  if (t === "UUID" || t === "TEXT" || /^VARCHAR(\(.*\))?$/.test(t) || /^CHAR(\(.*\))?$/.test(t)) {
-    return { schema: { type: "string" } };
-  }
-  if (t === "INTEGER" || t === "INT" || t === "BIGINT" || t === "SMALLINT" || t === "INT4" || t === "INT8" || t === "INT2") {
-    return { schema: { type: "integer" } };
-  }
-  if (/^NUMERIC(\(.*\))?$/.test(t) || /^DECIMAL(\(.*\))?$/.test(t) || t === "REAL" || t === "DOUBLEPRECISION" || t === "FLOAT") {
-    return { schema: { type: "number" } };
-  }
-  if (t === "BOOLEAN" || t === "BOOL") {
-    return { schema: { type: "boolean" } };
-  }
-  if (t === "TIMESTAMPTZ" || t === "TIMESTAMP" || t === "TIMESTAMPWITHTIMEZONE" || t === "TIMESTAMPWITHOUTTIMEZONE") {
-    return { schema: { type: "string", format: "date-time" } };
-  }
-  if (t === "DATE") {
-    return { schema: { type: "string", format: "date" } };
-  }
-  if (t === "JSONB" || t === "JSON") {
-    return { schema: { type: "object" } };
-  }
-  return {
-    schema: { type: "string" },
-    warning: `sql type "${sqlType}" not explicitly mapped; defaulting to string`
-  };
-}
-function deepMergeUnknown(base, override) {
-  const out = { ...base };
-  for (const [key, value] of Object.entries(override)) {
-    const baseValue = base[key];
-    if (value !== null && typeof value === "object" && !Array.isArray(value) && baseValue !== null && typeof baseValue === "object" && !Array.isArray(baseValue)) {
-      out[key] = deepMergeUnknown(
-        baseValue,
-        value
-      );
-    } else {
-      out[key] = value;
-    }
-  }
-  return out;
-}
-function mergeEntityConfig(generated, overrides) {
-  if (!overrides) return generated;
-  const merged = deepMergeUnknown(
-    generated,
-    overrides
-  );
-  const refined = merged;
-  return {
-    ...refined,
-    entityType: generated.entityType,
-    schema: refined.schema ?? generated.schema
-  };
-}
-function registerEntityFromSql(opts) {
-  const parsed = parseCreateTable(opts.createTableSql);
-  const properties = {};
-  const required = [];
-  for (const col of parsed.columns) {
-    const { schema, warning } = sqlTypeToJsonSchema(col.sqlType);
-    const propSchema = { ...schema };
-    if (warning) {
-      propSchema["x-warning"] = warning;
-    }
-    properties[col.name] = propSchema;
-    if (col.notNull && !col.hasDefault) {
-      required.push(col.name);
-    }
-  }
-  const generated = {
-    entityType: opts.entityType,
-    source: "runtime",
-    schema: {
-      type: "object",
-      title: parsed.tableName,
-      properties,
-      required
-    }
-  };
-  const config = mergeEntityConfig(generated, opts.overrides);
-  registerEntityJsonSchema(config);
-  return config;
-}
-
-// src/table/row-models.ts
-function resolveAccessor(columnDef, row, index) {
-  if (columnDef.accessorFn) return columnDef.accessorFn(row, index);
-  if (columnDef.accessorKey) return row[columnDef.accessorKey];
-  return void 0;
-}
-var builtInFilterFns = {
-  auto: (row, columnId, filterValue) => {
-    const val = row.getValue(columnId);
-    if (filterValue == null || filterValue === "") return true;
-    if (typeof val === "string") return val.toLowerCase().includes(String(filterValue).toLowerCase());
-    if (typeof val === "number") return val === Number(filterValue);
-    if (typeof val === "boolean") return val === filterValue;
-    return String(val).toLowerCase().includes(String(filterValue).toLowerCase());
-  }
-};
-function defaultSortingFn(a, b) {
-  if (a == null && b == null) return 0;
-  if (a == null) return 1;
-  if (b == null) return -1;
-  if (typeof a === "number" && typeof b === "number") return a - b;
-  if (a instanceof Date && b instanceof Date) return a.getTime() - b.getTime();
-  return String(a).localeCompare(String(b));
-}
-function createRow(original, index, columns, table, depth = 0, parentId, subRows = []) {
-  const id = table.options.getRowId ? table.options.getRowId(original, index) : String(index);
-  const row = {
-    id,
-    index,
-    original,
-    depth,
-    parentId,
-    subRows,
-    getValue: (columnId) => {
-      const col = columns.find((c) => c.id === columnId);
-      if (!col) return void 0;
-      return resolveAccessor(col.columnDef, original, index);
-    },
-    renderValue: (columnId) => {
-      const val = row.getValue(columnId);
-      return val ?? null;
-    },
-    getIsSelected: () => !!table.getState().rowSelection[id],
-    getCanSelect: () => {
-      const opt = table.options.enableRowSelection;
-      if (opt === false) return false;
-      if (typeof opt === "function") return opt(row);
-      return true;
-    },
-    getIsAllSubRowsSelected: () => subRows.length > 0 && subRows.every((sr) => sr.getIsSelected()),
-    getIsSomeSelected: () => subRows.some((sr) => sr.getIsSelected() || sr.getIsSomeSelected()),
-    toggleSelected: (value) => {
-      const next = value ?? !row.getIsSelected();
-      table.setRowSelection((prev) => ({ ...prev, [id]: next }));
-    },
-    getToggleSelectedHandler: () => (e) => {
-      row.toggleSelected();
-    },
-    getIsExpanded: () => {
-      const expanded = table.getState().expanded;
-      if (expanded === true) return true;
-      return !!expanded[id];
-    },
-    getCanExpand: () => subRows.length > 0,
-    toggleExpanded: (value) => {
-      const next = value ?? !row.getIsExpanded();
-      table.setExpanded((prev) => {
-        if (prev === true) {
-          const allRows = {};
-          table.getCoreRowModel().flatRows.forEach((r) => {
-            allRows[r.id] = true;
-          });
-          allRows[id] = next;
-          return allRows;
-        }
-        return { ...prev, [id]: next };
-      });
-    },
-    getToggleExpandedHandler: () => () => row.toggleExpanded(),
-    getIsGrouped: () => !!row.groupingColumnId,
-    groupingColumnId: void 0,
-    groupingValue: void 0,
-    getVisibleCells: () => row.getAllCells().filter((cell) => cell.column.getIsVisible()),
-    getAllCells: () => columns.map((col) => createCell(row, col, table)),
-    getIsPinned: () => false,
-    pin: () => {
-    }
-  };
-  return row;
-}
-function createCell(row, column, table) {
-  const cellId = `${row.id}_${column.id}`;
-  const cell = {
-    id: cellId,
-    row,
-    column,
-    getValue: () => row.getValue(column.id),
-    renderValue: () => row.renderValue(column.id),
-    getIsGrouped: () => row.getIsGrouped() && row.groupingColumnId === column.id,
-    getIsPlaceholder: () => false,
-    getIsAggregated: () => row.subRows.length > 0 && row.getIsGrouped() && row.groupingColumnId !== column.id,
-    getContext: () => ({
-      table,
-      row,
-      cell,
-      column,
-      getValue: cell.getValue,
-      renderValue: cell.renderValue
-    })
-  };
-  return cell;
-}
-function getCoreRowModel(data, columns, table) {
-  const getSubRows = table.options.getSubRows;
-  const flatRows = [];
-  function processRows(items, depth, parentId) {
-    return items.map((item, index) => {
-      const subData = getSubRows?.(item, index);
-      const row = createRow(item, flatRows.length, columns, table, depth, parentId);
-      flatRows.push(row);
-      if (subData && subData.length > 0) {
-        row.subRows = processRows(subData, depth + 1, row.id);
-      }
-      return row;
-    });
-  }
-  const rows = processRows(data, 0);
-  const rowsById = {};
-  flatRows.forEach((r) => {
-    rowsById[r.id] = r;
-  });
-  return { rows, flatRows, rowsById };
-}
-function getFilteredRowModel(rowModel, columnFilters, globalFilter, columns, globalFilterFn) {
-  const hasColumnFilters = columnFilters.length > 0;
-  const hasGlobalFilter = globalFilter != null && globalFilter !== "";
-  if (!hasColumnFilters && !hasGlobalFilter) return rowModel;
-  const filterFns = /* @__PURE__ */ new Map();
-  for (const cf of columnFilters) {
-    const col = columns.find((c) => c.id === cf.id);
-    if (col) {
-      const fn = col.columnDef.filterFn;
-      filterFns.set(cf.id, typeof fn === "function" ? fn : builtInFilterFns.auto);
-    }
-  }
-  const resolvedGlobalFilterFn = globalFilterFn ?? builtInFilterFns.auto;
-  const flatRows = [];
-  function filterRows(rows2) {
-    return rows2.filter((row) => {
-      for (const cf of columnFilters) {
-        const fn = filterFns.get(cf.id);
-        if (fn && !fn(row, cf.id, cf.value)) return false;
-      }
-      if (hasGlobalFilter) {
-        const matches = columns.some(
-          (col) => resolvedGlobalFilterFn(row, col.id, globalFilter)
-        );
-        if (!matches) return false;
-      }
-      flatRows.push(row);
-      if (row.subRows.length > 0) {
-        const filteredSubRows = filterRows(row.subRows);
-        if (filteredSubRows.length > 0) {
-          row = { ...row, subRows: filteredSubRows };
-          return true;
-        }
-      }
-      return true;
-    });
-  }
-  const rows = filterRows(rowModel.rows);
-  const rowsById = {};
-  flatRows.forEach((r) => {
-    rowsById[r.id] = r;
-  });
-  return { rows, flatRows, rowsById };
-}
-function getSortedRowModel(rowModel, sorting, columns) {
-  if (sorting.length === 0) return rowModel;
-  const sortFns = sorting.map((s) => {
-    const col = columns.find((c) => c.id === s.id);
-    const colDef = col?.columnDef ?? null;
-    let fn = null;
-    if (colDef?.sortingFn && typeof colDef.sortingFn === "function") {
-      fn = colDef.sortingFn;
-    }
-    return { columnId: s.id, desc: s.desc, fn, colDef };
-  });
-  function sortRows(rows2) {
-    const sorted = [...rows2].sort((rowA, rowB) => {
-      for (const { columnId, desc, fn, colDef } of sortFns) {
-        let result;
-        if (fn) {
-          result = fn(rowA, rowB, columnId);
-        } else {
-          const a = rowA.getValue(columnId);
-          const b = rowB.getValue(columnId);
-          result = defaultSortingFn(a, b);
-        }
-        if (colDef?.invertSorting) result = -result;
-        if (result !== 0) return desc ? -result : result;
-      }
-      return 0;
-    });
-    return sorted.map((row) => {
-      if (row.subRows.length > 0) {
-        return { ...row, subRows: sortRows(row.subRows) };
-      }
-      return row;
-    });
-  }
-  const rows = sortRows(rowModel.rows);
-  const flatRows = [];
-  function flatten(rows2) {
-    rows2.forEach((r) => {
-      flatRows.push(r);
-      if (r.subRows.length) flatten(r.subRows);
-    });
-  }
-  flatten(rows);
-  const rowsById = {};
-  flatRows.forEach((r) => {
-    rowsById[r.id] = r;
-  });
-  return { rows, flatRows, rowsById };
-}
-function getGroupedRowModel(rowModel, grouping, columns, table) {
-  if (grouping.length === 0) return rowModel;
-  function groupRows(rows2, depth) {
-    if (depth >= grouping.length) return rows2;
-    const columnId = grouping[depth];
-    const groups = /* @__PURE__ */ new Map();
-    for (const row of rows2) {
-      const value = row.getValue(columnId);
-      const key = value ?? "__null__";
-      if (!groups.has(key)) groups.set(key, []);
-      groups.get(key).push(row);
-    }
-    const groupedRows = [];
-    let groupIndex = 0;
-    for (const [key, groupItems] of groups) {
-      const firstRow = groupItems[0];
-      const groupRow = createRow(
-        firstRow.original,
-        groupIndex++,
-        columns,
-        table,
-        depth
-      );
-      groupRow.groupingColumnId = columnId;
-      groupRow.groupingValue = key === "__null__" ? null : key;
-      groupRow.subRows = groupRows(groupItems, depth + 1);
-      groupedRows.push(groupRow);
-    }
-    return groupedRows;
-  }
-  const rows = groupRows(rowModel.rows, 0);
-  const flatRows = [];
-  function flatten(items) {
-    items.forEach((r) => {
-      flatRows.push(r);
-      if (r.subRows.length) flatten(r.subRows);
-    });
-  }
-  flatten(rows);
-  const rowsById = {};
-  flatRows.forEach((r) => {
-    rowsById[r.id] = r;
-  });
-  return { rows, flatRows, rowsById };
-}
-function getExpandedRowModel(rowModel, expanded) {
-  const flatRows = [];
-  function expandRows(rows2) {
-    const result = [];
-    for (const row of rows2) {
-      result.push(row);
-      flatRows.push(row);
-      const isExpanded = expanded === true || typeof expanded === "object" && expanded[row.id];
-      if (isExpanded && row.subRows.length > 0) {
-        const expandedSubRows = expandRows(row.subRows);
-        result.push(...expandedSubRows);
-      }
-    }
-    return result;
-  }
-  const rows = expandRows(rowModel.rows);
-  const rowsById = {};
-  flatRows.forEach((r) => {
-    rowsById[r.id] = r;
-  });
-  return { rows, flatRows, rowsById };
-}
-function getPaginatedRowModel(rowModel, pagination) {
-  const { pageIndex, pageSize } = pagination;
-  const start = pageIndex * pageSize;
-  const end = start + pageSize;
-  const rows = rowModel.rows.slice(start, end);
-  const flatRows = rows;
-  const rowsById = {};
-  flatRows.forEach((r) => {
-    rowsById[r.id] = r;
-  });
-  return { rows, flatRows, rowsById };
-}
-function getSelectedRowModel(rowModel, selection) {
-  const rows = rowModel.flatRows.filter((r) => selection[r.id]);
-  const rowsById = {};
-  rows.forEach((r) => {
-    rowsById[r.id] = r;
-  });
-  return { rows, flatRows: rows, rowsById };
-}
-
-// src/table/faceting.ts
-function getFacetedUniqueValues(rowModel, columnId) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const row of rowModel.flatRows) {
-    const value = row.getValue(columnId);
-    if (Array.isArray(value)) {
-      for (const v of value) {
-        counts.set(v, (counts.get(v) ?? 0) + 1);
-      }
-    } else {
-      counts.set(value, (counts.get(value) ?? 0) + 1);
-    }
-  }
-  return counts;
-}
-function getFacetedMinMaxValues(rowModel, columnId) {
-  let min = Infinity;
-  let max = -Infinity;
-  let hasValue = false;
-  for (const row of rowModel.flatRows) {
-    const raw = row.getValue(columnId);
-    const value = typeof raw === "number" ? raw : Number(raw);
-    if (!Number.isNaN(value)) {
-      hasValue = true;
-      if (value < min) min = value;
-      if (value > max) max = value;
-    }
-  }
-  return hasValue ? [min, max] : void 0;
-}
-function getFacetedRowModel(preFilteredRowModel, columnId, allFilteredRowModel) {
-  return preFilteredRowModel;
-}
-
-exports.EMPTY_ENTITY_STATE = EMPTY_ENTITY_STATE;
-exports.EMPTY_IDS = EMPTY_IDS;
-exports.EMPTY_LIST_STATE = EMPTY_LIST_STATE;
-exports.EMPTY_SYNC_METADATA = EMPTY_SYNC_METADATA;
-exports.IncrementalView = IncrementalView;
-exports.RealtimeManager = RealtimeManager;
-exports.TerminalError = TerminalError;
-exports.TransientError = TransientError;
-exports.__resetActiveGraphStore = __resetActiveGraphStore;
-exports.__resetEntityTransports = __resetEntityTransports;
-exports.__resetStoreRegistry = __resetStoreRegistry;
-exports.applyAgUiDelta = applyAgUiDelta;
-exports.applyAgUiSnapshot = applyAgUiSnapshot;
-exports.applyJsonPatch = applyJsonPatch;
-exports.applyView = applyView;
-exports.attachGlobalListeners = attachGlobalListeners;
-exports.buildTenantWhere = buildTenantWhere;
-exports.cascadeInvalidation = cascadeInvalidation;
-exports.checkCompleteness = checkCompleteness;
-exports.collectDirtyPaths = collectDirtyPaths;
-exports.compareEntities = compareEntities;
-exports.configureEngine = configureEngine;
-exports.configureTimeTravel = configureTimeTravel;
-exports.createConvexAdapter = createConvexAdapter;
-exports.createDevtoolsEventBus = createDevtoolsEventBus;
-exports.createElectricAdapter = createElectricAdapter;
-exports.createFlintAdapter = createFlintAdapter;
-exports.createGraphAction = createGraphAction;
-exports.createGraphEffect = createGraphEffect;
-exports.createGraphQLSubscriptionAdapter = createGraphQLSubscriptionAdapter;
-exports.createGraphStore = createGraphStore;
-exports.createGraphTool = createGraphTool;
-exports.createGraphTransaction = createGraphTransaction;
-exports.createLoroMergeStrategy = createLoroMergeStrategy;
-exports.createPGlitePersistenceAdapter = createPGlitePersistenceAdapter;
-exports.createRow = createRow;
-exports.createSchemaGraphTool = createSchemaGraphTool;
-exports.createSupabaseRealtimeAdapter = createSupabaseRealtimeAdapter;
-exports.createSurrealLiveAdapter = createSurrealLiveAdapter;
-exports.createTauriSqlPersistenceAdapter = createTauriSqlPersistenceAdapter;
-exports.createTenantScopedElectricAdapter = createTenantScopedElectricAdapter;
-exports.createWebSocketAdapter = createWebSocketAdapter;
-exports.dedupe = dedupe;
-exports.escapeHtml = escapeHtml;
-exports.exportGraphSnapshot = exportGraphSnapshot;
-exports.exportGraphSnapshotWithSchemas = exportGraphSnapshotWithSchemas;
-exports.fetchEntity = fetchEntity;
-exports.fetchList = fetchList;
-exports.findInsertionIndex = findInsertionIndex;
-exports.flattenClauses = flattenClauses;
-exports.getActiveSubscriberCount = getActiveSubscriberCount;
-exports.getCoreRowModel = getCoreRowModel;
-exports.getElectricRealtimeManager = getRealtimeManager;
-exports.getEngineOptions = getEngineOptions;
-exports.getEntityJsonSchema = getEntityJsonSchema;
-exports.getEntityTransport = getEntityTransport;
-exports.getExpandedRowModel = getExpandedRowModel;
-exports.getFacetedMinMaxValues = getFacetedMinMaxValues;
-exports.getFacetedRowModel = getFacetedRowModel;
-exports.getFacetedUniqueValues = getFacetedUniqueValues;
-exports.getFilteredRowModel = getFilteredRowModel;
-exports.getGraphSyncStatus = getGraphSyncStatus;
-exports.getGroupedRowModel = getGroupedRowModel;
-exports.getMergeStrategy = getMergeStrategy;
-exports.getPaginatedRowModel = getPaginatedRowModel;
-exports.getRealtimeManager = getRealtimeManager;
-exports.getRegisteredEntityTypes = getRegisteredEntityTypes;
-exports.getRegisteredStores = getRegisteredStores;
-exports.getSchema = getSchema;
-exports.getSelectedRowModel = getSelectedRowModel;
-exports.getSortedRowModel = getSortedRowModel;
-exports.getTimeTravelState = getTimeTravelState;
-exports.getValueAtPath = getValueAtPath;
-exports.graphStore = graphStore;
-exports.graphSyncStatusStore = graphSyncStatusStore;
-exports.hasCustomPredicates = hasCustomPredicates;
-exports.hasMergeStrategy = hasMergeStrategy;
-exports.humanizeFieldName = humanizeFieldName;
-exports.hydrateGraphFromStorage = hydrateGraphFromStorage;
-exports.inferSchemaFieldType = inferSchemaFieldType;
-exports.lwwStrategy = lwwStrategy;
-exports.makeRestTransport = makeRestTransport;
-exports.matchesFilter = matchesFilter;
-exports.matchesSearch = matchesSearch;
-exports.parseCreateTable = parseCreateTable;
-exports.persistGraphToStorage = persistGraphToStorage;
-exports.prepareGraphStoreScope = prepareGraphStoreScope;
-exports.publishFlintMutation = publishFlintMutation;
-exports.queryOnce = queryOnce;
-exports.readRelations = readRelations;
-exports.recordGraphSnapshot = recordGraphSnapshot;
-exports.registerEntityFromSql = registerEntityFromSql;
-exports.registerEntityJsonSchema = registerEntityJsonSchema;
-exports.registerEntityTransport = registerEntityTransport;
-exports.registerMergeStrategy = registerMergeStrategy;
-exports.registerRuntimeSchema = registerRuntimeSchema;
-exports.registerSchema = registerSchema;
-exports.registerStore = registerStore;
-exports.registerSubscriber = registerSubscriber;
-exports.registryKey = registryKey;
-exports.renderMarkdownToHtml = renderMarkdownToHtml;
-exports.replayActionWithRetry = replayActionWithRetry;
-exports.resetRealtimeManager = resetRealtimeManager;
-exports.resolveActiveGraphStore = resolveActiveGraphStore;
-exports.restoreGraphSnapshot = restoreGraphSnapshot;
-exports.restoreGraphSnapshotBySeq = restoreGraphSnapshotBySeq;
-exports.runWithGraphStore = runWithGraphStore;
-exports.selectGraph = selectGraph;
-exports.serializeKey = serializeKey;
-exports.setActiveGraphStore = setActiveGraphStore;
-exports.setDefaultMergeStrategy = setDefaultMergeStrategy;
-exports.setValueAtPath = setValueAtPath;
-exports.sqlTypeToJsonSchema = sqlTypeToJsonSchema;
-exports.startGarbageCollector = startGarbageCollector;
-exports.startLocalFirstGraph = startLocalFirstGraph;
-exports.stepTimeTravel = stepTimeTravel;
-exports.stopGarbageCollector = stopGarbageCollector;
-exports.subscribeDevtoolsEvent = subscribeDevtoolsEvent;
-exports.subscribeSubscriberStats = subscribeSubscriberStats;
-exports.subscribeTimeTravel = subscribeTimeTravel;
-exports.toEntityError = toEntityError;
-exports.toGraphQLVariables = toGraphQLVariables;
-exports.toPrismaOrderBy = toPrismaOrderBy;
-exports.toPrismaWhere = toPrismaWhere;
-exports.toRestParams = toRestParams;
-exports.toSQLClauses = toSQLClauses;
-exports.unregisterSubscriber = unregisterSubscriber;
-exports.useGraphStore = useGraphStore;
-//# sourceMappingURL=index.cjs.map
-//# sourceMappingURL=index.cjs.map