@absolutejs/absolute 0.19.0-beta.1022 → 0.19.0-beta.1024

package/dist/svelte/index.js

@@ -2325,9 +2325,12 @@ var initDominoAdapter = (platformServer) => {
   return {
     APP_BASE_HREF: common.APP_BASE_HREF,
     bootstrapApplication: platformBrowser.bootstrapApplication,
+    Component: core.Component,
     DomSanitizer: platformBrowser.DomSanitizer,
     ENVIRONMENT_INITIALIZER: core.ENVIRONMENT_INITIALIZER,
     inject: core.inject,
+    InjectionToken: core.InjectionToken,
+    NgComponentOutlet: common.NgComponentOutlet,
     provideClientHydration: platformBrowser.provideClientHydration,
     provideServerRendering: platformServer.provideServerRendering,
     provideZonelessChangeDetection: core.provideZonelessChangeDetection,
@@ -2583,9 +2586,8 @@ var angularIslandSelector = "abs-angular-island", isAngularComponent = (value) =
   const componentName = typeof component.name === "string" && component.name.length > 0 ? component.name : "AngularIsland";
   return `${componentName}:${JSON.stringify(props)}`;
 }, buildAngularIslandWrapperMetadata = async (component, islandId, wrapperKey) => {
-  const { Component, InjectionToken, inject } = await import("@angular/core");
-  const { NgComponentOutlet } = await import("@angular/common");
   const deps = await getAngularDeps();
+  const { Component, InjectionToken, NgComponentOutlet, inject } = deps;
   const selector = getAngularIslandSelector(islandId);
   const propsToken = new InjectionToken(`${wrapperKey}:props`);
 
@@ -2691,7 +2693,15 @@ var init_islands = __esm(() => {
 var renderAngularIslandToHtmlInternal = async (component, props, islandId) => {
   const { renderAngularIslandToHtml: renderAngularIslandToHtml2 } = await Promise.resolve().then(() => (init_islands(), exports_islands));
   return renderAngularIslandToHtml2(component, props, islandId);
-}, renderAngularIslandToHtml2, renderReactIslandToHtml = (component, props) => import("react").then(({ createElement }) => import("react-dom/server").then(({ renderToStaticMarkup }) => renderToStaticMarkup(createElement(component, props)))), renderSvelteIslandToHtml = (component, props) => import("svelte/server").then(({ render }) => {
+}, renderAngularIslandToHtml2, LEADING_HOISTED_RESOURCE_RE, stripLeadingHoistedResources = (html) => {
+  let result = html;
+  let match = LEADING_HOISTED_RESOURCE_RE.exec(result);
+  while (match) {
+    result = result.slice(match[0].length);
+    match = LEADING_HOISTED_RESOURCE_RE.exec(result);
+  }
+  return result.trimStart();
+}, renderReactIslandToHtml = (component, props) => import("react").then(({ createElement }) => import("react-dom/server").then(({ renderToString }) => stripLeadingHoistedResources(renderToString(createElement(component, props))))), renderSvelteIslandToHtml = (component, props) => import("svelte/server").then(({ render }) => {
   const { body } = render(component, { props });
   return body;
 }), renderVueIslandToHtml = (component, props) => import("vue").then(({ createSSRApp, h: createVueVNode }) => {
@@ -2702,20 +2712,321 @@ var renderAngularIslandToHtmlInternal = async (component, props, islandId) => {
 });
 var init_islandSsr = __esm(() => {
   renderAngularIslandToHtml2 = renderAngularIslandToHtmlInternal;
+  LEADING_HOISTED_RESOURCE_RE = /^\s*(?:<link\b[^>]*\/?>|<meta\b[^>]*\/?>|<title\b[^>]*>[\s\S]*?<\/title>|<style\b[^>]*>[\s\S]*?<\/style>|<script\b[^>]*>[\s\S]*?<\/script>)/i;
+});
+
+// src/build/nativeRewrite.ts
+import { dlopen, FFIType, ptr } from "bun:ffi";
+import { platform, arch } from "os";
+import { resolve as resolve5 } from "path";
+var ffiDefinition, nativeLib = null, loadNative = () => {
+  if (nativeLib !== null)
+    return nativeLib;
+  const osPlatform = platform();
+  const cpu = arch();
+  const platformMap = {
+    "darwin-arm64": "darwin-arm64/fast_ops.dylib",
+    "darwin-x64": "darwin-x64/fast_ops.dylib",
+    "linux-arm64": "linux-arm64/fast_ops.so",
+    "linux-x64": "linux-x64/fast_ops.so",
+    "win32-arm64": "windows-arm64/fast_ops.dll",
+    "win32-x64": "windows-x64/fast_ops.dll"
+  };
+  const libPath = platformMap[`${osPlatform}-${cpu}`];
+  if (!libPath)
+    return null;
+  try {
+    const fullPath = resolve5(import.meta.dir, "../../native/packages", libPath);
+    const lib = dlopen(fullPath, ffiDefinition);
+    nativeLib = lib.symbols;
+    return nativeLib;
+  } catch {
+    return null;
+  }
+}, nativeRewriteImports = (content, replacements) => {
+  const lib = loadNative();
+  if (!lib)
+    return null;
+  const jsonStr = JSON.stringify(replacements);
+  const contentBuf = Buffer.from(content);
+  const jsonBuf = Buffer.from(jsonStr);
+  const outBuf = Buffer.alloc(content.length * 2);
+  const outLenBuf = new BigUint64Array([BigInt(outBuf.length)]);
+  const result = lib.rewrite_imports(ptr(contentBuf), contentBuf.length, ptr(jsonBuf), jsonBuf.length, ptr(outBuf), ptr(new Uint8Array(outLenBuf.buffer)));
+  if (result < 0)
+    return null;
+  if (result === 0)
+    return content;
+  const outLen = Number(outLenBuf[0]);
+  return outBuf.subarray(0, outLen).toString("utf-8");
+};
+var init_nativeRewrite = __esm(() => {
+  ffiDefinition = {
+    rewrite_imports: {
+      args: [
+        FFIType.ptr,
+        FFIType.u64,
+        FFIType.ptr,
+        FFIType.u64,
+        FFIType.ptr,
+        FFIType.ptr
+      ],
+      returns: FFIType.i32
+    }
+  };
+});
+
+// src/build/rewriteImportsPlugin.ts
+var exports_rewriteImportsPlugin = {};
+__export(exports_rewriteImportsPlugin, {
+  rewriteVendorDirectories: () => rewriteVendorDirectories,
+  rewriteImportsInContent: () => rewriteImportsInContent,
+  rewriteBuildOutputsWith: () => rewriteBuildOutputsWith,
+  rewriteBuildOutputs: () => rewriteBuildOutputs,
+  jsRewriteImports: () => jsRewriteImports,
+  fixMissingReExportNamespacesInContent: () => fixMissingReExportNamespacesInContent,
+  buildWithImportRewrite: () => buildWithImportRewrite
+});
+import { readdir as readdir2 } from "fs/promises";
+import { join as join5 } from "path";
+var escapeRegex = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), jsRewriteImports = (content, replacements) => {
+  let result = content;
+  for (const [specifier, webPath] of replacements) {
+    const escaped = escapeRegex(specifier);
+    const fromRegex = new RegExp(`(from\\s*["'])${escaped}(["'])`, "g");
+    const sideEffectRegex = new RegExp(`(import\\s*["'])${escaped}(["'])`, "g");
+    const dynamicRegex = new RegExp(`(import\\s*\\(\\s*["'])${escaped}(["']\\s*\\))`, "g");
+    result = result.replace(fromRegex, `$1${webPath}$2`);
+    result = result.replace(sideEffectRegex, `$1${webPath}$2`);
+    result = result.replace(dynamicRegex, `$1${webPath}$2`);
+  }
+  return result;
+}, rewriteImportsInContent = (content, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return content;
+  const replacements = Object.entries(vendorPaths).sort(([keyA], [keyB]) => keyB.length - keyA.length);
+  const native = nativeRewriteImports(content, replacements);
+  return native ?? jsRewriteImports(content, replacements);
+}, fixMissingReExportNamespacesInContent = (content) => {
+  const REEXPORT_PATTERN = /__reExport\(\s*[A-Za-z_$][\w$]*\s*,\s*([A-Za-z_$][\w$]*)\s*\)/g;
+  REEXPORT_PATTERN.lastIndex = 0;
+  const missing = [];
+  let match;
+  while ((match = REEXPORT_PATTERN.exec(content)) !== null) {
+    const ident = match[1];
+    if (!ident)
+      continue;
+    const nsImportRe = new RegExp(`\\bimport\\s*\\*\\s*as\\s+${ident}\\s+from\\b`);
+    if (nsImportRe.test(content))
+      continue;
+    const declRe = new RegExp(`\\b(?:const|let|var|function|class)\\s+${ident}\\b`);
+    if (declRe.test(content))
+      continue;
+    const namedImportRe = new RegExp(`\\bimport\\s*\\{[^}]*\\b${ident}\\b[^}]*\\}\\s*from\\b`);
+    if (namedImportRe.test(content))
+      continue;
+    const importPathRe = /(?:from\s+|import\s*)["']([^"']+)["']/g;
+    let pathMatch;
+    let sourcePath;
+    while ((pathMatch = importPathRe.exec(content)) !== null) {
+      const p = pathMatch[1];
+      if (!p)
+        continue;
+      const base = p.split("/").pop()?.replace(/\.[mc]?js$/, "");
+      if (!base)
+        continue;
+      const normalized = base.startsWith("_") ? base.slice(1) : base;
+      if (normalized === ident || normalized.endsWith(`_${ident}`)) {
+        sourcePath = p;
+        break;
+      }
+    }
+    if (sourcePath)
+      missing.push({ ident, path: sourcePath });
+  }
+  if (missing.length === 0)
+    return content;
+  const seen = new Set;
+  const unique = missing.filter((entry) => {
+    if (seen.has(entry.ident))
+      return false;
+    seen.add(entry.ident);
+    return true;
+  });
+  const inserts = unique.map((entry) => `import * as ${entry.ident} from "${entry.path}";`).join(`
+`);
+  return `${inserts}
+${content}`;
+}, isReadableArtifact = (artifact) => artifact.path.endsWith(".js"), rewriteBuildOutputs = async (outputs, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return;
+  await Promise.all(outputs.filter(isReadableArtifact).map(async (artifact) => {
+    let original;
+    try {
+      original = await artifact.text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    const rewritten = rewriteImportsInContent(original, vendorPaths);
+    if (rewritten === original)
+      return;
+    try {
+      await Bun.write(artifact.path, rewritten);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, rewriteBuildOutputsWith = async (outputs, resolveVendorPaths) => {
+  await Promise.all(outputs.filter(isReadableArtifact).map(async (artifact) => {
+    const vendorPaths = resolveVendorPaths(artifact);
+    if (Object.keys(vendorPaths).length === 0)
+      return;
+    let original;
+    try {
+      original = await artifact.text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    const rewritten = rewriteImportsInContent(original, vendorPaths);
+    if (rewritten === original)
+      return;
+    try {
+      await Bun.write(artifact.path, rewritten);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, rewriteVendorDirectories = async (vendorDirs, vendorPaths) => {
+  if (Object.keys(vendorPaths).length === 0)
+    return;
+  const allFiles = [];
+  for (const dir of vendorDirs) {
+    try {
+      const entries = await readdir2(dir);
+      for (const entry of entries) {
+        if (entry.endsWith(".js"))
+          allFiles.push(join5(dir, entry));
+      }
+    } catch {}
+  }
+  await Promise.all(allFiles.map(async (filePath) => {
+    let original;
+    try {
+      original = await Bun.file(filePath).text();
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+    let next = rewriteImportsInContent(original, vendorPaths);
+    next = fixMissingReExportNamespacesInContent(next);
+    if (next === original)
+      return;
+    try {
+      await Bun.write(filePath, next);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        return;
+      throw err;
+    }
+  }));
+}, buildWithImportRewrite = async (pendingBuild, vendorPaths) => {
+  const result = await pendingBuild;
+  if (result.outputs.length > 0) {
+    await rewriteBuildOutputs(result.outputs, vendorPaths);
+  }
+  return result;
+};
+var init_rewriteImportsPlugin = __esm(() => {
+  init_nativeRewrite();
+});
+
+// src/core/angularServerModule.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { dirname as dirname3, join as join6, relative as relative3 } from "path";
+var serverCacheRoot2, compiledModuleCache2, ANGULAR_SPECIFIER_RE, getCachedModulePath2 = (sourcePath) => {
+  const relativeSourcePath = relative3(process.cwd(), sourcePath).replace(/\\/g, "/");
+  const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
+  return join6(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
+}, collectVendorPaths = (code) => {
+  const vendorPaths = {};
+  if (!isProductionRuntime()) {
+    return vendorPaths;
+  }
+  const specifiers = new Set([...code.matchAll(ANGULAR_SPECIFIER_RE)].map((match) => match[1]));
+  specifiers.forEach((specifier) => {
+    if (!specifier)
+      return;
+    const resolved = resolveAngularRuntimePath(specifier);
+    if (resolved === specifier)
+      return;
+    vendorPaths[specifier] = resolved;
+  });
+  return vendorPaths;
+}, buildAngularServerModule = async (sourcePath) => {
+  const result = await Bun.build({
+    entrypoints: [sourcePath],
+    format: "esm",
+    packages: "external",
+    target: "bun",
+    throw: false
+  });
+  const entry = result.outputs.find((output) => output.kind === "entry-point");
+  if (!result.success || !entry) {
+    const message = result.logs.map((log2) => String(log2)).join(`
+`);
+    throw new Error(`Failed to compile Angular island server module for "${sourcePath}":
+${message}`);
+  }
+  const code = await entry.text();
+  const rewritten = rewriteImportsInContent(code, collectVendorPaths(code));
+  const modulePath = getCachedModulePath2(sourcePath);
+  await mkdir2(dirname3(modulePath), { recursive: true });
+  await Bun.write(modulePath, rewritten);
+  return modulePath;
+}, compileAngularServerModule = (sourcePath) => {
+  const cached = compiledModuleCache2.get(sourcePath);
+  if (cached) {
+    return cached;
+  }
+  const compiledModulePromise = buildAngularServerModule(sourcePath);
+  compiledModuleCache2.set(sourcePath, compiledModulePromise);
+  return compiledModulePromise;
+};
+var init_angularServerModule = __esm(() => {
+  init_resolveAngularPackage();
+  init_rewriteImportsPlugin();
+  serverCacheRoot2 = join6(process.cwd(), ".absolutejs", "islands", "angular");
+  compiledModuleCache2 = new Map;
+  ANGULAR_SPECIFIER_RE = /["'](@angular\/[^"']+)["']/g;
 });
 
 // src/core/vueServerModule.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4, realpathSync } from "fs";
-import { mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname3, join as join5, relative as relative3, resolve as resolve5 } from "path";
+import { mkdir as mkdir3 } from "fs/promises";
+import { dirname as dirname4, join as join7, relative as relative4, resolve as resolve6 } from "path";
 var {Transpiler } = globalThis.Bun;
-var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, transpiler2, ensureRelativeImportPath2 = (from, target) => {
-  const importPath = relative3(dirname3(from), target).replace(/\\/g, "/");
+var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot3, compiledModuleCache3, transpiler2, ensureRelativeImportPath2 = (from, target) => {
+  const importPath = relative4(dirname4(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
-}, getCachedModulePath2 = (sourcePath) => {
-  const relativeSourcePath = relative3(process.cwd(), sourcePath).replace(/\\/g, "/");
+}, getCachedModulePath3 = (sourcePath) => {
+  const relativeSourcePath = relative4(process.cwd(), sourcePath).replace(/\\/g, "/");
   const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
-  return join5(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
+  return join7(serverCacheRoot3, `${normalizedSourcePath}.server.js`);
 }, writeIfChanged2 = async (path, content) => {
   const targetFile = Bun.file(path);
   if (await targetFile.exists()) {
@@ -2742,7 +3053,7 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
 `) : nonVueLines.join(`
 `);
 }, extractRelativeVueImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => typeof importPath === "string" && importPath.startsWith(".") && importPath.endsWith(".vue")), compileVueServerModule = async (sourcePath) => {
-  const cachedModulePath = compiledModuleCache2.get(sourcePath);
+  const cachedModulePath = compiledModuleCache3.get(sourcePath);
   if (cachedModulePath)
     return cachedModulePath;
   const compiler = await import("@vue/compiler-sfc");
@@ -2775,7 +3086,7 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
   }).code : "const ssrRender = () => {};";
   const childImportPaths = extractRelativeVueImports(compiledScript.content);
   const compiledChildren = await Promise.all(childImportPaths.map(async (relativeImport) => ({
-    compiledPath: await compileVueServerModule(resolve5(dirname3(sourcePath), relativeImport)),
+    compiledPath: await compileVueServerModule(resolve6(dirname4(sourcePath), relativeImport)),
     spec: relativeImport
   })));
   const strippedScript = stripExports(compiledScript.content);
@@ -2787,20 +3098,20 @@ var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, tran
     "export default script;"
   ].join(`
 `));
-  const compiledModulePath = getCachedModulePath2(sourcePath);
+  const compiledModulePath = getCachedModulePath3(sourcePath);
   let rewritten = assembled;
   for (const child of compiledChildren) {
     rewritten = rewritten.replaceAll(child.spec, ensureRelativeImportPath2(compiledModulePath, child.compiledPath));
   }
-  await mkdir2(dirname3(compiledModulePath), { recursive: true });
+  await mkdir3(dirname4(compiledModulePath), { recursive: true });
   await writeIfChanged2(compiledModulePath, rewritten);
-  compiledModuleCache2.set(sourcePath, compiledModulePath);
+  compiledModuleCache3.set(sourcePath, compiledModulePath);
   return compiledModulePath;
 };
 var init_vueServerModule = __esm(() => {
   init_constants();
-  serverCacheRoot2 = join5(process.cwd(), ".absolutejs", "islands", "vue");
-  compiledModuleCache2 = new Map;
+  serverCacheRoot3 = join7(process.cwd(), ".absolutejs", "islands", "vue");
+  compiledModuleCache3 = new Map;
   transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
 });
 
@@ -2946,8 +3257,17 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
     throw new Error("Resolved Vue island is not a valid Vue component.");
   }
   return resolvedComponent;
+}, loadAngularServerBuildComponent = async (buildReferencePath, exportName) => {
+  const serverModulePath = await compileAngularServerModule(buildReferencePath);
+  const loadedModule = await import(serverModulePath);
+  if (exportName && exportName !== "default" && exportName in loadedModule) {
+    return loadedModule[exportName];
+  }
+  return "default" in loadedModule ? loadedModule.default : loadedModule;
 }, resolveAngularServerIslandComponent = async (component) => {
-  const resolvedComponent = await resolveServerIslandComponent(component);
+  const buildReference = getIslandBuildReference(component);
+  const buildReferencePath = buildReference?.source ? resolveBuildReferencePath(buildReference.source, import.meta.url) : null;
+  const resolvedComponent = buildReferencePath ? await loadAngularServerBuildComponent(buildReferencePath, buildReference?.export) : await resolveServerIslandComponent(component);
   if (!isAngularServerIslandComponent(resolvedComponent)) {
     throw new Error("Resolved Angular island is not a valid Angular component.");
   }
@@ -3003,6 +3323,7 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
 };
 var init_renderIslandMarkup = __esm(() => {
   init_islandSsr();
+  init_angularServerModule();
   init_svelteServerModule();
   init_vueServerModule();
   init_islandMarkupAttributes();
@@ -3134,7 +3455,6 @@ var runWithStreamingSlotRegistry = async (task) => {
 init_svelteServerModule();
 
 // src/core/islandPageContext.ts
-init_constants();
 var BOOTSTRAP_MANIFEST_KEY = "BootstrapClient";
 var ISLAND_MARKER = 'data-island="true"';
 var MANIFEST_MARKER = "__ABSOLUTE_MANIFEST__";
@@ -3255,61 +3575,69 @@ var pipeStreamWithHeadInjection = (stream, markup) => {
 var pipeStreamWithIslandMarkerDetection = (stream, markup) => {
   const encoder = new TextEncoder;
   const decoder = new TextDecoder;
-  const lookbehind = Math.max(ISLAND_MARKER.length, BYTES_PER_KILOBYTE);
-  const processPending = (controller, pending, injected) => {
-    if (injected) {
-      controller.enqueue(encoder.encode(pending));
-      return { injected, pending: "" };
+  const headLookbehind = CLOSING_HEAD_TAG.length - 1;
+  const enqueue = (controller, text) => {
+    if (text.length > 0) {
+      controller.enqueue(encoder.encode(text));
     }
-    const markerIndex = pending.indexOf(ISLAND_MARKER);
-    if (markerIndex >= 0) {
-      const tagStart = pending.lastIndexOf("<", markerIndex);
-      const injectAt = tagStart >= 0 ? tagStart : markerIndex;
-      const next = `${pending.slice(0, injectAt)}${markup}${pending.slice(injectAt)}`;
-      controller.enqueue(encoder.encode(next));
-      return { injected: true, pending: "" };
+  };
+  const processHolding = (controller, held) => {
+    if (!held.includes(ISLAND_MARKER)) {
+      return { held, injected: false, pending: "", sawHead: true };
     }
-    return {
-      injected,
-      pending: flushSafePendingText(controller, encoder, pending, lookbehind)
-    };
+    enqueue(controller, `${markup}${held}`);
+    return { held: "", injected: true, pending: "", sawHead: true };
   };
-  const finishIslandMarkerStream = (controller, pending) => {
-    const finalPending = pending + decoder.decode();
-    if (finalPending.length > 0) {
-      controller.enqueue(encoder.encode(finalPending));
+  const processHead = (controller, pending) => {
+    const headIndex = pending.indexOf(CLOSING_HEAD_TAG);
+    if (headIndex < 0) {
+      return {
+        held: "",
+        injected: false,
+        pending: flushSafePendingText(controller, encoder, pending, headLookbehind),
+        sawHead: false
+      };
     }
-    controller.close();
+    enqueue(controller, pending.slice(0, headIndex));
+    return processHolding(controller, pending.slice(headIndex));
   };
-  const consumeIslandChunk = async (controller, reader, pending, injected) => {
-    const { done, value } = await readStreamChunk(reader);
-    if (done || !value) {
-      return { done, injected, pending };
+  const processChunk = (controller, state, chunk) => {
+    if (state.injected) {
+      enqueue(controller, chunk);
+      return state;
     }
-    const processed = processPending(controller, pending + streamChunkToString(value, decoder), injected);
-    return {
-      done,
-      injected: processed.injected,
-      pending: processed.pending
-    };
+    if (!state.sawHead) {
+      return processHead(controller, state.pending + chunk);
+    }
+    return processHolding(controller, state.held + chunk);
   };
-  const runIslandMarkerLoop = async (controller, reader) => {
-    const consumeNextIslandChunk = async (injected, pending) => {
-      const consumed = await consumeIslandChunk(controller, reader, pending, injected);
-      const nextState = updateInjectedState(consumed, injected, pending);
-      if (nextState.done) {
-        return { injected, pending };
+  const finishMarkerStream = (controller, state) => {
+    const tail = decoder.decode();
+    const remainder = state.injected ? tail : (state.sawHead ? state.held : state.pending) + tail;
+    enqueue(controller, remainder);
+    controller.close();
+  };
+  const runMarkerLoop = (controller, reader) => {
+    const consumeNext = async (state) => {
+      const { done, value } = await readStreamChunk(reader);
+      if (done || !value) {
+        return state;
       }
-      return consumeNextIslandChunk(nextState.injected, nextState.pending);
+      return consumeNext(processChunk(controller, state, streamChunkToString(value, decoder)));
     };
-    return consumeNextIslandChunk(false, "");
+    return consumeNext({
+      held: "",
+      injected: false,
+      pending: "",
+      sawHead: false
+    });
   };
   return new ReadableStream({
     async start(controller) {
       const reader = stream.getReader();
       try {
-        const { pending } = await runIslandMarkerLoop(controller, reader);
-        finishIslandMarkerStream(controller, pending);
+        const finalState = await runMarkerLoop(controller, reader);
+        finishMarkerStream(controller, finalState);
       } catch (error) {
         controller.error(error);
       }
@@ -4032,5 +4360,5 @@ export {
   createTypedIsland
 };
 
-//# debugId=723477C050CC4ACA64756E2164756E21
+//# debugId=D41079B38272CB2A64756E2164756E21
 //# sourceMappingURL=index.js.map