@ykdz/template 0.0.33 → 0.0.36

package/node_modules/@ykdz/template-builtin-presets/dist/src/generation-record.d.ts

@@ -0,0 +1,24 @@
+import type { GenerationContext } from "#template-core/preset-definition";
+import type { PackageDefinitionId } from "#template-core/project-blueprint";
+export type GeneratedPackagePlanningRecord = {
+    readonly packageDefinitionId: PackageDefinitionId;
+    readonly path: string;
+    readonly definitionName: string;
+    readonly planningContribution: "foundationPlan" | "planInitialization" | "planPackageAddition";
+    readonly contributionIdentity: string;
+};
+export type GenerationRecord = {
+    readonly schemaVersion: 2;
+    readonly repositoryName: string;
+    readonly defaultPackageScope: string;
+    readonly preset: string;
+    readonly templateVersion: "0.0.0";
+    readonly toolchain: GenerationContext["toolchain"];
+    readonly packages: readonly GeneratedPackagePlanningRecord[];
+};
+/** Canonical durable Generation Record contract for a default npm scope. */
+export declare function isValidDefaultPackageScope(value: string): boolean;
+/** Strictly decodes the durable Record shape before semantic checks run. */
+export declare function decodeGenerationRecordStructure(value: unknown): GenerationRecord;
+/** Validates semantic invariants that are independent of a Project Blueprint. */
+export declare function parseGenerationRecord(value: unknown): GenerationRecord;

package/node_modules/@ykdz/template-builtin-presets/dist/src/generation-record.js

@@ -0,0 +1,154 @@
+import * as v from "valibot";
+import { isValidNodeLtsMajor, isValidPackageManagerPin, } from "#template-core/toolchain-resolution";
+/** Canonical durable Generation Record contract for a default npm scope. */
+export function isValidDefaultPackageScope(value) {
+    return /^[a-z0-9][a-z0-9._-]*$/.test(value);
+}
+function strictObjectMessage(issue, objectMessage) {
+    if (issue.path?.at(-1)?.origin !== "key")
+        return objectMessage;
+    const unknownKey = typeof issue.input === "string" ? issue.input : "<unknown>";
+    return `contains unknown Generation Record field; contains unknown field: ${unknownKey}`;
+}
+const packagePlanningRecordSchema = v.strictObject({
+    packageDefinitionId: v.string("packageDefinitionId must use the package-<sha256> format"),
+    path: v.string("path must be a non-empty string"),
+    definitionName: v.string("definitionName must be a non-empty string"),
+    planningContribution: v.picklist(["foundationPlan", "planInitialization", "planPackageAddition"], "planningContribution is unsupported"),
+    contributionIdentity: v.string("contributionIdentity must be a non-empty string"),
+}, (issue) => strictObjectMessage(issue, "package planning fact must be an object"));
+const generationRecordSchema = v.strictObject({
+    schemaVersion: v.literal(2, (issue) => `Unsupported Generation Record schema version ${String(issue.input)}; expected 2`),
+    repositoryName: v.string("repositoryName must be a non-empty string"),
+    defaultPackageScope: v.string("defaultPackageScope must be a valid npm scope"),
+    preset: v.string("preset must be a non-empty string"),
+    templateVersion: v.literal("0.0.0", "templateVersion must be 0.0.0"),
+    toolchain: v.strictObject({
+        nodeLtsMajor: v.string("toolchain.nodeLtsMajor must be a numeric Node major"),
+        packageManagerPin: v.string("toolchain.packageManagerPin must be an exact pnpm version pin"),
+    }, (issue) => strictObjectMessage(issue, "toolchain must be an object")),
+    packages: v.array(packagePlanningRecordSchema, "packages must be an array"),
+}, (issue) => strictObjectMessage(issue, "supported Generation Record must be an object"));
+function issuePath(issue) {
+    let result = "";
+    for (const item of issue.path ?? []) {
+        if (typeof item.key === "number") {
+            result += `[${item.key}]`;
+        }
+        else if (typeof item.key === "string") {
+            result += `${result.length === 0 ? "" : "."}${item.key}`;
+        }
+    }
+    return result;
+}
+const missingFieldMessages = new Map([
+    [
+        "schemaVersion",
+        "Unsupported Generation Record schema version undefined; expected 2",
+    ],
+    ["repositoryName", "repositoryName must be a non-empty string"],
+    ["defaultPackageScope", "defaultPackageScope must be a valid npm scope"],
+    ["preset", "preset must be a non-empty string"],
+    ["templateVersion", "templateVersion must be 0.0.0"],
+    ["toolchain", "toolchain must be an object"],
+    ["packages", "packages must be an array"],
+]);
+function missingFieldMessage(path, fallback) {
+    const exact = missingFieldMessages.get(path);
+    if (exact !== undefined)
+        return exact;
+    if (path.endsWith(".nodeLtsMajor")) {
+        return `${path} must be a numeric Node major`;
+    }
+    if (path.endsWith(".packageManagerPin")) {
+        return `${path} must be an exact pnpm version pin`;
+    }
+    if (path.endsWith(".packageDefinitionId")) {
+        return `${path} must use the package-<sha256> format`;
+    }
+    if (path.endsWith(".path") ||
+        path.endsWith(".definitionName") ||
+        path.endsWith(".contributionIdentity")) {
+        return `${path} must be a non-empty string`;
+    }
+    if (path.endsWith(".planningContribution")) {
+        return `${path} is unsupported`;
+    }
+    return fallback;
+}
+function structuralError(issues) {
+    return new Error(`Generation Record ${issues
+        .map((issue) => {
+        const path = issuePath(issue);
+        const last = issue.path?.at(-1);
+        if (issue.type === "strict_object" &&
+            last?.origin === "key" &&
+            issue.input !== undefined &&
+            !path.includes(".") &&
+            !path.includes("[")) {
+            const unknownKey = typeof issue.input === "string" ? issue.input : "<unknown>";
+            return `contains unknown field: ${unknownKey}; ${path}: contains unknown Generation Record field`;
+        }
+        let message = issue.message;
+        if (issue.type === "strict_object" &&
+            last?.origin === "key" &&
+            issue.input === undefined) {
+            message = missingFieldMessage(path, message);
+        }
+        const normalizedPath = path.length === 0 ? "." : path;
+        return message.startsWith(normalizedPath)
+            ? message
+            : `${normalizedPath}: ${message}`;
+    })
+        .join("; ")}`);
+}
+/** Strictly decodes the durable Record shape before semantic checks run. */
+export function decodeGenerationRecordStructure(value) {
+    const parsed = v.safeParse(generationRecordSchema, value);
+    if (!parsed.success)
+        throw structuralError(parsed.issues);
+    return parsed.output;
+}
+/** Validates semantic invariants that are independent of a Project Blueprint. */
+export function parseGenerationRecord(value) {
+    const record = decodeGenerationRecordStructure(value);
+    const issues = [];
+    if (record.repositoryName.length === 0 ||
+        record.repositoryName !== record.repositoryName.trim()) {
+        issues.push("repositoryName must be a non-empty string");
+    }
+    if (!isValidDefaultPackageScope(record.defaultPackageScope)) {
+        issues.push("defaultPackageScope must be a valid npm scope");
+    }
+    if (record.preset.length === 0 || record.preset !== record.preset.trim()) {
+        issues.push("preset must be a non-empty string");
+    }
+    if (!isValidNodeLtsMajor(record.toolchain.nodeLtsMajor)) {
+        issues.push("toolchain.nodeLtsMajor must be a numeric Node major");
+    }
+    if (!isValidPackageManagerPin(record.toolchain.packageManagerPin)) {
+        issues.push("toolchain.packageManagerPin must be an exact pnpm version pin");
+    }
+    for (const [index, item] of record.packages.entries()) {
+        if (!/^package-[a-f0-9]{64}$/.test(item.packageDefinitionId)) {
+            issues.push(`packages[${index}].packageDefinitionId must use the package-<sha256> format`);
+        }
+        if (item.path.length === 0) {
+            issues.push(`packages[${index}].path must be a non-empty string`);
+        }
+        if (item.definitionName.length === 0) {
+            issues.push(`packages[${index}].definitionName must be a non-empty string`);
+        }
+        if (item.contributionIdentity.length === 0) {
+            issues.push(`packages[${index}].contributionIdentity must be a non-empty string`);
+        }
+    }
+    const packageDefinitionIds = record.packages.map((item) => item.packageDefinitionId);
+    if (new Set(packageDefinitionIds).size !== packageDefinitionIds.length) {
+        issues.push("packages packageDefinitionId must be unique");
+    }
+    if (issues.length > 0) {
+        throw new Error(`Generation Record ${issues.join("; ")}`);
+    }
+    return record;
+}

package/node_modules/@ykdz/template-builtin-presets/dist/src/index.d.ts

@@ -1,3 +1,3 @@
-export { builtInPresetRegistry, builtInPresetTemplateSourceCheckContexts, builtInPresetTemplateSourceContexts, createGenerationContext, planGeneratedRepositoryInitialization, planGeneratedRepositoryPackageAddition, resolveBuiltInTemplateSource, validateProjectBlueprintV2, } from "./foundation.ts";
+export { builtInPresetRegistry, createGenerationContext, loadLocalTemplateMetadata, prepareGeneratedRepositoryInitialization, planGeneratedRepositoryInitialization, planGeneratedRepositoryPackageAddition, resolveBuiltInTemplateSource, validateProjectBlueprint, } from "./foundation.ts";
 export { templateSources } from "./template-sources.ts";
-export type { BuiltInPresetDefinition, BuiltInPresetTemplateSourceCheckContext, GeneratedRepositoryPlan, PackageContribution, ProjectBlueprintV2, BuiltInGenerationContext, } from "./foundation.ts";
+export type { BuiltInPresetDefinition, GeneratedRepositoryPlan, PackageContribution, ProjectBlueprint, BuiltInGenerationContext, LocalTemplateMetadata, InitializationIdentityOverrides, PublicationSetupHandoff, ResolvedInitialization, } from "./foundation.ts";

package/node_modules/@ykdz/template-builtin-presets/dist/src/index.js

@@ -1,2 +1,2 @@
-export { builtInPresetRegistry, builtInPresetTemplateSourceCheckContexts, builtInPresetTemplateSourceContexts, createGenerationContext, planGeneratedRepositoryInitialization, planGeneratedRepositoryPackageAddition, resolveBuiltInTemplateSource, validateProjectBlueprintV2, } from "./foundation.js";
+export { builtInPresetRegistry, createGenerationContext, loadLocalTemplateMetadata, prepareGeneratedRepositoryInitialization, planGeneratedRepositoryInitialization, planGeneratedRepositoryPackageAddition, resolveBuiltInTemplateSource, validateProjectBlueprint, } from "./foundation.js";
 export { templateSources } from "./template-sources.js";

package/node_modules/@ykdz/template-builtin-presets/dist/src/rust-bin/definition.d.ts

@@ -1,2 +1,31 @@
-import type { BuiltInPresetDefinition } from "#template-core/preset-definition";
-export declare const rustBinDefinition: BuiltInPresetDefinition;
+import { type GenerationContext } from "#template-core/preset-definition";
+export declare const rustBinDefinition: {
+    metadata: {
+        name: string;
+        title: string;
+        description: string;
+    };
+    source: import("@ykdz/template-core/renderer").TemplateSourceHandle;
+    plannerSourceFile: string;
+    packageContributionReplayAdapters: import("@ykdz/template-core/preset-definition").PackageContributionReplayAdapter[];
+    initialPrimaryPackage: {
+        defaultLeafName: string;
+        role: "native-package";
+        defaultPackagePath: ({ packageLeafName }: {
+            readonly packageLeafName: string;
+        }) => string;
+        planInitialContribution({ context, resolvedPackageIdentity }: {
+            readonly context: GenerationContext;
+            readonly resolvedPackageIdentity: import("@ykdz/template-core/preset-definition").ResolvedPrimaryPackageIdentity;
+        }): import("@ykdz/template-core/preset-definition").PlannedPackageContribution;
+    };
+    defaultPackagePath({ packageLeafName }: {
+        readonly context: GenerationContext;
+        readonly packageLeafName: string;
+    }): string;
+    planPackageAddition({ context, packageLeafName, packagePath }: {
+        readonly context: GenerationContext;
+        readonly packageLeafName: string;
+        readonly packagePath: string;
+    }): import("@ykdz/template-core/preset-definition").PlannedPackageContribution;
+};

package/node_modules/@ykdz/template-builtin-presets/dist/src/rust-bin/definition.js

@@ -1,14 +1,9 @@
 import { fileURLToPath } from "node:url";
 import { rustToolchainEnvironmentNeed } from "#template-core/module-graph";
+import { definePackageContributionReplayAdapter, } from "#template-core/preset-definition";
 import { templateSources } from "../template-sources.js";
-function cargoPackageName(projectName) {
-    const slug = projectName
-        .normalize("NFKD")
-        .replace(/[\u0300-\u036f]/g, "")
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "");
-    return slug || "rust-bin";
+function packagePathForLeaf(packageLeafName) {
+    return `packages/${packageLeafName}`;
 }
 function packageScripts() {
     return {
@@ -19,8 +14,8 @@ function packageScripts() {
     };
 }
 function rustContribution(options) {
-    const definition = {
-        name: `@${options.context.scope}/${options.packageLeafName}`,
+    const definition = options.packageDefinition ?? {
+        name: `@${options.context.defaultPackageScope}/${options.packageLeafName}`,
         path: options.packagePath,
         role: "native-package",
     };
@@ -64,7 +59,6 @@ function rustContribution(options) {
         exposure: { exports: {}, imports: {} },
         manifest: {
             name: definition.name,
-            version: "0.0.0",
             private: true,
             scripts: packageScripts(),
             engines: { node: options.context.toolchain.nodeLtsMajor },
@@ -133,6 +127,15 @@ function rustContribution(options) {
         },
     };
 }
+const binaryReplayAdapter = definePackageContributionReplayAdapter({
+    identity: "binary",
+    replay: ({ context, packageDefinition, packageLeafName }) => rustContribution({
+        context,
+        packageLeafName,
+        packagePath: packageDefinition.path,
+        packageDefinition,
+    }),
+});
 export const rustBinDefinition = {
     metadata: {
         name: "rust-bin",
@@ -141,31 +144,24 @@ export const rustBinDefinition = {
     },
     source: templateSources.rustBin,
     plannerSourceFile: fileURLToPath(import.meta.url),
-    blueprint(context) {
-        const packageLeafName = cargoPackageName(context.projectName);
-        return {
-            schemaVersion: 2,
-            packages: [
-                rustContribution({
-                    context,
-                    packageLeafName,
-                    packagePath: `packages/${packageLeafName}`,
-                }).definition,
-            ],
-        };
-    },
-    planInitialization(context) {
-        const packageLeafName = cargoPackageName(context.projectName);
-        return rustContribution({
-            context,
-            packageLeafName,
-            packagePath: `packages/${packageLeafName}`,
-        });
+    packageContributionReplayAdapters: [binaryReplayAdapter],
+    initialPrimaryPackage: {
+        defaultLeafName: "app",
+        role: "native-package",
+        defaultPackagePath: ({ packageLeafName }) => packagePathForLeaf(packageLeafName),
+        planInitialContribution({ context, resolvedPackageIdentity }) {
+            return binaryReplayAdapter.identify(rustContribution({
+                context,
+                packageLeafName: resolvedPackageIdentity.leafName,
+                packagePath: resolvedPackageIdentity.definition.path,
+                packageDefinition: resolvedPackageIdentity.definition,
+            }));
+        },
     },
     defaultPackagePath({ packageLeafName }) {
-        return `packages/${packageLeafName}`;
+        return packagePathForLeaf(packageLeafName);
     },
     planPackageAddition({ context, packageLeafName, packagePath }) {
-        return rustContribution({ context, packageLeafName, packagePath });
+        return binaryReplayAdapter.identify(rustContribution({ context, packageLeafName, packagePath }));
     },
 };

package/node_modules/@ykdz/template-builtin-presets/dist/src/shared/development-container.d.ts

@@ -1,2 +1,3 @@
 import type { DevelopmentContainerToolLayer } from "#template-core/development-container-tool-layer";
+export declare function githubCliDevelopmentContainerToolLayer(): DevelopmentContainerToolLayer;
 export declare function browserTestDevelopmentContainerToolLayer(): DevelopmentContainerToolLayer;

package/node_modules/@ykdz/template-builtin-presets/dist/src/shared/development-container.js

@@ -1,5 +1,22 @@
 import { loadTemplateDependencyCatalog } from "#template-core/dependency-catalog";
 import { templateSources } from "../template-sources.js";
+export function githubCliDevelopmentContainerToolLayer() {
+    return {
+        identity: "github-cli",
+        dockerfile: {
+            source: templateSources.sharedDevcontainer,
+            from: "github-cli.Dockerfile",
+        },
+        requires: ["node-pnpm"],
+        probes: [
+            {
+                identity: "github-cli",
+                command: "gh",
+                args: ["--version"],
+            },
+        ],
+    };
+}
 export function browserTestDevelopmentContainerToolLayer() {
     const playwrightTestVersion = loadTemplateDependencyCatalog()["@playwright/test"];
     if (playwrightTestVersion === undefined) {

package/node_modules/@ykdz/template-builtin-presets/dist/src/shared/typescript.d.ts

@@ -1,6 +1,6 @@
 import type { PackageContribution } from "#template-core/package-contribution";
-import type { GenerationContext } from "#template-core/preset-definition";
-import type { PackageDefinition } from "#template-core/project-blueprint-v2";
+import { type GenerationContext } from "#template-core/preset-definition";
+import type { PackageDefinition } from "#template-core/project-blueprint";
 import type { RenderOperation, TemplateSourceHandle } from "#template-core/renderer";
 export declare function typescriptConfigPackageName(context: GenerationContext): string;
 export declare function typescriptConfigPackageDefinition(context: GenerationContext): PackageDefinition;
@@ -10,4 +10,5 @@ export declare function typescriptConfigSourceOperation(options: {
     readonly from: string;
     readonly to: string;
 }): RenderOperation;
-export declare function typescriptConfigContribution(context: GenerationContext): PackageContribution;
+export declare function typescriptConfigContribution(context: GenerationContext, definition?: PackageDefinition): PackageContribution;
+export declare const typescriptConfigReplayAdapter: import("@ykdz/template-core/preset-definition").PackageContributionReplayAdapter;

package/node_modules/@ykdz/template-builtin-presets/dist/src/shared/typescript.js

@@ -1,6 +1,8 @@
+import { definePackageContributionReplayAdapter, } from "#template-core/preset-definition";
 import { templateSources } from "../template-sources.js";
+const typescriptConfigPackageReplacement = "TYPESCRIPT_CONFIG_PACKAGE";
 export function typescriptConfigPackageName(context) {
-    return `@${context.scope}/typescript-config`;
+    return context.foundationPackages.typescriptConfiguration.name;
 }
 export function typescriptConfigPackageDefinition(context) {
     return {
@@ -16,18 +18,16 @@ export function typescriptConfigSourceOperation(options) {
         from: options.from,
         to: options.to,
         replacements: {
-            TYPESCRIPT_CONFIG_PACKAGE: typescriptConfigPackageName(options.context),
+            [typescriptConfigPackageReplacement]: typescriptConfigPackageName(options.context),
         },
     };
 }
-export function typescriptConfigContribution(context) {
-    const definition = typescriptConfigPackageDefinition(context);
+export function typescriptConfigContribution(context, definition = typescriptConfigPackageDefinition(context)) {
     return {
         definition,
         exposure: { exports: {}, imports: {} },
         manifest: {
             name: definition.name,
-            version: "0.0.0",
             private: true,
             files: ["base.json"],
             scripts: {
@@ -68,3 +68,7 @@ export function typescriptConfigContribution(context) {
         },
     };
 }
+export const typescriptConfigReplayAdapter = definePackageContributionReplayAdapter({
+    identity: "typescript-config",
+    replay: ({ context, packageDefinition }) => typescriptConfigContribution(context, packageDefinition),
+});

package/node_modules/@ykdz/template-builtin-presets/dist/src/shared/vue.d.ts

@@ -1,6 +1,6 @@
 import type { PackageContribution } from "#template-core/package-contribution";
 import type { GenerationContext } from "#template-core/preset-definition";
-import type { PackageDefinition } from "#template-core/project-blueprint-v2";
+import type { PackageDefinition } from "#template-core/project-blueprint";
 import type { RenderOperation } from "#template-core/renderer";
 /** Vue's tooling peers need these repository policy overrides, never Core defaults. */
 export declare const vuePnpmDependencyOverrides: {

package/node_modules/@ykdz/template-builtin-presets/dist/src/shared/vue.js

@@ -32,7 +32,7 @@ export function vueApplicationScripts() {
         "lint:fix": "oxlint --format=unix --config ../../oxlint.config.ts . --fix",
         preview: "vite preview",
         test: "vitest run --reporter=agent --silent=passed-only",
-        "test:e2e": "node --conditions=source scripts/run-playwright.ts",
+        "test:e2e": "playwright test",
     };
 }
 export function sharedVueSourceOperations(context, packagePath) {
@@ -76,7 +76,6 @@ export function vueApplicationDevelopmentContainerToolLayers() {
 export function vueApplicationManifest(options) {
     return {
         name: options.definition.name,
-        version: "0.0.0",
         private: true,
         type: "module",
         ...vueApplicationExposure,

package/node_modules/@ykdz/template-builtin-presets/dist/src/ts-cli/definition.d.ts

@@ -1,2 +1,31 @@
-import type { BuiltInPresetDefinition } from "#template-core/preset-definition";
-export declare const tsCliDefinition: BuiltInPresetDefinition;
+import { type GenerationContext } from "#template-core/preset-definition";
+export declare const tsCliDefinition: {
+    metadata: {
+        name: string;
+        title: string;
+        description: string;
+    };
+    source: import("@ykdz/template-core/renderer").TemplateSourceHandle;
+    plannerSourceFile: string;
+    packageContributionReplayAdapters: import("@ykdz/template-core/preset-definition").PackageContributionReplayAdapter[];
+    initialPrimaryPackage: {
+        defaultLeafName: string;
+        role: "cli-tool";
+        defaultPackagePath: ({ packageLeafName }: {
+            readonly packageLeafName: string;
+        }) => string;
+        planInitialContribution({ context, resolvedPackageIdentity }: {
+            readonly context: GenerationContext;
+            readonly resolvedPackageIdentity: import("@ykdz/template-core/preset-definition").ResolvedPrimaryPackageIdentity;
+        }): import("@ykdz/template-core/preset-definition").PlannedPackageContribution;
+    };
+    defaultPackagePath({ packageLeafName }: {
+        readonly context: GenerationContext;
+        readonly packageLeafName: string;
+    }): string;
+    planPackageAddition({ context, packageLeafName, packagePath }: {
+        readonly context: GenerationContext;
+        readonly packageLeafName: string;
+        readonly packagePath: string;
+    }): import("@ykdz/template-core/preset-definition").PlannedPackageContribution;
+};