octane 0.2.11 → 0.2.13

package/dist/cjs/signals/control-binding.cjs

@@ -0,0 +1,368 @@
+"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 control_binding_exports = {};
+__export(control_binding_exports, {
+  __createBindingControls: () => __createBindingControls,
+  bindSignalControl: () => bindSignalControl
+});
+module.exports = __toCommonJS(control_binding_exports);
+var import_control_capture = require("../hydration/control-capture.cjs");
+var import_early_values = require("./early-values.cjs");
+var import_handle_protocol = require("./handle-protocol.cjs");
+var import_owner_context = require("./owner-context.cjs");
+var import_read_protocol = require("./read-protocol.cjs");
+var import_types = require("./types.cjs");
+var import_transition_state = require("./transition-state.cjs");
+const CONTROL_BINDINGS = /* @__PURE__ */ new WeakMap();
+const RADIO_WRITERS = /* @__PURE__ */ new WeakMap();
+function controlString(value) {
+  return typeof value === "string" ? value : typeof value === "function" || typeof value === "symbol" ? "" : String(value);
+}
+function publishRadioInput(input) {
+  const root = input.getRootNode();
+  const group = input.form !== null ? input.form.elements : root.nodeType === 9 ? root.getElementsByName(input.name) : root.querySelectorAll('input[type="radio"]');
+  const edits = [];
+  for (let index = 0; index < group.length; index++) {
+    const other = group[index];
+    if (other.localName !== "input" || other.type !== "radio" || other.name !== input.name || other.form !== input.form || other.getRootNode() !== root)
+      continue;
+    const write = RADIO_WRITERS.get(other);
+    if (write) edits.push([write, other.checked]);
+  }
+  for (const [write, checked] of edits) if (!checked) write(false);
+  for (const [write, checked] of edits) if (checked) write(true);
+}
+function __createBindingControls() {
+  const owner = (0, import_owner_context.currentSignalOwner)();
+  const run = owner === null ? (callback) => callback() : (0, import_owner_context.captureSignalOwner)(owner);
+  return {
+    claim(element, channel, notify) {
+      const control = element;
+      if (control?.nodeType !== 1 || channel !== "value" && channel !== "checked" || !["input", "textarea", "select"].includes(control.localName) || channel === "checked" && (control.localName !== "input" || !["checkbox", "radio"].includes(control.type)) || channel === "value" && control.localName === "input" && control.type === "file")
+        throw new TypeError(
+          "A signal control requires a native value/checked property and a signal."
+        );
+      if (CONTROL_BINDINGS.get(control)?.has(channel) || (0, import_early_values.hasHydrationControlSignalWriter)(control, channel))
+        throw new Error(
+          "This control property already has a signal binding. Dispose it before rebinding."
+        );
+      let channels = CONTROL_BINDINGS.get(control);
+      if (!channels) CONTROL_BINDINGS.set(control, channels = /* @__PURE__ */ new Set());
+      channels.add(channel);
+      let disposed = false;
+      let initialized = false;
+      let composing = false;
+      let raw;
+      let handle;
+      let active;
+      let unsubscribe;
+      let stopWriter;
+      let generation = 0;
+      let revision = 0;
+      const read = (value) => run(() => value[import_types.SIGNAL_BINDING_READ]());
+      const write = (value) => {
+        if (disposed || !(0, import_handle_protocol.isWritableSignal)(active)) return;
+        const writable = active;
+        (0, import_transition_state.withoutSignalCandidate)(
+          () => run(() => {
+            const previous = read(writable);
+            if (Object.is(previous, value) || Array.isArray(previous) && Array.isArray(value) && previous.length === value.length && previous.every((item, index) => item === value[index]))
+              return;
+            writable.set(value);
+          })
+        );
+      };
+      const nativeValue = () => {
+        const snapshot = (0, import_control_capture.snapshotHydrationControl)(control);
+        return channel === "checked" ? snapshot.checked : snapshot.selectedValues ?? snapshot.value;
+      };
+      const input = () => {
+        if (disposed) return;
+        if (channel === "checked" && control.type === "radio" && control.name !== "")
+          publishRadioInput(control);
+        else write(nativeValue());
+      };
+      const compositionStart = () => {
+        composing = true;
+      };
+      const compositionEnd = () => {
+        if (disposed) return;
+        composing = false;
+        input();
+        if (!disposed) notify();
+      };
+      const dispose = () => {
+        if (disposed) return;
+        disposed = true;
+        generation++;
+        raw = void 0;
+        active = handle = void 0;
+        if (channel === "checked") RADIO_WRITERS.delete(control);
+        let failed = false;
+        let failure;
+        const attempt = (stop2) => {
+          try {
+            stop2?.();
+          } catch (error) {
+            if (!failed) {
+              failed = true;
+              failure = error;
+            }
+          }
+        };
+        const stop = unsubscribe;
+        unsubscribe = void 0;
+        attempt(stop);
+        attempt(stopWriter);
+        stopWriter = void 0;
+        control.removeEventListener("input", input);
+        control.removeEventListener("compositionstart", compositionStart);
+        control.removeEventListener("compositionend", compositionEnd);
+        channels.delete(channel);
+        if (channels.size === 0) CONTROL_BINDINGS.delete(control);
+        if (failed) throw failure;
+      };
+      const prepare = (next, preview = false) => {
+        if (disposed) return { validate: () => false, discard() {
+        }, publish() {
+        }, commit() {
+        } };
+        if ((0, import_handle_protocol.isSignalHandle)(next) && (typeof next[import_types.SIGNAL_BINDING_READ] !== "function" || typeof next[import_types.SIGNAL_BINDING_SUBSCRIBE] !== "function"))
+          throw new TypeError(
+            "A signal control requires a native value/checked property and a signal."
+          );
+        if (!preview && raw !== next) {
+          const ticket2 = ++generation;
+          const stop = unsubscribe;
+          unsubscribe = void 0;
+          handle = void 0;
+          stop?.();
+          if (disposed) return { validate: () => false, discard() {
+          }, publish() {
+          }, commit() {
+          } };
+          raw = next;
+          handle = (0, import_handle_protocol.isSignalHandle)(next) ? next : void 0;
+          if (handle) {
+            const candidate2 = handle;
+            const stopNext = run(
+              () => candidate2[import_types.SIGNAL_BINDING_SUBSCRIBE](
+                (0, import_read_protocol.forwardNativeTransitionConsumer)(notify, () => {
+                  if (!disposed && generation === ticket2) {
+                    revision++;
+                    notify();
+                  }
+                }),
+                () => {
+                  if (!disposed && generation === ticket2) dispose();
+                }
+              )
+            );
+            if (typeof stopNext !== "function")
+              throw new TypeError("A signal control subscription must return cleanup.");
+            if (disposed || generation !== ticket2) stopNext();
+            else unsubscribe = stopNext;
+          }
+        }
+        if (disposed) return { validate: () => false, discard() {
+        }, publish() {
+        }, commit() {
+        } };
+        const candidate = preview ? (0, import_handle_protocol.isSignalHandle)(next) ? next : void 0 : handle;
+        const value = candidate ? read(candidate) : next;
+        if (disposed) return { validate: () => false, discard() {
+        }, publish() {
+        }, commit() {
+        } };
+        const multiple = control.localName === "select" && control.multiple;
+        if (candidate && (channel === "checked" ? typeof value !== "boolean" : multiple ? !Array.isArray(value) : typeof value !== "string"))
+          throw new TypeError(
+            channel === "checked" ? "A checked signal must contain a boolean." : multiple ? "A multiple select signal must contain an array." : "A value signal must contain a string."
+          );
+        let selected;
+        if (multiple && Array.isArray(value)) {
+          selected = /* @__PURE__ */ new Set();
+          for (const item of value) selected.add(candidate ? item : controlString(item));
+        }
+        const normalized = channel === "checked" ? !!value : value == null || multiple ? "" : controlString(value);
+        let ticket = generation;
+        const version = revision;
+        let accepted = !preview;
+        let retired = false;
+        let invalid = false;
+        let staged = preview && candidate && candidate !== handle ? run(
+          () => candidate[import_types.SIGNAL_BINDING_SUBSCRIBE](
+            (0, import_read_protocol.forwardNativeTransitionConsumer)(notify, () => {
+              if (retired || disposed) return;
+              if (!accepted) invalid = true;
+              else if (generation === ticket) {
+                revision++;
+                notify();
+              }
+            }),
+            () => {
+              if (!accepted) invalid = true;
+              else if (!disposed && generation === ticket) dispose();
+            }
+          )
+        ) : void 0;
+        const prepared = {
+          publish() {
+            if (retired || disposed || ticket !== generation) return;
+            if (!accepted) {
+              accepted = true;
+              if (raw !== next) {
+                const stop = unsubscribe;
+                ticket = ++generation;
+                raw = next;
+                handle = candidate;
+                unsubscribe = staged;
+                staged = void 0;
+                stop?.();
+              }
+            }
+            active = candidate;
+            if ((0, import_handle_protocol.isWritableSignal)(active)) {
+              stopWriter ??= (0, import_early_values.registerHydrationControlSignalWriter)(
+                control,
+                channel,
+                channel === "checked" && control.type === "radio" ? input : write
+              );
+              if (channel === "checked" && control.type === "radio")
+                RADIO_WRITERS.set(control, write);
+            } else {
+              stopWriter?.();
+              stopWriter = void 0;
+              if (channel === "checked") RADIO_WRITERS.delete(control);
+            }
+            if (initialized) return;
+            (0, import_control_capture.initializeHydrationControlCapture)(control.ownerDocument);
+            control.addEventListener("input", input);
+            control.addEventListener("compositionstart", compositionStart);
+            control.addEventListener("compositionend", compositionEnd);
+            initialized = true;
+            if (!(0, import_handle_protocol.isWritableSignal)(active)) return;
+            let snapshot;
+            do {
+              snapshot = (0, import_control_capture.snapshotHydrationControl)(control);
+              if (snapshot.editRevision > 0 && (0, import_handle_protocol.isWritableSignal)(active)) write(nativeValue());
+              if (disposed) return;
+            } while (!(0, import_control_capture.consumeHydrationControl)(control, snapshot.revision));
+          },
+          commit() {
+            if (retired || disposed || value == null || multiple && selected === void 0 || ticket !== generation || version !== revision || active !== candidate || composing || (0, import_control_capture.snapshotHydrationControl)(control).composing)
+              return;
+            if (channel === "checked") {
+              if (control.checked !== normalized)
+                control.checked = normalized;
+            } else if (selected) {
+              for (const option of control.options) {
+                if (disposed) return;
+                const next2 = selected.has(option.value);
+                if (option.selected !== next2) option.selected = next2;
+              }
+            } else if (!candidate && control.localName === "input" && control.type === "number" ? (
+              // Preserve a user's "1.0" for sampled numeric 1, but show zero over an empty edit.
+              value === 0 && control.value === "" || control.value != value
+            ) : control.value !== normalized)
+              control.value = normalized;
+          }
+        };
+        return preview ? Object.assign(prepared, {
+          validate: () => !retired && !invalid && !disposed && ticket === generation && version === revision,
+          discard() {
+            if (accepted || retired) return;
+            retired = true;
+            staged?.();
+            staged = void 0;
+          }
+        }) : prepared;
+      };
+      return {
+        prepare,
+        preview: (value) => prepare(value, true),
+        prepareCurrent: () => prepare(raw),
+        dispose
+      };
+    }
+  };
+}
+function bindSignalControl(control, channel, handle$) {
+  if (!(0, import_handle_protocol.isSignalHandle)(handle$))
+    throw new TypeError("A signal control requires a native value/checked property and a signal.");
+  let busy = false;
+  let dirty = false;
+  let disposed = false;
+  let lease;
+  const dispose = () => {
+    disposed = true;
+    lease.dispose();
+  };
+  const refresh = () => {
+    if (disposed) return;
+    dirty = true;
+    if (busy) return;
+    busy = true;
+    try {
+      while (dirty && !disposed) {
+        dirty = false;
+        const prepared = lease.prepare(handle$);
+        prepared.publish();
+        if (!dirty && !disposed) prepared.commit();
+      }
+    } catch (error) {
+      try {
+        dispose();
+      } catch {
+      }
+      throw error;
+    } finally {
+      busy = false;
+    }
+  };
+  refresh[import_read_protocol.NATIVE_TRANSITION_CONSUMER] = {
+    active: () => !disposed,
+    prepare: () => {
+      const prepared = lease.preview(handle$);
+      return {
+        validate: () => !disposed && !busy && prepared.validate(),
+        discard: prepared.discard,
+        commit() {
+          if (!disposed) {
+            busy = true;
+            try {
+              prepared.publish();
+              prepared.commit();
+            } finally {
+              busy = false;
+            }
+          }
+        }
+      };
+    }
+  };
+  lease = __createBindingControls().claim(control, channel, refresh);
+  refresh();
+  return dispose;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  __createBindingControls,
+  bindSignalControl
+});

package/dist/cjs/signals/derived-facade.cjs

@@ -0,0 +1,50 @@
+"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 derived_facade_exports = {};
+__export(derived_facade_exports, {
+  __derivedAt: () => __derivedAt,
+  derived$: () => derived$
+});
+module.exports = __toCommonJS(derived_facade_exports);
+var import_computations = require("./computations.cjs");
+var import_facade = require("./facade.cjs");
+var import_owner_context = require("./owner-context.cjs");
+function __derivedAt(site, compute, options) {
+  if (typeof compute !== "function") throw new TypeError("derived$ requires a function.");
+  const explicit = (0, import_facade.signalOptionsKey)(options);
+  site ??= explicit;
+  const key = (0, import_facade.descriptorKey)(site, explicit);
+  return new import_facade.DerivedDescriptor(
+    key,
+    "derived",
+    (owner) => {
+      const wrapped = compute.length ? (context) => (0, import_owner_context.runWithSignalOwner)(owner, () => compute(context)) : () => (0, import_owner_context.runWithSignalOwner)(owner, () => compute());
+      return (0, import_computations.createDeclaredDerivedCell)(owner, key, wrapped, options);
+    },
+    site
+  );
+}
+function derived$(compute, options) {
+  return __derivedAt(void 0, compute, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  __derivedAt,
+  derived$
+});

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

@@ -0,0 +1,71 @@
+"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 document_owner_exports = {};
+__export(document_owner_exports, {
+  documentSignalOwner: () => documentSignalOwner,
+  enableSignalDocument: () => enableSignalDocument,
+  installStreamedSignalOwnerActivator: () => installStreamedSignalOwnerActivator,
+  signalDocumentEnabled: () => signalDocumentEnabled,
+  streamedSignalOwnerActivator: () => streamedSignalOwnerActivator
+});
+module.exports = __toCommonJS(document_owner_exports);
+var import_error_codes_client_generated = require("../error-codes.client.generated.cjs");
+var import_early_values = require("./early-values.cjs");
+var import_owner_context = require("./owner-context.cjs");
+const documentOwners = /* @__PURE__ */ new WeakMap();
+let defaultInstalled = false;
+let signalDocumentEnabled = false;
+let streamedSignalOwnerActivator;
+function documentSignalOwner(container) {
+  const ownerDocument = container.nodeType === 9 ? container : container.ownerDocument;
+  if (ownerDocument === null) throw new TypeError("A signal document owner requires a document.");
+  let owner = documentOwners.get(ownerDocument);
+  if (owner === void 0) {
+    owner = Object.freeze({ scopeKey: "octane:document" });
+    documentOwners.set(ownerDocument, owner);
+  }
+  (0, import_early_values.registerSignalOwnerDocument)(owner, ownerDocument);
+  return owner;
+}
+function enableSignalDocument(abi = 1) {
+  if (abi !== 1) throw new TypeError((0, import_error_codes_client_generated.formatClientError)(74));
+  signalDocumentEnabled = true;
+  if (defaultInstalled) return;
+  defaultInstalled = true;
+  (0, import_owner_context.installDefaultSignalOwner)(
+    () => typeof document === "undefined" ? null : documentSignalOwner(document)
+  );
+}
+function installStreamedSignalOwnerActivator(activate) {
+  if (streamedSignalOwnerActivator !== void 0) {
+    throw new Error("A streamed signal hydration owner is already installed.");
+  }
+  streamedSignalOwnerActivator = activate;
+  return () => {
+    if (streamedSignalOwnerActivator === activate) streamedSignalOwnerActivator = void 0;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  documentSignalOwner,
+  enableSignalDocument,
+  installStreamedSignalOwnerActivator,
+  signalDocumentEnabled,
+  streamedSignalOwnerActivator
+});

package/dist/cjs/signals/early-values.cjs

@@ -0,0 +1,155 @@
+"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 early_values_exports = {};
+__export(early_values_exports, {
+  claimEarlyHydrationControlCapture: () => claimEarlyHydrationControlCapture,
+  clearEarlyHydrationControlRevision: () => clearEarlyHydrationControlRevision,
+  hasHydrationControlSignalWriter: () => hasHydrationControlSignalWriter,
+  publishHydrationControlSignalValues: () => publishHydrationControlSignalValues,
+  readEarlyHydrationControlRevision: () => readEarlyHydrationControlRevision,
+  readEarlySignalValue: () => readEarlySignalValue,
+  registerHydrationControlSignalWriter: () => registerHydrationControlSignalWriter,
+  registerSignalOwnerDocument: () => registerSignalOwnerDocument
+});
+module.exports = __toCommonJS(early_values_exports);
+var import_hydration_markers = require("../hydration-markers.cjs");
+const OWNER_DOCUMENTS = /* @__PURE__ */ new WeakMap();
+const DOCUMENT_VALUES = /* @__PURE__ */ new WeakMap();
+const CONTROL_WRITERS = /* @__PURE__ */ new WeakMap();
+const EARLY_CONTROL_REVISIONS = /* @__PURE__ */ new WeakMap();
+const CLAIMED_CONTROL_DOCUMENTS = /* @__PURE__ */ new WeakSet();
+function rendererOwner(owner) {
+  return typeof owner === "object" && owner !== null && "documentOwner" in owner;
+}
+function ownerObject(owner) {
+  return rendererOwner(owner) ? owner.instanceOwner : owner;
+}
+function valueKey(ownerKey, instanceKey, nodeKey) {
+  return JSON.stringify([ownerKey, instanceKey, nodeKey]);
+}
+function registerSignalOwnerDocument(owner, ownerDocument) {
+  OWNER_DOCUMENTS.set(ownerObject(owner), ownerDocument);
+  if (rendererOwner(owner)) OWNER_DOCUMENTS.set(owner.documentOwner, ownerDocument);
+}
+function documentForOwner(owner) {
+  return OWNER_DOCUMENTS.get(ownerObject(owner));
+}
+function bindingKey(owner, binding) {
+  const ownerKey = rendererOwner(owner) ? owner.documentOwner.scopeKey : owner.scopeKey;
+  const instanceKey = binding.scope === "instance" && rendererOwner(owner) ? owner.instanceKey : "";
+  return valueKey(ownerKey, instanceKey, binding.nodeKey);
+}
+function readEarlySignalValue(owner, binding) {
+  const ownerDocument = documentForOwner(owner);
+  return ownerDocument === void 0 ? void 0 : DOCUMENT_VALUES.get(ownerDocument)?.get(bindingKey(owner, binding));
+}
+function parseControlBindings(control) {
+  const raw = control.getAttribute(import_hydration_markers.SIGNAL_CONTROL_ATTR);
+  if (raw === null) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed) || parsed.length !== 3 || parsed[0] !== 1) return null;
+    if (typeof parsed[1] !== "string" || !Array.isArray(parsed[2])) return null;
+    const bindings = [];
+    for (const entry of parsed[2]) {
+      if (!Array.isArray(entry) || entry.length !== 3 || typeof entry[0] !== "string" || typeof entry[1] !== "string" || entry[2] !== "value" && entry[2] !== "checked") {
+        return null;
+      }
+      bindings.push(entry);
+    }
+    return { ownerKey: parsed[1], bindings };
+  } catch {
+    return null;
+  }
+}
+function controlValue(control, channel) {
+  if (channel === "checked") return control.checked;
+  if (control.localName === "select" && control.multiple) {
+    return Array.from(control.selectedOptions, (option) => option.value);
+  }
+  return control.value;
+}
+function publishHydrationControlSignalValues(control, revision) {
+  const metadata = parseControlBindings(control);
+  if (metadata !== null) {
+    let values = DOCUMENT_VALUES.get(control.ownerDocument);
+    if (values === void 0) DOCUMENT_VALUES.set(control.ownerDocument, values = /* @__PURE__ */ new Map());
+    for (const [instanceKey, nodeKey, channel] of metadata.bindings) {
+      const key = valueKey(metadata.ownerKey, instanceKey, nodeKey);
+      const previous = values.get(key);
+      if (CLAIMED_CONTROL_DOCUMENTS.has(control.ownerDocument) || previous === void 0 || revision >= previous.revision) {
+        values.set(key, { revision, value: controlValue(control, channel) });
+      }
+    }
+  }
+  const writers = CONTROL_WRITERS.get(control);
+  if (writers !== void 0) {
+    for (const [channel, write] of writers) write(controlValue(control, channel));
+  }
+}
+function registerHydrationControlSignalWriter(control, channel, write) {
+  let writers = CONTROL_WRITERS.get(control);
+  if (writers === void 0) CONTROL_WRITERS.set(control, writers = /* @__PURE__ */ new Map());
+  writers.set(channel, write);
+  return () => {
+    if (writers.get(channel) !== write) return;
+    writers.delete(channel);
+    if (writers.size === 0) CONTROL_WRITERS.delete(control);
+  };
+}
+function hasHydrationControlSignalWriter(control, channel) {
+  return CONTROL_WRITERS.get(control)?.has(channel) ?? false;
+}
+function readEarlyHydrationControlRevision(control) {
+  return EARLY_CONTROL_REVISIONS.get(control) ?? 0;
+}
+function clearEarlyHydrationControlRevision(control) {
+  EARLY_CONTROL_REVISIONS.delete(control);
+}
+function claimEarlyHydrationControlCapture(ownerDocument) {
+  CLAIMED_CONTROL_DOCUMENTS.add(ownerDocument);
+}
+function publishEarlyHydrationControlSignalValues(control, revision) {
+  if (CLAIMED_CONTROL_DOCUMENTS.has(control.ownerDocument)) return;
+  EARLY_CONTROL_REVISIONS.set(control, revision);
+  publishHydrationControlSignalValues(control, revision);
+}
+if (typeof globalThis !== "undefined") {
+  const host = globalThis;
+  host.__octanePublishSignalControl = publishEarlyHydrationControlSignalValues;
+  const mailbox = host.__octaneEarlySignalControls;
+  if (mailbox !== void 0) {
+    mailbox.p = publishEarlyHydrationControlSignalValues;
+    const queued = mailbox.q.splice(0);
+    for (const [control, revision] of queued) {
+      publishEarlyHydrationControlSignalValues(control, revision);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  claimEarlyHydrationControlCapture,
+  clearEarlyHydrationControlRevision,
+  hasHydrationControlSignalWriter,
+  publishHydrationControlSignalValues,
+  readEarlyHydrationControlRevision,
+  readEarlySignalValue,
+  registerHydrationControlSignalWriter,
+  registerSignalOwnerDocument
+});