octane 0.2.12 → 0.2.13

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

@@ -0,0 +1,15 @@
+import { type BindingOperation, type BindingValue } from './dom-bindings.js';
+import type { BindingPreparedValue } from './dom-binding-signals.js';
+export type BindingProjectionGroup = readonly (readonly [index: number, field: string])[];
+export interface BindingProjectionConnection {
+    readonly group: BindingProjectionGroup;
+    read(compute: unknown): BindingValue[];
+    get(): BindingValue[];
+    preview(compute: unknown): BindingPreparedValue<BindingValue[]>;
+    writeStyle(index: number, value: BindingValue): void;
+    dispose(preservePresentation?: boolean): void;
+}
+/** Optional, view-owned projections share a read and prepare every field before any write. */
+export declare function __createBindingProjections(): {
+    connect(group: BindingProjectionGroup, bindings: readonly BindingOperation[], nodes: readonly Node[], notify: () => void, restoreStyles?: boolean): BindingProjectionConnection;
+};

package/dist/dom-binding-projections.js

@@ -0,0 +1,187 @@
+import { __normalizeBinding } from "./dom-bindings.js";
+import { __createBindingStyles, __prepareBindingSources } from "./dom-binding-styles.js";
+import { captureSignalOwner, currentSignalOwner } from "./signals/owner-context.js";
+import {
+  beginNativeWriteGuard,
+  endNativeWriteGuard,
+  forwardNativeTransitionConsumer,
+  setNativeReadObserver
+} from "./signals/read-protocol.js";
+function __createBindingProjections() {
+  const owner = currentSignalOwner();
+  const run = owner === null ? (callback) => callback() : captureSignalOwner(owner);
+  const styles = __createBindingStyles();
+  return {
+    connect(group, bindings, nodes, notify, restoreStyles = false) {
+      let compute;
+      let disposed = false;
+      const subscriptions = /* @__PURE__ */ new Map();
+      const styleConnections = /* @__PURE__ */ new Map();
+      const get = () => {
+        if (disposed) return [];
+        const reads = /* @__PURE__ */ new Map();
+        const previousObserver = setNativeReadObserver((source, version) => {
+          if (!reads.has(source)) reads.set(source, version);
+          previousObserver?.(source, version);
+        });
+        const guard = beginNativeWriteGuard();
+        const values = [];
+        try {
+          run(() => {
+            const result = compute();
+            for (const [index, field] of group) {
+              if (disposed) break;
+              const binding = bindings[index];
+              const value = result?.[field];
+              if (binding[1] === "styleObject") {
+                let style = styleConnections.get(index);
+                if (!style) {
+                  style = styles.connect(nodes[binding[0]], notify, restoreStyles);
+                  styleConnections.set(index, style);
+                }
+                values[index] = style.read(value);
+              } else values[index] = __normalizeBinding(binding, value);
+            }
+          });
+        } finally {
+          endNativeWriteGuard(guard);
+          setNativeReadObserver(previousObserver);
+        }
+        for (const [source, stop] of subscriptions) {
+          if (reads.has(source)) continue;
+          subscriptions.delete(source);
+          stop();
+        }
+        for (const [source, version] of reads) {
+          if (disposed) break;
+          if (!subscriptions.has(source)) {
+            let active = true;
+            const stop = run(
+              () => source.subscribe(
+                forwardNativeTransitionConsumer(notify, () => {
+                  if (active && !disposed) notify();
+                })
+              )
+            );
+            if (typeof stop !== "function")
+              throw new TypeError("A DOM projection subscription must return cleanup.");
+            const cleanup = () => {
+              active = false;
+              stop();
+            };
+            if (disposed) cleanup();
+            else subscriptions.set(source, cleanup);
+          }
+          if (!disposed && source.getVersion() !== version) notify();
+        }
+        return values;
+      };
+      return {
+        group,
+        get,
+        preview(next) {
+          if (typeof next !== "function")
+            throw new TypeError("A DOM binding projection group requires a computation.");
+          const reads = /* @__PURE__ */ new Map();
+          const preparedStyles = [];
+          const createdStyles = /* @__PURE__ */ new Map();
+          const values = [];
+          const previousObserver = setNativeReadObserver((source, version) => {
+            if (!reads.has(source)) reads.set(source, version);
+            previousObserver?.(source, version);
+          });
+          const guard = beginNativeWriteGuard();
+          try {
+            run(() => {
+              const result = next();
+              for (const [index, field] of group) {
+                const binding = bindings[index];
+                const value = result?.[field];
+                if (binding[1] === "styleObject") {
+                  let style = styleConnections.get(index);
+                  if (!style) {
+                    style = styles.connect(nodes[binding[0]], notify, restoreStyles);
+                    createdStyles.set(index, style);
+                  }
+                  const prepared2 = style.preview(value);
+                  preparedStyles.push(prepared2);
+                  values[index] = prepared2.value;
+                } else values[index] = __normalizeBinding(binding, value);
+              }
+            });
+          } catch (error) {
+            for (const prepared2 of preparedStyles) prepared2.discard();
+            for (const style of createdStyles.values()) style.dispose(true);
+            throw error;
+          } finally {
+            endNativeWriteGuard(guard);
+            setNativeReadObserver(previousObserver);
+          }
+          let prepared;
+          try {
+            prepared = __prepareBindingSources(reads, subscriptions, notify, () => !disposed, run);
+          } catch (error) {
+            for (const style of preparedStyles) style.discard();
+            for (const style of createdStyles.values()) style.dispose(true);
+            throw error;
+          }
+          let accepted = false;
+          return {
+            value: values,
+            validate: () => prepared.validate() && preparedStyles.every((style) => style.validate()),
+            commit() {
+              accepted = true;
+              compute = next;
+              for (const [index, style] of createdStyles) styleConnections.set(index, style);
+              for (const style of preparedStyles) style.commit();
+              prepared.commit();
+            },
+            discard() {
+              if (accepted) return;
+              prepared.discard();
+              for (const style of preparedStyles) style.discard();
+              for (const style of createdStyles.values()) style.dispose(true);
+            }
+          };
+        },
+        read(next) {
+          if (typeof next !== "function")
+            throw new TypeError("A DOM binding projection group requires a computation.");
+          compute = next;
+          return get();
+        },
+        writeStyle(index, value) {
+          if (!disposed) styleConnections.get(index).write(value);
+        },
+        dispose(preservePresentation) {
+          if (disposed) return;
+          disposed = true;
+          compute = void 0;
+          let failed = false;
+          let failure;
+          for (const cleanup of [
+            ...subscriptions.values(),
+            ...[...styleConnections.values()].map(
+              (style) => () => style.dispose(preservePresentation)
+            )
+          ]) {
+            try {
+              cleanup();
+            } catch (error) {
+              if (!failed) {
+                failed = true;
+                failure = error;
+              }
+            }
+          }
+          subscriptions.clear();
+          styleConnections.clear();
+          if (failed) throw failure;
+        }
+      };
+    }
+  };
+}
+export {
+  __createBindingProjections
+};

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

@@ -0,0 +1,13 @@
+/** Compiler-owned DOM presentation markers. This leaf is shared by client and SSR. */
+export type BindingKey = string | number;
+export declare function encodeBindingKey(key: BindingKey): string;
+export declare function decodeBindingKey(encoded: string): BindingKey;
+export interface BindingMarker {
+    id: string;
+    site: string;
+    kind: 'root' | 'if' | 'for' | 'item' | 'text' | 'view' | 'slot' | 'opaque';
+    arm?: number;
+    key?: string;
+}
+export declare function parseBindingMarker(data: string): BindingMarker | null;
+export declare function isBindingOpenComment(data: string): boolean;

package/dist/dom-binding-protocol.js

@@ -0,0 +1,88 @@
+function encodeBindingKey(key) {
+  if (typeof key === "string")
+    return "s:" + JSON.stringify(key).replace(/-/g, "\\u002d").replace(/</g, "\\u003c");
+  if (typeof key === "number" && Number.isFinite(key)) return "n:" + String(key);
+  throw new TypeError("A DOM presentation key must be a string or finite number.");
+}
+function decodeBindingKey(encoded) {
+  let key;
+  try {
+    key = JSON.parse(encoded.slice(2));
+  } catch {
+    throw new TypeError("A DOM presentation key has invalid serialized identity.");
+  }
+  if (encoded.startsWith("s:") && typeof key === "string" || encoded.startsWith("n:") && typeof key === "number" && Number.isFinite(key)) {
+    if (encodeBindingKey(key) === encoded) return key;
+  }
+  throw new TypeError("A DOM presentation key has invalid serialized identity.");
+}
+function parseBindingMarker(data) {
+  if (data.startsWith("[f0;b;") || data.startsWith("[f1;b;")) {
+    const separator = data.indexOf(";", 6);
+    if (separator <= 6 || separator === data.length - 1) return null;
+    return {
+      id: data.slice(6, separator),
+      site: data.slice(separator + 1),
+      kind: "for",
+      arm: data.charCodeAt(2) - 48
+    };
+  }
+  if (!data.startsWith("[b;")) return null;
+  const idEnd = data.indexOf(";", 3);
+  if (idEnd <= 3 || idEnd === data.length - 1) return null;
+  const id = data.slice(3, idEnd);
+  if (data.slice(idEnd + 1) === "root") return { id, site: "root", kind: "root" };
+  const siteEnd = data.indexOf(";", idEnd + 1);
+  if (siteEnd <= idEnd + 1 || siteEnd === data.length - 1) return null;
+  const site = data.slice(idEnd + 1, siteEnd);
+  const kind = data.slice(siteEnd + 1);
+  if (kind === "t") return { id, site, kind: "text" };
+  if (kind === "v") return { id, site, kind: "view" };
+  if (kind === "s") return { id, site, kind: "slot" };
+  if (kind === "o") return { id, site, kind: "opaque" };
+  if (kind.startsWith("k;")) {
+    const key = kind.slice(2);
+    try {
+      decodeBindingKey(key);
+    } catch {
+      return null;
+    }
+    return { id, site, kind: "item", key };
+  }
+  if (/^(?:-1|0|[1-9]\d*)$/.test(kind)) {
+    const arm = Number(kind);
+    if (Number.isSafeInteger(arm)) return { id, site, kind: "if", arm };
+  }
+  return null;
+}
+function isBindingOpenComment(data) {
+  const list = data.startsWith("[f0;b;") || data.startsWith("[f1;b;");
+  if (!list && !data.startsWith("[b;")) return false;
+  const idStart = list ? 6 : 3;
+  const idEnd = data.indexOf(";", idStart);
+  if (idEnd <= idStart || idEnd === data.length - 1) return false;
+  if (list) return data.indexOf(";", idEnd + 1) === -1;
+  if (data.length - idEnd === 5 && data.endsWith(";root")) return true;
+  const siteEnd = data.indexOf(";", idEnd + 1);
+  if (siteEnd <= idEnd + 1 || siteEnd === data.length - 1) return false;
+  const tail = siteEnd + 1;
+  if (data.length === tail + 1) {
+    const code = data.charCodeAt(tail);
+    return code === 116 || code === 118 || code === 115 || code === 111 || code >= 48 && code <= 57;
+  }
+  if (data.charCodeAt(tail) === 107 && data.charCodeAt(tail + 1) === 59)
+    return (data.charCodeAt(tail + 2) === 115 || data.charCodeAt(tail + 2) === 110) && data.charCodeAt(tail + 3) === 58 && data.length > tail + 4;
+  if (data.length === tail + 2 && data.endsWith("-1")) return true;
+  if (data.charCodeAt(tail) < 49 || data.charCodeAt(tail) > 57) return false;
+  for (let index = tail + 1; index < data.length; index++) {
+    const code = data.charCodeAt(index);
+    if (code < 48 || code > 57) return false;
+  }
+  return true;
+}
+export {
+  decodeBindingKey,
+  encodeBindingKey,
+  isBindingOpenComment,
+  parseBindingMarker
+};

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

@@ -0,0 +1,21 @@
+import { type NativeTransitionPresentation } from './signals/read-protocol.js';
+import { type SignalHandle } from './signals/types.js';
+export interface BindingSignalConnection {
+    /** Resolve and observe a projected handle, or disconnect for an ordinary value. */
+    read(value: unknown): unknown;
+    /** Read only the already connected channel; never reevaluate the authored projection. */
+    get(): unknown;
+    /** Prepare a different projection without replacing the currently published lease. */
+    preview(value: unknown): BindingPreparedValue;
+    /** Optional whole-style writer, present only on the selected style capability. */
+    write?(value: unknown): void;
+    dispose(preservePresentation?: boolean): void;
+}
+export interface BindingPreparedValue<T = unknown> extends NativeTransitionPresentation {
+    readonly value: T;
+}
+/** @internal Query-selected capability; captures the existing owner, never creates a graph. */
+export declare function __createBindingSignals(): {
+    isSignal: (value: unknown) => value is SignalHandle<unknown>;
+    connect(notify: () => void): BindingSignalConnection;
+};

package/dist/dom-binding-signals.js

@@ -0,0 +1,109 @@
+import { captureSignalOwner, currentSignalOwner } from "./signals/owner-context.js";
+import {
+  forwardNativeTransitionConsumer
+} from "./signals/read-protocol.js";
+import {
+  SIGNAL_HANDLE,
+  SIGNAL_BINDING_READ,
+  SIGNAL_BINDING_SUBSCRIBE
+} from "./signals/types.js";
+function __createBindingSignals() {
+  const owner = currentSignalOwner();
+  const run = owner === null ? (callback) => callback() : captureSignalOwner(owner);
+  const isSignal = (value) => value !== null && (typeof value === "object" || typeof value === "function") && value[SIGNAL_HANDLE] === true;
+  return {
+    isSignal,
+    connect(notify) {
+      let value;
+      let handle;
+      let unsubscribe;
+      let generation = 0;
+      let disposed = false;
+      const get = () => disposed ? void 0 : handle ? run(() => handle[SIGNAL_BINDING_READ]()) : value;
+      const dispose = () => {
+        if (disposed) return;
+        disposed = true;
+        generation++;
+        handle = void 0;
+        const stop = unsubscribe;
+        unsubscribe = void 0;
+        stop?.();
+      };
+      return {
+        get,
+        dispose,
+        preview(next) {
+          const nextHandle = isSignal(next) ? next : void 0;
+          const ticket = generation;
+          const projected = nextHandle ? run(() => nextHandle[SIGNAL_BINDING_READ]()) : next;
+          let accepted = false;
+          let retired = false;
+          let invalid = false;
+          let acceptedGeneration = ticket;
+          const stopNext = nextHandle && nextHandle !== handle ? run(
+            () => nextHandle[SIGNAL_BINDING_SUBSCRIBE](
+              forwardNativeTransitionConsumer(notify, () => {
+                if (retired || disposed) return;
+                if (!accepted) invalid = true;
+                else if (generation === acceptedGeneration) notify();
+              })
+            )
+          ) : void 0;
+          return {
+            value: projected,
+            validate: () => !retired && !invalid && !disposed && generation === ticket,
+            commit() {
+              if (retired || accepted || disposed) return;
+              accepted = true;
+              value = next;
+              if (nextHandle === handle) return;
+              const stop = unsubscribe;
+              acceptedGeneration = ++generation;
+              handle = nextHandle;
+              unsubscribe = stopNext;
+              stop?.();
+            },
+            discard() {
+              if (accepted || retired) return;
+              retired = true;
+              stopNext?.();
+            }
+          };
+        },
+        read(next) {
+          if (disposed) return void 0;
+          const nextHandle = isSignal(next) ? next : void 0;
+          if (nextHandle !== handle) {
+            const ticket = ++generation;
+            const stop = unsubscribe;
+            unsubscribe = void 0;
+            handle = void 0;
+            stop?.();
+            if (disposed) return void 0;
+            handle = nextHandle;
+            if (handle) {
+              if (typeof handle[SIGNAL_BINDING_READ] !== "function" || typeof handle[SIGNAL_BINDING_SUBSCRIBE] !== "function")
+                throw new TypeError("A DOM binding signal requires the native binding protocol.");
+              const stopNext = run(
+                () => handle[SIGNAL_BINDING_SUBSCRIBE](
+                  forwardNativeTransitionConsumer(notify, () => {
+                    if (!disposed && ticket === generation) notify();
+                  })
+                )
+              );
+              if (typeof stopNext !== "function")
+                throw new TypeError("A DOM binding signal subscription must return cleanup.");
+              if (disposed || ticket !== generation) stopNext();
+              else unsubscribe = stopNext;
+            }
+          }
+          value = next;
+          return get();
+        }
+      };
+    }
+  };
+}
+export {
+  __createBindingSignals
+};

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

@@ -0,0 +1,17 @@
+import { type BindingValue } from './dom-bindings.js';
+import type { BindingSignalConnection } from './dom-binding-signals.js';
+import { type NativeReadSource, type NativeTransitionPresentation } from './signals/read-protocol.js';
+/** Acquire prospective graph leases before releasing any published subscription. */
+export declare function __prepareBindingSources(reads: Map<NativeReadSource, number>, subscriptions: Map<NativeReadSource, () => void>, notify: () => void, active: () => boolean, run: <T>(callback: () => T) => T): NativeTransitionPresentation;
+/** Canonical style values after native handles and CSS units have been resolved. */
+export type BindingStyleSnapshot = Readonly<Record<string, string | null>>;
+/** Shared preparation keeps native style projections on the canonical CSS rules. */
+export declare function __normalizeBindingStyle(value: unknown): BindingValue;
+/**
+ * Query-selected whole-style capability. Native source subscriptions belong to
+ * this binding lifetime; the existing graph and canonical style reader own all
+ * signal semantics. Fixed-property artifacts never import this module.
+ */
+export declare function __createBindingStyles(): {
+    connect(node: Element, notify: () => void, restoreStyles?: boolean): BindingSignalConnection;
+};