@ykdz/template 0.0.8 → 0.0.9

package/node_modules/@ykdz/template-core/dist/projection-capabilities.js

@@ -15,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: ".",
@@ -71,6 +73,24 @@ 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",
@@ -205,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);
@@ -244,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 {
@@ -274,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}`,
@@ -282,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)) {
@@ -358,10 +426,7 @@ export function interpretPresetProjectionDeclaration(options) {
     }
     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,
@@ -405,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],
     };
@@ -502,11 +568,29 @@ function createProjectionCompositionState(sourceRoots) {
 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))
@@ -517,6 +601,7 @@ function unknownCapabilityPropertyIssues(capability, pathPrefix) {
 }
 function parseWorkspaceLibraryPackageCapability(capability, pathPrefix) {
     const issues = [];
+    let sourceFiles = [];
     if (capability.workspacePackageGlob !== "packages/*") {
         issues.push({
             path: `${pathPrefix}.workspacePackageGlob`,
@@ -541,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;
@@ -556,7 +646,7 @@ function parseWorkspaceLibraryPackageCapability(capability, pathPrefix) {
         workspacePackageGlob: "packages/*",
         packageRole: "shared-library",
         packageSourcePreset: "ts-lib",
-        sourceFiles: capability.sourceFiles,
+        sourceFiles,
     };
 }
 function parseWorkspaceNodePackagesCapability(capability, pathPrefix) {
@@ -607,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",
@@ -625,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)) {
@@ -644,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) {
@@ -712,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`,
@@ -724,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;
@@ -737,7 +846,7 @@ function parseRustBinaryWorkspaceCapability(capability, pathPrefix) {
     return {
         kind: "rust-binary-workspace",
         workspacePackageGlob: "packages/*",
-        sourceFiles: capability.sourceFiles,
+        sourceFiles,
     };
 }
 function duplicateCapabilityIssues(capabilities) {
@@ -848,10 +957,7 @@ function stateForProjectionDeclaration(declaration, sourceRoots) {
     }
     const state = createProjectionCompositionState(sourceRoots);
     for (const capability of validation.value.capabilities) {
-        capabilityInterpreters[capability.kind].contribute({
-            capability: capability,
-            state,
-        });
+        contributeProjectionCapability(capability, state);
     }
     return state;
 }
@@ -875,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,
@@ -983,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"],
     };
 }
@@ -1147,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";
 }
@@ -1297,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:",
@@ -1338,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:",
@@ -1350,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 {
@@ -1762,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 = {
@@ -1833,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"],
                 },
             },
@@ -1882,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"],
             },
         },
@@ -1913,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"],
             },
         },
@@ -2014,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 [
             {
@@ -2024,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;
@@ -2050,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(),
         },
     ];
 }

package/node_modules/@ykdz/template-core/dist/renderer.d.ts

@@ -50,9 +50,9 @@ export type ReplaceAnchorsOperation = {
 export type RenderOperation = CopyFileOperation | WriteJsonOperation | MergeJsonOperation | WriteTextOperation | WriteTextFromFragmentsOperation | WriteTextTemplateOperation | SetExecutableOperation | ReplaceAnchorsOperation;
 export type RenderProjectOptions = {
     sourceRoot: string;
-    sourceRoots?: Record<string, string>;
+    sourceRoots?: Record<string, string> | undefined;
     targetRoot: string;
-    variables?: RenderVariables;
+    variables?: RenderVariables | undefined;
     operations: RenderOperation[];
 };
 export declare function renderProject(options: RenderProjectOptions): Promise<void>;

package/node_modules/@ykdz/template-core/dist/renderer.js

@@ -65,7 +65,7 @@ function serializeJsonValue(value, indentation, pathSegments, multilineArrays, r
     if (!isRecord(value)) {
         return JSON.stringify(value);
     }
-    const entries = Object.entries(value).sort(([left], [right]) => compareJsonKeys(left, right, pathSegments, rootKeyOrder));
+    const entries = Object.entries(value).toSorted(([left], [right]) => compareJsonKeys(left, right, pathSegments, rootKeyOrder));
     if (entries.length === 0) {
         return "{}";
     }
@@ -325,7 +325,7 @@ async function findTypeScriptAnchorRanges(sourceText) {
 }
 function replaceRanges(sourceText, ranges, replacements) {
     let nextText = sourceText;
-    for (const range of [...ranges].sort((a, b) => b.start - a.start)) {
+    for (const range of ranges.toSorted((a, b) => b.start - a.start)) {
         const replacement = replacements[range.name];
         if (replacement === undefined) {
             continue;

package/node_modules/@ykdz/template-core/dist/template-boundary-check.d.ts

@@ -18,7 +18,7 @@ export type TemplateBoundaryCheckProjection = {
     readonly sourceFilePath: string;
     readonly plan: {
         readonly sourceRoot: string;
-        readonly sourceRoots?: Record<string, string>;
+        readonly sourceRoots?: Record<string, string> | undefined;
         readonly operations: readonly RenderOperation[];
     };
 };

package/node_modules/@ykdz/template-core/dist/template-boundary-check.js

@@ -233,14 +233,12 @@ function jsonValuesEqual(left, right) {
         return false;
     }
     const leftEntries = Object.entries(left);
-    const rightRecord = right;
-    const rightKeys = new Set(Object.keys(rightRecord));
-    return (leftEntries.length === rightKeys.size &&
+    const rightEntries = Object.entries(right);
+    const rightValues = new Map(rightEntries);
+    return (leftEntries.length === rightEntries.length &&
         leftEntries.every(([key, value]) => {
-            rightKeys.delete(key);
-            return jsonValuesEqual(value, rightRecord[key]);
-        }) &&
-        rightKeys.size === 0);
+            return (rightValues.has(key) && jsonValuesEqual(value, rightValues.get(key)));
+        }));
 }
 function expressionMatchesJsonValue(expression, expectedValue) {
     const literalValue = expressionLiteralJsonValue(expression);
@@ -383,12 +381,12 @@ function isStructuralTurboValue(value) {
     });
 }
 const rootTsconfigConfigCompilerOptions = {
-    module: "NodeNext",
-    moduleResolution: "NodeNext",
+    module: "nodenext",
+    moduleResolution: "nodenext",
     noEmitOnError: true,
     skipLibCheck: false,
     strict: true,
-    target: "ES2022",
+    target: "es2023",
 };
 const rootTsconfigConfigIncludes = new Set([
     "oxlint.config.ts",

package/node_modules/@ykdz/template-core/dist/toolchain-resolution.d.ts

@@ -14,15 +14,15 @@ export type ResolvedToolchainVersions = {
     readonly diagnostics: string[];
 };
 export type ResolveToolchainVersionsOptions = {
-    readonly source?: ToolchainResolutionSource | "auto";
-    readonly fetchJson?: (url: string) => Promise<unknown>;
-    readonly nodeReleaseIndexUrl?: string;
-    readonly pnpmRegistryUrl?: string;
+    readonly source?: ToolchainResolutionSource | "auto" | undefined;
+    readonly fetchJson?: ((url: string) => Promise<unknown>) | undefined;
+    readonly nodeReleaseIndexUrl?: string | undefined;
+    readonly pnpmRegistryUrl?: string | undefined;
 };
 export declare const nodeReleaseIndexUrl = "https://nodejs.org/dist/index.json";
 export declare const pnpmRegistryUrl = "https://registry.npmjs.org/pnpm";
 type OnlineToolchainResolutionContractOptions = {
-    readonly fetchJson?: (url: string) => Promise<unknown>;
+    readonly fetchJson?: ((url: string) => Promise<unknown>) | undefined;
 };
 export type OnlineToolchainResolutionContractResult = {
     readonly nodeLtsMajor: NodeLtsMajor;