@epoch32/visage 1.1.3 → 1.1.4

package/dist/rpc/index.js

@@ -1,3569 +1,41 @@
-// src/form/schema.ts
-class Schema {
-  "~standard" = {
-    version: 1,
-    vendor: "visage",
-    validate: (val) => {
-      const res = this.validate(val);
-      if (res.success) {
-        return { value: res.data };
-      }
-      return {
-        issues: (res.issues || []).map((i) => ({
-          path: [i.path],
-          message: i.message
-        }))
-      };
-    }
-  };
-}
-
-class StringSchema extends Schema {
-  _min;
-  _max;
-  _emailMsg;
-  _regex;
-  _isOptional = false;
-  min(length, message) {
-    this._min = { val: length, msg: message };
-    return this;
-  }
-  max(length, message) {
-    this._max = { val: length, msg: message };
-    return this;
-  }
-  email(message) {
-    this._emailMsg = message ?? "Invalid email address";
-    return this;
-  }
-  regex(pattern, message) {
-    this._regex = { pattern, msg: message };
-    return this;
-  }
-  optional() {
-    this._isOptional = true;
-    return this;
-  }
-  validate(value, path = "") {
-    if (value === undefined || value === null || value === "") {
-      if (this._isOptional)
-        return { success: true, data: undefined };
-      return { success: false, issues: [{ path, message: "This field is required" }] };
-    }
-    if (typeof value !== "string") {
-      return { success: false, issues: [{ path, message: "Must be a string" }] };
-    }
-    if (this._min && value.length < this._min.val) {
-      return {
-        success: false,
-        issues: [{ path, message: this._min.msg ?? `Must be at least ${this._min.val} characters` }]
-      };
-    }
-    if (this._max && value.length > this._max.val) {
-      return {
-        success: false,
-        issues: [{ path, message: this._max.msg ?? `Must be at most ${this._max.val} characters` }]
-      };
-    }
-    if (this._emailMsg) {
-      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-      if (!emailRegex.test(value)) {
-        return { success: false, issues: [{ path, message: this._emailMsg }] };
-      }
-    }
-    if (this._regex && !this._regex.pattern.test(value)) {
-      return {
-        success: false,
-        issues: [{ path, message: this._regex.msg ?? "Invalid format" }]
-      };
-    }
-    return { success: true, data: value };
-  }
-}
-
-class NumberSchema extends Schema {
-  _min;
-  _max;
-  _integer;
-  _isOptional = false;
-  min(value, message) {
-    this._min = { val: value, msg: message };
-    return this;
-  }
-  max(value, message) {
-    this._max = { val: value, msg: message };
-    return this;
-  }
-  integer(message) {
-    this._integer = { msg: message };
-    return this;
-  }
-  optional() {
-    this._isOptional = true;
-    return this;
-  }
-  validate(value, path = "") {
-    if (value === undefined || value === null || value === "") {
-      if (this._isOptional)
-        return { success: true, data: undefined };
-      return { success: false, issues: [{ path, message: "This field is required" }] };
-    }
-    const num = Number(value);
-    if (Number.isNaN(num) || typeof value === "boolean") {
-      return { success: false, issues: [{ path, message: "Must be a valid number" }] };
-    }
-    if (this._integer && !Number.isInteger(num)) {
-      return {
-        success: false,
-        issues: [{ path, message: this._integer.msg ?? "Must be an integer" }]
-      };
-    }
-    if (this._min && num < this._min.val) {
-      return {
-        success: false,
-        issues: [{ path, message: this._min.msg ?? `Must be at least ${this._min.val}` }]
-      };
-    }
-    if (this._max && num > this._max.val) {
-      return {
-        success: false,
-        issues: [{ path, message: this._max.msg ?? `Must be at most ${this._max.val}` }]
-      };
-    }
-    return { success: true, data: num };
-  }
-}
-
-class BooleanSchema extends Schema {
-  validate(value, _path = "") {
-    return { success: true, data: Boolean(value) };
-  }
-}
-
-class ObjectSchema extends Schema {
-  shape;
-  constructor(shape) {
-    super();
-    this.shape = shape;
-  }
-  validate(value, basePath = "") {
-    if (typeof value !== "object" || value === null) {
-      return { success: false, issues: [{ path: basePath, message: "Must be an object" }] };
-    }
-    const issues = [];
-    const data = {};
-    for (const key in this.shape) {
-      const fieldSchema = this.shape[key];
-      const fieldVal = value[key];
-      const fieldPath = basePath ? `${basePath}.${key}` : key;
-      const res = validateWithSchema(fieldSchema, fieldVal, fieldPath);
-      if (res.success) {
-        data[key] = res.data;
-      } else if (res.issues) {
-        issues.push(...res.issues);
-      }
-    }
-    if (issues.length > 0) {
-      return { success: false, issues };
-    }
-    return { success: true, data };
-  }
-}
-function validateWithSchema(schema, value, path = "") {
-  if (!schema)
-    return { success: true, data: value };
-  if (schema instanceof Schema) {
-    return schema.validate(value, path);
-  }
-  if (typeof schema === "object" && "~standard" in schema) {
-    const res = schema["~standard"].validate(value);
-    if ("value" in res) {
-      return { success: true, data: res.value };
-    }
-    return {
-      success: false,
-      issues: res.issues.map((i) => ({
-        path: i.path ? i.path.join(".") : path,
-        message: i.message
-      }))
-    };
-  }
-  if (typeof schema === "function") {
-    const res = schema(value);
-    if (res === true || res === null || res === undefined) {
-      return { success: true, data: value };
-    }
-    if (typeof res === "string") {
-      return { success: false, issues: [{ path, message: res }] };
-    }
-    if (typeof res === "object") {
-      return res;
-    }
-  }
-  return { success: true, data: value };
-}
-var v = {
-  string: () => new StringSchema,
-  number: () => new NumberSchema,
-  boolean: () => new BooleanSchema,
-  object: (shape) => new ObjectSchema(shape)
-};
-// src/signals/types.ts
-var SubscriberState;
-((SubscriberState) => {
-  SubscriberState[SubscriberState["CLEAN"] = 0] = "CLEAN";
-  SubscriberState[SubscriberState["CHECK_DIRTY"] = 1] = "CHECK_DIRTY";
-  SubscriberState[SubscriberState["DIRTY"] = 2] = "DIRTY";
-  SubscriberState[SubscriberState["DISPOSED"] = 3] = "DISPOSED";
-})(SubscriberState ||= {});
-var SIGNAL_BRAND = Symbol("visage.signal");
-var COMPUTED_BRAND = Symbol("visage.computed");
-function isSignal(value) {
-  return typeof value === "function" && ((SIGNAL_BRAND in value) || (COMPUTED_BRAND in value));
-}
-
-// src/signals/system.ts
-var currentSubscriber = null;
-var currentScope = null;
-var batchDepth = 0;
-var pendingEffects = new Set;
-var warnedCyclicSubscribers = new WeakSet;
-var isFlushing = false;
-function setCurrentSubscriber(sub) {
-  currentSubscriber = sub;
-}
-function setCurrentScope(scope) {
-  currentScope = scope;
-}
-function getCurrentScope() {
-  return currentScope;
-}
-function addPendingEffect(eff) {
-  pendingEffects.add(eff);
-}
-function removePendingEffect(eff) {
-  pendingEffects.delete(eff);
-}
-var MAX_FLUSH_COUNT = 100;
-function flushEffects() {
-  if (isFlushing || batchDepth > 0)
-    return;
-  isFlushing = true;
-  let iterations = 0;
-  try {
-    while (pendingEffects.size > 0) {
-      if (++iterations > MAX_FLUSH_COUNT) {
-        pendingEffects.clear();
-        throw new Error(`[Visage Reactivity] Maximum update depth exceeded (${MAX_FLUSH_COUNT} cycles). ` + `An effect continuously triggered state mutations (infinite loop detected). ` + `Ensure effects that modify signals do not unconditionally depend on them, or use untrack() to read state.`);
-      }
-      const effectsToRun = Array.from(pendingEffects);
-      pendingEffects.clear();
-      for (const eff of effectsToRun) {
-        if (eff.state === 2 /* DIRTY */ || eff.state === 1 /* CHECK_DIRTY */) {
-          eff.run();
-        }
-      }
-    }
-  } finally {
-    isFlushing = false;
-  }
-}
-function batch(fn) {
-  batchDepth++;
-  try {
-    return fn();
-  } finally {
-    batchDepth--;
-    if (batchDepth === 0) {
-      flushEffects();
-    }
-  }
-}
-function untrack(fn) {
-  const prev = currentSubscriber;
-  currentSubscriber = null;
-  try {
-    return fn();
-  } finally {
-    currentSubscriber = prev;
-  }
-}
-
-// src/signals/computed.ts
-class Computed {
-  [COMPUTED_BRAND] = true;
-  _fn;
-  _value;
-  _subscribers = new Set;
-  sources = new Set;
-  sourceVersions = new Map;
-  state = 2 /* DIRTY */;
-  scope;
-  version = 0;
-  constructor(fn) {
-    this._fn = fn;
-    this.scope = currentScope;
-    if (currentScope) {
-      currentScope.addSubscriber(this);
-    }
-  }
-  get() {
-    if (this.state === 3 /* DISPOSED */) {
-      return this._fn();
-    }
-    if (currentSubscriber !== null && currentSubscriber.state !== 3 /* DISPOSED */) {
-      this._subscribers.add(currentSubscriber);
-      currentSubscriber.sources.add(this);
-      currentSubscriber.sourceVersions.set(this, this.version);
-    }
-    if (this.state === 2 /* DIRTY */ || this.state === 1 /* CHECK_DIRTY */) {
-      this.updateIfNecessary();
-    }
-    return this._value;
-  }
-  get value() {
-    return this.get();
-  }
-  removeSubscriber(sub) {
-    this._subscribers.delete(sub);
-  }
-  markDirty(targetState = 1 /* CHECK_DIRTY */) {
-    if (this.state >= targetState || this.state === 3 /* DISPOSED */) {
-      return;
-    }
-    this.state = targetState;
-    for (const sub of this._subscribers) {
-      sub.markDirty(1 /* CHECK_DIRTY */);
-    }
-  }
-  updateIfNecessary() {
-    if (this.state === 2 /* DIRTY */) {
-      const prev = this._value;
-      this.recompute();
-      return !Object.is(prev, this._value);
-    }
-    if (this.state === 1 /* CHECK_DIRTY */) {
-      let anyChanged = false;
-      for (const source of this.sources) {
-        if (source instanceof Computed) {
-          source.updateIfNecessary();
-        }
-        const lastVersion = this.sourceVersions.get(source);
-        if (lastVersion !== undefined && lastVersion !== source.version) {
-          anyChanged = true;
-        }
-      }
-      if (anyChanged) {
-        const prev = this._value;
-        this.recompute();
-        return !Object.is(prev, this._value);
-      }
-      this.state = 0 /* CLEAN */;
-      return false;
-    }
-    return false;
-  }
-  recompute() {
-    this.cleanupSources();
-    const prevSubscriber = currentSubscriber;
-    setCurrentSubscriber(this);
-    const prevScope = currentScope;
-    setCurrentScope(this.scope);
-    try {
-      const next = this._fn();
-      if (!Object.is(this._value, next)) {
-        this._value = next;
-        this.version++;
-      }
-      this.state = 0 /* CLEAN */;
-    } finally {
-      setCurrentSubscriber(prevSubscriber);
-      setCurrentScope(prevScope);
-    }
-  }
-  cleanupSources() {
-    for (const source of this.sources) {
-      source.removeSubscriber(this);
-    }
-    this.sources.clear();
-    this.sourceVersions.clear();
-  }
-  dispose() {
-    if (this.state === 3 /* DISPOSED */)
-      return;
-    this.state = 3 /* DISPOSED */;
-    this.cleanupSources();
-    this._subscribers.clear();
-  }
-}
-function computed(fn, options) {
-  const isInternal = options?.internal ?? false;
-  const customName = options?.name;
-  const c = new Computed(fn);
-  const accessor = () => c.get();
-  Object.defineProperties(accessor, {
-    [COMPUTED_BRAND]: { value: true },
-    get: { value: () => c.get() },
-    value: { get: () => c.get() }
-  });
-  if (!isInternal && typeof window !== "undefined" && window.__VISAGE_DEVTOOLS__) {
-    const devtools = window.__VISAGE_DEVTOOLS__;
-    const sigId = devtools.registerSignal({
-      name: customName,
-      type: "computed",
-      getValue: () => c.get(),
-      version: () => c.version,
-      subscribersCount: () => c._subscribers?.size ?? 0,
-      dependencies: () => Array.from(c.sources ?? []).map((src) => src._devId).filter(Boolean),
-      dependents: () => Array.from(c._subscribers ?? []).map((sub) => sub._devId).filter(Boolean)
-    });
-    c._devId = sigId;
-    if (currentScope) {
-      currentScope.addCleanup(() => {
-        devtools.unregisterSignal(sigId);
-      });
-    }
-  }
-  return accessor;
-}
-var createMemo = computed;
-// src/style/cx.ts
-function hasReactiveClass(val) {
-  if (typeof val === "function")
-    return true;
-  if (Array.isArray(val)) {
-    for (let i = 0;i < val.length; i++) {
-      if (hasReactiveClass(val[i]))
-        return true;
-    }
-    return false;
-  }
-  if (typeof val === "object" && val !== null) {
-    for (const k in val) {
-      if (typeof val[k] === "function")
-        return true;
-    }
-  }
-  return false;
-}
-function normalizeClass(val) {
-  if (!val)
-    return "";
-  if (typeof val === "function")
-    return normalizeClass(val());
-  if (typeof val === "string")
-    return val.trim();
-  if (typeof val === "number")
-    return String(val);
-  if (Array.isArray(val)) {
-    let res = "";
-    for (let i = 0;i < val.length; i++) {
-      const item = typeof val[i] === "function" ? val[i]() : val[i];
-      const itemStr = normalizeClass(item);
-      if (itemStr) {
-        res = res ? `${res} ${itemStr}` : itemStr;
-      }
-    }
-    return res;
-  }
-  if (typeof val === "object") {
-    let res = "";
-    for (const key in val) {
-      const condition = typeof val[key] === "function" ? val[key]() : val[key];
-      if (condition) {
-        res = res ? `${res} ${key}` : key;
-      }
-    }
-    return res;
-  }
-  return "";
-}
-function cx(...args) {
-  return normalizeClass(args);
-}
-
-// src/style/scale.ts
-var UNITLESS_PROPERTIES = new Set([
-  "animationIterationCount",
-  "aspectRatio",
-  "borderImageSlice",
-  "columnCount",
-  "columns",
-  "flex",
-  "flexGrow",
-  "flexShrink",
-  "flexOrder",
-  "fontWeight",
-  "lineHeight",
-  "opacity",
-  "order",
-  "orphans",
-  "scale",
-  "tabSize",
-  "widows",
-  "zIndex",
-  "zoom",
-  "fillOpacity",
-  "strokeOpacity"
-]);
-var DIMENSION_KEYWORDS = {
-  screen: "100dvh",
-  "screen-h": "100dvh",
-  "screen-w": "100dvw",
-  full: "100%",
-  half: "50%",
-  third: "33.333333%",
-  "two-thirds": "66.666667%",
-  quarter: "25%",
-  "three-quarters": "75%",
-  auto: "auto",
-  min: "min-content",
-  max: "max-content",
-  fit: "fit-content"
-};
-function space(val) {
-  if (val === undefined || val === null || val === "")
-    return "";
-  if (typeof val === "number") {
-    if (val === 0)
-      return "0px";
-    return `${val * 4}px`;
-  }
-  const str = String(val).trim();
-  if (str in DIMENSION_KEYWORDS) {
-    return DIMENSION_KEYWORDS[str];
-  }
-  return str;
-}
-function resolveDimension(val) {
-  if (val === undefined || val === null || val === "")
-    return "";
-  if (typeof val === "number") {
-    if (val === 0)
-      return "0px";
-    if (val > 48)
-      return `${val}px`;
-    return `${val * 4}px`;
-  }
-  const str = String(val).trim();
-  if (str in DIMENSION_KEYWORDS) {
-    return DIMENSION_KEYWORDS[str];
-  }
-  return str;
-}
-function px(val) {
-  return `${val}px`;
-}
-function rem(val) {
-  return `${val}rem`;
-}
-function em(val) {
-  return `${val}em`;
-}
-function fluid(minPx, maxPx, options) {
-  const minVw = options?.minVw ?? 375;
-  const maxVw = options?.maxVw ?? 1280;
-  const slope = (maxPx - minPx) / (maxVw - minVw);
-  const yIntercept = -minVw * slope + minPx;
-  const slopeVw = slope * 100;
-  const preferred = `${yIntercept.toFixed(2)}px + ${slopeVw.toFixed(2)}vw`;
-  const min = Math.min(minPx, maxPx);
-  const max = Math.max(minPx, maxPx);
-  return `clamp(${min}px, ${preferred}, ${max}px)`;
-}
-var SHADOW_PRESETS = {
-  none: "none",
-  sm: "0 1px 2px 0 rgba(0, 0, 0, 0.05)",
-  md: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)",
-  lg: "0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -4px rgba(0, 0, 0, 0.1)",
-  xl: "0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 8px 10px -6px rgba(0, 0, 0, 0.1)",
-  soft: "0 8px 30px rgba(0, 0, 0, 0.06)",
-  glow: "0 0 24px rgba(168, 85, 247, 0.35)",
-  inner: "inset 0 2px 4px 0 rgba(0, 0, 0, 0.06)"
-};
-function shadow(variant) {
-  if (variant in SHADOW_PRESETS) {
-    return SHADOW_PRESETS[variant];
-  }
-  return variant;
-}
-var RADIUS_PRESETS = {
-  none: "0px",
-  sm: "4px",
-  md: "8px",
-  lg: "12px",
-  xl: "16px",
-  "2xl": "20px",
-  "3xl": "24px",
-  full: "9999px"
-};
-function radius(variant) {
-  if (typeof variant === "number") {
-    return `${variant}px`;
-  }
-  if (variant in RADIUS_PRESETS) {
-    return RADIUS_PRESETS[variant];
-  }
-  return String(variant);
-}
-function glass(options = {}) {
-  const blurVal = typeof options.blur === "number" ? `${options.blur}px` : options.blur ?? "20px";
-  const tintVal = options.tint ?? "rgba(255, 255, 255, 0.65)";
-  const borderVal = options.border ?? "1px solid rgba(255, 255, 255, 0.75)";
-  return {
-    backdropFilter: `blur(${blurVal})`,
-    WebkitBackdropFilter: `blur(${blurVal})`,
-    backgroundColor: tintVal,
-    border: borderVal
-  };
-}
-function formatStyleProp(prop, val) {
-  if (val === null || val === undefined || val === "")
-    return "";
-  if (typeof val === "number") {
-    if (val === 0 || UNITLESS_PROPERTIES.has(prop)) {
-      return String(val);
-    }
-    return `${val}px`;
-  }
-  const str = String(val).trim();
-  if (str in DIMENSION_KEYWORDS) {
-    const lowerProp = prop.toLowerCase();
-    if (str === "screen") {
-      if (lowerProp.includes("width"))
-        return "100dvw";
-      return "100dvh";
-    }
-    return DIMENSION_KEYWORDS[str];
-  }
-  return str;
-}
-
-// src/dom/render.ts
-function isReactive(value) {
-  return isSignal(value) || typeof value === "function";
-}
-function resolveValue(val) {
-  if (typeof val === "function") {
-    return val();
-  }
-  return val;
-}
-function render(fn, container) {
-  return createRoot((dispose) => {
-    container.textContent = "";
-    const node = insertChild(container, fn());
-    onCleanup(() => {
-      if (node && node instanceof Node && node.parentNode === container) {
-        container.removeChild(node);
-      }
-    });
-    return dispose;
-  });
-}
-function setAttribute(el, key, value) {
-  if (key.startsWith("on") && typeof value === "function") {
-    const eventName = key.startsWith("onCapture") ? key.slice(9).toLowerCase() : key.slice(2).toLowerCase();
-    const useCapture = key.startsWith("onCapture");
-    el.addEventListener(eventName, value, useCapture);
-    onCleanup(() => {
-      el.removeEventListener(eventName, value, useCapture);
-    });
-    return;
-  }
-  if (key === "ref" && typeof value === "function") {
-    value(el);
-    return;
-  }
-  if (key === "class" || key === "className") {
-    if (hasReactiveClass(value)) {
-      effect(() => {
-        const cls = normalizeClass(value);
-        if (cls)
-          el.setAttribute("class", cls);
-        else
-          el.removeAttribute("class");
-      });
-    } else {
-      const cls = normalizeClass(value);
-      if (cls)
-        el.setAttribute("class", cls);
-      else
-        el.removeAttribute("class");
-    }
-    return;
-  }
-  if (isReactive(value)) {
-    effect(() => {
-      const resolved = resolveValue(value);
-      applyProp(el, key, resolved);
-    });
-  } else {
-    applyProp(el, key, value);
-  }
-}
-function setStyleProperty(el, prop, val) {
-  const formatted = formatStyleProp(prop, val);
-  if (prop.startsWith("--") || prop.includes("-")) {
-    if (formatted === "") {
-      el.style.removeProperty(prop);
-    } else {
-      el.style.setProperty(prop, formatted);
-    }
-  } else {
-    el.style[prop] = formatted;
-  }
-}
-function applyProp(el, key, value) {
-  if (value === null || value === undefined || value === false && !key.startsWith("aria-") && !key.startsWith("data-")) {
-    if (key === "className" || key === "class") {
-      el.removeAttribute("class");
-    } else if (key === "style" && typeof value === "string") {
-      el.removeAttribute("style");
-    } else if (key in el && !(el instanceof SVGElement)) {
-      try {
-        el[key] = typeof el[key] === "boolean" ? false : "";
-      } catch {
-        el.removeAttribute(key);
-      }
-    } else {
-      el.removeAttribute(key);
-    }
-    return;
-  }
-  if (key === "className" || key === "class") {
-    const cls = normalizeClass(value);
-    if (cls) {
-      el.setAttribute("class", cls);
-    } else {
-      el.removeAttribute("class");
-    }
-  } else if (key === "style") {
-    if (typeof value === "string") {
-      el.setAttribute("style", value);
-    } else if (typeof value === "object" && value !== null) {
-      for (const styleKey in value) {
-        const styleVal = value[styleKey];
-        if (isReactive(styleVal)) {
-          effect(() => {
-            setStyleProperty(el, styleKey, resolveValue(styleVal));
-          });
-        } else {
-          setStyleProperty(el, styleKey, styleVal);
-        }
-      }
-    }
-  } else if (key === "dangerouslySetInnerHTML" && value && typeof value.__html === "string") {
-    el.innerHTML = value.__html;
-  } else if (key in el && !(el instanceof SVGElement) && key !== "list" && key !== "form") {
-    try {
-      el[key] = value;
-    } catch {
-      el.setAttribute(key, String(value));
-    }
-  } else {
-    if (key.startsWith("aria-") || key.startsWith("data-")) {
-      el.setAttribute(key, String(value));
-    } else if (value === true) {
-      el.setAttribute(key, "");
-    } else {
-      el.setAttribute(key, String(value));
-    }
-  }
-}
-function insertChild(parent, child, before = null) {
-  if (child === null || child === undefined || child === false || child === true) {
-    return null;
-  }
-  if (child instanceof Node) {
-    parent.insertBefore(child, before);
-    return child;
-  }
-  if (Array.isArray(child)) {
-    const fragment = document.createDocumentFragment();
-    for (const item of child) {
-      insertChild(fragment, item);
-    }
-    parent.insertBefore(fragment, before);
-    return fragment;
-  }
-  if (isReactive(child)) {
-    const marker = document.createTextNode("");
-    parent.insertBefore(marker, before);
-    let childScope = null;
-    let currentNodes = [];
-    effect(() => {
-      const resolved = resolveValue(child);
-      if ((typeof resolved === "string" || typeof resolved === "number") && currentNodes.length === 1 && currentNodes[0].nodeType === Node.TEXT_NODE) {
-        currentNodes[0].data = String(resolved);
-        return;
-      }
-      if (childScope) {
-        childScope.dispose();
-      }
-      childScope = new Scope(getActiveScope());
-      runInScope(childScope, () => {
-        for (const node of currentNodes) {
-          if (node.parentNode) {
-            node.parentNode.removeChild(node);
-          }
-        }
-        currentNodes = [];
-        if (resolved === null || resolved === undefined || resolved === false) {
-          return;
-        }
-        const frag = document.createDocumentFragment();
-        if (typeof resolved === "string" || typeof resolved === "number" || typeof resolved === "boolean") {
-          frag.appendChild(document.createTextNode(String(resolved)));
-        } else {
-          insertChild(frag, resolved);
-        }
-        currentNodes = Array.from(frag.childNodes);
-        if (marker.parentNode) {
-          marker.parentNode.insertBefore(frag, marker);
-        }
-      });
-    });
-    onCleanup(() => {
-      if (childScope) {
-        childScope.dispose();
-      }
-      for (const node of currentNodes) {
-        if (node.parentNode) {
-          node.parentNode.removeChild(node);
-        }
-      }
-      if (marker.parentNode) {
-        marker.parentNode.removeChild(marker);
-      }
-    });
-    return marker;
-  }
-  const textNode = document.createTextNode(String(child));
-  parent.insertBefore(textNode, before);
-  return textNode;
-}
-
-// src/signals/scope.ts
-class Scope {
-  subscribers = new Set;
-  cleanups = [];
-  parent = null;
-  isDisposed = false;
-  context;
-  constructor(parent = currentScope) {
-    this.parent = parent;
-    if (parent && !parent.isDisposed) {
-      parent.cleanups.push(() => this.dispose());
-      if (parent.context) {
-        this.context = new Map(parent.context);
-      }
-    }
-  }
-  addSubscriber(sub) {
-    if (this.isDisposed)
-      return;
-    this.subscribers.add(sub);
-  }
-  addCleanup(fn) {
-    if (this.isDisposed) {
-      fn();
-      return;
-    }
-    this.cleanups.push(fn);
-  }
-  dispose() {
-    if (this.isDisposed)
-      return;
-    this.isDisposed = true;
-    for (const sub of this.subscribers) {
-      sub.dispose();
-    }
-    this.subscribers.clear();
-    for (let i = this.cleanups.length - 1;i >= 0; i--) {
-      try {
-        this.cleanups[i]();
-      } catch (err) {
-        console.error("Error during cleanup:", err);
-      }
-    }
-    this.cleanups = [];
-  }
-}
-function onCleanup(fn) {
-  if (currentSubscriber && "addCleanup" in currentSubscriber) {
-    currentSubscriber.addCleanup(fn);
-  } else if (currentScope) {
-    currentScope.addCleanup(fn);
-  }
-}
-function createRoot(fn) {
-  const prevScope = currentScope;
-  const scope = new Scope(null);
-  setCurrentScope(scope);
-  try {
-    return fn(() => scope.dispose());
-  } finally {
-    setCurrentScope(prevScope);
-  }
-}
-function runInScope(scope, fn) {
-  const prevScope = currentScope;
-  setCurrentScope(scope);
-  try {
-    return fn();
-  } finally {
-    setCurrentScope(prevScope);
-  }
-}
-function getActiveScope() {
-  return getCurrentScope();
-}
-
-// src/signals/context.ts
-function createContext(defaultValue) {
-  const id = Symbol("visage.context");
-  const context = {
-    id,
-    defaultValue,
-    Provider: (props) => {
-      const parentScope = getActiveScope();
-      const scope = new Scope(parentScope);
-      if (!scope.context) {
-        scope.context = new Map(parentScope?.context);
-      }
-      scope.context.set(id, props.value);
-      return runInScope(scope, () => {
-        const content = typeof props.children === "function" ? props.children() : props.children;
-        if (typeof document !== "undefined") {
-          const frag = document.createDocumentFragment();
-          insertChild(frag, content);
-          return frag;
-        }
-        return content;
-      });
-    }
-  };
-  return context;
-}
-function useContext(context) {
-  let scope = getActiveScope();
-  while (scope) {
-    if (scope.context?.has(context.id)) {
-      return scope.context.get(context.id);
-    }
-    scope = scope.parent;
-  }
-  return context.defaultValue;
-}
-// src/signals/effect.ts
-class Effect {
-  _fn;
-  sources = new Set;
-  sourceVersions = new Map;
-  cleanups = [];
-  state = 2 /* DIRTY */;
-  scope;
-  constructor(fn) {
-    this._fn = fn;
-    this.scope = currentScope;
-    if (currentScope) {
-      currentScope.addSubscriber(this);
-    }
-    this.run();
-  }
-  addCleanup(fn) {
-    this.cleanups.push(fn);
-  }
-  runCleanups() {
-    for (let i = this.cleanups.length - 1;i >= 0; i--) {
-      try {
-        this.cleanups[i]();
-      } catch (e) {
-        console.error("Error in effect cleanup:", e);
-      }
-    }
-    this.cleanups = [];
-  }
-  markDirty(targetState = 2 /* DIRTY */) {
-    if (this.state >= targetState || this.state === 3 /* DISPOSED */) {
-      return;
-    }
-    this.state = targetState;
-    addPendingEffect(this);
-    if (batchDepth === 0) {
-      flushEffects();
-    }
-  }
-  run() {
-    if (this.state === 3 /* DISPOSED */)
-      return;
-    if (this.state === 1 /* CHECK_DIRTY */) {
-      let isDirty = false;
-      for (const source of this.sources) {
-        if (source instanceof Computed) {
-          source.updateIfNecessary();
-        }
-        const lastVersion = this.sourceVersions.get(source);
-        if (lastVersion !== undefined && lastVersion !== source.version) {
-          isDirty = true;
-        }
-      }
-      if (!isDirty) {
-        this.state = 0 /* CLEAN */;
-        return;
-      }
-    }
-    this.runCleanups();
-    this.cleanupSources();
-    const prevSubscriber = currentSubscriber;
-    setCurrentSubscriber(this);
-    const prevScope = currentScope;
-    setCurrentScope(this.scope);
-    try {
-      this.state = 0 /* CLEAN */;
-      const res = this._fn();
-      if (typeof res === "function") {
-        this.cleanups.push(res);
-      }
-    } finally {
-      setCurrentSubscriber(prevSubscriber);
-      setCurrentScope(prevScope);
-    }
-  }
-  cleanupSources() {
-    for (const source of this.sources) {
-      source.removeSubscriber(this);
-    }
-    this.sources.clear();
-    this.sourceVersions.clear();
-  }
-  dispose() {
-    if (this.state === 3 /* DISPOSED */)
-      return;
-    this.state = 3 /* DISPOSED */;
-    this.runCleanups();
-    this.cleanupSources();
-    removePendingEffect(this);
-  }
-}
-function effect(fn) {
-  const eff = new Effect(fn);
-  return () => eff.dispose();
-}
-var createEffect = effect;
-// src/signals/signal.ts
-class Signal {
-  [SIGNAL_BRAND] = true;
-  _value;
-  _subscribers = new Set;
-  _equals;
-  _onSet;
-  version = 0;
-  constructor(initialValue, equals, onSet) {
-    this._value = initialValue;
-    this._equals = equals ?? Object.is;
-    this._onSet = onSet;
-  }
-  get() {
-    if (currentSubscriber !== null && currentSubscriber.state !== 3 /* DISPOSED */) {
-      this._subscribers.add(currentSubscriber);
-      currentSubscriber.sources.add(this);
-      currentSubscriber.sourceVersions.set(this, this.version);
-    }
-    return this._value;
-  }
-  set(newValue) {
-    if (this._equals(this._value, newValue)) {
-      return;
-    }
-    if (currentSubscriber !== null && this._subscribers.has(currentSubscriber)) {
-      if (!warnedCyclicSubscribers.has(currentSubscriber)) {
-        warnedCyclicSubscribers.add(currentSubscriber);
-        if (typeof console !== "undefined" && typeof console.warn === "function") {
-          console.warn(`[Visage Reactivity] Cyclic update detected: An active subscriber modified a signal that it depends on. ` + `To read a signal inside an effect/computed without creating a circular dependency, wrap the read in untrack():
-` + `  untrack(() => signal())`);
-        }
-      }
-    }
-    this._value = newValue;
-    this.version++;
-    if (this._onSet) {
-      this._onSet(newValue);
-    }
-    batch(() => {
-      this.notify();
-    });
-  }
-  update(fn) {
-    this.set(fn(this._value));
-  }
-  get value() {
-    return this.get();
-  }
-  set value(val) {
-    this.set(val);
-  }
-  removeSubscriber(sub) {
-    this._subscribers.delete(sub);
-  }
-  notify() {
-    if (this._subscribers.size === 0)
-      return;
-    const subs = Array.from(this._subscribers);
-    for (const sub of subs) {
-      sub.markDirty(2 /* DIRTY */);
-    }
-  }
-}
-function resolveStorage(storageOption) {
-  if (storageOption && typeof storageOption === "object") {
-    return storageOption;
-  }
-  if (storageOption === "session") {
-    try {
-      if (typeof sessionStorage !== "undefined")
-        return sessionStorage;
-    } catch {}
-    try {
-      if (typeof window !== "undefined" && window.sessionStorage) {
-        return window.sessionStorage;
-      }
-    } catch {}
-    try {
-      if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
-        return globalThis.sessionStorage;
-      }
-    } catch {}
-    return null;
-  }
-  try {
-    if (typeof localStorage !== "undefined")
-      return localStorage;
-  } catch {}
-  try {
-    if (typeof window !== "undefined" && window.localStorage) {
-      return window.localStorage;
-    }
-  } catch {}
-  try {
-    if (typeof globalThis !== "undefined" && globalThis.localStorage) {
-      return globalThis.localStorage;
-    }
-  } catch {}
-  return null;
-}
-function signal(initialValue, optionsOrEquals) {
-  const equals = typeof optionsOrEquals === "function" ? optionsOrEquals : optionsOrEquals?.equals;
-  const isInternal = typeof optionsOrEquals === "object" ? optionsOrEquals?.internal : false;
-  const customName = typeof optionsOrEquals === "object" ? optionsOrEquals?.name : undefined;
-  const persistOption = typeof optionsOrEquals === "object" ? optionsOrEquals?.persist : undefined;
-  const persistConfig = persistOption ? typeof persistOption === "string" ? { key: persistOption } : persistOption : undefined;
-  let effectiveInitial = initialValue;
-  const storage = persistConfig ? resolveStorage(persistConfig.storage) : null;
-  const serialize = persistConfig?.serialize ?? JSON.stringify;
-  const deserialize = persistConfig?.deserialize ?? JSON.parse;
-  if (persistConfig && storage) {
-    try {
-      const stored = storage.getItem(persistConfig.key);
-      if (stored !== null) {
-        effectiveInitial = deserialize(stored);
-      }
-    } catch {}
-  }
-  let isSyncing = false;
-  const onSet = persistConfig && storage ? (val) => {
-    if (isSyncing)
-      return;
-    try {
-      storage.setItem(persistConfig.key, serialize(val));
-    } catch {}
-  } : undefined;
-  const s = new Signal(effectiveInitial, equals, onSet);
-  if (persistConfig && storage && (persistConfig.syncTabs ?? true) && typeof window !== "undefined" && typeof window.addEventListener === "function") {
-    const onStorage = (e) => {
-      if (e.key === persistConfig.key) {
-        try {
-          const nextVal = e.newValue !== null ? deserialize(e.newValue) : initialValue;
-          isSyncing = true;
-          try {
-            s.set(nextVal);
-          } finally {
-            isSyncing = false;
-          }
-        } catch {}
-      }
-    };
-    window.addEventListener("storage", onStorage);
-    if (currentScope) {
-      currentScope.addCleanup(() => {
-        window.removeEventListener("storage", onStorage);
-      });
-    }
-  }
-  const accessor = (...args) => {
-    if (args.length === 0) {
-      return s.get();
-    }
-    s.set(args[0]);
-    return args[0];
-  };
-  Object.defineProperties(accessor, {
-    [SIGNAL_BRAND]: { value: true },
-    get: { value: () => s.get() },
-    set: { value: (v) => s.set(v) },
-    update: { value: (fn) => s.update(fn) },
-    value: {
-      get: () => s.get(),
-      set: (v) => s.set(v)
-    }
-  });
-  if (!isInternal && typeof window !== "undefined" && window.__VISAGE_DEVTOOLS__) {
-    const devtools = window.__VISAGE_DEVTOOLS__;
-    const sigId = devtools.registerSignal({
-      name: customName,
-      type: "signal",
-      getValue: () => s.get(),
-      version: () => s.version,
-      subscribersCount: () => s._subscribers?.size ?? 0,
-      dependents: () => Array.from(s._subscribers ?? []).map((sub) => sub._devId).filter(Boolean)
-    });
-    s._devId = sigId;
-    if (currentScope) {
-      currentScope.addCleanup(() => {
-        devtools.unregisterSignal(sigId);
-      });
-    }
-  }
-  return accessor;
-}
-function createSignal(initialValue, optionsOrEquals) {
-  const s = signal(initialValue, optionsOrEquals);
-  const setter = (value) => {
-    if (typeof value === "function") {
-      s.update(value);
-    } else {
-      s.set(value);
-    }
-  };
-  return [s, setter];
-}
-// src/signals/store.ts
-var STORE_RAW = Symbol("visage.store.raw");
-var STORE_SIGNALS = Symbol("visage.store.signals");
-var STORE_PROXY = Symbol("visage.store.proxy");
-function isObject(val) {
-  return typeof val === "object" && val !== null && (typeof Node === "undefined" || !(val instanceof Node)) && !isSignal(val);
-}
-function getOrCreatePropertySignal(target, prop) {
-  let signalsMap = target[STORE_SIGNALS];
-  if (!signalsMap) {
-    signalsMap = new Map;
-    Object.defineProperty(target, STORE_SIGNALS, {
-      value: signalsMap,
-      enumerable: false,
-      writable: true
-    });
-  }
-  let sig = signalsMap.get(prop);
-  if (!sig) {
-    sig = new Signal(target[prop]);
-    signalsMap.set(prop, sig);
-  }
-  return sig;
-}
-function createStoreProxy(target) {
-  if (!isObject(target))
-    return target;
-  if (target[STORE_PROXY])
-    return target[STORE_PROXY];
-  const proxy = new Proxy(target, {
-    get(target, prop, receiver) {
-      if (prop === STORE_RAW)
-        return target;
-      if (prop === STORE_PROXY)
-        return proxy;
-      if (typeof prop === "string" || typeof prop === "symbol") {
-        const sig = getOrCreatePropertySignal(target, prop);
-        sig.get();
-      }
-      const value = Reflect.get(target, prop, receiver);
-      if (isObject(value)) {
-        return createStoreProxy(value);
-      }
-      return value;
-    },
-    set(target, prop, value, receiver) {
-      const prevValue = Reflect.get(target, prop, receiver);
-      if (Object.is(prevValue, value)) {
-        return true;
-      }
-      const success = Reflect.set(target, prop, value, receiver);
-      if (success) {
-        const sig = getOrCreatePropertySignal(target, prop);
-        sig.set(value);
-        if (Array.isArray(target) && prop !== "length") {
-          const lenSig = getOrCreatePropertySignal(target, "length");
-          lenSig.set(target.length);
-        }
-      }
-      return success;
-    },
-    deleteProperty(target, prop) {
-      const hadProp = Reflect.has(target, prop);
-      const success = Reflect.deleteProperty(target, prop);
-      if (hadProp && success) {
-        const sig = getOrCreatePropertySignal(target, prop);
-        sig.set(undefined);
-      }
-      return success;
-    }
-  });
-  Object.defineProperty(target, STORE_PROXY, {
-    value: proxy,
-    enumerable: false,
-    writable: true
-  });
-  return proxy;
-}
-function createStore(initialState) {
-  if (!isObject(initialState)) {
-    throw new Error("createStore requires an object or array as initial state");
-  }
-  return createStoreProxy(initialState);
-}
-function mutateStore(store, mutator) {
-  batch(() => {
-    mutator(store);
-  });
-}
-function unwrapStore(store) {
-  if (isObject(store) && store[STORE_RAW]) {
-    return store[STORE_RAW];
-  }
-  return store;
-}
-// src/query/focus-manager.ts
-class FocusManager {
-  _focused;
-  _listeners = new Set;
-  _cleanup;
-  constructor() {
-    this.setupEventListener();
-  }
-  setupEventListener() {
-    if (typeof window === "undefined" || typeof window.addEventListener === "undefined") {
-      return;
-    }
-    const listener = () => {
-      this.notify(this.isFocused());
-    };
-    window.addEventListener("visibilitychange", listener, false);
-    window.addEventListener("focus", listener, false);
-    this._cleanup = () => {
-      window.removeEventListener("visibilitychange", listener);
-      window.removeEventListener("focus", listener);
-    };
-  }
-  setFocused(focused) {
-    this._focused = focused;
-    this.notify(this.isFocused());
-  }
-  isFocused() {
-    if (typeof this._focused === "boolean") {
-      return this._focused;
-    }
-    if (typeof document !== "undefined" && typeof document.visibilityState === "string") {
-      return document.visibilityState !== "hidden";
-    }
-    return true;
-  }
-  subscribe(listener) {
-    this._listeners.add(listener);
-    return () => {
-      this._listeners.delete(listener);
-    };
-  }
-  notify(focused) {
-    for (const listener of this._listeners) {
-      try {
-        listener(focused);
-      } catch (err) {
-        console.error("Error in focus listener:", err);
-      }
-    }
-  }
-  cleanup() {
-    this._cleanup?.();
-    this._listeners.clear();
-  }
-}
-var focusManager = new FocusManager;
-
-// src/query/mutation-cache.ts
-class Mutation {
-  options;
-  data;
-  error;
-  status;
-  submittedAt;
-  variables;
-  isIdle;
-  isPending;
-  isLoading;
-  isSuccess;
-  isError;
-  constructor(options) {
-    this.options = options;
-    this.data = signal(undefined);
-    this.error = signal(null);
-    this.status = signal("idle");
-    this.submittedAt = signal(0);
-    this.variables = signal(undefined);
-    this.isIdle = computed(() => this.status() === "idle");
-    this.isPending = computed(() => this.status() === "pending");
-    this.isLoading = this.isPending;
-    this.isSuccess = computed(() => this.status() === "success");
-    this.isError = computed(() => this.status() === "error");
-  }
-  async execute(variables, mutateOptions) {
-    this.status.set("pending");
-    this.error.set(null);
-    this.variables.set(variables);
-    this.submittedAt.set(Date.now());
-    let context;
-    try {
-      if (this.options.onMutate) {
-        const res = await this.options.onMutate(variables);
-        if (res !== undefined) {
-          context = res;
-        }
-      }
-      const result = await this.options.mutationFn(variables);
-      this.data.set(result);
-      this.status.set("success");
-      try {
-        await this.options.onSuccess?.(result, variables, context);
-      } catch (err) {
-        console.error("Error in mutation onSuccess:", err);
-      }
-      try {
-        mutateOptions?.onSuccess?.(result, variables, context);
-      } catch (err) {
-        console.error("Error in mutateOptions onSuccess:", err);
-      }
-      try {
-        await this.options.onSettled?.(result, null, variables, context);
-      } catch (err) {
-        console.error("Error in mutation onSettled:", err);
-      }
-      try {
-        mutateOptions?.onSettled?.(result, null, variables, context);
-      } catch (err) {
-        console.error("Error in mutateOptions onSettled:", err);
-      }
-      return result;
-    } catch (err) {
-      this.error.set(err);
-      this.status.set("error");
-      try {
-        await this.options.onError?.(err, variables, context);
-      } catch (e) {
-        console.error("Error in mutation onError:", e);
-      }
-      try {
-        mutateOptions?.onError?.(err, variables, context);
-      } catch (e) {
-        console.error("Error in mutateOptions onError:", e);
-      }
-      try {
-        await this.options.onSettled?.(undefined, err, variables, context);
-      } catch (e) {
-        console.error("Error in mutation onSettled:", e);
-      }
-      try {
-        mutateOptions?.onSettled?.(undefined, err, variables, context);
-      } catch (e) {
-        console.error("Error in mutateOptions onSettled:", e);
-      }
-      throw err;
-    }
-  }
-  reset() {
-    this.data.set(undefined);
-    this.error.set(null);
-    this.status.set("idle");
-    this.submittedAt.set(0);
-    this.variables.set(undefined);
-  }
-}
-
-class MutationCache {
-  mutations = new Set;
-  build(options) {
-    const mutation = new Mutation(options);
-    this.mutations.add(mutation);
-    return mutation;
-  }
-  remove(mutation) {
-    this.mutations.delete(mutation);
-  }
-  clear() {
-    this.mutations.clear();
-  }
-}
-
-// src/query/online-manager.ts
-class OnlineManager {
-  _online;
-  _listeners = new Set;
-  _cleanup;
-  constructor() {
-    this.setupEventListener();
-  }
-  setupEventListener() {
-    if (typeof window === "undefined" || typeof window.addEventListener === "undefined") {
-      return;
-    }
-    const onlineListener = () => this.notify(true);
-    const offlineListener = () => this.notify(false);
-    window.addEventListener("online", onlineListener, false);
-    window.addEventListener("offline", offlineListener, false);
-    this._cleanup = () => {
-      window.removeEventListener("online", onlineListener);
-      window.removeEventListener("offline", offlineListener);
-    };
-  }
-  setOnline(online) {
-    this._online = online;
-    this.notify(this.isOnline());
-  }
-  isOnline() {
-    if (typeof this._online === "boolean") {
-      return this._online;
-    }
-    if (typeof navigator !== "undefined" && typeof navigator.onLine === "boolean") {
-      return navigator.onLine;
-    }
-    return true;
-  }
-  subscribe(listener) {
-    this._listeners.add(listener);
-    return () => {
-      this._listeners.delete(listener);
-    };
-  }
-  notify(online) {
-    for (const listener of this._listeners) {
-      try {
-        listener(online);
-      } catch (err) {
-        console.error("Error in online listener:", err);
-      }
-    }
-  }
-  cleanup() {
-    this._cleanup?.();
-    this._listeners.clear();
-  }
-}
-var onlineManager = new OnlineManager;
-
-// src/query/utils.ts
-function isPlainObject(value) {
-  if (value === null || typeof value !== "object")
-    return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === null || proto === Object.prototype;
-}
-function hashKey(queryKey) {
-  return JSON.stringify(queryKey, (_key, val) => {
-    if (isPlainObject(val)) {
-      return Object.keys(val).sort().reduce((result, k) => {
-        result[k] = val[k];
-        return result;
-      }, {});
-    }
-    return val;
-  });
-}
-function deepEqual(a, b) {
-  if (Object.is(a, b))
-    return true;
-  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
-    return false;
-  }
-  if (Array.isArray(a) !== Array.isArray(b))
-    return false;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length !== b.length)
-      return false;
-    for (let i = 0;i < a.length; i++) {
-      if (!deepEqual(a[i], b[i]))
-        return false;
-    }
-    return true;
-  }
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length)
-    return false;
-  for (const key of keysA) {
-    if (!Object.hasOwn(b, key))
-      return false;
-    if (!deepEqual(a[key], b[key])) {
-      return false;
-    }
-  }
-  return true;
-}
-function partialDeepEqual(a, b) {
-  if (Object.is(a, b))
-    return true;
-  if (a === undefined || a === null || b === undefined || b === null) {
-    return a === b;
-  }
-  if (Array.isArray(a) && Array.isArray(b)) {
-    if (a.length > b.length)
-      return false;
-    for (let i = 0;i < a.length; i++) {
-      if (!partialDeepEqual(a[i], b[i]))
-        return false;
-    }
-    return true;
-  }
-  if (isPlainObject(a) && isPlainObject(b)) {
-    for (const key of Object.keys(a)) {
-      if (!(key in b))
-        return false;
-      if (!partialDeepEqual(a[key], b[key]))
-        return false;
-    }
-    return true;
-  }
-  return false;
-}
-function matchQuery(filters, query) {
-  if (!filters)
-    return true;
-  if (filters.queryKey !== undefined) {
-    const filterKey = Array.isArray(filters.queryKey) ? filters.queryKey : [filters.queryKey];
-    const queryKey = Array.isArray(query.queryKey) ? query.queryKey : [query.queryKey];
-    if (filters.exact) {
-      if (filterKey.length !== queryKey.length)
-        return false;
-      if (!deepEqual(filterKey, queryKey))
-        return false;
-    } else {
-      if (filterKey.length > queryKey.length)
-        return false;
-      for (let i = 0;i < filterKey.length; i++) {
-        if (!partialDeepEqual(filterKey[i], queryKey[i])) {
-          return false;
-        }
-      }
-    }
-  }
-  if (filters.type === "active" && query.observers.size === 0) {
-    return false;
-  }
-  if (filters.type === "inactive" && query.observers.size > 0) {
-    return false;
-  }
-  if (filters.stale !== undefined && query.isStale() !== filters.stale) {
-    return false;
-  }
-  if (filters.fetchStatus !== undefined && query.fetchStatus() !== filters.fetchStatus) {
-    return false;
-  }
-  if (filters.predicate && !filters.predicate(query)) {
-    return false;
-  }
-  return true;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/query/query-cache.ts
-function shouldRetry(failureCount, error, retry) {
-  if (retry === false)
-    return false;
-  if (retry === true)
-    return true;
-  if (typeof retry === "number")
-    return failureCount <= retry;
-  if (typeof retry === "function")
-    return retry(failureCount, error);
-  return failureCount < 3;
-}
-function getRetryDelay(attempt, error, retryDelay) {
-  if (typeof retryDelay === "function")
-    return retryDelay(attempt, error);
-  if (typeof retryDelay === "number")
-    return retryDelay;
-  return Math.min(1000 * 2 ** attempt, 30000);
-}
-
-class Query {
-  queryKey;
-  queryHash;
-  cache;
-  data;
-  error;
-  status;
-  fetchStatus;
-  dataUpdatedAt;
-  errorUpdatedAt;
-  failureCount;
-  isInvalidated;
-  observers = new Set;
-  _gcTimeout = null;
-  _abortController = null;
-  promise = null;
-  defaultGcTime = 5 * 60 * 1000;
-  constructor(options) {
-    this.queryKey = options.queryKey;
-    this.queryHash = options.queryHash;
-    this.cache = options.cache;
-    const initialData = typeof options.initialData === "function" ? options.initialData() : options.initialData;
-    const initialUpdatedAt = initialData !== undefined ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt ?? Date.now() : 0;
-    this.data = signal(initialData);
-    this.error = signal(null);
-    this.status = signal(initialData !== undefined ? "success" : "pending");
-    this.fetchStatus = signal("idle");
-    this.dataUpdatedAt = signal(initialUpdatedAt);
-    this.errorUpdatedAt = signal(0);
-    this.failureCount = signal(0);
-    this.isInvalidated = signal(false);
-  }
-  get state() {
-    return {
-      data: this.data(),
-      error: this.error(),
-      status: this.status(),
-      fetchStatus: this.fetchStatus(),
-      dataUpdatedAt: this.dataUpdatedAt(),
-      errorUpdatedAt: this.errorUpdatedAt(),
-      failureCount: this.failureCount(),
-      isInvalidated: this.isInvalidated()
-    };
-  }
-  isStale(staleTime = 0) {
-    if (this.isInvalidated())
-      return true;
-    if (this.dataUpdatedAt() === 0)
-      return true;
-    if (staleTime === Number.POSITIVE_INFINITY)
-      return false;
-    return Date.now() - this.dataUpdatedAt() >= staleTime;
-  }
-  addObserver(observer) {
-    this.observers.add(observer);
-    this.clearGcTimeout();
-  }
-  removeObserver(observer) {
-    this.observers.delete(observer);
-    if (this.observers.size === 0) {
-      this.scheduleGc(observer.options.gcTime);
-    }
-  }
-  scheduleGc(gcTime) {
-    this.clearGcTimeout();
-    const duration = gcTime !== undefined ? gcTime : this.defaultGcTime;
-    if (duration === Number.POSITIVE_INFINITY)
-      return;
-    if (duration <= 0) {
-      this.cache.remove(this);
-      return;
-    }
-    this._gcTimeout = setTimeout(() => {
-      if (this.observers.size === 0) {
-        this.cache.remove(this);
-      }
-    }, duration);
-  }
-  clearGcTimeout() {
-    if (this._gcTimeout !== null) {
-      clearTimeout(this._gcTimeout);
-      this._gcTimeout = null;
-    }
-  }
-  setData(updater, options) {
-    const prev = this.data();
-    const nextData = typeof updater === "function" ? updater(prev) : updater;
-    this.data.set(nextData);
-    this.error.set(null);
-    this.status.set("success");
-    this.isInvalidated.set(false);
-    this.dataUpdatedAt.set(options?.updatedAt ?? Date.now());
-    this.notifyObservers();
-    this.cache.notify({ type: "updated", query: this });
-    return nextData;
-  }
-  invalidate() {
-    this.isInvalidated.set(true);
-    if (this.observers.size > 0) {
-      for (const observer of this.observers) {
-        observer.onQueryUpdate();
-      }
-    }
-  }
-  cancel() {
-    if (this._abortController) {
-      this._abortController.abort();
-      this._abortController = null;
-    }
-    this.fetchStatus.set("idle");
-    this.promise = null;
-  }
-  reset() {
-    this.cancel();
-    this.data.set(undefined);
-    this.error.set(null);
-    this.status.set("pending");
-    this.fetchStatus.set("idle");
-    this.dataUpdatedAt.set(0);
-    this.errorUpdatedAt.set(0);
-    this.failureCount.set(0);
-    this.isInvalidated.set(false);
-    this.notifyObservers();
-  }
-  async fetch(options, fetchOptions) {
-    if (this.promise && !fetchOptions?.cancelRefetch) {
-      return this.promise;
-    }
-    if (this._abortController && fetchOptions?.cancelRefetch) {
-      this.cancel();
-    }
-    const controller = new AbortController;
-    this._abortController = controller;
-    this.fetchStatus.set("fetching");
-    const queryFn = options?.queryFn;
-    if (!queryFn) {
-      this.fetchStatus.set("idle");
-      throw new Error(`Missing queryFn for queryKey: ${JSON.stringify(this.queryKey)}`);
-    }
-    const execFetch = async () => {
-      let attempt = 0;
-      while (true) {
-        if (controller.signal.aborted) {
-          this.fetchStatus.set("idle");
-          this.promise = null;
-          throw new Error("Query was cancelled");
-        }
-        try {
-          const result = await queryFn({
-            queryKey: this.queryKey,
-            signal: controller.signal,
-            meta: options?.meta
-          });
-          if (controller.signal.aborted) {
-            throw new Error("Query was cancelled");
-          }
-          this.setData(result);
-          this.failureCount.set(0);
-          this.fetchStatus.set("idle");
-          this.promise = null;
-          return result;
-        } catch (err) {
-          if (controller.signal.aborted) {
-            this.fetchStatus.set("idle");
-            this.promise = null;
-            throw err;
-          }
-          attempt++;
-          this.failureCount.set(attempt);
-          const canRetry = shouldRetry(attempt, err, options?.retry);
-          if (canRetry) {
-            const delay = getRetryDelay(attempt, err, options?.retryDelay);
-            if (delay > 0) {
-              await sleep(delay);
-            }
-            continue;
-          }
-          this.error.set(err);
-          this.errorUpdatedAt.set(Date.now());
-          this.status.set("error");
-          this.fetchStatus.set("idle");
-          this.promise = null;
-          this.notifyObservers();
-          throw err;
-        }
-      }
-    };
-    this.promise = execFetch();
-    return this.promise;
-  }
-  notifyObservers() {
-    for (const observer of this.observers) {
-      observer.onQueryUpdate();
-    }
-  }
-  destroy() {
-    this.cancel();
-    this.clearGcTimeout();
-    this.observers.clear();
-  }
-}
-
-class QueryCache {
-  queries = new Map;
-  _subscribers = new Set;
-  subscribe(listener) {
-    this._subscribers.add(listener);
-    return () => this._subscribers.delete(listener);
-  }
-  notify(event) {
-    for (const sub of this._subscribers) {
-      sub(event);
-    }
-  }
-  getAll() {
-    return Array.from(this.queries.values());
-  }
-  build(_client, options) {
-    const queryHash = hashKey(options.queryKey);
-    let query = this.queries.get(queryHash);
-    if (!query) {
-      query = new Query({
-        queryKey: options.queryKey,
-        queryHash,
-        cache: this,
-        initialData: options.initialData,
-        initialDataUpdatedAt: options.initialDataUpdatedAt
-      });
-      this.add(query);
-    }
-    return query;
-  }
-  get(queryHash) {
-    return this.queries.get(queryHash);
-  }
-  add(query) {
-    this.queries.set(query.queryHash, query);
-    this.notify({ type: "added", query });
-  }
-  remove(query) {
-    const existing = this.queries.get(query.queryHash);
-    if (existing) {
-      existing.destroy();
-      this.queries.delete(query.queryHash);
-      this.notify({ type: "removed", query: existing });
-    }
-  }
-  find(filters) {
-    return this.findAll(filters)[0];
-  }
-  findAll(filters) {
-    const results = [];
-    for (const query of this.queries.values()) {
-      if (matchQuery(filters, query)) {
-        results.push(query);
-      }
-    }
-    return results;
-  }
-  clear() {
-    for (const query of this.queries.values()) {
-      query.destroy();
-    }
-    this.queries.clear();
-    this.notify({ type: "cleared" });
-  }
-}
-
-// src/query/query-client.ts
-class QueryClient {
-  queryCache;
-  mutationCache;
-  defaultOptions;
-  _unsubscribeFocus;
-  _unsubscribeOnline;
-  _isMounted = false;
-  constructor(config = {}) {
-    this.defaultOptions = config.defaultOptions ?? {};
-    this.queryCache = config.queryCache ?? new QueryCache;
-    this.mutationCache = config.mutationCache ?? new MutationCache;
-    this.mount();
-    if (typeof window !== "undefined" && window.__VISAGE_DEVTOOLS__) {
-      window.__VISAGE_DEVTOOLS__.attachQueryClient(this);
-    }
-  }
-  mount() {
-    if (this._isMounted)
-      return;
-    this._isMounted = true;
-    this._unsubscribeFocus = focusManager.subscribe((focused) => {
-      if (focused) {
-        this.onWindowFocus();
-      }
-    });
-    this._unsubscribeOnline = onlineManager.subscribe((online) => {
-      if (online) {
-        this.onOnline();
-      }
-    });
-  }
-  unmount() {
-    this._isMounted = false;
-    this._unsubscribeFocus?.();
-    this._unsubscribeOnline?.();
-  }
-  onWindowFocus() {
-    const activeQueries = this.queryCache.findAll({ type: "active" });
-    for (const query of activeQueries) {
-      const observer = Array.from(query.observers)[0];
-      const options = observer?.options ?? this.defaultOptions.queries ?? {};
-      const refetchOnFocus = options.refetchOnWindowFocus ?? true;
-      if (refetchOnFocus === "always" || refetchOnFocus && query.isStale(options.staleTime)) {
-        query.fetch(options).catch(() => {});
-      }
-    }
-  }
-  onOnline() {
-    const activeQueries = this.queryCache.findAll({ type: "active" });
-    for (const query of activeQueries) {
-      const observer = Array.from(query.observers)[0];
-      const options = observer?.options ?? this.defaultOptions.queries ?? {};
-      const refetchOnReconnect = options.refetchOnReconnect ?? true;
-      if (refetchOnReconnect === "always" || refetchOnReconnect && query.isStale(options.staleTime)) {
-        query.fetch(options).catch(() => {});
-      }
-    }
-  }
-  getDefaultOptions() {
-    return this.defaultOptions;
-  }
-  setDefaultOptions(options) {
-    this.defaultOptions = options;
-  }
-  getQueryCache() {
-    return this.queryCache;
-  }
-  getMutationCache() {
-    return this.mutationCache;
-  }
-  getQueryData(queryKey) {
-    const queryHash = hashKey(queryKey);
-    const query = this.queryCache.get(queryHash);
-    return query?.data();
-  }
-  setQueryData(queryKey, updater, options) {
-    const query = this.queryCache.build(this, {
-      queryKey,
-      ...this.defaultOptions.queries
-    });
-    return query.setData(updater, options);
-  }
-  getQueryState(queryKey) {
-    const queryHash = hashKey(queryKey);
-    const query = this.queryCache.get(queryHash);
-    return query?.state;
-  }
-  async fetchQuery(options) {
-    const mergedOptions = {
-      ...this.defaultOptions.queries,
-      ...options
-    };
-    const query = this.queryCache.build(this, mergedOptions);
-    if (!query.isStale(mergedOptions.staleTime) && query.data() !== undefined) {
-      return query.data();
-    }
-    return query.fetch(mergedOptions);
-  }
-  async prefetchQuery(options) {
-    try {
-      await this.fetchQuery(options);
-    } catch {}
-  }
-  async invalidateQueries(filters) {
-    const queries = this.queryCache.findAll(filters);
-    const promises = [];
-    for (const query of queries) {
-      query.invalidate();
-      if (query.observers.size > 0) {
-        const observer = Array.from(query.observers)[0];
-        const options = observer?.options ?? this.defaultOptions.queries ?? {};
-        promises.push(query.fetch(options).catch(() => {}));
-      }
-    }
-    await Promise.all(promises);
-  }
-  async refetchQueries(filters) {
-    const queries = this.queryCache.findAll(filters);
-    const promises = [];
-    for (const query of queries) {
-      if (query.observers.size > 0) {
-        const observer = Array.from(query.observers)[0];
-        const options = observer?.options ?? this.defaultOptions.queries ?? {};
-        promises.push(query.fetch(options, { cancelRefetch: true }).catch(() => {}));
-      }
-    }
-    await Promise.all(promises);
-  }
-  cancelQueries(filters) {
-    const queries = this.queryCache.findAll(filters);
-    for (const query of queries) {
-      query.cancel();
-    }
-  }
-  removeQueries(filters) {
-    const queries = this.queryCache.findAll(filters);
-    for (const query of queries) {
-      this.queryCache.remove(query);
-    }
-  }
-  async resetQueries(filters) {
-    const queries = this.queryCache.findAll(filters);
-    const promises = [];
-    for (const query of queries) {
-      query.reset();
-      if (query.observers.size > 0) {
-        const observer = Array.from(query.observers)[0];
-        const options = observer?.options ?? this.defaultOptions.queries ?? {};
-        promises.push(query.fetch(options).catch(() => {}));
-      }
-    }
-    await Promise.all(promises);
-  }
-  clear() {
-    this.queryCache.clear();
-    this.mutationCache.clear();
-  }
-}
-var QueryClientContext = createContext(null);
-var defaultGlobalClient = null;
-function getDefaultGlobalClient() {
-  if (!defaultGlobalClient) {
-    defaultGlobalClient = new QueryClient;
-  }
-  return defaultGlobalClient;
-}
-function QueryClientProvider(props) {
-  return QueryClientContext.Provider({
-    value: props.client,
-    children: props.children
-  });
-}
-function useQueryClient(client) {
-  if (client)
-    return client;
-  const ctxClient = useContext(QueryClientContext);
-  return ctxClient ?? getDefaultGlobalClient();
-}
-
-// src/query/create-mutation.ts
-function createMutation(options, client) {
-  const queryClient = useQueryClient(client);
-  const resolveOptions = () => typeof options === "function" ? options() : options;
-  const defaults = queryClient.getDefaultOptions().mutations ?? {};
-  const mergedOpts = { ...defaults, ...resolveOptions() };
-  const mutation = queryClient.mutationCache.build(mergedOpts);
-  const mutate = (variables, mutateOptions) => {
-    mutation.execute(variables, mutateOptions).catch(() => {});
-  };
-  const mutateAsync = (variables, mutateOptions) => {
-    return mutation.execute(variables, mutateOptions);
-  };
-  const accessor = () => {
-    return mutation.data();
-  };
-  Object.defineProperties(accessor, {
-    [SIGNAL_BRAND]: { value: true },
-    [COMPUTED_BRAND]: { value: true },
-    value: { get: () => mutation.data() },
-    mutate: { value: mutate },
-    mutateAsync: { value: mutateAsync },
-    data: { get: () => mutation.data },
-    error: { get: () => mutation.error },
-    status: { get: () => mutation.status },
-    isIdle: { get: () => mutation.isIdle },
-    isPending: { get: () => mutation.isPending },
-    isLoading: { get: () => mutation.isLoading },
-    isSuccess: { get: () => mutation.isSuccess },
-    isError: { get: () => mutation.isError },
-    reset: { value: () => mutation.reset() },
-    variables: { get: () => mutation.variables },
-    submittedAt: { get: () => mutation.submittedAt }
-  });
-  return accessor;
-}
-
-// src/dom/resource.ts
-var SuspenseContext = createContext(null);
-function createResource(sourceOrFetcher, maybeFetcher) {
-  const isDirect = typeof maybeFetcher !== "function";
-  const fetcher = isDirect ? sourceOrFetcher : maybeFetcher;
-  const source = isDirect ? null : sourceOrFetcher;
-  const data = signal(undefined);
-  const loading = signal(true);
-  const error = signal(null);
-  let currentPromise = null;
-  let requestId = 0;
-  const load = async (arg) => {
-    const currentReq = ++requestId;
-    loading.set(true);
-    error.set(null);
-    const promise = isDirect ? fetcher() : fetcher(arg);
-    currentPromise = promise;
-    const suspense = useContext(SuspenseContext);
-    if (suspense) {
-      suspense.registerPromise(promise);
-    }
-    try {
-      const res = await promise;
-      if (currentReq === requestId) {
-        data.set(res);
-        loading.set(false);
-        currentPromise = null;
-      }
-      return res;
-    } catch (err) {
-      if (currentReq === requestId) {
-        error.set(err);
-        loading.set(false);
-        currentPromise = null;
-      }
-      throw err;
-    }
-  };
-  if (source) {
-    effect(() => {
-      const sourceVal = resolveValue(source);
-      if (sourceVal !== false && sourceVal !== null && sourceVal !== undefined) {
-        load(sourceVal).catch(() => {});
-      }
-    });
-  } else {
-    load().catch(() => {});
-  }
-  const accessor = () => {
-    if (loading() && currentPromise) {
-      const suspense = useContext(SuspenseContext);
-      if (suspense) {
-        suspense.registerPromise(currentPromise);
-      }
-    }
-    return data();
-  };
-  Object.defineProperties(accessor, {
-    loading: { get: () => loading },
-    error: { get: () => error },
-    mutate: { value: (val) => data.set(val) },
-    refetch: { value: () => source ? load(resolveValue(source)) : load() }
-  });
-  return accessor;
-}
-// src/dom/async.ts
-function Suspense(props) {
-  if (typeof document === "undefined") {
-    return typeof props.children === "function" ? props.children() : props.children;
-  }
-  const marker = document.createTextNode("");
-  const initialFrag = document.createDocumentFragment();
-  const pendingCount = signal(0);
-  let currentScope = null;
-  let currentNodes = [];
-  let isMounted = false;
-  const suspenseValue = {
-    registerPromise(p) {
-      pendingCount.update((c) => c + 1);
-      p.finally(() => {
-        pendingCount.update((c) => Math.max(0, c - 1));
-      });
-    }
-  };
-  const renderContent = (content) => {
-    const parent = marker.parentNode ?? (!isMounted ? initialFrag : null);
-    if (!parent)
-      return;
-    for (const n of currentNodes) {
-      if (n.parentNode)
-        n.parentNode.removeChild(n);
-    }
-    currentNodes = [];
-    const frag = document.createDocumentFragment();
-    insertChild(frag, content);
-    currentNodes = Array.from(frag.childNodes);
-    if (marker.parentNode) {
-      marker.parentNode.insertBefore(frag, marker);
-    } else if (!isMounted) {
-      initialFrag.appendChild(frag);
-    }
-  };
-  effect(() => {
-    if (currentScope) {
-      currentScope.dispose();
-      currentScope = null;
-    }
-    currentScope = new Scope(getActiveScope());
-    runInScope(currentScope, () => {
-      let threwPromise = null;
-      let rendered = null;
-      try {
-        const SuspenseProvider = SuspenseContext.Provider;
-        rendered = SuspenseProvider({
-          value: suspenseValue,
-          children: props.children
-        });
-      } catch (err) {
-        if (err && typeof err.then === "function") {
-          threwPromise = err;
-          suspenseValue.registerPromise(err);
-        } else {
-          throw err;
-        }
-      }
-      if (pendingCount() > 0 || threwPromise) {
-        renderContent(props.fallback);
-      } else {
-        renderContent(rendered);
-      }
-    });
-  });
-  isMounted = true;
-  initialFrag.appendChild(marker);
-  onCleanup(() => {
-    if (currentScope)
-      currentScope.dispose();
-  });
-  return initialFrag;
-}
-function ErrorBoundary(props) {
-  if (typeof document === "undefined") {
-    try {
-      return typeof props.children === "function" ? props.children() : props.children;
-    } catch (err) {
-      return typeof props.fallback === "function" ? props.fallback(err, () => {}) : props.fallback;
-    }
-  }
-  const marker = document.createTextNode("");
-  const initialFrag = document.createDocumentFragment();
-  const currentError = signal(null);
-  let currentScope = null;
-  let currentNodes = [];
-  let isMounted = false;
-  const reset = () => {
-    currentError.set(null);
-  };
-  const renderNodes = (child) => {
-    const parent = marker.parentNode ?? (!isMounted ? initialFrag : null);
-    if (!parent)
-      return;
-    for (const n of currentNodes) {
-      if (n.parentNode)
-        n.parentNode.removeChild(n);
-    }
-    currentNodes = [];
-    const frag = document.createDocumentFragment();
-    insertChild(frag, child);
-    currentNodes = Array.from(frag.childNodes);
-    if (marker.parentNode) {
-      marker.parentNode.insertBefore(frag, marker);
-    } else if (!isMounted) {
-      initialFrag.appendChild(frag);
-    }
-  };
-  effect(() => {
-    const err = currentError();
-    if (currentScope) {
-      currentScope.dispose();
-      currentScope = null;
-    }
-    currentScope = new Scope(getActiveScope());
-    runInScope(currentScope, () => {
-      if (err !== null) {
-        const fallbackNode = typeof props.fallback === "function" ? props.fallback(err, reset) : props.fallback;
-        renderNodes(fallbackNode);
-      } else {
-        try {
-          const content = typeof props.children === "function" ? props.children() : props.children;
-          renderNodes(content);
-        } catch (catchedErr) {
-          currentError.set(catchedErr);
-        }
-      }
-    });
-  });
-  isMounted = true;
-  initialFrag.appendChild(marker);
-  onCleanup(() => {
-    if (currentScope)
-      currentScope.dispose();
-  });
-  return initialFrag;
-}
-
-// src/query/create-query.ts
-function createQuery(options, client) {
-  const queryClient = useQueryClient(client);
-  const resolveOptions = () => typeof options === "function" ? options() : options;
-  const currentQuery = signal(null);
-  const version = signal(0);
-  let activeObserver = null;
-  let intervalTimer = null;
-  const clearIntervalTimer = () => {
-    if (intervalTimer !== null) {
-      clearInterval(intervalTimer);
-      intervalTimer = null;
-    }
-  };
-  effect(() => {
-    const rawOpts = resolveOptions();
-    const defaults = queryClient.getDefaultOptions().queries ?? {};
-    const mergedOpts = {
-      ...defaults,
-      ...rawOpts
-    };
-    const isEnabled = typeof mergedOpts.enabled === "function" ? mergedOpts.enabled() : mergedOpts.enabled !== false;
-    const targetQuery = queryClient.queryCache.build(queryClient, mergedOpts);
-    if (untrack(currentQuery) !== targetQuery || !activeObserver) {
-      const prevQ = untrack(currentQuery);
-      if (prevQ && activeObserver) {
-        prevQ.removeObserver(activeObserver);
-      }
-      const observer = {
-        options: mergedOpts,
-        onQueryUpdate: () => {
-          version.update((v) => v + 1);
-        }
-      };
-      targetQuery.addObserver(observer);
-      activeObserver = observer;
-      currentQuery.set(targetQuery);
-    } else if (activeObserver) {
-      activeObserver.options = mergedOpts;
-    }
-    clearIntervalTimer();
-    const refetchInterval = typeof mergedOpts.refetchInterval === "function" ? mergedOpts.refetchInterval() : mergedOpts.refetchInterval;
-    if (refetchInterval && refetchInterval > 0) {
-      intervalTimer = setInterval(() => {
-        if (focusManager.isFocused() || mergedOpts.refetchIntervalInBackground) {
-          targetQuery.fetch(mergedOpts).catch(() => {});
-        }
-      }, refetchInterval);
-    }
-    if (isEnabled) {
-      untrack(() => {
-        if (targetQuery.isStale(mergedOpts.staleTime) && targetQuery.fetchStatus() === "idle") {
-          const fetchPromise = targetQuery.fetch(mergedOpts);
-          fetchPromise.catch(() => {});
-          const suspense = useContext(SuspenseContext);
-          if (suspense) {
-            suspense.registerPromise(fetchPromise);
-          }
-        }
-      });
-    }
-  });
-  onCleanup(() => {
-    clearIntervalTimer();
-    if (currentQuery() && activeObserver) {
-      currentQuery().removeObserver(activeObserver);
-    }
-  });
-  const data = computed(() => {
-    version();
-    const q = currentQuery();
-    const rawOpts = resolveOptions();
-    const rawData = q?.data();
-    if (rawData !== undefined) {
-      if (rawOpts.select) {
-        return rawOpts.select(rawData);
-      }
-      return rawData;
-    }
-    if (rawOpts.placeholderData !== undefined) {
-      return typeof rawOpts.placeholderData === "function" ? rawOpts.placeholderData(undefined) : rawOpts.placeholderData;
-    }
-    return;
-  });
-  const error = computed(() => {
-    version();
-    return currentQuery()?.error() ?? null;
-  });
-  const status = computed(() => {
-    version();
-    return currentQuery()?.status() ?? "pending";
-  });
-  const fetchStatus = computed(() => {
-    version();
-    return currentQuery()?.fetchStatus() ?? "idle";
-  });
-  const isLoading = computed(() => {
-    return status() === "pending" && fetchStatus() === "fetching";
-  });
-  const isFetching = computed(() => {
-    return fetchStatus() === "fetching";
-  });
-  const isSuccess = computed(() => {
-    return status() === "success";
-  });
-  const isError = computed(() => {
-    return status() === "error";
-  });
-  const isStale = computed(() => {
-    version();
-    const q = currentQuery();
-    const rawOpts = resolveOptions();
-    return q?.isStale(rawOpts.staleTime) ?? true;
-  });
-  const dataUpdatedAt = computed(() => {
-    version();
-    return currentQuery()?.dataUpdatedAt() ?? 0;
-  });
-  const errorUpdatedAt = computed(() => {
-    version();
-    return currentQuery()?.errorUpdatedAt() ?? 0;
-  });
-  const refetch = async (refetchOpts) => {
-    const q = untrack(() => currentQuery());
-    if (!q)
-      return;
-    const rawOpts = resolveOptions();
-    const defaults = queryClient.getDefaultOptions().queries ?? {};
-    const mergedOpts = { ...defaults, ...rawOpts };
-    const rawResult = await q.fetch(mergedOpts, { cancelRefetch: refetchOpts?.cancelRefetch });
-    if (rawOpts.select) {
-      return rawOpts.select(rawResult);
-    }
-    return rawResult;
-  };
-  const accessor = () => {
-    const q = currentQuery();
-    const rawOpts = resolveOptions();
-    if ((rawOpts.suspense || status() === "pending") && q?.promise) {
-      const suspense = useContext(SuspenseContext);
-      if (suspense) {
-        suspense.registerPromise(q.promise);
-      }
-    }
-    return data();
-  };
-  Object.defineProperties(accessor, {
-    [SIGNAL_BRAND]: { value: true },
-    [COMPUTED_BRAND]: { value: true },
-    value: { get: () => data() },
-    data: { get: () => data },
-    error: { get: () => error },
-    status: { get: () => status },
-    fetchStatus: { get: () => fetchStatus },
-    isLoading: { get: () => isLoading },
-    isFetching: { get: () => isFetching },
-    isSuccess: { get: () => isSuccess },
-    isError: { get: () => isError },
-    isStale: { get: () => isStale },
-    dataUpdatedAt: { get: () => dataUpdatedAt },
-    errorUpdatedAt: { get: () => errorUpdatedAt },
-    refetch: { value: refetch }
-  });
-  return accessor;
-}
-function createInfiniteQuery(options, client) {
-  const queryClient = useQueryClient(client);
-  const resolveOptions = () => typeof options === "function" ? options() : options;
-  const isFetchingNextPage = signal(false);
-  const isFetchingPreviousPage = signal(false);
-  const baseQuery = createQuery(() => {
-    const rawOpts = resolveOptions();
-    return {
-      ...rawOpts,
-      queryFn: async (ctx) => {
-        const pageParam = ctx.pageParam ?? rawOpts.initialPageParam;
-        const page = await rawOpts.queryFn({
-          ...ctx,
-          pageParam
-        });
-        return {
-          pages: [page],
-          pageParams: [pageParam]
-        };
-      },
-      select: undefined
-    };
-  }, queryClient);
-  const hasNextPage = computed(() => {
-    const current = baseQuery.data();
-    if (!current || current.pages.length === 0)
-      return false;
-    const rawOpts = resolveOptions();
-    const lastPage = current.pages[current.pages.length - 1];
-    const lastParam = current.pageParams[current.pageParams.length - 1];
-    const nextParam = rawOpts.getNextPageParam(lastPage, current.pages, lastParam, current.pageParams);
-    return nextParam !== undefined && nextParam !== null;
-  });
-  const hasPreviousPage = computed(() => {
-    const current = baseQuery.data();
-    if (!current || current.pages.length === 0)
-      return false;
-    const rawOpts = resolveOptions();
-    if (!rawOpts.getPreviousPageParam)
-      return false;
-    const firstPage = current.pages[0];
-    const firstParam = current.pageParams[0];
-    const prevParam = rawOpts.getPreviousPageParam(firstPage, current.pages, firstParam, current.pageParams);
-    return prevParam !== undefined && prevParam !== null;
-  });
-  const fetchNextPage = async () => {
-    const current = baseQuery.data();
-    if (!current || current.pages.length === 0)
-      return;
-    const rawOpts = resolveOptions();
-    const lastPage = current.pages[current.pages.length - 1];
-    const lastParam = current.pageParams[current.pageParams.length - 1];
-    const nextParam = rawOpts.getNextPageParam(lastPage, current.pages, lastParam, current.pageParams);
-    if (nextParam === undefined || nextParam === null) {
-      return current;
-    }
-    isFetchingNextPage.set(true);
-    try {
-      const newPage = await rawOpts.queryFn({
-        queryKey: rawOpts.queryKey,
-        signal: new AbortController().signal,
-        pageParam: nextParam,
-        meta: rawOpts.meta
-      });
-      const nextData = {
-        pages: [...current.pages, newPage],
-        pageParams: [...current.pageParams, nextParam]
-      };
-      queryClient.setQueryData(rawOpts.queryKey, nextData);
-      return nextData;
-    } finally {
-      isFetchingNextPage.set(false);
-    }
-  };
-  const fetchPreviousPage = async () => {
-    const current = baseQuery.data();
-    if (!current || current.pages.length === 0)
-      return;
-    const rawOpts = resolveOptions();
-    if (!rawOpts.getPreviousPageParam)
-      return current;
-    const firstPage = current.pages[0];
-    const firstParam = current.pageParams[0];
-    const prevParam = rawOpts.getPreviousPageParam(firstPage, current.pages, firstParam, current.pageParams);
-    if (prevParam === undefined || prevParam === null) {
-      return current;
-    }
-    isFetchingPreviousPage.set(true);
-    try {
-      const newPage = await rawOpts.queryFn({
-        queryKey: rawOpts.queryKey,
-        signal: new AbortController().signal,
-        pageParam: prevParam,
-        meta: rawOpts.meta
-      });
-      const nextData = {
-        pages: [newPage, ...current.pages],
-        pageParams: [prevParam, ...current.pageParams]
-      };
-      queryClient.setQueryData(rawOpts.queryKey, nextData);
-      return nextData;
-    } finally {
-      isFetchingPreviousPage.set(false);
-    }
-  };
-  const accessor = () => {
-    return baseQuery();
-  };
-  Object.defineProperties(accessor, {
-    [SIGNAL_BRAND]: { value: true },
-    [COMPUTED_BRAND]: { value: true },
-    value: { get: () => baseQuery.data() },
-    data: { get: () => baseQuery.data },
-    error: { get: () => baseQuery.error },
-    status: { get: () => baseQuery.status },
-    fetchStatus: { get: () => baseQuery.fetchStatus },
-    isLoading: { get: () => baseQuery.isLoading },
-    isFetching: { get: () => baseQuery.isFetching },
-    isSuccess: { get: () => baseQuery.isSuccess },
-    isError: { get: () => baseQuery.isError },
-    isStale: { get: () => baseQuery.isStale },
-    dataUpdatedAt: { get: () => baseQuery.dataUpdatedAt },
-    errorUpdatedAt: { get: () => baseQuery.errorUpdatedAt },
-    refetch: { value: baseQuery.refetch },
-    fetchNextPage: { value: fetchNextPage },
-    fetchPreviousPage: { value: fetchPreviousPage },
-    hasNextPage: { get: () => hasNextPage },
-    hasPreviousPage: { get: () => hasPreviousPage },
-    isFetchingNextPage: { get: () => isFetchingNextPage },
-    isFetchingPreviousPage: { get: () => isFetchingPreviousPage }
-  });
-  return accessor;
-}
-
-// src/rpc/error.ts
-var ERROR_CODE_TO_STATUS = {
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  METHOD_NOT_ALLOWED: 405,
-  TIMEOUT: 408,
-  CONFLICT: 409,
-  UNPROCESSABLE_CONTENT: 422,
-  INTERNAL_SERVER_ERROR: 500
-};
-var STATUS_TO_ERROR_CODE = {
-  400: "BAD_REQUEST",
-  401: "UNAUTHORIZED",
-  403: "FORBIDDEN",
-  404: "NOT_FOUND",
-  405: "METHOD_NOT_ALLOWED",
-  408: "TIMEOUT",
-  409: "CONFLICT",
-  422: "UNPROCESSABLE_CONTENT",
-  500: "INTERNAL_SERVER_ERROR"
-};
-
-class RPCError extends Error {
-  code;
-  status;
-  issues;
-  constructor(codeOrStatusOrOptions, message) {
-    if (typeof codeOrStatusOrOptions === "number") {
-      const code = STATUS_TO_ERROR_CODE[codeOrStatusOrOptions] || "INTERNAL_SERVER_ERROR";
-      super(message || code);
-      this.name = "RPCError";
-      this.code = code;
-      this.status = codeOrStatusOrOptions;
-    } else if (typeof codeOrStatusOrOptions === "string") {
-      super(message || codeOrStatusOrOptions);
-      this.name = "RPCError";
-      this.code = codeOrStatusOrOptions;
-      this.status = ERROR_CODE_TO_STATUS[codeOrStatusOrOptions] || 500;
-    } else {
-      super(codeOrStatusOrOptions.message ?? codeOrStatusOrOptions.code, {
-        cause: codeOrStatusOrOptions.cause
-      });
-      this.name = "RPCError";
-      this.code = codeOrStatusOrOptions.code;
-      this.status = ERROR_CODE_TO_STATUS[codeOrStatusOrOptions.code] ?? 500;
-      this.issues = codeOrStatusOrOptions.issues;
-    }
-  }
-  get statusCode() {
-    return this.status;
-  }
-}
-
-// src/rpc/procedure.ts
-function createProcedure(type, options, middlewares = []) {
-  return {
-    type,
-    inputSchema: options.input,
-    outputSchema: options.output,
-    middlewares: [...middlewares],
-    resolve: options.resolve
-  };
-}
-async function executeProcedure(procedure, opts) {
-  let input = opts.rawInput;
-  if (procedure.inputSchema) {
-    const res = validateWithSchema(procedure.inputSchema, opts.rawInput);
-    if (!res.success) {
-      throw new RPCError({
-        code: "BAD_REQUEST",
-        message: "Invalid procedure input",
-        issues: res.issues
-      });
-    }
-    input = res.data;
-  }
-  let currentIndex = 0;
-  let currentContext = opts.ctx;
-  const runPipeline = async (ctx) => {
-    currentContext = ctx;
-    if (currentIndex < procedure.middlewares.length) {
-      const mw = procedure.middlewares[currentIndex++];
-      return mw({
-        ctx: currentContext,
-        req: opts.req,
-        signal: opts.signal,
-        next: async (nextOpts) => {
-          return runPipeline(nextOpts?.ctx ?? currentContext);
-        }
-      });
-    }
-    return procedure.resolve({
-      input,
-      ctx: currentContext,
-      req: opts.req,
-      signal: opts.signal
-    });
-  };
-  const output = await runPipeline(currentContext);
-  if (procedure.outputSchema && procedure.type !== "subscription") {
-    const res = validateWithSchema(procedure.outputSchema, output);
-    if (!res.success) {
-      throw new RPCError({
-        code: "INTERNAL_SERVER_ERROR",
-        message: "Invalid procedure output",
-        issues: res.issues
-      });
-    }
-    return res.data;
-  }
-  return output;
-}
-
-// src/rpc/server.ts
-function getCORSHeaders(cors, req) {
-  const headers = new Headers;
-  if (!cors)
-    return headers;
-  const opts = typeof cors === "object" ? cors : {};
-  const originHeader = req.headers.get("origin") ?? "*";
-  let allowOrigin = "*";
-  if (typeof opts.origin === "function") {
-    const res = opts.origin(originHeader);
-    if (typeof res === "string")
-      allowOrigin = res;
-    else if (res)
-      allowOrigin = originHeader;
-  } else if (typeof opts.origin === "string") {
-    allowOrigin = opts.origin;
-  } else if (Array.isArray(opts.origin)) {
-    if (opts.origin.includes(originHeader))
-      allowOrigin = originHeader;
-  } else {
-    allowOrigin = originHeader || "*";
-  }
-  headers.set("Access-Control-Allow-Origin", allowOrigin);
-  headers.set("Access-Control-Allow-Methods", (opts.methods ?? ["GET", "POST", "OPTIONS", "HEAD"]).join(", "));
-  headers.set("Access-Control-Allow-Headers", (opts.allowedHeaders ?? ["Content-Type", "Authorization", "X-Requested-With"]).join(", "));
-  if (opts.exposedHeaders) {
-    headers.set("Access-Control-Expose-Headers", opts.exposedHeaders.join(", "));
-  }
-  if (opts.credentials) {
-    headers.set("Access-Control-Allow-Credentials", "true");
-  }
-  if (opts.maxAge !== undefined) {
-    headers.set("Access-Control-Max-Age", opts.maxAge.toString());
-  }
-  return headers;
-}
-function resolveProcedureFromPath(router, path) {
-  const parts = path.split(/[./]/).filter(Boolean);
-  let current = router._def.record;
-  for (let i = 0;i < parts.length; i++) {
-    const part = parts[i];
-    if (!current || typeof current !== "object") {
-      throw new RPCError({
-        code: "NOT_FOUND",
-        message: `Procedure '${path}' not found`
-      });
-    }
-    if (i === parts.length - 1) {
-      if (part in current && "type" in current[part]) {
-        return current[part];
-      }
-      throw new RPCError({
-        code: "NOT_FOUND",
-        message: `Procedure '${path}' not found`
-      });
-    }
-    if (part in current && "_def" in current[part]) {
-      current = current[part]._def.record;
-    } else if (part in current && typeof current[part] === "object") {
-      current = current[part];
-    } else {
-      throw new RPCError({
-        code: "NOT_FOUND",
-        message: `Procedure '${path}' not found`
-      });
-    }
-  }
-  throw new RPCError({
-    code: "NOT_FOUND",
-    message: `Procedure '${path}' not found`
-  });
-}
-function matchesRulePattern(pattern, urlPath, procedurePath) {
-  if (pattern === "*")
-    return true;
-  const cleanUrl = urlPath.replace(/^\/+|\/+$/g, "");
-  const cleanPattern = pattern.replace(/^\/+|\/+$/g, "");
-  const cleanProc = procedurePath.replace(/^\/+|\/+$/g, "");
-  if (cleanUrl === cleanPattern || cleanProc === cleanPattern || cleanProc === cleanPattern.replace(/\//g, ".")) {
-    return true;
-  }
-  if (cleanPattern.endsWith("*")) {
-    const prefix = cleanPattern.slice(0, -1);
-    if (cleanUrl.startsWith(prefix) || cleanProc.startsWith(prefix)) {
-      return true;
-    }
-    const dotPrefix = prefix.replace(/\//g, ".");
-    if (cleanProc.startsWith(dotPrefix)) {
-      return true;
-    }
-  }
-  try {
-    const regexStr = cleanPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-    const regex = new RegExp(`^${regexStr}$`);
-    return regex.test(cleanUrl) || regex.test(cleanProc);
-  } catch {
-    return false;
-  }
-}
-function createFetchHandler(options) {
-  const {
-    router,
-    endpoint = "",
-    createContext,
-    onError,
-    cors = true,
-    securityHeaders = true,
-    rules
-  } = options;
-  return async (request, ...extra) => {
-    const corsHeaders = getCORSHeaders(cors, request);
-    if (request.method === "OPTIONS") {
-      return new Response(null, {
-        status: 204,
-        headers: corsHeaders
-      });
-    }
-    const baseHeaders = new Headers(corsHeaders);
-    if (securityHeaders) {
-      if (typeof securityHeaders === "object") {
-        for (const [k, v] of Object.entries(securityHeaders)) {
-          baseHeaders.set(k, v);
-        }
-      } else {
-        baseHeaders.set("X-Content-Type-Options", "nosniff");
-      }
-    }
-    const url = new URL(request.url);
-    let pathname = url.pathname;
-    if (endpoint && pathname.startsWith(endpoint)) {
-      pathname = pathname.slice(endpoint.length);
-    }
-    pathname = pathname.replace(/^\/+|\/+$/g, "");
-    const procedurePath = pathname || url.searchParams.get("procedure") || "";
-    let ctx = {};
-    try {
-      if (createContext) {
-        ctx = await createContext({ req: request, extra });
-      }
-    } catch (err) {
-      const error = err instanceof RPCError ? err : new RPCError({
-        code: "UNAUTHORIZED",
-        message: err.message ?? "Context initialization failed",
-        cause: err
-      });
-      onError?.({ error, req: request });
-      baseHeaders.set("Content-Type", "application/json");
-      return new Response(JSON.stringify({
-        error: {
-          code: error.code,
-          message: error.message,
-          issues: error.issues
-        }
-      }), {
-        status: error.status,
-        headers: baseHeaders
-      });
-    }
-    const rulesList = [];
-    if (rules) {
-      if (Array.isArray(rules)) {
-        rulesList.push(...rules);
-      } else {
-        for (const [match, rule] of Object.entries(rules)) {
-          rulesList.push({ match, ...rule });
-        }
-      }
-    }
-    const matchingRules = rulesList.filter((r) => matchesRulePattern(r.match, url.pathname, procedurePath));
-    for (const rule of matchingRules) {
-      if (rule.requireHeaders) {
-        for (const headerName of rule.requireHeaders) {
-          if (!request.headers.get(headerName)) {
-            const error = new RPCError({
-              code: "UNAUTHORIZED",
-              message: `Missing required header '${headerName}' for rule '${rule.match}'`
-            });
-            onError?.({ error, path: procedurePath, req: request });
-            baseHeaders.set("Content-Type", "application/json");
-            return new Response(JSON.stringify({
-              error: {
-                code: error.code,
-                message: error.message
-              }
-            }), {
-              status: 401,
-              headers: baseHeaders
-            });
-          }
-        }
-      }
-      if (rule.requireParams) {
-        for (const paramName of rule.requireParams) {
-          if (!url.searchParams.has(paramName)) {
-            const error = new RPCError({
-              code: "BAD_REQUEST",
-              message: `Missing required query parameter '${paramName}' for rule '${rule.match}'`
-            });
-            onError?.({ error, path: procedurePath, req: request });
-            baseHeaders.set("Content-Type", "application/json");
-            return new Response(JSON.stringify({
-              error: {
-                code: error.code,
-                message: error.message
-              }
-            }), {
-              status: 400,
-              headers: baseHeaders
-            });
-          }
-        }
-      }
-      if (rule.guard) {
-        try {
-          const guardResult = await rule.guard({ req: request, ctx, path: procedurePath });
-          if (guardResult === false) {
-            throw new RPCError({
-              code: "UNAUTHORIZED",
-              message: `Access denied by route rule guard for '${rule.match}'`
-            });
-          }
-        } catch (err) {
-          const error = err instanceof RPCError ? err : new RPCError({
-            code: "UNAUTHORIZED",
-            message: err.message ?? "Unauthorized",
-            cause: err
-          });
-          onError?.({ error, path: procedurePath, req: request });
-          baseHeaders.set("Content-Type", "application/json");
-          return new Response(JSON.stringify({
-            error: {
-              code: error.code,
-              message: error.message
-            }
-          }), {
-            status: error.status,
-            headers: baseHeaders
-          });
-        }
-      }
-      if (rule.headers) {
-        const resHeaders = typeof rule.headers === "function" ? await rule.headers(request, ctx) : rule.headers;
-        for (const [k, v] of Object.entries(resHeaders)) {
-          baseHeaders.set(k, v);
-        }
-      }
-    }
-    if (request.method === "POST" && (!pathname || pathname === "batch")) {
-      try {
-        const body = await request.json();
-        if (Array.isArray(body)) {
-          const batchResults = await Promise.all(body.map(async (item) => {
-            try {
-              const proc = resolveProcedureFromPath(router, item.path);
-              const data = await executeProcedure(proc, {
-                rawInput: item.input,
-                ctx,
-                req: request,
-                signal: request.signal
-              });
-              return {
-                id: item.id,
-                result: { data }
-              };
-            } catch (err) {
-              const error = err instanceof RPCError ? err : new RPCError({
-                code: "INTERNAL_SERVER_ERROR",
-                message: err.message ?? "Internal Server Error",
-                cause: err
-              });
-              onError?.({ error, path: item.path, req: request });
-              return {
-                id: item.id,
-                error: {
-                  code: error.code,
-                  message: error.message,
-                  issues: error.issues
-                }
-              };
-            }
-          }));
-          baseHeaders.set("Content-Type", "application/json");
-          return new Response(JSON.stringify(batchResults), {
-            status: 200,
-            headers: baseHeaders
-          });
-        }
-      } catch (err) {
-        const error = new RPCError({
-          code: "BAD_REQUEST",
-          message: "Malformed batch request body",
-          cause: err
-        });
-        baseHeaders.set("Content-Type", "application/json");
-        return new Response(JSON.stringify({
-          error: {
-            code: error.code,
-            message: error.message
-          }
-        }), {
-          status: 400,
-          headers: baseHeaders
-        });
-      }
-    }
-    try {
-      const procedure = resolveProcedureFromPath(router, procedurePath);
-      if (procedure.type === "mutation" && request.method !== "POST") {
-        throw new RPCError({
-          code: "METHOD_NOT_ALLOWED",
-          message: "Mutations must use POST method"
-        });
-      }
-      let rawInput;
-      if (request.method === "GET") {
-        const inputParam = url.searchParams.get("input");
-        if (inputParam !== null) {
-          try {
-            rawInput = JSON.parse(inputParam);
-          } catch {
-            rawInput = inputParam;
-          }
-        }
-      } else if (request.method === "POST") {
-        try {
-          const body = await request.json();
-          rawInput = body && typeof body === "object" && "input" in body ? body.input : body;
-        } catch {
-          rawInput = undefined;
-        }
-      }
-      if (procedure.type === "subscription") {
-        const iterable = await executeProcedure(procedure, {
-          rawInput,
-          ctx,
-          req: request,
-          signal: request.signal
-        });
-        if (!iterable || typeof iterable[Symbol.asyncIterator] !== "function") {
-          throw new RPCError({
-            code: "INTERNAL_SERVER_ERROR",
-            message: "Subscription procedure must return an AsyncIterable"
-          });
-        }
-        const encoder = new TextEncoder;
-        const stream = new ReadableStream({
-          async start(controller) {
-            try {
-              for await (const chunk of iterable) {
-                if (request.signal.aborted)
-                  break;
-                const message = `data: ${JSON.stringify(chunk)}
-
-`;
-                controller.enqueue(encoder.encode(message));
-              }
-              controller.close();
-            } catch (err) {
-              const errorMessage = `event: error
-data: ${JSON.stringify({ message: err.message ?? "Stream error" })}
-
-`;
-              controller.enqueue(encoder.encode(errorMessage));
-              controller.close();
-            }
-          },
-          cancel() {
-            if (typeof iterable.return === "function") {
-              iterable.return();
-            }
-          }
-        });
-        baseHeaders.set("Content-Type", "text/event-stream; charset=utf-8");
-        baseHeaders.set("Cache-Control", "no-cache, no-transform");
-        baseHeaders.set("Connection", "keep-alive");
-        return new Response(stream, {
-          status: 200,
-          headers: baseHeaders
-        });
-      }
-      const data = await executeProcedure(procedure, {
-        rawInput,
-        ctx,
-        req: request,
-        signal: request.signal
-      });
-      const responsePayload = {
-        result: { data }
-      };
-      baseHeaders.set("Content-Type", "application/json");
-      return new Response(JSON.stringify(responsePayload), {
-        status: 200,
-        headers: baseHeaders
-      });
-    } catch (err) {
-      const error = err instanceof RPCError ? err : new RPCError({
-        code: "INTERNAL_SERVER_ERROR",
-        message: err.message ?? "Internal Server Error",
-        cause: err
-      });
-      onError?.({ error, path: procedurePath, req: request });
-      const responsePayload = {
-        error: {
-          code: error.code,
-          message: error.message,
-          issues: error.issues
-        }
-      };
-      baseHeaders.set("Content-Type", "application/json");
-      return new Response(JSON.stringify(responsePayload), {
-        status: ERROR_CODE_TO_STATUS[error.code] ?? 500,
-        headers: baseHeaders
-      });
-    }
-  };
-}
-
-// src/rpc/client.ts
-async function resolveHeaders(headers, fullPath = "") {
-  if (!headers)
-    return {};
-  if (typeof headers === "function") {
-    return await headers();
-  }
-  const result = {};
-  for (const [key, val] of Object.entries(headers)) {
-    if (typeof val === "object" || typeof val === "function") {
-      if (matchesRulePattern(key, fullPath, fullPath)) {
-        const resolved = typeof val === "function" ? await val() : val;
-        if (resolved && typeof resolved === "object") {
-          Object.assign(result, resolved);
-        }
-      }
-    } else if (typeof val === "string") {
-      result[key] = val;
-    }
-  }
-  return result;
-}
-function createProxyPath(options, path = []) {
-  return new Proxy({}, {
-    get(_target, prop) {
-      if (prop === "then")
-        return;
-      if (prop === "query") {
-        return async (input, callOpts) => {
-          const fetchFn = options.fetch ?? globalThis.fetch;
-          const baseUrl = options.baseUrl.replace(/\/+$/, "");
-          const fullPath = path.join(".");
-          let url = `${baseUrl}/${fullPath}`;
-          if (input !== undefined) {
-            const serialized = JSON.stringify(input);
-            url += `${url.includes("?") ? "&" : "?"}input=${encodeURIComponent(serialized)}`;
-          }
-          const dynamicHeaders = await resolveHeaders(options.headers, fullPath);
-          const headers = {
-            Accept: "application/json",
-            ...dynamicHeaders,
-            ...callOpts?.headers
-          };
-          const devtools = typeof window !== "undefined" ? window.__VISAGE_DEVTOOLS__ : null;
-          const logId = devtools?.logRpcCall({
-            id: `rpc_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
-            path: fullPath,
-            type: "query",
-            input
-          });
-          try {
-            const res = await fetchFn(url, {
-              method: "GET",
-              headers,
-              signal: callOpts?.signal
-            });
-            const body = await res.json();
-            if ("error" in body) {
-              devtools?.updateRpcCall(logId, { status: "error", error: body.error });
-              throw new RPCError({
-                code: body.error.code,
-                message: body.error.message,
-                issues: body.error.issues
-              });
-            }
-            devtools?.updateRpcCall(logId, { status: "success", response: body.result.data });
-            return body.result.data;
-          } catch (err) {
-            devtools?.updateRpcCall(logId, { status: "error", error: err });
-            throw err;
-          }
-        };
-      }
-      if (prop === "mutate") {
-        return async (input, callOpts) => {
-          const fetchFn = options.fetch ?? globalThis.fetch;
-          const baseUrl = options.baseUrl.replace(/\/+$/, "");
-          const fullPath = path.join(".");
-          const url = `${baseUrl}/${fullPath}`;
-          const dynamicHeaders = await resolveHeaders(options.headers, fullPath);
-          const headers = {
-            "Content-Type": "application/json",
-            Accept: "application/json",
-            ...dynamicHeaders,
-            ...callOpts?.headers
-          };
-          const devtools = typeof window !== "undefined" ? window.__VISAGE_DEVTOOLS__ : null;
-          const logId = devtools?.logRpcCall({
-            id: `rpc_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
-            path: fullPath,
-            type: "mutation",
-            input
-          });
-          try {
-            const res = await fetchFn(url, {
-              method: "POST",
-              headers,
-              body: JSON.stringify({ input }),
-              signal: callOpts?.signal
-            });
-            const body = await res.json();
-            if ("error" in body) {
-              devtools?.updateRpcCall(logId, { status: "error", error: body.error });
-              throw new RPCError({
-                code: body.error.code,
-                message: body.error.message,
-                issues: body.error.issues
-              });
-            }
-            devtools?.updateRpcCall(logId, { status: "success", response: body.result.data });
-            return body.result.data;
-          } catch (err) {
-            devtools?.updateRpcCall(logId, { status: "error", error: err });
-            throw err;
-          }
-        };
-      }
-      if (prop === "subscribe") {
-        return (input, callbacks) => {
-          const fetchFn = options.fetch ?? globalThis.fetch;
-          const baseUrl = options.baseUrl.replace(/\/+$/, "");
-          const fullPath = path.join(".");
-          let url = `${baseUrl}/${fullPath}`;
-          if (input !== undefined) {
-            const serialized = JSON.stringify(input);
-            url += `${url.includes("?") ? "&" : "?"}input=${encodeURIComponent(serialized)}`;
-          }
-          const controller = new AbortController;
-          const devtools = typeof window !== "undefined" ? window.__VISAGE_DEVTOOLS__ : null;
-          const logId = devtools?.logRpcCall({
-            id: `rpc_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
-            path: fullPath,
-            type: "subscription",
-            input
-          });
-          (async () => {
-            try {
-              const dynamicHeaders = await resolveHeaders(options.headers, fullPath);
-              const headers = {
-                Accept: "text/event-stream",
-                ...dynamicHeaders
-              };
-              const res = await fetchFn(url, {
-                method: "GET",
-                headers,
-                signal: controller.signal
-              });
-              if (!res.ok || !res.body) {
-                throw new Error(`Subscription connection failed with status ${res.status}`);
-              }
-              const reader = res.body.getReader();
-              const decoder = new TextDecoder;
-              let buffer = "";
-              while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                  break;
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split(`
-
-`);
-                buffer = lines.pop() ?? "";
-                for (const line of lines) {
-                  const trimmed = line.trim();
-                  if (trimmed.startsWith("data:")) {
-                    const jsonStr = trimmed.slice(5).trim();
-                    try {
-                      const parsed = JSON.parse(jsonStr);
-                      devtools?.logRpcEvent(logId, parsed);
-                      callbacks.onData(parsed);
-                    } catch (parseErr) {
-                      devtools?.updateRpcCall(logId, { status: "error", error: parseErr });
-                      callbacks.onError?.(parseErr);
-                    }
-                  } else if (trimmed.startsWith("event: error")) {
-                    devtools?.updateRpcCall(logId, { status: "error" });
-                    callbacks.onError?.(new Error("Server event stream error"));
-                  }
-                }
-              }
-              callbacks.onComplete?.();
-            } catch (err) {
-              if (!controller.signal.aborted) {
-                callbacks.onError?.(err);
-              }
-            }
-          })();
-          return {
-            unsubscribe: () => {
-              controller.abort();
-            }
-          };
-        };
-      }
-      if (prop === "queryKey") {
-        return (input) => {
-          const resolvedInput = typeof input === "function" ? input() : input;
-          const key = [...path];
-          if (resolvedInput !== undefined) {
-            key.push(resolvedInput);
-          }
-          return key;
-        };
-      }
-      if (prop === "queryOptions") {
-        return (input, extra) => {
-          const resolvedInput = typeof input === "function" ? input() : input;
-          const key = [...path];
-          if (resolvedInput !== undefined) {
-            key.push(resolvedInput);
-          }
-          return {
-            queryKey: key,
-            queryFn: ({ signal }) => {
-              const queryFn = createProxyPath(options, path).query;
-              return queryFn(resolvedInput, { signal });
-            },
-            ...extra
-          };
-        };
-      }
-      if (prop === "createQuery" || prop === "useQuery") {
-        return (input, extra) => {
-          const proxy = createProxyPath(options, path);
-          return createQuery(() => proxy.queryOptions(input, extra));
-        };
-      }
-      if (prop === "mutationKey") {
-        return () => [...path];
-      }
-      if (prop === "mutationOptions") {
-        return (extra) => {
-          return {
-            mutationKey: [...path],
-            mutationFn: (input) => {
-              const mutateFn = createProxyPath(options, path).mutate;
-              return mutateFn(input);
-            },
-            ...extra
-          };
-        };
-      }
-      if (prop === "createMutation" || prop === "useMutation") {
-        return (extra) => {
-          const proxy = createProxyPath(options, path);
-          return createMutation(proxy.mutationOptions(extra));
-        };
-      }
-      return createProxyPath(options, [...path, prop]);
-    }
-  });
-}
-function createClient(options) {
-  return createProxyPath(options, []);
-}
-// src/rpc/router.ts
-class RouterImpl {
-  _def;
-  constructor(record = {}, middlewares = []) {
-    this._def = {
-      record: { ...record },
-      middlewares: [...middlewares]
-    };
-  }
-  query(name, options) {
-    const proc = createProcedure("query", options, this._def.middlewares);
-    const newRecord = {
-      ...this._def.record,
-      [name]: proc
-    };
-    return new RouterImpl(newRecord, this._def.middlewares);
-  }
-  mutation(name, options) {
-    const proc = createProcedure("mutation", options, this._def.middlewares);
-    const newRecord = {
-      ...this._def.record,
-      [name]: proc
-    };
-    return new RouterImpl(newRecord, this._def.middlewares);
-  }
-  subscription(name, options) {
-    const proc = createProcedure("subscription", options, this._def.middlewares);
-    const newRecord = {
-      ...this._def.record,
-      [name]: proc
-    };
-    return new RouterImpl(newRecord, this._def.middlewares);
-  }
-  use(middleware) {
-    const updatedMiddlewares = [...this._def.middlewares, middleware];
-    const updatedRecord = {};
-    for (const key in this._def.record) {
-      const item = this._def.record[key];
-      if ("type" in item) {
-        updatedRecord[key] = {
-          ...item,
-          middlewares: [...updatedMiddlewares]
-        };
-      } else {
-        updatedRecord[key] = item;
-      }
-    }
-    return new RouterImpl(updatedRecord, updatedMiddlewares);
-  }
-  merge(prefix, router) {
-    const newRecord = {
-      ...this._def.record,
-      [prefix]: router
-    };
-    return new RouterImpl(newRecord, this._def.middlewares);
-  }
-}
-function createRouter(record) {
-  return new RouterImpl(record ?? {});
-}
-function query(options) {
-  return createProcedure("query", options);
-}
-function mutation(options) {
-  return createProcedure("mutation", options);
-}
-function subscription(options) {
-  return createProcedure("subscription", options);
-}
+import {
+  createClient2,
+  RouterImpl2,
+  createRouter2,
+  query3,
+  mutation3,
+  subscription3
+} from "../index-df5e614s.js";
+import {
+  ERROR_CODE_TO_STATUS2,
+  STATUS_TO_ERROR_CODE2,
+  RPCError2,
+  createProcedure2,
+  executeProcedure2,
+  createFetchHandler2
+} from "../index-965ryh36.js";
+import {
+  Schema2,
+  validateWithSchema2,
+  v2
+} from "../index-2zz0g2n2.js";
+import"../index-y9bq7h9g.js";
+import"../index-a4xns6cc.js";
+import"../index-6kfe1nr4.js";
 export {
-  ERROR_CODE_TO_STATUS,
-  RPCError,
-  RouterImpl,
-  STATUS_TO_ERROR_CODE,
-  Schema,
-  createClient,
-  createFetchHandler,
-  createProcedure,
-  createRouter,
-  executeProcedure,
-  mutation,
-  query,
-  subscription,
-  v,
-  validateWithSchema
+  ERROR_CODE_TO_STATUS2 as ERROR_CODE_TO_STATUS,
+  RPCError2 as RPCError,
+  RouterImpl2 as RouterImpl,
+  STATUS_TO_ERROR_CODE2 as STATUS_TO_ERROR_CODE,
+  Schema2 as Schema,
+  createClient2 as createClient,
+  createFetchHandler2 as createFetchHandler,
+  createProcedure2 as createProcedure,
+  createRouter2 as createRouter,
+  executeProcedure2 as executeProcedure,
+  mutation3 as mutation,
+  query3 as query,
+  subscription3 as subscription,
+  v2 as v,
+  validateWithSchema2 as validateWithSchema
 };