octane 0.2.12 → 0.2.13

package/dist/signals/facade.d.ts

@@ -0,0 +1,74 @@
+import { NATIVE_DOM_VALUE } from './read-protocol.js';
+export { isSignalHandle, isWritableSignal } from './handle-protocol.js';
+import { SIGNAL_HANDLE, SIGNAL_BINDING_IDENTITY, SIGNAL_BINDING_READ, SIGNAL_BINDING_SUBSCRIBE, SIGNAL_OWNER_RESOLVE, type DerivedCompute, type DerivedOptions, type DerivedSignal, type OwnerBoundSignal, type Scope, type ScopeSeed, type SignalHandle, type SignalOptions, type SignalOwner, type SignalOwnerIdentity, type SignalSnapshot, type WritableSignal } from './types.js';
+import type { StreamFrameIdentity, StreamedSignalResultFrame } from '../streamed-signals-protocol.js';
+/** @internal Install initial response data before this document creates any live cells. */
+export declare function initializeDocumentSignalOwner(owner: SignalOwnerIdentity, seed: ScopeSeed): void;
+/** @internal A document may freeze read work without retiring data or accepted writes. */
+export declare function createSignalOwnerLifecycle(owner: SignalOwner): {
+    readonly retired: boolean;
+    freeze(): void;
+    resume(): void;
+    retire(): void;
+};
+/** @internal Resolve a public descriptor in the current declaration owner. */
+export declare function resolveCurrentSignalHandle<T>(handle$: SignalHandle<T>): SignalHandle<T>;
+/** @internal Resolve a descriptor against a captured renderer/request owner. */
+export declare function resolveSignalHandleForOwner<T>(handle$: SignalHandle<T>, owner: SignalOwner): SignalHandle<T>;
+/** @internal Resolve a descriptor against an already selected signal scope. */
+export declare function resolveSignalHandleForScope<T>(handle$: SignalHandle<T>, owner: Scope): SignalHandle<T>;
+/** @internal Shared owner resolution for statically selected signal factories. */
+export declare abstract class Descriptor<T, H extends SignalHandle<T>> implements OwnerBoundSignal<T> {
+    readonly key: string;
+    readonly kind: H['kind'];
+    private readonly create;
+    private readonly site;
+    readonly [SIGNAL_HANDLE]: true;
+    private readonly cells;
+    constructor(key: string, kind: H['kind'], create: (owner: Scope) => H, site: string | undefined);
+    [SIGNAL_OWNER_RESOLVE](owner: Scope): H;
+    private resolvedCell;
+    protected resolve(): H;
+    get(): T;
+    [NATIVE_DOM_VALUE](): T;
+    [SIGNAL_BINDING_READ](): T;
+    [SIGNAL_BINDING_SUBSCRIBE](notify: () => void, onRetire?: () => void): () => void;
+    [SIGNAL_BINDING_IDENTITY](): {
+        scope: "document" | "instance";
+        nodeKey: string;
+    };
+    latest(): T | undefined;
+    latest<F>(fallback: F): T | F;
+    snapshot(): SignalSnapshot<T>;
+    subscribe(notify: () => void): () => void;
+}
+/** @internal Scalar and general derivations share the same public handle. */
+export declare class DerivedDescriptor<T> extends Descriptor<T, DerivedSignal<T>> implements DerivedSignal<T> {
+    readonly kind: 'derived';
+}
+/** @internal Preserve authored or compiler-assigned declaration identity. */
+export declare function descriptorKey(site: string | undefined, explicit: string | undefined): string;
+/** @internal Read authored identity once, without interpreting initial data as a key. */
+export declare function signalOptionsKey(options?: SignalOptions): string | undefined;
+export declare function __signalAt<T>(site: string | undefined, initial: T, options?: SignalOptions): WritableSignal<T>;
+export declare function signal$<T>(initial: T, options?: SignalOptions): WritableSignal<T>;
+/** Compiler-only scalar proof; authored derived$ remains dynamically asynchronous. */
+export declare function __derivedScalarAt<T>(site: string | undefined, compute: DerivedCompute<T>, options?: DerivedOptions & SignalOptions): DerivedSignal<T>;
+export declare function readSignalBinding<T>(handle$: SignalHandle<T>): T;
+/** @internal Start compiler-proven independent reads without consuming their results. */
+export declare function __startSignalReads(handles: readonly SignalHandle<unknown>[], primitive?: boolean): void;
+/** Bind receiver-owned selection authority, optionally before the query descriptor resolves. */
+export declare function bindStreamedSignalSelection(owner: SignalOwner, identity: StreamFrameIdentity): boolean;
+/** Accept one already-validated result frame without reviving a retired owner. */
+export declare function acceptStreamedSignalResult(owner: SignalOwner, frame: StreamedSignalResultFrame): boolean;
+/** Fail one exact result channel without exposing an untrusted remote stack. */
+export declare function failStreamedSignalResult(owner: SignalOwner, identity: StreamFrameIdentity, code: string): boolean;
+interface StreamedSignalReceiver {
+    attachResult(identity: StreamFrameIdentity, consumer: {
+        accept(frame: StreamedSignalResultFrame): void | false;
+        retainCompleted?(frames: StreamedSignalResultFrame[]): boolean;
+        fail(error: any): void;
+    }): () => void;
+}
+/** Connect a neutral early receiver to the signals engine without a hydration dependency. */
+export declare function attachStreamedSignalResult(receiver: StreamedSignalReceiver, owner: SignalOwner, identity: StreamFrameIdentity): () => void;

package/dist/signals/facade.js

@@ -0,0 +1,452 @@
+import {
+  acceptScopeStreamedResult,
+  bindScopeStreamedSelection,
+  createDeclaredSignalCell,
+  createScope,
+  failScopeStreamedResult,
+  ScopeImpl
+} from "./engine.js";
+import { createDeclaredScalarCell } from "./scalar-computations.js";
+import { ScopeDisposedError, SignalStreamError } from "./errors.js";
+import { isThenable, readSignalBinding as readBinding, untrack } from "./graph.js";
+import { readEarlySignalValue } from "./early-values.js";
+import { NATIVE_DOM_VALUE, forwardNativeTransitionConsumer } from "./read-protocol.js";
+import { isSignalHandle } from "./handle-protocol.js";
+import { isSignalHandle as isSignalHandle2, isWritableSignal } from "./handle-protocol.js";
+import {
+  captureSignalOwner,
+  currentSignalOwner,
+  installSignalOwnerRetirement,
+  runWithSignalOwner
+} from "./owner-context.js";
+import {
+  SIGNAL_HANDLE,
+  SIGNAL_BINDING_IDENTITY,
+  SIGNAL_BINDING_READ,
+  SIGNAL_BINDING_SUBSCRIBE,
+  SIGNAL_OWNER_RESOLVE
+} from "./types.js";
+const identityScopes = /* @__PURE__ */ new WeakMap();
+const scopeOwners = /* @__PURE__ */ new WeakMap();
+const retiredIdentities = /* @__PURE__ */ new WeakSet();
+const documentInstances = /* @__PURE__ */ new WeakMap();
+const instanceDocuments = /* @__PURE__ */ new WeakMap();
+const frozenDocuments = /* @__PURE__ */ new WeakMap();
+function isScope(owner) {
+  return typeof owner.signal$ === "function";
+}
+function isRendererOwner(owner) {
+  return "documentOwner" in owner && "instanceOwner" in owner && typeof owner.instanceKey === "string";
+}
+function resolveIdentity(identity, scopeKey, owner) {
+  if (retiredIdentities.has(identity)) throw new ScopeDisposedError(scopeKey);
+  let scope = identityScopes.get(identity);
+  if (!scope) {
+    scope = createScope({ scopeKey });
+    identityScopes.set(identity, scope);
+    scopeOwners.set(scope, owner);
+    const barrier = frozenDocuments.get(isRendererOwner(owner) ? owner.documentOwner : owner);
+    if (barrier !== void 0) scope.readBarrier = barrier;
+  }
+  return scope;
+}
+function initializeDocumentSignalOwner(owner, seed) {
+  if (isScope(owner) || isRendererOwner(owner)) {
+    throw new TypeError("Initial document signals require an implicit document owner.");
+  }
+  if (retiredIdentities.has(owner)) throw new ScopeDisposedError(owner.scopeKey);
+  if (identityScopes.has(owner)) {
+    throw new Error(
+      "Initial document signals must be installed once, before any signal reads or writes."
+    );
+  }
+  const scope = createScope({ scopeKey: owner.scopeKey, seed });
+  const barrier = frozenDocuments.get(owner);
+  if (barrier !== void 0) scope.readBarrier = barrier;
+  identityScopes.set(owner, scope);
+  scopeOwners.set(scope, owner);
+}
+function resolveOwner(owner) {
+  if (isScope(owner)) return owner;
+  if (isRendererOwner(owner)) {
+    if (!isScope(owner.documentOwner) && retiredIdentities.has(owner.documentOwner)) {
+      throw new ScopeDisposedError(owner.documentOwner.scopeKey);
+    }
+    if (isScope(owner.documentOwner) && owner.documentOwner.retired) {
+      throw new ScopeDisposedError(owner.documentOwner.scopeKey);
+    }
+    let instances = documentInstances.get(owner.documentOwner);
+    if (!instances) documentInstances.set(owner.documentOwner, instances = /* @__PURE__ */ new Set());
+    instances.add(owner.instanceOwner);
+    instanceDocuments.set(owner.instanceOwner, owner.documentOwner);
+    const documentKey = owner.documentOwner.scopeKey;
+    return resolveIdentity(
+      owner.instanceOwner,
+      `${documentKey}:instance:${owner.instanceKey}`,
+      owner
+    );
+  }
+  return resolveIdentity(owner, owner.scopeKey, owner);
+}
+function resolveDescriptorOwner(site, owner) {
+  if (isScope(owner)) owner = scopeOwners.get(owner) ?? owner;
+  if (!isRendererOwner(owner)) return resolveOwner(owner);
+  if (site?.startsWith("g:")) return resolveOwner(owner.documentOwner);
+  if (site?.startsWith("i:")) {
+    return resolveOwner(owner);
+  }
+  return resolveOwner(owner);
+}
+function existingIdentityScope(identity) {
+  if (retiredIdentities.has(identity)) return;
+  const scope = identityScopes.get(identity);
+  return scope?.retired ? void 0 : scope;
+}
+function streamedScope(owner, identity, create) {
+  if (isScope(owner)) {
+    return !owner.retired && identity.ownerKey === owner.scopeKey ? owner : void 0;
+  }
+  if (!isRendererOwner(owner)) return;
+  if (identity.ownerKey !== owner.documentOwner.scopeKey || identity.instanceKey !== owner.instanceKey || !identity.nodeKey.startsWith("g:") && !identity.nodeKey.startsWith("i:")) {
+    return;
+  }
+  const documentRetired = isScope(owner.documentOwner) ? owner.documentOwner.retired : retiredIdentities.has(owner.documentOwner);
+  if (documentRetired || retiredIdentities.has(owner.instanceOwner)) return;
+  const target = identity.nodeKey.startsWith("g:") ? owner.documentOwner : owner;
+  if (create) return resolveDescriptorOwner(identity.nodeKey, target);
+  if (isScope(target)) return target.retired ? void 0 : target;
+  return existingIdentityScope(isRendererOwner(target) ? target.instanceOwner : target);
+}
+installSignalOwnerRetirement((owner) => {
+  if (isScope(owner)) return;
+  const identity = isRendererOwner(owner) ? owner.instanceOwner : owner;
+  if (isRendererOwner(owner)) {
+    const document = instanceDocuments.get(identity);
+    if (document) documentInstances.get(document)?.delete(identity);
+    instanceDocuments.delete(identity);
+  } else {
+    const instances = documentInstances.get(identity);
+    if (instances) {
+      for (const instance of instances) {
+        retiredIdentities.add(instance);
+        const instanceScope = identityScopes.get(instance);
+        if (instanceScope) {
+          identityScopes.delete(instance);
+          scopeOwners.delete(instanceScope);
+          instanceScope.dispose();
+        }
+        instanceDocuments.delete(instance);
+      }
+      documentInstances.delete(identity);
+    }
+  }
+  retiredIdentities.add(identity);
+  const scope = identityScopes.get(identity);
+  if (!scope) return;
+  identityScopes.delete(identity);
+  scopeOwners.delete(scope);
+  scope.dispose();
+});
+function createSignalOwnerLifecycle(owner) {
+  if (isRendererOwner(owner))
+    throw new TypeError("A document lifecycle requires its document owner.");
+  let barrier;
+  let release;
+  let disposed = false;
+  const scopes = () => {
+    const result = [];
+    const scope = isScope(owner) ? owner : existingIdentityScope(owner);
+    if (scope instanceof ScopeImpl && !scope.retired) result.push(scope);
+    for (const instance of documentInstances.get(owner) ?? []) {
+      const scope2 = existingIdentityScope(instance);
+      if (scope2 instanceof ScopeImpl) result.push(scope2);
+    }
+    return result;
+  };
+  return {
+    get retired() {
+      return disposed || (isScope(owner) ? owner.retired : retiredIdentities.has(owner));
+    },
+    freeze() {
+      if (this.retired || barrier !== void 0) return;
+      barrier = new Promise((resolve) => {
+        release = resolve;
+      });
+      frozenDocuments.set(owner, barrier);
+      const existing = scopes();
+      for (const scope of existing) scope.readBarrier = barrier;
+      for (const scope of existing) scope.suspendReads();
+    },
+    resume() {
+      if (this.retired || barrier === void 0) return;
+      const existing = scopes();
+      barrier = void 0;
+      frozenDocuments.delete(owner);
+      for (const scope of existing) scope.readBarrier = void 0;
+      release?.();
+      release = void 0;
+      for (const scope of existing) {
+        if (barrier !== void 0 || this.retired) break;
+        scope.resumeReads();
+      }
+    },
+    retire() {
+      if (disposed) return;
+      disposed = true;
+      frozenDocuments.delete(owner);
+      const existing = scopes();
+      for (const instance of documentInstances.get(owner) ?? []) retiredIdentities.add(instance);
+      retiredIdentities.add(owner);
+      for (const scope of existing) scope.dispose();
+      documentInstances.delete(owner);
+      release?.();
+      release = void 0;
+      barrier = void 0;
+    }
+  };
+}
+function requireOwner() {
+  const owner = currentSignalOwner();
+  if (!owner) {
+    throw new Error(
+      "A module signal needs an active signal owner. Render it in an Octane root or use runWithSignalOwner()."
+    );
+  }
+  return owner;
+}
+function resolveCurrentSignalHandle(handle$) {
+  return resolveSignalHandleForOwner(handle$, requireOwner());
+}
+function resolveSignalHandleForOwner(handle$, owner) {
+  return resolveSignalHandleForScope(handle$, resolveOwner(owner));
+}
+function resolveSignalHandleForScope(handle$, owner) {
+  return SIGNAL_OWNER_RESOLVE in handle$ ? handle$[SIGNAL_OWNER_RESOLVE](owner) : handle$;
+}
+function requireSite(site) {
+  if (site) return site;
+  throw new Error(
+    "Module signal identity is assigned by the Octane compiler. Use an explicit key outside compiled code."
+  );
+}
+class Descriptor {
+  constructor(key, kind, create, site) {
+    this.key = key;
+    this.kind = kind;
+    this.create = create;
+    this.site = site;
+  }
+  key;
+  kind;
+  create;
+  site;
+  [SIGNAL_HANDLE] = true;
+  cells = /* @__PURE__ */ new WeakMap();
+  [SIGNAL_OWNER_RESOLVE](owner) {
+    requireSite(this.site);
+    return this.resolvedCell(resolveDescriptorOwner(this.site, owner));
+  }
+  resolvedCell(target) {
+    let cell = this.cells.get(target);
+    if (!cell) {
+      cell = this.create(target);
+      this.cells.set(target, cell);
+    }
+    return cell;
+  }
+  resolve() {
+    const token = requireOwner();
+    const owner = resolveDescriptorOwner(this.site, token);
+    requireSite(this.site);
+    return this.resolvedCell(owner);
+  }
+  get() {
+    return this.resolve().get();
+  }
+  [NATIVE_DOM_VALUE]() {
+    return this.get();
+  }
+  [SIGNAL_BINDING_READ]() {
+    return readBinding(this.resolve());
+  }
+  [SIGNAL_BINDING_SUBSCRIBE](notify, onRetire) {
+    const run = captureSignalOwner(requireOwner());
+    return this.resolve()[SIGNAL_BINDING_SUBSCRIBE](
+      forwardNativeTransitionConsumer(notify, () => run(notify)),
+      onRetire === void 0 ? void 0 : () => run(onRetire)
+    );
+  }
+  [SIGNAL_BINDING_IDENTITY]() {
+    return {
+      scope: this.site?.startsWith("g:") ? "document" : "instance",
+      nodeKey: this.key
+    };
+  }
+  latest(fallback) {
+    return this.resolve().latest(fallback);
+  }
+  snapshot() {
+    return this.resolve().snapshot();
+  }
+  subscribe(notify) {
+    const token = requireOwner();
+    const scope = resolveDescriptorOwner(this.site, token);
+    const run = captureSignalOwner(token);
+    return this[SIGNAL_OWNER_RESOLVE](scope).subscribe(
+      forwardNativeTransitionConsumer(notify, () => run(notify))
+    );
+  }
+}
+class SignalDescriptor extends Descriptor {
+  set(value) {
+    this.resolve().set(value);
+  }
+}
+class DerivedDescriptor extends Descriptor {
+}
+function descriptorKey(site, explicit) {
+  const key = explicit ?? site;
+  if (typeof key !== "string" || !key.trim()) return "<compiler-assigned-signal>";
+  return key;
+}
+function signalOptionsKey(options) {
+  if (options != null && typeof options !== "object") {
+    throw new TypeError("Signal declaration options must be an object.");
+  }
+  const key = options?.key;
+  if (key !== void 0 && (typeof key !== "string" || !key.trim())) {
+    throw new TypeError("A signal declaration key must be a nonempty string.");
+  }
+  return key;
+}
+function __signalAt(site, initial, options) {
+  const explicit = signalOptionsKey(options);
+  site ??= explicit;
+  const key = descriptorKey(site, explicit);
+  return new SignalDescriptor(
+    key,
+    "signal",
+    (owner) => {
+      const early = readEarlySignalValue(scopeOwners.get(owner) ?? owner, {
+        scope: site?.startsWith("g:") ? "document" : "instance",
+        nodeKey: key
+      });
+      return createDeclaredSignalCell(
+        owner,
+        key,
+        early === void 0 ? initial : early.value,
+        early !== void 0
+      );
+    },
+    site
+  );
+}
+function signal$(initial, options) {
+  return __signalAt(void 0, initial, options);
+}
+function __derivedScalarAt(site, compute, options) {
+  if (typeof compute !== "function") throw new TypeError("derived$ requires a function.");
+  const explicit = signalOptionsKey(options);
+  site ??= explicit;
+  const key = descriptorKey(site, explicit);
+  return new DerivedDescriptor(
+    key,
+    "derived",
+    (owner) => createDeclaredScalarCell(
+      owner,
+      key,
+      () => runWithSignalOwner(owner, () => compute())
+    ),
+    site
+  );
+}
+function readSignalBinding(handle$) {
+  if (!isSignalHandle(handle$)) throw new TypeError("A signal binding requires a signal handle.");
+  return handle$[SIGNAL_BINDING_READ]();
+}
+function __startSignalReads(handles, primitive = false) {
+  untrack(() => {
+    for (const handle of handles) {
+      try {
+        const value = handle[SIGNAL_BINDING_READ]();
+        if (primitive && value != null && (typeof value === "object" || typeof value === "function" || typeof value === "symbol"))
+          break;
+      } catch (error) {
+        if (!isThenable(error)) break;
+      }
+    }
+  });
+}
+function bindStreamedSignalSelection(owner, identity) {
+  const scope = streamedScope(owner, identity, true);
+  return scope ? bindScopeStreamedSelection(scope, identity) : false;
+}
+function acceptStreamedSignalResult(owner, frame) {
+  const scope = streamedScope(owner, frame.identity, false);
+  return scope ? acceptScopeStreamedResult(scope, frame) : false;
+}
+function failStreamedSignalResult(owner, identity, code) {
+  const scope = streamedScope(owner, identity, false);
+  return scope ? failScopeStreamedResult(scope, identity, new SignalStreamError(code)) : false;
+}
+function receiverErrorCode(error) {
+  if (error && (typeof error === "object" || typeof error === "function") && typeof error.code === "string") {
+    return error.code;
+  }
+  return "receiver";
+}
+function attachStreamedSignalResult(receiver, owner, identity) {
+  const scope = streamedScope(owner, identity, true);
+  if (!(scope instanceof ScopeImpl) || !scope.bindStreamedSelection(identity))
+    throw new SignalStreamError("identity");
+  const fail = (error) => {
+    failStreamedSignalResult(owner, identity, receiverErrorCode(error));
+  };
+  const consumer = {
+    accept(frame) {
+      if (acceptStreamedSignalResult(owner, frame)) return;
+      if (scope.isStreamedSelectionPending(frame.identity)) return false;
+      fail(new SignalStreamError("identity"));
+      throw new SignalStreamError("identity");
+    },
+    retainCompleted(frames) {
+      return scope.retainCompletedStreamedResult(identity, frames);
+    },
+    fail
+  };
+  try {
+    let detach = receiver.attachResult(identity, consumer);
+    const stopWaiting = scope.whenStreamedSelectionReady(identity, () => {
+      detach = receiver.attachResult(identity, consumer);
+    });
+    return () => {
+      stopWaiting();
+      detach();
+    };
+  } catch (error) {
+    fail(error);
+    throw error;
+  }
+}
+export {
+  DerivedDescriptor,
+  Descriptor,
+  __derivedScalarAt,
+  __signalAt,
+  __startSignalReads,
+  acceptStreamedSignalResult,
+  attachStreamedSignalResult,
+  bindStreamedSignalSelection,
+  createSignalOwnerLifecycle,
+  descriptorKey,
+  failStreamedSignalResult,
+  initializeDocumentSignalOwner,
+  isSignalHandle2 as isSignalHandle,
+  isWritableSignal,
+  readSignalBinding,
+  resolveCurrentSignalHandle,
+  resolveSignalHandleForOwner,
+  resolveSignalHandleForScope,
+  signal$,
+  signalOptionsKey
+};

package/dist/signals/graph.d.ts

@@ -1,16 +1,46 @@
+import type { SignalCandidateFrame } from './transition-candidate.js';
 import { type ReactiveFlags as AlienReactiveFlags, type ReactiveNode } from 'alien-signals/system';
 import { NATIVE_DOM_VALUE, type NativeReadInspection, type NativeReadSource, type NativeSerializedScope } from './read-protocol.js';
-import type { AdoptionFrame, ConnectionState, ScopeSeed, SIGNAL_HANDLE, SignalHandle, SignalSnapshot, SignalTraceEvent } from './types.js';
+import { SIGNAL_BINDING_READ, SIGNAL_BINDING_SUBSCRIBE, SIGNAL_BINDING_IDENTITY, SIGNAL_HANDLE, type AdoptionFrame, type ConnectionState, type ScopeSeed, type SignalHandle, type SignalSnapshot, type SignalTraceEvent } from './types.js';
 export interface GraphOwner {
     readonly scopeKey: string;
     readonly epoch: number;
     readonly retired: boolean;
+    /** Optional document freeze barrier; ordinary owners never allocate one. */
+    readonly readBarrier?: Promise<void> | undefined;
     readonly observers: Set<SignalObserver>;
     readonly seedable: boolean;
     beginAdoption(seed: ScopeSeed): AdoptionFrame;
     serializeRead(node: ScopedNode, read: SignalReadMode): readonly NativeSerializedScope[] | undefined;
     trace(type: SignalTraceEvent['type'], node?: ScopedNode): void;
+    /** Internal prototype: only explicitly supported producers may enter a candidate. */
+    forkCandidate?(node: ScopedNode, target: ScopedNode, frame: SignalCandidateFrame): CandidateProducer | undefined;
 }
+export interface CandidateProducer {
+    dispose(): void;
+    /** Explicit async reads complement the synchronous graph edges. */
+    dependencies?(): Iterable<ScopedNode>;
+    prepare(): {
+        status: 'ready';
+        receipt: CandidateProducerReceipt;
+    } | {
+        status: 'pending';
+        waiting: PromiseLike<unknown>;
+    } | {
+        status: 'error';
+        error: unknown;
+    } | {
+        status: 'invalid';
+    };
+}
+export interface CandidateProducerReceipt {
+    validate(): boolean;
+    publish(): () => void;
+    /** Canonical revisions are installed; transfer leases without evaluating readers. */
+    accept?(): void;
+}
+export { CandidateUnsupportedError } from './transition-state.js';
+export type { SignalCandidateFrame, CandidatePreparation } from './transition-candidate.js';
 export type SignalReadMode = 'value' | 'latest' | 'snapshot';
 declare const ReactiveFlags: {
     readonly None: 0;
@@ -39,6 +69,8 @@ export declare function setHistoricalReader(read: ((node: ScopedNode, read: Sign
 export declare function pure<T>(read: () => T): T;
 /** Untracking never relaxes the separate computation/render write guard. */
 export declare function untrack<T>(run: () => T): T;
+/** Cancellation callbacks observe committed state, even during candidate evaluation. */
+export declare function untrackCommitted<T>(run: () => T): T;
 export declare function startSignalBatch(): void;
 export declare function endSignalBatch(): void;
 export declare function signalBatch<T>(run: () => T): T;
@@ -50,13 +82,14 @@ export declare function readyState<T>(value: T, activity?: {
 }): NodeState<T>;
 export declare function errorState(error: unknown, connection?: ConnectionState, requestKey?: string): NodeState<never>;
 export declare function pendingState(waiting: PromiseLike<unknown>, connection?: ConnectionState, requestKey?: string, resolveWaiting?: () => void): NodeState<never>;
+export declare function idleState(): NodeState<never>;
 export declare function sameState(a: NodeState | undefined, b: NodeState): boolean;
 export declare function releaseRetention(node: ScopedNode): void;
 export declare class ScopedNode<T = any> implements SignalHandle<T>, ReactiveNode {
     readonly owner: GraphOwner;
     readonly key: string;
     readonly kind: 'signal' | 'derived' | 'async';
-    readonly [SIGNAL_HANDLE]: T;
+    get [SIGNAL_HANDLE](): true;
     deps: ReactiveNode['deps'];
     depsTail: ReactiveNode['depsTail'];
     subs: ReactiveNode['subs'];
@@ -64,7 +97,8 @@ export declare class ScopedNode<T = any> implements SignalHandle<T>, ReactiveNod
     flags: ReactiveFlags;
     revision: number;
     state: NodeState<T> | undefined;
-    compute: (() => NodeState<T>) | undefined;
+    compute: ((target: ScopedNode<T>) => NodeState<T>) | undefined;
+    invalidateAttempt: (() => void) | undefined;
     last: T | undefined;
     lastState: NodeState<T> | undefined;
     hasLast: boolean;
@@ -78,6 +112,12 @@ export declare class ScopedNode<T = any> implements SignalHandle<T>, ReactiveNod
     }): void;
     constructor(owner: GraphOwner, key: string, kind: 'signal' | 'derived' | 'async');
     get(): T;
+    [SIGNAL_BINDING_READ](): T;
+    [SIGNAL_BINDING_SUBSCRIBE](notify: () => void, onRetire?: () => void): () => void;
+    [SIGNAL_BINDING_IDENTITY](): {
+        scope: "instance";
+        nodeKey: string;
+    };
     [NATIVE_DOM_VALUE](): T;
     set(value: T | ((previous: T) => T)): void;
     latest(): T | undefined;
@@ -89,12 +129,15 @@ export declare function assertAlive(owner: GraphOwner): void;
 /** Inspect only cached metadata; never refresh a dormant or invalidated node. */
 export declare function inspectNativeNode(node: ScopedNode, read: SignalReadMode): NativeReadInspection;
 export declare function readNode<T>(node: ScopedNode<T>, read?: SignalReadMode): NodeState<T>;
-export declare function strictValue<T>(state: NodeState<T>): T;
+export declare function strictValue<T>(state: NodeState<T>, key?: string): T;
+/** Track historical lease release, but keep live binding reads out of the broad collector. */
+export declare function readSignalBinding<T>(handle$: SignalHandle<T>): T;
 export declare function refreshNode<T>(node: ScopedNode<T>): NodeState<T>;
 export declare function publishNode<T>(node: ScopedNode<T>, next: NodeState<T>): void;
 /** An explicit source retry invalidates even a cached description failure. */
 export declare function invalidateNode(node: ScopedNode): void;
 export declare function derivedState<T>(node: ScopedNode<T>, read: () => T): NodeState<T>;
+export declare function derivedValueState<T>(node: ScopedNode<T>, value: T, activity?: Pick<SignalSnapshot<T>, 'refreshing' | 'complete' | 'connection'>, additionalDependencies?: Iterable<ScopedNode>): NodeState<T>;
 export declare class SignalObserver implements ReactiveNode {
     node: ScopedNode | undefined;
     notify: (() => void) | undefined;
@@ -105,6 +148,8 @@ export declare class SignalObserver implements ReactiveNode {
     flags: ReactiveFlags;
     constructor(node: ScopedNode | undefined, notify: (() => void) | undefined, native: boolean, previous: NodeState | undefined);
 }
+export declare function attachObserver(node: ScopedNode, notify: () => void, native: boolean, state?: NodeState): () => void;
+/** Internal attempt dependency subscription; callers already hold a graph lease. */
+export declare function subscribeNode(node: ScopedNode, notify: () => void): () => void;
 export declare function stopObserver(observer: SignalObserver): void;
 export declare function retireGraph(owner: GraphOwner, nodes: Iterable<ScopedNode>): void;
-export {};