veryfront 0.1.131 → 0.1.136

package/src/src/agent/runtime/index.ts

@@ -77,6 +77,10 @@ import { resolveConfiguredAgentModel, resolveRuntimeModel } from "./model-resolu
 const logger = serverLogger.component("agent");
 const LOAD_SKILL_TOOL_ID = "load-skill";
 
+type RuntimeToolFilterConfig = AgentConfig & {
+  __vfAllowedRemoteTools?: string[];
+};
+
 function createAbortError(reason?: unknown): Error {
   if (reason instanceof Error) {
     return reason;
@@ -187,6 +191,18 @@ function isLocalModel(model: LanguageModel): boolean {
     (typeof m.modelId === "string" && m.modelId.startsWith("local/"));
 }
 
+function getRuntimeAllowedRemoteTools(config: AgentConfig): string[] | undefined {
+  const configWithRuntimeFilters = config as RuntimeToolFilterConfig;
+  if (!Object.hasOwn(configWithRuntimeFilters, "__vfAllowedRemoteTools")) {
+    return undefined;
+  }
+  const raw = configWithRuntimeFilters.__vfAllowedRemoteTools;
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw.every((toolName) => typeof toolName === "string") ? raw : [];
+}
+
 export class AgentRuntime {
   private id: string;
   private config: AgentConfig;
@@ -418,6 +434,7 @@ export class AgentRuntime {
 
       // Request-scoped skill policy (not class-level mutable state)
       let activeSkillPolicy: string[] | undefined;
+      const allowedRemoteToolNames = getRuntimeAllowedRemoteTools(this.config);
 
       for (let step = 0; step < maxSteps; step++) {
         this.status = "thinking";
@@ -425,6 +442,7 @@ export class AgentRuntime {
 
         let tools = isLocal ? [] : await getAvailableTools(this.config.tools, {
           includeSkillTools: Boolean(this.config.skills),
+          allowedRemoteToolNames,
         });
 
         // Layer 1: Filter tools based on active skill policy (planning-time)
@@ -548,6 +566,7 @@ export class AgentRuntime {
                   toolCallId: tc.toolCallId,
                   projectId: cacheCtx?.projectId,
                 },
+                allowedRemoteToolNames,
               );
 
               toolCall.status = "completed";
@@ -662,6 +681,7 @@ export class AgentRuntime {
     // Request-scoped skill policy (not class-level mutable state)
     let activeSkillPolicy: string[] | undefined;
     let finalFinishReason: string | undefined;
+    const allowedRemoteToolNames = getRuntimeAllowedRemoteTools(this.config);
 
     for (let step = 0; step < maxSteps; step++) {
       throwIfAborted(abortSignal);
@@ -669,6 +689,7 @@ export class AgentRuntime {
 
       let tools = isLocalStreaming ? [] : await getAvailableTools(this.config.tools, {
         includeSkillTools: Boolean(this.config.skills),
+        allowedRemoteToolNames,
       });
 
       // Layer 1: Filter tools based on active skill policy (planning-time)
@@ -680,7 +701,10 @@ export class AgentRuntime {
         model: languageModel,
         system: systemPrompt,
         messages: convertToModelMessages(currentMessages),
-        tools: convertToolsToAISDK(tools),
+        tools: convertToolsToAISDK(tools, {
+          model: effectiveModel,
+          allowedToolNames: allowedRemoteToolNames,
+        }),
         maxOutputTokens: this.resolveMaxOutputTokens(maxOutputTokensOverride),
         temperature: DEFAULT_TEMPERATURE,
         abortSignal,
@@ -791,6 +815,7 @@ export class AgentRuntime {
               toolCallId: tc.id,
               ...toolContext,
             },
+            allowedRemoteToolNames,
           );
           throwIfAborted(abortSignal);
 

package/src/src/agent/runtime/model-tool-converter.ts

@@ -10,6 +10,42 @@
 import { jsonSchema, tool } from "ai";
 import type { ToolSet } from "ai";
 import type { ToolDefinition } from "../../tool/index.js";
+import { anthropic } from "@ai-sdk/anthropic";
+
+export interface ConvertToolsToAISDKOptions {
+  model?: string;
+  allowedToolNames?: string[];
+}
+
+function resolveHostedProvider(model?: string): string | undefined {
+  if (!model) return undefined;
+
+  const [provider, second] = model.split("/", 3);
+  if (!provider) return undefined;
+  if (provider === "veryfront-cloud") {
+    return second || undefined;
+  }
+
+  return provider;
+}
+
+function resolveProviderNativeTools(
+  options?: ConvertToolsToAISDKOptions,
+): ToolSet | undefined {
+  if (!options?.allowedToolNames?.includes("web_search")) {
+    return undefined;
+  }
+
+  if (resolveHostedProvider(options.model) !== "anthropic") {
+    return undefined;
+  }
+
+  return {
+    web_search: anthropic.tools.webSearch_20250305({
+      maxUses: 5,
+    }),
+  };
+}
 
 /**
  * Convert veryfront tool definitions to AI SDK ToolSet.
@@ -19,9 +55,8 @@ import type { ToolDefinition } from "../../tool/index.js";
  */
 export function convertToolsToAISDK(
   tools: ToolDefinition[],
+  options?: ConvertToolsToAISDKOptions,
 ): ToolSet | undefined {
-  if (!tools.length) return undefined;
-
   const toolSet: ToolSet = {};
 
   for (const def of tools) {
@@ -31,5 +66,14 @@ export function convertToolsToAISDK(
     });
   }
 
-  return toolSet;
+  const providerNativeTools = resolveProviderNativeTools(options);
+  if (providerNativeTools) {
+    for (const [name, providerTool] of Object.entries(providerNativeTools)) {
+      if (!Object.hasOwn(toolSet, name)) {
+        toolSet[name] = providerTool;
+      }
+    }
+  }
+
+  return Object.keys(toolSet).length > 0 ? toolSet : undefined;
 }

package/src/src/agent/runtime/tool-helpers.ts

@@ -100,6 +100,7 @@ export async function executeConfiguredTool(
   input: Record<string, unknown>,
   toolsConfig: true | Record<string, ToolConfigEntry> | undefined,
   context?: ToolExecutionContext,
+  allowedRemoteToolNames?: string[],
 ): Promise<unknown> {
   const configuredTool = resolveConfiguredTool(toolsConfig, toolName);
   if (configuredTool) {
@@ -114,6 +115,9 @@ export async function executeConfiguredTool(
 
   // Fall back to remote execution for integration tools (e.g., github:list-repos)
   if (isRemoteIntegrationTool(toolName)) {
+    if (allowedRemoteToolNames && !allowedRemoteToolNames.includes(toolName)) {
+      throw new Error(`Tool "${toolName}" is not allowed for this run`);
+    }
     return await executeRemoteIntegrationTool(
       toolName,
       input,
@@ -152,7 +156,11 @@ function addToolDefinition(
  */
 export async function getAvailableTools(
   toolsConfig: true | Record<string, ToolConfigEntry> | undefined,
-  options?: { includeSkillTools?: boolean; includeIntegrationTools?: boolean },
+  options?: {
+    includeSkillTools?: boolean;
+    includeIntegrationTools?: boolean;
+    allowedRemoteToolNames?: string[];
+  },
 ): Promise<ToolDefinition[]> {
   if (!toolsConfig) return [];
 
@@ -176,7 +184,9 @@ export async function getAvailableTools(
         const { getRemoteIntegrationToolDefinitions } = await import(
           "../../integrations/remote-tools.js"
         );
-        const remoteDefs = await getRemoteIntegrationToolDefinitions();
+        const remoteDefs = (await getRemoteIntegrationToolDefinitions()).filter((def) =>
+          !options?.allowedRemoteToolNames || options.allowedRemoteToolNames.includes(def.name)
+        );
         for (const def of remoteDefs) {
           logToolDefinition(def.name, def);
         }
@@ -211,7 +221,9 @@ export async function getAvailableTools(
       const { getRemoteIntegrationToolDefinitions } = await import(
         "../../integrations/remote-tools.js"
       );
-      const remoteDefs = await getRemoteIntegrationToolDefinitions();
+      const remoteDefs = (await getRemoteIntegrationToolDefinitions()).filter((def) =>
+        !options?.allowedRemoteToolNames || options.allowedRemoteToolNames.includes(def.name)
+      );
       for (const def of remoteDefs) {
         // Skip if already present (e.g., explicitly configured by name)
         if (!tools.some((t) => t.name === def.name)) {

package/src/src/agent/types.ts

@@ -45,6 +45,28 @@ export type ModelString = string;
 // Import for use in AgentConfig
 import type { EdgeConfig, MemoryConfig } from "./schemas/index.js";
 
+export type AgentSuggestion =
+  | {
+    id: string;
+    type: "prompt";
+    title: string;
+    description?: string;
+    prompt: string;
+  }
+  | {
+    id: string;
+    type: "task";
+    title: string;
+    description?: string;
+    task: string;
+    prompt?: string;
+  };
+
+export interface AgentSuggestions {
+  welcomeMessage?: string;
+  suggestions: AgentSuggestion[];
+}
+
 export interface AgentConfig {
   id?: string;
   /**
@@ -78,6 +100,7 @@ export interface AgentConfig {
    * and registers the skill tools.
    */
   skills?: true | string[];
+  suggestions?: AgentSuggestions;
   /** Set to false to disable the default security middleware */
   security?: false;
 }

package/src/src/channels/control-plane.ts

@@ -29,6 +29,29 @@ export const RuntimeAgentSkillSchema = z.object({
   examples: z.array(z.string()).optional(),
 });
 
+export const RuntimeAgentSuggestionSchema = z.discriminatedUnion("type", [
+  z.object({
+    id: z.string().min(1),
+    type: z.literal("prompt"),
+    title: z.string().min(1),
+    description: z.string().optional(),
+    prompt: z.string().min(1),
+  }),
+  z.object({
+    id: z.string().min(1),
+    type: z.literal("task"),
+    title: z.string().min(1),
+    description: z.string().optional(),
+    task: z.string().min(1),
+    prompt: z.string().min(1).optional(),
+  }),
+]);
+
+export const RuntimeAgentSuggestionsSchema = z.object({
+  welcomeMessage: z.string().min(1).optional(),
+  suggestions: z.array(RuntimeAgentSuggestionSchema),
+});
+
 export const RuntimeAgentSchema = z.object({
   id: z.string().min(1),
   name: z.string().min(1),
@@ -36,6 +59,7 @@ export const RuntimeAgentSchema = z.object({
   model: z.string().nullable().optional(),
   version: z.string().nullable().optional(),
   skills: z.array(RuntimeAgentSkillSchema).optional(),
+  suggestions: RuntimeAgentSuggestionsSchema.optional(),
 });
 
 export const RuntimeAgentListResponseSchema = z.object({
@@ -67,6 +91,8 @@ const controlPlaneClaimsSchema = z.object({
 export type ControlPlaneSurface = z.infer<typeof ControlPlaneSurfaceSchema>;
 export type ControlPlaneAgentsListRequest = z.infer<typeof ControlPlaneAgentsListRequestSchema>;
 export type RuntimeAgentSkill = z.infer<typeof RuntimeAgentSkillSchema>;
+export type RuntimeAgentSuggestion = z.infer<typeof RuntimeAgentSuggestionSchema>;
+export type RuntimeAgentSuggestions = z.infer<typeof RuntimeAgentSuggestionsSchema>;
 export type RuntimeAgent = z.infer<typeof RuntimeAgentSchema>;
 export type RuntimeAgentListResponse = z.infer<typeof RuntimeAgentListResponseSchema>;
 export type DispatchClaims = z.infer<typeof dispatchClaimsSchema>;
@@ -235,6 +261,10 @@ function resolveAgentSkills(agent: Agent): RuntimeAgentSkill[] {
 
 function getRuntimeAgentMetadata(id: string, agent: Agent): RuntimeAgent {
   const rawConfig = agent.config as unknown as Record<string, unknown>;
+  const suggestionsParseResult = rawConfig.suggestions === undefined
+    ? null
+    : RuntimeAgentSuggestionsSchema.safeParse(rawConfig.suggestions);
+  const suggestions = suggestionsParseResult?.success ? suggestionsParseResult.data : undefined;
 
   return RuntimeAgentSchema.parse({
     id,
@@ -245,6 +275,7 @@ function getRuntimeAgentMetadata(id: string, agent: Agent): RuntimeAgent {
     model: agent.config.model ?? null,
     version: typeof rawConfig.version === "string" ? rawConfig.version : null,
     skills: resolveAgentSkills(agent),
+    ...(suggestions === undefined ? {} : { suggestions }),
   });
 }
 

package/src/src/discovery/handlers/tool-handler.ts

@@ -7,13 +7,24 @@ import { registerTool } from "../../mcp/index.js";
 import type { DiscoveryHandler } from "../types.js";
 import { filenameToId } from "../discovery-utils.js";
 
+function hasGeneratedToolId(tool: Tool): boolean {
+  return typeof tool.__veryfrontGeneratedId === "string" &&
+    tool.id === tool.__veryfrontGeneratedId;
+}
+
 export const toolHandler: DiscoveryHandler<Tool> = {
   typeName: "tool",
   validate: (item): item is Tool =>
     item !== null && typeof item === "object" && typeof (item as Tool).execute === "function",
-  getId: (_item, file) => filenameToId(file),
+  getId: (tool, file) => {
+    return typeof tool.id === "string" &&
+        tool.id.trim().length > 0 &&
+        !hasGeneratedToolId(tool)
+      ? tool.id
+      : filenameToId(file);
+  },
   register: (id, tool) => {
-    const toolWithId = { ...tool, id };
+    const toolWithId = tool.id === id ? tool : { ...tool, id };
     registerTool(id, toolWithId);
     return toolWithId;
   },

package/src/src/html/html-injection.ts

@@ -44,6 +44,8 @@ export interface InjectHTMLContentOptions {
   yjsGuid?: string;
   /** Pre-built import map JSON for ESM module resolution (injected into <head>) */
   importMapJson?: string;
+  /** Framework-generated project stylesheet for production shells */
+  projectStylesheetHref?: string;
 }
 
 function toProjectRelativePath(absolutePath: string, projectDir?: string): string {
@@ -96,6 +98,11 @@ export function injectHTMLContent(
     html = html.replace(/<\/head>/i, `${importMapTag}\n</head>`);
   }
 
+  if (options.projectStylesheetHref && /<\/head>/i.test(html) && !hasProjectStylesheet(html)) {
+    const projectStylesheetTag = `<link rel="stylesheet" href="${options.projectStylesheetHref}">`;
+    html = html.replace(/<\/head>/i, `${projectStylesheetTag}\n</head>`);
+  }
+
   const shouldUsePreviewStylesheet = options.mode === "development" ||
     options.environment === "preview";
 
@@ -116,8 +123,9 @@ export function injectHTMLContent(
         environment: options.environment,
       }),
     });
+    const nonceAttr = buildNonceAttribute(options.nonce);
     const hydrationScript =
-      `<script id="veryfront-hydration-data" type="application/json">${hydrationData}</script>`;
+      `<script id="veryfront-hydration-data" type="application/json"${nonceAttr}>${hydrationData}</script>`;
     html = html.replace(/<\/body>/i, `${hydrationScript}</body>`);
   }
 
@@ -125,19 +133,22 @@ export function injectHTMLContent(
     const hasDevScriptsPlaceholder = /{{\s*devScripts\s*}}/i.test(html);
 
     if (hasDevScriptsPlaceholder) {
-      html = html.replace(/{{\s*devScripts\s*}}/gi, getDevScripts());
+      html = html.replace(/{{\s*devScripts\s*}}/gi, getDevScripts(options.devPort, options.nonce));
     }
 
-    html = html.replace(/{{\s*devStyles\s*}}/gi, getDevStyles());
+    html = html.replace(/{{\s*devStyles\s*}}/gi, getDevStyles(options.nonce));
 
     if (!hasDevScriptsPlaceholder && hasBodyClose) {
-      html = html.replace(/<\/body>/i, `${getDevStyles()}${getDevScripts()}</body>`);
+      html = html.replace(
+        /<\/body>/i,
+        `${getDevStyles(options.nonce)}${getDevScripts(options.devPort, options.nonce)}</body>`,
+      );
     }
   } else {
     html = html.replace(/{{\s*devScripts\s*}}/gi, "");
     html = html.replace(/{{\s*devStyles\s*}}/gi, "");
 
-    const prodScripts = getProdScripts(options.slug);
+    const prodScripts = getProdScripts(options.slug, options.nonce);
     const hasProdScriptsPlaceholder = /{{\s*prodScripts\s*}}/i.test(html);
 
     if (hasProdScriptsPlaceholder) {

package/src/src/html/nonce-injection.ts

@@ -0,0 +1,300 @@
+import { escapeHtml } from "../utils/html-escape.js";
+
+function findTagEnd(html: string, start: number): number {
+  let activeQuote: '"' | "'" | null = null;
+
+  for (let index = start + 1; index < html.length; index++) {
+    const char = html[index];
+
+    if (activeQuote) {
+      if (char === activeQuote) activeQuote = null;
+      continue;
+    }
+
+    if (char === '"' || char === "'") {
+      activeQuote = char;
+      continue;
+    }
+
+    if (char === ">") return index;
+  }
+
+  return -1;
+}
+
+function getOpeningTagName(tag: string): "script" | "style" | undefined {
+  const match = /^<\s*([a-zA-Z][\w:-]*)/u.exec(tag);
+  const tagName = match?.[1]?.toLowerCase();
+  if (tagName === "script" || tagName === "style") return tagName;
+  return undefined;
+}
+
+function isTagBoundary(char: string | undefined): boolean {
+  return char === undefined || /\s|\/|>/u.test(char);
+}
+
+function findRawTextClosingTagStart(
+  lowerHtml: string,
+  tagName: "script" | "style",
+  fromIndex: number,
+): number {
+  const needle = `</${tagName}`;
+  let searchIndex = fromIndex;
+
+  while (searchIndex < lowerHtml.length) {
+    const closingIndex = lowerHtml.indexOf(needle, searchIndex);
+    if (closingIndex === -1) return -1;
+
+    if (isTagBoundary(lowerHtml[closingIndex + needle.length])) {
+      return closingIndex;
+    }
+
+    searchIndex = closingIndex + needle.length;
+  }
+
+  return -1;
+}
+
+interface ParsedAttribute {
+  name: string;
+  start: number;
+  end: number;
+  value: string | null;
+}
+
+function findAttribute(tag: string, attributeName: string): ParsedAttribute | undefined {
+  const closeIndex = tag.lastIndexOf(">");
+  if (closeIndex <= 0) return undefined;
+
+  let index = 1;
+  while (index < closeIndex && !/\s|\/|>/u.test(tag[index] ?? "")) index++;
+
+  while (index < closeIndex) {
+    while (index < closeIndex && /\s/u.test(tag[index] ?? "")) index++;
+    if (index >= closeIndex) break;
+
+    const char = tag[index];
+    if (char === "/" || char === ">") break;
+
+    const start = index;
+    while (index < closeIndex && !/[\s=/>]/u.test(tag[index] ?? "")) index++;
+    const name = tag.slice(start, index);
+
+    while (index < closeIndex && /\s/u.test(tag[index] ?? "")) index++;
+
+    let value: string | null = null;
+    if (tag[index] === "=") {
+      index++;
+      while (index < closeIndex && /\s/u.test(tag[index] ?? "")) index++;
+
+      const quote = tag[index];
+      if (quote === '"' || quote === "'") {
+        index++;
+        const valueStart = index;
+        while (index < closeIndex && tag[index] !== quote) index++;
+        value = tag.slice(valueStart, index);
+        if (index < closeIndex) index++;
+      } else {
+        const valueStart = index;
+        while (index < closeIndex && !/[\s>]/u.test(tag[index] ?? "")) index++;
+        value = tag.slice(valueStart, index);
+      }
+    }
+
+    if (name.toLowerCase() === attributeName) {
+      return { name, start, end: index, value };
+    }
+  }
+
+  return undefined;
+}
+
+function injectNonceIntoOpeningTag(tag: string, escapedNonce: string): string {
+  const existingNonce = findAttribute(tag, "nonce");
+  if (existingNonce) {
+    if (existingNonce.value?.trim()) return tag;
+
+    return `${tag.slice(0, existingNonce.start)}nonce="${escapedNonce}"${
+      tag.slice(existingNonce.end)
+    }`;
+  }
+
+  const closeIndex = tag.lastIndexOf(">");
+  if (closeIndex === -1) return tag;
+
+  const insertAt = /\/\s*>$/u.test(tag) ? closeIndex - 1 : closeIndex;
+  return `${tag.slice(0, insertAt)} nonce="${escapedNonce}"${tag.slice(insertAt)}`;
+}
+
+export function addNonceToHtmlTags(html: string, nonce?: string): string {
+  if (!nonce) return html;
+
+  const escapedNonce = escapeHtml(nonce);
+  const lowerHtml = html.toLowerCase();
+  let result = "";
+  let index = 0;
+  let rawTextTag: "script" | "style" | null = null;
+
+  while (index < html.length) {
+    if (rawTextTag) {
+      const closingIndex = findRawTextClosingTagStart(lowerHtml, rawTextTag, index);
+      if (closingIndex === -1) {
+        result += html.slice(index);
+        break;
+      }
+
+      result += html.slice(index, closingIndex);
+      index = closingIndex;
+      rawTextTag = null;
+      continue;
+    }
+
+    if (html.startsWith("<!--", index)) {
+      const commentEnd = html.indexOf("-->", index + 4);
+      const endIndex = commentEnd === -1 ? html.length : commentEnd + 3;
+      result += html.slice(index, endIndex);
+      index = endIndex;
+      continue;
+    }
+
+    if (html[index] !== "<") {
+      result += html[index];
+      index++;
+      continue;
+    }
+
+    const tagEnd = findTagEnd(html, index);
+    if (tagEnd === -1) {
+      result += html.slice(index);
+      break;
+    }
+
+    const tag = html.slice(index, tagEnd + 1);
+    const tagName = getOpeningTagName(tag);
+
+    if (!tagName) {
+      result += tag;
+      index = tagEnd + 1;
+      continue;
+    }
+
+    result += injectNonceIntoOpeningTag(tag, escapedNonce);
+    index = tagEnd + 1;
+
+    if (!/\/\s*>$/u.test(tag)) {
+      rawTextTag = tagName;
+    }
+  }
+
+  return result;
+}
+
+export function addNonceToHtmlStream(
+  stream: ReadableStream<Uint8Array>,
+  nonce?: string,
+): ReadableStream<Uint8Array> {
+  if (!nonce) return stream;
+
+  const escapedNonce = escapeHtml(nonce);
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let buffer = "";
+  let rawTextTag: "script" | "style" | null = null;
+
+  function transformBuffer(flush: boolean): string {
+    let result = "";
+    let index = 0;
+    const lowerBuffer = buffer.toLowerCase();
+
+    while (index < buffer.length) {
+      if (rawTextTag) {
+        const closingIndex = findRawTextClosingTagStart(lowerBuffer, rawTextTag, index);
+        if (closingIndex === -1) {
+          if (flush) {
+            result += buffer.slice(index);
+            index = buffer.length;
+            break;
+          }
+
+          const retainLength = `</${rawTextTag}`.length;
+          const safeEnd = Math.max(index, buffer.length - retainLength);
+          result += buffer.slice(index, safeEnd);
+          index = safeEnd;
+          break;
+        }
+
+        result += buffer.slice(index, closingIndex);
+        index = closingIndex;
+        rawTextTag = null;
+        continue;
+      }
+
+      if (buffer.startsWith("<!--", index)) {
+        const commentEnd = buffer.indexOf("-->", index + 4);
+        if (commentEnd === -1) {
+          if (flush) {
+            result += buffer.slice(index);
+            index = buffer.length;
+          }
+          break;
+        }
+
+        const endIndex = commentEnd + 3;
+        result += buffer.slice(index, endIndex);
+        index = endIndex;
+        continue;
+      }
+
+      if (buffer[index] !== "<") {
+        const nextTagIndex = buffer.indexOf("<", index);
+        const endIndex = nextTagIndex === -1 ? buffer.length : nextTagIndex;
+        result += buffer.slice(index, endIndex);
+        index = endIndex;
+        continue;
+      }
+
+      const tagEnd = findTagEnd(buffer, index);
+      if (tagEnd === -1) {
+        if (flush) {
+          result += buffer.slice(index);
+          index = buffer.length;
+        }
+        break;
+      }
+
+      const tag = buffer.slice(index, tagEnd + 1);
+      const tagName = getOpeningTagName(tag);
+
+      if (!tagName) {
+        result += tag;
+        index = tagEnd + 1;
+        continue;
+      }
+
+      result += injectNonceIntoOpeningTag(tag, escapedNonce);
+      index = tagEnd + 1;
+
+      if (!/\/\s*>$/u.test(tag)) {
+        rawTextTag = tagName;
+      }
+    }
+
+    buffer = buffer.slice(index);
+    return result;
+  }
+
+  return stream.pipeThrough(
+    new TransformStream<Uint8Array, Uint8Array>({
+      transform(chunk, controller) {
+        buffer += decoder.decode(chunk, { stream: true });
+        const transformed = transformBuffer(false);
+        if (transformed) controller.enqueue(encoder.encode(transformed));
+      },
+      flush(controller) {
+        buffer += decoder.decode();
+        const transformed = transformBuffer(true);
+        if (transformed) controller.enqueue(encoder.encode(transformed));
+      },
+    }),
+  );
+}