octane 0.2.12 → 0.2.13

package/README.md

@@ -45,6 +45,11 @@ interactions and disposable behavior without creating a component root or
 taking ownership of the existing markup. See the
 [external ownership guide](https://github.com/octanejs/octane/blob/main/docs/deferred-hydration.md#behavior-only-roots-and-external-ownership).
 
+For fixed native presentation, the experimental compiler-backed `adoptBindings`
+API updates declared properties on existing SSR nodes without importing the
+renderer. See [compiled DOM bindings](https://github.com/octanejs/octane/blob/main/docs/deferred-hydration.md#compiled-presentation-on-existing-dom)
+for explicit template eligibility, typed activation and lifetime ownership.
+
 For the full story, see the
 [main README](https://github.com/octanejs/octane#readme).
 

package/dist/behavior-root.d.ts

@@ -1,3 +1,6 @@
+export { adoptBindings, mountBindings, unbound } from './dom-bindings.js';
+export type { BindingSource, BindingOptions, BindingHandle } from './dom-bindings.js';
+export type { BindingRange, BindingMountTarget } from './dom-binding-program.js';
 /** A behavior-only root observes existing DOM without taking reconciliation ownership. */
 export interface BehaviorRootOptions {
     /** Dispose this root when the enclosing page or document lifetime ends. */
@@ -34,18 +37,25 @@ export interface BehaviorContext {
     readonly range?: ExternalRange;
 }
 export type BehaviorCleanup = () => void;
-export interface BehaviorEntry {
+export interface BehaviorEntry<Payload = unknown> {
     id?: string;
     target: string | Element;
     /** Restrict adoption to the closest range belonging to this exact owner. */
     owner?: unknown;
     events?: readonly string[];
+    /**
+     * Synchronously capture detached, immutable command arguments on the original
+     * native event, before readiness or adoption. Register eagerly; this cannot
+     * recover values from interactions that happened before registration.
+     * May preventDefault(), but must not return live DOM/state or a promise.
+     */
+    captureEvent?(event: Event, element: Element): Payload;
     ready?: PromiseLike<unknown>;
     dependencies?: readonly string[];
     conflicts?: readonly string[];
     signal?: AbortSignal;
     adopt(element: Element, context: BehaviorContext): void | BehaviorCleanup | PromiseLike<void | BehaviorCleanup>;
-    handleEvent?(event: Event, element: Element, context: BehaviorContext): void;
+    handleEvent?(event: Event, element: Element, context: BehaviorContext, payload: Payload): void;
 }
 export interface BehaviorRegistration {
     readonly id?: string;
@@ -59,7 +69,7 @@ export interface BehaviorRoot {
     /** A snapshot of currently active ranges, registrations, and asynchronous adoptions. */
     readonly ready: Promise<void>;
     registerExternalRange(element: Element, options: ExternalRangeOptions): ExternalRange;
-    registerBehavior(entry: BehaviorEntry): BehaviorRegistration;
+    registerBehavior<Payload = unknown>(entry: BehaviorEntry<Payload>): BehaviorRegistration;
     dispose(options?: BehaviorDisposeOptions): void;
 }
 /**

package/dist/behavior-root.js

@@ -1,3 +1,4 @@
+import { adoptBindings, mountBindings, unbound } from "./dom-bindings.js";
 const documentRegistries = /* @__PURE__ */ new WeakMap();
 const CANCELED = /* @__PURE__ */ Symbol("octane.behavior.canceled");
 function createReadiness() {
@@ -149,14 +150,14 @@ function disposeAdoption(adoption) {
   cleanup?.();
 }
 function flushQueuedEvents(record) {
-  if (record.status !== "active") return;
+  if (record.status !== "active" || record.captureDepth) return;
   const queue = record.queuedEvents;
   record.queuedEventFlushDepth++;
   try {
     while (record.queuedEventHead < queue.length) {
       const index = record.queuedEventHead;
       const queued = queue[index];
-      if (!contains(record.root, queued.element)) {
+      if (queued.payload === CANCELED || !contains(record.root, queued.element)) {
         record.queuedEventHead = index + 1;
         continue;
       }
@@ -176,7 +177,8 @@ function flushQueuedEvents(record) {
       record.entry.handleEvent?.(
         queued.event,
         queued.element,
-        adoptionContext(adoption, queued.event)
+        adoptionContext(adoption, queued.event),
+        queued.payload
       );
     }
   } finally {
@@ -342,6 +344,24 @@ function handleDelegatedEvent(root, event) {
     if (matched === null || !contains(root, matched)) continue;
     const range = nearestRange(root, matched);
     if (!rangeMatches(record, range)) continue;
+    if (record.entry.captureEvent !== void 0) {
+      const queued = { event, element: matched, range, payload: CANCELED };
+      record.queuedEvents.push(queued);
+      if (range?.status === "pending") record.waitingRanges.add(range);
+      record.captureDepth = (record.captureDepth ?? 0) + 1;
+      try {
+        const payload = record.entry.captureEvent(event, matched);
+        if (!record.controller.signal.aborted && contains(root, matched) && matchesTarget(record, matched) && nearestRange(root, matched) === range)
+          queued.payload = payload;
+      } catch (error) {
+        failBehavior(record, error);
+        throw error;
+      } finally {
+        record.captureDepth--;
+      }
+      flushQueuedEvents(record);
+      continue;
+    }
     if (record.status !== "active" || range?.status === "pending") {
       record.queuedEvents.push({ event, element: matched, range });
       if (range?.status === "pending") record.waitingRanges.add(range);
@@ -353,7 +373,7 @@ function handleDelegatedEvent(root, event) {
       flushQueuedEvents(record);
       continue;
     }
-    record.entry.handleEvent?.(event, matched, adoptionContext(adoption, event));
+    record.entry.handleEvent?.(event, matched, adoptionContext(adoption, event), void 0);
   }
 }
 function installListeners(root, events) {
@@ -710,5 +730,8 @@ function attachBehaviorRoot(container, options = {}) {
   return root;
 }
 export {
-  attachBehaviorRoot
+  adoptBindings,
+  attachBehaviorRoot,
+  mountBindings,
+  unbound
 };

package/dist/cjs/behavior-root.cjs

@@ -18,9 +18,13 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var behavior_root_exports = {};
 __export(behavior_root_exports, {
-  attachBehaviorRoot: () => attachBehaviorRoot
+  adoptBindings: () => import_dom_bindings.adoptBindings,
+  attachBehaviorRoot: () => attachBehaviorRoot,
+  mountBindings: () => import_dom_bindings.mountBindings,
+  unbound: () => import_dom_bindings.unbound
 });
 module.exports = __toCommonJS(behavior_root_exports);
+var import_dom_bindings = require("./dom-bindings.cjs");
 const documentRegistries = /* @__PURE__ */ new WeakMap();
 const CANCELED = /* @__PURE__ */ Symbol("octane.behavior.canceled");
 function createReadiness() {
@@ -172,14 +176,14 @@ function disposeAdoption(adoption) {
   cleanup?.();
 }
 function flushQueuedEvents(record) {
-  if (record.status !== "active") return;
+  if (record.status !== "active" || record.captureDepth) return;
   const queue = record.queuedEvents;
   record.queuedEventFlushDepth++;
   try {
     while (record.queuedEventHead < queue.length) {
       const index = record.queuedEventHead;
       const queued = queue[index];
-      if (!contains(record.root, queued.element)) {
+      if (queued.payload === CANCELED || !contains(record.root, queued.element)) {
         record.queuedEventHead = index + 1;
         continue;
       }
@@ -199,7 +203,8 @@ function flushQueuedEvents(record) {
       record.entry.handleEvent?.(
         queued.event,
         queued.element,
-        adoptionContext(adoption, queued.event)
+        adoptionContext(adoption, queued.event),
+        queued.payload
       );
     }
   } finally {
@@ -365,6 +370,24 @@ function handleDelegatedEvent(root, event) {
     if (matched === null || !contains(root, matched)) continue;
     const range = nearestRange(root, matched);
     if (!rangeMatches(record, range)) continue;
+    if (record.entry.captureEvent !== void 0) {
+      const queued = { event, element: matched, range, payload: CANCELED };
+      record.queuedEvents.push(queued);
+      if (range?.status === "pending") record.waitingRanges.add(range);
+      record.captureDepth = (record.captureDepth ?? 0) + 1;
+      try {
+        const payload = record.entry.captureEvent(event, matched);
+        if (!record.controller.signal.aborted && contains(root, matched) && matchesTarget(record, matched) && nearestRange(root, matched) === range)
+          queued.payload = payload;
+      } catch (error) {
+        failBehavior(record, error);
+        throw error;
+      } finally {
+        record.captureDepth--;
+      }
+      flushQueuedEvents(record);
+      continue;
+    }
     if (record.status !== "active" || range?.status === "pending") {
       record.queuedEvents.push({ event, element: matched, range });
       if (range?.status === "pending") record.waitingRanges.add(range);
@@ -376,7 +399,7 @@ function handleDelegatedEvent(root, event) {
       flushQueuedEvents(record);
       continue;
     }
-    record.entry.handleEvent?.(event, matched, adoptionContext(adoption, event));
+    record.entry.handleEvent?.(event, matched, adoptionContext(adoption, event), void 0);
   }
 }
 function installListeners(root, events) {
@@ -734,5 +757,8 @@ function attachBehaviorRoot(container, options = {}) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  attachBehaviorRoot
+  adoptBindings,
+  attachBehaviorRoot,
+  mountBindings,
+  unbound
 });

package/dist/cjs/class-names.cjs

@@ -0,0 +1,49 @@
+"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 class_names_exports = {};
+__export(class_names_exports, {
+  normalizeClass: () => normalizeClass
+});
+module.exports = __toCommonJS(class_names_exports);
+function normalizeClass(value) {
+  if (typeof value === "string") return value;
+  if (typeof value !== "object") {
+    return typeof value === "number" && value ? "" + value : "";
+  }
+  if (value === null) return "";
+  let str = "";
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      if (item) {
+        const inner = normalizeClass(item);
+        if (inner) str = str ? str + " " + inner : inner;
+      }
+    }
+  } else {
+    for (const k in value) {
+      if (value[k]) str = str ? str + " " + k : k;
+    }
+  }
+  return str;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizeClass
+});

package/dist/cjs/constants.cjs

@@ -28,6 +28,8 @@ __export(constants_exports, {
   FOR_BLOCK_OPEN_ITEMS: () => FOR_BLOCK_OPEN_ITEMS,
   HYDRATE_ID_ATTR: () => HYDRATE_ID_ATTR,
   HYDRATE_ID_COUNT_ATTR: () => HYDRATE_ID_COUNT_ATTR,
+  HYDRATE_INDEPENDENT_ATTR: () => import_hydration_markers.HYDRATE_INDEPENDENT_ATTR,
+  HYDRATE_INPUT_ATTR: () => import_hydration_markers.HYDRATE_INPUT_ATTR,
   HYDRATE_SEED_ATTR: () => HYDRATE_SEED_ATTR,
   HYDRATE_STATIC_END: () => HYDRATE_STATIC_END,
   HYDRATE_STATIC_ID_COUNT_PREFIX: () => HYDRATE_STATIC_ID_COUNT_PREFIX,
@@ -39,9 +41,11 @@ __export(constants_exports, {
   HYDRATION_RANGE_BOUNDARY: () => HYDRATION_RANGE_BOUNDARY,
   HYDRATION_START: () => HYDRATION_START,
   HYDRATION_TEXT_SEP: () => HYDRATION_TEXT_SEP,
+  INDEPENDENT_HYDRATE_MANIFEST_ATTR: () => import_hydration_markers.INDEPENDENT_HYDRATE_MANIFEST_ATTR,
   MUST_USE_PROPERTY_PROPS: () => MUST_USE_PROPERTY_PROPS,
   POSITIVE_NUMERIC_ATTR_PROPS: () => POSITIVE_NUMERIC_ATTR_PROPS,
   REJECTION_SENTINEL_KEY: () => REJECTION_SENTINEL_KEY,
+  SIGNAL_CONTROL_ATTR: () => import_hydration_markers.SIGNAL_CONTROL_ATTR,
   STREAM_BOUNDARY_ATTR: () => import_stream_protocol2.STREAM_BOUNDARY_ATTR,
   STREAM_RESOURCE_ATTR: () => STREAM_RESOURCE_ATTR,
   STREAM_SCRIPT_ATTR: () => STREAM_SCRIPT_ATTR,
@@ -63,6 +67,7 @@ __export(constants_exports, {
 });
 module.exports = __toCommonJS(constants_exports);
 var import_stream_protocol = require("./stream-protocol.cjs");
+var import_hydration_markers = require("./hydration-markers.cjs");
 var import_stream_protocol2 = require("./stream-protocol.cjs");
 var import_dom_tables = require("./dom-tables.cjs");
 const HYDRATION_START = "[";
@@ -121,6 +126,8 @@ const cssStyleValue = import_dom_tables.cssStyleValue;
   FOR_BLOCK_OPEN_ITEMS,
   HYDRATE_ID_ATTR,
   HYDRATE_ID_COUNT_ATTR,
+  HYDRATE_INDEPENDENT_ATTR,
+  HYDRATE_INPUT_ATTR,
   HYDRATE_SEED_ATTR,
   HYDRATE_STATIC_END,
   HYDRATE_STATIC_ID_COUNT_PREFIX,
@@ -132,9 +139,11 @@ const cssStyleValue = import_dom_tables.cssStyleValue;
   HYDRATION_RANGE_BOUNDARY,
   HYDRATION_START,
   HYDRATION_TEXT_SEP,
+  INDEPENDENT_HYDRATE_MANIFEST_ATTR,
   MUST_USE_PROPERTY_PROPS,
   POSITIVE_NUMERIC_ATTR_PROPS,
   REJECTION_SENTINEL_KEY,
+  SIGNAL_CONTROL_ATTR,
   STREAM_BOUNDARY_ATTR,
   STREAM_RESOURCE_ATTR,
   STREAM_SCRIPT_ATTR,

package/dist/cjs/css.cjs

@@ -21,36 +21,15 @@ __export(css_exports, {
   devWarnStyleCoercion: () => devWarnStyleCoercion,
   devWarnStyleProperty: () => devWarnStyleProperty,
   mergeClass: () => mergeClass,
-  normalizeClass: () => normalizeClass,
+  normalizeClass: () => import_class_names.normalizeClass,
   styleName: () => styleName
 });
 module.exports = __toCommonJS(css_exports);
-var import_dom_tables = require("./dom-tables.cjs");
-function normalizeClass(value) {
-  if (typeof value === "string") return value;
-  if (typeof value !== "object") {
-    return typeof value === "number" && value ? "" + value : "";
-  }
-  if (value === null) return "";
-  let str = "";
-  if (Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      const item = value[i];
-      if (item) {
-        const inner = normalizeClass(item);
-        if (inner) str = str ? str + " " + inner : inner;
-      }
-    }
-  } else {
-    for (const k in value) {
-      if (value[k]) str = str ? str + " " + k : k;
-    }
-  }
-  return str;
-}
+var import_class_names = require("./class-names.cjs");
+var import_style_values = require("./style-values.cjs");
 function mergeClass(left, right) {
-  const a = normalizeClass(left);
-  const b = normalizeClass(right);
+  const a = (0, import_class_names.normalizeClass)(left);
+  const b = (0, import_class_names.normalizeClass)(right);
   if (!a) return b;
   if (!b) return a;
   return a + " " + b;
@@ -59,7 +38,7 @@ const styleNameCache = /* @__PURE__ */ new Map();
 function styleName(name) {
   const cached = styleNameCache.get(name);
   if (cached !== void 0) return cached;
-  const result = (0, import_dom_tables.hyphenateStyleName)(name);
+  const result = (0, import_style_values.hyphenateStyleName)(name);
   styleNameCache.set(name, result);
   return result;
 }

package/dist/cjs/data-encoding.cjs

@@ -0,0 +1,160 @@
+"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 data_encoding_exports = {};
+__export(data_encoding_exports, {
+  decodeSignalValue: () => decodeSignalValue,
+  encodeSignalValue: () => encodeSignalValue,
+  snapshotSignalValue: () => snapshotSignalValue
+});
+module.exports = __toCommonJS(data_encoding_exports);
+var import_errors = require("./signals/errors.cjs");
+function unsupported() {
+  throw new import_errors.SignalSerializationError(
+    "Signal request arguments and seeds require acyclic plain data: undefined, null, booleans, finite numbers, strings, dense arrays, and plain objects with enumerable string data properties."
+  );
+}
+function encodeSignalValue(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === void 0) return ["undefined"];
+  if (value === null) return ["null"];
+  if (typeof value === "boolean") return ["boolean", value];
+  if (typeof value === "string") return ["string", value];
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return unsupported();
+    return ["number", Object.is(value, -0) ? "-0" : value];
+  }
+  if (typeof value !== "object" || ancestors.has(value)) return unsupported();
+  const prototype = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+    return unsupported();
+  }
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      const keys2 = Reflect.ownKeys(value);
+      if (keys2.length !== value.length + 1) return unsupported();
+      const items = [];
+      for (let i = 0; i < value.length; i++) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(i));
+        if (!descriptor || !descriptor.enumerable || !("value" in descriptor)) return unsupported();
+        items.push(encodeSignalValue(descriptor.value, ancestors));
+      }
+      return ["array", items];
+    }
+    const keys = Reflect.ownKeys(value);
+    if (keys.some((key) => typeof key !== "string")) return unsupported();
+    const entries = [];
+    for (const key of keys.sort()) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor.enumerable || !("value" in descriptor)) return unsupported();
+      entries.push([key, encodeSignalValue(descriptor.value, ancestors)]);
+    }
+    return ["object", entries];
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function snapshotSignalValue(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === void 0 || value === null || typeof value === "boolean" || typeof value === "string")
+    return value;
+  if (typeof value === "number") return Number.isFinite(value) ? value : unsupported();
+  if (typeof value !== "object" || ancestors.has(value)) return unsupported();
+  const prototype = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+    return unsupported();
+  }
+  ancestors.add(value);
+  try {
+    const keys = Reflect.ownKeys(value);
+    if (Array.isArray(value)) {
+      if (keys.length !== value.length + 1) return unsupported();
+      const items = [];
+      for (let i = 0; i < value.length; i++) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(i));
+        if (!descriptor || !descriptor.enumerable || !("value" in descriptor)) return unsupported();
+        items.push(snapshotSignalValue(descriptor.value, ancestors));
+      }
+      return Object.freeze(items);
+    }
+    if (keys.some((key) => typeof key !== "string")) return unsupported();
+    const object = {};
+    for (const key of keys.sort()) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor.enumerable || !("value" in descriptor)) return unsupported();
+      Object.defineProperty(object, key, {
+        value: snapshotSignalValue(descriptor.value, ancestors),
+        enumerable: true
+      });
+    }
+    return Object.freeze(object);
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function decodeSignalValue(encoded) {
+  if (!Array.isArray(encoded)) return unsupported();
+  const [tag, value] = encoded;
+  switch (tag) {
+    case "undefined":
+      if (encoded.length !== 1) return unsupported();
+      return void 0;
+    case "null":
+      if (encoded.length !== 1) return unsupported();
+      return null;
+    case "boolean":
+      if (encoded.length !== 2 || typeof value !== "boolean") return unsupported();
+      return value;
+    case "number":
+      if (encoded.length !== 2) return unsupported();
+      if (value === "-0") return -0;
+      if (typeof value !== "number" || !Number.isFinite(value) || Object.is(value, -0)) {
+        return unsupported();
+      }
+      return value;
+    case "string":
+      if (encoded.length !== 2 || typeof value !== "string") return unsupported();
+      return value;
+    case "array":
+      if (encoded.length !== 2 || !Array.isArray(value)) return unsupported();
+      return Object.freeze(value.map((item) => decodeSignalValue(item)));
+    case "object": {
+      if (encoded.length !== 2 || !Array.isArray(value)) return unsupported();
+      const object = {};
+      let previous;
+      for (const entry of value) {
+        if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string" || previous !== void 0 && entry[0] <= previous) {
+          return unsupported();
+        }
+        previous = entry[0];
+        Object.defineProperty(object, entry[0], {
+          value: decodeSignalValue(entry[1]),
+          enumerable: true
+        });
+      }
+      return Object.freeze(object);
+    }
+    default:
+      return unsupported();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decodeSignalValue,
+  encodeSignalValue,
+  snapshotSignalValue
+});

package/dist/cjs/dom-binding-handoff.cjs

@@ -0,0 +1,93 @@
+"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 dom_binding_handoff_exports = {};
+__export(dom_binding_handoff_exports, {
+  BINDING_HANDOFF: () => BINDING_HANDOFF,
+  beginBindingEvent: () => beginBindingEvent,
+  claimBindingHandoff: () => claimBindingHandoff,
+  consumeBindingEvent: () => consumeBindingEvent,
+  hasBindingHandoffEvent: () => hasBindingHandoffEvent,
+  markBindingEvent: () => markBindingEvent,
+  registerBindingEvent: () => registerBindingEvent,
+  releaseBindingHandoff: () => releaseBindingHandoff
+});
+module.exports = __toCommonJS(dom_binding_handoff_exports);
+const BINDING_HANDOFF = /* @__PURE__ */ Symbol.for("octane.binding-handoff");
+const events = /* @__PURE__ */ new WeakMap();
+const delivered = /* @__PURE__ */ new WeakMap();
+function registerBindingEvent(node, type) {
+  let counts = events.get(node);
+  if (counts === void 0) events.set(node, counts = /* @__PURE__ */ new Map());
+  counts.set(type, (counts.get(type) ?? 0) + 1);
+  return () => {
+    const count = counts.get(type) - 1;
+    if (count === 0) counts.delete(type);
+    else counts.set(type, count);
+    if (counts.size === 0) events.delete(node);
+  };
+}
+function claimBindingHandoff(lease, owner) {
+  if (!lease.active() || lease.owner !== void 0)
+    throw new Error("A DOM binding hydration lease must be active and have only one root owner.");
+  lease.owner = owner;
+}
+function releaseBindingHandoff(lease) {
+  lease.owner = void 0;
+}
+function hasBindingHandoffEvent(event) {
+  for (const node of event.composedPath()) {
+    if (events.get(node)?.has(event.type)) return true;
+  }
+  return false;
+}
+function markBindingEvent(event, node, capture) {
+  let nodes = delivered.get(event);
+  if (nodes === void 0) {
+    delivered.set(event, nodes = /* @__PURE__ */ new Map());
+    const cleanup = () => {
+      if (delivered.get(event) === nodes) delivered.delete(event);
+    };
+    if (event.isTrusted) setTimeout(cleanup, 0);
+    else queueMicrotask(cleanup);
+  }
+  nodes.set(node, (nodes.get(node) ?? 0) | (capture ? 2 : 1));
+}
+function consumeBindingEvent(event, node, capture) {
+  const nodes = delivered.get(event);
+  const flags = nodes?.get(node) ?? 0;
+  const bit = capture ? 2 : 1;
+  if ((flags & bit) === 0) return false;
+  if ((flags & ~bit) === 0) nodes.delete(node);
+  else nodes.set(node, flags & ~bit);
+  return true;
+}
+function beginBindingEvent(event) {
+  delivered.delete(event);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BINDING_HANDOFF,
+  beginBindingEvent,
+  claimBindingHandoff,
+  consumeBindingEvent,
+  hasBindingHandoffEvent,
+  markBindingEvent,
+  registerBindingEvent,
+  releaseBindingHandoff
+});