@ykdz/template 0.0.4 → 0.0.6

package/dist/src/package-addition.js

@@ -1,16 +1,22 @@
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { findBuiltInPresetProjection } from "../templates/registry.js";
 import { validateProjectBlueprint, } from "./declarations.js";
 import { collectGeneratedManifestCatalogReferences, pnpmWorkspaceYamlWithCatalogDependencies, } from "./dependency-catalog.js";
+import { PackageAdditionSupport } from "./package-addition-support.js";
+import { assertTypeScriptPackageBoundaryForLinkIntent, packageTurboTasks, planPackageLinks, } from "./package-linking.js";
+import { findBuiltInPresetSourceManifestPreset, loadBuiltInPresetSourceManifest, } from "./preset-source.js";
+import { defaultPackagePathForPresetSourcePackageAddition, planPresetSourcePackageAddition, } from "./projection-capabilities.js";
 import { renderProject } from "./renderer.js";
-function projectNameFromBlueprint(blueprint) {
+function projectNameFromBlueprint(blueprint, fallbackProjectName) {
     const firstPackage = blueprint.packages?.[0];
     const match = firstPackage?.name.match(/^@([^/]+)\//);
-    if (!match) {
-        throw new Error("Cannot infer workspace package scope from the stored Project Blueprint");
+    if (match) {
+        return match[1];
     }
-    return match[1];
+    if (/^[a-z0-9][a-z0-9._-]*$/.test(fallbackProjectName)) {
+        return fallbackProjectName;
+    }
+    throw new Error("Cannot infer workspace package scope from the stored Project Blueprint or root package.json");
 }
 function assertSafePackageLeaf(name) {
     if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
@@ -69,10 +75,17 @@ function validateExplicitPackagePath(packagePath) {
     }
     return packagePath;
 }
-function defaultPackagePathForPreset(preset, packageLeafName) {
-    return preset === "ts-lib"
-        ? `packages/${packageLeafName}`
-        : `apps/${packageLeafName}`;
+function supportedPackageAdditionPresetNames() {
+    return loadBuiltInPresetSourceManifest()
+        .presets.filter((preset) => preset.packageAdditionSupport === PackageAdditionSupport.Supported)
+        .map((preset) => preset.name);
+}
+function formatUnsupportedPackageAdditionPresetError(preset) {
+    return [
+        `Preset ${preset} cannot be used for Package Addition.`,
+        "It can still initialize a Generated Repository, but it cannot be added to an existing one.",
+        `Supported Package Addition presets: ${supportedPackageAdditionPresetNames().join(", ")}`,
+    ].join("\n");
 }
 function assertNoPackageConflict(blueprint, packageName, packagePath) {
     const existingByName = blueprint.packages?.find((pkg) => pkg.name === packageName);
@@ -84,6 +97,78 @@ function assertNoPackageConflict(blueprint, packageName, packagePath) {
         throw new Error(`Package Path ${packagePath} conflicts with existing package ${existingByPath.name} at ${existingByPath.path}`);
     }
 }
+function formatAvailablePackagePaths(blueprint) {
+    return (blueprint.packages ?? [])
+        .map((projectPackage) => projectPackage.path)
+        .join(", ");
+}
+function packageLinkIntentForSingleConsumer(options) {
+    if (options.consumerPackagePath === options.providerPackagePath) {
+        throw new Error(`Package Link Intent cannot link ${options.providerPackagePath} from itself`);
+    }
+    const consumer = options.blueprint.packages?.find((projectPackage) => projectPackage.path === options.consumerPackagePath);
+    if (!consumer) {
+        const availablePackagePaths = formatAvailablePackagePaths(options.blueprint);
+        throw new Error([
+            `Unknown Package Path for --link-from: ${options.consumerPackagePath}`,
+            availablePackagePaths
+                ? `Available Package Paths: ${availablePackagePaths}`
+                : undefined,
+        ]
+            .filter((line) => line !== undefined)
+            .join("\n"));
+    }
+    return {
+        consumerPackagePath: options.consumerPackagePath,
+        providerPackagePath: options.providerPackagePath,
+    };
+}
+function packageLinkIntentsForConsumers(options) {
+    const packageLinkIntents = [];
+    const seenConsumerPackagePaths = new Set();
+    for (const consumerPackagePath of options.consumerPackagePaths) {
+        if (seenConsumerPackagePaths.has(consumerPackagePath)) {
+            continue;
+        }
+        seenConsumerPackagePaths.add(consumerPackagePath);
+        packageLinkIntents.push(packageLinkIntentForSingleConsumer({
+            blueprint: options.blueprint,
+            consumerPackagePath,
+            providerPackagePath: options.providerPackagePath,
+        }));
+    }
+    return packageLinkIntents;
+}
+async function assertPackageLinkIntentConsumersAreTypeScriptBoundaries(options) {
+    for (const intent of options.packageLinkIntents) {
+        const consumer = options.blueprint.packages?.find((projectPackage) => projectPackage.path === intent.consumerPackagePath);
+        if (!consumer) {
+            continue;
+        }
+        if (consumer.role !== undefined && consumer.sourcePreset !== undefined) {
+            assertTypeScriptPackageBoundaryForLinkIntent(consumer, "consumer");
+            continue;
+        }
+        try {
+            const manifest = await readJson(path.join(options.root, consumer.path, "package.json"));
+            const scripts = isRecord(manifest) ? manifest.scripts : undefined;
+            const hasTypeScriptPackageShape = isRecord(manifest) &&
+                manifest.type === "module" &&
+                isRecord(scripts) &&
+                typeof scripts.typecheck === "string";
+            if (hasTypeScriptPackageShape) {
+                continue;
+            }
+            assertTypeScriptPackageBoundaryForLinkIntent(consumer, "consumer");
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT") {
+                assertTypeScriptPackageBoundaryForLinkIntent(consumer, "consumer");
+            }
+            throw error;
+        }
+    }
+}
 async function readJson(filePath) {
     return JSON.parse(await readFile(filePath, "utf8"));
 }
@@ -169,16 +254,23 @@ async function readGeneratedWorkspaceBlueprint(root) {
     await stat(path.join(root, "pnpm-workspace.yaml"));
     return blueprint;
 }
-async function readGeneratedRepositoryNodeVersion(root) {
+async function readGeneratedRepositoryPackageMetadata(root) {
     const packageJson = await readJson(path.join(root, "package.json"));
-    if (!isRecord(packageJson) || !isRecord(packageJson.engines)) {
+    if (!isRecord(packageJson)) {
+        throw new Error("Package Addition requires root package.json to be an object");
+    }
+    const projectName = packageJson.name;
+    if (typeof projectName !== "string" || projectName.length === 0) {
+        throw new Error("Package Addition requires root package.json to declare name");
+    }
+    if (!isRecord(packageJson.engines)) {
         throw new Error("Package Addition requires root package.json to declare engines.node");
     }
     const nodeVersion = packageJson.engines.node;
     if (typeof nodeVersion !== "string" || nodeVersion.length === 0) {
         throw new Error("Package Addition requires root package.json to declare engines.node");
     }
-    return nodeVersion;
+    return { projectName, nodeVersion };
 }
 function workspaceTextWithPackageGlob(text, glob) {
     if (text.includes(`  - ${glob}`)) {
@@ -190,34 +282,6 @@ function workspaceTextWithPackageGlob(text, glob) {
     }
     return nextText;
 }
-function assertRootTsconfig(input) {
-    if (!isRecord(input)) {
-        throw new Error("Cannot update root TypeScript project references: tsconfig.json must be an object");
-    }
-    const references = input.references;
-    if (references === undefined) {
-        return;
-    }
-    if (!Array.isArray(references)) {
-        throw new Error("Cannot update root TypeScript project references: references must be an array");
-    }
-    for (const reference of references) {
-        if (!isRecord(reference) || typeof reference.path !== "string") {
-            throw new Error("Cannot update root TypeScript project references: each reference must have a string path");
-        }
-    }
-}
-function rootTsconfigWithReferences(input, referencePaths) {
-    assertRootTsconfig(input);
-    const tsconfig = input;
-    const references = tsconfig.references ?? [];
-    for (const referencePath of referencePaths) {
-        if (!references.some((reference) => reference.path === referencePath)) {
-            references.push({ path: referencePath });
-        }
-    }
-    return { ...tsconfig, references };
-}
 function packageAdditionCatalogDependencies(operations) {
     const manifests = [];
     for (const operation of operations) {
@@ -232,13 +296,45 @@ function packageAdditionCatalogDependencies(operations) {
     }
     return collectGeneratedManifestCatalogReferences(manifests);
 }
-function blueprintWithPackage(blueprint, packageName, packagePath) {
+function generatedPackageManifestFromOperations(operations, packagePath) {
+    for (const operation of operations) {
+        if (operation.kind !== "writeJson" ||
+            operation.to !== `${packagePath}/package.json`) {
+            continue;
+        }
+        if (!isRecord(operation.value)) {
+            throw new Error(`Package Addition package manifest must be an object: ${operation.to}`);
+        }
+        return operation.value;
+    }
+    return undefined;
+}
+async function packageManifestsForTaskGraph(options) {
+    const manifests = [];
+    for (const packageDefinition of options.blueprint.packages ?? []) {
+        const manifestOverride = options.manifestOverrides?.get(packageDefinition.path);
+        const manifestFromOperations = generatedPackageManifestFromOperations(options.operations, packageDefinition.path);
+        manifests.push(manifestOverride ??
+            manifestFromOperations ??
+            (await readJson(path.join(options.root, packageDefinition.path, "package.json"))));
+    }
+    return manifests;
+}
+function blueprintWithPackage(blueprint, packageName, packagePath, packageRole, packageSourcePreset, packageLinkIntents) {
     const nextBlueprint = {
         ...blueprint,
         packages: [
             ...(blueprint.packages ?? []),
-            { name: packageName, path: packagePath },
+            {
+                name: packageName,
+                path: packagePath,
+                role: packageRole,
+                sourcePreset: packageSourcePreset,
+            },
         ],
+        packageLinkIntents: packageLinkIntents.length > 0
+            ? [...(blueprint.packageLinkIntents ?? []), ...packageLinkIntents]
+            : blueprint.packageLinkIntents,
     };
     const result = validateProjectBlueprint(nextBlueprint);
     if (!result.ok) {
@@ -246,6 +342,36 @@ function blueprintWithPackage(blueprint, packageName, packagePath) {
     }
     return result.value;
 }
+function assertObjectManifest(input, packagePath) {
+    if (!isRecord(input)) {
+        throw new Error(`Cannot update Package Link Intent manifest for ${packagePath}: package.json must be an object`);
+    }
+}
+function recordSortedByKey(record) {
+    return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
+}
+async function consumerManifestUpdatesForPackageLinkIntents(options) {
+    const updates = [];
+    for (const [packagePath, packageLinkDependencies,] of options.manifestDependenciesByPackagePath) {
+        const manifest = await readJson(path.join(options.root, packagePath, "package.json"));
+        assertObjectManifest(manifest, packagePath);
+        if (manifest.dependencies !== undefined &&
+            !isRecord(manifest.dependencies)) {
+            throw new Error(`Cannot update Package Link Intent manifest for ${packagePath}: dependencies must be an object`);
+        }
+        updates.push({
+            packagePath,
+            manifest: {
+                ...manifest,
+                dependencies: recordSortedByKey({
+                    ...manifest.dependencies,
+                    ...packageLinkDependencies,
+                }),
+            },
+        });
+    }
+    return updates;
+}
 function workspacePackageGlobsFromBlueprint(blueprint) {
     const globs = [];
     for (const packageDefinition of blueprint.packages ?? []) {
@@ -273,60 +399,271 @@ function rootScriptWithTurboPackageTask(script, task, workspacePackageGlobs) {
     commands[turboCommandIndex] = turboPackageTaskCommand(task, workspacePackageGlobs);
     return commands.join(" && ");
 }
-function rootPackageJsonWithPackageTaskFilters(input, blueprint) {
+function turboTaskNamesForPackageManifests(manifests) {
+    const taskNames = [];
+    for (const taskName of [
+        "typecheck",
+        "build",
+        "test",
+        "test:e2e",
+        "check",
+    ]) {
+        if (manifests.some((manifest) => typeof manifest.scripts?.[taskName] === "string")) {
+            taskNames.push(taskName);
+        }
+    }
+    return taskNames;
+}
+function rootScriptWithTurboPackageTasks(options) {
+    const rootCommands = options.script
+        .split(" && ")
+        .filter((command) => !command.startsWith("turbo run "));
+    const turboCommands = options.taskNames.map((taskName) => turboPackageTaskCommand(taskName, options.workspacePackageGlobs));
+    return [...rootCommands, ...turboCommands].join(" && ");
+}
+function rootPackageJsonWithPackageTaskFilters(input, blueprint, packageManifests) {
     assertRootPackageJson(input);
     const workspacePackageGlobs = workspacePackageGlobsFromBlueprint(blueprint);
+    const taskNames = turboTaskNamesForPackageManifests(packageManifests);
     return {
         ...input,
         scripts: {
             ...input.scripts,
-            check: rootScriptWithTurboPackageTask(input.scripts.check, "check", workspacePackageGlobs),
+            check: rootScriptWithTurboPackageTasks({
+                script: input.scripts.check,
+                taskNames,
+                workspacePackageGlobs,
+            }),
             fix: rootScriptWithTurboPackageTask(input.scripts.fix, "fix", workspacePackageGlobs),
         },
     };
 }
-async function planRootUpdates(root, blueprint, packageName, packagePath, workspacePackageGlob, rootTsconfigReferences, catalogDependencies) {
-    const nextBlueprint = blueprintWithPackage(blueprint, packageName, packagePath);
-    const workspaceText = pnpmWorkspaceYamlWithCatalogDependencies(workspaceTextWithPackageGlob(await readFile(path.join(root, "pnpm-workspace.yaml"), "utf8"), workspacePackageGlob), catalogDependencies);
-    const rootTsconfig = rootTsconfigWithReferences(await readJson(path.join(root, "tsconfig.json")), rootTsconfigReferences);
-    const rootPackageJson = rootPackageJsonWithPackageTaskFilters(await readJson(path.join(root, "package.json")), nextBlueprint);
+function manifestExportUsesCompiledRuntime(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const rootExport = value["."];
+    if (!isRecord(rootExport)) {
+        return false;
+    }
+    return (typeof rootExport.default === "string" &&
+        rootExport.default.startsWith("./dist/"));
+}
+function packageManifestsNeedDependencyBuilds(manifests) {
+    const compiledPackageNames = new Set(manifests
+        .filter((manifest) => manifestExportUsesCompiledRuntime(manifest.exports))
+        .map((manifest) => manifest.name)
+        .filter((name) => typeof name === "string"));
+    if (compiledPackageNames.size === 0) {
+        return false;
+    }
+    return manifests.some((manifest) => Object.entries(manifest.dependencies ?? {}).some(([dependencyName, specifier]) => specifier === "workspace:*" && compiledPackageNames.has(dependencyName)));
+}
+function turboConfigForPackageManifests(manifests) {
+    return {
+        tasks: packageTurboTasks({
+            dependencyBuildsRequired: packageManifestsNeedDependencyBuilds(manifests),
+        }),
+    };
+}
+function rootPackageJsonWithSharedOxcRuntimeDependencies(input, requiresSharedOxcConfiguration) {
+    if (!requiresSharedOxcConfiguration) {
+        return input;
+    }
+    if (input.type !== undefined && input.type !== "module") {
+        throw new Error('Cannot update root OXC configuration: package.json type must be "module" or omitted');
+    }
+    if (input.devDependencies !== undefined && !isRecord(input.devDependencies)) {
+        throw new Error("Cannot update root OXC configuration dependencies: devDependencies must be an object");
+    }
+    return {
+        ...input,
+        type: "module",
+        devDependencies: {
+            ...input.devDependencies,
+            oxfmt: input.devDependencies?.oxfmt ?? "catalog:",
+            oxlint: input.devDependencies?.oxlint ?? "catalog:",
+        },
+    };
+}
+function catalogDependenciesWithSharedOxcRuntimeDependencies(catalogDependencies, requiresSharedOxcConfiguration) {
+    const dependencies = [...catalogDependencies];
+    if (!requiresSharedOxcConfiguration) {
+        return dependencies;
+    }
+    for (const dependency of ["oxfmt", "oxlint"]) {
+        if (!dependencies.includes(dependency)) {
+            dependencies.push(dependency);
+        }
+    }
+    return dependencies;
+}
+async function planRootUpdates(root, blueprint, packageName, packagePath, packageRole, packageSourcePreset, packageLinkIntents, workspacePackageGlob, catalogDependencies, requiresSharedOxcConfiguration, operations) {
+    const nextBlueprint = blueprintWithPackage(blueprint, packageName, packagePath, packageRole, packageSourcePreset, packageLinkIntents);
+    const consumerManifestUpdates = packageLinkIntents.length > 0
+        ? await consumerManifestUpdatesForPackageLinkIntents({
+            root,
+            manifestDependenciesByPackagePath: planPackageLinks([
+                {
+                    name: packageName,
+                    path: packagePath,
+                    role: packageRole,
+                    sourcePreset: packageSourcePreset,
+                },
+            ], packageLinkIntents).manifestDependenciesByPackagePath,
+        })
+        : [];
+    const manifestOverrides = new Map(consumerManifestUpdates.map((update) => [
+        update.packagePath,
+        update.manifest,
+    ]));
+    const packageManifests = await packageManifestsForTaskGraph({
+        root,
+        blueprint: nextBlueprint,
+        operations,
+        manifestOverrides,
+    });
+    const workspaceText = pnpmWorkspaceYamlWithCatalogDependencies(workspaceTextWithPackageGlob(await readFile(path.join(root, "pnpm-workspace.yaml"), "utf8"), workspacePackageGlob), catalogDependenciesWithSharedOxcRuntimeDependencies(catalogDependencies, requiresSharedOxcConfiguration));
+    const rootPackageJson = rootPackageJsonWithPackageTaskFilters(await readJson(path.join(root, "package.json")), nextBlueprint, packageManifests);
     return {
         blueprint: nextBlueprint,
-        rootPackageJson,
-        rootTsconfig,
+        rootPackageJson: rootPackageJsonWithSharedOxcRuntimeDependencies(rootPackageJson, requiresSharedOxcConfiguration),
+        turboConfig: turboConfigForPackageManifests(packageManifests),
         workspaceText,
+        consumerManifestUpdates,
     };
 }
+async function readTextIfExists(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+async function writeIfMissing(filePath, text) {
+    if ((await readTextIfExists(filePath)) !== undefined) {
+        return;
+    }
+    await writeFile(filePath, text, "utf8");
+}
+async function ensureRootOxfmtConfig(root, sharedOxcRoot) {
+    await writeIfMissing(path.join(root, "oxfmt.config.ts"), await readFile(path.join(sharedOxcRoot, "oxfmt.config.ts"), "utf8"));
+}
+async function ensureRootOxlintConfig(options) {
+    const nodeConfig = await readFile(path.join(options.sharedOxcRoot, "node", "oxlint.config.ts"), "utf8");
+    const vueConfig = await readFile(path.join(options.sharedOxcRoot, "vue", "oxlint.config.ts"), "utf8");
+    const targetPath = path.join(options.root, "oxlint.config.ts");
+    const currentConfig = await readTextIfExists(targetPath);
+    if (currentConfig === undefined) {
+        await writeFile(targetPath, options.addedPreset === "vue-app" ? vueConfig : nodeConfig, "utf8");
+        return;
+    }
+    if (options.addedPreset !== "vue-app" || currentConfig === vueConfig) {
+        return;
+    }
+    if (currentConfig === nodeConfig) {
+        await writeFile(targetPath, vueConfig, "utf8");
+        return;
+    }
+    throw new Error("Cannot update root OXC lint configuration for Vue Package Addition: oxlint.config.ts has local changes");
+}
+async function ensureRootOxcConfiguration(options) {
+    if (!options.sharedOxcRoot) {
+        return;
+    }
+    await ensureRootOxfmtConfig(options.root, options.sharedOxcRoot);
+    await ensureRootOxlintConfig({
+        root: options.root,
+        sharedOxcRoot: options.sharedOxcRoot,
+        addedPreset: options.addedPreset,
+    });
+}
+function gitignoreContainsEntry(text, entry) {
+    return text
+        .split(/\r?\n/)
+        .some((line) => line.trim() === entry || line.trim() === `${entry}/`);
+}
+function gitignoreTextWithEntries(text, entries) {
+    const missingEntries = entries.filter((entry) => !gitignoreContainsEntry(text, entry));
+    if (missingEntries.length === 0) {
+        return text;
+    }
+    const prefix = text.trimEnd();
+    return `${prefix}${prefix.length > 0 ? "\n" : ""}${missingEntries.join("\n")}\n`;
+}
+function rootGitignoreEntriesForPackageAddition(preset, requiresSharedOxcConfiguration) {
+    const entries = requiresSharedOxcConfiguration
+        ? ["node_modules", "dist"]
+        : [];
+    if (preset === "vue-app") {
+        entries.push("playwright-report", "test-results");
+    }
+    return entries;
+}
+async function ensureRootGitignoreEntries(root, entries) {
+    if (entries.length === 0) {
+        return;
+    }
+    const gitignorePath = path.join(root, ".gitignore");
+    const currentText = (await readTextIfExists(gitignorePath)) ?? "";
+    const nextText = gitignoreTextWithEntries(currentText, entries);
+    if (nextText !== currentText) {
+        await writeFile(gitignorePath, nextText, "utf8");
+    }
+}
 export async function addPackage(options) {
     assertSafePackageLeaf(options.name);
     const root = path.resolve(options.cwd);
     const blueprint = await readGeneratedWorkspaceBlueprint(root);
-    const nodeVersion = await readGeneratedRepositoryNodeVersion(root);
-    const projectName = projectNameFromBlueprint(blueprint);
+    const repositoryMetadata = await readGeneratedRepositoryPackageMetadata(root);
+    const projectName = projectNameFromBlueprint(blueprint, repositoryMetadata.projectName);
     const packageName = `@${projectName}/${options.name}`;
-    const packagePath = options.path
-        ? validateExplicitPackagePath(options.path)
-        : defaultPackagePathForPreset(options.preset, options.name);
-    const projection = findBuiltInPresetProjection(options.preset);
-    const packageAddition = projection?.capabilities?.packageAddition;
-    if (!projection) {
+    const preset = findBuiltInPresetSourceManifestPreset(options.preset);
+    if (!preset) {
         throw new Error(`Unknown preset for Package Addition: ${options.preset}`);
     }
-    if (!packageAddition) {
-        throw new Error(`Package Addition is not supported by preset: ${options.preset}`);
+    if (preset.packageAdditionSupport !== PackageAdditionSupport.Supported) {
+        throw new Error(formatUnsupportedPackageAdditionPresetError(options.preset));
     }
-    const additionPlan = await packageAddition.planPackageAddition({
+    const packagePath = options.path
+        ? validateExplicitPackagePath(options.path)
+        : defaultPackagePathForPresetSourcePackageAddition(preset, options.name);
+    const additionPlan = await planPresetSourcePackageAddition({
+        preset,
+        addition: {
+            root,
+            blueprint,
+            packageLeafName: options.name,
+            packageName,
+            packagePath,
+            nodeVersion: repositoryMetadata.nodeVersion,
+        },
+    });
+    const requiresSharedOxcConfiguration = additionPlan.sourceRoots?.sharedOxc !== undefined;
+    assertNoPackageConflict(blueprint, packageName, additionPlan.packagePath);
+    const packageLinkIntents = packageLinkIntentsForConsumers({
+        blueprint,
+        consumerPackagePaths: options.linkFrom ?? [],
+        providerPackagePath: additionPlan.packagePath,
+    });
+    await assertPackageLinkIntentConsumersAreTypeScriptBoundaries({
         root,
         blueprint,
-        packageLeafName: options.name,
-        packageName,
-        packagePath,
-        nodeVersion,
+        packageLinkIntents,
     });
-    assertNoPackageConflict(blueprint, packageName, additionPlan.packagePath);
     await assertMissingPackagePath(additionPlan.packagePath, path.join(root, additionPlan.packagePath));
-    const rootUpdatePlan = await planRootUpdates(root, blueprint, packageName, additionPlan.packagePath, additionPlan.workspacePackageGlob, additionPlan.rootTsconfigReferences, packageAdditionCatalogDependencies(additionPlan.operations));
+    const rootUpdatePlan = await planRootUpdates(root, blueprint, packageName, additionPlan.packagePath, additionPlan.packageRole, additionPlan.packageSourcePreset, packageLinkIntents, additionPlan.workspaceMembershipGlob ?? additionPlan.workspacePackageGlob, packageAdditionCatalogDependencies(additionPlan.operations), requiresSharedOxcConfiguration, additionPlan.operations);
     await mkdir(path.join(root, additionPlan.packagePath), { recursive: true });
+    await ensureRootOxcConfiguration({
+        root,
+        sharedOxcRoot: additionPlan.sourceRoots?.sharedOxc,
+        addedPreset: options.preset,
+    });
+    await ensureRootGitignoreEntries(root, rootGitignoreEntriesForPackageAddition(options.preset, requiresSharedOxcConfiguration));
     await renderProject({
         sourceRoot: additionPlan.sourceRoot,
         sourceRoots: additionPlan.sourceRoots,
@@ -338,6 +675,9 @@ export async function addPackage(options) {
     }
     await writeFile(path.join(root, "pnpm-workspace.yaml"), rootUpdatePlan.workspaceText, "utf8");
     await writeJson(path.join(root, "package.json"), rootUpdatePlan.rootPackageJson);
-    await writeJson(path.join(root, "tsconfig.json"), rootUpdatePlan.rootTsconfig);
+    await writeJson(path.join(root, "turbo.json"), rootUpdatePlan.turboConfig);
+    for (const update of rootUpdatePlan.consumerManifestUpdates) {
+        await writeJson(path.join(root, update.packagePath, "package.json"), update.manifest);
+    }
     await writeJson(path.join(root, ".template/blueprint.json"), rootUpdatePlan.blueprint);
 }

package/dist/src/package-linking.d.ts

@@ -0,0 +1,55 @@
+export type PackageRole = "runtime-service" | "shared-library";
+export type PackageSourcePreset = "hono-api" | "ts-lib" | "vue-app";
+export type PackageDefinition = {
+    readonly name: string;
+    readonly path: string;
+    readonly role?: PackageRole;
+    readonly sourcePreset?: PackageSourcePreset;
+};
+export type PackageLinkIntent = {
+    readonly consumerPackagePath: string;
+    readonly providerPackagePath: string;
+};
+export type JitSourcePackageExposure = {
+    readonly kind: "jit-source";
+    readonly entrypoint: string;
+    readonly packageLocalImportPattern: string;
+    readonly packageLocalImportTarget: string;
+};
+export type CompiledPackageExposure = {
+    readonly kind: "compiled";
+    readonly entrypoint: string;
+    readonly sourceTypes: string;
+    readonly packageLocalImportPattern: string;
+    readonly packageLocalImportRuntimeTarget: string;
+    readonly packageLocalImportTypesTarget: string;
+};
+export type PackageExposure = CompiledPackageExposure | JitSourcePackageExposure;
+export type PackageLinkPlan = {
+    readonly exposuresByPackagePath: ReadonlyMap<string, PackageExposure>;
+    readonly manifestDependenciesByPackagePath: ReadonlyMap<string, Readonly<Record<string, "workspace:*">>>;
+    readonly turboTasks: TurboTaskGraph;
+};
+export type PackageManifestExposureFields = {
+    readonly exports: Record<string, unknown>;
+    readonly imports: Record<string, unknown>;
+    readonly types?: string;
+};
+export type PackageLinkBoundaryDirection = "consumer" | "provider";
+export type TurboTaskDefinition = {
+    readonly dependsOn?: readonly string[];
+    readonly outputs?: readonly string[];
+    readonly cache?: boolean;
+};
+export type TurboTaskGraph = Readonly<Record<string, TurboTaskDefinition>>;
+export type PackageTurboTaskOptions = {
+    readonly dependencyBuildsRequired: boolean;
+};
+export declare function derivePackageExposure(definition: PackageDefinition): PackageExposure;
+export declare function assertTypeScriptPackageBoundaryForLinkIntent(definition: PackageDefinition, direction: PackageLinkBoundaryDirection): asserts definition is PackageDefinition & {
+    readonly role: PackageRole;
+    readonly sourcePreset: PackageSourcePreset;
+};
+export declare function planPackageLinks(definitions: readonly PackageDefinition[], intents?: readonly PackageLinkIntent[]): PackageLinkPlan;
+export declare function packageTurboTasks({ dependencyBuildsRequired, }: PackageTurboTaskOptions): TurboTaskGraph;
+export declare function packageManifestExposureFields(exposure: PackageExposure): PackageManifestExposureFields;