@epoch32/visage 0.0.0-stage → 0.0.0

package/dist/src/api/index.js

@@ -0,0 +1,4002 @@
+// 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/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/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" ? untrack(() => 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;
+  version = 0;
+  constructor(initialValue, equals) {
+    this._value = initialValue;
+    this._equals = equals ?? Object.is;
+  }
+  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++;
+    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 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 s = new Signal(initialValue, equals);
+  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/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/api/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 buildUrl(baseUrl, pathSegments, queryParams) {
+  const cleanBase = baseUrl.replace(/\/+$/, "");
+  const cleanPath = pathSegments.filter(Boolean).join("/");
+  let url = cleanPath ? `${cleanBase}/${cleanPath}` : cleanBase;
+  if (queryParams !== undefined && queryParams !== null) {
+    if (typeof queryParams === "object") {
+      const params = new URLSearchParams;
+      for (const [k, v] of Object.entries(queryParams)) {
+        if (v !== undefined && v !== null) {
+          if (typeof v === "object") {
+            params.set(k, JSON.stringify(v));
+          } else {
+            params.set(k, String(v));
+          }
+        }
+      }
+      const qs = params.toString();
+      if (qs) {
+        url += `${url.includes("?") ? "&" : "?"}${qs}`;
+      }
+    } else {
+      url += `${url.includes("?") ? "&" : "?"}input=${encodeURIComponent(String(queryParams))}`;
+    }
+  }
+  return url;
+}
+function createApiProxy(options, path = []) {
+  const handlerFn = (...args) => {
+    if (args.length > 0) {
+      return createApiProxy(options, [...path, String(args[0])]);
+    }
+    return createApiProxy(options, path);
+  };
+  return new Proxy(handlerFn, {
+    get(_target, prop) {
+      if (prop === "then")
+        return;
+      const fullPath = path.join("/");
+      if (prop === "get") {
+        return async (input, callOpts) => {
+          const fetchFn = options.fetch ?? globalThis.fetch;
+          const url = buildUrl(options.baseUrl, path, input);
+          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: `api_${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 contentType = res.headers.get("Content-Type") || "";
+            if (contentType.includes("application/json")) {
+              const body = await res.json();
+              if (body && typeof body === "object" && "ok" in body) {
+                if (!body.ok) {
+                  devtools?.updateRpcCall(logId, { status: "error", error: body.error });
+                  throw new RPCError({
+                    code: body.error?.code || "INTERNAL_SERVER_ERROR",
+                    message: body.error?.message || "Request failed",
+                    issues: body.error?.issues
+                  });
+                }
+                devtools?.updateRpcCall(logId, { status: "success", response: body.data });
+                return body.data;
+              }
+              if (!res.ok) {
+                throw new Error(`Request failed with status ${res.status}`);
+              }
+              devtools?.updateRpcCall(logId, { status: "success", response: body });
+              return body;
+            }
+            if (!res.ok) {
+              throw new Error(`Request failed with status ${res.status}`);
+            }
+            const text = await res.text();
+            devtools?.updateRpcCall(logId, { status: "success", response: text });
+            return text;
+          } catch (err) {
+            devtools?.updateRpcCall(logId, { status: "error", error: err });
+            throw err;
+          }
+        };
+      }
+      if (prop === "post" || prop === "put" || prop === "patch" || prop === "delete" || prop === "del") {
+        const httpMethod = prop === "del" ? "DELETE" : prop.toUpperCase();
+        return async (body, callOpts) => {
+          const fetchFn = options.fetch ?? globalThis.fetch;
+          const url = buildUrl(options.baseUrl, path);
+          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: `api_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+            path: fullPath,
+            type: "mutation",
+            input: body
+          });
+          try {
+            const res = await fetchFn(url, {
+              method: httpMethod,
+              headers,
+              body: body !== undefined ? JSON.stringify(body) : undefined,
+              signal: callOpts?.signal
+            });
+            const contentType = res.headers.get("Content-Type") || "";
+            if (contentType.includes("application/json")) {
+              const resBody = await res.json();
+              if (resBody && typeof resBody === "object" && "ok" in resBody) {
+                if (!resBody.ok) {
+                  devtools?.updateRpcCall(logId, { status: "error", error: resBody.error });
+                  throw new RPCError({
+                    code: resBody.error?.code || "INTERNAL_SERVER_ERROR",
+                    message: resBody.error?.message || "Request failed",
+                    issues: resBody.error?.issues
+                  });
+                }
+                devtools?.updateRpcCall(logId, { status: "success", response: resBody.data });
+                return resBody.data;
+              }
+              if (!res.ok) {
+                throw new Error(`Request failed with status ${res.status}`);
+              }
+              devtools?.updateRpcCall(logId, { status: "success", response: resBody });
+              return resBody;
+            }
+            if (!res.ok) {
+              throw new Error(`Request failed with status ${res.status}`);
+            }
+            const text = await res.text();
+            devtools?.updateRpcCall(logId, { status: "success", response: text });
+            return text;
+          } catch (err) {
+            devtools?.updateRpcCall(logId, { status: "error", error: err });
+            throw err;
+          }
+        };
+      }
+      if (prop === "subscribe") {
+        return (input, callbacks) => {
+          const fetchFn = options.fetch ?? globalThis.fetch;
+          const url = buildUrl(options.baseUrl, path, input);
+          const controller = new AbortController;
+          const devtools = typeof window !== "undefined" ? window.__VISAGE_DEVTOOLS__ : null;
+          const logId = devtools?.logRpcCall({
+            id: `api_sse_${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(`SSE stream 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 SSE error"));
+                  }
+                }
+              }
+              callbacks.onComplete?.();
+            } catch (err) {
+              if (!controller.signal.aborted) {
+                callbacks.onError?.(err);
+              }
+            }
+          })();
+          return {
+            unsubscribe: () => {
+              controller.abort();
+            }
+          };
+        };
+      }
+      if (prop === "queryKey") {
+        return (input) => {
+          const resolved = typeof input === "function" ? input() : input;
+          const key = [...path];
+          if (resolved !== undefined)
+            key.push(resolved);
+          return key;
+        };
+      }
+      if (prop === "queryOptions") {
+        return (input, extra) => {
+          const resolved = typeof input === "function" ? input() : input;
+          const key = [...path];
+          if (resolved !== undefined)
+            key.push(resolved);
+          return {
+            queryKey: key,
+            queryFn: ({ signal }) => {
+              const proxy = createApiProxy(options, path);
+              return proxy.get(resolved, { signal });
+            },
+            ...extra
+          };
+        };
+      }
+      if (prop === "createQuery" || prop === "useQuery") {
+        return (input, extra) => {
+          const proxy = createApiProxy(options, path);
+          return createQuery(() => proxy.queryOptions(input, extra));
+        };
+      }
+      if (prop === "mutationKey") {
+        return () => [...path];
+      }
+      if (prop === "mutationOptions") {
+        return (extra) => {
+          return {
+            mutationKey: [...path],
+            mutationFn: (body) => {
+              const proxy = createApiProxy(options, path);
+              return proxy.post(body);
+            },
+            ...extra
+          };
+        };
+      }
+      if (prop === "createMutation" || prop === "useMutation") {
+        return (extra) => {
+          const proxy = createApiProxy(options, path);
+          return createMutation(proxy.mutationOptions(extra));
+        };
+      }
+      return createApiProxy(options, [...path, prop]);
+    }
+  });
+}
+function createApiClient(options) {
+  return createApiProxy(options, []);
+}
+// src/api/pragma.ts
+var PRAGMA_REGEX = /(?:\/\/\s*@visage-middleware\s+([^\r\n]+))|(?:\/\*\s*@visage-middleware\s+([\s\S]*?)\*\/)/i;
+function parsePragma(sourceCode) {
+  if (!sourceCode || typeof sourceCode !== "string") {
+    return { cascade: true, match: ["*"], exclude: [], priority: 0 };
+  }
+  const match = sourceCode.match(PRAGMA_REGEX);
+  if (!match) {
+    return { cascade: true, match: ["*"], exclude: [], priority: 0 };
+  }
+  const rawDirective = (match[1] || match[2] || "").trim();
+  const pragma = {
+    cascade: true,
+    match: ["*"],
+    exclude: [],
+    priority: 0
+  };
+  const pairs = rawDirective.split(/,(?![^[]*\])/);
+  for (const pair of pairs) {
+    const colonIdx = pair.indexOf(":");
+    if (colonIdx === -1)
+      continue;
+    const key = pair.slice(0, colonIdx).trim().toLowerCase();
+    const valStr = pair.slice(colonIdx + 1).trim();
+    if (key === "cascade") {
+      pragma.cascade = valStr === "true" || valStr === "1";
+    } else if (key === "priority") {
+      const num = Number.parseInt(valStr, 10);
+      if (!Number.isNaN(num))
+        pragma.priority = num;
+    } else if (key === "match" || key === "exclude") {
+      let items = [];
+      if (valStr.startsWith("[") && valStr.endsWith("]")) {
+        try {
+          items = JSON.parse(valStr.replace(/'/g, '"'));
+        } catch {
+          items = valStr.slice(1, -1).split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+        }
+      } else {
+        items = [valStr.replace(/^['"]|['"]$/g, "")];
+      }
+      if (key === "match")
+        pragma.match = items;
+      if (key === "exclude")
+        pragma.exclude = items;
+    }
+  }
+  return pragma;
+}
+function globToRegExp(pattern) {
+  const normalized = pattern.trim().replace(/^\/+|\/+$/g, "");
+  if (normalized === "*" || normalized === "**" || normalized === "") {
+    return /^.*$/;
+  }
+  const escaped = normalized.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "___DOUBLE_STAR___").replace(/\*/g, "[^/]+").replace(/___DOUBLE_STAR___/g, ".*");
+  return new RegExp(`^(?:/)?${escaped}(?:/)?$`);
+}
+function matchesAnyPattern(routePath, patterns) {
+  if (!patterns || patterns.length === 0)
+    return false;
+  const cleanPath = routePath.replace(/^\/+|\/+$/g, "");
+  for (const pat of patterns) {
+    const cleanPat = pat.replace(/^\/+|\/+$/g, "");
+    if (cleanPat === "*" || cleanPat === "**")
+      return true;
+    if (cleanPat === cleanPath)
+      return true;
+    if (globToRegExp(cleanPat).test(cleanPath))
+      return true;
+  }
+  return false;
+}
+function shouldApplyMiddleware(pragma, routePath, routeDir, middlewareDir) {
+  const normRouteDir = routeDir.replace(/^\/+|\/+$/g, "");
+  const normMwDir = middlewareDir.replace(/^\/+|\/+$/g, "");
+  const isDirectDir = normRouteDir === normMwDir;
+  const isSubDir = normMwDir === "" ? normRouteDir !== "" : normRouteDir.startsWith(`${normMwDir}/`);
+  if (!isDirectDir && !isSubDir) {
+    return false;
+  }
+  const isCascade = pragma.cascade ?? true;
+  if (isSubDir && !isCascade) {
+    return false;
+  }
+  let relativePath = routePath.replace(/^\/+|\/+$/g, "");
+  if (normMwDir && relativePath.startsWith(normMwDir)) {
+    relativePath = relativePath.slice(normMwDir.length).replace(/^\/+/, "");
+  }
+  if (pragma.exclude && pragma.exclude.length > 0) {
+    if (matchesAnyPattern(routePath, pragma.exclude) || matchesAnyPattern(relativePath, pragma.exclude)) {
+      return false;
+    }
+  }
+  if (!pragma.match || pragma.match.length === 0 || pragma.match.includes("*")) {
+    return true;
+  }
+  return matchesAnyPattern(routePath, pragma.match) || matchesAnyPattern(relativePath, pragma.match);
+}
+
+// src/api/file-router.ts
+function compileRoutePattern(path) {
+  const paramNames = [];
+  const normalized = path.replace(/\/+$/, "") || "/";
+  const regexStr = normalized.replace(/:([a-zA-Z0-9_]+)/g, (_, name) => {
+    paramNames.push(name);
+    return "([^/]+)";
+  }).replace(/\*([a-zA-Z0-9_]+)/g, (_, name) => {
+    paramNames.push(name);
+    return "(.*)";
+  });
+  const pattern = new RegExp(`^${regexStr}(?:/)?$`);
+  return { pattern, paramNames };
+}
+function normalizeFilePath(rawPath) {
+  const cleaned = rawPath.replace(/^\.\//, "").replace(/\.(ts|tsx|js|jsx)$/, "").replace(/^(src\/)?(routes|api)\//, "");
+  const parts = cleaned.split("/").filter(Boolean);
+  const fileName = parts.pop() || "";
+  const isMiddleware = fileName === "_middleware";
+  const dirParts = [...parts];
+  const directory = `/${dirParts.join("/")}`.replace(/\/+$/, "") || "/";
+  if (isMiddleware) {
+    return {
+      isMiddleware: true,
+      routePath: directory,
+      directory
+    };
+  }
+  if (fileName !== "index") {
+    const transformedFile = fileName.replace(/\[\.\.\.([a-zA-Z0-9_]+)\]/g, "*$1").replace(/\[([a-zA-Z0-9_]+)\]/g, ":$1");
+    parts.push(transformedFile);
+  }
+  const routePath = `/${parts.join("/")}`.replace(/\/+$/, "") || "/";
+  return {
+    isMiddleware: false,
+    routePath,
+    directory
+  };
+}
+function buildFileRouter(files, sourceMap = {}) {
+  const middlewaresByDir = [];
+  const rawRoutes = [];
+  for (const [filePath, mod] of Object.entries(files)) {
+    const { isMiddleware, routePath, directory } = normalizeFilePath(filePath);
+    const sourceCode = sourceMap[filePath] || "";
+    const pragma = mod.pragma || parsePragma(sourceCode);
+    if (isMiddleware) {
+      const mwFn = typeof mod === "function" ? mod : mod.middleware || mod.default;
+      if (typeof mwFn === "function") {
+        middlewaresByDir.push({
+          fn: mwFn,
+          pragma,
+          filePath,
+          directory
+        });
+      }
+    } else {
+      rawRoutes.push({
+        filePath,
+        routePath,
+        directory,
+        module: mod
+      });
+    }
+  }
+  middlewaresByDir.sort((a, b) => {
+    const dirA = a.directory || "/";
+    const dirB = b.directory || "/";
+    const depthA = dirA.split("/").filter(Boolean).length;
+    const depthB = dirB.split("/").filter(Boolean).length;
+    if (depthA !== depthB)
+      return depthA - depthB;
+    return (b.pragma.priority ?? 0) - (a.pragma.priority ?? 0);
+  });
+  const routes = [];
+  for (const raw of rawRoutes) {
+    const applicableMiddlewares = middlewaresByDir.filter((mw) => shouldApplyMiddleware(mw.pragma, raw.routePath, raw.directory, mw.directory || "/"));
+    const { pattern, paramNames } = compileRoutePattern(raw.routePath);
+    const procedures = {};
+    const mod = raw.module;
+    if (mod.default && typeof mod.default === "object" && "type" in mod.default) {
+      procedures.default = mod.default;
+    }
+    for (const [key, val] of Object.entries(mod)) {
+      if (val && typeof val === "object" && "type" in val && "options" in val) {
+        procedures[key] = val;
+      }
+    }
+    const handler = typeof mod.default === "function" && !("type" in mod.default) ? mod.default : undefined;
+    routes.push({
+      pattern,
+      paramNames,
+      routePath: raw.routePath,
+      filePath: raw.filePath,
+      directory: raw.directory,
+      procedures,
+      middlewares: applicableMiddlewares,
+      handler
+    });
+  }
+  routes.sort((a, b) => {
+    const isParamA = a.routePath.includes(":") || a.routePath.includes("*");
+    const isParamB = b.routePath.includes(":") || b.routePath.includes("*");
+    if (isParamA !== isParamB)
+      return isParamA ? 1 : -1;
+    return b.routePath.length - a.routePath.length;
+  });
+  return routes;
+}
+// src/api/middleware.ts
+async function executeMiddlewareChain(middlewares, req, url, params, initialCtx = {}) {
+  let currentCtx = { ...initialCtx };
+  let earlyResponse;
+  let index = 0;
+  const runner = async () => {
+    if (index >= middlewares.length) {
+      return;
+    }
+    const currentMw = middlewares[index++];
+    const next = async (enriched) => {
+      if (enriched && typeof enriched === "object") {
+        currentCtx = { ...currentCtx, ...enriched };
+      }
+      await runner();
+      return currentCtx;
+    };
+    const result = await currentMw({
+      req,
+      ctx: currentCtx,
+      url,
+      params,
+      next
+    });
+    if (result instanceof Response) {
+      earlyResponse = result;
+    }
+  };
+  await runner();
+  return {
+    response: earlyResponse,
+    ctx: currentCtx
+  };
+}
+
+// src/api/handler.ts
+function handleCors(req, config) {
+  if (!config)
+    return null;
+  const origin = req.headers.get("Origin") || "*";
+  const isAllowed = !config.origin || config.origin === "*" || typeof config.origin === "function" && config.origin(origin) || Array.isArray(config.origin) && config.origin.includes(origin) || config.origin === origin;
+  if (req.method === "OPTIONS") {
+    const headers = new Headers;
+    if (isAllowed) {
+      headers.set("Access-Control-Allow-Origin", origin);
+    }
+    headers.set("Access-Control-Allow-Methods", (config.methods || ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"]).join(", "));
+    headers.set("Access-Control-Allow-Headers", (config.allowedHeaders || ["Content-Type", "Authorization", "x-visage-rpc"]).join(", "));
+    if (config.credentials) {
+      headers.set("Access-Control-Allow-Credentials", "true");
+    }
+    if (config.maxAge) {
+      headers.set("Access-Control-Max-Age", config.maxAge.toString());
+    }
+    return new Response(null, { status: 204, headers });
+  }
+  return null;
+}
+function applyCorsHeaders(res, req, config) {
+  if (!config)
+    return res;
+  const origin = req.headers.get("Origin") || "*";
+  res.headers.set("Access-Control-Allow-Origin", origin);
+  if (config.credentials) {
+    res.headers.set("Access-Control-Allow-Credentials", "true");
+  }
+  return res;
+}
+function createApiHandler(routes, config = {}) {
+  const prefix = config.prefix ? `/${config.prefix.replace(/^\/+|\/+$/g, "")}` : "";
+  return async (req) => {
+    const corsPreflight = handleCors(req, config.cors);
+    if (corsPreflight)
+      return corsPreflight;
+    const url = new URL(req.url);
+    let pathname = url.pathname;
+    if (prefix && pathname.startsWith(prefix)) {
+      pathname = pathname.slice(prefix.length) || "/";
+    }
+    let matchedRoute = null;
+    const pathParams = {};
+    for (const route of routes) {
+      const match = pathname.match(route.pattern);
+      if (match) {
+        matchedRoute = route;
+        route.paramNames.forEach((name, i) => {
+          pathParams[name] = decodeURIComponent(match[i + 1] || "");
+        });
+        break;
+      }
+    }
+    if (!matchedRoute) {
+      return applyCorsHeaders(new Response(JSON.stringify({
+        ok: false,
+        error: { code: "NOT_FOUND", message: `Route not found: ${pathname}` }
+      }), { status: 404, headers: { "Content-Type": "application/json" } }), req, config.cors);
+    }
+    try {
+      const method = req.method.toUpperCase();
+      let procedure = matchedRoute.procedures.default;
+      if (!procedure) {
+        if (method === "GET") {
+          procedure = matchedRoute.procedures.GET || matchedRoute.procedures.get;
+        } else if (method === "POST") {
+          procedure = matchedRoute.procedures.POST || matchedRoute.procedures.post;
+        } else if (method === "PUT") {
+          procedure = matchedRoute.procedures.PUT || matchedRoute.procedures.put;
+        } else if (method === "DELETE") {
+          procedure = matchedRoute.procedures.DELETE || matchedRoute.procedures.del || matchedRoute.procedures.delete;
+        } else if (method === "PATCH") {
+          procedure = matchedRoute.procedures.PATCH || matchedRoute.procedures.patch;
+        }
+      }
+      const mwFns = [
+        ...matchedRoute.middlewares.map((m) => m.fn),
+        ...procedure?.middlewares || []
+      ];
+      const { response: earlyResponse, ctx } = await executeMiddlewareChain(mwFns, req, url, pathParams);
+      if (earlyResponse) {
+        return applyCorsHeaders(earlyResponse, req, config.cors);
+      }
+      if (matchedRoute.handler) {
+        const res = await matchedRoute.handler(req, ctx);
+        return applyCorsHeaders(res, req, config.cors);
+      }
+      if (!procedure) {
+        return applyCorsHeaders(new Response(JSON.stringify({
+          ok: false,
+          error: {
+            code: "METHOD_NOT_ALLOWED",
+            message: `Method ${method} not allowed on ${pathname}`
+          }
+        }), { status: 405, headers: { "Content-Type": "application/json" } }), req, config.cors);
+      }
+      let rawInput = {};
+      if (method === "GET") {
+        const inputQuery = url.searchParams.get("input");
+        if (inputQuery) {
+          try {
+            rawInput = JSON.parse(inputQuery);
+          } catch {
+            rawInput = inputQuery;
+          }
+        } else {
+          const spObj = {};
+          url.searchParams.forEach((val, key) => {
+            spObj[key] = val;
+          });
+          if (Object.keys(spObj).length > 0) {
+            rawInput = spObj;
+          }
+        }
+      } else {
+        const contentType = req.headers.get("Content-Type") || "";
+        if (contentType.includes("application/json")) {
+          try {
+            rawInput = await req.json();
+          } catch {
+            rawInput = {};
+          }
+        }
+      }
+      if (typeof rawInput === "object" && rawInput !== null) {
+        rawInput = { ...pathParams, ...rawInput };
+      }
+      let validatedInput = rawInput;
+      if (procedure.options.input) {
+        const validation = await validateWithSchema(procedure.options.input, rawInput);
+        if (!validation.success) {
+          return applyCorsHeaders(new Response(JSON.stringify({
+            ok: false,
+            error: {
+              code: "BAD_REQUEST",
+              message: "Validation Error",
+              issues: validation.issues
+            }
+          }), { status: 400, headers: { "Content-Type": "application/json" } }), req, config.cors);
+        }
+        validatedInput = validation.data;
+      }
+      if (procedure.type === "subscription") {
+        const generator = procedure.options.resolve({
+          input: validatedInput,
+          ctx,
+          req,
+          params: pathParams
+        });
+        const stream = new ReadableStream({
+          async start(controller) {
+            const encoder = new TextEncoder;
+            try {
+              for await (const chunk of generator) {
+                const payload = `data: ${JSON.stringify(chunk)}
+
+`;
+                controller.enqueue(encoder.encode(payload));
+              }
+              controller.close();
+            } catch (err) {
+              controller.error(err);
+            }
+          }
+        });
+        const sseRes = new Response(stream, {
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive"
+          }
+        });
+        return applyCorsHeaders(sseRes, req, config.cors);
+      }
+      const result = await procedure.options.resolve({
+        input: validatedInput,
+        ctx,
+        req,
+        params: pathParams
+      });
+      const successRes = new Response(JSON.stringify({ ok: true, data: result }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      });
+      return applyCorsHeaders(successRes, req, config.cors);
+    } catch (err) {
+      if (config.onError) {
+        const customRes = await config.onError(err, req);
+        return applyCorsHeaders(customRes, req, config.cors);
+      }
+      const statusCode = err instanceof RPCError ? err.statusCode : ERROR_CODE_TO_STATUS[err?.code] || 500;
+      const code = err instanceof RPCError ? err.code : "INTERNAL_SERVER_ERROR";
+      const message = err?.message || "Internal Server Error";
+      const errRes = new Response(JSON.stringify({ ok: false, error: { code, message } }), {
+        status: statusCode,
+        headers: { "Content-Type": "application/json" }
+      });
+      return applyCorsHeaders(errRes, req, config.cors);
+    }
+  };
+}
+function createApi(files, sourceMapOrConfig, maybeConfig) {
+  const sourceMap = sourceMapOrConfig && !("prefix" in sourceMapOrConfig) && !("cors" in sourceMapOrConfig) ? sourceMapOrConfig : {};
+  const config = maybeConfig || (sourceMapOrConfig && (("prefix" in sourceMapOrConfig) || ("cors" in sourceMapOrConfig)) ? sourceMapOrConfig : {});
+  const routes = buildFileRouter(files, sourceMap);
+  const fetchHandler = createApiHandler(routes, config);
+  return {
+    routes,
+    fetch: fetchHandler
+  };
+}
+// src/api/procedure.ts
+function query(options) {
+  return {
+    type: "query",
+    options
+  };
+}
+function mutation(options) {
+  return {
+    type: "mutation",
+    options
+  };
+}
+function subscription(options) {
+  return {
+    type: "subscription",
+    options: {
+      ...options,
+      resolve: options.resolve
+    }
+  };
+}
+function defineMiddleware(fn, pragma = { cascade: true, match: ["*"] }) {
+  return {
+    fn,
+    pragma
+  };
+}
+
+class ProcedureBuilder {
+  _middlewares = [];
+  _inputSchema;
+  constructor(middlewares = [], inputSchema) {
+    this._middlewares = middlewares;
+    this._inputSchema = inputSchema;
+  }
+  use(middleware) {
+    return new ProcedureBuilder([...this._middlewares, middleware], this._inputSchema);
+  }
+  input(schema) {
+    return new ProcedureBuilder(this._middlewares, schema);
+  }
+  query(resolve) {
+    return {
+      type: "query",
+      options: {
+        input: this._inputSchema,
+        resolve
+      },
+      middlewares: this._middlewares
+    };
+  }
+  mutation(resolve) {
+    return {
+      type: "mutation",
+      options: {
+        input: this._inputSchema,
+        resolve
+      },
+      middlewares: this._middlewares
+    };
+  }
+  subscription(resolve) {
+    return {
+      type: "subscription",
+      options: {
+        resolve
+      },
+      middlewares: this._middlewares
+    };
+  }
+}
+var procedure = new ProcedureBuilder;
+export {
+  ERROR_CODE_TO_STATUS,
+  ProcedureBuilder,
+  RPCError,
+  STATUS_TO_ERROR_CODE,
+  Schema,
+  buildFileRouter,
+  compileRoutePattern,
+  createApi,
+  createApiClient,
+  createApiHandler,
+  defineMiddleware,
+  executeMiddlewareChain,
+  globToRegExp,
+  matchesAnyPattern,
+  mutation,
+  normalizeFilePath,
+  parsePragma,
+  procedure,
+  query,
+  shouldApplyMiddleware,
+  subscription,
+  v,
+  validateWithSchema
+};