@kurotako/core 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @kurotako/core
 
+## 0.1.1
+
+### Patch Changes
+
+- 489a50d: Generated namespace root barrels now resolve overlapping public generator exports deterministically, so package declaration builds remain valid. The lexically first generator owns a colliding root export; every generator-specific subpath remains available.
+- c575bc1: Integration of the IR union type. After merge, the non-fatal validation `info`
+  channel (`union_cycle`, `degenerate_union`) is logged once at `warn`.
+  `GenerateContext` gains `cycles: Set<string>` — the `${namespace}.${name}` of
+  every entity / type alias that takes part in a `ref` cycle in the merged IR
+  (from `@kurotako/ir`'s `refCycleMembers`) — so a generator can lazily wrap or
+  widen a reference instead of relying on a local heuristic.
+- Updated dependencies [7a50439]
+  - @kurotako/ir@0.2.0
+
 ## 0.1.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -142,24 +142,24 @@ var DependencyCycleError = class extends TakoError {
 var OutputCollisionError = class extends TakoError {
   path;
   generators;
-  constructor(path5, generators, hint) {
+  constructor(path6, generators, hint) {
     super(
       "output_collision",
-      `generators '${generators[0]}' and '${generators[1]}' both emit '${path5}'${hint ? `. ${hint}` : ""}`
+      `generators '${generators[0]}' and '${generators[1]}' both emit '${path6}'${hint ? `. ${hint}` : ""}`
     );
-    this.path = path5;
+    this.path = path6;
     this.generators = generators;
   }
 };
 var InvalidOutputPathError = class extends TakoError {
   path;
   generator;
-  constructor(path5, generator) {
+  constructor(path6, generator) {
     super(
       "invalid_output_path",
-      `generator '${generator}' emits '${path5}', which escapes the output root`
+      `generator '${generator}' emits '${path6}', which escapes the output root`
     );
-    this.path = path5;
+    this.path = path6;
     this.generator = generator;
   }
 };
@@ -251,12 +251,12 @@ ${guidance}`
 };
 var OutputNotGeneratedError = class extends TakoError {
   path;
-  constructor(path5) {
+  constructor(path6) {
     super(
       "output_not_generated",
-      `refusing to wipe '${path5}': it is non-empty and its package.json lacks the '"//": "Generated by tako\u2026"' marker`
+      `refusing to wipe '${path6}': it is non-empty and its package.json lacks the '"//": "Generated by tako\u2026"' marker`
     );
-    this.path = path5;
+    this.path = path6;
   }
 };
 var PackageInstallError = class extends TakoError {
@@ -323,6 +323,9 @@ function childLogger(base, prefixMeta) {
   };
 }
 
+// src/run.ts
+var import_ir2 = require("@kurotako/ir");
+
 // src/collect.ts
 var import_node_path = __toESM(require("path"), 1);
 function normalizePath(rawPath, generator) {
@@ -470,7 +473,7 @@ function findCycle(nodes, dependents) {
 
 // src/merge.ts
 var import_ir = require("@kurotako/ir");
-function mergeSources(entries) {
+function mergeSources(entries, logger) {
   const sources = {};
   for (const { namespace, sourceIR } of entries) {
     if (sourceIR.namespace !== namespace) {
@@ -486,26 +489,27 @@ function mergeSources(entries) {
     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;
+  const result = (0, import_ir.validateIR)(ir);
+  if (!result.ok) {
+    throw new IrValidationError(result.issues);
+  }
+  for (const note of result.info ?? []) {
+    logger?.warn(
+      `IR ${note.code} at ${note.path === "" ? "<root>" : note.path}: ${note.message}`
+    );
   }
-  return ir;
+  return result.value;
 }
 
 // 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")) {
+function takesBanner(path6) {
+  if (path6.endsWith(".ts") || path6.endsWith(".tsx")) {
     return true;
   }
-  const basename = path5.slice(path5.lastIndexOf("/") + 1);
+  const basename = path6.slice(path6.lastIndexOf("/") + 1);
   return COMMENTABLE_BASENAMES.has(basename);
 }
 function applyBanner(files) {
@@ -517,6 +521,10 @@ function applyBanner(files) {
   });
 }
 
+// src/writer/barrel.ts
+var import_node_path2 = __toESM(require("path"), 1);
+var ts = __toESM(require("typescript"), 1);
+
 // src/writer/tree.ts
 function contributingGenerators(files) {
   const acc = /* @__PURE__ */ new Map();
@@ -544,65 +552,81 @@ function contributingGenerators(files) {
 }
 
 // src/writer/barrel.ts
-function synthesizeRootBarrels(files, artifactsByGenerator, logger) {
+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 collisions = exportedNameCollisions(namespace, generators, files);
+    const content = [
+      ...generators.map((name) => `export * from './${name}';`),
+      ...[...collisions.entries()].map(
+        ([identifier, owners]) => `export { ${identifier} } from './${owners[0]}';`
+      ),
+      ""
+    ].join("\n");
+    for (const [identifier, owners] of collisions) {
+      logger?.warn(
+        `namespace '${namespace}': identifier '${identifier}' is re-exported by generators [${owners.join(
+          ", "
+        )}]; '${namespace}/index.ts' explicitly re-exports it from '${owners[0]}'. Import a generator subpath to select another declaration.`,
+        { namespace, identifier, generators: owners }
       );
     }
-    const content = generators.map((name) => `export * from './${name}';
-`).join("");
     barrels.push({ path: `${namespace}/index.ts`, content });
   }
   return barrels;
 }
-function warnAmbiguousReExports(namespace, generators, artifactsByGenerator, logger) {
+function exportedNameCollisions(namespace, generators, files) {
+  const sourceFiles = new Map(
+    files.filter((file) => file.path.startsWith(`${namespace}/`)).map((file) => [toVirtualPath(file.path), file.content])
+  );
+  const rootNames = generators.map((generator) => toVirtualPath(`${namespace}/${generator}/index.ts`)).filter((fileName) => sourceFiles.has(fileName));
+  if (rootNames.length < 2) {
+    return /* @__PURE__ */ new Map();
+  }
+  const options = {
+    module: ts.ModuleKind.NodeNext,
+    moduleResolution: ts.ModuleResolutionKind.NodeNext,
+    noLib: true
+  };
+  const host = ts.createCompilerHost(options, true);
+  host.fileExists = (fileName) => sourceFiles.has(fileName);
+  host.readFile = (fileName) => sourceFiles.get(fileName);
+  host.getSourceFile = (fileName, languageVersion) => {
+    const text = sourceFiles.get(fileName);
+    return text === void 0 ? void 0 : ts.createSourceFile(fileName, text, languageVersion, true);
+  };
+  host.directoryExists = (directoryName) => [...sourceFiles.keys()].some(
+    (fileName) => fileName.startsWith(`${directoryName}/`)
+  );
+  const program = ts.createProgram({ rootNames, options, host });
+  const checker = program.getTypeChecker();
   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 }
-      );
+  for (const generator of generators) {
+    const source = program.getSourceFile(
+      toVirtualPath(`${namespace}/${generator}/index.ts`)
+    );
+    if (!source) continue;
+    const module2 = checker.getSymbolAtLocation(source);
+    if (!module2) continue;
+    for (const exported of checker.getExportsOfModule(module2)) {
+      const list = owners.get(exported.name) ?? [];
+      list.push(generator);
+      owners.set(exported.name, list);
     }
   }
+  return new Map(
+    [...owners].filter(([, owners2]) => owners2.length > 1).sort(([a], [b]) => a.localeCompare(b))
+  );
+}
+function toVirtualPath(fileName) {
+  return import_node_path2.default.posix.join("/", fileName);
 }
 
 // src/writer/directory.ts
 var import_promises = __toESM(require("fs/promises"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 var GITATTRIBUTES2 = "* linguist-generated=true\n";
 function sortByPath(entries) {
   return [...entries].sort(
@@ -617,24 +641,24 @@ var directoryWriter = {
         "mode 'dir' requires 'output.dir'"
       );
     }
-    const dir = import_node_path2.default.resolve(output.dir);
+    const dir = import_node_path3.default.resolve(output.dir);
     const planned = files.map((file) => ({
-      path: import_node_path2.default.join(dir, file.path),
+      path: import_node_path3.default.join(dir, file.path),
       content: file.content
     }));
     planned.push({
-      path: import_node_path2.default.join(dir, ".gitattributes"),
+      path: import_node_path3.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);
+    const dir = import_node_path3.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.mkdir(import_node_path3.default.dirname(file.path), { recursive: true });
       await import_promises.default.writeFile(file.path, file.content, "utf8");
     }
     return planned.map((file) => file.path);
@@ -645,7 +669,7 @@ var directoryWriter = {
 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);
+var import_node_path5 = __toESM(require("path"), 1);
 
 // src/writer/peers.ts
 function collectPeerDependencies(artifactsByGenerator, files) {
@@ -689,7 +713,7 @@ function collectPeerDependencies(artifactsByGenerator, files) {
 // 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_path4 = __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 = [
@@ -709,10 +733,10 @@ function isPackageManager(value) {
   return PACKAGE_MANAGERS.includes(value);
 }
 function* ancestors(startDir) {
-  let dir = import_node_path3.default.resolve(startDir);
+  let dir = import_node_path4.default.resolve(startDir);
   while (true) {
     yield dir;
-    const parent = import_node_path3.default.dirname(dir);
+    const parent = import_node_path4.default.dirname(dir);
     if (parent === dir) {
       return;
     }
@@ -725,16 +749,16 @@ function resolvePackageManager(opts) {
   }
   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))) {
+      if ((0, import_node_fs.existsSync)(import_node_path4.default.join(dir, file))) {
         return pm;
       }
     }
-    if ((0, import_node_fs.existsSync)(import_node_path3.default.join(dir, ".git"))) {
+    if ((0, import_node_fs.existsSync)(import_node_path4.default.join(dir, ".git"))) {
       break;
     }
   }
   for (const dir of ancestors(opts.startDir)) {
-    const pkgPath = import_node_path3.default.join(dir, "package.json");
+    const pkgPath = import_node_path4.default.join(dir, "package.json");
     if ((0, import_node_fs.existsSync)(pkgPath)) {
       try {
         const pkg = JSON.parse((0, import_node_fs.readFileSync)(pkgPath, "utf8"));
@@ -747,7 +771,7 @@ function resolvePackageManager(opts) {
       } catch {
       }
     }
-    if ((0, import_node_fs.existsSync)(import_node_path3.default.join(dir, ".git"))) {
+    if ((0, import_node_fs.existsSync)(import_node_path4.default.join(dir, ".git"))) {
       break;
     }
   }
@@ -780,7 +804,7 @@ function computePackageLayout({
       "mode 'package' requires 'output.scope'"
     );
   }
-  const packagesDir = import_node_path4.default.resolve(output.packagesDir);
+  const packagesDir = import_node_path5.default.resolve(output.packagesDir);
   const scope = output.scope;
   const scopeSlug = scope.replace(/^@/, "");
   const peersByNamespace = collectPeerDependencies(artifacts ?? {}, files);
@@ -803,17 +827,17 @@ function computePackageLayout({
     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 pkgDir = import_node_path5.default.join(packagesDir, `${scopeSlug}-${namespace}`);
     const entries = [];
     for (const src of sources) {
       planned.push({
-        path: import_node_path4.default.join(pkgDir, "src", src.path),
+        path: import_node_path5.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"),
+      path: import_node_path5.default.join(pkgDir, "package.json"),
       content: buildPackageJson(
         scope,
         namespace,
@@ -821,22 +845,22 @@ function computePackageLayout({
       )
     });
     planned.push({
-      path: import_node_path4.default.join(pkgDir, "tsconfig.json"),
+      path: import_node_path5.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"),
+      path: import_node_path5.default.join(pkgDir, "tsup.config.ts"),
       content: buildTsupConfig(sortedEntries)
     });
     planned.push({
-      path: import_node_path4.default.join(pkgDir, ".gitattributes"),
+      path: import_node_path5.default.join(pkgDir, ".gitattributes"),
       content: GITATTRIBUTES
     });
   }
   planned.push({
-    path: import_node_path4.default.join(packagesDir, ".gitattributes"),
+    path: import_node_path5.default.join(packagesDir, ".gitattributes"),
     content: `${scopeSlug}-*/** linguist-generated=true
 `
   });
@@ -852,11 +876,11 @@ var packageWriter = {
     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}`));
+      await guardAndReset(import_node_path5.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.mkdir(import_node_path5.default.dirname(file.path), { recursive: true });
       await import_promises2.default.writeFile(file.path, file.content, "utf8");
       written.push(file.path);
     }
@@ -878,13 +902,13 @@ var packageWriter = {
 };
 var TSUP_CONFIG_BASE_EXTENSIONS = [".ts", ".js", ".mjs", ".cjs"];
 function assertWorkspaceBaseFiles(packagesDir) {
-  const workspaceRoot = import_node_path4.default.dirname(packagesDir);
+  const workspaceRoot = import_node_path5.default.dirname(packagesDir);
   const missing = [];
-  if (!(0, import_node_fs2.existsSync)(import_node_path4.default.join(workspaceRoot, "tsconfig.base.json"))) {
+  if (!(0, import_node_fs2.existsSync)(import_node_path5.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}`))
+    (ext) => (0, import_node_fs2.existsSync)(import_node_path5.default.join(workspaceRoot, `tsup.config.base${ext}`))
   );
   if (!hasTsupBase) {
     missing.push("tsup.config.base.{ts,js,mjs,cjs}");
@@ -898,7 +922,7 @@ function assertWorkspaceBaseFiles(packagesDir) {
 }
 function isResolvableFrom(specifier, from) {
   try {
-    (0, import_node_module.createRequire)(import_node_path4.default.join(from, "noop.js")).resolve(specifier);
+    (0, import_node_module.createRequire)(import_node_path5.default.join(from, "noop.js")).resolve(specifier);
     return true;
   } catch {
     return false;
@@ -920,7 +944,7 @@ async function guardAndReset(pkgDir) {
 function hasGeneratedMarker(pkgDir) {
   try {
     const pkg = JSON.parse(
-      (0, import_node_fs2.readFileSync)(import_node_path4.default.join(pkgDir, "package.json"), "utf8")
+      (0, import_node_fs2.readFileSync)(import_node_path5.default.join(pkgDir, "package.json"), "utf8")
     );
     return typeof pkg["//"] === "string" && pkg["//"].startsWith("Generated by tako");
   } catch {
@@ -932,7 +956,7 @@ async function buildPackages(packagesDir, scopeSlug, namespaces, entriesByNamesp
   const originalCwd = process.cwd();
   try {
     for (const namespace of namespaces) {
-      const pkgDir = import_node_path4.default.join(packagesDir, `${scopeSlug}-${namespace}`);
+      const pkgDir = import_node_path5.default.join(packagesDir, `${scopeSlug}-${namespace}`);
       process.chdir(pkgDir);
       try {
         await build({
@@ -952,13 +976,13 @@ async function buildPackages(packagesDir, scopeSlug, namespaces, entriesByNamesp
           entry: Object.fromEntries(
             (entriesByNamespace.get(namespace) ?? []).map((entry) => [
               entry.replace(/^src\//, "").replace(/\.ts$/, ""),
-              import_node_path4.default.join(pkgDir, entry)
+              import_node_path5.default.join(pkgDir, entry)
             ])
           ),
-          tsconfig: import_node_path4.default.join(pkgDir, "tsconfig.json"),
+          tsconfig: import_node_path5.default.join(pkgDir, "tsconfig.json"),
           format: ["esm", "cjs"],
           dts: { compilerOptions: { composite: false, incremental: false } },
-          outDir: import_node_path4.default.join(pkgDir, "dist"),
+          outDir: import_node_path5.default.join(pkgDir, "dist"),
           silent: true
         });
       } catch (cause) {
@@ -971,10 +995,10 @@ async function buildPackages(packagesDir, scopeSlug, namespaces, entriesByNamesp
 }
 function findWorkspaceRoot(startDir) {
   for (const dir of ancestors(startDir)) {
-    if ((0, import_node_fs2.existsSync)(import_node_path4.default.join(dir, "pnpm-workspace.yaml"))) {
+    if ((0, import_node_fs2.existsSync)(import_node_path5.default.join(dir, "pnpm-workspace.yaml"))) {
       return dir;
     }
-    const pkgPath = import_node_path4.default.join(dir, "package.json");
+    const pkgPath = import_node_path5.default.join(dir, "package.json");
     if ((0, import_node_fs2.existsSync)(pkgPath)) {
       try {
         const pkg = JSON.parse((0, import_node_fs2.readFileSync)(pkgPath, "utf8"));
@@ -1088,7 +1112,13 @@ async function run(config, opts) {
     }
   }
   checkSignal();
-  const ir = mergeSources(entries);
+  const ir = mergeSources(entries, logger);
+  const cycles = /* @__PURE__ */ new Set();
+  for (const [namespace, source] of Object.entries(ir.sources)) {
+    for (const member of (0, import_ir2.refCycleMembers)(source)) {
+      cycles.add(`${namespace}.${member}`);
+    }
+  }
   checkSignal();
   const order = generatorOrder(config.generators);
   const artifacts = {};
@@ -1116,6 +1146,7 @@ async function run(config, opts) {
       const out = await generator.generate({
         ir: view,
         dependencies,
+        cycles,
         logger: childLogger(logger, { generator: name })
       });
       artifacts[name] = out.artifact;