@ykdz/template 0.0.7 → 0.0.9

package/{dist/src → node_modules/@ykdz/template-core/dist}/projection-capabilities.js

@@ -1,13 +1,10 @@
-import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { collectGeneratedManifestCatalogDependencies, collectGeneratedManifestCatalogReferences, renderGeneratedPnpmWorkspaceYaml, } from "./dependency-catalog.js";
 import { browserTestToolLayer, checkedDockerfileFirstNodePnpmDevcontainer, dockerfileFirstRustPnpmDevcontainer, nodePnpmToolLayer, rustToolLayer, } from "./devcontainer.js";
 import { editorCustomizationForCapabilities, } from "./editor-customization.js";
 import { renderFixCommand, renderRootCheckCommand, } from "./module-graph.js";
 import { packageManifestExposureFields, planPackageLinks, } from "./package-linking.js";
-import { packageTemplateRoot } from "./runtime-paths.js";
 const projectionCapabilityKinds = [
     "workspace-library-package",
     "workspace-node-packages",
@@ -18,6 +15,8 @@ const projectionCapabilityKinds = [
     "github-maintenance",
 ];
 const projectionCapabilityKindSet = new Set(projectionCapabilityKinds);
+const workspaceNodePackageKindSet = new Set(["hono-api", "vue-app"]);
+const workspaceNodePackagePathSet = new Set(["apps/api", "apps/web"]);
 const strictTypescriptRootBoundary = {
     kind: "workspace-orchestration",
     path: ".",
@@ -26,10 +25,6 @@ const workspacePackageBoundary = {
     kind: "package-boundary",
     path: ".",
 };
-const workspacePackageCollectionBoundary = {
-    kind: "package-boundary",
-    path: "packages/*",
-};
 const requiredPlanCapabilityProviders = [
     {
         flag: "rootCheck",
@@ -78,12 +73,30 @@ const exactCapabilityKeys = {
     "github-maintenance": ["kind"],
 };
 const dependencyMaintenanceEcosystems = ["npm", "github-actions", "docker"];
+function strictTypeScriptCompilerOptions(options) {
+    return {
+        ...options,
+        erasableSyntaxOnly: true,
+        exactOptionalPropertyTypes: true,
+        forceConsistentCasingInFileNames: true,
+        isolatedModules: true,
+        noEmitOnError: true,
+        noFallthroughCasesInSwitch: true,
+        noImplicitOverride: true,
+        noImplicitReturns: true,
+        noUncheckedIndexedAccess: true,
+        skipLibCheck: false,
+        strict: true,
+        target: "es2023",
+        verbatimModuleSyntax: true,
+    };
+}
 const capabilityInterpreters = {
     "workspace-library-package": {
         kind: "workspace-library-package",
         contribute({ capability, state }) {
             state.package = capability;
-            state.sourceRoot = templateSourceRoot(capability.packageSourcePreset);
+            state.sourceRoot = templateSourceRoot(state, capability.packageSourcePreset);
             state.packageDependencies.add("valibot");
             state.operationFactories.push(workspaceLibraryPackageOperations);
         },
@@ -92,7 +105,7 @@ const capabilityInterpreters = {
         kind: "workspace-node-packages",
         contribute({ capability, state }) {
             state.nodeWorkspace = capability;
-            state.sourceRoot = templateSourceRootForPreset(sourceRootPreset(capability));
+            state.sourceRoot = templateSourceRootForPreset(state, sourceRootPreset(capability));
             state.operationFactories.push(workspaceNodePackagesOperations);
             if (capability.packages.length > 1) {
                 state.rootScriptFragments.dev = "turbo run dev --parallel";
@@ -112,8 +125,9 @@ const capabilityInterpreters = {
         kind: "rust-binary-workspace",
         contribute({ capability, state }) {
             state.rustWorkspace = capability;
-            state.sourceRoot = templateSourceRootForPreset("rust-bin");
-            state.sourceRoots.sharedDevcontainer = sharedDevcontainerSourceRoot();
+            state.sourceRoot = templateSourceRootForPreset(state, "rust-bin");
+            state.sourceRoots.sharedDevcontainer =
+                state.projectionSourceRoots.sharedDevcontainer();
             state.rootCheckComponents.push({
                 kind: "turbo-package-check",
                 owner: workspaceGlobBoundary(capability.workspacePackageGlob),
@@ -186,7 +200,7 @@ const capabilityInterpreters = {
     "oxc-format-lint": {
         kind: "oxc-format-lint",
         contribute({ state }) {
-            state.sourceRoots.sharedOxc = sharedOxcSourceRoot();
+            state.sourceRoots.sharedOxc = state.projectionSourceRoots.sharedOxc();
             state.rootCheckComponents.unshift({
                 kind: "oxc-format-check",
                 owner: strictTypescriptRootBoundary,
@@ -211,21 +225,23 @@ const capabilityInterpreters = {
             state.rootScriptFragments["format:write"] =
                 "oxfmt --write --config oxfmt.config.ts oxlint.config.ts oxfmt.config.ts";
             state.rootScriptFragments.lint =
-                "oxlint --config oxlint.config.ts oxlint.config.ts oxfmt.config.ts --deny-warnings";
+                "oxlint --config oxlint.config.ts oxlint.config.ts oxfmt.config.ts";
             state.rootScriptFragments["lint:fix"] =
-                "oxlint --config oxlint.config.ts oxlint.config.ts oxfmt.config.ts --fix --deny-warnings";
+                "oxlint --config oxlint.config.ts oxlint.config.ts oxfmt.config.ts --fix";
             state.packageScriptFragments["format:check"] =
                 "oxfmt --check --config ../../oxfmt.config.ts .";
             state.packageScriptFragments["format:write"] =
                 "oxfmt --write --config ../../oxfmt.config.ts .";
             state.packageScriptFragments.lint =
-                "oxlint --config ../../oxlint.config.ts . --deny-warnings";
+                "oxlint --config ../../oxlint.config.ts .";
             state.packageScriptFragments["lint:fix"] =
-                "oxlint --config ../../oxlint.config.ts . --fix --deny-warnings";
+                "oxlint --config ../../oxlint.config.ts . --fix";
             state.rootDevDependencies.add("oxfmt");
             state.rootDevDependencies.add("oxlint");
+            state.rootDevDependencies.add("oxlint-tsgolint");
             state.packageDevDependencies.add("oxfmt");
             state.packageDevDependencies.add("oxlint");
+            state.packageDevDependencies.add("oxlint-tsgolint");
             state.editorCustomizationCapabilities.push("oxc-format-lint");
             state.flags.fixCommand = true;
             state.operationFactories.push(oxcFormatLintOperations);
@@ -234,7 +250,8 @@ const capabilityInterpreters = {
     "node-pnpm-devcontainer": {
         kind: "node-pnpm-devcontainer",
         contribute({ state }) {
-            state.sourceRoots.sharedDevcontainer = sharedDevcontainerSourceRoot();
+            state.sourceRoots.sharedDevcontainer =
+                state.projectionSourceRoots.sharedDevcontainer();
             state.flags.devcontainer = true;
             state.operationFactories.push(nodePnpmDevcontainerOperations);
         },
@@ -249,6 +266,52 @@ const capabilityInterpreters = {
         },
     },
 };
+function contributeProjectionCapability(capability, state) {
+    switch (capability.kind) {
+        case "workspace-library-package":
+            capabilityInterpreters["workspace-library-package"].contribute({
+                capability,
+                state,
+            });
+            return;
+        case "workspace-node-packages":
+            capabilityInterpreters["workspace-node-packages"].contribute({
+                capability,
+                state,
+            });
+            return;
+        case "rust-binary-workspace":
+            capabilityInterpreters["rust-binary-workspace"].contribute({
+                capability,
+                state,
+            });
+            return;
+        case "strict-typescript-root":
+            capabilityInterpreters["strict-typescript-root"].contribute({
+                capability,
+                state,
+            });
+            return;
+        case "oxc-format-lint":
+            capabilityInterpreters["oxc-format-lint"].contribute({
+                capability,
+                state,
+            });
+            return;
+        case "node-pnpm-devcontainer":
+            capabilityInterpreters["node-pnpm-devcontainer"].contribute({
+                capability,
+                state,
+            });
+            return;
+        case "github-maintenance":
+            capabilityInterpreters["github-maintenance"].contribute({
+                capability,
+                state,
+            });
+            return;
+    }
+}
 export function validateProjectionCapabilities(input) {
     if (!isRecord(input) || !Array.isArray(input.capabilities)) {
         return {
@@ -279,7 +342,7 @@ export function validateProjectionCapabilities(input) {
             });
             return;
         }
-        if (!projectionCapabilityKindSet.has(capability.kind)) {
+        if (!isProjectionCapabilityKind(capability.kind)) {
             issues.push({
                 path: `${pathPrefix}.kind`,
                 message: `Unknown Projection Capability kind: ${capability.kind}`,
@@ -287,7 +350,7 @@ export function validateProjectionCapabilities(input) {
             return;
         }
         const kind = capability.kind;
-        issues.push(...unknownCapabilityPropertyIssues(capability, pathPrefix));
+        issues.push(...unknownCapabilityPropertyIssues(kind, capability, pathPrefix));
         if (kind === "workspace-library-package") {
             const workspaceCapability = parseWorkspaceLibraryPackageCapability(capability, pathPrefix);
             if (Array.isArray(workspaceCapability)) {
@@ -361,12 +424,9 @@ export function interpretPresetProjectionDeclaration(options) {
             .map((issue) => `  - ${issue.path}: ${issue.message}`)
             .join("\n")}`);
     }
-    const state = createProjectionCompositionState();
+    const state = createProjectionCompositionState(options.sourceRoots);
     for (const capability of validation.value.capabilities) {
-        capabilityInterpreters[capability.kind].contribute({
-            capability: capability,
-            state,
-        });
+        contributeProjectionCapability(capability, state);
     }
     const checkPlan = {
         components: state.rootCheckComponents,
@@ -410,10 +470,11 @@ export function interpretPresetProjectionDeclaration(options) {
 export function blueprintForPresetSourcePreset(preset, options = { targetDir: process.cwd() }) {
     const packageScope = options.scope ?? projectNameFromDir(options.targetDir);
     const projectName = projectNameFromDir(options.targetDir);
+    const packageManager = preset.supportedPackageManagers[0];
     const blueprint = {
         schemaVersion: 1,
         preset: preset.name,
-        packageManager: preset.supportedPackageManagers[0],
+        ...(packageManager === undefined ? {} : { packageManager }),
         projectKind: preset.supportedProjectKinds[0] ?? "multi-package",
         features: [...preset.features],
     };
@@ -437,13 +498,14 @@ export function projectPresetSourcePreset(options) {
         preset: options.preset,
         declaration: options.preset.projection,
         context: options.context,
+        sourceRoots: options.sourceRoots,
     });
 }
 export async function planPresetSourcePackageAddition(options) {
     if (options.preset.projection === undefined) {
         throw new Error(`Preset ${options.preset.name} declares Package Addition support but has no Projection Declaration`);
     }
-    const state = stateForProjectionDeclaration(options.preset.projection);
+    const state = stateForProjectionDeclaration(options.preset.projection, options.sourceRoots);
     const additionCapability = packageAdditionCapabilityForState(options.preset.name, state);
     return {
         packagePath: options.addition.packagePath,
@@ -451,7 +513,7 @@ export async function planPresetSourcePackageAddition(options) {
         workspaceMembershipGlob: `${packageCollectionFromPackagePath(options.addition.packagePath)}/*`,
         packageRole: additionCapability.packageRole,
         packageSourcePreset: additionCapability.packageSourcePreset,
-        sourceRoot: templateSourceRootForPreset(additionCapability.sourcePreset),
+        sourceRoot: templateSourceRootForPreset(state, additionCapability.sourcePreset),
         sourceRoots: state.sourceRoots,
         operations: [
             ...packageAdditionOperationsForCapability({
@@ -475,34 +537,17 @@ export async function planPresetSourcePackageAddition(options) {
         ],
     };
 }
-export function defaultPackagePathForPresetSourcePackageAddition(preset, packageLeafName) {
+export function defaultPackagePathForPresetSourcePackageAddition(preset, packageLeafName, sourceRoots) {
     if (preset.projection === undefined) {
         throw new Error(`Preset ${preset.name} declares Package Addition support but has no Projection Declaration`);
     }
-    const state = stateForProjectionDeclaration(preset.projection);
+    const state = stateForProjectionDeclaration(preset.projection, sourceRoots);
     const additionCapability = packageAdditionCapabilityForState(preset.name, state);
     return `${packageCollection(additionCapability.workspacePackageGlob)}/${packageLeafName}`;
 }
-export function loadBuiltInPresetProjectionDeclaration(presetName) {
-    const manifestPath = path.join(packageTemplateRoot(path.dirname(fileURLToPath(import.meta.url))), "preset-source.json");
-    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-    if (!isRecord(manifest) || !Array.isArray(manifest.presets)) {
-        throw new Error("Built-in Preset Source Manifest must declare presets");
-    }
-    const preset = manifest.presets.find((candidate) => isRecord(candidate) && candidate.name === presetName);
-    if (!isRecord(preset) || preset.projection === undefined) {
-        throw new Error(`Built-in Preset ${presetName} must declare a Projection Declaration`);
-    }
-    const result = validateProjectionCapabilities(preset.projection);
-    if (!result.ok) {
-        throw new Error(`Built-in Preset ${presetName} Projection Declaration is invalid:\n${result.issues
-            .map((issue) => `  - ${issue.path}: ${issue.message}`)
-            .join("\n")}`);
-    }
-    return result.value;
-}
-function createProjectionCompositionState() {
+function createProjectionCompositionState(sourceRoots) {
     return {
+        projectionSourceRoots: sourceRoots,
         sourceRoots: {},
         rootCheckComponents: [],
         rootCheckEnvironmentNeeds: [],
@@ -523,11 +568,29 @@ function createProjectionCompositionState() {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isProjectionCapabilityKind(value) {
+    return projectionCapabilityKindSet.has(value);
+}
+function isWorkspaceNodePackageKind(value) {
+    return typeof value === "string" && workspaceNodePackageKindSet.has(value);
+}
+function isWorkspaceNodePackagePath(value) {
+    return typeof value === "string" && workspaceNodePackagePathSet.has(value);
+}
 function isNonEmptyString(value) {
     return typeof value === "string" && value.length > 0;
 }
-function unknownCapabilityPropertyIssues(capability, pathPrefix) {
-    const kind = capability.kind;
+function nonEmptyStringArray(value) {
+    const strings = [];
+    for (const entry of value) {
+        if (!isNonEmptyString(entry)) {
+            return undefined;
+        }
+        strings.push(entry);
+    }
+    return strings.length === 0 ? undefined : strings;
+}
+function unknownCapabilityPropertyIssues(kind, capability, pathPrefix) {
     const allowedKeys = new Set(exactCapabilityKeys[kind]);
     return Object.keys(capability)
         .filter((key) => !allowedKeys.has(key))
@@ -538,6 +601,7 @@ function unknownCapabilityPropertyIssues(capability, pathPrefix) {
 }
 function parseWorkspaceLibraryPackageCapability(capability, pathPrefix) {
     const issues = [];
+    let sourceFiles = [];
     if (capability.workspacePackageGlob !== "packages/*") {
         issues.push({
             path: `${pathPrefix}.workspacePackageGlob`,
@@ -562,12 +626,17 @@ function parseWorkspaceLibraryPackageCapability(capability, pathPrefix) {
             message: "workspace-library-package sourceFiles must be a non-empty array",
         });
     }
-    else if (capability.sourceFiles.length === 0 ||
-        !capability.sourceFiles.every(isNonEmptyString)) {
-        issues.push({
-            path: `${pathPrefix}.sourceFiles`,
-            message: "workspace-library-package sourceFiles must be a non-empty array of paths",
-        });
+    else {
+        const parsedSourceFiles = nonEmptyStringArray(capability.sourceFiles);
+        if (parsedSourceFiles === undefined) {
+            issues.push({
+                path: `${pathPrefix}.sourceFiles`,
+                message: "workspace-library-package sourceFiles must be a non-empty array of paths",
+            });
+        }
+        else {
+            sourceFiles = parsedSourceFiles;
+        }
     }
     if (issues.length > 0) {
         return issues;
@@ -577,7 +646,7 @@ function parseWorkspaceLibraryPackageCapability(capability, pathPrefix) {
         workspacePackageGlob: "packages/*",
         packageRole: "shared-library",
         packageSourcePreset: "ts-lib",
-        sourceFiles: capability.sourceFiles,
+        sourceFiles,
     };
 }
 function parseWorkspaceNodePackagesCapability(capability, pathPrefix) {
@@ -628,13 +697,18 @@ function parseWorkspaceNodePackage(value, pathPrefix) {
             },
         ];
     }
-    if (value.kind !== "hono-api" && value.kind !== "vue-app") {
+    const kind = isWorkspaceNodePackageKind(value.kind) ? value.kind : undefined;
+    const packagePath = isWorkspaceNodePackagePath(value.path)
+        ? value.path
+        : undefined;
+    let sourceFiles = [];
+    if (kind === undefined) {
         issues.push({
             path: `${pathPrefix}.kind`,
             message: "workspace-node-packages package kind must be hono-api or vue-app",
         });
     }
-    if (value.path !== "apps/api" && value.path !== "apps/web") {
+    if (packagePath === undefined) {
         issues.push({
             path: `${pathPrefix}.path`,
             message: "workspace-node-packages package path must be apps/api or apps/web",
@@ -646,12 +720,17 @@ function parseWorkspaceNodePackage(value, pathPrefix) {
             message: "workspace-node-packages package sourceFiles must be a non-empty array",
         });
     }
-    else if (value.sourceFiles.length === 0 ||
-        !value.sourceFiles.every(isNonEmptyString)) {
-        issues.push({
-            path: `${pathPrefix}.sourceFiles`,
-            message: "workspace-node-packages package sourceFiles must be a non-empty array of paths",
-        });
+    else {
+        const parsedSourceFiles = nonEmptyStringArray(value.sourceFiles);
+        if (parsedSourceFiles === undefined) {
+            issues.push({
+                path: `${pathPrefix}.sourceFiles`,
+                message: "workspace-node-packages package sourceFiles must be a non-empty array of paths",
+            });
+        }
+        else {
+            sourceFiles = parsedSourceFiles;
+        }
     }
     const allowedKeys = new Set(["kind", "path", "sourceFiles"]);
     for (const key of Object.keys(value)) {
@@ -665,10 +744,13 @@ function parseWorkspaceNodePackage(value, pathPrefix) {
     if (issues.length > 0) {
         return issues;
     }
+    if (kind === undefined || packagePath === undefined) {
+        throw new Error(`workspace-node-packages package validation failed without diagnostics at ${pathPrefix}`);
+    }
     return {
-        kind: value.kind,
-        path: value.path,
-        sourceFiles: value.sourceFiles,
+        kind,
+        path: packagePath,
+        sourceFiles,
     };
 }
 function parseWorkspaceNodePackageLinks(value, pathPrefix, declaredPackagePaths, issues) {
@@ -733,6 +815,7 @@ function parseWorkspaceNodePackageLinks(value, pathPrefix, declaredPackagePaths,
 }
 function parseRustBinaryWorkspaceCapability(capability, pathPrefix) {
     const issues = [];
+    let sourceFiles = [];
     if (capability.workspacePackageGlob !== "packages/*") {
         issues.push({
             path: `${pathPrefix}.workspacePackageGlob`,
@@ -745,12 +828,17 @@ function parseRustBinaryWorkspaceCapability(capability, pathPrefix) {
             message: "rust-binary-workspace sourceFiles must be a non-empty array",
         });
     }
-    else if (capability.sourceFiles.length === 0 ||
-        !capability.sourceFiles.every(isNonEmptyString)) {
-        issues.push({
-            path: `${pathPrefix}.sourceFiles`,
-            message: "rust-binary-workspace sourceFiles must be a non-empty array of paths",
-        });
+    else {
+        const parsedSourceFiles = nonEmptyStringArray(capability.sourceFiles);
+        if (parsedSourceFiles === undefined) {
+            issues.push({
+                path: `${pathPrefix}.sourceFiles`,
+                message: "rust-binary-workspace sourceFiles must be a non-empty array of paths",
+            });
+        }
+        else {
+            sourceFiles = parsedSourceFiles;
+        }
     }
     if (issues.length > 0) {
         return issues;
@@ -758,7 +846,7 @@ function parseRustBinaryWorkspaceCapability(capability, pathPrefix) {
     return {
         kind: "rust-binary-workspace",
         workspacePackageGlob: "packages/*",
-        sourceFiles: capability.sourceFiles,
+        sourceFiles,
     };
 }
 function duplicateCapabilityIssues(capabilities) {
@@ -860,19 +948,16 @@ function blueprintPackagesForCapabilities(capabilities, packageScope, projectNam
         return [];
     });
 }
-function stateForProjectionDeclaration(declaration) {
+function stateForProjectionDeclaration(declaration, sourceRoots) {
     const validation = validateProjectionCapabilities(declaration);
     if (!validation.ok) {
         throw new Error(`Projection Declaration is invalid:\n${validation.issues
             .map((issue) => `  - ${issue.path}: ${issue.message}`)
             .join("\n")}`);
     }
-    const state = createProjectionCompositionState();
+    const state = createProjectionCompositionState(sourceRoots);
     for (const capability of validation.value.capabilities) {
-        capabilityInterpreters[capability.kind].contribute({
-            capability: capability,
-            state,
-        });
+        contributeProjectionCapability(capability, state);
     }
     return state;
 }
@@ -896,6 +981,9 @@ function packageAdditionCapabilityForState(presetName, state) {
             throw new Error(`Preset ${presetName} is an initialization-only workspace and cannot be used for Package Addition`);
         }
         const nodePackage = state.nodeWorkspace.packages[0];
+        if (nodePackage === undefined) {
+            throw new Error(`Preset ${presetName} must declare one package for Package Addition`);
+        }
         return {
             sourcePreset: nodePackage.kind,
             workspacePackageGlob: state.nodeWorkspace.workspacePackageGlob,
@@ -1004,19 +1092,15 @@ function libraryPackageAdditionOperations(options) {
 }
 function libraryTsconfigJson() {
     return {
-        compilerOptions: {
+        compilerOptions: strictTypeScriptCompilerOptions({
             composite: true,
             declaration: true,
             declarationMap: true,
-            module: "NodeNext",
-            moduleResolution: "NodeNext",
-            noEmitOnError: true,
+            module: "nodenext",
+            moduleResolution: "nodenext",
             rootDir: "src",
-            skipLibCheck: false,
-            strict: true,
-            target: "ES2022",
             types: ["node"],
-        },
+        }),
         include: ["src/**/*.ts"],
     };
 }
@@ -1168,7 +1252,11 @@ function hasVuePackage(capability) {
 }
 function sourceRootPreset(capability) {
     if (capability.packages.length === 1) {
-        return capability.packages[0].kind;
+        const nodePackage = capability.packages[0];
+        if (nodePackage === undefined) {
+            throw new Error("Node package workspace must contain one package");
+        }
+        return nodePackage.kind;
     }
     return "vue-hono-app";
 }
@@ -1318,6 +1406,7 @@ function honoApiPackageJson(context, packageName, scripts, exposureFields) {
             "@types/node": "catalog:",
             oxfmt: "catalog:",
             oxlint: "catalog:",
+            "oxlint-tsgolint": "catalog:",
             "tsc-alias": "catalog:",
             ...(scripts.dev === undefined ? {} : { tsx: "catalog:" }),
             typescript: "catalog:",
@@ -1359,6 +1448,7 @@ function vuePackageJson(context, packageName, scripts, packageLinkDependencies =
             "@vue/tsconfig": "catalog:",
             oxfmt: "catalog:",
             oxlint: "catalog:",
+            "oxlint-tsgolint": "catalog:",
             tailwindcss: "catalog:",
             typescript: "catalog:",
             vite: "catalog:",
@@ -1371,7 +1461,7 @@ function vuePackageJson(context, packageName, scripts, packageLinkDependencies =
     };
 }
 function catalogDependencies(dependencies) {
-    return Object.fromEntries([...dependencies].sort().map((dependency) => [dependency, "catalog:"]));
+    return Object.fromEntries([...dependencies].toSorted().map((dependency) => [dependency, "catalog:"]));
 }
 function generationRecord(context) {
     return {
@@ -1783,8 +1873,8 @@ function nodePackageScripts(nodePackage, workspace) {
     const oxcScripts = {
         "format:check": "oxfmt --check --config ../../oxfmt.config.ts .",
         "format:write": "oxfmt --write --config ../../oxfmt.config.ts .",
-        lint: "oxlint --config ../../oxlint.config.ts . --deny-warnings",
-        "lint:fix": "oxlint --config ../../oxlint.config.ts . --fix --deny-warnings",
+        lint: "oxlint --config ../../oxlint.config.ts .",
+        "lint:fix": "oxlint --config ../../oxlint.config.ts . --fix",
     };
     if (nodePackage.kind === "hono-api") {
         const checks = {
@@ -1854,19 +1944,15 @@ function nodePackageTsconfigOperations(nodePackage, workspace) {
                 kind: "writeJson",
                 to: `${nodePackage.path}/tsconfig.json`,
                 value: {
-                    compilerOptions: {
+                    compilerOptions: strictTypeScriptCompilerOptions({
                         composite: true,
                         ...(workspace.packages.length > 1
                             ? { declaration: true, declarationMap: true }
                             : {}),
-                        module: "NodeNext",
-                        moduleResolution: "NodeNext",
-                        noEmitOnError: true,
-                        skipLibCheck: false,
-                        strict: true,
-                        target: "ES2022",
+                        module: "nodenext",
+                        moduleResolution: "nodenext",
                         types: ["node", "vitest/globals"],
-                    },
+                    }),
                     include: ["src/**/*.ts", "test/**/*.ts", "vitest.config.ts"],
                 },
             },
@@ -1903,17 +1989,13 @@ function nodePackageTsconfigOperations(nodePackage, workspace) {
             to: `${nodePackage.path}/tsconfig.app.json`,
             value: {
                 extends: "@vue/tsconfig/tsconfig.dom.json",
-                compilerOptions: {
+                compilerOptions: strictTypeScriptCompilerOptions({
                     composite: true,
                     module: "ESNext",
                     moduleResolution: "Bundler",
-                    noEmitOnError: true,
-                    skipLibCheck: false,
-                    strict: true,
-                    target: "ES2022",
                     tsBuildInfoFile: "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
                     types: ["web-bluetooth"],
-                },
+                }),
                 include: ["env.d.ts", "src/**/*.ts", "src/**/*.vue"],
             },
         },
@@ -1934,21 +2016,17 @@ function nodePackageTsconfigOperations(nodePackage, workspace) {
             kind: "writeJson",
             to: `${nodePackage.path}/tsconfig.node.json`,
             value: {
-                compilerOptions: {
+                compilerOptions: strictTypeScriptCompilerOptions({
                     composite: true,
                     module: "ESNext",
                     moduleResolution: "Bundler",
-                    noEmitOnError: true,
                     lib: ["ESNext", "DOM", "DOM.Iterable"],
                     ...(workspace.packages.length > 1
                         ? { outDir: "./node_modules/.tmp/tsconfig.node" }
                         : {}),
-                    skipLibCheck: false,
-                    strict: true,
-                    target: "ES2022",
                     tsBuildInfoFile: "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
                     types: ["node"],
-                },
+                }),
                 include: ["playwright.config.ts", "vite.config.ts", "vitest.config.ts"],
             },
         },
@@ -2035,6 +2113,17 @@ function strictTypescriptOperations({ context, state, }) {
     if (state.package === undefined && state.nodeWorkspace === undefined) {
         throw new Error("strict-typescript-root requires a workspace package layout");
     }
+    const rootConfigTsconfigOperation = () => {
+        if (state.sourceRoots.sharedOxc === undefined) {
+            throw new Error("strict-typescript-root requires shared OXC source when rendering tsconfig.config.json");
+        }
+        return {
+            kind: "copyFile",
+            from: "tsconfig.config.json",
+            to: "tsconfig.config.json",
+            sourceRoot: "sharedOxc",
+        };
+    };
     if (state.nodeWorkspace !== undefined) {
         return [
             {
@@ -2045,21 +2134,7 @@ function strictTypescriptOperations({ context, state, }) {
                     references: rootTsconfigReferences(state.nodeWorkspace),
                 },
             },
-            {
-                kind: "writeJson",
-                to: "tsconfig.config.json",
-                value: {
-                    compilerOptions: {
-                        module: "NodeNext",
-                        moduleResolution: "NodeNext",
-                        noEmitOnError: true,
-                        skipLibCheck: false,
-                        strict: true,
-                        target: "ES2022",
-                    },
-                    include: ["oxlint.config.ts", "oxfmt.config.ts"],
-                },
-            },
+            rootConfigTsconfigOperation(),
         ];
     }
     const libraryPackage = state.package;
@@ -2071,40 +2146,11 @@ function strictTypescriptOperations({ context, state, }) {
                 files: [],
             },
         },
-        {
-            kind: "writeJson",
-            to: "tsconfig.config.json",
-            value: {
-                compilerOptions: {
-                    module: "NodeNext",
-                    moduleResolution: "NodeNext",
-                    noEmitOnError: true,
-                    skipLibCheck: false,
-                    strict: true,
-                    target: "ES2022",
-                },
-                include: ["oxlint.config.ts", "oxfmt.config.ts"],
-            },
-        },
+        rootConfigTsconfigOperation(),
         {
             kind: "writeJson",
             to: `${workspacePackagePath(context, libraryPackage)}/tsconfig.json`,
-            value: {
-                compilerOptions: {
-                    composite: true,
-                    declaration: true,
-                    declarationMap: true,
-                    module: "NodeNext",
-                    moduleResolution: "NodeNext",
-                    noEmitOnError: true,
-                    rootDir: "src",
-                    skipLibCheck: false,
-                    strict: true,
-                    target: "ES2022",
-                    types: ["node"],
-                },
-                include: ["src/**/*.ts"],
-            },
+            value: libraryTsconfigJson(),
         },
     ];
 }
@@ -2193,15 +2239,9 @@ function githubMaintenanceOperations() {
         },
     ];
 }
-function templateSourceRoot(sourcePreset) {
-    return templateSourceRootForPreset(sourcePreset);
-}
-function templateSourceRootForPreset(sourcePreset) {
-    return packageTemplateRoot(path.dirname(fileURLToPath(import.meta.url)), sourcePreset);
-}
-function sharedOxcSourceRoot() {
-    return packageTemplateRoot(path.dirname(fileURLToPath(import.meta.url)), "shared", "oxc");
+function templateSourceRoot(state, sourcePreset) {
+    return templateSourceRootForPreset(state, sourcePreset);
 }
-function sharedDevcontainerSourceRoot() {
-    return packageTemplateRoot(path.dirname(fileURLToPath(import.meta.url)), "shared", "devcontainer");
+function templateSourceRootForPreset(state, sourcePreset) {
+    return state.projectionSourceRoots.preset(sourcePreset);
 }