@ykdz/template 0.0.3 → 0.0.4

package/dist/src/package-addition.js

@@ -2,6 +2,7 @@ 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 { renderProject } from "./renderer.js";
 function projectNameFromBlueprint(blueprint) {
     const firstPackage = blueprint.packages?.[0];
@@ -16,13 +17,80 @@ function assertSafePackageLeaf(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 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}`);
+    }
+}
 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 +100,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 +121,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") {
@@ -122,6 +218,20 @@ function rootTsconfigWithReferences(input, referencePaths) {
     }
     return { ...tsconfig, references };
 }
+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 blueprintWithPackage(blueprint, packageName, packagePath) {
     const nextBlueprint = {
         ...blueprint,
@@ -132,15 +242,57 @@ function blueprintWithPackage(blueprint, packageName, packagePath) {
     };
     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);
+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 rootPackageJsonWithPackageTaskFilters(input, blueprint) {
+    assertRootPackageJson(input);
+    const workspacePackageGlobs = workspacePackageGlobsFromBlueprint(blueprint);
+    return {
+        ...input,
+        scripts: {
+            ...input.scripts,
+            check: rootScriptWithTurboPackageTask(input.scripts.check, "check", 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);
     return {
-        blueprint: blueprintWithPackage(blueprint, packageName, packagePath),
+        blueprint: nextBlueprint,
+        rootPackageJson,
         rootTsconfig,
         workspaceText,
     };
@@ -152,6 +304,9 @@ export async function addPackage(options) {
     const nodeVersion = await readGeneratedRepositoryNodeVersion(root);
     const projectName = projectNameFromBlueprint(blueprint);
     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) {
@@ -165,13 +320,12 @@ export async function addPackage(options) {
         blueprint,
         packageLeafName: options.name,
         packageName,
+        packagePath,
         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);
+    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));
     await mkdir(path.join(root, additionPlan.packagePath), { recursive: true });
     await renderProject({
         sourceRoot: additionPlan.sourceRoot,
@@ -183,6 +337,7 @@ 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, "package.json"), rootUpdatePlan.rootPackageJson);
     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, ".template/blueprint.json"), rootUpdatePlan.blueprint);
 }

package/dist/src/preset-projection.d.ts

@@ -9,6 +9,7 @@ export type PresetPackageAdditionOptions = {
     readonly blueprint: ProjectBlueprint;
     readonly packageLeafName: string;
     readonly packageName: string;
+    readonly packagePath: string;
     readonly nodeVersion: string;
 };
 export type PresetPackageAdditionPlan = {
@@ -63,4 +64,3 @@ export declare function planNextStepInstructionsForProjection(options: {
     readonly targetDir: string;
     readonly plan: PresetProjectionPlan;
 }): readonly NextStepInstruction[];
-//# sourceMappingURL=preset-projection.d.ts.map

package/dist/src/project-github.d.ts

@@ -12,9 +12,11 @@ export type PnpmTaskLayer = {
     readonly installCommand: "pnpm install";
     readonly checkCommand: "pnpm run check";
 };
-export type DependencyEcosystem = "npm" | "cargo" | "github-actions";
+export type DependencyEcosystem = "npm" | "cargo" | "github-actions" | "docker" | "rust-toolchain";
+export type DependabotDirectory = `/${string}`;
 export type DependencyMaintenancePolicy = {
     readonly ecosystems: DependencyEcosystem[];
+    readonly directories?: Partial<Record<DependencyEcosystem, DependabotDirectory>>;
     readonly interval: "weekly";
 };
 type ProjectCheckWorkflowOptions = {
@@ -26,4 +28,3 @@ type ProjectCheckWorkflowOptions = {
 export declare function projectCheckWorkflow(options: ProjectCheckWorkflowOptions): string;
 export declare function projectDependabotConfig(policy: DependencyMaintenancePolicy): string;
 export {};
-//# sourceMappingURL=project-github.d.ts.map

package/dist/src/project-github.js

@@ -44,16 +44,34 @@ export function projectCheckWorkflow(options) {
 export function projectDependabotConfig(policy) {
     return [
         "version: 2",
+        "",
         "updates:",
-        ...policy.ecosystems.flatMap((ecosystem) => [
-            `  - package-ecosystem: ${ecosystem}`,
-            "    directory: /",
-            "    schedule:",
-            `      interval: ${policy.interval}`,
-        ]),
+        ...policy.ecosystems.flatMap((ecosystem) => renderDependabotUpdate(ecosystem, policy.directories?.[ecosystem] ??
+            defaultDependabotDirectory(ecosystem), policy.interval)),
         "",
     ].join("\n");
 }
+function renderDependabotUpdate(ecosystem, directory, interval) {
+    const lines = [
+        `  - package-ecosystem: ${ecosystem}`,
+        `    directory: ${renderDependabotDirectory(ecosystem, directory)}`,
+        "    schedule:",
+        `      interval: ${interval}`,
+    ];
+    if (ecosystem === "npm") {
+        lines.push("    ignore:", '      - dependency-name: "@types/node"', "        update-types:", "          - version-update:semver-major");
+    }
+    if (ecosystem === "docker") {
+        lines.push("    ignore:", "      - dependency-name: mcr.microsoft.com/devcontainers/typescript-node", "        update-types:", "          - version-update:semver-major");
+    }
+    return lines;
+}
+function renderDependabotDirectory(ecosystem, directory) {
+    return ecosystem === "cargo" ? JSON.stringify(directory) : directory;
+}
+function defaultDependabotDirectory(ecosystem) {
+    return ecosystem === "docker" ? "/.devcontainer" : "/";
+}
 function renderCiEnvironmentNeedCommand(need) {
     if (need.kind === "playwright-browser-assets" &&
         need.owner.path === "apps/web") {

package/dist/src/renderer.d.ts

@@ -21,6 +21,21 @@ export type WriteTextOperation = {
     to: string;
     text: string;
 };
+export type WriteTextFromFragmentsOperation = {
+    kind: "writeTextFromFragments";
+    to: string;
+    fragments: readonly {
+        from: string;
+        sourceRoot?: string;
+    }[];
+};
+export type WriteTextTemplateOperation = {
+    kind: "writeTextTemplate";
+    from: string;
+    to: string;
+    sourceRoot?: string;
+    replacements: Record<string, string>;
+};
 export type SetExecutableOperation = {
     kind: "setExecutable";
     path: string;
@@ -32,7 +47,7 @@ export type ReplaceAnchorsOperation = {
     language: "typescript";
     replacements: Record<string, string>;
 };
-export type RenderOperation = CopyFileOperation | WriteJsonOperation | MergeJsonOperation | WriteTextOperation | SetExecutableOperation | ReplaceAnchorsOperation;
+export type RenderOperation = CopyFileOperation | WriteJsonOperation | MergeJsonOperation | WriteTextOperation | WriteTextFromFragmentsOperation | WriteTextTemplateOperation | SetExecutableOperation | ReplaceAnchorsOperation;
 export type RenderProjectOptions = {
     sourceRoot: string;
     sourceRoots?: Record<string, string>;
@@ -43,4 +58,3 @@ export type RenderProjectOptions = {
 export declare function renderProject(options: RenderProjectOptions): Promise<void>;
 export declare function renderNewProject(options: RenderProjectOptions): Promise<void>;
 export {};
-//# sourceMappingURL=renderer.d.ts.map

package/dist/src/renderer.js

@@ -1,5 +1,5 @@
 import { constants } from "node:fs";
-import { chmod, copyFile, mkdir, mkdtemp, readFile, readdir, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import { chmod, copyFile, mkdir, mkdtemp, readFile, readdir, rename, rm, rmdir, stat, writeFile, } from "node:fs/promises";
 import path from "node:path";
 function expandTemplatePath(templatePath, variables) {
     return templatePath.replaceAll(/\{\{([A-Za-z][A-Za-z0-9_]*)\}\}/g, (_, name) => {
@@ -19,7 +19,8 @@ function resolveContainedPath(root, relativePath) {
     }
     const resolvedRoot = path.resolve(root);
     const resolvedPath = path.resolve(resolvedRoot, relativePath);
-    const insideRoot = resolvedPath === resolvedRoot || resolvedPath.startsWith(`${resolvedRoot}${path.sep}`);
+    const insideRoot = resolvedPath === resolvedRoot ||
+        resolvedPath.startsWith(`${resolvedRoot}${path.sep}`);
     if (!insideRoot) {
         throw new Error(`Renderer path escapes its root: ${relativePath}`);
     }
@@ -47,7 +48,7 @@ function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isScalarJsonValue(value) {
-    return value === null || ["boolean", "number", "string"].includes(typeof value);
+    return (value === null || ["boolean", "number", "string"].includes(typeof value));
 }
 function serializeJsonValue(value, indentation, pathSegments, multilineArrays, rootKeyOrder) {
     if (Array.isArray(value)) {
@@ -88,7 +89,13 @@ const packageJsonRootKeyOrder = [
     "peerDependencies",
     "optionalDependencies",
     "engines",
-    "packageManager"
+    "packageManager",
+];
+const devcontainerJsonRootKeyOrder = [
+    "name",
+    "build",
+    "image",
+    "customizations",
 ];
 function compareJsonKeys(left, right, pathSegments, rootKeyOrder) {
     if (pathSegments.length === 0 && rootKeyOrder) {
@@ -101,10 +108,13 @@ function compareJsonKeys(left, right, pathSegments, rootKeyOrder) {
     return left.localeCompare(right);
 }
 function rootKeyOrderForPath(toPath) {
-    if (path.basename(toPath) !== "package.json") {
-        return undefined;
+    if (path.basename(toPath) === "package.json") {
+        return new Map(packageJsonRootKeyOrder.map((key, index) => [key, index]));
+    }
+    if (toPath.split(path.sep).join("/") === ".devcontainer/devcontainer.json") {
+        return new Map(devcontainerJsonRootKeyOrder.map((key, index) => [key, index]));
     }
-    return new Map(packageJsonRootKeyOrder.map((key, index) => [key, index]));
+    return undefined;
 }
 function serializeJson(value, multilineArrays = [], rootKeyOrder) {
     return `${serializeJsonValue(value, 0, [], new Set(multilineArrays), rootKeyOrder)}\n`;
@@ -151,7 +161,7 @@ const foundationTextFiles = new Set([
     "README",
     "README.md",
     "LICENSE",
-    "CHANGELOG.md"
+    "CHANGELOG.md",
 ]);
 function assertFoundationTextPath(relativePath) {
     const normalizedPath = relativePath.split(path.sep).join("/");
@@ -162,11 +172,20 @@ function assertFoundationTextPath(relativePath) {
     if (isRootLevel && relativePath.endsWith(".md")) {
         return;
     }
-    if (isRootLevel && (relativePath.endsWith(".yaml") || relativePath.endsWith(".yml"))) {
+    if (isRootLevel &&
+        (relativePath.endsWith(".yaml") || relativePath.endsWith(".yml"))) {
         return;
     }
     if (isRootLevel &&
-        ["Cargo.toml", "Cargo.lock", "rustfmt.toml"].includes(normalizedPath)) {
+        [
+            "Cargo.toml",
+            "Cargo.lock",
+            "rustfmt.toml",
+            "rust-toolchain.toml",
+        ].includes(normalizedPath)) {
+        return;
+    }
+    if (/^packages\/[A-Za-z0-9._-]+\/(?:Cargo\.toml|Cargo\.lock|rustfmt\.toml)$/.test(normalizedPath)) {
         return;
     }
     if (/^\.github\/workflows\/[A-Za-z0-9._-]+\.ya?ml$/.test(normalizedPath)) {
@@ -175,6 +194,9 @@ function assertFoundationTextPath(relativePath) {
     if (/^\.github\/dependabot\.ya?ml$/.test(normalizedPath)) {
         return;
     }
+    if (normalizedPath === ".devcontainer/Dockerfile") {
+        return;
+    }
     throw new Error(`Text output is limited to foundation files: ${relativePath}`);
 }
 async function renderWriteText(operation, options) {
@@ -184,6 +206,56 @@ async function renderWriteText(operation, options) {
     await mkdir(path.dirname(to), { recursive: true });
     await writeGeneratedFile(to, operation.text);
 }
+async function renderWriteTextFromFragments(operation, options) {
+    const toPath = expandOperationPath(operation.to, options);
+    assertFoundationTextPath(toPath);
+    const to = resolveContainedPath(options.targetRoot, toPath);
+    const texts = await Promise.all(operation.fragments.map(async (fragment) => {
+        const sourceRoot = fragment.sourceRoot === undefined
+            ? options.sourceRoot
+            : options.sourceRoots?.[fragment.sourceRoot];
+        if (sourceRoot === undefined) {
+            throw new Error(`Unknown renderer source root: ${fragment.sourceRoot}`);
+        }
+        const fromPath = expandTemplatePath(fragment.from, options.variables ?? {});
+        const from = resolveContainedPath(sourceRoot, fromPath);
+        return readFile(from, "utf8");
+    }));
+    await mkdir(path.dirname(to), { recursive: true });
+    await writeGeneratedFile(to, texts.map((text) => text.trimEnd()).join("\n\n") + "\n");
+}
+function replaceTextTemplateVariables(sourceText, replacements) {
+    const used = new Set();
+    const rendered = sourceText.replaceAll(/\{\{([A-Za-z][A-Za-z0-9_]*)\}\}/g, (_placeholder, name) => {
+        const replacement = replacements[name];
+        if (replacement === undefined) {
+            throw new Error(`Missing text template variable: ${name}`);
+        }
+        used.add(name);
+        return replacement;
+    });
+    for (const name of Object.keys(replacements)) {
+        if (!used.has(name)) {
+            throw new Error(`Unused text template variable: ${name}`);
+        }
+    }
+    return rendered;
+}
+async function renderWriteTextTemplate(operation, options) {
+    const sourceRoot = operation.sourceRoot === undefined
+        ? options.sourceRoot
+        : options.sourceRoots?.[operation.sourceRoot];
+    if (sourceRoot === undefined) {
+        throw new Error(`Unknown renderer source root: ${operation.sourceRoot}`);
+    }
+    const toPath = expandOperationPath(operation.to, options);
+    assertFoundationTextPath(toPath);
+    const from = resolveContainedPath(sourceRoot, expandTemplatePath(operation.from, options.variables ?? {}));
+    const to = resolveContainedPath(options.targetRoot, toPath);
+    const sourceText = await readFile(from, "utf8");
+    await mkdir(path.dirname(to), { recursive: true });
+    await writeGeneratedFile(to, replaceTextTemplateVariables(sourceText, operation.replacements));
+}
 async function renderSetExecutable(operation, options) {
     const filePath = resolveContainedPath(options.targetRoot, expandOperationPath(operation.path, options));
     const currentMode = (await stat(filePath)).mode;
@@ -224,7 +296,7 @@ async function findTypeScriptAnchorRanges(sourceText) {
             anchors.push({
                 name,
                 start: comment.pos,
-                end: comment.end
+                end: comment.end,
             });
         }
         ts.forEachChild(node, collectNodeAnchors);
@@ -296,7 +368,10 @@ async function copyGeneratedFile(from, to) {
 }
 async function writeGeneratedFile(to, text, overwrite = false) {
     try {
-        await writeFile(to, text, { encoding: "utf8", flag: overwrite ? "w" : "wx" });
+        await writeFile(to, text, {
+            encoding: "utf8",
+            flag: overwrite ? "w" : "wx",
+        });
     }
     catch (error) {
         if (isNodeError(error) && error.code === "EEXIST") {
@@ -323,6 +398,14 @@ export async function renderProject(options) {
             await renderWriteText(operation, options);
             continue;
         }
+        if (operation.kind === "writeTextFromFragments") {
+            await renderWriteTextFromFragments(operation, options);
+            continue;
+        }
+        if (operation.kind === "writeTextTemplate") {
+            await renderWriteTextTemplate(operation, options);
+            continue;
+        }
         if (operation.kind === "setExecutable") {
             await renderSetExecutable(operation, options);
             continue;

package/dist/src/runtime-paths.d.ts

@@ -1,2 +1 @@
 export declare function packageTemplateRoot(moduleDir: string, ...segments: string[]): string;
-//# sourceMappingURL=runtime-paths.d.ts.map

package/dist/src/template-boundary-check.d.ts

@@ -0,0 +1,34 @@
+import type { PresetProjectionPlan } from "./preset-projection.js";
+import type { RenderOperation } from "./renderer.js";
+export type TemplateBoundaryDebt = {
+    readonly preset: string;
+    readonly generatedPath: string;
+    readonly owningFunction: string;
+    readonly reason: string;
+};
+export type TemplateBoundaryViolation = {
+    readonly preset: string;
+    readonly generatedPath: string;
+    readonly owningFunction: string;
+    readonly operationKind: RenderOperation["kind"];
+    readonly sourceFilePath: string;
+    readonly allowlistReason?: string;
+};
+export type TemplateBoundaryCheckProjection = {
+    readonly name: string;
+    readonly sourceFilePath: string;
+    readonly plan: PresetProjectionPlan;
+};
+export type TemplateBoundaryCheckResult = {
+    readonly ok: boolean;
+    readonly violations: readonly TemplateBoundaryViolation[];
+    readonly allowlistedDebt: readonly TemplateBoundaryViolation[];
+    readonly unusedAllowlistEntries: readonly TemplateBoundaryDebt[];
+};
+export type CheckTemplateSourceBoundaryOptions = {
+    readonly projections: readonly TemplateBoundaryCheckProjection[];
+    readonly allowlist?: readonly TemplateBoundaryDebt[];
+};
+export declare const templateBoundaryDebtAllowlist: readonly TemplateBoundaryDebt[];
+export declare function isProtectedGeneratedPath(generatedPath: string): boolean;
+export declare function checkTemplateSourceBoundary({ projections, allowlist, }: CheckTemplateSourceBoundaryOptions): Promise<TemplateBoundaryCheckResult>;