@kurotako/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1238 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BANNER: () => BANNER,
+  DependencyCycleError: () => DependencyCycleError,
+  DriverError: () => DriverError,
+  DuplicateNamespaceError: () => DuplicateNamespaceError,
+  GITATTRIBUTES: () => GITATTRIBUTES,
+  HookError: () => HookError,
+  InvalidDependencyError: () => InvalidDependencyError,
+  InvalidOutputPathError: () => InvalidOutputPathError,
+  IrValidationError: () => IrValidationError,
+  MissingPackageWorkspaceFilesError: () => MissingPackageWorkspaceFilesError,
+  NamespaceMismatchError: () => NamespaceMismatchError,
+  OutputCollisionError: () => OutputCollisionError,
+  OutputNotGeneratedError: () => OutputNotGeneratedError,
+  OutputPeerConflictError: () => OutputPeerConflictError,
+  PackageBuildError: () => PackageBuildError,
+  PackageInstallError: () => PackageInstallError,
+  TakoError: () => TakoError,
+  UnknownDependencyError: () => UnknownDependencyError,
+  UnsupportedOutputModeError: () => UnsupportedOutputModeError,
+  applyBanner: () => applyBanner,
+  childLogger: () => childLogger,
+  collectPeerDependencies: () => collectPeerDependencies,
+  directoryWriter: () => directoryWriter,
+  noopLogger: () => noopLogger,
+  packageWriter: () => packageWriter,
+  resolvePackageManager: () => resolvePackageManager,
+  run: () => run,
+  runInstall: () => runInstall,
+  selectWriter: () => selectWriter,
+  synthesizeRootBarrels: () => synthesizeRootBarrels
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var TakoError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = new.target.name;
+    this.code = code;
+  }
+};
+var NamespaceMismatchError = class extends TakoError {
+  namespace;
+  returned;
+  constructor(namespace, returned) {
+    super(
+      "namespace_mismatch",
+      `parser for namespace '${namespace}' returned a SourceIR with namespace '${returned}'`
+    );
+    this.namespace = namespace;
+    this.returned = returned;
+  }
+};
+var IrValidationError = class extends TakoError {
+  issues;
+  namespace;
+  constructor(issues, namespace) {
+    const detail = issues.map((i) => `${i.path === "" ? "<root>" : i.path}: ${i.message}`).join("; ");
+    const where = namespace ? ` in namespace '${namespace}'` : "";
+    super("ir_invalid", `invalid IR${where}: ${detail}`);
+    this.issues = issues;
+    this.namespace = namespace;
+  }
+};
+var DuplicateNamespaceError = class extends TakoError {
+  namespace;
+  constructor(namespace) {
+    super(
+      "duplicate_namespace",
+      `two sources claim the namespace '${namespace}'`
+    );
+    this.namespace = namespace;
+  }
+};
+var UnknownDependencyError = class extends TakoError {
+  generator;
+  missing;
+  constructor(generator, missing) {
+    super(
+      "unknown_dependency",
+      `generator '${generator}' declares a hard dependency on '${missing}', which is not in the config`
+    );
+    this.generator = generator;
+    this.missing = missing;
+  }
+};
+var InvalidDependencyError = class extends TakoError {
+  generator;
+  dependency;
+  constructor(generator, dependency) {
+    super(
+      "invalid_dependency",
+      `generator '${generator}' lists '${dependency}' in both dependsOn and optionalDependsOn`
+    );
+    this.generator = generator;
+    this.dependency = dependency;
+  }
+};
+var DependencyCycleError = class extends TakoError {
+  cycle;
+  constructor(cycle) {
+    super(
+      "dependency_cycle",
+      `the generator dependency graph has a cycle: ${cycle.join(" -> ")}`
+    );
+    this.cycle = cycle;
+  }
+};
+var OutputCollisionError = class extends TakoError {
+  path;
+  generators;
+  constructor(path5, generators, hint) {
+    super(
+      "output_collision",
+      `generators '${generators[0]}' and '${generators[1]}' both emit '${path5}'${hint ? `. ${hint}` : ""}`
+    );
+    this.path = path5;
+    this.generators = generators;
+  }
+};
+var InvalidOutputPathError = class extends TakoError {
+  path;
+  generator;
+  constructor(path5, generator) {
+    super(
+      "invalid_output_path",
+      `generator '${generator}' emits '${path5}', which escapes the output root`
+    );
+    this.path = path5;
+    this.generator = generator;
+  }
+};
+var UnsupportedOutputModeError = class extends TakoError {
+  mode;
+  constructor(mode) {
+    super(
+      "unsupported_output_mode",
+      `unsupported output mode '${mode}' (expected 'dir' or 'package')`
+    );
+    this.mode = mode;
+  }
+};
+var OutputPeerConflictError = class extends TakoError {
+  namespace;
+  package;
+  ranges;
+  generators;
+  constructor(namespace, pkg, ranges, generators) {
+    super(
+      "output_peer_conflict",
+      `namespace '${namespace}': generators [${generators.join(", ")}] declare peer '${pkg}' with conflicting ranges [${ranges.join(", ")}]`
+    );
+    this.namespace = namespace;
+    this.package = pkg;
+    this.ranges = ranges;
+    this.generators = generators;
+  }
+};
+var PackageBuildError = class extends TakoError {
+  namespace;
+  constructor(namespace, options) {
+    super(
+      "package_build_error",
+      `the build of the generated package for namespace '${namespace}' failed`,
+      options
+    );
+    this.namespace = namespace;
+  }
+};
+var MISSING_PACKAGE_WORKSPACE_FILE_GUIDANCE = {
+  "tsconfig.base.json": `Create '<workspaceRoot>/tsconfig.base.json':
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true
+  }
+}
+
+Use these values as-is, no adjustment needed: in particular, keep
+"moduleResolution": "bundler" \u2014 'node16'/'nodenext' would fail to compile
+the extensionless \`export * from './zod';\` that tako's generated root
+barrel always emits.`,
+  "tsup.config.base.{ts,js,mjs,cjs}": `Create '<workspaceRoot>/tsup.config.base.ts':
+import type { Options } from 'tsup';
+
+export const basePreset: Options = {
+  entry: ['src/index.ts'],
+  format: ['esm', 'cjs'],
+  dts: { compilerOptions: { composite: false, incremental: false } },
+  sourcemap: true,
+  clean: true,
+  target: 'node22',
+  outDir: 'dist',
+};`,
+  "'typescript' (devDependency, needed for the .d.ts build)": `Run, from '<workspaceRoot>':
+  <your package manager> add -D typescript`
+};
+var MissingPackageWorkspaceFilesError = class extends TakoError {
+  workspaceRoot;
+  missing;
+  constructor(workspaceRoot, missing) {
+    const guidance = missing.map((item) => {
+      const template = MISSING_PACKAGE_WORKSPACE_FILE_GUIDANCE[item];
+      return template ? template.replaceAll("<workspaceRoot>", workspaceRoot) : item;
+    }).join("\n\n");
+    super(
+      "missing_package_workspace_files",
+      `mode 'package' requires 'tsconfig.base.json' and 'tsup.config.base.{ts,js,mjs,cjs}' in '${workspaceRoot}' (one directory above 'packagesDir'); missing: ${missing.join(", ")}
+
+${guidance}`
+    );
+    this.workspaceRoot = workspaceRoot;
+    this.missing = missing;
+  }
+};
+var OutputNotGeneratedError = class extends TakoError {
+  path;
+  constructor(path5) {
+    super(
+      "output_not_generated",
+      `refusing to wipe '${path5}': it is non-empty and its package.json lacks the '"//": "Generated by tako\u2026"' marker`
+    );
+    this.path = path5;
+  }
+};
+var PackageInstallError = class extends TakoError {
+  pm;
+  constructor(pm, options) {
+    super(
+      "package_install_error",
+      `the '${pm} install' step for the generated packages exited non-zero`,
+      options
+    );
+    this.pm = pm;
+  }
+};
+var DriverError = class extends TakoError {
+  role;
+  driverName;
+  namespace;
+  constructor(role, driverName, options) {
+    const where = options?.namespace ? ` (namespace '${options.namespace}')` : "";
+    super(
+      "driver_error",
+      `${role} '${driverName}'${where} threw during ${role === "parser" ? "parse" : "generate"}`,
+      options
+    );
+    this.role = role;
+    this.driverName = driverName;
+    this.namespace = options?.namespace;
+  }
+};
+var HookError = class extends TakoError {
+  hook;
+  constructor(hook, options) {
+    super("hook_error", `the '${hook}' hook threw`, options);
+    this.hook = hook;
+  }
+};
+
+// src/logger.ts
+var noopLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+function mergeMeta(prefixMeta, meta) {
+  if (meta === void 0) {
+    return { ...prefixMeta };
+  }
+  if (meta !== null && typeof meta === "object" && !Array.isArray(meta)) {
+    return { ...prefixMeta, ...meta };
+  }
+  return { ...prefixMeta, value: meta };
+}
+function childLogger(base, prefixMeta) {
+  return {
+    debug: (msg, meta) => base.debug(msg, mergeMeta(prefixMeta, meta)),
+    info: (msg, meta) => base.info(msg, mergeMeta(prefixMeta, meta)),
+    warn: (msg, meta) => base.warn(msg, mergeMeta(prefixMeta, meta)),
+    error: (msg, meta) => base.error(msg, mergeMeta(prefixMeta, meta))
+  };
+}
+
+// src/collect.ts
+var import_node_path = __toESM(require("path"), 1);
+function normalizePath(rawPath, generator) {
+  const posix = rawPath.replace(/\\/g, "/");
+  if (posix.startsWith("/")) {
+    throw new InvalidOutputPathError(rawPath, generator);
+  }
+  const normalized = import_node_path.default.posix.normalize(posix);
+  if (normalized === ".." || normalized.startsWith("../") || import_node_path.default.posix.isAbsolute(normalized)) {
+    throw new InvalidOutputPathError(rawPath, generator);
+  }
+  return normalized;
+}
+function mergeTrees(perGenerator, opts) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const { generator, files } of perGenerator) {
+    for (const file of files) {
+      const normalized = normalizePath(file.path, generator);
+      const existing = byPath.get(normalized);
+      if (existing) {
+        throw new OutputCollisionError(
+          normalized,
+          [existing.generator, generator],
+          opts?.collisionHint
+        );
+      }
+      byPath.set(normalized, {
+        generator,
+        file: { path: normalized, content: file.content }
+      });
+    }
+  }
+  return [...byPath.values()].map((entry) => entry.file).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+
+// src/filter.ts
+function filterIR(ir, namespaces) {
+  const clone = structuredClone(ir);
+  if (namespaces === void 0) {
+    return clone;
+  }
+  const keep = new Set(namespaces);
+  const sources = {};
+  for (const [key, source] of Object.entries(clone.sources)) {
+    if (keep.has(key)) {
+      sources[key] = source;
+    }
+  }
+  clone.sources = sources;
+  return clone;
+}
+
+// src/graph.ts
+function generatorOrder(generators) {
+  const names = Object.keys(generators);
+  const index = new Map(names.map((name, i) => [name, i]));
+  const dependents = new Map(names.map((n) => [n, []]));
+  const indegree = new Map(names.map((n) => [n, 0]));
+  for (const name of names) {
+    const cfg = generators[name];
+    const hard = cfg?.generator.dependsOn ?? [];
+    const optional = cfg?.generator.optionalDependsOn ?? [];
+    const seen = /* @__PURE__ */ new Set();
+    const addEdge = (dep) => {
+      if (seen.has(dep)) {
+        return;
+      }
+      seen.add(dep);
+      dependents.get(dep)?.push(name);
+      indegree.set(name, (indegree.get(name) ?? 0) + 1);
+    };
+    for (const dep of hard) {
+      if (optional.includes(dep)) {
+        throw new InvalidDependencyError(name, dep);
+      }
+      if (!index.has(dep)) {
+        throw new UnknownDependencyError(name, dep);
+      }
+      addEdge(dep);
+    }
+    for (const dep of optional) {
+      if (!index.has(dep)) {
+        continue;
+      }
+      addEdge(dep);
+    }
+  }
+  const byConfigOrder = (a, b) => (index.get(a) ?? 0) - (index.get(b) ?? 0);
+  const ready = names.filter((n) => (indegree.get(n) ?? 0) === 0).sort(byConfigOrder);
+  const order = [];
+  while (ready.length > 0) {
+    const node = ready.shift();
+    order.push(node);
+    for (const dependent of dependents.get(node) ?? []) {
+      const next = (indegree.get(dependent) ?? 0) - 1;
+      indegree.set(dependent, next);
+      if (next === 0) {
+        ready.push(dependent);
+        ready.sort(byConfigOrder);
+      }
+    }
+  }
+  if (order.length < names.length) {
+    const remaining = new Set(names.filter((n) => !order.includes(n)));
+    throw new DependencyCycleError(findCycle(remaining, dependents));
+  }
+  return order;
+}
+function findCycle(nodes, dependents) {
+  const stack = [];
+  const onStack = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const walk = (node) => {
+    stack.push(node);
+    onStack.add(node);
+    for (const next of dependents.get(node) ?? []) {
+      if (!nodes.has(next)) {
+        continue;
+      }
+      if (onStack.has(next)) {
+        return [...stack.slice(stack.indexOf(next)), next];
+      }
+      if (!visited.has(next)) {
+        const found = walk(next);
+        if (found) {
+          return found;
+        }
+      }
+    }
+    stack.pop();
+    onStack.delete(node);
+    visited.add(node);
+    return void 0;
+  };
+  for (const node of nodes) {
+    if (!visited.has(node)) {
+      const found = walk(node);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return [...nodes];
+}
+
+// src/merge.ts
+var import_ir = require("@kurotako/ir");
+function mergeSources(entries) {
+  const sources = {};
+  for (const { namespace, sourceIR } of entries) {
+    if (sourceIR.namespace !== namespace) {
+      throw new NamespaceMismatchError(namespace, sourceIR.namespace);
+    }
+    const validation = (0, import_ir.validateSourceIR)(sourceIR);
+    if (!validation.ok) {
+      throw new IrValidationError(validation.issues, namespace);
+    }
+    if (namespace in sources) {
+      throw new DuplicateNamespaceError(namespace);
+    }
+    sources[namespace] = validation.value;
+  }
+  const ir = { irVersion: import_ir.IR_VERSION, sources };
+  try {
+    (0, import_ir.assertIR)(ir);
+  } catch (error) {
+    if (error instanceof import_ir.IrValidationError) {
+      throw new IrValidationError(error.issues);
+    }
+    throw error;
+  }
+  return ir;
+}
+
+// src/writer/banner.ts
+var BANNER = "// Generated by tako. Do not edit.\n";
+var GITATTRIBUTES = "* linguist-generated=true\n";
+var COMMENTABLE_BASENAMES = /* @__PURE__ */ new Set(["tsconfig.json"]);
+function takesBanner(path5) {
+  if (path5.endsWith(".ts") || path5.endsWith(".tsx")) {
+    return true;
+  }
+  const basename = path5.slice(path5.lastIndexOf("/") + 1);
+  return COMMENTABLE_BASENAMES.has(basename);
+}
+function applyBanner(files) {
+  return files.map((file) => {
+    if (!takesBanner(file.path) || file.content.startsWith(BANNER)) {
+      return file;
+    }
+    return { path: file.path, content: BANNER + file.content };
+  });
+}
+
+// src/writer/tree.ts
+function contributingGenerators(files) {
+  const acc = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const parts = file.path.split("/");
+    if (parts.length < 3) {
+      continue;
+    }
+    const [namespace, generator] = parts;
+    if (!namespace || !generator) {
+      continue;
+    }
+    let set = acc.get(namespace);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      acc.set(namespace, set);
+    }
+    set.add(generator);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [namespace, set] of acc) {
+    out.set(namespace, [...set].sort());
+  }
+  return out;
+}
+
+// src/writer/barrel.ts
+function synthesizeRootBarrels(files, artifactsByGenerator, logger) {
+  const contributors = contributingGenerators(files);
+  const barrels = [];
+  for (const namespace of [...contributors.keys()].sort()) {
+    const generators = contributors.get(namespace) ?? [];
+    if (artifactsByGenerator && logger) {
+      warnAmbiguousReExports(
+        namespace,
+        generators,
+        artifactsByGenerator,
+        logger
+      );
+    }
+    const content = generators.map((name) => `export * from './${name}';
+`).join("");
+    barrels.push({ path: `${namespace}/index.ts`, content });
+  }
+  return barrels;
+}
+function warnAmbiguousReExports(namespace, generators, artifactsByGenerator, logger) {
+  const owners = /* @__PURE__ */ new Map();
+  for (const name of generators) {
+    const artifact = artifactsByGenerator[name];
+    if (!artifact) {
+      continue;
+    }
+    const identifiers = /* @__PURE__ */ new Set();
+    for (const [key, entity] of Object.entries(artifact.entities)) {
+      const dot = key.indexOf(".");
+      const entityNamespace = dot === -1 ? key : key.slice(0, dot);
+      if (entityNamespace !== namespace) {
+        continue;
+      }
+      for (const identifier of Object.values(entity.symbols)) {
+        identifiers.add(identifier);
+      }
+    }
+    for (const identifier of identifiers) {
+      const list = owners.get(identifier) ?? [];
+      list.push(name);
+      owners.set(identifier, list);
+    }
+  }
+  for (const [identifier, list] of owners) {
+    if (list.length > 1) {
+      const sorted = [...list].sort();
+      logger.warn(
+        `namespace '${namespace}': identifier '${identifier}' is re-exported by generators [${sorted.join(
+          ", "
+        )}]; the ambiguous star re-export from '${namespace}/index.ts' will be dropped. Import it from a generator subpath instead.`,
+        { namespace, identifier, generators: sorted }
+      );
+    }
+  }
+}
+
+// src/writer/directory.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var GITATTRIBUTES2 = "* linguist-generated=true\n";
+function sortByPath(entries) {
+  return [...entries].sort(
+    (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+  );
+}
+var directoryWriter = {
+  async plan({ files, output }) {
+    if (!output.dir) {
+      throw new TakoError(
+        "invalid_output_config",
+        "mode 'dir' requires 'output.dir'"
+      );
+    }
+    const dir = import_node_path2.default.resolve(output.dir);
+    const planned = files.map((file) => ({
+      path: import_node_path2.default.join(dir, file.path),
+      content: file.content
+    }));
+    planned.push({
+      path: import_node_path2.default.join(dir, ".gitattributes"),
+      content: GITATTRIBUTES2
+    });
+    return sortByPath(planned);
+  },
+  async write(input) {
+    const planned = await this.plan(input);
+    const dir = import_node_path2.default.resolve(input.output.dir);
+    await import_promises.default.rm(dir, { recursive: true, force: true });
+    await import_promises.default.mkdir(dir, { recursive: true });
+    for (const file of planned) {
+      await import_promises.default.mkdir(import_node_path2.default.dirname(file.path), { recursive: true });
+      await import_promises.default.writeFile(file.path, file.content, "utf8");
+    }
+    return planned.map((file) => file.path);
+  }
+};
+
+// src/writer/package.ts
+var import_node_fs2 = require("fs");
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_module = require("module");
+var import_node_path4 = __toESM(require("path"), 1);
+
+// src/writer/peers.ts
+function collectPeerDependencies(artifactsByGenerator, files) {
+  const contributors = contributingGenerators(files);
+  const result = {};
+  for (const namespace of [...contributors.keys()].sort()) {
+    const generators = contributors.get(namespace) ?? [];
+    const merged = /* @__PURE__ */ new Map();
+    for (const generator of generators) {
+      const peers = artifactsByGenerator[generator]?.peerDependencies;
+      if (!peers) {
+        continue;
+      }
+      for (const [pkg, range] of Object.entries(peers)) {
+        const existing = merged.get(pkg);
+        if (existing && existing.range !== range) {
+          throw new OutputPeerConflictError(
+            namespace,
+            pkg,
+            [existing.range, range],
+            [existing.generator, generator]
+          );
+        }
+        if (!existing) {
+          merged.set(pkg, { range, generator });
+        }
+      }
+    }
+    const sorted = {};
+    for (const pkg of [...merged.keys()].sort()) {
+      const entry = merged.get(pkg);
+      if (entry) {
+        sorted[pkg] = entry.range;
+      }
+    }
+    result[namespace] = sorted;
+  }
+  return result;
+}
+
+// src/writer/pm.ts
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_util = require("util");
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var PACKAGE_MANAGERS = [
+  "bun",
+  "pnpm",
+  "yarn",
+  "npm"
+];
+var LOCKFILES = [
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"],
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["package-lock.json", "npm"]
+];
+function isPackageManager(value) {
+  return PACKAGE_MANAGERS.includes(value);
+}
+function* ancestors(startDir) {
+  let dir = import_node_path3.default.resolve(startDir);
+  while (true) {
+    yield dir;
+    const parent = import_node_path3.default.dirname(dir);
+    if (parent === dir) {
+      return;
+    }
+    dir = parent;
+  }
+}
+function resolvePackageManager(opts) {
+  if (opts.configured) {
+    return opts.configured;
+  }
+  for (const dir of ancestors(opts.startDir)) {
+    for (const [file, pm] of LOCKFILES) {
+      if ((0, import_node_fs.existsSync)(import_node_path3.default.join(dir, file))) {
+        return pm;
+      }
+    }
+    if ((0, import_node_fs.existsSync)(import_node_path3.default.join(dir, ".git"))) {
+      break;
+    }
+  }
+  for (const dir of ancestors(opts.startDir)) {
+    const pkgPath = import_node_path3.default.join(dir, "package.json");
+    if ((0, import_node_fs.existsSync)(pkgPath)) {
+      try {
+        const pkg = JSON.parse((0, import_node_fs.readFileSync)(pkgPath, "utf8"));
+        if (typeof pkg.packageManager === "string") {
+          const name = pkg.packageManager.split("@")[0] ?? "";
+          if (isPackageManager(name)) {
+            return name;
+          }
+        }
+      } catch {
+      }
+    }
+    if ((0, import_node_fs.existsSync)(import_node_path3.default.join(dir, ".git"))) {
+      break;
+    }
+  }
+  return null;
+}
+async function runInstall(pm, cwd) {
+  try {
+    await execFileAsync(pm, ["install"], { cwd });
+  } catch (cause) {
+    throw new PackageInstallError(pm, { cause });
+  }
+}
+
+// src/writer/package.ts
+var MARKER = "Generated by tako. Do not edit.";
+function computePackageLayout({
+  files,
+  output,
+  artifacts
+}) {
+  if (!output.packagesDir) {
+    throw new TakoError(
+      "invalid_output_config",
+      "mode 'package' requires 'output.packagesDir'"
+    );
+  }
+  if (!output.scope) {
+    throw new TakoError(
+      "invalid_output_config",
+      "mode 'package' requires 'output.scope'"
+    );
+  }
+  const packagesDir = import_node_path4.default.resolve(output.packagesDir);
+  const scope = output.scope;
+  const scopeSlug = scope.replace(/^@/, "");
+  const peersByNamespace = collectPeerDependencies(artifacts ?? {}, files);
+  const byNamespace = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const slash = file.path.indexOf("/");
+    if (slash === -1) {
+      continue;
+    }
+    const namespace = file.path.slice(0, slash);
+    const rest = file.path.slice(slash + 1);
+    const list = byNamespace.get(namespace) ?? [];
+    list.push({ path: rest, content: file.content });
+    byNamespace.set(namespace, list);
+  }
+  const namespaces = [...byNamespace.keys()].sort();
+  const entriesByNamespace = /* @__PURE__ */ new Map();
+  const planned = [];
+  for (const namespace of namespaces) {
+    const sources = [...byNamespace.get(namespace) ?? []].sort(
+      (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+    );
+    const pkgDir = import_node_path4.default.join(packagesDir, `${scopeSlug}-${namespace}`);
+    const entries = [];
+    for (const src of sources) {
+      planned.push({
+        path: import_node_path4.default.join(pkgDir, "src", src.path),
+        content: src.content
+      });
+      entries.push(`src/${src.path}`);
+    }
+    planned.push({
+      path: import_node_path4.default.join(pkgDir, "package.json"),
+      content: buildPackageJson(
+        scope,
+        namespace,
+        peersByNamespace[namespace] ?? {}
+      )
+    });
+    planned.push({
+      path: import_node_path4.default.join(pkgDir, "tsconfig.json"),
+      content: buildTsconfig(namespace)
+    });
+    const sortedEntries = entries.sort();
+    entriesByNamespace.set(namespace, sortedEntries);
+    planned.push({
+      path: import_node_path4.default.join(pkgDir, "tsup.config.ts"),
+      content: buildTsupConfig(sortedEntries)
+    });
+    planned.push({
+      path: import_node_path4.default.join(pkgDir, ".gitattributes"),
+      content: GITATTRIBUTES
+    });
+  }
+  planned.push({
+    path: import_node_path4.default.join(packagesDir, ".gitattributes"),
+    content: `${scopeSlug}-*/** linguist-generated=true
+`
+  });
+  planned.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+  return { packagesDir, scopeSlug, namespaces, entriesByNamespace, planned };
+}
+var packageWriter = {
+  async plan(input) {
+    return computePackageLayout(input).planned;
+  },
+  async write({ files, output, artifacts, logger = noopLogger }) {
+    const { packagesDir, scopeSlug, namespaces, entriesByNamespace, planned } = computePackageLayout({ files, output, artifacts, logger });
+    assertWorkspaceBaseFiles(packagesDir);
+    await import_promises2.default.mkdir(packagesDir, { recursive: true });
+    for (const namespace of namespaces) {
+      await guardAndReset(import_node_path4.default.join(packagesDir, `${scopeSlug}-${namespace}`));
+    }
+    const written = [];
+    for (const file of planned) {
+      await import_promises2.default.mkdir(import_node_path4.default.dirname(file.path), { recursive: true });
+      await import_promises2.default.writeFile(file.path, file.content, "utf8");
+      written.push(file.path);
+    }
+    await buildPackages(packagesDir, scopeSlug, namespaces, entriesByNamespace);
+    const pm = resolvePackageManager({
+      configured: output.packageManager,
+      startDir: packagesDir
+    });
+    if (pm) {
+      await runInstall(pm, findWorkspaceRoot(packagesDir) ?? packagesDir);
+    } else {
+      logger.warn(
+        "could not resolve a package manager; run '<your package manager> install' in the workspace root to link the generated packages",
+        { packagesDir }
+      );
+    }
+    return written.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  }
+};
+var TSUP_CONFIG_BASE_EXTENSIONS = [".ts", ".js", ".mjs", ".cjs"];
+function assertWorkspaceBaseFiles(packagesDir) {
+  const workspaceRoot = import_node_path4.default.dirname(packagesDir);
+  const missing = [];
+  if (!(0, import_node_fs2.existsSync)(import_node_path4.default.join(workspaceRoot, "tsconfig.base.json"))) {
+    missing.push("tsconfig.base.json");
+  }
+  const hasTsupBase = TSUP_CONFIG_BASE_EXTENSIONS.some(
+    (ext) => (0, import_node_fs2.existsSync)(import_node_path4.default.join(workspaceRoot, `tsup.config.base${ext}`))
+  );
+  if (!hasTsupBase) {
+    missing.push("tsup.config.base.{ts,js,mjs,cjs}");
+  }
+  if (!isResolvableFrom("typescript", workspaceRoot)) {
+    missing.push("'typescript' (devDependency, needed for the .d.ts build)");
+  }
+  if (missing.length > 0) {
+    throw new MissingPackageWorkspaceFilesError(workspaceRoot, missing);
+  }
+}
+function isResolvableFrom(specifier, from) {
+  try {
+    (0, import_node_module.createRequire)(import_node_path4.default.join(from, "noop.js")).resolve(specifier);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function guardAndReset(pkgDir) {
+  let entries;
+  try {
+    entries = await import_promises2.default.readdir(pkgDir);
+  } catch {
+    entries = [];
+  }
+  if (entries.length > 0 && !hasGeneratedMarker(pkgDir)) {
+    throw new OutputNotGeneratedError(pkgDir);
+  }
+  await import_promises2.default.rm(pkgDir, { recursive: true, force: true });
+  await import_promises2.default.mkdir(pkgDir, { recursive: true });
+}
+function hasGeneratedMarker(pkgDir) {
+  try {
+    const pkg = JSON.parse(
+      (0, import_node_fs2.readFileSync)(import_node_path4.default.join(pkgDir, "package.json"), "utf8")
+    );
+    return typeof pkg["//"] === "string" && pkg["//"].startsWith("Generated by tako");
+  } catch {
+    return false;
+  }
+}
+async function buildPackages(packagesDir, scopeSlug, namespaces, entriesByNamespace) {
+  const { build } = await import("tsup");
+  const originalCwd = process.cwd();
+  try {
+    for (const namespace of namespaces) {
+      const pkgDir = import_node_path4.default.join(packagesDir, `${scopeSlug}-${namespace}`);
+      process.chdir(pkgDir);
+      try {
+        await build({
+          // Config auto-discovery (cosmiconfig) is disabled: the pkgDir's own
+          // tsup.config.ts exists for humans building the package standalone
+          // later, but resolving it here — a TS file re-exporting
+          // `../../tsup.config.base` — through tsup's config loader instead of
+          // this programmatic call caused spurious "Could not resolve" entry
+          // errors.
+          config: false,
+          // A relative `entry` array goes through tinyglobby, whose matches
+          // esbuild then resolves against the cwd esbuild's service captured
+          // at first use — *not* the cwd at this call, so it silently breaks
+          // after the first `process.chdir()` in this loop. An absolute-path
+          // entry *map* skips glob resolution entirely (tsup only runs
+          // `fs.existsSync` on it) and keeps `dist/` mirroring `src/`.
+          entry: Object.fromEntries(
+            (entriesByNamespace.get(namespace) ?? []).map((entry) => [
+              entry.replace(/^src\//, "").replace(/\.ts$/, ""),
+              import_node_path4.default.join(pkgDir, entry)
+            ])
+          ),
+          tsconfig: import_node_path4.default.join(pkgDir, "tsconfig.json"),
+          format: ["esm", "cjs"],
+          dts: { compilerOptions: { composite: false, incremental: false } },
+          outDir: import_node_path4.default.join(pkgDir, "dist"),
+          silent: true
+        });
+      } catch (cause) {
+        throw new PackageBuildError(namespace, { cause });
+      }
+    }
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+function findWorkspaceRoot(startDir) {
+  for (const dir of ancestors(startDir)) {
+    if ((0, import_node_fs2.existsSync)(import_node_path4.default.join(dir, "pnpm-workspace.yaml"))) {
+      return dir;
+    }
+    const pkgPath = import_node_path4.default.join(dir, "package.json");
+    if ((0, import_node_fs2.existsSync)(pkgPath)) {
+      try {
+        const pkg = JSON.parse((0, import_node_fs2.readFileSync)(pkgPath, "utf8"));
+        if (pkg.workspaces !== void 0) {
+          return dir;
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function buildPackageJson(scope, namespace, peerDependencies) {
+  const pkg = {
+    name: `${scope}/${namespace}`,
+    version: "0.0.0",
+    type: "module",
+    main: "./dist/index.cjs",
+    module: "./dist/index.js",
+    types: "./dist/index.d.ts",
+    exports: {
+      ".": {
+        types: "./dist/index.d.ts",
+        import: "./dist/index.js",
+        require: "./dist/index.cjs"
+      },
+      "./*": {
+        types: "./dist/*.d.ts",
+        import: "./dist/*.js",
+        require: "./dist/*.cjs"
+      }
+    },
+    files: ["dist", "src"],
+    peerDependencies,
+    sideEffects: false,
+    scripts: { build: "tsup" },
+    "//": MARKER
+  };
+  return `${JSON.stringify(pkg, null, 2)}
+`;
+}
+function buildTsconfig(namespace) {
+  const body = JSON.stringify(
+    {
+      extends: "../../tsconfig.base.json",
+      compilerOptions: {
+        outDir: "dist",
+        paths: { [`${namespace}/*`]: ["./src/*"] }
+      },
+      include: ["src"]
+    },
+    null,
+    2
+  );
+  return `${BANNER}${body}
+`;
+}
+function buildTsupConfig(entries) {
+  const list = entries.map((entry) => `    '${entry}',`).join("\n");
+  return `${BANNER}import { basePreset } from '../../tsup.config.base';
+
+export default {
+  ...basePreset,
+  entry: [
+${list}
+  ],
+};
+`;
+}
+
+// src/writer/index.ts
+function selectWriter(output) {
+  const mode = output.mode ?? "dir";
+  if (mode === "dir") {
+    return directoryWriter;
+  }
+  if (mode === "package") {
+    return packageWriter;
+  }
+  throw new UnsupportedOutputModeError(mode);
+}
+
+// src/run.ts
+async function run(config, opts) {
+  const logger = opts?.logger ?? noopLogger;
+  const checkSignal = () => opts?.signal?.throwIfAborted();
+  checkSignal();
+  const entries = [];
+  for (const namespace of Object.keys(config.sources).sort()) {
+    checkSignal();
+    const source = config.sources[namespace];
+    if (!source) {
+      continue;
+    }
+    const { parser } = source;
+    const anchorDir = await parser.anchor?.(config.rootDir) ?? config.rootDir;
+    const ctx = {
+      namespace,
+      cwd: config.rootDir,
+      anchorDir,
+      logger: childLogger(logger, { namespace })
+    };
+    try {
+      const sourceIR = await parser.parse(ctx);
+      entries.push({ namespace, sourceIR });
+    } catch (error) {
+      if (error instanceof DriverError) {
+        throw error;
+      }
+      throw new DriverError("parser", parser.name, { cause: error, namespace });
+    }
+  }
+  checkSignal();
+  const ir = mergeSources(entries);
+  checkSignal();
+  const order = generatorOrder(config.generators);
+  const artifacts = {};
+  const perGenerator = [];
+  for (const name of order) {
+    checkSignal();
+    const cfg = config.generators[name];
+    if (!cfg) {
+      continue;
+    }
+    const { generator } = cfg;
+    const view = filterIR(ir, cfg.namespaces);
+    const declared = [
+      ...generator.dependsOn ?? [],
+      ...generator.optionalDependsOn ?? []
+    ];
+    const dependencies = {};
+    for (const dep of declared) {
+      const artifact = artifacts[dep];
+      if (artifact) {
+        dependencies[dep] = artifact;
+      }
+    }
+    try {
+      const out = await generator.generate({
+        ir: view,
+        dependencies,
+        logger: childLogger(logger, { generator: name })
+      });
+      artifacts[name] = out.artifact;
+      perGenerator.push({ generator: name, files: out.files });
+    } catch (error) {
+      if (error instanceof DriverError) {
+        throw error;
+      }
+      throw new DriverError("generator", generator.name, { cause: error });
+    }
+  }
+  checkSignal();
+  const collected = mergeTrees(perGenerator);
+  checkSignal();
+  const barrels = synthesizeRootBarrels(collected, artifacts, logger);
+  const merged = mergeTrees(
+    [
+      ...perGenerator,
+      { generator: "<synthesized root barrel>", files: barrels }
+    ],
+    {
+      collisionHint: "each generator must emit under its own '<namespace>/<generatorName>/' sub-tree; '<namespace>/index.ts' is synthesized by tako"
+    }
+  );
+  const files = applyBanner(merged);
+  const outputTree = (output) => {
+    const names = new Set(output.generators ?? order);
+    const filteredFiles = collected.filter(
+      (file) => names.has(file.path.split("/")[1] ?? "")
+    );
+    const outputBarrels = synthesizeRootBarrels(
+      filteredFiles,
+      artifacts,
+      logger
+    );
+    return applyBanner(
+      mergeTrees([
+        { generator: "<filtered>", files: filteredFiles },
+        { generator: "<synthesized root barrel>", files: outputBarrels }
+      ])
+    );
+  };
+  if (opts?.plan === true) {
+    const planned = [];
+    for (const output of config.outputs) {
+      checkSignal();
+      const writer = selectWriter(output);
+      planned.push(
+        ...await writer.plan({
+          files: outputTree(output),
+          output,
+          artifacts,
+          logger
+        })
+      );
+    }
+    planned.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+    return { ir, order, files, artifacts, written: [], plan: planned };
+  }
+  const written = [];
+  if (opts?.write !== false) {
+    for (const output of config.outputs) {
+      checkSignal();
+      const writer = selectWriter(output);
+      const writtenPaths = await writer.write({
+        files: outputTree(output),
+        output,
+        artifacts,
+        logger
+      });
+      written.push({ output, files: writtenPaths });
+      checkSignal();
+      const outputDir = (output.mode === "package" ? output.packagesDir : output.dir) ?? config.rootDir;
+      try {
+        await config.hooks?.afterEmit?.({
+          outputDir,
+          files: writtenPaths,
+          logger
+        });
+      } catch (error) {
+        throw new HookError("afterEmit", { cause: error });
+      }
+    }
+  }
+  return { ir, order, files, artifacts, written };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BANNER,
+  DependencyCycleError,
+  DriverError,
+  DuplicateNamespaceError,
+  GITATTRIBUTES,
+  HookError,
+  InvalidDependencyError,
+  InvalidOutputPathError,
+  IrValidationError,
+  MissingPackageWorkspaceFilesError,
+  NamespaceMismatchError,
+  OutputCollisionError,
+  OutputNotGeneratedError,
+  OutputPeerConflictError,
+  PackageBuildError,
+  PackageInstallError,
+  TakoError,
+  UnknownDependencyError,
+  UnsupportedOutputModeError,
+  applyBanner,
+  childLogger,
+  collectPeerDependencies,
+  directoryWriter,
+  noopLogger,
+  packageWriter,
+  resolvePackageManager,
+  run,
+  runInstall,
+  selectWriter,
+  synthesizeRootBarrels
+});
+//# sourceMappingURL=index.cjs.map