@streetui/state 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 StreetUI contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,167 @@
+# @streetui/state
+
+StreetUI's reactive core: signals, derived values, effects, batching, stores —
+and `resource()`, the framework-native primitive for async data.
+
+This document focuses on `resource()` and its error-handling companion,
+`errorBoundary` (which lives in `@streetui/dsl` because it is a DSL block). For
+the signal primitives (`signal`, `derived`, `effect`, `batch`) see the inline
+docs in `src/signal.ts`.
+
+## Why a resource primitive
+
+Async data has the same three hard problems in every app: *state* (is it
+loading, did it fail, what's the value?), *races* (a slow request must not
+overwrite a newer one), and *lifecycle* (a request must stop touching the UI
+once its owner is gone). `resource()` solves all three on top of StreetUI's
+existing signals — no second reactive system, no virtual DOM, and no HTTP client
+baked in. The loader is any `Promise`-returning function, so `fetch()` works
+directly and any transport is supported.
+
+## `resource(loader, options?)`
+
+```ts
+import { resource } from '@streetui/state';
+
+const users = resource<User[]>(
+  ({ signal }) => fetch('/api/users', { signal }).then((r) => {
+    if (!r.ok) throw new Error(`HTTP ${r.status}`);
+    return r.json() as Promise<User[]>;
+  }),
+);
+```
+
+`resource<T>(...)` returns a strongly typed `Resource<T>` — `data` is
+`T | undefined`, and `error` is `unknown` (never `any`).
+
+### Loader
+
+```ts
+type ResourceLoader<T> = (ctx: { signal: AbortSignal }) => Promise<T> | T;
+```
+
+The loader receives an `AbortSignal`. Forward it to `fetch` (or any
+signal-aware operation) so in-flight work is cancelled when the resource is
+superseded or disposed. Cancellation is opt-in: ignoring the signal is fine, it
+just means the request runs to completion (its late result is discarded, never
+applied).
+
+### State (all reactive signals)
+
+| Member | Type | Meaning |
+|---|---|---|
+| `status` | `ReadonlySignal<'idle' \| 'loading' \| 'success' \| 'error'>` | Lifecycle state |
+| `data` | `ReadonlySignal<T \| undefined>` | Latest successful value |
+| `error` | `ReadonlySignal<unknown>` | Latest error (`undefined` when none) |
+| `loading` | `ReadonlySignal<boolean>` | `status === 'loading'` |
+| `isRefetching` | `ReadonlySignal<boolean>` | Loading *while* previous `data` is retained |
+
+These are read-only views over internal signals — consumers cannot `.set` them.
+Because they are ordinary signals, `when(...)`, `listOf(...)`, `derived(...)`
+and effects all work with them unchanged.
+
+**Refetching is not a separate status.** A refetch enters `status === 'loading'`
+but keeps the previous `data`; use `isRefetching` (or `loading && data !== undefined`)
+to show a "refreshing" affordance without hiding the current data.
+
+### Methods
+
+- `refetch(): Promise<void>` — start a new request. The previous `data` is
+  preserved during the reload (and on failure), so the UI never flashes empty.
+- `dispose(): void` — abort any in-flight request, drop `watch` subscriptions,
+  and permanently stop the resource from writing state. Idempotent.
+
+### Options
+
+```ts
+interface ResourceOptions {
+  immediate?: boolean;                              // default true — load on creation
+  watch?: ReadonlyArray<ReadonlySignal<unknown>>;   // explicit dependencies
+  onCleanup?: (fn: () => void) => void;             // auto-register dispose
+}
+```
+
+- **`immediate`** — set `false` to stay `'idle'` until the first `refetch()`.
+- **`watch`** — dependencies are *explicit*. When any listed signal changes, the
+  resource refetches. There is no hidden auto-tracking, so there is no way to
+  create an accidental infinite refetch loop.
+- **`onCleanup`** — pass a route's `ctx.onCleanup` (or any registrar) and
+  `dispose` is registered for you.
+
+```ts
+const query = signal('');
+const results = resource(
+  ({ signal }) => search(query.get(), signal),
+  { watch: [query], onCleanup: ctx.onCleanup },
+);
+```
+
+## Guarantees
+
+- **Race safety.** Each run gets a monotonic id; when a response arrives its id
+  is compared to the latest. An older response can never overwrite a newer one.
+- **Abort.** Every run creates an `AbortController`; superseding a run or
+  disposing the resource aborts the previous one. A self-triggered `AbortError`
+  is swallowed (it is not a real failure and is never surfaced as `error`).
+- **Lifecycle.** After `dispose()` no further state writes happen — a late
+  resolution or rejection is ignored. Wire `dispose` to the owner's cleanup and
+  the resource can never update detached DOM.
+
+## Error boundaries (`errorBoundary`, from `@streetui/dsl`)
+
+`errorBoundary` contains failures to a region of the tree instead of letting one
+failed async area take down the app:
+
+```ts
+c.errorBoundary('users', (body) => {
+  body.when(users.loading, (l) => l.text('Loading…'));
+  body.listOf('list', derived(() => users.data.get() ?? []), (u, _i, x) =>
+    x.text(u.name),
+  );
+}, {
+  source: users.error,                     // one signal or an array of them
+  onRetry: () => void users.refetch(),
+  fallback: (fb, error, retry) => {
+    fb.text(`Failed: ${(error as Error).message}`);
+    fb.button('Retry', { onClick: retry });
+  },
+});
+```
+
+Behaviour:
+
+- Enters the error state when any observed **`source`** signal becomes non-null,
+  **or** when the body builder throws synchronously while building.
+- **`retry()`** clears the local error, invokes `onRetry` (typically
+  `resource.refetch`), and re-attempts the body — without rebuilding the app.
+- Reuses the same reactive `when()` machinery, so the fallback subtree and every
+  handler/subscription inside it is torn down on removal.
+- It does **not** trap arbitrary global errors, and errors remain observable via
+  the resource's `error` signal.
+
+## SSR seeding
+
+For server rendering, `resource()` accepts a server-resolved result so the
+client does not re-fetch on hydration:
+
+```ts
+const users = resource(loadUsers, {
+  initialData: seed,        // from the SSR state island (see @streetui/renderer)
+  // initialError: err,     // or seed an error instead
+  // initialStatus: 'success',
+});
+```
+
+When any of `initialData` / `initialError` / `initialStatus` is provided, the
+resource starts in the corresponding non-`idle` state (`'success'` from
+`initialData`, `'error'` from `initialError`, or an explicit `initialStatus`)
+and **skips the automatic initial load**. It can still `refetch()` on demand;
+pass `immediate: true` if you deliberately want a client-side refetch right after
+hydration. Read the seed out of the SSR island with `readState` from
+`@streetui/renderer`.
+
+## What this is *not*
+
+`resource()` is deliberately small. It is not a caching layer, query library,
+mutation framework, global store, suspense integration, or devtools. Those are
+separate concerns that can be composed on top if and when they are needed.

package/dist/index.cjs

@@ -0,0 +1,390 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DerivedSignal: () => DerivedSignal,
+  Signal: () => Signal,
+  Store: () => Store,
+  batch: () => batch,
+  createStore: () => createStore,
+  derived: () => derived,
+  effect: () => effect,
+  isBatching: () => isBatching,
+  observerCount: () => observerCount,
+  resource: () => resource,
+  signal: () => signal,
+  signalKind: () => signalKind
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/signal.ts
+var _activeConsumer = null;
+function withConsumer(consumer, fn) {
+  const prev = _activeConsumer;
+  _activeConsumer = consumer;
+  try {
+    return fn();
+  } finally {
+    _activeConsumer = prev;
+  }
+}
+var _batchDepth = 0;
+var _pendingFlushes = /* @__PURE__ */ new Map();
+function _enqueueBatchFlush(sig, value) {
+  _pendingFlushes.set(sig, { signal: sig, value });
+}
+function _drainBatch() {
+  const flushes = [..._pendingFlushes.values()];
+  _pendingFlushes.clear();
+  for (const { signal: sig, value } of flushes) {
+    sig._flushBatch(value);
+  }
+}
+var Signal = class {
+  _value;
+  _subscribers = /* @__PURE__ */ new Set();
+  _consumers = /* @__PURE__ */ new Set();
+  constructor(initial) {
+    this._value = initial;
+  }
+  get() {
+    if (_activeConsumer !== null) {
+      this._consumers.add(_activeConsumer);
+      _activeConsumer._addSource(this);
+    }
+    return this._value;
+  }
+  peek() {
+    return this._value;
+  }
+  set(value) {
+    if (Object.is(this._value, value)) return;
+    this._value = value;
+    if (_batchDepth > 0) {
+      _enqueueBatchFlush(this, value);
+    } else {
+      this._flush(value);
+    }
+  }
+  update(fn) {
+    this.set(fn(this._value));
+  }
+  subscribe(fn) {
+    this._subscribers.add(fn);
+    return () => {
+      this._subscribers.delete(fn);
+    };
+  }
+  _removeConsumer(consumer) {
+    this._consumers.delete(consumer);
+  }
+  /**
+   * Called by the batch machinery after the batch has completed.
+   * Notifies subscribers with the final coalesced value.
+   */
+  _flushBatch(value) {
+    this._flush(value);
+  }
+  _flush(value) {
+    for (const sub of [...this._subscribers]) sub(value);
+    for (const consumer of [...this._consumers]) consumer._invalidate();
+  }
+  /**
+   * @internal DevTools inspection only. The number of live observers
+   * (direct subscribers plus derived/effect consumers). Read-only; never
+   * mutates reactive state.
+   */
+  _observerCount() {
+    return this._subscribers.size + this._consumers.size;
+  }
+};
+var DerivedSignal = class {
+  _value = void 0;
+  _dirty = true;
+  _disposed = false;
+  _fn;
+  _subscribers = /* @__PURE__ */ new Set();
+  /** All upstream sources this derived currently reads from. */
+  _sources = /* @__PURE__ */ new Set();
+  /** Downstream consumers that depend on this derived. */
+  _consumers = /* @__PURE__ */ new Set();
+  constructor(fn) {
+    this._fn = fn;
+  }
+  get() {
+    if (_activeConsumer !== null) {
+      this._consumers.add(_activeConsumer);
+      _activeConsumer._addSource(this);
+    }
+    if (this._dirty) this._recompute();
+    return this._value;
+  }
+  peek() {
+    if (this._dirty) this._recompute();
+    return this._value;
+  }
+  subscribe(fn) {
+    if (this._dirty) this._recompute();
+    this._subscribers.add(fn);
+    return () => {
+      this._subscribers.delete(fn);
+    };
+  }
+  _addSource(src) {
+    this._sources.add(src);
+  }
+  _removeConsumer(consumer) {
+    this._consumers.delete(consumer);
+  }
+  _invalidate() {
+    if (this._disposed) return;
+    this._dirty = true;
+    const newVal = this.peek();
+    for (const sub of [...this._subscribers]) sub(newVal);
+    for (const consumer of [...this._consumers]) consumer._invalidate();
+  }
+  _recompute() {
+    for (const src of this._sources) src._removeConsumer(this);
+    this._sources.clear();
+    this._value = withConsumer(this, this._fn);
+    this._dirty = false;
+  }
+  dispose() {
+    this._disposed = true;
+    for (const src of this._sources) src._removeConsumer(this);
+    this._sources.clear();
+    this._subscribers.clear();
+    this._consumers.clear();
+  }
+  /**
+   * @internal DevTools inspection only. Live observers (subscribers plus
+   * downstream consumers). Read-only.
+   */
+  _observerCount() {
+    return this._subscribers.size + this._consumers.size;
+  }
+};
+var Effect = class {
+  _fn;
+  _cleanup = void 0;
+  _disposed = false;
+  _sources = /* @__PURE__ */ new Set();
+  constructor(fn) {
+    this._fn = fn;
+    this._run();
+  }
+  _addSource(src) {
+    this._sources.add(src);
+  }
+  _invalidate() {
+    if (this._disposed) return;
+    this._run();
+  }
+  _run() {
+    for (const src of this._sources) src._removeConsumer(this);
+    this._sources.clear();
+    if (typeof this._cleanup === "function") this._cleanup();
+    const result = withConsumer(this, this._fn);
+    this._cleanup = typeof result === "function" ? result : void 0;
+  }
+  dispose() {
+    this._disposed = true;
+    for (const src of this._sources) src._removeConsumer(this);
+    this._sources.clear();
+    if (typeof this._cleanup === "function") this._cleanup();
+    this._cleanup = void 0;
+  }
+};
+function signal(initial) {
+  return new Signal(initial);
+}
+function derived(fn) {
+  return new DerivedSignal(fn);
+}
+function effect(fn) {
+  const e = new Effect(fn);
+  return () => e.dispose();
+}
+function batch(fn) {
+  _batchDepth++;
+  try {
+    fn();
+  } finally {
+    _batchDepth--;
+    if (_batchDepth === 0) {
+      _drainBatch();
+    }
+  }
+}
+function isBatching() {
+  return _batchDepth > 0;
+}
+function signalKind(source) {
+  return source instanceof DerivedSignal ? "derived" : "writable";
+}
+function observerCount(source) {
+  const maybe = source;
+  return typeof maybe._observerCount === "function" ? maybe._observerCount() : void 0;
+}
+
+// src/store.ts
+var Store = class {
+  _signals;
+  constructor(initial) {
+    const signals = {};
+    for (const key in initial) {
+      if (Object.prototype.hasOwnProperty.call(initial, key)) {
+        signals[key] = signal(initial[key]);
+      }
+    }
+    this._signals = signals;
+  }
+  get(key) {
+    const s = this._signals[key];
+    if (s === void 0) {
+      throw new Error(`Store: unknown key "${String(key)}"`);
+    }
+    return s.get();
+  }
+  set(key, value) {
+    const s = this._signals[key];
+    if (s === void 0) {
+      throw new Error(`Store: unknown key "${String(key)}"`);
+    }
+    s.set(value);
+  }
+  signal(key) {
+    const s = this._signals[key];
+    if (s === void 0) {
+      throw new Error(`Store: unknown key "${String(key)}"`);
+    }
+    return s;
+  }
+  subscribe(key, fn) {
+    return this.signal(key).subscribe(fn);
+  }
+  getSnapshot() {
+    const snap = {};
+    for (const key in this._signals) {
+      if (Object.prototype.hasOwnProperty.call(this._signals, key)) {
+        snap[key] = this._signals[key]?.peek();
+      }
+    }
+    return snap;
+  }
+};
+function createStore(initial) {
+  return new Store(initial);
+}
+
+// src/resource.ts
+function isAbortError(err) {
+  return err instanceof Error && err.name === "AbortError" || typeof DOMException !== "undefined" && err instanceof DOMException && err.name === "AbortError";
+}
+function resource(loader, options = {}) {
+  const hasInitial = options.initialData !== void 0 || options.initialError !== void 0 || options.initialStatus !== void 0;
+  const seededStatus = options.initialStatus ?? (options.initialData !== void 0 ? "success" : options.initialError !== void 0 ? "error" : "idle");
+  const status = signal(seededStatus);
+  const data = signal(options.initialData);
+  const error = signal(options.initialError);
+  const loading = derived(() => status.get() === "loading");
+  const isRefetching = derived(() => status.get() === "loading" && data.get() !== void 0);
+  let disposed = false;
+  let runId = 0;
+  let controller = null;
+  const load = async () => {
+    if (disposed) return;
+    controller?.abort();
+    const myRun = ++runId;
+    const myController = new AbortController();
+    controller = myController;
+    batch(() => {
+      error.set(void 0);
+      status.set("loading");
+    });
+    try {
+      const result = await loader({ signal: myController.signal });
+      if (disposed || myRun !== runId) return;
+      batch(() => {
+        data.set(result);
+        error.set(void 0);
+        status.set("success");
+      });
+    } catch (err) {
+      if (disposed || myRun !== runId) return;
+      if (isAbortError(err)) return;
+      batch(() => {
+        error.set(err);
+        status.set("error");
+      });
+    }
+  };
+  const refetch = () => load();
+  const watchUnsubs = [];
+  if (options.watch !== void 0) {
+    for (const dep of options.watch) {
+      watchUnsubs.push(
+        dep.subscribe(() => {
+          if (!disposed) void load();
+        })
+      );
+    }
+  }
+  const dispose = () => {
+    if (disposed) return;
+    disposed = true;
+    controller?.abort();
+    controller = null;
+    for (const unsub of watchUnsubs) unsub();
+    watchUnsubs.length = 0;
+  };
+  if (options.onCleanup !== void 0) {
+    options.onCleanup(dispose);
+  }
+  if (options.immediate === true || options.immediate !== false && !hasInitial) {
+    void load();
+  }
+  return {
+    status,
+    data,
+    error,
+    loading,
+    isRefetching,
+    refetch,
+    dispose
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DerivedSignal,
+  Signal,
+  Store,
+  batch,
+  createStore,
+  derived,
+  effect,
+  isBatching,
+  observerCount,
+  resource,
+  signal,
+  signalKind
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/signal.ts","../src/store.ts","../src/resource.ts"],"sourcesContent":["export * from './signal.js';\nexport * from './store.js';\nexport * from './resource.js';\n","/**\n * StreetUI reactive signals — framework-owned reactivity, no external libraries.\n *\n * Architecture:\n *   Signal<T>        — writable, holds a value, notifies on change\n *   DerivedSignal<T> — read-only, lazily computed from other signals\n *   effect()         — side-effect that re-runs when dependencies change\n *   batch()          — run multiple updates before notifying\n */\n\nexport type Subscriber<T> = (value: T) => void;\nexport type Unsubscribe = () => void;\n\n// ── Tracking ──────────────────────────────────────────────────────────────────\n\n/**\n * Any reactive source that can have downstream consumers attached.\n * Both Signal and DerivedSignal implement this.\n */\nexport interface ReactiveSource<T> {\n  get(): T;\n  peek(): T;\n  subscribe(fn: Subscriber<T>): Unsubscribe;\n  /** Internal: remove a downstream consumer. */\n  _removeConsumer(consumer: ReactiveConsumer): void;\n}\n\n/**\n * A downstream consumer (DerivedSignal or Effect) that can be invalidated\n * and can register itself as depending on a source.\n */\nexport interface ReactiveConsumer {\n  _invalidate(): void;\n  /** Internal: called by a source to register a dependency. */\n  _addSource(src: ReactiveSource<unknown>): void;\n}\n\n/** The active consumer being tracked during a computation. */\nlet _activeConsumer: ReactiveConsumer | null = null;\n\nfunction withConsumer<T>(consumer: ReactiveConsumer, fn: () => T): T {\n  const prev = _activeConsumer;\n  _activeConsumer = consumer;\n  try {\n    return fn();\n  } finally {\n    _activeConsumer = prev;\n  }\n}\n\n// ── Batch state (must be before Signal class so .set() can reference it) ──────\n\n/** Depth counter — batches nest; only the outermost flush propagates. */\nlet _batchDepth = 0;\n\ninterface PendingFlush {\n  signal: Signal<unknown>;\n  value: unknown;\n}\n\n/**\n * Keyed by signal identity — last-write-wins for each signal within a batch.\n * An ordered Map preserves first-seen insertion order for stable flush sequence.\n */\nconst _pendingFlushes = new Map<Signal<unknown>, PendingFlush>();\n\nfunction _enqueueBatchFlush(sig: Signal<unknown>, value: unknown): void {\n  _pendingFlushes.set(sig, { signal: sig, value });\n}\n\nfunction _drainBatch(): void {\n  const flushes = [..._pendingFlushes.values()];\n  _pendingFlushes.clear();\n  for (const { signal: sig, value } of flushes) {\n    sig._flushBatch(value);\n  }\n}\n\n// ── Signal ────────────────────────────────────────────────────────────────────\n\nexport interface ReadonlySignal<T> {\n  get(): T;\n  peek(): T;\n  subscribe(fn: Subscriber<T>): Unsubscribe;\n}\n\nexport class Signal<T> implements ReactiveSource<T>, ReadonlySignal<T> {\n  protected _value: T;\n  private readonly _subscribers: Set<Subscriber<T>> = new Set();\n  private readonly _consumers: Set<ReactiveConsumer> = new Set();\n\n  constructor(initial: T) {\n    this._value = initial;\n  }\n\n  get(): T {\n    if (_activeConsumer !== null) {\n      this._consumers.add(_activeConsumer);\n      _activeConsumer._addSource(this as ReactiveSource<unknown>);\n    }\n    return this._value;\n  }\n\n  peek(): T {\n    return this._value;\n  }\n\n  set(value: T): void {\n    if (Object.is(this._value, value)) return;\n    this._value = value;\n    if (_batchDepth > 0) {\n      // Defer notification until the batch flushes.\n      // The stored value is always the latest (last-write-wins for same signal).\n      _enqueueBatchFlush(this as unknown as Signal<unknown>, value);\n    } else {\n      this._flush(value);\n    }\n  }\n\n  update(fn: (current: T) => T): void {\n    this.set(fn(this._value));\n  }\n\n  subscribe(fn: Subscriber<T>): Unsubscribe {\n    this._subscribers.add(fn);\n    return () => { this._subscribers.delete(fn); };\n  }\n\n  _removeConsumer(consumer: ReactiveConsumer): void {\n    this._consumers.delete(consumer);\n  }\n\n  /**\n   * Called by the batch machinery after the batch has completed.\n   * Notifies subscribers with the final coalesced value.\n   */\n  _flushBatch(value: unknown): void {\n    this._flush(value as T);\n  }\n\n  private _flush(value: T): void {\n    for (const sub of [...this._subscribers]) sub(value);\n    for (const consumer of [...this._consumers]) consumer._invalidate();\n  }\n\n  /**\n   * @internal DevTools inspection only. The number of live observers\n   * (direct subscribers plus derived/effect consumers). Read-only; never\n   * mutates reactive state.\n   */\n  _observerCount(): number {\n    return this._subscribers.size + this._consumers.size;\n  }\n}\n\n// ── DerivedSignal ─────────────────────────────────────────────────────────────\n\nexport class DerivedSignal<T> implements ReactiveSource<T>, ReactiveConsumer, ReadonlySignal<T> {\n  private _value: T | undefined = undefined;\n  private _dirty = true;\n  private _disposed = false;\n  private readonly _fn: () => T;\n  private readonly _subscribers: Set<Subscriber<T>> = new Set();\n  /** All upstream sources this derived currently reads from. */\n  private readonly _sources: Set<ReactiveSource<unknown>> = new Set();\n  /** Downstream consumers that depend on this derived. */\n  private readonly _consumers: Set<ReactiveConsumer> = new Set();\n\n  constructor(fn: () => T) {\n    this._fn = fn;\n  }\n\n  get(): T {\n    // Register this derived with the outer consumer if any\n    if (_activeConsumer !== null) {\n      this._consumers.add(_activeConsumer);\n      _activeConsumer._addSource(this as ReactiveSource<unknown>);\n    }\n    if (this._dirty) this._recompute();\n    return this._value as T;\n  }\n\n  peek(): T {\n    if (this._dirty) this._recompute();\n    return this._value as T;\n  }\n\n  subscribe(fn: Subscriber<T>): Unsubscribe {\n    // Eagerly compute so sources track this derived as a consumer\n    if (this._dirty) this._recompute();\n    this._subscribers.add(fn);\n    return () => { this._subscribers.delete(fn); };\n  }\n\n  _addSource(src: ReactiveSource<unknown>): void {\n    this._sources.add(src);\n  }\n\n  _removeConsumer(consumer: ReactiveConsumer): void {\n    this._consumers.delete(consumer);\n  }\n\n  _invalidate(): void {\n    if (this._disposed) return;\n    this._dirty = true;\n    const newVal = this.peek(); // recompute\n    for (const sub of [...this._subscribers]) sub(newVal);\n    for (const consumer of [...this._consumers]) consumer._invalidate();\n  }\n\n  private _recompute(): void {\n    // Detach from all current sources before re-tracking\n    for (const src of this._sources) src._removeConsumer(this);\n    this._sources.clear();\n\n    this._value = withConsumer(this, this._fn);\n    this._dirty = false;\n  }\n\n  dispose(): void {\n    this._disposed = true;\n    for (const src of this._sources) src._removeConsumer(this);\n    this._sources.clear();\n    this._subscribers.clear();\n    this._consumers.clear();\n  }\n\n  /**\n   * @internal DevTools inspection only. Live observers (subscribers plus\n   * downstream consumers). Read-only.\n   */\n  _observerCount(): number {\n    return this._subscribers.size + this._consumers.size;\n  }\n}\n\n// ── effect ────────────────────────────────────────────────────────────────────\n\nclass Effect implements ReactiveConsumer {\n  private readonly _fn: () => void | (() => void);\n  private _cleanup: (() => void) | undefined = undefined;\n  private _disposed = false;\n  private readonly _sources: Set<ReactiveSource<unknown>> = new Set();\n\n  constructor(fn: () => void | (() => void)) {\n    this._fn = fn;\n    this._run();\n  }\n\n  _addSource(src: ReactiveSource<unknown>): void {\n    this._sources.add(src);\n  }\n\n  _invalidate(): void {\n    if (this._disposed) return;\n    this._run();\n  }\n\n  private _run(): void {\n    // Detach from all current sources before re-tracking\n    for (const src of this._sources) src._removeConsumer(this);\n    this._sources.clear();\n\n    if (typeof this._cleanup === 'function') this._cleanup();\n    const result = withConsumer(this, this._fn);\n    this._cleanup = typeof result === 'function' ? result : undefined;\n  }\n\n  dispose(): void {\n    this._disposed = true;\n    for (const src of this._sources) src._removeConsumer(this);\n    this._sources.clear();\n    if (typeof this._cleanup === 'function') this._cleanup();\n    this._cleanup = undefined;\n  }\n}\n\n// ── Public API ─────────────────────────────────────────────────────────────────\n\nexport function signal<T>(initial: T): Signal<T> {\n  return new Signal(initial);\n}\n\nexport function derived<T>(fn: () => T): DerivedSignal<T> {\n  return new DerivedSignal(fn);\n}\n\nexport function effect(fn: () => void | (() => void)): Unsubscribe {\n  const e = new Effect(fn);\n  return () => e.dispose();\n}\n\n/**\n * Run multiple signal updates as an atomic batch.\n *\n * Within the callback, calls to signal.set() are deferred — each signal\n * accumulates its latest value. When the outermost batch() returns,\n * each modified signal fires its subscribers exactly once with the final\n * value. Nested batch() calls are supported; the flush only runs when the\n * outermost batch exits.\n *\n * Example:\n *   batch(() => {\n *     count.set(1);\n *     count.set(2);\n *     count.set(3);\n *   });\n *   // subscribers see count = 3 exactly once\n */\nexport function batch(fn: () => void): void {\n  _batchDepth++;\n  try {\n    fn();\n  } finally {\n    _batchDepth--;\n    if (_batchDepth === 0) {\n      _drainBatch();\n    }\n  }\n}\n\n/** True when inside a batch() call. Useful for advanced scheduling integration. */\nexport function isBatching(): boolean {\n  return _batchDepth > 0;\n}\n\n// ── Inspection (read-only, DevTools-facing) ─────────────────────────────────\n\n/** Whether a signal is writable (`signal()`) or computed (`derived()`). */\nexport type SignalKind = 'writable' | 'derived';\n\n/** Classify a reactive value as writable or derived. */\nexport function signalKind(source: ReadonlySignal<unknown>): SignalKind {\n  return source instanceof DerivedSignal ? 'derived' : 'writable';\n}\n\n/**\n * The number of live observers on a signal — direct subscribers plus derived\n * or effect consumers — or `undefined` if the source does not expose the count.\n * Read-only; safe for DevTools. Never mutates reactive state.\n */\nexport function observerCount(source: ReadonlySignal<unknown>): number | undefined {\n  const maybe = source as { _observerCount?: () => number };\n  return typeof maybe._observerCount === 'function' ? maybe._observerCount() : undefined;\n}\n","/**\n * A simple reactive store built on top of signals.\n * Useful for structured state with multiple fields.\n */\n\nimport { Signal, signal, type Subscriber, type Unsubscribe } from './signal.js';\n\nexport type StoreState = Record<string, unknown>;\n\nexport class Store<T extends StoreState> {\n  private readonly _signals: Record<string, Signal<unknown>>;\n\n  constructor(initial: T) {\n    const signals: Record<string, Signal<unknown>> = {};\n    for (const key in initial) {\n      if (Object.prototype.hasOwnProperty.call(initial, key)) {\n        signals[key] = signal(initial[key] as unknown);\n      }\n    }\n    this._signals = signals;\n  }\n\n  get<K extends keyof T>(key: K): T[K] {\n    const s = this._signals[key as string];\n    if (s === undefined) {\n      throw new Error(`Store: unknown key \"${String(key)}\"`);\n    }\n    return s.get() as T[K];\n  }\n\n  set<K extends keyof T>(key: K, value: T[K]): void {\n    const s = this._signals[key as string];\n    if (s === undefined) {\n      throw new Error(`Store: unknown key \"${String(key)}\"`);\n    }\n    s.set(value as unknown);\n  }\n\n  signal<K extends keyof T>(key: K): Signal<T[K]> {\n    const s = this._signals[key as string];\n    if (s === undefined) {\n      throw new Error(`Store: unknown key \"${String(key)}\"`);\n    }\n    return s as unknown as Signal<T[K]>;\n  }\n\n  subscribe<K extends keyof T>(key: K, fn: Subscriber<T[K]>): Unsubscribe {\n    return this.signal(key).subscribe(fn);\n  }\n\n  getSnapshot(): T {\n    const snap = {} as T;\n    for (const key in this._signals) {\n      if (Object.prototype.hasOwnProperty.call(this._signals, key)) {\n        (snap as Record<string, unknown>)[key] = this._signals[key]?.peek();\n      }\n    }\n    return snap;\n  }\n}\n\nexport function createStore<T extends StoreState>(initial: T): Store<T> {\n  return new Store(initial);\n}\n","/**\n * StreetUI async resources — framework-native asynchronous data.\n *\n * A `resource` wraps a Promise-returning loader and exposes its lifecycle as\n * ordinary StreetUI signals (status / data / error), so it composes with\n * `derived`, `effect`, `when()`, `listOf` and the renderer with no second\n * reactive system.\n *\n * State machine:\n *\n *   idle ──(load)──▶ loading ──(resolve)──▶ success\n *                      │\n *                      └────(reject)──────▶ error\n *\n * Refetch keeps the previously-loaded `data` visible while `status` is\n * `'loading'` again (see `isRefetching`) — there is no separate `'refetching'`\n * status; it is expressed through `status === 'loading'` with `data` still set.\n *\n * The resource is transport-agnostic: the loader is any function returning a\n * value or a Promise. When it accepts the provided `AbortSignal`, in-flight\n * work is cancelled on `dispose()` or when a newer request supersedes it.\n */\n\nimport { signal, derived, batch, type ReadonlySignal, type Unsubscribe } from './signal.js';\n\nexport type ResourceStatus = 'idle' | 'loading' | 'success' | 'error';\n\n/** Context handed to the loader; carries an AbortSignal for cancellation. */\nexport interface ResourceLoaderContext {\n  readonly signal: AbortSignal;\n}\n\n/** Any value-or-Promise producing function. Receives an abort-aware context. */\nexport type ResourceLoader<T> = (ctx: ResourceLoaderContext) => Promise<T> | T;\n\nexport interface ResourceOptions<T = unknown> {\n  /** Load immediately on creation. Defaults to `true`. When `false`, stays `idle` until `refetch()`. */\n  readonly immediate?: boolean;\n  /**\n   * Explicit reactive dependencies. When any listed signal changes, the\n   * resource refetches. Dependencies are explicit (not auto-tracked from the\n   * loader body) so there is no risk of an accidental infinite refetch loop.\n   */\n  readonly watch?: ReadonlyArray<ReadonlySignal<unknown>>;\n  /**\n   * Optional teardown registrar (e.g. a route's `ctx.onCleanup`). When given,\n   * the resource registers its own `dispose` so it is cleaned up automatically\n   * when its owner is removed.\n   */\n  readonly onCleanup?: (fn: () => void) => void;\n  /**\n   * Server-provided initial value for hydration. When present the resource\n   * starts in `'success'` with this data already visible, and the initial\n   * auto-load is skipped (so the client does not refetch data the server\n   * already resolved). This is the client half of SSR resource transfer; the\n   * server side awaits `refetch()` before serializing. Set `immediate: true`\n   * explicitly to force a client refetch anyway.\n   */\n  readonly initialData?: T;\n  /** Server-provided initial error for hydration (mirrors `initialData`). */\n  readonly initialError?: unknown;\n  /**\n   * Explicit initial status override. Rarely needed — inferred as `'success'`\n   * from `initialData` or `'error'` from `initialError`.\n   */\n  readonly initialStatus?: ResourceStatus;\n}\n\nexport interface Resource<T> {\n  /** Reactive lifecycle status. */\n  readonly status: ReadonlySignal<ResourceStatus>;\n  /** The last successfully-loaded value, or `undefined` before first success. */\n  readonly data: ReadonlySignal<T | undefined>;\n  /** The most recent error, or `undefined` when there is none. Typed `unknown` — never `any`. */\n  readonly error: ReadonlySignal<unknown>;\n  /** Convenience: `status === 'loading'`. */\n  readonly loading: ReadonlySignal<boolean>;\n  /** Convenience: loading while previously-loaded data is still present (a refetch). */\n  readonly isRefetching: ReadonlySignal<boolean>;\n  /** Trigger a new request. Resolves when the request settles (or is superseded). */\n  refetch(): Promise<void>;\n  /** Cancel in-flight work, drop watchers, and ignore any late results. Idempotent. */\n  dispose(): void;\n}\n\n/** True for an abort we initiated (so it is not surfaced as a real error). */\nfunction isAbortError(err: unknown): boolean {\n  return (\n    err instanceof Error && err.name === 'AbortError'\n  ) || (\n    typeof DOMException !== 'undefined' && err instanceof DOMException && err.name === 'AbortError'\n  );\n}\n\nexport function resource<T>(loader: ResourceLoader<T>, options: ResourceOptions<T> = {}): Resource<T> {\n  // Seed hydrated initial state (SSR transfer). `initialStatus` wins if given,\n  // otherwise infer success/error from the provided value.\n  const hasInitial =\n    options.initialData !== undefined ||\n    options.initialError !== undefined ||\n    options.initialStatus !== undefined;\n\n  const seededStatus: ResourceStatus =\n    options.initialStatus ??\n    (options.initialData !== undefined\n      ? 'success'\n      : options.initialError !== undefined\n        ? 'error'\n        : 'idle');\n\n  const status = signal<ResourceStatus>(seededStatus);\n  const data = signal<T | undefined>(options.initialData);\n  const error = signal<unknown>(options.initialError);\n\n  const loading = derived<boolean>(() => status.get() === 'loading');\n  const isRefetching = derived<boolean>(() => status.get() === 'loading' && data.get() !== undefined);\n\n  let disposed = false;\n  /** Monotonic request id — only the newest request may write state (race guard). */\n  let runId = 0;\n  let controller: AbortController | null = null;\n\n  const load = async (): Promise<void> => {\n    if (disposed) return;\n\n    // Supersede any in-flight request: abort it and bump the run id so its\n    // eventual resolution is ignored.\n    controller?.abort();\n    const myRun = ++runId;\n    const myController = new AbortController();\n    controller = myController;\n\n    // Enter loading. Preserve `data` (so a refetch keeps showing the old value)\n    // and clear any previous error.\n    batch(() => {\n      error.set(undefined);\n      status.set('loading');\n    });\n\n    try {\n      const result = await loader({ signal: myController.signal });\n      // Ignore stale or cancelled resolutions.\n      if (disposed || myRun !== runId) return;\n      batch(() => {\n        data.set(result);\n        error.set(undefined);\n        status.set('success');\n      });\n    } catch (err) {\n      if (disposed || myRun !== runId) return;\n      // A self-initiated abort is not a user-visible error.\n      if (isAbortError(err)) return;\n      batch(() => {\n        error.set(err);\n        status.set('error');\n      });\n    }\n  };\n\n  const refetch = (): Promise<void> => load();\n\n  // Explicit reactive dependencies: refetch when any watched signal changes.\n  const watchUnsubs: Unsubscribe[] = [];\n  if (options.watch !== undefined) {\n    for (const dep of options.watch) {\n      watchUnsubs.push(\n        dep.subscribe(() => {\n          if (!disposed) void load();\n        }),\n      );\n    }\n  }\n\n  const dispose = (): void => {\n    if (disposed) return;\n    disposed = true;\n    controller?.abort();\n    controller = null;\n    for (const unsub of watchUnsubs) unsub();\n    watchUnsubs.length = 0;\n  };\n\n  if (options.onCleanup !== undefined) {\n    options.onCleanup(dispose);\n  }\n\n  // Auto-load on creation unless disabled. When hydrated initial state is\n  // present we skip the initial load by default (the server already resolved\n  // it); an explicit `immediate: true` still forces a refetch.\n  if (options.immediate === true || (options.immediate !== false && !hasInitial)) {\n    void load();\n  }\n\n  return {\n    status,\n    data,\n    error,\n    loading,\n    isRefetching,\n    refetch,\n    dispose,\n  };\n}\n"],"mappings":"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","names":[]}