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

package/dist/lib/signal/resource-api.cjs

@@ -1 +1,626 @@
-"use strict";var A=Object.defineProperty;var le=Object.getOwnPropertyDescriptor;var de=Object.getOwnPropertyNames;var fe=Object.prototype.hasOwnProperty;var pe=(e,t)=>{for(var n in t)A(e,n,{get:t[n],enumerable:!0})},he=(e,t,n,o)=>{if(t&&typeof t=="object"||typeof t=="function")for(let s of de(t))!fe.call(e,s)&&s!==n&&A(e,s,{get:()=>t[s],enumerable:!(o=le(t,s))||o.enumerable});return e};var ve=e=>he(A({},"__esModule",{value:!0}),e);var Re={};pe(Re,{resource:()=>ke});module.exports=ve(Re);var Te="__fluixi_signal_next_state__",we=e=>{typeof queueMicrotask=="function"?queueMicrotask(e):Promise.resolve().then(e)},r=globalThis[Te]??={consumer:null,untracked:!1,owner:null,queue:[],scheduled:!1,flushing:!1,batchDepth:0,hostSchedule:we,onSuspend:null,onError:null};var F=0,K=1,v=2,k=class{constructor(){this.observers=null;this.watchers=null;this.version=0}updateIfNecessary(){}track(){if(r.untracked)return;let t=r.consumer;t&&((this.observers??=new Set).add(t),(t.sources??=new Set).add(this))}},R=class extends k{constructor(t,n){super(),this._value=t,this._equals=n?.equals===!1?()=>!1:n?.equals??Object.is}get(){return this.track(),this._value}set(t){if(!this._equals(this._value,t)){if(this._value=t,this.version++,this.observers)for(let n of[...this.observers])n.markDirty(v);C(this)}}peek(){return this._value}},T=class extends k{constructor(n,o){super();this._threw=!1;this._initialized=!1;this.state=v;this.sources=null;this._fn=n,this._equals=o?.equals===!1?()=>!1:o?.equals??Object.is}get(){if(r.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===K&&this.sources){for(let n of this.sources)if(n.updateIfNecessary(),this.state===v)break}(this.state===v||!this._initialized)&&this.recompute(),this.state=F}recompute(){if(this.sources){for(let c of this.sources)c.observers?.delete(this);this.sources.clear()}let n=r.consumer,o=r.untracked;r.consumer=this,r.untracked=!1;let s,i=!1,a;try{s=this._fn()}catch(c){i=!0,a=c,s=this._value}finally{r.consumer=n,r.untracked=o}let w=!this._initialized||this._threw!==i||(i?a!==this._error:!this._equals(this._value,s));if(this._initialized=!0,this._threw=i,this._error=a,this._value=s,w){if(this.version++,this.observers)for(let c of[...this.observers])c.markDirty(v);C(this)}}markDirty(n){if(this.state>=n)return;let o=this.state===F;if(this.state=n,o){if(this.observers)for(let s of[...this.observers])s.markDirty(K);C(this)}}peek(){if(this.updateIfNecessary(),this._threw)throw this._error;return this._value}};function C(e){if(e.watchers)for(let t of[...e.watchers])t._notify(e)}var _=class{constructor(t){this._watched=new Set;this._pending=new Set;this._notifyFn=t}watch(...t){for(let n of t)this._watched.add(n),(n.watchers??=new Set).add(this)}unwatch(...t){for(let n of t)this._watched.delete(n),n.watchers?.delete(this),this._pending.delete(n)}getPending(){let t=[...this._pending];return this._pending.clear(),t}_notify(t){if(!this._watched.has(t)||this._pending.has(t))return;let n=this._pending.size===0;this._pending.add(t),n&&this._notifyFn()}};function L(e){if(r.untracked)return e();r.untracked=!0;try{return e()}finally{r.untracked=!1}}function ye(e){return{cleanups:null,owned:null,parent:e,contexts:null}}function N(e,t){let n=r.owner;r.owner=e;try{return t()}finally{r.owner=n}}function j(e){if(r.owner){if(r.owner.disposed){e();return}(r.owner.cleanups??=[]).push(e)}}function E(e,t=!0){if(!e.disposed){if(e.owned){for(let n=e.owned.length-1;n>=0;n--)E(e.owned[n]);e.owned=null}if(e.cleanups){for(let n=e.cleanups.length-1;n>=0;n--)e.cleanups[n]();e.cleanups=null}t&&(e.disposed=!0)}}function U(e){r.hostSchedule=e??(t=>{Promise.resolve().then(t)})}function me(e){e.queued||(e.queued=!0,r.queue.push(e),!r.scheduled&&r.batchDepth===0&&(r.scheduled=!0,r.hostSchedule(O)))}function O(){if(r.scheduled=!1,r.flushing)return;r.flushing=!0;let e=0;try{for(;r.queue.length;){if(++e>1e5)throw new Error("[fluixi] effect flush did not settle (cycle?)");let t=r.queue;r.queue=[];for(let n of t)n.queued=!1,n.disposed||n.run()}}finally{r.flushing=!1}}function Y(){r.batchDepth===0&&O()}function $(e){r.batchDepth++;try{return e()}finally{--r.batchDepth===0&&O()}}var I=class{constructor(t){this.queued=!1;this.disposed=!1;this.owner=ye(r.owner),r.owner&&(r.owner.cleanups??=[]).push(()=>this.dispose()),this.computed=new T(()=>{E(this.owner,!1),N(this.owner,()=>{let n=t();typeof n=="function"&&(this.owner.cleanups??=[]).push(n)})}),this.watcher=new _(()=>me(this)),this.run(),this.watcher.watch(this.computed)}run(){if(!this.disposed){this.watcher.getPending();try{this.computed.get()}catch(t){if(t&&typeof t.then=="function"&&r.onSuspend){r.onSuspend(t,this.owner);return}if(r.onError&&r.onError(t,this.owner))return;throw t}}}dispose(){this.disposed||(this.disposed=!0,this.watcher.unwatch(this.computed),E(this.owner))}};function B(e){let t=new I(e);return()=>t.dispose()}U(()=>{});var Se=Symbol.for("signal");var ge=Symbol.for("signal-node");function h(e,t){let n=new R(e,{equals:t?.equals}),o=(()=>n.get()),s=(i=>{let a=typeof i=="function"?i(n.peek()):i;return n.set(a),Y(),a});return Object.defineProperty(o,Se,{value:!0,enumerable:!0}),Object.defineProperty(o,ge,{value:{get value(){return n.peek()},get version(){return n.version}},enumerable:!1}),[o,s]}function J(e,t){let n=t;return B(()=>{n=e(n)})}function d(e){return $(e)}function V(e){return L(e)}var Q=null;function te(e){Q&&Q(e)}var X=null;function ne(e){return X?X(e):void 0}var Z=null;function re(){return Z?Z():void 0}var ee=null;function oe(e,t){ee&&ee(e,t)}function xe(e){return!!e&&typeof e.then=="function"}var M=Symbol();function se(e,t,n={}){let o,s;typeof t=="function"?(o=typeof e=="function"?e:()=>e,s=t):(o=()=>!0,s=e,t&&typeof t=="object"&&(n=t));let i=n.transport===!1?void 0:re(),a=i!==void 0?ne(i):void 0,w=a!==void 0,[c,P]=h(a!==void 0?a.value:n.initialValue,{equals:!1}),[G,y]=h(void 0,{equals:!1}),[q,f]=h(a!==void 0||n.initialValue!==void 0?"ready":"unresolved",{equals:!1}),[ie,p]=h(void 0,{equals:!1}),[ue,ae]=h(void 0,{equals:!1}),m=M,D=!1;J(()=>{let u=o();if(ue(),u===!1||u===null||u===void 0){m=M,d(()=>{f("unresolved"),p(void 0),y(void 0)});return}let S=D;if(D=!1,m!==M&&u===m&&!S)return;if(m=u,w){w=!1;return}let g=!1;j(()=>g=!0);let z=V(q),ce=V(c),H=z==="ready"||z==="refreshing";d(()=>{f(H?"refreshing":"pending"),y(void 0)});try{let l=s(u,{value:ce,refetching:H});xe(l)?(p(l),te(l),l.then(x=>{g||(i!==void 0&&oe(i,x),d(()=>{P(()=>x),f("ready"),p(void 0)}))},x=>{g||d(()=>{y(x),f("errored"),p(void 0)})})):d(()=>{P(()=>l),f("ready"),p(void 0)})}catch(l){if(g)return;d(()=>{y(l),f("errored"),p(void 0)})}});let W=()=>{let u=q();return u==="pending"||u==="refreshing"},b=(()=>{let u=G();if(u)throw u;if(W()){let S=ie();if(S)throw S}return c()});return Object.defineProperties(b,{state:{get:q},loading:{get:W},error:{get:G},latest:{get:c}}),Object.defineProperty(b,Symbol.for("resource"),{value:!0,enumerable:!0}),Object.defineProperty(b,Symbol.for("signal"),{value:!0,enumerable:!0}),[b,{mutate:P,refetch:()=>{D=!0,ae(void 0)}}]}function ke(...e){let[t,n]=se(...e);return Object.assign(t,n)}
+"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/resource-api.ts
+var resource_api_exports = {};
+__export(resource_api_exports, {
+  resource: () => resource
+});
+module.exports = __toCommonJS(resource_api_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);
+
+// 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 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;
+  }
+}
+
+// src/lib/signal/graph/runtime.ts
+function makeOwner(parent) {
+  return { cleanups: null, owned: null, parent, contexts: null };
+}
+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 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
+setScheduler(() => {
+});
+var $SIGNAL = /* @__PURE__ */ Symbol.for("signal");
+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 createEffect(fn, value) {
+  let prev = value;
+  return effect(() => {
+    const r = fn(prev);
+    prev = r;
+  }, true);
+}
+function batch2(fn) {
+  return batch(fn);
+}
+function untrack2(fn) {
+  return untrack(fn);
+}
+
+// src/lib/signal/graph/ssr-hooks.ts
+var _resourceTracker = null;
+function trackResourcePromise(p) {
+  if (_resourceTracker) _resourceTracker(p);
+}
+var _serverDataGetter = null;
+function getServerData(id) {
+  return _serverDataGetter ? _serverDataGetter(id) : void 0;
+}
+var _resourceIdSource = null;
+function nextResourceId() {
+  return _resourceIdSource ? _resourceIdSource() : void 0;
+}
+var _resourceDataSink = null;
+function reportResourceData(id, value) {
+  if (_resourceDataSink) _resourceDataSink(id, value);
+}
+
+// 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/resource-api.ts
+function resource(...args) {
+  const [read, actions] = createResource(...args);
+  return Object.assign(read, actions);
+}

package/dist/lib/signal/resource-api.d.ts

@@ -1,9 +1,9 @@
 /**
- * `resource` — `createResource` as one binding instead of a tuple.
+ * `resource`: `createResource` as one binding instead of a tuple.
  *
  *   const user = resource(userId, fetchUser);
  *
- *   user();          // the value — suspends under <Suspense>, exactly as before
+ *   user();          // the value: suspends under <Suspense>, exactly as before
  *   user.latest;     // last settled value, kept across a refetch
  *   user.loading;    // boolean
  *   user.error;
@@ -11,11 +11,11 @@
  *   user.mutate(next);
  *
  * `createResource` already hands back a callable carrying `loading`/`error`/`latest`,
- * with only the two actions split into a second tuple slot — so this mostly folds that
+ * with only the two actions split into a second tuple slot, so this mostly folds that
  * split away.
  *
- * The returned function IS the accessor `createResource` gave back, with the two actions
- * assigned onto it — so suspending, tracking and SSR seeding are untouched, and a read is
+ * The returned function is the accessor `createResource` gave back, with the two actions
+ * assigned onto it, so suspending, tracking and SSR seeding are untouched, and a read is
  * the same call it always was.
  */
 import { createResource } from './graph/resource.js';

package/dist/lib/signal/resource-api.js

@@ -1,9 +1,9 @@
 /**
- * `resource` — `createResource` as one binding instead of a tuple.
+ * `resource`: `createResource` as one binding instead of a tuple.
  *
  *   const user = resource(userId, fetchUser);
  *
- *   user();          // the value — suspends under <Suspense>, exactly as before
+ *   user();          // the value: suspends under <Suspense>, exactly as before
  *   user.latest;     // last settled value, kept across a refetch
  *   user.loading;    // boolean
  *   user.error;
@@ -11,11 +11,11 @@
  *   user.mutate(next);
  *
  * `createResource` already hands back a callable carrying `loading`/`error`/`latest`,
- * with only the two actions split into a second tuple slot — so this mostly folds that
+ * with only the two actions split into a second tuple slot, so this mostly folds that
  * split away.
  *
- * The returned function IS the accessor `createResource` gave back, with the two actions
- * assigned onto it — so suspending, tracking and SSR seeding are untouched, and a read is
+ * The returned function is the accessor `createResource` gave back, with the two actions
+ * assigned onto it, so suspending, tracking and SSR seeding are untouched, and a read is
  * the same call it always was.
  */
 import { createResource } from './graph/resource.js';