@stacksjs/stx 0.2.95 → 0.2.97

package/dist/state-management.js

@@ -1,2 +1,533 @@
-// @bun
-import{Ag as h,Bg as i,Cg as j,Dg as k,Eg as l,Fg as m,Gg as n,Hg as o,Ig as p,Jg as q,Kg as r,Lg as s,Mg as t,Ng as u,Og as v,Pg as w,Qg as x,Rg as y,Sg as z,Tg as A,Ug as B,Vg as C,tg as a,ug as b,vg as c,wg as d,xg as e,yg as f,zg as g}from"./chunk-tffh3b1e.js";import"./chunk-xv34zbp4.js";export{n as validationMiddleware,q as useStore,B as transformStoreImports,p as throttleMiddleware,s as serializeStores,C as registerStoresClient,a as registerStore,m as loggerMiddleware,v as initDevTools,o as immerMiddleware,t as hydrateStores,c as hasStore,z as hasDefinedStore,d as getStoreNames,b as getStore,y as getDefinedStoreNames,x as getDefinedStore,A as generateStoreImportRuntime,u as generateHydrationScript,w as defineStore,r as createStoreDirective,f as createStore,k as createSelector,g as createReadonlyStore,l as createMemoizedSelector,j as createActions,i as createAction,h as computed,e as clearStores};
+const globalState = {
+  stores: new Map,
+  subscriptions: new Map
+};
+export function registerStore(name, store) {
+  globalState.stores.set(name, store);
+}
+export function getStore(name) {
+  return globalState.stores.get(name);
+}
+export function hasStore(name) {
+  return globalState.stores.has(name);
+}
+export function getStoreNames() {
+  return Array.from(globalState.stores.keys());
+}
+export function clearStores() {
+  for (const store of globalState.stores.values())
+    store.destroy();
+  globalState.stores.clear();
+  globalState.subscriptions.clear();
+}
+const memoryStorage = new Map;
+function getStorageAdapter(type) {
+  if (type === "memory")
+    return {
+      getItem: (key) => memoryStorage.get(key) ?? null,
+      setItem: (key, value) => memoryStorage.set(key, value),
+      removeItem: (key) => memoryStorage.delete(key)
+    };
+  if (typeof window > "u")
+    return {
+      getItem: (key) => memoryStorage.get(key) ?? null,
+      setItem: (key, value) => memoryStorage.set(key, value),
+      removeItem: (key) => memoryStorage.delete(key)
+    };
+  return type === "local" ? window.localStorage : window.sessionStorage;
+}
+function pickPaths(obj, paths) {
+  const result = {};
+  for (const path of paths) {
+    const parts = path.split(".");
+    let source = obj, target = result, valid = !0;
+    for (let i = 0;i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (source && typeof source === "object" && part in source) {
+        source = source[part];
+        if (!(part in target))
+          target[part] = {};
+        target = target[part];
+      } else {
+        valid = !1;
+        break;
+      }
+    }
+    if (valid && source && typeof source === "object") {
+      const lastPart = parts[parts.length - 1];
+      if (lastPart in source)
+        target[lastPart] = source[lastPart];
+    }
+  }
+  return result;
+}
+export function createStore(initialValue, options = {}) {
+  const {
+    name,
+    persist,
+    devtools = !1,
+    middleware = [],
+    equals = (a, b) => a === b
+  } = options;
+  let currentValue = initialValue;
+  const subscribers = new Set;
+  let persistTimeout = null;
+  if (persist) {
+    const storage = getStorageAdapter(persist.storage || "local"), key = persist.key || `stx-store:${name || "unnamed"}`, deserialize = persist.deserialize || JSON.parse;
+    try {
+      const stored = storage.getItem(key);
+      if (stored) {
+        const parsed = deserialize(stored);
+        if (persist.paths && typeof parsed === "object" && parsed !== null)
+          currentValue = { ...initialValue, ...parsed };
+        else
+          currentValue = parsed;
+      }
+    } catch {}
+  }
+  const persistValue = (value) => {
+    if (!persist)
+      return;
+    const storage = getStorageAdapter(persist.storage || "local"), key = persist.key || `stx-store:${name || "unnamed"}`, serialize = persist.serialize || JSON.stringify, toPersist = persist.paths && typeof value === "object" && value !== null ? pickPaths(value, persist.paths) : value;
+    if (persist.debounce) {
+      if (persistTimeout)
+        clearTimeout(persistTimeout);
+      persistTimeout = setTimeout(() => {
+        storage.setItem(key, serialize(toPersist));
+      }, persist.debounce);
+    } else
+      storage.setItem(key, serialize(toPersist));
+  }, notify = (newValue, prevValue) => {
+    for (const subscriber of subscribers)
+      try {
+        subscriber(newValue, prevValue);
+      } catch (error) {
+        console.error("[stx-store] Subscriber error:", error);
+      }
+  }, devToolsNotify = devtools ? (action, newValue) => {
+    if (typeof window < "u" && window.__STX_DEVTOOLS__)
+      window.__STX_DEVTOOLS__.onStoreChange(name || "unnamed", action, newValue);
+  } : () => {}, baseSet = (value) => {
+    const prevValue = currentValue;
+    if (!equals(value, prevValue)) {
+      currentValue = value;
+      persistValue(value);
+      notify(value, prevValue);
+      devToolsNotify("set", value);
+    }
+  };
+  let wrappedSet = baseSet;
+  const store = {
+    get: () => currentValue,
+    set: (value) => {
+      if (typeof value === "function")
+        wrappedSet(value(currentValue));
+      else
+        wrappedSet(value);
+    },
+    subscribe: (subscriber) => {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    },
+    update: (updater) => {
+      if (typeof currentValue !== "object" || currentValue === null)
+        throw Error("update() can only be used with object stores");
+      const partial = typeof updater === "function" ? updater(currentValue) : updater;
+      store.set({ ...currentValue, ...partial });
+    },
+    reset: () => {
+      store.set(initialValue);
+      devToolsNotify("reset", initialValue);
+    },
+    name,
+    destroy: () => {
+      subscribers.clear();
+      if (persistTimeout)
+        clearTimeout(persistTimeout);
+      if (name)
+        globalState.stores.delete(name);
+    }
+  };
+  for (const mw of middleware.reverse())
+    wrappedSet = mw(baseSet, () => currentValue, store)(wrappedSet);
+  if (name)
+    registerStore(name, store);
+  return store;
+}
+export function createReadonlyStore(getter, options = {}) {
+  const subscribers = new Set;
+  let currentValue = getter();
+  return {
+    get: () => {
+      const newValue = getter();
+      if (newValue !== currentValue) {
+        const prevValue = currentValue;
+        currentValue = newValue;
+        for (const subscriber of subscribers)
+          subscriber(newValue, prevValue);
+      }
+      return currentValue;
+    },
+    subscribe: (subscriber) => {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    },
+    name: options.name,
+    destroy: () => {
+      subscribers.clear();
+    }
+  };
+}
+export function computed(stores, compute, options = {}) {
+  const { equals = (a, b) => a === b } = options, getValues = () => stores.map((s) => s.get());
+  let currentValue = compute(...getValues());
+  const subscribers = new Set, unsubscribes = [];
+  for (const sourceStore of stores) {
+    const unsub = sourceStore.subscribe(() => {
+      const newValue = compute(...getValues());
+      if (!equals(newValue, currentValue)) {
+        const prevValue = currentValue;
+        currentValue = newValue;
+        for (const subscriber of subscribers)
+          subscriber(newValue, prevValue);
+      }
+    });
+    unsubscribes.push(unsub);
+  }
+  return {
+    get: () => currentValue,
+    set: () => {
+      throw Error("Cannot set a computed store");
+    },
+    subscribe: (subscriber) => {
+      subscribers.add(subscriber);
+      return () => {
+        subscribers.delete(subscriber);
+      };
+    },
+    update: () => {
+      throw Error("Cannot update a computed store");
+    },
+    reset: () => {
+      throw Error("Cannot reset a computed store");
+    },
+    destroy: () => {
+      for (const unsub of unsubscribes)
+        unsub();
+      subscribers.clear();
+    }
+  };
+}
+export function createAction(store, name, handler) {
+  return async (...params) => {
+    const currentState = store.get(), newState = await handler(currentState, ...params);
+    store.set(newState);
+    if (typeof window < "u" && window.__STX_DEVTOOLS__)
+      window.__STX_DEVTOOLS__.onAction(store.name || "unnamed", name, params);
+  };
+}
+export function createActions(store, actions) {
+  const result = {};
+  for (const [name, handler] of Object.entries(actions))
+    result[name] = createAction(store, name, handler);
+  return result;
+}
+export function createSelector(store, selector, options = {}) {
+  return computed([store], selector, options);
+}
+export function createMemoizedSelector(store, selector, deps) {
+  let cachedDeps, cachedResult;
+  return computed([store], (state) => {
+    const currentDeps = deps(state);
+    if (cachedDeps && cachedDeps.length === currentDeps.length) {
+      let changed = !1;
+      for (let i = 0;i < currentDeps.length; i++)
+        if (cachedDeps[i] !== currentDeps[i]) {
+          changed = !0;
+          break;
+        }
+      if (!changed && cachedResult !== void 0)
+        return cachedResult;
+    }
+    cachedDeps = currentDeps;
+    cachedResult = selector(state);
+    return cachedResult;
+  });
+}
+export function loggerMiddleware(name) {
+  return (_set, get) => (nextSet) => (value) => {
+    const prev = get();
+    console.group(`[stx-store${name ? `:${name}` : ""}] Update`);
+    console.log("Previous:", prev);
+    console.log("Next:", value);
+    console.groupEnd();
+    nextSet(value);
+  };
+}
+export function validationMiddleware(validate) {
+  return (_set, _get) => (nextSet) => (value) => {
+    const result = validate(value);
+    if (result === !0)
+      nextSet(value);
+    else if (typeof result === "string")
+      console.error(`[stx-store] Validation failed: ${result}`);
+    else
+      console.error("[stx-store] Validation failed");
+  };
+}
+export function immerMiddleware() {
+  return (_set, _get) => (nextSet) => (value) => {
+    const cloned = JSON.parse(JSON.stringify(value));
+    nextSet(cloned);
+  };
+}
+export function throttleMiddleware(ms) {
+  let lastCall = 0, pendingValue, timeout = null;
+  return (_set, _get) => (nextSet) => (value) => {
+    const now = Date.now();
+    if (now - lastCall >= ms) {
+      lastCall = now;
+      nextSet(value);
+    } else {
+      pendingValue = value;
+      if (!timeout)
+        timeout = setTimeout(() => {
+          if (pendingValue !== void 0) {
+            lastCall = Date.now();
+            nextSet(pendingValue);
+            pendingValue = void 0;
+          }
+          timeout = null;
+        }, ms - (now - lastCall));
+    }
+  };
+}
+export function useStore(nameOrStore) {
+  const store = typeof nameOrStore === "string" ? getStore(nameOrStore) : nameOrStore;
+  if (!store)
+    throw Error(`Store "${nameOrStore}" not found`);
+  return store.get();
+}
+export function createStoreDirective(storeName) {
+  const store = getStore(storeName);
+  if (!store)
+    throw Error(`Store "${storeName}" not found`);
+  return {
+    name: "store",
+    hasEndTag: !1,
+    handler: () => {
+      return JSON.stringify(store.get());
+    }
+  };
+}
+export function serializeStores() {
+  const state = {};
+  for (const [name, store] of globalState.stores.entries())
+    state[name] = store.get();
+  return JSON.stringify(state);
+}
+export function hydrateStores(serialized) {
+  try {
+    const state = JSON.parse(serialized);
+    for (const [name, value] of Object.entries(state)) {
+      const store = getStore(name);
+      if (store)
+        store.set(value);
+    }
+  } catch (error) {
+    console.error("[stx-store] Hydration failed:", error);
+  }
+}
+export function generateHydrationScript() {
+  return `<script>window.__STX_STORE_STATE__=${serializeStores()};
+if(window.__STX_HYDRATE_STORES__){window.__STX_HYDRATE_STORES__()}</script>`;
+}
+export function initDevTools() {
+  if (typeof window > "u")
+    return;
+  window.__STX_DEVTOOLS__ = {
+    stores: globalState.stores,
+    history: [],
+    onStoreChange(store, action, state) {
+      this.history.push({ store, action, state, timestamp: Date.now() });
+      if (this.history.length > 100)
+        this.history.shift();
+    },
+    onAction(store, action, _params) {
+      console.log(`[stx-devtools] ${store}.${action}`);
+    },
+    getState() {
+      const state = {};
+      for (const [name, store] of this.stores.entries())
+        state[name] = store.get();
+      return state;
+    },
+    getHistory() {
+      return this.history;
+    },
+    timeTravel(index) {
+      const entry = this.history[index];
+      if (entry) {
+        const store = getStore(entry.store);
+        if (store)
+          store.set(entry.state);
+      }
+    }
+  };
+}
+export function defineStore(id, setupOrOptions, extraOptions) {
+  if (typeof setupOrOptions === "function") {
+    if (typeof window < "u" && window.stx?.defineStore)
+      return window.stx.defineStore(id, setupOrOptions, extraOptions);
+    return setupOrOptions();
+  }
+  const options = setupOrOptions, {
+    state: initialState,
+    getters = {},
+    actions = {},
+    persist,
+    devtools = !0
+  } = options, resolvedInitialState = typeof initialState === "function" ? initialState() : initialState, persistOptions = persist === !0 ? { storage: "local", key: `stx-store:${id}` } : persist || void 0, store = createStore(resolvedInitialState, {
+    name: id,
+    persist: persistOptions,
+    devtools
+  }), storeProxy = new Proxy({}, {
+    get(_target, prop) {
+      const propStr = String(prop);
+      if (propStr === "$state")
+        return store.get();
+      if (propStr === "$subscribe")
+        return store.subscribe;
+      if (propStr === "$reset")
+        return store.reset;
+      if (propStr === "$patch")
+        return (partial) => {
+          if (typeof partial === "function") {
+            const draft = { ...store.get() };
+            partial(draft);
+            store.set(draft);
+          } else
+            store.update(partial);
+        };
+      if (propStr === "_store")
+        return store;
+      if (propStr === "$id")
+        return id;
+      if (propStr in getters)
+        return getters[propStr](store.get());
+      if (propStr in actions)
+        return (...args) => {
+          return actions[propStr].apply(storeProxy, args);
+        };
+      const state = store.get();
+      if (state && typeof state === "object" && propStr in state)
+        return state[propStr];
+      return;
+    },
+    set(_target, prop, value) {
+      const propStr = String(prop);
+      if (propStr.startsWith("$") || propStr === "_store")
+        return !1;
+      const state = store.get();
+      if (state && typeof state === "object") {
+        store.set({ ...state, [propStr]: value });
+        return !0;
+      }
+      return !1;
+    },
+    has(_target, prop) {
+      const propStr = String(prop), state = store.get();
+      return propStr.startsWith("$") || propStr === "_store" || propStr in getters || propStr in actions || state && typeof state === "object" && propStr in state;
+    },
+    ownKeys() {
+      const state = store.get();
+      return [
+        ...state && typeof state === "object" ? Object.keys(state) : [],
+        ...Object.keys(getters),
+        ...Object.keys(actions),
+        "$state",
+        "$subscribe",
+        "$reset",
+        "$patch",
+        "$id"
+      ];
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      return {
+        enumerable: !0,
+        configurable: !0,
+        get: () => this.get(_target, prop, storeProxy)
+      };
+    }
+  });
+  storeRegistry.set(id, storeProxy);
+  return storeProxy;
+}
+const storeRegistry = new Map;
+export function getDefinedStore(name) {
+  return storeRegistry.get(name);
+}
+export function getDefinedStoreNames() {
+  return Array.from(storeRegistry.keys());
+}
+export function hasDefinedStore(name) {
+  return storeRegistry.has(name);
+}
+export function generateStoreImportRuntime() {
+  return `
+// STX Store Runtime - extends stx global
+(function() {
+  if (typeof window === 'undefined') return;
+  var s = window.stx || {};
+
+  // Helper to wait for stores to be ready
+  s.waitForStore = function(storeName, timeout) {
+    timeout = timeout || 5000;
+    var start = Date.now();
+    return new Promise(function(resolve, reject) {
+      function check() {
+        var store = s.useStore ? s.useStore(storeName) : null;
+        if (store) {
+          resolve(store);
+        }
+else if (Date.now() - start > timeout) {
+          reject(new Error('Timeout waiting for store: ' + storeName));
+        }
+else {
+          requestAnimationFrame(check);
+        }
+      }
+      check();
+    });
+  };
+
+  window.stx = s;
+})();
+`;
+}
+export function transformStoreImports(code) {
+  const storeRegex = /import\s*\{([^}]+)\}\s*from\s*['"](@stores|stx\/stores)['"]\s*;?\n?/g;
+  code = code.replace(storeRegex, (_match, imports) => {
+    return `const { ${imports.split(",").map((s) => s.trim()).filter(Boolean).join(", ")} } = window.__STX_STORES__
+`;
+  });
+  const composablesRegex = /import\s*\{([^}]+)\}\s*from\s*['"]@composables['"]\s*;?\n?/g;
+  code = code.replace(composablesRegex, (_match, imports) => {
+    return `const { ${imports.split(",").map((s) => s.trim()).filter(Boolean).join(", ")} } = window.__composables
+`;
+  });
+  return code;
+}
+export function registerStoresClient(stores) {
+  if (typeof window > "u")
+    return;
+  const w = window;
+  w.__STX_STORES__ = w.__STX_STORES__ || {};
+  for (const [name, store] of Object.entries(stores))
+    w.__STX_STORES__[name] = store;
+  window.dispatchEvent(new CustomEvent("stx:stores-ready", { detail: Object.keys(stores) }));
+}

package/dist/store-imports.js

@@ -1,2 +1,13 @@
-// @bun
-import{tt as a}from"./chunk-keawsbpn.js";import"./chunk-xv34zbp4.js";export{a as transformStoreImports};
+export function transformStoreImports(code) {
+  const storeRegex = /import\s*\{([^}]+)\}\s*from\s*['"](@stores|stx\/stores)['"]\s*;?\n?/g;
+  code = code.replace(storeRegex, (_match, imports) => {
+    return `const { ${imports.split(",").map((s) => s.trim()).filter(Boolean).join(", ")} } = window.__STX_STORES__
+`;
+  });
+  const composablesRegex = /import\s*\{([^}]+)\}\s*from\s*['"]@composables['"]\s*;?\n?/g;
+  code = code.replace(composablesRegex, (_match, imports) => {
+    return `const { ${imports.split(",").map((s) => s.trim()).filter(Boolean).join(", ")} } = window.__composables
+`;
+  });
+  return code;
+}

package/dist/store-loader.js

@@ -1,7 +1,74 @@
-// @bun
-import{Rr as L}from"./chunk-1xz0w746.js";import"./chunk-m8448qby.js";import"./chunk-kx6eb6ma.js";import"./chunk-g1vt329s.js";import"./chunk-7074g241.js";import"./chunk-9cf97f9p.js";import"./chunk-6djzdes9.js";import"./chunk-v7f8jj15.js";import"./chunk-keawsbpn.js";import"./chunk-8b3z0zd5.js";import"./chunk-hbgxbgam.js";import"./chunk-ejh8fyak.js";import"./chunk-krqn0ddk.js";import"./chunk-y1k17c8b.js";import"./chunk-2j21d3ka.js";import"./chunk-frg705zq.js";import"./chunk-hjm2xab3.js";import"./chunk-07y6m5xx.js";import"./chunk-wazkqv7n.js";import"./chunk-x05nxhyv.js";import"./chunk-31dr4bys.js";import"./chunk-mgj88zeq.js";import"./chunk-m167kjhv.js";import"./chunk-3a4qsygv.js";import"./chunk-dqn9gyhb.js";import"./chunk-988dw6q3.js";import"./chunk-8qc1bsym.js";import"./chunk-xyg1r5w0.js";import"./chunk-7gd339hd.js";import"./chunk-4deg33rw.js";import"./chunk-pa9zb7ty.js";import"./chunk-a2g2qb2y.js";import"./chunk-h5jxydqq.js";import"./chunk-nhv099jv.js";import"./chunk-shv88d2d.js";import"./chunk-0dx4q6yq.js";import"./chunk-ek2w6zvy.js";import"./chunk-9wmq2272.js";import"./chunk-7dkz6z2s.js";import"./chunk-9ecv8aqj.js";import"./chunk-bdk6g1vj.js";import"./chunk-xqq1vxb6.js";import"./chunk-amaa1bev.js";import"./chunk-r5m9xtm7.js";import"./chunk-bs3gmfxz.js";import"./chunk-1zgsgk4b.js";import"./chunk-2jxbwnkz.js";import"./chunk-zen6ax1y.js";import"./chunk-yb1t2h8h.js";import"./chunk-fjk3x41y.js";import"./chunk-5shey2e4.js";import"./chunk-27zsyhrd.js";import{Ty as K}from"./chunk-7ed3tean.js";import"./chunk-8vtm0m84.js";import"./chunk-tzwtg722.js";import"./chunk-ah88wzbg.js";import"./chunk-v8j49spx.js";import"./chunk-tg2f1mzq.js";import"./chunk-n9dhs1dw.js";import"./chunk-rwrv9wbf.js";import"./chunk-wg9k6h8w.js";import"./chunk-9jtj77jx.js";import"./chunk-qygvvygy.js";import"./chunk-gz5fmp3q.js";import"./chunk-vjbefncc.js";import"./chunk-8xj7c3mf.js";import"./chunk-qvrbjpdc.js";import"./chunk-w3b6m427.js";import"./chunk-rz2ec6g7.js";import"./chunk-35faj94w.js";import"./chunk-djddhmcc.js";import"./chunk-knm8a8yx.js";import"./chunk-xv34zbp4.js";import z from"path";var y=new Map;async function X(H){let w;if(H)w=z.resolve(H);else{let j=await L();w=z.resolve(j.root||process.cwd(),j.storesDir||"stores")}let I=y.get(w);if(I!==void 0)return I||null;let M=new Bun.Glob("*.ts"),A=[];try{for await(let j of M.scan({cwd:w,absolute:!0})){let q=z.basename(j,".ts");if(["index","types"].includes(q))continue;if(j.includes(".d.ts"))continue;A.push(j)}}catch{return y.set(w,""),null}if(A.length===0)return y.set(w,""),null;let B=[];for(let j of A){let q=await Bun.file(j).text();B.push({file:j,hasUseStore:/useStore\s*\(/.test(q)})}B.sort((j,q)=>{if(j.hasUseStore===q.hasUseStore)return 0;return j.hasUseStore?1:-1});let O=B.map((j)=>j.file),G=[],Q=new Bun.Transpiler({loader:"ts",target:"browser",define:K()});for(let j of O)try{let q=await Bun.file(j).text(),R=z.basename(j,".ts");q=q.replace(/^import\s+.*from\s+['"][^'"]+['"]\s*;?\s*$/gm,""),q=q.replace(/^export\s+(default\s+)?/gm,""),q=Q.transformSync(q),G.push(`// Store: ${R}
-${q.trim()}`)}catch(q){console.warn(`[stx] Failed to load store ${j}:`,q)}if(G.length===0)return y.set(w,""),null;let J=`;(function(){
-${G.join(`
+import path from "node:path";
+import { loadStxConfig } from "./config.js";
+import { getPublicEnvDefine } from "./public-env.js";
+const _cachedStoreScripts = new Map;
+export async function getStoreScript(storesDir) {
+  let resolvedDir;
+  if (storesDir)
+    resolvedDir = path.resolve(storesDir);
+  else {
+    const config = await loadStxConfig();
+    resolvedDir = path.resolve(config.root || process.cwd(), config.storesDir || "stores");
+  }
+  const cached = _cachedStoreScripts.get(resolvedDir);
+  if (cached !== void 0)
+    return cached || null;
+  const glob = new Bun.Glob("*.ts"), storeFiles = [];
+  try {
+    for await (const file of glob.scan({ cwd: resolvedDir, absolute: !0 })) {
+      const name = path.basename(file, ".ts");
+      if (["index", "types"].includes(name))
+        continue;
+      if (file.includes(".d.ts"))
+        continue;
+      storeFiles.push(file);
+    }
+  } catch {
+    _cachedStoreScripts.set(resolvedDir, "");
+    return null;
+  }
+  if (storeFiles.length === 0) {
+    _cachedStoreScripts.set(resolvedDir, "");
+    return null;
+  }
+  const filesWithDeps = [];
+  for (const file of storeFiles) {
+    const content = await Bun.file(file).text();
+    filesWithDeps.push({
+      file,
+      hasUseStore: /useStore\s*\(/.test(content)
+    });
+  }
+  filesWithDeps.sort((a, b) => {
+    if (a.hasUseStore === b.hasUseStore)
+      return 0;
+    return a.hasUseStore ? 1 : -1;
+  });
+  const sortedFiles = filesWithDeps.map((f) => f.file), chunks = [], transpiler = new Bun.Transpiler({ loader: "ts", target: "browser", define: getPublicEnvDefine() });
+  for (const file of sortedFiles)
+    try {
+      let code = await Bun.file(file).text();
+      const storeName = path.basename(file, ".ts");
+      code = code.replace(/^import\s+.*from\s+['"][^'"]+['"]\s*;?\s*$/gm, "");
+      code = code.replace(/^export\s+(default\s+)?/gm, "");
+      code = transpiler.transformSync(code);
+      chunks.push(`// Store: ${storeName}
+${code.trim()}`);
+    } catch (e) {
+      console.warn(`[stx] Failed to load store ${file}:`, e);
+    }
+  if (chunks.length === 0) {
+    _cachedStoreScripts.set(resolvedDir, "");
+    return null;
+  }
+  const code = `;(function(){
+${chunks.join(`
 
 `)}
-})();`;return y.set(w,J),J}function Y(){y.clear()}export{X as getStoreScript,Y as clearStoreCache};
+})();`;
+  _cachedStoreScripts.set(resolvedDir, code);
+  return code;
+}
+export function clearStoreCache() {
+  _cachedStoreScripts.clear();
+}