octane 0.2.12 → 0.2.13

package/dist/server/signal-query-observation.js

@@ -0,0 +1,134 @@
+class StreamAttemptMirror {
+  constructor(releaseObservation) {
+    this.releaseObservation = releaseObservation;
+  }
+  releaseObservation;
+  pending;
+  queued;
+  hasQueued = false;
+  acknowledgement;
+  terminal;
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  next() {
+    if (this.pending !== void 0) {
+      return Promise.reject(new TypeError("A streamed signal result permits one pending read."));
+    }
+    this.acknowledgement?.();
+    this.acknowledgement = void 0;
+    if (this.hasQueued) {
+      this.hasQueued = false;
+      const value = this.queued;
+      this.queued = void 0;
+      return Promise.resolve({ done: false, value });
+    }
+    if (this.terminal !== void 0) {
+      return this.terminal.kind === "complete" ? Promise.resolve({ done: true, value: void 0 }) : Promise.reject(this.terminal.error);
+    }
+    return new Promise((resolve, reject) => {
+      this.pending = { resolve, reject };
+    });
+  }
+  return() {
+    this.releaseObservation();
+    return Promise.resolve({ done: true, value: void 0 });
+  }
+  publish(value) {
+    if (this.terminal !== void 0) return Promise.resolve();
+    const acknowledgement = new Promise((resolve) => {
+      this.acknowledgement = resolve;
+    });
+    if (this.pending !== void 0) {
+      const pending = this.pending;
+      this.pending = void 0;
+      pending.resolve({ done: false, value });
+    } else {
+      this.queued = value;
+      this.hasQueued = true;
+    }
+    return acknowledgement;
+  }
+  complete() {
+    if (this.terminal !== void 0) return;
+    this.terminal = { kind: "complete" };
+    this.queued = void 0;
+    this.hasQueued = false;
+    this.acknowledgement?.();
+    this.acknowledgement = void 0;
+    this.pending?.resolve({ done: true, value: void 0 });
+    this.pending = void 0;
+  }
+  fail(error) {
+    if (this.terminal !== void 0) return;
+    this.terminal = { kind: "error", error };
+    this.queued = void 0;
+    this.hasQueued = false;
+    this.acknowledgement?.();
+    this.acknowledgement = void 0;
+    this.pending?.reject(error);
+    this.pending = void 0;
+  }
+}
+class QueryAttemptObservations {
+  observations = /* @__PURE__ */ new Set();
+  observe(context, source) {
+    let observation;
+    const release = () => this.release(observation);
+    const mirror = source.kind === "stream" ? new StreamAttemptMirror(release) : void 0;
+    observation = { controller: new AbortController(), mirror };
+    this.observations.add(observation);
+    try {
+      context.observe({
+        ownerKey: context.owner.documentOwner.scopeKey,
+        instanceKey: context.owner.instanceKey,
+        nodeKey: source.nodeKey,
+        selectionKey: source.selectionKey,
+        attempt: source.attempt,
+        kind: source.kind,
+        result: mirror ?? source.result,
+        signal: observation.controller.signal,
+        isCurrent: () => source.isCurrent() && this.observations.has(observation),
+        release
+      });
+    } catch (error) {
+      release();
+      throw error;
+    }
+  }
+  release(observation) {
+    if (!this.observations.delete(observation)) return;
+    observation.mirror?.complete();
+    observation.controller.abort();
+  }
+  retire() {
+    for (const observation of this.observations) {
+      observation.mirror?.fail(
+        new DOMException("The signal query attempt was replaced.", "AbortError")
+      );
+      observation.controller.abort();
+    }
+    this.observations.clear();
+  }
+  complete() {
+    for (const observation of this.observations) observation.mirror?.complete();
+  }
+  fail(error) {
+    for (const observation of this.observations) observation.mirror?.fail(error);
+  }
+  publish(value) {
+    let pending;
+    for (const observation of this.observations) {
+      if (observation.mirror === void 0) continue;
+      (pending ??= []).push(observation.mirror.publish(value));
+    }
+    return pending === void 0 ? void 0 : Promise.all(pending).then(() => {
+    });
+  }
+}
+function createServerSignalQueryAttemptObservations() {
+  return new QueryAttemptObservations();
+}
+export {
+  createServerSignalQueryAttemptObservations
+};

package/dist/server/streamed-region.d.ts

@@ -0,0 +1,15 @@
+import type { RenderResult } from '../runtime.server.js';
+import { type StreamFrameIdentity, type StreamedRegionPlacementFrame } from '../streamed-signals-protocol.js';
+export interface StreamedRegionPlacementOptions {
+    readonly sequence: number;
+    readonly contentRevision: number;
+    /** Completed-build stylesheet URLs; the receiver waits for them before reveal. */
+    readonly styles?: readonly string[];
+}
+/**
+ * Package a completed renderer snapshot for an explicitly registered dormant
+ * region. Render under the region's request owner; never reuse cached response
+ * HTML with a different document, owner, or selection envelope. Cache source
+ * data instead. The current protocol admits one data owner per region.
+ */
+export declare function createStreamedRegionPlacementFrame(identity: StreamFrameIdentity, rendered: RenderResult, options: StreamedRegionPlacementOptions): StreamedRegionPlacementFrame;

package/dist/server/streamed-region.js

@@ -0,0 +1,30 @@
+import {
+  isStreamedRendererFrame
+} from "../streamed-signals-protocol.js";
+function createStreamedRegionPlacementFrame(identity, rendered, options) {
+  const scopes = rendered.signals?.scopes;
+  if (scopes?.length !== 1 || scopes[0].scopeKey !== identity.ownerKey) {
+    throw new TypeError("A streamed region requires the exact historical signal owner.");
+  }
+  if (rendered.head) {
+    throw new TypeError("A streamed region cannot replace document head metadata.");
+  }
+  const frame = {
+    identity: { ...identity },
+    sequence: options.sequence,
+    channel: "placement",
+    kind: "html",
+    contentRevision: options.contentRevision,
+    mode: "full",
+    // Scoped CSS is part of the same atomic candidate and precedes its users.
+    // The outer pair belongs to the receiver, not to the component's layout.
+    html: "<!--[-->" + rendered.css + rendered.html + "<!--]-->",
+    historicalFrame: scopes[0],
+    styles: options.styles === void 0 ? [] : [...options.styles]
+  };
+  if (!isStreamedRendererFrame(frame)) throw new TypeError("Invalid streamed region snapshot.");
+  return frame;
+}
+export {
+  createStreamedRegionPlacementFrame
+};

package/dist/server/streamed-signals.d.ts

@@ -0,0 +1,45 @@
+import { type StreamedRendererFrame, type StreamedSignalResultFrame, type StreamFrameIdentity } from '../streamed-signals-protocol.js';
+import type { StreamInjectionSource } from '../runtime.server.js';
+import type { ServerSignalQueryAttempt } from '../signals/query-attempt-observer.js';
+export interface StreamedRendererLimits {
+    readonly maxFrameBytes?: number;
+    readonly maxTotalBytes?: number;
+    readonly timeoutMs?: number;
+}
+export interface StreamedSignalResultOptions extends StreamedRendererLimits {
+    readonly signal?: AbortSignal;
+    /** Re-enter the captured server request owner for lazy iterator pulls. */
+    readonly run?: <T>(callback: () => T) => T;
+    /** @internal Initial-document authority announcement before result frames. */
+    readonly announceSelection?: boolean;
+}
+export interface AutomaticStreamedSignalOptions extends StreamedRendererLimits {
+    readonly buildId: string;
+    readonly documentId: string;
+    readonly selectionGeneration?: number;
+    readonly nonce?: string;
+}
+export interface AutomaticStreamedSignalInjection extends StreamInjectionSource {
+    observeSignalAttempt(attempt: ServerSignalQueryAttempt, run?: <T>(callback: () => T) => T): void;
+}
+/** Produce the authoritative result-channel grammar without exposing server errors. */
+export declare function createStreamedSignalResultFrames(identity: StreamFrameIdentity, result: unknown, options?: Pick<StreamedSignalResultOptions, 'signal' | 'run'>): AsyncGenerator<StreamedSignalResultFrame>;
+/** Demand-driven newline-delimited transport for later fetched SSR regions/results. */
+export declare function createStreamedRendererFrameStream(frames: AsyncIterable<StreamedRendererFrame>, options?: StreamedRendererLimits & {
+    signal?: AbortSignal;
+}): ReadableStream<Uint8Array>;
+/** Serialize one validated frame for an already-installed pre-module receiver. */
+export declare function streamedRendererFrameScript(frame: StreamedRendererFrame, nonce?: string): string;
+/**
+ * Adapt one signal result to renderTo*Stream's external injection channel.
+ * The producer advances only after the renderer confirms the prior injected
+ * script reached its transport sink.
+ */
+export declare function createStreamedSignalInjection(identity: StreamFrameIdentity, result: unknown, options?: StreamedSignalResultOptions & {
+    nonce?: string;
+}): StreamInjectionSource;
+/**
+ * Multiplex every query attempt discovered by one SSR render into the same
+ * backpressure-aware pre-module result channel.
+ */
+export declare function createAutomaticStreamedSignalInjection(options: AutomaticStreamedSignalOptions, external?: StreamInjectionSource): AutomaticStreamedSignalInjection;