@signalium/query 1.0.12 → 1.0.14

package/dist/cjs/development/index.js

@@ -0,0 +1,2985 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const signalium = require("signalium");
+const utils = require("signalium/utils");
+var RefetchInterval = /* @__PURE__ */ ((RefetchInterval2) => {
+  RefetchInterval2[RefetchInterval2["Every1Second"] = 1e3] = "Every1Second";
+  RefetchInterval2[RefetchInterval2["Every5Seconds"] = 5e3] = "Every5Seconds";
+  RefetchInterval2[RefetchInterval2["Every10Seconds"] = 1e4] = "Every10Seconds";
+  RefetchInterval2[RefetchInterval2["Every30Seconds"] = 3e4] = "Every30Seconds";
+  RefetchInterval2[RefetchInterval2["Every1Minute"] = 6e4] = "Every1Minute";
+  RefetchInterval2[RefetchInterval2["Every5Minutes"] = 3e5] = "Every5Minutes";
+  return RefetchInterval2;
+})(RefetchInterval || {});
+var NetworkMode = /* @__PURE__ */ ((NetworkMode2) => {
+  NetworkMode2["Always"] = "always";
+  NetworkMode2["Online"] = "online";
+  NetworkMode2["OfflineFirst"] = "offlineFirst";
+  return NetworkMode2;
+})(NetworkMode || {});
+var Mask = /* @__PURE__ */ ((Mask2) => {
+  Mask2[Mask2["UNDEFINED"] = 1] = "UNDEFINED";
+  Mask2[Mask2["NULL"] = 2] = "NULL";
+  Mask2[Mask2["NUMBER"] = 4] = "NUMBER";
+  Mask2[Mask2["STRING"] = 8] = "STRING";
+  Mask2[Mask2["BOOLEAN"] = 16] = "BOOLEAN";
+  Mask2[Mask2["OBJECT"] = 32] = "OBJECT";
+  Mask2[Mask2["ARRAY"] = 64] = "ARRAY";
+  Mask2[Mask2["ID"] = 128] = "ID";
+  Mask2[Mask2["RECORD"] = 256] = "RECORD";
+  Mask2[Mask2["UNION"] = 512] = "UNION";
+  Mask2[Mask2["ENTITY"] = 1024] = "ENTITY";
+  Mask2[Mask2["HAS_SUB_ENTITY"] = 2048] = "HAS_SUB_ENTITY";
+  Mask2[Mask2["HAS_NUMBER_FORMAT"] = 4096] = "HAS_NUMBER_FORMAT";
+  Mask2[Mask2["HAS_STRING_FORMAT"] = 8192] = "HAS_STRING_FORMAT";
+  Mask2[Mask2["PARSE_RESULT"] = 16384] = "PARSE_RESULT";
+  return Mask2;
+})(Mask || {});
+const ARRAY_KEY = Symbol("array");
+const RECORD_KEY = Symbol("record");
+const entries$2 = Object.entries;
+const isArray$2 = Array.isArray;
+class ValidatorDef {
+  kind;
+  mask;
+  _optional;
+  _nullable;
+  _nullish;
+  _shapeKey = void 0;
+  _shape;
+  subEntityPaths = void 0;
+  typenameField = void 0;
+  typenameValue = void 0;
+  idField = void 0;
+  values = void 0;
+  /**
+   * Lazy factory function for creating entity methods.
+   * Evaluated once during reifyShape() and cached in _methods.
+   */
+  _methodsFactory = void 0;
+  /**
+   * Cached methods object from evaluating _methodsFactory.
+   * Populated during reifyShape() - the same methods object is shared across all proxies,
+   * but each proxy binds its own reactive method wrappers.
+   */
+  _methods = void 0;
+  /**
+   * Entity configuration including stream options.
+   */
+  _entityConfig = void 0;
+  constructor(kind, mask, shape, values = void 0) {
+    this.kind = kind;
+    this.mask = mask;
+    this._shape = shape;
+    this.values = values;
+  }
+  static cloneWith(def, mask, values = void 0) {
+    const newDef = new ValidatorDef(def.kind, mask | def.mask, def._shape, values);
+    newDef.subEntityPaths = def.subEntityPaths;
+    newDef.values = def.values;
+    newDef.typenameField = def.typenameField;
+    newDef.typenameValue = def.typenameValue;
+    newDef.idField = def.idField;
+    newDef._methodsFactory = def._methodsFactory;
+    newDef._methods = def._methods;
+    newDef._entityConfig = def._entityConfig;
+    return newDef;
+  }
+  reifyShape() {
+    if (this._shapeKey === void 0) {
+      switch (this.kind) {
+        case 5: {
+          const shape = this._shape();
+          this._shape = reifyObjectShape(this, shape);
+          if (this._methodsFactory && !this._methods) {
+            this._methods = this._methodsFactory();
+          }
+          break;
+        }
+        case 0:
+          this._shape = reifyObjectShape(this, this._shape);
+          break;
+        case 1:
+          this._shape = reifyUnionShape(this, this._shape);
+          break;
+        case 3:
+        case 4:
+        case 6: {
+          const shape = this._shape;
+          let shapeKey;
+          if (shape instanceof ValidatorDef) {
+            shapeKey = shape.shapeKey;
+            if (shape.mask & (Mask.ENTITY | Mask.HAS_SUB_ENTITY)) {
+              this.mask |= Mask.HAS_SUB_ENTITY;
+            }
+          } else if (shape instanceof CaseInsensitiveSet) {
+            shapeKey = utils.hashValue(Array.from(shape));
+          } else {
+            shapeKey = utils.hashValue(shape);
+          }
+          this._shapeKey = utils.hashValue([this.kind, this.mask, this.values, shapeKey]);
+          break;
+        }
+      }
+    }
+  }
+  get shape() {
+    this.reifyShape();
+    return this._shape;
+  }
+  get methods() {
+    this.reifyShape();
+    return this._methods;
+  }
+  get shapeKey() {
+    this.reifyShape();
+    return this._shapeKey;
+  }
+  set shapeKey(key) {
+    this._shapeKey = key >>> 0;
+  }
+  get optional() {
+    if (this._optional === void 0) {
+      this._optional = ValidatorDef.cloneWith(this, Mask.UNDEFINED);
+    }
+    return this._optional;
+  }
+  get nullable() {
+    if (this._nullable === void 0) {
+      this._nullable = ValidatorDef.cloneWith(this, Mask.NULL);
+    }
+    return this._nullable;
+  }
+  get nullish() {
+    if (this._nullish === void 0) {
+      this._nullish = ValidatorDef.cloneWith(this, Mask.UNDEFINED | Mask.NULL);
+    }
+    return this._nullish;
+  }
+  /**
+   * Creates a new ValidatorDef that extends this one with additional fields and optional methods.
+   * Only valid for ENTITY and OBJECT types.
+   * Prevents overriding of existing fields including id and typename.
+   *
+   * For entities, accepts a function that returns the new fields (lazy reification).
+   * For objects, accepts the new fields directly.
+   *
+   * @param newFieldsOrGetter - New fields to add (lazy function for entities, direct object for objects)
+   * @param newMethodsGetter - Optional lazy factory returning new methods to add (entities only, merged with existing)
+   */
+  extend(newFieldsOrGetter, newMethodsGetter) {
+    if (this.kind !== 5 && this.kind !== 0) {
+      throw new Error("extend() can only be called on Entity or Object types");
+    }
+    if (this.kind === 5) {
+      const newFieldsGetter = newFieldsOrGetter;
+      const parentMethodsFactory = this._methodsFactory;
+      const extendedDef = new ValidatorDef(5, this.mask, () => {
+        const existingShape = this.shape;
+        const newFields = newFieldsGetter();
+        for (const key of Object.keys(newFields)) {
+          if (key in existingShape) {
+            throw new Error(`Cannot extend: field '${key}' already exists in type definition`);
+          }
+        }
+        return { ...existingShape, ...newFields };
+      });
+      if (parentMethodsFactory || newMethodsGetter) {
+        extendedDef._methodsFactory = () => {
+          const parentMethods = parentMethodsFactory ? parentMethodsFactory() : {};
+          const newMethods = newMethodsGetter ? newMethodsGetter() : {};
+          return { ...parentMethods, ...newMethods };
+        };
+      }
+      extendedDef._entityConfig = this._entityConfig;
+      return extendedDef;
+    } else {
+      this.reifyShape();
+      const existingShape = this._shape;
+      const newFields = newFieldsOrGetter;
+      for (const key of Object.keys(newFields)) {
+        if (key in existingShape) {
+          throw new Error(`Cannot extend: field '${key}' already exists in type definition`);
+        }
+      }
+      return new ValidatorDef(0, this.mask, { ...existingShape, ...newFields });
+    }
+  }
+}
+class CaseInsensitiveSet extends Set {
+  lowercaseMap;
+  // lowercase -> canonical (strings only)
+  constructor(values) {
+    super(values);
+    this.lowercaseMap = /* @__PURE__ */ new Map();
+    for (const value of values) {
+      if (typeof value === "string") {
+        const lowercase = value.toLowerCase();
+        const existing = this.lowercaseMap.get(lowercase);
+        if (existing !== void 0) {
+          throw new Error(
+            `Case-insensitive enum cannot have multiple values with the same lowercase form: '${existing}' and '${value}' both become '${lowercase}'`
+          );
+        }
+        this.lowercaseMap.set(lowercase, value);
+      }
+    }
+  }
+  /**
+   * Check if a value exists in the set (case-insensitively for strings).
+   * Used for backwards compatibility with Set-based checks.
+   */
+  has(value) {
+    return this.get(value) !== void 0;
+  }
+  /**
+   * Get the canonical value for a given input.
+   * For strings, performs case-insensitive lookup and returns the canonical casing.
+   * For numbers/booleans, performs exact match.
+   * Returns undefined if no match is found.
+   */
+  get(value) {
+    if (typeof value === "string") {
+      return this.lowercaseMap.get(value.toLowerCase());
+    }
+    if (super.has(value)) {
+      return value;
+    }
+    return void 0;
+  }
+}
+function defineArray(shape) {
+  return new ValidatorDef(3, Mask.ARRAY, shape);
+}
+function defineRecord(shape) {
+  return new ValidatorDef(4, Mask.RECORD | Mask.OBJECT, shape);
+}
+function defineParseResult(innerType) {
+  return new ValidatorDef(
+    6,
+    Mask.PARSE_RESULT,
+    innerType
+  );
+}
+function defineObject(shape) {
+  return new ValidatorDef(0, Mask.OBJECT, shape);
+}
+function defineUnion(...types) {
+  let mask = 0;
+  let definition;
+  let shape;
+  let values;
+  for (const type of types) {
+    if (typeof type === "number") {
+      mask |= type;
+      continue;
+    }
+    if (type instanceof Set) {
+      if (values === void 0) {
+        values = new Set(type);
+      } else {
+        for (const val of type) {
+          values.add(val);
+        }
+      }
+      continue;
+    }
+    if (definition === void 0) {
+      definition = type;
+      continue;
+    }
+    if (shape === void 0) {
+      shape = [definition];
+    }
+    shape.push(type);
+  }
+  if (definition === void 0) {
+    if (values === void 0) {
+      return mask;
+    }
+    if (mask === 0) {
+      return values;
+    }
+    return new ValidatorDef(2, mask | Mask.UNION, void 0, values);
+  }
+  if (shape === void 0) {
+    return ValidatorDef.cloneWith(definition, mask | Mask.UNION, values);
+  }
+  return new ValidatorDef(1, mask | Mask.UNION, shape, values);
+}
+function defineNullish(type) {
+  if (typeof type === "number") {
+    return type | Mask.UNDEFINED | Mask.NULL;
+  }
+  if (type instanceof Set) {
+    return defineUnion(type, Mask.UNDEFINED, Mask.NULL);
+  }
+  return type.nullish;
+}
+function defineOptional(type) {
+  if (typeof type === "number") {
+    return type | Mask.UNDEFINED;
+  }
+  if (type instanceof Set) {
+    return defineUnion(type, Mask.UNDEFINED);
+  }
+  return type.optional;
+}
+function defineNullable(type) {
+  if (typeof type === "number") {
+    return type | Mask.NULL;
+  }
+  if (type instanceof Set) {
+    return defineUnion(type, Mask.NULL);
+  }
+  return type.nullable;
+}
+function reifyObjectShape(def, shape) {
+  let shapeKey = utils.hashValue([def.mask, def.values]);
+  for (const [key, value] of entries$2(shape)) {
+    switch (typeof value) {
+      case "number":
+        if ((value & Mask.ID) !== 0) {
+          if (def.idField !== void 0) {
+            throw new Error(`Duplicate id field: ${key}`);
+          }
+          def.idField = key;
+        }
+        shapeKey += utils.hashValue(key) ^ value;
+        break;
+      case "string":
+        if (def.typenameField !== void 0 && def.typenameField !== key) {
+          throw new Error(`Duplicate typename field: ${key}`);
+        }
+        def.typenameField = key;
+        def.typenameValue = value;
+        shapeKey += utils.hashValue(key) ^ utils.hashValue(value);
+        break;
+      case "object":
+        if (value instanceof CaseInsensitiveSet) {
+          shapeKey ^= utils.hashValue(key) ^ utils.hashValue(Array.from(value));
+          break;
+        }
+        if (value instanceof Set) {
+          shapeKey ^= utils.hashValue(key) ^ utils.hashValue(value);
+          break;
+        }
+        shapeKey += utils.hashValue(key) ^ value.shapeKey;
+        if (value.mask & (Mask.ENTITY | Mask.HAS_SUB_ENTITY)) {
+          def.mask |= Mask.HAS_SUB_ENTITY;
+          if (def.subEntityPaths === void 0) {
+            def.subEntityPaths = key;
+          } else if (isArray$2(def.subEntityPaths)) {
+            def.subEntityPaths.push(key);
+          } else {
+            def.subEntityPaths = [def.subEntityPaths, key];
+          }
+        }
+        break;
+    }
+  }
+  def.shapeKey = shapeKey >>> 0;
+  return shape;
+}
+function reifyUnionShape(def, defs) {
+  let mask = def.mask;
+  let shape = /* @__PURE__ */ Object.create(null);
+  let unionTypenameField;
+  let shapeKey = utils.hashValue([mask, def.values]);
+  for (const nestedDef of defs) {
+    const nestedMask = nestedDef.mask;
+    mask |= nestedMask;
+    shapeKey += nestedDef.shapeKey;
+    if ((nestedMask & Mask.UNION) !== 0) {
+      const nestedUnion = nestedDef;
+      if (nestedUnion.typenameField !== void 0) {
+        if (unionTypenameField !== void 0 && unionTypenameField !== nestedUnion.typenameField) {
+          throw new Error(
+            `Union typename field conflict: Cannot merge unions with different typename fields ('${unionTypenameField}' vs '${nestedUnion.typenameField}')`
+          );
+        }
+        unionTypenameField = nestedUnion.typenameField;
+      }
+      const nestedShape = nestedUnion.shape;
+      if (nestedShape !== void 0) {
+        for (const key of [...Object.keys(nestedShape), ARRAY_KEY, RECORD_KEY]) {
+          const value = nestedShape[key];
+          if (shape[key] !== void 0 && shape[key] !== value) {
+            throw new Error(
+              `Union merge conflict: Duplicate typename value '${String(key)}' found when merging nested unions (${String(shape[key])} vs ${String(value)})`
+            );
+          }
+          shape[key] = value;
+        }
+      }
+    } else if ((nestedMask & Mask.ARRAY) !== 0) {
+      if (shape[ARRAY_KEY] !== void 0) {
+        throw new Error("Array shape already defined");
+      }
+      shape[ARRAY_KEY] = nestedDef.shape;
+    } else if ((nestedMask & Mask.RECORD) !== 0) {
+      if (shape[RECORD_KEY] !== void 0) {
+        throw new Error("Record shape already defined");
+      }
+      shape[RECORD_KEY] = nestedDef.shape;
+    } else {
+      const typenameField = nestedDef.typenameField;
+      const typename = nestedDef.typenameValue;
+      if (typename === void 0) {
+        throw new Error(
+          "Object definitions must have a typename to be in a union with other objects, records, or arrays"
+        );
+      }
+      if (unionTypenameField !== void 0 && typenameField !== unionTypenameField) {
+        throw new Error("Object definitions must have the same typename field to be in the same union");
+      }
+      unionTypenameField = typenameField;
+      shape[typename] = nestedDef;
+    }
+  }
+  def.typenameField = unionTypenameField;
+  def.shapeKey = shapeKey >>> 0;
+  def.mask = mask;
+  return shape;
+}
+function defineTypename(value) {
+  return value;
+}
+function defineConst(value) {
+  return /* @__PURE__ */ new Set([value]);
+}
+const defineEnum = ((...values) => {
+  return new Set(values);
+});
+defineEnum.caseInsensitive = (...values) => {
+  return new CaseInsensitiveSet(values);
+};
+const FORMAT_MASK_SHIFT = 16;
+let nextFormatId = 0;
+const FORMAT_PARSERS = [];
+const FORMAT_MAP = /* @__PURE__ */ new Map();
+const FORMAT_ID_TO_NAME = /* @__PURE__ */ new Map();
+function defineFormatted(format) {
+  const mask = FORMAT_MAP.get(format);
+  if (mask === void 0) {
+    throw new Error(`Format ${format} not registered`);
+  }
+  return mask;
+}
+function getFormat(mask) {
+  const formatId = mask >> FORMAT_MASK_SHIFT;
+  return FORMAT_PARSERS[formatId];
+}
+function getFormatName(mask) {
+  const formatId = mask >> FORMAT_MASK_SHIFT;
+  return FORMAT_ID_TO_NAME.get(formatId);
+}
+function registerFormat(name, type, parse, serialize) {
+  const maskId = nextFormatId++;
+  FORMAT_PARSERS[maskId] = parse;
+  FORMAT_ID_TO_NAME.set(maskId, name);
+  const shiftedId = maskId << FORMAT_MASK_SHIFT;
+  const formatMask = type === Mask.STRING ? Mask.HAS_STRING_FORMAT : Mask.HAS_NUMBER_FORMAT;
+  const mask = shiftedId | type | formatMask;
+  FORMAT_MAP.set(name, mask);
+}
+registerFormat(
+  "date",
+  Mask.STRING,
+  (value) => {
+    const match = value.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+    if (!match) {
+      throw new Error(`Invalid date string: ${value}. Expected YYYY-MM-DD format.`);
+    }
+    const [, year, month, day] = match;
+    const date = new Date(Date.UTC(parseInt(year, 10), parseInt(month, 10) - 1, parseInt(day, 10)));
+    if (isNaN(date.getTime())) {
+      throw new Error(`Invalid date string: ${value}`);
+    }
+    return date;
+  }
+);
+registerFormat(
+  "date-time",
+  Mask.STRING,
+  (value) => {
+    const date = new Date(value);
+    if (isNaN(date.getTime())) {
+      throw new Error(`Invalid date-time string: ${value}`);
+    }
+    return date;
+  }
+);
+function entity(shape, methods, config) {
+  const def = new ValidatorDef(
+    5,
+    // The mask should be OBJECT | ENTITY so that values match when compared
+    Mask.ENTITY | Mask.OBJECT,
+    shape
+  );
+  if (methods) {
+    def._methodsFactory = methods;
+  }
+  if (config) {
+    def._entityConfig = config;
+  }
+  return def;
+}
+const t = {
+  format: defineFormatted,
+  typename: defineTypename,
+  const: defineConst,
+  enum: defineEnum,
+  id: Mask.ID | Mask.STRING | Mask.NUMBER,
+  string: Mask.STRING,
+  number: Mask.NUMBER,
+  boolean: Mask.BOOLEAN,
+  null: Mask.NULL,
+  undefined: Mask.UNDEFINED,
+  array: defineArray,
+  object: defineObject,
+  record: defineRecord,
+  union: defineUnion,
+  nullish: defineNullish,
+  optional: defineOptional,
+  nullable: defineNullable,
+  result: defineParseResult
+};
+function typeToString(type) {
+  if (type instanceof CaseInsensitiveSet) {
+    const values = Array.from(type).map((v) => typeof v === "string" ? `"${v}"` : String(v));
+    return values.join(" | ");
+  }
+  if (type instanceof Set) {
+    const values = Array.from(type).map((v) => typeof v === "string" ? `"${v}"` : String(v));
+    return values.join(" | ");
+  }
+  if (typeof type === "string") {
+    return `"${type}"`;
+  }
+  if (typeof type === "boolean") {
+    return String(type);
+  }
+  if (typeof type === "number") {
+    const hasFormat = (type & (Mask.HAS_STRING_FORMAT | Mask.HAS_NUMBER_FORMAT)) !== 0;
+    if (hasFormat) {
+      const formatName = getFormatName(type);
+      if (formatName) {
+        return `"${formatName}"`;
+      }
+    }
+    const types = [];
+    if (type & Mask.UNDEFINED) types.push("undefined");
+    if (type & Mask.NULL) types.push("null");
+    if (type & Mask.NUMBER) types.push("number");
+    if (type & Mask.STRING) types.push("string");
+    if (type & Mask.BOOLEAN) types.push("boolean");
+    if (type & Mask.OBJECT) types.push("object");
+    if (type & Mask.ARRAY) types.push("array");
+    if (types.length === 0) {
+      return "unknown";
+    }
+    return types.length === 1 ? types[0] : types.join(" | ");
+  }
+  let mask = type.mask;
+  if (mask & Mask.UNION) {
+    const unionType = type;
+    const parts = [];
+    if (unionType.values !== void 0 && unionType.values.size > 0) {
+      for (const val of unionType.values) {
+        const valStr = typeof val === "string" ? `"${val}"` : String(val);
+        parts.push(valStr);
+      }
+    }
+    if (unionType.shape !== void 0) {
+      if (unionType.shape[ARRAY_KEY] !== void 0) {
+        parts.push(`Array<${typeToString(unionType.shape[ARRAY_KEY])}>`);
+      }
+      if (unionType.shape[RECORD_KEY] !== void 0) {
+        parts.push(`Record<string, ${typeToString(unionType.shape[RECORD_KEY])}>`);
+      }
+      for (const [key, value] of Object.entries(unionType.shape)) {
+        if (key !== ARRAY_KEY && key !== RECORD_KEY) {
+          parts.push(key);
+        }
+      }
+    }
+    mask = unionType.mask;
+    const hasFormat = (mask & (Mask.HAS_STRING_FORMAT | Mask.HAS_NUMBER_FORMAT)) !== 0;
+    if (hasFormat) {
+      const formatName = getFormatName(mask);
+      if (formatName) {
+        parts.push(`"${formatName}"`);
+      }
+    }
+    if (mask & Mask.UNDEFINED) parts.push("undefined");
+    if (mask & Mask.NULL) parts.push("null");
+    if (mask & Mask.NUMBER) parts.push("number");
+    if (mask & Mask.STRING) parts.push("string");
+    if (mask & Mask.BOOLEAN) parts.push("boolean");
+    if (parts.length === 0) {
+      return "union";
+    }
+    return parts.join(" | ");
+  }
+  if (mask & Mask.ENTITY) {
+    return `Entity<${type.typenameValue}>`;
+  }
+  if (mask & Mask.ARRAY) {
+    const shape = type.shape;
+    return `Array<${typeToString(shape)}>`;
+  }
+  if (mask & Mask.RECORD) {
+    const shape = type.shape;
+    return `Record<string, ${typeToString(shape)}>`;
+  }
+  if (mask & Mask.OBJECT) {
+    const typename = type.typenameValue;
+    return typename ? `Object<${typename}>` : "object";
+  }
+  return "unknown";
+}
+function typeError(path, expectedType, value) {
+  return new TypeError(
+    `Validation error at ${path}: expected ${typeToString(expectedType)}, got ${typeof value === "object" ? value === null ? "null" : Array.isArray(value) ? "array" : "object" : typeof value}`
+  );
+}
+const isArray$1 = Array.isArray;
+function typeMaskOf(value) {
+  if (value === null) return Mask.NULL;
+  switch (typeof value) {
+    case "number":
+      return Mask.NUMBER;
+    case "string":
+      return Mask.STRING;
+    case "boolean":
+      return Mask.BOOLEAN;
+    case "undefined":
+      return Mask.UNDEFINED;
+    case "object":
+      return isArray$1(value) ? Mask.ARRAY : Mask.OBJECT;
+    default:
+      throw new Error(`Invalid type: ${typeof value}`);
+  }
+}
+function draft(entity2) {
+  return deepClone$1(entity2);
+}
+function deepClone$1(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (isArray$1(value)) {
+    return value.map((item) => deepClone$1(item));
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  if (value instanceof Map) {
+    const clonedMap = /* @__PURE__ */ new Map();
+    for (const [k, v] of value) {
+      clonedMap.set(deepClone$1(k), deepClone$1(v));
+    }
+    return clonedMap;
+  }
+  if (value instanceof Set) {
+    const clonedSet = /* @__PURE__ */ new Set();
+    for (const v of value) {
+      clonedSet.add(deepClone$1(v));
+    }
+    return clonedSet;
+  }
+  const result = {};
+  for (const key of Object.keys(value)) {
+    result[key] = deepClone$1(value[key]);
+  }
+  return result;
+}
+const noopWarn = () => {
+};
+const entries$1 = Object.entries;
+const isArray = Array.isArray;
+const PROXY_ID = /* @__PURE__ */ new WeakMap();
+function parseUnionValue(valueType, value, unionDef, path, warn = noopWarn) {
+  if (valueType === Mask.ARRAY) {
+    const shape = unionDef.shape[ARRAY_KEY];
+    if (shape === void 0 || typeof shape === "number") {
+      return value;
+    }
+    return parseArrayValue(value, shape, path, warn);
+  } else {
+    const typenameField = unionDef.typenameField;
+    const typename = typenameField ? value[typenameField] : void 0;
+    if (typename === void 0 || typeof typename !== "string") {
+      const recordShape = unionDef.shape[RECORD_KEY];
+      if (recordShape === void 0 || typeof recordShape === "number") {
+        throw new Error(
+          `Typename field '${typenameField}' is required for union discrimination but was not found in the data`
+        );
+      }
+      return parseRecordValue(value, recordShape, path, warn);
+    }
+    const matchingDef = unionDef.shape[typename];
+    if (matchingDef === void 0 || typeof matchingDef === "number") {
+      throw new Error(`Unknown typename '${typename}' in union`);
+    }
+    return parseObjectValue(value, matchingDef, path, warn);
+  }
+}
+function parseArrayValue(array, arrayShape, path, warn = noopWarn) {
+  const result = [];
+  for (let i = 0; i < array.length; i++) {
+    try {
+      result.push(parseValue(array[i], arrayShape, `${path}[${i}]`, false, warn));
+    } catch (e) {
+      warn("Failed to parse array item, filtering out", {
+        index: i,
+        value: array[i],
+        error: e instanceof Error ? e.message : String(e)
+      });
+    }
+  }
+  return result;
+}
+function parseRecordValue(record, recordShape, path, warn = noopWarn) {
+  for (const [key, value] of entries$1(record)) {
+    record[key] = parseValue(value, recordShape, `${path}["${key}"]`, false, warn);
+  }
+  return record;
+}
+function parseObjectValue(object, objectShape, path, warn = noopWarn) {
+  if (PROXY_ID.has(object)) {
+    return object;
+  }
+  const shape = objectShape.shape;
+  for (const [key, propShape] of entries$1(shape)) {
+    object[key] = parseValue(object[key], propShape, `${path}.${key}`, false, warn);
+  }
+  return object;
+}
+function parseValue(value, propDef, path, skipFallbacks = false, warn = noopWarn) {
+  if (propDef instanceof CaseInsensitiveSet) {
+    const canonical = propDef.get(value);
+    if (canonical === void 0) {
+      throw typeError(path, propDef, value);
+    }
+    return canonical;
+  }
+  if (propDef instanceof Set) {
+    if (!propDef.has(value)) {
+      throw typeError(path, propDef, value);
+    }
+    return value;
+  }
+  switch (typeof propDef) {
+    case "string":
+      if (value === void 0 || value === null) {
+        return propDef;
+      }
+      if (value !== propDef) {
+        throw typeError(path, propDef, value);
+      }
+      return value;
+    // handle primitives
+    case "number": {
+      let valueType = typeMaskOf(value);
+      if ((propDef & valueType) === 0) {
+        if (!skipFallbacks && (propDef & Mask.UNDEFINED) !== 0) {
+          warn("Invalid value for optional type, defaulting to undefined", { value, path });
+          return void 0;
+        }
+        throw typeError(path, propDef, value);
+      }
+      if ((propDef & (Mask.HAS_STRING_FORMAT | Mask.HAS_NUMBER_FORMAT)) !== 0) {
+        try {
+          return getFormat(propDef)(value);
+        } catch (e) {
+          if (!skipFallbacks && (propDef & Mask.UNDEFINED) !== 0) {
+            warn("Invalid formatted value for optional type, defaulting to undefined", {
+              value,
+              path,
+              error: e instanceof Error ? e.message : String(e)
+            });
+            return void 0;
+          }
+          throw e;
+        }
+      }
+      return value;
+    }
+    // handle complex objects
+    default: {
+      let valueType = typeMaskOf(value);
+      const propMask = propDef.mask;
+      if ((propMask & Mask.PARSE_RESULT) !== 0) {
+        try {
+          const innerResult = parseValue(value, propDef.shape, path, true, warn);
+          return { success: true, value: innerResult };
+        } catch (e) {
+          return { success: false, error: e instanceof Error ? e : new Error(String(e)) };
+        }
+      }
+      if ((propMask & valueType) === 0 && !propDef.values?.has(value)) {
+        if (!skipFallbacks && (propMask & Mask.UNDEFINED) !== 0) {
+          warn("Invalid value for optional type, defaulting to undefined", { value, path });
+          return void 0;
+        }
+        throw typeError(path, propMask, value);
+      }
+      if (valueType < Mask.OBJECT) {
+        if ((propMask & (Mask.HAS_STRING_FORMAT | Mask.HAS_NUMBER_FORMAT)) !== 0) {
+          try {
+            return getFormat(propMask)(value);
+          } catch (e) {
+            if (!skipFallbacks && (propMask & Mask.UNDEFINED) !== 0) {
+              warn("Invalid formatted value for optional type, defaulting to undefined", {
+                value,
+                path,
+                error: e instanceof Error ? e.message : String(e)
+              });
+              return void 0;
+            }
+            throw e;
+          }
+        }
+        return value;
+      }
+      if ((valueType & Mask.UNION) !== 0) {
+        return parseUnionValue(
+          valueType,
+          value,
+          propDef,
+          path,
+          warn
+        );
+      }
+      if (valueType === Mask.ARRAY) {
+        return parseArrayValue(value, propDef.shape, path, warn);
+      }
+      return parseObjectValue(value, propDef, path, warn);
+    }
+  }
+}
+function mergeValues(target, update) {
+  for (const [key, value] of entries$1(update)) {
+    const targetValue = target[key];
+    if (typeof value === "object" && value !== null && !isArray(value) && !PROXY_ID.has(value) && typeof targetValue === "object" && targetValue !== null && !isArray(targetValue) && !PROXY_ID.has(targetValue)) {
+      mergeValues(targetValue, value);
+    } else {
+      target[key] = value;
+    }
+  }
+  return target;
+}
+const CustomNodeInspect = Symbol.for("nodejs.util.inspect.custom");
+function createEntityProxy(id, entityRecord, def, entityRelay, scopeOwner, warn = noopWarn, desc) {
+  const shape = def.shape;
+  const methods = def.methods;
+  const wrappedMethods = /* @__PURE__ */ new Map();
+  const toJSON = () => ({
+    __entityRef: id
+  });
+  let proxy;
+  const handler = {
+    get(target, prop) {
+      if (prop === "toJSON") {
+        return toJSON;
+      }
+      const { data, cache, notifier } = entityRecord;
+      entityRelay?.value;
+      notifier.consume();
+      if (cache.has(prop)) {
+        return cache.get(prop);
+      }
+      if (methods && typeof prop === "string" && prop in methods) {
+        let wrapped = wrappedMethods.get(prop);
+        if (!wrapped) {
+          wrapped = signalium.reactiveMethod(proxy, methods[prop].bind(proxy));
+          wrappedMethods.set(prop, wrapped);
+        }
+        return wrapped;
+      }
+      const value = data[prop];
+      const propDef = shape[prop];
+      if (!Object.hasOwnProperty.call(shape, prop)) {
+        return value;
+      }
+      const parsed = parseValue(value, propDef, `[[${desc}]].${prop}`, false, warn);
+      cache.set(prop, parsed);
+      return parsed;
+    },
+    has(target, prop) {
+      if (methods && typeof prop === "string" && prop in methods) {
+        return true;
+      }
+      return prop in shape;
+    },
+    ownKeys(target) {
+      const keys = Object.keys(shape);
+      const typenameField = def.typenameField;
+      if (typenameField && !keys.includes(typenameField)) {
+        keys.push(typenameField);
+      }
+      if (methods) {
+        for (const methodKey of Object.keys(methods)) {
+          if (!keys.includes(methodKey)) {
+            keys.push(methodKey);
+          }
+        }
+      }
+      return keys;
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      const typenameField = def.typenameField;
+      if (prop in shape || prop === typenameField) {
+        return {
+          enumerable: true,
+          configurable: true
+        };
+      }
+      if (methods && typeof prop === "string" && prop in methods) {
+        return {
+          enumerable: false,
+          configurable: true
+        };
+      }
+      return void 0;
+    }
+  };
+  proxy = new Proxy(
+    {
+      [CustomNodeInspect]: () => {
+        return Object.keys(shape).reduce(
+          (acc, key) => {
+            acc[key] = proxy[key];
+            return acc;
+          },
+          {}
+        );
+      }
+    },
+    handler
+  );
+  PROXY_ID.set(proxy, id);
+  signalium.setScopeOwner(proxy, scopeOwner);
+  return proxy;
+}
+function getProxyId(object) {
+  return PROXY_ID.get(object);
+}
+function deepClone(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => deepClone(item));
+  }
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+  const cloned = {};
+  for (const key of Object.keys(value)) {
+    cloned[key] = deepClone(value[key]);
+  }
+  return cloned;
+}
+class EntityStore {
+  map = /* @__PURE__ */ new Map();
+  queryClient;
+  /**
+   * Tracks pending optimistic updates by entity key.
+   * Each entity can only have one pending update at a time (throws if concurrent).
+   */
+  pendingOptimisticUpdates = /* @__PURE__ */ new Map();
+  constructor(queryClient) {
+    this.queryClient = queryClient;
+  }
+  hasEntity(key) {
+    return this.map.has(key);
+  }
+  getEntity(key) {
+    return this.map.get(key);
+  }
+  getNestedEntityRefIds(key, refIds) {
+    const record = this.getEntity(key);
+    if (record === void 0) {
+      throw new Error(`Entity ${key} not found when getting nested entity ref ids`);
+    }
+    refIds.add(key);
+    record.notifier.consume();
+    if (record.entityRefs !== void 0) {
+      for (const ref of record.entityRefs) {
+        this.getNestedEntityRefIds(ref, refIds);
+      }
+    }
+    return refIds;
+  }
+  hydratePreloadedEntity(key, shape) {
+    const record = this.getEntity(key);
+    if (record === void 0) {
+      throw new Error(`Entity ${key} not found`);
+    }
+    record.proxy = this.createEntityProxy(record, shape);
+    return record;
+  }
+  setPreloadedEntity(key, data) {
+    const record = {
+      key,
+      data,
+      notifier: signalium.notifier(),
+      cache: /* @__PURE__ */ new Map(),
+      id: void 0,
+      proxy: void 0,
+      entityRefs: void 0
+    };
+    this.map.set(key, record);
+    return record;
+  }
+  setEntity(key, obj, shape, entityRefs) {
+    let record = this.map.get(key);
+    if (record === void 0) {
+      record = this.setPreloadedEntity(key, obj);
+      record.proxy = this.createEntityProxy(record, shape);
+    } else {
+      record.data = mergeValues(record.data, obj);
+      record.notifier.notify();
+      record.cache.clear();
+    }
+    record.entityRefs = entityRefs;
+    return record;
+  }
+  // ======================================================
+  // Optimistic Update Tracking
+  // ======================================================
+  /**
+   * Register a pending optimistic update for an entity.
+   * Snapshots the current state and applies the optimistic update.
+   *
+   * @throws Error if the entity already has a pending optimistic update
+   */
+  registerOptimisticUpdate(entityKey, fields) {
+    if (this.pendingOptimisticUpdates.has(entityKey)) {
+      throw new Error(
+        `Cannot apply optimistic update: entity ${entityKey} already has a pending optimistic update from another mutation.`
+      );
+    }
+    const record = this.map.get(entityKey);
+    if (!record) {
+      this.pendingOptimisticUpdates.set(entityKey, { snapshot: {} });
+      return;
+    }
+    const snapshot = deepClone(record.data);
+    this.pendingOptimisticUpdates.set(entityKey, { snapshot });
+    record.data = mergeValues(record.data, fields);
+    record.cache.clear();
+    queueMicrotask(() => {
+      record.notifier.notify();
+    });
+  }
+  /**
+   * Revert the optimistic update for an entity, restoring its snapshot.
+   * Called when a mutation fails.
+   */
+  revertOptimisticUpdate(entityKey) {
+    const pending = this.pendingOptimisticUpdates.get(entityKey);
+    if (!pending) {
+      return;
+    }
+    const record = this.map.get(entityKey);
+    if (record && Object.keys(pending.snapshot).length > 0) {
+      record.data = pending.snapshot;
+      record.cache.clear();
+      queueMicrotask(() => {
+        record.notifier.notify();
+      });
+    }
+    this.pendingOptimisticUpdates.delete(entityKey);
+  }
+  /**
+   * Clear the optimistic update for an entity without reverting.
+   * Called when a mutation succeeds (the optimistic update is now confirmed).
+   */
+  clearOptimisticUpdates(entityKey) {
+    this.pendingOptimisticUpdates.delete(entityKey);
+  }
+  createEntityProxy(record, shape) {
+    const idField = shape.idField;
+    if (idField === void 0) {
+      throw new Error(`Entity id field is required ${shape.typenameValue}`);
+    }
+    const id = record.data[idField];
+    if (typeof id !== "string" && typeof id !== "number") {
+      console.log(record.data);
+      throw new Error(`Entity id must be string or number: ${shape.typenameValue}`);
+    }
+    record.id = id;
+    let entityRelay;
+    const entityConfig = shape._entityConfig;
+    if (entityConfig?.stream) {
+      entityRelay = signalium.relay((state) => {
+        const context = this.queryClient.getContext();
+        const onUpdate = (update) => {
+          const currentValue = record.data;
+          const merged = mergeValues(currentValue, update);
+          record.data = merged;
+          record.notifier.notify();
+          record.cache.clear();
+        };
+        const unsubscribe = entityConfig.stream.subscribe(context, id, onUpdate);
+        state.value = record.proxy;
+        return unsubscribe;
+      });
+    }
+    const warn = this.queryClient.getContext().log?.warn;
+    return createEntityProxy(record.key, record, shape, entityRelay, this.queryClient, warn);
+  }
+}
+class NetworkManager {
+  onlineSignal;
+  manualOverride = void 0;
+  eventListenersAttached = false;
+  constructor(initialStatus) {
+    const initialOnlineStatus = initialStatus ?? this.detectOnlineStatus();
+    this.onlineSignal = signalium.signal(initialOnlineStatus);
+    if (this.canAttachListeners()) {
+      this.attachEventListeners();
+    }
+  }
+  /**
+   * Returns true if the network is currently online
+   */
+  get isOnline() {
+    if (this.manualOverride !== void 0) {
+      return this.manualOverride;
+    }
+    return this.onlineSignal.value;
+  }
+  /**
+   * Manually set the network status (useful for testing)
+   */
+  setNetworkStatus(online) {
+    this.manualOverride = online;
+    this.onlineSignal.value = online;
+  }
+  /**
+   * Clear manual override and return to automatic detection
+   */
+  clearManualOverride() {
+    this.manualOverride = void 0;
+    this.onlineSignal.value = this.detectOnlineStatus();
+  }
+  /**
+   * Get the reactive signal for online status
+   * This allows reactive functions to depend on network status
+   */
+  getOnlineSignal() {
+    return this.onlineSignal;
+  }
+  /**
+   * Detect current online status from the environment
+   */
+  detectOnlineStatus() {
+    if (typeof navigator !== "undefined" && "onLine" in navigator) {
+      return navigator.onLine;
+    }
+    return true;
+  }
+  /**
+   * Check if we can attach event listeners (browser or React Native)
+   */
+  canAttachListeners() {
+    return typeof window !== "undefined" && typeof window.addEventListener === "function";
+  }
+  /**
+   * Attach event listeners for online/offline events
+   */
+  attachEventListeners() {
+    if (this.eventListenersAttached) {
+      return;
+    }
+    const handleOnline = () => {
+      if (this.manualOverride === void 0) {
+        this.onlineSignal.value = true;
+      }
+    };
+    const handleOffline = () => {
+      if (this.manualOverride === void 0) {
+        this.onlineSignal.value = false;
+      }
+    };
+    window.addEventListener("online", handleOnline);
+    window.addEventListener("offline", handleOffline);
+    this.eventListenersAttached = true;
+  }
+}
+class NoOpNetworkManager {
+  static onlineSignal = signalium.signal(true);
+  get isOnline() {
+    return true;
+  }
+  setNetworkStatus(_online) {
+  }
+  clearManualOverride() {
+  }
+  getOnlineSignal() {
+    return NoOpNetworkManager.onlineSignal;
+  }
+  destroy() {
+  }
+}
+const defaultNetworkManager = new NetworkManager();
+const NetworkManagerContext = signalium.context(defaultNetworkManager);
+const entries = Object.entries;
+function parseUnionEntities(valueType, value, unionDef, queryClient, entityRefs) {
+  if (valueType === Mask.ARRAY) {
+    const shape = unionDef.shape[ARRAY_KEY];
+    if (shape === void 0 || typeof shape === "number") {
+      return value;
+    }
+    return parseArrayEntities(
+      value,
+      { mask: Mask.ARRAY, shape, values: void 0 },
+      queryClient,
+      entityRefs
+    );
+  } else {
+    const typenameField = unionDef.typenameField;
+    const typename = typenameField ? value[typenameField] : void 0;
+    if (typename === void 0 || typeof typename !== "string") {
+      const recordShape = unionDef.shape[RECORD_KEY];
+      if (recordShape === void 0 || typeof recordShape === "number") {
+        throw new Error(
+          `Typename field '${typenameField}' is required for union discrimination but was not found in the data`
+        );
+      }
+      return parseRecordEntities(
+        value,
+        recordShape,
+        queryClient,
+        entityRefs
+      );
+    }
+    const matchingDef = unionDef.shape[typename];
+    if (matchingDef === void 0 || typeof matchingDef === "number") {
+      throw new Error(`Unknown typename '${typename}' in union`);
+    }
+    return parseObjectEntities(
+      value,
+      matchingDef,
+      queryClient,
+      entityRefs
+    );
+  }
+}
+function parseArrayEntities(array, arrayShape, queryClient, entityRefs) {
+  const result = [];
+  for (let i = 0; i < array.length; i++) {
+    try {
+      result.push(parseEntities(array[i], arrayShape, queryClient, entityRefs));
+    } catch (e) {
+      queryClient.getContext().log?.warn?.("Failed to parse array item, filtering out", {
+        index: i,
+        value: array[i],
+        error: e instanceof Error ? e.message : String(e)
+      });
+    }
+  }
+  return result;
+}
+function parseRecordEntities(record, recordShape, queryClient, entityRefs) {
+  if (typeof recordShape === "number") {
+    return record;
+  }
+  for (const [key, value] of entries(record)) {
+    record[key] = parseEntities(value, recordShape, queryClient, entityRefs);
+  }
+  return record;
+}
+function parseObjectEntities(obj, objectShape, queryClient, entityRefs) {
+  const entityRefId = obj.__entityRef;
+  if (typeof entityRefId === "number") {
+    return queryClient.hydrateEntity(entityRefId, objectShape).proxy;
+  }
+  const { mask } = objectShape;
+  const childRefs = mask & Mask.ENTITY ? /* @__PURE__ */ new Set() : entityRefs;
+  const shape = objectShape.shape;
+  const subEntityPaths = objectShape.subEntityPaths;
+  if (subEntityPaths !== void 0) {
+    if (typeof subEntityPaths === "string") {
+      const propDef = shape[subEntityPaths];
+      obj[subEntityPaths] = parseEntities(obj[subEntityPaths], propDef, queryClient, childRefs);
+    } else {
+      for (const path of subEntityPaths) {
+        const propDef = shape[path];
+        obj[path] = parseEntities(obj[path], propDef, queryClient, childRefs);
+      }
+    }
+  }
+  if (mask & Mask.ENTITY) {
+    const entityDef = objectShape;
+    const typename = entityDef.typenameValue;
+    const id = obj[entityDef.idField];
+    if (id === void 0) {
+      throw new Error(`Entity id is required: ${typename}`);
+    }
+    const desc = `${typename}:${id}`;
+    const key = utils.hashValue(desc);
+    if (entityRefs !== void 0) {
+      entityRefs.add(key);
+    }
+    return queryClient.saveEntity(key, obj, entityDef, childRefs).proxy;
+  }
+  const warn = queryClient.getContext().log?.warn;
+  for (const [key, propDef] of entries(shape)) {
+    if (subEntityPaths !== void 0) {
+      if (typeof subEntityPaths === "string" ? key === subEntityPaths : subEntityPaths.includes(key)) {
+        continue;
+      }
+    }
+    obj[key] = parseValue(
+      obj[key],
+      propDef,
+      `${objectShape.typenameValue ?? "object"}.${key}`,
+      false,
+      warn
+    );
+  }
+  return obj;
+}
+function parseEntities(value, def, queryClient, entityRefs) {
+  const valueType = typeMaskOf(value);
+  const defType = def.mask;
+  if ((defType & Mask.PARSE_RESULT) !== 0) {
+    try {
+      const innerResult = parseEntities(
+        value,
+        def.shape,
+        queryClient,
+        entityRefs
+      );
+      return { success: true, value: innerResult };
+    } catch (e) {
+      return { success: false, error: e instanceof Error ? e : new Error(String(e)) };
+    }
+  }
+  if (valueType < Mask.OBJECT || (defType & valueType) === 0) {
+    return value;
+  }
+  if ((defType & Mask.UNION) !== 0) {
+    return parseUnionEntities(
+      valueType,
+      value,
+      def,
+      queryClient,
+      entityRefs
+    );
+  }
+  if (valueType === Mask.ARRAY) {
+    return parseArrayEntities(value, def.shape, queryClient, entityRefs);
+  }
+  if ((defType & Mask.RECORD) !== 0) {
+    return parseRecordEntities(
+      value,
+      def.shape,
+      queryClient,
+      entityRefs
+    );
+  }
+  return parseObjectEntities(value, def, queryClient, entityRefs);
+}
+class QueryResultExtra {
+  _streamOrphansNotifier = void 0;
+  _streamOrphans = void 0;
+  _optimisticInsertsNotifier = void 0;
+  _optimisticInserts = void 0;
+  onChanged;
+  constructor(onChanged) {
+    this.onChanged = onChanged;
+  }
+  get streamOrphansNotifier() {
+    return this._streamOrphansNotifier ?? (this._streamOrphansNotifier = signalium.notifier());
+  }
+  get optimisticInsertsNotifier() {
+    return this._optimisticInsertsNotifier ?? (this._optimisticInsertsNotifier = signalium.notifier());
+  }
+  get streamOrphans() {
+    return this._streamOrphans ?? (this._streamOrphans = /* @__PURE__ */ new Set());
+  }
+  get optimisticInserts() {
+    return this._optimisticInserts ?? (this._optimisticInserts = /* @__PURE__ */ new Set());
+  }
+  /**
+   * Returns the QueryExtra object for public API consumption.
+   * Consumes the notifiers to establish reactive tracking.
+   */
+  getExtra() {
+    this.streamOrphansNotifier.consume();
+    this.optimisticInsertsNotifier.consume();
+    return {
+      streamOrphans: this.streamOrphans,
+      optimisticInserts: this.optimisticInserts
+    };
+  }
+  /**
+   * Add a stream orphan entity.
+   * Returns true if the orphan was added (not a duplicate).
+   */
+  addStreamOrphan(entity2) {
+    const orphans = this.streamOrphans;
+    const sizeBefore = orphans.size;
+    orphans.add(entity2);
+    if (orphans.size !== sizeBefore) {
+      this.streamOrphansNotifier.notify();
+      const proxyId = getProxyId(entity2);
+      if (proxyId !== void 0) {
+        this.removeOptimisticInsertById(proxyId);
+      }
+      this.onChanged();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Add an optimistic insert entity.
+   * Returns true if the insert was added (not a duplicate).
+   */
+  addOptimisticInsert(entity2) {
+    const inserts = this.optimisticInserts;
+    const sizeBefore = inserts.size;
+    inserts.add(entity2);
+    if (inserts.size !== sizeBefore) {
+      this.optimisticInsertsNotifier.notify();
+      this.onChanged();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Remove an optimistic insert by its entity.
+   * Returns true if the insert was removed.
+   */
+  removeOptimisticInsert(entity2) {
+    const proxyId = getProxyId(entity2);
+    if (proxyId === void 0) {
+      return false;
+    }
+    return this.removeOptimisticInsertById(proxyId);
+  }
+  /**
+   * Remove an optimistic insert by proxy ID.
+   */
+  removeOptimisticInsertById(proxyId) {
+    const inserts = this._optimisticInserts;
+    if (inserts === void 0 || inserts.size === 0) {
+      return false;
+    }
+    for (const existing of inserts) {
+      if (getProxyId(existing) === proxyId) {
+        inserts.delete(existing);
+        this.optimisticInsertsNotifier.notify();
+        this.onChanged();
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a proxy ID exists in stream orphans.
+   */
+  hasOrphanWithId(proxyId) {
+    const orphans = this._streamOrphans;
+    if (orphans === void 0) {
+      return false;
+    }
+    for (const orphan of orphans) {
+      if (getProxyId(orphan) === proxyId) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Reconcile orphans and optimistic inserts against the main response entity refs.
+   * Removes any that now exist in the main response.
+   */
+  reconcile(allRefIds) {
+    const orphans = this._streamOrphans;
+    if (orphans !== void 0 && orphans.size > 0) {
+      let orphansChanged = false;
+      for (const orphan of orphans) {
+        const entityRefId = getProxyId(orphan);
+        if (entityRefId !== void 0 && allRefIds.has(entityRefId)) {
+          orphans.delete(orphan);
+          orphansChanged = true;
+        }
+      }
+      if (orphansChanged) {
+        this.streamOrphansNotifier.notify();
+      }
+    }
+    const inserts = this._optimisticInserts;
+    if (inserts !== void 0 && inserts.size > 0) {
+      let insertsChanged = false;
+      for (const insert of inserts) {
+        const entityRefId = getProxyId(insert);
+        if (entityRefId !== void 0) {
+          if (allRefIds.has(entityRefId)) {
+            inserts.delete(insert);
+            insertsChanged = true;
+          } else if (orphans !== void 0 && orphans.has(insert)) {
+            inserts.delete(insert);
+            insertsChanged = true;
+          }
+        }
+      }
+      if (insertsChanged) {
+        this.optimisticInsertsNotifier.notify();
+      }
+    }
+  }
+  /**
+   * Clear all stream orphans and optimistic inserts.
+   * Called on refetch.
+   */
+  clear() {
+    let changed = false;
+    if (this._streamOrphans !== void 0 && this._streamOrphans.size > 0) {
+      this._streamOrphans = void 0;
+      this.streamOrphansNotifier.notify();
+      changed = true;
+    }
+    if (this._optimisticInserts !== void 0 && this._optimisticInserts.size > 0) {
+      this._optimisticInserts = void 0;
+      this.optimisticInsertsNotifier.notify();
+      changed = true;
+    }
+    if (changed) {
+      this.onChanged();
+    }
+  }
+  /**
+   * Load extra data from cached values.
+   */
+  loadFromCache(cachedExtra, queryClient, streamShape, optimisticInsertsShape) {
+    if (cachedExtra.streamOrphanRefs && cachedExtra.streamOrphanRefs.length > 0 && streamShape) {
+      const orphans = this.streamOrphans;
+      for (const refId of cachedExtra.streamOrphanRefs) {
+        const entityRecord = queryClient.hydrateEntity(refId, streamShape);
+        orphans.add(entityRecord.proxy);
+      }
+    }
+    if (cachedExtra.optimisticInsertRefs && cachedExtra.optimisticInsertRefs.length > 0 && optimisticInsertsShape) {
+      const inserts = this.optimisticInserts;
+      for (const refId of cachedExtra.optimisticInsertRefs) {
+        const entityRecord = queryClient.hydrateEntity(refId, optimisticInsertsShape);
+        inserts.add(entityRecord.proxy);
+      }
+    }
+  }
+  /**
+   * Get extra data for persistence (converts Sets to arrays of entity ref IDs).
+   */
+  getForPersistence() {
+    const orphans = this._streamOrphans;
+    const inserts = this._optimisticInserts;
+    if ((orphans === void 0 || orphans.size === 0) && (inserts === void 0 || inserts.size === 0)) {
+      return void 0;
+    }
+    const extra = {};
+    if (orphans !== void 0 && orphans.size > 0) {
+      extra.streamOrphanRefs = [];
+      for (const orphan of orphans) {
+        const refId = getProxyId(orphan);
+        if (refId !== void 0) {
+          extra.streamOrphanRefs.push(refId);
+        }
+      }
+    }
+    if (inserts !== void 0 && inserts.size > 0) {
+      extra.optimisticInsertRefs = [];
+      for (const insert of inserts) {
+        const refId = getProxyId(insert);
+        if (refId !== void 0) {
+          extra.optimisticInsertRefs.push(refId);
+        }
+      }
+    }
+    return extra;
+  }
+  /**
+   * Check if there's any extra data.
+   */
+  get hasData() {
+    return this._streamOrphans !== void 0 && this._streamOrphans.size > 0 || this._optimisticInserts !== void 0 && this._optimisticInserts.size > 0;
+  }
+}
+class QueryResultImpl {
+  def;
+  queryKey;
+  // Instance key (includes Signal identity)
+  storageKey = -1;
+  // Storage key (extracted values only)
+  queryClient;
+  initialized = false;
+  isRefetchingSignal = signalium.signal(false);
+  isFetchingMoreSignal = signalium.signal(false);
+  updatedAt = void 0;
+  params = void 0;
+  refIds = void 0;
+  allNestedRefIdsSignal = void 0;
+  refetchPromise = void 0;
+  fetchMorePromise = void 0;
+  unsubscribe = void 0;
+  relay;
+  _relayState = void 0;
+  wasPaused = false;
+  currentParams = void 0;
+  debounceTimer = void 0;
+  get relayState() {
+    const relayState = this._relayState;
+    if (!relayState) {
+      throw new Error("Relay state not initialized");
+    }
+    return relayState;
+  }
+  _extra = void 0;
+  get extraData() {
+    return this._extra ?? (this._extra = new QueryResultExtra(() => this.persistExtraData()));
+  }
+  _nextPageParams = void 0;
+  get nextPageParams() {
+    if (this.def.type !== QueryType.InfiniteQuery) {
+      return null;
+    }
+    let params = this._nextPageParams;
+    const value = this.relayState.value;
+    if (params === void 0 && value !== void 0) {
+      if (!Array.isArray(value)) {
+        throw new Error("Query result is not an array, this is a bug");
+      }
+      const infiniteDef = this.def;
+      const nextParams = infiniteDef.pagination?.getNextPageParams?.(value[value.length - 1]);
+      if (nextParams === void 0) {
+        params = null;
+      } else {
+        let hasDefinedParams = false;
+        const clonedParams = { ...this.currentParams };
+        for (const [key, value2] of Object.entries(nextParams)) {
+          if (value2 !== void 0 && value2 !== null) {
+            clonedParams[key] = value2;
+            hasDefinedParams = true;
+          }
+        }
+        this._nextPageParams = params = hasDefinedParams ? clonedParams : null;
+      }
+    }
+    return params ?? null;
+  }
+  constructor(def, queryClient, queryKey, params) {
+    utils.setReactivePromise(this);
+    this.def = def;
+    this.queryClient = queryClient;
+    this.queryKey = queryKey;
+    this.params = params;
+    this.relay = signalium.relay((state) => {
+      this._relayState = state;
+      this.currentParams = extractParamsForKey(this.params);
+      this.storageKey = queryKeyFor(this.def, this.currentParams);
+      this.queryClient.activateQuery(this);
+      const isPaused = this.isPaused;
+      this.wasPaused = isPaused;
+      if (this.initialized) {
+        if (!isPaused) {
+          if (this.def.type === QueryType.Stream || this.def.stream) {
+            this.setupSubscription();
+          }
+          if (this.def.type !== QueryType.Stream && this.isStale) {
+            this.refetch();
+          }
+        }
+      } else {
+        this.initialize();
+      }
+      const deactivate = () => {
+        clearTimeout(this.debounceTimer);
+        this.debounceTimer = void 0;
+        this.unsubscribe?.();
+        this.unsubscribe = void 0;
+        if (this.def.type !== QueryType.Stream && this.def.cache?.refetchInterval) {
+          this.queryClient.refetchManager.removeQuery(this);
+        }
+        this.queryClient.memoryEvictionManager.scheduleEviction(this.queryKey);
+      };
+      return {
+        update: () => {
+          const { wasPaused, isPaused: isPaused2 } = this;
+          this.wasPaused = isPaused2;
+          if (isPaused2) {
+            deactivate();
+            return;
+          }
+          const newExtractedParams = extractParamsForKey(this.params);
+          const newStorageKey = queryKeyFor(this.def, newExtractedParams);
+          const paramsDidChange = newStorageKey !== this.storageKey;
+          if (paramsDidChange) {
+            this.params = newExtractedParams;
+            this.storageKey = newStorageKey;
+          }
+          if (wasPaused) {
+            this.queryClient.activateQuery(this);
+            if (this.def.type !== QueryType.Stream) {
+              const refreshStaleOnReconnect = this.def.cache?.refreshStaleOnReconnect ?? true;
+              if (refreshStaleOnReconnect && this.isStale) {
+                state.setPromise(this.runQuery(this.currentParams, true));
+              }
+            } else {
+              this.setupSubscription();
+            }
+          } else if (paramsDidChange) {
+            if (this.def.type !== QueryType.Stream) {
+              this.debouncedRefetch();
+            } else {
+              this.setupSubscription();
+            }
+          }
+        },
+        deactivate
+      };
+    });
+  }
+  // ======================================================
+  // ReactivePromise properties
+  // =====================================================
+  get value() {
+    return this.relay.value;
+  }
+  get error() {
+    return this.relay.error;
+  }
+  get isPending() {
+    return this.relay.isPending;
+  }
+  get isRejected() {
+    return this.relay.isRejected;
+  }
+  get isResolved() {
+    return this.relay.isResolved;
+  }
+  get isSettled() {
+    return this.relay.isSettled;
+  }
+  get isReady() {
+    return this.relay.isReady;
+  }
+  // TODO: Intimate APIs needed for `useReactive`, this is a code smell and
+  // we should find a better way to entangle these more generically
+  get _version() {
+    return this.relay._version;
+  }
+  get _signal() {
+    return this.relay._signal;
+  }
+  get _flags() {
+    return this.relay._flags;
+  }
+  // Forward Promise methods
+  then(onfulfilled, onrejected) {
+    return this.relay.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.relay.catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.relay.finally(onfinally);
+  }
+  get [Symbol.toStringTag]() {
+    return "QueryResult";
+  }
+  // ======================================================
+  // Internal fetch methods
+  // ======================================================
+  getAllEntityRefs() {
+    let allNestedRefIdsSignal = this.allNestedRefIdsSignal;
+    if (!allNestedRefIdsSignal) {
+      const queryClient = this.queryClient;
+      this.allNestedRefIdsSignal = allNestedRefIdsSignal = signalium.reactiveSignal(() => {
+        this.relay.value;
+        const allRefIds = /* @__PURE__ */ new Set();
+        if (this.refIds !== void 0) {
+          for (const refId of this.refIds) {
+            queryClient.getNestedEntityRefIds(refId, allRefIds);
+          }
+        }
+        this.extraData.reconcile(allRefIds);
+        return allRefIds;
+      });
+    }
+    return allNestedRefIdsSignal.value;
+  }
+  /**
+   * Initialize the query by loading from cache and fetching if stale
+   */
+  async initialize() {
+    const state = this.relayState;
+    this.initialized = true;
+    let cached;
+    try {
+      cached = await this.queryClient.loadCachedQuery(this.def, this.storageKey);
+      if (cached !== void 0) {
+        this.updatedAt = cached.updatedAt;
+        this.refIds = cached.refIds;
+        if (cached.extra) {
+          const def = this.def;
+          this.extraData.loadFromCache(
+            cached.extra,
+            this.queryClient,
+            def.stream?.shape,
+            def.optimisticInserts?.shape
+          );
+        }
+        const shape = this.def.shape;
+        state.value = shape instanceof ValidatorDef ? parseEntities(cached.value, shape, this.queryClient, /* @__PURE__ */ new Set()) : parseValue(cached.value, shape, this.def.id);
+      }
+    } catch (error) {
+      this.queryClient.deleteCachedQuery(this.storageKey);
+      this.queryClient.getContext().log?.warn?.("Failed to initialize query, the query cache may be corrupted or invalid", error);
+    }
+    if (this.isPaused) {
+      return;
+    }
+    try {
+      if (this.def.type === QueryType.Stream || this.def.stream) {
+        this.setupSubscription();
+      }
+      if (this.def.type !== QueryType.Stream) {
+        if (cached !== void 0) {
+          if (this.isStale) {
+            if (this.def.debounce !== void 0 && this.def.debounce > 0) {
+              this.debouncedRefetch();
+            } else {
+              this.refetch();
+            }
+          }
+        } else {
+          state.setPromise(this.runQuery(this.currentParams, true));
+        }
+      }
+    } catch (error) {
+      state.setError(error);
+    }
+  }
+  /**
+   * Handle stream updates. This method handles both StreamQuery and Query/InfiniteQuery with stream options.
+   * - For StreamQuery: directly updates the relay state with the entity
+   * - For Query/InfiniteQuery with stream: updates entities in response or adds to orphans
+   */
+  setupSubscription() {
+    this.unsubscribe?.();
+    let subscribeFn;
+    let shapeDef;
+    if (this.def.type === QueryType.Stream) {
+      shapeDef = this.def.shape;
+      subscribeFn = this.def.subscribeFn;
+    } else {
+      const stream = this.def.stream;
+      if (!stream) {
+        return;
+      }
+      shapeDef = stream.shape;
+      subscribeFn = stream.subscribeFn;
+    }
+    const extractedParams = this.currentParams;
+    this.unsubscribe = subscribeFn(this.queryClient.getContext(), extractedParams, (update) => {
+      const parsedData = parseObjectEntities(update, shapeDef, this.queryClient);
+      if (this.def.type === QueryType.Stream) {
+        this.relayState.value = parsedData;
+        this.updatedAt = Date.now();
+        this.queryClient.saveQueryData(this.def, this.storageKey, parsedData, this.updatedAt);
+      } else {
+        const allRefIds = this.getAllEntityRefs();
+        const proxyId = getProxyId(parsedData);
+        if (proxyId !== void 0 && !allRefIds.has(proxyId)) {
+          this.extraData.addStreamOrphan(parsedData);
+        }
+      }
+    });
+  }
+  /**
+   * Fetches fresh data, updates the cache, and updates updatedAt timestamp
+   */
+  async runQuery(params, reset = false) {
+    if (this.isPaused) {
+      throw new Error("Query is paused due to network status");
+    }
+    const { retries, retryDelay } = this.getRetryConfig();
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        const queryDef = this.def;
+        const freshData = await queryDef.fetchFn(this.queryClient.getContext(), params);
+        let entityRefs;
+        const isInfinite = this.def.type === QueryType.InfiniteQuery;
+        if (isInfinite && !reset && this.refIds !== void 0) {
+          entityRefs = this.refIds;
+        } else {
+          entityRefs = this.refIds = /* @__PURE__ */ new Set();
+        }
+        const shape = this.def.shape;
+        const parsedData = shape instanceof ValidatorDef ? parseEntities(freshData, shape, this.queryClient, entityRefs) : parseValue(freshData, shape, this.def.id);
+        let queryData;
+        if (isInfinite) {
+          const prevQueryData = this.relayState.value;
+          queryData = reset || prevQueryData === void 0 ? [parsedData] : [...prevQueryData, parsedData];
+        } else {
+          queryData = parsedData;
+        }
+        let updatedAt;
+        if (reset) {
+          updatedAt = this.updatedAt = Date.now();
+        } else {
+          updatedAt = this.updatedAt ??= Date.now();
+        }
+        this._nextPageParams = void 0;
+        this.queryClient.saveQueryData(
+          this.def,
+          this.storageKey,
+          queryData,
+          updatedAt,
+          entityRefs,
+          this.getExtraForPersistence()
+        );
+        this.updatedAt = Date.now();
+        return queryData;
+      } catch (error) {
+        lastError = error;
+        if (attempt >= retries) {
+          throw error;
+        }
+        const delay = retryDelay(attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        if (this.isPaused) {
+          throw new Error("Query is paused due to network status");
+        }
+      }
+    }
+    throw lastError;
+  }
+  // ======================================================
+  // Private debounce methods
+  // ======================================================
+  /**
+   * Triggers a debounced refetch. If debounce is configured, delays the fetch.
+   * Otherwise, calls refetch immediately.
+   */
+  debouncedRefetch() {
+    const debounce = this.def.debounce;
+    if (debounce === void 0) {
+      this.refetch();
+      return;
+    }
+    clearTimeout(this.debounceTimer);
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = void 0;
+      this.refetch();
+    }, debounce);
+  }
+  // ======================================================
+  // Public methods
+  // ======================================================
+  refetch = () => {
+    if (this.def.type === QueryType.Stream) {
+      throw new Error("Cannot refetch a stream query");
+    }
+    if (this.fetchMorePromise) {
+      throw new Error("Query is fetching more, cannot refetch");
+    }
+    if (this.refetchPromise) {
+      return this.refetchPromise;
+    }
+    clearTimeout(this.debounceTimer);
+    this.debounceTimer = void 0;
+    this._nextPageParams = void 0;
+    this.isRefetchingSignal.value = true;
+    this._version.update((v) => v + 1);
+    const promise = this.runQuery(this.currentParams, true).then((result) => {
+      this.relayState.value = result;
+      if (this._extra !== void 0) {
+        this._extra.clear();
+      }
+      return result;
+    }).catch((error) => {
+      this.relayState.setError(error);
+      return Promise.reject(error);
+    }).finally(() => {
+      this._version.update((v) => v + 1);
+      this.isRefetchingSignal.value = false;
+      this.refetchPromise = void 0;
+    });
+    this.refetchPromise = promise;
+    return promise;
+  };
+  fetchNextPage = () => {
+    if (this.def.type === QueryType.Stream) {
+      throw new Error("Cannot fetch next page on a stream query");
+    }
+    if (this.refetchPromise) {
+      return Promise.reject(new Error("Query is refetching, cannot fetch next page"));
+    }
+    if (this.fetchMorePromise) {
+      return this.fetchMorePromise;
+    }
+    const nextPageParams = this.nextPageParams;
+    if (!nextPageParams) {
+      return Promise.reject(new Error("No next page params"));
+    }
+    this.isFetchingMoreSignal.value = true;
+    this._version.update((v) => v + 1);
+    const promise = this.runQuery(nextPageParams, false).then((result) => {
+      this.relayState.value = result;
+      return result;
+    }).catch((error) => {
+      this.relayState.setError(error);
+      return Promise.reject(error);
+    }).finally(() => {
+      this._version.update((v) => v + 1);
+      this.isFetchingMoreSignal.value = false;
+      this.fetchMorePromise = void 0;
+    });
+    this.fetchMorePromise = promise;
+    return promise;
+  };
+  // ======================================================
+  // Public properties
+  // ======================================================
+  get isRefetching() {
+    return this.isRefetchingSignal.value;
+  }
+  get isFetchingMore() {
+    return this.isFetchingMoreSignal.value;
+  }
+  get isFetching() {
+    return this.relay.isPending || this.isRefetching || this.isFetchingMore;
+  }
+  get hasNextPage() {
+    return this.nextPageParams !== null;
+  }
+  get extra() {
+    this.getAllEntityRefs();
+    return this.extraData.getExtra();
+  }
+  /**
+   * Persist the current extra data to the store
+   */
+  persistExtraData() {
+    if (this.updatedAt === void 0) {
+      return;
+    }
+    const extra = this._extra?.getForPersistence();
+    this.queryClient.saveQueryData(
+      this.def,
+      this.storageKey,
+      this.relayState.value,
+      this.updatedAt,
+      this.refIds,
+      extra
+    );
+  }
+  /**
+   * Get extra data for persistence (converts Sets to arrays of entity ref IDs)
+   */
+  getExtraForPersistence() {
+    return this._extra?.getForPersistence();
+  }
+  /**
+   * Add an optimistic insert to the query result.
+   * The insert will be automatically removed when:
+   * - The entity appears in a refetched response
+   * - The entity appears as a stream orphan
+   * - refetch() is called
+   */
+  addOptimisticInsert(insert) {
+    const def = this.def;
+    const optimisticInsertsConfig = def.optimisticInserts;
+    if (optimisticInsertsConfig === void 0) {
+      throw new Error(
+        "Query does not have optimisticInserts configured. Add optimisticInserts: { type: YourEntity } to the query definition."
+      );
+    }
+    let proxyId = getProxyId(insert);
+    let parsedInsert = insert;
+    if (proxyId === void 0) {
+      parsedInsert = parseObjectEntities(insert, optimisticInsertsConfig.shape, this.queryClient);
+      proxyId = getProxyId(parsedInsert);
+      if (proxyId === void 0) {
+        throw new Error("Optimistic insert must be or produce an entity proxy");
+      }
+    }
+    const allRefIds = this.getAllEntityRefs();
+    if (allRefIds.has(proxyId)) {
+      return;
+    }
+    if (this.extraData.hasOrphanWithId(proxyId)) {
+      return;
+    }
+    this.extraData.addOptimisticInsert(parsedInsert);
+  }
+  /**
+   * Remove an optimistic insert from the query result.
+   * This is a no-op if the insert has already been removed.
+   */
+  removeOptimisticInsert(insert) {
+    this.extraData.removeOptimisticInsert(insert);
+  }
+  get isStale() {
+    if (this.def.type === QueryType.Stream) {
+      return false;
+    }
+    if (this.updatedAt === void 0) {
+      return true;
+    }
+    const staleTime = this.def.cache?.staleTime ?? 0;
+    return Date.now() - this.updatedAt >= staleTime;
+  }
+  get isPaused() {
+    if (this.def.type === QueryType.Stream) {
+      return false;
+    }
+    const networkMode = this.def.cache?.networkMode ?? NetworkMode.Online;
+    const networkManager = this.queryClient.networkManager;
+    const isOnline = networkManager.getOnlineSignal().value;
+    switch (networkMode) {
+      case NetworkMode.Always:
+        return false;
+      case NetworkMode.Online:
+        return !isOnline;
+      case NetworkMode.OfflineFirst:
+        return !isOnline && this.updatedAt === void 0;
+      default:
+        return false;
+    }
+  }
+  getRetryConfig() {
+    if (this.def.type === QueryType.Stream) {
+      return { retries: 0, retryDelay: () => 0 };
+    }
+    const retryOption = this.def.cache?.retry;
+    const isServer = this.queryClient.isServer;
+    let retries;
+    let retryDelay;
+    if (retryOption === false) {
+      retries = 0;
+    } else if (retryOption === void 0) {
+      retries = isServer ? 0 : 3;
+    } else if (typeof retryOption === "number") {
+      retries = retryOption;
+    } else {
+      retries = retryOption.retries;
+    }
+    if (typeof retryOption === "object" && retryOption.retryDelay) {
+      retryDelay = retryOption.retryDelay;
+    } else {
+      retryDelay = (attempt) => 1e3 * Math.pow(2, attempt);
+    }
+    return { retries, retryDelay };
+  }
+}
+class MutationResultImpl {
+  def;
+  queryClient;
+  // The underlying ReactiveTask that handles all state management
+  _task;
+  // Track which entity keys we've registered optimistic updates for
+  // EntityMap handles the actual snapshots
+  _pendingOptimisticKeys = /* @__PURE__ */ new Set();
+  constructor(def, queryClient) {
+    this.def = def;
+    this.queryClient = queryClient;
+    this._task = this.createTask();
+  }
+  createTask() {
+    return signalium.task(async (request) => {
+      try {
+        const response = await this.executeWithRetry(request);
+        const parsedResponse = this.parseAndUpdateEntities(response);
+        this.clearOptimisticUpdates();
+        return parsedResponse;
+      } catch (error) {
+        this.revertOptimisticUpdates();
+        throw error;
+      }
+    });
+  }
+  // ======================================================
+  // Delegated ReactivePromise properties
+  // ======================================================
+  get value() {
+    return this._task.value;
+  }
+  get error() {
+    return this._task.error;
+  }
+  get isPending() {
+    return this._task.isPending;
+  }
+  get isRejected() {
+    return this._task.isRejected;
+  }
+  get isResolved() {
+    return this._task.isResolved;
+  }
+  get isSettled() {
+    return this._task.isSettled;
+  }
+  get isReady() {
+    return this._task.isReady;
+  }
+  // ======================================================
+  // Promise interface (delegated)
+  // ======================================================
+  then(onfulfilled, onrejected) {
+    return this._task.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this._task.catch(onrejected);
+  }
+  finally(onfinally) {
+    return this._task.finally(onfinally);
+  }
+  get [Symbol.toStringTag]() {
+    return "MutationResult";
+  }
+  // ======================================================
+  // Mutation execution
+  // ======================================================
+  run = (request) => {
+    if (this.def.optimisticUpdates) {
+      this.applyOptimisticUpdates(request);
+    }
+    this._task.run(request);
+    return this;
+  };
+  reset = () => {
+    this.revertOptimisticUpdates();
+    this._task = this.createTask();
+  };
+  // ======================================================
+  // Optimistic updates
+  // ======================================================
+  applyOptimisticUpdates(request) {
+    this._pendingOptimisticKeys.clear();
+    const requestShape = this.def.requestShape;
+    if (!(requestShape instanceof ValidatorDef)) {
+      return;
+    }
+    this.findAndUpdateEntities(request, requestShape);
+  }
+  /**
+   * Recursively walks the data according to its shape, finding and updating all entities.
+   */
+  findAndUpdateEntities(value, def) {
+    const valueType = typeMaskOf(value);
+    const defType = def.mask;
+    if (valueType < Mask.OBJECT || (defType & valueType) === 0) {
+      return;
+    }
+    if ((defType & Mask.UNION) !== 0) {
+      const unionDef = def;
+      if (valueType === Mask.ARRAY) {
+        const arrayShape = unionDef.shape["[]"];
+        if (arrayShape && typeof arrayShape !== "number") {
+          this.findAndUpdateEntitiesInArray(value, arrayShape);
+        }
+      } else {
+        const typenameField = unionDef.typenameField;
+        const typename = typenameField ? value[typenameField] : void 0;
+        if (typename && typeof typename === "string") {
+          const matchingDef = unionDef.shape[typename];
+          if (matchingDef && typeof matchingDef !== "number") {
+            this.findAndUpdateEntitiesInObject(value, matchingDef);
+          }
+        }
+      }
+      return;
+    }
+    if (valueType === Mask.ARRAY) {
+      const arrayShape = def.shape;
+      if (arrayShape && typeof arrayShape !== "number") {
+        this.findAndUpdateEntitiesInArray(value, arrayShape);
+      }
+      return;
+    }
+    if ((defType & Mask.RECORD) !== 0) {
+      const recordShape = def.shape;
+      if (recordShape && typeof recordShape !== "number") {
+        for (const item of Object.values(value)) {
+          this.findAndUpdateEntities(item, recordShape);
+        }
+      }
+      return;
+    }
+    this.findAndUpdateEntitiesInObject(value, def);
+  }
+  findAndUpdateEntitiesInArray(array, shape) {
+    for (const item of array) {
+      this.findAndUpdateEntities(item, shape);
+    }
+  }
+  findAndUpdateEntitiesInObject(obj, def) {
+    const { mask } = def;
+    if (mask & Mask.ENTITY) {
+      const entityDef = def;
+      const idField = entityDef.idField;
+      const entityId = obj[idField];
+      if (entityId !== void 0) {
+        const typename = entityDef.typenameValue;
+        const entityKey = utils.hashValue(`${typename}:${entityId}`);
+        this.queryClient.registerOptimisticUpdate(entityKey, obj);
+        this._pendingOptimisticKeys.add(entityKey);
+      }
+    }
+    const shape = def.shape;
+    const subEntityPaths = def.subEntityPaths;
+    if (subEntityPaths !== void 0) {
+      if (typeof subEntityPaths === "string") {
+        const propDef = shape[subEntityPaths];
+        if (propDef && typeof propDef !== "number") {
+          this.findAndUpdateEntities(obj[subEntityPaths], propDef);
+        }
+      } else {
+        for (const path of subEntityPaths) {
+          const propDef = shape[path];
+          if (propDef && typeof propDef !== "number") {
+            this.findAndUpdateEntities(obj[path], propDef);
+          }
+        }
+      }
+    }
+  }
+  revertOptimisticUpdates() {
+    for (const entityKey of this._pendingOptimisticKeys) {
+      this.queryClient.revertOptimisticUpdate(entityKey);
+    }
+    this._pendingOptimisticKeys.clear();
+  }
+  clearOptimisticUpdates() {
+    for (const entityKey of this._pendingOptimisticKeys) {
+      this.queryClient.clearOptimisticUpdates(entityKey);
+    }
+    this._pendingOptimisticKeys.clear();
+  }
+  // ======================================================
+  // Response parsing
+  // ======================================================
+  parseAndUpdateEntities(response) {
+    const responseShape = this.def.responseShape;
+    if (!(responseShape instanceof ValidatorDef)) {
+      return response;
+    }
+    const entityRefs = /* @__PURE__ */ new Set();
+    const parsed = parseEntities(response, responseShape, this.queryClient, entityRefs);
+    return parsed;
+  }
+  // ======================================================
+  // Retry logic
+  // ======================================================
+  async executeWithRetry(request) {
+    const { retries, retryDelay } = this.getRetryConfig();
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        return await this.def.mutateFn(this.queryClient.getContext(), request);
+      } catch (error) {
+        lastError = error;
+        if (attempt >= retries) {
+          throw error;
+        }
+        const delay = retryDelay(attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw lastError;
+  }
+  getRetryConfig() {
+    const retryOption = this.def.cache?.retry;
+    let retries;
+    let retryDelay;
+    if (retryOption === false) {
+      retries = 0;
+    } else if (retryOption === void 0) {
+      retries = 0;
+    } else if (typeof retryOption === "number") {
+      retries = retryOption;
+    } else {
+      retries = retryOption.retries;
+    }
+    if (typeof retryOption === "object" && retryOption.retryDelay) {
+      retryDelay = retryOption.retryDelay;
+    } else {
+      retryDelay = (attempt) => 1e3 * Math.pow(2, attempt);
+    }
+    return { retries, retryDelay };
+  }
+}
+const BASE_TICK_INTERVAL = 1e3;
+class RefetchManager {
+  constructor(multiplier = 1) {
+    this.multiplier = multiplier;
+    const tickInterval = BASE_TICK_INTERVAL * this.multiplier;
+    this.intervalId = setTimeout(() => this.tick(), tickInterval);
+  }
+  intervalId;
+  clock = 0;
+  // Increments by 1000ms on each tick
+  // Buckets: Map of actual interval -> Set of query instances
+  buckets = /* @__PURE__ */ new Map();
+  addQuery(instance) {
+    if (instance.def.type === QueryType.Stream) {
+      return;
+    }
+    const interval = instance.def.cache?.refetchInterval;
+    if (!interval) {
+      return;
+    }
+    const actualInterval = interval * this.multiplier;
+    let bucket = this.buckets.get(actualInterval);
+    if (!bucket) {
+      bucket = /* @__PURE__ */ new Set();
+      this.buckets.set(actualInterval, bucket);
+    }
+    bucket.add(instance);
+  }
+  removeQuery(query2) {
+    if (query2.def.type === QueryType.Stream) {
+      return;
+    }
+    const interval = query2.def.cache?.refetchInterval;
+    if (!interval) {
+      return;
+    }
+    const actualInterval = interval * this.multiplier;
+    const bucket = this.buckets.get(actualInterval);
+    if (bucket) {
+      bucket.delete(query2);
+      if (bucket.size === 0) {
+        this.buckets.delete(actualInterval);
+      }
+    }
+  }
+  tick() {
+    this.clock += BASE_TICK_INTERVAL * this.multiplier;
+    for (const [interval, bucket] of this.buckets.entries()) {
+      if (this.clock % interval === 0) {
+        for (const query2 of bucket) {
+          if (query2 && !query2.isFetching) {
+            query2.refetch();
+          }
+        }
+      }
+    }
+    const tickInterval = BASE_TICK_INTERVAL * this.multiplier;
+    this.intervalId = setTimeout(() => this.tick(), tickInterval);
+  }
+  destroy() {
+    clearTimeout(this.intervalId);
+  }
+}
+class NoOpRefetchManager {
+  addQuery(_instance) {
+  }
+  removeQuery(_query) {
+  }
+  destroy() {
+  }
+}
+const EVICTION_INTERVAL = 60 * 1e3;
+class MemoryEvictionManager {
+  // Queries to evict on tick after next
+  constructor(queryClient, multiplier = 1) {
+    this.queryClient = queryClient;
+    this.multiplier = multiplier;
+    this.intervalId = setInterval(this.tick, EVICTION_INTERVAL * this.multiplier);
+  }
+  intervalId;
+  currentFlush = /* @__PURE__ */ new Set();
+  // Queries to evict on next tick
+  nextFlush = /* @__PURE__ */ new Set();
+  scheduleEviction(queryKey) {
+    this.nextFlush.add(queryKey);
+  }
+  cancelEviction(queryKey) {
+    this.currentFlush.delete(queryKey);
+    this.nextFlush.delete(queryKey);
+  }
+  tick = () => {
+    if (!this.queryClient) return;
+    for (const queryKey of this.currentFlush) {
+      this.queryClient.queryInstances.delete(queryKey);
+    }
+    this.currentFlush = this.nextFlush;
+    this.nextFlush = /* @__PURE__ */ new Set();
+  };
+  destroy() {
+    clearInterval(this.intervalId);
+  }
+}
+class NoOpMemoryEvictionManager {
+  scheduleEviction(_queryKey) {
+  }
+  cancelEviction(_queryKey) {
+  }
+  destroy() {
+  }
+}
+function resolveBaseUrl(baseUrl) {
+  if (baseUrl === void 0) return void 0;
+  if (typeof baseUrl === "string") return baseUrl;
+  if (typeof baseUrl === "function") return baseUrl();
+  return baseUrl.value;
+}
+var QueryType = /* @__PURE__ */ ((QueryType2) => {
+  QueryType2["Query"] = "query";
+  QueryType2["InfiniteQuery"] = "infiniteQuery";
+  QueryType2["Stream"] = "stream";
+  return QueryType2;
+})(QueryType || {});
+function isSignal(value) {
+  return typeof value === "object" && value !== null;
+}
+function extractParamsForKey(params) {
+  if (params === void 0) {
+    return void 0;
+  }
+  const extracted = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (isSignal(value)) {
+      extracted[key] = value.value;
+    } else {
+      extracted[key] = value;
+    }
+  }
+  return extracted;
+}
+const queryKeyFor = (queryDef, params) => {
+  return utils.hashValue([queryDef.id, queryDef.shapeKey, params]);
+};
+class QueryClient {
+  constructor(store, context2 = { fetch, log: console }, networkManager, memoryEvictionManager, refetchManager) {
+    this.store = store;
+    this.context = context2;
+    this.memoryEvictionManager = memoryEvictionManager ?? new MemoryEvictionManager(this, this.context.evictionMultiplier);
+    this.refetchManager = refetchManager ?? new RefetchManager(this.context.refetchMultiplier);
+    this.networkManager = networkManager ?? new NetworkManager();
+    this.isServer = typeof window === "undefined";
+    this.entityMap = new EntityStore(this);
+  }
+  entityMap;
+  queryInstances = /* @__PURE__ */ new Map();
+  mutationInstances = /* @__PURE__ */ new Map();
+  memoryEvictionManager;
+  refetchManager;
+  networkManager;
+  isServer;
+  getContext() {
+    return this.context;
+  }
+  saveQueryData(queryDef, queryKey, data, updatedAt, entityRefs, extra) {
+    const clonedRefs = entityRefs !== void 0 ? new Set(entityRefs) : void 0;
+    this.store.saveQuery(queryDef, queryKey, data, updatedAt, clonedRefs, extra);
+  }
+  activateQuery(queryInstance) {
+    const { def, queryKey, storageKey } = queryInstance;
+    this.store.activateQuery(def, storageKey);
+    if (def.type !== "stream" && def.cache?.refetchInterval) {
+      this.refetchManager.addQuery(queryInstance);
+    }
+    this.memoryEvictionManager.cancelEviction(queryKey);
+  }
+  loadCachedQuery(queryDef, queryKey) {
+    return this.store.loadQuery(queryDef, queryKey, this.entityMap);
+  }
+  deleteCachedQuery(queryKey) {
+    this.store.deleteQuery(queryKey);
+  }
+  /**
+   * Loads a query from the document store and returns a QueryResult
+   * that triggers fetches and prepopulates with cached data
+   */
+  getQuery(queryDef, params) {
+    const queryKey = queryKeyFor(queryDef, params);
+    let queryInstance = this.queryInstances.get(queryKey);
+    if (queryInstance === void 0) {
+      queryInstance = new QueryResultImpl(queryDef, this, queryKey, params);
+      this.queryInstances.set(queryKey, queryInstance);
+    }
+    return queryInstance;
+  }
+  /**
+   * Gets or creates a MutationResult for the given mutation definition.
+   * Mutations are cached by their definition ID.
+   */
+  getMutation(mutationDef) {
+    const mutationId = mutationDef.id;
+    let mutationInstance = this.mutationInstances.get(mutationId);
+    if (mutationInstance === void 0) {
+      mutationInstance = new MutationResultImpl(mutationDef, this);
+      this.mutationInstances.set(mutationId, mutationInstance);
+    }
+    return mutationInstance;
+  }
+  // ======================================================
+  // Optimistic Update Management
+  // ======================================================
+  /**
+   * Register pending optimistic updates for an entity.
+   * Called by MutationResult when applying optimistic updates.
+   */
+  registerOptimisticUpdate(entityKey, fields) {
+    this.entityMap.registerOptimisticUpdate(entityKey, fields);
+  }
+  /**
+   * Clear pending optimistic updates for an entity without reverting.
+   * Called by MutationResult when mutation succeeds.
+   */
+  clearOptimisticUpdates(entityKey) {
+    this.entityMap.clearOptimisticUpdates(entityKey);
+  }
+  /**
+   * Revert pending optimistic updates for an entity, restoring its snapshot.
+   * Called by MutationResult when mutation fails.
+   */
+  revertOptimisticUpdate(entityKey) {
+    this.entityMap.revertOptimisticUpdate(entityKey);
+  }
+  hydrateEntity(key, shape) {
+    return this.entityMap.hydratePreloadedEntity(key, shape);
+  }
+  saveEntity(key, obj, shape, entityRefs) {
+    const record = this.entityMap.setEntity(key, obj, shape, entityRefs);
+    this.store.saveEntity(key, obj, entityRefs);
+    return record;
+  }
+  getNestedEntityRefIds(key, refIds) {
+    return this.entityMap.getNestedEntityRefIds(key, refIds);
+  }
+  destroy() {
+    this.refetchManager.destroy();
+    this.memoryEvictionManager.destroy();
+  }
+}
+const QueryClientContext = signalium.context(void 0);
+function addOptimisticInsert(query2, insert) {
+  query2.addOptimisticInsert(insert);
+}
+function removeOptimisticInsert(query2, insert) {
+  query2.removeOptimisticInsert(insert);
+}
+function createPathInterpolator(pathTemplate) {
+  const segments = [];
+  const paramKeys = [];
+  const paramKeysSet = /* @__PURE__ */ new Set();
+  let lastIndex = 0;
+  const paramRegex = /\[([^\]]+)\]/g;
+  let match;
+  while ((match = paramRegex.exec(pathTemplate)) !== null) {
+    segments.push(pathTemplate.slice(lastIndex, match.index));
+    paramKeys.push(match[1]);
+    paramKeysSet.add(match[1]);
+    lastIndex = paramRegex.lastIndex;
+  }
+  segments.push(pathTemplate.slice(lastIndex));
+  return (params) => {
+    let result = segments[0];
+    for (let i = 0; i < paramKeys.length; i++) {
+      result += encodeURIComponent(String(params[paramKeys[i]])) + segments[i + 1];
+    }
+    let searchParams = null;
+    for (const key in params) {
+      if (!paramKeysSet.has(key) && params[key] !== void 0) {
+        if (searchParams === null) {
+          searchParams = new URLSearchParams();
+        }
+        searchParams.append(key, String(params[key]));
+      }
+    }
+    if (searchParams !== null) {
+      result += "?" + searchParams.toString();
+    }
+    return result;
+  };
+}
+const QUERY_DEFINITION_MAP = /* @__PURE__ */ new Map();
+function buildQueryFn(queryDefinitionBuilder) {
+  let queryDefinition;
+  const getQueryDefinition = () => {
+    if (queryDefinition === void 0) {
+      const {
+        path,
+        method = "GET",
+        response,
+        requestOptions,
+        cache,
+        pagination,
+        stream,
+        optimisticInserts,
+        debounce
+      } = queryDefinitionBuilder();
+      const id = `${method}:${path}`;
+      let shape;
+      let shapeKey;
+      if (typeof response === "object") {
+        if (response instanceof ValidatorDef) {
+          shape = response;
+          shapeKey = response.shapeKey;
+        } else if (response instanceof Set) {
+          shape = response;
+          shapeKey = utils.hashValue(response);
+        } else {
+          shape = t.object(response);
+          shapeKey = shape.shapeKey;
+        }
+      } else {
+        shape = response;
+        shapeKey = utils.hashValue(shape);
+      }
+      const interpolatePath = createPathInterpolator(path);
+      const fetchFn = async (context, params) => {
+        const interpolatedPath = interpolatePath(params);
+        const baseUrl = resolveBaseUrl(requestOptions?.baseUrl) ?? resolveBaseUrl(context.baseUrl);
+        const fullUrl = baseUrl ? `${baseUrl}${interpolatedPath}` : interpolatedPath;
+        const { baseUrl: _baseUrl, ...fetchOptions } = requestOptions ?? {};
+        const response2 = await context.fetch(fullUrl, {
+          method,
+          ...fetchOptions
+        });
+        return response2.json();
+      };
+      let streamConfig = void 0;
+      if (stream) {
+        let streamShape;
+        let streamShapeKey;
+        const eventDef = stream.type;
+        if (typeof eventDef === "object") {
+          if (eventDef instanceof ValidatorDef) {
+            streamShape = eventDef;
+            streamShapeKey = eventDef.shapeKey;
+          } else if (eventDef instanceof Set) {
+            streamShape = eventDef;
+            streamShapeKey = utils.hashValue(eventDef);
+          } else {
+            streamShape = t.object(eventDef);
+            streamShapeKey = streamShape.shapeKey;
+          }
+        } else {
+          streamShape = eventDef;
+          streamShapeKey = utils.hashValue(streamShape);
+        }
+        streamConfig = {
+          shape: streamShape,
+          shapeKey: streamShapeKey,
+          subscribeFn: (context, params, onUpdate) => {
+            return stream.subscribe(context, params, onUpdate);
+          }
+        };
+      }
+      let optimisticInsertsConfig = void 0;
+      if (optimisticInserts) {
+        let insertShape;
+        let insertShapeKey;
+        const insertDef = optimisticInserts.type;
+        if (typeof insertDef === "object") {
+          if (insertDef instanceof ValidatorDef) {
+            insertShape = insertDef;
+            insertShapeKey = insertDef.shapeKey;
+          } else if (insertDef instanceof Set) {
+            insertShape = insertDef;
+            insertShapeKey = utils.hashValue(insertDef);
+          } else {
+            insertShape = t.object(insertDef);
+            insertShapeKey = insertShape.shapeKey;
+          }
+        } else {
+          insertShape = insertDef;
+          insertShapeKey = utils.hashValue(insertShape);
+        }
+        optimisticInsertsConfig = {
+          shape: insertShape,
+          shapeKey: insertShapeKey
+        };
+      }
+      queryDefinition = {
+        type: pagination ? QueryType.InfiniteQuery : QueryType.Query,
+        id,
+        shape,
+        shapeKey,
+        fetchFn,
+        pagination,
+        cache,
+        stream: streamConfig,
+        optimisticInserts: optimisticInsertsConfig,
+        debounce
+      };
+    }
+    return queryDefinition;
+  };
+  const queryFn = signalium.reactive(
+    (params) => {
+      const queryClient = signalium.getContext(QueryClientContext);
+      if (queryClient === void 0) {
+        throw new Error("QueryClient not found");
+      }
+      return queryClient.getQuery(getQueryDefinition(), params);
+    }
+    // TODO: Getting a lot of type errors due to infinite recursion here.
+    // For now, we return as any to coerce to the external type signature,
+    // and internally we manage the difference.
+  );
+  QUERY_DEFINITION_MAP.set(queryFn, getQueryDefinition);
+  return queryFn;
+}
+function query(queryDefinitionBuilder) {
+  return buildQueryFn(queryDefinitionBuilder);
+}
+function infiniteQuery(queryDefinitionBuilder) {
+  return buildQueryFn(queryDefinitionBuilder);
+}
+function streamQuery(queryDefinitionBuilder) {
+  let streamDefinition;
+  const getStreamDefinition = () => {
+    if (streamDefinition === void 0) {
+      const { id, response, subscribe, cache } = queryDefinitionBuilder();
+      if (!(response instanceof ValidatorDef) || (response.mask & Mask.ENTITY) === 0) {
+        throw new Error("Stream query response must be an EntityDef");
+      }
+      streamDefinition = {
+        type: QueryType.Stream,
+        id,
+        shape: response,
+        shapeKey: response.shapeKey,
+        subscribeFn: (context, params, onUpdate) => {
+          return subscribe(params, onUpdate);
+        },
+        cache
+      };
+    }
+    return streamDefinition;
+  };
+  const streamFn = signalium.reactive((params) => {
+    const queryClient = signalium.getContext(QueryClientContext);
+    if (queryClient === void 0) {
+      throw new Error("QueryClient not found");
+    }
+    return queryClient.getQuery(getStreamDefinition(), params);
+  });
+  QUERY_DEFINITION_MAP.set(streamFn, getStreamDefinition);
+  return streamFn;
+}
+const MUTATION_DEFINITION_MAP = /* @__PURE__ */ new Map();
+function processTypeDef(typeDef) {
+  let shape;
+  let shapeKey;
+  if (typeof typeDef === "object") {
+    if (typeDef instanceof ValidatorDef) {
+      shape = typeDef;
+      shapeKey = typeDef.shapeKey;
+    } else if (typeDef instanceof Set) {
+      shape = typeDef;
+      shapeKey = utils.hashValue(typeDef);
+    } else {
+      shape = t.object(typeDef);
+      shapeKey = shape.shapeKey;
+    }
+  } else {
+    shape = typeDef;
+    shapeKey = utils.hashValue(shape);
+  }
+  return { shape, shapeKey };
+}
+function buildMutationFn(mutationDefinitionBuilder) {
+  let mutationDefinition;
+  const getMutationDefinition = () => {
+    if (mutationDefinition === void 0) {
+      const {
+        path,
+        method = "POST",
+        request,
+        response,
+        optimisticUpdates = false,
+        cache
+      } = mutationDefinitionBuilder();
+      const id = `mutation:${method}:${path}`;
+      const { shape: requestShape, shapeKey: requestShapeKey } = processTypeDef(request);
+      const { shape: responseShape, shapeKey: responseShapeKey } = processTypeDef(response);
+      const interpolatePath = createPathInterpolator(path);
+      const pathParamNames = /* @__PURE__ */ new Set();
+      const paramRegex = /\[([^\]]+)\]/g;
+      let match;
+      while ((match = paramRegex.exec(path)) !== null) {
+        pathParamNames.add(match[1]);
+      }
+      const mutateFn = async (context, requestData) => {
+        const pathParams = {};
+        for (const paramName of pathParamNames) {
+          pathParams[paramName] = requestData[paramName];
+        }
+        const url = interpolatePath(pathParams);
+        const fetchResponse = await context.fetch(url, {
+          method,
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(requestData)
+        });
+        return fetchResponse.json();
+      };
+      mutationDefinition = {
+        id,
+        requestShape,
+        requestShapeKey,
+        responseShape,
+        responseShapeKey,
+        mutateFn,
+        optimisticUpdates,
+        cache
+      };
+    }
+    return mutationDefinition;
+  };
+  const mutationFn = () => {
+    const queryClient = signalium.getContext(QueryClientContext);
+    if (queryClient === void 0) {
+      throw new Error("QueryClient not found");
+    }
+    return queryClient.getMutation(getMutationDefinition());
+  };
+  MUTATION_DEFINITION_MAP.set(mutationFn, getMutationDefinition);
+  return mutationFn;
+}
+function mutation(mutationDefinitionBuilder) {
+  return buildMutationFn(mutationDefinitionBuilder);
+}
+exports.ARRAY_KEY = ARRAY_KEY;
+exports.Mask = Mask;
+exports.MemoryEvictionManager = MemoryEvictionManager;
+exports.NetworkManager = NetworkManager;
+exports.NetworkManagerContext = NetworkManagerContext;
+exports.NetworkMode = NetworkMode;
+exports.NoOpMemoryEvictionManager = NoOpMemoryEvictionManager;
+exports.NoOpNetworkManager = NoOpNetworkManager;
+exports.NoOpRefetchManager = NoOpRefetchManager;
+exports.QueryClient = QueryClient;
+exports.QueryClientContext = QueryClientContext;
+exports.RECORD_KEY = RECORD_KEY;
+exports.RefetchInterval = RefetchInterval;
+exports.RefetchManager = RefetchManager;
+exports.addOptimisticInsert = addOptimisticInsert;
+exports.defaultNetworkManager = defaultNetworkManager;
+exports.draft = draft;
+exports.entity = entity;
+exports.infiniteQuery = infiniteQuery;
+exports.mutation = mutation;
+exports.query = query;
+exports.registerFormat = registerFormat;
+exports.removeOptimisticInsert = removeOptimisticInsert;
+exports.streamQuery = streamQuery;
+exports.t = t;
+//# sourceMappingURL=index.js.map