npm - @renderify/cli - Versions diffs - 0.1.0 - Mend

@renderify/cli 0.1.0

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 (10) hide show

package/dist/cli.esm.js ADDED Viewed

@@ -0,0 +1,1203 @@
+// src/index.ts
+import { createHash } from "crypto";
+import fs from "fs";
+import http from "http";
+import path from "path";
+import {
+  createRenderifyApp,
+  DefaultApiIntegration,
+  DefaultCodeGenerator,
+  DefaultContextManager,
+  DefaultCustomizationEngine,
+  DefaultPerformanceOptimizer,
+  DefaultRenderifyConfig,
+  DefaultUIRenderer
+} from "@renderify/core";
+import {
+  collectComponentModules,
+  collectRuntimeSourceImports,
+  isRuntimePlan
+} from "@renderify/ir";
+import { createLLMInterpreter } from "@renderify/llm";
+import { DefaultRuntimeManager, JspmModuleLoader } from "@renderify/runtime";
+import { DefaultSecurityChecker } from "@renderify/security";
+// src/playground-html.ts
+var PLAYGROUND_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Renderify Runtime Playground</title>
+    <style>
+      :root {
+        --bg-top: #e7f3ff;
+        --bg-bottom: #fff9f0;
+        --panel: rgba(255, 255, 255, 0.86);
+        --line: rgba(17, 24, 39, 0.12);
+        --ink: #0f172a;
+        --subtle: #475569;
+        --brand: #0f766e;
+        --brand-2: #0369a1;
+        --danger: #b91c1c;
+      }
+      * {
+        box-sizing: border-box;
+      }
+      body {
+        margin: 0;
+        color: var(--ink);
+        font-family: "IBM Plex Sans", "Avenir Next", "Segoe UI", sans-serif;
+        background: radial-gradient(circle at 10% 0%, var(--bg-top), var(--bg-bottom));
+      }
+      .shell {
+        min-height: 100vh;
+        padding: 20px;
+      }
+      .title {
+        margin: 0 0 8px;
+        font-size: 28px;
+      }
+      .sub {
+        margin: 0 0 16px;
+        color: var(--subtle);
+      }
+      .grid {
+        display: grid;
+        grid-template-columns: repeat(12, minmax(0, 1fr));
+        gap: 14px;
+      }
+      .card {
+        background: var(--panel);
+        border: 1px solid var(--line);
+        border-radius: 14px;
+        padding: 14px;
+        backdrop-filter: blur(8px);
+      }
+      .span-4 {
+        grid-column: span 4;
+      }
+      .span-8 {
+        grid-column: span 8;
+      }
+      .span-12 {
+        grid-column: span 12;
+      }
+      h2 {
+        margin: 0 0 10px;
+        font-size: 16px;
+      }
+      textarea {
+        width: 100%;
+        min-height: 118px;
+        border: 1px solid var(--line);
+        border-radius: 10px;
+        padding: 10px 11px;
+        font: inherit;
+        resize: vertical;
+        background: #fff;
+      }
+      .actions {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 8px;
+        margin-top: 10px;
+      }
+      button {
+        border: 1px solid transparent;
+        border-radius: 10px;
+        padding: 8px 12px;
+        font: inherit;
+        font-weight: 600;
+        cursor: pointer;
+        background: linear-gradient(160deg, var(--brand), var(--brand-2));
+        color: #fff;
+      }
+      button.secondary {
+        background: #fff;
+        color: var(--ink);
+        border-color: var(--line);
+      }
+      button.danger {
+        background: var(--danger);
+      }
+      button:disabled {
+        opacity: 0.45;
+        cursor: not-allowed;
+      }
+      .status {
+        min-height: 20px;
+        margin-top: 10px;
+        color: var(--subtle);
+        font-size: 13px;
+      }
+      .render-output {
+        min-height: 130px;
+        border: 1px dashed rgba(15, 118, 110, 0.35);
+        border-radius: 10px;
+        padding: 10px;
+        background: rgba(255, 255, 255, 0.9);
+      }
+      pre {
+        margin: 0;
+        max-height: 360px;
+        overflow: auto;
+        padding: 10px;
+        font-size: 12px;
+        border-radius: 10px;
+        background: #0f172a;
+        color: #dbeafe;
+      }
+      @media (max-width: 980px) {
+        .span-4,
+        .span-8 {
+          grid-column: span 12;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <div class="shell">
+      <h1 class="title">Renderify Playground</h1>
+      <p class="sub">Prompt -> RuntimePlan -> Runtime execution -> Browser render</p>
+      <div class="grid">
+        <section class="card span-4">
+          <h2>Prompt</h2>
+          <textarea id="prompt">Build an analytics dashboard with a chart and KPI cards</textarea>
+          <div class="actions">
+            <button id="run-prompt">Render Prompt</button>
+            <button id="stream-prompt" class="secondary">Stream Prompt</button>
+            <button id="clear" class="danger">Clear</button>
+          </div>
+          <div class="status" id="status">Ready.</div>
+        </section>
+        <section class="card span-8">
+          <h2>Rendered HTML</h2>
+          <div class="render-output" id="html-output"></div>
+        </section>
+        <section class="card span-6">
+          <h2>Plan JSON</h2>
+          <textarea id="plan-editor">{}</textarea>
+          <div class="actions">
+            <button id="run-plan">Render Plan</button>
+            <button id="probe-plan" class="secondary">Probe Plan</button>
+            <button id="copy-plan-link" class="secondary">Copy Plan Link</button>
+          </div>
+        </section>
+        <section class="card span-6">
+          <h2>Diagnostics</h2>
+          <pre id="diagnostics">{}</pre>
+        </section>
+        <section class="card span-12">
+          <h2>Streaming Feed</h2>
+          <pre id="stream-output">[]</pre>
+        </section>
+      </div>
+    </div>
+    <script>
+      const byId = (id) => document.getElementById(id);
+      const statusEl = byId("status");
+      const promptEl = byId("prompt");
+      const htmlOutputEl = byId("html-output");
+      const planEditorEl = byId("plan-editor");
+      const diagnosticsEl = byId("diagnostics");
+      const streamOutputEl = byId("stream-output");
+      const copyPlanLinkEl = byId("copy-plan-link");
+      const controls = [
+        byId("run-prompt"),
+        byId("stream-prompt"),
+        byId("run-plan"),
+        byId("probe-plan"),
+        copyPlanLinkEl,
+        byId("clear"),
+      ];
+      const setBusy = (busy) => {
+        controls.forEach((button) => {
+          button.disabled = busy;
+        });
+      };
+      const setStatus = (text) => {
+        statusEl.textContent = text;
+      };
+      const safeJson = (value) => {
+        try {
+          return JSON.stringify(value ?? {}, null, 2);
+        } catch (error) {
+          return String(error);
+        }
+      };
+      const HASH_SOURCE_LANGUAGE_KEYS = {
+        js64: "js",
+        jsx64: "jsx",
+        ts64: "ts",
+        tsx64: "tsx",
+      };
+      const toBase64Bytes = (input) => {
+        const normalized = String(input ?? "")
+          .trim()
+          .replace(/[\\r\\n\\t ]+/g, "")
+          .replace(/-/g, "+")
+          .replace(/_/g, "/");
+        if (!normalized) {
+          throw new Error("Base64 payload is empty.");
+        }
+        const remainder = normalized.length % 4;
+        const padded =
+          remainder === 0 ? normalized : normalized + "=".repeat(4 - remainder);
+        return atob(padded);
+      };
+      const decodeBase64Text = (input) => {
+        const binary = toBase64Bytes(input);
+        const bytes = new Uint8Array(binary.length);
+        for (let index = 0; index < binary.length; index += 1) {
+          bytes[index] = binary.charCodeAt(index);
+        }
+        return new TextDecoder().decode(bytes);
+      };
+      const encodeBase64Url = (input) => {
+        const text = String(input ?? "");
+        const bytes = new TextEncoder().encode(text);
+        let binary = "";
+        for (const byte of bytes) {
+          binary += String.fromCharCode(byte);
+        }
+        return btoa(binary)
+          .replace(/\\+/g, "-")
+          .replace(/\\//g, "_")
+          .replace(/=+$/g, "");
+      };
+      const getHashSearchParams = () => {
+        const rawHash = window.location.hash.startsWith("#")
+          ? window.location.hash.slice(1)
+          : window.location.hash;
+        return new URLSearchParams(rawHash);
+      };
+      const parseJsonFromBase64 = (input, label) => {
+        try {
+          const decoded = decodeBase64Text(input);
+          return JSON.parse(decoded);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          throw new Error("Failed to decode " + label + ": " + message);
+        }
+      };
+      const resolveSourceHashPayload = (params) => {
+        const sourceEntry = Object.entries(HASH_SOURCE_LANGUAGE_KEYS).find(
+          ([key]) => params.has(key),
+        );
+        if (!sourceEntry && !params.has("source64")) {
+          return null;
+        }
+        const explicitLanguage = String(params.get("language") || "")
+          .trim()
+          .toLowerCase();
+        const language =
+          (sourceEntry ? sourceEntry[1] : undefined) ||
+          (explicitLanguage === "js" ||
+          explicitLanguage === "jsx" ||
+          explicitLanguage === "ts" ||
+          explicitLanguage === "tsx"
+            ? explicitLanguage
+            : "jsx");
+        const sourceRaw = sourceEntry ? params.get(sourceEntry[0]) : params.get("source64");
+        if (!sourceRaw) {
+          throw new Error("Source hash payload is empty.");
+        }
+        const code = decodeBase64Text(sourceRaw);
+        const runtimeRaw = String(params.get("runtime") || "").trim().toLowerCase();
+        const runtime =
+          runtimeRaw === "renderify" || runtimeRaw === "preact"
+            ? runtimeRaw
+            : language === "jsx" || language === "tsx"
+              ? "preact"
+              : "renderify";
+        const exportName = String(params.get("exportName") || "default").trim() || "default";
+        const manifestPayload = params.get("manifest64");
+        const moduleManifest = manifestPayload
+          ? parseJsonFromBase64(manifestPayload, "manifest64")
+          : undefined;
+        const planId =
+          String(params.get("id") || "").trim() ||
+          "hash_source_" + Date.now().toString(36);
+        return {
+          specVersion: "runtime-plan/v1",
+          id: planId,
+          version: 1,
+          root: {
+            type: "element",
+            tag: "div",
+            children: [{ type: "text", value: "Renderify source root" }],
+          },
+          capabilities: {},
+          ...(moduleManifest &&
+          typeof moduleManifest === "object" &&
+          !Array.isArray(moduleManifest)
+            ? { moduleManifest }
+            : {}),
+          source: {
+            code,
+            language,
+            exportName,
+            runtime,
+          },
+          metadata: {
+            tags: ["hash-deeplink", "source"],
+          },
+        };
+      };
+      async function request(path, method, body) {
+        const response = await fetch(path, {
+          method,
+          headers: { "content-type": "application/json" },
+          body: body ? JSON.stringify(body) : undefined,
+        });
+        const payload = await response.json();
+        if (!response.ok) {
+          throw new Error(payload && payload.error ? String(payload.error) : "request failed");
+        }
+        return payload;
+      }
+      const applyRenderPayload = (payload) => {
+        htmlOutputEl.innerHTML = String(payload.html ?? "");
+        planEditorEl.value = safeJson(payload.planDetail ?? {});
+        diagnosticsEl.textContent = safeJson({
+          traceId: payload.traceId,
+          state: payload.state ?? {},
+          diagnostics: payload.diagnostics ?? [],
+        });
+      };
+      async function renderPlanObject(plan, statusText) {
+        setBusy(true);
+        setStatus(statusText || "Rendering plan...");
+        try {
+          const payload = await request("/api/plan", "POST", { plan });
+          applyRenderPayload(payload);
+          setStatus("Plan rendered.");
+          return payload;
+        } catch (error) {
+          setStatus("Plan render failed.");
+          diagnosticsEl.textContent = String(error);
+          throw error;
+        } finally {
+          setBusy(false);
+        }
+      }
+      async function runPrompt() {
+        const prompt = promptEl.value.trim();
+        if (!prompt) {
+          setStatus("Prompt is required.");
+          return;
+        }
+        setBusy(true);
+        setStatus("Rendering prompt...");
+        try {
+          const payload = await request("/api/prompt", "POST", { prompt });
+          applyRenderPayload(payload);
+          streamOutputEl.textContent = "[]";
+          setStatus("Prompt rendered.");
+        } catch (error) {
+          setStatus("Prompt render failed.");
+          diagnosticsEl.textContent = String(error);
+        } finally {
+          setBusy(false);
+        }
+      }
+      async function streamPrompt() {
+        const prompt = promptEl.value.trim();
+        if (!prompt) {
+          setStatus("Prompt is required.");
+          return;
+        }
+        setBusy(true);
+        setStatus("Streaming prompt...");
+        const streamEvents = [];
+        try {
+          const response = await fetch("/api/prompt-stream", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ prompt }),
+          });
+          if (!response.ok || !response.body) {
+            throw new Error("stream request failed");
+          }
+          const reader = response.body.getReader();
+          const decoder = new TextDecoder();
+          let buffer = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+              if (!line.trim()) {
+                continue;
+              }
+              const event = JSON.parse(line);
+              streamEvents.push({
+                type: event.type,
+                planId: event.planId ?? null,
+                llmTextLength: String(event.llmText ?? "").length,
+              });
+              if (event.html) {
+                htmlOutputEl.innerHTML = String(event.html);
+              }
+              if (event.type === "final" && event.final) {
+                applyRenderPayload(event.final);
+              }
+            }
+          }
+          streamOutputEl.textContent = safeJson(streamEvents);
+          setStatus("Stream completed.");
+        } catch (error) {
+          setStatus("Stream failed.");
+          diagnosticsEl.textContent = String(error);
+        } finally {
+          setBusy(false);
+        }
+      }
+      async function runPlan() {
+        const raw = planEditorEl.value.trim();
+        if (!raw) {
+          setStatus("Plan JSON is required.");
+          return;
+        }
+        try {
+          const plan = JSON.parse(raw);
+          await renderPlanObject(plan, "Rendering plan...");
+        } catch (error) {
+          setStatus("Plan render failed.");
+          diagnosticsEl.textContent = String(error);
+        }
+      }
+      async function probePlan() {
+        const raw = planEditorEl.value.trim();
+        if (!raw) {
+          setStatus("Plan JSON is required.");
+          return;
+        }
+        setBusy(true);
+        setStatus("Probing plan...");
+        try {
+          const plan = JSON.parse(raw);
+          const payload = await request("/api/probe-plan", "POST", { plan });
+          diagnosticsEl.textContent = safeJson(payload);
+          setStatus("Plan probe completed.");
+        } catch (error) {
+          setStatus("Plan probe failed.");
+          diagnosticsEl.textContent = String(error);
+        } finally {
+          setBusy(false);
+        }
+      }
+      function clearAll() {
+        htmlOutputEl.innerHTML = "";
+        diagnosticsEl.textContent = "{}";
+        streamOutputEl.textContent = "[]";
+        setStatus("Cleared.");
+      }
+      async function copyPlanLink() {
+        const raw = planEditorEl.value.trim();
+        if (!raw) {
+          setStatus("Plan JSON is required.");
+          return;
+        }
+        try {
+          const parsed = JSON.parse(raw);
+          const encoded = encodeBase64Url(JSON.stringify(parsed));
+          const shareUrl =
+            window.location.origin +
+            window.location.pathname +
+            "#plan64=" +
+            encoded;
+          if (navigator.clipboard && typeof navigator.clipboard.writeText === "function") {
+            await navigator.clipboard.writeText(shareUrl);
+            setStatus("Plan share link copied.");
+            diagnosticsEl.textContent = safeJson({
+              shareUrl,
+            });
+            return;
+          }
+          diagnosticsEl.textContent = shareUrl;
+          setStatus("Clipboard unavailable; share URL written to diagnostics.");
+        } catch (error) {
+          setStatus("Failed to create share link.");
+          diagnosticsEl.textContent = String(error);
+        }
+      }
+      async function renderFromHashPayload() {
+        const params = getHashSearchParams();
+        if (Array.from(params.keys()).length === 0) {
+          return;
+        }
+        try {
+          const plan64 = params.get("plan64");
+          const plan = plan64
+            ? parseJsonFromBase64(plan64, "plan64")
+            : resolveSourceHashPayload(params);
+          if (!plan) {
+            return;
+          }
+          planEditorEl.value = safeJson(plan);
+          await renderPlanObject(plan, "Rendering hash payload...");
+          setStatus("Hash payload rendered.");
+        } catch (error) {
+          setStatus("Hash payload render failed.");
+          diagnosticsEl.textContent = String(error);
+        }
+      }
+      byId("run-prompt").addEventListener("click", runPrompt);
+      byId("stream-prompt").addEventListener("click", streamPrompt);
+      byId("run-plan").addEventListener("click", runPlan);
+      byId("probe-plan").addEventListener("click", probePlan);
+      copyPlanLinkEl.addEventListener("click", () => {
+        void copyPlanLink();
+      });
+      byId("clear").addEventListener("click", clearAll);
+      void renderFromHashPayload();
+      window.addEventListener("hashchange", () => {
+        void renderFromHashPayload();
+      });
+    </script>
+  </body>
+</html>`;
+// src/index.ts
+var DEFAULT_PROMPT = "Hello Renderify runtime";
+var DEFAULT_PORT = 4317;
+var JSON_BODY_LIMIT_BYTES = 1e6;
+var AUTO_MANIFEST_INTEGRITY_TIMEOUT_MS = 8e3;
+var REMOTE_MODULE_INTEGRITY_CACHE = /* @__PURE__ */ new Map();
+var { readFile } = fs.promises;
+function createLLM(config) {
+  const provider = config.get("llmProvider") ?? "openai";
+  const providerOptions = {
+    apiKey: config.get("llmApiKey"),
+    timeoutMs: config.get("llmRequestTimeoutMs")
+  };
+  if (provider === "openai" || provider === "google" || typeof process.env.RENDERIFY_LLM_MODEL === "string") {
+    providerOptions.model = config.get("llmModel");
+  }
+  if (provider === "openai" || provider === "google" || typeof process.env.RENDERIFY_LLM_BASE_URL === "string") {
+    providerOptions.baseUrl = config.get("llmBaseUrl");
+  }
+  return createLLMInterpreter({
+    provider,
+    providerOptions
+  });
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.command === "help") {
+    printHelp();
+    return;
+  }
+  const config = new DefaultRenderifyConfig();
+  await config.load();
+  const llm = createLLM(config);
+  const runtimeModuleLoader = new JspmModuleLoader({
+    cdnBaseUrl: config.get("jspmCdnUrl")
+  });
+  const runtime = new DefaultRuntimeManager({
+    moduleLoader: runtimeModuleLoader,
+    enforceModuleManifest: config.get("runtimeEnforceModuleManifest") !== false,
+    allowIsolationFallback: config.get("runtimeAllowIsolationFallback") === true,
+    supportedPlanSpecVersions: config.get(
+      "runtimeSupportedSpecVersions"
+    ),
+    enableDependencyPreflight: config.get("runtimeEnableDependencyPreflight") !== false,
+    failOnDependencyPreflightError: config.get("runtimeFailOnDependencyPreflightError") === true,
+    remoteFetchTimeoutMs: config.get("runtimeRemoteFetchTimeoutMs") ?? 12e3,
+    remoteFetchRetries: config.get("runtimeRemoteFetchRetries") ?? 2,
+    remoteFetchBackoffMs: config.get("runtimeRemoteFetchBackoffMs") ?? 150,
+    remoteFallbackCdnBases: config.get(
+      "runtimeRemoteFallbackCdnBases"
+    ) ?? ["https://esm.sh"],
+    browserSourceSandboxMode: config.get(
+      "runtimeBrowserSourceSandboxMode"
+    ),
+    browserSourceSandboxTimeoutMs: config.get("runtimeBrowserSourceSandboxTimeoutMs") ?? 4e3,
+    browserSourceSandboxFailClosed: config.get("runtimeBrowserSourceSandboxFailClosed") !== false
+  });
+  const renderifyApp = createRenderifyApp({
+    config,
+    context: new DefaultContextManager(),
+    llm,
+    codegen: new DefaultCodeGenerator(),
+    runtime,
+    security: new DefaultSecurityChecker(),
+    performance: new DefaultPerformanceOptimizer(),
+    ui: new DefaultUIRenderer(),
+    apiIntegration: new DefaultApiIntegration(),
+    customization: new DefaultCustomizationEngine()
+  });
+  await renderifyApp.start();
+  try {
+    switch (args.command) {
+      case "run": {
+        const result = await renderifyApp.renderPrompt(
+          args.prompt ?? DEFAULT_PROMPT
+        );
+        console.log(result.html);
+        break;
+      }
+      case "plan": {
+        const result = await renderifyApp.renderPrompt(
+          args.prompt ?? DEFAULT_PROMPT
+        );
+        console.log(JSON.stringify(result.plan, null, 2));
+        break;
+      }
+      case "probe-plan": {
+        if (!args.planFile) {
+          throw new Error("probe-plan requires a JSON file path");
+        }
+        const plan = await loadPlanFile(args.planFile);
+        const security = await renderifyApp.getSecurityChecker().checkPlan(plan);
+        const runtimeProbe = await runtime.probePlan(plan);
+        const runtimeErrorDiagnostics = runtimeProbe.diagnostics.filter(
+          (item) => item.level === "error"
+        );
+        const preflightDiagnostics = runtimeProbe.diagnostics.filter(
+          (item) => item.code.startsWith("RUNTIME_PREFLIGHT_")
+        );
+        const report = {
+          planId: plan.id,
+          safe: security.safe,
+          securityIssueCount: security.issues.length,
+          runtimeErrorCount: runtimeErrorDiagnostics.length,
+          preflightIssueCount: preflightDiagnostics.length,
+          ok: security.safe && security.issues.length === 0 && runtimeErrorDiagnostics.length === 0,
+          securityIssues: security.issues,
+          securityDiagnostics: security.diagnostics,
+          dependencyStatuses: runtimeProbe.dependencies,
+          runtimeDiagnostics: runtimeProbe.diagnostics
+        };
+        console.log(JSON.stringify(report, null, 2));
+        break;
+      }
+      case "render-plan": {
+        if (!args.planFile) {
+          throw new Error("render-plan requires a JSON file path");
+        }
+        const plan = await loadPlanFile(args.planFile);
+        const result = await renderifyApp.renderPlan(plan, {
+          prompt: `render-plan:${path.basename(args.planFile)}`
+        });
+        console.log(result.html);
+        break;
+      }
+      case "playground": {
+        const port = args.port ?? resolvePlaygroundPort();
+        await runPlaygroundServer({
+          app: renderifyApp,
+          port,
+          moduleLoader: runtimeModuleLoader,
+          autoManifestIntegrityTimeoutMs: AUTO_MANIFEST_INTEGRITY_TIMEOUT_MS
+        });
+        break;
+      }
+    }
+  } finally {
+    await renderifyApp.stop();
+  }
+}
+function parseArgs(argv) {
+  const [rawCommand, ...rest] = argv;
+  switch (rawCommand) {
+    case void 0:
+      return { command: "run", prompt: DEFAULT_PROMPT };
+    case "run":
+      return {
+        command: "run",
+        prompt: rest.join(" ").trim() || DEFAULT_PROMPT
+      };
+    case "plan":
+      return {
+        command: "plan",
+        prompt: rest.join(" ").trim() || DEFAULT_PROMPT
+      };
+    case "probe-plan":
+      return { command: "probe-plan", planFile: rest[0] };
+    case "render-plan":
+      return { command: "render-plan", planFile: rest[0] };
+    case "playground":
+      return {
+        command: "playground",
+        port: parsePort(rest[0])
+      };
+    case "help":
+      return { command: "help" };
+    default:
+      return {
+        command: "run",
+        prompt: [rawCommand, ...rest].join(" ").trim() || DEFAULT_PROMPT
+      };
+  }
+}
+function parsePort(rawValue) {
+  if (!rawValue) {
+    return void 0;
+  }
+  const parsed = Number(rawValue);
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+    throw new Error(`Invalid port: ${rawValue}`);
+  }
+  return parsed;
+}
+function resolvePlaygroundPort() {
+  const candidates = [process.env.RENDERIFY_PLAYGROUND_PORT, process.env.PORT];
+  for (const candidate of candidates) {
+    const port = parsePortFromEnv(candidate);
+    if (port !== void 0) {
+      return port;
+    }
+  }
+  return DEFAULT_PORT;
+}
+function parsePortFromEnv(rawValue) {
+  if (!rawValue) {
+    return void 0;
+  }
+  const parsed = Number(rawValue);
+  if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
+    return void 0;
+  }
+  return parsed;
+}
+function printHelp() {
+  console.log(`Usage:
+  renderify run <prompt>                     Render prompt and print HTML
+  renderify plan <prompt>                    Print runtime plan JSON
+  renderify probe-plan <file>                Probe RuntimePlan dependencies and policy compatibility
+  renderify render-plan <file>               Execute RuntimePlan JSON file
+  renderify playground [port]                Start browser runtime playground`);
+}
+async function loadPlanFile(filePath) {
+  const absolute = path.resolve(filePath);
+  const content = await readFile(absolute, "utf8");
+  const parsed = JSON.parse(content);
+  if (!isRuntimePlan(parsed)) {
+    throw new Error(`Invalid RuntimePlan JSON in file: ${absolute}`);
+  }
+  return parsed;
+}
+async function runPlaygroundServer(options) {
+  const { app, port, moduleLoader, autoManifestIntegrityTimeoutMs } = options;
+  const server = http.createServer((req, res) => {
+    void handlePlaygroundRequest(
+      req,
+      res,
+      app,
+      moduleLoader,
+      autoManifestIntegrityTimeoutMs
+    );
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  const info = server.address();
+  const resolvedPort = typeof info === "object" && info !== null ? info.port : port;
+  const baseUrl = `http://127.0.0.1:${resolvedPort}`;
+  console.log(`Renderify playground is running at ${baseUrl}`);
+  console.log("Press Ctrl+C to stop.");
+  await new Promise((resolve, reject) => {
+    let closed = false;
+    const finalize = (error) => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    };
+    const onSignal = () => {
+      server.close((error) => {
+        if (error) {
+          finalize(error);
+          return;
+        }
+        finalize();
+      });
+    };
+    process.on("SIGINT", onSignal);
+    process.on("SIGTERM", onSignal);
+  });
+}
+async function handlePlaygroundRequest(req, res, app, moduleLoader, autoManifestIntegrityTimeoutMs) {
+  const method = (req.method ?? "GET").toUpperCase();
+  const parsedUrl = new URL(req.url ?? "/", "http://127.0.0.1");
+  const pathname = parsedUrl.pathname;
+  try {
+    if (method === "GET" && pathname === "/") {
+      sendHtml(res, PLAYGROUND_HTML);
+      return;
+    }
+    if (method === "GET" && pathname === "/api/health") {
+      sendJson(res, 200, { ok: true, status: "ready" });
+      return;
+    }
+    if (method === "POST" && pathname === "/api/prompt") {
+      const body = await readJsonBody(req);
+      const prompt = typeof body.prompt === "string" && body.prompt.trim().length > 0 ? body.prompt.trim() : DEFAULT_PROMPT;
+      const result = await app.renderPrompt(prompt);
+      sendJson(res, 200, serializeRenderResult(result));
+      return;
+    }
+    if (method === "POST" && pathname === "/api/prompt-stream") {
+      const body = await readJsonBody(req);
+      const prompt = typeof body.prompt === "string" && body.prompt.trim().length > 0 ? body.prompt.trim() : DEFAULT_PROMPT;
+      await sendPromptStream(res, app, prompt);
+      return;
+    }
+    if (method === "POST" && pathname === "/api/plan") {
+      const body = await readJsonBody(req);
+      const plan = body.plan;
+      if (!isRuntimePlan(plan)) {
+        sendJson(res, 400, { error: "body.plan must be a RuntimePlan object" });
+        return;
+      }
+      const hydratedPlan = await hydratePlaygroundPlanManifest(plan, {
+        moduleLoader,
+        requireIntegrity: app.getSecurityChecker().getPolicy().requireModuleIntegrity,
+        integrityTimeoutMs: autoManifestIntegrityTimeoutMs
+      });
+      const result = await app.renderPlan(hydratedPlan, {
+        prompt: "playground:plan"
+      });
+      sendJson(res, 200, serializeRenderResult(result));
+      return;
+    }
+    if (method === "POST" && pathname === "/api/probe-plan") {
+      const body = await readJsonBody(req);
+      const plan = body.plan;
+      if (!isRuntimePlan(plan)) {
+        sendJson(res, 400, { error: "body.plan must be a RuntimePlan object" });
+        return;
+      }
+      const hydratedPlan = await hydratePlaygroundPlanManifest(plan, {
+        moduleLoader,
+        requireIntegrity: app.getSecurityChecker().getPolicy().requireModuleIntegrity,
+        integrityTimeoutMs: autoManifestIntegrityTimeoutMs
+      });
+      const security = await app.getSecurityChecker().checkPlan(hydratedPlan);
+      const runtimeProbe = await app.getRuntimeManager().probePlan(hydratedPlan);
+      sendJson(res, 200, {
+        safe: security.safe,
+        securityIssues: security.issues,
+        securityDiagnostics: security.diagnostics,
+        dependencies: runtimeProbe.dependencies,
+        runtimeDiagnostics: runtimeProbe.diagnostics
+      });
+      return;
+    }
+    sendJson(res, 404, { error: "Not found" });
+  } catch (error) {
+    sendJson(res, 500, {
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+function serializeRenderResult(result) {
+  return {
+    traceId: result.traceId,
+    html: result.html,
+    plan: {
+      id: result.plan.id,
+      version: result.plan.version
+    },
+    planDetail: result.plan,
+    diagnostics: result.execution.diagnostics,
+    state: result.execution.state ?? {}
+  };
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  let totalBytes = 0;
+  for await (const chunk of req) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    totalBytes += buffer.length;
+    if (totalBytes > JSON_BODY_LIMIT_BYTES) {
+      throw new Error(`JSON body exceeds ${JSON_BODY_LIMIT_BYTES} bytes`);
+    }
+    chunks.push(buffer);
+  }
+  if (chunks.length === 0) {
+    return {};
+  }
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (raw.length === 0) {
+    return {};
+  }
+  const parsed = JSON.parse(raw);
+  if (!isRecord(parsed)) {
+    throw new Error("JSON body must be an object");
+  }
+  return parsed;
+}
+function sendJson(res, statusCode, payload) {
+  const body = JSON.stringify(payload);
+  res.writeHead(statusCode, {
+    "content-type": "application/json; charset=utf-8",
+    "content-length": Buffer.byteLength(body),
+    "cache-control": "no-store"
+  });
+  res.end(body);
+}
+function sendHtml(res, html) {
+  res.writeHead(200, {
+    "content-type": "text/html; charset=utf-8",
+    "content-length": Buffer.byteLength(html),
+    "cache-control": "no-store"
+  });
+  res.end(html);
+}
+async function sendPromptStream(res, app, prompt) {
+  res.writeHead(200, {
+    "content-type": "application/x-ndjson; charset=utf-8",
+    "cache-control": "no-store",
+    connection: "keep-alive",
+    "x-accel-buffering": "no"
+  });
+  try {
+    for await (const chunk of app.renderPromptStream(prompt)) {
+      const serialized = serializePromptStreamChunk(chunk);
+      res.write(`${JSON.stringify(serialized)}
+`);
+    }
+  } catch (error) {
+    res.write(
+      `${JSON.stringify({
+        type: "error",
+        error: error instanceof Error ? error.message : String(error)
+      })}
+`
+    );
+  } finally {
+    res.end();
+  }
+}
+function serializePromptStreamChunk(chunk) {
+  if (chunk.type === "final") {
+    return {
+      type: chunk.type,
+      traceId: chunk.traceId,
+      prompt: chunk.prompt,
+      llmText: chunk.llmText,
+      final: chunk.final ? serializeRenderResult(chunk.final) : void 0,
+      html: chunk.html,
+      diagnostics: chunk.diagnostics ?? [],
+      planId: chunk.planId
+    };
+  }
+  return {
+    type: chunk.type,
+    traceId: chunk.traceId,
+    prompt: chunk.prompt,
+    llmText: chunk.llmText,
+    delta: chunk.delta,
+    html: chunk.html,
+    diagnostics: chunk.diagnostics ?? [],
+    planId: chunk.planId
+  };
+}
+async function hydratePlaygroundPlanManifest(plan, options) {
+  const bareSpecifiers = await collectRuntimePlanBareSpecifiers(plan);
+  if (bareSpecifiers.length === 0) {
+    return plan;
+  }
+  const nextManifest = { ...plan.moduleManifest ?? {} };
+  let changed = false;
+  for (const specifier of bareSpecifiers) {
+    if (nextManifest[specifier]) {
+      continue;
+    }
+    let resolvedUrl;
+    try {
+      resolvedUrl = options.moduleLoader.resolveSpecifier(specifier);
+    } catch {
+      continue;
+    }
+    const descriptor = {
+      resolvedUrl
+    };
+    if (options.requireIntegrity && isHttpUrl(resolvedUrl)) {
+      const integrity = await fetchRemoteModuleIntegrity(
+        resolvedUrl,
+        options.integrityTimeoutMs
+      );
+      if (integrity) {
+        descriptor.integrity = integrity;
+      }
+    }
+    nextManifest[specifier] = descriptor;
+    changed = true;
+  }
+  if (!changed) {
+    return plan;
+  }
+  return {
+    ...plan,
+    moduleManifest: nextManifest
+  };
+}
+async function collectRuntimePlanBareSpecifiers(plan) {
+  const specifiers = /* @__PURE__ */ new Set();
+  for (const specifier of plan.imports ?? []) {
+    if (isBareModuleSpecifier(specifier)) {
+      specifiers.add(specifier);
+    }
+  }
+  for (const specifier of plan.capabilities.allowedModules ?? []) {
+    if (isBareModuleSpecifier(specifier)) {
+      specifiers.add(specifier);
+    }
+  }
+  for (const moduleSpecifier of collectComponentModules(plan.root)) {
+    if (isBareModuleSpecifier(moduleSpecifier)) {
+      specifiers.add(moduleSpecifier);
+    }
+  }
+  if (plan.source?.code) {
+    for (const sourceImport of await collectRuntimeSourceImports(
+      plan.source.code
+    )) {
+      if (isBareModuleSpecifier(sourceImport)) {
+        specifiers.add(sourceImport);
+      }
+    }
+  }
+  return [...specifiers];
+}
+function isBareModuleSpecifier(specifier) {
+  const trimmed = specifier.trim();
+  if (trimmed.length === 0) {
+    return false;
+  }
+  return !trimmed.startsWith("./") && !trimmed.startsWith("../") && !trimmed.startsWith("/") && !trimmed.startsWith("http://") && !trimmed.startsWith("https://") && !trimmed.startsWith("data:") && !trimmed.startsWith("blob:");
+}
+function isHttpUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+async function fetchRemoteModuleIntegrity(url, timeoutMs) {
+  const cached = REMOTE_MODULE_INTEGRITY_CACHE.get(url);
+  if (cached) {
+    return cached;
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), Math.max(1, timeoutMs));
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      return void 0;
+    }
+    const body = await response.arrayBuffer();
+    const digest = createHash("sha384").update(Buffer.from(body)).digest("base64");
+    const integrity = `sha384-${digest}`;
+    REMOTE_MODULE_INTEGRITY_CACHE.set(url, integrity);
+    return integrity;
+  } catch {
+    return void 0;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+void main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.esm.js.map