octane 0.2.12 → 0.2.13

package/dist/constants.d.ts

@@ -97,6 +97,7 @@ export declare const HYDRATE_ID_COUNT_ATTR = "data-octane-hydrate-id-count";
 export { HYDRATE_STREAM_TOKEN_ATTR } from './stream-protocol.js';
 /** Direct-child JSON script carrying this boundary's `use()` seed slice. */
 export declare const HYDRATE_SEED_ATTR = "data-octane-hydrate-seed";
+export { INDEPENDENT_HYDRATE_MANIFEST_ATTR, HYDRATE_INDEPENDENT_ATTR, HYDRATE_INPUT_ATTR, SIGNAL_CONTROL_ATTR, } from './hydration-markers.js';
 /** Sentinel <template> attribute marking a pending streamed boundary. */
 export { STREAM_BOUNDARY_ATTR } from './stream-protocol.js';
 /** Hidden segment container attribute carrying a completed boundary's content. */

package/dist/constants.js

@@ -28,6 +28,12 @@ const HYDRATE_WHEN_ATTR = "data-octane-hydrate-when";
 const HYDRATE_ID_COUNT_ATTR = "data-octane-hydrate-id-count";
 import { HYDRATE_STREAM_TOKEN_ATTR } from "./stream-protocol.js";
 const HYDRATE_SEED_ATTR = "data-octane-hydrate-seed";
+import {
+  INDEPENDENT_HYDRATE_MANIFEST_ATTR,
+  HYDRATE_INDEPENDENT_ATTR,
+  HYDRATE_INPUT_ATTR,
+  SIGNAL_CONTROL_ATTR
+} from "./hydration-markers.js";
 import { STREAM_BOUNDARY_ATTR } from "./stream-protocol.js";
 const STREAM_SEGMENT_ATTR = "data-oct-s";
 const STREAM_SEED_ATTR = "data-oct-seed";
@@ -66,6 +72,8 @@ export {
   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,
@@ -77,9 +85,11 @@ export {
   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/css.d.ts

@@ -1,8 +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;
+import { normalizeClass } from './class-names.js';
+export { normalizeClass };
 /**
  * Append a later class source onto an earlier one. Used when a synthesized
  * scope hash must share the element with a spread's class instead of replacing

package/dist/css.js

@@ -1,25 +1,4 @@
-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;
-}
+import { normalizeClass } from "./class-names.js";
 function mergeClass(left, right) {
   const a = normalizeClass(left);
   const b = normalizeClass(right);
@@ -27,7 +6,7 @@ function mergeClass(left, right) {
   if (!b) return a;
   return a + " " + b;
 }
-import { hyphenateStyleName } from "./dom-tables.js";
+import { hyphenateStyleName } from "./style-values.js";
 const styleNameCache = /* @__PURE__ */ new Map();
 function styleName(name) {
   const cached = styleNameCache.get(name);

package/dist/data-encoding.d.ts

@@ -0,0 +1,9 @@
+import type { EncodedSignalValue } from './signals/types.js';
+export declare function encodeSignalValue(value: unknown, ancestors?: Set<object>): EncodedSignalValue;
+/**
+ * Take an immutable plain-data snapshot without an encode/decode round trip.
+ * Keep this traversal separate so encode-only consumers retain neither its code
+ * nor a per-value mode branch. Both paths enforce the same input descriptor rules.
+ */
+export declare function snapshotSignalValue(value: unknown, ancestors?: Set<object>): unknown;
+export declare function decodeSignalValue(encoded: EncodedSignalValue): unknown;

package/dist/data-encoding.js

@@ -0,0 +1,134 @@
+import { SignalSerializationError } from "./signals/errors.js";
+function unsupported() {
+  throw new 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();
+  }
+}
+export {
+  decodeSignalValue,
+  encodeSignalValue,
+  snapshotSignalValue
+};

package/dist/dom-binding-classes.d.ts

@@ -0,0 +1,15 @@
+export interface BindingClassGroup {
+    /** Preparation can be discarded without changing the DOM or its receipts. */
+    prepare(value: string): {
+        commit(): void;
+    };
+    /** An uncommitted adoption leaves the historical SSR contribution intact. */
+    dispose(preservePresentation?: boolean): void;
+}
+export declare function __bindingClassReceipt(baseline: unknown, groups: readonly unknown[]): string;
+/**
+ * Adopt the server's historical contribution, not a possibly newer client value.
+ * Baseline and sibling groups each retain their own contribution to shared atoms.
+ * The surrounding binding runtime owns channel exclusion and subscription lifetime.
+ */
+export declare function createBindingClassGroup(node: Element, name: string, index: number, initialReceipt?: string): BindingClassGroup;

package/dist/dom-binding-classes.js

@@ -0,0 +1,129 @@
+import { normalizeClass } from "./class-names.js";
+const receipts = /* @__PURE__ */ new WeakMap();
+function tokens(value) {
+  return new Set(value.match(/[^\t\n\f\r ]+/g));
+}
+function __bindingClassReceipt(baseline, groups) {
+  return JSON.stringify([normalizeClass(baseline), groups.map(normalizeClass)]);
+}
+function readReceipt(node, name, initialReceipt) {
+  let value;
+  try {
+    value = JSON.parse(initialReceipt ?? node.getAttribute(name) ?? "null");
+  } catch {
+    throw new Error("DOM class groups require a valid compiler-issued class receipt.");
+  }
+  if (!name.startsWith("data-octane-class-") || !Array.isArray(value) || value.length !== 2 || typeof value[0] !== "string" || !Array.isArray(value[1]) || value[1].some((group) => typeof group !== "string"))
+    throw new Error("DOM class groups require a valid compiler-issued class receipt.");
+  const counts = /* @__PURE__ */ new Map();
+  for (const contribution of [value[0], ...value[1]])
+    for (const token of tokens(contribution)) counts.set(token, (counts.get(token) ?? 0) + 1);
+  return { name, baseline: value[0], values: value[1], counts, active: /* @__PURE__ */ new Set() };
+}
+function createBindingClassGroup(node, name, index, initialReceipt) {
+  let receipt = receipts.get(node);
+  if (receipt !== void 0 && receipt.name !== name)
+    throw new Error("A DOM host cannot mix class groups from different binding views.");
+  receipt ??= readReceipt(node, name, initialReceipt);
+  if (!Number.isInteger(index) || index < 0 || index >= receipt.values.length)
+    throw new Error("A DOM class group does not match its compiler-issued receipt.");
+  if (receipt.active.has(index)) throw new Error("This DOM class group already has a binding.");
+  receipt.active.add(index);
+  receipts.set(node, receipt);
+  let disposed = false;
+  let committed = false;
+  let revision = 0;
+  let retiring = /* @__PURE__ */ new Set();
+  const state = receipt;
+  function publish(value, next) {
+    const old = tokens(state.values[index]);
+    const remove = [];
+    const add = [];
+    for (const token of old) {
+      if (next.has(token)) continue;
+      const count = state.counts.get(token) - 1;
+      if (count === 0) {
+        state.counts.delete(token);
+        remove.push(token);
+      } else state.counts.set(token, count);
+    }
+    for (const token of next) {
+      if (old.has(token)) continue;
+      const count = state.counts.get(token) ?? 0;
+      state.counts.set(token, count + 1);
+      if (count === 0) add.push(token);
+    }
+    state.values[index] = value;
+    revision++;
+    retiring = new Set(remove);
+    for (const token of remove) {
+      node.classList.remove(token);
+      retiring.delete(token);
+      if (disposed) return;
+    }
+    for (const token of add) {
+      node.classList.add(token);
+      if (disposed) return;
+    }
+    node.setAttribute(name, JSON.stringify([state.baseline, state.values]));
+  }
+  return {
+    prepare(value) {
+      if (disposed) throw new Error("Cannot prepare a disposed DOM class group.");
+      const preparedAt = revision;
+      const next = value === state.values[index] ? null : tokens(value);
+      return {
+        commit() {
+          if (disposed) return;
+          if (preparedAt !== revision)
+            throw new Error("Cannot commit an outdated DOM class group preparation.");
+          committed = true;
+          if (next !== null) publish(value, next);
+        }
+      };
+    },
+    dispose(preservePresentation) {
+      if (disposed) return;
+      disposed = true;
+      if (!committed || preservePresentation) {
+        state.active.delete(index);
+        if (state.active.size === 0) receipts.delete(node);
+        return;
+      }
+      const old = tokens(state.values[index]);
+      state.values[index] = "";
+      revision++;
+      const remove = /* @__PURE__ */ new Set();
+      for (const token of old) {
+        const count = state.counts.get(token) - 1;
+        if (count === 0) {
+          state.counts.delete(token);
+          remove.add(token);
+        } else state.counts.set(token, count);
+      }
+      for (const token of retiring) if (!state.counts.has(token)) remove.add(token);
+      retiring.clear();
+      let failed = false;
+      let failure;
+      const attempt = (write) => {
+        try {
+          write();
+        } catch (error) {
+          if (!failed) {
+            failed = true;
+            failure = error;
+          }
+        }
+      };
+      for (const token of remove) attempt(() => node.classList.remove(token));
+      attempt(() => node.setAttribute(name, JSON.stringify([state.baseline, state.values])));
+      state.active.delete(index);
+      if (state.active.size === 0) receipts.delete(node);
+      if (failed) throw failure;
+    }
+  };
+}
+export {
+  __bindingClassReceipt,
+  createBindingClassGroup
+};

package/dist/dom-binding-controls.d.ts

@@ -0,0 +1,2 @@
+/** Optional compiler-selected bridge to the canonical native control adapter. */
+export { __createBindingControls, type BindingControlLease, type BindingControlPrepared, } from './signals/control-binding.js';

package/dist/dom-binding-controls.js

@@ -0,0 +1,6 @@
+import {
+  __createBindingControls
+} from "./signals/control-binding.js";
+export {
+  __createBindingControls
+};

package/dist/dom-binding-handoff.d.ts

@@ -0,0 +1,55 @@
+/** Renderer-independent capability carried by an adopted, compiler-proven view. */
+export declare const BINDING_HANDOFF: unique symbol;
+/** Current early-owned range, not a license to render a different shape. */
+export interface BindingHandoffRange {
+    readonly kind: 'if' | 'view' | 'slot' | 'text';
+    readonly end: Node;
+    readonly arm?: number;
+    readonly view?: string;
+    readonly slot?: string;
+}
+/** A closed caller shape proven for this actual child range, never for its module globally. */
+export interface BindingHandoffView {
+    readonly id: string;
+    readonly closedProps: readonly string[];
+}
+export interface BindingHandoffRest {
+    readonly id: string;
+    readonly node: number;
+    readonly spread: number;
+    readonly keys: readonly string[];
+}
+export interface BindingHandoff {
+    readonly id: string;
+    readonly root: Node;
+    readonly anchor: Node;
+    readonly end?: Node;
+    /** Allocated only for a claimed structural presentation. -1 means publication is in progress. */
+    revision?(): number;
+    ranges?(): ReadonlyMap<Node, BindingHandoffRange>;
+    view?(root: Node): BindingHandoffView | undefined;
+    rest?(element: Element, site: number): BindingHandoffRest | undefined;
+    valid?(): boolean;
+    /** One deferred retry; only structural leases allocate publication listeners. */
+    afterPublication?(callback: () => void): () => void;
+    active(): boolean;
+    retire(publish?: () => void): void;
+    owner?: object;
+}
+export interface BindingHandoffCapability {
+    [BINDING_HANDOFF](): BindingHandoff;
+}
+/** @internal Reuse the adapter's native listener lifetime; no renderer dependency. */
+export declare function registerBindingEvent(node: Node, type: string): () => void;
+/** @internal Called only by a host explicitly acquiring bindingLeases. */
+export declare function claimBindingHandoff(lease: BindingHandoff, owner: object): void;
+/** @internal Releasing a pending claim does not dispose the early presentation. */
+export declare function releaseBindingHandoff(lease: BindingHandoff): void;
+/** @internal Native adapters work before the host imports its renderer. */
+export declare function hasBindingHandoffEvent(event: Event): boolean;
+/** @internal A synchronous takeover must not redeliver the original native command. */
+export declare function markBindingEvent(event: Event, node: Node, capture: boolean): void;
+/** @internal Consume only this node/phase, preserving unrelated ancestor handlers. */
+export declare function consumeBindingEvent(event: Event, node: Node, capture: boolean): boolean;
+/** @internal The renderer's outermost native capture observer starts each dispatch. */
+export declare function beginBindingEvent(event: Event): void;

package/dist/dom-binding-handoff.js

@@ -0,0 +1,62 @@
+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);
+}
+export {
+  BINDING_HANDOFF,
+  beginBindingEvent,
+  claimBindingHandoff,
+  consumeBindingEvent,
+  hasBindingHandoffEvent,
+  markBindingEvent,
+  registerBindingEvent,
+  releaseBindingHandoff
+};