npm - beam-alpha - Versions diffs - 0.1.0 - Mend

beam-alpha 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 (28) hide show

package/README.md +114 -0
package/bin/blueprint.mjs +7 -0
package/dist/beam.js +3272 -0
package/dist/canvas/assets/AzeretMono-C5fM7CrN.woff2 +0 -0
package/dist/canvas/assets/OpenRunde-Bold-DS-_1xH5.woff2 +0 -0
package/dist/canvas/assets/OpenRunde-Medium-Krf-ZDqK.woff2 +0 -0
package/dist/canvas/assets/OpenRunde-Regular-BZVnpUN1.woff2 +0 -0
package/dist/canvas/assets/OpenRunde-Semibold-Nru5tuSm.woff2 +0 -0
package/dist/canvas/assets/index-BIsbDeNY.css +1 -0
package/dist/canvas/assets/index.embed-CE8oqNgH.js +230 -0
package/dist/canvas/index.html +16 -0
package/dist/cli.js +678 -0
package/dist/index.d.ts +74 -0
package/dist/index.js +8663 -0
package/dist/next/pin-loader.cjs +120 -0
package/dist/next/source-loader.cjs +137 -0
package/dist/next.d.ts +60 -0
package/dist/next.js +8896 -0
package/dist/overlay/overlay.css +1 -0
package/dist/overlay/overlay.js +219 -0
package/dist/probe.js +3084 -0
package/dist/runtime/core.d.ts +43 -0
package/dist/runtime/core.js +36 -0
package/dist/runtime/core.prod.js +19 -0
package/dist/runtime/react.d.ts +16 -0
package/dist/runtime/react.js +48 -0
package/dist/runtime/react.prod.js +17 -0
package/package.json +67 -0

package/dist/canvas/index.html ADDED Viewed

@@ -0,0 +1,16 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <title>Blueprint</title>
+    <!-- No CSP meta here: this page is served by the user's own dev server
+         (`@blueprint/dev`), and Electron's policy would fight it. `main.tsx`'s
+         page keeps the locked-down one. -->
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <script type="module" crossorigin src="/__blueprint/assets/index.embed-CE8oqNgH.js"></script>
+    <link rel="stylesheet" crossorigin href="/__blueprint/assets/index-BIsbDeNY.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist/cli.js ADDED Viewed

@@ -0,0 +1,678 @@
+// src/cli.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join3 } from "node:path";
+// ../mcp/src/config.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var SERVER_NAME = "blueprint";
+function entryFor(url) {
+  return { type: "http", url };
+}
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function mergeConfig(config, url) {
+  const next = config ? { ...config } : {};
+  const servers = { ...next.mcpServers ?? {} };
+  const existing = servers[SERVER_NAME];
+  const desired = entryFor(url);
+  const changed = !existing || existing.url !== desired.url || existing.type !== desired.type;
+  servers[SERVER_NAME] = { ...existing, ...desired };
+  next.mcpServers = servers;
+  return { config: next, changed };
+}
+async function writeMerged(path, url) {
+  const current = await readJson(path);
+  const { config, changed } = mergeConfig(current, url);
+  if (!changed && current) return;
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, JSON.stringify(config, null, 2) + "\n");
+}
+async function writeClaudeCodeConfig(root, url) {
+  await writeMerged(join(root, ".mcp.json"), url);
+}
+function mergeClaudeSettings(settings) {
+  const next = settings ? { ...settings } : {};
+  let changed = false;
+  const disabled = next.disabledMcpjsonServers;
+  if (disabled?.includes(SERVER_NAME)) {
+    next.disabledMcpjsonServers = disabled.filter((n) => n !== SERVER_NAME);
+    changed = true;
+  }
+  const enabled = next.enabledMcpjsonServers ?? [];
+  if (!next.enableAllProjectMcpServers && !enabled.includes(SERVER_NAME)) {
+    next.enabledMcpjsonServers = [...enabled, SERVER_NAME];
+    changed = true;
+  }
+  return { settings: next, changed };
+}
+function claudeSettingsPath(root) {
+  return join(root, ".claude", "settings.local.json");
+}
+async function writeClaudeCodeTrust(root) {
+  const path = claudeSettingsPath(root);
+  const current = await readJson(path);
+  const { settings, changed } = mergeClaudeSettings(current);
+  if (!changed && current) return;
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, JSON.stringify(settings, null, 2) + "\n");
+}
+// src/generate.ts
+import { parse } from "@babel/parser";
+import MagicString from "magic-string";
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2 } from "node:fs";
+import { mkdir as mkdir2, readdir, readFile as readFile2, rename, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname3, join as join2, posix, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+// ../shared/src/frames.ts
+var UNGROUPED = "";
+var VIEWPORT_PRESETS = [
+  { id: "desktop", label: "Desktop", w: 1280, h: 800 },
+  { id: "tablet", label: "Tablet", w: 834, h: 1194 },
+  { id: "phone", label: "Phone", w: 390, h: 844 }
+];
+var DEFAULT_VIEWPORT = VIEWPORT_PRESETS[0];
+// ../shared/src/sandbox.ts
+var BLUEPRINT_DIR = ".blueprint";
+var SANDBOX_DIR = `${BLUEPRINT_DIR}/sandbox`;
+var SANDBOX_ENTRY = `${SANDBOX_DIR}/index.html`;
+var SANDBOX_MARKER = "blueprint:sandbox-entry";
+var BLUEPRINT_IGNORE = `# ${SANDBOX_MARKER}
+# Blueprint's own folder: your canvas, your script choice, and any sandboxes
+# your agent writes. All of it is local state rather than source, and deleting
+# the folder leaves the project exactly as it was.
+*
+`;
+var SANDBOX_SUFFIX = ".sandbox.tsx";
+var SANDBOX_SOURCE_MARKER = "blueprint:source";
+var SANDBOX_FORK_MARKER = "blueprint:fork";
+function forkMarkerLine(lineage) {
+  return `// ${SANDBOX_FORK_MARKER} ${lineage.file}#${lineage.exportName} @${lineage.forkedAt}`;
+}
+var SANDBOX_LINEAGE_FILE = `${SANDBOX_DIR}/lineage.json`;
+function sandboxFile(component) {
+  return `${SANDBOX_DIR}/${component}${SANDBOX_SUFFIX}`;
+}
+function selectionQuery(state) {
+  if (!state) return "";
+  if (typeof state === "string") return `&state=${encodeURIComponent(state)}`;
+  return Object.entries(state).map(
+    ([group, option]) => group === UNGROUPED ? `&state=${encodeURIComponent(option)}` : `&v=${encodeURIComponent(`${group}:${option}`)}`
+  ).join("");
+}
+var VIRTUAL_SANDBOX_BASE = "/__blueprint/sandbox";
+function virtualSandboxRoute(component, state) {
+  const query = selectionQuery(state);
+  return `${VIRTUAL_SANDBOX_BASE}/${encodeURIComponent(component)}${query ? `?${query.slice(1)}` : ""}`;
+}
+var SANDBOX_PROBE = `${SANDBOX_DIR}/served.txt`;
+var SANDBOX_CONTRACT = `// ${SANDBOX_DIR}/<Component>${SANDBOX_SUFFIX}
+// ${SANDBOX_SOURCE_MARKER} <path to the real component, from the repo root>
+// IMPORT the real component from its real path \u2014 never copy it. A copy is a
+// fork, and "Move into the app" would become a merge instead of a delete.
+// Node resolution walks up, so the project's own node_modules is shared.
+import { Button } from '../../src/components/Button'
+export default function Sandbox() { /* renders the component on its own */ }
+// optional \u2014 each becomes an option in the card's variants picker.
+// ALTERNATIVES (the card can only be in one) share an axis; leave the group off
+// and they are the card's one unnamed axis:
+export const states = [
+  { name: 'Default', render: () => <Button>Save</Button> },
+  { name: 'Loading', render: () => <Button loading>Save</Button> }
+]
+// ORTHOGONAL dimensions (every combination is a real thing to look at) are
+// SEPARATE axes \u2014 one \`group\` each, one picker each, and the DEFAULT EXPORT
+// renders the combination, because it is the only thing that sees all of it:
+//
+//   export const states = [
+//     { group: 'Theme',  name: 'Light' },  { group: 'Theme',  name: 'Dark' },
+//     { group: 'Layout', name: 'Grid' },   { group: 'Layout', name: 'List' }
+//   ]
+//   export default function Sandbox({ variant }) {
+//     return <Button theme={variant.Theme} layout={variant.Layout} />
+//   }
+//
+// The test is mechanical: if the cross product is meaningful they are separate
+// axes; if half of it is nonsense they were one axis all along. A union-typed
+// prop IS an axis, and its default is the first option. At most 4 axes, at most
+// 6 options each. An option carries its own \`render\` ONLY on a single-axis file.
+// TWO RULES FOR THIS FOLDER
+// 1. Write nothing outside ${SANDBOX_DIR}/. Blueprint checks with git after
+//    you report done, and a sandbox that touched the app says so on the card.
+// 2. No NEW utility classes on your own wrappers. This folder is gitignored,
+//    and Tailwind skips gitignored paths \u2014 a className="p-6" here silently
+//    generates nothing. Use an inline style. The component's own classes come
+//    from src/ and work normally.`;
+function sandboxReadme() {
+  return `<!-- ${SANDBOX_MARKER} -->
+# ${SANDBOX_DIR}
+Sandboxes \u2014 one file per component, each rendering that component **on its
+own** so it can be looked at without the screen around it. Blueprint shows them
+as cards. With \`@blueprint/dev\` installed they are served from a virtual
+route (\`/__blueprint/sandbox/<Component>\`, no entry file anywhere) and
+\`blueprint generate sandbox <Component>\` scaffolds one deterministically;
+otherwise \`index.html\` beside this file is the page that serves them.
+They are compiled by your own dev server with your own config: your aliases,
+your tsconfig, your plugins, your providers and your component library all
+apply here exactly as they do in the app. Each sandbox **imports** the real
+component from its real path \u2014 never a copy, so tuning one here is tuning the
+real thing and moving the work back is a move rather than a merge.
+## The shape
+\`\`\`tsx
+// ${SANDBOX_DIR}/Button.sandbox.tsx
+// ${SANDBOX_SOURCE_MARKER} src/components/Button.tsx
+import { Button } from '../../src/components/Button'
+export default function Sandbox() {
+  return <Button>Save</Button>
+}
+// optional \u2014 each becomes a state the card can switch to
+export const states = [
+  { name: 'Default', render: () => <Button>Save</Button> },
+  { name: 'Loading', render: () => <Button disabled>Saving\u2026</Button> }
+]
+\`\`\`
+## One thing to know about Tailwind
+This folder is gitignored, and Tailwind v4 skips gitignored paths \u2014 so a
+utility class used **only** in here generates nothing. The component's own
+classes come from \`src/\` and work normally; it is only new classes on a
+sandbox's own wrapper that don't, and an inline style is the answer. If you
+would rather use utilities here, one line in your CSS opts the folder in:
+\`\`\`css
+@import 'tailwindcss';
+@source '../${BLUEPRINT_DIR}';
+\`\`\`
+## Who writes what
+Blueprint writes this README, the HTML entry and the ignore file, and nothing
+else. The component code is written by your coding agent, so it follows your
+conventions and you review it the way you review everything else. Blueprint
+never edits a sandbox after it is written \u2014 tweaks stay as live overrides on
+the card. Nothing either of them writes ever lands outside \`${BLUEPRINT_DIR}/\`,
+and Blueprint checks with \`git status\` after every request rather than
+trusting it.
+## Deleting
+Safe, always. Nothing in your app imports any of this. Remove a single file, or
+the whole \`${BLUEPRINT_DIR}/\` folder, and the project is exactly as it was.
+`;
+}
+// src/sandboxShell.ts
+var COMPONENT_RE = /^[A-Za-z0-9_-]+$/;
+// src/scope.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname as dirname2, relative, resolve, sep } from "node:path";
+function isWorkspaceRoot(dir) {
+  if (existsSync(resolve(dir, "pnpm-workspace.yaml")) || existsSync(resolve(dir, "lerna.json"))) return true;
+  try {
+    const pkg = JSON.parse(readFileSync(resolve(dir, "package.json"), "utf8"));
+    return Boolean(pkg.workspaces);
+  } catch {
+    return false;
+  }
+}
+function enclosingWorkspace(root) {
+  let outermost = root;
+  let current = root;
+  for (; ; ) {
+    if (isWorkspaceRoot(current) || existsSync(resolve(current, ".git"))) outermost = current;
+    const parent = dirname2(current);
+    if (parent === current) return outermost;
+    current = parent;
+  }
+}
+function projectScope(root) {
+  return { root, workspace: enclosingWorkspace(root) };
+}
+function within(dir, file) {
+  return file === dir || file.startsWith(dir + sep);
+}
+function inScope(scope, file) {
+  return within(scope.workspace, file) && !file.split(sep).includes("node_modules");
+}
+function resolveInScope(scope, address) {
+  const abs = resolve(scope.root, address);
+  return inScope(scope, abs) ? abs : null;
+}
+// src/generate.ts
+var SCAN_FILE_CAP = 2e3;
+var SCAN_DEPTH_CAP = 8;
+var NEVER_SCAN = /* @__PURE__ */ new Set(["node_modules", "dist", "out", "build", "coverage", ".git", ".next", BLUEPRINT_DIR]);
+async function generateSandbox(root, request) {
+  const component = request.component;
+  if (!COMPONENT_RE.test(component)) {
+    return { status: "error", component, detail: "Component names are [A-Za-z0-9_-]+." };
+  }
+  const target = join2(root, sandboxFile(component));
+  if (existsSync2(target)) {
+    return { status: "exists", component, file: sandboxFile(component), route: virtualSandboxRoute(component) };
+  }
+  const resolved = await resolveSource(root, component, request.source);
+  if (resolved.status !== "ok") return { component, ...resolved };
+  const { sourceRel, sourceAbs, text } = resolved;
+  const exportInfo = parseExport(text, component);
+  if (!exportInfo) {
+    return {
+      status: "not-exported",
+      component,
+      detail: `${sourceRel} doesn\u2019t export ${component}, so a sandbox can\u2019t import it. If it should be isolated anyway, ask the agent \u2014 copying an unexported component is a judgment call.`
+    };
+  }
+  const body = request.fork ? forkBody(component, sourceRel, text, exportInfo) : importBody(component, sourceRel, request.props, exportInfo);
+  await mkdir2(dirname3(target), { recursive: true });
+  await ensureBoilerplate(root);
+  await writeAtomic(target, body);
+  if (request.fork) {
+    await recordLineage(root, component, { origin: hashOf(text), fork: hashOf(body) });
+  }
+  return { status: "created", component, file: sandboxFile(component), route: virtualSandboxRoute(component) };
+}
+async function resolveSource(root, component, source) {
+  if (source) {
+    const file = source.replace(/:\d+$/, "");
+    const scope = projectScope(root);
+    const abs = resolveInScope(scope, file);
+    if (abs === null) {
+      return {
+        status: "error",
+        detail: resolve2(root, file).split(sep2).includes("node_modules") ? "Sandboxes are for the project\u2019s own components, not node_modules." : `${file} is outside the project\u2019s workspace.`
+      };
+    }
+    let text;
+    try {
+      text = await readFile2(abs, "utf8");
+    } catch {
+      return { status: "not-found", detail: `${file} doesn\u2019t exist.` };
+    }
+    return { status: "ok", sourceRel: toPosix(relative2(root, abs)), sourceAbs: abs, text };
+  }
+  const shortlist = [];
+  let scanned = 0;
+  const walk = async (dir, depth) => {
+    if (depth > SCAN_DEPTH_CAP || scanned > SCAN_FILE_CAP) return;
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (scanned > SCAN_FILE_CAP) return;
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && !NEVER_SCAN.has(entry.name)) await walk(join2(dir, entry.name), depth + 1);
+        continue;
+      }
+      if (!/\.(tsx|jsx)$/.test(entry.name)) continue;
+      scanned += 1;
+      const abs = join2(dir, entry.name);
+      let text;
+      try {
+        text = await readFile2(abs, "utf8");
+      } catch {
+        continue;
+      }
+      if (!text.includes(component) || !text.includes("export")) continue;
+      if (parseExport(text, component)) shortlist.push({ rel: toPosix(relative2(root, abs)), abs, text });
+    }
+  };
+  await walk(root, 0);
+  if (scanned > SCAN_FILE_CAP) {
+    return {
+      status: "error",
+      detail: `The project is too big to scan (${SCAN_FILE_CAP}+ files) \u2014 name the component\u2019s file.`
+    };
+  }
+  if (shortlist.length === 0) {
+    return { status: "not-found", detail: `No .tsx/.jsx file under the project exports ${component}.` };
+  }
+  if (shortlist.length > 1) {
+    return {
+      status: "ambiguous",
+      detail: `${shortlist.length} files export ${component} \u2014 name one.`,
+      candidates: shortlist.map((c) => c.rel)
+    };
+  }
+  const only = shortlist[0];
+  return { status: "ok", sourceRel: only.rel, sourceAbs: only.abs, text: only.text };
+}
+function parseExport(text, component) {
+  let program;
+  try {
+    const ast = parse(text, { sourceType: "module", plugins: ["jsx", "typescript"] });
+    program = ast.program.body;
+  } catch {
+    return null;
+  }
+  let found = null;
+  let hasDefault = false;
+  for (const node of program) {
+    if (node.type === "ExportDefaultDeclaration") {
+      hasDefault = true;
+      const decl2 = node["declaration"];
+      const name = decl2.type === "FunctionDeclaration" || decl2.type === "ClassDeclaration" ? decl2["id"]?.["name"] : decl2.type === "Identifier" ? decl2["name"] : void 0;
+      if (name === component) found ??= { importKind: "default", localName: component };
+      continue;
+    }
+    if (node.type !== "ExportNamedDeclaration") continue;
+    const decl = node["declaration"];
+    if (decl) {
+      if ((decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") && decl["id"]?.["name"] === component) {
+        found ??= { importKind: "named", localName: component };
+      }
+      if (decl.type === "VariableDeclaration") {
+        for (const d of decl["declarations"]) {
+          const id = d["id"];
+          if (id.type === "Identifier" && id["name"] === component) found ??= { importKind: "named", localName: component };
+        }
+      }
+    }
+    for (const spec of node["specifiers"] ?? []) {
+      if (spec.type !== "ExportSpecifier") continue;
+      const exported = spec["exported"];
+      const exportedName = exported.type === "Identifier" ? exported["name"] : exported["value"];
+      if (exportedName !== component) continue;
+      const local = spec["local"];
+      const localName = local.type === "Identifier" ? local["name"] : null;
+      found ??= { importKind: "named", localName: node["source"] ? null : localName };
+    }
+  }
+  return found ? { ...found, hasDefault } : null;
+}
+function importSpecifier(sourceRel) {
+  const fromDir = posix.join(...SANDBOX_DIR.split("/"));
+  const spec = posix.relative(fromDir, sourceRel).replace(/\.(tsx|jsx|ts|js)$/, "");
+  return spec.startsWith(".") ? spec : `./${spec}`;
+}
+function propsBrief(props) {
+  const entries = Object.entries(props ?? {});
+  if (entries.length === 0) return [];
+  return [
+    "// Props it was rendered with when it was pointed at \u2014 legible strings,",
+    "// captured live, worth more than anything invented:",
+    ...entries.map(([k, v]) => `//   ${k}=${v}`)
+  ];
+}
+function importBody(component, sourceRel, props, exportInfo) {
+  const spec = importSpecifier(sourceRel);
+  const importLine = exportInfo.importKind === "default" ? `import ${component} from '${spec}'` : `import { ${component} } from '${spec}'`;
+  return [
+    `// ${SANDBOX_DIR}/${component}${SANDBOX_SUFFIX}`,
+    `// ${SANDBOX_SOURCE_MARKER} ${sourceRel}`,
+    "//",
+    "// Generated by Blueprint \u2014 the mechanical half. The judgment half is the",
+    "// bp:fill slots below: realistic props, the axes this component varies",
+    "// along, and any tunables declared with useParam.",
+    importLine,
+    "",
+    ...propsBrief(props),
+    `export default function Sandbox() {`,
+    props && Object.keys(props).length > 0 ? `  // bp:fill props \u2014 give ${component} what it really renders with (captured above).` : `  // bp:fill props \u2014 give ${component} realistic props, in its most representative state.`,
+    `  return <${component} />`,
+    `}`,
+    "",
+    "// bp:fill states \u2014 the AXES this component varies along, not a flat list",
+    "// of combinations. Same `group` = alternatives (the card can only be in",
+    "// one: Default, Loading, Error). Different groups = orthogonal, one picker",
+    "// each \u2014 { group: 'Theme', name: 'Dark' } \u2014 and then the DEFAULT EXPORT",
+    "// renders the combination from its `variant` prop, because it is the only",
+    "// thing that sees all of it. A union-typed prop IS an axis and its default",
+    "// is the first option; at most 4 axes, at most 6 options each.",
+    `export const states = [{ name: 'Default', render: () => <${component} /> }]`,
+    ""
+  ].join("\n");
+}
+function forkBody(component, sourceRel, text, exportInfo) {
+  const header = [
+    `// ${SANDBOX_DIR}/${component}${SANDBOX_SUFFIX}`,
+    `// ${SANDBOX_SOURCE_MARKER} ${sourceRel}`,
+    forkMarkerLine({ file: sourceRel, exportName: component, forkedAt: (/* @__PURE__ */ new Date()).toISOString() }),
+    "//",
+    "// A FORK \u2014 this file is a copy, and the card tracks its drift from the",
+    "// origin. The way back is Merge (land the changes) or Propose (a PR).",
+    ""
+  ].join("\n");
+  const rewritten = rewriteRelativeImports(text, sourceRel);
+  const lines = [];
+  if (exportInfo.localName) {
+    if (!exportInfo.hasDefault) {
+      lines.push("", `export default function Sandbox() {`, `  return <${exportInfo.localName} />`, `}`);
+    }
+    lines.push(
+      "",
+      `export const states = [{ name: 'Default', render: () => <${exportInfo.localName} /> }]`,
+      ""
+    );
+  }
+  return header + rewritten + lines.join("\n");
+}
+function rewriteRelativeImports(text, sourceRel) {
+  let program;
+  try {
+    const ast = parse(text, { sourceType: "module", plugins: ["jsx", "typescript"] });
+    program = ast.program.body;
+  } catch {
+    return text;
+  }
+  const sourceDir = posix.dirname(sourceRel);
+  const sandboxDir = posix.join(...SANDBOX_DIR.split("/"));
+  const ms = new MagicString(text);
+  let touched = false;
+  for (const node of program) {
+    if (node.type !== "ImportDeclaration" && node.type !== "ExportNamedDeclaration" && node.type !== "ExportAllDeclaration")
+      continue;
+    const src = node["source"];
+    if (!src || typeof src.value !== "string") continue;
+    if (!src.value.startsWith("./") && !src.value.startsWith("../")) continue;
+    const absolute = posix.join(sourceDir, src.value);
+    let next = posix.relative(sandboxDir, absolute);
+    if (!next.startsWith(".")) next = `./${next}`;
+    ms.overwrite(src.start, src.end, JSON.stringify(next).replace(/"/g, "'"));
+    touched = true;
+  }
+  return touched ? ms.toString() : text;
+}
+function hashOf(text) {
+  return createHash("sha1").update(text).digest("hex");
+}
+async function readLineage(root) {
+  try {
+    const raw = JSON.parse(await readFile2(join2(root, SANDBOX_LINEAGE_FILE), "utf8"));
+    if (typeof raw !== "object" || raw === null) return {};
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+      const rec = value;
+      if (typeof rec?.origin === "string" && typeof rec?.fork === "string")
+        out[key] = { origin: rec.origin, fork: rec.fork };
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+async function recordLineage(root, component, record) {
+  const all = await readLineage(root);
+  all[component] = record;
+  await writeAtomic(join2(root, SANDBOX_LINEAGE_FILE), JSON.stringify(all, null, 2) + "\n");
+}
+async function ensureBoilerplate(root) {
+  await mkdir2(join2(root, SANDBOX_DIR), { recursive: true });
+  await writeOwned(join2(root, BLUEPRINT_DIR, ".gitignore"), BLUEPRINT_IGNORE);
+  await writeOwned(join2(root, SANDBOX_DIR, "README.md"), sandboxReadme());
+}
+async function writeOwned(path, content) {
+  let existing = null;
+  try {
+    existing = await readFile2(path, "utf8");
+  } catch {
+    existing = null;
+  }
+  if (existing === content) return;
+  if (existing !== null && !existing.includes(SANDBOX_MARKER)) return;
+  await writeFile2(path, content, "utf8");
+}
+async function writeAtomic(path, content) {
+  const tmp = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+  await writeFile2(tmp, content, "utf8");
+  await rename(tmp, path);
+}
+function toPosix(p) {
+  return p.split(sep2).join("/");
+}
+// src/cli.ts
+var USAGE = [
+  "Usage:",
+  "  blueprint init [--port <n>]",
+  "  blueprint generate sandbox <Component> [--source <file>] [--fork]"
+].join("\n");
+async function runCli(argv) {
+  const [command] = argv;
+  if (command === "init") return runInit(argv.slice(1));
+  if (command === "generate") return runGenerate(argv.slice(1));
+  console.error(USAGE);
+  return 2;
+}
+function nextRouteFile(root) {
+  const app = existsSync3(join3(root, "src", "app")) && !existsSync3(join3(root, "app")) ? join3("src", "app") : "app";
+  return join3(app, "api", "blueprint", "[[...path]]", "route.ts");
+}
+var NEXT_ROUTE_SOURCE = `export { GET, POST, PUT, DELETE } from '@blueprint/dev/next'
+export const dynamic = 'force-dynamic'
+`;
+async function runInit(rest) {
+  const root = process.cwd();
+  const isNext = ["next.config.ts", "next.config.mts", "next.config.js", "next.config.mjs", "next.config.cjs"].some(
+    (name) => existsSync3(join3(root, name))
+  );
+  let port = isNext ? 3e3 : 5173;
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i];
+    if (arg === "--port" && rest[i + 1]) {
+      const parsed = Number.parseInt(rest[i + 1], 10);
+      if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
+        console.error(`--port needs a port number, got ${JSON.stringify(rest[i + 1])}.`);
+        return 2;
+      }
+      port = parsed;
+      i += 1;
+    } else {
+      console.error(`Unknown argument: ${arg}`);
+      console.error(USAGE);
+      return 2;
+    }
+  }
+  const url = `http://localhost:${port}/__blueprint/mcp`;
+  await writeClaudeCodeConfig(root, url);
+  await writeClaudeCodeTrust(root);
+  await ensureBoilerplate(root);
+  console.log(`Wrote .mcp.json \u2014 your agent connects to ${url}`);
+  console.log("Wrote .claude/settings.local.json \u2014 Claude Code starts without a trust prompt.");
+  if (isNext) {
+    const route = nextRouteFile(root);
+    const file = join3(root, route);
+    if (existsSync3(file)) console.log(`${route} is already there \u2014 left as it is.`);
+    else {
+      await mkdir3(join3(file, ".."), { recursive: true });
+      await writeFile3(file, NEXT_ROUTE_SOURCE, "utf8");
+      console.log(`Wrote ${route} \u2014 the Blueprint route handler.`);
+    }
+    console.log("");
+    console.log("Wrap your Next config:");
+    console.log("");
+    console.log("  import { withBlueprint } from '@blueprint/dev/next'");
+    console.log("");
+    console.log("  export default withBlueprint({ /* your config */ })");
+    console.log("");
+    console.log("And put the probe in the root layout\u2019s <head>:");
+    console.log("");
+    console.log("  import { Beam } from '@blueprint/dev/next'");
+    console.log("");
+    console.log("  <head><Beam /></head>");
+    console.log("");
+    console.log(
+      `Then run your dev server on this machine, open your app and press \u2325\u2318B \u2014 or open http://localhost:${port}/__blueprint for the canvas. If the server binds a different port, the host corrects .mcp.json on first request.`
+    );
+    return 0;
+  }
+  console.log("");
+  console.log("Add the plugin (first in the array) to your vite config:");
+  console.log("");
+  console.log("  import { blueprint } from '@blueprint/dev'");
+  console.log("");
+  console.log("  export default defineConfig({");
+  console.log("    plugins: [blueprint() /* , react(), tailwindcss(), \u2026 */]");
+  console.log("  })");
+  console.log("");
+  console.log(
+    `Then run your dev server on this machine, open your app and press \u2325\u2318B \u2014 or open http://localhost:${port}/__blueprint for the canvas. If the server binds a different port, the plugin corrects .mcp.json on boot.`
+  );
+  return 0;
+}
+async function runGenerate(rest) {
+  const [kind, component, ...args] = rest;
+  if (kind !== "sandbox" || !component || component.startsWith("-")) {
+    console.error(USAGE);
+    return 2;
+  }
+  const request = { component };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--fork") request.fork = true;
+    else if (arg === "--source" && args[i + 1]) {
+      request.source = args[i + 1];
+      i += 1;
+    } else {
+      console.error(`Unknown argument: ${arg}`);
+      return 2;
+    }
+  }
+  const result = await generateSandbox(process.cwd(), request);
+  switch (result.status) {
+    case "created":
+      console.log(`Created ${result.file}${request.fork ? " (fork, lineage recorded)" : ""}`);
+      console.log(`Serving at ${result.route} once the dev server runs with the blueprint() plugin.`);
+      return 0;
+    case "exists":
+      console.log(`${result.file} already exists \u2014 the generator never overwrites.`);
+      console.log(`Serving at ${result.route}.`);
+      return 0;
+    case "ambiguous":
+      console.error(result.detail ?? "Several files export that name.");
+      for (const candidate of result.candidates ?? []) console.error(`  ${candidate}`);
+      console.error(`Run again with --source <file>.`);
+      return 1;
+    default:
+      console.error(result.detail ?? `Refused: ${result.status}.`);
+      return 1;
+  }
+}
+export {
+  runCli
+};