@vielzeug/ripple 1.2.3 → 2.0.0

package/dist/tracking.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracking.cjs","names":[],"sources":["../src/tracking.ts"],"sourcesContent":["import type { ComputedBase, ReactiveBase } from './reactive-base';\nimport type { CleanupFn, Subscriber } from './types';\n\n// ── Global revision clock ─────────────────────────────────────────────────────\n//\n// Monotonically-increasing counter incremented on every signal write.\n// ComputedImpl records the clock value after each successful recompute and uses\n// it as an O(1) \"nothing has changed globally\" fast-path check in refreshIfDirty.\n\nlet globalRevision = 0;\n\nexport const tickRevision = (): number => ++globalRevision;\nexport const getRevision = (): number => globalRevision;\n\n// ── Internal types ────────────────────────────────────────────────────────────\n\nexport type DepEntry = {\n  source: ReactiveBase<unknown>;\n  version: number;\n};\n\n/** Called by trackSource to observe each reactive source accessed during a tracked run. */\nexport type SourceObserver = (source: ReactiveBase<unknown>) => void;\n\n// TrackingCtx carries both dep-collection state AND an optional sourceObserver.\n// Putting the observer inside the context (R12) scopes it to the specific effect/computed\n// run rather than making it a process-wide global — nested computed recomputes use their\n// own context (no observer), so the debugEffect pattern works without identity checks.\n// sourceObserver is shared across both branches and lives outside the discriminant union.\nexport type TrackingCtx = {\n  sourceObserver?: SourceObserver;\n} & (\n  | {\n      computed: ComputedBase<unknown>;\n      depCollector: DepEntry[];\n      kind: 'computed';\n    }\n  | {\n      cleanups: CleanupFn[];\n      deps: Map<ReactiveBase<unknown>, number>;\n      effect: Subscriber;\n      kind: 'effect';\n      subscriptions: Set<CleanupFn>;\n    }\n);\n\n// ── Scheduling state ────────────────────────────────────────────────────────\n//\n// Colocated here (rather than in scheduling.ts) so it can be a field of\n// ExecutionContext without a runtime circular import between tracking.ts and\n// scheduling.ts — scheduling.ts only needs `getSchedulingState()` and the\n// `SchedulingState` type (type-only import, erased at compile time).\n//\n// Isolating this per-request (via the SSR hook) closes the documented gap where\n// concurrent SSR requests share one flush queue: `batchDepth`, `pendingSubscribers`,\n// and the dirty-computed sets are the only scheduling fields that can observably\n// leak across requests (they persist across `await` boundaries via `batch()`\n// spanning shared module-level signals). The propagation epoch/stack in\n// scheduling.ts stay module-level scratch memory — they're only touched within a\n// single synchronous call stack, which JS's run-to-completion model already isolates.\n\nexport type SchedulingState = {\n  activeDirty: 'a' | 'b';\n  batchDepth: number;\n  readonly dirtyWithEffectSubsA: Set<ComputedBase<unknown>>;\n  readonly dirtyWithEffectSubsB: Set<ComputedBase<unknown>>;\n  readonly pendingSubscribers: Set<Subscriber>;\n};\n\nexport const createSchedulingState = (): SchedulingState => ({\n  activeDirty: 'a',\n  batchDepth: 0,\n  dirtyWithEffectSubsA: new Set(),\n  dirtyWithEffectSubsB: new Set(),\n  pendingSubscribers: new Set(),\n});\n\n// ── ExecutionContext ──────────────────────────────────────────────────────────\n//\n// Unified context replaces two separate globals (_tracking and _scopeStack).\n// Both the dep-tracking context and the innermost scope's cleanup array live here.\n// The SSR hook overrides the entire context per-request — fixing the prior bug\n// where scope cleanups were always a process-wide singleton even with the hook.\n\nexport type ExecutionContext = {\n  readonly scheduling: SchedulingState;\n  readonly scopeCleanups: CleanupFn[] | null;\n  readonly tracking: TrackingCtx | null;\n};\n\nexport type ContextHook = {\n  get(): ExecutionContext;\n  run<T>(ctx: ExecutionContext, fn: () => T): T;\n};\n\nlet _ctx: ExecutionContext = { scheduling: createSchedulingState(), scopeCleanups: null, tracking: null };\nlet _hook: ContextHook | null = null;\n\nconst getCtx = (): ExecutionContext => (_hook !== null ? _hook.get() : _ctx);\n\n/** Returns the scheduling-state bucket for the active execution context (module-level singleton outside SSR). */\nexport const getSchedulingState = (): SchedulingState => getCtx().scheduling;\n\n/** `true` once an SSR context hook is installed — scheduling state is then request-isolated. */\nexport const hasContextHook = (): boolean => _hook !== null;\n\n// ── Tracking ──────────────────────────────────────────────────────────────────\n\nexport const getTracking = (): TrackingCtx | null => getCtx().tracking;\n\nexport const withTracking = <T>(tracking: TrackingCtx | null, fn: () => T): T => {\n  if (_hook !== null) {\n    const current = _hook.get();\n\n    return _hook.run({ ...current, tracking }, fn);\n  }\n\n  const prev = _ctx;\n\n  _ctx = { ..._ctx, tracking };\n\n  try {\n    return fn();\n  } finally {\n    _ctx = prev;\n  }\n};\n\n// ── Scope cleanup ─────────────────────────────────────────────────────────────\n\n/**\n * Pushes `cleanups` as the active scope cleanup array for the duration of `fn`.\n * Any `onCleanup()` calls inside `fn` will register into these cleanups.\n * Effects and computed values created inside `fn` are also auto-registered.\n */\nexport const withScopeCleanups = <T>(cleanups: CleanupFn[], fn: () => T): T => {\n  if (_hook !== null) {\n    const current = _hook.get();\n\n    return _hook.run({ ...current, scopeCleanups: cleanups }, fn);\n  }\n\n  const prev = _ctx;\n\n  _ctx = { ..._ctx, scopeCleanups: cleanups };\n\n  try {\n    return fn();\n  } finally {\n    _ctx = prev;\n  }\n};\n\n/**\n * Returns the cleanup array of the innermost active scope, or `null` if not inside a scope.\n */\nexport const getScopeCleanups = (): CleanupFn[] | null => getCtx().scopeCleanups;\n\n// ── Auto-disposal ───────────────────────────────────────────────────────────────\n//\n// Shared by every primitive that ties its own lifetime to the context it was\n// created in (computed(), resource()): dispose when the enclosing effect re-runs\n// or disposes, or — if not inside an effect — when the enclosing scope disposes.\n// No-op if neither is active (the caller owns disposal directly).\n//\n// Why signal() and store() don't call this: computed()/resource() are *derived*\n// computations — recreating one on every effect re-run is normal and cheap, so\n// tying their lifetime to the enclosing context avoids leaking a fresh graph\n// node per run. signal()/store() hold raw, caller-owned state that is typically\n// created once and read across many effect re-runs; auto-disposing it on the\n// first re-run would silently break any effect that reads a signal it declared\n// itself. Callers who genuinely want scope-scoped state should use\n// `scope.add(() => mySignal.dispose())` explicitly.\n\n/**\n * Registers `dispose` to run when the enclosing effect re-runs/disposes, or —\n * if there is no enclosing effect — when the enclosing scope disposes.\n */\nexport const autoRegisterDisposal = (dispose: CleanupFn): void => {\n  const ctx = getTracking();\n\n  if (ctx?.kind === 'effect') {\n    ctx.cleanups.push(dispose);\n  } else {\n    getScopeCleanups()?.push(dispose);\n  }\n};\n\n// ── Context hook (for SSR) ────────────────────────────────────────────────────\n\n/**\n * @internal Used only by `/ripple/ssr`.\n * Installs a context hook that overrides both tracking and scope-cleanup access.\n * Returns the previous hook so callers can restore it.\n */\nexport const _installContextHook = (hook: ContextHook | null): ContextHook | null => {\n  const prev = _hook;\n\n  _hook = hook;\n\n  return prev;\n};\n\n// ── Source observer ───────────────────────────────────────────────────────────\n//\n// Observer is now scoped to the active TrackingCtx instead of a process-wide global.\n// This means it only fires for direct deps of the current effect/computed — nested\n// computed recomputes use their own context (no observer) so no identity check needed.\n\n/**\n * Runs `fn` while calling `observer` for every reactive source directly accessed.\n * Used by `debugEffect` to detect which sources changed between runs.\n * No-op if called outside an active tracking context.\n */\nexport const withSourceObserver = <T>(observer: SourceObserver, fn: () => T): T => {\n  const current = getTracking();\n\n  if (current === null) return fn();\n\n  return withTracking({ ...current, sourceObserver: observer }, fn);\n};\n\n// ── untrack ───────────────────────────────────────────────────────────────────\n\n/**\n * Runs `fn` without recording any reactive reads as dependencies of the enclosing\n * effect or computed. Useful when you need to read reactive state \"silently\".\n *\n * @example\n * ```ts\n * effect(() => {\n *   const a = count.value;               // tracked\n *   const b = untrack(() => name.value); // NOT tracked — no re-run when name changes\n * });\n * ```\n */\nexport const untrack = <T>(fn: () => T): T => withTracking(null, fn);\n\n// ── trackSource ───────────────────────────────────────────────────────────────\n//\n// Records `source` as a dependency of the currently active tracking context.\n// For computed contexts: only records the dep entry — addComputedSub is called\n// later by updateDeps() in computed.ts (only for genuinely NEW deps, preventing\n// duplicate WeakRef entries).\n// For effect contexts: immediately subscribes the effect to the source and\n// records the dep for getDependencies().\n\nexport const trackSource = (source: ReactiveBase<unknown>): void => {\n  const ctx = getTracking();\n\n  if (ctx === null) return;\n\n  ctx.sourceObserver?.(source);\n\n  if (ctx.kind === 'computed') {\n    ctx.depCollector.push({ source, version: source.version });\n  } else if (ctx.kind === 'effect') {\n    const owner = ctx.effect;\n\n    source.addEffectSub(owner);\n    ctx.subscriptions.add(() => source.removeEffectSub(owner));\n    ctx.deps.set(source, source.version);\n  }\n};\n"],"mappings":"AASA,IAAI,EAAiB,EAER,MAA6B,EAAE,EAC/B,MAA4B,EAyD5B,OAAgD,CAC3D,YAAa,IACb,WAAY,EACZ,qBAAsB,IAAI,IAC1B,qBAAsB,IAAI,IAC1B,mBAAoB,IAAI,GAC1B,GAoBI,EAAyB,CAAE,WAAY,EAAsB,EAAG,cAAe,KAAM,SAAU,IAAK,EACpG,EAA4B,KAE1B,MAAkC,IAAU,KAAqB,EAAd,EAAM,IAAI,EAGtD,MAA4C,EAAO,CAAC,CAAC,WAGrD,MAAgC,IAAU,KAI1C,MAAwC,EAAO,CAAC,CAAC,SAEjD,GAAmB,EAA8B,IAAmB,CAC/E,GAAI,IAAU,KAAM,CAClB,IAAM,EAAU,EAAM,IAAI,EAE1B,OAAO,EAAM,IAAI,CAAE,GAAG,EAAS,UAAS,EAAG,CAAE,CAC/C,CAEA,IAAM,EAAO,EAEb,EAAO,CAAE,GAAG,EAAM,UAAS,EAE3B,GAAI,CACF,OAAO,EAAG,CACZ,QAAU,CACR,EAAO,CACT,CACF,EASa,GAAwB,EAAuB,IAAmB,CAC7E,GAAI,IAAU,KAAM,CAClB,IAAM,EAAU,EAAM,IAAI,EAE1B,OAAO,EAAM,IAAI,CAAE,GAAG,EAAS,cAAe,CAAS,EAAG,CAAE,CAC9D,CAEA,IAAM,EAAO,EAEb,EAAO,CAAE,GAAG,EAAM,cAAe,CAAS,EAE1C,GAAI,CACF,OAAO,EAAG,CACZ,QAAU,CACR,EAAO,CACT,CACF,EAKa,MAA6C,EAAO,CAAC,CAAC,cAsBtD,EAAwB,GAA6B,CAChE,IAAM,EAAM,EAAY,EAEpB,GAAK,OAAS,SAChB,EAAI,SAAS,KAAK,CAAO,EAEzB,EAAiB,CAAC,EAAE,KAAK,CAAO,CAEpC,EASa,EAAuB,GAAiD,CACnF,IAAM,EAAO,EAIb,MAFA,GAAQ,EAED,CACT,EAaa,GAAyB,EAA0B,IAAmB,CACjF,IAAM,EAAU,EAAY,EAI5B,OAFI,IAAY,KAAa,EAAG,EAEzB,EAAa,CAAE,GAAG,EAAS,eAAgB,CAAS,EAAG,CAAE,CAClE,EAgBa,EAAc,GAAmB,EAAa,KAAM,CAAE,EAWtD,EAAe,GAAwC,CAClE,IAAM,EAAM,EAAY,EAEpB,OAAQ,KAIZ,IAFA,EAAI,iBAAiB,CAAM,EAEvB,EAAI,OAAS,WACf,EAAI,aAAa,KAAK,CAAE,SAAQ,QAAS,EAAO,OAAQ,CAAC,OACpD,GAAI,EAAI,OAAS,SAAU,CAChC,IAAM,EAAQ,EAAI,OAElB,EAAO,aAAa,CAAK,EACzB,EAAI,cAAc,QAAU,EAAO,gBAAgB,CAAK,CAAC,EACzD,EAAI,KAAK,IAAI,EAAQ,EAAO,OAAO,CACrC,EACF"}

package/dist/tracking.d.ts

@@ -1,82 +0,0 @@
-import type { ComputedBase, ReactiveBase } from './reactive-base';
-import type { CleanupFn, Subscriber } from './types';
-export declare const tickRevision: () => number;
-export declare const getRevision: () => number;
-export type DepEntry = {
-    source: ReactiveBase<unknown>;
-    version: number;
-};
-/** Called by trackSource to observe each reactive source accessed during a tracked run. */
-export type SourceObserver = (source: ReactiveBase<unknown>) => void;
-export type TrackingCtx = {
-    sourceObserver?: SourceObserver;
-} & ({
-    computed: ComputedBase<unknown>;
-    depCollector: DepEntry[];
-    kind: 'computed';
-} | {
-    cleanups: CleanupFn[];
-    deps: Map<ReactiveBase<unknown>, number>;
-    effect: Subscriber;
-    kind: 'effect';
-    subscriptions: Set<CleanupFn>;
-});
-export type SchedulingState = {
-    activeDirty: 'a' | 'b';
-    batchDepth: number;
-    readonly dirtyWithEffectSubsA: Set<ComputedBase<unknown>>;
-    readonly dirtyWithEffectSubsB: Set<ComputedBase<unknown>>;
-    readonly pendingSubscribers: Set<Subscriber>;
-};
-export declare const createSchedulingState: () => SchedulingState;
-export type ExecutionContext = {
-    readonly scheduling: SchedulingState;
-    readonly scopeCleanups: CleanupFn[] | null;
-    readonly tracking: TrackingCtx | null;
-};
-export type ContextHook = {
-    get(): ExecutionContext;
-    run<T>(ctx: ExecutionContext, fn: () => T): T;
-};
-/** Returns the scheduling-state bucket for the active execution context (module-level singleton outside SSR). */
-export declare const getSchedulingState: () => SchedulingState;
-/** `true` once an SSR context hook is installed — scheduling state is then request-isolated. */
-export declare const hasContextHook: () => boolean;
-export declare const getTracking: () => TrackingCtx | null;
-export declare const withTracking: <T>(tracking: TrackingCtx | null, fn: () => T) => T;
-/**
- * Pushes `cleanups` as the active scope cleanup array for the duration of `fn`.
- * Any `onCleanup()` calls inside `fn` will register into these cleanups.
- * Effects and computed values created inside `fn` are also auto-registered.
- */
-export declare const withScopeCleanups: <T>(cleanups: CleanupFn[], fn: () => T) => T;
-/**
- * Returns the cleanup array of the innermost active scope, or `null` if not inside a scope.
- */
-export declare const getScopeCleanups: () => CleanupFn[] | null;
-/**
- * Registers `dispose` to run when the enclosing effect re-runs/disposes, or —
- * if there is no enclosing effect — when the enclosing scope disposes.
- */
-export declare const autoRegisterDisposal: (dispose: CleanupFn) => void;
-/**
- * Runs `fn` while calling `observer` for every reactive source directly accessed.
- * Used by `debugEffect` to detect which sources changed between runs.
- * No-op if called outside an active tracking context.
- */
-export declare const withSourceObserver: <T>(observer: SourceObserver, fn: () => T) => T;
-/**
- * Runs `fn` without recording any reactive reads as dependencies of the enclosing
- * effect or computed. Useful when you need to read reactive state "silently".
- *
- * @example
- * ```ts
- * effect(() => {
- *   const a = count.value;               // tracked
- *   const b = untrack(() => name.value); // NOT tracked — no re-run when name changes
- * });
- * ```
- */
-export declare const untrack: <T>(fn: () => T) => T;
-export declare const trackSource: (source: ReactiveBase<unknown>) => void;
-//# sourceMappingURL=tracking.d.ts.map

package/dist/tracking.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracking.d.ts","sourceRoot":"","sources":["../src/tracking.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAUrD,eAAO,MAAM,YAAY,QAAO,MAA0B,CAAC;AAC3D,eAAO,MAAM,WAAW,QAAO,MAAwB,CAAC;AAIxD,MAAM,MAAM,QAAQ,GAAG;IACrB,MAAM,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,2FAA2F;AAC3F,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,OAAO,CAAC,KAAK,IAAI,CAAC;AAOrE,MAAM,MAAM,WAAW,GAAG;IACxB,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC,GAAG,CACA;IACE,QAAQ,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IAChC,YAAY,EAAE,QAAQ,EAAE,CAAC;IACzB,IAAI,EAAE,UAAU,CAAC;CAClB,GACD;IACE,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,IAAI,EAAE,GAAG,CAAC,YAAY,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC;IACzC,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,aAAa,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC;CAC/B,CACJ,CAAC;AAiBF,MAAM,MAAM,eAAe,GAAG;IAC5B,WAAW,EAAE,GAAG,GAAG,GAAG,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,oBAAoB,EAAE,GAAG,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1D,QAAQ,CAAC,oBAAoB,EAAE,GAAG,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;IAC1D,QAAQ,CAAC,kBAAkB,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;CAC9C,CAAC;AAEF,eAAO,MAAM,qBAAqB,QAAO,eAMvC,CAAC;AASH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IACrC,QAAQ,CAAC,aAAa,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,IAAI,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,IAAI,gBAAgB,CAAC;IACxB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,gBAAgB,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;CAC/C,CAAC;AAOF,iHAAiH;AACjH,eAAO,MAAM,kBAAkB,QAAO,eAAsC,CAAC;AAE7E,gGAAgG;AAChG,eAAO,MAAM,cAAc,QAAO,OAAyB,CAAC;AAI5D,eAAO,MAAM,WAAW,QAAO,WAAW,GAAG,IAAyB,CAAC;AAEvE,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,UAAU,WAAW,GAAG,IAAI,EAAE,IAAI,MAAM,CAAC,KAAG,CAgB3E,CAAC;AAIF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,EAAE,UAAU,SAAS,EAAE,EAAE,IAAI,MAAM,CAAC,KAAG,CAgBzE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,QAAO,SAAS,EAAE,GAAG,IAA8B,CAAC;AAkBjF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,SAAS,KAAG,IAQzD,CAAC;AAuBF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,UAAU,cAAc,EAAE,IAAI,MAAM,CAAC,KAAG,CAM7E,CAAC;AAIF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,IAAI,MAAM,CAAC,KAAG,CAA2B,CAAC;AAWrE,eAAO,MAAM,WAAW,GAAI,QAAQ,YAAY,CAAC,OAAO,CAAC,KAAG,IAgB3D,CAAC"}

package/dist/tracking.js

@@ -1,76 +0,0 @@
-//#region src/tracking.ts
-var e = 0, t = () => ++e, n = () => e, r = () => ({
-	activeDirty: "a",
-	batchDepth: 0,
-	dirtyWithEffectSubsA: /* @__PURE__ */ new Set(),
-	dirtyWithEffectSubsB: /* @__PURE__ */ new Set(),
-	pendingSubscribers: /* @__PURE__ */ new Set()
-}), i = {
-	scheduling: r(),
-	scopeCleanups: null,
-	tracking: null
-}, a = null, o = () => a === null ? i : a.get(), s = () => o().scheduling, c = () => a !== null, l = () => o().tracking, u = (e, t) => {
-	if (a !== null) {
-		let n = a.get();
-		return a.run({
-			...n,
-			tracking: e
-		}, t);
-	}
-	let n = i;
-	i = {
-		...i,
-		tracking: e
-	};
-	try {
-		return t();
-	} finally {
-		i = n;
-	}
-}, d = (e, t) => {
-	if (a !== null) {
-		let n = a.get();
-		return a.run({
-			...n,
-			scopeCleanups: e
-		}, t);
-	}
-	let n = i;
-	i = {
-		...i,
-		scopeCleanups: e
-	};
-	try {
-		return t();
-	} finally {
-		i = n;
-	}
-}, f = () => o().scopeCleanups, p = (e) => {
-	let t = l();
-	t?.kind === "effect" ? t.cleanups.push(e) : f()?.push(e);
-}, m = (e) => {
-	let t = a;
-	return a = e, t;
-}, h = (e, t) => {
-	let n = l();
-	return n === null ? t() : u({
-		...n,
-		sourceObserver: e
-	}, t);
-}, g = (e) => u(null, e), _ = (e) => {
-	let t = l();
-	if (t !== null) {
-		if (t.sourceObserver?.(e), t.kind === "computed") t.depCollector.push({
-			source: e,
-			version: e.version
-		});
-		else if (t.kind === "effect") {
-			let n = t.effect;
-			e.addEffectSub(n), t.subscriptions.add(() => e.removeEffectSub(n)), t.deps.set(e, e.version);
-		}
-	}
-};
-//#endregion
-export { m as _installContextHook, p as autoRegisterDisposal, r as createSchedulingState, n as getRevision, s as getSchedulingState, f as getScopeCleanups, l as getTracking, c as hasContextHook, t as tickRevision, _ as trackSource, g as untrack, d as withScopeCleanups, h as withSourceObserver, u as withTracking };
-
-//# sourceMappingURL=tracking.js.map

package/dist/tracking.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracking.js","names":[],"sources":["../src/tracking.ts"],"sourcesContent":["import type { ComputedBase, ReactiveBase } from './reactive-base';\nimport type { CleanupFn, Subscriber } from './types';\n\n// ── Global revision clock ─────────────────────────────────────────────────────\n//\n// Monotonically-increasing counter incremented on every signal write.\n// ComputedImpl records the clock value after each successful recompute and uses\n// it as an O(1) \"nothing has changed globally\" fast-path check in refreshIfDirty.\n\nlet globalRevision = 0;\n\nexport const tickRevision = (): number => ++globalRevision;\nexport const getRevision = (): number => globalRevision;\n\n// ── Internal types ────────────────────────────────────────────────────────────\n\nexport type DepEntry = {\n  source: ReactiveBase<unknown>;\n  version: number;\n};\n\n/** Called by trackSource to observe each reactive source accessed during a tracked run. */\nexport type SourceObserver = (source: ReactiveBase<unknown>) => void;\n\n// TrackingCtx carries both dep-collection state AND an optional sourceObserver.\n// Putting the observer inside the context (R12) scopes it to the specific effect/computed\n// run rather than making it a process-wide global — nested computed recomputes use their\n// own context (no observer), so the debugEffect pattern works without identity checks.\n// sourceObserver is shared across both branches and lives outside the discriminant union.\nexport type TrackingCtx = {\n  sourceObserver?: SourceObserver;\n} & (\n  | {\n      computed: ComputedBase<unknown>;\n      depCollector: DepEntry[];\n      kind: 'computed';\n    }\n  | {\n      cleanups: CleanupFn[];\n      deps: Map<ReactiveBase<unknown>, number>;\n      effect: Subscriber;\n      kind: 'effect';\n      subscriptions: Set<CleanupFn>;\n    }\n);\n\n// ── Scheduling state ────────────────────────────────────────────────────────\n//\n// Colocated here (rather than in scheduling.ts) so it can be a field of\n// ExecutionContext without a runtime circular import between tracking.ts and\n// scheduling.ts — scheduling.ts only needs `getSchedulingState()` and the\n// `SchedulingState` type (type-only import, erased at compile time).\n//\n// Isolating this per-request (via the SSR hook) closes the documented gap where\n// concurrent SSR requests share one flush queue: `batchDepth`, `pendingSubscribers`,\n// and the dirty-computed sets are the only scheduling fields that can observably\n// leak across requests (they persist across `await` boundaries via `batch()`\n// spanning shared module-level signals). The propagation epoch/stack in\n// scheduling.ts stay module-level scratch memory — they're only touched within a\n// single synchronous call stack, which JS's run-to-completion model already isolates.\n\nexport type SchedulingState = {\n  activeDirty: 'a' | 'b';\n  batchDepth: number;\n  readonly dirtyWithEffectSubsA: Set<ComputedBase<unknown>>;\n  readonly dirtyWithEffectSubsB: Set<ComputedBase<unknown>>;\n  readonly pendingSubscribers: Set<Subscriber>;\n};\n\nexport const createSchedulingState = (): SchedulingState => ({\n  activeDirty: 'a',\n  batchDepth: 0,\n  dirtyWithEffectSubsA: new Set(),\n  dirtyWithEffectSubsB: new Set(),\n  pendingSubscribers: new Set(),\n});\n\n// ── ExecutionContext ──────────────────────────────────────────────────────────\n//\n// Unified context replaces two separate globals (_tracking and _scopeStack).\n// Both the dep-tracking context and the innermost scope's cleanup array live here.\n// The SSR hook overrides the entire context per-request — fixing the prior bug\n// where scope cleanups were always a process-wide singleton even with the hook.\n\nexport type ExecutionContext = {\n  readonly scheduling: SchedulingState;\n  readonly scopeCleanups: CleanupFn[] | null;\n  readonly tracking: TrackingCtx | null;\n};\n\nexport type ContextHook = {\n  get(): ExecutionContext;\n  run<T>(ctx: ExecutionContext, fn: () => T): T;\n};\n\nlet _ctx: ExecutionContext = { scheduling: createSchedulingState(), scopeCleanups: null, tracking: null };\nlet _hook: ContextHook | null = null;\n\nconst getCtx = (): ExecutionContext => (_hook !== null ? _hook.get() : _ctx);\n\n/** Returns the scheduling-state bucket for the active execution context (module-level singleton outside SSR). */\nexport const getSchedulingState = (): SchedulingState => getCtx().scheduling;\n\n/** `true` once an SSR context hook is installed — scheduling state is then request-isolated. */\nexport const hasContextHook = (): boolean => _hook !== null;\n\n// ── Tracking ──────────────────────────────────────────────────────────────────\n\nexport const getTracking = (): TrackingCtx | null => getCtx().tracking;\n\nexport const withTracking = <T>(tracking: TrackingCtx | null, fn: () => T): T => {\n  if (_hook !== null) {\n    const current = _hook.get();\n\n    return _hook.run({ ...current, tracking }, fn);\n  }\n\n  const prev = _ctx;\n\n  _ctx = { ..._ctx, tracking };\n\n  try {\n    return fn();\n  } finally {\n    _ctx = prev;\n  }\n};\n\n// ── Scope cleanup ─────────────────────────────────────────────────────────────\n\n/**\n * Pushes `cleanups` as the active scope cleanup array for the duration of `fn`.\n * Any `onCleanup()` calls inside `fn` will register into these cleanups.\n * Effects and computed values created inside `fn` are also auto-registered.\n */\nexport const withScopeCleanups = <T>(cleanups: CleanupFn[], fn: () => T): T => {\n  if (_hook !== null) {\n    const current = _hook.get();\n\n    return _hook.run({ ...current, scopeCleanups: cleanups }, fn);\n  }\n\n  const prev = _ctx;\n\n  _ctx = { ..._ctx, scopeCleanups: cleanups };\n\n  try {\n    return fn();\n  } finally {\n    _ctx = prev;\n  }\n};\n\n/**\n * Returns the cleanup array of the innermost active scope, or `null` if not inside a scope.\n */\nexport const getScopeCleanups = (): CleanupFn[] | null => getCtx().scopeCleanups;\n\n// ── Auto-disposal ───────────────────────────────────────────────────────────────\n//\n// Shared by every primitive that ties its own lifetime to the context it was\n// created in (computed(), resource()): dispose when the enclosing effect re-runs\n// or disposes, or — if not inside an effect — when the enclosing scope disposes.\n// No-op if neither is active (the caller owns disposal directly).\n//\n// Why signal() and store() don't call this: computed()/resource() are *derived*\n// computations — recreating one on every effect re-run is normal and cheap, so\n// tying their lifetime to the enclosing context avoids leaking a fresh graph\n// node per run. signal()/store() hold raw, caller-owned state that is typically\n// created once and read across many effect re-runs; auto-disposing it on the\n// first re-run would silently break any effect that reads a signal it declared\n// itself. Callers who genuinely want scope-scoped state should use\n// `scope.add(() => mySignal.dispose())` explicitly.\n\n/**\n * Registers `dispose` to run when the enclosing effect re-runs/disposes, or —\n * if there is no enclosing effect — when the enclosing scope disposes.\n */\nexport const autoRegisterDisposal = (dispose: CleanupFn): void => {\n  const ctx = getTracking();\n\n  if (ctx?.kind === 'effect') {\n    ctx.cleanups.push(dispose);\n  } else {\n    getScopeCleanups()?.push(dispose);\n  }\n};\n\n// ── Context hook (for SSR) ────────────────────────────────────────────────────\n\n/**\n * @internal Used only by `/ripple/ssr`.\n * Installs a context hook that overrides both tracking and scope-cleanup access.\n * Returns the previous hook so callers can restore it.\n */\nexport const _installContextHook = (hook: ContextHook | null): ContextHook | null => {\n  const prev = _hook;\n\n  _hook = hook;\n\n  return prev;\n};\n\n// ── Source observer ───────────────────────────────────────────────────────────\n//\n// Observer is now scoped to the active TrackingCtx instead of a process-wide global.\n// This means it only fires for direct deps of the current effect/computed — nested\n// computed recomputes use their own context (no observer) so no identity check needed.\n\n/**\n * Runs `fn` while calling `observer` for every reactive source directly accessed.\n * Used by `debugEffect` to detect which sources changed between runs.\n * No-op if called outside an active tracking context.\n */\nexport const withSourceObserver = <T>(observer: SourceObserver, fn: () => T): T => {\n  const current = getTracking();\n\n  if (current === null) return fn();\n\n  return withTracking({ ...current, sourceObserver: observer }, fn);\n};\n\n// ── untrack ───────────────────────────────────────────────────────────────────\n\n/**\n * Runs `fn` without recording any reactive reads as dependencies of the enclosing\n * effect or computed. Useful when you need to read reactive state \"silently\".\n *\n * @example\n * ```ts\n * effect(() => {\n *   const a = count.value;               // tracked\n *   const b = untrack(() => name.value); // NOT tracked — no re-run when name changes\n * });\n * ```\n */\nexport const untrack = <T>(fn: () => T): T => withTracking(null, fn);\n\n// ── trackSource ───────────────────────────────────────────────────────────────\n//\n// Records `source` as a dependency of the currently active tracking context.\n// For computed contexts: only records the dep entry — addComputedSub is called\n// later by updateDeps() in computed.ts (only for genuinely NEW deps, preventing\n// duplicate WeakRef entries).\n// For effect contexts: immediately subscribes the effect to the source and\n// records the dep for getDependencies().\n\nexport const trackSource = (source: ReactiveBase<unknown>): void => {\n  const ctx = getTracking();\n\n  if (ctx === null) return;\n\n  ctx.sourceObserver?.(source);\n\n  if (ctx.kind === 'computed') {\n    ctx.depCollector.push({ source, version: source.version });\n  } else if (ctx.kind === 'effect') {\n    const owner = ctx.effect;\n\n    source.addEffectSub(owner);\n    ctx.subscriptions.add(() => source.removeEffectSub(owner));\n    ctx.deps.set(source, source.version);\n  }\n};\n"],"mappings":";AASA,IAAI,IAAiB,GAER,UAA6B,EAAE,GAC/B,UAA4B,GAyD5B,WAAgD;CAC3D,aAAa;CACb,YAAY;CACZ,sCAAsB,IAAI,IAAI;CAC9B,sCAAsB,IAAI,IAAI;CAC9B,oCAAoB,IAAI,IAAI;AAC9B,IAoBI,IAAyB;CAAE,YAAY,EAAsB;CAAG,eAAe;CAAM,UAAU;AAAK,GACpG,IAA4B,MAE1B,UAAkC,MAAU,OAAqB,IAAd,EAAM,IAAI,GAGtD,UAA4C,EAAO,CAAC,CAAC,YAGrD,UAAgC,MAAU,MAI1C,UAAwC,EAAO,CAAC,CAAC,UAEjD,KAAmB,GAA8B,MAAmB;CAC/E,IAAI,MAAU,MAAM;EAClB,IAAM,IAAU,EAAM,IAAI;EAE1B,OAAO,EAAM,IAAI;GAAE,GAAG;GAAS;EAAS,GAAG,CAAE;CAC/C;CAEA,IAAM,IAAO;CAEb,IAAO;EAAE,GAAG;EAAM;CAAS;CAE3B,IAAI;EACF,OAAO,EAAG;CACZ,UAAU;EACR,IAAO;CACT;AACF,GASa,KAAwB,GAAuB,MAAmB;CAC7E,IAAI,MAAU,MAAM;EAClB,IAAM,IAAU,EAAM,IAAI;EAE1B,OAAO,EAAM,IAAI;GAAE,GAAG;GAAS,eAAe;EAAS,GAAG,CAAE;CAC9D;CAEA,IAAM,IAAO;CAEb,IAAO;EAAE,GAAG;EAAM,eAAe;CAAS;CAE1C,IAAI;EACF,OAAO,EAAG;CACZ,UAAU;EACR,IAAO;CACT;AACF,GAKa,UAA6C,EAAO,CAAC,CAAC,eAsBtD,KAAwB,MAA6B;CAChE,IAAM,IAAM,EAAY;CAExB,AAAI,GAAK,SAAS,WAChB,EAAI,SAAS,KAAK,CAAO,IAEzB,EAAiB,CAAC,EAAE,KAAK,CAAO;AAEpC,GASa,KAAuB,MAAiD;CACnF,IAAM,IAAO;CAIb,OAFA,IAAQ,GAED;AACT,GAaa,KAAyB,GAA0B,MAAmB;CACjF,IAAM,IAAU,EAAY;CAI5B,OAFI,MAAY,OAAa,EAAG,IAEzB,EAAa;EAAE,GAAG;EAAS,gBAAgB;CAAS,GAAG,CAAE;AAClE,GAgBa,KAAc,MAAmB,EAAa,MAAM,CAAE,GAWtD,KAAe,MAAwC;CAClE,IAAM,IAAM,EAAY;CAEpB,UAAQ,MAIZ;MAFA,EAAI,iBAAiB,CAAM,GAEvB,EAAI,SAAS,YACf,EAAI,aAAa,KAAK;GAAE;GAAQ,SAAS,EAAO;EAAQ,CAAC;OACpD,IAAI,EAAI,SAAS,UAAU;GAChC,IAAM,IAAQ,EAAI;GAIlB,AAFA,EAAO,aAAa,CAAK,GACzB,EAAI,cAAc,UAAU,EAAO,gBAAgB,CAAK,CAAC,GACzD,EAAI,KAAK,IAAI,GAAQ,EAAO,OAAO;EACrC;;AACF"}

package/dist/utilities.cjs

@@ -1,2 +0,0 @@
-const e=require("./tracking.cjs"),t=require("./symbols.cjs");var n=e=>({get disposed(){return e.disposed},[t.IS_SIGNAL]:!0,get name(){return e.name},peek(){return e.peek()},subscribe(t){return e.subscribe(t)},get value(){return e.value}}),r=e=>typeof e==`object`&&!!e&&!!e[t.IS_SIGNAL],i=e=>r(e)&&!e[t.IS_COMPUTED]&&!e[t.IS_STORE],a=e=>typeof e==`object`&&!!e&&!!e[t.IS_COMPUTED],o=e=>typeof e==`object`&&!!e&&!!e[t.IS_STORE];exports.isComputed=a,exports.isReactive=r,exports.isSignal=i,exports.isStore=o,exports.readonly=n,exports.untrack=e.untrack;
-//# sourceMappingURL=utilities.cjs.map

package/dist/utilities.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"utilities.cjs","names":[],"sources":["../src/utilities.ts"],"sourcesContent":["import type { Computed, Readable, Signal } from './types';\n\nimport { IS_COMPUTED, IS_SIGNAL, IS_STORE } from './symbols';\nimport { untrack } from './tracking';\n\nexport { untrack };\n\n// ── Readonly wrapper ──────────────────────────────────────────────────────────\n//\n// readonly() returns Readable<T> — no dispose() because the wrapper does not\n// own the source. Callers retain ownership and must dispose the source themselves.\n// The [IS_SIGNAL] brand is set so isReactive(readonly(s)) and isSignal(readonly(s))\n// both return true (it is reactive, not IS_COMPUTED, not IS_STORE).\n// [IS_COMPUTED] is intentionally NOT set — the wrapper is not a Computed<T>\n// and does not have dispose().\n\n/**\n * Wraps a reactive value to produce a structurally read-only view.\n * The `value` setter is hidden. Delegates reads directly to the source —\n * no extra reactive graph node, no extra subscription.\n *\n * The caller retains ownership of the source and is responsible for disposing it.\n *\n * @example\n * ```ts\n * const count = signal(0);\n * const readCount = readonly(count);\n * readCount.value; // fine — tracks dep on count\n * // readCount.value = 1; // TypeScript error — Readable has no setter\n * ```\n */\nexport const readonly = <T>(source: Readable<T>): Readable<T> => {\n  const wrapper = {\n    get disposed(): boolean {\n      return source.disposed;\n    },\n    [IS_SIGNAL]: true as const,\n    get name(): string | undefined {\n      return source.name;\n    },\n    peek(): T {\n      return source.peek();\n    },\n    subscribe(listener: () => void) {\n      return source.subscribe(listener);\n    },\n    get value(): T {\n      return source.value;\n    },\n  };\n\n  return wrapper as unknown as Readable<T>;\n};\n\n// ── Type guards ───────────────────────────────────────────────────────────────\n\n/**\n * Returns `true` for any reactive value that implements `Readable<T>` — including\n * `signal()`, `computed()`, `store()`, and `readonly()` wrappers.\n *\n * This is the broad \"is this value reactive?\" check. Use `isSignal` for writable-only\n * signals, or `isComputed` to narrow to computed values.\n *\n * @example\n * ```ts\n * isReactive(signal(0))            // true\n * isReactive(computed(() => 1))    // true\n * isReactive(store({ x: 0 }))     // true\n * isReactive(readonly(signal(0)))  // true\n * isReactive({})                   // false\n * ```\n */\nexport const isReactive = <T = unknown>(value: unknown): value is Readable<T> =>\n  typeof value === 'object' && value !== null && !!(value as Record<typeof IS_SIGNAL, unknown>)[IS_SIGNAL];\n\n/**\n * Returns `true` only for writable `Signal<T>` values — excludes `computed()` and `store()`.\n * `readonly()` wrappers of a signal still report `true` since they carry the same\n * `IS_SIGNAL` brand as their source (they are not `IS_COMPUTED`/`IS_STORE`).\n *\n * Use `isReactive` for the broad \"is this reactive?\" check.\n *\n * @example\n * ```ts\n * isSignal(signal(0))            // true\n * isSignal(computed(() => 1))    // false — computed excluded\n * isSignal(store({ x: 0 }))     // false — store excluded\n * isSignal(readonly(signal(0)))  // true — readonly has IS_SIGNAL, not IS_COMPUTED/IS_STORE\n * isSignal({})                   // false\n * ```\n */\nexport const isSignal = <T = unknown>(value: unknown): value is Signal<T> =>\n  isReactive(value) &&\n  !(value as unknown as Record<typeof IS_COMPUTED, unknown>)[IS_COMPUTED] &&\n  !(value as unknown as Record<typeof IS_STORE, unknown>)[IS_STORE];\n\nexport const isComputed = <T = unknown>(value: unknown): value is Computed<T> =>\n  typeof value === 'object' && value !== null && !!(value as Record<typeof IS_COMPUTED, unknown>)[IS_COMPUTED];\n\nexport const isStore = <T extends object = object>(value: unknown): value is import('./types').Store<T> =>\n  typeof value === 'object' && value !== null && !!(value as Record<typeof IS_STORE, unknown>)[IS_STORE];\n"],"mappings":"6DA+BA,IAAa,EAAe,IAoBnB,CAlBL,IAAI,UAAoB,CACtB,OAAO,EAAO,QAChB,GACC,EAAA,WAAY,GACb,IAAI,MAA2B,CAC7B,OAAO,EAAO,IAChB,EACA,MAAU,CACR,OAAO,EAAO,KAAK,CACrB,EACA,UAAU,EAAsB,CAC9B,OAAO,EAAO,UAAU,CAAQ,CAClC,EACA,IAAI,OAAW,CACb,OAAO,EAAO,KAChB,CAGK,GAqBI,EAA2B,GACtC,OAAO,GAAU,YAAY,GAAkB,CAAC,CAAE,EAA4C,EAAA,WAkBnF,EAAyB,GACpC,EAAW,CAAK,GAChB,CAAE,EAAyD,EAAA,cAC3D,CAAE,EAAsD,EAAA,UAE7C,EAA2B,GACtC,OAAO,GAAU,YAAY,GAAkB,CAAC,CAAE,EAA8C,EAAA,aAErF,EAAsC,GACjD,OAAO,GAAU,YAAY,GAAkB,CAAC,CAAE,EAA2C,EAAA"}

package/dist/utilities.d.ts

@@ -1,56 +0,0 @@
-import type { Computed, Readable, Signal } from './types';
-import { untrack } from './tracking';
-export { untrack };
-/**
- * Wraps a reactive value to produce a structurally read-only view.
- * The `value` setter is hidden. Delegates reads directly to the source —
- * no extra reactive graph node, no extra subscription.
- *
- * The caller retains ownership of the source and is responsible for disposing it.
- *
- * @example
- * ```ts
- * const count = signal(0);
- * const readCount = readonly(count);
- * readCount.value; // fine — tracks dep on count
- * // readCount.value = 1; // TypeScript error — Readable has no setter
- * ```
- */
-export declare const readonly: <T>(source: Readable<T>) => Readable<T>;
-/**
- * Returns `true` for any reactive value that implements `Readable<T>` — including
- * `signal()`, `computed()`, `store()`, and `readonly()` wrappers.
- *
- * This is the broad "is this value reactive?" check. Use `isSignal` for writable-only
- * signals, or `isComputed` to narrow to computed values.
- *
- * @example
- * ```ts
- * isReactive(signal(0))            // true
- * isReactive(computed(() => 1))    // true
- * isReactive(store({ x: 0 }))     // true
- * isReactive(readonly(signal(0)))  // true
- * isReactive({})                   // false
- * ```
- */
-export declare const isReactive: <T = unknown>(value: unknown) => value is Readable<T>;
-/**
- * Returns `true` only for writable `Signal<T>` values — excludes `computed()` and `store()`.
- * `readonly()` wrappers of a signal still report `true` since they carry the same
- * `IS_SIGNAL` brand as their source (they are not `IS_COMPUTED`/`IS_STORE`).
- *
- * Use `isReactive` for the broad "is this reactive?" check.
- *
- * @example
- * ```ts
- * isSignal(signal(0))            // true
- * isSignal(computed(() => 1))    // false — computed excluded
- * isSignal(store({ x: 0 }))     // false — store excluded
- * isSignal(readonly(signal(0)))  // true — readonly has IS_SIGNAL, not IS_COMPUTED/IS_STORE
- * isSignal({})                   // false
- * ```
- */
-export declare const isSignal: <T = unknown>(value: unknown) => value is Signal<T>;
-export declare const isComputed: <T = unknown>(value: unknown) => value is Computed<T>;
-export declare const isStore: <T extends object = object>(value: unknown) => value is import("./types").Store<T>;
-//# sourceMappingURL=utilities.d.ts.map

package/dist/utilities.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../src/utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAG1D,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAErC,OAAO,EAAE,OAAO,EAAE,CAAC;AAWnB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,QAAQ,QAAQ,CAAC,CAAC,CAAC,KAAG,QAAQ,CAAC,CAAC,CAqB3D,CAAC;AAIF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,GAAG,OAAO,EAAE,OAAO,OAAO,KAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,CAC8B,CAAC;AAE3G;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,GAAG,OAAO,EAAE,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,CAAC,CAGL,CAAC;AAEpE,eAAO,MAAM,UAAU,GAAI,CAAC,GAAG,OAAO,EAAE,OAAO,OAAO,KAAG,KAAK,IAAI,QAAQ,CAAC,CAAC,CACkC,CAAC;AAE/G,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,OAAO,OAAO,KAAG,KAAK,IAAI,OAAO,SAAS,EAAE,KAAK,CAAC,CAAC,CACE,CAAC"}

package/dist/utilities.js

@@ -1,25 +0,0 @@
-import { untrack as e } from "./tracking.js";
-import { IS_COMPUTED as t, IS_SIGNAL as n, IS_STORE as r } from "./symbols.js";
-//#region src/utilities.ts
-var i = (e) => ({
-	get disposed() {
-		return e.disposed;
-	},
-	[n]: !0,
-	get name() {
-		return e.name;
-	},
-	peek() {
-		return e.peek();
-	},
-	subscribe(t) {
-		return e.subscribe(t);
-	},
-	get value() {
-		return e.value;
-	}
-}), a = (e) => typeof e == "object" && !!e && !!e[n], o = (e) => a(e) && !e[t] && !e[r], s = (e) => typeof e == "object" && !!e && !!e[t], c = (e) => typeof e == "object" && !!e && !!e[r];
-//#endregion
-export { s as isComputed, a as isReactive, o as isSignal, c as isStore, i as readonly, e as untrack };
-
-//# sourceMappingURL=utilities.js.map

package/dist/utilities.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utilities.js","names":[],"sources":["../src/utilities.ts"],"sourcesContent":["import type { Computed, Readable, Signal } from './types';\n\nimport { IS_COMPUTED, IS_SIGNAL, IS_STORE } from './symbols';\nimport { untrack } from './tracking';\n\nexport { untrack };\n\n// ── Readonly wrapper ──────────────────────────────────────────────────────────\n//\n// readonly() returns Readable<T> — no dispose() because the wrapper does not\n// own the source. Callers retain ownership and must dispose the source themselves.\n// The [IS_SIGNAL] brand is set so isReactive(readonly(s)) and isSignal(readonly(s))\n// both return true (it is reactive, not IS_COMPUTED, not IS_STORE).\n// [IS_COMPUTED] is intentionally NOT set — the wrapper is not a Computed<T>\n// and does not have dispose().\n\n/**\n * Wraps a reactive value to produce a structurally read-only view.\n * The `value` setter is hidden. Delegates reads directly to the source —\n * no extra reactive graph node, no extra subscription.\n *\n * The caller retains ownership of the source and is responsible for disposing it.\n *\n * @example\n * ```ts\n * const count = signal(0);\n * const readCount = readonly(count);\n * readCount.value; // fine — tracks dep on count\n * // readCount.value = 1; // TypeScript error — Readable has no setter\n * ```\n */\nexport const readonly = <T>(source: Readable<T>): Readable<T> => {\n  const wrapper = {\n    get disposed(): boolean {\n      return source.disposed;\n    },\n    [IS_SIGNAL]: true as const,\n    get name(): string | undefined {\n      return source.name;\n    },\n    peek(): T {\n      return source.peek();\n    },\n    subscribe(listener: () => void) {\n      return source.subscribe(listener);\n    },\n    get value(): T {\n      return source.value;\n    },\n  };\n\n  return wrapper as unknown as Readable<T>;\n};\n\n// ── Type guards ───────────────────────────────────────────────────────────────\n\n/**\n * Returns `true` for any reactive value that implements `Readable<T>` — including\n * `signal()`, `computed()`, `store()`, and `readonly()` wrappers.\n *\n * This is the broad \"is this value reactive?\" check. Use `isSignal` for writable-only\n * signals, or `isComputed` to narrow to computed values.\n *\n * @example\n * ```ts\n * isReactive(signal(0))            // true\n * isReactive(computed(() => 1))    // true\n * isReactive(store({ x: 0 }))     // true\n * isReactive(readonly(signal(0)))  // true\n * isReactive({})                   // false\n * ```\n */\nexport const isReactive = <T = unknown>(value: unknown): value is Readable<T> =>\n  typeof value === 'object' && value !== null && !!(value as Record<typeof IS_SIGNAL, unknown>)[IS_SIGNAL];\n\n/**\n * Returns `true` only for writable `Signal<T>` values — excludes `computed()` and `store()`.\n * `readonly()` wrappers of a signal still report `true` since they carry the same\n * `IS_SIGNAL` brand as their source (they are not `IS_COMPUTED`/`IS_STORE`).\n *\n * Use `isReactive` for the broad \"is this reactive?\" check.\n *\n * @example\n * ```ts\n * isSignal(signal(0))            // true\n * isSignal(computed(() => 1))    // false — computed excluded\n * isSignal(store({ x: 0 }))     // false — store excluded\n * isSignal(readonly(signal(0)))  // true — readonly has IS_SIGNAL, not IS_COMPUTED/IS_STORE\n * isSignal({})                   // false\n * ```\n */\nexport const isSignal = <T = unknown>(value: unknown): value is Signal<T> =>\n  isReactive(value) &&\n  !(value as unknown as Record<typeof IS_COMPUTED, unknown>)[IS_COMPUTED] &&\n  !(value as unknown as Record<typeof IS_STORE, unknown>)[IS_STORE];\n\nexport const isComputed = <T = unknown>(value: unknown): value is Computed<T> =>\n  typeof value === 'object' && value !== null && !!(value as Record<typeof IS_COMPUTED, unknown>)[IS_COMPUTED];\n\nexport const isStore = <T extends object = object>(value: unknown): value is import('./types').Store<T> =>\n  typeof value === 'object' && value !== null && !!(value as Record<typeof IS_STORE, unknown>)[IS_STORE];\n"],"mappings":";;;AA+BA,IAAa,KAAe,OAoBnB;CAlBL,IAAI,WAAoB;EACtB,OAAO,EAAO;CAChB;EACC,IAAY;CACb,IAAI,OAA2B;EAC7B,OAAO,EAAO;CAChB;CACA,OAAU;EACR,OAAO,EAAO,KAAK;CACrB;CACA,UAAU,GAAsB;EAC9B,OAAO,EAAO,UAAU,CAAQ;CAClC;CACA,IAAI,QAAW;EACb,OAAO,EAAO;CAChB;AAGK,IAqBI,KAA2B,MACtC,OAAO,KAAU,cAAY,KAAkB,CAAC,CAAE,EAA4C,IAkBnF,KAAyB,MACpC,EAAW,CAAK,KAChB,CAAE,EAAyD,MAC3D,CAAE,EAAsD,IAE7C,KAA2B,MACtC,OAAO,KAAU,cAAY,KAAkB,CAAC,CAAE,EAA8C,IAErF,KAAsC,MACjD,OAAO,KAAU,cAAY,KAAkB,CAAC,CAAE,EAA2C"}