@vesk/vesk-cli 0.2.64 → 0.2.66

package/dist/cli.js

@@ -1177,10 +1177,10 @@ function run_block(block2) {
     const res = block2.fn(block2.s);
     if (typeof res === "function") {
       block2.t = res;
-      let current2 = block2;
-      while (current2 !== null && (current2.f & CONTAINS_TEARDOWN) === 0) {
-        current2.f ^= CONTAINS_TEARDOWN;
-        current2 = current2.p;
+      let current3 = block2;
+      while (current3 !== null && (current3.f & CONTAINS_TEARDOWN) === 0) {
+        current3.f ^= CONTAINS_TEARDOWN;
+        current3 = current3.p;
       }
     }
     block2.d = active_dependency;
@@ -1227,13 +1227,13 @@ function create_dependency(tracked2) {
   if (is_orphan(tracked2.b)) {
     (tracked2.r ??= /* @__PURE__ */ new Set()).add(reaction);
   }
-  const existing = reaction.d;
-  if (existing !== null) {
-    reaction.d = existing.n;
-    existing.c = tracked2.c;
-    existing.t = tracked2;
-    existing.n = null;
-    return existing;
+  const existing2 = reaction.d;
+  if (existing2 !== null) {
+    reaction.d = existing2.n;
+    existing2.c = tracked2.c;
+    existing2.t = tracked2;
+    existing2.n = null;
+    return existing2;
   }
   return {
     c: tracked2.c,
@@ -1276,44 +1276,44 @@ function is_block_dirty(block2) {
   return is_tracking_dirty(block2.d);
 }
 function flush_updates(root_block) {
-  let current2 = root_block;
+  let current3 = root_block;
   const pre_effects = [];
   const other_blocks = [];
   const effects = [];
   let scope_root = disable_scoped_flush ? root_block : null;
-  while (current2 !== null) {
-    const flags = current2.f;
+  while (current3 !== null) {
+    const flags = current3.f;
     const on_path = (flags & CONTAINS_UPDATE) !== 0;
     if (on_path) {
-      current2.f ^= CONTAINS_UPDATE;
+      current3.f ^= CONTAINS_UPDATE;
     }
     if ((flags & UPDATE_SOURCE) !== 0) {
-      current2.f ^= UPDATE_SOURCE;
+      current3.f ^= UPDATE_SOURCE;
       if (scope_root === null) {
-        scope_root = current2;
+        scope_root = current3;
       }
     }
     if ((flags & PAUSED) === 0 && (on_path || scope_root !== null)) {
       if ((flags & PRE_EFFECT_BLOCK) !== 0) {
-        pre_effects.push(current2);
+        pre_effects.push(current3);
       } else if ((flags & EFFECT_BLOCK) !== 0) {
-        effects.push(current2);
+        effects.push(current3);
       } else {
-        other_blocks.push(current2);
+        other_blocks.push(current3);
       }
-      const child = current2.first;
+      const child = current3.first;
       if (child !== null) {
-        current2 = child;
+        current3 = child;
         continue;
       }
     }
-    let parent = current2.p;
-    current2 = current2.next;
-    while (current2 === null && parent !== null) {
+    let parent = current3.p;
+    current3 = current3.next;
+    while (current3 === null && parent !== null) {
       if (parent === scope_root) {
         scope_root = null;
       }
-      current2 = parent.next;
+      current3 = parent.next;
       parent = parent.p;
     }
   }
@@ -1406,17 +1406,17 @@ function schedule_update(block2) {
     queue_microtask();
   }
   block2.f |= UPDATE_SOURCE;
-  let current2 = block2;
-  while (current2 !== null) {
-    const flags = current2.f;
+  let current3 = block2;
+  while (current3 !== null) {
+    const flags = current3.f;
     if ((flags & CONTAINS_UPDATE) !== 0) return;
-    current2.f ^= CONTAINS_UPDATE;
+    current3.f ^= CONTAINS_UPDATE;
     if ((flags & ROOT_BLOCK) !== 0) {
       break;
     }
-    current2 = current2.p;
+    current3 = current3.p;
   }
-  queued_root_blocks.push(current2);
+  queued_root_blocks.push(current3);
 }
 function register_dependency(tracked2) {
   if (!disable_scoped_flush && active_block !== null && active_block !== tracked2.b) {
@@ -1445,20 +1445,20 @@ function register_dependency(tracked2) {
     dependency = create_dependency(tracked2);
     active_dependency = dependency;
   } else {
-    let current2 = dependency;
-    while (current2 !== null) {
-      if (current2.t === tracked2) {
-        current2.c = tracked2.c;
+    let current3 = dependency;
+    while (current3 !== null) {
+      if (current3.t === tracked2) {
+        current3.c = tracked2.c;
         return;
       }
-      const next = current2.n;
+      const next = current3.n;
       if (next === null) {
         break;
       }
-      current2 = next;
+      current3 = next;
     }
     dependency = create_dependency(tracked2);
-    current2.n = dependency;
+    current3.n = dependency;
   }
 }
 function unsubscribe_reaction(reaction) {
@@ -1837,10 +1837,10 @@ var init_context = __esm({
        * way to every reader.
        */
       get() {
-        let current2 = getActiveComponent();
-        while (current2) {
-          if (current2.c?.has(this)) return current2.c.get(this);
-          current2 = current2.p;
+        let current3 = getActiveComponent();
+        while (current3) {
+          if (current3.c?.has(this)) return current3.c.get(this);
+          current3 = current3.p;
         }
         return this._v;
       }
@@ -1858,11 +1858,11 @@ var init_context = __esm({
 
 // ../runtime/src/server-events.ts
 function getStore() {
-  const g4 = globalThis;
-  if (!g4.__vesk_server_ctx || typeof g4.__vesk_server_ctx !== "object") {
-    g4.__vesk_server_ctx = {};
+  const g5 = globalThis;
+  if (!g5.__vesk_server_ctx || typeof g5.__vesk_server_ctx !== "object") {
+    g5.__vesk_server_ctx = {};
   }
-  return g4.__vesk_server_ctx;
+  return g5.__vesk_server_ctx;
 }
 function server_locals() {
   return getStore();
@@ -2126,8 +2126,8 @@ function streamText(res, into, onChunk) {
 function settle(handle2, data2) {
   if (handle2.block !== null && is_destroyed(handle2.block)) return;
   if (handle2.into) setInto(handle2.into, data2);
-  const current2 = get(handle2.state);
-  if (!(current2.data === data2 && !current2.loading && current2.error === null)) {
+  const current3 = get(handle2.state);
+  if (!(current3.data === data2 && !current3.loading && current3.error === null)) {
     set(handle2.state, { loading: false, error: null, data: data2 });
   }
   handle2.settleNotify();
@@ -2136,22 +2136,22 @@ function settleError(handle2, error) {
   if (handle2.block !== null && is_destroyed(handle2.block)) return;
   if (isAbortError(error)) {
     if (handle2.controller !== null) return;
-    const current3 = get(handle2.state);
-    if (current3.loading) set(handle2.state, { loading: false, error: null, data: current3.data });
+    const current4 = get(handle2.state);
+    if (current4.loading) set(handle2.state, { loading: false, error: null, data: current4.data });
     handle2.settleNotify();
     return;
   }
-  const current2 = get(handle2.state);
-  set(handle2.state, { loading: false, error, data: current2.data });
+  const current3 = get(handle2.state);
+  set(handle2.state, { loading: false, error, data: current3.data });
   handle2.settleNotify();
 }
 function markRefetching(handle2) {
-  const current2 = get(handle2.state);
-  if (current2.loading) return;
+  const current3 = get(handle2.state);
+  if (current3.loading) return;
   set(handle2.state, {
     loading: true,
     error: null,
-    data: handle2.options.keepPreviousData ? current2.data : void 0
+    data: handle2.options.keepPreviousData ? current3.data : void 0
   });
 }
 function attachSettle(handle2, promise) {
@@ -2217,10 +2217,10 @@ function startRequest(handle2, skipCache) {
       });
       return settled;
     }
-    const existing = getInflight().get(key);
+    const existing2 = getInflight().get(key);
     const startToken = g().__vsk_ssr_token || void 0;
-    const prom2 = existing ?? runFetcher(handle2, options.timeout || 0);
-    if (!existing) {
+    const prom2 = existing2 ?? runFetcher(handle2, options.timeout || 0);
+    if (!existing2) {
       getInflight().set(key, prom2);
       prom2.then(
         (data2) => {
@@ -2252,10 +2252,10 @@ function startRequest(handle2, skipCache) {
     }
   }
   if (options.dedupe !== false) {
-    const existing = getInflight().get(key);
-    if (existing) {
-      attachSettle(handle2, existing);
-      return existing;
+    const existing2 = getInflight().get(key);
+    if (existing2) {
+      attachSettle(handle2, existing2);
+      return existing2;
     }
   }
   markRefetching(handle2);
@@ -2398,8 +2398,8 @@ function createResource(fn, key, into, options = {}) {
       on_destroy(() => {
         if (is_destroyed(handle2.block)) {
           handle2.controller?.abort();
-          const current2 = getRegistry().get(resourceKey);
-          if (current2) current2.delete(handle2);
+          const current3 = getRegistry().get(resourceKey);
+          if (current3) current3.delete(handle2);
         }
       });
     }
@@ -2860,9 +2860,9 @@ function createHydrateWalker(container, markerList) {
 }
 function bumpNavEpoch() {
   try {
-    const g4 = globalThis;
-    const next = (g4.__vesk_nav_epoch || 0) + 1;
-    g4.__vesk_nav_epoch = next;
+    const g5 = globalThis;
+    const next = (g5.__vesk_nav_epoch || 0) + 1;
+    g5.__vesk_nav_epoch = next;
     return next;
   } catch {
     return 0;
@@ -4009,8 +4009,8 @@ function LoadingIndicator(props = {}, _registry, hydrate) {
   if (hydrate && typeof hydrate.nextElement === "function") {
     el = hydrate.nextElement("div");
     if (el && !el.parentNode && hydrate.root) {
-      const existing = hydrate.root.querySelector(`[${INDICATOR_ATTR}]`);
-      if (existing) el = existing;
+      const existing2 = hydrate.root.querySelector(`[${INDICATOR_ATTR}]`);
+      if (existing2) el = existing2;
     }
   } else {
     el = document.createElement("div");
@@ -4330,8 +4330,8 @@ function NavLink(props, registry, hydrate) {
   if (hydrate && hydrate.nextElement) {
     let a2 = hydrate.nextElement("a");
     if (a2 && !a2.parentNode && hydrate.root) {
-      const existing = hydrate.root.querySelector("a");
-      if (existing) a2 = existing;
+      const existing2 = hydrate.root.querySelector("a");
+      if (existing2) a2 = existing2;
     }
     const claimed = a2 ? a2.parentNode !== null : false;
     if (!a2) a2 = document.createElement("a");
@@ -4779,8 +4779,8 @@ async function fetchRouteData(path) {
 }
 function getRouteData(path, scope2) {
   const key = scope2 === void 0 ? path : path + "\0" + scope2;
-  const existing = _dataPromises.get(key);
-  if (existing) return existing;
+  const existing2 = _dataPromises.get(key);
+  if (existing2) return existing2;
   const p = fetchRouteData(path).finally(() => {
     _dataPromises.delete(key);
   });
@@ -5604,8 +5604,8 @@ function createRouter(routes, options = {}) {
     },
     _runGuards(to) {
       const from = get(_state.path) || window.location.pathname;
-      for (const g4 of this._beforeGuards ?? []) {
-        const d = g4(to, from);
+      for (const g5 of this._beforeGuards ?? []) {
+        const d = g5(to, from);
         if (d instanceof Promise) {
           return d.then((r) => {
             if (r === false || typeof r === "string") return r;
@@ -5931,8 +5931,8 @@ function createFileRouter(routeTree, options = {}) {
     },
     _runGuards(to) {
       const from = get(_state.path) || window.location.pathname;
-      for (const g4 of this._beforeGuards ?? []) {
-        const d = g4(to, from);
+      for (const g5 of this._beforeGuards ?? []) {
+        const d = g5(to, from);
         if (d instanceof Promise) {
           return d.then((r) => {
             if (r === false || typeof r === "string") return r;
@@ -6377,6 +6377,58 @@ var init_router = __esm({
   }
 });
 
+// ../runtime/src/security-overrides.ts
+function resolveAls() {
+  try {
+    const proc = g2.process;
+    const mod = proc?.getBuiltinModule?.("async_hooks");
+    const ctor = mod?.AsyncLocalStorage;
+    return ctor ? new ctor() : null;
+  } catch {
+    return null;
+  }
+}
+function current() {
+  if (als) return als.getStore() ?? null;
+  return fallbackStore;
+}
+function runWithSecurityOverrides(fn) {
+  const bag = {};
+  if (als) return als.run(bag, fn);
+  const prev = fallbackStore;
+  fallbackStore = bag;
+  try {
+    return fn();
+  } finally {
+    fallbackStore = prev;
+  }
+}
+function setSecurityOverride(key, value) {
+  const bag = current();
+  if (bag) bag[key] = value;
+}
+function getSecurityOverrides() {
+  const bag = current();
+  if (!bag) return null;
+  return Object.keys(bag).length > 0 ? bag : null;
+}
+var g2, als, fallbackStore, bridge, existing;
+var init_security_overrides = __esm({
+  "../runtime/src/security-overrides.ts"() {
+    "use strict";
+    g2 = globalThis;
+    als = resolveAls();
+    fallbackStore = null;
+    bridge = {
+      run: runWithSecurityOverrides,
+      get: getSecurityOverrides,
+      set: setSecurityOverride
+    };
+    existing = g2.__vesk_security || {};
+    g2.__vesk_security = { ...existing, ...bridge };
+  }
+});
+
 // ../../node_modules/acorn/dist/acorn.mjs
 var acorn_exports = {};
 __export(acorn_exports, {
@@ -10098,7 +10150,7 @@ var init_acorn = __esm({
       }
       return i + 2;
     };
-    RegExpValidationState.prototype.current = function current(forceU) {
+    RegExpValidationState.prototype.current = function current2(forceU) {
       if (forceU === void 0) forceU = false;
       return this.at(this.pos, forceU);
     };
@@ -10123,8 +10175,8 @@ var init_acorn = __esm({
       var pos = this.pos;
       for (var i = 0, list = chs; i < list.length; i += 1) {
         var ch = list[i];
-        var current2 = this.at(pos, forceU);
-        if (current2 === -1 || current2 !== ch) {
+        var current3 = this.at(pos, forceU);
+        if (current3 === -1 || current3 !== ch) {
           return false;
         }
         pos = this.nextIndex(pos, forceU);
@@ -20367,8 +20419,8 @@ function collectModuleSpecifiers(ast) {
   return specs;
 }
 function collectModuleBundled(absPath, collector) {
-  const existing = collector.keysByAbs.get(absPath);
-  if (existing) return existing;
+  const existing2 = collector.keysByAbs.get(absPath);
+  if (existing2) return existing2;
   const key = `__veskMod${collector.keysByAbs.size}`;
   collector.keysByAbs.set(absPath, key);
   const dir = dirname2(absPath);
@@ -22417,16 +22469,16 @@ function generateIR(ast, source, filename) {
       if (called.has(fn)) usedFunctions.add(fn);
     }
     if (usedFunctions.size > 0) {
-      const existing = /* @__PURE__ */ new Set();
+      const existing2 = /* @__PURE__ */ new Set();
       for (const imp of imports) {
         if (importModuleTarget(imp) !== "@vesk/runtime") continue;
-        for (const n of extractImportNames(imp)) existing.add(n);
+        for (const n of extractImportNames(imp)) existing2.add(n);
       }
       const boundLocally = /* @__PURE__ */ new Set();
       for (const imp of imports) {
         for (const pair of importBindingPairs(imp)) boundLocally.add(pair.local);
       }
-      const missing = [...usedFunctions].filter((f) => !existing.has(f) && !boundLocally.has(f));
+      const missing = [...usedFunctions].filter((f) => !existing2.has(f) && !boundLocally.has(f));
       if (missing.length > 0) {
         imports.push(`import { ${missing.join(", ")} } from '@vesk/runtime';`);
       }
@@ -22494,6 +22546,7 @@ __export(server_utils_exports, {
   escapeHtml: () => escapeHtml,
   evalTopLevelCode: () => evalTopLevelCode,
   exprJS: () => exprJS,
+  extractRuntimeBindingPairs: () => extractRuntimeBindingPairs,
   extractRuntimeNames: () => extractRuntimeNames,
   extractTopLevelNames: () => extractTopLevelNames,
   getClientIp: () => getClientIp,
@@ -22835,16 +22888,16 @@ function sha256Bytes(msg) {
       const s1 = rr(w[j - 2], 17) ^ rr(w[j - 2], 19) ^ w[j - 2] >>> 10;
       w[j] = w[j - 16] + s0 + w[j - 7] + s1 >>> 0;
     }
-    let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g4 = h6, h = h7;
+    let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g5 = h6, h = h7;
     for (let j = 0; j < 64; j++) {
       const S1 = rr(e, 6) ^ rr(e, 11) ^ rr(e, 25);
-      const ch = e & f ^ ~e & g4;
+      const ch = e & f ^ ~e & g5;
       const t1 = h + S1 + ch + SHA_K[j] + w[j] >>> 0;
       const S0 = rr(a, 2) ^ rr(a, 13) ^ rr(a, 22);
       const maj = a & b ^ a & c ^ b & c;
       const t2 = S0 + maj >>> 0;
-      h = g4;
-      g4 = f;
+      h = g5;
+      g5 = f;
       f = e;
       e = d + t1 >>> 0;
       d = c;
@@ -22858,7 +22911,7 @@ function sha256Bytes(msg) {
     h3 = h3 + d >>> 0;
     h4 = h4 + e >>> 0;
     h5 = h5 + f >>> 0;
-    h6 = h6 + g4 >>> 0;
+    h6 = h6 + g5 >>> 0;
     h7 = h7 + h >>> 0;
   }
   const out = new Uint8Array(32);
@@ -23281,33 +23334,39 @@ function tryParseTopLevel(code) {
     return null;
   }
 }
-function extractRuntimeNames(importStrs) {
-  const names = [];
+function extractRuntimeBindingPairs(importStrs) {
+  const pairs = [];
+  const isRuntimeTarget = (src2) => src2 === "@vesk/runtime" || src2 === "@vesk/reactivity" || src2.startsWith("@vesk/runtime/");
   for (const imp of importStrs) {
     const ast = tryParseImport(imp);
     if (ast) {
       for (const stmt of ast.body) {
         if (stmt.type !== "ImportDeclaration") continue;
+        if (stmt.importKind === "type") continue;
         const src2 = stmt.source?.value;
-        if (typeof src2 !== "string" || src2 !== "@vesk/runtime" && src2 !== "@vesk/reactivity") continue;
+        if (typeof src2 !== "string" || !isRuntimeTarget(src2)) continue;
         for (const spec of stmt.specifiers || []) {
           if (spec.importKind === "type") continue;
           if (spec.type === "ImportSpecifier") {
-            const name = spec.local?.name || spec.imported?.name;
-            if (name) names.push(name);
+            const local = spec.local?.name;
+            const imported = spec.imported?.name;
+            if (local) pairs.push({ imported: imported || local, local });
           } else if (spec.type === "ImportDefaultSpecifier" || spec.type === "ImportNamespaceSpecifier") {
-            if (spec.local?.name) names.push(spec.local.name);
+            if (spec.local?.name) pairs.push({ imported: "*", local: spec.local.name });
           }
         }
       }
       continue;
     }
     const target = importModuleTarget(imp);
-    if (target === "@vesk/runtime" || target === "@vesk/reactivity") {
-      for (const name of extractImportNames(imp)) names.push(name);
+    if (target && isRuntimeTarget(target)) {
+      for (const name of extractImportNames(imp)) pairs.push({ imported: name, local: name });
     }
   }
-  return names;
+  return pairs;
+}
+function extractRuntimeNames(importStrs) {
+  return extractRuntimeBindingPairs(importStrs).map((p) => p.local);
 }
 function tryParseImport(code) {
   try {
@@ -23348,7 +23407,7 @@ function setRuntimeModule(mod) {
   __cachedRuntimeModule = mod;
 }
 function loadRuntimeImports(importStrs) {
-  const names = extractRuntimeNames(importStrs);
+  const pairs = extractRuntimeBindingPairs(importStrs);
   const mod = __cachedRuntimeModule || index_server_exports;
   if (mod) {
     const result = {};
@@ -23357,8 +23416,12 @@ function loadRuntimeImports(importStrs) {
     for (const name of ["get", "set", "track"]) {
       if (name in mod) result[name] = mod[name];
     }
-    for (const name of names) {
-      if (name in mod) result[name] = mod[name];
+    for (const { imported, local } of pairs) {
+      if (imported === "*") {
+        result[local] = mod;
+      } else if (imported in mod) {
+        result[local] = mod[imported];
+      }
     }
     return result;
   }
@@ -23871,7 +23934,7 @@ function headers() {
 }
 function applyRequestSecurity(request, response) {
   if (!request || !response) return;
-  const overrides = request.getSecurityOverrides?.() || {};
+  const overrides = getSecurityOverrides() || request.getSecurityOverrides?.() || {};
   if (overrides.contentSecurityPolicy !== void 0) {
     response.setCsp(overrides.contentSecurityPolicy);
   }
@@ -23951,6 +24014,7 @@ var ServerRequest, ServerResponse, DEFAULT_MAX_BODY_BYTES2, PayloadTooLargeError
 var init_request = __esm({
   "../runtime/src/request.ts"() {
     "use strict";
+    init_security_overrides();
     ServerRequest = class extends Request {
       _cookies;
       _params;
@@ -24192,19 +24256,25 @@ var init_request = __esm({
       }
       setCsp(policy) {
         this._security.contentSecurityPolicy = policy;
+        setSecurityOverride("contentSecurityPolicy", policy);
       }
       setRateLimit(options) {
         this._security.rateLimit = options;
+        setSecurityOverride("rateLimit", options);
       }
       setCsrf(enable) {
         this._security.csrf = enable;
+        setSecurityOverride("csrf", enable);
       }
       setSecurityHeader(name, value) {
         if (!this._security.customHeaders) this._security.customHeaders = {};
         this._security.customHeaders[name] = value;
+        const existing2 = this._security.customHeaders;
+        setSecurityOverride("customHeaders", { ...existing2 });
       }
       setTrustProxy(enable) {
         this._security.trustProxy = enable;
+        setSecurityOverride("trustProxy", enable);
       }
       getSecurityOverrides() {
         return this._security;
@@ -24302,14 +24372,14 @@ var init_request = __esm({
       _flushSecurityHeaders() {
         for (const [name, value] of Object.entries(this._secHeaders)) {
           if (value === null) continue;
-          const existing = this.headers?.get(name);
-          if (!existing) this.headers?.set(name, value);
+          const existing2 = this.headers?.get(name);
+          if (!existing2) this.headers?.set(name, value);
         }
         this._secHeaders = {};
         if (this._cookieHeaders.length > 0) {
-          const existing = this.headers?.get("Set-Cookie");
-          if (existing) {
-            this.headers?.set("Set-Cookie", existing + ", " + this._cookieHeaders.join(", "));
+          const existing2 = this.headers?.get("Set-Cookie");
+          if (existing2) {
+            this.headers?.set("Set-Cookie", existing2 + ", " + this._cookieHeaders.join(", "));
           } else {
             this.headers?.set("Set-Cookie", this._cookieHeaders.join(", "));
           }
@@ -24769,8 +24839,8 @@ function Experiment(props) {
   }
   if (track3 && assignedVariant && typeof window !== "undefined") {
     const w = window;
-    const existing = w.__vsk_experiments || (w.__vsk_experiments = []);
-    existing.push({ experiment: name, variant: assignedVariant.name || "default" });
+    const existing2 = w.__vsk_experiments || (w.__vsk_experiments = []);
+    existing2.push({ experiment: name, variant: assignedVariant.name || "default" });
   }
   return assignedVariant ? assignedVariant.children || assignedVariant.content || null : defaultContent;
 }
@@ -24844,8 +24914,8 @@ function Field(props, registry, hydrate) {
   if (hydrate && hydrate.nextElement) {
     let wrapper2 = hydrate.nextElement("div");
     if (wrapper2 && !wrapper2.parentNode && hydrate.root) {
-      const existing = hydrate.root.querySelector(`[data-vsk-field="${name}"]`);
-      if (existing) wrapper2 = existing;
+      const existing2 = hydrate.root.querySelector(`[data-vsk-field="${name}"]`);
+      if (existing2) wrapper2 = existing2;
     }
     const inner = wrapper2 ? wrapper2.querySelector(`[data-vsk-field="${name}"]`) : null;
     const fieldEl = inner || wrapper2;
@@ -24987,8 +25057,8 @@ function Form(props, registry, hydrate) {
     const skipK = typeof hydrate.takeSkipK === "function" ? hydrate.takeSkipK() : 0;
     let form2 = hydrate.nextElement("form", skipK);
     if (form2 && !form2.parentNode && hydrate.root) {
-      const existing = hydrate.root.querySelector("form");
-      if (existing) form2 = existing;
+      const existing2 = hydrate.root.querySelector("form");
+      if (existing2) form2 = existing2;
     }
     if (form2) {
       form2.noValidate = true;
@@ -26846,8 +26916,8 @@ function Md(props, _registry, hydrate) {
   if (hydrate && typeof hydrate.nextElement === "function") {
     let el = hydrate.nextElement("div");
     if (el && !el.parentNode && hydrate.root) {
-      const existing = hydrate.root.querySelector("div");
-      if (existing) el = existing;
+      const existing2 = hydrate.root.querySelector("div");
+      if (existing2) el = existing2;
     }
     const claimed = !!el.parentNode;
     if (pathMode && claimed) {
@@ -27417,18 +27487,18 @@ function rerenderNode(node, deps, call) {
   if (typeof document === "undefined") return node;
   if (deps.length === 0) return node;
   let owned = null;
-  let current2 = null;
+  let current3 = null;
   if (Array.isArray(node)) {
     const roots = node.filter((n) => n && typeof n.nodeType === "number");
     owned = roots.length ? roots : null;
-    current2 = owned ? owned[0] : null;
+    current3 = owned ? owned[0] : null;
   } else if (node && typeof node.nodeType === "number") {
-    current2 = node;
+    current3 = node;
   }
-  if (!current2) return node;
+  if (!current3) return node;
   const liveRange = () => {
     if (owned) return owned;
-    return current2 && current2.parentNode ? [current2] : null;
+    return current3 && current3.parentNode ? [current3] : null;
   };
   let seen = deps.map(readDep);
   effect(() => {
@@ -27444,7 +27514,7 @@ function rerenderNode(node, deps, call) {
     for (const freshNode of fresh) parent.insertBefore(freshNode, old[0]);
     for (const oldNode of old) if (oldNode.parentNode) oldNode.parentNode.removeChild(oldNode);
     owned = next.nodeType === 11 ? fresh : null;
-    current2 = fresh[0] ?? current2;
+    current3 = fresh[0] ?? current3;
   });
   return node;
 }
@@ -27460,9 +27530,9 @@ var init_primitive = __esm({
 
 // ../runtime/src/action.ts
 function getActionRegistry() {
-  const g4 = globalThis;
-  if (!g4[registryKey]) g4[registryKey] = {};
-  return g4[registryKey];
+  const g5 = globalThis;
+  if (!g5[registryKey]) g5[registryKey] = {};
+  return g5[registryKey];
 }
 function hashString(str3) {
   let h1 = 2166136261;
@@ -27500,8 +27570,8 @@ function getAction(id) {
   return getActionRegistry()[id] || null;
 }
 function clearActions() {
-  const g4 = globalThis;
-  g4[registryKey] = {};
+  const g5 = globalThis;
+  g5[registryKey] = {};
 }
 function isFormAction(action) {
   return typeof action === "object" && action !== null && (action.__veskAction === true || typeof action.id === "string" && typeof action.url === "string");
@@ -27714,8 +27784,8 @@ function setIn(value, path, next) {
   const [key, ...rest] = path;
   const container = Array.isArray(value) ? value : isObject(value) ? value : null;
   if (container === null) return value;
-  const current2 = Array.isArray(container) ? container[typeof key === "number" ? key : Number(key)] : container[String(key)];
-  if (rest.length > 0 && current2 === void 0) return value;
+  const current3 = Array.isArray(container) ? container[typeof key === "number" ? key : Number(key)] : container[String(key)];
+  if (rest.length > 0 && current3 === void 0) return value;
   if (Array.isArray(value)) {
     const index = typeof key === "number" ? key : Number(key);
     if (!Number.isInteger(index) || index < 0) return value;
@@ -27736,18 +27806,18 @@ function updateIn(value, path, fn) {
   return setIn(value, [key], next);
 }
 function getIn(value, path) {
-  let current2 = value;
+  let current3 = value;
   for (const key of path) {
-    if (Array.isArray(current2)) {
+    if (Array.isArray(current3)) {
       const index = typeof key === "number" ? key : Number(key);
       if (!Number.isInteger(index)) return void 0;
-      current2 = current2[index];
+      current3 = current3[index];
       continue;
     }
-    if (!isObject(current2)) return void 0;
-    current2 = current2[String(key)];
+    if (!isObject(current3)) return void 0;
+    current3 = current3[String(key)];
   }
-  return current2;
+  return current3;
 }
 var init_nested_update = __esm({
   "../runtime/src/nested-update.ts"() {
@@ -27755,6 +27825,1019 @@ var init_nested_update = __esm({
   }
 });
 
+// ../runtime/src/store-persistence.ts
+function currentSsrToken() {
+  const g5 = globalThis;
+  return typeof g5.__vsk_ssr_token === "string" ? g5.__vsk_ssr_token : "";
+}
+function persistedStoreCookieName(storageKey) {
+  return "vsk_store_" + encodeURIComponent(storageKey);
+}
+function bucketFor(token) {
+  const set2 = pendingKeys.get(token);
+  if (set2) return set2;
+  const fresh = /* @__PURE__ */ new Set();
+  pendingKeys.set(token, fresh);
+  return fresh;
+}
+function readPersistedStorage(storageKey) {
+  if (!storageKey) return null;
+  if (typeof window === "undefined") {
+    bucketFor(currentSsrToken()).add(storageKey);
+    return serverReadHook ? serverReadHook(storageKey) ?? null : null;
+  }
+  const init = globalThis.__VESK_STORE_INIT__;
+  if (init && init[storageKey] !== void 0) {
+    const raw2 = init[storageKey];
+    delete init[storageKey];
+    try {
+      localStorage.setItem(storageKey, raw2);
+    } catch {
+    }
+    return raw2;
+  }
+  try {
+    return localStorage.getItem(storageKey);
+  } catch {
+    return null;
+  }
+}
+function writePersistedStorage(storageKey, raw2) {
+  if (!storageKey) return;
+  if (typeof window !== "undefined") {
+    try {
+      localStorage.setItem(storageKey, raw2);
+    } catch {
+    }
+  }
+  if (typeof document !== "undefined") {
+    try {
+      document.cookie = persistedStoreCookieName(storageKey) + "=" + encodeURIComponent(raw2) + "; path=/; max-age=31536000; SameSite=Lax";
+    } catch {
+    }
+  }
+}
+function clearPersistedStorage(storageKey) {
+  if (!storageKey) return;
+  if (typeof window !== "undefined") {
+    try {
+      localStorage.removeItem(storageKey);
+    } catch {
+    }
+  }
+  if (typeof document !== "undefined") {
+    try {
+      document.cookie = persistedStoreCookieName(storageKey) + "=; path=/; max-age=0";
+    } catch {
+    }
+  }
+}
+var serverReadHook, pendingKeys;
+var init_store_persistence = __esm({
+  "../runtime/src/store-persistence.ts"() {
+    "use strict";
+    serverReadHook = null;
+    pendingKeys = /* @__PURE__ */ new Map();
+  }
+});
+
+// ../runtime/src/store.ts
+function cloneState(value) {
+  return Array.isArray(value) ? value.slice() : { ...value };
+}
+function createStore(initial, options = {}) {
+  const { persist = false, storageKey, devtools = false } = options;
+  let value = cloneState(initial);
+  if (persist && storageKey) {
+    const stored = readPersistedStorage(storageKey);
+    if (stored) {
+      try {
+        value = JSON.parse(stored);
+      } catch {
+      }
+    }
+  }
+  const stateCell = track(value);
+  const subs = /* @__PURE__ */ new Set();
+  const watchers = [];
+  const middlewares = [];
+  let prevValue = cloneState(value);
+  let batchDepth = 0;
+  let dirty = false;
+  function notifyNow(action, payload) {
+    const current3 = stateCell.get();
+    if (current3 === prevValue) return;
+    subs.forEach((fn) => fn(current3));
+    watchers.forEach(({ selector, cb, equals }) => {
+      const eq = equals ?? Object.is;
+      const newVal = selector(current3);
+      const oldVal = selector(prevValue);
+      if (!eq(newVal, oldVal)) cb(newVal, oldVal);
+    });
+    middlewares.forEach((fn) => fn(current3, action, payload));
+    if (devtools && typeof window !== "undefined") {
+      const dt = window.__VESK_STORE_DEVTOOLS__;
+      if (dt && typeof dt.send === "function") {
+        dt.send({ type: action, payload, state: structuredClone(current3) });
+      }
+    }
+    prevValue = cloneState(current3);
+  }
+  function notifyDirty(action, payload) {
+    if (batchDepth > 0) {
+      dirty = true;
+    } else {
+      notifyNow(action, payload);
+    }
+  }
+  function persistToStorage() {
+    if (persist && storageKey) {
+      try {
+        writePersistedStorage(storageKey, JSON.stringify(stateCell.get()));
+      } catch (err) {
+        console.log("error saving to localStorage: ", err);
+      }
+    }
+  }
+  function get2() {
+    return stateCell.get();
+  }
+  function set2(next, action = "set") {
+    stateCell.set(next);
+    persistToStorage();
+    notifyDirty(action, next);
+  }
+  function update(partialOrFn, action = "update") {
+    const current3 = stateCell.get();
+    const patch = typeof partialOrFn === "function" ? partialOrFn(current3) : partialOrFn;
+    const next = Object.assign(cloneState(current3), patch);
+    stateCell.set(next);
+    persistToStorage();
+    notifyDirty(action, patch);
+  }
+  function deleteKeys(keys, action = "delete") {
+    const current3 = stateCell.get();
+    const kArray = Array.isArray(keys) ? keys : [keys];
+    const next = cloneState(current3);
+    kArray.forEach((k) => {
+      delete next[k];
+    });
+    stateCell.set(next);
+    persistToStorage();
+    notifyDirty(action, keys);
+  }
+  function reset2() {
+    stateCell.set(cloneState(initial));
+    notifyDirty("reset");
+  }
+  function rehydrate(newInitial) {
+    Object.assign(initial, newInitial);
+    stateCell.set(cloneState(initial));
+    notifyDirty("rehydrate");
+  }
+  function clear() {
+    stateCell.set(cloneState(initial));
+    if (persist && storageKey) {
+      clearPersistedStorage(storageKey);
+    }
+    notifyDirty("clear");
+  }
+  function batch(fn) {
+    batchDepth++;
+    try {
+      return flush_sync(fn);
+    } finally {
+      batchDepth--;
+      if (batchDepth === 0 && dirty) {
+        notifyDirty("batch");
+        dirty = false;
+      }
+    }
+  }
+  function subscribe(fn, selector, equals) {
+    const eq = equals ?? Object.is;
+    let hasPrev = false;
+    let prev;
+    const wrapper = selector ? (state) => {
+      const selected = selector(state);
+      if (!hasPrev || !eq(selected, prev)) {
+        hasPrev = true;
+        prev = selected;
+        fn(selected);
+      }
+    } : fn;
+    subs.add(wrapper);
+    wrapper(stateCell.get());
+    return () => subs.delete(wrapper);
+  }
+  function watch2(selector, callback, equals) {
+    watchers.push({ selector, cb: callback, equals });
+    return () => {
+      const i = watchers.findIndex((w) => w.cb === callback);
+      if (i >= 0) watchers.splice(i, 1);
+    };
+  }
+  function use(middleware) {
+    middlewares.push(middleware);
+    return () => {
+      const i = middlewares.indexOf(middleware);
+      if (i >= 0) middlewares.splice(i, 1);
+    };
+  }
+  function derive(selector, equals) {
+    return {
+      subscribe(cb) {
+        return subscribe(
+          (v) => cb(v),
+          selector,
+          equals
+        );
+      }
+    };
+  }
+  function toJSON() {
+    return structuredClone(stateCell.get());
+  }
+  return {
+    get: get2,
+    set: set2,
+    update,
+    delete: deleteKeys,
+    clear,
+    subscribe,
+    watch: watch2,
+    use,
+    derive,
+    batch,
+    reset: reset2,
+    rehydrate,
+    toJSON
+  };
+}
+var init_store = __esm({
+  "../runtime/src/store.ts"() {
+    "use strict";
+    init_ripple_runtime();
+    init_store_persistence();
+  }
+});
+
+// ../runtime/src/path-store.ts
+function isObject2(value) {
+  return value !== null && typeof value === "object";
+}
+function isDigits(s) {
+  if (s.length === 0) return false;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 48 || c > 57) return false;
+  }
+  return true;
+}
+function parseStorePath(input) {
+  const tokens = [];
+  let i = 0;
+  const n = input.length;
+  const readBracketed = () => {
+    i++;
+    let start = i;
+    while (i < n && input[i] >= "0" && input[i] <= "9") i++;
+    if (start === i || input[i] !== "]") {
+      throw new Error(`Path store: bad index in path "${input}"`);
+    }
+    tokens.push(Number(input.slice(start, i)));
+    i++;
+  };
+  while (i < n) {
+    const c = input[i];
+    if (c === ".") {
+      i++;
+      continue;
+    }
+    if (c === "[") {
+      readBracketed();
+      continue;
+    }
+    let start = i;
+    while (i < n && input[i] !== "." && input[i] !== "[") i++;
+    tokens.push(input.slice(start, i));
+  }
+  return tokens;
+}
+function pathKey(tokens) {
+  return tokens.join("\0");
+}
+function tokensOfKey(key) {
+  if (key === "") return [];
+  return key.split("\0").map((t) => isDigits(t) ? Number(t) : t);
+}
+function isPrefix(prefix, full) {
+  if (prefix.length > full.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (String(prefix[i]) !== String(full[i])) return false;
+  }
+  return true;
+}
+function isStrictPrefix(prefix, full) {
+  return prefix.length > 0 && prefix.length < full.length && isPrefix(prefix, full);
+}
+function cloneValue(value, seen) {
+  if (value === null || typeof value !== "object") return value;
+  seen = seen ?? /* @__PURE__ */ new Map();
+  const existing2 = seen.get(value);
+  if (existing2 !== void 0) return existing2;
+  if (value instanceof Date) {
+    const d = new Date(value.getTime());
+    seen.set(value, d);
+    return d;
+  }
+  if (value instanceof RegExp) {
+    const r = new RegExp(value.source, value.flags);
+    seen.set(value, r);
+    return r;
+  }
+  if (value instanceof Map) {
+    const out = /* @__PURE__ */ new Map();
+    seen.set(value, out);
+    for (const [k, v] of value) out.set(cloneValue(k, seen), cloneValue(v, seen));
+    return out;
+  }
+  if (value instanceof Set) {
+    const out = /* @__PURE__ */ new Set();
+    seen.set(value, out);
+    for (const v of value) out.add(cloneValue(v, seen));
+    return out;
+  }
+  if (Array.isArray(value)) {
+    const out = [];
+    seen.set(value, out);
+    for (const item of value) out.push(cloneValue(item, seen));
+    return out;
+  }
+  if (ArrayBuffer.isView(value)) {
+    const out = value.slice();
+    seen.set(value, out);
+    return out;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto === Object.prototype || proto === null) {
+    const out = {};
+    seen.set(value, out);
+    for (const key of Object.keys(value)) {
+      out[key] = cloneValue(value[key], seen);
+    }
+    return out;
+  }
+  seen.set(value, value);
+  try {
+    return structuredClone(value);
+  } catch {
+    return value;
+  }
+}
+function plainClone(value, seen) {
+  if (value === null || typeof value !== "object") return value;
+  seen = seen ?? /* @__PURE__ */ new Set();
+  if (seen.has(value)) throw new Error("Path store: toJSON() cannot serialize cyclic state");
+  seen.add(value);
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof RegExp) return String(value);
+  if (value instanceof Map) {
+    const out2 = [];
+    for (const [k, v] of value) out2.push([plainClone(k, seen), plainClone(v, seen)]);
+    return out2;
+  }
+  if (value instanceof Set) {
+    const out2 = [];
+    for (const v of value) out2.push(plainClone(v, seen));
+    return out2;
+  }
+  if (Array.isArray(value)) {
+    const out2 = [];
+    for (const item of value) out2.push(plainClone(item, seen));
+    return out2;
+  }
+  const out = {};
+  for (const key of Object.keys(value)) {
+    out[key] = plainClone(value[key], seen);
+  }
+  return out;
+}
+function shallowDiff(before, after, base, out) {
+  if (Object.is(before, after)) return;
+  const beforeObj = isObject2(before);
+  const afterObj = isObject2(after);
+  if (!beforeObj || !afterObj || Array.isArray(before) !== Array.isArray(after)) {
+    out.push({ path: pathKey(base), before, after });
+    return;
+  }
+  const array = Array.isArray(before);
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(before),
+    ...Object.keys(after)
+  ]);
+  for (const key of keys) {
+    const segment = array && isDigits(key) ? Number(key) : key;
+    shallowDiff(
+      before[key],
+      after[key],
+      [...base, segment],
+      out
+    );
+  }
+}
+function createPathStore(initial, options = {}) {
+  const { persist = false, storageKey, historyLimit = 500 } = options;
+  let state = cloneValue(initial);
+  if (persist && storageKey) {
+    const raw2 = readPersistedStorage(storageKey);
+    if (raw2) {
+      try {
+        const parsed = JSON.parse(raw2);
+        if (parsed !== null && typeof parsed === "object") {
+          state = { ...state, ...cloneValue(parsed) };
+        }
+      } catch {
+      }
+    }
+  }
+  const rootCell = track(state);
+  const cellRoot = {};
+  function nodeFor(path, create) {
+    let node = cellRoot;
+    for (const seg of path) {
+      const key = String(seg);
+      let child = node.children?.get(key);
+      if (!child) {
+        if (!create) return null;
+        child = {};
+        if (!node.children) node.children = /* @__PURE__ */ new Map();
+        node.children.set(key, child);
+      }
+      node = child;
+    }
+    return node;
+  }
+  function cellFor(path) {
+    const node = nodeFor(path, true);
+    if (!node.cell) {
+      node.cell = track(getIn(state, path));
+      setImprint(node, path);
+    }
+    return node.cell;
+  }
+  function collectCellNodes(node) {
+    const out = [];
+    if (!node) return out;
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.cell) out.push(n);
+      if (n.children) for (const child of n.children.values()) stack.push(child);
+    }
+    return out;
+  }
+  function cellsRelatedTo(path) {
+    const out = [];
+    const tNode = nodeFor(path, false);
+    out.push(...collectCellNodes(tNode));
+    for (let i = path.length - 1; i > 0; i--) {
+      const ancestor = nodeFor(path.slice(0, i), false);
+      if (ancestor?.cell) out.push(ancestor);
+    }
+    return out;
+  }
+  function syncCell(node, path) {
+    const cell = node.cell;
+    const next = getIn(state, path);
+    if (!Object.is(cell.get(), next)) cell.set(next);
+  }
+  function syncPathCells(touched) {
+    if (touched === null) {
+      for (const node of collectCellNodes(cellRoot)) {
+        if (node.cell) syncCell(node, nodePathOf(node));
+      }
+      return;
+    }
+    for (const node of cellsRelatedTo(touched)) {
+      if (!node.cell) continue;
+      syncCell(node, nodePathOf(node));
+    }
+  }
+  function nodePathOf(node) {
+    return nodePathCache.get(node) ?? [];
+  }
+  const nodePathCache = /* @__PURE__ */ new Map();
+  function setImprint(node, path) {
+    nodePathCache.set(node, path.slice());
+  }
+  const derivedDefs = /* @__PURE__ */ new Map();
+  const depRoot = { defs: null };
+  function depNodeFor(tokens, create) {
+    let node = depRoot;
+    for (const seg of tokens) {
+      const key = String(seg);
+      let child = node.children?.get(key);
+      if (!child) {
+        if (!create) return null;
+        child = { defs: null };
+        if (!node.children) node.children = /* @__PURE__ */ new Map();
+        node.children.set(key, child);
+      }
+      node = child;
+    }
+    return node;
+  }
+  function registerDep(def, tokens) {
+    const node = depNodeFor(tokens, true);
+    if (!node.defs) node.defs = /* @__PURE__ */ new Set();
+    node.defs.add(def);
+  }
+  function unregisterDep(def, tokens) {
+    const node = depNodeFor(tokens, false);
+    if (node?.defs) {
+      node.defs.delete(def);
+      if (node.defs.size === 0) node.defs = null;
+    }
+  }
+  function registerDef(def) {
+    for (const dep of def.deps) registerDep(def, dep);
+  }
+  function unregisterDef(def) {
+    for (const dep of def.deps) unregisterDep(def, dep);
+  }
+  function derivedsRelatedTo(path, out) {
+    const n = depNodeFor(path, false);
+    if (n) {
+      const stack = [n];
+      while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.defs) for (const def of node.defs) out.add(def);
+        if (node.children) for (const child of node.children.values()) stack.push(child);
+      }
+    }
+    for (let i = path.length - 1; i > 0; i--) {
+      const ancestor = depNodeFor(path.slice(0, i), false);
+      if (ancestor?.defs) for (const def of ancestor.defs) out.add(def);
+    }
+    return Array.from(out);
+  }
+  const COLLAPSE_THRESHOLD = 8;
+  const proxyTargets = /* @__PURE__ */ new WeakMap();
+  function evaluate(selector) {
+    return untrack2(() => {
+      const deps = [];
+      const seen = /* @__PURE__ */ new Set();
+      const envelopeLeaves = /* @__PURE__ */ new Map();
+      const collapsed = /* @__PURE__ */ new Set();
+      const recordLeaf = (path) => {
+        const k = pathKey(path);
+        if (!seen.has(k)) {
+          seen.add(k);
+          deps.push(path);
+        }
+      };
+      const recordEnvelope = (env) => {
+        if (env.length === 0) return;
+        const k = pathKey(env);
+        const count = (envelopeLeaves.get(k) ?? 0) + 1;
+        envelopeLeaves.set(k, count);
+        if (count >= COLLAPSE_THRESHOLD) collapsed.add(k);
+        recordLeaf(env);
+      };
+      const isPlain = (value) => value !== null && typeof value === "object" && (Array.isArray(value) || Object.prototype.toString.call(value) === "[object Object]");
+      const wrap = (value, base) => {
+        if (!isPlain(value)) return value;
+        const proxy = new Proxy(value, {
+          get(target, prop, receiver) {
+            if (typeof prop === "symbol") return Reflect.get(target, prop, receiver);
+            const array = Array.isArray(target);
+            const segment = array && isDigits(String(prop)) ? Number(prop) : String(prop);
+            const child = base.concat(segment);
+            const v = Reflect.get(target, prop, receiver);
+            if (isPlain(v)) return wrap(v, child);
+            if (typeof v === "function") return v;
+            recordLeaf(child);
+            if (array) recordEnvelope(base);
+            return v;
+          },
+          set() {
+            throw new Error("Path store: derived selectors must be pure \u2014 no writes.");
+          }
+        });
+        proxyTargets.set(proxy, value);
+        return proxy;
+      };
+      const unwrap = (value) => {
+        if (value === null || typeof value !== "object") return value;
+        const target = proxyTargets.get(value);
+        if (target !== void 0) return unwrap(target);
+        if (Array.isArray(value)) {
+          let changed2 = false;
+          const out2 = [];
+          for (const item of value) {
+            const next = unwrap(item);
+            if (next !== item) changed2 = true;
+            out2.push(next);
+          }
+          return changed2 ? out2 : value;
+        }
+        let changed = false;
+        const out = {};
+        for (const key of Object.keys(value)) {
+          const next = unwrap(value[key]);
+          if (next !== value[key]) changed = true;
+          out[key] = next;
+        }
+        return changed ? out : value;
+      };
+      const result = selector(wrap(state, []));
+      const finalDeps = collapsed.size === 0 ? deps : deps.filter((d) => {
+        for (const envKey of collapsed) {
+          if (isStrictPrefix(tokensOfKey(envKey), d)) return false;
+        }
+        return true;
+      });
+      return { value: unwrap(result), deps: finalDeps };
+    });
+  }
+  function recomputeDerived(changes, version3) {
+    const queue = [];
+    const queued = /* @__PURE__ */ new Set();
+    const collect = (tokens) => {
+      for (const def of derivedsRelatedTo(tokens, /* @__PURE__ */ new Set())) {
+        if (!queued.has(def)) {
+          queued.add(def);
+          queue.push(def);
+        }
+      }
+    };
+    for (const change of changes) collect(tokensOfKey(change.path));
+    while (queue.length > 0) {
+      const def = queue.pop();
+      unregisterDef(def);
+      const { value, deps } = evaluate(def.selector);
+      def.deps = deps;
+      registerDef(def);
+      const before = def.cell.get();
+      if (!def.equals(before, value)) {
+        def.cell.set(value);
+        def.lastTrigger = changes.map((c) => tokensOfKey(c.path));
+        def.lastTriggerVersion = version3;
+        mergedDirty = true;
+        const change = { path: def.path, before, after: value };
+        changes.push(change);
+        collect(def.tokens);
+      }
+    }
+  }
+  let mergedCache = null;
+  let mergedDirty = true;
+  function invalidateMerged() {
+    mergedCache = null;
+    mergedDirty = true;
+  }
+  function buildMerged() {
+    if (!mergedDirty && mergedCache !== null) return mergedCache;
+    const base = rootCell.get();
+    if (derivedDefs.size === 0) {
+      mergedCache = base;
+      mergedDirty = false;
+      return base;
+    }
+    let acc = base;
+    for (const def of derivedDefs.values()) {
+      acc = setIn(acc, def.tokens, def.cell.get());
+    }
+    mergedCache = acc;
+    mergedDirty = false;
+    return acc;
+  }
+  const events = [];
+  let version2 = 0;
+  let undoStack = [];
+  let redoStack = [];
+  const lastCause = /* @__PURE__ */ new Map();
+  function recordCause(changes, action, atVersion) {
+    for (const change of changes) {
+      lastCause.set(change.path, { action, version: atVersion });
+    }
+  }
+  function commit(next, action, touched) {
+    untrack2(() => {
+      if (Object.is(next, state)) return;
+      const changes = [];
+      if (touched !== null) {
+        shallowDiff(getIn(state, touched), getIn(next, touched), touched, changes);
+      } else {
+        shallowDiff(state, next, [], changes);
+      }
+      if (changes.length === 0) return;
+      undoStack.push(state);
+      if (undoStack.length > historyLimit) undoStack.shift();
+      redoStack = [];
+      state = next;
+      rootCell.set(state);
+      invalidateMerged();
+      const nextVersion = version2 + 1;
+      recordCause(changes, action, nextVersion);
+      recomputeDerived(changes, nextVersion);
+      syncPathCells(touched);
+      dispatchAll();
+      persistToStorage();
+      version2 = nextVersion;
+      events.push({ version: version2, action, at: Date.now(), changes });
+      if (events.length > historyLimit) events.shift();
+    });
+  }
+  function restore(snapshot, action) {
+    const changes = [];
+    untrack2(() => {
+      shallowDiff(state, snapshot, [], changes);
+      state = snapshot;
+      rootCell.set(state);
+      invalidateMerged();
+      const nextVersion = version2 + 1;
+      recordCause(changes, action, nextVersion);
+      recomputeDerived(changes, nextVersion);
+      syncPathCells(null);
+      if (changes.length > 0) dispatchAll();
+      persistToStorage();
+      version2 = nextVersion;
+      events.push({ version: version2, action, at: Date.now(), changes });
+      if (events.length > historyLimit) events.shift();
+    });
+    return changes;
+  }
+  function persistToStorage() {
+    if (!persist || !storageKey) return;
+    try {
+      writePersistedStorage(storageKey, JSON.stringify(state));
+    } catch {
+    }
+  }
+  const subscribers = /* @__PURE__ */ new Set();
+  const watchers = /* @__PURE__ */ new Set();
+  function dispatchAll() {
+    const current3 = buildMerged();
+    for (const wrapper of subscribers) wrapper(current3);
+    for (const wrapper of watchers) wrapper();
+  }
+  function whyAt(tokens, depth = 0, versionNow = version2) {
+    const path = pathKey(tokens);
+    const value = getIn(state, tokens);
+    if (depth > 64) return { path, value, cause: "initial" };
+    const def = derivedDefs.get(path);
+    if (def) {
+      const node = {
+        path,
+        value: def.cell.get(),
+        cause: "derived",
+        from: def.deps.map((dep) => whyAt(dep, depth + 1))
+      };
+      if (def.lastTrigger) {
+        node.changedBy = def.lastTrigger.map((trigger, i) => ({
+          path: pathKey(trigger),
+          value: getIn(state, trigger),
+          cause: "action",
+          action: i === 0 ? void 0 : void 0,
+          // filled below from events
+          version: def.lastTriggerVersion
+        }));
+        const first = def.lastTrigger[0];
+        const ev = events.slice().reverse().find((e) => e.changes.some((c) => c.path === pathKey(first)));
+        if (ev) {
+          node.changedBy[0].action = ev.action;
+          node.changedBy[0].version = ev.version;
+          node.version = ev.version;
+        }
+      }
+      void versionNow;
+      return node;
+    }
+    const cause = lastCause.get(path);
+    if (cause) {
+      if (cause.action === "undo" || cause.action === "redo") {
+        return { path, value, cause: "time-travel", action: cause.action, version: cause.version };
+      }
+      return { path, value, cause: "action", action: cause.action, version: cause.version };
+    }
+    return { path, value, cause: "initial" };
+  }
+  function renderExplanation(node, indent4 = 0) {
+    const pad = "  ".repeat(indent4);
+    const lines = [];
+    const tag = node.cause === "derived" ? "derived" : node.cause === "action" ? `${node.action ?? "action"} \xB7 v${node.version ?? "?"}` : node.cause === "time-travel" ? `time-travel \xB7 v${node.version ?? "?"}` : "initial";
+    lines.push(`${pad}${node.path} = ${JSON.stringify(node.value)}  (${tag})`);
+    if (node.changedBy && node.changedBy.length > 0) {
+      lines.push(`${pad}  recomputed after:`);
+      for (const change of node.changedBy) {
+        lines.push(renderExplanation({ ...change, from: void 0 }, indent4 + 2));
+      }
+    } else if (node.from && node.from.length > 0) {
+      for (const child of node.from) lines.push(renderExplanation(child, indent4 + 1));
+    }
+    return lines.join("\n");
+  }
+  function derivedHandle(def, displayPath2) {
+    return {
+      path: def.path,
+      get deps() {
+        return def.deps.map((dep) => dep.join("."));
+      },
+      get() {
+        return def.cell.get();
+      },
+      subscribe(cb) {
+        let prev = def.cell.get();
+        return store.subscribe(() => {
+          const next = def.cell.get();
+          if (!Object.is(prev, next)) {
+            prev = next;
+            cb(next);
+          }
+        });
+      }
+    };
+    void displayPath2;
+  }
+  const store = {
+    /** Reactive whole-state read — re-runs on any commit. Includes derived
+     *  values at their registered paths (derived wins over a raw key). */
+    get() {
+      rootCell.get();
+      return buildMerged();
+    },
+    /** A fine-grained, causally-aware handle for one nested path. When a
+     *  derived is registered at this path, the handle reads/writes the
+     *  derived (set/update then throw read-only). */
+    at(path) {
+      const tokens = parseStorePath(path);
+      const key = pathKey(tokens);
+      const def = derivedDefs.get(key);
+      if (def) {
+        const handle2 = derivedHandle(def, path);
+        return {
+          path: key,
+          get: handle2.get,
+          set() {
+            throw new Error(`Path store: derived path "${path}" is read-only.`);
+          },
+          update() {
+            throw new Error(`Path store: derived path "${path}" is read-only.`);
+          },
+          subscribe: handle2.subscribe
+        };
+      }
+      return {
+        path: key,
+        get() {
+          return cellFor(tokens).get();
+        },
+        set(value, action = "set") {
+          commit(setIn(state, tokens, cloneValue(value)), action, tokens);
+        },
+        update(fn, action = "update") {
+          commit(updateIn(state, tokens, fn), action, tokens);
+        },
+        subscribe(cb) {
+          let prev = cellFor(tokens).get();
+          return store.subscribe(() => {
+            const next = cellFor(tokens).get();
+            if (!Object.is(prev, next)) {
+              prev = next;
+              cb(next);
+            }
+          });
+        }
+      };
+    },
+    /** Replace the whole state (attributed to `action`). */
+    set(next, action = "set") {
+      commit(cloneValue(next), action, null);
+    },
+    /** Shallow merge a partial (or `(prev) => partial`) into the root. */
+    update(patch, action = "update") {
+      const partial = typeof patch === "function" ? patch(state) : patch;
+      commit({ ...state, ...cloneValue(partial) }, action, null);
+    },
+    setIn(path, value, action = "setIn") {
+      const tokens = typeof path === "string" ? parseStorePath(path) : path;
+      commit(setIn(state, tokens, cloneValue(value)), action, tokens);
+    },
+    updateIn(path, fn, action = "updateIn") {
+      const tokens = typeof path === "string" ? parseStorePath(path) : path;
+      commit(updateIn(state, tokens, fn), action, tokens);
+    },
+    /**
+     * Register a derived node at `path`. The selector is evaluated inside
+     * `untrack` against a read-recording proxy, so its source paths are
+     * captured automatically — including array envelopes, which make
+     * aggregate deriveds re-run when the array's membership changes.
+     */
+    derived(path, selector, equals = Object.is) {
+      const tokens = parseStorePath(path);
+      const key = pathKey(tokens);
+      const first = evaluate(selector);
+      const def = {
+        path: key,
+        tokens,
+        selector,
+        equals,
+        cell: track(first.value),
+        deps: first.deps,
+        lastTrigger: null,
+        lastTriggerVersion: 0
+      };
+      derivedDefs.set(key, def);
+      registerDef(def);
+      mergedDirty = true;
+      return derivedHandle(def, path);
+    },
+    subscribe(fn, selector, equals) {
+      const eq = equals ?? Object.is;
+      let hasPrev = false;
+      let prev;
+      const wrapper = selector ? () => {
+        const selected = selector(buildMerged());
+        if (!hasPrev || !eq(selected, prev)) {
+          hasPrev = true;
+          prev = selected;
+          fn(selected);
+        }
+      } : (current3) => fn(current3);
+      subscribers.add(wrapper);
+      wrapper(buildMerged());
+      return () => {
+        subscribers.delete(wrapper);
+      };
+    },
+    watch(selector, callback) {
+      let prev = selector(buildMerged());
+      const wrapper = () => {
+        const next = selector(buildMerged());
+        if (!Object.is(prev, next)) {
+          const old = prev;
+          prev = next;
+          callback(next, old);
+        }
+      };
+      watchers.add(wrapper);
+      return () => {
+        watchers.delete(wrapper);
+      };
+    },
+    /** Causal explanation for the current value at `path`. */
+    why(path) {
+      return whyAt(parseStorePath(path));
+    },
+    /** A printable causal chain for devtools / tests. */
+    explain(path) {
+      return renderExplanation(whyAt(parseStorePath(path)));
+    },
+    /** The recorded events, oldest first. */
+    get events() {
+      return events;
+    },
+    get version() {
+      return version2;
+    },
+    canUndo() {
+      return undoStack.length > 0;
+    },
+    canRedo() {
+      return redoStack.length > 0;
+    },
+    undo() {
+      const prev = undoStack.pop();
+      if (prev === void 0) return false;
+      redoStack.push(state);
+      restore(prev, "undo");
+      return true;
+    },
+    redo() {
+      const next = redoStack.pop();
+      if (next === void 0) return false;
+      undoStack.push(state);
+      restore(next, "redo");
+      return true;
+    },
+    /** A JSON-safe snapshot of the current merged state. */
+    toJSON() {
+      return plainClone(buildMerged());
+    }
+  };
+  return store;
+}
+var init_path_store = __esm({
+  "../runtime/src/path-store.ts"() {
+    "use strict";
+    init_ripple_runtime();
+    init_nested_update();
+    init_store_persistence();
+  }
+});
+
 // ../runtime/src/index-server.ts
 var index_server_exports = {};
 __export(index_server_exports, {
@@ -27809,8 +28892,10 @@ __export(index_server_exports, {
   createContext: () => createContext,
   createFileRouter: () => createFileRouter,
   createLocals: () => createLocals,
+  createPathStore: () => createPathStore,
   createResource: () => createResource,
   createRouter: () => createRouter,
+  createStore: () => createStore,
   create_component_ctx: () => create_component_ctx,
   create_try_block: () => create_try_block,
   custom: () => custom,
@@ -27936,6 +29021,8 @@ var init_index_server = __esm({
     init_action();
     init_metadata();
     init_nested_update();
+    init_store();
+    init_path_store();
   }
 });
 
@@ -33707,8 +34794,8 @@ function isThenable(value) {
   return typeof value?.then === "function";
 }
 function withSsrStore(fn) {
-  const existing = storage.getStore();
-  if (existing) return fn();
+  const existing2 = storage.getStore();
+  if (existing2) return fn();
   const store = createSsrStore();
   keepSsrSlot(store.token);
   let result;
@@ -33750,15 +34837,15 @@ function dropSsrSlot(token) {
 function isSsrSlotLive(token) {
   return liveSlots.has(token);
 }
-var TOKEN_KEY, IMPL_KEY, g2, impl, storage, liveSlots, ssrSink2;
+var TOKEN_KEY, IMPL_KEY, g3, impl, storage, liveSlots, ssrSink2;
 var init_ssr_store = __esm({
   "../compiler/src/ssr-store.ts"() {
     "use strict";
     init_index_server();
     TOKEN_KEY = "__vsk_ssr_token";
     IMPL_KEY = "__vsk_ssr_store_impl";
-    g2 = globalThis;
-    impl = g2[IMPL_KEY] ?? (g2[IMPL_KEY] = {
+    g3 = globalThis;
+    impl = g3[IMPL_KEY] ?? (g3[IMPL_KEY] = {
       storage: new AsyncLocalStorage(),
       liveSlots: /* @__PURE__ */ new Map(),
       // Only the copy that created the implementation installs the token
@@ -34065,17 +35152,17 @@ async function settleSsrPromises(token) {
   }
 }
 function pruneSsrDataSlots() {
-  const g4 = globalThis;
+  const g5 = globalThis;
   const prefix = "__vsk_ssr_data_";
   const stale = [];
-  for (const k of Object.keys(g4)) {
+  for (const k of Object.keys(g5)) {
     if (typeof k !== "string" || !k.startsWith(prefix)) continue;
     if (isSsrSlotLive(k.slice(prefix.length))) continue;
     stale.push(k);
   }
   if (stale.length <= 40) return;
   stale.sort().slice(0, stale.length - 40).forEach((k) => {
-    delete g4[k];
+    delete g5[k];
   });
 }
 async function applyHeadPlugins(headHtml, plugins, ctx2) {
@@ -34804,9 +35891,9 @@ function getPluginRecords(appDir, veskDir, configPluginNames) {
 }
 function setPluginActive(veskDir, name, active) {
   const state = readPluginState(veskDir);
-  const existing = state.plugins.find((p) => eqIgnoreCase(p.name, name));
-  if (existing) {
-    existing.active = active;
+  const existing2 = state.plugins.find((p) => eqIgnoreCase(p.name, name));
+  if (existing2) {
+    existing2.active = active;
   } else {
     state.plugins.push({ name, package: name, active });
   }
@@ -34886,13 +35973,13 @@ async function installPlugin(appDir, veskDir, pkg) {
   }
   const state = readPluginState(veskDir);
   const name = probe.packageJson?.name || pkg;
-  const existing = state.plugins.find(
+  const existing2 = state.plugins.find(
     (p) => eqIgnoreCase(p.package, pkg) || eqIgnoreCase(p.name, name)
   );
-  if (existing) {
-    existing.package = pkg;
-    existing.name = name;
-    existing.active = true;
+  if (existing2) {
+    existing2.package = pkg;
+    existing2.name = name;
+    existing2.active = true;
   } else {
     state.plugins.push({ name, package: pkg, active: true });
   }
@@ -34930,12 +36017,12 @@ async function updatePlugin(appDir, veskDir, pkg) {
   const probe = resolvePackage(appDir, pkg);
   const state = readPluginState(veskDir);
   const name = probe.packageJson?.name || pkg;
-  const existing = state.plugins.find(
+  const existing2 = state.plugins.find(
     (p) => eqIgnoreCase(p.package, pkg) || eqIgnoreCase(p.name, name)
   );
-  if (existing) {
-    existing.package = pkg;
-    existing.name = name;
+  if (existing2) {
+    existing2.package = pkg;
+    existing2.name = name;
   } else {
     state.plugins.push({ name, package: pkg, active: true });
   }
@@ -34944,7 +36031,7 @@ async function updatePlugin(appDir, veskDir, pkg) {
     name,
     pkg,
     source: "state",
-    activeRaw: existing ? existing.active : true,
+    activeRaw: existing2 ? existing2.active : true,
     error: null
   }, appDir);
 }
@@ -36153,16 +37240,21 @@ function __matchPath(pattern, pathname) {
   let pi = 0, pp = 0;
   const params = {};
   while (pi < pathParts.length && pp < patternParts.length) {
-    if (patternParts[pp].startsWith(':')) {
-      const name = patternParts[pp].slice(1);
-      params[name] = pathParts[pi];
+    const seg = patternParts[pp];
+    // A "*name" segment is a catch-all and absorbs the rest of the path.
+    if (seg.startsWith('*')) { params[seg.slice(1)] = pathParts.slice(pi).join('/'); pi = pathParts.length; pp++; }
+    else if (seg.startsWith(':')) {
+      params[seg.slice(1)] = pathParts[pi];
       pi++; pp++;
-    } else if (patternParts[pp] === pathParts[pi]) {
+    } else if (seg === pathParts[pi]) {
       pi++; pp++;
     } else {
       return null;
     }
   }
+  // A trailing catch-all still matches an empty tail; the loop above exits as
+  // soon as the URL is exhausted, so without this it was never reached.
+  if (pp === patternParts.length - 1 && patternParts[pp].startsWith('*')) { params[patternParts[pp].slice(1)] = pathParts.slice(pi).join('/'); pp++; }
   if (pp === patternParts.length && pi === pathParts.length) return params;
   return null;
 }
@@ -39112,9 +40204,9 @@ function Md2(props, _registry, hydrate) {
   if (hydrate && typeof hydrate.nextElement === "function") {
     let el = hydrate.nextElement("div");
     if (el && !el.parentNode && hydrate.root) {
-      const existing = hydrate.root.querySelector("div");
-      if (existing)
-        el = existing;
+      const existing2 = hydrate.root.querySelector("div");
+      if (existing2)
+        el = existing2;
     }
     const claimed = !!el.parentNode;
     if (pathMode && claimed) {
@@ -40089,9 +41181,9 @@ function getJSXTagName2(el) {
   if (name.type === "JSXNamespacedName") return name.namespace.name + ":" + name.name.name;
   return null;
 }
-function emitJSXText(g4, text, start, end) {
+function emitJSXText(g5, text, start, end) {
   if (text.indexOf("<") === -1 && text.indexOf(">") === -1 && text.indexOf("&") === -1 && text.indexOf("{") === -1 && text.indexOf("}") === -1) {
-    g4.add(text, start, end);
+    g5.add(text, start, end);
     return;
   }
   let out = "";
@@ -40104,7 +41196,7 @@ function emitJSXText(g4, text, start, end) {
     else if (c === "}") out += "&#125;";
     else out += c;
   }
-  g4.add(out, start, end);
+  g5.add(out, start, end);
 }
 function collapseWithMap(value) {
   let out = "";
@@ -40261,31 +41353,31 @@ function stripCallTypeArgs(text) {
   }
   return text;
 }
-function emitTrackDeclStatement(g4, source, stmt, indent4, isLast, opts) {
+function emitTrackDeclStatement(g5, source, stmt, indent4, isLast, opts) {
   const fullText = stripTrailingSemicolons(source.slice(stmt.start, stmt.end).trimEnd());
   const text = fullText + (!fullText.endsWith("}") && !isLast ? ";" : "");
   const decls = stmt.declarations || [];
-  g4.add(indent4);
+  g5.add(indent4);
   let prevEnd = stmt.start;
   for (let di = 0; di < decls.length; di++) {
     const decl = decls[di];
     const id = decl.id;
     const isLazy = id && id.type === "ArrayPattern" && id.lazy === true && decl.init;
     if (!isLazy) {
-      g4.addRaw(source.slice(prevEnd, decl.start));
-      g4.add(source.slice(decl.start, decl.end), decl.start, decl.end);
+      g5.addRaw(source.slice(prevEnd, decl.start));
+      g5.add(source.slice(decl.start, decl.end), decl.start, decl.end);
       prevEnd = decl.end;
       continue;
     }
-    if (di > 0) g4.addRaw(source.slice(prevEnd, decl.start));
+    if (di > 0) g5.addRaw(source.slice(prevEnd, decl.start));
     const ch = text[decl.end - stmt.start] ?? " ";
     const elements = id.elements || [];
     const names = elements.map((el) => el ? el.name : null).filter((n) => typeof n === "string");
     const initText = source.slice(decl.init.start, decl.init.end);
     if (names.length === 0) {
-      g4.add("let _ = ");
-      g4.add(initText, decl.init.start, decl.init.end);
-      if (ch !== ";") g4.addRaw(";");
+      g5.add("let _ = ");
+      g5.add(initText, decl.init.start, decl.init.end);
+      if (ch !== ";") g5.addRaw(";");
       prevEnd = decl.end;
       continue;
     }
@@ -40296,133 +41388,133 @@ function emitTrackDeclStatement(g4, source, stmt, indent4, isLast, opts) {
     const firstRange = [elements[0].start, elements[0].end];
     const dropLastSemi = ch === ";";
     if (opts.typedCells) {
-      const cellName = g4.cellCount === 0 ? "__cell" : `__cell${g4.cellCount}`;
-      g4.cellCount++;
+      const cellName = g5.cellCount === 0 ? "__cell" : `__cell${g5.cellCount}`;
+      g5.cellCount++;
       if (annotation) {
-        g4.add(`const ${cellName}: Tracked<`);
-        g4.add(annotation, annStart, annEnd);
-        g4.add("> = ");
+        g5.add(`const ${cellName}: Tracked<`);
+        g5.add(annotation, annStart, annEnd);
+        g5.add("> = ");
       } else {
-        g4.add(`const ${cellName} = `);
+        g5.add(`const ${cellName} = `);
       }
       const cellInit = annotation ? stripCallTypeArgs(initText) : initText;
-      g4.add(cellInit, decl.init.start, decl.init.end);
-      g4.add(";");
-      g4.add(" let ");
-      g4.add(first, firstRange[0], firstRange[1], REACTIVE_DATA);
+      g5.add(cellInit, decl.init.start, decl.init.end);
+      g5.add(";");
+      g5.add(" let ");
+      g5.add(first, firstRange[0], firstRange[1], REACTIVE_DATA);
       if (annotation) {
-        g4.add(": ");
-        g4.add(annotation, annStart, annEnd);
+        g5.add(": ");
+        g5.add(annotation, annStart, annEnd);
       }
-      g4.add(` = ${cellName}.get();`);
+      g5.add(` = ${cellName}.get();`);
       for (let n = 1; n < names.length; n++) {
-        g4.add(" let ");
-        g4.add(names[n], elements[n].start, elements[n].end, REACTIVE_DATA);
-        g4.add(` = ${cellName};`);
+        g5.add(" let ");
+        g5.add(names[n], elements[n].start, elements[n].end, REACTIVE_DATA);
+        g5.add(` = ${cellName};`);
       }
-      if (dropLastSemi) g4.code = g4.code.slice(0, -1);
+      if (dropLastSemi) g5.code = g5.code.slice(0, -1);
     } else {
       if (annotation) {
-        g4.add("let ");
-        g4.add(first, firstRange[0], firstRange[1], REACTIVE_DATA);
-        g4.add(": ");
-        g4.add(annotation, annStart, annEnd);
-        g4.add(" = (");
-        g4.add(stripCallTypeArgs(initText), decl.init.start, decl.init.end);
-        g4.add(" as unknown as ");
-        g4.add(annotation, annStart, annEnd);
-        g4.add(");");
+        g5.add("let ");
+        g5.add(first, firstRange[0], firstRange[1], REACTIVE_DATA);
+        g5.add(": ");
+        g5.add(annotation, annStart, annEnd);
+        g5.add(" = (");
+        g5.add(stripCallTypeArgs(initText), decl.init.start, decl.init.end);
+        g5.add(" as unknown as ");
+        g5.add(annotation, annStart, annEnd);
+        g5.add(");");
       } else {
-        const cellName = g4.cellCount === 0 ? "__cell" : `__cell${g4.cellCount}`;
-        g4.cellCount++;
-        g4.add(`const ${cellName} = `);
-        g4.add(initText, decl.init.start, decl.init.end);
-        g4.add("; let ");
-        g4.add(first, firstRange[0], firstRange[1], REACTIVE_DATA);
-        g4.add(` = ${cellName}.get();`);
+        const cellName = g5.cellCount === 0 ? "__cell" : `__cell${g5.cellCount}`;
+        g5.cellCount++;
+        g5.add(`const ${cellName} = `);
+        g5.add(initText, decl.init.start, decl.init.end);
+        g5.add("; let ");
+        g5.add(first, firstRange[0], firstRange[1], REACTIVE_DATA);
+        g5.add(` = ${cellName}.get();`);
       }
       for (let n = 1; n < names.length; n++) {
-        g4.add(" let ");
-        g4.add(names[n], elements[n].start, elements[n].end, REACTIVE_DATA);
-        g4.add(": any = ");
-        g4.add(first, firstRange[0], firstRange[1]);
-        g4.add(";");
-        if (n === names.length - 1 && dropLastSemi) g4.code = g4.code.slice(0, -1);
+        g5.add(" let ");
+        g5.add(names[n], elements[n].start, elements[n].end, REACTIVE_DATA);
+        g5.add(": any = ");
+        g5.add(first, firstRange[0], firstRange[1]);
+        g5.add(";");
+        if (n === names.length - 1 && dropLastSemi) g5.code = g5.code.slice(0, -1);
       }
-      if (names.length === 1 && dropLastSemi) g4.code = g4.code.slice(0, -1);
+      if (names.length === 1 && dropLastSemi) g5.code = g5.code.slice(0, -1);
     }
     prevEnd = decl.end;
   }
-  if (!isLast) g4.addRaw(";");
+  if (!isLast) g5.addRaw(";");
 }
-function emitBlock(g4, source, body, indent4, opts) {
+function emitBlock(g5, source, body, indent4, opts) {
   const stmts = body && body.type === "BlockStatement" ? body.body : body ? Array.isArray(body) ? body : [body] : [];
-  g4.addRaw("{\n");
-  emitBody(g4, source, stmts, indent4 + "  ", opts);
-  g4.addRaw("\n");
-  g4.add(indent4);
-  g4.addRaw("}");
+  g5.addRaw("{\n");
+  emitBody(g5, source, stmts, indent4 + "  ", opts);
+  g5.addRaw("\n");
+  g5.add(indent4);
+  g5.addRaw("}");
 }
-function emitJSXAttr(g4, source, attr) {
+function emitJSXAttr(g5, source, attr) {
   if (attr.type === "JSXSpreadAttribute") {
-    g4.add(source.slice(attr.start, attr.end), attr.start, attr.end);
+    g5.add(source.slice(attr.start, attr.end), attr.start, attr.end);
     return;
   }
   const name = attr.name;
-  g4.add(source.slice(name.start, name.end), name.start, name.end);
+  g5.add(source.slice(name.start, name.end), name.start, name.end);
   const v = attr.value;
   if (!v) return;
-  g4.add(source.slice(name.end, v.start), name.end, v.start);
+  g5.add(source.slice(name.end, v.start), name.end, v.start);
   if (v.type === "JSXExpressionContainer") {
-    g4.add(source.slice(v.start, v.expression.start), v.start, v.expression.start);
-    g4.add(source.slice(v.expression.start, v.expression.end), v.expression.start, v.expression.end);
-    g4.add(source.slice(v.expression.end, v.end), v.expression.end, v.end);
+    g5.add(source.slice(v.start, v.expression.start), v.start, v.expression.start);
+    g5.add(source.slice(v.expression.start, v.expression.end), v.expression.start, v.expression.end);
+    g5.add(source.slice(v.expression.end, v.end), v.expression.end, v.end);
   } else {
-    g4.add(source.slice(v.start, v.end), v.start, v.end);
+    g5.add(source.slice(v.start, v.end), v.start, v.end);
   }
 }
-function emitJSXElement(g4, source, el, opts, hoist) {
+function emitJSXElement(g5, source, el, opts, hoist) {
   const op = el.openingElement;
   const name = op.name;
   let prev;
   if (name) {
-    g4.add(source.slice(op.start, name.start), op.start, name.start);
-    g4.add(source.slice(name.start, name.end), name.start, name.end);
+    g5.add(source.slice(op.start, name.start), op.start, name.start);
+    g5.add(source.slice(name.start, name.end), name.start, name.end);
     prev = name.end;
   } else {
     prev = op.start + 1;
   }
   for (const attr of op.attributes ?? []) {
-    g4.add(source.slice(prev, attr.start), prev, attr.start);
-    emitJSXAttr(g4, source, attr);
+    g5.add(source.slice(prev, attr.start), prev, attr.start);
+    emitJSXAttr(g5, source, attr);
     prev = attr.end;
   }
   const tail = source.slice(prev, op.end);
   if (op.selfClosing && !tail.includes("/")) {
     const gt = tail.lastIndexOf(">");
     const head = gt === -1 ? tail : tail.slice(0, gt);
-    if (head) g4.add(head, prev, prev + head.length);
-    g4.addRaw("/>");
+    if (head) g5.add(head, prev, prev + head.length);
+    g5.addRaw("/>");
   } else {
-    g4.add(tail, prev, op.end);
+    g5.add(tail, prev, op.end);
   }
   if (op.selfClosing) return;
-  emitJSXChildren(g4, source, el.children ?? [], opts, hoist);
+  emitJSXChildren(g5, source, el.children ?? [], opts, hoist);
   if (el.closingElement) {
-    g4.add(source.slice(el.closingElement.start, el.closingElement.end), el.closingElement.start, el.closingElement.end);
+    g5.add(source.slice(el.closingElement.start, el.closingElement.end), el.closingElement.start, el.closingElement.end);
   }
 }
-function emitJSXExprBody(g4, source, expr, opts) {
-  if (expr.type === "JSXElement") return emitJSXElement(g4, source, expr, opts);
-  if (expr.type === "JSXFragment") return emitJSXFragment(g4, source, expr, opts);
-  g4.add(source.slice(expr.start, expr.end), expr.start, expr.end);
+function emitJSXExprBody(g5, source, expr, opts) {
+  if (expr.type === "JSXElement") return emitJSXElement(g5, source, expr, opts);
+  if (expr.type === "JSXFragment") return emitJSXFragment(g5, source, expr, opts);
+  g5.add(source.slice(expr.start, expr.end), expr.start, expr.end);
 }
-function emitJSXFragment(g4, source, frag, opts, hoist) {
-  g4.addRaw("<>");
-  emitJSXChildren(g4, source, frag.children ?? [], opts, hoist);
-  g4.addRaw("</>");
+function emitJSXFragment(g5, source, frag, opts, hoist) {
+  g5.addRaw("<>");
+  emitJSXChildren(g5, source, frag.children ?? [], opts, hoist);
+  g5.addRaw("</>");
 }
-function emitForClauseMap(g4, source, child, text, map, clauseStart, bodyEmit, emptyEmit) {
+function emitForClauseMap(g5, source, child, text, map, clauseStart, bodyEmit, emptyEmit) {
   const clauseEnd = findBalancedEnd(text, clauseStart - 1);
   const clause = text.slice(clauseStart, clauseEnd);
   const ofIdx = findTopLevelSep(clause, "of");
@@ -40439,38 +41531,38 @@ function emitForClauseMap(g4, source, child, text, map, clauseStart, bodyEmit, e
   const itemVar = stripDeclKeyword(lhs).trim();
   if (ofIdx !== -1) {
     if (emptyEmit) {
-      g4.addRaw("{ (() => { const _v = ");
-      g4.add(arrExpr, arrStart, arrEnd);
-      g4.addRaw("; return _v.length === 0 ? (");
+      g5.addRaw("{ (() => { const _v = ");
+      g5.add(arrExpr, arrStart, arrEnd);
+      g5.addRaw("; return _v.length === 0 ? (");
       emptyEmit();
-      g4.addRaw(") : _v.map((");
-      g4.addRaw(itemVar);
-      g4.addRaw(": (typeof _v)[number]) => (");
+      g5.addRaw(") : _v.map((");
+      g5.addRaw(itemVar);
+      g5.addRaw(": (typeof _v)[number]) => (");
       bodyEmit();
-      g4.addRaw(")); })() }");
+      g5.addRaw(")); })() }");
     } else {
-      g4.addRaw("{ ");
-      g4.add(arrExpr, arrStart, arrEnd);
-      g4.addRaw(".map((");
-      g4.addRaw(itemVar);
-      g4.addRaw(": (typeof ");
-      g4.add(arrExpr, arrStart, arrEnd);
-      g4.addRaw(")[number]) => (");
+      g5.addRaw("{ ");
+      g5.add(arrExpr, arrStart, arrEnd);
+      g5.addRaw(".map((");
+      g5.addRaw(itemVar);
+      g5.addRaw(": (typeof ");
+      g5.add(arrExpr, arrStart, arrEnd);
+      g5.addRaw(")[number]) => (");
       bodyEmit();
-      g4.addRaw(")) }");
+      g5.addRaw(")) }");
     }
   } else {
-    g4.addRaw("{ Object.keys(");
-    g4.add(arrExpr, arrStart, arrEnd);
-    g4.addRaw(").map((");
-    g4.addRaw(itemVar);
-    g4.addRaw(") => (");
+    g5.addRaw("{ Object.keys(");
+    g5.add(arrExpr, arrStart, arrEnd);
+    g5.addRaw(").map((");
+    g5.addRaw(itemVar);
+    g5.addRaw(") => (");
     bodyEmit();
-    g4.addRaw(")) }");
+    g5.addRaw(")) }");
   }
   return true;
 }
-function emitJSXChildren(g4, source, children, opts, hoist) {
+function emitJSXChildren(g5, source, children, opts, hoist) {
   let i = 0;
   let forPending = false;
   while (i < children.length) {
@@ -40496,46 +41588,46 @@ function emitJSXChildren(g4, source, children, opts, hoist) {
           const emptyContainer = children[i + 3];
           if (emptyTextNode && emptyTextNode.type === "JSXText" && ["#empty", "empty"].includes(emptyTextNode.value.trim()) && emptyContainer && emptyContainer.type === "JSXExpressionContainer" && emptyContainer.expression.type !== "JSXEmptyExpression") {
             consumed = 4;
-            emptyEmit = () => emitJSXExprBody(g4, source, emptyContainer.expression, opts);
+            emptyEmit = () => emitJSXExprBody(g5, source, emptyContainer.expression, opts);
           }
           let matched = false;
           if (nextChild.type === "JSXExpressionContainer") {
             const exprNode = nextChild.expression;
             if (exprNode.type === "JSXEmptyExpression") {
-              g4.add(text, child.start, child.end);
+              g5.add(text, child.start, child.end);
               i++;
               continue;
             }
             matched = emitForClauseMap(
-              g4,
+              g5,
               source,
               child,
               text,
               map,
               clauseStartCollapsed,
-              () => emitJSXExprBody(g4, source, exprNode, opts),
+              () => emitJSXExprBody(g5, source, exprNode, opts),
               emptyEmit
             );
           } else if (nextChild.type === "JSXFragment") {
             matched = emitForClauseMap(
-              g4,
+              g5,
               source,
               child,
               text,
               map,
               clauseStartCollapsed,
-              () => emitJSXFragment(g4, source, nextChild, opts),
+              () => emitJSXFragment(g5, source, nextChild, opts),
               emptyEmit
             );
           } else {
             matched = emitForClauseMap(
-              g4,
+              g5,
               source,
               child,
               text,
               map,
               clauseStartCollapsed,
-              () => emitJSXElement(g4, source, nextChild, opts),
+              () => emitJSXElement(g5, source, nextChild, opts),
               emptyEmit
             );
           }
@@ -40552,184 +41644,184 @@ function emitJSXChildren(g4, source, children, opts, hoist) {
         continue;
       }
       forPending = false;
-      emitJSXText(g4, text, child.start, child.end);
+      emitJSXText(g5, text, child.start, child.end);
       i++;
     } else if (child.type === "JSXExpressionContainer") {
       if (child.expression.type === "JSXEmptyExpression") {
         i++;
         continue;
       }
-      g4.addRaw("{");
-      g4.add(source.slice(child.expression.start, child.expression.end), child.expression.start, child.expression.end);
-      g4.addRaw("}");
+      g5.addRaw("{");
+      g5.add(source.slice(child.expression.start, child.expression.end), child.expression.start, child.expression.end);
+      g5.addRaw("}");
       i++;
     } else if (child.type === "JSXElement") {
       if (getJSXTagName2(child) === "style") {
         const openEnd = child.openingElement?.end ?? child.start;
         const closeStart = child.closingElement?.start ?? child.end;
-        g4.recordStyle(child.start, child.end, source.slice(openEnd, closeStart));
+        g5.recordStyle(child.start, child.end, source.slice(openEnd, closeStart));
         i++;
         continue;
       }
-      emitJSXElement(g4, source, child, opts, hoist);
+      emitJSXElement(g5, source, child, opts, hoist);
       i++;
     } else if (child.type === "JSXFragment") {
-      emitJSXFragment(g4, source, child, opts, hoist);
+      emitJSXFragment(g5, source, child, opts, hoist);
       i++;
     } else if (child.type === "IfStatement" || child.type === "ForOfStatement" || child.type === "ForStatement" || child.type === "ForInStatement" || child.type === "WhileStatement" || child.type === "DoWhileStatement" || child.type === "SwitchStatement" || child.type === "TryStatement" || child.type === "VariableDeclaration" || child.type === "ExpressionStatement") {
       if (hoist && hoist.set.has(child)) {
         i++;
         continue;
       }
-      g4.addRaw("{(() => { ");
-      emitBody(g4, source, [child], "", opts);
-      g4.addRaw(" })()}");
+      g5.addRaw("{(() => { ");
+      emitBody(g5, source, [child], "", opts);
+      g5.addRaw(" })()}");
       i++;
     } else {
       i++;
     }
   }
 }
-function emitIf(g4, source, stmt, indent4, opts) {
-  g4.add(indent4);
-  g4.addRaw("if (");
-  g4.add(source.slice(stmt.test.start, stmt.test.end), stmt.test.start, stmt.test.end);
-  g4.addRaw(") ");
-  emitBlock(g4, source, stmt.consequent, indent4, opts);
+function emitIf(g5, source, stmt, indent4, opts) {
+  g5.add(indent4);
+  g5.addRaw("if (");
+  g5.add(source.slice(stmt.test.start, stmt.test.end), stmt.test.start, stmt.test.end);
+  g5.addRaw(") ");
+  emitBlock(g5, source, stmt.consequent, indent4, opts);
   if (stmt.alternate) {
-    g4.addRaw(" else ");
-    emitBlock(g4, source, stmt.alternate, indent4, opts);
+    g5.addRaw(" else ");
+    emitBlock(g5, source, stmt.alternate, indent4, opts);
   }
 }
-function emitLoopVariable(g4, source, left) {
+function emitLoopVariable(g5, source, left) {
   if (left && left.type === "Identifier") {
-    g4.addRaw("const ");
-    g4.add(source.slice(left.start, left.end), left.start, left.end);
+    g5.addRaw("const ");
+    g5.add(source.slice(left.start, left.end), left.start, left.end);
     return;
   }
-  g4.add(source.slice(left.start, left.end), left.start, left.end);
-}
-function emitForOf(g4, source, stmt, indent4, opts) {
-  g4.add(indent4);
-  g4.addRaw("for (");
-  emitLoopVariable(g4, source, stmt.left);
-  g4.addRaw(" of ");
-  g4.add(source.slice(stmt.right.start, stmt.right.end), stmt.right.start, stmt.right.end);
-  g4.addRaw(") ");
-  emitBlock(g4, source, stmt.body, indent4, opts);
-}
-function emitForIn(g4, source, stmt, indent4, opts) {
-  g4.add(indent4);
-  g4.addRaw("for (");
-  emitLoopVariable(g4, source, stmt.left);
-  g4.addRaw(" in ");
-  g4.add(source.slice(stmt.right.start, stmt.right.end), stmt.right.start, stmt.right.end);
-  g4.addRaw(") ");
-  emitBlock(g4, source, stmt.body, indent4, opts);
-}
-function emitFor(g4, source, stmt, indent4, opts) {
-  g4.add(indent4);
-  g4.addRaw("for (");
-  if (stmt.init) g4.add(source.slice(stmt.init.start, stmt.init.end), stmt.init.start, stmt.init.end);
-  g4.addRaw("; ");
-  if (stmt.test) g4.add(source.slice(stmt.test.start, stmt.test.end), stmt.test.start, stmt.test.end);
-  g4.addRaw("; ");
-  if (stmt.update) g4.add(source.slice(stmt.update.start, stmt.update.end), stmt.update.start, stmt.update.end);
-  g4.addRaw(") ");
-  emitBlock(g4, source, stmt.body, indent4, opts);
-}
-function emitWhile(g4, source, stmt, indent4, opts) {
-  g4.add(indent4);
-  g4.addRaw("while (");
-  g4.add(source.slice(stmt.test.start, stmt.test.end), stmt.test.start, stmt.test.end);
-  g4.addRaw(") ");
-  emitBlock(g4, source, stmt.body, indent4, opts);
-}
-function emitDoWhile(g4, source, stmt, indent4, opts) {
-  g4.add(indent4);
-  g4.addRaw("do ");
-  emitBlock(g4, source, stmt.body, indent4, opts);
-  g4.addRaw(" while (");
-  g4.add(source.slice(stmt.test.start, stmt.test.end), stmt.test.start, stmt.test.end);
-  g4.addRaw(");");
-}
-function emitSwitch(g4, source, stmt, indent4, opts) {
-  g4.add(indent4);
-  g4.addRaw("switch (");
-  g4.add(source.slice(stmt.discriminant.start, stmt.discriminant.end), stmt.discriminant.start, stmt.discriminant.end);
-  g4.addRaw(") {");
+  g5.add(source.slice(left.start, left.end), left.start, left.end);
+}
+function emitForOf(g5, source, stmt, indent4, opts) {
+  g5.add(indent4);
+  g5.addRaw("for (");
+  emitLoopVariable(g5, source, stmt.left);
+  g5.addRaw(" of ");
+  g5.add(source.slice(stmt.right.start, stmt.right.end), stmt.right.start, stmt.right.end);
+  g5.addRaw(") ");
+  emitBlock(g5, source, stmt.body, indent4, opts);
+}
+function emitForIn(g5, source, stmt, indent4, opts) {
+  g5.add(indent4);
+  g5.addRaw("for (");
+  emitLoopVariable(g5, source, stmt.left);
+  g5.addRaw(" in ");
+  g5.add(source.slice(stmt.right.start, stmt.right.end), stmt.right.start, stmt.right.end);
+  g5.addRaw(") ");
+  emitBlock(g5, source, stmt.body, indent4, opts);
+}
+function emitFor(g5, source, stmt, indent4, opts) {
+  g5.add(indent4);
+  g5.addRaw("for (");
+  if (stmt.init) g5.add(source.slice(stmt.init.start, stmt.init.end), stmt.init.start, stmt.init.end);
+  g5.addRaw("; ");
+  if (stmt.test) g5.add(source.slice(stmt.test.start, stmt.test.end), stmt.test.start, stmt.test.end);
+  g5.addRaw("; ");
+  if (stmt.update) g5.add(source.slice(stmt.update.start, stmt.update.end), stmt.update.start, stmt.update.end);
+  g5.addRaw(") ");
+  emitBlock(g5, source, stmt.body, indent4, opts);
+}
+function emitWhile(g5, source, stmt, indent4, opts) {
+  g5.add(indent4);
+  g5.addRaw("while (");
+  g5.add(source.slice(stmt.test.start, stmt.test.end), stmt.test.start, stmt.test.end);
+  g5.addRaw(") ");
+  emitBlock(g5, source, stmt.body, indent4, opts);
+}
+function emitDoWhile(g5, source, stmt, indent4, opts) {
+  g5.add(indent4);
+  g5.addRaw("do ");
+  emitBlock(g5, source, stmt.body, indent4, opts);
+  g5.addRaw(" while (");
+  g5.add(source.slice(stmt.test.start, stmt.test.end), stmt.test.start, stmt.test.end);
+  g5.addRaw(");");
+}
+function emitSwitch(g5, source, stmt, indent4, opts) {
+  g5.add(indent4);
+  g5.addRaw("switch (");
+  g5.add(source.slice(stmt.discriminant.start, stmt.discriminant.end), stmt.discriminant.start, stmt.discriminant.end);
+  g5.addRaw(") {");
   let firstCase = true;
   for (const c of stmt.cases ?? []) {
-    g4.addRaw(firstCase ? "\n" : "\n");
+    g5.addRaw(firstCase ? "\n" : "\n");
     firstCase = false;
-    g4.add(indent4);
-    g4.addRaw("  ");
+    g5.add(indent4);
+    g5.addRaw("  ");
     if (c.test) {
-      g4.addRaw("case ");
-      g4.add(source.slice(c.test.start, c.test.end), c.test.start, c.test.end);
-      g4.addRaw(":");
+      g5.addRaw("case ");
+      g5.add(source.slice(c.test.start, c.test.end), c.test.start, c.test.end);
+      g5.addRaw(":");
     } else {
-      g4.addRaw("default:");
+      g5.addRaw("default:");
     }
-    const before = g4.code.length;
-    emitBody(g4, source, c.consequent, indent4 + "    ", opts);
-    if (g4.code.length > before) g4.addRaw("\n");
+    const before = g5.code.length;
+    emitBody(g5, source, c.consequent, indent4 + "    ", opts);
+    if (g5.code.length > before) g5.addRaw("\n");
   }
-  g4.addRaw("\n");
-  g4.add(indent4);
-  g4.addRaw("}");
+  g5.addRaw("\n");
+  g5.add(indent4);
+  g5.addRaw("}");
 }
-function emitTry(g4, source, stmt, indent4, opts) {
-  g4.add(indent4);
-  g4.addRaw("try ");
-  emitBlock(g4, source, stmt.block, indent4, opts);
+function emitTry(g5, source, stmt, indent4, opts) {
+  g5.add(indent4);
+  g5.addRaw("try ");
+  emitBlock(g5, source, stmt.block, indent4, opts);
   if (stmt.handler) {
-    g4.addRaw(" catch");
+    g5.addRaw(" catch");
     if (stmt.handler.param) {
-      g4.addRaw(" (");
-      g4.add(source.slice(stmt.handler.param.start, stmt.handler.param.end), stmt.handler.param.start, stmt.handler.param.end);
-      g4.addRaw(")");
+      g5.addRaw(" (");
+      g5.add(source.slice(stmt.handler.param.start, stmt.handler.param.end), stmt.handler.param.start, stmt.handler.param.end);
+      g5.addRaw(")");
     }
-    g4.addRaw(" ");
-    emitBlock(g4, source, stmt.handler.body, indent4, opts);
+    g5.addRaw(" ");
+    emitBlock(g5, source, stmt.handler.body, indent4, opts);
   }
   if (stmt.finalizer) {
-    g4.addRaw(" finally ");
-    emitBlock(g4, source, stmt.finalizer, indent4, opts);
+    g5.addRaw(" finally ");
+    emitBlock(g5, source, stmt.finalizer, indent4, opts);
   }
 }
-function emitPlainStatement(g4, source, stmt, indent4, isLast) {
+function emitPlainStatement(g5, source, stmt, indent4, isLast) {
   let text = stripTrailingSemicolons(source.slice(stmt.start, stmt.end).trimEnd());
   if (text === "") return;
-  g4.add(indent4);
-  g4.add(text, stmt.start, stmt.end);
-  if (!text.endsWith("}") && !isLast) g4.addRaw(";");
+  g5.add(indent4);
+  g5.add(text, stmt.start, stmt.end);
+  if (!text.endsWith("}") && !isLast) g5.addRaw(";");
 }
-function emitStatement(g4, source, stmt, indent4, isLast, opts, hoist) {
+function emitStatement(g5, source, stmt, indent4, isLast, opts, hoist) {
   switch (stmt.type) {
     case "JSXElement":
       if (getJSXTagName2(stmt) === "style") {
         const openEnd = stmt.openingElement?.end ?? stmt.start;
         const closeStart = stmt.closingElement?.start ?? stmt.end;
-        g4.recordStyle(stmt.start, stmt.end, source.slice(openEnd, closeStart));
+        g5.recordStyle(stmt.start, stmt.end, source.slice(openEnd, closeStart));
         return;
       }
-      g4.add(indent4);
-      emitJSXElement(g4, source, stmt, opts, hoist);
-      if (!isLast) g4.addRaw(";");
+      g5.add(indent4);
+      emitJSXElement(g5, source, stmt, opts, hoist);
+      if (!isLast) g5.addRaw(";");
       return;
     case "JSXFragment":
-      g4.add(indent4);
-      emitJSXFragment(g4, source, stmt, opts, hoist);
-      if (!isLast) g4.addRaw(";");
+      g5.add(indent4);
+      emitJSXFragment(g5, source, stmt, opts, hoist);
+      if (!isLast) g5.addRaw(";");
       return;
     case "JSXExpressionContainer": {
       if (stmt.expression.type === "JSXEmptyExpression") return;
-      g4.add(indent4);
-      g4.addRaw("{");
-      g4.add(source.slice(stmt.expression.start, stmt.expression.end), stmt.expression.start, stmt.expression.end);
-      g4.addRaw("}");
-      if (!isLast) g4.addRaw(";");
+      g5.add(indent4);
+      g5.addRaw("{");
+      g5.add(source.slice(stmt.expression.start, stmt.expression.end), stmt.expression.start, stmt.expression.end);
+      g5.addRaw("}");
+      if (!isLast) g5.addRaw(";");
       return;
     }
     case "VeskBlock": {
@@ -40737,10 +41829,10 @@ function emitStatement(g4, source, stmt, indent4, isLast, opts, hoist) {
       const innerStmts = stmt.body ?? [];
       let firstLine = true;
       for (let i = 0; i < innerStmts.length; i++) {
-        const before = g4.code.length;
-        emitStatement(g4, source, innerStmts[i], indent4, isLast && i === innerStmts.length - 1, opts, hoist);
-        if (g4.code.length > before) {
-          if (!firstLine) g4.addRaw("\n");
+        const before = g5.code.length;
+        emitStatement(g5, source, innerStmts[i], indent4, isLast && i === innerStmts.length - 1, opts, hoist);
+        if (g5.code.length > before) {
+          if (!firstLine) g5.addRaw("\n");
           firstLine = false;
         }
       }
@@ -40748,38 +41840,38 @@ function emitStatement(g4, source, stmt, indent4, isLast, opts, hoist) {
     }
     case "VariableDeclaration":
       if (isTrackDeclStatement(stmt)) {
-        emitTrackDeclStatement(g4, source, stmt, indent4, isLast, opts);
+        emitTrackDeclStatement(g5, source, stmt, indent4, isLast, opts);
         return;
       }
-      return emitPlainStatement(g4, source, stmt, indent4, isLast);
+      return emitPlainStatement(g5, source, stmt, indent4, isLast);
     case "IfStatement":
-      return emitIf(g4, source, stmt, indent4, opts);
+      return emitIf(g5, source, stmt, indent4, opts);
     case "ForOfStatement":
-      return emitForOf(g4, source, stmt, indent4, opts);
+      return emitForOf(g5, source, stmt, indent4, opts);
     case "ForInStatement":
-      return emitForIn(g4, source, stmt, indent4, opts);
+      return emitForIn(g5, source, stmt, indent4, opts);
     case "ForStatement":
-      return emitFor(g4, source, stmt, indent4, opts);
+      return emitFor(g5, source, stmt, indent4, opts);
     case "WhileStatement":
-      return emitWhile(g4, source, stmt, indent4, opts);
+      return emitWhile(g5, source, stmt, indent4, opts);
     case "DoWhileStatement":
-      return emitDoWhile(g4, source, stmt, indent4, opts);
+      return emitDoWhile(g5, source, stmt, indent4, opts);
     case "SwitchStatement":
-      return emitSwitch(g4, source, stmt, indent4, opts);
+      return emitSwitch(g5, source, stmt, indent4, opts);
     case "TryStatement":
-      return emitTry(g4, source, stmt, indent4, opts);
+      return emitTry(g5, source, stmt, indent4, opts);
     case "LabeledStatement": {
-      g4.add(indent4);
-      g4.add(stmt.label.name, stmt.label.start, stmt.label.end);
-      g4.addRaw(":\n");
-      emitStatement(g4, source, stmt.body, indent4, isLast, opts);
+      g5.add(indent4);
+      g5.add(stmt.label.name, stmt.label.start, stmt.label.end);
+      g5.addRaw(":\n");
+      emitStatement(g5, source, stmt.body, indent4, isLast, opts);
       return;
     }
     default:
-      return emitPlainStatement(g4, source, stmt, indent4, isLast);
+      return emitPlainStatement(g5, source, stmt, indent4, isLast);
   }
 }
-function emitBody(g4, source, stmts, indent4, opts, hoist) {
+function emitBody(g5, source, stmts, indent4, opts, hoist) {
   let firstLine = true;
   let i = 0;
   while (i < stmts.length) {
@@ -40787,34 +41879,34 @@ function emitBody(g4, source, stmts, indent4, opts, hoist) {
     const isLast = i === stmts.length - 1;
     if (stmt.type === "ForOfStatement" && stmts[i + 1] && stmts[i + 1].type === "VeskBlock" && stmts[i + 1].tag === "empty") {
       const empty2 = stmts[i + 1];
-      if (!firstLine) g4.addRaw("\n");
+      if (!firstLine) g5.addRaw("\n");
       firstLine = false;
-      emitForOf(g4, source, stmt, indent4, opts);
+      emitForOf(g5, source, stmt, indent4, opts);
       const inner = empty2.body ?? [];
       if (inner.length > 0) {
-        g4.addRaw("\n");
-        g4.add(indent4);
-        g4.add(source.slice(stmt.right.start, stmt.right.end), stmt.right.start, stmt.right.end);
-        g4.addRaw(".length === 0 && (() => {");
-        g4.addRaw("\n");
-        emitBody(g4, source, inner, indent4 + "  ", opts);
-        g4.addRaw("\n");
-        g4.add(indent4);
-        g4.addRaw("})();");
+        g5.addRaw("\n");
+        g5.add(indent4);
+        g5.add(source.slice(stmt.right.start, stmt.right.end), stmt.right.start, stmt.right.end);
+        g5.addRaw(".length === 0 && (() => {");
+        g5.addRaw("\n");
+        emitBody(g5, source, inner, indent4 + "  ", opts);
+        g5.addRaw("\n");
+        g5.add(indent4);
+        g5.addRaw("})();");
       }
       i += 2;
       continue;
     }
-    const before = g4.code.length;
-    emitStatement(g4, source, stmt, indent4, isLast, opts, hoist);
-    if (g4.code.length > before) {
-      if (!firstLine) g4.addRaw("\n");
+    const before = g5.code.length;
+    emitStatement(g5, source, stmt, indent4, isLast, opts, hoist);
+    if (g5.code.length > before) {
+      if (!firstLine) g5.addRaw("\n");
       firstLine = false;
     }
     i++;
   }
 }
-function emitChunkMapped(g4, source, start, end) {
+function emitChunkMapped(g5, source, start, end) {
   if (end <= start) return;
   let pos = start;
   let i = start;
@@ -40826,8 +41918,8 @@ function emitChunkMapped(g4, source, start, end) {
         if (openEnd !== -1 && openEnd <= end) {
           const closeIdx = source.indexOf("</style>", openEnd);
           if (closeIdx !== -1 && closeIdx + 8 <= end) {
-            g4.add(source.slice(pos, i), pos, i);
-            g4.recordStyle(i, closeIdx + 8, source.slice(openEnd, closeIdx));
+            g5.add(source.slice(pos, i), pos, i);
+            g5.recordStyle(i, closeIdx + 8, source.slice(openEnd, closeIdx));
             pos = closeIdx + 8;
             i = closeIdx + 8;
             continue;
@@ -40837,20 +41929,20 @@ function emitChunkMapped(g4, source, start, end) {
     }
     i++;
   }
-  g4.add(source.slice(pos, end), pos, end);
+  g5.add(source.slice(pos, end), pos, end);
 }
-function emitReturn(g4, source, stmt, opts) {
-  g4.add(source.slice(stmt.start, stmt.start + 6), stmt.start, stmt.start + 6);
+function emitReturn(g5, source, stmt, opts) {
+  g5.add(source.slice(stmt.start, stmt.start + 6), stmt.start, stmt.start + 6);
   const arg = stmt.argument;
   if (!arg) {
-    emitChunkMapped(g4, source, stmt.start + 6, stmt.end);
+    emitChunkMapped(g5, source, stmt.start + 6, stmt.end);
     return;
   }
-  emitChunkMapped(g4, source, stmt.start + 6, arg.start);
-  if (arg.type === "JSXElement") emitJSXElement(g4, source, arg, opts);
-  else if (arg.type === "JSXFragment") emitJSXFragment(g4, source, arg, opts);
-  else emitChunkMapped(g4, source, arg.start, arg.end);
-  emitChunkMapped(g4, source, arg.end, stmt.end);
+  emitChunkMapped(g5, source, stmt.start + 6, arg.start);
+  if (arg.type === "JSXElement") emitJSXElement(g5, source, arg, opts);
+  else if (arg.type === "JSXFragment") emitJSXFragment(g5, source, arg, opts);
+  else emitChunkMapped(g5, source, arg.start, arg.end);
+  emitChunkMapped(g5, source, arg.end, stmt.end);
 }
 function collectHoistEligible(children, set2, list) {
   for (const child of children ?? []) {
@@ -40870,7 +41962,7 @@ function collectHoistEligible(children, set2, list) {
     }
   }
 }
-function emitBodyCore(g4, source, stmts, opts) {
+function emitBodyCore(g5, source, stmts, opts) {
   const hoistSet = /* @__PURE__ */ new Set();
   const byRoot = /* @__PURE__ */ new Map();
   const collectRoot = (root3) => {
@@ -40921,107 +42013,107 @@ function emitBodyCore(g4, source, stmts, opts) {
         byRoot.delete(u.node);
         const n = list.length;
         for (let k = 0; k < n; k++) {
-          const before2 = g4.code.length;
-          emitStatement(g4, source, list[k], "", false, opts, ctx2);
-          if (g4.code.length > before2) g4.addRaw("\n");
+          const before2 = g5.code.length;
+          emitStatement(g5, source, list[k], "", false, opts, ctx2);
+          if (g5.code.length > before2) g5.addRaw("\n");
         }
       }
     }
     if (u.empty !== void 0) {
-      emitForOf(g4, source, u.node, "", opts);
+      emitForOf(g5, source, u.node, "", opts);
       const inner = u.empty.body ?? [];
       if (inner.length > 0) {
-        g4.addRaw("\n");
-        g4.add("");
-        g4.add(
+        g5.addRaw("\n");
+        g5.add("");
+        g5.add(
           source.slice(u.node.right.start, u.node.right.end),
           u.node.right.start,
           u.node.right.end
         );
-        g4.addRaw(".length === 0 && (() => {");
-        g4.addRaw("\n");
-        emitBody(g4, source, inner, "  ", opts);
-        g4.addRaw("\n");
-        g4.add("");
-        g4.addRaw("})();");
+        g5.addRaw(".length === 0 && (() => {");
+        g5.addRaw("\n");
+        emitBody(g5, source, inner, "  ", opts);
+        g5.addRaw("\n");
+        g5.add("");
+        g5.addRaw("})();");
       }
       return;
     }
-    const before = g4.code.length;
-    emitStatement(g4, source, u.node, "", isLast, opts, ctx2);
-    if (g4.code.length > before && !isLast) g4.addRaw("\n");
+    const before = g5.code.length;
+    emitStatement(g5, source, u.node, "", isLast, opts, ctx2);
+    if (g5.code.length > before && !isLast) g5.addRaw("\n");
   };
   for (let i = 0; i < units.length; i++) {
     emitUnit(units[i], i === units.length - 1);
   }
 }
-function emitExpressionBody(g4, source, coreStart, coreEnd, stmts, opts) {
+function emitExpressionBody(g5, source, coreStart, coreEnd, stmts, opts) {
   let pos = coreStart;
   for (const stmt of stmts) {
     if (!stmt) continue;
-    emitChunkMapped(g4, source, pos, stmt.start);
+    emitChunkMapped(g5, source, pos, stmt.start);
     pos = stmt.start;
     if (isTrackDeclStatement(stmt)) {
-      emitTrackDeclStatement(g4, source, stmt, "", true, opts);
+      emitTrackDeclStatement(g5, source, stmt, "", true, opts);
     } else if (stmt.type === "ReturnStatement") {
-      emitReturn(g4, source, stmt, opts);
+      emitReturn(g5, source, stmt, opts);
     } else {
-      emitChunkMapped(g4, source, stmt.start, stmt.end);
+      emitChunkMapped(g5, source, stmt.start, stmt.end);
     }
     pos = stmt.end;
   }
-  emitChunkMapped(g4, source, pos, coreEnd);
+  emitChunkMapped(g5, source, pos, coreEnd);
 }
-function emitRestMapped(g4, text, base, end) {
+function emitRestMapped(g5, text, base, end) {
   let i = 0;
   while (i < text.length && !isIdentStart(text[i])) i++;
   if (i >= text.length) {
-    g4.add(text, base, end);
+    g5.add(text, base, end);
     return;
   }
   let j = i + 1;
   while (j < text.length && isIdentChar(text[j])) j++;
-  g4.add(text.slice(0, i), base, base + i);
-  g4.add(text.slice(i, j), base + i, base + j);
-  g4.add(text.slice(j), base + j, end);
+  g5.add(text.slice(0, i), base, base + i);
+  g5.add(text.slice(i, j), base + i, base + j);
+  g5.add(text.slice(j), base + j, end);
 }
-function emitComponentHeader(g4, source, start, bodyStart) {
+function emitComponentHeader(g5, source, start, bodyStart) {
   const h = source.slice(start, bodyStart);
   const k = findFirstKeyword(h, "component");
   if (k === -1) {
     const { text, end: end2 } = stripTrailingClientRange(h);
     if (!text.includes("(")) {
       const trimmed = text.trimEnd();
-      g4.add(trimmed, start, start + end2 - (text.length - trimmed.length));
-      g4.addRaw("() ");
+      g5.add(trimmed, start, start + end2 - (text.length - trimmed.length));
+      g5.addRaw("() ");
     } else {
-      g4.add(text, start, start + end2);
+      g5.add(text, start, start + end2);
     }
     return;
   }
-  g4.add(h.slice(0, k), start, start + k);
-  g4.add("function", start + k, start + k + "component".length);
+  g5.add(h.slice(0, k), start, start + k);
+  g5.add("function", start + k, start + k + "component".length);
   const restBase = start + k + "component".length;
   const { text: rest, end } = stripTrailingClientRange(h.slice(k + "component".length));
   const transformed = h.slice(0, k) + "function" + rest;
   if (!transformed.includes("(")) {
     const trimmed = rest.trimEnd();
-    emitRestMapped(g4, trimmed, restBase, restBase + end - (rest.length - trimmed.length));
-    g4.addRaw("() ");
+    emitRestMapped(g5, trimmed, restBase, restBase + end - (rest.length - trimmed.length));
+    g5.addRaw("() ");
   } else {
-    emitRestMapped(g4, rest, restBase, restBase + end);
+    emitRestMapped(g5, rest, restBase, restBase + end);
   }
 }
-function emitComponent(g4, source, node, start, opts) {
+function emitComponent(g5, source, node, start, opts) {
   const body = node.body;
   if (!body || body.start == null || body.end == null) return;
-  emitComponentHeader(g4, source, start, body.start);
+  emitComponentHeader(g5, source, start, body.start);
   const statementMode = isStatementMode2(node);
   const stmts = body.body ?? [];
   if (statementMode) {
-    g4.addRaw("{ ");
-    emitBodyCore(g4, source, stmts, opts);
-    g4.addRaw(" }");
+    g5.addRaw("{ ");
+    emitBodyCore(g5, source, stmts, opts);
+    g5.addRaw(" }");
   } else {
     const raw2 = source.slice(body.start, body.end);
     const rawLen = raw2.length;
@@ -41041,9 +42133,9 @@ function emitComponent(g4, source, node, start, opts) {
     }
     while (coreStart < coreEnd && isWhitespaceChar(source[coreStart])) coreStart++;
     while (coreEnd > coreStart && isWhitespaceChar(source[coreEnd - 1])) coreEnd--;
-    if (hasBraces) g4.addRaw("{ ");
-    emitExpressionBody(g4, source, coreStart, coreEnd, stmts, opts);
-    if (hasBraces) g4.addRaw(" }");
+    if (hasBraces) g5.addRaw("{ ");
+    emitExpressionBody(g5, source, coreStart, coreEnd, stmts, opts);
+    if (hasBraces) g5.addRaw(" }");
   }
 }
 function isModuleAst(ast) {
@@ -41073,26 +42165,26 @@ function compileVskCodegen(source, opts = {}) {
     };
   }
   const clean = blankForClauses(source, ast);
-  const g4 = new VskGen();
+  const g5 = new VskGen();
   const components = getComponents(ast).sort((a, b) => a.start - b.start);
   let pos = 0;
   for (const { node, start } of components) {
     const body = node.body;
     if (!body || body.start == null || body.end == null) continue;
-    g4.add(clean.slice(pos, start), pos, start);
-    emitComponent(g4, clean, node, start, opts);
+    g5.add(clean.slice(pos, start), pos, start);
+    emitComponent(g5, clean, node, start, opts);
     pos = body.end;
   }
-  g4.add(clean.slice(pos), pos, source.length);
-  let code = g4.code;
+  g5.add(clean.slice(pos), pos, source.length);
+  let code = g5.code;
   if (isModuleAst(ast) && containsIdentifier(code, "Head") && !isIdentifierImported(code, "Head")) {
-    g4.prepend("declare const Head: (props: { children?: Component }) => Component;\n");
-    code = g4.code;
+    g5.prepend("declare const Head: (props: { children?: Component }) => Component;\n");
+    code = g5.code;
   }
   if (!isModuleAst(ast)) {
     code += "\nexport {};\n";
   }
-  return { code, mappings: g4.mappings, styleRegions: g4.styleRegions, errors: [] };
+  return { code, mappings: g5.mappings, styleRegions: g5.styleRegions, errors: [] };
 }
 function isTypeDecl(stmt) {
   return stmt.type === "TSInterfaceDeclaration" || stmt.type === "TSTypeAliasDeclaration" || stmt.type === "ExportNamedDeclaration" && (stmt.declaration?.type === "TSInterfaceDeclaration" || stmt.declaration?.type === "TSTypeAliasDeclaration");
@@ -47797,25 +48889,25 @@ function runMigrate(options) {
     }
     const applicable = codemods.filter((c) => c.appliesTo(abs));
     if (applicable.length === 0) continue;
-    let current2 = source;
+    let current3 = source;
     let changed = false;
     for (const codemod of applicable) {
       let result;
       try {
-        result = codemod.run(current2, ctx2);
+        result = codemod.run(current3, ctx2);
       } catch (e) {
         report.skipped.push(`${relPath}: ${codemod.id} failed (${e.message})`);
         continue;
       }
       report.notes.push(...result.notes);
-      if (result.code !== null && result.code !== current2) {
-        current2 = result.code;
+      if (result.code !== null && result.code !== current3) {
+        current3 = result.code;
         changed = true;
       }
     }
     if (!changed) continue;
     report.filesChanged.push(relPath);
-    if (!options.dryRun) writeFileSync22(abs, current2, "utf-8");
+    if (!options.dryRun) writeFileSync22(abs, current3, "utf-8");
   }
   return report;
 }
@@ -50212,9 +51304,9 @@ var ChunkImports = class {
         this.fail(`nameless named-import from '${source}' in ${filePath}`, code);
         return false;
       }
-      const existing = group.named.get(imported);
-      if (existing && existing.local !== local) {
-        this.fail(`'${imported}' from '${source}' bound to both '${existing.local}' and '${local}' in ${filePath}`, code);
+      const existing2 = group.named.get(imported);
+      if (existing2 && existing2.local !== local) {
+        this.fail(`'${imported}' from '${source}' bound to both '${existing2.local}' and '${local}' in ${filePath}`, code);
         return false;
       }
       group.named.set(imported, { kind: "named", local, imported });
@@ -50249,11 +51341,11 @@ var ChunkImports = class {
     const lines = [];
     const sources = [...this.bySource.keys()].sort();
     for (const src2 of sources) {
-      const g4 = this.bySource.get(src2);
+      const g5 = this.bySource.get(src2);
       const parts = [];
-      if (g4.default) parts.push(`import ${g4.default.local} from ${JSON.stringify(src2)}`);
-      if (g4.namespace) parts.push(`import * as ${g4.namespace.local} from ${JSON.stringify(src2)}`);
-      const named = [...g4.named.values()].sort((a, b) => a.imported < b.imported ? -1 : 1);
+      if (g5.default) parts.push(`import ${g5.default.local} from ${JSON.stringify(src2)}`);
+      if (g5.namespace) parts.push(`import * as ${g5.namespace.local} from ${JSON.stringify(src2)}`);
+      const named = [...g5.named.values()].sort((a, b) => a.imported < b.imported ? -1 : 1);
       if (named.length > 0) {
         const specs = named.map((sp) => sp.imported === sp.local ? sp.local : `${sp.imported} as ${sp.local}`).join(", ");
         parts.push(`import { ${specs} } from ${JSON.stringify(src2)}`);
@@ -50924,10 +52016,17 @@ async function buildTreeShakenRuntimeNow(runtimeDir, usedNames) {
   const missing = unique.filter((n) => !available.has(n));
   if (missing.length > 0) {
     console.error(`vesk: runtime names not exported \u2014 ${missing.join(", ")}; falling back to full runtime`);
+    const full = await bundleRuntimeNames(runtimeDir, [...available]);
+    if (full) return full;
     return buildRuntimeCode(runtimeDir);
   }
+  return await bundleRuntimeNames(runtimeDir, unique, true) ?? buildRuntimeCode(runtimeDir);
+}
+async function bundleRuntimeNames(runtimeDir, names, strict = false) {
+  if (names.length === 0) return null;
   const entry = runtimeTreeShakeEntry();
   const indexClient = esbuildPath(join7(runtimeDir, "index-client.js"));
+  const unique = [...new Set(names)];
   try {
     try {
       mkdirSync3(dirname8(entry), { recursive: true });
@@ -50964,8 +52063,8 @@ const { ${unique.join(", ")} } = __veskRuntime;
 export { ${unique.join(", ")} };
 `;
   } catch (e) {
-    console.error("vesk: runtime tree-shake failed, falling back to full runtime:", e.message);
-    return buildRuntimeCode(runtimeDir);
+    if (strict) console.error("vesk: runtime tree-shake failed, falling back to full runtime:", e.message);
+    return null;
   } finally {
     try {
       unlinkSync3(entry);
@@ -51072,6 +52171,18 @@ if (typeof document !== 'undefined') __router.start();
 }
 
 // ../adapter/src/manifest.ts
+function specificityKey(path) {
+  return path.split("/").filter(Boolean).map((seg) => seg.startsWith("*") ? "2" + seg : seg.startsWith(":") ? "1" + seg : "0" + seg);
+}
+function compareSpecificity(a, b) {
+  const ka = specificityKey(a);
+  const kb = specificityKey(b);
+  const len = Math.min(ka.length, kb.length);
+  for (let i = 0; i < len; i++) {
+    if (ka[i] !== kb[i]) return ka[i] < kb[i] ? -1 : 1;
+  }
+  return kb.length - ka.length;
+}
 function generateManifest(routes, ssrRoutes, apiRoutes, staticRoutes, middlewareEnabled, actionMap, headExtra, eventsEnabled = false) {
   const routeEntries = [];
   for (const r of ssrRoutes) {
@@ -51086,15 +52197,23 @@ function generateManifest(routes, ssrRoutes, apiRoutes, staticRoutes, middleware
     if (r._isrTags) entry.tags = r._isrTags;
     routeEntries.push(entry);
   }
+  const apiEntries = [];
   for (const r of apiRoutes) {
     const urlParts = r.fullPath.split("/").filter(Boolean);
-    const name = urlParts.map((s) => s.startsWith(":") ? s.slice(1) || "param" : s).join("_") || "index";
-    routeEntries.push({
-      path: `/api${r.fullPath}`,
+    const parts = urlParts.map((s, i) => {
+      const last = i === urlParts.length - 1;
+      if (last && r.isCatchAll && s.startsWith(":")) return "*" + s.slice(1);
+      return s;
+    });
+    const name = parts.map((s) => s.startsWith(":") || s.startsWith("*") ? s.slice(1) || "param" : s).join("_") || "index";
+    apiEntries.push({
+      path: parts.length ? `/api/${parts.join("/")}` : "/api",
       type: "api",
       function: `server/api/${name}.js`
     });
   }
+  apiEntries.sort((a, b) => compareSpecificity(a.path, b.path));
+  routeEntries.push(...apiEntries);
   const ssgEntries = [];
   for (const r of staticRoutes) {
     ssgEntries.push({
@@ -51423,18 +52542,27 @@ async function startProdServer(outDir, options) {
     let pi = 0, pp2 = 0;
     const params = {};
     while (pi < pathParts.length && pp2 < patternParts.length) {
-      if (patternParts[pp2].startsWith(":")) {
-        const name = patternParts[pp2].slice(1);
+      const seg = patternParts[pp2];
+      if (seg.startsWith("*")) {
+        params[seg.slice(1)] = pathParts.slice(pi).join("/");
+        pi = pathParts.length;
+        pp2++;
+      } else if (seg.startsWith(":")) {
+        const name = seg.slice(1);
         params[name] = pathParts[pi];
         pi++;
         pp2++;
-      } else if (patternParts[pp2] === pathParts[pi]) {
+      } else if (seg === pathParts[pi]) {
         pi++;
         pp2++;
       } else {
         return null;
       }
     }
+    if (pp2 === patternParts.length - 1 && patternParts[pp2].startsWith("*")) {
+      params[patternParts[pp2].slice(1)] = pathParts.slice(pi).join("/");
+      pp2++;
+    }
     if (pp2 === patternParts.length && pi === pathParts.length) return params;
     return null;
   }
@@ -51468,6 +52596,34 @@ async function startProdServer(outDir, options) {
       }
       return origWriteHead(statusCode, headers2);
     });
+    const securityBridge = globalThis.__vesk_security;
+    const securityRun = securityBridge?.run;
+    const withSecurityScope = securityRun ? (fn) => securityRun(fn) : (fn) => fn();
+    const applyOverrideHeaders = (headers2) => {
+      const overrides = securityBridge?.get?.();
+      if (!overrides) return headers2;
+      const next = { ...headers2 };
+      if (typeof overrides.contentSecurityPolicy === "string") {
+        next["Content-Security-Policy"] = overrides.contentSecurityPolicy;
+      }
+      const custom2 = overrides.customHeaders;
+      if (custom2) {
+        for (const [name, value] of Object.entries(custom2)) {
+          if (value === false) delete next[name];
+          else next[name] = value;
+        }
+      }
+      return next;
+    };
+    const origWriteHead2 = res.writeHead.bind(res);
+    let overridesApplied = false;
+    res.writeHead = ((statusCode, headers2) => {
+      if (!overridesApplied) {
+        overridesApplied = true;
+        headers2 = applyOverrideHeaders(headers2 || {});
+      }
+      return origWriteHead2(statusCode, headers2);
+    });
     const publicDir = resolve13(staticDir, "public");
     const rootFile = url.pathname.length > 1 ? resolveWithin(publicDir, url.pathname.slice(1)) : null;
     if (rootFile && existsSync15(rootFile) && statSync6(rootFile).isFile()) {
@@ -51607,7 +52763,8 @@ async function startProdServer(outDir, options) {
       }
       try {
         const webRequest = makeWebRequest(req, url.href, maxBodyBytes);
-        const response = await mod.handleAction(webRequest, actionId);
+        const handleAction = mod.handleAction.bind(mod);
+        const response = await withSecurityScope(() => handleAction(webRequest, actionId));
         await deliverResponse(res, response);
       } catch (e) {
         const status = errorStatus(e, 500);
@@ -51626,7 +52783,7 @@ async function startProdServer(outDir, options) {
             if (mod) {
               try {
                 const webRequest = makeWebRequest(req, url.href, maxBodyBytes);
-                const response = await mod.handle(webRequest);
+                const response = await withSecurityScope(() => mod.handle(webRequest));
                 await deliverResponse(res, response);
                 return;
               } catch (e) {
@@ -51668,7 +52825,7 @@ async function startProdServer(outDir, options) {
               if (route.revalidate && route.revalidate > 0) {
                 const { pageIsr: pageIsr2 } = await Promise.resolve().then(() => (init_index_server(), index_server_exports));
                 cachedResult = await pageIsr2(url.pathname, async () => {
-                  const response2 = await mod.handle(webRequest);
+                  const response2 = await withSecurityScope(() => mod.handle(webRequest));
                   return { html: await response2.text(), headers: Object.fromEntries(response2.headers) };
                 }, { revalidate: route.revalidate, tags: route.tags || [] });
               }
@@ -51677,7 +52834,7 @@ async function startProdServer(outDir, options) {
                 res.end(cachedResult.html);
                 return;
               }
-              const response = await mod.handle(webRequest);
+              const response = await withSecurityScope(() => mod.handle(webRequest));
               const headers2 = Object.fromEntries(response.headers);
               if (!headers2["content-type"] && !headers2["Content-Type"]) headers2["Content-Type"] = "text/html";
               if (response.body && typeof response.body.getReader === "function") {
@@ -52432,8 +53589,8 @@ init_index_server();
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 var TOKEN_KEY2 = "__vsk_ssr_token";
 var IMPL_KEY2 = "__vsk_ssr_store_impl";
-var g3 = globalThis;
-var impl2 = g3[IMPL_KEY2] ?? (g3[IMPL_KEY2] = {
+var g4 = globalThis;
+var impl2 = g4[IMPL_KEY2] ?? (g4[IMPL_KEY2] = {
   storage: new AsyncLocalStorage2(),
   liveSlots: /* @__PURE__ */ new Map(),
   // Only the copy that created the implementation installs the token
@@ -52452,8 +53609,8 @@ function isThenable2(value) {
   return typeof value?.then === "function";
 }
 function withSsrStore2(fn) {
-  const existing = storage2.getStore();
-  if (existing)
+  const existing2 = storage2.getStore();
+  if (existing2)
     return fn();
   const store = createSsrStore3();
   keepSsrSlot2(store.token);
@@ -55372,6 +56529,20 @@ function collectSources(tree) {
   walk9(tree);
   return map;
 }
+function segmentRank(node) {
+  if (node.isGroup || node.fullPath === "/")
+    return 0;
+  if (node.isCatchAll)
+    return 3;
+  if (node.isDynamic)
+    return 2;
+  return 1;
+}
+function bySegmentPrecedence(nodes) {
+  if (nodes.length < 2)
+    return nodes;
+  return nodes.map((node, index) => ({ node, index, rank: segmentRank(node) })).sort((a, b) => a.rank - b.rank || a.index - b.index).map((entry) => entry.node);
+}
 function matchUrl(tree, pathname) {
   const parts = pathname.split("/").filter(Boolean);
   const chain = [];
@@ -55387,7 +56558,7 @@ function matchUrl(tree, pathname) {
     chain.push(node);
   }
   function matchNodes(nodes, partIndex) {
-    for (const node of nodes) {
+    for (const node of bySegmentPrecedence(nodes)) {
       if (node.isGroup) {
         const marker = chain.length;
         if (node.layout || node.page)
@@ -55560,6 +56731,20 @@ function scanApiDir(rootDir, dir, parentPath) {
   }
   return nodes;
 }
+function specificityRank(node) {
+  if (node.fullPath === "/")
+    return 0;
+  if (node.isCatchAll)
+    return 3;
+  if (node.isDynamic)
+    return 2;
+  return 1;
+}
+function bySpecificity(nodes) {
+  if (nodes.length < 2)
+    return nodes;
+  return nodes.map((node, index) => ({ node, index, rank: specificityRank(node) })).sort((a, b) => a.rank - b.rank || a.index - b.index).map((entry) => entry.node);
+}
 function matchApiUrl(tree, pathname) {
   let normalized = pathname.split("?")[0].split("#")[0];
   if (normalized === "/api") {
@@ -55569,31 +56754,40 @@ function matchApiUrl(tree, pathname) {
   }
   const parts = normalized.split("/").filter(Boolean);
   const params = {};
+  function restoreParams(snapshot) {
+    for (const key of Object.keys(params)) {
+      if (!(key in snapshot))
+        delete params[key];
+    }
+    for (const key of Object.keys(snapshot))
+      params[key] = snapshot[key];
+  }
   function matchNodes(nodes, partIndex) {
-    for (const node of nodes) {
+    for (const node of bySpecificity(nodes)) {
       if (node.fullPath === "/") {
         if (partIndex >= parts.length && node.filePath)
           return node;
         return matchNodes(node.children, partIndex);
       }
-      if (partIndex >= parts.length) {
-        if (node.filePath)
-          return node;
-        continue;
-      }
-      const part = parts[partIndex];
+      const part = partIndex < parts.length ? parts[partIndex] : void 0;
       if (node.isCatchAll) {
+        if (!node.filePath)
+          continue;
         const paramName = node.path.startsWith(":") ? node.path.slice(1) : node.path;
         params[paramName] = parts.slice(partIndex).map(decodeURIComponent).join("/");
         return node;
       }
+      if (part === void 0)
+        continue;
       if (node.isDynamic) {
         const paramName = node.path.startsWith(":") ? node.path.slice(1) : node.path;
         params[paramName] = decodeURIComponent(part);
         if (node.children.length > 0) {
+          const snapshot = { ...params };
           const result = matchNodes(node.children, partIndex + 1);
           if (result)
             return result;
+          restoreParams(snapshot);
         }
         if (node.filePath)
           return node;
@@ -55601,10 +56795,14 @@ function matchApiUrl(tree, pathname) {
         continue;
       }
       if (node.path === part) {
+        if (partIndex + 1 >= parts.length && node.filePath)
+          return node;
         if (node.children.length > 0) {
+          const snapshot = { ...params };
           const result = matchNodes(node.children, partIndex + 1);
           if (result)
             return result;
+          restoreParams(snapshot);
         }
         if (node.filePath)
           return node;
@@ -56599,9 +57797,9 @@ var ChunkImports2 = class {
         this.fail(`nameless named-import from '${source}' in ${filePath}`, code);
         return false;
       }
-      const existing = group.named.get(imported);
-      if (existing && existing.local !== local) {
-        this.fail(`'${imported}' from '${source}' bound to both '${existing.local}' and '${local}' in ${filePath}`, code);
+      const existing2 = group.named.get(imported);
+      if (existing2 && existing2.local !== local) {
+        this.fail(`'${imported}' from '${source}' bound to both '${existing2.local}' and '${local}' in ${filePath}`, code);
         return false;
       }
       group.named.set(imported, { kind: "named", local, imported });
@@ -56638,13 +57836,13 @@ var ChunkImports2 = class {
     const lines = [];
     const sources = [...this.bySource.keys()].sort();
     for (const src2 of sources) {
-      const g4 = this.bySource.get(src2);
+      const g5 = this.bySource.get(src2);
       const parts = [];
-      if (g4.default)
-        parts.push(`import ${g4.default.local} from ${JSON.stringify(src2)}`);
-      if (g4.namespace)
-        parts.push(`import * as ${g4.namespace.local} from ${JSON.stringify(src2)}`);
-      const named = [...g4.named.values()].sort((a, b) => a.imported < b.imported ? -1 : 1);
+      if (g5.default)
+        parts.push(`import ${g5.default.local} from ${JSON.stringify(src2)}`);
+      if (g5.namespace)
+        parts.push(`import * as ${g5.namespace.local} from ${JSON.stringify(src2)}`);
+      const named = [...g5.named.values()].sort((a, b) => a.imported < b.imported ? -1 : 1);
       if (named.length > 0) {
         const specs = named.map((sp) => sp.imported === sp.local ? sp.local : `${sp.imported} as ${sp.local}`).join(", ");
         parts.push(`import { ${specs} } from ${JSON.stringify(src2)}`);
@@ -57367,10 +58565,19 @@ async function buildTreeShakenRuntimeNow2(runtimeDir, usedNames) {
   const missing = unique.filter((n) => !available.has(n));
   if (missing.length > 0) {
     console.error(`vesk: runtime names not exported \u2014 ${missing.join(", ")}; falling back to full runtime`);
+    const full = await bundleRuntimeNames2(runtimeDir, [...available]);
+    if (full)
+      return full;
     return buildRuntimeCode2(runtimeDir);
   }
+  return await bundleRuntimeNames2(runtimeDir, unique, true) ?? buildRuntimeCode2(runtimeDir);
+}
+async function bundleRuntimeNames2(runtimeDir, names, strict = false) {
+  if (names.length === 0)
+    return null;
   const entry = runtimeTreeShakeEntry2();
   const indexClient = esbuildPath2(join20(runtimeDir, "index-client.js"));
+  const unique = [...new Set(names)];
   try {
     try {
       mkdirSync12(dirname18(entry), { recursive: true });
@@ -57407,8 +58614,9 @@ const { ${unique.join(", ")} } = __veskRuntime;
 export { ${unique.join(", ")} };
 `;
   } catch (e) {
-    console.error("vesk: runtime tree-shake failed, falling back to full runtime:", e.message);
-    return buildRuntimeCode2(runtimeDir);
+    if (strict)
+      console.error("vesk: runtime tree-shake failed, falling back to full runtime:", e.message);
+    return null;
   } finally {
     try {
       unlinkSync4(entry);
@@ -57853,9 +59061,9 @@ function getPluginRecords2(appDir, veskDir, configPluginNames) {
 }
 function setPluginActive2(veskDir, name, active) {
   const state = readPluginState2(veskDir);
-  const existing = state.plugins.find((p) => eqIgnoreCase2(p.name, name));
-  if (existing) {
-    existing.active = active;
+  const existing2 = state.plugins.find((p) => eqIgnoreCase2(p.name, name));
+  if (existing2) {
+    existing2.active = active;
   } else {
     state.plugins.push({ name, package: name, active });
   }
@@ -57942,11 +59150,11 @@ async function installPlugin2(appDir, veskDir, pkg) {
   }
   const state = readPluginState2(veskDir);
   const name = probe.packageJson?.name || pkg;
-  const existing = state.plugins.find((p) => eqIgnoreCase2(p.package, pkg) || eqIgnoreCase2(p.name, name));
-  if (existing) {
-    existing.package = pkg;
-    existing.name = name;
-    existing.active = true;
+  const existing2 = state.plugins.find((p) => eqIgnoreCase2(p.package, pkg) || eqIgnoreCase2(p.name, name));
+  if (existing2) {
+    existing2.package = pkg;
+    existing2.name = name;
+    existing2.active = true;
   } else {
     state.plugins.push({ name, package: pkg, active: true });
   }
@@ -57978,10 +59186,10 @@ async function updatePlugin2(appDir, veskDir, pkg) {
   const probe = resolvePackage2(appDir, pkg);
   const state = readPluginState2(veskDir);
   const name = probe.packageJson?.name || pkg;
-  const existing = state.plugins.find((p) => eqIgnoreCase2(p.package, pkg) || eqIgnoreCase2(p.name, name));
-  if (existing) {
-    existing.package = pkg;
-    existing.name = name;
+  const existing2 = state.plugins.find((p) => eqIgnoreCase2(p.package, pkg) || eqIgnoreCase2(p.name, name));
+  if (existing2) {
+    existing2.package = pkg;
+    existing2.name = name;
   } else {
     state.plugins.push({ name, package: pkg, active: true });
   }
@@ -57990,7 +59198,7 @@ async function updatePlugin2(appDir, veskDir, pkg) {
     name,
     pkg,
     source: "state",
-    activeRaw: existing ? existing.active : true,
+    activeRaw: existing2 ? existing2.active : true,
     error: null
   }, appDir);
 }
@@ -60325,8 +61533,8 @@ function loadAgenticConfig(projectDir) {
 }
 function saveAgenticConfig(projectDir, patch) {
   const p = configPath(projectDir);
-  const current2 = loadAgenticConfig(projectDir);
-  const next = { ...DEFAULT_CONFIG, ...current2, ...patch };
+  const current3 = loadAgenticConfig(projectDir);
+  const next = { ...DEFAULT_CONFIG, ...current3, ...patch };
   const toWrite = { provider: next.provider, model: next.model, mode: next.mode, maxSteps: next.maxSteps };
   if (next.baseUrl)
     toWrite.baseUrl = next.baseUrl;
@@ -62066,11 +63274,11 @@ function createVeskTools(deps) {
             const contained = resolveWithin3(projectDir, info.path.slice(projectDir.length + 1));
             if (!contained)
               return jsonError("path escapes project root");
-            const current2 = readFileSync32(info.path, "utf-8");
-            const patched = applySimpleConfigToggle(current2, key, a.value);
+            const current3 = readFileSync32(info.path, "utf-8");
+            const patched = applySimpleConfigToggle(current3, key, a.value);
             if (patched === null)
               return jsonError("could not safely edit the config object; use the source editor");
-            if (patched === current2)
+            if (patched === current3)
               return jsonOk({ ok: true, path: info.path, source: patched, unchanged: true });
             writeFileSync18(info.path, patched, "utf-8");
             return jsonOk({ ok: true, path: info.path, source: patched });
@@ -62200,11 +63408,11 @@ function createVeskTools(deps) {
           const at2 = pkg.lastIndexOf("@");
           if (at2 > 0)
             name = pkg.slice(0, at2);
-          const existing = state.plugins.find((p) => eqIgnoreCase3(p.package, pkg) || eqIgnoreCase3(p.package, name) || eqIgnoreCase3(p.name, name));
-          if (existing) {
-            existing.package = pkg;
-            existing.name = name;
-            existing.active = true;
+          const existing2 = state.plugins.find((p) => eqIgnoreCase3(p.package, pkg) || eqIgnoreCase3(p.package, name) || eqIgnoreCase3(p.name, name));
+          if (existing2) {
+            existing2.package = pkg;
+            existing2.name = name;
+            existing2.active = true;
           } else {
             state.plugins.push({ name, package: pkg, active: true });
           }
@@ -62265,9 +63473,9 @@ function createVeskTools(deps) {
           if (!name)
             return jsonError('missing "name" in body');
           const state = readPluginState3(veskDir);
-          const existing = state.plugins.find((p) => eqIgnoreCase3(p.name, name) || eqIgnoreCase3(p.package, name));
-          if (existing) {
-            existing.active = true;
+          const existing2 = state.plugins.find((p) => eqIgnoreCase3(p.name, name) || eqIgnoreCase3(p.package, name));
+          if (existing2) {
+            existing2.active = true;
           } else {
             state.plugins.push({ name, package: name, active: true });
           }
@@ -62297,9 +63505,9 @@ function createVeskTools(deps) {
           if (!name)
             return jsonError('missing "name" in body');
           const state = readPluginState3(veskDir);
-          const existing = state.plugins.find((p) => eqIgnoreCase3(p.name, name) || eqIgnoreCase3(p.package, name));
-          if (existing) {
-            existing.active = false;
+          const existing2 = state.plugins.find((p) => eqIgnoreCase3(p.name, name) || eqIgnoreCase3(p.package, name));
+          if (existing2) {
+            existing2.active = false;
           } else {
             state.plugins.push({ name, package: name, active: false });
           }
@@ -62374,8 +63582,8 @@ function createVeskTools(deps) {
             return jsonError("invalid checkpointId");
           }
           try {
-            const existing = getCheckpoint(projectDir, checkpointId);
-            if (existing) {
+            const existing2 = getCheckpoint(projectDir, checkpointId);
+            if (existing2) {
               const rolled = rollback(projectDir, checkpointId);
               if (rolled)
                 return jsonOk({ ok: true, checkpointId, checkpoint: rolled, rolledBack: true });
@@ -63310,10 +64518,10 @@ function parseCookies3(str3) {
 // ../runtime/dist/action.js
 var registryKey2 = "__vesk_actions";
 function getActionRegistry2() {
-  const g4 = globalThis;
-  if (!g4[registryKey2])
-    g4[registryKey2] = {};
-  return g4[registryKey2];
+  const g5 = globalThis;
+  if (!g5[registryKey2])
+    g5[registryKey2] = {};
+  return g5[registryKey2];
 }
 function getAction2(id) {
   return getActionRegistry2()[id] || null;
@@ -63969,9 +65177,9 @@ function storeDataScript(payload) {
   return "/_vesk/ssr-data.js?t=" + token;
 }
 function currentSsrData() {
-  const g4 = globalThis;
-  const token = g4.__vsk_ssr_token;
-  const slot = (token ? g4[`__vsk_ssr_data_${token}`] : void 0) || {};
+  const g5 = globalThis;
+  const token = g5.__vsk_ssr_token;
+  const slot = (token ? g5[`__vsk_ssr_data_${token}`] : void 0) || {};
   return { ...ssrSink3.snapshot() || {}, ...slot };
 }
 function countPages(nodes) {
@@ -64064,9 +65272,9 @@ async function startDevServer(port, projectDir, config, host) {
     }
   }
   function eventsStore() {
-    const g4 = globalThis;
-    if (!g4.__vesk_server_ctx) g4.__vesk_server_ctx = {};
-    return g4.__vesk_server_ctx;
+    const g5 = globalThis;
+    if (!g5.__vesk_server_ctx) g5.__vesk_server_ctx = {};
+    return g5.__vesk_server_ctx;
   }
   function makeEventCtx(overrides) {
     const store = eventsStore();
@@ -64362,9 +65570,9 @@ async function startDevServer(port, projectDir, config, host) {
   function updateSourceMapping() {
     sourceToComponents.clear();
     for (const [compName, sourcePath2] of collectSources(routeTree)) {
-      const existing = sourceToComponents.get(sourcePath2) || [];
-      existing.push(compName);
-      sourceToComponents.set(sourcePath2, existing);
+      const existing2 = sourceToComponents.get(sourcePath2) || [];
+      existing2.push(compName);
+      sourceToComponents.set(sourcePath2, existing2);
     }
   }
   updateSourceMapping();
@@ -64564,12 +65772,12 @@ async function startDevServer(port, projectDir, config, host) {
         debounceTimer = setTimeout(async () => {
           const t0 = Date.now();
           try {
-            const current2 = fileExists ? readFileSync38(fullPath, "utf-8") : null;
-            if (eventType !== "rename" && current2 !== null && lastSeenContent.get(fullPath) === current2) {
+            const current3 = fileExists ? readFileSync38(fullPath, "utf-8") : null;
+            if (eventType !== "rename" && current3 !== null && lastSeenContent.get(fullPath) === current3) {
               LOG.info(`skipped unchanged (${filename})`);
               return;
             }
-            lastSeenContent.set(fullPath, current2);
+            lastSeenContent.set(fullPath, current3);
             if (typeof globalThis.__vesk_broadcastHmr === "function") {
               globalThis.__vesk_broadcastHmr({ type: "compiling" });
             }
@@ -64593,8 +65801,8 @@ async function startDevServer(port, projectDir, config, host) {
               if (treeChanged || isOutsideApp || fileDeleted) {
                 await buildClientBundle();
                 await bundleRuntime2();
-              } else if (fileExists && current2 !== null) {
-                let source = current2;
+              } else if (fileExists && current3 !== null) {
+                let source = current3;
                 if (/content=["'][^"']*\.md["']/i.test(source)) {
                   source = inlineMdContentAttrs2(source, dirname26(fullPath), guessProjectRoots2(appDirPath));
                 }
@@ -65592,8 +66800,10 @@ __export(index_server_exports2, {
   createContext: () => createContext,
   createFileRouter: () => createFileRouter,
   createLocals: () => createLocals,
+  createPathStore: () => createPathStore,
   createResource: () => createResource,
   createRouter: () => createRouter,
+  createStore: () => createStore,
   create_component_ctx: () => create_component_ctx,
   create_try_block: () => create_try_block,
   custom: () => custom,
@@ -65716,6 +66926,8 @@ init_loading_indicator();
 init_action();
 init_metadata();
 init_nested_update();
+init_store();
+init_path_store();
 
 // src/index.ts
 var __filename2 = fileURLToPath9(import.meta.url);