@foir/sdk 0.8.0 → 0.10.0

package/dist/live.js

@@ -0,0 +1,845 @@
+// src/data/decimal.ts
+var DECIMAL_PATTERN = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
+var MAX_SCALE = 1e3;
+function pow10(n) {
+  return 10n ** BigInt(n);
+}
+function divRound(numerator, denominator, rounding) {
+  if (denominator === 0n) throw new RangeError("FoirDecimal: division by zero");
+  const negative = numerator < 0n !== denominator < 0n;
+  const n = numerator < 0n ? -numerator : numerator;
+  const d = denominator < 0n ? -denominator : denominator;
+  let quotient = n / d;
+  const remainder = n % d;
+  if (remainder !== 0n && rounding !== "down") {
+    const doubled = remainder * 2n;
+    if (doubled > d) {
+      quotient += 1n;
+    } else if (doubled === d) {
+      if (rounding === "half-up" || quotient % 2n === 1n) quotient += 1n;
+    }
+  }
+  return negative ? -quotient : quotient;
+}
+function parse(input) {
+  const text = input.trim();
+  if (!DECIMAL_PATTERN.test(text)) {
+    throw new TypeError(
+      `FoirDecimal: ${JSON.stringify(input)} is not a decimal. Expected a numeric string such as "19.99".`
+    );
+  }
+  const [mantissa, exponentText] = text.split(/[eE]/);
+  const exponent = exponentText ? Number(exponentText) : 0;
+  const negative = mantissa.startsWith("-");
+  const unsigned = negative || mantissa.startsWith("+") ? mantissa.slice(1) : mantissa;
+  const [integerPart = "", fractionPart = ""] = unsigned.split(".");
+  let units = BigInt(`${integerPart || "0"}${fractionPart}`);
+  let scale = fractionPart.length - exponent;
+  if (scale < 0) {
+    units *= pow10(-scale);
+    scale = 0;
+  }
+  if (scale > MAX_SCALE) {
+    throw new RangeError(`FoirDecimal: scale ${scale} exceeds the maximum of ${MAX_SCALE}`);
+  }
+  return { units: negative ? -units : units, scale };
+}
+var FoirDecimal = class _FoirDecimal {
+  // Not `readonly` only so `#of` can populate a fresh instance without going
+  // back through the string parser. Never mutated after construction, and
+  // `#`-private so immutability is not part of the public contract to keep.
+  #units;
+  #scale;
+  constructor(value) {
+    if (value instanceof _FoirDecimal) {
+      this.#units = value.#units;
+      this.#scale = value.#scale;
+      return;
+    }
+    if (typeof value === "bigint") {
+      this.#units = value;
+      this.#scale = 0;
+      return;
+    }
+    if (typeof value !== "string") {
+      throw new TypeError(
+        `FoirDecimal: refusing to construct from ${typeof value}. A JavaScript number is a float and may already have lost precision \u2014 pass the string, or use FoirDecimal.fromNumber() to accept that loss explicitly.`
+      );
+    }
+    const { units, scale } = parse(value);
+    this.#units = units;
+    this.#scale = scale;
+  }
+  /**
+   * Build a decimal from a JavaScript number, accepting the precision that
+   * number may already have lost.
+   *
+   * Deliberately not the constructor. It is for interop — a value read from a
+   * third-party JSON API that emitted a float — and naming it at every call
+   * site is the point. `fromNumber(0.1 + 0.2)` gives `0.30000000000000004`,
+   * because that is genuinely the value it was handed.
+   */
+  static fromNumber(value) {
+    if (!Number.isFinite(value)) {
+      throw new RangeError(`FoirDecimal: ${value} is not a finite number`);
+    }
+    return new _FoirDecimal(value.toPrecision(17));
+  }
+  /** `true` if `value` parses as a decimal. Does not throw. */
+  static isDecimalString(value) {
+    return typeof value === "string" && DECIMAL_PATTERN.test(value.trim());
+  }
+  /** Decimal places carried by this value. `19.90` has scale 2. */
+  get scale() {
+    return this.#scale;
+  }
+  /** Re-express at `scale`, rounding away any digits that no longer fit. */
+  rescale(scale, rounding = "half-up") {
+    if (!Number.isInteger(scale) || scale < 0 || scale > MAX_SCALE) {
+      throw new RangeError(`FoirDecimal: scale must be an integer in 0..${MAX_SCALE}, got ${scale}`);
+    }
+    if (scale === this.#scale) return this;
+    const units = scale > this.#scale ? this.#units * pow10(scale - this.#scale) : divRound(this.#units, pow10(this.#scale - scale), rounding);
+    return _FoirDecimal.#of(units, scale);
+  }
+  add(other) {
+    const [a, b, scale] = _FoirDecimal.#align(this, other);
+    return _FoirDecimal.#of(a + b, scale);
+  }
+  sub(other) {
+    const [a, b, scale] = _FoirDecimal.#align(this, other);
+    return _FoirDecimal.#of(a - b, scale);
+  }
+  /** Exact: scales add, so `1.10 × 1.10` is `1.2100` rather than `1.21`. */
+  mul(other) {
+    const rhs = new _FoirDecimal(other);
+    return _FoirDecimal.#of(this.#units * rhs.#units, this.#scale + rhs.#scale);
+  }
+  /** The only inexact operation — see {@link FoirDecimalDivOptions}. */
+  div(other, options = {}) {
+    const { scale = 20, rounding = "half-even" } = options;
+    if (!Number.isInteger(scale) || scale < 0 || scale > MAX_SCALE) {
+      throw new RangeError(`FoirDecimal: scale must be an integer in 0..${MAX_SCALE}, got ${scale}`);
+    }
+    const rhs = new _FoirDecimal(other);
+    const numerator = this.#units * pow10(rhs.#scale + scale);
+    const denominator = rhs.#units * pow10(this.#scale);
+    return _FoirDecimal.#of(divRound(numerator, denominator, rounding), scale);
+  }
+  abs() {
+    return this.#units < 0n ? _FoirDecimal.#of(-this.#units, this.#scale) : this;
+  }
+  neg() {
+    return _FoirDecimal.#of(-this.#units, this.#scale);
+  }
+  isZero() {
+    return this.#units === 0n;
+  }
+  isNegative() {
+    return this.#units < 0n;
+  }
+  /** `-1`, `0` or `1`. Use this rather than `<`, which throws. */
+  cmp(other) {
+    const [a, b] = _FoirDecimal.#align(this, other);
+    return a < b ? -1 : a > b ? 1 : 0;
+  }
+  /** Numeric equality: `1.0` equals `1.00`. Scale is display, not identity. */
+  equals(other) {
+    return this.cmp(other) === 0;
+  }
+  /**
+   * Fixed-place string, rounding `half-up` by default because this is the
+   * display operation and that is what a person means by "to 2dp".
+   */
+  toFixed(places, rounding = "half-up") {
+    return this.rescale(places, rounding).toString();
+  }
+  /**
+   * The canonical wire form, preserving scale. Never exponent notation, so the
+   * output always parses back to an equal value.
+   */
+  toString() {
+    const negative = this.#units < 0n;
+    const digits = (negative ? -this.#units : this.#units).toString();
+    if (this.#scale === 0) return negative ? `-${digits}` : digits;
+    const padded = digits.padStart(this.#scale + 1, "0");
+    const integerPart = padded.slice(0, padded.length - this.#scale);
+    const fractionPart = padded.slice(padded.length - this.#scale);
+    return `${negative ? "-" : ""}${integerPart}.${fractionPart}`;
+  }
+  /** `JSON.stringify` emits the canonical string, not an object. Pinned by test. */
+  toJSON() {
+    return this.toString();
+  }
+  /**
+   * Explicitly lossy — this is the boundary back into float, and naming it is
+   * the point. Fine for a chart axis; never for money you will add up.
+   */
+  toNumber() {
+    return Number(this.toString());
+  }
+  /**
+   * Answers the `'string'` hint so template literals work, and throws on every
+   * other hint so `+`, `<` and `Number()` fail loudly instead of silently
+   * concatenating or truncating.
+   */
+  [Symbol.toPrimitive](hint) {
+    if (hint === "string") return this.toString();
+    throw new TypeError(
+      hint === "number" ? "FoirDecimal: cannot be coerced to a number implicitly. Use .toNumber() to accept the precision loss, or .cmp() to compare." : "FoirDecimal: cannot be coerced implicitly. Use .add() / .sub() / .mul() / .div() for arithmetic, .cmp() to compare, or .toString() for text."
+    );
+  }
+  get [Symbol.toStringTag]() {
+    return "FoirDecimal";
+  }
+  /** Skip parsing when the units are already known to be well-formed. */
+  static #of(units, scale) {
+    const instance = new _FoirDecimal(0n);
+    instance.#units = units;
+    instance.#scale = scale;
+    return instance;
+  }
+  /** Bring two values to a common scale so their units can be compared. */
+  static #align(left, right) {
+    const rhs = new _FoirDecimal(right);
+    const scale = Math.max(left.#scale, rhs.#scale);
+    return [
+      left.#units * pow10(scale - left.#scale),
+      rhs.#units * pow10(scale - rhs.#scale),
+      scale
+    ];
+  }
+};
+
+// src/live/keys.ts
+function foirDecimalKey(value) {
+  const text = value.toString();
+  if (!text.includes(".")) return text;
+  const trimmed = text.replace(/0+$/, "").replace(/\.$/, "");
+  return trimmed === "-0" || trimmed === "" ? "0" : trimmed;
+}
+function foirStableKey(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undef";
+  if (value instanceof FoirDecimal) return `d:${foirDecimalKey(value)}`;
+  if (value instanceof Date) return `t:${value.toISOString()}`;
+  if (Array.isArray(value)) return `[${value.map(foirStableKey).join(",")}]`;
+  switch (typeof value) {
+    case "string":
+      return `s:${JSON.stringify(value)}`;
+    case "number":
+      return `n:${Object.is(value, -0) ? "0" : String(value)}`;
+    case "bigint":
+      return `n:${value.toString()}`;
+    case "boolean":
+      return `b:${value ? "1" : "0"}`;
+    case "object": {
+      const entries = Object.keys(value).sort().map((k) => `${JSON.stringify(k)}:${foirStableKey(value[k])}`);
+      return `{${entries.join(",")}}`;
+    }
+    default:
+      throw new TypeError(
+        `[foir] a query argument of type ${typeof value} cannot be part of a cache key`
+      );
+  }
+}
+function callTarget(call) {
+  return "model" in call ? `m:${call.model}` : `ns:${call.namespace}`;
+}
+function foirQueryKey(call) {
+  const parts = [
+    callTarget(call),
+    `op:${call.op}`,
+    `args:${foirStableKey(call.args ?? {})}`
+  ];
+  if (call.include !== void 0) parts.push(`inc:${foirStableKey(call.include)}`);
+  if (call.omit !== void 0) parts.push(`omit:${foirStableKey([...call.omit].sort())}`);
+  if (call.pick !== void 0) parts.push(`pick:${foirStableKey([...call.pick].sort())}`);
+  if (call.depth !== void 0) parts.push(`depth:${call.depth}`);
+  return parts.join("|");
+}
+
+// src/live/headers.ts
+var FOIR_CACHE_TAGS_HEADER = "X-Foir-Cache-Tags";
+var FOIR_SURROGATE_KEY_HEADER = "Surrogate-Key";
+var FOIR_PROJECT_SEQ_HEADER = "X-Foir-Project-Seq";
+function splitTags(raw) {
+  if (!raw) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const tag of raw.split(/\s+/)) {
+    if (!tag || seen.has(tag)) continue;
+    seen.add(tag);
+    out.push(tag);
+  }
+  return out;
+}
+function readFoirLiveHeaders(headers) {
+  const surrogate = splitTags(headers.get(FOIR_SURROGATE_KEY_HEADER));
+  const tags = surrogate.length > 0 ? surrogate : splitTags(headers.get(FOIR_CACHE_TAGS_HEADER));
+  const raw = headers.get(FOIR_PROJECT_SEQ_HEADER);
+  let seq = null;
+  if (raw) {
+    const parsed = Number(raw);
+    if (Number.isSafeInteger(parsed) && parsed > 0) seq = parsed;
+  }
+  return { tags, seq };
+}
+
+// src/live/writetoken.ts
+var FOIR_WRITE_TOKEN_HEADER = "X-Foir-Write-Token";
+function readFoirWriteToken(headers) {
+  const raw = headers.get(FOIR_WRITE_TOKEN_HEADER);
+  if (typeof raw !== "string") return null;
+  const token = raw.trim();
+  return token === "" ? null : token;
+}
+function foirWriteTokenHeaders(token) {
+  if (typeof token !== "string") return {};
+  const trimmed = token.trim();
+  return trimmed === "" ? {} : { [FOIR_WRITE_TOKEN_HEADER]: trimmed };
+}
+
+// src/live/events.ts
+var RECORD_TAG_PREFIX = "rec:";
+var CACHED_CHANNEL = "published";
+function foirRecordTag(recordId) {
+  return `${RECORD_TAG_PREFIX}${recordId}`;
+}
+function foirModelTag(modelKey) {
+  return `model:${modelKey}:${CACHED_CHANNEL}`;
+}
+function foirTagsForRecordChange(event) {
+  const record = foirRecordTag(event.recordId);
+  if (event.action === "updated") return [record];
+  return [record, foirModelTag(event.modelKey)];
+}
+
+// src/live/tagIndex.ts
+function createFoirTagIndex() {
+  const byKey = /* @__PURE__ */ new Map();
+  const byTag = /* @__PURE__ */ new Map();
+  function unindex(key) {
+    const previous = byKey.get(key);
+    if (!previous) return;
+    for (const tag of previous) {
+      const keys = byTag.get(tag);
+      if (!keys) continue;
+      keys.delete(key);
+      if (keys.size === 0) byTag.delete(tag);
+    }
+    byKey.delete(key);
+  }
+  return {
+    set(key, tags) {
+      unindex(key);
+      const unique = [...new Set(tags)];
+      if (unique.length === 0) {
+        return;
+      }
+      byKey.set(key, unique);
+      for (const tag of unique) {
+        let keys = byTag.get(tag);
+        if (!keys) {
+          keys = /* @__PURE__ */ new Set();
+          byTag.set(tag, keys);
+        }
+        keys.add(key);
+      }
+    },
+    remove: unindex,
+    tagsFor(key) {
+      return byKey.get(key) ?? [];
+    },
+    keysForTags(tags) {
+      const out = /* @__PURE__ */ new Set();
+      for (const tag of tags) {
+        const keys = byTag.get(tag);
+        if (!keys) continue;
+        for (const key of keys) out.add(key);
+      }
+      return [...out];
+    },
+    clear() {
+      byKey.clear();
+      byTag.clear();
+    },
+    get size() {
+      return byKey.size;
+    }
+  };
+}
+
+// src/live/store.ts
+function createFoirLiveStore(options = {}) {
+  const now = options.now ?? (() => Date.now());
+  const entries = /* @__PURE__ */ new Map();
+  const index = createFoirTagIndex();
+  const inFlight = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  const appliedSeq = /* @__PURE__ */ new Map();
+  let epoch = 0;
+  function announce(invalidation) {
+    for (const listener of listeners) listener(invalidation);
+  }
+  function dropKey(key) {
+    entries.delete(key);
+    index.remove(key);
+  }
+  function writeAt(key, write, issuedAt) {
+    if (issuedAt !== epoch) return false;
+    const existing = entries.get(key);
+    const seq = write.seq ?? null;
+    if (existing && existing.seq !== null && seq !== null && seq < existing.seq) {
+      return false;
+    }
+    const tags = write.tags ?? [];
+    entries.set(key, {
+      payload: write.payload,
+      tags,
+      seq,
+      omitted: write.omit ? [...write.omit] : [],
+      storedAt: now()
+    });
+    index.set(key, tags);
+    return true;
+  }
+  return {
+    read(key, readOptions) {
+      const entry = entries.get(key);
+      if (!entry) return void 0;
+      const needs = readOptions?.needs;
+      if (needs && needs.length > 0 && entry.omitted.length > 0) {
+        for (const need of needs) {
+          if (entry.omitted.includes(need)) return void 0;
+        }
+      }
+      return entry;
+    },
+    write(key, write) {
+      return writeAt(key, write, epoch);
+    },
+    drop: dropKey,
+    dedupe(key, run) {
+      const running = inFlight.get(key);
+      if (running) return running;
+      const issuedAt = epoch;
+      const fence = {
+        write: (write) => writeAt(key, write, issuedAt),
+        get current() {
+          return issuedAt === epoch;
+        }
+      };
+      const promise = (async () => run(fence))().finally(() => {
+        if (inFlight.get(key) === promise) inFlight.delete(key);
+      });
+      inFlight.set(key, promise);
+      return promise;
+    },
+    applyRecordChange(event) {
+      const tags = foirTagsForRecordChange(event);
+      const seq = typeof event.seq === "number" ? event.seq : null;
+      if (seq !== null) {
+        const applied = appliedSeq.get(event.recordId);
+        if (applied !== void 0 && seq <= applied) {
+          return { keys: [], tags, ignored: true };
+        }
+        appliedSeq.set(event.recordId, seq);
+      }
+      const keys = index.keysForTags(tags);
+      for (const key of keys) dropKey(key);
+      const invalidation = { keys, tags, ignored: false };
+      if (keys.length > 0) announce(invalidation);
+      return invalidation;
+    },
+    resync() {
+      epoch += 1;
+      const keys = [...entries.keys()];
+      entries.clear();
+      index.clear();
+      appliedSeq.clear();
+      announce({ keys, tags: [], ignored: false });
+    },
+    onInvalidate(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    get size() {
+      return entries.size;
+    },
+    tags: index
+  };
+}
+
+// src/live/resync.ts
+var FOIR_RESYNC_ERROR_CODES = ["cursor_expired", "backlog_too_large"];
+function foirRequiresResync(error) {
+  const code = error.code;
+  return typeof code === "string" && FOIR_RESYNC_ERROR_CODES.includes(code);
+}
+function foirResumeCursor(error) {
+  const resumeFrom = error.graphQLErrors?.[0]?.extensions?.resumeFrom;
+  return typeof resumeFrom === "number" && Number.isSafeInteger(resumeFrom) && resumeFrom > 0 ? resumeFrom : null;
+}
+
+// src/live/reconcile.ts
+var RECORD_TAG_PREFIX2 = "rec:";
+function foirHeldRecordIds(index, modelKey) {
+  const ids2 = /* @__PURE__ */ new Set();
+  for (const key of index.keysForTags([foirModelTag(modelKey)])) {
+    for (const tag of index.tagsFor(key)) {
+      if (tag.startsWith(RECORD_TAG_PREFIX2)) ids2.add(tag.slice(RECORD_TAG_PREFIX2.length));
+    }
+  }
+  return [...ids2];
+}
+var DEFAULT_BATCH_SIZE = 200;
+function createFoirReconciler(options) {
+  const batchSize = options.batchSize && options.batchSize > 0 ? options.batchSize : DEFAULT_BATCH_SIZE;
+  const inFlight = /* @__PURE__ */ new Map();
+  async function run(modelKey) {
+    const held = [...new Set(options.heldIds?.(modelKey) ?? [])];
+    if (held.length === 0) return [];
+    const visible = /* @__PURE__ */ new Set();
+    for (let i = 0; i < held.length; i += batchSize) {
+      const batch = held.slice(i, i + batchSize);
+      let answer;
+      try {
+        answer = await options.resolve(modelKey, batch);
+      } catch (error) {
+        options.onError?.(error, modelKey);
+        return [];
+      }
+      for (const id of answer) visible.add(id);
+    }
+    const gone = held.filter((id) => !visible.has(id));
+    if (gone.length > 0) options.onGone(modelKey, gone);
+    return gone;
+  }
+  return {
+    reconcile(modelKey) {
+      const existing = inFlight.get(modelKey);
+      if (existing) return existing;
+      const promise = run(modelKey).finally(() => {
+        inFlight.delete(modelKey);
+      });
+      inFlight.set(modelKey, promise);
+      return promise;
+    }
+  };
+}
+function foirTagsForGoneRecords(modelKey, goneIds) {
+  if (goneIds.length === 0) return [];
+  return [...goneIds.map(foirRecordTag), foirModelTag(modelKey)];
+}
+
+// src/live/manager.ts
+function createFoirLiveManager(options) {
+  const watches = /* @__PURE__ */ new Map();
+  function open(modelKey, watch) {
+    const after = watch.cursor ?? void 0;
+    watch.subscription = options.subscribe(
+      modelKey,
+      after === void 0 ? {} : { after },
+      {
+        onData: (event) => {
+          if (typeof event.seq === "number" && (watch.cursor === null || event.seq > watch.cursor)) {
+            watch.cursor = event.seq;
+          }
+          options.onChange(event);
+        },
+        onError: (error) => {
+          if (foirRequiresResync(error)) {
+            watch.cursor = null;
+            options.onResync?.(error, modelKey);
+            return;
+          }
+          options.onError?.(error, modelKey);
+        },
+        onReconnect: () => {
+          resume(modelKey);
+        }
+      }
+    );
+  }
+  function resume(modelKey) {
+    const watch = watches.get(modelKey);
+    if (!watch || watch.count === 0 || watch.resuming) return;
+    watch.resuming = true;
+    try {
+      watch.subscription?.unsubscribe();
+      watch.subscription = null;
+      open(modelKey, watch);
+    } finally {
+      watch.resuming = false;
+    }
+    options.reconcile?.(modelKey);
+  }
+  return {
+    retain(modelKey) {
+      let watch = watches.get(modelKey);
+      if (!watch) {
+        watch = { count: 0, subscription: null, cursor: null, resuming: false };
+        watches.set(modelKey, watch);
+      }
+      watch.count += 1;
+      if (watch.count === 1) open(modelKey, watch);
+      let released = false;
+      return () => {
+        if (released) return;
+        released = true;
+        const current = watches.get(modelKey);
+        if (!current) return;
+        current.count -= 1;
+        if (current.count > 0) return;
+        current.subscription?.unsubscribe();
+        current.subscription = null;
+      };
+    },
+    cursorFor(modelKey) {
+      return watches.get(modelKey)?.cursor ?? null;
+    },
+    watchers(modelKey) {
+      return watches.get(modelKey)?.count ?? 0;
+    },
+    get watching() {
+      return [...watches.entries()].filter(([, w]) => w.subscription !== null).map(([k]) => k);
+    },
+    dispose() {
+      for (const watch of watches.values()) {
+        watch.subscription?.unsubscribe();
+        watch.subscription = null;
+        watch.count = 0;
+      }
+      watches.clear();
+    }
+  };
+}
+
+// src/live/tanstack.ts
+var FOIR_QUERY_KEY_ROOT = "foir";
+function foirQueryKeys(call) {
+  const target = "model" in call ? call.model : call.namespace;
+  return [FOIR_QUERY_KEY_ROOT, target, call.op, foirQueryKey(call)];
+}
+function foirModelQueryKey(modelKey) {
+  return [FOIR_QUERY_KEY_ROOT, modelKey];
+}
+function applyFoirRecordChange(queryClient, event, options = {}) {
+  const mode = options.mode ?? "auto";
+  const idField = options.idField ?? "_id";
+  const effect = {
+    invalidated: [],
+    removed: [],
+    created: event.action === "created",
+    totalCountStale: event.action === "created" || event.action === "deleted"
+  };
+  if (mode === "off" || mode === "notify") return effect;
+  const modelKey = foirModelQueryKey(event.modelKey);
+  if (event.action === "deleted") {
+    const removed = [];
+    queryClient.setQueriesData({ queryKey: modelKey }, (previous) => {
+      const next = withoutRecord(previous, event.recordId, idField);
+      return next.changed ? next.value : previous;
+    });
+    for (const [key, value] of queryClient.getQueriesData({ queryKey: modelKey })) {
+      if (!containsRecord(value, event.recordId, idField)) removed.push(key);
+    }
+    return { ...effect, removed };
+  }
+  if (event.action === "updated") {
+    const invalidated = [];
+    const invalidate = options.invalidate ?? ((key) => {
+      queryClient.invalidateQueries({ queryKey: key, exact: true });
+    });
+    for (const [key, value] of queryClient.getQueriesData({ queryKey: modelKey })) {
+      if (!containsRecord(value, event.recordId, idField)) continue;
+      invalidate(key);
+      invalidated.push(key);
+    }
+    return { ...effect, invalidated };
+  }
+  return effect;
+}
+function foirTagsForQueryInvalidation(event) {
+  return event.action === "updated" ? [foirRecordTag(event.recordId)] : [foirRecordTag(event.recordId), foirModelTag(event.modelKey)];
+}
+function ids(value, idField) {
+  const page = value;
+  if (!page || typeof page !== "object") return [];
+  const out = [];
+  for (const edge of page.edges ?? []) {
+    const id = edge?.node?.[idField];
+    if (typeof id === "string") out.push(id);
+  }
+  for (const node of page.nodes ?? []) {
+    const id = node?.[idField];
+    if (typeof id === "string") out.push(id);
+  }
+  const own = page[idField];
+  if (typeof own === "string") out.push(own);
+  return out;
+}
+function containsRecord(value, recordId, idField) {
+  return ids(value, idField).includes(recordId);
+}
+function withoutRecord(value, recordId, idField) {
+  const page = value;
+  if (!page || typeof page !== "object") return { value, changed: false };
+  let changed = false;
+  const next = { ...page };
+  if (Array.isArray(page.edges)) {
+    const edges = page.edges.filter(
+      (edge) => edge?.node?.[idField] !== recordId
+    );
+    if (edges.length !== page.edges.length) {
+      next.edges = edges;
+      changed = true;
+    }
+  }
+  if (Array.isArray(page.nodes)) {
+    const nodes = page.nodes.filter(
+      (node) => node?.[idField] !== recordId
+    );
+    if (nodes.length !== page.nodes.length) {
+      next.nodes = nodes;
+      changed = true;
+    }
+  }
+  return changed ? { value: next, changed: true } : { value, changed: false };
+}
+
+// src/live/coalesce.ts
+var DEFAULT_WINDOW_MS = 25;
+var DEFAULT_MAX_CONCURRENT = 4;
+function createFoirCoalescer(options) {
+  const windowMs = options.windowMs ?? DEFAULT_WINDOW_MS;
+  const maxConcurrent = Math.max(1, options.maxConcurrent ?? DEFAULT_MAX_CONCURRENT);
+  const timers = options.timers ?? {
+    setTimeout: (fn, ms) => setTimeout(fn, ms),
+    clearTimeout: (handle) => clearTimeout(handle)
+  };
+  const waiting = /* @__PURE__ */ new Set();
+  const running = /* @__PURE__ */ new Set();
+  const superseded = /* @__PURE__ */ new Set();
+  let timer = null;
+  let idle = [];
+  let disposed = false;
+  function settleIdle() {
+    if (waiting.size > 0 || running.size > 0 || timer !== null) return;
+    const waiters = idle;
+    idle = [];
+    for (const resolve of waiters) resolve();
+  }
+  function pump() {
+    while (running.size < maxConcurrent && waiting.size > 0) {
+      const key = waiting.values().next().value;
+      waiting.delete(key);
+      running.add(key);
+      void start(key);
+    }
+    settleIdle();
+  }
+  async function start(key) {
+    try {
+      await options.run(key);
+    } catch (error) {
+      options.onError?.(error, key);
+    } finally {
+      running.delete(key);
+      if (superseded.delete(key) && !disposed) {
+        waiting.add(key);
+      }
+      pump();
+    }
+  }
+  function arm() {
+    if (timer !== null || disposed) return;
+    timer = timers.setTimeout(() => {
+      timer = null;
+      pump();
+    }, windowMs);
+  }
+  return {
+    invalidate(key) {
+      if (disposed) return;
+      if (running.has(key)) {
+        superseded.add(key);
+        return;
+      }
+      waiting.add(key);
+      arm();
+    },
+    async flush() {
+      if (timer !== null) {
+        timers.clearTimeout(timer);
+        timer = null;
+      }
+      pump();
+      if (waiting.size === 0 && running.size === 0) return;
+      await new Promise((resolve) => idle.push(resolve));
+    },
+    get pending() {
+      return waiting.size;
+    },
+    get inFlight() {
+      return running.size;
+    },
+    dispose() {
+      disposed = true;
+      if (timer !== null) {
+        timers.clearTimeout(timer);
+        timer = null;
+      }
+      waiting.clear();
+      superseded.clear();
+      settleIdle();
+    }
+  };
+}
+
+// src/live/drift.ts
+function foirDriftIsActionable(drift) {
+  return Number.isFinite(drift.generated) && Number.isFinite(drift.server) && drift.generated !== drift.server;
+}
+function createFoirDriftHandler(options) {
+  return (drift) => {
+    if (!foirDriftIsActionable(drift)) {
+      options.onIgnored?.(drift);
+      return;
+    }
+    options.resync(drift);
+  };
+}
+export {
+  FOIR_CACHE_TAGS_HEADER,
+  FOIR_PROJECT_SEQ_HEADER,
+  FOIR_QUERY_KEY_ROOT,
+  FOIR_RESYNC_ERROR_CODES,
+  FOIR_SURROGATE_KEY_HEADER,
+  FOIR_WRITE_TOKEN_HEADER,
+  applyFoirRecordChange,
+  createFoirCoalescer,
+  createFoirDriftHandler,
+  createFoirLiveManager,
+  createFoirLiveStore,
+  createFoirReconciler,
+  createFoirTagIndex,
+  foirDecimalKey,
+  foirDriftIsActionable,
+  foirHeldRecordIds,
+  foirModelQueryKey,
+  foirModelTag,
+  foirQueryKey,
+  foirQueryKeys,
+  foirRecordTag,
+  foirRequiresResync,
+  foirResumeCursor,
+  foirStableKey,
+  foirTagsForGoneRecords,
+  foirTagsForQueryInvalidation,
+  foirTagsForRecordChange,
+  foirWriteTokenHeaders,
+  readFoirLiveHeaders,
+  readFoirWriteToken
+};