octane 0.2.11 → 0.2.13

package/dist/signals/graph.js

@@ -1,3 +1,11 @@
+import {
+  activeCandidate,
+  candidateWriteCount,
+  deferCandidateInvalidation,
+  recordCandidateUrgentWrite,
+  registerCandidateGraph,
+  withoutSignalCandidate
+} from "./transition-state.js";
 import {
   createReactiveSystem
 } from "alien-signals/system";
@@ -5,16 +13,27 @@ import {
   ScopeDisposedError,
   SignalCycleError,
   SignalFrameError,
+  SignalIdleError,
   SignalWriteError
 } from "./errors.js";
 import {
   NativeAdoptionMiss,
+  NATIVE_DOM_VALUE,
+  getNativeCandidate,
+  forwardNativeTransitionConsumer,
   getNativeReadObserver,
   getNativeAdoptionResolver,
   isNativeWriteGuarded,
   reportNativeRead,
   setNativeReadObserver
 } from "./read-protocol.js";
+import {
+  SIGNAL_BINDING_READ,
+  SIGNAL_BINDING_SUBSCRIBE,
+  SIGNAL_BINDING_IDENTITY,
+  SIGNAL_HANDLE
+} from "./types.js";
+import { CandidateUnsupportedError } from "./transition-state.js";
 const ReactiveFlags = {
   None: 0,
   Mutable: 1,
@@ -53,7 +72,15 @@ const graph = createReactiveSystem({
         node.flags |= ReactiveFlags.Dirty;
       }
       node.owner.trace("invalidate", node);
-      if (node.kind === "async") queued.add(node);
+      if (node.invalidateAttempt) {
+        if (deferCandidateInvalidation) {
+          const invalidate = node.invalidateAttempt;
+          queued.add(() => {
+            if (node.invalidateAttempt === invalidate) invalidate();
+          });
+        } else node.invalidateAttempt();
+        queued.add(node);
+      } else if (node.kind === "async") queued.add(node);
     } else {
       queued.add(node);
     }
@@ -94,6 +121,9 @@ function untrack(run) {
     setNativeReadObserver(previousObserver);
   }
 }
+function untrackCommitted(run) {
+  return withoutSignalCandidate(() => untrack(run));
+}
 function startSignalBatch() {
   batchDepth++;
 }
@@ -171,6 +201,16 @@ function pendingState(waiting, connection = "none", requestKey, resolveWaiting)
     ...resolveWaiting ? { resolveWaiting } : {}
   };
 }
+function idleState() {
+  return {
+    snapshot: {
+      status: "idle",
+      refreshing: false,
+      connection: "none",
+      complete: false
+    }
+  };
+}
 function sameOwners(a, b) {
   if (a.owners === b.owners) return true;
   if ((a.owners?.size ?? 0) !== (b.owners?.size ?? 0)) return false;
@@ -270,6 +310,9 @@ class ScopedNode {
   owner;
   key;
   kind;
+  get [SIGNAL_HANDLE]() {
+    return true;
+  }
   deps;
   depsTail;
   subs;
@@ -278,6 +321,7 @@ class ScopedNode {
   revision = 0;
   state;
   compute;
+  invalidateAttempt;
   last;
   lastState;
   hasLast = false;
@@ -291,18 +335,49 @@ class ScopedNode {
     throw new TypeError("Only an async signal can be retried.");
   }
   get() {
-    return strictValue(readNode(this));
+    return strictValue(readNode(this), this.key);
+  }
+  [SIGNAL_BINDING_READ]() {
+    return readSignalBinding(this);
+  }
+  [SIGNAL_BINDING_SUBSCRIBE](notify, onRetire) {
+    assertAlive(this.owner);
+    return attachObserver(
+      this,
+      onRetire === void 0 ? notify : forwardNativeTransitionConsumer(
+        notify,
+        () => this.owner.retired ? onRetire() : notify()
+      ),
+      true
+    );
+  }
+  [SIGNAL_BINDING_IDENTITY]() {
+    return { scope: "instance", nodeKey: this.key };
+  }
+  [NATIVE_DOM_VALUE]() {
+    return this.get();
   }
   set(value) {
     assertAlive(this.owner);
     assertWritable();
     if (this.kind !== "signal") throw new TypeError("Only a writable signal accepts set().");
+    const candidate = activeCandidate ?? getNativeCandidate();
+    if (candidate) {
+      candidate.run(() => candidate.write(this, value));
+      return;
+    }
     signalBatch(() => {
-      const previous = strictValue(refreshNode(this));
+      const previous = strictValue(refreshNode(this), this.key);
       const next = typeof value === "function" ? untrack(() => pure(() => value(previous))) : value;
-      if (Object.is(previous, next)) return;
-      publishNode(this, readyState(next));
-      this.owner.trace("write", this);
+      const releases = candidateWriteCount ? recordCandidateUrgentWrite(this, value) : void 0;
+      try {
+        if (!Object.is(previous, next)) {
+          publishNode(this, readyState(next));
+          this.owner.trace("write", this);
+        }
+      } finally {
+        if (releases) for (const release of releases) release();
+      }
     });
   }
   latest(fallback) {
@@ -352,8 +427,21 @@ function inspectNativeNode(node, read) {
     dependencies
   };
 }
+function createNativeSource(node, read) {
+  return {
+    getVersion: () => activeCandidate && !activeCandidate.observes(node) ? NaN : node.revision,
+    subscribe: (notify) => {
+      assertAlive(node.owner);
+      return attachObserver(node, notify, true);
+    },
+    serialize: (revision) => node.revision === revision ? node.owner.serializeRead(node, read) : void 0,
+    inspect: () => inspectNativeNode(node, read)
+  };
+}
 function readNode(node, read = "value") {
   assertAlive(node.owner);
+  const candidate = activeCandidate;
+  if (candidate) node = candidate.resolve(node);
   const historical = historicalReader?.(node, read);
   if (historical) return historical;
   if (!historicalReader && node.owner.seedable) {
@@ -365,27 +453,35 @@ function readNode(node, read = "value") {
   if (activeNode) graph.link(node, activeNode, trackingCycle);
   if (getNativeReadObserver()) {
     const field = read === "value" ? "nativeSource" : read === "latest" ? "nativeLatestSource" : "nativeSnapshotSource";
-    const source = node[field] ??= {
-      getVersion: () => node.revision,
-      subscribe: (notify) => {
-        assertAlive(node.owner);
-        return attachObserver(node, notify, true);
-      },
-      serialize: (revision) => node.revision === revision ? node.owner.serializeRead(node, read) : void 0,
-      inspect: () => inspectNativeNode(node, read)
-    };
-    reportNativeRead(source, node.revision);
+    const source = node[field] ??= createNativeSource(node, read);
+    reportNativeRead(
+      candidate ? candidate.nativeSource(node, read, source) : source,
+      node.revision
+    );
   }
   if (observed.owners) for (const owner of observed.owners) assertAlive(owner);
   if (activeNode) recordOwners(node, observed);
   return observed;
 }
-function strictValue(state) {
+function strictValue(state, key = "idle") {
   const snapshot = state.snapshot;
   if (snapshot.status === "ready") return snapshot.value;
   if (snapshot.status === "error") throw snapshot.error;
+  if (snapshot.status === "idle") throw new SignalIdleError(key);
   throw state.waiting;
 }
+function readSignalBinding(handle$) {
+  const resolveAdoption = getNativeAdoptionResolver();
+  if ((historicalReader || resolveAdoption) && handle$ instanceof ScopedNode && handle$.owner.seedable && (historicalReader || resolveAdoption?.(handle$.owner))) {
+    return handle$.get();
+  }
+  const observer = setNativeReadObserver(null);
+  try {
+    return handle$.get();
+  } finally {
+    setNativeReadObserver(observer);
+  }
+}
 function refreshNode(node) {
   assertAlive(node.owner);
   if (node.evaluating) throw new SignalCycleError(node.key);
@@ -428,7 +524,7 @@ function evaluate(node) {
   let next;
   let owners;
   try {
-    next = node.compute();
+    next = node.compute(node);
   } catch (error) {
     if (isThenable(error)) {
       const wakeup = node.wakeup ??= createWakeup();
@@ -497,9 +593,17 @@ function invalidateNode(node) {
 function derivedState(node, read) {
   const value = pure(read);
   if (isThenable(value)) throw new TypeError("derived$ requires a synchronous computation.");
+  return derivedValueState(node, value);
+}
+function derivedValueState(node, value, activity, additionalDependencies) {
   let refreshing = false;
   let complete = true;
   let connection = "none";
+  if (activity) {
+    refreshing = activity.refreshing;
+    complete = activity.complete;
+    connection = activity.connection;
+  }
   for (let link = node.deps; link && node.depsTail; link = link.nextDep) {
     const dependency = link.dep.state?.snapshot;
     if (dependency) {
@@ -512,6 +616,18 @@ function derivedState(node, read) {
     }
     if (link === node.depsTail) break;
   }
+  if (additionalDependencies) {
+    for (const node2 of additionalDependencies) {
+      const dependency = node2.state?.snapshot;
+      if (!dependency) continue;
+      refreshing ||= dependency.refreshing;
+      complete &&= dependency.complete;
+      if (dependency.connection === "open") connection = "open";
+      else if (connection !== "open" && dependency.connection === "connecting")
+        connection = "connecting";
+      else if (connection === "none" && dependency.connection === "closed") connection = "closed";
+    }
+  }
   return readyState(value, { refreshing, complete, connection });
 }
 class SignalObserver {
@@ -535,6 +651,10 @@ function attachObserver(node, notify, native, state) {
   node.owner.observers.add(observer);
   return () => stopObserver(observer);
 }
+function subscribeNode(node, notify) {
+  const state = untrack(() => refreshNode(node));
+  return attachObserver(node, notify, true, state);
+}
 function runObserver(observer) {
   const node = observer.node;
   if (!node || !observer.flags) return;
@@ -574,6 +694,7 @@ function retireGraph(owner, nodes) {
       node.state = errorState(retirementError);
       releaseRetention(node);
       node.compute = void 0;
+      node.invalidateAttempt = void 0;
       if (node.kind === "async") node.retry = ScopedNode.prototype.retry;
       if (node.subs) {
         graph.propagate(node.subs, executionDepth !== 0);
@@ -587,14 +708,45 @@ function retireGraph(owner, nodes) {
     retirementError = previousError;
   }
 }
+registerCandidateGraph({
+  ScopedNode,
+  graph,
+  flags: ReactiveFlags,
+  historical: () => historicalReader !== void 0,
+  link: (from, to) => {
+    graph.link(from, to, ++trackingCycle);
+  },
+  removeQueued: (node) => {
+    queued.delete(node);
+  },
+  assertAlive,
+  strictValue,
+  refreshNode,
+  pure,
+  untrack,
+  signalBatch,
+  publishNode,
+  readyState,
+  commitState,
+  sameState,
+  releaseRetainedOwners,
+  retainOwners,
+  releaseRetention,
+  createNativeSource,
+  attachObserver
+});
 export {
+  CandidateUnsupportedError,
   ScopedNode,
   SignalObserver,
   assertAlive,
   assertWritable,
+  attachObserver,
   derivedState,
+  derivedValueState,
   endSignalBatch,
   errorState,
+  idleState,
   inspectNativeNode,
   invalidateNode,
   isThenable,
@@ -602,6 +754,7 @@ export {
   publishNode,
   pure,
   readNode,
+  readSignalBinding,
   readyState,
   refreshNode,
   releaseRetention,
@@ -612,5 +765,7 @@ export {
   startSignalBatch,
   stopObserver,
   strictValue,
-  untrack
+  subscribeNode,
+  untrack,
+  untrackCommitted
 };

package/dist/signals/handle-protocol.d.ts

@@ -0,0 +1,4 @@
+import { type SignalHandle, type WritableSignal } from './types.js';
+/** Native handle capability checks must not import the graph or create an owner. */
+export declare function isSignalHandle(value: unknown): value is SignalHandle<unknown>;
+export declare function isWritableSignal(value: unknown): value is WritableSignal<unknown>;

package/dist/signals/handle-protocol.js

@@ -0,0 +1,11 @@
+import { SIGNAL_HANDLE } from "./types.js";
+function isSignalHandle(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && value[SIGNAL_HANDLE] === true;
+}
+function isWritableSignal(value) {
+  return isSignalHandle(value) && value.kind === "signal" && typeof value.set === "function";
+}
+export {
+  isSignalHandle,
+  isWritableSignal
+};

package/dist/signals/index.d.ts

@@ -1,5 +1,14 @@
 /** Stable scoped signals. This entry does not import a renderer. */
 export { createScope } from './engine.js';
-export { query } from './requests.js';
-export { ScopeDisposedError, SignalCycleError, SignalFrameError, SignalSerializationError, SignalWriteError, } from './errors.js';
-export type { SIGNAL_HANDLE, QUERY_REQUEST, AdoptionFrame, ConnectionState, DerivedSignal, EncodedSignalValue, Query, QueryContext, QueryRequest, Resource, Scope, ScopeInspection, ScopeOptions, ScopeSeed, SignalHandle, SignalSeedEntry, SignalSnapshot, SignalTraceEvent, WritableSignal, } from './types.js';
+export { bindSignalControl } from './control-binding.js';
+export { enableSignalDocument as __enableSignalDocument } from './document-owner.js';
+export { createResource, query } from './requests.js';
+export { ActionUncertainError, action$, isActionUncertain, optimistic$ } from './actions.js';
+export { __derivedAt, derived$ } from './derived-facade.js';
+export { __queryAt, query$ } from './query-facade.js';
+export { isSignalHandle, isWritableSignal } from './handle-protocol.js';
+export { __derivedScalarAt, __signalAt, __startSignalReads, acceptStreamedSignalResult, attachStreamedSignalResult, bindStreamedSignalSelection, readSignalBinding, failStreamedSignalResult, signal$, } from './facade.js';
+export { captureSignalOwner, currentSignalOwner, installSignalOwnerEnvironment, retireSignalOwnerIdentity, runWithSignalOwner, } from './owner-context.js';
+export { ScopeDisposedError, SignalCycleError, SignalFrameError, SignalIdleError, SignalSerializationError, SignalStreamError, SignalWriteError, } from './errors.js';
+export { QUERY_REQUEST, SIGNAL_BINDING_IDENTITY, SIGNAL_BINDING_READ, SIGNAL_BINDING_SUBSCRIBE, SIGNAL_HANDLE, skip, } from './types.js';
+export type { AdoptionFrame, ActionOperation, ActionUncertain, ConnectionState, DerivedCompute, DerivedContext, DerivedOptions, DerivedSignal, EncodedSignalValue, Query, QueryContext, QueryLoadResult, QueryOptions, QueryRequest, QuerySignal, Resource, OptimisticOptions, OptimisticSignal, Scope, ScopeInspection, ScopeOptions, ScopeSeed, SignalHandle, SignalOptions, SignalBindingIdentity, SignalAction, SignalOwner, SignalOwnerEnvironment, SignalOwnerIdentity, SignalRendererOwnerIdentity, SignalSeedEntry, SignalSnapshot, SignalTraceEvent, WritableSignal, } from './types.js';

package/dist/signals/index.js

@@ -1,18 +1,87 @@
 import { createScope } from "./engine.js";
-import { query } from "./requests.js";
+import { bindSignalControl } from "./control-binding.js";
+import { enableSignalDocument } from "./document-owner.js";
+import { createResource, query } from "./requests.js";
+import { ActionUncertainError, action$, isActionUncertain, optimistic$ } from "./actions.js";
+import { __derivedAt, derived$ } from "./derived-facade.js";
+import { __queryAt, query$ } from "./query-facade.js";
+import { isSignalHandle, isWritableSignal } from "./handle-protocol.js";
+import {
+  __derivedScalarAt,
+  __signalAt,
+  __startSignalReads,
+  acceptStreamedSignalResult,
+  attachStreamedSignalResult,
+  bindStreamedSignalSelection,
+  readSignalBinding,
+  failStreamedSignalResult,
+  signal$
+} from "./facade.js";
+import {
+  captureSignalOwner,
+  currentSignalOwner,
+  installSignalOwnerEnvironment,
+  retireSignalOwnerIdentity,
+  runWithSignalOwner
+} from "./owner-context.js";
 import {
   ScopeDisposedError,
   SignalCycleError,
   SignalFrameError,
+  SignalIdleError,
   SignalSerializationError,
+  SignalStreamError,
   SignalWriteError
 } from "./errors.js";
+import {
+  QUERY_REQUEST,
+  SIGNAL_BINDING_IDENTITY,
+  SIGNAL_BINDING_READ,
+  SIGNAL_BINDING_SUBSCRIBE,
+  SIGNAL_HANDLE,
+  skip
+} from "./types.js";
 export {
+  ActionUncertainError,
+  QUERY_REQUEST,
+  SIGNAL_BINDING_IDENTITY,
+  SIGNAL_BINDING_READ,
+  SIGNAL_BINDING_SUBSCRIBE,
+  SIGNAL_HANDLE,
   ScopeDisposedError,
   SignalCycleError,
   SignalFrameError,
+  SignalIdleError,
   SignalSerializationError,
+  SignalStreamError,
   SignalWriteError,
+  __derivedAt,
+  __derivedScalarAt,
+  enableSignalDocument as __enableSignalDocument,
+  __queryAt,
+  __signalAt,
+  __startSignalReads,
+  acceptStreamedSignalResult,
+  action$,
+  attachStreamedSignalResult,
+  bindSignalControl,
+  bindStreamedSignalSelection,
+  captureSignalOwner,
+  createResource,
   createScope,
-  query
+  currentSignalOwner,
+  derived$,
+  failStreamedSignalResult,
+  installSignalOwnerEnvironment,
+  isActionUncertain,
+  isSignalHandle,
+  isWritableSignal,
+  optimistic$,
+  query,
+  query$,
+  readSignalBinding,
+  retireSignalOwnerIdentity,
+  runWithSignalOwner,
+  signal$,
+  skip
 };

package/dist/signals/native-read-client.d.ts

@@ -4,6 +4,9 @@ interface NativeReadHost {
     capture(): object | null;
     cleanup(scope: Scope, dispose: () => void): void;
     schedule(block: Block): void;
+    /** Candidate admission renders this exact subscribed owner without notifying it. */
+    prepare?(block: Block): void;
+    retire?(block: Block): void;
     /** Reuse current ref manifests after a superseding root commits. */
     replayRefs(capture: object, owner: PublicationOwner): boolean;
     refDisposed(entry: object): boolean;

package/dist/signals/native-read-client.js

@@ -2,6 +2,7 @@ import {
   createNativeReadCollector,
   validateNativeReadWitness
 } from "./native-read-collector.js";
+import { NATIVE_TRANSITION_CONSUMER } from "./read-protocol.js";
 import { inspectNativeReadWitness } from "./native-read-inspection.js";
 function createNativeReadDriver(host) {
   const consumers = /* @__PURE__ */ new WeakMap();
@@ -37,6 +38,7 @@ function createNativeReadDriver(host) {
   function disposeConsumer(consumer) {
     if (consumer.disposed) return;
     consumer.disposed = true;
+    host.retire?.(consumer.block);
     if (consumer.committed !== null) release(consumer.committed);
     consumer.committed = null;
     for (const candidate of consumer.pending) release(candidate);
@@ -59,6 +61,14 @@ function createNativeReadDriver(host) {
       };
       consumers.set(scope, consumer);
       const owned = consumer;
+      if (host.prepare !== void 0) {
+        Object.assign(owned.notify, {
+          [NATIVE_TRANSITION_CONSUMER]: {
+            active: () => !owned.disposed && !owned.block.disposed,
+            prepare: () => host.prepare(owned.block)
+          }
+        });
+      }
       host.cleanup(scope, () => disposeConsumer(owned));
     }
     return consumer;

package/dist/signals/owner-context.d.ts

@@ -0,0 +1,22 @@
+import type { SignalOwner, SignalOwnerEnvironment } from './types.js';
+declare let installedEnvironment: SignalOwnerEnvironment | undefined;
+declare let synchronousOwner: SignalOwner | null;
+/** @internal Live capability guards; reading them never installs a default owner. */
+export { installedEnvironment as activeSignalOwnerEnvironment, synchronousOwner as activeSynchronousSignalOwner, };
+/** Install a concurrency-safe owner carrier without importing the signal engine. */
+export declare function installSignalOwnerEnvironment(environment: SignalOwnerEnvironment): () => void;
+export declare function currentSignalOwner(): SignalOwner | null;
+/** @internal Distinguish an active owner frame from the lazy document fallback. */
+export declare function currentExplicitSignalOwner(): SignalOwner | null;
+/** @internal Client renderer installs its lazy document owner, never a last-root owner. */
+export declare function installDefaultSignalOwner(current: () => SignalOwner | null): () => void;
+/** Enter an owner for a synchronous declaration, read, write, or callback. */
+export declare function runWithSignalOwner<T>(owner: SignalOwner, callback: () => T): T;
+/** @internal Synchronous SSR entry without retaining a callback frame per component. */
+export declare function enterSynchronousSignalOwner(owner: SignalOwner): SignalOwner | null | undefined;
+/** @internal Pair with a successful synchronous entry in a finally block. */
+export declare function restoreSynchronousSignalOwner(previous: SignalOwner | null): void;
+export declare function captureSignalOwner(owner: SignalOwner): <T>(callback: () => T) => T;
+/** Retire renderer-created identity state without linking the renderer to the engine. */
+export declare function retireSignalOwnerIdentity(owner: SignalOwner): void;
+export declare function installSignalOwnerRetirement(retire: (owner: SignalOwner) => void): () => void;

package/dist/signals/owner-context.js

@@ -0,0 +1,77 @@
+let installedEnvironment;
+let synchronousOwner = null;
+let defaultOwner;
+let retireOwner;
+function installSignalOwnerEnvironment(environment) {
+  if (!environment || typeof environment.current !== "function" || typeof environment.run !== "function" || typeof environment.capture !== "function") {
+    throw new TypeError("A signal owner environment requires current, run, and capture.");
+  }
+  const previous = installedEnvironment;
+  installedEnvironment = environment;
+  return () => {
+    if (installedEnvironment === environment) installedEnvironment = previous;
+  };
+}
+function currentSignalOwner() {
+  if (installedEnvironment !== void 0) return installedEnvironment.current() ?? synchronousOwner;
+  return synchronousOwner ?? defaultOwner?.() ?? null;
+}
+function currentExplicitSignalOwner() {
+  return installedEnvironment?.current() ?? synchronousOwner;
+}
+function installDefaultSignalOwner(current) {
+  if (typeof current !== "function")
+    throw new TypeError("A default signal owner requires a provider.");
+  const previous = defaultOwner;
+  defaultOwner = current;
+  return () => {
+    if (defaultOwner === current) defaultOwner = previous;
+  };
+}
+function runWithSignalOwner(owner, callback) {
+  if (typeof callback !== "function") throw new TypeError("A signal owner callback is required.");
+  if (installedEnvironment) return installedEnvironment.run(owner, callback);
+  const previous = synchronousOwner;
+  synchronousOwner = owner;
+  try {
+    return callback();
+  } finally {
+    synchronousOwner = previous;
+  }
+}
+function enterSynchronousSignalOwner(owner) {
+  if (installedEnvironment !== void 0) return void 0;
+  const previous = synchronousOwner;
+  synchronousOwner = owner;
+  return previous;
+}
+function restoreSynchronousSignalOwner(previous) {
+  synchronousOwner = previous;
+}
+function captureSignalOwner(owner) {
+  return installedEnvironment?.capture(owner) ?? ((callback) => runWithSignalOwner(owner, callback));
+}
+function retireSignalOwnerIdentity(owner) {
+  retireOwner?.(owner);
+}
+function installSignalOwnerRetirement(retire) {
+  const previous = retireOwner;
+  retireOwner = retire;
+  return () => {
+    if (retireOwner === retire) retireOwner = previous;
+  };
+}
+export {
+  installedEnvironment as activeSignalOwnerEnvironment,
+  synchronousOwner as activeSynchronousSignalOwner,
+  captureSignalOwner,
+  currentExplicitSignalOwner,
+  currentSignalOwner,
+  enterSynchronousSignalOwner,
+  installDefaultSignalOwner,
+  installSignalOwnerEnvironment,
+  installSignalOwnerRetirement,
+  restoreSynchronousSignalOwner,
+  retireSignalOwnerIdentity,
+  runWithSignalOwner
+};

package/dist/signals/query-attempt-observer.d.ts

@@ -0,0 +1,49 @@
+import type { SignalRendererOwnerIdentity } from './types.js';
+export interface ServerSignalQueryAttempt {
+    readonly ownerKey: string;
+    readonly instanceKey: string;
+    readonly nodeKey: string;
+    readonly selectionKey: string;
+    readonly attempt: number;
+    readonly kind: 'promise' | 'stream';
+    readonly result: unknown;
+    readonly signal: AbortSignal;
+    readonly isCurrent: () => boolean;
+    /** Stop retaining and backpressuring this renderer observation. */
+    readonly release: () => void;
+}
+export type ServerSignalQueryAttemptObserver = (attempt: ServerSignalQueryAttempt) => void;
+export interface ServerSignalQueryAttemptObserverContext {
+    readonly owner: SignalRendererOwnerIdentity;
+    readonly observe: ServerSignalQueryAttemptObserver;
+    readonly createObservations: () => ServerSignalQueryAttemptObservations;
+}
+export interface ServerSignalQueryAttemptSource {
+    readonly nodeKey: string;
+    readonly selectionKey: string;
+    readonly attempt: number;
+    readonly kind: 'promise' | 'stream';
+    readonly result: unknown;
+    readonly isCurrent: () => boolean;
+}
+/** The shared request engine owns a lease, not the server's transport mirrors. */
+export interface ServerSignalQueryAttemptObservations {
+    observe(context: ServerSignalQueryAttemptObserverContext, source: ServerSignalQueryAttemptSource): void;
+    publish(value: unknown): Promise<void> | undefined;
+    complete(): void;
+    fail(error: unknown): void;
+    retire(): void;
+}
+/**
+ * Install a synchronous renderer observation context around authored server
+ * signal work. The context is restored before a returned promise can suspend,
+ * so concurrent requests cannot inherit one another's observer.
+ *
+ * @internal
+ */
+export declare function runWithServerSignalQueryAttemptObserver<T>(owner: SignalRendererOwnerIdentity, observe: ServerSignalQueryAttemptObserver, createObservations: () => ServerSignalQueryAttemptObservations, callback: () => T): T;
+/** @internal Keep the browser/query fast path allocation-free when no server observer matches. */
+export declare function serverSignalQueryAttemptObserver(scopeKey: string): ServerSignalQueryAttemptObserverContext | undefined;
+export declare function hasServerSignalQueryAttemptObserver(scopeKey: string): boolean;
+/** @internal Preserve observation across a pending query description, not an async context. */
+export declare function captureCurrentServerSignalQueryAttemptObserver(scopeKey: string): (<T>(callback: () => T) => T) | undefined;