octane 0.2.13 → 0.2.15

package/dist/signals/control-binding.d.ts

@@ -1,4 +1,5 @@
-import { type SignalHandle } from './types.js';
+import { type SignalControlBinding } from './control-handoff.js';
+import { type SignalHandle, type SignalOwner } from './types.js';
 type SignalControl = HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement;
 type ControlChannel = 'value' | 'checked';
 export interface BindingControlPrepared {
@@ -15,17 +16,20 @@ export interface BindingControlLease {
     prepare(value: unknown): BindingControlPrepared;
     preview(value: unknown): BindingControlPreview;
     prepareCurrent(): BindingControlPrepared;
+    active(): boolean;
+    composing(): boolean;
     dispose(): void;
 }
 /** @internal Optional compiled-control capability; captures, but never creates, an owner. */
-export declare function __createBindingControls(): {
+export declare function __createBindingControls(owner?: SignalOwner | null): {
     claim(element: Element, channel: ControlChannel, notify: () => void): BindingControlLease;
 };
 /**
  * Bind one native property on externally owned DOM without creating a renderer.
  * Writable signals adopt captured early edits and receive native input; other
- * handles only project. Dispose before transferring the property to another owner.
+ * handles only project. The callable cleanup may be offered to hydrateRoot in
+ * controlLeases; declined or suspended presentation keeps this binding active.
  */
-export declare function bindSignalControl(control: SignalControl, channel: 'value', handle$: SignalHandle<string | readonly string[]>): () => void;
-export declare function bindSignalControl(control: HTMLInputElement, channel: 'checked', handle$: SignalHandle<boolean>): () => void;
+export declare function bindSignalControl(control: SignalControl, channel: 'value', handle$: SignalHandle<string | readonly string[]>): SignalControlBinding;
+export declare function bindSignalControl(control: HTMLInputElement, channel: 'checked', handle$: SignalHandle<boolean>): SignalControlBinding;
 export {};

package/dist/signals/control-binding.js

@@ -8,14 +8,22 @@ import {
   registerHydrationControlSignalWriter
 } from "./early-values.js";
 import { isSignalHandle, isWritableSignal } from "./handle-protocol.js";
+import {
+  CONTROL_BINDINGS,
+  CONTROL_HANDOFF
+} from "./control-handoff.js";
 import { captureSignalOwner, currentSignalOwner } from "./owner-context.js";
 import {
   forwardNativeTransitionConsumer,
   NATIVE_TRANSITION_CONSUMER
 } from "./read-protocol.js";
-import { SIGNAL_BINDING_READ, SIGNAL_BINDING_SUBSCRIBE } from "./types.js";
+import {
+  SIGNAL_BINDING_IDENTITY,
+  SIGNAL_BINDING_READ,
+  SIGNAL_BINDING_SUBSCRIBE,
+  SIGNAL_OWNER_RESOLVE
+} from "./types.js";
 import { withoutSignalCandidate } from "./transition-state.js";
-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);
@@ -34,8 +42,7 @@ function publishRadioInput(input) {
   for (const [write, checked] of edits) if (!checked) write(false);
   for (const [write, checked] of edits) if (checked) write(true);
 }
-function __createBindingControls() {
-  const owner = currentSignalOwner();
+function __createBindingControls(owner = currentSignalOwner()) {
   const run = owner === null ? (callback) => callback() : captureSignalOwner(owner);
   return {
     claim(element, channel, notify) {
@@ -284,11 +291,16 @@ function __createBindingControls() {
         prepare,
         preview: (value) => prepare(value, true),
         prepareCurrent: () => prepare(raw),
+        active: () => !disposed,
+        composing: () => composing,
         dispose
       };
     }
   };
 }
+function controlSignalOwner(owner, document) {
+  return owner !== null && "documentOwner" in owner ? document ? owner.documentOwner : owner.instanceOwner : owner;
+}
 function bindSignalControl(control, channel, handle$) {
   if (!isSignalHandle(handle$))
     throw new TypeError("A signal control requires a native value/checked property and a signal.");
@@ -296,6 +308,7 @@ function bindSignalControl(control, channel, handle$) {
   let dirty = false;
   let disposed = false;
   let lease;
+  let handoff;
   const dispose = () => {
     disposed = true;
     lease.dispose();
@@ -343,9 +356,28 @@ function bindSignalControl(control, channel, handle$) {
       };
     }
   };
-  lease = __createBindingControls().claim(control, channel, refresh);
+  const owner = currentSignalOwner();
+  lease = __createBindingControls(owner).claim(control, channel, refresh);
   refresh();
-  return dispose;
+  return Object.assign(dispose, {
+    [CONTROL_HANDOFF]() {
+      return handoff ??= {
+        control,
+        channel,
+        active: () => !disposed && lease.active(),
+        matches(handle) {
+          if (disposed || !lease.active() || handle !== handle$) return false;
+          if (!(SIGNAL_OWNER_RESOLVE in handle$)) return true;
+          const document = handle$[SIGNAL_BINDING_IDENTITY]().scope === "document";
+          return owner !== null && controlSignalOwner(owner, document) === controlSignalOwner(currentSignalOwner(), document) && !disposed && lease.active();
+        },
+        composing: lease.composing,
+        // dispose revokes authority before invoking fallible subscription
+        // cleanup; a later call cannot release the renderer's replacement.
+        retire: dispose
+      };
+    }
+  });
 }
 export {
   __createBindingControls,

package/dist/signals/control-handoff.d.ts

@@ -0,0 +1,26 @@
+import type { SignalHandle } from './types.js';
+/** Renderer-independent capability shared by early views and later presentation. */
+export declare const BINDING_HANDOFF: unique symbol;
+/** Explicit, renderer-independent ownership of one standalone native control. */
+export declare const CONTROL_HANDOFF: unique symbol;
+/** @internal One claim registry for writable and readonly native control leases. */
+export declare const CONTROL_BINDINGS: WeakMap<Element, Set<"value" | "checked">>;
+/** @internal Readonly projections also own the property, even without an input writer. */
+export declare function hasSignalControlBinding(control: Element, channel: 'value' | 'checked'): boolean;
+/** @internal A root may consume this capability only with its accepted presentation. */
+export interface ControlHandoff {
+    readonly control: Element;
+    readonly channel: 'value' | 'checked';
+    active(): boolean;
+    /** Called within the prospective renderer's signal owner, without changing authority. */
+    matches(handle: SignalHandle<unknown>): boolean;
+    composing(): boolean;
+    retire(): void;
+    owner?: object;
+}
+/** Callable cleanup which can also be offered explicitly to hydrateRoot's controlLeases. */
+export interface SignalControlBinding {
+    (): void;
+    /** @internal Merely requesting the capability never transfers the control. */
+    [CONTROL_HANDOFF](): ControlHandoff;
+}

package/dist/signals/control-handoff.js

@@ -0,0 +1,12 @@
+const BINDING_HANDOFF = /* @__PURE__ */ Symbol.for("octane.binding-handoff");
+const CONTROL_HANDOFF = /* @__PURE__ */ Symbol.for("octane.control-handoff");
+const CONTROL_BINDINGS = /* @__PURE__ */ new WeakMap();
+function hasSignalControlBinding(control, channel) {
+  return CONTROL_BINDINGS.get(control)?.has(channel) ?? false;
+}
+export {
+  BINDING_HANDOFF,
+  CONTROL_BINDINGS,
+  CONTROL_HANDOFF,
+  hasSignalControlBinding
+};

package/dist/signals/index.d.ts

@@ -1,6 +1,7 @@
 /** Stable scoped signals. This entry does not import a renderer. */
 export { createScope } from './engine.js';
 export { bindSignalControl } from './control-binding.js';
+export type { SignalControlBinding } from './control-handoff.js';
 export { enableSignalDocument as __enableSignalDocument } from './document-owner.js';
 export { createResource, query } from './requests.js';
 export { ActionUncertainError, action$, isActionUncertain, optimistic$ } from './actions.js';

package/dist/stream-protocol.d.ts

@@ -1,5 +1,9 @@
 /** Sentinel <template> attribute marking a pending streamed boundary. */
 export declare const STREAM_BOUNDARY_ATTR = "data-oct-b";
+/** Renderer-owned JSON script carrying resolved SSR Suspense values. */
+export declare const SUSPENSE_SCRIPT_ATTR = "data-octane-suspense";
+/** Renderer-owned executable/data scripts emitted by the streaming protocol. */
+export declare const STREAM_SCRIPT_ATTR = "data-octane-stream";
 /** Render-unique token stamped on deferred-hydration owners in a streamed shell. */
 export declare const HYDRATE_STREAM_TOKEN_ATTR = "data-octane-stream-token";
 /** Find a physical hydration range's close without trusting malformed comment input. */

package/dist/stream-protocol.js

@@ -1,5 +1,7 @@
 import { isBindingOpenComment } from "./dom-binding-protocol.js";
 const STREAM_BOUNDARY_ATTR = "data-oct-b";
+const SUSPENSE_SCRIPT_ATTR = "data-octane-suspense";
+const STREAM_SCRIPT_ATTR = "data-octane-stream";
 const HYDRATE_STREAM_TOKEN_ATTR = "data-octane-stream-token";
 function hydrationMarkerMultiplicity(data, open) {
   const marker = open ? "[" : "]";
@@ -64,6 +66,8 @@ function isRendererStreamBoundaryTemplate(node, expectedToken) {
 export {
   HYDRATE_STREAM_TOKEN_ATTR,
   STREAM_BOUNDARY_ATTR,
+  STREAM_SCRIPT_ATTR,
+  SUSPENSE_SCRIPT_ATTR,
   isRendererStreamBoundaryTemplate,
   isRendererStreamToken,
   rendererRangeClose,

package/dist/version.js

@@ -1,4 +1,4 @@
-const version = "0.2.13";
+const version = "0.2.15";
 export {
   version
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "octane",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "license": "MIT",
   "type": "module",
   "sideEffects": [