@fictjs/ssr 0.20.0 → 0.22.0

package/dist/index.js

@@ -1,1089 +1,15 @@
 import {
-  createStreamRuntimeCode
-} from "./chunk-DI4PFT6R.js";
-
-// src/index.ts
-import { render } from "@fictjs/runtime";
-import {
-  __fictDisableSSR,
-  __fictEnableSSR,
-  __fictCreateSSRSession,
-  __fictGetScopeRegistry,
-  __fictGetScopesForBoundary,
-  __fictRunWithSSRSession,
-  __fictSerializeSSRState,
-  __fictSerializeSSRStateForScopes,
-  __fictSetSSRStreamHooks
-} from "@fictjs/runtime/internal";
-import { parseHTML } from "linkedom";
-
-// src/globals.ts
-function installGlobals(window, document) {
-  const win = window;
-  const required = {
-    window: win,
-    document,
-    self: win,
-    Node: win.Node,
-    Element: win.Element,
-    HTMLElement: win.HTMLElement,
-    SVGElement: win.SVGElement,
-    Document: win.Document,
-    DocumentFragment: win.DocumentFragment,
-    Text: win.Text,
-    Comment: win.Comment
-  };
-  const optional = {
-    Range: win.Range,
-    Event: win.Event,
-    CustomEvent: win.CustomEvent,
-    MutationObserver: win.MutationObserver,
-    DOMParser: win.DOMParser,
-    getComputedStyle: win.getComputedStyle?.bind(win)
-  };
-  const missing = Object.entries(required).filter(([, value]) => value === void 0).map(([key]) => key);
-  if (missing.length) {
-    throw new Error(`[fict/ssr] Missing DOM globals: ${missing.join(", ")}`);
-  }
-  const globals = { ...required, ...optional };
-  const keys = Object.keys(globals);
-  const snapshot = captureGlobals(keys);
-  for (const key of keys) {
-    const value = globals[key];
-    if (value !== void 0) {
-      ;
-      globalThis[key] = value;
-    }
-  }
-  return () => restoreGlobals(snapshot);
-}
-function installManifest(manifest) {
-  if (!manifest) return () => {
-  };
-  let resolved;
-  if (typeof manifest === "string") {
-    const raw = readTextFileFromPath(manifest);
-    resolved = JSON.parse(raw);
-  } else {
-    resolved = manifest;
-  }
-  const key = "__FICT_MANIFEST__";
-  const snapshot = {
-    exists: Object.prototype.hasOwnProperty.call(globalThis, key),
-    value: globalThis[key]
-  };
-  globalThis[key] = resolved;
-  return () => {
-    if (snapshot.exists) {
-      ;
-      globalThis[key] = snapshot.value;
-    } else {
-      delete globalThis[key];
-    }
-  };
-}
-function captureGlobals(keys) {
-  const snapshot = [];
-  for (const key of keys) {
-    const exists = Object.prototype.hasOwnProperty.call(globalThis, key);
-    const value = globalThis[key];
-    snapshot.push({ key, exists, value });
-  }
-  return snapshot;
-}
-function restoreGlobals(snapshot) {
-  for (const entry of snapshot) {
-    if (entry.exists) {
-      ;
-      globalThis[entry.key] = entry.value;
-    } else {
-      delete globalThis[entry.key];
-    }
-  }
-}
-function readTextFileFromPath(path) {
-  const g = globalThis;
-  const deno = g.Deno;
-  if (deno && typeof deno.readTextFileSync === "function") {
-    return deno.readTextFileSync(path);
-  }
-  const nodeRequire = getNodeRequire();
-  if (nodeRequire) {
-    const fs = nodeRequire("node:fs");
-    return fs.readFileSync(path, "utf8");
-  }
-  throw new Error(
-    "[fict/ssr] `manifest` as file path is only supported in Node.js or Deno. Pass a manifest object in edge runtimes."
-  );
-}
-function getNodeRequire() {
-  const g = globalThis;
-  const direct = g.require;
-  if (typeof direct === "function") {
-    return direct;
-  }
-  try {
-    return Function('return typeof require === "function" ? require : null')();
-  } catch {
-    return null;
-  }
-}
-
-// src/stream-bridge.ts
-function createQueuedTextStream(options = {}) {
-  const encoder = new TextEncoder();
-  const queue = [];
-  let controller = null;
-  let closed = false;
-  let aborted;
-  const readyResolvers = [];
-  const resolveReady = () => {
-    if (!controller || (controller.desiredSize ?? 1) <= 0) return;
-    while (readyResolvers.length > 0) {
-      readyResolvers.shift()?.();
-    }
-  };
-  const drainReady = () => {
-    while (readyResolvers.length > 0) {
-      readyResolvers.shift()?.();
-    }
-  };
-  const abortQueue = (reason, notifyController = true) => {
-    if (closed || aborted !== void 0) return;
-    aborted = reason ?? new Error("Stream aborted");
-    queue.length = 0;
-    drainReady();
-    if (notifyController) {
-      controller?.error(aborted);
-    }
-  };
-  const stream = new ReadableStream({
-    start(ctrl) {
-      controller = ctrl;
-      for (const chunk of queue) {
-        ctrl.enqueue(chunk);
-      }
-      queue.length = 0;
-      if (aborted !== void 0) {
-        ctrl.error(aborted);
-        return;
-      }
-      if (closed) {
-        ctrl.close();
-      }
-    },
-    pull() {
-      resolveReady();
-    },
-    cancel(reason) {
-      abortQueue(reason, false);
-      options.onCancel?.(reason);
-    }
-  });
-  const writer = {
-    write(chunk) {
-      if (closed || aborted !== void 0) return;
-      const data = encoder.encode(chunk);
-      if (controller) {
-        controller.enqueue(data);
-        if ((controller.desiredSize ?? 1) <= 0) {
-          return new Promise((resolve) => {
-            readyResolvers.push(resolve);
-          });
-        }
-      } else {
-        queue.push(data);
-      }
-      return void 0;
-    },
-    close() {
-      if (closed || aborted !== void 0) return;
-      closed = true;
-      drainReady();
-      controller?.close();
-    },
-    abort(reason) {
-      abortQueue(reason);
-    }
-  };
-  return { stream, writer };
-}
-function createPipeBridge() {
-  const nodeBridge = createNodePipeBridge();
-  if (nodeBridge) return nodeBridge;
-  const targets = /* @__PURE__ */ new Set();
-  const buffer = [];
-  let state = "open";
-  let abortReason = null;
-  const safeWrite = (target, chunk) => {
-    try {
-      const ready = target.write(chunk);
-      if (ready === false) {
-        return new Promise((resolve) => {
-          const withOnce = target;
-          if (typeof withOnce.once === "function") {
-            withOnce.once("drain", resolve);
-          } else {
-            resolve();
-          }
-        });
-      }
-    } catch {
-    }
-    return void 0;
-  };
-  const safeEnd = (target) => {
-    try {
-      target.end();
-    } catch {
-    }
-  };
-  const safeDestroy = (target, reason) => {
-    const withDestroy = target;
-    if (typeof withDestroy.destroy === "function") {
-      try {
-        withDestroy.destroy(reason);
-      } catch {
-      }
-      return;
-    }
-    safeEnd(target);
-  };
-  return {
-    pipe(writable) {
-      targets.add(writable);
-      if (buffer.length > 0) {
-        for (const chunk of buffer) {
-          safeWrite(writable, chunk);
-        }
-        buffer.length = 0;
-      }
-      if (state === "closed") {
-        safeEnd(writable);
-      } else if (state === "aborted") {
-        safeDestroy(writable, abortReason ?? new Error("Stream aborted"));
-      }
-    },
-    write(chunk) {
-      if (state !== "open") return;
-      if (targets.size === 0) {
-        buffer.push(chunk);
-        return;
-      }
-      const pending = [];
-      for (const target of targets) {
-        const result = safeWrite(target, chunk);
-        if (result) pending.push(result);
-      }
-      return pending.length > 0 ? Promise.all(pending).then(() => void 0) : void 0;
-    },
-    close() {
-      if (state !== "open") return;
-      state = "closed";
-      for (const target of targets) {
-        safeEnd(target);
-      }
-      if (targets.size > 0) {
-        buffer.length = 0;
-      }
-    },
-    abort(reason) {
-      if (state !== "open") return;
-      state = "aborted";
-      abortReason = reason instanceof Error ? reason : new Error("Stream aborted");
-      for (const target of targets) {
-        safeDestroy(target, abortReason);
-      }
-      buffer.length = 0;
-    }
-  };
-}
-function createNodePipeBridge() {
-  const nodeRequire = getNodeRequire2();
-  if (!nodeRequire) return null;
-  try {
-    const streamModule = nodeRequire("node:stream");
-    if (!streamModule.PassThrough) return null;
-    const passThrough = new streamModule.PassThrough();
-    const buffer = [];
-    let piped = false;
-    let state = "open";
-    let abortReason = null;
-    const writeToPassThrough = (chunk) => {
-      if (passThrough.write(chunk) === false) {
-        return new Promise((resolve) => {
-          const withOnce = passThrough;
-          if (typeof withOnce.once === "function") {
-            withOnce.once("drain", resolve);
-          } else {
-            resolve();
-          }
-        });
-      }
-      return void 0;
-    };
-    const flushBuffer = () => {
-      if (buffer.length === 0) return void 0;
-      const pending = [];
-      for (const chunk of buffer) {
-        const result = writeToPassThrough(chunk);
-        if (result) pending.push(result);
-      }
-      buffer.length = 0;
-      return pending.length > 0 ? Promise.all(pending).then(() => void 0) : void 0;
-    };
-    const destroyPassThrough = (error) => {
-      if (typeof passThrough.destroy === "function") {
-        passThrough.destroy(error);
-      } else {
-        passThrough.end();
-      }
-    };
-    return {
-      pipe(writable) {
-        piped = true;
-        passThrough.pipe(writable);
-        if (state === "aborted") {
-          destroyPassThrough(abortReason ?? new Error("Stream aborted"));
-          return;
-        }
-        const flushed = flushBuffer();
-        if (state === "closed") {
-          if (flushed) {
-            void flushed.then(() => passThrough.end());
-          } else {
-            passThrough.end();
-          }
-        }
-      },
-      write(chunk) {
-        if (state !== "open") return;
-        if (!piped) {
-          buffer.push(chunk);
-          return void 0;
-        }
-        return writeToPassThrough(chunk);
-      },
-      close() {
-        if (state !== "open") return;
-        state = "closed";
-        if (!piped) return;
-        passThrough.end();
-      },
-      abort(reason) {
-        if (state !== "open") return;
-        state = "aborted";
-        abortReason = reason instanceof Error ? reason : new Error("Stream aborted");
-        buffer.length = 0;
-        if (piped) {
-          destroyPassThrough(abortReason);
-        }
-      }
-    };
-  } catch {
-    return null;
-  }
-}
-function getNodeRequire2() {
-  const g = globalThis;
-  const direct = g.require;
-  if (typeof direct === "function") {
-    return direct;
-  }
-  try {
-    return Function('return typeof require === "function" ? require : null')();
-  } catch {
-    return null;
-  }
-}
-
-// src/index.ts
-var DEFAULT_HTML = "<!doctype html><html><head></head><body></body></html>";
-function createSSRDocument(html = DEFAULT_HTML) {
-  const window = parseHTML(html);
-  const document = window.document;
-  if (!window || !document) {
-    throw new Error("[fict/ssr] Failed to create DOM. Missing window or document.");
-  }
-  return { window, document };
-}
-function renderToDocument(view, options = {}) {
-  const session = __fictCreateSSRSession();
-  return __fictRunWithSSRSession(session, () => renderToDocumentInSession(view, options));
-}
-function renderToDocumentInSession(view, options) {
-  const includeSnapshot = options.includeSnapshot !== false;
-  __fictEnableSSR();
-  let dom;
-  let restoreGlobals2 = () => {
-  };
-  let restoreManifest = () => {
-  };
-  let container;
-  let teardown = () => {
-  };
-  try {
-    dom = resolveDom(options);
-    const { document, window } = dom;
-    const shouldExpose = options.exposeGlobals !== false;
-    restoreGlobals2 = shouldExpose ? installGlobals(window, document) : () => {
-    };
-    restoreManifest = installManifest(options.manifest);
-    container = resolveContainer(document, options);
-    teardown = render(view, container);
-    if (includeSnapshot) {
-      const state = __fictSerializeSSRState();
-      injectSnapshot(document, container, state, options);
-    }
-  } catch (error) {
-    __fictDisableSSR();
-    restoreGlobals2();
-    restoreManifest();
-    throw error;
-  }
-  __fictDisableSSR();
-  const html = serializeOutput(dom.document, container, options);
-  const dispose = () => {
-    try {
-      teardown();
-    } finally {
-      restoreGlobals2();
-      restoreManifest();
-    }
-  };
-  return { html, document: dom.document, window: dom.window, container, dispose };
-}
-function renderToString(view, options = {}) {
-  const result = renderToDocument(view, options);
-  const html = result.html;
-  result.dispose();
-  return html;
-}
-async function renderToStringAsync(view, options = {}) {
-  return renderToString(view, options);
-}
-function renderToStream(view, options = {}) {
-  const encoder = new TextEncoder();
-  let controller = null;
-  let abortRender = null;
-  const readyResolvers = [];
-  const drainBackpressure = () => {
-    while (readyResolvers.length > 0) {
-      readyResolvers.shift()?.();
-    }
-  };
-  const resolveBackpressure = () => {
-    if (!controller || (controller.desiredSize ?? 1) <= 0) return;
-    drainBackpressure();
-  };
-  const closeController = () => {
-    abortRender = null;
-    drainBackpressure();
-    if (!controller) return;
-    try {
-      controller.close();
-    } finally {
-      controller = null;
-    }
-  };
-  const errorController = (reason) => {
-    abortRender = null;
-    drainBackpressure();
-    if (!controller) return;
-    try {
-      controller.error(reason);
-    } finally {
-      controller = null;
-    }
-  };
-  const stream = new ReadableStream({
-    start(ctrl) {
-      controller = ctrl;
-      const started = startStreamingRender(view, options, {
-        write(chunk) {
-          if (!controller) return;
-          controller.enqueue(encoder.encode(chunk));
-          if ((controller.desiredSize ?? 1) <= 0) {
-            return new Promise((resolve) => {
-              readyResolvers.push(resolve);
-            });
-          }
-          return void 0;
-        },
-        close() {
-          closeController();
-        },
-        abort(reason) {
-          errorController(reason);
-        }
-      });
-      abortRender = started.abort;
-      started.shellReady.catch(() => void 0);
-      started.allReady.catch(() => void 0);
-    },
-    pull() {
-      resolveBackpressure();
-    },
-    cancel(reason) {
-      const abort = abortRender;
-      controller = null;
-      drainBackpressure();
-      abort?.(reason ?? new Error("Stream canceled"));
-    }
-  });
-  return stream;
-}
-function renderToPipeableStream(view, options = {}) {
-  const bridge = createPipeBridge();
-  const { shellReady, allReady, abort } = startStreamingRender(view, options, {
-    write(chunk) {
-      return bridge.write(chunk);
-    },
-    close() {
-      bridge.close();
-    },
-    abort(reason) {
-      bridge.abort(reason);
-    }
-  });
-  return {
-    pipe(writable) {
-      bridge.pipe(writable);
-    },
-    abort,
-    shellReady,
-    allReady
-  };
-}
-function renderToPartial(view, options = {}) {
-  const partialOptions = {
-    ...options,
-    mode: "shell",
-    fullDocument: options.fullDocument ?? true
-  };
-  let shell = "";
-  let shellPhase = true;
-  let abortPartial = null;
-  const queued = createQueuedTextStream({
-    onCancel(reason) {
-      abortPartial?.(reason ?? new Error("Stream canceled"));
-    }
-  });
-  const { shellReady, allReady, abort } = startStreamingRender(
-    view,
-    partialOptions,
-    {
-      write(chunk) {
-        if (shellPhase) {
-          shell += chunk;
-          return;
-        }
-        return queued.writer.write(chunk);
-      },
-      close() {
-        queued.writer.close();
-      },
-      abort(reason) {
-        queued.writer.abort(reason);
-      }
-    },
-    {
-      includeTailInShell: true,
-      onShellFlushed() {
-        shellPhase = false;
-      }
-    }
-  );
-  abortPartial = abort;
-  return {
-    shell,
-    stream: queued.stream,
-    shellReady,
-    allReady,
-    abort
-  };
-}
-function resolveDom(options) {
-  if (options.dom) {
-    return options.dom;
-  }
-  if (options.document && options.window) {
-    return { document: options.document, window: options.window };
-  }
-  if (options.document) {
-    const window = options.window ?? options.document.defaultView ?? options.document.defaultView ?? void 0;
-    if (!window) {
-      throw new Error(
-        "[fict/ssr] A window is required when providing a document without defaultView."
-      );
-    }
-    return { document: options.document, window };
-  }
-  if (options.window) {
-    return { document: options.window.document, window: options.window };
-  }
-  return createSSRDocument(options.html);
-}
-function isPromiseLike(value) {
-  return typeof value === "object" && value !== null && typeof value.then === "function";
-}
-function startStreamingRender(view, options, writer, control = {}) {
-  const session = __fictCreateSSRSession();
-  return __fictRunWithSSRSession(
-    session,
-    () => startStreamingRenderInSession(session, view, options, writer, control)
-  );
-}
-function startStreamingRenderInSession(session, view, options, writer, control = {}) {
-  const runInSession = (fn) => __fictRunWithSSRSession(session, fn);
-  const resolvedOptions = {
-    ...options,
-    // Streaming requires a real document; default to fullDocument when unspecified.
-    fullDocument: options.fullDocument ?? true
-  };
-  let resolveShell;
-  let rejectShell;
-  let resolveAll;
-  let rejectAll;
-  let shellSettled = false;
-  const shellReady = new Promise((res, rej) => {
-    resolveShell = () => {
-      if (shellSettled) return;
-      shellSettled = true;
-      res();
-    };
-    rejectShell = (err) => {
-      if (shellSettled) return;
-      shellSettled = true;
-      rej(err);
-    };
-  });
-  const allReady = new Promise((res, rej) => {
-    resolveAll = res;
-    rejectAll = rej;
-  });
-  let dom = null;
-  let restoreGlobals2 = () => {
-  };
-  let restoreManifest = () => {
-  };
-  let teardown = () => {
-  };
-  let container = null;
-  let closed = false;
-  let tailHtml = "";
-  let wroteShell = false;
-  let shellCarriesTail = false;
-  let writeChain = null;
-  let writeFailed = false;
-  let removeAbortListener = () => {
-  };
-  const mode = options.mode ?? "shell";
-  const includeSnapshot = options.includeSnapshot !== false;
-  const sentScopes = /* @__PURE__ */ new Set();
-  const boundaryMap = /* @__PURE__ */ new Map();
-  let boundaryId = 0;
-  let pendingCount = 0;
-  const handleWriteError = (error) => {
-    if (writeFailed) return;
-    writeFailed = true;
-    options.onError?.(error);
-    writer.abort(error);
-    cleanup();
-    rejectShell(error);
-    rejectAll(error);
-  };
-  const enqueueWrite = (chunk) => {
-    if (writeFailed) return;
-    const trackWrite = (promise) => {
-      const tracked = promise.then(
-        () => {
-          if (writeChain === tracked) {
-            writeChain = null;
-          }
-        },
-        (error) => {
-          if (writeChain === tracked) {
-            writeChain = null;
-          }
-          handleWriteError(error);
-        }
-      );
-      writeChain = tracked;
-    };
-    const writeAsync = () => Promise.resolve(writer.write(chunk)).then(() => void 0);
-    if (writeChain) {
-      trackWrite(writeChain.then(writeAsync));
-      return;
-    }
-    try {
-      const result = writer.write(chunk);
-      if (isPromiseLike(result)) {
-        trackWrite(
-          result.then(
-            () => void 0,
-            (error) => {
-              throw error;
-            }
-          )
-        );
-      }
-    } catch (error) {
-      handleWriteError(error);
-    }
-  };
-  const afterWrites = (fn) => {
-    const pending = writeChain;
-    if (!pending) {
-      if (!writeFailed) {
-        fn();
-      }
-      return;
-    }
-    void pending.then(() => {
-      if (!writeFailed) {
-        fn();
-      }
-    });
-  };
-  const markShellReady = () => {
-    afterWrites(() => {
-      control.onShellFlushed?.();
-      resolveShell();
-      options.onShellReady?.();
-    });
-  };
-  const writeSnapshotForScopes = (scopeIds) => {
-    runInSession(() => {
-      if (!includeSnapshot || scopeIds.length === 0) return;
-      const registry = __fictGetScopeRegistry();
-      const pending = scopeIds.filter((id) => registry.has(id) && !sentScopes.has(id));
-      if (pending.length === 0) return;
-      const snapshot = __fictSerializeSSRStateForScopes(pending);
-      const ids = Object.keys(snapshot.scopes);
-      if (ids.length === 0) return;
-      const chunk = buildIncrementalSnapshotChunk(snapshot, resolvedOptions);
-      if (chunk) {
-        enqueueWrite(chunk);
-      }
-      for (const id of ids) {
-        sentScopes.add(id);
-      }
-    });
-  };
-  const writeSnapshotForBoundary = (boundary) => {
-    runInSession(() => {
-      const scopes = __fictGetScopesForBoundary(boundary);
-      writeSnapshotForScopes(scopes);
-    });
-  };
-  const writeRemainingSnapshots = () => {
-    runInSession(() => {
-      const scopes = Array.from(__fictGetScopeRegistry().keys());
-      writeSnapshotForScopes(scopes);
-    });
-  };
-  const cleanup = () => {
-    removeAbortListener();
-    removeAbortListener = () => {
-    };
-    runInSession(() => {
-      __fictSetSSRStreamHooks(null);
-      __fictDisableSSR();
-    });
-    restoreGlobals2();
-    restoreManifest();
-    try {
-      teardown();
-    } catch {
-    }
-  };
-  const finalize = () => {
-    if (closed) return;
-    closed = true;
-    if (mode === "all" && dom && container && !wroteShell) {
-      if (includeSnapshot) {
-        const snapshot = __fictSerializeSSRState();
-        injectSnapshot(dom.document, container, snapshot, resolvedOptions);
-      }
-      const fullHtml = serializeOutput(dom.document, container, resolvedOptions);
-      enqueueWrite(fullHtml);
-      afterWrites(() => {
-        writer.close();
-        cleanup();
-        resolveShell();
-        resolveAll();
-        options.onShellReady?.();
-        options.onAllReady?.();
-      });
-      return;
-    }
-    writeRemainingSnapshots();
-    if (tailHtml) {
-      enqueueWrite(tailHtml);
-    }
-    afterWrites(() => {
-      writer.close();
-      cleanup();
-      resolveAll();
-      options.onAllReady?.();
-    });
-  };
-  const maybeFinalize = () => {
-    if (pendingCount === 0) {
-      finalize();
-    }
-  };
-  const hooks = {
-    registerBoundary(start, end) {
-      const id = `s${++boundaryId}`;
-      boundaryMap.set(id, { start, end, pending: false });
-      return id;
-    },
-    boundaryPending(id) {
-      const entry = boundaryMap.get(id);
-      if (!entry || entry.pending) return;
-      entry.pending = true;
-      pendingCount++;
-    },
-    boundaryResolved(id) {
-      const entry = boundaryMap.get(id);
-      if (!entry) return;
-      if (entry.pending) {
-        entry.pending = false;
-        pendingCount = Math.max(0, pendingCount - 1);
-      }
-      if (mode === "shell") {
-        writeSnapshotForBoundary(id);
-        if (dom) {
-          const html = serializeBetween(dom.document, entry.start, entry.end);
-          enqueueWrite(buildPatchChunk(id, html, resolvedOptions));
-        }
-      }
-      maybeFinalize();
-    },
-    onError(err) {
-      options.onError?.(err);
-      abort(err);
-    }
-  };
-  const abort = (reason) => {
-    if (closed) return;
-    closed = true;
-    writeFailed = true;
-    writer.abort(reason);
-    cleanup();
-    const abortReason = reason ?? new Error("Stream aborted");
-    rejectShell(abortReason);
-    rejectAll(abortReason);
-  };
-  if (options.signal) {
-    if (options.signal.aborted) {
-      abort(options.signal.reason);
-      return { shellReady, allReady, abort };
-    } else {
-      const onAbort = () => abort(options.signal?.reason);
-      options.signal.addEventListener("abort", onAbort, { once: true });
-      removeAbortListener = () => options.signal?.removeEventListener("abort", onAbort);
-    }
-  }
-  try {
-    __fictEnableSSR();
-    __fictSetSSRStreamHooks(hooks);
-    dom = resolveDom(resolvedOptions);
-    restoreGlobals2 = resolvedOptions.exposeGlobals !== false ? installGlobals(dom.window, dom.document) : () => {
-    };
-    restoreManifest = installManifest(resolvedOptions.manifest);
-    container = resolveContainer(dom.document, resolvedOptions);
-    teardown = render(view, container);
-    if (mode === "all") {
-      if (pendingCount === 0) {
-        finalize();
-      }
-      return { shellReady, allReady, abort };
-    }
-    const shellHtml = serializeOutput(dom.document, container, resolvedOptions);
-    const streamRuntime = boundaryMap.size > 0 ? buildStreamRuntimeScript(resolvedOptions) : "";
-    if (resolvedOptions.fullDocument) {
-      const split = splitDocumentHtml(shellHtml);
-      if (!split) {
-        throw new Error("[fict/ssr] Failed to locate </body> for streaming output.");
-      }
-      if (control.includeTailInShell) {
-        enqueueWrite(split.head + streamRuntime);
-        tailHtml = split.tail;
-        shellCarriesTail = true;
-      } else {
-        enqueueWrite(split.head + streamRuntime);
-        tailHtml = split.tail;
-      }
-    } else {
-      enqueueWrite(shellHtml + streamRuntime);
-    }
-    wroteShell = true;
-    writeSnapshotForScopes(Array.from(__fictGetScopeRegistry().keys()));
-    if (shellCarriesTail && tailHtml) {
-      enqueueWrite(tailHtml);
-      tailHtml = "";
-      shellCarriesTail = false;
-    }
-    markShellReady();
-    maybeFinalize();
-  } catch (err) {
-    options.onError?.(err);
-    abort(err);
-  }
-  return { shellReady, allReady, abort };
-}
-function resolveContainer(document, options) {
-  if (options.container) {
-    if (options.container.ownerDocument && options.container.ownerDocument !== document) {
-      throw new Error("[fict/ssr] Provided container belongs to a different document.");
-    }
-    return options.container;
-  }
-  const tag = options.containerTag ?? "div";
-  const container = document.createElement(tag);
-  if (options.containerId) {
-    container.setAttribute("id", options.containerId);
-  }
-  if (options.containerAttributes) {
-    for (const [name, value] of Object.entries(options.containerAttributes)) {
-      if (value === null || value === void 0 || value === false) continue;
-      container.setAttribute(name, value === true ? "" : String(value));
-    }
-  }
-  if (document.body) {
-    document.body.appendChild(container);
-  }
-  return container;
-}
-function buildStreamRuntimeScript(options) {
-  const nonce = renderNonceAttribute(options);
-  if (options.streamRuntime === "external") {
-    if (!options.streamRuntimeSrc) {
-      throw new Error('[fict/ssr] streamRuntimeSrc is required when streamRuntime is "external".');
-    }
-    return `<script${nonce} src="${escapeAttribute(options.streamRuntimeSrc)}" data-fict-stream-runtime data-fict-stream-observer></script>`;
-  }
-  return `<script${nonce}>${createStreamRuntimeCode({
-    observerMode: resolveStreamPatchMode(options) === "observer"
-  })}</script>`;
-}
-function buildPatchChunk(id, html, options) {
-  const template = `<template data-fict-suspense="${escapeAttribute(id)}">${html}</template>`;
-  if (resolveStreamPatchMode(options) === "observer") {
-    return template;
-  }
-  return `${template}<script${renderNonceAttribute(options)}>__FICT_STREAM.apply("${escapeScriptString(id)}")</script>`;
-}
-function resolveStreamPatchMode(options) {
-  if (options.streamPatchMode) return options.streamPatchMode;
-  return options.streamRuntime === "external" ? "observer" : "inline";
-}
-function serializeBetween(document, start, end) {
-  const wrapper = document.createElement("div");
-  let node = start.nextSibling;
-  while (node && node !== end) {
-    wrapper.appendChild(node.cloneNode(true));
-    node = node.nextSibling;
-  }
-  return wrapper.innerHTML;
-}
-function splitDocumentHtml(html) {
-  const lower = html.toLowerCase();
-  const idx = lower.lastIndexOf("</body>");
-  if (idx === -1) return null;
-  return { head: html.slice(0, idx), tail: html.slice(idx) };
-}
-function buildIncrementalSnapshotChunk(state, options) {
-  const json = serializeSnapshotForScript(state);
-  const nonce = renderNonceAttribute(options);
-  if (options.snapshotTarget === "head") {
-    const jsonLiteral = JSON.stringify(json);
-    const setNonce = options.scriptNonce !== void 0 ? `s.setAttribute('nonce',${serializeScriptStringLiteral(options.scriptNonce)});` : "";
-    return `<script${nonce}>(function(){var s=document.createElement('script');s.type='application/json';s.setAttribute('data-fict-snapshot','');${setNonce}s.textContent=${jsonLiteral};(document.head||document.documentElement).appendChild(s);}())</script>`;
-  }
-  return `<script${nonce} type="application/json" data-fict-snapshot>${json}</script>`;
-}
-function serializeOutput(document, container, options) {
-  if (options.fullDocument) {
-    const doctype = serializeDoctype(document, options.doctype);
-    const html = document.documentElement ? document.documentElement.outerHTML : container.outerHTML;
-    return doctype ? `${doctype}${html}` : html;
-  }
-  if (options.includeContainer) {
-    return container.outerHTML;
-  }
-  return container.innerHTML;
-}
-function injectSnapshot(document, container, state, options) {
-  const script = document.createElement("script");
-  script.type = "application/json";
-  script.id = options.snapshotScriptId ?? "__FICT_SNAPSHOT__";
-  if (options.scriptNonce !== void 0) {
-    script.setAttribute("nonce", options.scriptNonce);
-  }
-  script.textContent = serializeSnapshotForScript(state);
-  if (options.fullDocument) {
-    if (options.snapshotTarget === "head" && document.head) {
-      document.head.appendChild(script);
-      return;
-    }
-    if (document.body) {
-      document.body.appendChild(script);
-      return;
-    }
-  }
-  const target = options.snapshotTarget ?? "container";
-  if (target === "body" && document.body) {
-    document.body.appendChild(script);
-    return;
-  }
-  if (target === "head" && document.head) {
-    document.head.appendChild(script);
-    return;
-  }
-  container.appendChild(script);
-}
-function serializeSnapshotForScript(state) {
-  return JSON.stringify(state).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
-}
-function serializeScriptStringLiteral(value) {
-  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
-}
-function renderNonceAttribute(options) {
-  return options.scriptNonce === void 0 ? "" : ` nonce="${escapeAttribute(options.scriptNonce)}"`;
-}
-function escapeAttribute(value) {
-  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-function escapeScriptString(value) {
-  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
-}
-function serializeDoctype(document, override) {
-  if (override === null) return "";
-  if (override !== void 0) return override;
-  const doctype = document.doctype;
-  if (!doctype) return "";
-  const name = doctype.name || "html";
-  const publicId = doctype.publicId;
-  const systemId = doctype.systemId;
-  let id = "";
-  if (publicId) {
-    id = ` PUBLIC "${publicId}"`;
-    if (systemId) {
-      id += ` "${systemId}"`;
-    }
-  } else if (systemId) {
-    id = ` SYSTEM "${systemId}"`;
-  }
-  return `<!DOCTYPE ${name}${id}>`;
-}
+  createSSRDocument,
+  renderToDocument,
+  renderToPipeableStream,
+  renderToStream,
+  renderToString,
+  renderToStringAsync
+} from "./chunk-LW7ALN63.js";
+import "./chunk-DI4PFT6R.js";
 export {
   createSSRDocument,
   renderToDocument,
-  renderToPartial,
   renderToPipeableStream,
   renderToStream,
   renderToString,