npm - alepha - Versions diffs - 0.15.2 → 0.15.4 - Mend

alepha 0.15.2 → 0.15.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (180) hide show

package/README.md +68 -80
package/dist/api/audits/index.d.ts.map +1 -1
package/dist/api/audits/index.js +8 -0
package/dist/api/audits/index.js.map +1 -1
package/dist/api/files/index.d.ts +170 -170
package/dist/api/files/index.d.ts.map +1 -1
package/dist/api/files/index.js +1 -0
package/dist/api/files/index.js.map +1 -1
package/dist/api/jobs/index.d.ts.map +1 -1
package/dist/api/jobs/index.js +3 -0
package/dist/api/jobs/index.js.map +1 -1
package/dist/api/notifications/index.browser.js +1 -0
package/dist/api/notifications/index.browser.js.map +1 -1
package/dist/api/notifications/index.js +1 -0
package/dist/api/notifications/index.js.map +1 -1
package/dist/api/parameters/index.d.ts +260 -260
package/dist/api/parameters/index.d.ts.map +1 -1
package/dist/api/parameters/index.js +10 -0
package/dist/api/parameters/index.js.map +1 -1
package/dist/api/users/index.d.ts +12 -1
package/dist/api/users/index.d.ts.map +1 -1
package/dist/api/users/index.js +18 -2
package/dist/api/users/index.js.map +1 -1
package/dist/batch/index.d.ts +4 -4
package/dist/bucket/index.d.ts +8 -0
package/dist/bucket/index.d.ts.map +1 -1
package/dist/bucket/index.js +7 -2
package/dist/bucket/index.js.map +1 -1
package/dist/cli/index.d.ts +196 -74
package/dist/cli/index.d.ts.map +1 -1
package/dist/cli/index.js +234 -50
package/dist/cli/index.js.map +1 -1
package/dist/command/index.d.ts +10 -0
package/dist/command/index.d.ts.map +1 -1
package/dist/command/index.js +67 -13
package/dist/command/index.js.map +1 -1
package/dist/core/index.browser.js +28 -21
package/dist/core/index.browser.js.map +1 -1
package/dist/core/index.d.ts.map +1 -1
package/dist/core/index.js +28 -21
package/dist/core/index.js.map +1 -1
package/dist/core/index.native.js +28 -21
package/dist/core/index.native.js.map +1 -1
package/dist/email/index.d.ts +21 -13
package/dist/email/index.d.ts.map +1 -1
package/dist/email/index.js +10561 -4
package/dist/email/index.js.map +1 -1
package/dist/lock/core/index.d.ts +6 -1
package/dist/lock/core/index.d.ts.map +1 -1
package/dist/lock/core/index.js +9 -1
package/dist/lock/core/index.js.map +1 -1
package/dist/mcp/index.d.ts +5 -5
package/dist/orm/index.bun.js +32 -16
package/dist/orm/index.bun.js.map +1 -1
package/dist/orm/index.d.ts +4 -1
package/dist/orm/index.d.ts.map +1 -1
package/dist/orm/index.js +34 -22
package/dist/orm/index.js.map +1 -1
package/dist/react/auth/index.browser.js +2 -1
package/dist/react/auth/index.browser.js.map +1 -1
package/dist/react/auth/index.js +2 -1
package/dist/react/auth/index.js.map +1 -1
package/dist/react/core/index.d.ts +3 -3
package/dist/react/router/index.browser.js +9 -15
package/dist/react/router/index.browser.js.map +1 -1
package/dist/react/router/index.d.ts +305 -407
package/dist/react/router/index.d.ts.map +1 -1
package/dist/react/router/index.js +581 -781
package/dist/react/router/index.js.map +1 -1
package/dist/scheduler/index.d.ts +13 -1
package/dist/scheduler/index.d.ts.map +1 -1
package/dist/scheduler/index.js +42 -4
package/dist/scheduler/index.js.map +1 -1
package/dist/security/index.d.ts +42 -42
package/dist/security/index.d.ts.map +1 -1
package/dist/security/index.js +8 -7
package/dist/security/index.js.map +1 -1
package/dist/server/auth/index.d.ts +167 -167
package/dist/server/compress/index.d.ts.map +1 -1
package/dist/server/compress/index.js +1 -0
package/dist/server/compress/index.js.map +1 -1
package/dist/server/health/index.d.ts +17 -17
package/dist/server/links/index.d.ts +39 -39
package/dist/server/links/index.js +1 -1
package/dist/server/links/index.js.map +1 -1
package/dist/server/static/index.js +7 -2
package/dist/server/static/index.js.map +1 -1
package/dist/server/swagger/index.d.ts +8 -0
package/dist/server/swagger/index.d.ts.map +1 -1
package/dist/server/swagger/index.js +7 -2
package/dist/server/swagger/index.js.map +1 -1
package/dist/sms/index.d.ts +8 -0
package/dist/sms/index.d.ts.map +1 -1
package/dist/sms/index.js +7 -2
package/dist/sms/index.js.map +1 -1
package/dist/system/index.browser.js +734 -12
package/dist/system/index.browser.js.map +1 -1
package/dist/system/index.d.ts +8 -0
package/dist/system/index.d.ts.map +1 -1
package/dist/system/index.js +7 -2
package/dist/system/index.js.map +1 -1
package/dist/vite/index.d.ts +3 -2
package/dist/vite/index.d.ts.map +1 -1
package/dist/vite/index.js +42 -8
package/dist/vite/index.js.map +1 -1
package/dist/websocket/index.d.ts +34 -34
package/dist/websocket/index.d.ts.map +1 -1
package/package.json +9 -4
package/src/api/audits/controllers/AdminAuditController.ts +8 -0
package/src/api/files/controllers/AdminFileStatsController.ts +1 -0
package/src/api/jobs/controllers/AdminJobController.ts +3 -0
package/src/api/logs/TODO.md +13 -10
package/src/api/notifications/controllers/AdminNotificationController.ts +1 -0
package/src/api/parameters/controllers/AdminConfigController.ts +10 -0
package/src/api/users/controllers/AdminIdentityController.ts +3 -0
package/src/api/users/controllers/AdminSessionController.ts +3 -0
package/src/api/users/controllers/AdminUserController.ts +5 -0
package/src/cli/apps/AlephaPackageBuilderCli.ts +9 -0
package/src/cli/atoms/buildOptions.ts +99 -9
package/src/cli/commands/build.ts +150 -32
package/src/cli/commands/db.ts +5 -7
package/src/cli/commands/init.spec.ts +50 -6
package/src/cli/commands/init.ts +28 -5
package/src/cli/providers/ViteDevServerProvider.ts +31 -9
package/src/cli/services/AlephaCliUtils.ts +16 -0
package/src/cli/services/PackageManagerUtils.ts +2 -0
package/src/cli/services/ProjectScaffolder.spec.ts +97 -0
package/src/cli/services/ProjectScaffolder.ts +28 -6
package/src/cli/templates/agentMd.ts +6 -1
package/src/cli/templates/apiAppSecurityTs.ts +11 -0
package/src/cli/templates/apiIndexTs.ts +18 -4
package/src/cli/templates/webAppRouterTs.ts +25 -1
package/src/cli/templates/webHelloComponentTsx.ts +15 -5
package/src/command/helpers/Runner.spec.ts +135 -0
package/src/command/helpers/Runner.ts +4 -1
package/src/command/providers/CliProvider.spec.ts +325 -0
package/src/command/providers/CliProvider.ts +117 -7
package/src/core/Alepha.ts +32 -25
package/src/email/index.workerd.ts +36 -0
package/src/email/providers/WorkermailerEmailProvider.ts +221 -0
package/src/lock/core/primitives/$lock.ts +13 -1
package/src/orm/index.bun.ts +1 -1
package/src/orm/index.ts +2 -6
package/src/orm/providers/drivers/BunSqliteProvider.ts +4 -1
package/src/orm/providers/drivers/CloudflareD1Provider.ts +57 -30
package/src/orm/providers/drivers/DatabaseProvider.ts +9 -1
package/src/orm/providers/drivers/NodeSqliteProvider.ts +4 -1
package/src/react/auth/services/ReactAuth.ts +3 -1
package/src/react/router/atoms/ssrManifestAtom.ts +7 -0
package/src/react/router/hooks/useActive.ts +1 -1
package/src/react/router/hooks/useRouter.ts +1 -1
package/src/react/router/index.ts +4 -0
package/src/react/router/primitives/$page.browser.spec.tsx +24 -24
package/src/react/router/primitives/$page.spec.tsx +0 -32
package/src/react/router/primitives/$page.ts +6 -14
package/src/react/router/providers/ReactBrowserProvider.ts +6 -3
package/src/react/router/providers/ReactPageProvider.ts +1 -1
package/src/react/router/providers/ReactPreloadProvider.spec.ts +142 -0
package/src/react/router/providers/ReactPreloadProvider.ts +85 -0
package/src/react/router/providers/ReactServerProvider.ts +21 -82
package/src/react/router/providers/ReactServerTemplateProvider.spec.ts +210 -0
package/src/react/router/providers/ReactServerTemplateProvider.ts +228 -665
package/src/react/router/providers/SSRManifestProvider.ts +7 -0
package/src/react/router/services/ReactRouter.ts +13 -13
package/src/scheduler/index.workerd.ts +43 -0
package/src/scheduler/providers/CronProvider.ts +53 -6
package/src/scheduler/providers/WorkerdCronProvider.ts +102 -0
package/src/security/__tests__/ServerSecurityProvider.spec.ts +77 -0
package/src/security/providers/ServerSecurityProvider.ts +30 -22
package/src/server/compress/providers/ServerCompressProvider.ts +6 -0
package/src/server/core/providers/NodeHttpServerProvider.spec.ts +9 -3
package/src/server/links/providers/ServerLinksProvider.spec.ts +332 -0
package/src/server/links/providers/ServerLinksProvider.ts +1 -1
package/src/system/index.browser.ts +25 -0
package/src/system/index.workerd.ts +1 -0
package/src/system/providers/FileSystemProvider.ts +8 -0
package/src/system/providers/NodeFileSystemProvider.ts +11 -2
package/src/vite/tasks/buildServer.ts +2 -12
package/src/vite/tasks/generateCloudflare.ts +47 -8
package/src/vite/tasks/generateDocker.ts +4 -0

package/src/react/router/providers/ReactServerTemplateProvider.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { $inject, Alepha, AlephaError } from "alepha";
+import { $inject, Alepha } from "alepha";
 import { $logger } from "alepha/logger";
 import { AlephaContext } from "alepha/react";
 import type { SimpleHead } from "alepha/react/head";
@@ -9,377 +9,148 @@ import { Redirection } from "../errors/Redirection.ts";
 import type { ReactRouterState } from "./ReactPageProvider.ts";
 /**
- * Handles HTML template parsing, preprocessing, and streaming for SSR.
+ * Handles HTML streaming for SSR.
  *
- * Responsibilities:
- * - Parse template once at startup into logical slots
- * - Pre-encode static parts as Uint8Array for zero-copy streaming
- * - Render dynamic parts (attributes, head content) efficiently
- * - Build hydration data for client-side rehydration
- *
- * This provider is injected into ReactServerProvider to handle all
- * template-related operations, keeping ReactServerProvider focused
- * on request handling and React rendering coordination.
+ * Uses hardcoded HTML structure - all customization via $head primitive.
+ * Pre-encodes static parts as Uint8Array for zero-copy streaming.
  */
 export class ReactServerTemplateProvider {
   protected readonly log = $logger();
   protected readonly alepha = $inject(Alepha);
   /**
-   * Shared TextEncoder instance - reused across all requests.
+   * Shared TextEncoder - reused across all requests.
    */
   protected readonly encoder = new TextEncoder();
   /**
-   * Pre-encoded common strings for streaming.
+   * Pre-encoded static HTML parts for zero-copy streaming.
    */
-  protected readonly ENCODED = {
+  protected readonly SLOTS = {
+    DOCTYPE: this.encoder.encode("<!DOCTYPE html>\n"),
+    HTML_OPEN: this.encoder.encode("<html"),
+    HTML_CLOSE: this.encoder.encode(">\n"),
+    HEAD_OPEN: this.encoder.encode("<head>"),
+    HEAD_CLOSE: this.encoder.encode("</head>\n"),
+    BODY_OPEN: this.encoder.encode("<body"),
+    BODY_CLOSE: this.encoder.encode(">\n"),
+    ROOT_OPEN: this.encoder.encode('<div id="root">'),
+    ROOT_CLOSE: this.encoder.encode("</div>\n"),
+    BODY_HTML_CLOSE: this.encoder.encode("</body>\n</html>"),
     HYDRATION_PREFIX: this.encoder.encode("<script>window.__ssr="),
     HYDRATION_SUFFIX: this.encoder.encode("</script>"),
-    EMPTY: this.encoder.encode(""),
   } as const;
   /**
-   * Cached template slots - parsed once, reused for all requests.
+   * Early head content (charset, viewport, entry assets).
+   * Set once during configuration, reused for all requests.
    */
-  protected slots: TemplateSlots | null = null;
+  protected earlyHeadContent = "";
   /**
    * Root element ID for React mounting.
    */
-  public get rootId(): string {
-    return "root";
-  }
+  public readonly rootId = "root";
   /**
-   * Regex pattern for matching the root div and extracting its content.
+   * Regex for extracting root div content from HTML.
    */
-  public get rootDivRegex(): RegExp {
-    return new RegExp(
-      `<div([^>]*)\\s+id=["']${this.rootId}["']([^>]*)>([\\s\\S]*?)<\\/div>`,
-      "i",
-    );
-  }
+  public readonly rootDivRegex = new RegExp(
+    `<div[^>]*\\s+id=["']${this.rootId}["'][^>]*>([\\s\\S]*?)<\\/div>`,
+    "i",
+  );
   /**
-   * Extract the content inside the root div from HTML.
-   *
-   * @param html - Full HTML string
-   * @returns The content inside the root div, or undefined if not found
+   * Extract content inside the root div from HTML.
    */
   public extractRootContent(html: string): string | undefined {
-    const match = html.match(this.rootDivRegex);
-    return match?.[3];
-  }
-  /**
-   * Check if template has been parsed and slots are available.
-   */
-  public isReady(): boolean {
-    return this.slots !== null;
-  }
-  /**
-   * Get the parsed template slots.
-   * Throws if template hasn't been parsed yet.
-   */
-  public getSlots(): TemplateSlots {
-    if (!this.slots) {
-      throw new AlephaError(
-        "Template not parsed. Call parseTemplate() during configuration.",
-      );
-    }
-    return this.slots;
+    return html.match(this.rootDivRegex)?.[1];
   }
   /**
-   * Parse an HTML template into logical slots for efficient streaming.
-   *
-   * This should be called once during server startup/configuration.
-   * The parsed slots are cached and reused for all requests.
+   * Set early head content (charset, viewport, entry assets).
+   * Called once during server configuration.
    */
-  public parseTemplate(template: string): TemplateSlots {
-    this.log.debug("Parsing template into slots");
-    const rootId = this.rootId;
-    // Extract doctype
-    const doctypeMatch = template.match(/<!DOCTYPE[^>]*>/i);
-    const doctype = doctypeMatch?.[0] ?? "<!DOCTYPE html>";
-    let remaining = doctypeMatch
-      ? template.slice(doctypeMatch.index! + doctypeMatch[0].length)
-      : template;
-    // Extract <html> tag and attributes
-    const htmlMatch = remaining.match(/<html([^>]*)>/i);
-    const htmlAttrsStr = htmlMatch?.[1]?.trim() ?? "";
-    const htmlOriginalAttrs = this.parseAttributes(htmlAttrsStr);
-    remaining = htmlMatch
-      ? remaining.slice(htmlMatch.index! + htmlMatch[0].length)
-      : remaining;
-    // Extract <head> content
-    const headMatch = remaining.match(/<head([^>]*)>([\s\S]*?)<\/head>/i);
-    const headOriginalContent = headMatch?.[2]?.trim() ?? "";
-    remaining = headMatch
-      ? remaining.slice(headMatch.index! + headMatch[0].length)
-      : remaining;
-    // Extract <body> tag and attributes
-    const bodyMatch = remaining.match(/<body([^>]*)>/i);
-    const bodyAttrsStr = bodyMatch?.[1]?.trim() ?? "";
-    const bodyOriginalAttrs = this.parseAttributes(bodyAttrsStr);
-    const bodyStartIndex = bodyMatch
-      ? bodyMatch.index! + bodyMatch[0].length
-      : 0;
-    remaining = remaining.slice(bodyStartIndex);
-    // Find root div
-    const rootDivRegex = new RegExp(
-      `<div([^>]*)\\s+id=["']${rootId}["']([^>]*)>([\\s\\S]*?)<\\/div>`,
-      "i",
-    );
-    const rootMatch = remaining.match(rootDivRegex);
-    let beforeRoot = "";
-    let afterRoot = "";
-    let rootAttrs = "";
-    if (rootMatch) {
-      beforeRoot = remaining.slice(0, rootMatch.index!).trim();
-      const rootEndIndex = rootMatch.index! + rootMatch[0].length;
-      // Find </body> for afterRoot
-      const bodyCloseIndex = remaining.indexOf("</body>");
-      afterRoot =
-        bodyCloseIndex > rootEndIndex
-          ? remaining.slice(rootEndIndex, bodyCloseIndex).trim()
-          : "";
-      rootAttrs = `${rootMatch[1] ?? ""}${rootMatch[2] ?? ""}`.trim();
-    } else {
-      // No root div found - will inject one
-      const bodyCloseIndex = remaining.indexOf("</body>");
-      if (bodyCloseIndex > 0) {
-        beforeRoot = remaining.slice(0, bodyCloseIndex).trim();
-      }
-    }
-    // Build the root div opening tag
-    const rootOpenTag = rootAttrs
-      ? `<div ${rootAttrs} id="${rootId}">`
-      : `<div id="${rootId}">`;
-    this.slots = {
-      // Pre-encoded static parts
-      doctype: this.encoder.encode(`${doctype}\n`),
-      htmlOpen: this.encoder.encode("<html"),
-      htmlClose: this.encoder.encode(">\n"),
-      headOpen: this.encoder.encode("<head>"),
-      headClose: this.encoder.encode("</head>\n"),
-      bodyOpen: this.encoder.encode("<body"),
-      bodyClose: this.encoder.encode(">\n"),
-      rootOpen: this.encoder.encode(rootOpenTag),
-      rootClose: this.encoder.encode("</div>\n"),
-      scriptClose: this.encoder.encode("</body>\n</html>"),
-      // Original content for merging
-      htmlOriginalAttrs,
-      bodyOriginalAttrs,
-      headOriginalContent,
-      beforeRoot,
-      afterRoot,
-    };
-    this.log.debug("Template parsed successfully", {
-      hasHtmlAttrs: Object.keys(htmlOriginalAttrs).length > 0,
-      hasBodyAttrs: Object.keys(bodyOriginalAttrs).length > 0,
-      hasHeadContent: headOriginalContent.length > 0,
-      hasBeforeRoot: beforeRoot.length > 0,
-      hasAfterRoot: afterRoot.length > 0,
-    });
-    return this.slots;
-  }
-  /**
-   * Parse HTML attributes string into a record.
-   *
-   * Handles: key="value", key='value', key=value, and boolean key
-   */
-  protected parseAttributes(attrStr: string): Record<string, string> {
-    const attrs: Record<string, string> = {};
-    if (!attrStr) return attrs;
-    // Match: key="value", key='value', key=value, or just key (boolean)
-    const attrRegex = /([^\s=]+)(?:=(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
-    for (const match of attrStr.matchAll(attrRegex)) {
-      const key = match[1];
-      const value = match[2] ?? match[3] ?? match[4] ?? "";
-      attrs[key] = value;
-    }
+  public setEarlyHeadContent(
+    entryAssets: string,
+    globalHead?: SimpleHead,
+  ): void {
+    const charset = globalHead?.charset ?? "UTF-8";
+    const viewport =
+      globalHead?.viewport ?? "width=device-width, initial-scale=1";
-    return attrs;
+    this.earlyHeadContent =
+      `<meta charset="${this.escapeHtml(charset)}">\n` +
+      `<meta name="viewport" content="${this.escapeHtml(viewport)}">\n` +
+      entryAssets;
   }
   /**
    * Render attributes record to HTML string.
-   *
-   * @param attrs - Attributes to render
-   * @returns HTML attribute string like ` lang="en" class="dark"`
    */
-  public renderAttributes(attrs: Record<string, string>): string {
+  public renderAttributes(attrs?: Record<string, string>): string {
+    if (!attrs) return "";
     const entries = Object.entries(attrs);
     if (entries.length === 0) return "";
     return entries
       .map(([key, value]) => ` ${key}="${this.escapeHtml(value)}"`)
       .join("");
   }
-  /**
-   * Render merged HTML attributes (original + dynamic).
-   */
-  public renderMergedHtmlAttrs(dynamicAttrs?: Record<string, string>): string {
-    const slots = this.getSlots();
-    const merged = { ...slots.htmlOriginalAttrs, ...dynamicAttrs };
-    return this.renderAttributes(merged);
-  }
-  /**
-   * Render merged body attributes (original + dynamic).
-   */
-  public renderMergedBodyAttrs(dynamicAttrs?: Record<string, string>): string {
-    const slots = this.getSlots();
-    const merged = { ...slots.bodyOriginalAttrs, ...dynamicAttrs };
-    return this.renderAttributes(merged);
-  }
   /**
    * Render head content (title, meta, link, script tags).
-   *
-   * @param head - Head data to render
-   * @param includeOriginal - Whether to include original head content
-   * @returns HTML string with head content
    */
-  public renderHeadContent(head?: SimpleHead, includeOriginal = true): string {
-    const slots = this.getSlots();
-    let content = "";
-    // Include original head content first
-    if (includeOriginal && slots.headOriginalContent) {
-      content += slots.headOriginalContent;
-    }
+  public renderHeadContent(head?: SimpleHead): string {
+    if (!head) return "";
-    if (!head) return content;
+    let content = "";
-    // Title - check if already exists in original content
     if (head.title) {
-      if (content.includes("<title>")) {
-        // Replace existing title
-        content = content.replace(
-          /<title>.*?<\/title>/i,
-          `<title>${this.escapeHtml(head.title)}</title>`,
-        );
-      } else {
-        content += `<title>${this.escapeHtml(head.title)}</title>\n`;
-      }
+      content += `<title>${this.escapeHtml(head.title)}</title>\n`;
     }
-    // Meta tags
     if (head.meta) {
       for (const meta of head.meta) {
-        content += this.renderMetaTag(meta);
+        if (meta.property) {
+          content += `<meta property="${this.escapeHtml(meta.property)}" content="${this.escapeHtml(meta.content)}">\n`;
+        } else if (meta.name) {
+          content += `<meta name="${this.escapeHtml(meta.name)}" content="${this.escapeHtml(meta.content)}">\n`;
+        }
       }
     }
-    // Link tags
     if (head.link) {
       for (const link of head.link) {
-        content += this.renderLinkTag(link);
+        content += `<link rel="${this.escapeHtml(link.rel)}" href="${this.escapeHtml(link.href)}"`;
+        if (link.type) content += ` type="${this.escapeHtml(link.type)}"`;
+        if (link.as) content += ` as="${this.escapeHtml(link.as)}"`;
+        if (link.crossorigin != null) content += ' crossorigin=""';
+        content += ">\n";
       }
     }
-    // Script tags
     if (head.script) {
       for (const script of head.script) {
-        content += this.renderScriptTag(script);
+        if (typeof script === "string") {
+          content += `<script>${script}</script>\n`;
+        } else {
+          const { content: scriptContent, ...rest } = script;
+          const attrs = Object.entries(rest)
+            .filter(([, v]) => v !== false && v !== undefined)
+            .map(([k, v]) =>
+              v === true ? k : `${k}="${this.escapeHtml(String(v))}"`,
+            )
+            .join(" ");
+          content += scriptContent
+            ? `<script ${attrs}>${scriptContent}</script>\n`
+            : `<script ${attrs}></script>\n`;
+        }
       }
     }
     return content;
   }
-  /**
-   * Render a meta tag.
-   */
-  protected renderMetaTag(meta: {
-    name?: string;
-    property?: string;
-    content: string;
-  }): string {
-    if (meta.property) {
-      return `<meta property="${this.escapeHtml(meta.property)}" content="${this.escapeHtml(meta.content)}">\n`;
-    }
-    if (meta.name) {
-      return `<meta name="${this.escapeHtml(meta.name)}" content="${this.escapeHtml(meta.content)}">\n`;
-    }
-    return "";
-  }
-  /**
-   * Render a link tag.
-   */
-  protected renderLinkTag(link: {
-    rel: string;
-    href: string;
-    type?: string;
-    as?: string;
-    crossorigin?: string;
-  }): string {
-    let tag = `<link rel="${this.escapeHtml(link.rel)}" href="${this.escapeHtml(link.href)}"`;
-    if (link.type) {
-      tag += ` type="${this.escapeHtml(link.type)}"`;
-    }
-    if (link.as) {
-      tag += ` as="${this.escapeHtml(link.as)}"`;
-    }
-    if (link.crossorigin != null) {
-      tag += ' crossorigin=""';
-    }
-    tag += ">\n";
-    return tag;
-  }
-  /**
-   * Render a script tag.
-   */
-  protected renderScriptTag(
-    script:
-      | string
-      | (Record<string, string | boolean | undefined> & { content?: string }),
-  ): string {
-    // Handle plain string as inline script
-    if (typeof script === "string") {
-      return `<script>${script}</script>\n`;
-    }
-    const { content, ...rest } = script;
-    const attrs = Object.entries(rest)
-      .filter(([, value]) => value !== false && value !== undefined)
-      .map(([key, value]) => {
-        if (value === true) return key;
-        return `${key}="${this.escapeHtml(String(value))}"`;
-      })
-      .join(" ");
-    if (content) {
-      return attrs
-        ? `<script ${attrs}>${content}</script>\n`
-        : `<script>${content}</script>\n`;
-    }
-    return `<script ${attrs}></script>\n`;
-  }
   /**
    * Escape HTML special characters.
    */
@@ -394,7 +165,6 @@ export class ReactServerTemplateProvider {
   /**
    * Safely serialize data to JSON for embedding in HTML.
-   * Escapes characters that could break out of script tags.
    */
   public safeJsonSerialize(data: unknown): string {
     return JSON.stringify(data)
@@ -405,19 +175,16 @@ export class ReactServerTemplateProvider {
   /**
    * Build hydration data from router state.
-   *
-   * This creates the data structure that will be serialized to window.__ssr
-   * for client-side rehydration.
    */
   public buildHydrationData(state: ReactRouterState): HydrationData {
     const { request, context, ...store } =
       this.alepha.context.als?.getStore() ?? {};
     const layers = state.layers.map((layer) => ({
-      part: layer.part, // mandatory for previous-checking
-      name: layer.name, // mandatory for previous-checking
-      config: layer.config, // mandatory for previous-checking (contains 'query' & 'params')
-      props: layer.props, // our not-so-secret data cache
+      part: layer.part,
+      name: layer.name,
+      config: layer.config,
+      props: layer.props,
       error: layer.error
         ? {
             ...layer.error,
@@ -428,9 +195,7 @@ export class ReactServerTemplateProvider {
         : undefined,
     }));
-    const hydrationData: HydrationData = {
-      layers,
-    };
+    const hydrationData: HydrationData = { layers };
     for (const [key, value] of Object.entries(store)) {
       if (
@@ -445,250 +210,101 @@ export class ReactServerTemplateProvider {
     return hydrationData;
   }
+  // ---------------------------------------------------------------------------
+  // Core streaming methods
+  // ---------------------------------------------------------------------------
   /**
-   * Stream the body content: body tag, root div, React content, hydration, and closing tags.
-   *
-   * If an error occurs during React streaming, it injects error HTML instead of aborting,
-   * ensuring users see an error message rather than a white screen.
+   * Pipe React stream to controller with backpressure handling.
+   * Returns true if stream completed successfully, false if error occurred.
    */
-  protected async streamBodyContent(
+  protected async pipeReactStream(
     controller: ReadableStreamDefaultController<Uint8Array>,
     reactStream: ReadableStream<Uint8Array>,
     state: ReactRouterState,
-    hydration: boolean,
-  ): Promise<void> {
-    const slots = this.getSlots();
-    const encoder = this.encoder;
-    const head = state.head;
-    // <body ...>
-    controller.enqueue(slots.bodyOpen);
-    controller.enqueue(
-      encoder.encode(this.renderMergedBodyAttrs(head?.bodyAttributes)),
-    );
-    controller.enqueue(slots.bodyClose);
-    // Content before root (if any)
-    if (slots.beforeRoot) {
-      controller.enqueue(encoder.encode(slots.beforeRoot));
-    }
-    // <div id="root">
-    controller.enqueue(slots.rootOpen);
-    // Stream React content - catch errors from the React stream
+  ): Promise<boolean> {
     const reader = reactStream.getReader();
-    let streamError: unknown = null;
     try {
       while (true) {
+        // Backpressure: wait if buffer is full
+        if (controller.desiredSize !== null && controller.desiredSize <= 0) {
+          await new Promise<void>((resolve) => queueMicrotask(resolve));
+        }
         const { done, value } = await reader.read();
         if (done) break;
         controller.enqueue(value);
       }
+      return true;
     } catch (error) {
-      // React stream errored - save for error HTML injection
-      streamError = error;
-      this.log.error("Error during React stream reading", error);
+      this.log.error("React stream error", error);
+      controller.enqueue(
+        this.encoder.encode(
+          this.renderErrorToString(
+            error instanceof Error ? error : new Error(String(error)),
+            state,
+          ),
+        ),
+      );
+      return false;
     } finally {
       reader.releaseLock();
     }
-    // If React stream errored, inject error HTML inside the root div
-    if (streamError) {
-      this.injectErrorHtml(controller, encoder, slots, streamError, state, {
-        headClosed: true,
-        bodyStarted: true,
-      });
-      // injectErrorHtml already closes the document, so return early
-      return;
-    }
-    // </div>
-    controller.enqueue(slots.rootClose);
-    // Content after root (if any)
-    if (slots.afterRoot) {
-      controller.enqueue(encoder.encode(slots.afterRoot));
-    }
-    // Hydration script
-    if (hydration) {
-      const hydrationData = this.buildHydrationData(state);
-      controller.enqueue(this.ENCODED.HYDRATION_PREFIX);
-      controller.enqueue(encoder.encode(this.safeJsonSerialize(hydrationData)));
-      controller.enqueue(this.ENCODED.HYDRATION_SUFFIX);
-    }
-    // </body></html>
-    controller.enqueue(slots.scriptClose);
   }
   /**
-   * Create a ReadableStream that streams the HTML template with React content.
-   *
-   * This is the main entry point for SSR streaming. It:
-   * 1. Sends <head> immediately (browser starts downloading assets)
-   * 2. Streams React content as it renders
-   * 3. Appends hydration script and closing tags
-   *
-   * @param reactStream - ReadableStream from renderToReadableStream
-   * @param state - Router state with head data
-   * @param options - Streaming options
+   * Stream complete HTML document (head already closed).
+   * Used by both createHtmlStream and late phase of createEarlyHtmlStream.
    */
-  public createHtmlStream(
+  protected async streamBodyAndClose(
+    controller: ReadableStreamDefaultController<Uint8Array>,
     reactStream: ReadableStream<Uint8Array>,
     state: ReactRouterState,
-    options: {
-      hydration?: boolean;
-      onError?: (error: unknown) => void;
-    } = {},
-  ): ReadableStream<Uint8Array> {
-    const { hydration = true, onError } = options;
-    const slots = this.getSlots();
-    const head = state.head;
-    const encoder = this.encoder;
-    return new ReadableStream<Uint8Array>({
-      start: async (controller) => {
-        try {
-          // DOCTYPE
-          controller.enqueue(slots.doctype);
-          // <html ...>
-          controller.enqueue(slots.htmlOpen);
-          controller.enqueue(
-            encoder.encode(this.renderMergedHtmlAttrs(head?.htmlAttributes)),
-          );
-          controller.enqueue(slots.htmlClose);
-          // <head>...</head>
-          controller.enqueue(slots.headOpen);
-          if (this.earlyHeadContent) {
-            controller.enqueue(encoder.encode(this.earlyHeadContent));
-          }
-          controller.enqueue(encoder.encode(this.renderHeadContent(head)));
-          controller.enqueue(slots.headClose);
-          // Body content (body, root, React, hydration, closing tags)
-          await this.streamBodyContent(
-            controller,
-            reactStream,
-            state,
-            hydration,
-          );
-          controller.close();
-        } catch (error) {
-          onError?.(error);
-          controller.error(error);
-        }
-      },
-    });
-  }
-  /**
-   * Early head content for preloading.
-   *
-   * Contains entry assets (JS + CSS) that are always required and can be
-   * sent before page loaders run.
-   */
-  protected earlyHeadContent: string = "";
-  /**
-   * Set the early head content (entry script + CSS).
-   *
-   * Also strips these assets from the original head content to avoid duplicates,
-   * since we're moving them to the early phase.
-   *
-   * Automatically prepends critical meta tags (charset, viewport) if not present
-   * in $head configuration, ensuring they're sent as early as possible.
-   *
-   * @param content - HTML string with entry assets
-   * @param globalHead - Global head configuration from $head primitives
-   * @param entryAssets - Entry asset paths to strip from original head
-   */
-  public setEarlyHeadContent(
-    content: string,
-    globalHead?: SimpleHead,
-    entryAssets?: { js?: string; css: string[] },
-  ): void {
-    // Build early content with critical meta tags first
-    const criticalMeta: string[] = [];
-    // Add charset - use custom value from $head or default to UTF-8
-    const charset = globalHead?.charset ?? "UTF-8";
-    criticalMeta.push(`<meta charset="${this.escapeHtml(charset)}">`);
+    hydration: boolean,
+  ): Promise<void> {
+    const { encoder, SLOTS: slots } = this;
-    // Add viewport - use custom value from $head or default
-    const viewport =
-      globalHead?.viewport ?? "width=device-width, initial-scale=1";
-    criticalMeta.push(
-      `<meta name="viewport" content="${this.escapeHtml(viewport)}">`,
+    // Body open
+    controller.enqueue(slots.BODY_OPEN);
+    controller.enqueue(
+      encoder.encode(this.renderAttributes(state.head?.bodyAttributes)),
     );
+    controller.enqueue(slots.BODY_CLOSE);
-    // Prepend critical meta tags before entry assets
-    this.earlyHeadContent =
-      criticalMeta.length > 0
-        ? `${criticalMeta.join("\n")}\n${content}`
-        : content;
-    // Strip entry assets from original head content to avoid duplicates
-    if (entryAssets && this.slots) {
-      let headContent = this.slots.headOriginalContent;
-      // Remove entry script tag
-      if (entryAssets.js) {
-        // Match script tag with this src (handles various attribute orders)
-        const scriptPattern = new RegExp(
-          `<script[^>]*\\ssrc=["']${this.escapeRegExp(entryAssets.js)}["'][^>]*>\\s*</script>\\s*`,
-          "gi",
-        );
-        headContent = headContent.replace(scriptPattern, "");
-      }
-      // Remove entry CSS link tags
-      for (const css of entryAssets.css) {
-        const linkPattern = new RegExp(
-          `<link[^>]*\\shref=["']${this.escapeRegExp(css)}["'][^>]*>\\s*`,
-          "gi",
-        );
-        headContent = headContent.replace(linkPattern, "");
-      }
+    // Root + React content
+    controller.enqueue(slots.ROOT_OPEN);
+    await this.pipeReactStream(controller, reactStream, state);
+    controller.enqueue(slots.ROOT_CLOSE);
-      this.slots.headOriginalContent = headContent.trim();
+    // Hydration
+    if (hydration) {
+      controller.enqueue(slots.HYDRATION_PREFIX);
+      controller.enqueue(
+        encoder.encode(this.safeJsonSerialize(this.buildHydrationData(state))),
+      );
+      controller.enqueue(slots.HYDRATION_SUFFIX);
     }
-  }
-  /**
-   * Escape special regex characters in a string.
-   */
-  protected escapeRegExp(str: string): string {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    controller.enqueue(slots.BODY_HTML_CLOSE);
   }
+  // ---------------------------------------------------------------------------
+  // Public streaming APIs
+  // ---------------------------------------------------------------------------
   /**
-   * Create an optimized HTML stream with early head streaming.
-   *
-   * This version sends critical assets (entry.js, CSS) BEFORE page loaders run,
-   * allowing the browser to start downloading them immediately.
+   * Create HTML stream with early head optimization.
    *
    * Flow:
    * 1. Send DOCTYPE, <html>, <head> open, entry preloads (IMMEDIATE)
-   * 2. Run async work (createLayers, etc.)
+   * 2. Run async work (page loaders)
    * 3. Send rest of head, body, React content, hydration
-   *
-   * @param globalHead - Global head with htmlAttributes (from $head primitives)
-   * @param asyncWork - Async function to run between early head and rest of stream
-   * @param options - Streaming options
    */
   public createEarlyHtmlStream(
     globalHead: SimpleHead,
     asyncWork: () => Promise<
-      | {
-          state: ReactRouterState;
-          reactStream: ReadableStream<Uint8Array>;
-        }
+      | { state: ReactRouterState; reactStream: ReadableStream<Uint8Array> }
       | { redirect: string }
       | null
     >,
@@ -698,10 +314,8 @@ export class ReactServerTemplateProvider {
     } = {},
   ): ReadableStream<Uint8Array> {
     const { hydration = true, onError } = options;
-    const slots = this.getSlots();
-    const encoder = this.encoder;
+    const { encoder, SLOTS: slots } = this;
-    // Track streaming state for error recovery
     let headClosed = false;
     let bodyStarted = false;
     let routerState: ReactRouterState | undefined;
@@ -710,42 +324,33 @@ export class ReactServerTemplateProvider {
       start: async (controller) => {
         try {
           // === EARLY PHASE (before async work) ===
-          // DOCTYPE
-          controller.enqueue(slots.doctype);
-          // <html ...> with global htmlAttributes only
-          controller.enqueue(slots.htmlOpen);
+          controller.enqueue(slots.DOCTYPE);
+          controller.enqueue(slots.HTML_OPEN);
           controller.enqueue(
-            encoder.encode(
-              this.renderMergedHtmlAttrs(globalHead?.htmlAttributes),
-            ),
+            encoder.encode(this.renderAttributes(globalHead?.htmlAttributes)),
           );
-          controller.enqueue(slots.htmlClose);
-          // <head> open + entry preloads
-          controller.enqueue(slots.headOpen);
+          controller.enqueue(slots.HTML_CLOSE);
+          controller.enqueue(slots.HEAD_OPEN);
           if (this.earlyHeadContent) {
             controller.enqueue(encoder.encode(this.earlyHeadContent));
           }
-          // === ASYNC WORK (createLayers, etc.) ===
+          // === ASYNC WORK ===
           const result = await asyncWork();
-          // Handle redirect - inject meta refresh since headers already sent
+          // Handle redirect
           if (!result || "redirect" in result) {
             if (result && "redirect" in result) {
-              this.log.debug(
-                "Loader redirect detected after streaming started, using meta refresh",
-                { redirect: result.redirect },
-              );
+              this.log.debug("Loader redirect, using meta refresh", {
+                redirect: result.redirect,
+              });
               controller.enqueue(
                 encoder.encode(
                   `<meta http-equiv="refresh" content="0; url=${this.escapeHtml(result.redirect)}">\n`,
                 ),
               );
             }
-            controller.enqueue(slots.headClose);
+            controller.enqueue(slots.HEAD_CLOSE);
             controller.enqueue(encoder.encode("<body></body></html>"));
             controller.close();
             return;
@@ -755,43 +360,29 @@ export class ReactServerTemplateProvider {
           routerState = state;
           // === LATE PHASE (after async work) ===
-          // Rest of head content (title, meta, links from loaders)
           controller.enqueue(
             encoder.encode(this.renderHeadContent(state.head)),
           );
-          controller.enqueue(slots.headClose);
+          controller.enqueue(slots.HEAD_CLOSE);
           headClosed = true;
-          // Body content (body, root, React, hydration, closing tags)
           bodyStarted = true;
-          await this.streamBodyContent(
+          await this.streamBodyAndClose(
             controller,
             reactStream,
             state,
             hydration,
           );
           controller.close();
         } catch (error) {
           onError?.(error);
-          // Instead of aborting the stream, inject error HTML so user sees
-          // an error message instead of white screen.
-          // React 19 streaming SSR doesn't reliably trigger ErrorBoundary,
-          // so we must handle it at the stream level.
           try {
-            this.injectErrorHtml(
-              controller,
-              encoder,
-              slots,
-              error,
-              routerState,
-              { headClosed, bodyStarted },
-            );
+            this.injectErrorHtml(controller, error, routerState, {
+              headClosed,
+              bodyStarted,
+            });
             controller.close();
           } catch {
-            // If error injection fails, abort as last resort
             controller.error(error);
           }
         }
@@ -800,116 +391,123 @@ export class ReactServerTemplateProvider {
   }
   /**
-   * Inject error HTML into the stream when an error occurs during streaming.
-   *
-   * Uses the router state's onError handler to render the error component,
-   * falling back to ErrorViewer if no custom handler is defined.
-   * Renders using renderToString to produce static HTML.
-   *
-   * Since we may have already sent partial HTML (DOCTYPE, <html>, <head>),
-   * we need to complete the document with an error message instead of aborting.
-   *
-   * Handles different states:
-   * - headClosed=false, bodyStarted=false: Need to add head content, close head, open body, add error, close all
-   * - headClosed=true, bodyStarted=false: Need to open body, add error, close all
-   * - headClosed=true, bodyStarted=true: Already inside root div, add error, close all
+   * Create HTML stream (non-early version, for testing/prerender).
+   */
+  public createHtmlStream(
+    reactStream: ReadableStream<Uint8Array>,
+    state: ReactRouterState,
+    options: { hydration?: boolean; onError?: (error: unknown) => void } = {},
+  ): ReadableStream<Uint8Array> {
+    const { hydration = true, onError } = options;
+    const { encoder, SLOTS: slots } = this;
+    return new ReadableStream<Uint8Array>({
+      start: async (controller) => {
+        try {
+          // Head
+          controller.enqueue(slots.DOCTYPE);
+          controller.enqueue(slots.HTML_OPEN);
+          controller.enqueue(
+            encoder.encode(this.renderAttributes(state.head?.htmlAttributes)),
+          );
+          controller.enqueue(slots.HTML_CLOSE);
+          controller.enqueue(slots.HEAD_OPEN);
+          if (this.earlyHeadContent) {
+            controller.enqueue(encoder.encode(this.earlyHeadContent));
+          }
+          controller.enqueue(
+            encoder.encode(this.renderHeadContent(state.head)),
+          );
+          controller.enqueue(slots.HEAD_CLOSE);
+          // Body (shared logic)
+          await this.streamBodyAndClose(
+            controller,
+            reactStream,
+            state,
+            hydration,
+          );
+          controller.close();
+        } catch (error) {
+          onError?.(error);
+          controller.error(error);
+        }
+      },
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Error handling
+  // ---------------------------------------------------------------------------
+  /**
+   * Inject error HTML when streaming fails.
    */
   protected injectErrorHtml(
     controller: ReadableStreamDefaultController<Uint8Array>,
-    encoder: TextEncoder,
-    slots: TemplateSlots,
     error: unknown,
     routerState: ReactRouterState | undefined,
     streamState: { headClosed: boolean; bodyStarted: boolean },
   ): void {
-    // If head not closed, add remaining head content first
+    const { encoder, SLOTS: slots } = this;
     if (!streamState.headClosed) {
-      // Include original head content (CSS, scripts) and any head from router state
-      const headContent = this.renderHeadContent(routerState?.head);
-      if (headContent) {
-        controller.enqueue(encoder.encode(headContent));
-      }
-      controller.enqueue(slots.headClose);
+      controller.enqueue(
+        encoder.encode(this.renderHeadContent(routerState?.head)),
+      );
+      controller.enqueue(slots.HEAD_CLOSE);
     }
-    // If body hasn't started, we need to open body and root div
     if (!streamState.bodyStarted) {
-      // Open body with any body attributes from state
-      controller.enqueue(slots.bodyOpen);
+      controller.enqueue(slots.BODY_OPEN);
       controller.enqueue(
         encoder.encode(
-          this.renderMergedBodyAttrs(routerState?.head?.bodyAttributes),
+          this.renderAttributes(routerState?.head?.bodyAttributes),
         ),
       );
-      controller.enqueue(slots.bodyClose);
-      // Content before root (if any)
-      if (slots.beforeRoot) {
-        controller.enqueue(encoder.encode(slots.beforeRoot));
-      }
-      controller.enqueue(slots.rootOpen);
+      controller.enqueue(slots.BODY_CLOSE);
+      controller.enqueue(slots.ROOT_OPEN);
     }
-    // Try to render error using router state's error handler
-    const errorHtml = this.renderErrorToString(
-      error instanceof Error ? error : new Error(String(error)),
-      routerState,
+    controller.enqueue(
+      encoder.encode(
+        this.renderErrorToString(
+          error instanceof Error ? error : new Error(String(error)),
+          routerState,
+        ),
+      ),
     );
-    controller.enqueue(encoder.encode(errorHtml));
-    // Close root div
-    controller.enqueue(slots.rootClose);
-    // Content after root (if any)
-    if (!streamState.bodyStarted && slots.afterRoot) {
-      controller.enqueue(encoder.encode(slots.afterRoot));
-    }
-    // Close document
-    controller.enqueue(slots.scriptClose);
+    controller.enqueue(slots.ROOT_CLOSE);
+    controller.enqueue(slots.BODY_HTML_CLOSE);
   }
   /**
-   * Render an error to HTML string using the router's error handler.
-   *
-   * Falls back to ErrorViewer if:
-   * - No router state is available
-   * - The error handler returns null/undefined
-   * - The error handler itself throws
+   * Render error to HTML string.
    */
   protected renderErrorToString(
     error: Error,
     routerState: ReactRouterState | undefined,
   ): string {
-    // Log the error with stack trace for debugging
     this.log.error("SSR rendering error", error);
     let errorElement: ReactNode;
-    // Try to use the router state's error handler
     if (routerState?.onError) {
       try {
         const result = routerState.onError(error, routerState);
-        // If handler returns a Redirection, we can't handle it (headers already sent)
-        // Log and fall through to default error viewer
         if (result instanceof Redirection) {
-          this.log.warn(
-            "Error handler returned Redirection but headers already sent",
-            { redirect: result.redirect },
-          );
-        } else if (result !== null && result !== undefined) {
+          this.log.warn("Error handler returned Redirection but headers sent", {
+            redirect: result.redirect,
+          });
+        } else if (result != null) {
           errorElement = result;
         }
       } catch (handlerError) {
-        this.log.error("Error handler threw an exception", handlerError);
-        // Fall through to default error viewer
+        this.log.error("Error handler threw", handlerError);
       }
     }
-    // Fall back to ErrorViewer if no element was produced
     if (!errorElement) {
       errorElement = createElement(ErrorViewer, {
         error,
@@ -917,7 +515,6 @@ export class ReactServerTemplateProvider {
       });
     }
-    // Wrap in AlephaContext.Provider so any components that need it can access it
     const wrappedElement = createElement(
       AlephaContext.Provider,
       { value: this.alepha },
@@ -927,53 +524,19 @@ export class ReactServerTemplateProvider {
     try {
       return renderToString(wrappedElement);
     } catch (renderError) {
-      // If renderToString fails, return minimal fallback HTML
       this.log.error("Failed to render error component", renderError);
       return error.message;
     }
   }
 }
-// ---------------------------------------------------------------------------------------------------------------------
-/**
- * Template slots - the template split into logical parts for efficient streaming.
- *
- * Static parts are pre-encoded as Uint8Array for zero-copy streaming.
- * Dynamic parts (attributes, head content) are kept as strings/objects for merging.
- */
-export interface TemplateSlots {
-  // Pre-encoded static parts
-  doctype: Uint8Array;
-  htmlOpen: Uint8Array; // "<html"
-  htmlClose: Uint8Array; // ">"
-  headOpen: Uint8Array; // "<head>"
-  headClose: Uint8Array; // "</head>"
-  bodyOpen: Uint8Array; // "<body"
-  bodyClose: Uint8Array; // ">"
-  rootOpen: Uint8Array; // '<div id="root">'
-  rootClose: Uint8Array; // "</div>"
-  scriptClose: Uint8Array; // "</body></html>"
-  // Original content (kept for merging)
-  htmlOriginalAttrs: Record<string, string>;
-  bodyOriginalAttrs: Record<string, string>;
-  headOriginalContent: string;
-  beforeRoot: string; // content between <body> and root div
-  afterRoot: string; // content between root div and </body>
-}
 /**
- * Hydration state that gets serialized to window.__ssr
+ * Hydration state serialized to window.__ssr
  */
 export interface HydrationData {
   layers: Array<{
     data?: unknown;
-    error?: {
-      name: string;
-      message: string;
-      stack?: string;
-    };
+    error?: { name: string; message: string; stack?: string };
   }>;
   [key: string]: unknown;
 }