@ykdz/template 0.0.3 → 0.0.5

package/dist/src/package-addition.js

@@ -1,28 +1,186 @@
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { findBuiltInPresetProjection } from "../templates/registry.js";
+import { builtInPresetProjections, 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 { 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)) {
         throw new Error("--name must be a lowercase package leaf name using letters, numbers, and hyphens");
     }
 }
+const reservedPackagePathCollections = new Set([
+    ".devcontainer",
+    ".git",
+    ".github",
+    ".template",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "out",
+    "target",
+]);
+function assertSafePackagePathSegment(packagePath, segment) {
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(segment)) {
+        throw new Error(`Package Path ${packagePath} must use safe path segments with lowercase letters, numbers, and hyphens`);
+    }
+}
+function validateExplicitPackagePath(packagePath) {
+    if (path.isAbsolute(packagePath)) {
+        throw new Error(`Package Path ${packagePath} must be relative`);
+    }
+    if (packagePath !== packagePath.trim()) {
+        throw new Error(`Package Path ${packagePath} must not contain whitespace`);
+    }
+    if (packagePath === ".." ||
+        packagePath.startsWith("../") ||
+        packagePath.endsWith("/..") ||
+        packagePath.includes("/../")) {
+        throw new Error(`Package Path ${packagePath} must not escape the workspace`);
+    }
+    const normalized = path.posix.normalize(packagePath);
+    if (normalized !== packagePath || packagePath.includes("\\")) {
+        throw new Error(`Package Path ${packagePath} must be exactly two safe path segments`);
+    }
+    const segments = packagePath.split("/");
+    if (segments.length !== 2) {
+        throw new Error(`Package Path ${packagePath} must be exactly two safe path segments`);
+    }
+    const [collection, packageDirectory] = segments;
+    if (!collection || !packageDirectory) {
+        throw new Error(`Package Path ${packagePath} must be exactly two safe path segments`);
+    }
+    if (reservedPackagePathCollections.has(collection)) {
+        throw new Error(`Package Path ${packagePath} uses reserved collection ${collection}`);
+    }
+    assertSafePackagePathSegment(packagePath, collection);
+    assertSafePackagePathSegment(packagePath, packageDirectory);
+    if (reservedPackagePathCollections.has(packageDirectory)) {
+        throw new Error(`Package Path ${packagePath} uses reserved package directory ${packageDirectory}`);
+    }
+    return packagePath;
+}
+function defaultPackagePathForPreset(preset, packageLeafName) {
+    return preset === "ts-lib"
+        ? `packages/${packageLeafName}`
+        : `apps/${packageLeafName}`;
+}
+function supportedPackageAdditionPresetNames() {
+    return builtInPresetProjections
+        .filter((projection) => projection.metadata.packageAdditionSupport ===
+        PackageAdditionSupport.Supported)
+        .map((projection) => projection.metadata.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);
+    if (existingByName) {
+        throw new Error(`Package Path ${packagePath} conflicts with existing package ${existingByName.name} at ${existingByName.path}`);
+    }
+    const existingByPath = blueprint.packages?.find((pkg) => pkg.path === packagePath);
+    if (existingByPath) {
+        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"));
 }
 async function writeJson(filePath, value) {
     await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
 }
-async function assertMissing(targetPath) {
+async function assertMissingPackagePath(packagePath, targetPath) {
     try {
         await stat(targetPath);
     }
@@ -32,7 +190,7 @@ async function assertMissing(targetPath) {
         }
         throw error;
     }
-    throw new Error(`Package Addition would overwrite an existing path: ${targetPath}`);
+    throw new Error(`Package Path ${packagePath} conflicts with existing filesystem path ${targetPath}`);
 }
 function resolveGeneratedPath(root, relativePath) {
     if (path.isAbsolute(relativePath)) {
@@ -53,11 +211,39 @@ function isNodeError(error) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function assertRootPackageJson(input) {
+    if (!isRecord(input)) {
+        throw new Error("Cannot update root Package Addition scripts: package.json must be an object");
+    }
+    if (!isRecord(input.scripts)) {
+        throw new Error("Cannot update root Package Addition scripts: scripts must be an object");
+    }
+    for (const scriptName of ["check", "fix"]) {
+        if (typeof input.scripts[scriptName] !== "string") {
+            throw new Error(`Cannot update root Package Addition scripts: scripts.${scriptName} must be a string`);
+        }
+    }
+}
 async function readGeneratedWorkspaceBlueprint(root) {
-    const blueprintPath = path.join(root, ".project-kit/blueprint.json");
-    const result = validateProjectBlueprint(await readJson(blueprintPath));
+    const blueprintPath = path.join(root, ".template/blueprint.json");
+    let blueprintJson;
+    try {
+        blueprintJson = await readJson(blueprintPath);
+    }
+    catch (error) {
+        if (error instanceof SyntaxError ||
+            (isNodeError(error) && error.code === "ENOENT")) {
+            throw new Error("Package Addition requires a valid .template/blueprint.json");
+        }
+        throw error;
+    }
+    const result = validateProjectBlueprint(blueprintJson);
     if (!result.ok) {
-        throw new Error("Package Addition requires a valid .project-kit/blueprint.json");
+        if (isRecord(blueprintJson) &&
+            blueprintJson.projectKind === "single-package") {
+            throw new Error("Package Addition only supports existing workspace Generated Repositories");
+        }
+        throw new Error("Package Addition requires a valid .template/blueprint.json");
     }
     const blueprint = result.value;
     if (blueprint.projectKind !== "multi-package") {
@@ -73,16 +259,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}`)) {
@@ -94,85 +287,390 @@ 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 packageAdditionCatalogDependencies(operations) {
+    const manifests = [];
+    for (const operation of operations) {
+        if (operation.kind !== "writeJson" ||
+            path.basename(operation.to) !== "package.json") {
+            continue;
+        }
+        if (!isRecord(operation.value)) {
+            throw new Error(`Package Addition package manifest must be an object: ${operation.to}`);
         }
+        manifests.push(operation.value);
     }
+    return collectGeneratedManifestCatalogReferences(manifests);
 }
-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 });
+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 { ...tsconfig, references };
+    return manifests;
 }
-function blueprintWithPackage(blueprint, packageName, packagePath) {
+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) {
-        throw new Error("Package Addition would write an invalid .project-kit/blueprint.json");
+        throw new Error("Package Addition would write an invalid .template/blueprint.json");
     }
     return result.value;
 }
-async function planRootUpdates(root, blueprint, packageName, packagePath, workspacePackageGlob, rootTsconfigReferences) {
-    const workspaceText = workspaceTextWithPackageGlob(await readFile(path.join(root, "pnpm-workspace.yaml"), "utf8"), workspacePackageGlob);
-    const rootTsconfig = rootTsconfigWithReferences(await readJson(path.join(root, "tsconfig.json")), rootTsconfigReferences);
+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 ?? []) {
+        const [workspaceDir] = packageDefinition.path.split("/");
+        if (!workspaceDir) {
+            throw new Error(`Cannot update root Package Addition scripts: invalid package path ${packageDefinition.path}`);
+        }
+        const glob = `${workspaceDir}/*`;
+        if (!globs.includes(glob)) {
+            globs.push(glob);
+        }
+    }
+    return globs;
+}
+function turboPackageTaskCommand(task, workspacePackageGlobs) {
+    const filters = workspacePackageGlobs.map((glob) => `--filter './${glob}'`);
+    return [`turbo run ${task}`, ...filters].join(" ");
+}
+function rootScriptWithTurboPackageTask(script, task, workspacePackageGlobs) {
+    const commands = script.split(" && ");
+    const turboCommandIndex = commands.findIndex((command) => command.startsWith(`turbo run ${task}`));
+    if (turboCommandIndex === -1) {
+        throw new Error(`Cannot update root Package Addition scripts: scripts.${task} must run Turbo package tasks`);
+    }
+    commands[turboCommandIndex] = turboPackageTaskCommand(task, workspacePackageGlobs);
+    return commands.join(" && ");
+}
+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: rootScriptWithTurboPackageTasks({
+                script: input.scripts.check,
+                taskNames,
+                workspacePackageGlobs,
+            }),
+            fix: rootScriptWithTurboPackageTask(input.scripts.fix, "fix", workspacePackageGlobs),
+        },
+    };
+}
+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 {
-        blueprint: blueprintWithPackage(blueprint, packageName, packagePath),
-        rootTsconfig,
+        ...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: 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) {
         throw new Error(`Unknown preset for Package Addition: ${options.preset}`);
     }
+    if (projection.metadata.packageAdditionSupport !==
+        PackageAdditionSupport.Supported) {
+        throw new Error(formatUnsupportedPackageAdditionPresetError(options.preset));
+    }
+    const packageAddition = projection.capabilities?.packageAddition;
     if (!packageAddition) {
-        throw new Error(`Package Addition is not supported by preset: ${options.preset}`);
+        throw new Error(`Preset ${options.preset} declares Package Addition support but has no Package Addition implementation`);
     }
     const additionPlan = await packageAddition.planPackageAddition({
         root,
         blueprint,
         packageLeafName: options.name,
         packageName,
-        nodeVersion,
+        packagePath,
+        nodeVersion: repositoryMetadata.nodeVersion,
     });
-    if (blueprint.packages?.some((pkg) => pkg.name === packageName || pkg.path === additionPlan.packagePath)) {
-        throw new Error(`Package Addition conflicts with an existing package definition: ${packageName}`);
-    }
-    await assertMissing(path.join(root, additionPlan.packagePath));
-    const rootUpdatePlan = await planRootUpdates(root, blueprint, packageName, additionPlan.packagePath, additionPlan.workspacePackageGlob, additionPlan.rootTsconfigReferences);
+    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,
+        packageLinkIntents,
+    });
+    await assertMissingPackagePath(additionPlan.packagePath, path.join(root, additionPlan.packagePath));
+    const rootUpdatePlan = await planRootUpdates(root, blueprint, packageName, additionPlan.packagePath, additionPlan.packageRole, additionPlan.packageSourcePreset, packageLinkIntents, 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,
@@ -183,6 +681,10 @@ export async function addPackage(options) {
         await writeFile(resolveGeneratedPath(root, textFile.path), textFile.text, "utf8");
     }
     await writeFile(path.join(root, "pnpm-workspace.yaml"), rootUpdatePlan.workspaceText, "utf8");
-    await writeJson(path.join(root, "tsconfig.json"), rootUpdatePlan.rootTsconfig);
-    await writeJson(path.join(root, ".project-kit/blueprint.json"), rootUpdatePlan.blueprint);
+    await writeJson(path.join(root, "package.json"), rootUpdatePlan.rootPackageJson);
+    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);
 }