@noir-ai/create 1.2.0-beta.1

package/dist/index.js

@@ -0,0 +1,712 @@
+// src/manifest.ts
+import { join, relative } from "path";
+import {
+  AGENTS_MD_FILENAME,
+  emitAgentsMd,
+  resolveAdapter
+} from "@noir-ai/adapters";
+import {
+  CONTEXT_BLOCK,
+  IGNORE_BLOCK,
+  managedBlock,
+  NOIR_DIR,
+  paths,
+  RULES_BLOCK
+} from "@noir-ai/core";
+var BRIEF_BLOCK = managedBlock("brief", "html");
+var P = {
+  projectId: `${NOIR_DIR}/project.id`,
+  config: `${NOIR_DIR}/config.yml`,
+  noirMd: `${NOIR_DIR}/NOIR.md`,
+  rulesMd: `${NOIR_DIR}/rules/RULES.md`
+};
+var MANIFEST_PATH_PARITY = [
+  [P.projectId, paths.projectId],
+  [P.config, paths.config],
+  [P.noirMd, paths.noirMd],
+  [P.rulesMd, paths.rulesMd]
+];
+function buildManifest(ctx) {
+  return [...hostAgnosticEntries(ctx), ...buildHostArtifacts(resolveAdapter(ctx.host), ctx)];
+}
+function hostAgnosticEntries(ctx) {
+  return [
+    {
+      path: P.projectId,
+      mode: "skipIfExists",
+      content: `${ctx.projectId}
+`,
+      description: "canonical project id (store DB is named after it)"
+    },
+    {
+      path: P.config,
+      mode: "skipIfExists",
+      template: "config.yml.tmpl",
+      description: "user config seed (host + mode)"
+    },
+    {
+      path: P.noirMd,
+      mode: "managedBlock",
+      block: BRIEF_BLOCK,
+      template: "noir.md.tmpl",
+      description: "NOIR.md auto-brief (project id pointer)"
+    },
+    {
+      path: P.rulesMd,
+      mode: "skipIfExists",
+      template: "rules-seed.md.tmpl",
+      description: "AI working-rules seed"
+    },
+    // --- ignore files (host-agnostic; co-owned via IGNORE_BLOCK) ------------
+    {
+      path: ".gitignore",
+      mode: "managedBlock",
+      block: IGNORE_BLOCK,
+      template: "gitignore.tmpl",
+      description: ".gitignore noir managed block"
+    },
+    {
+      path: ".dockerignore",
+      mode: "managedBlock",
+      block: IGNORE_BLOCK,
+      template: "dockerignore.tmpl",
+      description: ".dockerignore noir managed block"
+    },
+    {
+      path: ".npmignore",
+      mode: "managedBlock",
+      block: IGNORE_BLOCK,
+      template: "npmignore.tmpl",
+      description: ".npmignore noir managed block"
+    },
+    {
+      path: ".prettierignore",
+      mode: "managedBlock",
+      block: IGNORE_BLOCK,
+      template: "prettierignore.tmpl",
+      description: ".prettierignore noir managed block"
+    }
+  ];
+}
+function buildHostArtifacts(adapter, ctx) {
+  const ectx = { root: ctx.root };
+  const host = adapter.id;
+  const entries = [];
+  const emitsAgentsMd = host === "agents-md" || host === "cursor" || host === "opencode";
+  if (emitsAgentsMd) {
+    entries.push({
+      path: hostRel(adapter.agentsMdPath?.(ectx) ?? join(ctx.root, AGENTS_MD_FILENAME), ctx.root),
+      mode: "regenerate",
+      host,
+      content: emitAgentsMd(ectx),
+      description: `AGENTS.md (${host}'s native context surface; @-imports .noir/)`
+    });
+  }
+  switch (host) {
+    case "claude":
+      entries.push({
+        path: "CLAUDE.md",
+        mode: "managedBlock",
+        host,
+        block: CONTEXT_BLOCK,
+        template: "claude-context-block.md.tmpl",
+        description: "CLAUDE.md context @import block"
+      });
+      entries.push({
+        path: "CLAUDE.md",
+        mode: "managedBlock",
+        host,
+        block: RULES_BLOCK,
+        template: "claude-rules-block.md.tmpl",
+        description: "CLAUDE.md rules @import block"
+      });
+      break;
+    case "gemini":
+      entries.push({
+        path: "GEMINI.md",
+        mode: "managedBlock",
+        host,
+        block: CONTEXT_BLOCK,
+        content: "@.noir/NOIR.md",
+        description: "GEMINI.md context @-import block"
+      });
+      entries.push({
+        path: "GEMINI.md",
+        mode: "managedBlock",
+        host,
+        block: RULES_BLOCK,
+        content: "@.noir/rules/RULES.md",
+        description: "GEMINI.md rules @-import block"
+      });
+      break;
+    case "agents-md":
+    case "cursor":
+    case "opencode":
+      break;
+  }
+  const mcpAbs = adapter.mcpConfigPath?.(ectx) ?? join(ctx.root, ".mcp.json");
+  const mcpRel = hostRel(mcpAbs, ctx.root);
+  if (host === "claude") {
+    const mcpTemplate = ctx.transport === "streamable-http" ? "mcp.http.json.tmpl" : "mcp.stdio.json.tmpl";
+    entries.push({
+      path: mcpRel,
+      mode: "regenerate",
+      host,
+      template: mcpTemplate,
+      description: "host MCP server pointer"
+    });
+  } else {
+    const mcpContent = `${adapter.emitMcpConfig(ectx, {
+      transport: ctx.transport,
+      ...ctx.url !== void 0 ? { url: ctx.url } : {}
+    })}
+`;
+    entries.push({
+      path: mcpRel,
+      mode: "regenerate",
+      host,
+      content: mcpContent,
+      description: `${host} MCP server pointer`
+    });
+  }
+  return entries;
+}
+function hostRel(abs, root) {
+  const rel = relative(root, abs);
+  if (rel.length === 0 || rel.startsWith("..") || rel.startsWith("/")) {
+    throw new Error(`buildHostArtifacts: path '${abs}' is not under root '${root}'`);
+  }
+  return rel.replace(/\\/g, "/");
+}
+
+// src/migrations/index.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+
+// src/migrations/runner.ts
+function runMigrations(root, from, to, opts = {}) {
+  const window = pickWindow(from ?? "0.0.0", to, MIGRATIONS);
+  const ctx = { root, dryRun: opts.dryRun === true };
+  const aggregate = { changed: [], conflicts: [], notes: [] };
+  const ran = [];
+  for (const script of window) {
+    ran.push(`${script.from}\u2192${script.to}`);
+    let res;
+    try {
+      res = script.run(ctx);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      aggregate.conflicts.push(`<runner>:${script.from}\u2192${script.to} threw: ${msg}`);
+      continue;
+    }
+    aggregate.changed.push(...res.changed);
+    aggregate.conflicts.push(...res.conflicts);
+    aggregate.notes.push(...res.notes);
+  }
+  return {
+    ...aggregate,
+    from,
+    to,
+    ran
+  };
+}
+function pickWindow(from, to, scripts) {
+  return scripts.filter((s) => compareVer(s.from) >= compareVer(from) && compareVer(s.to) <= compareVer(to)).sort((a, b) => compareVer(a.to) - compareVer(b.to));
+}
+function compareVer(v) {
+  const parts = v.split("-")[0]?.split(".") ?? [];
+  let n = 0;
+  for (let i = 0; i < 3; i++) {
+    const p = Number(parts[i] ?? "0");
+    n = n * 1e3 + (Number.isFinite(p) ? p : 0);
+  }
+  return n;
+}
+
+// src/migrations/index.ts
+var synthetic = {
+  from: "1.0.0",
+  to: "1.0.0",
+  description: "no-op synthetic migration (runner smoke test)",
+  run: (ctx) => {
+    const result = { changed: [], conflicts: [], notes: [] };
+    if (process.env.NOIR_TEST_FORCE_CONFLICT === "1" && !ctx.dryRun) {
+      const file = join2(ctx.root, ".noir", "scaffold-version");
+      if (existsSync(file)) {
+        const prev = readFileSync(file, "utf8");
+        const merged = applyInlineConflict(prev, "noir-scaffold=1.0.0\n", "ours", "theirs");
+        writeFileSync(file, merged, "utf8");
+        result.conflicts.push(".noir/scaffold-version");
+      }
+    }
+    result.notes.push("synthetic 1.0.0\u21921.0.0 migration ran");
+    return result;
+  }
+};
+var MIGRATIONS = [synthetic];
+function applyInlineConflict(ours, theirs, oursLabel = "ours", theirsLabel = "theirs") {
+  return `<<<<<<< ${oursLabel}
+${ours}=======
+${theirs}>>>>>>> ${theirsLabel}
+`;
+}
+function applyWithConflict(ours, theirs, path) {
+  if (ours === theirs) return { text: ours, conflicted: false };
+  return {
+    text: applyInlineConflict(ours, theirs, path, path),
+    conflicted: true
+  };
+}
+
+// src/scaffold.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync6, rmSync as rmSync2 } from "fs";
+import { dirname as dirname4, join as join7 } from "path";
+import { createProjectId, paths as paths2 } from "@noir-ai/core";
+
+// src/scaffold-version.ts
+import { mkdirSync, readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
+import { NOIR_DIR as NOIR_DIR2 } from "@noir-ai/core";
+
+// src/writers.ts
+import {
+  closeSync,
+  existsSync as existsSync2,
+  openSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  rmSync,
+  writeFileSync as writeFileSync2,
+  writeSync
+} from "fs";
+import { basename, dirname, join as join3 } from "path";
+import { stripManagedBlock, writeManagedRegion } from "@noir-ai/core";
+function regenerate(absPath, content) {
+  const dir = dirname(absPath);
+  const tmp = join3(
+    dir,
+    `.${basename(absPath)}.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`
+  );
+  let fd;
+  try {
+    fd = openSync(tmp, "w");
+    writeSync(fd, content, 0, "utf8");
+    closeSync(fd);
+    fd = void 0;
+    renameSync(tmp, absPath);
+  } finally {
+    if (fd !== void 0) {
+      try {
+        closeSync(fd);
+      } catch {
+      }
+    }
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+    }
+  }
+  return { path: absPath, mode: "regenerate", written: true };
+}
+function managedBlock2(absPath, block, regionText) {
+  writeManagedRegion(absPath, block, regionText);
+  return { path: absPath, mode: "managedBlock", written: true };
+}
+function managedBlocks(absPath, regions) {
+  if (regions.length === 0) {
+    throw new Error("managedBlocks requires at least one region");
+  }
+  if (regions.length === 1) {
+    const only = regions[0];
+    if (!only) throw new Error("managedBlocks: undefined region");
+    return managedBlock2(absPath, only.block, only.regionText);
+  }
+  let content = "";
+  try {
+    content = readFileSync2(absPath, "utf8");
+  } catch {
+  }
+  let stripped = content;
+  for (const r of regions) {
+    stripped = stripManagedBlock(stripped, r.block);
+  }
+  const regionsJoined = regions.map((r) => r.regionText).join("\n");
+  const next = stripped.trim().length > 0 ? `${stripped.trimEnd()}
+
+${regionsJoined}` : regionsJoined;
+  writeFileSync2(absPath, next, "utf8");
+  return { path: absPath, mode: "managedBlock", written: true };
+}
+function buildRegion(block, body) {
+  return `${block.begin}
+${body.trimEnd()}
+${block.end}
+`;
+}
+function skipIfExists(absPath, content) {
+  if (existsSync2(absPath)) {
+    return { path: absPath, mode: "skipIfExists", written: false };
+  }
+  writeFileSync2(absPath, content, "utf8");
+  return { path: absPath, mode: "skipIfExists", written: true };
+}
+
+// src/scaffold-version.ts
+var CURRENT_SCAFFOLD_VERSION = "1.0.0";
+var PREFIX = "noir-scaffold=";
+function scaffoldVersionPath(root) {
+  return join4(root, NOIR_DIR2, "scaffold-version");
+}
+function readScaffoldVersion(root) {
+  let raw;
+  try {
+    raw = readFileSync3(scaffoldVersionPath(root), "utf8");
+  } catch {
+    return null;
+  }
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith(PREFIX)) {
+      const v = trimmed.slice(PREFIX.length).trim();
+      if (v.length > 0) return v;
+    }
+  }
+  return null;
+}
+function writeScaffoldVersion(root, version) {
+  const file = scaffoldVersionPath(root);
+  mkdirSync(dirname2(file), { recursive: true });
+  regenerate(file, `${PREFIX}${version}
+`);
+}
+
+// src/stack-detect.ts
+import { existsSync as existsSync3, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
+var NODE_FRAMEWORKS = [
+  ["next", "next"],
+  ["vite", "vite"],
+  ["express", "express"],
+  ["fastify", "fastify"],
+  ["nuxt", "nuxt"],
+  ["remix", "remix"],
+  ["@sveltejs/kit", "sveltekit"],
+  ["@angular/core", "angular"],
+  ["react", "react"],
+  ["vue", "vue"]
+];
+var PYTHON_FRAMEWORKS = [
+  ["fastapi", "fastapi"],
+  ["flask", "flask"],
+  ["django", "django"],
+  ["sanic", "sanic"],
+  ["starlette", "starlette"],
+  ["tornado", "tornado"],
+  ["aiohttp", "aiohttp"],
+  ["bottle", "bottle"],
+  ["pyramid", "pyramid"],
+  ["falcon", "falcon"]
+];
+function readJson(file) {
+  try {
+    return JSON.parse(readFileSync4(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function detectStack(root) {
+  const languages = /* @__PURE__ */ new Set();
+  const frameworks = /* @__PURE__ */ new Set();
+  let monorepo = false;
+  let packageManager = null;
+  const pjPath = join5(root, "package.json");
+  if (existsSync3(pjPath)) {
+    const pj = readJson(pjPath);
+    if (pj) {
+      const hasTs = Boolean(pj.devDependencies?.typescript) || existsSync3(join5(root, "tsconfig.json"));
+      languages.add(hasTs ? "typescript" : "javascript");
+      const deps = /* @__PURE__ */ new Set([
+        ...Object.keys(pj.dependencies ?? {}),
+        ...Object.keys(pj.devDependencies ?? {})
+      ]);
+      for (const [dep, id] of NODE_FRAMEWORKS) {
+        if (deps.has(dep)) frameworks.add(id);
+      }
+      const ws = pj.workspaces;
+      if (Array.isArray(ws) || typeof ws === "object" && ws !== null && Array.isArray(ws.packages)) {
+        monorepo = true;
+      }
+      if (typeof pj.packageManager === "string" && pj.packageManager.length > 0) {
+        const m = pj.packageManager.split("@")[0];
+        if (m) packageManager = m;
+      }
+    }
+  }
+  if (existsSync3(join5(root, "pnpm-workspace.yaml"))) {
+    monorepo = true;
+    packageManager = packageManager ?? "pnpm";
+  }
+  if (existsSync3(join5(root, "turbo.json")) || existsSync3(join5(root, "nx.json"))) {
+    monorepo = true;
+  }
+  if (!packageManager) {
+    if (existsSync3(join5(root, "pnpm-lock.yaml"))) packageManager = "pnpm";
+    else if (existsSync3(join5(root, "yarn.lock"))) packageManager = "yarn";
+    else if (existsSync3(join5(root, "package-lock.json"))) packageManager = "npm";
+  }
+  if (existsSync3(join5(root, "pyproject.toml")) || existsSync3(join5(root, "requirements.txt")) || existsSync3(join5(root, "Pipfile")) || existsSync3(join5(root, "setup.py"))) {
+    languages.add("python");
+    if (existsSync3(join5(root, "pyproject.toml"))) {
+      const raw = safeRead(join5(root, "pyproject.toml"));
+      if (raw) {
+        for (const [dep, id] of PYTHON_FRAMEWORKS) {
+          if (pyprojectHasDep(raw, dep)) frameworks.add(id);
+        }
+      }
+    }
+  }
+  if (existsSync3(join5(root, "go.mod"))) {
+    languages.add("go");
+    packageManager = packageManager ?? "go-modules";
+  }
+  if (existsSync3(join5(root, "Cargo.toml"))) {
+    languages.add("rust");
+    const raw = safeRead(join5(root, "Cargo.toml"));
+    if (raw) {
+      if (/^\s*actix-web\b/m.test(raw)) frameworks.add("actix-web");
+      if (/^\s*actix\s*=/m.test(raw)) frameworks.add("actix");
+      if (/^\s*axum\s*=/m.test(raw)) frameworks.add("axum");
+      if (/^\s*rocket\s*=/m.test(raw)) frameworks.add("rocket");
+    }
+    packageManager = packageManager ?? "cargo";
+  }
+  return {
+    languages: [...languages].sort(),
+    monorepo,
+    frameworks: [...frameworks].sort(),
+    packageManager
+  };
+}
+function safeRead(file) {
+  try {
+    return readFileSync4(file, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function pyprojectHasDep(raw, dep) {
+  const esc = dep.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const before = `(?:^|["'\\s])`;
+  const after = `(?=\\s|["'<>=!~;]|\\[|$)`;
+  return new RegExp(`${before}${esc}${after}`, "m").test(raw);
+}
+
+// src/template.ts
+var TOKEN = /\{\{\s*([^}{}]+?)\s*\}\}/g;
+function render(template, vars) {
+  return template.replace(TOKEN, (whole, name) => {
+    if (!Object.hasOwn(vars, name)) return whole;
+    const v = vars[name];
+    if (v === void 0 || v === null) return whole;
+    return String(v);
+  });
+}
+
+// src/template-loader.ts
+import { readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname3, join as join6, resolve } from "path";
+import { fileURLToPath } from "url";
+var DEFAULT_TEMPLATES_DIR = resolveTemplatesDir();
+function resolveTemplatesDir() {
+  const override = process.env.NOIR_TEMPLATES_DIR;
+  if (override && override.length > 0) return resolve(override);
+  const here = dirname3(fileURLToPath(import.meta.url));
+  return join6(here, "..", "templates");
+}
+function loadTemplate(name) {
+  return readFileSync5(join6(DEFAULT_TEMPLATES_DIR, name), "utf8");
+}
+function templatesDir() {
+  return DEFAULT_TEMPLATES_DIR;
+}
+
+// src/scaffold.ts
+var WRITER_BY_MODE = {
+  // 'runtime' subset = regenerate + managedBlock (the always-safe-to-rewrite
+  // entries). sync + init --upgrade emit only this subset; skipIfExists is
+  // reserved for first-run init/create so user edits survive.
+  regenerate: "runtime",
+  managedBlock: "runtime",
+  skipIfExists: "all"
+};
+async function scaffold(opts) {
+  const host = opts.host ?? "claude";
+  const transport = opts.transport ?? "stdio";
+  if (transport === "streamable-http" && !opts.url) {
+    throw new Error("transport 'streamable-http' requires opts.url");
+  }
+  if (opts.mode === "create" && !opts.dryRun) {
+    mkdirSync2(opts.root, { recursive: true });
+  }
+  const idFile = readProjectIdFile(opts.root);
+  const projectId = resolveProjectId(opts, idFile);
+  if (!opts.dryRun && idFile.state === "corrupt") {
+    rmSync2(paths2.projectId(opts.root), { force: true });
+  }
+  const fromVersion = readScaffoldVersion(opts.root);
+  const stack = detectStack(opts.root);
+  const migrationsRan = [];
+  const migrationConflicts = [];
+  if (opts.mode === "init" && opts.upgrade === true && fromVersion !== null) {
+    const m = runMigrations(opts.root, fromVersion, CURRENT_SCAFFOLD_VERSION, {
+      dryRun: opts.dryRun === true
+    });
+    migrationsRan.push(...m.ran);
+    migrationConflicts.push(...m.conflicts);
+  }
+  const manifest = buildManifest({ root: opts.root, projectId, host, transport, url: opts.url });
+  const emitRuntimeOnly = opts.mode === "sync" || opts.mode === "init" && opts.upgrade === true;
+  const vars = {
+    root: opts.root,
+    projectId,
+    host,
+    transport,
+    url: opts.url
+  };
+  const written = [];
+  const skipped = [];
+  const groups = groupApplicableByPath(manifest, host, emitRuntimeOnly);
+  for (const [relPath, entries] of groups) {
+    const abs = join7(opts.root, relPath);
+    const managed = entries.filter((e) => e.mode === "managedBlock");
+    if (managed.length >= 2) {
+      if (opts.dryRun) {
+        written.push(relPath);
+        continue;
+      }
+      mkdirSync2(dirname4(abs), { recursive: true });
+      const regions = managed.map((e) => {
+        const block = e.block;
+        if (!block) {
+          throw new Error(`manifest entry ${e.path}: managedBlock mode missing 'block'`);
+        }
+        return { block, regionText: buildRegion(block, renderEntry(e, vars)) };
+      });
+      managedBlocks(abs, regions);
+      written.push(relPath);
+      continue;
+    }
+    if (!opts.dryRun) mkdirSync2(dirname4(abs), { recursive: true });
+    for (const entry of entries) {
+      if (opts.dryRun) {
+        if (entry.mode === "skipIfExists" && existsSync4(abs)) skipped.push(entry.path);
+        else written.push(entry.path);
+        continue;
+      }
+      const body = renderEntry(entry, vars);
+      if (entry.mode === "regenerate") {
+        regenerate(abs, body);
+        written.push(entry.path);
+      } else if (entry.mode === "managedBlock") {
+        const block = entry.block;
+        if (!block) {
+          throw new Error(`manifest entry ${entry.path}: managedBlock mode missing 'block'`);
+        }
+        if (isNoirMdPath(entry.path)) healLegacyNoirMd(abs);
+        managedBlock2(abs, block, buildRegion(block, body));
+        written.push(entry.path);
+      } else {
+        const out = skipIfExists(abs, body);
+        if (out.written) written.push(entry.path);
+        else skipped.push(entry.path);
+      }
+    }
+  }
+  if ((opts.mode === "init" || opts.mode === "create") && !opts.dryRun) {
+    writeScaffoldVersion(opts.root, CURRENT_SCAFFOLD_VERSION);
+  }
+  return {
+    written,
+    skipped,
+    migrationsRan,
+    migrationConflicts,
+    stack,
+    projectId,
+    fromVersion,
+    toVersion: CURRENT_SCAFFOLD_VERSION,
+    host
+  };
+}
+function readProjectIdFile(root) {
+  let raw;
+  try {
+    raw = readFileSync6(paths2.projectId(root), "utf8");
+  } catch {
+    return { state: "absent", id: null };
+  }
+  const trimmed = raw.trim();
+  return trimmed.length > 0 ? { state: "valid", id: trimmed } : { state: "corrupt", id: null };
+}
+function resolveProjectId(opts, idFile) {
+  if (opts.projectId !== void 0) return opts.projectId;
+  if (idFile.state === "valid") return idFile.id;
+  if (opts.mode === "sync") {
+    throw new Error(`Noir is not initialized in ${opts.root}. Run \`noir init\` first.`);
+  }
+  return createProjectId();
+}
+function groupApplicableByPath(manifest, host, emitRuntimeOnly) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of manifest) {
+    if (entry.host !== void 0 && entry.host !== host) continue;
+    if (emitRuntimeOnly && WRITER_BY_MODE[entry.mode] !== "runtime") continue;
+    const list = groups.get(entry.path);
+    if (list) list.push(entry);
+    else groups.set(entry.path, [entry]);
+  }
+  return groups;
+}
+function isNoirMdPath(relPath) {
+  return relPath === ".noir/NOIR.md";
+}
+function healLegacyNoirMd(absPath) {
+  let content;
+  try {
+    content = readFileSync6(absPath, "utf8");
+  } catch {
+    return;
+  }
+  if (/<!-- noir:[a-z]+ begin -->/.test(content)) return;
+  rmSync2(absPath, { force: true });
+}
+function renderEntry(entry, vars) {
+  if (entry.template !== void 0) {
+    return render(loadTemplate(entry.template), vars);
+  }
+  if (entry.content !== void 0) return entry.content;
+  throw new Error(`manifest entry ${entry.path}: must define 'content' or 'template'`);
+}
+export {
+  BRIEF_BLOCK,
+  CURRENT_SCAFFOLD_VERSION,
+  MANIFEST_PATH_PARITY,
+  MIGRATIONS,
+  applyInlineConflict,
+  applyWithConflict,
+  buildHostArtifacts,
+  buildManifest,
+  buildRegion,
+  detectStack,
+  loadTemplate,
+  managedBlock2 as managedBlock,
+  readScaffoldVersion,
+  regenerate,
+  render,
+  runMigrations,
+  scaffold,
+  scaffoldVersionPath,
+  skipIfExists,
+  templatesDir,
+  writeScaffoldVersion
+};
+//# sourceMappingURL=index.js.map