react-fine-grained-signals 0.1.0 → 0.2.0

package/dist/core-runtime-2jSE9Tz5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-runtime-2jSE9Tz5.js","names":["READABLE_INTEROP_V1","READABLE_INTEROP_V1","READABLE_INTEROP_V1","collector","READABLE_INTEROP_V1"],"sources":["../src/core/execution-owner.ts","../src/core/interop-context.mts","../src/core/foreign-readable-v1.mts","../src/core/interop.ts","../src/core/render-tracking.ts","../src/core/signal-brand.ts","../src/core/alien-derived-runtime-core.mts","../src/core/render-runtime.mts","../src/core/reactive-runtime.ts","../src/core/core-runtime.ts"],"sourcesContent":["declare const untrackedOwnerBrand: unique symbol;\nexport const UNTRACKED_OWNER = Symbol.for(\n  \"react-fine-grained-signals.untracked-owner.v2\",\n) as typeof untrackedOwnerBrand;\n\n/** Shared lexical owner for graph, render, and explicitly untracked reads. */\nexport type ExecutionOwnerV2 =\n  | GraphExecutionOwnerV2\n  | RenderExecutionOwnerV2;\n\nexport type ExecutionContextOwnerV2 = ExecutionOwnerV2 | typeof UNTRACKED_OWNER;\n\nexport interface GraphExecutionOwnerV2 {\n  readonly version: 2;\n  readonly kind: \"graph\";\n  readonly runtimeToken: object;\n  add(protocol: ReadableProtocolV1, revision: number): void;\n  /**\n   * Adopts an effect another copy created while this owner's effect or\n   * computed runs: `dispose` is called when that owner next re-runs or is\n   * disposed. Optional so an owner without it leaves the effect unowned.\n   */\n  own?(dispose: () => void): void;\n}\n\nexport interface RenderExecutionOwnerV2 {\n  readonly version: 2;\n  readonly kind: \"render\";\n  readonly scopePolicy?: \"managed\" | \"bare\";\n  readonly runtimeToken: object;\n  closeScope?(): void;\n  add(protocol: ReadableProtocolV1, revision: number): void;\n  isSpeculative?(): boolean;\n  markSpeculativeDeepRead?(): void;\n  /** As on the graph owner: adopts an effect created by a speculative getter. */\n  own?(dispose: () => void): void;\n}\n\nexport interface ReadableProtocolV1 {\n  readonly version: 1;\n  readonly runtimeToken: object;\n  getRevision(): number;\n  subscribe(listener: (revision: number) => void): {\n    unsubscribe(): void;\n    revision: number;\n  };\n}\n\nexport function isGraphExecutionOwner(\n  owner: ExecutionContextOwnerV2 | undefined,\n): owner is GraphExecutionOwnerV2 {\n  return typeof owner === \"object\" && owner !== null && owner.kind === \"graph\";\n}\n\nexport function isRenderExecutionOwner(\n  owner: ExecutionContextOwnerV2 | undefined,\n): owner is RenderExecutionOwnerV2 {\n  return typeof owner === \"object\" && owner !== null && owner.kind === \"render\";\n}\n\ninterface ExecutionContextV2 {\n  readonly version: 2;\n  owner: ExecutionContextOwnerV2 | undefined;\n  frames: Array<{ owner: ExecutionOwnerV2; active: boolean }>;\n}\n\nconst CONTEXT_KEY = Symbol.for(\"react-fine-grained-signals.shared-execution-owner.v2\");\n\nconst globalObject = globalThis as typeof globalThis & Record<symbol, unknown>;\nconst existing = globalObject[CONTEXT_KEY] as ExecutionContextV2 | undefined;\nif (existing !== undefined && existing.version !== 2) {\n  throw new Error(\"Incompatible RFSG shared execution owner\");\n}\n\nexport const executionContext: ExecutionContextV2 = existing ?? {\n  version: 2,\n  owner: undefined,\n  frames: [],\n};\nexecutionContext.frames ??= [];\nif (existing === undefined) {\n  Object.defineProperty(globalObject, CONTEXT_KEY, {\n    value: executionContext,\n    enumerable: false,\n    configurable: false,\n    writable: false,\n  });\n}\n\nexport function withExecutionOwner<T>(owner: ExecutionOwnerV2, callback: () => T): T {\n  const restore = pushExecutionOwner(owner);\n  try {\n    return callback();\n  } finally {\n    restore();\n  }\n}\n\n/** Temporarily changes lexical ownership inside one synchronous call. */\nexport function withSynchronousExecutionOwner<T>(\n  owner: ExecutionContextOwnerV2,\n  callback: () => T,\n): T {\n  const previous = executionContext.owner;\n  executionContext.owner = owner;\n  try {\n    return callback();\n  } finally {\n    executionContext.owner = previous;\n  }\n}\n\nexport function pushExecutionOwner(owner: ExecutionOwnerV2): () => void {\n  const frame = { owner, active: true };\n  executionContext.frames.push(frame);\n  executionContext.owner = owner;\n  let active = true;\n  return () => {\n    if (!active) return;\n    active = false;\n    frame.active = false;\n    while (executionContext.frames.at(-1)?.active === false) executionContext.frames.pop();\n    executionContext.owner = executionContext.frames.at(-1)?.owner;\n  };\n}\n","export const READABLE_INTEROP_V1 = Symbol.for(\"react-fine-grained-signals.readable-interop.v1\");\n","import { READABLE_INTEROP_V1 } from \"./interop-context.mjs\";\nimport { UNTRACKED_OWNER, executionContext, withSynchronousExecutionOwner } from \"./execution-owner.js\";\nimport type { ExecutionContextOwnerV2, ReadableProtocolV1 } from \"./execution-owner.js\";\nimport { isGraphExecutionOwner, isRenderExecutionOwner } from \"./execution-owner.js\";\nimport type { ForeignReadableAdapterOptions, RuntimeNode } from \"./alien-derived-types.js\";\n\ninterface CandidateReadable {\n  readonly value: unknown;\n}\n\n/** A render owner records another copy's read under its protocol object itself. */\nexport function isReadableProtocol(value: unknown): value is ReadableProtocolV1 {\n  return typeof value === \"object\" && value !== null\n    && Reflect.get(value, \"version\") === 1\n    && typeof Reflect.get(value, \"getRevision\") === \"function\"\n    && typeof Reflect.get(value, \"subscribe\") === \"function\";\n}\n\nfunction observeRevision(node: RuntimeNode): number {\n  return node.renderRevision ??= 0;\n}\n\n// Owns the cross-copy readable protocol and its bridge nodes. Graph scheduling,\n// linking, and propagation remain in the single Alien-derived graph core.\nexport function createForeignReadableAdapter({\n  runtimeToken,\n  makeNode,\n  mutableFlag,\n  dirtyFlag,\n  getActiveSubscriber,\n  link,\n  propagate,\n  shallowPropagate,\n  flush,\n  isRunning,\n  isBatching,\n  effect,\n  own,\n}: ForeignReadableAdapterOptions) {\n  const readableNodes = new WeakMap<object, RuntimeNode>();\n  const foreignNodes = new WeakMap<ReadableProtocolV1, RuntimeNode>();\n  const localReadable = Symbol(\"localReadable\");\n  type LocalReadableProtocol = ReadableProtocolV1 & { readonly [localReadable]: CandidateReadable };\n\n  function getLocalReadableRevision(this: LocalReadableProtocol): number {\n    const readable = this[localReadable];\n    const node = readableNodes.get(readable)!;\n    try { withSynchronousExecutionOwner(UNTRACKED_OWNER, () => readable.value); }\n    catch { /* Revisions remain observable while computed read errors are cached. */ }\n    return observeRevision(node);\n  }\n\n  function subscribeLocalReadable(this: LocalReadableProtocol, listener: (revision: number) => void) {\n    const readable = this[localReadable];\n    const node = readableNodes.get(readable)!;\n    const revision = observeRevision(node);\n    let initial = true;\n    const unsubscribe = effect(() => {\n      try { readable.value; } catch { /* Keep errored computed boundaries observed. */ }\n      if (initial) initial = false;\n      else listener(observeRevision(node));\n    });\n    return { unsubscribe, revision };\n  }\n\n  // A bridge is a source whose value is the other copy's revision. Like a\n  // source write, every newly learned revision -- pushed, read, or polled --\n  // marks it Dirty and propagates to its subscribers, so `pendingRevision`\n  // never advances past a revision its subscribers were not told about (a\n  // silent advance would make the later push look stale and drop it).\n  function advance(node: RuntimeNode, revision: number): boolean {\n    if (revision === node.pendingRevision) return false;\n    node.pendingRevision = revision;\n    node.flags = mutableFlag | dirtyFlag;\n    if (node.subs !== undefined) propagate(node.subs, isRunning());\n    return true;\n  }\n\n  // A revision this copy learns by reading rather than by push: advance, then\n  // settle at once, as a source read settles a pending write, so the reader\n  // and later checks see a committed bridge instead of a change they already\n  // observed. Effects it queues run when the push (or the next flush) arrives.\n  function observeForeignRevision(node: RuntimeNode, revision: number): void {\n    if (advance(node, revision)) {\n      node.revision = revision;\n      node.flags = mutableFlag;\n      if (node.subs !== undefined) shallowPropagate(node.subs);\n    }\n  }\n\n  function ensureForeignNode(protocol: ReadableProtocolV1, observedRevision: number): RuntimeNode {\n    let node = foreignNodes.get(protocol);\n    if (node === undefined) {\n      node = makeNode(\"external\", mutableFlag, {\n        protocol,\n        revision: observedRevision,\n        pendingRevision: observedRevision,\n        unsubscribe: undefined,\n      });\n      foreignNodes.set(protocol, node);\n    }\n    // Before linking, so the reader itself is not invalidated by what it read.\n    observeForeignRevision(node, observedRevision);\n    const subscriber = getActiveSubscriber();\n    if (subscriber?.kind === \"computed\") subscriber.foreignDependent = true;\n    if (subscriber !== undefined) link(node, subscriber);\n    // A handshake that finds the source already past the revision this effect\n    // just read marks it stale (bit 128), so its first run is retried once it\n    // finishes; see `effect()` in alien-derived-runtime-core.mts.\n    if (subscriber?.kind === \"effect\" && activateForeignNode(node)) subscriber.flags |= 128;\n    return node;\n  }\n\n  // Returns true when the subscription reports a revision newer than the one\n  // this copy last observed.\n  function activateForeignNode(node: RuntimeNode): boolean | undefined {\n    if (node.unsubscribe === undefined) {\n      const protocol = node.protocol;\n      const subscription = protocol!.subscribe((revision) => {\n        if (revision !== node.revision) advance(node, revision);\n        // Flush even for a revision a read already learned: that read only\n        // queued the bridge's effects.\n        if (!isBatching()) flush();\n      });\n      node.unsubscribe = subscription.unsubscribe;\n      if (advance(node, subscription.revision)) {\n        if (!isBatching()) flush();\n        return true;\n      }\n    }\n  }\n\n  const graphOwner = {\n    version: 2 as const,\n    kind: \"graph\" as const,\n    runtimeToken,\n    add(protocol: ReadableProtocolV1, revision: number) { ensureForeignNode(protocol, revision); },\n    own,\n  };\n\n  function withGraphOwner<T>(callback: () => T): T {\n    const owner = executionContext.owner;\n    if (isGraphExecutionOwner(owner) && owner.runtimeToken === runtimeToken) return callback();\n    return withSynchronousExecutionOwner(graphOwner, callback);\n  }\n\n  function publishForeignReadable(readable: object, node: RuntimeNode, owner: ExecutionContextOwnerV2 | undefined): void {\n    if (owner === UNTRACKED_OWNER || ((isGraphExecutionOwner(owner) || isRenderExecutionOwner(owner)) && owner.runtimeToken === runtimeToken)) return;\n    const protocol = node.readableProtocol;\n    if (protocol !== undefined) {\n      if (isGraphExecutionOwner(owner) || isRenderExecutionOwner(owner)) owner.add(protocol, observeRevision(node));\n    }\n  }\n\n  function attachProtocol(readable: CandidateReadable, node: RuntimeNode): void {\n    readableNodes.set(readable, node);\n    const protocol: LocalReadableProtocol = {\n      version: 1 as const,\n      runtimeToken,\n      [localReadable]: readable,\n      getRevision: getLocalReadableRevision,\n      subscribe: subscribeLocalReadable,\n    };\n    node.readableProtocol = protocol;\n    Object.defineProperty(readable, READABLE_INTEROP_V1, {\n      value: protocol,\n      enumerable: false,\n      writable: false,\n      configurable: false,\n    });\n  }\n\n  function getReadableRevision(readable: object): number {\n    const node = readableNodes.get(readable);\n    if (node !== undefined) return observeRevision(node);\n    const protocolValue: unknown = Reflect.get(readable, READABLE_INTEROP_V1);\n    if (isReadableProtocol(protocolValue)) return protocolValue.getRevision();\n    throw new TypeError(\"Unknown candidate readable\");\n  }\n\n  return {\n    attachProtocol,\n    ensureForeignNode,\n    activateForeignNode,\n    observeForeignRevision,\n    getNodeForReadable: (value: object) => readableNodes.get(value),\n    getReadableRevision,\n    observeRevision,\n    publishForeignReadable,\n    graphOwner,\n    withGraphOwner,\n  };\n}\n","/** Internal, same-global communication for independently instantiated runtimes. */\nexport interface ReadableInteropV1 {\n  readonly version: 1;\n  readonly runtimeToken: object;\n  getRevision(): number;\n  subscribe(listener: (revision: number) => void): {\n    unsubscribe(): void;\n    revision: number;\n  };\n}\n\nexport interface InteropGraphCollectorV1 {\n  readonly runtimeToken: object;\n  add(protocol: ReadableInteropV1, observedRevision: number): void;\n}\n\nexport interface InteropRenderCollectorV1 {\n  add(protocol: ReadableInteropV1, observedRevision: number): void;\n}\n\nexport interface InteropRenderScopeV1 {\n  readonly token: object;\n  readonly managed: boolean;\n  isActive(): boolean;\n  finish(): void;\n}\n\nexport interface SharedInteropContextV1 {\n  readonly version: 1;\n  graphCollector?: InteropGraphCollectorV1 | undefined;\n  renderCollector?: InteropRenderCollectorV1 | undefined;\n  renderScope?: InteropRenderScopeV1 | undefined;\n  speculativeDepth: number;\n  speculativeDeepReadEpoch: number;\n}\n\nexport const READABLE_INTEROP_V1 = Symbol.for(\n  \"react-fine-grained-signals.readable-interop.v1\",\n);\n\nconst SHARED_CONTEXT_V1 = Symbol.for(\n  \"react-fine-grained-signals.shared-interop-context.v1\",\n);\n\nlet cachedContext: SharedInteropContextV1 | undefined;\n\n/** Resolve the tiny same-global context shared by duplicate module copies. */\nexport function getSharedInteropContext(): SharedInteropContextV1 {\n  if (cachedContext !== undefined) return cachedContext;\n\n  const globalObject = globalThis as typeof globalThis & Record<symbol, unknown>;\n  const existing = globalObject[SHARED_CONTEXT_V1] as SharedInteropContextV1 | undefined;\n  if (existing !== undefined) {\n    if (existing.version !== 1 || typeof existing.speculativeDepth !== \"number\") {\n      throw new Error(\"Incompatible react-fine-grained-signals interop context\");\n    }\n    cachedContext = existing;\n    return existing;\n  }\n\n  const context: SharedInteropContextV1 = {\n    version: 1,\n    speculativeDepth: 0,\n    speculativeDeepReadEpoch: 0,\n  };\n  Object.defineProperty(globalObject, SHARED_CONTEXT_V1, {\n    value: context,\n    enumerable: false,\n    configurable: false,\n    writable: false,\n  });\n  cachedContext = context;\n  return context;\n}\n\nexport function getReadableInterop(readable: object): ReadableInteropV1 | undefined {\n  const protocol = (readable as Record<PropertyKey, unknown>)[READABLE_INTEROP_V1];\n  if (protocol === undefined || typeof protocol !== \"object\" || protocol === null) {\n    return undefined;\n  }\n  const candidate = protocol as Partial<ReadableInteropV1>;\n  return candidate.version === 1 &&\n      typeof candidate.getRevision === \"function\" &&\n      typeof candidate.subscribe === \"function\" &&\n      typeof candidate.runtimeToken === \"object\" && candidate.runtimeToken !== null\n    ? candidate as ReadableInteropV1\n    : undefined;\n}\n\nexport function attachReadableInterop(\n  readable: object,\n  protocol: ReadableInteropV1,\n): void {\n  Object.defineProperty(readable, READABLE_INTEROP_V1, {\n    value: protocol,\n    enumerable: false,\n    configurable: false,\n    writable: false,\n  });\n}\n\nexport function withInteropGraphCollector<T>(\n  collector: InteropGraphCollectorV1,\n  callback: () => T,\n): T {\n  const context = getSharedInteropContext();\n  const previous = context.graphCollector;\n  context.graphCollector = collector;\n  try {\n    return callback();\n  } finally {\n    context.graphCollector = previous;\n  }\n}\n\nexport function withoutInteropGraphCollector<T>(callback: () => T): T {\n  const context = getSharedInteropContext();\n  const previous = context.graphCollector;\n  context.graphCollector = undefined;\n  try {\n    return callback();\n  } finally {\n    context.graphCollector = previous;\n  }\n}\n\nexport function publishInteropGraphRead(\n  protocol: ReadableInteropV1,\n  observedRevision: number,\n): void {\n  const collector = getSharedInteropContext().graphCollector;\n  if (collector !== undefined && collector.runtimeToken !== protocol.runtimeToken) {\n    collector.add(protocol, observedRevision);\n  }\n}\n\nexport function withInteropRenderCollector<T>(\n  collector: InteropRenderCollectorV1 | undefined,\n  callback: () => T,\n): T {\n  const context = getSharedInteropContext();\n  const previous = context.renderCollector;\n  context.renderCollector = collector;\n  try {\n    return callback();\n  } finally {\n    context.renderCollector = previous;\n  }\n}\n\n/** Push a render boundary and restore only a still-active parent boundary. */\nexport function pushInteropRenderScope(\n  scope: InteropRenderScopeV1,\n  collector: InteropRenderCollectorV1,\n): () => void {\n  const context = getSharedInteropContext();\n  const previousScope = context.renderScope;\n  const previousCollector = context.renderCollector;\n  context.renderScope = scope;\n  context.renderCollector = collector;\n  let active = true;\n  return () => {\n    if (!active) return;\n    active = false;\n    if (context.renderScope !== scope) return;\n    const restoreScope = previousScope?.isActive() ? previousScope : undefined;\n    context.renderScope = restoreScope;\n    context.renderCollector = restoreScope === undefined ? undefined : previousCollector;\n  };\n}\n\nexport function withoutInteropRenderCollector<T>(callback: () => T): T {\n  return withInteropRenderCollector(undefined, callback);\n}\n\nexport function publishInteropRenderRead(\n  protocol: ReadableInteropV1,\n  observedRevision: number,\n): void {\n  getSharedInteropContext().renderCollector?.add(protocol, observedRevision);\n}\n\nexport function withInteropSpeculativeMode<T>(callback: () => T): T {\n  const context = getSharedInteropContext();\n  context.speculativeDepth += 1;\n  try {\n    return callback();\n  } finally {\n    context.speculativeDepth -= 1;\n  }\n}\n\n/** Run durable graph work without inheriting an outer speculative callback. */\nexport function withoutInteropSpeculativeMode<T>(callback: () => T): T {\n  const context = getSharedInteropContext();\n  const previousDepth = context.speculativeDepth;\n  context.speculativeDepth = 0;\n  try {\n    return callback();\n  } finally {\n    context.speculativeDepth = previousDepth;\n  }\n}\n\nexport function isInteropSpeculative(): boolean {\n  return getSharedInteropContext().speculativeDepth > 0;\n}\n\n/** Marks speculative deep reads whose per-key dependencies were not collected. */\nexport function markInteropSpeculativeDeepRead(): void {\n  const context = getSharedInteropContext();\n  context.speculativeDeepReadEpoch = (context.speculativeDeepReadEpoch ?? 0) + 1;\n}\n","import {\n  getReadableInterop,\n  withoutInteropRenderCollector,\n  type ReadableInteropV1,\n} from \"./interop.js\";\nimport { UNTRACKED_OWNER, executionContext, withSynchronousExecutionOwner } from \"./execution-owner.js\";\n\n/** Internal dependency contract used by the React render collector. */\nexport interface RenderDependency {\n  getRenderVersion(): number;\n  subscribeRender(listener: () => void): () => void;\n}\n\nexport interface RenderCollector {\n  add(dependency: RenderDependency, observedVersion: number): void;\n}\n\nconst foreignRenderDependencies = new WeakMap<ReadableInteropV1, RenderDependency>();\n\nclass ForeignRenderDependency implements RenderDependency {\n  constructor(readonly protocol: ReadableInteropV1) {}\n\n  getRenderVersion(): number {\n    return this.protocol.getRevision();\n  }\n\n  subscribeRender(listener: () => void): () => void {\n    const subscription = this.protocol.subscribe(() => listener());\n    return () => subscription.unsubscribe();\n  }\n}\n\n/** Reuse one render adapter for each foreign readable protocol. */\nexport function getForeignRenderDependency(protocol: ReadableInteropV1): RenderDependency {\n  let dependency = foreignRenderDependencies.get(protocol);\n  if (dependency === undefined) {\n    dependency = new ForeignRenderDependency(protocol);\n    foreignRenderDependencies.set(protocol, dependency);\n  }\n  return dependency;\n}\n\n/** Resolve the private protocol attached to a foreign candidate readable. */\nexport function getForeignReadableRenderDependency(readable: object): RenderDependency | undefined {\n  const protocol = getReadableInterop(readable);\n  return protocol === undefined ? undefined : getForeignRenderDependency(protocol);\n}\n\nexport let activeRenderCollector: RenderCollector | undefined;\n\n/** Returns whether a React render is currently collecting signal reads. */\nexport function hasActiveRenderCollector(): boolean {\n  return activeRenderCollector !== undefined;\n}\n\n/** Replaces the current render collector and returns the previous collector. */\nexport function setActiveRenderCollector(\n  collector?: RenderCollector,\n): RenderCollector | undefined {\n  const previous = activeRenderCollector;\n  activeRenderCollector = collector;\n  return previous;\n}\n\n/** Records a dependency and reports whether render collection was active. */\nexport function trackRenderDependency(\n  dependency: RenderDependency,\n  observedVersion?: number,\n): boolean {\n  if (activeRenderCollector === undefined) return false;\n  activeRenderCollector.add(dependency, observedVersion ?? dependency.getRenderVersion());\n  return true;\n}\n\n/** Runs a callback without adding its reads to the active React render. */\nexport function untrackedRender<T>(callback: () => T): T {\n  const previous = setActiveRenderCollector();\n  try {\n    const owner = executionContext.owner;\n    const run = () => withoutInteropRenderCollector(callback);\n    // A render-only pause must keep an enclosing graph subscriber active.\n    if (owner !== undefined && typeof owner !== \"symbol\" && owner.kind === \"graph\") {\n      return run();\n    }\n    return withSynchronousExecutionOwner(UNTRACKED_OWNER, run);\n  } finally {\n    setActiveRenderCollector(previous);\n  }\n}\n\n/** A small versioned subscription surface shared by signals and computeds. */\nexport class RenderSubscription implements RenderDependency {\n  // Written slots, not absent ones: the hooks are `undefined` whenever the\n  // constructor is called without them, and `#listeners` is cleared back to\n  // `undefined` to release the Set once the last listener unsubscribes.\n  readonly #onFirstSubscriber?: (() => void) | undefined;\n  readonly #onLastSubscriber?: (() => void) | undefined;\n  #listeners?: Set<() => void> | undefined;\n  #version = 0;\n\n  constructor(\n    onFirstSubscriber?: () => void,\n    onLastSubscriber?: () => void,\n  ) {\n    this.#onFirstSubscriber = onFirstSubscriber;\n    this.#onLastSubscriber = onLastSubscriber;\n  }\n\n  getRenderVersion(): number {\n    return this.#version;\n  }\n\n  subscribeRender(listener: () => void): () => void {\n    const listeners = (this.#listeners ??= new Set());\n    const wasEmpty = listeners.size === 0;\n    listeners.add(listener);\n    if (wasEmpty) this.#onFirstSubscriber?.();\n\n    return () => {\n      const currentListeners = this.#listeners;\n      if (currentListeners === undefined || !currentListeners.delete(listener)) {\n        return;\n      }\n      if (currentListeners.size === 0) {\n        this.#listeners = undefined;\n        this.#onLastSubscriber?.();\n      }\n    };\n  }\n\n  track(): boolean {\n    return trackRenderDependency(this);\n  }\n\n  /**\n   * Whether anything is currently subscribed on the React side. Used by\n   * `deepSignal`'s metadata pruning to tell a genuinely dead per-key version\n   * signal from one a mounted component still depends on — dropping the\n   * latter would strand that subscriber on a `RenderSubscription` the\n   * property map no longer reaches, so it would never be notified again.\n   */\n  hasListeners(): boolean {\n    return this.#listeners !== undefined && this.#listeners.size !== 0;\n  }\n\n  bumpVersion(): void {\n    this.#version = (this.#version + 1) | 0;\n  }\n\n  notify(): void {\n    this.bumpVersion();\n    const listeners = this.#listeners;\n    if (listeners === undefined) return;\n    // Snapshot before iterating: a listener may (un)subscribe synchronously.\n    // oxlint-disable-next-line unicorn/no-useless-spread\n    for (const listener of [...listeners]) notifyListener(listener);\n  }\n}\n\n/**\n * Invokes one subscription listener, keeping its failure from cancelling the\n * listeners queued behind it. Without this, a single throwing subscriber\n * aborts the rest of the notify cycle, so unrelated components silently miss\n * the update that was being delivered. Reported the same way as the other\n * background-callback failures in this codebase (`readBoundSignal` in\n * src/runtime/jsx.ts): `console.error(message, { cause })`.\n */\nexport function notifyListener(listener: () => void): void {\n  try {\n    listener();\n  } catch (error) {\n    console.error(\n      \"react-fine-grained-signals: a render-subscription listener threw; continuing with the remaining listeners.\",\n      { cause: error },\n    );\n  }\n}\n","/**\n * Package-wide identity marker shared by public signal wrappers and deep proxies.\n *\n * The key names a *generation* of the cross-copy contract; the number stored\n * under it is that generation's minor version. A minor version only ever widens\n * the contract, so anything from the minimum upwards is trusted; a change that\n * an older copy could not honour takes a new key instead.\n *\n * v0.1.x used `react-fine-grained-signals.signal` and trusted every version\n * from 1 upwards. A v0.2 signal is only reactive under the v2 shared execution\n * owner and the ReadableInterop V1 protocol, neither of which a v0.1.x copy\n * knows, so reusing that key with a larger number would have let v0.1.x\n * recognize v0.2 signals (and v0.2 recognize v0.1.x ones) and then silently\n * never update. A separate key makes each generation reject the other's\n * signals outright: JSX and `isSignal` fail loudly instead of going stale.\n */\nexport const SIGNAL_BRAND: unique symbol = Symbol.for(\"react-fine-grained-signals.signal.v2\");\nexport const SIGNAL_BRAND_VERSION = 1;\nexport const SIGNAL_BRAND_MIN_VERSION = 1;\n\n/** The v0.1.x key, kept only to report an incompatible signal clearly. */\nexport const LEGACY_SIGNAL_BRAND_V1 = Symbol.for(\"react-fine-grained-signals.signal\");\n","/* Production-shaped Alien-derived graph, adapted from Alien Signals 3.2.1.\n * Source: https://github.com/stackblitz/alien-signals/tree/8734d386d925025d0e99419bd9161c17b112c5ee\n * Copyright (c) 2024-present Johnson Chu. See the repository license notice.\n * Imports only alien-signals/system; RFSG APIs and adapters remain local.\n */\nimport { createReactiveSystem } from \"alien-signals/system\";\nimport type { Link, ReactiveFlags, ReactiveNode } from \"alien-signals/system\";\nimport { UNTRACKED_OWNER, executionContext, isGraphExecutionOwner, isRenderExecutionOwner, withSynchronousExecutionOwner } from \"./execution-owner.js\";\nimport { createForeignReadableAdapter, isReadableProtocol } from \"./foreign-readable-v1.mjs\";\nimport { READABLE_INTEROP_V1 } from \"./interop-context.mjs\";\nimport type { ExecutionContextOwnerV2, ExecutionOwnerV2, ReadableProtocolV1 } from \"./execution-owner.js\";\nimport { activeRenderCollector, trackRenderDependency } from \"./render-tracking.js\";\nimport { SIGNAL_BRAND, SIGNAL_BRAND_MIN_VERSION, SIGNAL_BRAND_VERSION } from \"./signal-brand.js\";\nimport type { AlienDerivedGraphRuntime, RenderAdapterForCore, RenderAttempt, RuntimeNode, RuntimeSource, RuntimeComputed, RuntimeEffect, RuntimeReadable, RuntimeWritable, SpeculativeComputedEntry } from \"./alien-derived-types.js\";\n\n// These mirror `ReactiveFlags` in alien-signals/system 3.2.1 bit for bit; the\n// exact dependency pin in package.json is what keeps them valid.\nconst None = 0 as ReactiveFlags;\nconst Mutable = 1 as ReactiveFlags;\nconst Watching = 2 as ReactiveFlags;\nconst RecursedCheck = 4 as ReactiveFlags;\nconst Recursed = 8 as ReactiveFlags;\nconst Dirty = 16 as ReactiveFlags;\nconst Pending = 32 as ReactiveFlags;\n// Alien 3.2.1's high-level `HasChildEffect`: set on an effect or computed that\n// created an effect while running, so its next run disposes those children.\nconst HasChildEffect = 64 as ReactiveFlags;\n\nexport function createAlienDerivedRuntime(): AlienDerivedGraphRuntime {\nconst runtimeToken = {};\nlet renderAdapter: RenderAdapterForCore | undefined;\nlet activeRenderAttempt: RenderAttempt | undefined;\n\nlet activeSub: RuntimeNode | undefined;\n// Disposers of effects created by the speculative getter now running.\nlet speculativeChildren: Array<() => void> | undefined;\nlet cycle = 0;\nlet runDepth = 0;\nlet batchDepth = 0;\nlet flushIndex = 0;\nlet queuedLength = 0;\nconst queue: Array<RuntimeNode | undefined> = [];\n\nconst system = createReactiveSystem({\n  update(rawNode: ReactiveNode) {\n    const node = rawNode as RuntimeNode;\n    if (node.kind === \"external\") {\n      // Commit only what was propagated; see `advance` in foreign-readable-v1.\n      const changed = node.revision !== node.pendingRevision;\n      node.revision = node.pendingRevision;\n      node.flags = Mutable;\n      return changed;\n    }\n    if (node.kind === \"computed\") return updateComputed(node as RuntimeComputed);\n    if (node.kind === \"source\") return updateSource(node);\n    node.flags = Mutable;\n    return true;\n  },\n  notify(rawEffect: ReactiveNode) {\n    let current: RuntimeNode | undefined = rawEffect as RuntimeNode;\n    let insertIndex = queuedLength;\n    const firstInsertedIndex = insertIndex;\n    do {\n      const effect = current!;\n      queue[insertIndex++] = effect;\n      effect.flags &= ~Watching;\n      current = effect.subs?.sub as RuntimeNode | undefined;\n      if (current === undefined || !(current.flags & Watching)) break;\n    // This queue walk intentionally advances until its linked-list sentinel.\n    // oxlint-disable-next-line no-constant-condition\n    } while (true);\n    queuedLength = insertIndex;\n    let leftIndex = firstInsertedIndex;\n    while (leftIndex < --insertIndex) {\n      const left = queue[leftIndex]!;\n      queue[leftIndex++] = queue[insertIndex]!;\n      queue[insertIndex] = left;\n    }\n  },\n  unwatched(rawNode: ReactiveNode) {\n    const node = rawNode as RuntimeNode;\n    if (node.kind === \"external\") {\n      node.unsubscribe?.();\n      node.unsubscribe = undefined;\n    } else if (node.kind === \"computed\") {\n      if (node.depsTail !== undefined) {\n        node.flags = Mutable | Dirty;\n        disposeDeps(node);\n      }\n    } else if (node.kind === \"effect\") {\n      disposeEffect(node as RuntimeEffect);\n    }\n  },\n});\nconst { link: alienLink, unlink: alienUnlink, propagate, checkDirty, shallowPropagate } = system;\n\nfunction linkNode(dependency: RuntimeNode, subscriber: RuntimeNode, version: number): void {\n  alienLink(dependency as unknown as ReactiveNode, subscriber as unknown as ReactiveNode, version);\n}\n\nfunction unlinkNode(linkage: Link, subscriber: RuntimeNode): Link | undefined {\n  return alienUnlink(linkage, subscriber as unknown as ReactiveNode);\n}\n\nfunction makeNode(kind: RuntimeNode[\"kind\"], flags: number, fields: Partial<RuntimeNode> = {}): RuntimeNode {\n  return { kind, flags: flags as ReactiveFlags, deps: undefined, depsTail: undefined, subs: undefined, subsTail: undefined, renderRevision: 0, ...fields } as RuntimeNode;\n}\n\nconst foreignAdapter = createForeignReadableAdapter({\n  runtimeToken,\n  makeNode,\n  mutableFlag: Mutable,\n  dirtyFlag: Dirty,\n  getActiveSubscriber: () => activeSub,\n  link: (node: RuntimeNode, subscriber: RuntimeNode) => linkNode(node, subscriber, cycle),\n  propagate,\n  shallowPropagate,\n  flush: () => flush(),\n  isRunning: () => !!runDepth,\n  isBatching: () => !!batchDepth,\n  effect: (callback: () => unknown) => detachedEffect(callback),\n  own: adopt,\n});\nconst renderDependencies = new WeakMap<object, RuntimeNode>();\nconst deepSignalNodes = new WeakSet<RuntimeNode>();\nconst deepWatchedNodes = new WeakSet<RuntimeNode>();\n\nfunction getRenderDependency(readable: { value: unknown }, node: RuntimeNode) {\n  if (!renderDependencies.has(readable)) {\n    node.getRenderVersion = () => foreignAdapter.observeRevision(node);\n    node.subscribeRender = (listener: () => void) => {\n      let initial = true;\n      let version = foreignAdapter.observeRevision(node);\n      return detachedEffect(() => {\n        try { readable.value; } catch { /* Keep erroring boundaries subscribed. */ }\n        const nextVersion = foreignAdapter.observeRevision(node);\n        if (initial) initial = false;\n        else if (nextVersion !== version) listener();\n        version = nextVersion;\n      });\n    };\n    renderDependencies.set(readable, node);\n  }\n  return renderDependencies.get(readable)!;\n}\n\nfunction readSource(source: RuntimeNode): unknown {\n  if (source.flags & Dirty && updateSource(source)) {\n    if (source.subs !== undefined) shallowPropagate(source.subs);\n  }\n  if (activeSub !== undefined) linkNode(source, activeSub, cycle);\n  return source.currentValue;\n}\n\n// The read half of `readSource` without linking. Another copy's `untracked()`\n// clears only its own subscriber, so a read under the shared UNTRACKED_OWNER\n// must not link to whichever subscriber this copy happens to be running.\nfunction readSourceUntracked(source: RuntimeNode): unknown {\n  if (source.flags & Dirty && updateSource(source)) {\n    if (source.subs !== undefined) shallowPropagate(source.subs);\n  }\n  return source.currentValue;\n}\n\n// Another copy's graph or render owner is reading. That copy records the read\n// through `publishForeignReadable`; this copy's `activeSub` may still be an\n// outer frame (B effect -> A computed -> B signal) that never read the value,\n// so such a read must not link to it.\nfunction isForeignOwner(owner: ExecutionContextOwnerV2 | undefined): owner is ExecutionOwnerV2 {\n  return (isGraphExecutionOwner(owner) || isRenderExecutionOwner(owner)) && owner.runtimeToken !== runtimeToken;\n}\n\nconst attachProtocol = foreignAdapter.attachProtocol;\nconst ensureForeignNode = foreignAdapter.ensureForeignNode;\nconst graphOwner = foreignAdapter.graphOwner;\n// User callbacks (computed getters, effect bodies) are called as `() => T`:\n// no arguments and no `this`, as in v0.1.1.\nfunction withGraphOwner<T>(callback: () => T): T {\n  const owner = executionContext.owner;\n  const previousAttempt = activeRenderAttempt;\n  const alreadyOwned = isGraphExecutionOwner(owner) && owner.runtimeToken === runtimeToken;\n  if (previousAttempt === undefined && alreadyOwned) return callback();\n  activeRenderAttempt = undefined;\n  if (!alreadyOwned) executionContext.owner = graphOwner;\n  try { return callback(); }\n  finally {\n    if (!alreadyOwned) executionContext.owner = owner;\n    activeRenderAttempt = previousAttempt;\n  }\n}\n\nfunction configureRenderAdapter(adapter: RenderAdapterForCore): void {\n  renderAdapter = adapter;\n}\n\nfunction withRenderAttempt<T>(attempt: RenderAttempt | undefined, callback: () => T): T {\n  const restore = pushRenderAttempt(attempt);\n  try { return callback(); }\n  finally { restore(); }\n}\n\nfunction pushRenderAttempt(attempt: RenderAttempt | undefined): () => void {\n  const previous = activeRenderAttempt;\n  activeRenderAttempt = attempt;\n  let active = true;\n  return () => {\n    if (!active) return;\n    active = false;\n    if (activeRenderAttempt === attempt) activeRenderAttempt = previous;\n  };\n}\n\nfunction getActiveRenderAttempt() { return activeRenderAttempt; }\nconst getNodeForReadable = foreignAdapter.getNodeForReadable;\nconst getReadableRevision = foreignAdapter.getReadableRevision;\nfunction isComputedClean(node: RuntimeNode): boolean {\n  // A foreign revision this copy has not been told about yet still dirties it.\n  if (node.foreignDependent) refreshForeignDependencies(node as RuntimeComputed, new Set());\n  return node.initialized === true && !(node.flags & (Dirty | Pending));\n}\n\n// A speculative dependency is keyed either by a readable (this copy's, or one\n// carrying another copy's protocol) or, for a read another copy published to\n// the render owner, by that copy's protocol object itself.\nfunction getDependencyRevision(dependency: object): number {\n  return isReadableProtocol(dependency) ? dependency.getRevision() : getReadableRevision(dependency);\n}\n\nfunction promoteComputed(readable: object, node: RuntimeNode, entry: SpeculativeComputedEntry): boolean {\n  // Already initialized, by a real read or another attempt's promotion: both\n  // advance `renderRevision`, so `settleRenderAttempt` compares this attempt's\n  // value with the node's rather than trusting the revision it recorded.\n  if (node.initialized) return true;\n  const computed = node as RuntimeComputed;\n  const hadForeignDependencies = computed.foreignDependent;\n  // Another copy's protocol, with the revision the render read it at, or a\n  // local node (whose revision slot is unused).\n  const dependencies: Array<RuntimeNode | ReadableProtocolV1> = [];\n  const revisions: number[] = [];\n  for (const [dependency, revision] of entry.dependencies) {\n    let protocol: unknown = dependency;\n    if (!isReadableProtocol(dependency)) {\n      if (getReadableRevision(dependency) !== revision) return false;\n      const dependencyNode = foreignAdapter.getNodeForReadable(dependency);\n      if (dependencyNode !== undefined) {\n        // Link a dependency only in the state the speculative read observed. A\n        // computed's revision moves only when it re-evaluates, so one a later\n        // write left Dirty or Pending fails here, as it does on cache reuse.\n        if (dependencyNode.kind === \"computed\" && !isComputedClean(dependencyNode)) return false;\n        // The render read a source's pending value without settling it. Settle it\n        // before linking, as Alien's own signal read does, or a later write back\n        // to the stale committed value compares equal and never reaches us.\n        if (dependencyNode.kind === \"source\") readSourceUntracked(dependencyNode);\n        dependencies.push(dependencyNode);\n        revisions.push(revision);\n        continue;\n      }\n      protocol = Reflect.get(dependency, READABLE_INTEROP_V1);\n      if (!isReadableProtocol(protocol)) return false;\n    } else if (dependency.getRevision() !== revision) {\n      return false;\n    }\n    dependencies.push(protocol as ReadableProtocolV1);\n    revisions.push(revision);\n  }\n  disposeDeps(computed);\n  computed.depsTail = undefined;\n  const previousSub = activeSub;\n  activeSub = computed;\n  cycle += 1;\n  try {\n    for (let index = 0; index < dependencies.length; index += 1) {\n      const dependency = dependencies[index]!;\n      if ((dependency as RuntimeNode).kind === undefined) ensureForeignNode(dependency as ReadableProtocolV1, revisions[index]!);\n      else linkNode(dependency as RuntimeNode, computed, cycle);\n    }\n  } finally { activeSub = previousSub; }\n  recomputeForeignDependencies(computed);\n  if (hadForeignDependencies !== computed.foreignDependent) updateForeignDependencyAncestors(computed);\n  computed.value = entry.value;\n  computed.error = entry.error;\n  computed.hasError = entry.hasError;\n  computed.initialized = true;\n  computed.flags = Mutable;\n  // Initialization is a value change, as in `updateComputed`, so any other\n  // attempt that read this computed before it existed re-checks its value.\n  computed.renderRevision = (computed.renderRevision + 1) | 0;\n  return true;\n}\n\nfunction hasSubscribers(readable: object): boolean {\n  return foreignAdapter.getNodeForReadable(readable)?.subs !== undefined;\n}\nfunction hasActiveSubscriber(): boolean { return activeSub !== undefined; }\nfunction getBatchDepth(): number { return batchDepth; }\n\nfunction updateSource(source: RuntimeNode): boolean {\n  source.flags = Mutable;\n  const changed = !Object.is(source.currentValue, source.currentValue = source.pendingValue);\n  return changed;\n}\n\nfunction readComputed(computed: RuntimeComputed, track = true): unknown {\n  // Bridge pushes cannot be relied on at read time: an inactive bridge gets\n  // none, and an active one hears of a write only when the other copy's flush\n  // reaches it, which can be after this copy has re-run on another of that\n  // write's consequences (or after the other copy's batch). Poll them here.\n  if (computed.foreignDependent) {\n    refreshForeignDependencies(computed, new Set());\n  }\n  // RecursedCheck is only set on a computed while its own getter is on the\n  // stack, so any read of it here -- direct or through other computeds -- is\n  // a cycle that would otherwise silently return a stale intermediate value.\n  if (computed.flags & RecursedCheck) {\n    throw new Error(\"Computed cycle detected\");\n  }\n  const flags = computed.flags;\n  if (flags & Dirty || (flags & Pending && ((computed.deps !== undefined && checkDirty(computed.deps, computed as unknown as ReactiveNode)) || (computed.flags = flags & ~Pending, false)))) {\n    if (updateComputed(computed) && computed.subs !== undefined) shallowPropagate(computed.subs);\n  } else if (!flags) {\n    updateComputed(computed);\n  }\n  if (track && activeSub !== undefined) {\n    linkNode(computed, activeSub, cycle);\n    if (activeSub.kind === \"computed\" && computed.foreignDependent) activeSub.foreignDependent = true;\n    if (activeSub.kind === \"effect\" && computed.foreignDependent) activateForeignDependencies(computed, new Set());\n  }\n  if (computed.hasError) throw computed.error;\n  return computed.value;\n}\n\n// A newer revision invalidates the bridge's subscribers through the graph\n// itself (see `observeForeignRevision`), so this computed and everything\n// between it and the bridge re-check, and the bridge's other subscribers do\n// too instead of later comparing against an already-advanced revision.\nfunction refreshForeignDependencies(node: RuntimeComputed, visited: Set<RuntimeNode>): void {\n  if (visited.has(node)) return;\n  visited.add(node);\n  for (let dependency = node.deps; dependency !== undefined; dependency = dependency.nextDep) {\n    const dep = dependency.dep as RuntimeNode;\n    if (dep.kind === \"external\") foreignAdapter.observeForeignRevision(dep, dep.protocol!.getRevision());\n    else if (dep.kind === \"computed\" && dep.foreignDependent) refreshForeignDependencies(dep as RuntimeComputed, visited);\n  }\n}\n\nfunction activateForeignDependencies(node: RuntimeComputed, visited: Set<RuntimeNode>): void {\n  if (visited.has(node)) return;\n  visited.add(node);\n  let dependency = node.deps;\n  while (dependency !== undefined) {\n    const dep = dependency.dep as RuntimeNode;\n    if (dep.kind === \"external\") foreignAdapter.activateForeignNode(dep);\n    else if (dep.kind === \"computed\") activateForeignDependencies(dep as RuntimeComputed, visited);\n    dependency = dependency.nextDep;\n  }\n}\n\nfunction updateComputed(computed: RuntimeComputed): boolean {\n  if (computed.flags & HasChildEffect) disposeChildEffects(computed);\n  computed.depsTail = undefined;\n  computed.flags = Mutable | RecursedCheck;\n  const previous = activeSub;\n  activeSub = computed;\n  let changed = !computed.initialized;\n  const hadError = computed.hasError;\n  const hadForeignDependencies = computed.foreignDependent;\n  const previousValue = computed.value;\n  computed.foreignDependent = false;\n  try {\n    cycle += 1;\n    try {\n      computed.value = withGraphOwner(computed.getter);\n      computed.error = undefined;\n      computed.hasError = false;\n    } catch (error) {\n      computed.value = undefined;\n      computed.error = error;\n      computed.hasError = true;\n    }\n    computed.initialized = true;\n    changed = changed || hadError || computed.hasError || !Object.is(previousValue, computed.value);\n    if (changed && computed.renderRevision !== undefined) computed.renderRevision = (computed.renderRevision + 1) | 0;\n    return changed;\n  } finally {\n    activeSub = previous;\n    computed.flags &= ~RecursedCheck;\n    purgeDeps(computed);\n    recomputeForeignDependencies(computed);\n    if (hadForeignDependencies !== computed.foreignDependent) updateForeignDependencyAncestors(computed);\n    // A recomputation reached through an effect's dirty check (rather than a\n    // direct read by that effect) can link a new foreign bridge whose value\n    // does not change this computed's result yet, so the effect never re-reads\n    // it and never activates it. Activate here whenever an effect watches us.\n    if (computed.foreignDependent && computed.subs !== undefined && isWatchedByEffect(computed, new Set())) {\n      activateForeignDependencies(computed, new Set());\n    }\n  }\n}\n\n// A computed's subscribers are effects and other computeds only.\nfunction isWatchedByEffect(node: RuntimeNode, visited: Set<RuntimeNode>): boolean {\n  if (visited.has(node)) return false;\n  visited.add(node);\n  for (let link = node.subs; link !== undefined; link = link.nextSub) {\n    const subscriber = link.sub as RuntimeNode;\n    if (subscriber.kind === \"effect\" ? subscriber.flags !== None : isWatchedByEffect(subscriber, visited)) return true;\n  }\n  return false;\n}\n\n// Alien 3.2.1's child-effect disposal: an effect created while `sub` ran is\n// linked as one of `sub`'s dependencies; unlinking it before `sub` runs again\n// leaves it with no subscriber, which disposes it through `unwatched`.\nfunction disposeChildEffects(sub: RuntimeNode): void {\n  let link = sub.depsTail;\n  while (link !== undefined) {\n    const previous = link.prevDep;\n    if ((link.dep as RuntimeNode).kind === \"effect\") unlinkNode(link, sub);\n    link = previous;\n  }\n}\n\nfunction recomputeForeignDependencies(computed: RuntimeComputed): void {\n  let dependency = computed.deps;\n  let foreignDependent = false;\n  while (dependency !== undefined) {\n    const dep = dependency.dep as RuntimeNode;\n    if (dep.kind === \"external\" || (dep.kind === \"computed\" && (dep as RuntimeComputed).foreignDependent)) {\n      foreignDependent = true;\n      break;\n    }\n    dependency = dependency.nextDep;\n  }\n  computed.foreignDependent = foreignDependent;\n}\n\nfunction updateForeignDependencyAncestors(computed: RuntimeComputed): void {\n  let link = computed.subs;\n  while (link !== undefined) {\n    const subscriber = link.sub as RuntimeNode;\n    if (subscriber.kind === \"computed\") {\n      const computedSubscriber = subscriber as RuntimeComputed;\n      const wasForeignDependent = computedSubscriber.foreignDependent;\n      recomputeForeignDependencies(computedSubscriber);\n      if (wasForeignDependent !== computedSubscriber.foreignDependent) updateForeignDependencyAncestors(computedSubscriber);\n    }\n    link = link.nextSub;\n  }\n}\n\nfunction runEffect(effect: RuntimeEffect): void {\n  const flags = effect.flags;\n  if (flags & Dirty || (flags & Pending && effect.deps !== undefined && checkDirty(effect.deps, effect as unknown as ReactiveNode))) {\n    if (flags & HasChildEffect) disposeChildEffects(effect);\n    if (effect.cleanup !== undefined) {\n      try {\n        runCleanup(effect);\n      } catch (error) {\n        reportFailure(error);\n      }\n      if (!effect.flags) return;\n    }\n    effect.depsTail = undefined;\n    effect.flags = Watching | RecursedCheck;\n    const previous = activeSub;\n    activeSub = effect;\n    try {\n      cycle += 1;\n      runDepth += 1;\n      const cleanup: unknown = withGraphOwner(effect.fn);\n      effect.cleanup = typeof cleanup === \"function\" ? cleanup as () => unknown : undefined;\n      if (!effect.flags && effect.cleanup !== undefined) runCleanup(effect);\n    } finally {\n      runDepth -= 1;\n      activeSub = previous;\n      effect.flags &= ~RecursedCheck;\n      settleDeps(effect);\n    }\n  } else if (effect.deps !== undefined) {\n    effect.flags = Watching | (flags & HasChildEffect);\n  }\n}\n\n// After a run: drop the dependencies this run stopped reading. An effect that\n// disposed itself mid-run has to drop every link instead -- both the previous\n// run's (its disposer only saw this run's prefix, since a run starts from an\n// empty `depsTail`) and any its reads after the disposer re-created -- rather\n// than keep a dead closure subscribed for the lifetime of those sources.\nfunction settleDeps(effect: RuntimeNode): void {\n  // With no tail, `purgeDeps` drops every link from the head.\n  if (effect.flags === None) effect.depsTail = undefined;\n  purgeDeps(effect);\n}\n\nfunction flush() {\n  try {\n    while (flushIndex < queuedLength) {\n      const effect = queue[flushIndex]!;\n      queue[flushIndex++] = undefined;\n      try {\n      runEffect(effect as RuntimeEffect);\n      } catch (error) {\n        reportFailure(error);\n      }\n    }\n  } finally {\n    while (flushIndex < queuedLength) {\n      const effect = queue[flushIndex]!;\n      queue[flushIndex++] = undefined;\n      effect!.flags |= Watching | Recursed;\n    }\n    flushIndex = 0;\n    queuedLength = 0;\n  }\n}\n\nfunction reportFailure(error: unknown): void {\n  try {\n    console.error(\"react-fine-grained-signals: an effect() callback threw; the error is contained and reported here so this flush can finish.\", { cause: error });\n  } catch { /* Reporting must not interrupt scheduler progress. */ }\n  try {\n    const report = globalThis.reportError;\n    if (typeof report === \"function\") report.call(globalThis, error);\n  } catch { /* Keep a failing host reporter from escaping the runtime. */ }\n}\n\nfunction disposeDeps(sub: RuntimeNode): void {\n  let depLink = sub.depsTail;\n  while (depLink !== undefined) {\n    const previous = depLink.prevDep;\n    unlinkNode(depLink, sub);\n    depLink = previous;\n  }\n}\n\nfunction purgeDeps(sub: RuntimeNode): void {\n  const tail = sub.depsTail;\n  let depLink = tail === undefined ? sub.deps : tail.nextDep;\n  while (depLink !== undefined) depLink = unlinkNode(depLink, sub);\n}\n\nfunction runCleanup(effect: RuntimeEffect): unknown {\n  const cleanup = effect.cleanup;\n  effect.cleanup = undefined;\n  const previous = activeSub;\n  activeSub = undefined;\n  try {\n    return withSynchronousExecutionOwner(UNTRACKED_OWNER, cleanup!);\n  } finally { activeSub = previous; }\n}\n\nfunction disposeEffect(effect: RuntimeEffect): void {\n  effect.flags = None;\n  disposeDeps(effect);\n  // An owned child also leaves its parent's dependency list, so the parent\n  // stops holding a link to a disposed effect.\n  const ownerLink = effect.subs;\n  if (ownerLink !== undefined) unlinkNode(ownerLink, ownerLink.sub as RuntimeNode);\n  if (effect.cleanup !== undefined) {\n    try { runCleanup(effect); }\n    catch (error) { reportFailure(error); }\n  }\n}\n\n// Library-internal subscriptions (render stores, direct DOM bindings, the\n// cross-copy protocol) must never become owned by whichever user effect is\n// running when React or another copy happens to create them synchronously.\nfunction detachedEffect(fn: () => unknown): () => void {\n  return effect(fn, true);\n}\n\nfunction effect(fn: () => unknown, detached?: boolean): () => void {\n  const node = makeNode(\"effect\", Watching | RecursedCheck, { fn, cleanup: undefined });\n  const dispose = () => disposeEffect(node as RuntimeEffect);\n  const previous = activeSub;\n  // As in Alien 3.2.1 (and v0.1.x, which used it), an effect created while\n  // another effect or computed runs (the only kinds that become `activeSub`)\n  // is owned by it: the owner's next run or its disposal disposes the child.\n  // That owner may belong to another copy, which this copy reaches only\n  // through the shared owner; a speculative getter has no owner (see `adopt`).\n  if (!detached) {\n    const owner = executionContext.owner;\n    if (previous === undefined && speculativeChildren === undefined && (isGraphExecutionOwner(owner) || isRenderExecutionOwner(owner)) && owner.runtimeToken !== runtimeToken) owner.own?.(dispose);\n    else adopt(dispose, node);\n  }\n  try {\n    activeSub = node;\n    runDepth += 1;\n    try {\n      const cleanup: unknown = withGraphOwner(fn);\n      node.cleanup = typeof cleanup === \"function\" ? cleanup as () => unknown : undefined;\n    } catch (error) {\n      node.cleanup = undefined;\n      reportFailure(error);\n    } finally {\n      runDepth -= 1;\n      activeSub = previous;\n      node.flags &= ~RecursedCheck;\n      purgeDeps(node);\n    }\n  } catch (error) {\n    // Keep setup failures from escaping even if bookkeeping itself fails.\n    reportFailure(error);\n  }\n  if (!runDepth && !batchDepth) {\n    // Only the stale-read bit (128, RFSG-only; set by the foreign adapter's\n    // subscription handshake, cleared by the next run's `flags` assignment)\n    // re-runs a new effect. A write its first run made to its own dependencies\n    // -- directly, or through effects it flushed -- leaves Recursed/Pending\n    // instead and, as in Alien 3.2.1 and v0.1.1, does not. The bit is a literal\n    // rather than a named constant to keep the signal-only bundle in budget.\n    if (node.flags & 128) runEffect(node as RuntimeEffect);\n    if (queuedLength) flush();\n  }\n  return dispose;\n}\n\n// Makes an effect a child of the running effect or computed, whose next run or\n// disposal unlinks it and so disposes it. Also the shared owners' `own`, for an\n// effect another copy created: a childless stand-in effect takes its place in\n// the dependency list and disposes it on cleanup, so only the disposer crosses\n// the copy boundary. With no running subscriber, a speculative getter's\n// effects are collected for `evaluateSpeculatively` to dispose.\nfunction adopt(disposeChild: () => void, child = makeNode(\"effect\", Watching, { cleanup: disposeChild })): void {\n  if (activeSub !== undefined) {\n    linkNode(child, activeSub, 0);\n    activeSub.flags |= HasChildEffect;\n  } else speculativeChildren?.push(disposeChild);\n}\n\n// A speculative render evaluation has no subscriber to own the effects its\n// getter creates and may never be promoted, so they are disposed as soon as\n// it returns. Returns whether there were any: such a result is not promoted,\n// so the committed computed runs its getter (and creates them) for real.\nfunction evaluateSpeculatively(computed: RuntimeComputed, entry: SpeculativeComputedEntry): boolean {\n  const previousSub = activeSub;\n  const previousChildren = speculativeChildren;\n  const children: Array<() => void> = [];\n  const getter = computed.getter;\n  activeSub = undefined;\n  speculativeChildren = children;\n  try {\n    entry.value = getter();\n  } catch (error) {\n    entry.error = error;\n    entry.hasError = true;\n  } finally {\n    activeSub = previousSub;\n    speculativeChildren = previousChildren;\n    for (const disposeChild of children) disposeChild();\n  }\n  return children.length > 0;\n}\n\n\nfunction batch<T>(fn: () => T): T {\n  batchDepth += 1;\n  try {\n    return fn();\n  } finally {\n    batchDepth -= 1;\n    if (!batchDepth) flush();\n  }\n}\n\nfunction untracked<T>(fn: () => T): T {\n  const previous = activeSub;\n  const previousAttempt = activeRenderAttempt;\n  activeSub = undefined;\n  activeRenderAttempt = undefined;\n  try { return withSynchronousExecutionOwner(UNTRACKED_OWNER, fn); }\n  finally {\n    activeRenderAttempt = previousAttempt;\n    activeSub = previous;\n  }\n}\n\n// Public API/brand candidates. Each public object is the readable class\n// instance itself; no outer wrapper, interop protocol, or per-instance methods.\nconst brandDescriptor = () => ({ value: SIGNAL_BRAND_VERSION, enumerable: false, writable: false, configurable: false });\nfunction registerHelperBrand(value: object): void {\n  Object.defineProperty(value, SIGNAL_BRAND, brandDescriptor());\n}\n\nfunction inlineWrite(node: RuntimeSource, value: unknown): void {\n  if (!Object.is(node.pendingValue, node.pendingValue = value)) {\n    if (node.renderRevision !== undefined) node.renderRevision = (node.renderRevision + 1) | 0;\n    node.flags = Mutable | Dirty;\n    const subscribers = node.subs;\n    if (subscribers !== undefined) {\n      propagate(subscribers, !!runDepth);\n      if (!batchDepth) flush();\n    }\n  }\n}\n\nfunction inlineDeepSignalWrite(node: RuntimeSource, value: unknown): void {\n  // DeepSignal version sources use this specialized entry point so liveness\n  // bookkeeping stays exact without classifying every ordinary source write.\n  deepWatchedNodes.delete(node);\n  inlineWrite(node, value);\n}\n\nclass HelperBrandSignal<T = unknown> {\n  #node: RuntimeSource;\n  constructor(node: RuntimeSource, branded = true) { this.#node = node; if (branded) registerHelperBrand(this); attachProtocol(this, node); }\n  get value(): T {\n    const node = this.#node;\n    const currentOwner = executionContext.owner;\n    // A render attempt is installed with its render owner. Ordinary owner-free\n    // reads can skip speculative-render dispatch while preserving collection.\n    if (currentOwner === undefined) {\n      const value = readSource(node);\n      const collector = activeRenderCollector;\n      if (collector !== undefined) {\n        trackRenderDependency(getRenderDependency(this, node) as import(\"./alien-derived-types.js\").RenderReadableDependency);\n      }\n      return value as T;\n    }\n    // Reads inside this copy's own effects and computeds: no render attempt is\n    // installed (`withGraphOwner` clears it), nothing is untracked or foreign.\n    if (currentOwner === graphOwner) return readSource(node) as T;\n    const attempt = activeRenderAttempt;\n    if (attempt !== undefined && isRenderExecutionOwner(currentOwner) && currentOwner.runtimeToken === runtimeToken && renderAdapter !== undefined) {\n      foreignAdapter.observeRevision(node);\n      return renderAdapter.readSource(this, node, attempt) as T;\n    }\n    if (currentOwner === UNTRACKED_OWNER) return readSourceUntracked(node) as T;\n    if (isForeignOwner(currentOwner)) {\n      const value = readSourceUntracked(node);\n      foreignAdapter.publishForeignReadable(this, node, currentOwner);\n      return value as T;\n    }\n    return readSource(node) as T;\n  }\n  set value(value: T) { inlineWrite(this.#node, value); }\n  peek(): T { return this.#node.pendingValue as T; }\n}\n\n/** Internal DeepSignal root and per-property version sources have a distinct\n * write entry point because their liveness markers must be cleared before any\n * write, including an Object.is-equal write. Ordinary branded signals never\n * pay that bookkeeping cost. */\nclass DeepSignalRuntimeSource<T = unknown> {\n  #node: RuntimeSource;\n  constructor(node: RuntimeSource) { this.#node = node; attachProtocol(this, node); }\n  get value(): T {\n    const node = this.#node;\n    const currentOwner = executionContext.owner;\n    if (currentOwner === undefined) {\n      const value = readSource(node);\n      const collector = activeRenderCollector;\n      if (collector !== undefined) {\n        trackRenderDependency(getRenderDependency(this, node) as import(\"./alien-derived-types.js\").RenderReadableDependency);\n      }\n      return value as T;\n    }\n    // Reads inside this copy's own effects and computeds: no render attempt is\n    // installed (`withGraphOwner` clears it), nothing is untracked or foreign.\n    if (currentOwner === graphOwner) return readSource(node) as T;\n    const attempt = activeRenderAttempt;\n    if (attempt !== undefined && isRenderExecutionOwner(currentOwner) && currentOwner.runtimeToken === runtimeToken && renderAdapter !== undefined) {\n      foreignAdapter.observeRevision(node);\n      return renderAdapter.readSource(this, node, attempt) as T;\n    }\n    if (currentOwner === UNTRACKED_OWNER) return readSourceUntracked(node) as T;\n    if (isForeignOwner(currentOwner)) {\n      const value = readSourceUntracked(node);\n      foreignAdapter.publishForeignReadable(this, node, currentOwner);\n      return value as T;\n    }\n    return readSource(node) as T;\n  }\n  set value(value: T) { inlineDeepSignalWrite(this.#node, value); }\n  peek(): T { return this.#node.pendingValue as T; }\n}\nfunction createBrandedSignal<T>(makeReadable: new (node: RuntimeSource) => RuntimeWritable<T>, initialValue: T): RuntimeWritable<T> {\n  const node = makeNode(\"source\", Mutable, { currentValue: initialValue, pendingValue: initialValue });\n  return new makeReadable(node as RuntimeSource);\n}\nconst signalClassBrandHelper = <T,>(initialValue: T): RuntimeWritable<T> => createBrandedSignal(HelperBrandSignal<T>, initialValue);\n\nclass HelperBrandComputed<T = unknown> {\n  #node: RuntimeComputed;\n  constructor(node: RuntimeComputed, branded = true) { this.#node = node; if (branded) registerHelperBrand(this); attachProtocol(this, node); }\n  get value(): T {\n    const node = this.#node;\n    const currentOwner = executionContext.owner;\n    // See the source getter: this copy's own graph scope needs no other check.\n    if (currentOwner === graphOwner) return readComputed(node) as T;\n    const attempt = activeRenderAttempt;\n    if (attempt !== undefined && isRenderExecutionOwner(currentOwner) && currentOwner.runtimeToken === runtimeToken && renderAdapter !== undefined) {\n      foreignAdapter.observeRevision(node);\n      return renderAdapter.readComputed(this, node, attempt) as T;\n    }\n    const owner = currentOwner;\n    // A foreign owner records this read itself (from `finally`, so an erroring\n    // computed stays observable); it must not link to this copy's `activeSub`.\n    const foreign = owner !== undefined && isForeignOwner(owner);\n    try {\n      return readComputed(node, owner !== UNTRACKED_OWNER && !foreign) as T;\n    } finally {\n      if (owner === undefined) {\n        if (activeRenderCollector !== undefined) trackRenderDependency(getRenderDependency(this, node) as import(\"./alien-derived-types.js\").RenderReadableDependency);\n      } else if (foreign) {\n        foreignAdapter.publishForeignReadable(this, node, owner);\n      }\n    }\n  }\n  peek(): T { return untracked(() => readComputed(this.#node) as T); }\n}\nfunction createBrandedComputed<T>(makeReadable: new (node: RuntimeComputed) => RuntimeReadable<T>, getter: () => T): RuntimeReadable<T> {\n  const node = makeNode(\"computed\", None, { getter, value: undefined, error: undefined, hasError: false, initialized: false });\n  return new makeReadable(node as RuntimeComputed);\n}\nconst computedClassBrandHelper = <T,>(getter: () => T): RuntimeReadable<T> => createBrandedComputed(HelperBrandComputed<T>, getter);\n\nfunction hasBrandAndPeek(value: unknown): value is { peek(): unknown } & object {\n  if (typeof value !== \"object\" || value === null) return false;\n  const version = Reflect.get(value, SIGNAL_BRAND);\n  return typeof version === \"number\" && version >= SIGNAL_BRAND_MIN_VERSION && typeof Reflect.get(value, \"peek\") === \"function\";\n}\nconst isSignalBrandHelper = hasBrandAndPeek;\nfunction createDeepSignal<T>(initialValue: T): RuntimeWritable<T> {\n  const node = makeNode(\"source\", Mutable, { currentValue: initialValue, pendingValue: initialValue });\n  const readable = new DeepSignalRuntimeSource<T>(node as RuntimeSource);\n  deepSignalNodes.add(node);\n  return readable;\n}\nfunction createDeepSignalVersion<T>(initialValue: T): RuntimeWritable<T> {\n  const node = makeNode(\"source\", Mutable, { currentValue: initialValue, pendingValue: initialValue });\n  const readable = new DeepSignalRuntimeSource<T>(node as RuntimeSource);\n  deepSignalNodes.add(node);\n  return readable;\n}\nfunction markDeepSignalWatched(readable: object): void {\n    const node = foreignAdapter.getNodeForReadable(readable);\n    if (node !== undefined) deepWatchedNodes.add(node);\n  }\nfunction hasDeepSignalSubscribers(readable: object): boolean {\n    const node = foreignAdapter.getNodeForReadable(readable);\n    return node !== undefined && (\n      deepWatchedNodes.has(node) || (deepSignalNodes.has(node) && hasSubscribers(readable))\n    );\n  }\nfunction getRenderVersion(readable: object): number {\n    return foreignAdapter.getReadableRevision(readable);\n  }\nfunction subscribeReadables(readables: readonly RuntimeReadable[], notify: () => void): () => void {\n    let initial = true;\n    return detachedEffect(() => {\n      for (const readable of readables) {\n        try { readable.value; } catch { /* Keep errored computed boundaries observed. */ }\n      }\n      if (initial) initial = false;\n      else notify();\n    });\n  }\n\n  return {\n    runtimeToken, graphOwner, configureRenderAdapter, withRenderAttempt, pushRenderAttempt,\n    getActiveRenderAttempt, getNodeForReadable, getReadableRevision, getDependencyRevision, isComputedClean,\n    promoteComputed, evaluateSpeculatively, adopt, hasSubscribers, hasActiveSubscriber, getBatchDepth,\n    signal: signalClassBrandHelper, computed: computedClassBrandHelper,\n    effect, detachedEffect, batch, untracked, SIGNAL_BRAND, isSignal: isSignalBrandHelper,\n    createDeepSignal, createDeepSignalVersion, markDeepSignalWatched, hasDeepSignalSubscribers,\n    getRenderVersion, subscribeReadables,\n  };\n}\n","/* Attempt-local render and speculative adapter for the production graph. */\nimport { executionContext, isGraphExecutionOwner, isRenderExecutionOwner, pushExecutionOwner, UNTRACKED_OWNER } from \"./execution-owner.js\";\nimport type { RenderExecutionOwnerV2 } from \"./execution-owner.js\";\nimport { activeRenderCollector, setActiveRenderCollector } from \"./render-tracking.js\";\nimport { isReadableProtocol } from \"./foreign-readable-v1.mjs\";\nimport { READABLE_INTEROP_V1 } from \"./interop-context.mjs\";\nimport type { RenderCollector } from \"./render-tracking.js\";\nimport type { AlienDerivedGraphRuntime, RenderAttempt, RenderReadableDependency, RuntimeComputed, RuntimeNode, RuntimeReadable, RuntimeSource, SpeculativeComputedEntry } from \"./alien-derived-types.js\";\n\nexport function createAlienDerivedRenderAdapter(core: AlienDerivedGraphRuntime) {\nlet activeSpeculativeComputed: SpeculativeComputedEntry | undefined;\nconst readablesByNode = new WeakMap<RuntimeNode, object>();\nconst collectorFrames: Array<{ collector: RenderCollector; active: boolean }> = [];\nlet baseRenderCollector: RenderCollector | undefined;\n\nfunction addDependency(attempt: RenderAttempt, dependency: object, revision: number): void {\n  const node = core.getNodeForReadable(dependency);\n  if (node !== undefined) readablesByNode.set(node, dependency);\n  if (activeSpeculativeComputed !== undefined) {\n    activeSpeculativeComputed.dependencies.set(dependency, revision);\n  } else {\n    attempt.add(dependency, revision);\n  }\n}\n\nfunction readSource(readable: object, node: RuntimeSource, attempt: RenderAttempt): unknown {\n  addDependency(attempt, readable, node.renderRevision);\n  return node.pendingValue;\n}\n\nfunction readComputed(readable: object, node: RuntimeComputed, attempt: RenderAttempt): unknown {\n  if (activeSpeculativeComputed !== undefined) {\n    const restoreAttempt = core.pushRenderAttempt(undefined);\n    try { return (readable as RuntimeReadable).value; }\n    finally {\n      addDependency(attempt, readable, node.renderRevision);\n      restoreAttempt();\n    }\n  }\n  addDependency(attempt, readable, node.renderRevision);\n  const cache = attempt.computedCache;\n  let entry = cache.get(node);\n  // A speculative result is only reusable while every dependency it read is\n  // still at the revision it saw. An attempt can outlive its render (a bare\n  // scope stays open until commit or a microtask, and on the server nothing\n  // ever commits), so this is what keeps \"read, write, read again\" from\n  // returning the old value. Checked here, on reuse, so writes pay nothing.\n  if (entry !== undefined && isEntryCurrent(entry)) {\n    if (entry.hasError) throw entry.error;\n    return entry.value;\n  }\n  if (core.isComputedClean(node)) {\n    if (node.hasError) throw node.error;\n    return node.value;\n  }\n\n  entry = {\n    dependencies: new Map(),\n    value: undefined,\n    error: undefined,\n    hasError: false,\n    canPromote: false,\n  };\n  cache.set(node, entry);\n  const previous = activeSpeculativeComputed;\n  activeSpeculativeComputed = entry;\n  const deepReadEpoch = attempt.speculativeDeepReadEpoch;\n  let createdEffects = false;\n  try {\n    createdEffects = core.evaluateSpeculatively(node, entry);\n  } finally {\n    activeSpeculativeComputed = previous;\n    entry.canPromote = !createdEffects && deepReadEpoch === attempt.speculativeDeepReadEpoch;\n  }\n  if (entry.hasError) throw entry.error;\n  return entry.value;\n}\n\n// Sources bump their revision on every value-changing write. A computed's\n// revision only moves when it re-evaluates, so it also has to be clean (a\n// write upstream marks even an unwatched computed dirty or pending, since\n// computeds stay linked to their sources). Foreign protocols report their own.\nfunction isEntryCurrent(entry: SpeculativeComputedEntry): boolean {\n  for (const [dependency, revision] of entry.dependencies) {\n    const node = core.getNodeForReadable(dependency);\n    if (node === undefined) {\n      if (core.getDependencyRevision(dependency) !== revision) return false;\n    } else if (node.renderRevision !== revision || (node.kind === \"computed\" && !core.isComputedClean(node))) {\n      return false;\n    }\n  }\n  return true;\n}\n\ncore.configureRenderAdapter({ readSource, readComputed });\n\nfunction createRenderAttempt(): RenderAttempt {\n  return {\n    dependencies: new Map(),\n    computedCache: new Map(),\n    speculativeDeepReadEpoch: 0,\n    add(dependency, revision) {\n      if (!this.dependencies.has(dependency)) this.dependencies.set(dependency, revision);\n    },\n    markSpeculativeDeepRead() { this.speculativeDeepReadEpoch += 1; },\n  };\n}\n\nfunction createRenderOwner(attempt: RenderAttempt, scopePolicy: \"managed\" | \"bare\" = \"managed\"): RenderExecutionOwnerV2 {\n  return {\n    version: 2 as const,\n    kind: \"render\" as const,\n    scopePolicy,\n    runtimeToken: core.runtimeToken,\n    add(protocol, revision) { addDependency(attempt, protocol, revision); },\n    isSpeculative() { return activeSpeculativeComputed !== undefined; },\n    markSpeculativeDeepRead() { attempt.markSpeculativeDeepRead(); },\n    own: core.adopt,\n  };\n}\n\nfunction pushRenderScope(attempt: RenderAttempt, scopePolicy: \"managed\" | \"bare\" = \"managed\"): () => void {\n  const parent = executionContext.owner;\n  if (isRenderExecutionOwner(parent) && !(parent.scopePolicy === \"managed\" && scopePolicy === \"managed\")) {\n    parent.closeScope?.();\n  }\n  const restoreAttempt = core.pushRenderAttempt(attempt);\n  const owner = createRenderOwner(attempt, scopePolicy);\n  const restoreOwner = pushExecutionOwner(owner);\n  const collector: RenderCollector = { add(dependency: RenderReadableDependency, revision: number) { addDependency(attempt, dependency, revision); } };\n  if (collectorFrames.length === 0) baseRenderCollector = activeRenderCollector;\n  const frame = { collector, active: true };\n  collectorFrames.push(frame);\n  setActiveRenderCollector(collector);\n  let active = true;\n  const restoreScope = () => {\n    if (!active) return;\n    active = false;\n    frame.active = false;\n    while (collectorFrames.at(-1)?.active === false) collectorFrames.pop();\n    setActiveRenderCollector(collectorFrames.at(-1)?.collector ?? baseRenderCollector);\n    if (collectorFrames.length === 0) baseRenderCollector = undefined;\n    restoreAttempt();\n    restoreOwner();\n  };\n  owner.closeScope = restoreScope;\n  return restoreScope;\n}\n\nfunction withRenderScope<T>(attempt: RenderAttempt, callback: () => T, scopePolicy: \"managed\" | \"bare\" = \"managed\"): T {\n  const restore = pushRenderScope(attempt, scopePolicy);\n  try { return callback(); }\n  finally { restore(); }\n}\n\nfunction promoteRenderAttempt(attempt: RenderAttempt): boolean {\n  for (const [node, entry] of attempt.computedCache) {\n    if (!entry.canPromote) continue;\n    const readable = readablesByNode.get(node);\n    if (readable === undefined || !core.promoteComputed(readable, node, entry)) return false;\n  }\n  return true;\n}\n\nfunction settleRenderAttempt(attempt: RenderAttempt): boolean {\n  let stable = true;\n  for (const [dependency, revision] of attempt.dependencies) {\n    const currentRevision = getRenderVersion(dependency);\n    if (currentRevision === revision) continue;\n    const node = core.getNodeForReadable(dependency);\n    const entry = node === undefined ? undefined : attempt.computedCache.get(node);\n    if (node === undefined || entry === undefined || node.initialized !== true || entry.hasError !== node.hasError ||\n        (!entry.hasError && !Object.is(entry.value, node.value))) {\n      stable = false;\n      continue;\n    }\n    attempt.dependencies.set(dependency, currentRevision);\n  }\n  return stable;\n}\n\nfunction getRenderVersion(readable: object): number {\n  if (isReadableProtocol(readable) || core.getNodeForReadable(readable) !== undefined || Reflect.get(readable, READABLE_INTEROP_V1) !== undefined) {\n    return core.getDependencyRevision(readable);\n  }\n  const getVersion = Reflect.get(readable, \"getRenderVersion\");\n  if (typeof getVersion === \"function\") return getVersion.call(readable) as number;\n  throw new TypeError(\"Unknown render dependency\");\n}\nfunction hasActiveRenderOwner(): boolean { return isRenderExecutionOwner(executionContext.owner); }\nfunction isSpeculative() {\n  const owner = executionContext.owner;\n  if (isGraphExecutionOwner(owner) || owner === UNTRACKED_OWNER) return false;\n  return isRenderExecutionOwner(owner)\n    && (owner.isSpeculative?.() === true || activeSpeculativeComputed !== undefined);\n}\nfunction markSpeculativeDeepRead(): void {\n  const attempt = core.getActiveRenderAttempt();\n  if (attempt !== undefined) attempt.markSpeculativeDeepRead();\n  else if (isRenderExecutionOwner(executionContext.owner)) executionContext.owner.markSpeculativeDeepRead?.();\n}\n\nfunction subscribeReadables(readables: readonly RuntimeReadable[], notify: () => void): () => void {\n  let initial = true;\n  return core.detachedEffect(() => {\n    for (const readable of readables) {\n      try { readable.value; } catch { /* Keep errored computed boundaries observed. */ }\n    }\n    if (initial) initial = false;\n    else notify();\n  });\n}\n\nfunction captureRenderSnapshot(readable: RuntimeReadable): { value: unknown; dependencies: Map<object, number>; attempt: RenderAttempt } {\n  const attempt = createRenderAttempt();\n  let value: unknown;\n  withRenderScope(attempt, () => { value = readable.value; });\n  return { value, dependencies: attempt.dependencies, attempt };\n}\n\nfunction getExecutionOwner() { return executionContext.owner; }\n  return {\n    createRenderAttempt, createRenderOwner, pushRenderScope, withRenderScope,\n    promoteRenderAttempt, settleRenderAttempt, getRenderVersion, hasActiveRenderOwner, isSpeculative,\n    markSpeculativeDeepRead, subscribeReadables, captureRenderSnapshot,\n    getExecutionOwner,\n  };\n}\n","import { createAlienDerivedRuntime } from \"./alien-derived-runtime-core.mjs\";\nimport { createAlienDerivedRenderAdapter } from \"./render-runtime.mjs\";\nimport type { AlienDerivedRenderAdapter, RuntimeNode } from \"./alien-derived-types.js\";\n\nexport interface RuntimeReadonlySignal<T> {\n  readonly value: T;\n  peek(): T;\n}\n\nexport interface RuntimeSignal<T> extends RuntimeReadonlySignal<T> {\n  value: T;\n}\n\nexport interface ReactiveRuntime {\n  readonly runtimeToken: object;\n  readonly graphOwner: {\n    readonly kind: \"graph\";\n    readonly runtimeToken: object;\n    add(protocol: object, revision: number): void;\n  };\n  getNodeForReadable(readable: RuntimeReadonlySignal<unknown>): RuntimeNode | undefined;\n  readonly renderAdapter: AlienDerivedRenderAdapter;\n  signal<T>(value: T): RuntimeSignal<T>;\n  computed<T>(getter: () => T): RuntimeReadonlySignal<T>;\n  effect(fn: () => void | (() => void)): () => void;\n  detachedEffect(fn: () => void | (() => void)): () => void;\n  batch<T>(fn: () => T): T;\n  untracked<T>(fn: () => T): T;\n  hasSubscribers(readable: RuntimeReadonlySignal<unknown>): boolean;\n  hasActiveSubscriber(): boolean;\n  getBatchDepth(): number;\n  createDeepSignal<T>(initialValue: T): RuntimeSignal<T>;\n  createDeepSignalVersion<T>(initialValue: T): RuntimeSignal<T>;\n  markDeepSignalWatched(readable: RuntimeReadonlySignal<unknown>): void;\n  hasDeepSignalSubscribers(readable: RuntimeReadonlySignal<unknown>): boolean;\n  isSpeculative(): boolean;\n  markSpeculativeDeepRead(): void;\n}\n\n/** Builds one Alien-derived graph and its separate owner/render adapters. */\nexport function createReactiveRuntime(): ReactiveRuntime {\n  const graph = createAlienDerivedRuntime();\n  const render = createAlienDerivedRenderAdapter(graph);\n\n  return {\n    runtimeToken: graph.runtimeToken,\n    graphOwner: graph.graphOwner,\n    getNodeForReadable: graph.getNodeForReadable,\n    renderAdapter: render,\n    signal: graph.signal,\n    computed: graph.computed,\n    effect: graph.effect,\n    detachedEffect: graph.detachedEffect,\n    batch: graph.batch,\n    untracked: graph.untracked,\n    hasSubscribers: graph.hasSubscribers,\n    hasActiveSubscriber: graph.hasActiveSubscriber,\n    getBatchDepth: graph.getBatchDepth,\n    createDeepSignal: graph.createDeepSignal,\n    createDeepSignalVersion: graph.createDeepSignalVersion,\n    markDeepSignalWatched: graph.markDeepSignalWatched,\n    hasDeepSignalSubscribers: graph.hasDeepSignalSubscribers,\n    isSpeculative: render.isSpeculative,\n    markSpeculativeDeepRead: render.markSpeculativeDeepRead,\n  };\n}\n","import { createReactiveRuntime } from \"./reactive-runtime.js\";\n\n/** The single graph used by this package's public signal APIs. */\nexport const coreRuntime = createReactiveRuntime();\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -1,27 +1,18 @@
 import { a as effect, c as untracked, i as computed, n as Signal, o as isSignal, r as batch, s as signal, t as ReadonlySignal } from "./base-Bx5ahfW2.js";
-import { r as useSignals } from "./use-signals-CBDbbAbV.js";
+import { a as deepSignal, i as NotDeepSignal, n as createSignalAwareElement, r as DeepSignal } from "./jsx-BQGrTir3.js";
+import { r as useSignalTracking } from "./use-signals-CJYcdFdL.js";
 import { DependencyList } from "react";
-//#region src/core/deep-signal.d.ts
-/** A signal whose plain-object and array values are reactive by property. */
-interface DeepSignal<T extends object> extends Signal<T> {}
-/**
- * Creates a signal that lazily tracks nested plain-object and array properties.
- * Mutations must go through `.value`; changes made through the original raw
- * object are intentionally not observable.
- */
-declare function deepSignal<T extends object>(initialValue: T): DeepSignal<T>;
-//#endregion
 //#region src/react/hooks.d.ts
 /** An immutable value that React can safely compare as an external-store snapshot. */
 type SignalSnapshot = string | number | boolean | bigint | symbol | null | undefined;
 /** Creates a signal whose identity is stable for the lifetime of this component. */
-declare function useSignal<T>(initialValue: T): Signal<T>;
+export declare function useSignal<T>(initialValue: T): Signal<T>;
 /**
  * Creates a deep signal whose identity is stable for the component lifetime.
  * A factory is evaluated only while initializing a mounted component instance;
  * it must remain pure because React Strict Mode may replay initial rendering.
  */
-declare function useDeepSignal<T extends object>(initialValue: T | (() => T)): DeepSignal<T>;
+export declare function useDeepSignal<T extends object>(initialValue: T | (() => T)): DeepSignal<T>;
 /**
  * Selects a property-level primitive snapshot from a deep signal.
  *
@@ -36,7 +27,7 @@ declare function useDeepSignal<T extends object>(initialValue: T | (() => T)): D
  * "changed size between renders" dev warning, mirroring `useComputed`'s
  * dependency-mode-switch guard.
  */
-declare function useDeepSignalValue<T extends object, S extends SignalSnapshot>(source: DeepSignal<T>, selector: (value: T) => S, dependencies: DependencyList): S;
+export declare function useDeepSignalValue<T extends object, S extends SignalSnapshot>(source: DeepSignal<T>, selector: (value: T) => S, dependencies: DependencyList): S;
 /**
  * Creates a computed signal with a stable identity.
  *
@@ -51,7 +42,7 @@ declare function useDeepSignalValue<T extends object, S extends SignalSnapshot>(
  * closure used by the previously committed computed. Choose one mode for a
  * component's lifetime.
  */
-declare function useComputed<T>(getValue: () => T, dependencies?: DependencyList): ReadonlySignal<T>;
+export declare function useComputed<T>(getValue: () => T, dependencies?: DependencyList): ReadonlySignal<T>;
 /**
  * Runs a reactive effect after this component has committed, disposing it when
  * the component unmounts (and during React Strict Mode's development replay).
@@ -64,17 +55,21 @@ declare function useComputed<T>(getValue: () => T, dependencies?: DependencyList
  * all of those values in `dependencies`. The effect is then reconnected after
  * those dependencies change. Choose one mode for a component's lifetime.
  */
-declare function useSignalEffect(callback: () => void | (() => void), dependencies?: DependencyList): void;
+export declare function useSignalEffect(callback: () => void | (() => void), dependencies?: DependencyList): void;
 /**
- * Reads a signal and subscribes the component to subsequent changes.
+ * Reads a signal and subscribes the component to subsequent changes through
+ * ReadableInterop V1 when available.
+ *
+ * `useSyncExternalStore` owns the initial consistency check after subscribing.
+ * For V1 readables, its watcher tracks revisions without an EffectNode. A
+ * read that throws (a computed whose cached error `.value` rethrows) remains
+ * for the render-time `getSnapshot` to surface to an Error Boundary; only the
+ * structural-readable fallback needs an effect to contain background errors.
  *
- * The immediate run made by the public `effect` API establishes dependency
- * tracking only. It intentionally does not notify React: `useSyncExternalStore`
- * owns the initial consistency check after subscribing. See `createSignalStore`
- * for the shared subscribe/notify wiring, including why a read that throws
- * (a computed whose cached error `.value` rethrows) is swallowed in the
- * background effect and left for `getSnapshot` to rethrow instead.
+ * A `deepSignal` is rejected at compile time: this subscribes to root
+ * replacement only, so nested mutations would never re-render. Read deep state
+ * with `useDeepSignalValue` or inside a tracked component instead.
  */
-declare function useSignalValue<T>(source: ReadonlySignal<T>): T;
+export declare function useSignalValue<T>(source: ReadonlySignal<T> & NotDeepSignal): T;
 //#endregion
-export { type DeepSignal, type ReadonlySignal, type Signal, type SignalSnapshot, batch, computed, deepSignal, effect, isSignal, signal, untracked, useComputed, useDeepSignal, useDeepSignalValue, useSignal, useSignalEffect, useSignalValue, useSignals };
+export { type DeepSignal, type ReadonlySignal, type Signal, type SignalSnapshot, batch, computed, createSignalAwareElement as createElement, deepSignal, effect, isSignal, signal, untracked, useSignalTracking };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { a as effect, c as signal, i as computed, l as untracked, o as isSignal, r as batch } from "./base-BZTnpU8U.js";
-import { a as useSignalEffect, i as useSignal, n as useDeepSignal, o as useSignalValue, r as useDeepSignalValue, s as deepSignal, t as useComputed } from "./hooks-BFIWh7AD.js";
-import { n as useSignals } from "./use-signals-8i2B-94o.js";
-export { batch, computed, deepSignal, effect, isSignal, signal, untracked, useComputed, useDeepSignal, useDeepSignalValue, useSignal, useSignalEffect, useSignalValue, useSignals };
+import { a as isSignal, c as untracked, i as effect, n as computed, s as signal, t as batch } from "./base-WD_74mfC.js";
+import { a as useDeepSignalValue, c as useSignalValue, i as useDeepSignal, l as deepSignal, n as createSignalAwareElement, o as useSignal, r as useComputed, s as useSignalEffect } from "./jsx-P6volZdr.js";
+import { n as useSignalTracking } from "./use-signals-C1K8-vJX.js";
+export { batch, computed, createSignalAwareElement as createElement, deepSignal, effect, isSignal, signal, untracked, useComputed, useDeepSignal, useDeepSignalValue, useSignal, useSignalEffect, useSignalTracking, useSignalValue };

package/dist/{jsx-Xp5q2y97.d.ts → jsx-BQGrTir3.d.ts}

@@ -1,13 +1,47 @@
-import { t as ReadonlySignal } from "./base-Bx5ahfW2.js";
+import { n as Signal, t as ReadonlySignal } from "./base-Bx5ahfW2.js";
 import * as React from "react";
+//#region src/core/deep-signal.d.ts
+declare const deepSignalBrand: unique symbol;
+/** A signal whose plain-object and array values are reactive by property. */
+interface DeepSignal<T extends object> extends Signal<T> {
+  /**
+   * Type-only marker; never present at runtime. It lets positions that only
+   * observe a signal's root value reject a deep signal at compile time,
+   * because they would not re-render on nested mutations.
+   */
+  readonly [deepSignalBrand]: true;
+}
+/**
+ * Package-internal: intersected with `ReadonlySignal<T>` where only root
+ * replacement is observed (`useSignalValue`, JSX children and host props), so
+ * passing a `DeepSignal` there is a type error instead of a silently stale UI.
+ */
+type NotDeepSignal = {
+  readonly [deepSignalBrand]?: never;
+};
+/**
+ * Creates a signal that lazily tracks nested plain-object and array properties.
+ * Mutations must go through `.value`; changes made through the original raw
+ * object are intentionally not observable.
+ */
+declare function deepSignal<T extends object>(initialValue: T): DeepSignal<T>;
+//#endregion
 //#region src/runtime/jsx.d.ts
 declare const SVG_ELEMENTS: readonly ["svg", "animate", "animateMotion", "animateTransform", "circle", "clipPath", "defs", "desc", "ellipse", "feBlend", "feColorMatrix", "feComponentTransfer", "feComposite", "feConvolveMatrix", "feDiffuseLighting", "feDisplacementMap", "feDistantLight", "feDropShadow", "feFlood", "feFuncA", "feFuncB", "feFuncG", "feFuncR", "feGaussianBlur", "feImage", "feMerge", "feMergeNode", "feMorphology", "feOffset", "fePointLight", "feSpecularLighting", "feSpotLight", "feTile", "feTurbulence", "filter", "foreignObject", "g", "image", "line", "linearGradient", "marker", "mask", "metadata", "mpath", "path", "pattern", "polygon", "polyline", "radialGradient", "rect", "set", "stop", "switch", "symbol", "text", "textPath", "tspan", "use", "view"];
 type SvgElement = (typeof SVG_ELEMENTS)[number];
 declare const MATHML_ELEMENTS: readonly ["annotation", "annotation-xml", "maction", "math", "merror", "mfrac", "mi", "mmultiscripts", "mn", "mo", "mover", "mpadded", "mphantom", "mprescripts", "mroot", "mrow", "ms", "mspace", "msqrt", "mstyle", "msub", "msubsup", "msup", "mtable", "mtd", "mtext", "mtr", "munder", "munderover", "semantics"];
 type MathMlElement = (typeof MATHML_ELEMENTS)[number];
 type NonHtmlHostElement = SvgElement | MathMlElement;
-type SignalChild = React.ReactNode | ReadonlySignal<SignalChild> | readonly SignalChild[];
-type Signalable<T> = T | ReadonlySignal<T>;
+type SignalChild = React.ReactNode | (ReadonlySignal<SignalChild> & NotDeepSignal) | readonly SignalChild[];
+/**
+ * The classic-runtime `createElement` that the automatic runtime falls back to
+ * for `<div {...props} key="k" />` — TypeScript, Babel and Oxc all import it
+ * from the package root of `jsxImportSource`. It applies the same host-prop
+ * bindings and child normalization as `jsx`, and leaves `key` (and `ref`) in
+ * the config for React's own `createElement` to extract.
+ */
+declare function createSignalAwareElement(type: React.ElementType, config?: Record<string, unknown> | null, ...children: unknown[]): React.ReactElement;
+type Signalable<T> = T | (ReadonlySignal<T> & NotDeepSignal);
 type DirectSignalPropName = "title" | "id" | "className" | "hidden" | "disabled" | "style" | "value" | "checked";
 type AriaPropName = `aria-${string}`;
 type AddSignalChildren<P> = Omit<P, "children"> & {
@@ -27,7 +61,8 @@ declare namespace JSX {
   type LibraryManagedAttributes<C, P> = React.JSX.LibraryManagedAttributes<C, P>;
   interface IntrinsicAttributes extends React.JSX.IntrinsicAttributes {}
   interface IntrinsicClassAttributes<T> extends React.JSX.IntrinsicClassAttributes<T> {}
-  type IntrinsicElements = { [Tag in keyof React.JSX.IntrinsicElements]: Tag extends NonHtmlHostElement ? AddSignalChildren<React.JSX.IntrinsicElements[Tag]> : AddHtmlSignalProps<React.JSX.IntrinsicElements[Tag]>; };
+  interface IntrinsicElements extends SignalIntrinsicElements {}
 }
+type SignalIntrinsicElements = { [Tag in keyof React.JSX.IntrinsicElements]: Tag extends NonHtmlHostElement ? AddSignalChildren<React.JSX.IntrinsicElements[Tag]> : AddHtmlSignalProps<React.JSX.IntrinsicElements[Tag]>; };
 //#endregion
-export { JSX as t };
+export { deepSignal as a, NotDeepSignal as i, createSignalAwareElement as n, DeepSignal as r, JSX as t };