@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/interactive.js

@@ -0,0 +1,383 @@
+import fs from "node:fs";
+import path from "node:path";
+import * as readline from "node:readline";
+import { processExpressions } from "./expressions.js";
+import { processDirectives } from "./process.js";
+const c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m"
+}, commands = {
+  help: {
+    description: "Show available commands",
+    usage: "help [command]",
+    handler: async (args, _state) => {
+      if (args[0] && commands[args[0]]) {
+        const cmd = commands[args[0]];
+        console.log(`
+${c.bold}${args[0]}${c.reset} - ${cmd.description}`);
+        console.log(`  Usage: ${c.cyan}${cmd.usage}${c.reset}
+`);
+      } else {
+        console.log(`
+${c.bold}Available Commands:${c.reset}
+`);
+        for (const [name, cmd] of Object.entries(commands))
+          console.log(`  ${c.cyan}${name.padEnd(12)}${c.reset} ${cmd.description}`);
+        console.log(`
+${c.dim}Type 'help <command>' for more details${c.reset}
+`);
+      }
+    }
+  },
+  render: {
+    description: "Render a template file",
+    usage: "render <file> [--raw]",
+    handler: async (args, state) => {
+      if (!args[0]) {
+        console.log(`${c.red}Error: Please specify a file to render${c.reset}`);
+        return;
+      }
+      const filePath = path.resolve(state.cwd, args[0]);
+      if (!await Bun.file(filePath).exists()) {
+        console.log(`${c.red}Error: File not found: ${filePath}${c.reset}`);
+        return;
+      }
+      try {
+        const content = await Bun.file(filePath).text(), showRaw = args.includes("--raw");
+        console.log(`
+${c.dim}Rendering ${filePath}...${c.reset}
+`);
+        const result = await processDirectives(content, state.context, filePath, {}, new Set);
+        state.lastResult = result;
+        if (showRaw)
+          console.log(result);
+        else
+          result.split(`
+`).forEach((line, i) => {
+            const lineNum = String(i + 1).padStart(3, " ");
+            console.log(`${c.dim}${lineNum}${c.reset} ${line}`);
+          });
+        console.log();
+      } catch (error) {
+        console.log(`${c.red}Error rendering template:${c.reset}`, error);
+      }
+    }
+  },
+  eval: {
+    description: "Evaluate an expression",
+    usage: "eval <expression>",
+    handler: async (args, state) => {
+      if (!args.length) {
+        console.log(`${c.red}Error: Please provide an expression to evaluate${c.reset}`);
+        return;
+      }
+      const expr = args.join(" ");
+      try {
+        const template = `{{ ${expr} }}`, output = (await processExpressions(template, state.context, "eval")).trim();
+        state.lastResult = output;
+        console.log(`${c.green}\u2192${c.reset} ${output}`);
+      } catch (error) {
+        console.log(`${c.red}Error:${c.reset}`, error);
+      }
+    }
+  },
+  set: {
+    description: "Set a context variable",
+    usage: "set <key> <value>",
+    handler: async (args, state) => {
+      if (args.length < 2) {
+        console.log(`${c.red}Error: Usage: set <key> <value>${c.reset}`);
+        return;
+      }
+      const key = args[0], valueStr = args.slice(1).join(" ");
+      let value;
+      try {
+        value = JSON.parse(valueStr);
+      } catch {
+        value = valueStr;
+      }
+      state.context[key] = value;
+      console.log(`${c.green}\u2713${c.reset} ${key} = ${JSON.stringify(value)}`);
+    }
+  },
+  unset: {
+    description: "Remove a context variable",
+    usage: "unset <key>",
+    handler: async (args, state) => {
+      if (!args[0]) {
+        console.log(`${c.red}Error: Please specify a variable to remove${c.reset}`);
+        return;
+      }
+      if (args[0] in state.context) {
+        delete state.context[args[0]];
+        console.log(`${c.green}\u2713${c.reset} Removed ${args[0]}`);
+      } else
+        console.log(`${c.yellow}Variable not found: ${args[0]}${c.reset}`);
+    }
+  },
+  context: {
+    description: "Show current context variables",
+    usage: "context",
+    handler: async (_args, state) => {
+      const keys = Object.keys(state.context);
+      if (keys.length === 0) {
+        console.log(`${c.dim}Context is empty${c.reset}`);
+        return;
+      }
+      console.log(`
+${c.bold}Context Variables:${c.reset}
+`);
+      for (const key of keys) {
+        const value = state.context[key], type = Array.isArray(value) ? "array" : typeof value, preview = JSON.stringify(value).slice(0, 50);
+        console.log(`  ${c.cyan}${key}${c.reset} ${c.dim}(${type})${c.reset}: ${preview}${preview.length >= 50 ? "..." : ""}`);
+      }
+      console.log();
+    }
+  },
+  clear: {
+    description: "Clear context or screen",
+    usage: "clear [context|screen]",
+    handler: async (args, state) => {
+      if (args[0] === "context" || !args[0]) {
+        state.context = {};
+        console.log(`${c.green}\u2713${c.reset} Context cleared`);
+      }
+      if (args[0] === "screen" || !args[0])
+        console.clear();
+    }
+  },
+  cd: {
+    description: "Change working directory",
+    usage: "cd <directory>",
+    handler: async (args, state) => {
+      if (!args[0]) {
+        console.log(`${c.cyan}${state.cwd}${c.reset}`);
+        return;
+      }
+      const newPath = path.resolve(state.cwd, args[0]);
+      if (!fs.existsSync(newPath)) {
+        console.log(`${c.red}Error: Directory not found: ${newPath}${c.reset}`);
+        return;
+      }
+      if (!fs.statSync(newPath).isDirectory()) {
+        console.log(`${c.red}Error: Not a directory: ${newPath}${c.reset}`);
+        return;
+      }
+      state.cwd = newPath;
+      console.log(`${c.green}\u2713${c.reset} ${newPath}`);
+    }
+  },
+  ls: {
+    description: "List files in current directory",
+    usage: "ls [pattern]",
+    handler: async (args, state) => {
+      const pattern = args[0] || "*", glob = new Bun.Glob(pattern), files = [];
+      for await (const file of glob.scan({ cwd: state.cwd, onlyFiles: !1 }))
+        files.push(file);
+      if (files.length === 0) {
+        console.log(`${c.dim}No files found${c.reset}`);
+        return;
+      }
+      files.sort();
+      const stxFiles = files.filter((f) => f.endsWith(".stx")), mdFiles = files.filter((f) => f.endsWith(".md")), otherFiles = files.filter((f) => !f.endsWith(".stx") && !f.endsWith(".md"));
+      if (stxFiles.length > 0) {
+        console.log(`
+${c.bold}Templates:${c.reset}`);
+        stxFiles.forEach((f) => console.log(`  ${c.green}${f}${c.reset}`));
+      }
+      if (mdFiles.length > 0) {
+        console.log(`
+${c.bold}Markdown:${c.reset}`);
+        mdFiles.forEach((f) => console.log(`  ${c.blue}${f}${c.reset}`));
+      }
+      if (otherFiles.length > 0) {
+        console.log(`
+${c.bold}Other:${c.reset}`);
+        otherFiles.forEach((f) => console.log(`  ${c.dim}${f}${c.reset}`));
+      }
+      console.log();
+    }
+  },
+  cat: {
+    description: "Show file contents",
+    usage: "cat <file>",
+    handler: async (args, state) => {
+      if (!args[0]) {
+        console.log(`${c.red}Error: Please specify a file${c.reset}`);
+        return;
+      }
+      const filePath = path.resolve(state.cwd, args[0]);
+      if (!await Bun.file(filePath).exists()) {
+        console.log(`${c.red}Error: File not found: ${filePath}${c.reset}`);
+        return;
+      }
+      const lines = (await Bun.file(filePath).text()).split(`
+`);
+      console.log();
+      lines.forEach((line, i) => {
+        const lineNum = String(i + 1).padStart(3, " ");
+        console.log(`${c.dim}${lineNum}${c.reset} ${line}`);
+      });
+      console.log();
+    }
+  },
+  load: {
+    description: "Load context from JSON file",
+    usage: "load <file.json>",
+    handler: async (args, state) => {
+      if (!args[0]) {
+        console.log(`${c.red}Error: Please specify a JSON file${c.reset}`);
+        return;
+      }
+      const filePath = path.resolve(state.cwd, args[0]);
+      if (!await Bun.file(filePath).exists()) {
+        console.log(`${c.red}Error: File not found: ${filePath}${c.reset}`);
+        return;
+      }
+      try {
+        const content = await Bun.file(filePath).text(), data = JSON.parse(content);
+        state.context = { ...state.context, ...data };
+        console.log(`${c.green}\u2713${c.reset} Loaded ${Object.keys(data).length} variables from ${args[0]}`);
+      } catch (error) {
+        console.log(`${c.red}Error parsing JSON:${c.reset}`, error);
+      }
+    }
+  },
+  save: {
+    description: "Save context to JSON file",
+    usage: "save <file.json>",
+    handler: async (args, state) => {
+      if (!args[0]) {
+        console.log(`${c.red}Error: Please specify a file name${c.reset}`);
+        return;
+      }
+      const filePath = path.resolve(state.cwd, args[0]);
+      try {
+        await Bun.write(filePath, JSON.stringify(state.context, null, 2));
+        console.log(`${c.green}\u2713${c.reset} Context saved to ${args[0]}`);
+      } catch (error) {
+        console.log(`${c.red}Error saving file:${c.reset}`, error);
+      }
+    }
+  },
+  history: {
+    description: "Show command history",
+    usage: "history [count]",
+    handler: async (args, state) => {
+      const count = args[0] ? Number.parseInt(args[0], 10) : 20, entries = state.history.slice(-count);
+      if (entries.length === 0) {
+        console.log(`${c.dim}No history${c.reset}`);
+        return;
+      }
+      console.log();
+      entries.forEach((cmd, i) => {
+        const num = String(state.history.length - entries.length + i + 1).padStart(3, " ");
+        console.log(`${c.dim}${num}${c.reset} ${cmd}`);
+      });
+      console.log();
+    }
+  },
+  exit: {
+    description: "Exit interactive mode",
+    usage: "exit",
+    handler: async (_args, state) => {
+      state.running = !1;
+      console.log(`
+${c.dim}Goodbye!${c.reset}
+`);
+    }
+  },
+  quit: {
+    description: "Exit interactive mode (alias for exit)",
+    usage: "quit",
+    handler: async (args, state) => commands.exit.handler(args, state)
+  }
+};
+function getCompletions(line, state) {
+  const parts = line.split(" "), cmd = parts[0];
+  if (parts.length === 1)
+    return Object.keys(commands).filter((c) => c.startsWith(cmd));
+  if (["render", "cat", "load", "cd"].includes(cmd)) {
+    const partial = parts.slice(1).join(" "), dir = path.dirname(partial) || ".", prefix = path.basename(partial), searchDir = path.resolve(state.cwd, dir);
+    if (fs.existsSync(searchDir) && fs.statSync(searchDir).isDirectory())
+      try {
+        return fs.readdirSync(searchDir).filter((f) => f.startsWith(prefix)).map((f) => `${cmd} ${dir === "." ? "" : `${dir}/`}${f}`);
+      } catch {
+        return [];
+      }
+  }
+  if (["unset", "eval", "set"].includes(cmd)) {
+    const partial = parts[1] || "";
+    return Object.keys(state.context).filter((k) => k.startsWith(partial)).map((k) => `${cmd} ${k}`);
+  }
+  return [];
+}
+export async function startInteractive(options = {}) {
+  const state = {
+    context: options.context || {},
+    cwd: options.cwd || process.cwd(),
+    history: [],
+    running: !0,
+    lastResult: null
+  }, rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    completer: (line) => {
+      return [getCompletions(line, state), line];
+    },
+    historySize: options.maxHistory || 100
+  });
+  console.log(`
+${c.bold}${c.blue}stx Interactive Mode${c.reset}
+${c.dim}Type 'help' for available commands, 'exit' to quit${c.reset}
+`);
+  const prompt = () => {
+    const cwdShort = state.cwd.replace(process.env.HOME || "", "~");
+    rl.question(`${c.cyan}stx${c.reset} ${c.dim}${cwdShort}${c.reset} ${c.green}>${c.reset} `, async (input) => {
+      const line = input.trim();
+      if (!line) {
+        if (state.running)
+          prompt();
+        return;
+      }
+      state.history.push(line);
+      const parts = line.match(/(?:[^\s"]|"[^"]*")+/g) || [], cmd = parts[0]?.toLowerCase(), args = parts.slice(1).map((a) => a.replace(/^"|"$/g, ""));
+      if (cmd && commands[cmd])
+        try {
+          await commands[cmd].handler(args, state);
+        } catch (error) {
+          console.log(`${c.red}Error:${c.reset}`, error);
+        }
+      else if (cmd)
+        if (line.includes("{{") || line.includes("}}"))
+          try {
+            const result = await processExpressions(line, state.context, "eval");
+            console.log(`${c.green}\u2192${c.reset} ${result}`);
+          } catch {
+            console.log(`${c.red}Unknown command: ${cmd}${c.reset}`);
+            console.log(`${c.dim}Type 'help' for available commands${c.reset}`);
+          }
+        else {
+          console.log(`${c.red}Unknown command: ${cmd}${c.reset}`);
+          console.log(`${c.dim}Type 'help' for available commands${c.reset}`);
+        }
+      if (state.running)
+        prompt();
+      else
+        rl.close();
+    });
+  };
+  rl.on("SIGINT", () => {
+    console.log(`
+${c.dim}(Use 'exit' to quit)${c.reset}`);
+    prompt();
+  });
+  prompt();
+}

package/dist/internal-markdown.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Internal markdown utilities to replace ts-md dependency
+ * Provides frontmatter parsing and markdown to HTML conversion
+ */
+export interface FrontmatterResult {
+    data: Record<string, unknown>;
+    content: string;
+}
+export interface MarkdownOptions {
+    gfm?: boolean;
+    breaks?: boolean;
+}
+/**
+ * Parse YAML frontmatter from markdown content
+ * Frontmatter is delimited by --- at the start of the file
+ */
+export declare function parseFrontmatter(content: string): FrontmatterResult;
+/**
+ * Convert markdown to HTML
+ * Simple implementation that handles common markdown patterns
+ */
+export declare function parseMarkdown(content: string, options?: MarkdownOptions): string;

package/dist/internal-markdown.js

@@ -0,0 +1,141 @@
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function isSafeUrl(url) {
+  const trimmed = url.trim().toLowerCase();
+  return !trimmed.startsWith("javascript:") && !trimmed.startsWith("vbscript:") && !trimmed.startsWith("data:text/html");
+}
+export function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---\r?\n/, match = content.match(frontmatterRegex);
+  if (!match)
+    return {
+      data: {},
+      content: content.trim()
+    };
+  const yamlContent = match[1], markdownContent = content.slice(match[0].length), data = {};
+  for (const line of yamlContent.split(`
+`)) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine || trimmedLine.startsWith("#"))
+      continue;
+    const colonIndex = trimmedLine.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    const key = trimmedLine.slice(0, colonIndex).trim();
+    let value = trimmedLine.slice(colonIndex + 1).trim();
+    if (typeof value === "string") {
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))
+        value = value.slice(1, -1);
+      else if (value.startsWith("[") && value.endsWith("]"))
+        try {
+          value = JSON.parse(value);
+        } catch {}
+      else if (value === "true")
+        value = !0;
+      else if (value === "false")
+        value = !1;
+      else if (/^-?\d+(?:\.\d+)?$/.test(value))
+        value = Number(value);
+    }
+    data[key] = value;
+  }
+  return {
+    data,
+    content: markdownContent.trim()
+  };
+}
+export function parseMarkdown(content, options = {}) {
+  const { gfm = !0, breaks = !1 } = options;
+  let html = content;
+  const codeBlocks = [];
+  html = html.replace(/```(\w*)\n([\s\S]*?)```/g, (_match, lang, code) => {
+    const index = codeBlocks.length, langAttr = lang ? ` class="language-${escapeHtml(lang)}"` : "";
+    codeBlocks.push(`<pre><code${langAttr}>${escapeHtml(code.trim())}</code></pre>`);
+    return `\x00CODEBLOCK${index}\x00`;
+  });
+  html = html.replace(/`([^`]*)`/g, (_m, code) => `<code>${escapeHtml(code)}</code>`);
+  html = html.replace(/^######\s+(.*)$/gm, "<h6>$1</h6>");
+  html = html.replace(/^#####\s+(.*)$/gm, "<h5>$1</h5>");
+  html = html.replace(/^####\s+(.*)$/gm, "<h4>$1</h4>");
+  html = html.replace(/^###\s+(.*)$/gm, "<h3>$1</h3>");
+  html = html.replace(/^##\s+(.*)$/gm, "<h2>$1</h2>");
+  html = html.replace(/^#\s+(.*)$/gm, "<h1>$1</h1>");
+  html = html.replace(/\*\*\*(.+?)\*\*\*/g, "<strong><em>$1</em></strong>");
+  html = html.replace(/___(.+?)___/g, "<strong><em>$1</em></strong>");
+  html = html.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+  html = html.replace(/__(.+?)__/g, "<strong>$1</strong>");
+  html = html.replace(/\*(.+?)\*/g, "<em>$1</em>");
+  html = html.replace(/(?<![a-zA-Z0-9])_(.+?)_(?![a-zA-Z0-9])/g, "<em>$1</em>");
+  if (gfm)
+    html = html.replace(/~~(.+?)~~/g, "<del>$1</del>");
+  html = html.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (_m, alt, url) => {
+    return `<img src="${isSafeUrl(url) ? escapeHtml(url) : ""}" alt="${escapeHtml(alt)}" />`;
+  });
+  html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, text, url) => {
+    return `<a href="${isSafeUrl(url) ? escapeHtml(url) : ""}">${text}</a>`;
+  });
+  html = html.replace(/^(?:---|\*\*\*|___)\s*$/gm, "<hr />");
+  html = html.replace(/^>\s+(.*)$/gm, "<blockquote>$1</blockquote>");
+  html = html.replace(/<\/blockquote>\n<blockquote>/g, `
+`);
+  html = html.replace(/^[*\-+]\s+(.*)$/gm, "<li data-ul>$1</li>");
+  html = html.replace(/(<li data-ul>.*<\/li>\n?)+/g, "<ul>$&</ul>");
+  html = html.replace(/<\/ul>\n<ul>/g, "");
+  html = html.replace(/^\d+\.\s+(.*)$/gm, "<li data-ol>$1</li>");
+  html = html.replace(/(<li data-ol>.*<\/li>\n?)+/g, "<ol>$&</ol>");
+  html = html.replace(/<\/ol>\n<ol>/g, "");
+  html = html.replace(/<li data-ul>/g, "<li>");
+  html = html.replace(/<li data-ol>/g, "<li>");
+  if (gfm)
+    html = html.replace(/^\|(.+)\|\s*\n\|[-:\s|]+\|\s*\n((?:\|.+\|\s*\n)*)/gm, (_match, header, body) => {
+      const headerRow = `<tr>${header.split("|").map((h) => h.trim()).filter(Boolean).map((h) => `<th>${escapeHtml(h)}</th>`).join("")}</tr>`, bodyRows = body.trim().split(`
+`).map((row) => {
+        return `<tr>${row.split("|").map((c) => c.trim()).filter(Boolean).map((c) => `<td>${escapeHtml(c)}</td>`).join("")}</tr>`;
+      }).join(`
+`);
+      return `<table>
+<thead>
+${headerRow}
+</thead>
+<tbody>
+${bodyRows}
+</tbody>
+</table>`;
+    });
+  if (gfm) {
+    html = html.replace(/<li>\s*\[\s*\]\s*/g, '<li><input type="checkbox" disabled /> ');
+    html = html.replace(/<li>\s*\[x\]\s*/gi, '<li><input type="checkbox" checked disabled /> ');
+  }
+  const lines = html.split(`
+`), processedLines = [];
+  let inParagraph = !1, paragraphContent = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (/^<(?:h[1-6]|ul|ol|li|blockquote|pre|table|thead|tbody|tr|th|td|hr|div|p)/.test(trimmed) || /^\0CODEBLOCK\d+\0$/.test(trimmed) || trimmed === "") {
+      if (inParagraph && paragraphContent.length > 0) {
+        processedLines.push(`<p>${paragraphContent.join(breaks ? `<br />
+` : `
+`)}</p>`);
+        paragraphContent = [];
+        inParagraph = !1;
+      }
+      processedLines.push(line);
+    } else {
+      inParagraph = !0;
+      paragraphContent.push(trimmed);
+    }
+  }
+  if (inParagraph && paragraphContent.length > 0)
+    processedLines.push(`<p>${paragraphContent.join(breaks ? `<br />
+` : `
+`)}</p>`);
+  html = processedLines.join(`
+`);
+  if (breaks)
+    html = html.replace(/\n/g, `<br />
+`);
+  for (let i = 0;i < codeBlocks.length; i++)
+    html = html.replace(`\x00CODEBLOCK${i}\x00`, codeBlocks[i]);
+  html = html.replace(/<p>\s*<\/p>/g, "");
+  return html.trim();
+}

package/dist/island-chunking.d.ts

@@ -0,0 +1,48 @@
+/** One extracted island chunk: a content hash and the IIFE it holds. */
+export interface IslandChunk {
+    /** Content hash of `code` — the chunk's filename stem (`/_stx/islands/<hash>.js`). */
+    hash: string;
+    /** The island setup IIFE (trimmed) to write to the chunk file. */
+    code: string;
+}
+export interface ExtractIslandChunksResult {
+    /** HTML with each inline island IIFE replaced by a `data-stx-src` reference. */
+    html: string;
+    /** The unique chunks to write (deduped by content hash within the page). */
+    chunks: IslandChunk[];
+}
+export interface ExtractIslandChunksOptions {
+    /**
+     * Stamp `data-stx-integrity="sha384-…"` (Subresource Integrity) on each
+     * chunked tag so the runtime can pin the chunk against tampering and a strict
+     * CSP can require SRI. Default `false` — only enable when chunks are served
+     * byte-for-byte unchanged (no CDN/proxy transform), else the hash won't match
+     * and the island silently won't hydrate.
+     */
+    integrity?: boolean;
+    /**
+     * Minify each chunk's JS (whitespace only) before hashing/writing, so the
+     * lazily-loaded bytes aren't padded with source whitespace. Default `false`;
+     * the SSG passes its `minify` flag. Hashing happens over the minified bytes,
+     * so the content hash + SRI always match what's served.
+     */
+    minify?: boolean;
+}
+/**
+ * Lift inline island IIFEs into content-hashed chunks. Pure: no filesystem
+ * access — the caller writes `result.chunks` and `result.html`.
+ */
+export declare function extractIslandChunks(html: string, options?: ExtractIslandChunksOptions): ExtractIslandChunksResult;
+/**
+ * Warm the chunks of islands likely to hydrate soon (`visible` / `idle`
+ * triggers) with `<link rel="prefetch" as="script">` in the document head, so
+ * the chunk is already cached when the trigger fires — instant hydration with no
+ * inline JS. Pure and idempotent; operates on already-chunked HTML (it reads the
+ * `data-stx-src` the emitter added) and is a no-op when there's no `<head>`, no
+ * chunked island, or no island with an eligible trigger.
+ *
+ * `prefetch` (not `preload`) is deliberate: it's low-priority/idle, so it never
+ * competes with the critical render path, and it avoids the "preloaded resource
+ * not used within N seconds" console warning for below-the-fold islands.
+ */
+export declare function injectIslandChunkPrefetch(html: string): string;

package/dist/island-chunking.js

@@ -0,0 +1,52 @@
+import { createHash } from "node:crypto";
+function minifyChunk(code) {
+  try {
+    return new Bun.Transpiler({ loader: "js", minifyWhitespace: !0 }).transformSync(code).replace(/\}(var |let |const |function )/g, "};$1").trim();
+  } catch {
+    return code;
+  }
+}
+const ISLAND_SCRIPT_RE = /<script\s+type="stx\/island"\s+data-stx-island="([^"]+)"([^>]*)>([\s\S]*?)<\/script>/g;
+function hashChunk(code) {
+  return Bun.hash(code).toString(16);
+}
+export function extractIslandChunks(html, options = {}) {
+  if (!html.includes('type="stx/island"'))
+    return { html, chunks: [] };
+  const chunksByHash = new Map, rewritten = html.replace(ISLAND_SCRIPT_RE, (full, sid, attrs, body) => {
+    let code = body.trim();
+    if (!code)
+      return full;
+    if (/\bdata-stx-src=/.test(attrs))
+      return full;
+    if (options.minify)
+      code = minifyChunk(code);
+    const hash = hashChunk(code);
+    if (!chunksByHash.has(hash))
+      chunksByHash.set(hash, code);
+    const integrityAttr = options.integrity ? ` data-stx-integrity="sha384-${createHash("sha384").update(code).digest("base64")}"` : "";
+    return `<script type="stx/island" data-stx-island="${sid}" data-stx-src="/_stx/islands/${hash}.js"${integrityAttr}${attrs}></script>`;
+  }), chunks = Array.from(chunksByHash, ([hash, code]) => ({ hash, code }));
+  return { html: rewritten, chunks };
+}
+const PREFETCH_TRIGGERS = new Set(["visible", "idle"]);
+export function injectIslandChunkPrefetch(html) {
+  if (!html.includes("data-stx-src="))
+    return html;
+  const triggerBySid = new Map, hostRe = /data-stx-scope="([^"]+)"[^>]*?stx-hydrate="([^"]+)"/g;
+  let h;
+  while ((h = hostRe.exec(html)) !== null)
+    triggerBySid.set(h[1], h[2]);
+  const urls = new Set, tagRe = /data-stx-island="([^"]+)"[^>]*?data-stx-src="([^"]+)"/g;
+  let t;
+  while ((t = tagRe.exec(html)) !== null)
+    if (PREFETCH_TRIGGERS.has(triggerBySid.get(t[1]) || ""))
+      urls.add(t[2]);
+  const headEnd = html.lastIndexOf("</head>");
+  if (urls.size === 0 || headEnd === -1)
+    return html;
+  const links = Array.from(urls).filter((url) => !html.includes(`rel="prefetch" href="${url}"`)).map((url) => `<link rel="prefetch" href="${url}" as="script">`).join("");
+  if (!links)
+    return html;
+  return html.slice(0, headEnd) + links + html.slice(headEnd);
+}

package/dist/isolated-build.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Run `build` over `entrypoints`, falling back to one-at-a-time on failure.
+ *
+ * @param entrypoints absolute paths to build
+ * @param build performs a Bun.build over the given subset; should throw or
+ * reject on failure, which is what Bun.build does by default
+ */
+export declare function buildIsolatingFailures(entrypoints: string[], build: (subset: string[]) => Promise<unknown>): Promise<IsolatedBuildResult>;
+export declare interface IsolatedBuildResult {
+  succeeded: string[]
+  failed: Array<{ entrypoint: string, error: string }>
+}

package/dist/isolated-build.js

@@ -0,0 +1,18 @@
+import { formatBuildFailure } from "./build-message.js";
+export async function buildIsolatingFailures(entrypoints, build) {
+  if (entrypoints.length === 0)
+    return { succeeded: [], failed: [] };
+  try {
+    await build(entrypoints);
+    return { succeeded: [...entrypoints], failed: [] };
+  } catch {}
+  const succeeded = [], failed = [];
+  for (const entrypoint of entrypoints)
+    try {
+      await build([entrypoint]);
+      succeeded.push(entrypoint);
+    } catch (error) {
+      failed.push({ entrypoint, error: formatBuildFailure(error, entrypoint) });
+    }
+  return { succeeded, failed };
+}