octane 0.2.11 → 0.2.13

package/dist/cjs/signals/types.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 types_exports = {};
+__export(types_exports, {
+  QUERY_REQUEST: () => QUERY_REQUEST,
+  SIGNAL_BINDING_IDENTITY: () => SIGNAL_BINDING_IDENTITY,
+  SIGNAL_BINDING_READ: () => SIGNAL_BINDING_READ,
+  SIGNAL_BINDING_SUBSCRIBE: () => SIGNAL_BINDING_SUBSCRIBE,
+  SIGNAL_HANDLE: () => SIGNAL_HANDLE,
+  SIGNAL_OWNER_RESOLVE: () => SIGNAL_OWNER_RESOLVE,
+  skip: () => skip
+});
+module.exports = __toCommonJS(types_exports);
+const SIGNAL_HANDLE = /* @__PURE__ */ Symbol.for("octane.signal-handle");
+const SIGNAL_BINDING_READ = /* @__PURE__ */ Symbol.for("octane.signal-binding-read");
+const SIGNAL_BINDING_SUBSCRIBE = /* @__PURE__ */ Symbol.for(
+  "octane.signal-binding-subscribe"
+);
+const SIGNAL_BINDING_IDENTITY = /* @__PURE__ */ Symbol.for(
+  "octane.signal-binding-identity"
+);
+const QUERY_REQUEST = /* @__PURE__ */ Symbol.for("octane.query-request");
+const SIGNAL_OWNER_RESOLVE = /* @__PURE__ */ Symbol.for("octane.signal-owner-resolve");
+const skip = /* @__PURE__ */ Symbol.for("octane.query-skip");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QUERY_REQUEST,
+  SIGNAL_BINDING_IDENTITY,
+  SIGNAL_BINDING_READ,
+  SIGNAL_BINDING_SUBSCRIBE,
+  SIGNAL_HANDLE,
+  SIGNAL_OWNER_RESOLVE,
+  skip
+});

package/dist/cjs/stream-protocol.cjs

@@ -26,12 +26,15 @@ __export(stream_protocol_exports, {
   streamTokenFromBoundaryId: () => streamTokenFromBoundaryId
 });
 module.exports = __toCommonJS(stream_protocol_exports);
+var import_dom_binding_protocol = require("./dom-binding-protocol.cjs");
 const STREAM_BOUNDARY_ATTR = "data-oct-b";
 const HYDRATE_STREAM_TOKEN_ATTR = "data-octane-stream-token";
 function hydrationMarkerMultiplicity(data, open) {
   const marker = open ? "[" : "]";
   if (data === marker) return 1;
   if (open && (data === "[f0" || data === "[f1")) return 1;
+  if (open && (data.startsWith("[b;") || data.startsWith("[f")) && (0, import_dom_binding_protocol.isBindingOpenComment)(data))
+    return 1;
   if (data.length < 2 || data.charCodeAt(0) !== marker.charCodeAt(0)) return 0;
   const first = data.charCodeAt(1);
   if (first < 49 || first > 57) return 0;

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

@@ -0,0 +1,159 @@
+"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 streamed_signals_protocol_exports = {};
+__export(streamed_signals_protocol_exports, {
+  decodeStreamedRendererFrame: () => decodeStreamedRendererFrame,
+  encodeStreamedRendererFrameForScript: () => encodeStreamedRendererFrameForScript,
+  isStreamFrameIdentity: () => isStreamFrameIdentity,
+  isStreamedRendererFrame: () => isStreamedRendererFrame,
+  sameStreamFrameIdentity: () => sameStreamFrameIdentity,
+  streamFrameIdentityKey: () => streamFrameIdentityKey
+});
+module.exports = __toCommonJS(streamed_signals_protocol_exports);
+function isRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return false;
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== "string") return false;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor.enumerable || !("value" in descriptor)) return false;
+  }
+  return true;
+}
+function isKey(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 1024;
+}
+function isCounter(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function hasOnly(record, allowed) {
+  return Object.keys(record).every((key) => allowed.has(key));
+}
+const IDENTITY_KEYS = /* @__PURE__ */ new Set([
+  "protocol",
+  "buildId",
+  "documentId",
+  "ownerKey",
+  "instanceKey",
+  "nodeKey",
+  "selectionKey",
+  "selectionGeneration",
+  "attempt"
+]);
+function isStreamFrameIdentity(value) {
+  if (!isRecord(value) || !hasOnly(value, IDENTITY_KEYS)) return false;
+  return value.protocol === 1 && isKey(value.buildId) && isKey(value.documentId) && isKey(value.ownerKey) && isKey(value.instanceKey) && isKey(value.nodeKey) && isKey(value.selectionKey) && isCounter(value.selectionGeneration) && isCounter(value.attempt);
+}
+function isEncodedSignalValue(value, depth = 0) {
+  if (depth > 100 || !Array.isArray(value) || typeof value[0] !== "string") return false;
+  const tag = value[0];
+  if (tag === "undefined" || tag === "null") return value.length === 1;
+  if (value.length !== 2) return false;
+  if (tag === "boolean") return typeof value[1] === "boolean";
+  if (tag === "string") return typeof value[1] === "string";
+  if (tag === "number") {
+    return value[1] === "-0" || typeof value[1] === "number" && Number.isFinite(value[1]) && !Object.is(value[1], -0);
+  }
+  if (tag === "array") {
+    return Array.isArray(value[1]) && value[1].every((item) => isEncodedSignalValue(item, depth + 1));
+  }
+  if (tag !== "object" || !Array.isArray(value[1])) return false;
+  let previous;
+  for (const entry of value[1]) {
+    if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string" || previous !== void 0 && entry[0] <= previous || !isEncodedSignalValue(entry[1], depth + 1)) {
+      return false;
+    }
+    previous = entry[0];
+  }
+  return true;
+}
+function isHistoricalFrame(value) {
+  return isRecord(value) && value.version === 1 && isKey(value.scopeKey) && Array.isArray(value.entries);
+}
+const RESULT_BASE_KEYS = /* @__PURE__ */ new Set(["identity", "sequence", "channel", "kind"]);
+function isStreamedRendererFrame(value) {
+  if (!isRecord(value) || !isStreamFrameIdentity(value.identity) || !isCounter(value.sequence)) {
+    return false;
+  }
+  if (value.channel === "result") {
+    if (value.kind === "open") {
+      return hasOnly(value, /* @__PURE__ */ new Set([...RESULT_BASE_KEYS, "resource"])) && (value.resource === "promise" || value.resource === "stream");
+    }
+    if (value.kind === "value") {
+      return hasOnly(value, /* @__PURE__ */ new Set([...RESULT_BASE_KEYS, "value"])) && isEncodedSignalValue(value.value);
+    }
+    if (value.kind === "error") {
+      return hasOnly(value, /* @__PURE__ */ new Set([...RESULT_BASE_KEYS, "code"])) && isKey(value.code);
+    }
+    return value.kind === "complete" && hasOnly(value, RESULT_BASE_KEYS);
+  }
+  if (value.channel !== "placement" || value.kind !== "html") return false;
+  const allowed = /* @__PURE__ */ new Set([
+    "identity",
+    "sequence",
+    "channel",
+    "kind",
+    "contentRevision",
+    "baseRevision",
+    "mode",
+    "html",
+    "historicalFrame",
+    "styles"
+  ]);
+  if (!hasOnly(value, allowed) || !isCounter(value.contentRevision) || value.mode !== "full" && value.mode !== "delta" || typeof value.html !== "string" || !isHistoricalFrame(value.historicalFrame) || !Array.isArray(value.styles) || !value.styles.every(isKey) || new Set(value.styles).size !== value.styles.length) {
+    return false;
+  }
+  if (value.mode === "delta") return isCounter(value.baseRevision);
+  return value.baseRevision === void 0 || isCounter(value.baseRevision);
+}
+function decodeStreamedRendererFrame(json) {
+  const value = JSON.parse(json);
+  if (!isStreamedRendererFrame(value)) throw new Error("Invalid Octane streamed renderer frame.");
+  return value;
+}
+function encodeStreamedRendererFrameForScript(frame) {
+  if (!isStreamedRendererFrame(frame)) throw new Error("Invalid Octane streamed renderer frame.");
+  return JSON.stringify(frame).replace(/&/g, "\\u0026").replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function sameStreamFrameIdentity(a, b) {
+  return a.protocol === b.protocol && a.buildId === b.buildId && a.documentId === b.documentId && a.ownerKey === b.ownerKey && a.instanceKey === b.instanceKey && a.nodeKey === b.nodeKey && a.selectionKey === b.selectionKey && a.selectionGeneration === b.selectionGeneration && a.attempt === b.attempt;
+}
+function streamFrameIdentityKey(identity) {
+  return JSON.stringify([
+    identity.protocol,
+    identity.buildId,
+    identity.documentId,
+    identity.ownerKey,
+    identity.instanceKey,
+    identity.nodeKey,
+    identity.selectionKey,
+    identity.selectionGeneration,
+    identity.attempt
+  ]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decodeStreamedRendererFrame,
+  encodeStreamedRendererFrameForScript,
+  isStreamFrameIdentity,
+  isStreamedRendererFrame,
+  sameStreamFrameIdentity,
+  streamFrameIdentityKey
+});

package/dist/cjs/style-values.cjs

@@ -0,0 +1,122 @@
+"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 style_values_exports = {};
+__export(style_values_exports, {
+  cssStyleValue: () => cssStyleValue,
+  hyphenateStyleName: () => hyphenateStyleName,
+  isUnitlessStyleProp: () => isUnitlessStyleProp
+});
+module.exports = __toCommonJS(style_values_exports);
+const UNITLESS_STYLE_PROPS = /* @__PURE__ */ new Set();
+for (const base of [
+  "animationIterationCount",
+  "aspectRatio",
+  "borderImageOutset",
+  "borderImageSlice",
+  "borderImageWidth",
+  "boxFlex",
+  "boxFlexGroup",
+  "boxOrdinalGroup",
+  "columnCount",
+  "columns",
+  "flex",
+  "flexGrow",
+  "flexPositive",
+  "flexShrink",
+  "flexNegative",
+  "flexOrder",
+  "gridArea",
+  "gridRow",
+  "gridRowEnd",
+  "gridRowSpan",
+  "gridRowStart",
+  "gridColumn",
+  "gridColumnEnd",
+  "gridColumnSpan",
+  "gridColumnStart",
+  "fontWeight",
+  "lineClamp",
+  "lineHeight",
+  "opacity",
+  "order",
+  "orphans",
+  "scale",
+  "tabSize",
+  "widows",
+  "zIndex",
+  "zoom",
+  "fillOpacity",
+  "floodOpacity",
+  "stopOpacity",
+  "strokeDasharray",
+  "strokeDashoffset",
+  "strokeMiterlimit",
+  "strokeOpacity",
+  "strokeWidth"
+]) {
+  const c = base.toLowerCase();
+  UNITLESS_STYLE_PROPS.add(c);
+  UNITLESS_STYLE_PROPS.add("webkit" + c);
+  UNITLESS_STYLE_PROPS.add("ms" + c);
+  UNITLESS_STYLE_PROPS.add("moz" + c);
+  UNITLESS_STYLE_PROPS.add("o" + c);
+}
+const unitlessStylePropCache = /* @__PURE__ */ new Map();
+function isUnitlessStyleProp(name) {
+  const cached = unitlessStylePropCache.get(name);
+  if (cached !== void 0) return cached;
+  const result = UNITLESS_STYLE_PROPS.has(name.replaceAll("-", "").toLowerCase());
+  unitlessStylePropCache.set(name, result);
+  return result;
+}
+function cssStyleValue(name, value) {
+  if (typeof value === "number" && value !== 0 && name.charCodeAt(0) !== 45 && !isUnitlessStyleProp(name)) {
+    return value + "px";
+  }
+  return typeof value === "string" ? value.trim() : "" + value;
+}
+function hyphenateStyleName(name) {
+  if (name === "cssFloat") return "float";
+  if (name.charCodeAt(0) === 45) return name;
+  let hasUpper = false;
+  for (let i = 0; i < name.length; i++) {
+    const c = name.charCodeAt(i);
+    if (c >= 65 && c <= 90) {
+      hasUpper = true;
+      break;
+    }
+  }
+  if (!hasUpper) return name;
+  let out = "";
+  for (let i = 0; i < name.length; i++) {
+    const c = name.charCodeAt(i);
+    if (c >= 65 && c <= 90) out += "-" + String.fromCharCode(c + 32);
+    else out += name[i];
+  }
+  if (out.charCodeAt(0) === 109 && out.charCodeAt(1) === 115 && out.charCodeAt(2) === 45) {
+    out = "-" + out;
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cssStyleValue,
+  hyphenateStyleName,
+  isUnitlessStyleProp
+});

package/dist/cjs/trusted-html.cjs

@@ -0,0 +1,30 @@
+"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 trusted_html_exports = {};
+__export(trusted_html_exports, {
+  trustHTML: () => trustHTML
+});
+module.exports = __toCommonJS(trusted_html_exports);
+function trustHTML(html) {
+  return { __html: html };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  trustHTML
+});

package/dist/cjs/version.cjs

@@ -21,7 +21,7 @@ __export(version_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(version_exports);
-const version = "0.2.11";
+const version = "0.2.13";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   version

package/dist/class-names.d.ts

@@ -0,0 +1,5 @@
+/**
+ * clsx-style class composition (strings, numbers, arrays, objects, nesting;
+ * falsy drops out). Octane's `class`/`className` semantics at every apply site.
+ */
+export declare function normalizeClass(value: unknown): string;

package/dist/class-names.js

@@ -0,0 +1,25 @@
+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;
+}
+export {
+  normalizeClass
+};

package/dist/compiler/bundler.js

@@ -14,6 +14,7 @@ import * as nodeFs from 'node:fs';
 import * as nodeModule from 'node:module';
 import * as nodePath from 'node:path';
 import { parseModule } from '@tsrx/core';
+export { DOM_BINDING_COMPILER_ABI_VERSION } from './dom-bindings.js';
 import {
 	compile,
 	compileForBundler,
@@ -23,6 +24,7 @@ import {
 } from './compile.js';
 import { validateRendererModuleSource } from './compile-universal.js';
 import { HYDRATE_QUERY_PARAM, hydrateBoundaryPathFromId } from './hydrate-boundaries.js';
+import { parseDomBindingRequest, formatDomBindingRequest } from './dom-binding-request.js';
 import {
 	DOM_RENDERER_MODULE,
 	normalizeRendererConfig,
@@ -54,6 +56,7 @@ export {
 	CLIENT_REFERENCE_MANIFEST_VERSION,
 	createClientReferenceManifest,
 } from './client-only-server.js';
+export const INDEPENDENT_HYDRATION_MANIFEST_FILENAME = 'octane-independent-hydration.json';
 export {
 	DOM_RENDERER_ID,
 	DOM_RENDERER_MODULE,
@@ -516,6 +519,7 @@ class OctaneBundlerCompiler {
 			profile: options.profile === true,
 			inlineHookMemo: options.inlineHookMemo !== false,
 			strong: options.strong === true,
+			knownAttributeSpreads: options.knownAttributeSpreads,
 			universalRuntime: normalizeUniversalRuntime(options.universalRuntime),
 		};
 		this.renderers = normalizeRendererConfig(options.renderers);
@@ -523,17 +527,17 @@ class OctaneBundlerCompiler {
 		// Octane islands): when enabled, a project `.tsrx` is Octane's by
 		// extension (nothing else compiles the syntax), and a project
 		// `.tsx`/`.ts`/`.js` is Octane's only if it opens with a leading
-		// `/** @jsxImportSource octane */` pragma (any registered renderer's
-		// intrinsics module also counts) — full compilation for `.tsx`, hook
-		// slotting for plain `.ts`/`.js`. A leading pragma naming a foreign
-		// source (`react`, …) does NOT claim the file. Unmarked project
+		// `/** @jsxImportSource octane */` pragma (the `octane/strong` type
+		// surface and registered renderer intrinsics also count) — full
+		// compilation for `.tsx`, hook slotting for plain `.ts`/`.js`. A leading
+		// pragma naming a foreign source (`react`, …) does NOT claim the file. Unmarked project
 		// modules pass through to the host toolchain. Installed/linked
 		// packages keep their manifest `usesOctane` decision. The pragma
 		// always ships unchanged — it is meaningful to TypeScript and
 		// downstream tools (in a JSX-less `.ts`/`.js` module TypeScript
 		// ignores it, so there it acts purely as the ownership marker).
 		this.requireDirective = options.requireDirective === true;
-		this.pragmaOwnedModules = new Set([DOM_RENDERER_MODULE]);
+		this.pragmaOwnedModules = new Set([DOM_RENDERER_MODULE, 'octane/strong']);
 		for (const renderer of Object.values(this.renderers.registry)) {
 			if (renderer.intrinsics !== undefined) this.pragmaOwnedModules.add(renderer.intrinsics);
 		}
@@ -691,7 +695,7 @@ class OctaneBundlerCompiler {
 
 	/**
 	 * Does a leading `@jsxImportSource` pragma claim this module for Octane?
-	 * `octane` itself and every registered renderer's intrinsics module count;
+	 * `octane`, its Strong type surface, and registered renderer intrinsics count;
 	 * a pragma naming a FOREIGN source (`react`, `@emotion/react`, …) does not
 	 * claim the file — under the requireDirective gate the module behaves
 	 * exactly like an unmarked one.
@@ -706,9 +710,9 @@ class OctaneBundlerCompiler {
 	 * A project `.tsrx` is Octane's by extension — in an Octane pipeline
 	 * nothing else compiles the syntax, so there is nothing to opt into;
 	 * every other project module is Octane's only when `pragmaOwned` (its
-	 * leading `@jsxImportSource` pragma names octane or a registered
-	 * renderer's intrinsics module). This gate covers full compilation; the
-	 * plain `.ts`/`.js` hook-slotting branch of `transform` applies the same
+	 * leading `@jsxImportSource` pragma names octane, octane/strong, or a
+	 * registered renderer's intrinsics module). This gate covers full compilation;
+	 * the plain `.ts`/`.js` hook-slotting branch of `transform` applies the same
 	 * pragma rule inline.
 	 * Two carve-outs: installed and linked packages are exempt (their
 	 * manifest `usesOctane` rule is already the explicit per-package
@@ -1064,6 +1068,10 @@ class OctaneBundlerCompiler {
 		);
 		const file = cleanModuleId(id);
 		const hydrateBoundaryPath = hydrateBoundaryPathFromId(id);
+		const bindingRequest = parseDomBindingRequest(id);
+		if (bindingRequest !== null && hydrateBoundaryPath !== null) {
+			throw new Error('Octane DOM binding and Hydrate queries cannot be combined.');
+		}
 		const collected = {
 			dependencies: new Set(),
 			missingDependencies: new Set(),
@@ -1096,7 +1104,7 @@ class OctaneBundlerCompiler {
 			options.universalRuntime ?? this.defaults.universalRuntime,
 		);
 		const filename = this._canonicalModuleId(file);
-		const targetRuntimeRequests = (source, kind) => {
+		const targetRuntimeRequests = (source, kind, streamedSignals = false) => {
 			if (environment !== 'server' || options.explicitRuntimeRequests !== true) return null;
 			const runtimeResult = rewriteServerRuntimeRequests(source, filename);
 			if (runtimeResult === null) return null;
@@ -1104,6 +1112,7 @@ class OctaneBundlerCompiler {
 				code: runtimeResult.code,
 				map: runtimeResult.map,
 				kind,
+				...(streamedSignals ? { streamedSignals: true } : null),
 				...finishMetadata(collected),
 			};
 		};
@@ -1131,6 +1140,9 @@ class OctaneBundlerCompiler {
 		const fullCompile =
 			this._isFullCompileSource(file, collected) &&
 			this._passesOwnershipGate(file, filename, pragmaOwned);
+		if (bindingRequest !== null && !fullCompile) {
+			throw new Error('Octane DOM binding queries require a compiler-owned .tsrx/.tsx view.');
+		}
 		// The narrow-the-rule config error concerns modules Octane owns. Under
 		// the ownership gate a host-owned project module (unmarked, or in an
 		// excluded path) may legitimately sit inside a client-only include in a
@@ -1177,13 +1189,22 @@ class OctaneBundlerCompiler {
 				!hasRendererBoundaries &&
 				typeof options.resolveCssModuleConstant === 'function';
 			const compileFilename =
-				hydrateBoundaryPath === null
-					? filename
-					: `${filename}?${HYDRATE_QUERY_PARAM}=${encodeURIComponent(hydrateBoundaryPath)}`;
+				bindingRequest !== null
+					? formatDomBindingRequest(filename, bindingRequest)
+					: hydrateBoundaryPath === null
+						? filename
+						: `${filename}?${HYDRATE_QUERY_PARAM}=${encodeURIComponent(hydrateBoundaryPath)}`;
 			const compileOptions = {
 				hmr,
 				mode: environment,
 				dev,
+				...(renderer.target === 'dom' &&
+				(options.knownAttributeSpreads ?? this.defaults.knownAttributeSpreads) !== undefined
+					? {
+							knownAttributeSpreads:
+								options.knownAttributeSpreads ?? this.defaults.knownAttributeSpreads,
+						}
+					: null),
 				...(renderer.target === 'dom' && options.textTypeFacts !== undefined
 					? { textTypeFacts: options.textTypeFacts }
 					: null),
@@ -1223,9 +1244,12 @@ class OctaneBundlerCompiler {
 			let out;
 			let voidComponentAst = null;
 			let cssModuleConstantImports;
-			if (collectVoidComponentExports || collectCssModuleConstants) {
+			let independentWidgets;
+			const collectIndependentWidgets = code.includes('Hydrate') && code.includes('independent');
+			if (collectVoidComponentExports || collectCssModuleConstants || collectIndependentWidgets) {
 				const compilation = compileForBundler(code, compileFilename, compileOptions);
 				out = compilation.result;
+				if (collectIndependentWidgets) independentWidgets = compilation.independentWidgets;
 				if (collectVoidComponentExports) voidComponentAst = compilation.hydrateAst;
 				if (collectCssModuleConstants) {
 					cssModuleConstantImports = compilation.cssModuleConstantImports;
@@ -1239,6 +1263,8 @@ class OctaneBundlerCompiler {
 				map: out.map,
 				diagnostics: out.diagnostics,
 				kind: 'compile',
+				...(out.streamedSignals === true ? { streamedSignals: true } : null),
+				...(out.bindingConstants === undefined ? null : { bindingConstants: out.bindingConstants }),
 				renderer,
 				...(out.universalRuntime === undefined ? null : { universalRuntime: out.universalRuntime }),
 				...(clientReference === null ? null : { clientReference }),
@@ -1248,6 +1274,7 @@ class OctaneBundlerCompiler {
 							voidComponentExports: findVoidComponentExports(voidComponentAst, filename),
 						}),
 				...(cssModuleConstantImports === undefined ? null : { cssModuleConstantImports }),
+				...(independentWidgets === undefined ? null : { independentWidgets }),
 				descriptorChildrenExports:
 					preparedDescriptorChildrenExports === null
 						? findDescriptorChildrenExports(code, filename)
@@ -1340,14 +1367,16 @@ class OctaneBundlerCompiler {
 					: {}),
 			});
 			if (out === null) return passThrough();
-			return (
-				targetRuntimeRequests(out.code, 'slots') ?? {
-					code: out.code,
-					map: out.map,
-					kind: 'slots',
-					...finishMetadata(collected),
-				}
-			);
+			// Strong plain modules report nonfatal hints like compiled modules do.
+			this._forwardCompileDiagnostics(out.diagnostics);
+			const slotted = targetRuntimeRequests(out.code, 'slots', out.streamedSignals) ?? {
+				code: out.code,
+				map: out.map,
+				kind: 'slots',
+				...(out.streamedSignals === true ? { streamedSignals: true } : null),
+				...finishMetadata(collected),
+			};
+			return out.diagnostics === undefined ? slotted : { ...slotted, diagnostics: out.diagnostics };
 		}
 
 		return passThrough();