@ykdz/template 0.0.35 → 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/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

@@ -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;
+};

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

@@ -1,6 +1,10 @@
 import { fileURLToPath } from "node:url";
+import { definePackageContributionReplayAdapter, } from "#template-core/preset-definition";
 import { typescriptConfigSourceOperation } from "../shared/typescript.js";
 import { templateSources } from "../template-sources.js";
+function packagePathForLeaf(packageLeafName) {
+    return `packages/${packageLeafName}`;
+}
 function packageScripts() {
     return {
         "format:check": "oxfmt --list-different --config ../../oxfmt.config.ts .",
@@ -16,27 +20,12 @@ function packageScripts() {
     };
 }
 function cliContribution(options) {
-    const definition = {
-        name: `@${options.context.scope}/${options.packageLeafName}`,
+    const definition = options.packageDefinition ?? {
+        name: `@${options.context.defaultPackageScope}/${options.packageLeafName}`,
         path: options.packagePath,
         role: "cli-tool",
     };
-    const exposure = {
-        exports: {
-            ".": {
-                source: "./src/main.ts",
-                types: "./dist/main.d.ts",
-                default: "./dist/main.js",
-            },
-        },
-        imports: {
-            "#main": {
-                source: "./src/main.ts",
-                types: "./src/main.ts",
-                default: "./dist/main.js",
-            },
-        },
-    };
+    const exposure = { exports: {}, imports: {} };
     const operations = [
         {
             kind: "writeJson",
@@ -71,16 +60,14 @@ function cliContribution(options) {
         {
             kind: "copyFile",
             source: templateSources.tsCli,
-            from: "src/main.ts",
-            to: `${definition.path}/src/main.ts`,
+            from: "src/cli-command-identity.ts",
+            to: `${definition.path}/src/cli-command-identity.ts`,
         },
         {
-            kind: "replaceAnchors",
-            path: `${definition.path}/src/main.ts`,
-            language: "typescript",
-            replacements: {
-                "cli-command-name": `const commandName = ${JSON.stringify(options.packageLeafName)};`,
-            },
+            kind: "copyFile",
+            source: templateSources.tsCli,
+            from: "src/main.ts",
+            to: `${definition.path}/src/main.ts`,
         },
         {
             kind: "copyFile",
@@ -91,16 +78,14 @@ function cliContribution(options) {
         {
             kind: "copyFile",
             source: templateSources.tsCli,
-            from: "test/integration/command.test.ts",
-            to: `${definition.path}/test/integration/command.test.ts`,
+            from: "test/unit/cli-command-identity.test.ts",
+            to: `${definition.path}/test/unit/cli-command-identity.test.ts`,
         },
         {
-            kind: "replaceAnchors",
-            path: `${definition.path}/test/integration/command.test.ts`,
-            language: "typescript",
-            replacements: {
-                "cli-test-command-name": `commandName = ${JSON.stringify(options.packageLeafName)};`,
-            },
+            kind: "copyFile",
+            source: templateSources.tsCli,
+            from: "test/integration/command.test.ts",
+            to: `${definition.path}/test/integration/command.test.ts`,
         },
         {
             kind: "copyFile",
@@ -126,12 +111,10 @@ function cliContribution(options) {
         exposure,
         manifest: {
             name: definition.name,
-            version: "0.0.0",
-            publishConfig: { access: "public" },
+            private: true,
             files: ["dist"],
             type: "module",
             bin: { [options.packageLeafName]: "./dist/cli.js" },
-            ...exposure,
             scripts: packageScripts(),
             dependencies: { commander: "catalog:" },
             devDependencies: {
@@ -147,8 +130,12 @@ function cliContribution(options) {
         operations,
         environmentNeeds: [],
         foundation: {
+            ...(options.publicationCandidate
+                ? { npmPublication: { kind: "public-cli-candidate" } }
+                : {}),
             toolchains: {},
             editorCapabilities: ["oxc-format-lint"],
+            typescriptConfigurationPackage: { dependency: "required" },
             dependencyMaintenance: {
                 ecosystems: ["npm", "github-actions", "docker"],
                 interval: "weekly",
@@ -156,37 +143,71 @@ function cliContribution(options) {
         },
     };
 }
+const cliPublicationCandidateReplayAdapter = definePackageContributionReplayAdapter({
+    identity: "cli-publication-candidate",
+    replay: ({ context, packageDefinition, packageLeafName, planningContribution, }) => {
+        if (planningContribution !== "planInitialization") {
+            throw new Error("cli-publication-candidate replay identity requires planInitialization provenance");
+        }
+        return cliContribution({
+            context,
+            packageLeafName,
+            packagePath: packageDefinition.path,
+            packageDefinition,
+            publicationCandidate: true,
+        });
+    },
+});
+const cliPackageAdditionReplayAdapter = definePackageContributionReplayAdapter({
+    identity: "cli-package-addition",
+    replay: ({ context, packageDefinition, packageLeafName, planningContribution, }) => {
+        if (planningContribution !== "planPackageAddition") {
+            throw new Error("cli-package-addition replay identity requires planPackageAddition provenance");
+        }
+        return cliContribution({
+            context,
+            packageLeafName,
+            packagePath: packageDefinition.path,
+            packageDefinition,
+            publicationCandidate: false,
+        });
+    },
+});
 export const tsCliDefinition = {
     metadata: {
         name: "ts-cli",
         title: "TypeScript CLI",
-        description: "Publishable TypeScript command-line package.",
+        description: "TypeScript command-line package.",
     },
     source: templateSources.tsCli,
     plannerSourceFile: fileURLToPath(import.meta.url),
-    blueprint(context) {
-        return {
-            schemaVersion: 2,
-            packages: [
-                cliContribution({
-                    context,
-                    packageLeafName: context.projectName,
-                    packagePath: `packages/${context.projectName}`,
-                }).definition,
-            ],
-        };
-    },
-    planInitialization(context) {
-        return cliContribution({
-            context,
-            packageLeafName: context.projectName,
-            packagePath: `packages/${context.projectName}`,
-        });
+    packageContributionReplayAdapters: [
+        cliPublicationCandidateReplayAdapter,
+        cliPackageAdditionReplayAdapter,
+    ],
+    initialPrimaryPackage: {
+        defaultLeafName: "cli",
+        role: "cli-tool",
+        defaultPackagePath: ({ packageLeafName }) => packagePathForLeaf(packageLeafName),
+        planInitialContribution({ context, resolvedPackageIdentity }) {
+            return cliPublicationCandidateReplayAdapter.identify(cliContribution({
+                context,
+                packageLeafName: resolvedPackageIdentity.leafName,
+                packagePath: resolvedPackageIdentity.definition.path,
+                packageDefinition: resolvedPackageIdentity.definition,
+                publicationCandidate: true,
+            }));
+        },
     },
     defaultPackagePath({ packageLeafName }) {
-        return `packages/${packageLeafName}`;
+        return packagePathForLeaf(packageLeafName);
     },
     planPackageAddition({ context, packageLeafName, packagePath }) {
-        return cliContribution({ context, packageLeafName, packagePath });
+        return cliPackageAdditionReplayAdapter.identify(cliContribution({
+            context,
+            packageLeafName,
+            packagePath,
+            publicationCandidate: false,
+        }));
     },
 };