octane 0.2.11 → 0.2.13

package/dist/cjs/signals/graph.cjs

@@ -18,13 +18,17 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var graph_exports = {};
 __export(graph_exports, {
+  CandidateUnsupportedError: () => import_transition_state2.CandidateUnsupportedError,
   ScopedNode: () => ScopedNode,
   SignalObserver: () => SignalObserver,
   assertAlive: () => assertAlive,
   assertWritable: () => assertWritable,
+  attachObserver: () => attachObserver,
   derivedState: () => derivedState,
+  derivedValueState: () => derivedValueState,
   endSignalBatch: () => endSignalBatch,
   errorState: () => errorState,
+  idleState: () => idleState,
   inspectNativeNode: () => inspectNativeNode,
   invalidateNode: () => invalidateNode,
   isThenable: () => isThenable,
@@ -32,6 +36,7 @@ __export(graph_exports, {
   publishNode: () => publishNode,
   pure: () => pure,
   readNode: () => readNode,
+  readSignalBinding: () => readSignalBinding,
   readyState: () => readyState,
   refreshNode: () => refreshNode,
   releaseRetention: () => releaseRetention,
@@ -42,12 +47,17 @@ __export(graph_exports, {
   startSignalBatch: () => startSignalBatch,
   stopObserver: () => stopObserver,
   strictValue: () => strictValue,
-  untrack: () => untrack
+  subscribeNode: () => subscribeNode,
+  untrack: () => untrack,
+  untrackCommitted: () => untrackCommitted
 });
 module.exports = __toCommonJS(graph_exports);
+var import_transition_state = require("./transition-state.cjs");
 var import_system = require("alien-signals/system");
 var import_errors = require("./errors.cjs");
 var import_read_protocol = require("./read-protocol.cjs");
+var import_types = require("./types.cjs");
+var import_transition_state2 = require("./transition-state.cjs");
 const ReactiveFlags = {
   None: 0,
   Mutable: 1,
@@ -86,7 +96,15 @@ const graph = (0, import_system.createReactiveSystem)({
         node.flags |= ReactiveFlags.Dirty;
       }
       node.owner.trace("invalidate", node);
-      if (node.kind === "async") queued.add(node);
+      if (node.invalidateAttempt) {
+        if (import_transition_state.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);
     }
@@ -127,6 +145,9 @@ function untrack(run) {
     (0, import_read_protocol.setNativeReadObserver)(previousObserver);
   }
 }
+function untrackCommitted(run) {
+  return (0, import_transition_state.withoutSignalCandidate)(() => untrack(run));
+}
 function startSignalBatch() {
   batchDepth++;
 }
@@ -204,6 +225,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;
@@ -303,6 +334,9 @@ class ScopedNode {
   owner;
   key;
   kind;
+  get [import_types.SIGNAL_HANDLE]() {
+    return true;
+  }
   deps;
   depsTail;
   subs;
@@ -311,6 +345,7 @@ class ScopedNode {
   revision = 0;
   state;
   compute;
+  invalidateAttempt;
   last;
   lastState;
   hasLast = false;
@@ -324,18 +359,49 @@ class ScopedNode {
     throw new TypeError("Only an async signal can be retried.");
   }
   get() {
-    return strictValue(readNode(this));
+    return strictValue(readNode(this), this.key);
+  }
+  [import_types.SIGNAL_BINDING_READ]() {
+    return readSignalBinding(this);
+  }
+  [import_types.SIGNAL_BINDING_SUBSCRIBE](notify, onRetire) {
+    assertAlive(this.owner);
+    return attachObserver(
+      this,
+      onRetire === void 0 ? notify : (0, import_read_protocol.forwardNativeTransitionConsumer)(
+        notify,
+        () => this.owner.retired ? onRetire() : notify()
+      ),
+      true
+    );
+  }
+  [import_types.SIGNAL_BINDING_IDENTITY]() {
+    return { scope: "instance", nodeKey: this.key };
+  }
+  [import_read_protocol.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 = import_transition_state.activeCandidate ?? (0, import_read_protocol.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 = import_transition_state.candidateWriteCount ? (0, import_transition_state.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) {
@@ -385,8 +451,21 @@ function inspectNativeNode(node, read) {
     dependencies
   };
 }
+function createNativeSource(node, read) {
+  return {
+    getVersion: () => import_transition_state.activeCandidate && !import_transition_state.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 = import_transition_state.activeCandidate;
+  if (candidate) node = candidate.resolve(node);
   const historical = historicalReader?.(node, read);
   if (historical) return historical;
   if (!historicalReader && node.owner.seedable) {
@@ -398,27 +477,35 @@ function readNode(node, read = "value") {
   if (activeNode) graph.link(node, activeNode, trackingCycle);
   if ((0, import_read_protocol.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)
-    };
-    (0, import_read_protocol.reportNativeRead)(source, node.revision);
+    const source = node[field] ??= createNativeSource(node, read);
+    (0, import_read_protocol.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 import_errors.SignalIdleError(key);
   throw state.waiting;
 }
+function readSignalBinding(handle$) {
+  const resolveAdoption = (0, import_read_protocol.getNativeAdoptionResolver)();
+  if ((historicalReader || resolveAdoption) && handle$ instanceof ScopedNode && handle$.owner.seedable && (historicalReader || resolveAdoption?.(handle$.owner))) {
+    return handle$.get();
+  }
+  const observer = (0, import_read_protocol.setNativeReadObserver)(null);
+  try {
+    return handle$.get();
+  } finally {
+    (0, import_read_protocol.setNativeReadObserver)(observer);
+  }
+}
 function refreshNode(node) {
   assertAlive(node.owner);
   if (node.evaluating) throw new import_errors.SignalCycleError(node.key);
@@ -461,7 +548,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();
@@ -530,9 +617,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) {
@@ -545,6 +640,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 {
@@ -568,6 +675,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;
@@ -607,6 +718,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);
@@ -620,15 +732,46 @@ function retireGraph(owner, nodes) {
     retirementError = previousError;
   }
 }
+(0, import_transition_state.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
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CandidateUnsupportedError,
   ScopedNode,
   SignalObserver,
   assertAlive,
   assertWritable,
+  attachObserver,
   derivedState,
+  derivedValueState,
   endSignalBatch,
   errorState,
+  idleState,
   inspectNativeNode,
   invalidateNode,
   isThenable,
@@ -636,6 +779,7 @@ function retireGraph(owner, nodes) {
   publishNode,
   pure,
   readNode,
+  readSignalBinding,
   readyState,
   refreshNode,
   releaseRetention,
@@ -646,5 +790,7 @@ function retireGraph(owner, nodes) {
   startSignalBatch,
   stopObserver,
   strictValue,
-  untrack
+  subscribeNode,
+  untrack,
+  untrackCommitted
 });

package/dist/cjs/signals/handle-protocol.cjs

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handle_protocol_exports = {};
+__export(handle_protocol_exports, {
+  isSignalHandle: () => isSignalHandle,
+  isWritableSignal: () => isWritableSignal
+});
+module.exports = __toCommonJS(handle_protocol_exports);
+var import_types = require("./types.cjs");
+function isSignalHandle(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null && value[import_types.SIGNAL_HANDLE] === true;
+}
+function isWritableSignal(value) {
+  return isSignalHandle(value) && value.kind === "signal" && typeof value.set === "function";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isSignalHandle,
+  isWritableSignal
+});

package/dist/cjs/signals/index.cjs

@@ -18,25 +18,104 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var signals_exports = {};
 __export(signals_exports, {
+  ActionUncertainError: () => import_actions.ActionUncertainError,
+  QUERY_REQUEST: () => import_types.QUERY_REQUEST,
+  SIGNAL_BINDING_IDENTITY: () => import_types.SIGNAL_BINDING_IDENTITY,
+  SIGNAL_BINDING_READ: () => import_types.SIGNAL_BINDING_READ,
+  SIGNAL_BINDING_SUBSCRIBE: () => import_types.SIGNAL_BINDING_SUBSCRIBE,
+  SIGNAL_HANDLE: () => import_types.SIGNAL_HANDLE,
   ScopeDisposedError: () => import_errors.ScopeDisposedError,
   SignalCycleError: () => import_errors.SignalCycleError,
   SignalFrameError: () => import_errors.SignalFrameError,
+  SignalIdleError: () => import_errors.SignalIdleError,
   SignalSerializationError: () => import_errors.SignalSerializationError,
+  SignalStreamError: () => import_errors.SignalStreamError,
   SignalWriteError: () => import_errors.SignalWriteError,
+  __derivedAt: () => import_derived_facade.__derivedAt,
+  __derivedScalarAt: () => import_facade.__derivedScalarAt,
+  __enableSignalDocument: () => import_document_owner.enableSignalDocument,
+  __queryAt: () => import_query_facade.__queryAt,
+  __signalAt: () => import_facade.__signalAt,
+  __startSignalReads: () => import_facade.__startSignalReads,
+  acceptStreamedSignalResult: () => import_facade.acceptStreamedSignalResult,
+  action$: () => import_actions.action$,
+  attachStreamedSignalResult: () => import_facade.attachStreamedSignalResult,
+  bindSignalControl: () => import_control_binding.bindSignalControl,
+  bindStreamedSignalSelection: () => import_facade.bindStreamedSignalSelection,
+  captureSignalOwner: () => import_owner_context.captureSignalOwner,
+  createResource: () => import_requests.createResource,
   createScope: () => import_engine.createScope,
-  query: () => import_requests.query
+  currentSignalOwner: () => import_owner_context.currentSignalOwner,
+  derived$: () => import_derived_facade.derived$,
+  failStreamedSignalResult: () => import_facade.failStreamedSignalResult,
+  installSignalOwnerEnvironment: () => import_owner_context.installSignalOwnerEnvironment,
+  isActionUncertain: () => import_actions.isActionUncertain,
+  isSignalHandle: () => import_handle_protocol.isSignalHandle,
+  isWritableSignal: () => import_handle_protocol.isWritableSignal,
+  optimistic$: () => import_actions.optimistic$,
+  query: () => import_requests.query,
+  query$: () => import_query_facade.query$,
+  readSignalBinding: () => import_facade.readSignalBinding,
+  retireSignalOwnerIdentity: () => import_owner_context.retireSignalOwnerIdentity,
+  runWithSignalOwner: () => import_owner_context.runWithSignalOwner,
+  signal$: () => import_facade.signal$,
+  skip: () => import_types.skip
 });
 module.exports = __toCommonJS(signals_exports);
 var import_engine = require("./engine.cjs");
+var import_control_binding = require("./control-binding.cjs");
+var import_document_owner = require("./document-owner.cjs");
 var import_requests = require("./requests.cjs");
+var import_actions = require("./actions.cjs");
+var import_derived_facade = require("./derived-facade.cjs");
+var import_query_facade = require("./query-facade.cjs");
+var import_handle_protocol = require("./handle-protocol.cjs");
+var import_facade = require("./facade.cjs");
+var import_owner_context = require("./owner-context.cjs");
 var import_errors = require("./errors.cjs");
+var import_types = require("./types.cjs");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ActionUncertainError,
+  QUERY_REQUEST,
+  SIGNAL_BINDING_IDENTITY,
+  SIGNAL_BINDING_READ,
+  SIGNAL_BINDING_SUBSCRIBE,
+  SIGNAL_HANDLE,
   ScopeDisposedError,
   SignalCycleError,
   SignalFrameError,
+  SignalIdleError,
   SignalSerializationError,
+  SignalStreamError,
   SignalWriteError,
+  __derivedAt,
+  __derivedScalarAt,
+  __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/cjs/signals/native-read-client.cjs

@@ -22,6 +22,7 @@ __export(native_read_client_exports, {
 });
 module.exports = __toCommonJS(native_read_client_exports);
 var import_native_read_collector = require("./native-read-collector.cjs");
+var import_read_protocol = require("./read-protocol.cjs");
 var import_native_read_inspection = require("./native-read-inspection.cjs");
 function createNativeReadDriver(host) {
   const consumers = /* @__PURE__ */ new WeakMap();
@@ -57,6 +58,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);
@@ -79,6 +81,14 @@ function createNativeReadDriver(host) {
       };
       consumers.set(scope, consumer);
       const owned = consumer;
+      if (host.prepare !== void 0) {
+        Object.assign(owned.notify, {
+          [import_read_protocol.NATIVE_TRANSITION_CONSUMER]: {
+            active: () => !owned.disposed && !owned.block.disposed,
+            prepare: () => host.prepare(owned.block)
+          }
+        });
+      }
       host.cleanup(scope, () => disposeConsumer(owned));
     }
     return consumer;

package/dist/cjs/signals/owner-context.cjs

@@ -0,0 +1,112 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var owner_context_exports = {};
+__export(owner_context_exports, {
+  activeSignalOwnerEnvironment: () => installedEnvironment,
+  activeSynchronousSignalOwner: () => synchronousOwner,
+  captureSignalOwner: () => captureSignalOwner,
+  currentExplicitSignalOwner: () => currentExplicitSignalOwner,
+  currentSignalOwner: () => currentSignalOwner,
+  enterSynchronousSignalOwner: () => enterSynchronousSignalOwner,
+  installDefaultSignalOwner: () => installDefaultSignalOwner,
+  installSignalOwnerEnvironment: () => installSignalOwnerEnvironment,
+  installSignalOwnerRetirement: () => installSignalOwnerRetirement,
+  restoreSynchronousSignalOwner: () => restoreSynchronousSignalOwner,
+  retireSignalOwnerIdentity: () => retireSignalOwnerIdentity,
+  runWithSignalOwner: () => runWithSignalOwner
+});
+module.exports = __toCommonJS(owner_context_exports);
+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;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  activeSignalOwnerEnvironment,
+  activeSynchronousSignalOwner,
+  captureSignalOwner,
+  currentExplicitSignalOwner,
+  currentSignalOwner,
+  enterSynchronousSignalOwner,
+  installDefaultSignalOwner,
+  installSignalOwnerEnvironment,
+  installSignalOwnerRetirement,
+  restoreSynchronousSignalOwner,
+  retireSignalOwnerIdentity,
+  runWithSignalOwner
+});