davaux 0.8.0

package/dist/client/signal.d.ts

@@ -0,0 +1,90 @@
+type Subscriber = () => void;
+type Cleanup = (() => void) | void;
+export type Signal<T> = [get: () => T, set: (value: T) => void];
+export type ReadonlySignal<T> = () => T;
+/**
+ * Create a reactive signal — a getter/setter pair.
+ * Reading the getter inside an effect or reactive JSX child subscribes that
+ * context to future updates; calling the setter notifies all subscribers.
+ *
+ * @example
+ * const [count, setCount] = createSignal(0)
+ * count()            // read: 0
+ * setCount(1)        // write
+ * setCount(n => n + 1)  // updater function
+ */
+export declare function createSignal<T>(initialValue: T): Signal<T>;
+/**
+ * Run a side effect immediately and re-run it whenever its reactive
+ * dependencies change. The effect automatically tracks which signals are
+ * read during execution and subscribes to each of them.
+ *
+ * Return a cleanup function (or nothing) — it runs before the next execution
+ * and when the enclosing scope is disposed.
+ *
+ * @example
+ * createEffect(() => {
+ *   document.title = name()  // re-runs whenever `name` changes
+ * })
+ */
+export declare function createEffect(fn: () => Cleanup): void;
+/**
+ * Create a memoized derived value. Recomputes only when its reactive
+ * dependencies change; all readers share the same cached result.
+ *
+ * @example
+ * const fullName = createMemo(() => `${firstName()} ${lastName()}`)
+ * <h1>{() => fullName()}</h1>
+ */
+export declare function createMemo<T>(fn: () => T): ReadonlySignal<T>;
+/**
+ * Register a teardown tied to the current reactive scope.
+ * Called before the enclosing effect re-runs, or when the root is disposed.
+ * No-op if called outside any reactive scope.
+ *
+ * @example
+ * createEffect(() => {
+ *   const id = setInterval(tick, 1000)
+ *   onCleanup(() => clearInterval(id))
+ * })
+ */
+export declare function onCleanup(fn: () => void): void;
+/**
+ * Create a reactive scope with an explicit lifetime. The `dispose` function
+ * tears down all effects and cleanups registered within the scope.
+ * Useful for managing reactive state outside the normal component lifecycle.
+ *
+ * @example
+ * const dispose = createRoot((d) => {
+ *   createEffect(() => console.log(count()))
+ *   return d
+ * })
+ * dispose()  // tear everything down
+ */
+export declare function createRoot<T>(fn: (dispose: () => void) => T): T;
+/**
+ * Read signals inside `fn` without registering reactive dependencies.
+ * The enclosing effect will not re-run when those signals change.
+ *
+ * @example
+ * createEffect(() => {
+ *   const a = a()              // tracked — effect re-runs when `a` changes
+ *   const b = untrack(() => b())  // not tracked
+ * })
+ */
+export declare function untrack<T>(fn: () => T): T;
+/**
+ * Batch multiple signal writes into a single downstream notification pass.
+ * Without batching, each setter triggers its own update cycle.
+ *
+ * @example
+ * batch(() => {
+ *   setX(1)
+ *   setY(2)  // effects that read both x and y run once, not twice
+ * })
+ */
+export declare function batch<T>(fn: () => T): T;
+export declare function trackRead(subs: Set<Subscriber>): void;
+export declare function notifySubs(subs: Set<Subscriber>): void;
+export {};
+//# sourceMappingURL=signal.d.ts.map

package/dist/client/signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal.d.ts","sourceRoot":"","sources":["../../client/signal.ts"],"names":[],"mappings":"AAGA,KAAK,UAAU,GAAG,MAAM,IAAI,CAAA;AAE5B,KAAK,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAA;AAOlC,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC,CAAA;AAC/D,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,MAAM,CAAC,CAAA;AAEvC;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAoB1D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,OAAO,GAAG,IAAI,CAgCpD;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAM5D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI,CAE9C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,KAAK,CAAC,GAAG,CAAC,CAa/D;AAED;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQzC;AAED;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAYvC;AAKD,wBAAgB,SAAS,CAAC,IAAI,EAAE,GAAG,CAAC,UAAU,CAAC,GAAG,IAAI,CAErD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,UAAU,CAAC,GAAG,IAAI,CAMtD"}

package/dist/client/signal.js

@@ -0,0 +1,115 @@
+let currentSubscriber = null;
+let currentCleanups = null;
+let batchDepth = 0;
+const pendingEffects = /* @__PURE__ */ new Set();
+function createSignal(initialValue) {
+  let value = initialValue;
+  const subscribers = /* @__PURE__ */ new Set();
+  const get = () => {
+    if (currentSubscriber) subscribers.add(currentSubscriber);
+    return value;
+  };
+  const set = (next) => {
+    if (Object.is(value, next)) return;
+    value = next;
+    if (batchDepth > 0) {
+      for (const sub of subscribers) pendingEffects.add(sub);
+    } else {
+      for (const sub of [...subscribers]) sub();
+    }
+  };
+  return [get, set];
+}
+function createEffect(fn) {
+  const state = { cleanups: [] };
+  if (currentCleanups) {
+    currentCleanups.push(() => {
+      for (const c of state.cleanups) c();
+      state.cleanups = [];
+    });
+  }
+  const run = () => {
+    for (const c of state.cleanups) c();
+    state.cleanups = [];
+    const prev = currentSubscriber;
+    const prevCleanups = currentCleanups;
+    currentSubscriber = run;
+    currentCleanups = state.cleanups;
+    try {
+      const cleanup = fn();
+      if (cleanup) state.cleanups.push(cleanup);
+    } finally {
+      currentSubscriber = prev;
+      currentCleanups = prevCleanups;
+    }
+  };
+  run();
+}
+function createMemo(fn) {
+  const [get, set] = createSignal(void 0);
+  createEffect(() => {
+    set(fn());
+  });
+  return get;
+}
+function onCleanup(fn) {
+  currentCleanups?.push(fn);
+}
+function createRoot(fn) {
+  const cleanups = [];
+  const dispose = () => {
+    for (const c of cleanups) c();
+    cleanups.length = 0;
+  };
+  const prev = currentCleanups;
+  currentCleanups = cleanups;
+  try {
+    return fn(dispose);
+  } finally {
+    currentCleanups = prev;
+  }
+}
+function untrack(fn) {
+  const prev = currentSubscriber;
+  currentSubscriber = null;
+  try {
+    return fn();
+  } finally {
+    currentSubscriber = prev;
+  }
+}
+function batch(fn) {
+  batchDepth++;
+  try {
+    return fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0) {
+      const toRun = [...pendingEffects];
+      pendingEffects.clear();
+      for (const sub of toRun) sub();
+    }
+  }
+}
+function trackRead(subs) {
+  if (currentSubscriber) subs.add(currentSubscriber);
+}
+function notifySubs(subs) {
+  if (batchDepth > 0) {
+    for (const sub of subs) pendingEffects.add(sub);
+  } else {
+    for (const sub of [...subs]) sub();
+  }
+}
+export {
+  batch,
+  createEffect,
+  createMemo,
+  createRoot,
+  createSignal,
+  notifySubs,
+  onCleanup,
+  trackRead,
+  untrack
+};
+//# sourceMappingURL=signal.js.map

package/dist/client/signal.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../client/signal.ts"],
+  "sourcesContent": ["// Fine-grained reactivity for browser islands.\n// Signal changes update only the DOM nodes that read them \u2014 no VDOM diffing.\n\ntype Subscriber = () => void\n// biome-ignore lint/suspicious/noConfusingVoidType: void in this union is intentional \u2014 it lets createEffect accept functions that return nothing without an explicit `undefined` return\ntype Cleanup = (() => void) | void\n\nlet currentSubscriber: Subscriber | null = null\nlet currentCleanups: (() => void)[] | null = null\nlet batchDepth = 0\nconst pendingEffects = new Set<Subscriber>()\n\nexport type Signal<T> = [get: () => T, set: (value: T) => void]\nexport type ReadonlySignal<T> = () => T\n\n/**\n * Create a reactive signal \u2014 a getter/setter pair.\n * Reading the getter inside an effect or reactive JSX child subscribes that\n * context to future updates; calling the setter notifies all subscribers.\n *\n * @example\n * const [count, setCount] = createSignal(0)\n * count()            // read: 0\n * setCount(1)        // write\n * setCount(n => n + 1)  // updater function\n */\nexport function createSignal<T>(initialValue: T): Signal<T> {\n  let value = initialValue\n  const subscribers = new Set<Subscriber>()\n\n  const get = (): T => {\n    if (currentSubscriber) subscribers.add(currentSubscriber)\n    return value\n  }\n\n  const set = (next: T): void => {\n    if (Object.is(value, next)) return\n    value = next\n    if (batchDepth > 0) {\n      for (const sub of subscribers) pendingEffects.add(sub)\n    } else {\n      for (const sub of [...subscribers]) sub()\n    }\n  }\n\n  return [get, set]\n}\n\n/**\n * Run a side effect immediately and re-run it whenever its reactive\n * dependencies change. The effect automatically tracks which signals are\n * read during execution and subscribes to each of them.\n *\n * Return a cleanup function (or nothing) \u2014 it runs before the next execution\n * and when the enclosing scope is disposed.\n *\n * @example\n * createEffect(() => {\n *   document.title = name()  // re-runs whenever `name` changes\n * })\n */\nexport function createEffect(fn: () => Cleanup): void {\n  // Use an object wrapper so the parent-scope disposal closure always reads\n  // the current cleanups array, not a stale reference from an earlier run.\n  const state = { cleanups: [] as (() => void)[] }\n\n  // If created inside a parent scope (createRoot or another createEffect),\n  // register disposal so this effect's cleanups run when the parent disposes.\n  if (currentCleanups) {\n    currentCleanups.push(() => {\n      for (const c of state.cleanups) c()\n      state.cleanups = []\n    })\n  }\n\n  const run: Subscriber = () => {\n    for (const c of state.cleanups) c()\n    state.cleanups = []\n\n    const prev = currentSubscriber\n    const prevCleanups = currentCleanups\n    currentSubscriber = run\n    currentCleanups = state.cleanups\n    try {\n      const cleanup = fn()\n      if (cleanup) state.cleanups.push(cleanup)\n    } finally {\n      currentSubscriber = prev\n      currentCleanups = prevCleanups\n    }\n  }\n\n  run()\n}\n\n/**\n * Create a memoized derived value. Recomputes only when its reactive\n * dependencies change; all readers share the same cached result.\n *\n * @example\n * const fullName = createMemo(() => `${firstName()} ${lastName()}`)\n * <h1>{() => fullName()}</h1>\n */\nexport function createMemo<T>(fn: () => T): ReadonlySignal<T> {\n  const [get, set] = createSignal<T>(undefined as T)\n  createEffect(() => {\n    set(fn())\n  })\n  return get\n}\n\n/**\n * Register a teardown tied to the current reactive scope.\n * Called before the enclosing effect re-runs, or when the root is disposed.\n * No-op if called outside any reactive scope.\n *\n * @example\n * createEffect(() => {\n *   const id = setInterval(tick, 1000)\n *   onCleanup(() => clearInterval(id))\n * })\n */\nexport function onCleanup(fn: () => void): void {\n  currentCleanups?.push(fn)\n}\n\n/**\n * Create a reactive scope with an explicit lifetime. The `dispose` function\n * tears down all effects and cleanups registered within the scope.\n * Useful for managing reactive state outside the normal component lifecycle.\n *\n * @example\n * const dispose = createRoot((d) => {\n *   createEffect(() => console.log(count()))\n *   return d\n * })\n * dispose()  // tear everything down\n */\nexport function createRoot<T>(fn: (dispose: () => void) => T): T {\n  const cleanups: (() => void)[] = []\n  const dispose = (): void => {\n    for (const c of cleanups) c()\n    cleanups.length = 0\n  }\n  const prev = currentCleanups\n  currentCleanups = cleanups\n  try {\n    return fn(dispose)\n  } finally {\n    currentCleanups = prev\n  }\n}\n\n/**\n * Read signals inside `fn` without registering reactive dependencies.\n * The enclosing effect will not re-run when those signals change.\n *\n * @example\n * createEffect(() => {\n *   const a = a()              // tracked \u2014 effect re-runs when `a` changes\n *   const b = untrack(() => b())  // not tracked\n * })\n */\nexport function untrack<T>(fn: () => T): T {\n  const prev = currentSubscriber\n  currentSubscriber = null\n  try {\n    return fn()\n  } finally {\n    currentSubscriber = prev\n  }\n}\n\n/**\n * Batch multiple signal writes into a single downstream notification pass.\n * Without batching, each setter triggers its own update cycle.\n *\n * @example\n * batch(() => {\n *   setX(1)\n *   setY(2)  // effects that read both x and y run once, not twice\n * })\n */\nexport function batch<T>(fn: () => T): T {\n  batchDepth++\n  try {\n    return fn()\n  } finally {\n    batchDepth--\n    if (batchDepth === 0) {\n      const toRun = [...pendingEffects]\n      pendingEffects.clear()\n      for (const sub of toRun) sub()\n    }\n  }\n}\n\n// \u2500\u2500\u2500 Store integration hooks \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n// Used by store.ts to participate in the same subscriber graph and batching.\n\nexport function trackRead(subs: Set<Subscriber>): void {\n  if (currentSubscriber) subs.add(currentSubscriber)\n}\n\nexport function notifySubs(subs: Set<Subscriber>): void {\n  if (batchDepth > 0) {\n    for (const sub of subs) pendingEffects.add(sub)\n  } else {\n    for (const sub of [...subs]) sub()\n  }\n}\n"],
+  "mappings": "AAOA,IAAI,oBAAuC;AAC3C,IAAI,kBAAyC;AAC7C,IAAI,aAAa;AACjB,MAAM,iBAAiB,oBAAI,IAAgB;AAgBpC,SAAS,aAAgB,cAA4B;AAC1D,MAAI,QAAQ;AACZ,QAAM,cAAc,oBAAI,IAAgB;AAExC,QAAM,MAAM,MAAS;AACnB,QAAI,kBAAmB,aAAY,IAAI,iBAAiB;AACxD,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,CAAC,SAAkB;AAC7B,QAAI,OAAO,GAAG,OAAO,IAAI,EAAG;AAC5B,YAAQ;AACR,QAAI,aAAa,GAAG;AAClB,iBAAW,OAAO,YAAa,gBAAe,IAAI,GAAG;AAAA,IACvD,OAAO;AACL,iBAAW,OAAO,CAAC,GAAG,WAAW,EAAG,KAAI;AAAA,IAC1C;AAAA,EACF;AAEA,SAAO,CAAC,KAAK,GAAG;AAClB;AAeO,SAAS,aAAa,IAAyB;AAGpD,QAAM,QAAQ,EAAE,UAAU,CAAC,EAAoB;AAI/C,MAAI,iBAAiB;AACnB,oBAAgB,KAAK,MAAM;AACzB,iBAAW,KAAK,MAAM,SAAU,GAAE;AAClC,YAAM,WAAW,CAAC;AAAA,IACpB,CAAC;AAAA,EACH;AAEA,QAAM,MAAkB,MAAM;AAC5B,eAAW,KAAK,MAAM,SAAU,GAAE;AAClC,UAAM,WAAW,CAAC;AAElB,UAAM,OAAO;AACb,UAAM,eAAe;AACrB,wBAAoB;AACpB,sBAAkB,MAAM;AACxB,QAAI;AACF,YAAM,UAAU,GAAG;AACnB,UAAI,QAAS,OAAM,SAAS,KAAK,OAAO;AAAA,IAC1C,UAAE;AACA,0BAAoB;AACpB,wBAAkB;AAAA,IACpB;AAAA,EACF;AAEA,MAAI;AACN;AAUO,SAAS,WAAc,IAAgC;AAC5D,QAAM,CAAC,KAAK,GAAG,IAAI,aAAgB,MAAc;AACjD,eAAa,MAAM;AACjB,QAAI,GAAG,CAAC;AAAA,EACV,CAAC;AACD,SAAO;AACT;AAaO,SAAS,UAAU,IAAsB;AAC9C,mBAAiB,KAAK,EAAE;AAC1B;AAcO,SAAS,WAAc,IAAmC;AAC/D,QAAM,WAA2B,CAAC;AAClC,QAAM,UAAU,MAAY;AAC1B,eAAW,KAAK,SAAU,GAAE;AAC5B,aAAS,SAAS;AAAA,EACpB;AACA,QAAM,OAAO;AACb,oBAAkB;AAClB,MAAI;AACF,WAAO,GAAG,OAAO;AAAA,EACnB,UAAE;AACA,sBAAkB;AAAA,EACpB;AACF;AAYO,SAAS,QAAW,IAAgB;AACzC,QAAM,OAAO;AACb,sBAAoB;AACpB,MAAI;AACF,WAAO,GAAG;AAAA,EACZ,UAAE;AACA,wBAAoB;AAAA,EACtB;AACF;AAYO,SAAS,MAAS,IAAgB;AACvC;AACA,MAAI;AACF,WAAO,GAAG;AAAA,EACZ,UAAE;AACA;AACA,QAAI,eAAe,GAAG;AACpB,YAAM,QAAQ,CAAC,GAAG,cAAc;AAChC,qBAAe,MAAM;AACrB,iBAAW,OAAO,MAAO,KAAI;AAAA,IAC/B;AAAA,EACF;AACF;AAKO,SAAS,UAAU,MAA6B;AACrD,MAAI,kBAAmB,MAAK,IAAI,iBAAiB;AACnD;AAEO,SAAS,WAAW,MAA6B;AACtD,MAAI,aAAa,GAAG;AAClB,eAAW,OAAO,KAAM,gBAAe,IAAI,GAAG;AAAA,EAChD,OAAO;AACL,eAAW,OAAO,CAAC,GAAG,IAAI,EAAG,KAAI;AAAA,EACnC;AACF;",
+  "names": []
+}

package/dist/client/store.d.ts

@@ -0,0 +1,26 @@
+/** A value or a function that receives the previous value and returns the next. */
+export type Updater<T> = T | ((prev: T) => T);
+/** Typed path-based setter for a store. Supports 1–3 level deep key paths;
+ * deeper paths fall through to an untyped escape hatch. */
+export interface SetStoreFn<T extends object> {
+    <K extends keyof T>(k: K, v: Updater<T[K]>): void;
+    <K1 extends keyof T, K2 extends keyof NonNullable<T[K1]>>(k1: K1, k2: K2, v: Updater<NonNullable<T[K1]>[K2]>): void;
+    <K1 extends keyof T, K2 extends keyof NonNullable<T[K1]>, K3 extends keyof NonNullable<NonNullable<T[K1]>[K2]>>(k1: K1, k2: K2, k3: K3, v: Updater<NonNullable<NonNullable<T[K1]>[K2]>[K3]>): void;
+    (...args: unknown[]): void;
+}
+/**
+ * Create a reactive store for shared inter-island state. Returns a
+ * `[store, setStore]` pair. `store` is a deeply reactive readonly proxy —
+ * reads inside effects and JSX are tracked at individual property granularity,
+ * so only the effects that read a changed key re-run.
+ *
+ * Use `setStore` with dot-path key segments; functional updaters are supported
+ * at every level. Arrays must be updated via functional updaters (not `.push()`).
+ *
+ * @example
+ * const [cart, setCart] = createStore({ items: [] as Item[], total: 0 })
+ * setCart('items', items => [...items, newItem])
+ * setCart('total', t => t + newItem.price)
+ */
+export declare function createStore<T extends object>(init: T): [store: T, setStore: SetStoreFn<T>];
+//# sourceMappingURL=store.d.ts.map

package/dist/client/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../client/store.ts"],"names":[],"mappings":"AA4DA,mFAAmF;AACnF,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;AAE7C;2DAC2D;AAC3D,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,MAAM;IAC1C,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAA;IACjD,CAAC,EAAE,SAAS,MAAM,CAAC,EAAE,EAAE,SAAS,MAAM,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EACtD,EAAE,EAAE,EAAE,EACN,EAAE,EAAE,EAAE,EACN,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GACjC,IAAI,CAAA;IACP,CACE,EAAE,SAAS,MAAM,CAAC,EAClB,EAAE,SAAS,MAAM,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EACnC,EAAE,SAAS,MAAM,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAEpD,EAAE,EAAE,EAAE,EACN,EAAE,EAAE,EAAE,EACN,EAAE,EAAE,EAAE,EACN,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,GAClD,IAAI,CAAA;IACP,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAA;CAC3B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAU1F"}

package/dist/client/store.js

@@ -0,0 +1,63 @@
+import { notifySubs, trackRead } from "./signal.js";
+const nodeMap = /* @__PURE__ */ new WeakMap();
+function getSubs(target, key) {
+  let keyMap = nodeMap.get(target);
+  if (!keyMap) {
+    keyMap = /* @__PURE__ */ new Map();
+    nodeMap.set(target, keyMap);
+  }
+  let s = keyMap.get(key);
+  if (!s) {
+    s = /* @__PURE__ */ new Set();
+    keyMap.set(key, s);
+  }
+  return s;
+}
+function wrap(raw) {
+  return new Proxy(raw, {
+    get(target, key, receiver) {
+      const val = Reflect.get(target, key, receiver);
+      if (typeof key === "string" && typeof val !== "function") {
+        trackRead(getSubs(target, key));
+      }
+      if (val !== null && typeof val === "object") return wrap(val);
+      return val;
+    },
+    set() {
+      throw new Error("[davaux] Store is read-only \u2014 use setStore() to update");
+    },
+    deleteProperty() {
+      throw new Error("[davaux] Store is read-only \u2014 use setStore() to update");
+    }
+  });
+}
+function setPath(raw, path, value) {
+  const [head, ...tail] = path;
+  const key = String(head);
+  if (tail.length === 0) {
+    const prev = raw[key];
+    const next = typeof value === "function" ? value(prev) : value;
+    if (Object.is(prev, next)) return;
+    raw[key] = next;
+    notifySubs(getSubs(raw, key));
+  } else {
+    const child = raw[key];
+    if (child === null || typeof child !== "object") {
+      throw new Error(`[davaux] setStore: "${key}" is not an object`);
+    }
+    setPath(child, tail, value);
+  }
+}
+function createStore(init) {
+  const raw = structuredClone(init);
+  const store = wrap(raw);
+  const setStore = (...args) => {
+    if (args.length < 2) throw new Error("[davaux] setStore requires a path and a value");
+    setPath(raw, args.slice(0, -1), args[args.length - 1]);
+  };
+  return [store, setStore];
+}
+export {
+  createStore
+};
+//# sourceMappingURL=store.js.map

package/dist/client/store.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../client/store.ts"],
+  "sourcesContent": ["import { notifySubs, trackRead } from './signal.js'\n\ntype PlainObj = Record<string | symbol, unknown>\ntype Subscriber = () => void\n\n// Per-property subscriber sets, keyed on the raw (unwrapped) target object.\nconst nodeMap = new WeakMap<object, Map<string | symbol, Set<Subscriber>>>()\n\nfunction getSubs(target: object, key: string | symbol): Set<Subscriber> {\n  let keyMap = nodeMap.get(target)\n  if (!keyMap) {\n    keyMap = new Map()\n    nodeMap.set(target, keyMap)\n  }\n  let s = keyMap.get(key)\n  if (!s) {\n    s = new Set()\n    keyMap.set(key, s)\n  }\n  return s\n}\n\nfunction wrap<T extends object>(raw: T): T {\n  return new Proxy(raw, {\n    get(target, key, receiver) {\n      const val = Reflect.get(target, key, receiver)\n      // Only track string-keyed data reads (not Symbol builtins or methods)\n      if (typeof key === 'string' && typeof val !== 'function') {\n        trackRead(getSubs(target, key))\n      }\n      if (val !== null && typeof val === 'object') return wrap(val as object)\n      return val\n    },\n    set() {\n      throw new Error('[davaux] Store is read-only \u2014 use setStore() to update')\n    },\n    deleteProperty() {\n      throw new Error('[davaux] Store is read-only \u2014 use setStore() to update')\n    },\n  })\n}\n\nfunction setPath(raw: PlainObj, path: (string | number)[], value: unknown): void {\n  const [head, ...tail] = path\n  const key = String(head)\n  if (tail.length === 0) {\n    const prev = raw[key]\n    const next = typeof value === 'function' ? (value as (p: unknown) => unknown)(prev) : value\n    if (Object.is(prev, next)) return\n    raw[key] = next\n    notifySubs(getSubs(raw, key))\n  } else {\n    const child = raw[key]\n    if (child === null || typeof child !== 'object') {\n      throw new Error(`[davaux] setStore: \"${key}\" is not an object`)\n    }\n    setPath(child as PlainObj, tail, value)\n  }\n}\n\n/** A value or a function that receives the previous value and returns the next. */\nexport type Updater<T> = T | ((prev: T) => T)\n\n/** Typed path-based setter for a store. Supports 1\u20133 level deep key paths;\n * deeper paths fall through to an untyped escape hatch. */\nexport interface SetStoreFn<T extends object> {\n  <K extends keyof T>(k: K, v: Updater<T[K]>): void\n  <K1 extends keyof T, K2 extends keyof NonNullable<T[K1]>>(\n    k1: K1,\n    k2: K2,\n    v: Updater<NonNullable<T[K1]>[K2]>,\n  ): void\n  <\n    K1 extends keyof T,\n    K2 extends keyof NonNullable<T[K1]>,\n    K3 extends keyof NonNullable<NonNullable<T[K1]>[K2]>,\n  >(\n    k1: K1,\n    k2: K2,\n    k3: K3,\n    v: Updater<NonNullable<NonNullable<T[K1]>[K2]>[K3]>,\n  ): void\n  (...args: unknown[]): void\n}\n\n/**\n * Create a reactive store for shared inter-island state. Returns a\n * `[store, setStore]` pair. `store` is a deeply reactive readonly proxy \u2014\n * reads inside effects and JSX are tracked at individual property granularity,\n * so only the effects that read a changed key re-run.\n *\n * Use `setStore` with dot-path key segments; functional updaters are supported\n * at every level. Arrays must be updated via functional updaters (not `.push()`).\n *\n * @example\n * const [cart, setCart] = createStore({ items: [] as Item[], total: 0 })\n * setCart('items', items => [...items, newItem])\n * setCart('total', t => t + newItem.price)\n */\nexport function createStore<T extends object>(init: T): [store: T, setStore: SetStoreFn<T>] {\n  const raw = structuredClone(init) as PlainObj\n  const store = wrap(raw) as T\n\n  const setStore = (...args: unknown[]): void => {\n    if (args.length < 2) throw new Error('[davaux] setStore requires a path and a value')\n    setPath(raw, args.slice(0, -1) as (string | number)[], args[args.length - 1])\n  }\n\n  return [store, setStore as unknown as SetStoreFn<T>]\n}\n"],
+  "mappings": "AAAA,SAAS,YAAY,iBAAiB;AAMtC,MAAM,UAAU,oBAAI,QAAuD;AAE3E,SAAS,QAAQ,QAAgB,KAAuC;AACtE,MAAI,SAAS,QAAQ,IAAI,MAAM;AAC/B,MAAI,CAAC,QAAQ;AACX,aAAS,oBAAI,IAAI;AACjB,YAAQ,IAAI,QAAQ,MAAM;AAAA,EAC5B;AACA,MAAI,IAAI,OAAO,IAAI,GAAG;AACtB,MAAI,CAAC,GAAG;AACN,QAAI,oBAAI,IAAI;AACZ,WAAO,IAAI,KAAK,CAAC;AAAA,EACnB;AACA,SAAO;AACT;AAEA,SAAS,KAAuB,KAAW;AACzC,SAAO,IAAI,MAAM,KAAK;AAAA,IACpB,IAAI,QAAQ,KAAK,UAAU;AACzB,YAAM,MAAM,QAAQ,IAAI,QAAQ,KAAK,QAAQ;AAE7C,UAAI,OAAO,QAAQ,YAAY,OAAO,QAAQ,YAAY;AACxD,kBAAU,QAAQ,QAAQ,GAAG,CAAC;AAAA,MAChC;AACA,UAAI,QAAQ,QAAQ,OAAO,QAAQ,SAAU,QAAO,KAAK,GAAa;AACtE,aAAO;AAAA,IACT;AAAA,IACA,MAAM;AACJ,YAAM,IAAI,MAAM,6DAAwD;AAAA,IAC1E;AAAA,IACA,iBAAiB;AACf,YAAM,IAAI,MAAM,6DAAwD;AAAA,IAC1E;AAAA,EACF,CAAC;AACH;AAEA,SAAS,QAAQ,KAAe,MAA2B,OAAsB;AAC/E,QAAM,CAAC,MAAM,GAAG,IAAI,IAAI;AACxB,QAAM,MAAM,OAAO,IAAI;AACvB,MAAI,KAAK,WAAW,GAAG;AACrB,UAAM,OAAO,IAAI,GAAG;AACpB,UAAM,OAAO,OAAO,UAAU,aAAc,MAAkC,IAAI,IAAI;AACtF,QAAI,OAAO,GAAG,MAAM,IAAI,EAAG;AAC3B,QAAI,GAAG,IAAI;AACX,eAAW,QAAQ,KAAK,GAAG,CAAC;AAAA,EAC9B,OAAO;AACL,UAAM,QAAQ,IAAI,GAAG;AACrB,QAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;AAC/C,YAAM,IAAI,MAAM,uBAAuB,GAAG,oBAAoB;AAAA,IAChE;AACA,YAAQ,OAAmB,MAAM,KAAK;AAAA,EACxC;AACF;AAyCO,SAAS,YAA8B,MAA8C;AAC1F,QAAM,MAAM,gBAAgB,IAAI;AAChC,QAAM,QAAQ,KAAK,GAAG;AAEtB,QAAM,WAAW,IAAI,SAA0B;AAC7C,QAAI,KAAK,SAAS,EAAG,OAAM,IAAI,MAAM,+CAA+C;AACpF,YAAQ,KAAK,KAAK,MAAM,GAAG,EAAE,GAA0B,KAAK,KAAK,SAAS,CAAC,CAAC;AAAA,EAC9E;AAEA,SAAO,CAAC,OAAO,QAAoC;AACrD;",
+  "names": []
+}

package/dist/client/useHead.d.ts

@@ -0,0 +1,28 @@
+export interface MetaDescriptor {
+    /** `<meta name="...">` value. Mutually exclusive with `property`. */
+    name?: string;
+    /** `<meta property="...">` value (Open Graph, etc.). Mutually exclusive with `name`. */
+    property?: string;
+    content: string | (() => string);
+}
+export interface UseHeadOptions {
+    /** Reactive document title. A function re-runs whenever its signals change. */
+    title?: string | (() => string);
+    /** Meta tags to add/update in `<head>`. Existing tags are updated in place. */
+    meta?: MetaDescriptor[];
+}
+/**
+ * Update `document.title` and `<meta>` tags from inside a client island.
+ * String values are set once; function values are wrapped in `createEffect`
+ * and update reactively whenever their signals change.
+ *
+ * No-op on the server — use `ctx.head` from the page handler for initial SSR values.
+ *
+ * @example
+ * useHead({
+ *   title: () => `${article()} — My Site`,
+ *   meta: [{ name: 'description', content: () => article().summary }],
+ * })
+ */
+export declare function useHead(options: UseHeadOptions): void;
+//# sourceMappingURL=useHead.d.ts.map

package/dist/client/useHead.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHead.d.ts","sourceRoot":"","sources":["../../client/useHead.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc;IAC7B,qEAAqE;IACrE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,wFAAwF;IACxF,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,CAAA;CACjC;AAED,MAAM,WAAW,cAAc;IAC7B,+EAA+E;IAC/E,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,CAAA;IAC/B,+EAA+E;IAC/E,IAAI,CAAC,EAAE,cAAc,EAAE,CAAA;CACxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAgCrD"}

package/dist/client/useHead.js

@@ -0,0 +1,33 @@
+import { createEffect, onCleanup } from "./signal.js";
+function useHead(options) {
+  if (typeof document === "undefined") return;
+  if (options.title !== void 0) {
+    const title = options.title;
+    createEffect(() => {
+      document.title = typeof title === "function" ? title() : title;
+    });
+  }
+  for (const descriptor of options.meta ?? []) {
+    const attr = descriptor.name !== void 0 ? "name" : "property";
+    const attrValue = descriptor.name ?? descriptor.property;
+    let el = document.querySelector(`meta[${attr}="${attrValue}"]`);
+    const created = !el;
+    if (!el) {
+      el = document.createElement("meta");
+      el.setAttribute(attr, attrValue);
+      document.head.appendChild(el);
+    }
+    const metaEl = el;
+    const content = descriptor.content;
+    createEffect(() => {
+      metaEl.content = typeof content === "function" ? content() : content;
+    });
+    if (created) {
+      onCleanup(() => metaEl.remove());
+    }
+  }
+}
+export {
+  useHead
+};
+//# sourceMappingURL=useHead.js.map

package/dist/client/useHead.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../client/useHead.ts"],
+  "sourcesContent": ["import { createEffect, onCleanup } from './signal.js'\n\nexport interface MetaDescriptor {\n  /** `<meta name=\"...\">` value. Mutually exclusive with `property`. */\n  name?: string\n  /** `<meta property=\"...\">` value (Open Graph, etc.). Mutually exclusive with `name`. */\n  property?: string\n  content: string | (() => string)\n}\n\nexport interface UseHeadOptions {\n  /** Reactive document title. A function re-runs whenever its signals change. */\n  title?: string | (() => string)\n  /** Meta tags to add/update in `<head>`. Existing tags are updated in place. */\n  meta?: MetaDescriptor[]\n}\n\n/**\n * Update `document.title` and `<meta>` tags from inside a client island.\n * String values are set once; function values are wrapped in `createEffect`\n * and update reactively whenever their signals change.\n *\n * No-op on the server \u2014 use `ctx.head` from the page handler for initial SSR values.\n *\n * @example\n * useHead({\n *   title: () => `${article()} \u2014 My Site`,\n *   meta: [{ name: 'description', content: () => article().summary }],\n * })\n */\nexport function useHead(options: UseHeadOptions): void {\n  if (typeof document === 'undefined') return\n\n  if (options.title !== undefined) {\n    const title = options.title\n    createEffect(() => {\n      document.title = typeof title === 'function' ? title() : title\n    })\n  }\n\n  for (const descriptor of options.meta ?? []) {\n    const attr = descriptor.name !== undefined ? 'name' : 'property'\n    const attrValue = (descriptor.name ?? descriptor.property) as string\n\n    let el = document.querySelector(`meta[${attr}=\"${attrValue}\"]`) as HTMLMetaElement | null\n    const created = !el\n    if (!el) {\n      el = document.createElement('meta')\n      el.setAttribute(attr, attrValue)\n      document.head.appendChild(el)\n    }\n\n    const metaEl = el\n    const content = descriptor.content\n    createEffect(() => {\n      metaEl.content = typeof content === 'function' ? content() : content\n    })\n\n    if (created) {\n      onCleanup(() => metaEl.remove())\n    }\n  }\n}\n"],
+  "mappings": "AAAA,SAAS,cAAc,iBAAiB;AA8BjC,SAAS,QAAQ,SAA+B;AACrD,MAAI,OAAO,aAAa,YAAa;AAErC,MAAI,QAAQ,UAAU,QAAW;AAC/B,UAAM,QAAQ,QAAQ;AACtB,iBAAa,MAAM;AACjB,eAAS,QAAQ,OAAO,UAAU,aAAa,MAAM,IAAI;AAAA,IAC3D,CAAC;AAAA,EACH;AAEA,aAAW,cAAc,QAAQ,QAAQ,CAAC,GAAG;AAC3C,UAAM,OAAO,WAAW,SAAS,SAAY,SAAS;AACtD,UAAM,YAAa,WAAW,QAAQ,WAAW;AAEjD,QAAI,KAAK,SAAS,cAAc,QAAQ,IAAI,KAAK,SAAS,IAAI;AAC9D,UAAM,UAAU,CAAC;AACjB,QAAI,CAAC,IAAI;AACP,WAAK,SAAS,cAAc,MAAM;AAClC,SAAG,aAAa,MAAM,SAAS;AAC/B,eAAS,KAAK,YAAY,EAAE;AAAA,IAC9B;AAEA,UAAM,SAAS;AACf,UAAM,UAAU,WAAW;AAC3B,iBAAa,MAAM;AACjB,aAAO,UAAU,OAAO,YAAY,aAAa,QAAQ,IAAI;AAAA,IAC/D,CAAC;AAED,QAAI,SAAS;AACX,gBAAU,MAAM,OAAO,OAAO,CAAC;AAAA,IACjC;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/config.d.ts

@@ -0,0 +1,182 @@
+import type { Plugin } from 'esbuild';
+import type { RouteType } from './types.js';
+/**
+ * A Davaux plugin — extends the framework with new route file types and/or
+ * esbuild transforms. Implement this interface and return it from a factory
+ * function, then pass it to `plugins` in `davaux.config.ts`.
+ *
+ * @example
+ * // packages/my-plugin/src/index.ts
+ * import type { DavauxPlugin } from 'davaux/config'
+ * export function myPlugin(): DavauxPlugin {
+ *   return {
+ *     name: 'my-plugin',
+ *     esbuild: [myEsbuildPlugin()],
+ *     scanner: { suffixes: [['.page.myext', 'page']] },
+ *   }
+ * }
+ */
+export interface DavauxPlugin {
+    name: string;
+    /** esbuild plugins contributed to every build context (server routes, islands, client) */
+    esbuild?: Plugin[];
+    /** Additional route file suffixes the scanner should recognize */
+    scanner?: {
+        suffixes: [suffix: string, type: RouteType][];
+    };
+}
+/** Collect esbuild plugins from an array of DavauxPlugins. */
+export declare function collectEsbuildPlugins(plugins?: DavauxPlugin[]): Plugin[];
+/** Collect scanner suffix entries from an array of DavauxPlugins. */
+export declare function collectScannerSuffixes(plugins?: DavauxPlugin[]): [string, RouteType][];
+export interface EditorConfig {
+    /**
+     * Opt-in to the visual editor and inspector overlay.
+     * Must be explicitly set to `true` — disabled by default so the editor
+     * endpoints and inspector script are never exposed unless intended.
+     */
+    enabled?: boolean;
+    /** Floating inspector/editor badge options. */
+    badge?: {
+        /** Corner of the viewport where the badge appears. Default: `'bottom-right'` */
+        position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+        /** Custom label text shown on the badge. Default: `'Inspector'` */
+        label?: string;
+    };
+    /**
+     * Force a specific colour scheme for the editor UI instead of auto-detecting
+     * from the inspected page's theme attribute.
+     */
+    theme?: 'auto' | 'dark' | 'light';
+    /**
+     * Raw CSS string injected into the editor frame's `<style>` tag.
+     * Use this to override colours, hide elements, or adjust layout.
+     */
+    css?: string;
+    /**
+     * Path to a CSS file (relative to the project root) whose contents are
+     * injected into the editor frame. Merged with `css` if both are provided.
+     * The file is re-read on each request in dev mode, so changes apply without a restart.
+     */
+    cssFile?: string;
+}
+export interface DavauxConfig {
+    /** Server defaults for `davaux dev`, `davaux start`, and `davaux preview`. CLI flags (--port, --hostname) take priority over these. */
+    server?: {
+        port?: number;
+        hostname?: string;
+    };
+    /**
+     * Import path aliases, using the same glob syntax as `tsconfig.json` `paths`.
+     * Each entry is forwarded to esbuild `alias` in every build context so TypeScript
+     * and the bundler stay in sync without any extra plugin.
+     *
+     * @example
+     * import { defineConfig } from 'davaux/config'
+     * export default defineConfig({
+     *   paths: { '@/*': './src/*' },
+     * })
+     */
+    paths?: Record<string, string>;
+    /**
+     * Davaux plugins — each plugin can contribute esbuild transforms and/or
+     * register new route file extensions with the scanner.
+     *
+     * @example
+     * import { defineConfig } from 'davaux/config'
+     * import { markdown } from '@davaux/markdown'
+     * export default defineConfig({
+     *   plugins: [markdown()],
+     * })
+     */
+    plugins?: DavauxPlugin[];
+    /**
+     * Additional packages to exclude from esbuild bundling. Useful for packages
+     * that use native bindings or CJS `require()` that cannot be bundled into ESM.
+     * Each entry is added to the esbuild `external` list alongside `node:*` and `davaux`.
+     *
+     * @example
+     * import { defineConfig } from 'davaux/config'
+     * export default defineConfig({
+     *   external: ['@libsql/client', 'libsql'],
+     * })
+     */
+    external?: string[];
+    /** Visual editor and inspector overlay configuration. Disabled by default — set `enabled: true` to opt in. */
+    editor?: EditorConfig;
+    /**
+     * OML (Object Markup Language) options. OML is the intermediate representation
+     * used by the visual editor and production page caching.
+     */
+    oml?: {
+        /**
+         * Control which routes use OML tree construction and result caching in production.
+         * By default no routes are cached — this must be explicitly configured.
+         *
+         * Use `include` for apps that are mostly dynamic with a few cacheable routes,
+         * or `exclude` for apps that are mostly static with a few dynamic routes.
+         * Routes not covered by the cache config use the string renderer directly in
+         * production — no OML tree is built and no result is stored.
+         *
+         * @example
+         * // Whitelist — only these routes are cached
+         * oml: { cache: { include: ['/', '/blog/:slug', '/docs/*'] } }
+         *
+         * // Blacklist — all routes cached except these
+         * oml: { cache: { exclude: ['/dashboard', '/account/*'] } }
+         */
+        cache?: OmlCacheConfig;
+    };
+    /** Options that only apply to `davaux static` (static site generation). */
+    ssg?: {
+        /**
+         * Override the default `out/` output directory.
+         * The `--out` CLI flag takes priority over this value.
+         */
+        outDir?: string;
+        /**
+         * Trailing slash behaviour for generated output files.
+         * - `'always'` (default) — `/about` → `out/about/index.html` (served as `/about/`)
+         * - `'never'` — `/about` → `out/about.html` (served as `/about`)
+         */
+        trailingSlash?: 'always' | 'never';
+        /**
+         * Path prefix for subdirectory deployments (e.g. `'/docs'` for GitHub Pages
+         * at `user.github.io/my-project/`). Prepended to all injected `/_davaux/*`
+         * script and stylesheet URLs in the generated HTML.
+         */
+        basePath?: string;
+        /**
+         * Generate a `404.html` at the root of `outDir` for static hosts
+         * (Netlify, GitHub Pages) that serve it on unmatched paths.
+         * Defaults to `true` when an `_error.tsx` exists in the routes directory.
+         */
+        notFound?: boolean;
+        /**
+         * Auto-generate a `sitemap.xml` from all rendered routes.
+         * Pass `{ baseUrl: 'https://example.com' }` to enable.
+         * Pass `false` to explicitly disable.
+         */
+        sitemap?: false | {
+            baseUrl: string;
+        };
+    };
+}
+/**
+ * Convert tsconfig-style `paths` glob entries to esbuild `alias` entries.
+ * `'@/*': './src/*'` → `'@': './src'`
+ */
+export declare function pathsToAlias(paths: Record<string, string>): Record<string, string>;
+/**
+ * Controls which routes use OML tree construction and caching in production.
+ * Use `include` to whitelist specific URL patterns, or `exclude` to blacklist them.
+ * Patterns support `:param` (single dynamic segment) and `*` (any characters).
+ */
+export type OmlCacheConfig = {
+    include: string[];
+} | {
+    exclude: string[];
+};
+/** Wraps a config object for TypeScript inference — returns it unchanged. */
+export declare function defineConfig(config: DavauxConfig): DavauxConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AACrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAI3C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,0FAA0F;IAC1F,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,kEAAkE;IAClE,OAAO,CAAC,EAAE;QACR,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,CAAA;KAC9C,CAAA;CACF;AAED,8DAA8D;AAC9D,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,YAAY,EAAO,GAAG,MAAM,EAAE,CAE5E;AAED,qEAAqE;AACrE,wBAAgB,sBAAsB,CAAC,OAAO,GAAE,YAAY,EAAO,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,EAAE,CAE1F;AAID,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,+CAA+C;IAC/C,KAAK,CAAC,EAAE;QACN,gFAAgF;QAChF,QAAQ,CAAC,EAAE,cAAc,GAAG,aAAa,GAAG,WAAW,GAAG,UAAU,CAAA;QACpE,mEAAmE;QACnE,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,CAAA;IACD;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;IACjC;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,uIAAuI;IACvI,MAAM,CAAC,EAAE;QACP,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,QAAQ,CAAC,EAAE,MAAM,CAAA;KAClB,CAAA;IACD;;;;;;;;;;OAUG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,EAAE,YAAY,EAAE,CAAA;IACxB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,8GAA8G;IAC9G,MAAM,CAAC,EAAE,YAAY,CAAA;IACrB;;;OAGG;IACH,GAAG,CAAC,EAAE;QACJ;;;;;;;;;;;;;;;WAeG;QACH,KAAK,CAAC,EAAE,cAAc,CAAA;KACvB,CAAA;IACD,2EAA2E;IAC3E,GAAG,CAAC,EAAE;QACJ;;;WAGG;QACH,MAAM,CAAC,EAAE,MAAM,CAAA;QACf;;;;WAIG;QACH,aAAa,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAA;QAClC;;;;WAIG;QACH,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB;;;;WAIG;QACH,QAAQ,CAAC,EAAE,OAAO,CAAA;QAClB;;;;WAIG;QACH,OAAO,CAAC,EAAE,KAAK,GAAG;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE,CAAA;KACtC,CAAA;CACF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAIlF;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AAE1E,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAE/D"}

package/dist/config.js

@@ -0,0 +1,21 @@
+function collectEsbuildPlugins(plugins = []) {
+  return plugins.flatMap((p) => p.esbuild ?? []);
+}
+function collectScannerSuffixes(plugins = []) {
+  return plugins.flatMap((p) => p.scanner?.suffixes ?? []);
+}
+function pathsToAlias(paths) {
+  return Object.fromEntries(
+    Object.entries(paths).map(([k, v]) => [k.replace(/\/\*$/, ""), v.replace(/\/\*$/, "")])
+  );
+}
+function defineConfig(config) {
+  return config;
+}
+export {
+  collectEsbuildPlugins,
+  collectScannerSuffixes,
+  defineConfig,
+  pathsToAlias
+};
+//# sourceMappingURL=config.js.map