@fluixi/reactive 1.0.0-alpha.83 → 1.0.0-alpha.84

package/dist/lib/signal/index.cjs

@@ -1 +1,1275 @@
-"use strict";var de=Object.defineProperty;var Rn=Object.getOwnPropertyDescriptor;var kn=Object.getOwnPropertyNames;var On=Object.prototype.hasOwnProperty;var _n=(e,n)=>{for(var r in n)de(e,r,{get:n[r],enumerable:!0})},Cn=(e,n,r,t)=>{if(n&&typeof n=="object"||typeof n=="function")for(let s of kn(n))!On.call(e,s)&&s!==r&&de(e,s,{get:()=>n[s],enumerable:!(t=Rn(n,s))||t.enumerable});return e};var An=e=>Cn(de({},"__esModule",{value:!0}),e);var Jn={};_n(Jn,{$PROXY:()=>$n,$SIGNAL:()=>zn,Signal:()=>bn,SuspenseContext:()=>ce,__DEV__:()=>re,batch:()=>R,createChildOwner:()=>je,createComputed:()=>Xe,createContext:()=>N,createDebounce:()=>pn,createDebouncedResource:()=>vn,createDebouncedSignal:()=>Re,createDeferred:()=>fn,createEffect:()=>S,createErrorBoundary:()=>wn,createMemo:()=>x,createRenderEffect:()=>Qe,createResource:()=>B,createRoot:()=>A,createSelector:()=>ln,createSignal:()=>f,createSuspenseBoundary:()=>mn,disposeScope:()=>Ve,effect:()=>Qn,flush:()=>Ze,getOwner:()=>z,getServerData:()=>se,indexArray:()=>jn,isComponent:()=>tn,isMemo:()=>nn,isOwnerDisposed:()=>He,isProvider:()=>sn,isResource:()=>rn,isSignal:()=>te,isSuspense:()=>on,keyArray:()=>Fn,makeArrayFlat:()=>Te,mapArray:()=>Bn,memo:()=>Xn,nextResourceId:()=>ie,observeReactiveNodes:()=>le,on:()=>en,onCleanup:()=>m,provide:()=>M,provideErrorBoundary:()=>xn,provideSuspense:()=>yn,readChildren:()=>hn,reportReactiveBinding:()=>Ie,reportReactiveContext:()=>P,reportReactiveContextCreated:()=>J,reportReactiveDirective:()=>Ne,reportReactiveProps:()=>qe,reportResourceData:()=>ue,resource:()=>gn,runWithOwner:()=>U,setOwner:()=>he,setResourceDataSink:()=>dn,setResourceIdSource:()=>cn,setResourceTracker:()=>un,setServerDataGetter:()=>an,signal:()=>Yn,startTransition:()=>ye,trackResourcePromise:()=>oe,untrack:()=>b,useContext:()=>Le,useTransition:()=>Je});module.exports=An(Jn);var En="__fluixi_signal_next_state__",Dn=e=>{typeof queueMicrotask=="function"?queueMicrotask(e):Promise.resolve().then(e)},o=globalThis[En]??={consumer:null,untracked:!1,owner:null,queue:[],scheduled:!1,flushing:!1,batchDepth:0,hostSchedule:Dn,onSuspend:null,onError:null,observer:null};var _e="1.0.0-alpha.83";function le(e){return o.observer=e,()=>{o.observer===e&&(o.observer=null)}}var y=[],Pn;function V(e){let n=o.observer;n&&n.created(e.parents===void 0?{...e,parents:y,origin:e.origin??Pn}:e)}function Ae(e){return o.observer?(y.push(e),!0):!1}function Ee(){y.pop()}function De(e){o.observer?.ran?.(e)}function Pe(e,n){o.observer?.wrote?.(e,n)}function Ie(e,n,r,t){let s=o.observer;!s?.bound||!y.length||s.bound(y[y.length-1],e,n,r,t)}function qe(e){let n=o.observer;!n?.props||!y.length||!e||n.props(y[y.length-1],e)}function Ne(e,n,r,t){let s=o.observer;!s?.directive||!y.length||s.directive(y[y.length-1],e,n,r,t)}function J(e){o.observer?.contextCreated?.(e)}function P(e,n,r){let t=o.observer;!t?.context||!y.length||t.context(y[y.length-1],e,n,r)}function H(e){o.observer?.disposed?.(e)}var In="__FLUIXI_DEVTOOLS_HOOK__",Ce=globalThis[In];if(typeof Ce?.inject=="function")try{Ce.inject({observeReactiveNodes:le,version:_e})}catch{}function fe(){return o.observer!=null}var Me=0,Ue=1,L=2,Z=class{constructor(){this.observers=null;this.watchers=null;this.version=0}updateIfNecessary(){}track(){if(o.untracked)return;let n=o.consumer;n&&((this.observers??=new Set).add(n),(n.sources??=new Set).add(this))}},I=class extends Z{constructor(n,r){super(),this._value=n,this._equals=r?.equals===!1?()=>!1:r?.equals??Object.is}get(){return this.track(),this._value}set(n){if(!this._equals(this._value,n)){if(this._value=n,this.version++,Pe(this,o.consumer),this.observers)for(let r of[...this.observers])r.markDirty(L);pe(this)}}peek(){return this._value}},O=class extends Z{constructor(r,t){super();this._threw=!1;this._initialized=!1;this.state=L;this.sources=null;this._fn=r,this._equals=t?.equals===!1?()=>!1:t?.equals??Object.is}get(){if(o.consumer===this)throw new Error("Signal.Computed cannot read itself");if(this.track(),this.updateIfNecessary(),this._threw)throw this._error;return this._value}updateIfNecessary(){if(this.state===Ue&&this.sources){for(let r of this.sources)if(r.updateIfNecessary(),this.state===L)break}(this.state===L||!this._initialized)&&this.recompute(),this.state=Me}recompute(){if(this.sources){for(let l of this.sources)l.observers?.delete(this);this.sources.clear()}let r=o.consumer,t=o.untracked,s=Ae(this);o.consumer=this,o.untracked=!1;let a,u=!1,c;try{a=this._fn()}catch(l){u=!0,c=l,a=this._value}finally{o.consumer=r,o.untracked=t,s&&Ee()}let i=!this._initialized||this._threw!==u||(u?c!==this._error:!this._equals(this._value,a));if(this._initialized=!0,this._threw=u,this._error=c,this._value=a,De(this),i){if(this.version++,this.observers)for(let l of[...this.observers])l.markDirty(L);pe(this)}}markDirty(r){if(this.state>=r)return;let t=this.state===Me;if(this.state=r,t){if(this.observers)for(let s of[...this.observers])s.markDirty(Ue);pe(this)}}peek(){if(this.updateIfNecessary(),this._threw)throw this._error;return this._value}};function pe(e){if(e.watchers)for(let n of[...e.watchers])n._notify(e)}var q=class{constructor(n){this._watched=new Set;this._pending=new Set;this._notifyFn=n}watch(...n){for(let r of n)this._watched.add(r),(r.watchers??=new Set).add(this)}unwatch(...n){for(let r of n)this._watched.delete(r),r.watchers?.delete(this),this._pending.delete(r)}getPending(){let n=[...this._pending];return this._pending.clear(),n}_notify(n){if(!this._watched.has(n)||this._pending.has(n))return;let r=this._pending.size===0;this._pending.add(n),r&&this._notifyFn()}};function W(e){if(o.untracked)return e();o.untracked=!0;try{return e()}finally{o.untracked=!1}}function Be(){return o.consumer}function Fe(e){return!!(e.observers&&e.observers.size)||!!(e.watchers&&e.watchers.size)}function je(e){let n=K(e);return e&&(e.owned??=[]).push(n),n}function Ve(e,n=!0){G(e,n)}function He(e){return!!e&&e.disposed===!0}function K(e){return{cleanups:null,owned:null,parent:e,contexts:null}}function N(e,n){let r=Symbol(n??"context");return J(r),{id:r,defaultValue:e,Provider:s=>{P(r,"provide",s.value);let a=o.owner,u=K(a);(u.contexts=new Map).set(r,s.value),a&&(a.owned??=[]).push(u),o.owner=u;try{return s.children}finally{o.owner=a}}}}function Le(e){let n=o.owner;for(;n;){if(n.contexts&&n.contexts.has(e.id)){let r=n.contexts.get(e.id);return P(e.id,"read",r),r}n=n.parent}return P(e.id,"read",e.defaultValue),e.defaultValue}function ee(e,n){let r=e;for(;r;){if(r.contexts&&r.contexts.has(n.id))return r.contexts.get(n.id);r=r.parent}return n.defaultValue}function M(e,n,r){let t=K(o.owner);(t.contexts=new Map).set(e.id,n),o.owner&&(o.owner.owned??=[]).push(t);let s=o.owner;o.owner=t;try{return r()}finally{o.owner=s}}function We(e){o.onSuspend=e}function Ge(e){return o.onSuspend?(o.onSuspend(e,o.owner),!0):!1}function Ke(e){o.onError=e}function z(){return o.owner}function he(e){let n=o.owner;return o.owner=e,n}function U(e,n){let r=o.owner;o.owner=e;try{return n()}finally{o.owner=r}}function m(e){if(o.owner){if(o.owner.disposed){e();return}(o.owner.cleanups??=[]).push(e)}}function G(e,n=!0){if(!e.disposed){if(e.owned){for(let r=e.owned.length-1;r>=0;r--)G(e.owned[r]);e.owned=null}if(e.cleanups){for(let r=e.cleanups.length-1;r>=0;r--)e.cleanups[r]();e.cleanups=null}n&&(e.disposed=!0)}}function A(e){let n=K(o.owner);o.owner&&(o.owner.owned??=[]).push(n);let r=o.owner;o.owner=n;try{return e(()=>G(n))}finally{o.owner=r}}function ze(e){o.hostSchedule=e??(n=>{Promise.resolve().then(n)})}function qn(e){e.queued||(e.queued=!0,o.queue.push(e),!o.scheduled&&o.batchDepth===0&&(o.scheduled=!0,o.hostSchedule($)))}function $(){if(o.scheduled=!1,o.flushing)return;o.flushing=!0;let e=0;try{for(;o.queue.length;){if(++e>1e5)throw new Error("[fluixi] effect flush did not settle (cycle?)");let n=o.queue;o.queue=[];for(let r of n)r.queued=!1,r.disposed||r.run()}}finally{o.flushing=!1}}function $e(){o.batchDepth===0&&$()}function me(e){o.batchDepth++;try{return e()}finally{--o.batchDepth===0&&$()}}var ve=class{constructor(n,r=!1){this.queued=!1;this.disposed=!1;this.owner=K(o.owner),o.owner&&(o.owner.cleanups??=[]).push(()=>this.dispose()),this.computed=new O(()=>{G(this.owner,!1),U(this.owner,()=>{let t=n();typeof t=="function"&&(this.owner.cleanups??=[]).push(t)})}),V({kind:"effect",node:this.computed,handle:this,internal:!r}),this.watcher=new q(()=>qn(this)),this.run(),this.watcher.watch(this.computed)}run(){if(!this.disposed){this.watcher.getPending();try{this.computed.get()}catch(n){if(n&&typeof n.then=="function"&&o.onSuspend){o.onSuspend(n,this.owner);return}if(o.onError&&o.onError(n,this.owner))return;throw n}}}dispose(){this.disposed||(this.disposed=!0,H(this.computed),this.watcher.unwatch(this.computed),G(this.owner))}};function ne(e,n=!1){let r=new ve(e,n);return()=>r.dispose()}function Nn(e){return!!e&&typeof e.then=="function"}ze(()=>{});var Ye=Symbol.for("signal"),Mn=Symbol.for("memo"),Un=Symbol.for("signal-node");function f(e,n){let r=new I(e,{equals:n?.equals}),t=(()=>r.get()),s=(a=>{let u=typeof a=="function"?a(r.peek()):a;return r.set(u),$e(),u});return Object.defineProperty(t,Ye,{value:!0,enumerable:!0}),Object.defineProperty(t,Un,{value:{get value(){return r.peek()},get version(){return r.version}},enumerable:!1}),V({kind:"signal",node:r,handle:t,name:n?.name,set:s}),fe()&&m(()=>H(r)),[t,s]}function x(e,n,r){let t=n,s=z(),a=new O(()=>U(s,()=>{try{return t=e(t)}catch(c){if(Nn(c))return Ge(c),t;throw c}}),{equals:r?.equals}),u=(()=>a.get());return Object.defineProperty(u,Ye,{value:!0,enumerable:!0}),Object.defineProperty(u,Mn,{value:!0,enumerable:!0}),V({kind:"memo",node:a,handle:u,name:r?.name}),fe()&&m(()=>H(a)),u}function S(e,n){let r=n;return ne(()=>{r=e(r)},!0)}function Xe(e,n){let r=n;ne(()=>{r=e(r)})}function Qe(e,n){let r=n;return ne(()=>{r=e(r)})}function R(e){return me(e)}function b(e){return W(e)}function ye(e){return me(e),Promise.resolve()}function Je(){return[()=>!1,ye]}function Ze(){return $(),Promise.resolve()}function en(e,n,r){let t=Array.isArray(e),s,a=r?.defer??!1;return u=>{let c=t?e.map(l=>l()):e();if(a){a=!1,s=c;return}let i=W(()=>n(c,s,u));return s=c,i}}function Bn(e,n,r){let t=[];return m(()=>{for(let s of t)s.dispose();t=[]}),x(()=>{let s=e()||[];return b(()=>{if(s.length===0){for(let i of t)i.dispose();return t=[],r?.fallback?r.fallback():[]}let a=new Map;for(let i of t)a.has(i.item)||a.set(i.item,i);let u=[],c=new Set;for(let i=0;i<s.length;i++){let l=s[i],v=a.get(l);if(v&&!c.has(v))v.setIndex(i),u.push(v),c.add(v);else{let d,p,h;A(T=>{h=T;let[E,F]=f(i,{name:"row index"});p=F,d=n(l,E)});let g={item:l,rendered:d,dispose:h,setIndex:p};u.push(g),c.add(g)}}for(let i of t)c.has(i)||i.dispose();return t=u,u.map(i=>i.rendered)})},void 0,{name:"mapArray"})}function Fn(e,n,r,t){let s=[],a=[];return m(()=>{for(let u of a)u.dispose();s=[],a=[]}),x(()=>{let u=e()||[];return b(()=>{if(u.length===0){for(let d of a)d.dispose();return s=[],a=[],t?.fallback?t.fallback():[]}let c=new Map;for(let d=0;d<s.length;d++)c.set(s[d],a[d]);let i=[],l=[],v=new Set;for(let d=0;d<u.length;d++){let p=n(u[d]),h=c.get(p);if(h&&!v.has(p))h.setIndex(d),i.push(h);else{let g,T,E;A(F=>{E=F;let[_,j]=f(d,{name:"row index"});T=j;let Y=x(D=>{let k=(e()||[])[_()];return k??D},u[d]);g=r(Y,_)}),i.push({rendered:g,dispose:E,setIndex:T})}l.push(p),v.add(p)}for(let[d,p]of c)v.has(d)||p.dispose();return s=l,a=i,i.map(d=>d.rendered)})},void 0,{name:"keyArray"})}function jn(e,n,r){let t=[];return m(()=>{for(let s of t)s.dispose();t=[]}),x(()=>{let s=e()||[];return b(()=>{if(s.length===0){for(let i of t)i.dispose();return t=[],r?.fallback?r.fallback():[]}let a=t.length,u=s.length;for(let i=a;i<u;i++){let l,v,d,p=s[i];A(h=>{d=h;let[g,T]=f(p);v=T,l=n(g,i)}),t.push({rendered:l,setItem:v,dispose:d})}for(let i=u;i<a;i++)t[i].dispose();u<a&&(t=t.slice(0,u));let c=Math.min(a,u);for(let i=0;i<c;i++)t[i].setItem(s[i]);return t.map(i=>i.rendered)})},void 0,{name:"indexArray"})}var Vn=typeof window>"u"?!1:window.__FLUIXI_PROD__===!0,re=typeof process>"u"?Vn:!1,Hn=Symbol.for("signal"),Ln=Symbol.for("memo"),Wn=Symbol.for("resource");function te(e){return typeof e=="function"&&e[Hn]===!0}function nn(e){return typeof e=="function"&&e[Ln]===!0}function rn(e){return typeof e=="function"&&e[Wn]===!0}function tn(e){return typeof e=="function"&&e[Symbol.for("fluixi-component")]===!0}function on(e){return typeof e=="function"&&e[Symbol.for("fluixi-suspense")]===!0}function sn(e){return typeof e=="function"&&e[Symbol.for("fluixi-provider")]===!0}function Te(e){return Array.isArray(e)?e.length===2&&e[1]===" "?Array.isArray(e[0])?Te(e[0]):(typeof e[0]=="function",e[0]):e.length===1&&typeof e[0]=="function"?e[0]:e:e}var we=null;function un(e){we=e}function oe(e){we&&we(e)}var xe=null;function an(e){xe=e}function se(e){return xe?xe(e):void 0}var be=null;function cn(e){be=e}function ie(){return be?be():void 0}var ge=null;function dn(e){ge=e}function ue(e,n){ge&&ge(e,n)}function ln(e,n=(r,t)=>r===t){let r=new Map;return S(()=>{let t=e();for(let[s,a]of r){let[u,c]=a,i=n(s,t);u()!==i&&c(i)}}),t=>{let s=r.get(t);if(!s){let[a,u]=f(!1);s=[a,u],r.set(t,s);let c=e();u(n(t,c))}return s[0]()}}function fn(e,n){let[r,t]=f(e(),n);return S(()=>{let s=e();n?.timeoutMs?setTimeout(()=>t(()=>s),n.timeoutMs):typeof requestIdleCallback=="function"?requestIdleCallback(()=>t(()=>s)):Promise.resolve().then(()=>t(()=>s))}),r}function pn(e,n){let r,t=(...s)=>{r!==void 0&&clearTimeout(r),r=setTimeout(()=>{r=void 0,e(...s)},n)};return m(()=>{r!==void 0&&clearTimeout(r)}),t}function Gn(e){return!!e&&typeof e.then=="function"}var Se=Symbol();function B(e,n,r={}){let t,s;typeof n=="function"?(t=typeof e=="function"?e:()=>e,s=n):(t=()=>!0,s=e,n&&typeof n=="object"&&(r=n));let a=r.transport===!1?void 0:ie(),u=a!==void 0?se(a):void 0,c=u!==void 0,[i,l]=f(u!==void 0?u.value:r.initialValue,{equals:!1}),[v,d]=f(void 0,{equals:!1}),[p,h]=f(u!==void 0||r.initialValue!==void 0?"ready":"unresolved",{equals:!1}),[g,T]=f(void 0,{equals:!1}),[E,F]=f(void 0,{equals:!1}),_=Se,j=!1;S(()=>{let w=t();if(E(),w===!1||w===null||w===void 0){_=Se,R(()=>{h("unresolved"),T(void 0),d(void 0)});return}let k=j;if(j=!1,_!==Se&&w===_&&!k)return;if(_=w,c){c=!1;return}let X=!1;m(()=>X=!0);let ke=b(p),Sn=b(i),Oe=ke==="ready"||ke==="refreshing";R(()=>{h(Oe?"refreshing":"pending"),d(void 0)});try{let C=s(w,{value:Sn,refetching:Oe});Gn(C)?(T(C),oe(C),C.then(Q=>{X||(a!==void 0&&ue(a,Q),R(()=>{l(()=>Q),h("ready"),T(void 0)}))},Q=>{X||R(()=>{d(Q),h("errored"),T(void 0)})})):R(()=>{l(()=>C),h("ready"),T(void 0)})}catch(C){if(X)return;R(()=>{d(C),h("errored"),T(void 0)})}});let Y=()=>{let w=p();return w==="pending"||w==="refreshing"},D=(()=>{let w=v();if(w)throw w;if(Y()){let k=g();if(k)throw k}return i()});return Object.defineProperties(D,{state:{get:p},loading:{get:Y},error:{get:v},latest:{get:i}}),Object.defineProperty(D,Symbol.for("resource"),{value:!0,enumerable:!0}),Object.defineProperty(D,Symbol.for("signal"),{value:!0,enumerable:!0}),[D,{mutate:l,refetch:()=>{j=!0,F(void 0)}}]}function Re(e,n=300){let[r,t]=f(e),[s,a]=f(e),[u,c]=f(!1),i,l=()=>{i!==void 0&&(clearTimeout(i),i=void 0)},v=()=>{l();let p=b(r);return a(()=>p),c(!1),p},d=(p=>{let h=typeof p=="function"?p(b(r)):p;return t(()=>h),c(!0),l(),i=setTimeout(v,n),h});return m(l),[s,d,{immediate:r,pending:u,flush:v,cancel:()=>{l(),c(!1)}}]}function Kn(e){return e!=null&&e!==""}function vn(e,n,r={}){let{delay:t=300,initialValue:s,shouldFetch:a=Kn}=r,[u,c,i]=Re(e,t),l=()=>a(u())?u():!1,[v,{refetch:d}]=B(l,n,s===void 0?{}:{initialValue:s});return[v,{...i,query:u,setQuery:c,refetch:d}]}function ae(e){if(typeof e=="function"&&!e.length){let n=e();return te(n)?n:ae(n)}if(Array.isArray(e)){let n=[];for(let r=0;r<e.length;r++){let t=ae(e[r]);Array.isArray(t)?n.push.apply(n,t):n.push(t)}return n}return e}function hn(e){let n=x(e);return re?x(()=>ae(n()),void 0,{name:"children"}):x(()=>ae(n()))}var ce=N();We((e,n)=>{let r=ee(n,ce);r&&(r.increment(),e.finally(()=>r.decrement()))});function mn(){let[e,n]=f(0),r=0;return{increment:()=>n(r+=1),decrement:()=>n(r-=1),inFallback:()=>e()>0}}function yn(e,n){return M(ce,e,n)}var Tn=N();Ke((e,n)=>{let r=ee(n,Tn);return r?(r.setError(e),!0):!1});function wn(){let[e,n]=f(void 0,{equals:!1});return{error:e,reset:()=>n(()=>{}),setError:t=>n(()=>t)}}function xn(e,n){return M(Tn,e,n)}var bn={State:I,Computed:O,subtle:{Watcher:q,untrack:W,currentComputed:Be,hasSinks:Fe}};var zn=Symbol.for("signal"),$n=Symbol.for("fluixi-proxy");function Yn(e,n){let[r,t]=f(e,n);return Object.assign(r,{set:t})}function Xn(e,n,r){return x(e,n,r)}function Qn(e,n){return S(e,n)}function gn(...e){let[n,r]=B(...e);return Object.assign(n,r)}
+/*! @fluixi/reactive v1.0.0-alpha.84 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/signal/index.ts
+var index_exports = {};
+__export(index_exports, {
+  $PROXY: () => $PROXY,
+  $SIGNAL: () => $SIGNAL3,
+  Signal: () => Signal,
+  SuspenseContext: () => SuspenseContext,
+  __DEV__: () => __DEV__,
+  batch: () => batch2,
+  childOwner: () => childOwner,
+  computed: () => computed,
+  context: () => context,
+  createChildOwner: () => createChildOwner,
+  createComputed: () => createComputed,
+  createContext: () => createContext,
+  createDebounce: () => createDebounce,
+  createDebouncedResource: () => createDebouncedResource,
+  createDebouncedSignal: () => createDebouncedSignal,
+  createDeferred: () => createDeferred,
+  createEffect: () => createEffect,
+  createErrorBoundary: () => createErrorBoundary,
+  createMemo: () => createMemo,
+  createRenderEffect: () => createRenderEffect,
+  createResource: () => createResource,
+  createRoot: () => createRoot,
+  createSelector: () => createSelector,
+  createSignal: () => createSignal,
+  createSuspenseBoundary: () => createSuspenseBoundary,
+  disposeScope: () => disposeScope,
+  effect: () => effect2,
+  flush: () => flush,
+  getOwner: () => getOwner,
+  getServerData: () => getServerData,
+  indexArray: () => indexArray,
+  isComponent: () => isComponent,
+  isMemo: () => isMemo,
+  isOwnerDisposed: () => isOwnerDisposed,
+  isProvider: () => isProvider,
+  isResource: () => isResource,
+  isSignal: () => isSignal,
+  isSuspense: () => isSuspense,
+  joinedVersions: () => joinedVersions,
+  keyArray: () => keyArray,
+  makeArrayFlat: () => makeArrayFlat,
+  mapArray: () => mapArray,
+  memo: () => memo,
+  nextResourceId: () => nextResourceId,
+  observeReactiveNodes: () => observeReactiveNodes,
+  on: () => on,
+  onCleanup: () => onCleanup,
+  provide: () => provide,
+  provideErrorBoundary: () => provideErrorBoundary,
+  provideSuspense: () => provideSuspense,
+  readChildren: () => readChildren,
+  renderEffect: () => renderEffect,
+  reportReactiveBinding: () => reportReactiveBinding,
+  reportReactiveContext: () => reportReactiveContext,
+  reportReactiveContextCreated: () => reportReactiveContextCreated,
+  reportReactiveDirective: () => reportReactiveDirective,
+  reportReactiveProps: () => reportReactiveProps,
+  reportResourceData: () => reportResourceData,
+  resource: () => resource,
+  root: () => root,
+  runWithOwner: () => runWithOwner,
+  setOwner: () => setOwner,
+  setResourceDataSink: () => setResourceDataSink,
+  setResourceIdSource: () => setResourceIdSource,
+  setResourceTracker: () => setResourceTracker,
+  setServerDataGetter: () => setServerDataGetter,
+  signal: () => signal,
+  startTransition: () => startTransition,
+  trackResourcePromise: () => trackResourcePromise,
+  untrack: () => untrack2,
+  useContext: () => useContext,
+  useTransition: () => useTransition
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/version.generated.ts
+var VERSION = "1.0.0-alpha.84";
+
+// src/lib/signal/graph/state.ts
+var MAJOR = VERSION.split(".")[0];
+var KEY = `__fluixi_signal_state_v${MAJOR}__`;
+var VERSIONS_KEY = `__fluixi_signal_builds_v${MAJOR}__`;
+var defaultSchedule = (run) => {
+  if (typeof queueMicrotask === "function") queueMicrotask(run);
+  else void Promise.resolve().then(run);
+};
+function defaults() {
+  return {
+    consumer: null,
+    untracked: false,
+    owner: null,
+    queue: [],
+    scheduled: false,
+    flushing: false,
+    batchDepth: 0,
+    hostSchedule: defaultSchedule,
+    onSuspend: null,
+    onError: null,
+    observer: null
+  };
+}
+var realm = globalThis;
+function backfillState(existing) {
+  const fresh = defaults();
+  const target = existing;
+  for (const field of Object.keys(fresh)) {
+    if (!(field in existing)) target[field] = fresh[field];
+  }
+  return existing;
+}
+function claim() {
+  const existing = realm[KEY];
+  return existing ? backfillState(existing) : realm[KEY] = defaults();
+}
+var G = claim();
+(realm[VERSIONS_KEY] ??= []).push(VERSION);
+function joinedVersions() {
+  return [...new Set(realm[VERSIONS_KEY] ?? [])];
+}
+
+// src/lib/signal/graph/observe.ts
+function observeReactiveNodes(next) {
+  G.observer = next;
+  return () => {
+    if (G.observer === next) G.observer = null;
+  };
+}
+var running = [];
+var origin;
+function reportReactiveNode(report) {
+  const observer = G.observer;
+  if (observer) {
+    observer.created(
+      report.parents === void 0 ? { ...report, parents: running, origin: report.origin ?? origin } : report
+    );
+  }
+}
+function enterReactiveRun(node) {
+  if (!G.observer) return false;
+  running.push(node);
+  return true;
+}
+function exitReactiveRun() {
+  running.pop();
+}
+function reportReactiveRun(node) {
+  G.observer?.ran?.(node);
+}
+function reportReactiveWrite(node, by) {
+  G.observer?.wrote?.(node, by);
+}
+function reportReactiveBinding(target, kind, name, accessor) {
+  const observer = G.observer;
+  if (!observer?.bound || !running.length) return;
+  observer.bound(running[running.length - 1], target, kind, name, accessor);
+}
+function reportReactiveProps(props) {
+  const observer = G.observer;
+  if (!observer?.props || !running.length || !props) return;
+  observer.props(running[running.length - 1], props);
+}
+function reportReactiveDirective(target, kind, name, accessor) {
+  const observer = G.observer;
+  if (!observer?.directive || !running.length) return;
+  observer.directive(running[running.length - 1], target, kind, name, accessor);
+}
+function reportReactiveContextCreated(id) {
+  G.observer?.contextCreated?.(id);
+}
+function reportReactiveContext(id, kind, value) {
+  const observer = G.observer;
+  if (!observer?.context || !running.length) return;
+  observer.context(running[running.length - 1], id, kind, value);
+}
+function reportReactiveDispose(node) {
+  G.observer?.disposed?.(node);
+}
+var HOOK = "__FLUIXI_DEVTOOLS_HOOK__";
+var hook = globalThis[HOOK];
+if (typeof hook?.inject === "function") {
+  try {
+    hook.inject({ observeReactiveNodes, version: VERSION });
+  } catch {
+  }
+}
+function isObserved() {
+  return G.observer != null;
+}
+
+// src/lib/signal/graph/core.ts
+var CLEAN = 0;
+var CHECK = 1;
+var DIRTY = 2;
+var Source = class {
+  constructor() {
+    /** Computeds, and watched leaves, that read this node. */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.observers = null;
+    /** Watchers eagerly observing this node, which is how `runtime.ts` schedules effects. */
+    this.watchers = null;
+    /** Bumped whenever this node's value actually changes (equality-gated). */
+    this.version = 0;
+  }
+  /** Settle this node so a reader sees a current value/version. Overridden by Computed. */
+  updateIfNecessary() {
+  }
+  /** Link the current consumer (if any) as an observer of this node. */
+  track() {
+    if (G.untracked) return;
+    const consumer = G.consumer;
+    if (!consumer) return;
+    (this.observers ??= /* @__PURE__ */ new Set()).add(consumer);
+    (consumer.sources ??= /* @__PURE__ */ new Set()).add(this);
+  }
+};
+var State = class extends Source {
+  constructor(value, options) {
+    super();
+    this._value = value;
+    this._equals = options?.equals === false ? () => false : options?.equals ?? Object.is;
+  }
+  get() {
+    this.track();
+    return this._value;
+  }
+  set(next) {
+    if (this._equals(this._value, next)) return;
+    this._value = next;
+    this.version++;
+    reportReactiveWrite(this, G.consumer);
+    if (this.observers) for (const o of [...this.observers]) o.markDirty(DIRTY);
+    notifyWatchers(this);
+  }
+  /** Read without subscribing (peek). */
+  peek() {
+    return this._value;
+  }
+};
+var Computed = class extends Source {
+  constructor(fn, options) {
+    super();
+    this._threw = false;
+    this._initialized = false;
+    this.state = DIRTY;
+    /** Nodes this computation read on its last run. Rebuilt on every run. */
+    this.sources = null;
+    this._fn = fn;
+    this._equals = options?.equals === false ? () => false : options?.equals ?? Object.is;
+  }
+  get() {
+    if (G.consumer === this) {
+      throw new Error("Signal.Computed cannot read itself");
+    }
+    this.track();
+    this.updateIfNecessary();
+    if (this._threw) throw this._error;
+    return this._value;
+  }
+  /** Settle, if CHECK, verify sources; if DIRTY (or never run), recompute. */
+  updateIfNecessary() {
+    if (this.state === CHECK) {
+      if (this.sources) {
+        for (const s of this.sources) {
+          s.updateIfNecessary();
+          if (this.state === DIRTY) break;
+        }
+      }
+    }
+    if (this.state === DIRTY || !this._initialized) this.recompute();
+    this.state = CLEAN;
+  }
+  recompute() {
+    if (this.sources) {
+      for (const s of this.sources) s.observers?.delete(this);
+      this.sources.clear();
+    }
+    const prevConsumer = G.consumer;
+    const prevUntracked = G.untracked;
+    const watched = enterReactiveRun(this);
+    G.consumer = this;
+    G.untracked = false;
+    let next;
+    let threw = false;
+    let err;
+    try {
+      next = this._fn();
+    } catch (e) {
+      threw = true;
+      err = e;
+      next = this._value;
+    } finally {
+      G.consumer = prevConsumer;
+      G.untracked = prevUntracked;
+      if (watched) exitReactiveRun();
+    }
+    const changed = !this._initialized || this._threw !== threw || (threw ? err !== this._error : !this._equals(this._value, next));
+    this._initialized = true;
+    this._threw = threw;
+    this._error = err;
+    this._value = next;
+    reportReactiveRun(this);
+    if (changed) {
+      this.version++;
+      if (this.observers) for (const o of [...this.observers]) o.markDirty(DIRTY);
+      notifyWatchers(this);
+    }
+  }
+  /**
+   * Push a maybe-dirty mark. A direct observer of a changed node gets DIRTY; its
+   * own observers get CHECK (recurse), stopping where already marked, so the
+   * push is O(newly-dirtied) and never recomputes.
+   */
+  markDirty(level) {
+    if (this.state >= level) return;
+    const wasClean = this.state === CLEAN;
+    this.state = level;
+    if (wasClean) {
+      if (this.observers) for (const o of [...this.observers]) o.markDirty(CHECK);
+      notifyWatchers(this);
+    }
+  }
+  peek() {
+    this.updateIfNecessary();
+    if (this._threw) throw this._error;
+    return this._value;
+  }
+};
+function notifyWatchers(node) {
+  if (!node.watchers) return;
+  for (const w of [...node.watchers]) w._notify(node);
+}
+var Watcher = class {
+  constructor(notify) {
+    this._watched = /* @__PURE__ */ new Set();
+    this._pending = /* @__PURE__ */ new Set();
+    this._notifyFn = notify;
+  }
+  watch(...nodes) {
+    for (const n of nodes) {
+      this._watched.add(n);
+      (n.watchers ??= /* @__PURE__ */ new Set()).add(this);
+    }
+  }
+  unwatch(...nodes) {
+    for (const n of nodes) {
+      this._watched.delete(n);
+      n.watchers?.delete(this);
+      this._pending.delete(n);
+    }
+  }
+  /** Watched nodes that may have changed since the last getPending(). */
+  getPending() {
+    const out = [...this._pending];
+    this._pending.clear();
+    return out;
+  }
+  /** @internal, a watched node became non-clean. Edge-triggered: notify once. */
+  _notify(node) {
+    if (!this._watched.has(node) || this._pending.has(node)) return;
+    const wasEmpty = this._pending.size === 0;
+    this._pending.add(node);
+    if (wasEmpty) this._notifyFn();
+  }
+};
+function untrack(fn) {
+  if (G.untracked) return fn();
+  G.untracked = true;
+  try {
+    return fn();
+  } finally {
+    G.untracked = false;
+  }
+}
+function currentComputed() {
+  return G.consumer;
+}
+function hasSinks(node) {
+  return !!(node.observers && node.observers.size) || !!(node.watchers && node.watchers.size);
+}
+
+// src/lib/signal/graph/runtime.ts
+function createChildOwner(parent) {
+  const owner = makeOwner(parent);
+  if (parent) (parent.owned ??= []).push(owner);
+  return owner;
+}
+function disposeScope(owner, final = true) {
+  disposeOwner(owner, final);
+}
+function isOwnerDisposed(owner) {
+  return !!owner && owner.disposed === true;
+}
+function makeOwner(parent) {
+  return { cleanups: null, owned: null, parent, contexts: null };
+}
+function createContext(defaultValue, name) {
+  const id = Symbol(name ?? "context");
+  reportReactiveContextCreated(id);
+  const Provider = (props) => {
+    reportReactiveContext(id, "provide", props.value);
+    const parent = G.owner;
+    const owner = makeOwner(parent);
+    (owner.contexts = /* @__PURE__ */ new Map()).set(id, props.value);
+    if (parent) (parent.owned ??= []).push(owner);
+    G.owner = owner;
+    try {
+      return props.children;
+    } finally {
+      G.owner = parent;
+    }
+  };
+  return { id, defaultValue, Provider };
+}
+function useContext(context2) {
+  let o = G.owner;
+  while (o) {
+    if (o.contexts && o.contexts.has(context2.id)) {
+      const found = o.contexts.get(context2.id);
+      reportReactiveContext(context2.id, "read", found);
+      return found;
+    }
+    o = o.parent;
+  }
+  reportReactiveContext(context2.id, "read", context2.defaultValue);
+  return context2.defaultValue;
+}
+function readContextFrom(owner, context2) {
+  let o = owner;
+  while (o) {
+    if (o.contexts && o.contexts.has(context2.id)) return o.contexts.get(context2.id);
+    o = o.parent;
+  }
+  return context2.defaultValue;
+}
+function provide(context2, value, fn) {
+  const owner = makeOwner(G.owner);
+  (owner.contexts = /* @__PURE__ */ new Map()).set(context2.id, value);
+  if (G.owner) (G.owner.owned ??= []).push(owner);
+  const prev = G.owner;
+  G.owner = owner;
+  try {
+    return fn();
+  } finally {
+    G.owner = prev;
+  }
+}
+function setSuspendHandler(fn) {
+  G.onSuspend = fn;
+}
+function reportSuspend(promise) {
+  if (G.onSuspend) {
+    G.onSuspend(promise, G.owner);
+    return true;
+  }
+  return false;
+}
+function setErrorHandler(fn) {
+  G.onError = fn;
+}
+function getOwner() {
+  return G.owner;
+}
+function setOwner(owner) {
+  const prev = G.owner;
+  G.owner = owner;
+  return prev;
+}
+function runWithOwner(owner, fn) {
+  const prev = G.owner;
+  G.owner = owner;
+  try {
+    return fn();
+  } finally {
+    G.owner = prev;
+  }
+}
+function onCleanup(fn) {
+  if (!G.owner) return;
+  if (G.owner.disposed) {
+    fn();
+    return;
+  }
+  (G.owner.cleanups ??= []).push(fn);
+}
+function disposeOwner(owner, final = true) {
+  if (owner.disposed) return;
+  if (owner.owned) {
+    for (let i = owner.owned.length - 1; i >= 0; i--) disposeOwner(owner.owned[i]);
+    owner.owned = null;
+  }
+  if (owner.cleanups) {
+    for (let i = owner.cleanups.length - 1; i >= 0; i--) owner.cleanups[i]();
+    owner.cleanups = null;
+  }
+  if (final) owner.disposed = true;
+}
+function createRoot(fn) {
+  const owner = makeOwner(G.owner);
+  if (G.owner) (G.owner.owned ??= []).push(owner);
+  const prev = G.owner;
+  G.owner = owner;
+  try {
+    return fn(() => disposeOwner(owner));
+  } finally {
+    G.owner = prev;
+  }
+}
+function setScheduler(fn) {
+  G.hostSchedule = fn ?? ((run) => void Promise.resolve().then(run));
+}
+function enqueue(e) {
+  if (e.queued) return;
+  e.queued = true;
+  G.queue.push(e);
+  if (!G.scheduled && G.batchDepth === 0) {
+    G.scheduled = true;
+    G.hostSchedule(flushSync);
+  }
+}
+function flushSync() {
+  G.scheduled = false;
+  if (G.flushing) return;
+  G.flushing = true;
+  let guard = 0;
+  try {
+    while (G.queue.length) {
+      if (++guard > 1e5) throw new Error("[fluixi] effect flush did not settle (cycle?)");
+      const batchOf = G.queue;
+      G.queue = [];
+      for (const e of batchOf) {
+        e.queued = false;
+        if (!e.disposed) e.run();
+      }
+    }
+  } finally {
+    G.flushing = false;
+  }
+}
+function afterWrite() {
+  if (G.batchDepth === 0) flushSync();
+}
+function batch(fn) {
+  G.batchDepth++;
+  try {
+    return fn();
+  } finally {
+    if (--G.batchDepth === 0) flushSync();
+  }
+}
+var EffectNode = class {
+  constructor(fn, report = false) {
+    this.queued = false;
+    this.disposed = false;
+    this.owner = makeOwner(G.owner);
+    if (G.owner) (G.owner.cleanups ??= []).push(() => this.dispose());
+    this.computed = new Computed(() => {
+      disposeOwner(this.owner, false);
+      runWithOwner(this.owner, () => {
+        const r = fn();
+        if (typeof r === "function") (this.owner.cleanups ??= []).push(r);
+      });
+    });
+    reportReactiveNode({ kind: "effect", node: this.computed, handle: this, internal: !report });
+    this.watcher = new Watcher(() => enqueue(this));
+    this.run();
+    this.watcher.watch(this.computed);
+  }
+  run() {
+    if (this.disposed) return;
+    this.watcher.getPending();
+    try {
+      this.computed.get();
+    } catch (e) {
+      if (e && typeof e.then === "function" && G.onSuspend) {
+        G.onSuspend(e, this.owner);
+        return;
+      }
+      if (G.onError && G.onError(e, this.owner)) return;
+      throw e;
+    }
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    reportReactiveDispose(this.computed);
+    this.watcher.unwatch(this.computed);
+    disposeOwner(this.owner);
+  }
+};
+function effect(fn, report = false) {
+  const node = new EffectNode(fn, report);
+  return () => node.dispose();
+}
+
+// src/lib/signal/graph/compat.ts
+function isThenable(v) {
+  return !!v && typeof v.then === "function";
+}
+setScheduler(() => {
+});
+var $SIGNAL = /* @__PURE__ */ Symbol.for("signal");
+var $MEMO = /* @__PURE__ */ Symbol.for("memo");
+var $NODE = /* @__PURE__ */ Symbol.for("signal-node");
+function createSignal(value, options) {
+  const state = new State(value, { equals: options?.equals });
+  const read = (() => state.get());
+  const write = ((next) => {
+    const v = typeof next === "function" ? next(state.peek()) : next;
+    state.set(v);
+    afterWrite();
+    return v;
+  });
+  Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
+  Object.defineProperty(read, $NODE, {
+    value: {
+      get value() {
+        return state.peek();
+      },
+      get version() {
+        return state.version;
+      }
+    },
+    enumerable: false
+  });
+  reportReactiveNode({
+    kind: "signal",
+    node: state,
+    handle: read,
+    name: options?.name,
+    set: write
+  });
+  if (isObserved()) onCleanup(() => reportReactiveDispose(state));
+  return [read, write];
+}
+function createMemo(fn, value, options) {
+  let prev = value;
+  const owner = getOwner();
+  const c = new Computed(
+    () => runWithOwner(owner, () => {
+      try {
+        return prev = fn(prev);
+      } catch (e) {
+        if (isThenable(e)) {
+          reportSuspend(e);
+          return prev;
+        }
+        throw e;
+      }
+    }),
+    { equals: options?.equals }
+  );
+  const read = (() => c.get());
+  Object.defineProperty(read, $SIGNAL, { value: true, enumerable: true });
+  Object.defineProperty(read, $MEMO, { value: true, enumerable: true });
+  reportReactiveNode({ kind: "memo", node: c, handle: read, name: options?.name });
+  if (isObserved()) onCleanup(() => reportReactiveDispose(c));
+  return read;
+}
+function createEffect(fn, value) {
+  let prev = value;
+  return effect(() => {
+    const r = fn(prev);
+    prev = r;
+  }, true);
+}
+function createComputed(fn, value) {
+  let prev = value;
+  effect(() => {
+    prev = fn(prev);
+  });
+}
+function createRenderEffect(fn, value) {
+  let prev = value;
+  return effect(() => {
+    prev = fn(prev);
+  });
+}
+function batch2(fn) {
+  return batch(fn);
+}
+function untrack2(fn) {
+  return untrack(fn);
+}
+function startTransition(fn) {
+  batch(fn);
+  return Promise.resolve();
+}
+function useTransition() {
+  return [() => false, startTransition];
+}
+function flush() {
+  flushSync();
+  return Promise.resolve();
+}
+function on(deps, fn, options) {
+  const isArray = Array.isArray(deps);
+  let prevValue;
+  let defer = options?.defer ?? false;
+  return (prevResult) => {
+    const value = isArray ? deps.map((d) => d()) : deps();
+    if (defer) {
+      defer = false;
+      prevValue = value;
+      return void 0;
+    }
+    const result = untrack(() => fn(value, prevValue, prevResult));
+    prevValue = value;
+    return result;
+  };
+}
+
+// src/lib/signal/list.ts
+function mapArray(list, mapFn, options) {
+  let items = [];
+  onCleanup(() => {
+    for (const e of items) e.dispose();
+    items = [];
+  });
+  return createMemo(() => {
+    const next = list() || [];
+    return untrack2(() => {
+      if (next.length === 0) {
+        for (const e of items) e.dispose();
+        items = [];
+        return options?.fallback ? options.fallback() : [];
+      }
+      const prevByItem = /* @__PURE__ */ new Map();
+      for (const e of items) if (!prevByItem.has(e.item)) prevByItem.set(e.item, e);
+      const result = [];
+      const used = /* @__PURE__ */ new Set();
+      for (let i = 0; i < next.length; i++) {
+        const value = next[i];
+        const reuse = prevByItem.get(value);
+        if (reuse && !used.has(reuse)) {
+          reuse.setIndex(i);
+          result.push(reuse);
+          used.add(reuse);
+        } else {
+          let rendered, setIndex, dispose;
+          createRoot((d) => {
+            dispose = d;
+            const [index, setIdx] = createSignal(i, { name: "row index" });
+            setIndex = setIdx;
+            rendered = mapFn(value, index);
+          });
+          const entry = { item: value, rendered, dispose, setIndex };
+          result.push(entry);
+          used.add(entry);
+        }
+      }
+      for (const e of items) if (!used.has(e)) e.dispose();
+      items = result;
+      return result.map((e) => e.rendered);
+    });
+  }, void 0, { name: "mapArray" });
+}
+function keyArray(list, keyFn, mapFn, options) {
+  let keys = [];
+  let entries = [];
+  onCleanup(() => {
+    for (const e of entries) e.dispose();
+    keys = [];
+    entries = [];
+  });
+  return createMemo(() => {
+    const next = list() || [];
+    return untrack2(() => {
+      if (next.length === 0) {
+        for (const e of entries) e.dispose();
+        keys = [];
+        entries = [];
+        return options?.fallback ? options.fallback() : [];
+      }
+      const prevByKey = /* @__PURE__ */ new Map();
+      for (let i = 0; i < keys.length; i++) prevByKey.set(keys[i], entries[i]);
+      const resultEntries = [];
+      const resultKeys = [];
+      const usedKeys = /* @__PURE__ */ new Set();
+      for (let i = 0; i < next.length; i++) {
+        const key = keyFn(next[i]);
+        const reuse = prevByKey.get(key);
+        if (reuse && !usedKeys.has(key)) {
+          reuse.setIndex(i);
+          resultEntries.push(reuse);
+        } else {
+          let rendered, setIndex, dispose;
+          createRoot((d) => {
+            dispose = d;
+            const [index, setIdx] = createSignal(i, { name: "row index" });
+            setIndex = setIdx;
+            const item = createMemo((prev) => {
+              const cur = list() || [];
+              const v = cur[index()];
+              return v !== void 0 && v !== null ? v : prev;
+            }, next[i]);
+            rendered = mapFn(item, index);
+          });
+          resultEntries.push({ rendered, dispose, setIndex });
+        }
+        resultKeys.push(key);
+        usedKeys.add(key);
+      }
+      for (const [key, e] of prevByKey) if (!usedKeys.has(key)) e.dispose();
+      keys = resultKeys;
+      entries = resultEntries;
+      return resultEntries.map((e) => e.rendered);
+    });
+  }, void 0, { name: "keyArray" });
+}
+function indexArray(list, mapFn, options) {
+  let slots = [];
+  onCleanup(() => {
+    for (const s of slots) s.dispose();
+    slots = [];
+  });
+  return createMemo(() => {
+    const next = list() || [];
+    return untrack2(() => {
+      if (next.length === 0) {
+        for (const s of slots) s.dispose();
+        slots = [];
+        return options?.fallback ? options.fallback() : [];
+      }
+      const prevLen = slots.length;
+      const nextLen = next.length;
+      for (let i = prevLen; i < nextLen; i++) {
+        let rendered, setItem, dispose;
+        const value = next[i];
+        createRoot((d) => {
+          dispose = d;
+          const [item, setVal] = createSignal(value);
+          setItem = setVal;
+          rendered = mapFn(item, i);
+        });
+        slots.push({ rendered, setItem, dispose });
+      }
+      for (let i = nextLen; i < prevLen; i++) slots[i].dispose();
+      if (nextLen < prevLen) slots = slots.slice(0, nextLen);
+      const survive = Math.min(prevLen, nextLen);
+      for (let i = 0; i < survive; i++) slots[i].setItem(next[i]);
+      return slots.map((s) => s.rendered);
+    });
+  }, void 0, { name: "indexArray" });
+}
+
+// src/lib/signal/graph/detect.ts
+var __BROWSER_PROD__ = typeof window === "undefined" ? false : window.__FLUIXI_PROD__ === true;
+var __DEV__ = typeof process === "undefined" ? __BROWSER_PROD__ : false;
+var $SIGNAL2 = /* @__PURE__ */ Symbol.for("signal");
+var $MEMO2 = /* @__PURE__ */ Symbol.for("memo");
+var $RESOURCE = /* @__PURE__ */ Symbol.for("resource");
+function isSignal(value) {
+  return typeof value === "function" && value[$SIGNAL2] === true;
+}
+function isMemo(value) {
+  return typeof value === "function" && value[$MEMO2] === true;
+}
+function isResource(value) {
+  return typeof value === "function" && value[$RESOURCE] === true;
+}
+function isComponent(value) {
+  return typeof value === "function" && value[/* @__PURE__ */ Symbol.for("fluixi-component")] === true;
+}
+function isSuspense(value) {
+  return typeof value === "function" && value[/* @__PURE__ */ Symbol.for("fluixi-suspense")] === true;
+}
+function isProvider(value) {
+  return typeof value === "function" && value[/* @__PURE__ */ Symbol.for("fluixi-provider")] === true;
+}
+function makeArrayFlat(values) {
+  if (!Array.isArray(values)) return values;
+  if (values.length === 2 && values[1] === " ") {
+    if (Array.isArray(values[0])) return makeArrayFlat(values[0]);
+    if (typeof values[0] === "function") return values[0];
+    return values[0];
+  }
+  if (values.length === 1 && typeof values[0] === "function") return values[0];
+  return values;
+}
+
+// src/lib/signal/graph/ssr-hooks.ts
+var _resourceTracker = null;
+function setResourceTracker(fn) {
+  _resourceTracker = fn;
+}
+function trackResourcePromise(p) {
+  if (_resourceTracker) _resourceTracker(p);
+}
+var _serverDataGetter = null;
+function setServerDataGetter(fn) {
+  _serverDataGetter = fn;
+}
+function getServerData(id) {
+  return _serverDataGetter ? _serverDataGetter(id) : void 0;
+}
+var _resourceIdSource = null;
+function setResourceIdSource(fn) {
+  _resourceIdSource = fn;
+}
+function nextResourceId() {
+  return _resourceIdSource ? _resourceIdSource() : void 0;
+}
+var _resourceDataSink = null;
+function setResourceDataSink(fn) {
+  _resourceDataSink = fn;
+}
+function reportResourceData(id, value) {
+  if (_resourceDataSink) _resourceDataSink(id, value);
+}
+
+// src/lib/signal/graph/derived.ts
+function createSelector(source, fn = (k, v) => k === v) {
+  const map = /* @__PURE__ */ new Map();
+  createEffect(() => {
+    const value = source();
+    for (const [key, signal2] of map) {
+      const [get, set] = signal2;
+      const match = fn(key, value);
+      if (get() !== match) set(match);
+    }
+  });
+  return (key) => {
+    let signal2 = map.get(key);
+    if (!signal2) {
+      const [get, set] = createSignal(false);
+      signal2 = [get, set];
+      map.set(key, signal2);
+      const value = source();
+      set(fn(key, value));
+    }
+    return signal2[0]();
+  };
+}
+function createDeferred(source, options) {
+  const [delayed, setDelayed] = createSignal(source(), options);
+  createEffect(() => {
+    const v = source();
+    if (options?.timeoutMs) setTimeout(() => setDelayed(() => v), options.timeoutMs);
+    else if (typeof requestIdleCallback === "function")
+      requestIdleCallback(() => setDelayed(() => v));
+    else Promise.resolve().then(() => setDelayed(() => v));
+  });
+  return delayed;
+}
+function createDebounce(fn, delay) {
+  let timer;
+  const debounced = (...args) => {
+    if (timer !== void 0) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = void 0;
+      fn(...args);
+    }, delay);
+  };
+  onCleanup(() => {
+    if (timer !== void 0) clearTimeout(timer);
+  });
+  return debounced;
+}
+
+// src/lib/signal/graph/resource.ts
+function isPromise(v) {
+  return !!v && typeof v.then === "function";
+}
+var UNSET = /* @__PURE__ */ Symbol();
+function createResource(source, fetcherFn, options = {}) {
+  let s;
+  let fetcher;
+  if (typeof fetcherFn === "function") {
+    s = typeof source === "function" ? source : () => source;
+    fetcher = fetcherFn;
+  } else {
+    s = () => true;
+    fetcher = source;
+    if (fetcherFn && typeof fetcherFn === "object") options = fetcherFn;
+  }
+  const ssrId = options.transport === false ? void 0 : nextResourceId();
+  const seed = ssrId !== void 0 ? getServerData(ssrId) : void 0;
+  let skipFirstFetch = seed !== void 0;
+  const [value, setValue] = createSignal(
+    seed !== void 0 ? seed.value : options.initialValue,
+    { equals: false }
+  );
+  const [error, setError] = createSignal(void 0, { equals: false });
+  const [state, setState] = createSignal(
+    seed !== void 0 || options.initialValue !== void 0 ? "ready" : "unresolved",
+    { equals: false }
+  );
+  const [promise, setPromise] = createSignal(void 0, { equals: false });
+  const [track, trigger] = createSignal(void 0, { equals: false });
+  let prevKey = UNSET;
+  let manualRefetch = false;
+  createEffect(() => {
+    const val = s();
+    track();
+    if (val === false || val === null || val === void 0) {
+      prevKey = UNSET;
+      batch2(() => {
+        setState("unresolved");
+        setPromise(void 0);
+        setError(void 0);
+      });
+      return;
+    }
+    const isManual = manualRefetch;
+    manualRefetch = false;
+    if (prevKey !== UNSET && val === prevKey && !isManual) return;
+    prevKey = val;
+    if (skipFirstFetch) {
+      skipFirstFetch = false;
+      return;
+    }
+    let cancelled = false;
+    onCleanup(() => cancelled = true);
+    const currentState = untrack2(state);
+    const currentValue = untrack2(value);
+    const isRefreshing = currentState === "ready" || currentState === "refreshing";
+    batch2(() => {
+      setState(isRefreshing ? "refreshing" : "pending");
+      setError(void 0);
+    });
+    try {
+      const res = fetcher(val, { value: currentValue, refetching: isRefreshing });
+      if (isPromise(res)) {
+        setPromise(res);
+        trackResourcePromise(res);
+        res.then(
+          (v) => {
+            if (cancelled) return;
+            if (ssrId !== void 0) reportResourceData(ssrId, v);
+            batch2(() => {
+              setValue(() => v);
+              setState("ready");
+              setPromise(void 0);
+            });
+          },
+          (e) => {
+            if (cancelled) return;
+            batch2(() => {
+              setError(e);
+              setState("errored");
+              setPromise(void 0);
+            });
+          }
+        );
+      } else {
+        batch2(() => {
+          setValue(() => res);
+          setState("ready");
+          setPromise(void 0);
+        });
+      }
+    } catch (e) {
+      if (cancelled) return;
+      batch2(() => {
+        setError(e);
+        setState("errored");
+        setPromise(void 0);
+      });
+    }
+  });
+  const loading = () => {
+    const st = state();
+    return st === "pending" || st === "refreshing";
+  };
+  const resource2 = (() => {
+    const e = error();
+    if (e) throw e;
+    if (loading()) {
+      const p = promise();
+      if (p) throw p;
+    }
+    return value();
+  });
+  Object.defineProperties(resource2, {
+    state: { get: state },
+    loading: { get: loading },
+    error: { get: error },
+    latest: { get: value }
+  });
+  Object.defineProperty(resource2, /* @__PURE__ */ Symbol.for("resource"), { value: true, enumerable: true });
+  Object.defineProperty(resource2, /* @__PURE__ */ Symbol.for("signal"), { value: true, enumerable: true });
+  return [
+    resource2,
+    {
+      mutate: setValue,
+      refetch: () => {
+        manualRefetch = true;
+        trigger(void 0);
+      }
+    }
+  ];
+}
+
+// src/lib/signal/graph/debounced.ts
+function createDebouncedSignal(initial, delay = 300) {
+  const [immediate, setImmediate] = createSignal(initial);
+  const [settled, setSettled] = createSignal(initial);
+  const [pending, setPending] = createSignal(false);
+  let timer;
+  const clear = () => {
+    if (timer === void 0) return;
+    clearTimeout(timer);
+    timer = void 0;
+  };
+  const settle = () => {
+    clear();
+    const value = untrack2(immediate);
+    setSettled(() => value);
+    setPending(false);
+    return value;
+  };
+  const set = ((value) => {
+    const next = typeof value === "function" ? value(untrack2(immediate)) : value;
+    setImmediate(() => next);
+    setPending(true);
+    clear();
+    timer = setTimeout(settle, delay);
+    return next;
+  });
+  onCleanup(clear);
+  return [settled, set, { immediate, pending, flush: settle, cancel: () => {
+    clear();
+    setPending(false);
+  } }];
+}
+function meaningful(query) {
+  return query !== void 0 && query !== null && query !== "";
+}
+function createDebouncedResource(initial, fetcher, options = {}) {
+  const { delay = 300, initialValue, shouldFetch = meaningful } = options;
+  const [query, setQuery, controls] = createDebouncedSignal(initial, delay);
+  const source = () => shouldFetch(query()) ? query() : false;
+  const [resource2, { refetch }] = createResource(
+    source,
+    fetcher,
+    initialValue === void 0 ? {} : { initialValue }
+  );
+  return [resource2, { ...controls, query, setQuery, refetch }];
+}
+
+// src/lib/signal/graph/children.ts
+function resolveChildrenValue(children) {
+  if (typeof children === "function" && !children.length) {
+    const result = children();
+    if (isSignal(result)) return result;
+    return resolveChildrenValue(result);
+  }
+  if (Array.isArray(children)) {
+    const results = [];
+    for (let i = 0; i < children.length; i++) {
+      const result = resolveChildrenValue(children[i]);
+      Array.isArray(result) ? results.push.apply(results, result) : results.push(result);
+    }
+    return results;
+  }
+  return children;
+}
+function readChildren(fn) {
+  const children = createMemo(fn);
+  return __DEV__ ? createMemo(() => resolveChildrenValue(children()), void 0, { name: "children" }) : createMemo(() => resolveChildrenValue(children()));
+}
+
+// src/lib/signal/graph/suspense.ts
+var SuspenseContext = createContext();
+setSuspendHandler((promise, owner) => {
+  const boundary = readContextFrom(owner, SuspenseContext);
+  if (!boundary) return;
+  boundary.increment();
+  promise.finally(() => boundary.decrement());
+});
+function createSuspenseBoundary() {
+  const [pending, setPending] = createSignal(0);
+  let count = 0;
+  return {
+    increment: () => setPending(count += 1),
+    decrement: () => setPending(count -= 1),
+    inFallback: () => pending() > 0
+  };
+}
+function provideSuspense(boundary, fn) {
+  return provide(SuspenseContext, boundary, fn);
+}
+
+// src/lib/signal/graph/error-boundary.ts
+var ErrorContext = createContext();
+setErrorHandler((error, owner) => {
+  const boundary = readContextFrom(owner, ErrorContext);
+  if (!boundary) return false;
+  boundary.setError(error);
+  return true;
+});
+function createErrorBoundary() {
+  const [error, setError] = createSignal(void 0, { equals: false });
+  const boundary = {
+    error,
+    reset: () => setError(() => void 0),
+    setError: (e) => setError(() => e)
+  };
+  return boundary;
+}
+function provideErrorBoundary(boundary, fn) {
+  return provide(ErrorContext, boundary, fn);
+}
+
+// src/lib/signal/graph/index.ts
+var Signal = {
+  State,
+  Computed,
+  subtle: {
+    Watcher,
+    untrack,
+    currentComputed,
+    hasSinks
+  }
+};
+
+// src/lib/signal/graph/signal-next.ts
+var $SIGNAL3 = /* @__PURE__ */ Symbol.for("signal");
+var $PROXY = /* @__PURE__ */ Symbol.for("fluixi-proxy");
+
+// src/lib/signal/api.ts
+function signal(value, options) {
+  const [read, write] = createSignal(value, options);
+  return Object.assign(read, { set: write });
+}
+function memo(fn, value, options) {
+  return createMemo(fn, value, options);
+}
+function effect2(fn, value) {
+  return createEffect(fn, value);
+}
+function root(fn) {
+  return createRoot(fn);
+}
+function renderEffect(fn, value) {
+  return createRenderEffect(fn, value);
+}
+function computed(fn, value) {
+  createComputed(fn, value);
+}
+function context(defaultValue, name) {
+  return createContext(defaultValue, name);
+}
+function childOwner(parent) {
+  return createChildOwner(parent);
+}
+
+// src/lib/signal/resource-api.ts
+function resource(...args) {
+  const [read, actions] = createResource(...args);
+  return Object.assign(read, actions);
+}