@babylonjsmarket/cli 1.0.2

package/dist/lib/inject/engine.js

@@ -0,0 +1,655 @@
+// src/lib/inject/engine.ts
+import fs2 from "fs";
+import path2 from "path";
+import mri from "mri";
+import colors2 from "picocolors";
+
+// src/lib/inject/inject-options.ts
+import colors from "picocolors";
+var { cyan, bold } = colors;
+var INJECT_HELP = `Usage: bjs inject [OPTION]... NAME...
+
+Submit a component or system from your project's ${cyan("src/components/<Name>/")} to
+BabylonJS Market for curator review (reverse of ${cyan("arcade eject")}).
+
+With no ${bold("--target")}, the tool auto-detects per seed:
+  * any file extending ${cyan("PanelDebuggerSystem")} / ${cyan("StateStepperSystem")} or
+    importing from ${cyan("@babylonjsmarket/viz-pro")} \u2192 ${cyan("viz-pro")},
+  * otherwise \u2192 ${cyan("arcade-pro")}.
+
+Multi-seed inputs must all detect to the same target.
+
+Options:
+  --target <arcade-pro|viz-pro>   skip auto-detection
+  --source <path>                 override <cwd>/src/components/<Name>/
+  --layer <core|solid|ecs>        viz-pro only; skip per-file layer detection
+  --force                         allow overwriting an existing target
+  --dry-run                       print the plan, write nothing, do not submit
+  -h, --help                      print this help message
+
+Examples:
+  bjs inject Foo                              # auto-detect target
+  bjs inject Foo Bar --dry-run                # multi-name, preview
+  bjs inject MyPanelDebugger --target viz-pro
+  bjs inject Foo --source ./packages/demo/src/components/Foo
+`;
+
+// src/lib/inject/detect-target.ts
+function detectTarget(seedFiles) {
+  for (const { source } of seedFiles) {
+    if (/from\s+['"]@babylonjsmarket\/viz-pro['"]/.test(source)) return "viz-pro";
+    if (/extends\s+(PanelDebuggerSystem|StateStepperSystem)\b/.test(source)) return "viz-pro";
+  }
+  return "arcade-pro";
+}
+function detectLayer(filePath, source, subjectLayer) {
+  const base = filePath.split(/[\\/]/).pop() ?? filePath;
+  if (/\.test\.tsx?$/.test(base)) {
+    return subjectLayer ?? "core";
+  }
+  const hasSolidImport = /from\s+['"]solid-js['"]/.test(source);
+  if (/\.tsx$/.test(base) && hasSolidImport) return "solid";
+  if (/extends\s+(PanelDebuggerSystem|StateStepperSystem|System)\b/.test(source)) return "ecs";
+  if (/System\.ts$/.test(base)) return "ecs";
+  if (/extends\s+Component\b/.test(source) && !hasSolidImport) return "ecs";
+  if (/\bdefinePanel\s*\(/.test(source) && !hasSolidImport) return "core";
+  return "core";
+}
+
+// src/lib/inject/monorepo-root.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function findMonorepoRoot() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  let dir = here;
+  while (true) {
+    const pkgPath = path.join(dir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        if (pkg.name === "babylonjs-market-monorepo") {
+          return {
+            root: dir,
+            arcadeProRoot: path.join(dir, "packages", "arcade-pro"),
+            vizProRoot: path.join(dir, "packages", "viz-pro")
+          };
+        }
+      } catch {
+      }
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      throw new Error(
+        `Could not locate umbrella repo (no ancestor package.json with name "babylonjs-market-monorepo" above ${here}).`
+      );
+    }
+    dir = parent;
+  }
+}
+
+// src/lib/inject/engine.ts
+var { cyan: cyan2, green, yellow, dim, bold: bold2 } = colors2;
+function componentFiles(dir) {
+  const out = [];
+  const walk = (d) => {
+    for (const e of fs2.readdirSync(d, { withFileTypes: true })) {
+      const p = path2.join(d, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (/\.(ts|tsx)$/.test(e.name)) out.push(p);
+    }
+  };
+  if (fs2.existsSync(dir)) walk(dir);
+  return out;
+}
+function allComponentFiles(dir) {
+  const out = [];
+  const walk = (d) => {
+    for (const e of fs2.readdirSync(d, { withFileTypes: true })) {
+      const p = path2.join(d, e.name);
+      if (e.isDirectory()) walk(p);
+      else out.push(p);
+    }
+  };
+  if (fs2.existsSync(dir)) walk(dir);
+  return out;
+}
+function projectComponentNames(projectDir) {
+  const dir = path2.join(projectDir, "src", "components");
+  if (!fs2.existsSync(dir)) return [];
+  return fs2.readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name !== "_shared").map((e) => e.name);
+}
+function directDeps(name, componentsDir, allNames) {
+  const deps = /* @__PURE__ */ new Set();
+  const metaPath = path2.join(componentsDir, name, "meta.json");
+  if (fs2.existsSync(metaPath)) {
+    try {
+      const meta = JSON.parse(fs2.readFileSync(metaPath, "utf8"));
+      for (const d of meta.dependencies ?? []) if (allNames.has(d)) deps.add(d);
+    } catch {
+    }
+  }
+  const relRe = /['"]\.\.\/([A-Z][A-Za-z0-9_]*)\//g;
+  const aliasRe = /['"]~\/components\/([A-Z][A-Za-z0-9_]*)\//g;
+  for (const file of componentFiles(path2.join(componentsDir, name))) {
+    const src = fs2.readFileSync(file, "utf8");
+    let m;
+    while (m = relRe.exec(src)) if (allNames.has(m[1])) deps.add(m[1]);
+    while (m = aliasRe.exec(src)) if (allNames.has(m[1])) deps.add(m[1]);
+  }
+  return deps;
+}
+function resolveClosure(seed, componentsDir, allNames) {
+  const all = new Set(allNames);
+  const out = new Set(seed);
+  const queue = [...seed];
+  while (queue.length) {
+    const next = queue.pop();
+    for (const dep of directDeps(next, componentsDir, all)) {
+      if (!out.has(dep)) {
+        out.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+  return out;
+}
+function rewriteArcadeImports(src, injected) {
+  return src.replace(
+    /(['"])@babylonjsmarket\/(?:arcade|arcade-pro)\/([A-Z][A-Za-z0-9_]*)\1/g,
+    (whole, quote, sibling) => {
+      if (injected.has(sibling)) {
+        return `${quote}../${sibling}/${sibling}${quote}`;
+      }
+      return whole;
+    }
+  );
+}
+function rewriteVizImports(src, injected, layerOf, fromLayer) {
+  return src.replace(
+    /(['"])@babylonjsmarket\/(?:viz-pro|arcade|arcade-pro)\/([A-Z][A-Za-z0-9_]*)\1/g,
+    (whole, quote, sibling) => {
+      if (!injected.has(sibling)) return whole;
+      const dest = layerOf(sibling);
+      if (!dest) return whole;
+      const rel = dest === fromLayer ? `./${sibling}` : `../${dest}/${sibling}`;
+      return `${quote}${rel}${quote}`;
+    }
+  );
+}
+function planArcadeProRegistry(existingRegistry, names, registryRelPath = "src/registry.ts") {
+  const warnings = [];
+  if (existingRegistry === void 0) {
+    warnings.push(
+      `! packages/arcade-pro/${registryRelPath} not found \u2014 add resolvers manually for: ${names.join(", ")}`
+    );
+    return { lines: [], added: [], warnings, markerFound: false };
+  }
+  const marker = /ARCADE_PRO_COMPONENT_REGISTRY:\s*Record<string,\s*LazyComponentResolver>\s*=\s*\{/;
+  if (!marker.test(existingRegistry)) {
+    warnings.push(
+      `! Could not find 'ARCADE_PRO_COMPONENT_REGISTRY' marker \u2014 add resolvers manually for: ${names.join(", ")}`
+    );
+    return { lines: [], added: [], warnings, markerFound: false };
+  }
+  const added = [];
+  const lines = [];
+  for (const name of names) {
+    if (existingRegistry.includes(`./Components/${name}/${name}`)) continue;
+    lines.push(`  ${name}: () => import('./Components/${name}/${name}'),`);
+    added.push(name);
+  }
+  return { lines, added, warnings, markerFound: true };
+}
+function patchArcadeProRegistry(arcadeProRoot, names, dryRun) {
+  const registryPath = path2.join(arcadeProRoot, "src", "registry.ts");
+  const existing = fs2.existsSync(registryPath) ? fs2.readFileSync(registryPath, "utf8") : void 0;
+  const plan = planArcadeProRegistry(existing, names);
+  if (plan.warnings.length) return plan.warnings;
+  if (plan.added.length && !dryRun) {
+    const marker = /ARCADE_PRO_COMPONENT_REGISTRY:\s*Record<string,\s*LazyComponentResolver>\s*=\s*\{/;
+    const next = existing.replace(marker, (m) => `${m}
+${plan.lines.join("\n")}`);
+    fs2.writeFileSync(registryPath, next);
+  }
+  return plan.added.map((n) => `  patched registry: ${n}`);
+}
+function planVizProBarrel(existingBarrel, layer, fileName) {
+  if (existingBarrel === void 0) {
+    return {
+      line: null,
+      warnings: [
+        `! packages/viz-pro/src/${layer}/index.ts not found \u2014 add the barrel re-export manually for ${fileName}`
+      ]
+    };
+  }
+  const needle = `from './${fileName}'`;
+  if (existingBarrel.includes(needle)) return { line: null, warnings: [] };
+  return { line: `export * from './${fileName}';`, warnings: [] };
+}
+function patchVizProBarrel(vizProRoot, layer, fileName, dryRun) {
+  const barrelPath = path2.join(vizProRoot, "src", layer, "index.ts");
+  const existing = fs2.existsSync(barrelPath) ? fs2.readFileSync(barrelPath, "utf8") : void 0;
+  const plan = planVizProBarrel(existing, layer, fileName);
+  if (plan.warnings.length) return plan.warnings;
+  if (plan.line === null) return [];
+  if (!dryRun) {
+    const next = existing.endsWith("\n") ? existing + plan.line + "\n" : existing + "\n" + plan.line + "\n";
+    fs2.writeFileSync(barrelPath, next);
+  }
+  return [`  patched ${layer}/index.ts: ${fileName}`];
+}
+function stripProjectRegistry(projectDir, names, dryRun) {
+  const registryPath = path2.join(projectDir, "src", "registry.ts");
+  if (!fs2.existsSync(registryPath)) return [];
+  let text = fs2.readFileSync(registryPath, "utf8");
+  const removed = [];
+  for (const name of names) {
+    const re = new RegExp(
+      `^\\s*${name}\\s*:\\s*\\(\\)\\s*=>\\s*import\\(\\s*['"]\\.\\/components\\/${name}\\/${name}['"]\\s*\\)\\s*,?\\s*\\r?\\n`,
+      "m"
+    );
+    if (re.test(text)) {
+      text = text.replace(re, "");
+      removed.push(name);
+    }
+  }
+  if (removed.length && !dryRun) fs2.writeFileSync(registryPath, text);
+  return removed;
+}
+async function inject(args, opts = {}) {
+  if (args.includes("-h") || args.includes("--help")) {
+    console.log(INJECT_HELP);
+    return;
+  }
+  const argv = mri(args, {
+    boolean: ["dry-run", "move", "confirm", "force"],
+    string: ["target", "source", "layer"]
+  });
+  const mode = opts.mode ?? "apply";
+  const dryRun = Boolean(argv["dry-run"]);
+  const move = Boolean(argv.move);
+  const confirm = Boolean(argv.confirm);
+  const force = Boolean(argv.force);
+  const explicitTarget = argv.target;
+  const sourceOverride = argv.source;
+  const layerOverride = argv.layer;
+  const names = argv._.map(String);
+  const cwd = opts.cwd ?? process.cwd();
+  const projectDir = opts.projectDir ?? cwd;
+  if (names.length === 0) {
+    console.error(yellow("No component names given. Pass at least one, e.g. `bjs inject Foo`."));
+    process.exit(1);
+    return;
+  }
+  if (mode === "collect" && (move || confirm)) {
+    console.error(yellow("--move and --confirm are not available in member submission mode."));
+    process.exit(1);
+    return;
+  }
+  if (move && !confirm) {
+    console.error(yellow("--move requires --confirm (it deletes project files). Pass --move --confirm."));
+    process.exit(1);
+    return;
+  }
+  if (move && dryRun) {
+    console.error(yellow("--move and --dry-run are mutually exclusive. Drop one."));
+    process.exit(1);
+    return;
+  }
+  if (explicitTarget && explicitTarget !== "arcade-pro" && explicitTarget !== "viz-pro") {
+    console.error(yellow(`Unknown --target ${explicitTarget}. Use arcade-pro or viz-pro.`));
+    process.exit(1);
+    return;
+  }
+  if (layerOverride && layerOverride !== "core" && layerOverride !== "solid" && layerOverride !== "ecs") {
+    console.error(yellow(`Unknown --layer ${layerOverride}. Use core, solid, or ecs.`));
+    process.exit(1);
+    return;
+  }
+  if (sourceOverride && names.length > 1) {
+    console.error(yellow("--source applies to a single seed; pass one NAME with --source."));
+    process.exit(1);
+    return;
+  }
+  let packageRoot = opts.packageRoot;
+  let vizProRoot = opts.vizProRoot;
+  if (mode === "apply" && (!packageRoot || !vizProRoot)) {
+    try {
+      const monorepo = findMonorepoRoot();
+      packageRoot ??= monorepo.arcadeProRoot;
+      vizProRoot ??= monorepo.vizProRoot;
+    } catch (e) {
+      console.error(yellow(e.message));
+      process.exit(1);
+      return;
+    }
+  }
+  const componentsDir = path2.join(projectDir, "src", "components");
+  const allProjectNames = projectComponentNames(projectDir);
+  const seeds = [];
+  for (const name of names) {
+    const sourceDir = sourceOverride ? path2.resolve(cwd, sourceOverride) : path2.join(componentsDir, name);
+    if (!fs2.existsSync(sourceDir)) {
+      console.error(
+        yellow(
+          `Could not find source for "${name}". Looked at ${sourceDir}. Use --source <path> to point at the seed explicitly.`
+        )
+      );
+      process.exit(1);
+      return;
+    }
+    seeds.push({ name, sourceDir });
+  }
+  const seedNames = new Set(seeds.map((s) => s.name));
+  const closure = sourceOverride ? seedNames : resolveClosure(seedNames, componentsDir, allProjectNames);
+  const closureFiles = [];
+  for (const name of closure) {
+    const dir = sourceOverride && seedNames.has(name) ? seeds.find((s) => s.name === name).sourceDir : path2.join(componentsDir, name);
+    for (const f of componentFiles(dir)) {
+      closureFiles.push({ path: f, source: fs2.readFileSync(f, "utf8") });
+    }
+  }
+  const target = explicitTarget ?? detectTarget(closureFiles);
+  if (!explicitTarget && seeds.length > 1) {
+    for (const seed of seeds) {
+      const dir = seed.sourceDir;
+      const files = componentFiles(dir).map((f) => ({
+        path: f,
+        source: fs2.readFileSync(f, "utf8")
+      }));
+      const perSeed = detectTarget(files);
+      if (perSeed !== target) {
+        console.error(
+          yellow(
+            `Auto-detect disagrees across seeds: "${seed.name}" \u2192 ${perSeed}, others \u2192 ${target}. Pass --target explicitly or split into separate runs.`
+          )
+        );
+        process.exit(1);
+        return;
+      }
+    }
+  }
+  let chosenRoot;
+  if (mode === "apply") {
+    try {
+      if (target === "arcade-pro") {
+        if (!fs2.existsSync(packageRoot)) {
+          throw new Error(
+            `packages/arcade-pro is not checked out at ${packageRoot}. Run \`git submodule update --init packages/arcade-pro\` and retry.`
+          );
+        }
+        chosenRoot = packageRoot;
+      } else {
+        if (!fs2.existsSync(vizProRoot)) {
+          throw new Error(
+            `packages/viz-pro is not checked out at ${vizProRoot}. Run \`git submodule update --init packages/viz-pro\` and retry.`
+          );
+        }
+        chosenRoot = vizProRoot;
+      }
+    } catch (e) {
+      console.error(yellow(e.message));
+      process.exit(1);
+      return;
+    }
+  }
+  console.log(
+    bold2(dryRun ? "\nInject plan (dry run \u2014 nothing written):" : "\nInjecting:")
+  );
+  console.log(`  target:     ${cyan2(target)}`);
+  console.log(`  components: ${cyan2([...closure].sort().join(", "))}`);
+  if (mode === "collect") {
+    const result = target === "arcade-pro" ? collectArcadePro({ seeds, closure, componentsDir, sourceOverride }) : collectVizPro({ seeds, closure, componentsDir, sourceOverride, layerOverride });
+    for (const f of result.files) console.log(green(`  + packages/${target}/${f.path}`));
+    for (const w of result.warnings) console.log(yellow(w));
+    console.log(
+      dryRun ? dim("\nRe-run without --dry-run to submit.\n") : dim("\nCollect-mode plan ready (no submission performed by the library).\n")
+    );
+    return { ...result, target };
+  }
+  if (target === "arcade-pro") {
+    await injectArcadePro({
+      seeds,
+      closure,
+      componentsDir,
+      sourceOverride,
+      arcadeProRoot: chosenRoot,
+      dryRun,
+      force
+    });
+  } else {
+    await injectVizPro({
+      seeds,
+      closure,
+      componentsDir,
+      sourceOverride,
+      vizProRoot: chosenRoot,
+      dryRun,
+      force,
+      layerOverride
+    });
+  }
+  if (move) {
+    if (sourceOverride) {
+      console.log(
+        yellow(
+          "  ! --move with --source: only the source dir is removed; cannot reliably patch a foreign project's registry."
+        )
+      );
+    }
+    for (const seed of seeds) {
+      if (fs2.existsSync(seed.sourceDir)) {
+        if (!dryRun) fs2.rmSync(seed.sourceDir, { recursive: true, force: true });
+        console.log(dim(`  - ${path2.relative(projectDir, seed.sourceDir)}/ (project copy removed)`));
+      }
+    }
+    const removed = stripProjectRegistry(
+      projectDir,
+      seeds.map((s) => s.name),
+      dryRun
+    );
+    for (const name of removed) {
+      console.log(dim(`  - project registry entry: ${name}`));
+    }
+  }
+  console.log(
+    dryRun ? dim("\nRe-run without --dry-run to apply.\n") : green(`
+Done. Components landed in packages/${target}/.
+`)
+  );
+}
+async function injectArcadePro(args) {
+  const { seeds, closure, componentsDir, sourceOverride, arcadeProRoot, dryRun, force } = args;
+  const destComponents = path2.join(arcadeProRoot, "src", "Components");
+  if (!dryRun) fs2.mkdirSync(destComponents, { recursive: true });
+  const sourceOf = (name) => {
+    const seed = seeds.find((s) => s.name === name);
+    return seed && sourceOverride ? seed.sourceDir : path2.join(componentsDir, name);
+  };
+  for (const name of [...closure].sort()) {
+    const src = sourceOf(name);
+    const dest = path2.join(destComponents, name);
+    if (fs2.existsSync(dest) && !force) {
+      console.log(
+        yellow(`  ! packages/arcade-pro/src/Components/${name}/ already exists \u2014 pass --force to overwrite.`)
+      );
+      continue;
+    }
+    if (!dryRun) {
+      if (fs2.existsSync(dest)) fs2.rmSync(dest, { recursive: true, force: true });
+      fs2.cpSync(src, dest, { recursive: true });
+    }
+    console.log(green(`  + packages/arcade-pro/src/Components/${name}/`));
+  }
+  if (!dryRun) {
+    for (const name of closure) {
+      const dest = path2.join(destComponents, name);
+      if (!fs2.existsSync(dest)) continue;
+      rewriteTree(dest, (text) => rewriteArcadeImports(text, closure));
+    }
+  }
+  for (const line of patchArcadeProRegistry(
+    arcadeProRoot,
+    [...closure].sort(),
+    dryRun
+  )) {
+    console.log(line.startsWith("!") ? yellow(line) : dim(line));
+  }
+}
+function collectArcadePro(args) {
+  const { seeds, closure, componentsDir, sourceOverride } = args;
+  const sourceOf = (name) => {
+    const seed = seeds.find((s) => s.name === name);
+    return seed && sourceOverride ? seed.sourceDir : path2.join(componentsDir, name);
+  };
+  const files = [];
+  const warnings = [];
+  for (const name of [...closure].sort()) {
+    const src = sourceOf(name);
+    if (!fs2.existsSync(src)) {
+      warnings.push(`  ! source for ${name} missing at ${src}`);
+      continue;
+    }
+    for (const abs of allComponentFiles(src)) {
+      const rel = path2.relative(src, abs);
+      const baseRel = path2.posix.join("src", "Components", name, rel.split(path2.sep).join("/"));
+      const isText = /\.(ts|tsx)$/i.test(abs);
+      const raw = fs2.readFileSync(abs, "utf8");
+      const contents = isText ? rewriteArcadeImports(raw, closure) : raw;
+      files.push({ path: baseRel, contents });
+    }
+  }
+  const patches = [];
+  for (const name of [...closure].sort()) {
+    patches.push({
+      file: "src/registry.ts",
+      kind: "registry-append",
+      line: `  ${name}: () => import('./Components/${name}/${name}'),`
+    });
+  }
+  return { files, patches, warnings };
+}
+function classifyVizFiles(args) {
+  const { seeds, closure, componentsDir, sourceOverride, layerOverride } = args;
+  const sourceOf = (name) => {
+    const seed = seeds.find((s) => s.name === name);
+    return seed && sourceOverride ? seed.sourceDir : path2.join(componentsDir, name);
+  };
+  const files = [];
+  for (const name of closure) {
+    const dir = sourceOf(name);
+    for (const abs of componentFiles(dir)) {
+      const base = path2.basename(abs);
+      if (/\.test\.tsx?$/.test(base)) continue;
+      const source = fs2.readFileSync(abs, "utf8");
+      const layer = layerOverride ?? detectLayer(abs, source);
+      files.push({ src: abs, base, owner: name, source, layer, destBase: base });
+    }
+  }
+  for (const name of closure) {
+    const dir = sourceOf(name);
+    for (const abs of componentFiles(dir)) {
+      const base = path2.basename(abs);
+      if (!/\.test\.tsx?$/.test(base)) continue;
+      const source = fs2.readFileSync(abs, "utf8");
+      const subjectBase = base.replace(/\.test(\.tsx?)$/, "$1");
+      const subjectAlt = base.replace(/\.test\.tsx?$/, ".tsx");
+      const subject = files.find((f) => f.owner === name && (f.base === subjectBase || f.base === subjectAlt));
+      const layer = layerOverride ?? detectLayer(abs, source, subject?.layer);
+      files.push({ src: abs, base, owner: name, source, layer, destBase: base });
+    }
+  }
+  const primaryLayer = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    if (/\.test\.tsx?$/.test(f.base)) continue;
+    if (!primaryLayer.has(f.owner)) primaryLayer.set(f.owner, f.layer);
+  }
+  return { files, primaryLayer };
+}
+async function injectVizPro(args) {
+  const { closure, vizProRoot, dryRun, force } = args;
+  const { files, primaryLayer } = classifyVizFiles(args);
+  const layerOf = (name) => primaryLayer.get(name);
+  for (const f of files) {
+    const dest = path2.join(vizProRoot, "src", f.layer, f.destBase);
+    if (fs2.existsSync(dest) && !force) {
+      console.log(
+        yellow(
+          `  ! packages/viz-pro/src/${f.layer}/${f.destBase} already exists \u2014 pass --force to overwrite.`
+        )
+      );
+    }
+  }
+  for (const f of files) {
+    const destDir = path2.join(vizProRoot, "src", f.layer);
+    const dest = path2.join(destDir, f.destBase);
+    if (fs2.existsSync(dest) && !force) continue;
+    if (!dryRun) {
+      fs2.mkdirSync(destDir, { recursive: true });
+      const rewritten = rewriteVizImports(f.source, closure, layerOf, f.layer);
+      fs2.writeFileSync(dest, rewritten);
+    }
+    console.log(green(`  + packages/viz-pro/src/${f.layer}/${f.destBase}`));
+  }
+  const barrelNames = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    if (/\.test\.tsx?$/.test(f.base)) continue;
+    const stem = f.destBase.replace(/\.tsx?$/, "");
+    const key = `${f.layer}:${stem}`;
+    if (barrelNames.has(key)) continue;
+    barrelNames.add(key);
+    for (const line of patchVizProBarrel(vizProRoot, f.layer, stem, dryRun)) {
+      console.log(line.startsWith("!") ? yellow(line) : dim(line));
+    }
+  }
+  console.log(
+    dim(
+      "  hint: if you want named re-exports from the package root, edit packages/viz-pro/src/index.ts by hand."
+    )
+  );
+}
+function collectVizPro(args) {
+  const { closure } = args;
+  const { files: classified, primaryLayer } = classifyVizFiles(args);
+  const layerOf = (name) => primaryLayer.get(name);
+  const files = [];
+  const warnings = [];
+  for (const f of classified) {
+    const rel = path2.posix.join("src", f.layer, f.destBase);
+    const contents = rewriteVizImports(f.source, closure, layerOf, f.layer);
+    files.push({ path: rel, contents });
+  }
+  const patches = [];
+  const barrelKeys = /* @__PURE__ */ new Set();
+  for (const f of classified) {
+    if (/\.test\.tsx?$/.test(f.base)) continue;
+    const stem = f.destBase.replace(/\.tsx?$/, "");
+    const key = `${f.layer}:${stem}`;
+    if (barrelKeys.has(key)) continue;
+    barrelKeys.add(key);
+    patches.push({
+      file: `src/${f.layer}/index.ts`,
+      kind: "barrel-append",
+      line: `export * from './${stem}';`
+    });
+  }
+  return { files, patches, warnings };
+}
+function rewriteTree(dir, rewrite) {
+  for (const e of fs2.readdirSync(dir, { withFileTypes: true })) {
+    const p = path2.join(dir, e.name);
+    if (e.isDirectory()) rewriteTree(p, rewrite);
+    else if (/\.(ts|tsx)$/.test(e.name)) {
+      const before = fs2.readFileSync(p, "utf8");
+      const after = rewrite(before);
+      if (after !== before) fs2.writeFileSync(p, after);
+    }
+  }
+}
+export {
+  detectLayer,
+  detectTarget,
+  inject
+};
+//# sourceMappingURL=engine.js.map