@vesk/vesk-cli 0.2.64 → 0.2.65

package/dist/cli.js

@@ -22494,6 +22494,7 @@ __export(server_utils_exports, {
   escapeHtml: () => escapeHtml,
   evalTopLevelCode: () => evalTopLevelCode,
   exprJS: () => exprJS,
+  extractRuntimeBindingPairs: () => extractRuntimeBindingPairs,
   extractRuntimeNames: () => extractRuntimeNames,
   extractTopLevelNames: () => extractTopLevelNames,
   getClientIp: () => getClientIp,
@@ -23281,33 +23282,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 +23355,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 +23364,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;
   }
@@ -27755,6 +27766,1019 @@ var init_nested_update = __esm({
   }
 });
 
+// ../runtime/src/store-persistence.ts
+function currentSsrToken() {
+  const g4 = globalThis;
+  return typeof g4.__vsk_ssr_token === "string" ? g4.__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 current2 = stateCell.get();
+    if (current2 === prevValue) return;
+    subs.forEach((fn) => fn(current2));
+    watchers.forEach(({ selector, cb, equals }) => {
+      const eq = equals ?? Object.is;
+      const newVal = selector(current2);
+      const oldVal = selector(prevValue);
+      if (!eq(newVal, oldVal)) cb(newVal, oldVal);
+    });
+    middlewares.forEach((fn) => fn(current2, 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(current2) });
+      }
+    }
+    prevValue = cloneState(current2);
+  }
+  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 current2 = stateCell.get();
+    const patch = typeof partialOrFn === "function" ? partialOrFn(current2) : partialOrFn;
+    const next = Object.assign(cloneState(current2), patch);
+    stateCell.set(next);
+    persistToStorage();
+    notifyDirty(action, patch);
+  }
+  function deleteKeys(keys, action = "delete") {
+    const current2 = stateCell.get();
+    const kArray = Array.isArray(keys) ? keys : [keys];
+    const next = cloneState(current2);
+    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 existing = seen.get(value);
+  if (existing !== void 0) return existing;
+  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 current2 = buildMerged();
+    for (const wrapper of subscribers) wrapper(current2);
+    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);
+        }
+      } : (current2) => fn(current2);
+      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 +28833,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 +28962,8 @@ var init_index_server = __esm({
     init_action();
     init_metadata();
     init_nested_update();
+    init_store();
+    init_path_store();
   }
 });
 
@@ -36153,16 +37181,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;
 }
@@ -50924,10 +51957,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 +52004,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 +52112,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 +52138,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 +52483,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;
   }
@@ -55372,6 +56441,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 +56470,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 +56643,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 +56666,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 +56707,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;
@@ -57367,10 +58477,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 +58526,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);
@@ -65592,8 +66712,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 +66838,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);