gorsee 0.2.3 → 0.2.5

package/dist-pkg/reactive/diagnostics.js

@@ -0,0 +1,363 @@
+export const REACTIVE_TRACE_SCHEMA_VERSION = 1;
+let diagnosticsEnabled = !1, captureEvents = !1, maxEvents = 200, nextNodeId = 1, nextEventSeq = 1;
+const snapshot = {
+  signalsCreated: 0,
+  signalReads: 0,
+  signalWrites: 0,
+  computedCreated: 0,
+  computedReads: 0,
+  computedRuns: 0,
+  effectCreated: 0,
+  effectRuns: 0,
+  resourcesCreated: 0,
+  resourceLoadsStarted: 0,
+  resourceLoadsSucceeded: 0,
+  resourceLoadsFailed: 0,
+  resourceInvalidations: 0,
+  resourceMutations: 0,
+  mutationsCreated: 0,
+  mutationRuns: 0,
+  mutationSuccesses: 0,
+  mutationFailures: 0,
+  mutationRollbacks: 0,
+  mutationResets: 0
+}, nodes = new Map, edges = new Map, events = [], activeComputations = [], pendingInvalidations = new Map, resourceNodeIdsByKey = new Map;
+export function configureReactiveDiagnostics(config = {}) {
+  diagnosticsEnabled = config.enabled === !0;
+  captureEvents = config.captureEvents === !0;
+  maxEvents = Math.max(1, config.maxEvents ?? 200);
+}
+export function resetReactiveDiagnostics() {
+  snapshot.signalsCreated = 0;
+  snapshot.signalReads = 0;
+  snapshot.signalWrites = 0;
+  snapshot.computedCreated = 0;
+  snapshot.computedReads = 0;
+  snapshot.computedRuns = 0;
+  snapshot.effectCreated = 0;
+  snapshot.effectRuns = 0;
+  snapshot.resourcesCreated = 0;
+  snapshot.resourceLoadsStarted = 0;
+  snapshot.resourceLoadsSucceeded = 0;
+  snapshot.resourceLoadsFailed = 0;
+  snapshot.resourceInvalidations = 0;
+  snapshot.resourceMutations = 0;
+  snapshot.mutationsCreated = 0;
+  snapshot.mutationRuns = 0;
+  snapshot.mutationSuccesses = 0;
+  snapshot.mutationFailures = 0;
+  snapshot.mutationRollbacks = 0;
+  snapshot.mutationResets = 0;
+  nextNodeId = 1;
+  nextEventSeq = 1;
+  nodes.clear();
+  edges.clear();
+  events.length = 0;
+  activeComputations.length = 0;
+  pendingInvalidations.clear();
+  resourceNodeIdsByKey.clear();
+}
+export function getReactiveDiagnosticsSnapshot() {
+  return { ...snapshot };
+}
+export function getReactiveGraphNodes() {
+  return Array.from(nodes.values()).map((node) => ({ ...node }));
+}
+export function getReactiveDependencyEdges() {
+  return Array.from(edges.values()).map((edge) => ({ ...edge }));
+}
+export function getReactiveDiagnosticsEvents() {
+  return events.map((event) => ({
+    ...event,
+    causeNodeIds: event.causeNodeIds ? [...event.causeNodeIds] : void 0,
+    causeLabels: event.causeLabels ? [...event.causeLabels] : void 0
+  }));
+}
+export function getReactiveTraceArtifact() {
+  return {
+    schemaVersion: REACTIVE_TRACE_SCHEMA_VERSION,
+    snapshot: getReactiveDiagnosticsSnapshot(),
+    nodes: getReactiveGraphNodes(),
+    edges: getReactiveDependencyEdges(),
+    events: getReactiveDiagnosticsEvents()
+  };
+}
+export function trackSignalCreated(label) {
+  if (!diagnosticsEnabled)
+    return null;
+  snapshot.signalsCreated++;
+  const nodeId = registerNode("signal", label);
+  pushEvent({ kind: "signal:create", nodeId, label });
+  return nodeId;
+}
+export function trackSignalRead(nodeId, label) {
+  if (!diagnosticsEnabled)
+    return;
+  snapshot.signalReads++;
+  updateNode(nodeId, (node) => {
+    node.reads++;
+  });
+  if (nodeId != null) {
+    registerDependency(nodeId, label);
+    pushEvent({ kind: "signal:read", nodeId, label });
+  }
+}
+export function trackSignalWrite(nodeId, label) {
+  if (!diagnosticsEnabled)
+    return;
+  snapshot.signalWrites++;
+  updateNode(nodeId, (node) => {
+    node.writes++;
+  });
+  if (nodeId != null) {
+    pushEvent({ kind: "signal:write", nodeId, label });
+    propagateInvalidation(nodeId, label, "write");
+  }
+}
+export function trackComputedCreated(label) {
+  if (!diagnosticsEnabled)
+    return null;
+  snapshot.computedCreated++;
+  const nodeId = registerNode("computed", label);
+  pushEvent({ kind: "computed:create", nodeId, label });
+  return nodeId;
+}
+export function trackComputedRead(nodeId, label) {
+  if (!diagnosticsEnabled)
+    return;
+  snapshot.computedReads++;
+  updateNode(nodeId, (node) => {
+    node.reads++;
+  });
+  if (nodeId != null) {
+    registerDependency(nodeId, label);
+    pushEvent({ kind: "computed:read", nodeId, label });
+  }
+}
+export function trackEffectCreated(label) {
+  if (!diagnosticsEnabled)
+    return null;
+  snapshot.effectCreated++;
+  const nodeId = registerNode("effect", label);
+  pushEvent({ kind: "effect:create", nodeId, label });
+  return nodeId;
+}
+export function trackResourceCreated(label, cacheKey) {
+  if (!diagnosticsEnabled)
+    return null;
+  snapshot.resourcesCreated++;
+  const nodeId = registerNode("resource", label);
+  if (cacheKey) {
+    const existing = resourceNodeIdsByKey.get(cacheKey) ?? new Set;
+    existing.add(nodeId);
+    resourceNodeIdsByKey.set(cacheKey, existing);
+  }
+  pushEvent({ kind: "resource:create", nodeId, label, cacheKey });
+  return nodeId;
+}
+export function trackResourceLoadStart(nodeId, label, cacheKey, detail) {
+  if (!diagnosticsEnabled || nodeId == null)
+    return;
+  snapshot.resourceLoadsStarted++;
+  updateNode(nodeId, (node) => {
+    node.runs++;
+  });
+  pushEvent({ kind: "resource:load.start", nodeId, label, cacheKey, detail });
+}
+export function trackResourceLoadSuccess(nodeId, label, cacheKey) {
+  if (!diagnosticsEnabled || nodeId == null)
+    return;
+  snapshot.resourceLoadsSucceeded++;
+  pushEvent({ kind: "resource:load.success", nodeId, label, cacheKey });
+}
+export function trackResourceLoadError(nodeId, label, cacheKey, detail) {
+  if (!diagnosticsEnabled || nodeId == null)
+    return;
+  snapshot.resourceLoadsFailed++;
+  pushEvent({ kind: "resource:load.error", nodeId, label, cacheKey, detail });
+}
+export function trackResourceRefetch(nodeId, label, cacheKey) {
+  if (!diagnosticsEnabled || nodeId == null)
+    return;
+  pushEvent({ kind: "resource:refetch", nodeId, label, cacheKey });
+}
+export function trackResourceMutate(nodeId, label, cacheKey) {
+  if (!diagnosticsEnabled || nodeId == null)
+    return;
+  snapshot.resourceMutations++;
+  updateNode(nodeId, (node) => {
+    node.writes++;
+  });
+  pushEvent({ kind: "resource:mutate", nodeId, label, cacheKey });
+}
+export function trackResourceInvalidation(cacheKey, reason) {
+  if (!diagnosticsEnabled)
+    return;
+  const nodeIds = resourceNodeIdsByKey.get(cacheKey);
+  if (!nodeIds || nodeIds.size === 0)
+    return;
+  for (const nodeId of nodeIds) {
+    snapshot.resourceInvalidations++;
+    updateNode(nodeId, (node) => {
+      node.invalidations++;
+    });
+    const label = nodes.get(nodeId)?.label;
+    pushEvent({ kind: "resource:invalidate", nodeId, label, cacheKey, reason });
+    propagateInvalidation(nodeId, label, reason);
+  }
+}
+export function trackMutationCreated(label) {
+  if (!diagnosticsEnabled)
+    return null;
+  snapshot.mutationsCreated++;
+  const nodeId = registerNode("mutation", label);
+  pushEvent({ kind: "mutation:create", nodeId, label });
+  return nodeId;
+}
+export function trackMutationStart(nodeId, label) {
+  if (!diagnosticsEnabled || nodeId == null)
+    return;
+  snapshot.mutationRuns++;
+  updateNode(nodeId, (node) => {
+    node.runs++;
+  });
+  pushEvent({ kind: "mutation:start", nodeId, label });
+}
+export function trackMutationSuccess(nodeId, label) {
+  if (!diagnosticsEnabled || nodeId == null)
+    return;
+  snapshot.mutationSuccesses++;
+  pushEvent({ kind: "mutation:success", nodeId, label });
+}
+export function trackMutationError(nodeId, label, detail) {
+  if (!diagnosticsEnabled || nodeId == null)
+    return;
+  snapshot.mutationFailures++;
+  pushEvent({ kind: "mutation:error", nodeId, label, detail });
+}
+export function trackMutationSettled(nodeId, label) {
+  if (!diagnosticsEnabled || nodeId == null)
+    return;
+  pushEvent({ kind: "mutation:settled", nodeId, label });
+}
+export function trackMutationRollback(nodeId, label) {
+  if (!diagnosticsEnabled || nodeId == null)
+    return;
+  snapshot.mutationRollbacks++;
+  pushEvent({ kind: "mutation:rollback", nodeId, label });
+}
+export function trackMutationReset(nodeId, label) {
+  if (!diagnosticsEnabled || nodeId == null)
+    return;
+  snapshot.mutationResets++;
+  pushEvent({ kind: "mutation:reset", nodeId, label });
+}
+export function runTrackedComputation(nodeId, kind, label, fn) {
+  if (!diagnosticsEnabled || nodeId == null)
+    return fn();
+  const causes = consumeInvalidationCauses(nodeId);
+  if (kind === "computed")
+    snapshot.computedRuns++;
+  if (kind === "effect")
+    snapshot.effectRuns++;
+  updateNode(nodeId, (node) => {
+    node.runs++;
+  });
+  pushEvent({
+    kind: kind === "computed" ? "computed:run" : "effect:run",
+    nodeId,
+    label,
+    causeNodeIds: causes.map((cause) => cause.sourceNodeId),
+    causeLabels: causes.map((cause) => cause.sourceLabel).filter((value) => Boolean(value))
+  });
+  activeComputations.push({ nodeId, kind, label });
+  try {
+    return fn();
+  } finally {
+    activeComputations.pop();
+  }
+}
+function registerNode(kind, label) {
+  const id = nextNodeId++;
+  nodes.set(id, {
+    id,
+    kind,
+    label,
+    reads: 0,
+    writes: 0,
+    runs: 0,
+    invalidations: 0
+  });
+  return id;
+}
+function updateNode(nodeId, update) {
+  if (nodeId == null)
+    return;
+  const node = nodes.get(nodeId);
+  if (!node)
+    return;
+  update(node);
+}
+function registerDependency(sourceNodeId, sourceLabel) {
+  const active = activeComputations[activeComputations.length - 1];
+  if (!active)
+    return;
+  if (active.nodeId === sourceNodeId)
+    return;
+  const sourceNode = nodes.get(sourceNodeId), targetNode = nodes.get(active.nodeId);
+  if (!sourceNode || !targetNode)
+    return;
+  const key = `${sourceNodeId}->${active.nodeId}`, existing = edges.get(key);
+  if (existing) {
+    existing.reads++;
+    return;
+  }
+  edges.set(key, {
+    sourceNodeId,
+    targetNodeId: active.nodeId,
+    sourceKind: sourceNode.kind,
+    targetKind: targetNode.kind,
+    sourceLabel: sourceNode.label ?? sourceLabel,
+    targetLabel: targetNode.label ?? active.label,
+    reads: 1
+  });
+}
+function propagateInvalidation(sourceNodeId, sourceLabel, reason) {
+  for (const edge of edges.values()) {
+    if (edge.sourceNodeId !== sourceNodeId)
+      continue;
+    updateNode(edge.targetNodeId, (node) => {
+      node.invalidations++;
+    });
+    const pending = pendingInvalidations.get(edge.targetNodeId) ?? [];
+    if (!pending.some((cause) => cause.sourceNodeId === sourceNodeId && cause.reason === reason)) {
+      pending.push({ sourceNodeId, sourceLabel, reason });
+      pendingInvalidations.set(edge.targetNodeId, pending);
+    }
+    pushEvent({
+      kind: "invalidation",
+      nodeId: edge.targetNodeId,
+      label: edge.targetLabel,
+      relatedNodeId: sourceNodeId,
+      relatedLabel: sourceLabel,
+      reason,
+      causeNodeIds: [sourceNodeId],
+      causeLabels: sourceLabel ? [sourceLabel] : void 0
+    });
+  }
+}
+function consumeInvalidationCauses(nodeId) {
+  const causes = pendingInvalidations.get(nodeId) ?? [];
+  pendingInvalidations.delete(nodeId);
+  return causes;
+}
+function pushEvent(event) {
+  if (!captureEvents)
+    return;
+  events.push({
+    ...event,
+    seq: nextEventSeq++
+  });
+  if (events.length > maxEvents)
+    events.splice(0, events.length - maxEvents);
+}

package/dist-pkg/reactive/effect.d.ts

@@ -0,0 +1,3 @@
+import { type ReactiveDiagnosticOptions } from "./diagnostics.js";
+export type CleanupFn = () => void;
+export declare function createEffect(fn: () => void, options?: ReactiveDiagnosticOptions): CleanupFn;

package/dist-pkg/reactive/effect.js

@@ -0,0 +1,6 @@
+import { effect as alienEffect } from "alien-signals";
+import { runTrackedComputation, trackEffectCreated } from "./diagnostics.js";
+export function createEffect(fn, options = {}) {
+  const nodeId = trackEffectCreated(options.label);
+  return alienEffect(() => runTrackedComputation(nodeId, "effect", options.label, fn));
+}

package/dist-pkg/reactive/index.d.ts

@@ -0,0 +1,9 @@
+export { createSignal } from "./signal.js";
+export { createComputed } from "./computed.js";
+export { createEffect } from "./effect.js";
+export { configureReactiveDiagnostics, getReactiveDependencyEdges, getReactiveDiagnosticsEvents, getReactiveDiagnosticsSnapshot, getReactiveGraphNodes, getReactiveTraceArtifact, REACTIVE_TRACE_SCHEMA_VERSION, resetReactiveDiagnostics, type ReactiveDiagnosticsConfig, type ReactiveDiagnosticEvent, type ReactiveDiagnosticOptions, type ReactiveDependencyEdge, type ReactiveDiagnosticsSnapshot, type ReactiveGraphNode, type ReactiveTraceArtifact, } from "./diagnostics.js";
+export { createResource, invalidateResource, invalidateAll } from "./resource.js";
+export { createDataQuery, createDataMutation, type DataQuery, type DataQueryOptions, type DataMutation, type DataMutationOptions } from "./data.js";
+export { createStore } from "./store.js";
+export { createLive, type LiveOptions, type LiveSignal } from "./live.js";
+export { createMutation, type Mutation, type MutationState, type MutationOptions } from "./optimistic.js";

package/dist-pkg/reactive/index.js

@@ -0,0 +1,18 @@
+export { createSignal } from "./signal.js";
+export { createComputed } from "./computed.js";
+export { createEffect } from "./effect.js";
+export {
+  configureReactiveDiagnostics,
+  getReactiveDependencyEdges,
+  getReactiveDiagnosticsEvents,
+  getReactiveDiagnosticsSnapshot,
+  getReactiveGraphNodes,
+  getReactiveTraceArtifact,
+  REACTIVE_TRACE_SCHEMA_VERSION,
+  resetReactiveDiagnostics
+} from "./diagnostics.js";
+export { createResource, invalidateResource, invalidateAll } from "./resource.js";
+export { createDataQuery, createDataMutation } from "./data.js";
+export { createStore } from "./store.js";
+export { createLive } from "./live.js";
+export { createMutation } from "./optimistic.js";

package/dist-pkg/reactive/live.d.ts

@@ -0,0 +1,15 @@
+import { type SignalGetter } from "./signal.js";
+export interface LiveOptions<T> {
+    url: string;
+    initialValue: T;
+    transform?: (data: unknown) => T;
+    reconnect?: boolean;
+    reconnectDelay?: number;
+}
+export interface LiveSignal<T> {
+    readonly value: SignalGetter<T>;
+    readonly connected: SignalGetter<boolean>;
+    send: (data: unknown) => void;
+    close: () => void;
+}
+export declare function createLive<T>(options: LiveOptions<T>): LiveSignal<T>;

package/dist-pkg/reactive/live.js

@@ -0,0 +1,58 @@
+import { createSignal } from "./signal.js";
+export function createLive(options) {
+  const {
+    url,
+    initialValue,
+    transform,
+    reconnect = !0,
+    reconnectDelay = 1000
+  } = options, [value, setValue] = createSignal(initialValue), [connected, setConnected] = createSignal(!1);
+  let ws = null, closed = !1, retryCount = 0;
+  function handleMessage(event) {
+    try {
+      const parsed = JSON.parse(String(event.data)), result = transform ? transform(parsed) : parsed;
+      setValue(result);
+    } catch {}
+  }
+  function handleOpen() {
+    retryCount = 0;
+    setConnected(!0);
+  }
+  function handleClose() {
+    setConnected(!1);
+    ws = null;
+    if (!closed && reconnect)
+      scheduleReconnect();
+  }
+  function scheduleReconnect() {
+    const delay = Math.min(reconnectDelay * 2 ** retryCount, 30000);
+    retryCount++;
+    setTimeout(connect, delay);
+  }
+  function connect() {
+    if (closed)
+      return;
+    if (typeof globalThis.WebSocket > "u")
+      return;
+    ws = new WebSocket(url);
+    ws.addEventListener("open", handleOpen);
+    ws.addEventListener("message", handleMessage);
+    ws.addEventListener("close", handleClose);
+    ws.addEventListener("error", () => {});
+  }
+  function send(data) {
+    if (ws && ws.readyState === WebSocket.OPEN)
+      ws.send(JSON.stringify(data));
+  }
+  function close() {
+    closed = !0;
+    if (ws) {
+      ws.close();
+      ws = null;
+    }
+    setConnected(!1);
+  }
+  if (typeof globalThis.WebSocket < "u")
+    connect();
+  return { value, connected, send, close };
+}

package/dist-pkg/reactive/optimistic.d.ts

@@ -0,0 +1,20 @@
+import { type SignalGetter } from "./signal.js";
+export interface MutationOptions<T, V> {
+    mutationFn: (variables: V) => Promise<T>;
+    onSuccess?: (data: T, variables: V) => void;
+    onError?: (error: Error, variables: V) => void;
+    onSettled?: (data: T | undefined, error: Error | undefined) => void;
+    label?: string;
+}
+export interface MutationState<T> {
+    readonly data: SignalGetter<T | undefined>;
+    readonly error: SignalGetter<Error | undefined>;
+    readonly isPending: SignalGetter<boolean>;
+}
+export interface Mutation<T, V> extends MutationState<T> {
+    mutate: (variables: V) => Promise<T>;
+    /** Optimistic: update signal immediately, rollback if server fails */
+    optimistic: <S>(signal: SignalGetter<S>, setter: (current: S) => void, update: (current: S, variables: V) => S, variables: V) => Promise<T>;
+    reset: () => void;
+}
+export declare function createMutation<T, V = void>(options: MutationOptions<T, V>): Mutation<T, V>;

package/dist-pkg/reactive/optimistic.js

@@ -0,0 +1,54 @@
+import { createSignal } from "./signal.js";
+import {
+  trackMutationCreated,
+  trackMutationError,
+  trackMutationReset,
+  trackMutationRollback,
+  trackMutationSettled,
+  trackMutationStart,
+  trackMutationSuccess
+} from "./diagnostics.js";
+export function createMutation(options) {
+  const mutationNodeId = trackMutationCreated(options.label), [data, setData] = createSignal(void 0), [error, setError] = createSignal(void 0), [isPending, setIsPending] = createSignal(!1);
+  async function mutate(variables) {
+    trackMutationStart(mutationNodeId, options.label);
+    setIsPending(!0);
+    setError(void 0);
+    try {
+      const result = await options.mutationFn(variables);
+      setData(result);
+      trackMutationSuccess(mutationNodeId, options.label);
+      options.onSuccess?.(result, variables);
+      options.onSettled?.(result, void 0);
+      return result;
+    } catch (err) {
+      const e = err instanceof Error ? err : Error(String(err));
+      setError(e);
+      trackMutationError(mutationNodeId, options.label, e.message);
+      options.onError?.(e, variables);
+      options.onSettled?.(void 0, e);
+      throw e;
+    } finally {
+      trackMutationSettled(mutationNodeId, options.label);
+      setIsPending(!1);
+    }
+  }
+  async function optimistic(signal, setter, update, variables) {
+    const previous = signal();
+    setter(update(previous, variables));
+    try {
+      return await mutate(variables);
+    } catch (err) {
+      setter(previous);
+      trackMutationRollback(mutationNodeId, options.label);
+      throw err;
+    }
+  }
+  function reset() {
+    trackMutationReset(mutationNodeId, options.label);
+    setData(void 0);
+    setError(void 0);
+    setIsPending(!1);
+  }
+  return { data, error, isPending, mutate, optimistic, reset };
+}

package/dist-pkg/reactive/resource.d.ts

@@ -0,0 +1,25 @@
+import { type SignalGetter } from "./signal.js";
+export interface ResourceOptions {
+    /** Initial data (skip first fetch) */
+    initialData?: unknown;
+    /** Retry count on failure (default: 0) */
+    retry?: number;
+    /** Retry delay in ms (default: 1000) */
+    retryDelay?: number;
+    /** Cache key for deduplication */
+    key?: string;
+    /** Stale time in ms — refetch after this period */
+    staleTime?: number;
+    /** Optional diagnostics label for reactive tracing */
+    label?: string;
+}
+export interface ResourceState<T> {
+    loading: SignalGetter<boolean>;
+    error: SignalGetter<Error | undefined>;
+    refetch: () => void;
+    mutate: (value: T | undefined | ((prev: T | undefined) => T | undefined)) => void;
+}
+export type ResourceReturn<T> = [SignalGetter<T | undefined>, ResourceState<T>];
+export declare function invalidateResource(key: string): void;
+export declare function invalidateAll(): void;
+export declare function createResource<T>(fetcher: () => Promise<T>, options?: ResourceOptions): ResourceReturn<T>;

package/dist-pkg/reactive/resource.js

@@ -0,0 +1,97 @@
+import { createSignal } from "./signal.js";
+import {
+  trackResourceCreated,
+  trackResourceInvalidation,
+  trackResourceLoadError,
+  trackResourceLoadStart,
+  trackResourceLoadSuccess,
+  trackResourceMutate,
+  trackResourceRefetch
+} from "./diagnostics.js";
+const resourceCache = new Map;
+export function invalidateResource(key) {
+  resourceCache.delete(key);
+  trackResourceInvalidation(key, "resource.invalidate");
+}
+export function invalidateAll() {
+  for (const key of resourceCache.keys())
+    trackResourceInvalidation(key, "resource.invalidateAll");
+  resourceCache.clear();
+}
+export function createResource(fetcher, options) {
+  const retryCount = options?.retry ?? 0, retryDelay = options?.retryDelay ?? 1000, cacheKey = options?.key, staleTime = options?.staleTime, diagnosticsLabel = options?.label ?? cacheKey, resourceNodeId = trackResourceCreated(diagnosticsLabel, cacheKey), cached = cacheKey ? resourceCache.get(cacheKey) : void 0, hasValidCache = cached && staleTime && Date.now() - cached.fetchedAt < staleTime, initialValue = hasValidCache ? cached.data : options?.initialData, [data, setData] = createSignal(initialValue), [loading, setLoading] = createSignal(!hasValidCache), [error, setError] = createSignal(void 0);
+  async function fetchWithRetry(attempt) {
+    try {
+      return await fetcher();
+    } catch (err) {
+      if (attempt < retryCount) {
+        await new Promise((r) => setTimeout(r, retryDelay * (attempt + 1)));
+        return fetchWithRetry(attempt + 1);
+      }
+      throw err;
+    }
+  }
+  const load = () => {
+    if (cacheKey) {
+      const entry = resourceCache.get(cacheKey);
+      if (entry?.promise) {
+        trackResourceLoadStart(resourceNodeId, diagnosticsLabel, cacheKey, "deduped");
+        entry.promise.then((result) => {
+          setData(() => result);
+          setLoading(!1);
+          trackResourceLoadSuccess(resourceNodeId, diagnosticsLabel, cacheKey);
+        }).catch((err) => {
+          setError(err instanceof Error ? err : Error(String(err)));
+          setLoading(!1);
+          trackResourceLoadError(resourceNodeId, diagnosticsLabel, cacheKey, err instanceof Error ? err.message : String(err));
+        });
+        return;
+      }
+    }
+    setLoading(!0);
+    setError(void 0);
+    trackResourceLoadStart(resourceNodeId, diagnosticsLabel, cacheKey);
+    const promise = fetchWithRetry(0);
+    if (cacheKey) {
+      const entry = resourceCache.get(cacheKey) ?? { data: void 0, fetchedAt: 0 };
+      entry.promise = promise;
+      resourceCache.set(cacheKey, entry);
+    }
+    promise.then((result) => {
+      setData(() => result);
+      setLoading(!1);
+      trackResourceLoadSuccess(resourceNodeId, diagnosticsLabel, cacheKey);
+      if (cacheKey)
+        resourceCache.set(cacheKey, { data: result, fetchedAt: Date.now() });
+    }).catch((err) => {
+      setError(err instanceof Error ? err : Error(String(err)));
+      setLoading(!1);
+      trackResourceLoadError(resourceNodeId, diagnosticsLabel, cacheKey, err instanceof Error ? err.message : String(err));
+      if (cacheKey) {
+        const entry = resourceCache.get(cacheKey);
+        if (entry)
+          entry.promise = void 0;
+      }
+    });
+  };
+  if (!hasValidCache)
+    load();
+  return [
+    data,
+    {
+      loading,
+      error,
+      refetch: () => {
+        trackResourceRefetch(resourceNodeId, diagnosticsLabel, cacheKey);
+        load();
+      },
+      mutate: (value) => {
+        trackResourceMutate(resourceNodeId, diagnosticsLabel, cacheKey);
+        if (typeof value === "function")
+          setData(value);
+        else
+          setData(() => value);
+      }
+    }
+  ];
+}

package/dist-pkg/reactive/signal.d.ts

@@ -0,0 +1,4 @@
+import { type ReactiveDiagnosticOptions } from "./diagnostics.js";
+export type SignalGetter<T> = () => T;
+export type SignalSetter<T> = (value: T | ((prev: T) => T)) => void;
+export declare function createSignal<T>(initialValue: T, options?: ReactiveDiagnosticOptions): [SignalGetter<T>, SignalSetter<T>];