octane 0.2.12 → 0.2.13

package/dist/hydration/stream-result-receiver.d.ts

@@ -0,0 +1,70 @@
+import { type StreamedRegionPlacementFrame, type StreamedSignalResultFrame, type StreamFrameIdentity } from '../streamed-signals-protocol.js';
+import type { HistoricalFrameLease, StreamedRegionRegistration } from './stream-receiver.js';
+export interface StreamedResultConsumer {
+    /** False defers this validated frame; reattaching the same consumer retries its bounded mailbox. */
+    accept(frame: StreamedSignalResultFrame): void | false;
+    /** True transfers this bounded completed mailbox to consumer-owned retention, without publishing it. */
+    retainCompleted?(frames: StreamedSignalResultFrame[]): boolean;
+    fail(error: StreamedReceiverError): void;
+}
+export interface StreamedResultReceiverOptions {
+    readonly buildId: string;
+    readonly documentId: string;
+    readonly ownerKey: string;
+    readonly maxPendingFrames?: number;
+    readonly maxPendingBytes?: number;
+    readonly pendingTimeoutMs?: number;
+    readonly onError?: (error: StreamedReceiverError) => void;
+}
+export type StreamedFrameDisposition = 'accepted' | 'stale';
+export declare class StreamedReceiverError extends Error {
+    readonly code: 'identity' | 'sequence' | 'protocol' | 'overflow' | 'timeout' | 'terminal' | 'styles' | 'historical-frame' | 'placement';
+    constructor(code: 'identity' | 'sequence' | 'protocol' | 'overflow' | 'timeout' | 'terminal' | 'styles' | 'historical-frame' | 'placement', message: string);
+}
+interface ResultState {
+    sequence: number;
+    opened: boolean;
+    resource?: 'promise' | 'stream';
+    values: number;
+    terminal: boolean;
+    frames: StreamedSignalResultFrame[];
+    bytes: number;
+    consumer?: StreamedResultConsumer;
+    timer?: ReturnType<typeof setTimeout>;
+    failure?: StreamedReceiverError;
+}
+export interface StreamedSelectionState {
+    identity: StreamFrameIdentity;
+    result: ResultState;
+    placementSequence: number;
+    contentRevision: number;
+    region?: StreamedRegionRegistration;
+    historical?: HistoricalFrameLease;
+    pendingPlacement?: {
+        cancel(): void;
+    };
+    failure?: StreamedReceiverError;
+}
+export interface StreamedResultReceiver {
+    registerSelection(identity: StreamFrameIdentity, contentRevision?: number): void;
+    attachResult(identity: StreamFrameIdentity, consumer: StreamedResultConsumer): () => void;
+    receive(frame: unknown): Promise<StreamedFrameDisposition>;
+    receiveJson(json: string): Promise<StreamedFrameDisposition>;
+    /** Fail only the exact current selection; false means stale or already failed. */
+    failSelection(identity: StreamFrameIdentity, error: StreamedReceiverError): boolean;
+    dispose(): void;
+}
+/**
+ * Accept streamed results without HTML placement. Valid unregistered placement
+ * frames still advance their sequence and return stale, as on the full receiver.
+ */
+export declare function createStreamedResultReceiver(options: StreamedResultReceiverOptions): StreamedResultReceiver;
+/**
+ * Internal static seam: the full receiver supplies DOM placement while both
+ * variants retain the same selection, result, failure and cleanup authority.
+ */
+export declare function createStreamedResultReceiverState(options: StreamedResultReceiverOptions, commitPlacement?: (state: StreamedSelectionState, frame: StreamedRegionPlacementFrame, isCurrent: (state: StreamedSelectionState, identity: StreamFrameIdentity) => boolean) => Promise<StreamedFrameDisposition>): {
+    receiver: StreamedResultReceiver;
+    current: (identity: StreamFrameIdentity) => StreamedSelectionState | undefined;
+};
+export {};

package/dist/hydration/stream-result-receiver.js

@@ -0,0 +1,246 @@
+import {
+  decodeStreamedRendererFrame,
+  isStreamedRendererFrame,
+  sameStreamFrameIdentity
+} from "../streamed-signals-protocol.js";
+class StreamedReceiverError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "StreamedReceiverError";
+  }
+  code;
+}
+function retainCompletedResult(result) {
+  if (result.frames.at(-1)?.kind === "complete" && result.consumer?.retainCompleted?.(result.frames) === true) {
+    result.frames = [];
+    result.bytes = 0;
+  }
+}
+const DEFAULT_PENDING_FRAMES = 64;
+const DEFAULT_PENDING_BYTES = 1024 * 1024;
+const DEFAULT_PENDING_TIMEOUT = 3e4;
+function counter(value, fallback) {
+  const result = value ?? fallback;
+  if (!Number.isSafeInteger(result) || result <= 0) {
+    throw new RangeError("Stream receiver limits must be positive safe integers.");
+  }
+  return result;
+}
+function slotKey(identity) {
+  return JSON.stringify([identity.instanceKey, identity.nodeKey]);
+}
+function frameBytes(frame) {
+  return new TextEncoder().encode(JSON.stringify(frame)).byteLength;
+}
+function createStreamedResultReceiver(options) {
+  return createStreamedResultReceiverState(options).receiver;
+}
+function createStreamedResultReceiverState(options, commitPlacement) {
+  const maxFrames = counter(options.maxPendingFrames, DEFAULT_PENDING_FRAMES);
+  const maxBytes = counter(options.maxPendingBytes, DEFAULT_PENDING_BYTES);
+  const timeoutMs = counter(options.pendingTimeoutMs, DEFAULT_PENDING_TIMEOUT);
+  const selections = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const report = (error, state) => {
+    if (state !== void 0) {
+      if (state.failure !== void 0) return;
+      state.failure = error;
+      state.pendingPlacement?.cancel();
+      if (!state.result.terminal) {
+        state.result.failure = error;
+        try {
+          state.result.consumer?.fail(error);
+        } catch {
+        }
+        state.result.frames.length = 0;
+        state.result.bytes = 0;
+      }
+      if (state.result.timer !== void 0) clearTimeout(state.result.timer);
+      state.result.terminal = true;
+    }
+    options.onError?.(error);
+  };
+  const current = (identity) => {
+    if (identity.buildId !== options.buildId || identity.documentId !== options.documentId || identity.ownerKey !== options.ownerKey) {
+      return;
+    }
+    const state = selections.get(slotKey(identity));
+    return state !== void 0 && sameStreamFrameIdentity(state.identity, identity) ? state : void 0;
+  };
+  const isCurrent = (state, identity) => !disposed && state.failure === void 0 && current(identity) === state;
+  const registerSelection = (identity, contentRevision = 0) => {
+    if (!isStreamedRendererFrame({
+      identity,
+      sequence: 0,
+      channel: "result",
+      kind: "complete"
+    })) {
+      throw new StreamedReceiverError("identity", "Invalid streamed selection identity.");
+    }
+    if (identity.buildId !== options.buildId || identity.documentId !== options.documentId || identity.ownerKey !== options.ownerKey || !Number.isSafeInteger(contentRevision) || contentRevision < 0) {
+      throw new StreamedReceiverError("identity", "Streamed selection has the wrong authority.");
+    }
+    const key = slotKey(identity);
+    const previous = selections.get(key);
+    if (previous !== void 0) {
+      previous.pendingPlacement?.cancel();
+      if (previous.result.timer !== void 0) clearTimeout(previous.result.timer);
+      previous.historical?.release();
+    }
+    const state = {
+      identity,
+      result: { sequence: 0, opened: false, values: 0, terminal: false, frames: [], bytes: 0 },
+      placementSequence: 0,
+      contentRevision
+    };
+    selections.set(key, state);
+    state.result.timer = setTimeout(() => {
+      report(new StreamedReceiverError("timeout", "Streamed result timed out."), state);
+    }, timeoutMs);
+  };
+  const attachResult = (identity, consumer) => {
+    const state = current(identity);
+    if (state === void 0) {
+      throw new StreamedReceiverError("identity", "Cannot attach a result to a stale selection.");
+    }
+    if (state.result.consumer !== void 0 && state.result.consumer !== consumer) {
+      throw new StreamedReceiverError("identity", "A streamed result already has a consumer.");
+    }
+    state.result.consumer = consumer;
+    if (state.result.failure !== void 0) {
+      consumer.fail(state.result.failure);
+      return () => {
+        if (state.result.consumer === consumer) state.result.consumer = void 0;
+      };
+    }
+    let accepted = 0;
+    try {
+      for (const frame of state.result.frames) {
+        if (consumer.accept(frame) === false) break;
+        accepted++;
+      }
+    } finally {
+      if (accepted === state.result.frames.length) state.result.bytes = 0;
+      else {
+        for (let index = 0; index < accepted; index++) {
+          state.result.bytes -= frameBytes(state.result.frames[index]);
+        }
+      }
+      state.result.frames.splice(0, accepted);
+    }
+    retainCompletedResult(state.result);
+    return () => {
+      if (state.result.consumer === consumer) state.result.consumer = void 0;
+    };
+  };
+  const receiveResult = (state, frame) => {
+    const result = state.result;
+    if (result.terminal || frame.sequence !== result.sequence) {
+      throw new StreamedReceiverError("sequence", "Invalid or duplicate streamed result sequence.");
+    }
+    result.sequence++;
+    if (!result.opened) {
+      if (frame.kind !== "open") {
+        throw new StreamedReceiverError("terminal", "A streamed result must begin with open.");
+      }
+      result.opened = true;
+      result.resource = frame.resource;
+    } else if (frame.kind === "open") {
+      throw new StreamedReceiverError("terminal", "A streamed result cannot open twice.");
+    } else if (frame.kind === "value") {
+      result.values++;
+      if (result.resource === "promise" && result.values > 1) {
+        throw new StreamedReceiverError(
+          "terminal",
+          "A promise result emitted more than one value."
+        );
+      }
+    } else {
+      if (frame.kind === "complete" && result.resource === "promise" && result.values !== 1) {
+        throw new StreamedReceiverError(
+          "terminal",
+          "A promise result completed without one value."
+        );
+      }
+    }
+    if (result.consumer === void 0 || result.frames.length !== 0 || result.consumer.accept(frame) === false) {
+      const bytes = frameBytes(frame);
+      if (result.frames.length + 1 > maxFrames || result.bytes + bytes > maxBytes) {
+        throw new StreamedReceiverError("overflow", "Streamed result mailbox exceeded its bound.");
+      }
+      result.frames.push(frame);
+      result.bytes += bytes;
+    }
+    if (frame.kind === "complete" || frame.kind === "error") {
+      result.terminal = true;
+      if (result.timer !== void 0) clearTimeout(result.timer);
+    }
+    if (frame.kind === "complete") retainCompletedResult(result);
+    return "accepted";
+  };
+  const receivePlacement = async (state, frame) => {
+    if (frame.sequence !== state.placementSequence) {
+      throw new StreamedReceiverError("sequence", "Invalid or duplicate placement sequence.");
+    }
+    state.placementSequence++;
+    const registration = state.region;
+    if (registration === void 0 || registration.isActive()) return "stale";
+    if (frame.contentRevision <= state.contentRevision) return "stale";
+    if (frame.mode === "delta" && frame.baseRevision !== state.contentRevision) return "stale";
+    return commitPlacement?.(state, frame, isCurrent) ?? "stale";
+  };
+  const receive = async (value) => {
+    if (disposed) return "stale";
+    if (!isStreamedRendererFrame(value)) {
+      const error = new StreamedReceiverError("protocol", "Malformed streamed renderer frame.");
+      report(error);
+      throw error;
+    }
+    const frame = value;
+    const state = current(frame.identity);
+    if (state === void 0 || state.failure !== void 0) return "stale";
+    try {
+      return frame.channel === "result" ? receiveResult(state, frame) : await receivePlacement(state, frame);
+    } catch (error) {
+      if (disposed || current(frame.identity) !== state) return "stale";
+      const receiverError = error instanceof StreamedReceiverError ? error : new StreamedReceiverError("protocol", "Streamed renderer frame failed.");
+      report(receiverError, state);
+      throw receiverError;
+    }
+  };
+  const receiver = {
+    registerSelection,
+    attachResult,
+    receive,
+    receiveJson(json) {
+      return receive(decodeStreamedRendererFrame(json));
+    },
+    failSelection(identity, error) {
+      if (disposed) return false;
+      const state = current(identity);
+      if (state === void 0 || state.failure !== void 0) return false;
+      report(error, state);
+      return true;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const state of selections.values()) {
+        try {
+          report(new StreamedReceiverError("terminal", "Streamed receiver was disposed."), state);
+        } catch {
+        } finally {
+          state.historical?.release();
+        }
+      }
+      selections.clear();
+    }
+  };
+  return { receiver, current };
+}
+export {
+  StreamedReceiverError,
+  createStreamedResultReceiver,
+  createStreamedResultReceiverState
+};

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

@@ -0,0 +1,44 @@
+import { type NativeSignalManifest } from '../signals/native-read-seeds.js';
+export type { NativeSignalManifest } from '../signals/native-read-seeds.js';
+import type { SignalOwnerIdentity } from '../signals/types.js';
+import { type StreamedRendererDeliveryOptions } from './stream-delivery.js';
+import { type StreamedRegionReceiver } from './stream-receiver.js';
+import { type StreamedResultReceiver } from './stream-result-receiver.js';
+export { installSignalDocumentLifecycle, type SignalDocumentLifecycleOptions, } from './document-lifecycle.js';
+export interface StreamedSignalHydrationOptions extends StreamedRendererDeliveryOptions {
+    readonly buildId: string;
+    readonly documentId: string;
+    /** Custom authority; pass it to hydrateRoot or use runWithSignalOwner in behavior callbacks. */
+    readonly signalOwner?: SignalOwnerIdentity;
+    /**
+     * Initial-response data only. Install once, before live signal access or stream
+     * attachment. Only the document scope is initialized; instance snapshots stay
+     * historical. A failed join retires newly initialized authority rather than
+     * rolling state back. The caller supplies the matching build/document identity.
+     */
+    readonly initialSignals?: NativeSignalManifest;
+    readonly target?: Record<string, unknown>;
+}
+export interface StreamedSignalResults {
+    readonly signalOwner: SignalOwnerIdentity;
+    readonly receiver: StreamedResultReceiver;
+    dispose(): void;
+    /** Permanently fence this document's old ingress without restoring its early mailbox. */
+    suspend(): void;
+}
+export interface StreamedSignalHydration extends StreamedSignalResults {
+    readonly receiver: StreamedRegionReceiver;
+}
+/**
+ * Upgrade the server's pre-module mailboxes before behavior reads or hydration.
+ * No component root is required. An optional hydrateRoot receives the returned
+ * owner so its instance-local descriptors join the same server-authorized
+ * selections without starting duplicate browser loaders.
+ */
+export declare function bootstrapStreamedSignalHydration(options: StreamedSignalHydrationOptions): StreamedSignalHydration;
+/**
+ * Upgrade the same pre-module mailboxes when the host owns DOM delivery.
+ * Results join the existing signal owner synchronously, without region placement
+ * support. Use bootstrapStreamedSignalHydration to register streamed HTML ranges.
+ */
+export declare function bootstrapStreamedSignalResults(options: StreamedSignalHydrationOptions): StreamedSignalResults;

package/dist/hydration/streamed-signals.js

@@ -0,0 +1,186 @@
+import {
+  documentSignalOwner,
+  enableSignalDocument,
+  installStreamedSignalOwnerActivator
+} from "../signals/document-owner.js";
+import { attachStreamedSignalResult, initializeDocumentSignalOwner } from "../signals/facade.js";
+import { registerSignalOwnerDocument } from "../signals/early-values.js";
+import { retireSignalOwnerIdentity } from "../signals/owner-context.js";
+import {
+  parseNativeSignalManifest
+} from "../signals/native-read-seeds.js";
+import {
+  isStreamFrameIdentity,
+  isStreamedRendererFrame,
+  streamFrameIdentityKey
+} from "../streamed-signals-protocol.js";
+import {
+  installStreamedRendererGlobal
+} from "./stream-delivery.js";
+import { createStreamedRegionReceiver } from "./stream-receiver.js";
+import {
+  createStreamedResultReceiver
+} from "./stream-result-receiver.js";
+import {
+  installSignalDocumentLifecycle
+} from "./document-lifecycle.js";
+const STREAMED_SIGNAL_SELECTIONS = "__octaneStreamedSignalSelections";
+function documentOwner(owner) {
+  return "documentOwner" in owner ? owner.documentOwner : owner;
+}
+function bootstrapStreamedSignalHydration(options) {
+  return bootstrapStreamedSignals(options, createStreamedRegionReceiver);
+}
+function bootstrapStreamedSignalResults(options) {
+  return bootstrapStreamedSignals(options, createStreamedResultReceiver);
+}
+function bootstrapStreamedSignals(options, createReceiver) {
+  if (!options.buildId || !options.documentId) {
+    throw new TypeError("Streamed signal hydration requires buildId and documentId.");
+  }
+  const target = options.target ?? globalThis;
+  const signalOwner = options.signalOwner ?? documentSignalOwner(document);
+  const receiver = createReceiver({
+    buildId: options.buildId,
+    documentId: options.documentId,
+    ownerKey: signalOwner.scopeKey,
+    ...options.maxPendingFrames === void 0 ? {} : { maxPendingFrames: options.maxPendingFrames },
+    ...options.maxPendingBytes === void 0 ? {} : { maxPendingBytes: options.maxPendingBytes },
+    ...options.timeoutMs === void 0 ? {} : { pendingTimeoutMs: options.timeoutMs }
+  });
+  const early = target[STREAMED_SIGNAL_SELECTIONS];
+  if (early === void 0 || early === null || typeof early !== "object" || early.version !== 1 || !Array.isArray(early.identities) || typeof early.register !== "function") {
+    receiver.dispose();
+    throw new Error("The streamed signal selection bootstrap is missing or incompatible.");
+  }
+  if (early.overflow === true) {
+    receiver.dispose();
+    throw new Error("The pre-module streamed signal selection mailbox overflowed.");
+  }
+  const selections = /* @__PURE__ */ new Map();
+  const owners = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const attach = (selection, owner) => {
+    if (selection.detach !== void 0 || selection.identity.instanceKey !== owner.instanceKey)
+      return;
+    selection.detach = attachStreamedSignalResult(receiver, owner, selection.identity);
+  };
+  const register = (candidate) => {
+    if (disposed) return;
+    if (!isStreamFrameIdentity(candidate) || candidate.buildId !== options.buildId || candidate.documentId !== options.documentId || candidate.ownerKey !== signalOwner.scopeKey) {
+      throw new Error("A streamed signal selection has the wrong authority.");
+    }
+    const slot = JSON.stringify([candidate.instanceKey, candidate.nodeKey]);
+    const previous = selections.get(slot);
+    previous?.detach?.();
+    receiver.registerSelection(candidate);
+    const selection = { identity: candidate };
+    selections.set(slot, selection);
+    const owner = owners.get(candidate.instanceKey);
+    if (owner !== void 0) attach(selection, owner);
+    else if (candidate.nodeKey.startsWith("g:")) {
+      attach(selection, {
+        scopeKey: signalOwner.scopeKey,
+        documentOwner: signalOwner,
+        instanceOwner: signalOwner,
+        instanceKey: candidate.instanceKey
+      });
+    }
+  };
+  const originalRegister = early.register;
+  let uninstallOwnerActivator;
+  let initialized = false;
+  try {
+    uninstallOwnerActivator = installStreamedSignalOwnerActivator((owner) => {
+      if (disposed || !("documentOwner" in owner) || documentOwner(owner) !== signalOwner) return;
+      if (owners.has(owner.instanceKey)) return;
+      owners.set(owner.instanceKey, owner);
+      for (const selection of selections.values()) attach(selection, owner);
+    });
+    if (options.initialSignals !== void 0) {
+      const manifest = parseNativeSignalManifest(JSON.stringify(options.initialSignals));
+      initializeDocumentSignalOwner(
+        signalOwner,
+        manifest.scopes.find((scope) => scope.scopeKey === signalOwner.scopeKey) ?? {
+          version: 1,
+          scopeKey: signalOwner.scopeKey,
+          entries: []
+        }
+      );
+      initialized = true;
+    }
+    registerSignalOwnerDocument(signalOwner, document);
+    enableSignalDocument();
+    early.register = register;
+    for (const identity of early.identities) register(identity);
+    early.identities.length = 0;
+  } catch (error) {
+    uninstallOwnerActivator?.();
+    if (early.register === register) early.register = originalRegister;
+    for (const selection of selections.values()) selection.detach?.();
+    receiver.dispose();
+    if (initialized) retireSignalOwnerIdentity(signalOwner);
+    throw error;
+  }
+  const earlyRenderer = target.__octaneStreamedRenderer;
+  if (earlyRenderer !== void 0 && earlyRenderer !== null && typeof earlyRenderer === "object" && earlyRenderer.version === 1 && Array.isArray(earlyRenderer.frames)) {
+    const current = new Set(
+      [...selections.values()].map(({ identity }) => streamFrameIdentityKey(identity))
+    );
+    let retained = 0;
+    for (const frame of earlyRenderer.frames) {
+      if (isStreamedRendererFrame(frame) && frame.channel === "result" && current.has(streamFrameIdentityKey(frame.identity))) {
+        void receiver.receive(frame).catch(() => {
+        });
+      } else {
+        earlyRenderer.frames[retained++] = frame;
+      }
+    }
+    earlyRenderer.frames.length = retained;
+  }
+  let uninstallDelivery;
+  try {
+    uninstallDelivery = installStreamedRendererGlobal(receiver, target, options);
+  } catch (error) {
+    uninstallOwnerActivator();
+    early.register = originalRegister;
+    for (const selection of selections.values()) selection.detach?.();
+    receiver.dispose();
+    if (initialized) retireSignalOwnerIdentity(signalOwner);
+    throw error;
+  }
+  const installedRenderer = target.__octaneStreamedRenderer;
+  const close = (restore) => {
+    if (disposed) return;
+    disposed = true;
+    if (early.register === register) early.register = restore ? originalRegister : () => {
+    };
+    uninstallOwnerActivator();
+    for (const selection of selections.values()) selection.detach?.();
+    const ownsIngress = target.__octaneStreamedRenderer === installedRenderer;
+    uninstallDelivery();
+    if (!restore && ownsIngress) {
+      target.__octaneStreamedRenderer = { receive() {
+      } };
+      if (earlyRenderer) earlyRenderer.frames.length = 0;
+    }
+    selections.clear();
+    owners.clear();
+    receiver.dispose();
+  };
+  return {
+    signalOwner,
+    receiver,
+    dispose() {
+      close(true);
+    },
+    suspend() {
+      close(false);
+    }
+  };
+}
+export {
+  bootstrapStreamedSignalHydration,
+  bootstrapStreamedSignalResults,
+  installSignalDocumentLifecycle
+};

package/dist/hydration/types.d.ts

@@ -49,6 +49,12 @@ export type HydrationPrefetchFunction = (context: HydrationPrefetchContext) => v
 export type HydrateWhen = HydrationStrategy | (() => HydrationStrategy);
 type HydrateCommonOptions = {
     when: HydrateWhen;
+    /**
+     * Require this boundary to activate without evaluating or hydrating its
+     * lexical parent. The compiler rejects the boundary when it cannot prove a
+     * standalone capture, ownership, ID, and style contract.
+     */
+    independent?: boolean;
     fallback?: unknown;
     onHydrated?: () => void;
 };

package/dist/hydration-markers.d.ts

@@ -0,0 +1,7 @@
+/** Inert compiler/bundler manifest for one independently activatable boundary. */
+export declare const INDEPENDENT_HYDRATE_MANIFEST_ATTR = "data-octane-independent";
+export declare const HYDRATE_INDEPENDENT_ATTR = "data-octane-hydrate-independent";
+/** Compiler-owned stable key for a native control that can receive input before activation. */
+export declare const HYDRATE_INPUT_ATTR = "data-octane-input";
+/** Server-only writable-signal identity joined to a compiler control site. */
+export declare const SIGNAL_CONTROL_ATTR = "data-octane-signal-control";

package/dist/hydration-markers.js

@@ -0,0 +1,10 @@
+const INDEPENDENT_HYDRATE_MANIFEST_ATTR = "data-octane-independent";
+const HYDRATE_INDEPENDENT_ATTR = "data-octane-hydrate-independent";
+const HYDRATE_INPUT_ATTR = "data-octane-input";
+const SIGNAL_CONTROL_ATTR = "data-octane-signal-control";
+export {
+  HYDRATE_INDEPENDENT_ATTR,
+  HYDRATE_INPUT_ATTR,
+  INDEPENDENT_HYDRATE_MANIFEST_ATTR,
+  SIGNAL_CONTROL_ATTR
+};

package/dist/independent-hydration-protocol.d.ts

@@ -0,0 +1,31 @@
+import type { EncodedSignalValue } from './signals/types.js';
+export interface IndependentHydrateCapture {
+    readonly name: string;
+    readonly type: 'json';
+}
+export interface IndependentHydrateManifestTemplate {
+    readonly version: 1;
+    readonly boundaryId: string;
+    readonly exportName: string;
+    readonly captureSchema: readonly IndependentHydrateCapture[];
+    readonly hookSeed: number;
+    readonly idSeed: number;
+    readonly signalSites: readonly string[];
+    readonly parentDependencies: false;
+}
+export interface IndependentHydrateBuildRecord {
+    readonly moduleId: string;
+    readonly styles: readonly string[];
+}
+/** Compiler proof plus request-specific encoded captures for one island. */
+export interface IndependentHydrateManifest extends IndependentHydrateManifestTemplate {
+    readonly buildId: string;
+    /** Per-render instance boundary, not the compiler template lookup key. */
+    readonly boundaryId: string;
+    readonly moduleId: string;
+    readonly captures: readonly EncodedSignalValue[];
+    readonly styles: readonly string[];
+}
+export declare function isIndependentHydrateManifest(value: unknown): value is IndependentHydrateManifest;
+export declare function createIndependentHydrateManifest(template: IndependentHydrateManifestTemplate, values: readonly unknown[], instanceBoundaryId: string, buildId: string, build: IndependentHydrateBuildRecord): IndependentHydrateManifest;
+export declare function serializeIndependentHydrateManifest(manifest: IndependentHydrateManifest): string;