@ykdz/template 0.0.23 → 0.0.25

package/node_modules/@ykdz/template-core/dist/module-graph.js

@@ -1,147 +1,112 @@
-function renderTurboPackageFilter(owner) {
-    if (owner.kind !== "package-boundary") {
-        throw new Error("Turbo package tasks require a Package Boundary owner.");
+export function checkEnvironmentNeedFact(need) {
+    switch (need.kind) {
+        case "playwright-browser-assets":
+            return { kind: need.kind, browser: need.browser, owner: need.owner };
+        case "shellcheck-command":
+            return { kind: need.kind, owner: need.owner };
+        case "rust-toolchain":
+            return {
+                kind: need.kind,
+                owner: need.owner,
+                toolchain: need.toolchain,
+            };
     }
-    return `--filter './${owner.path}'`;
 }
-const turboAgentOutputArgs = [
-    "--output-logs=errors-only",
-    "--log-order=grouped",
-];
-export function renderTurboRunCommand(taskNames, args = []) {
-    return ["turbo run", ...taskNames, ...args, ...turboAgentOutputArgs].join(" ");
-}
-export function checkComponentTaskName(component) {
-    return checkComponentTaskNames(component)[0] ?? "check:run";
-}
-function checkComponentTaskNames(component) {
-    switch (component.kind) {
-        case "typescript-typecheck":
-        case "turbo-package-typecheck":
-            return ["typecheck:run"];
-        case "oxc-lint":
-        case "cargo-clippy":
-            return ["lint:run"];
-        case "oxc-format-check":
-        case "rustfmt-check":
-            return ["format:check:run"];
-        case "build":
-        case "turbo-package-build":
-            return ["build:run"];
-        case "unit-test":
-        case "cargo-test":
-        case "turbo-package-test":
-            return ["test:run"];
-        case "e2e-test":
-        case "turbo-package-e2e-test":
-            return ["test:e2e:run"];
-        case "turbo-check":
-        case "turbo-package-check":
-            return [
-                "format:check:run",
-                "lint:run",
-                "typecheck:run",
-                "build:run",
-                "test:run",
-                "test:e2e:run",
-            ];
-    }
-}
-export function fixComponentTaskName(component) {
-    return fixComponentTaskNames(component)[0] ?? "fix:run";
-}
-function fixComponentTaskNames(component) {
-    switch (component.kind) {
-        case "oxc-format-write":
-        case "rustfmt-write":
-            return ["format:write:run"];
-        case "oxc-lint-fix":
-            return ["lint:fix:run"];
-        case "turbo-fix":
-        case "turbo-package-fix":
-            return ["format:write:run", "lint:fix:run"];
-    }
-}
-function uniqueTaskNames(taskNames) {
-    return [...new Set(taskNames)];
-}
-export function renderCheckLeafCommand(component) {
-    switch (component.kind) {
-        case "typescript-typecheck":
-            return "pnpm run typecheck";
-        case "oxc-lint":
-            return "pnpm run lint";
-        case "oxc-format-check":
-            return "pnpm run format:check";
-        case "build":
-            return "pnpm run build";
-        case "unit-test":
-            return "pnpm run test";
-        case "e2e-test":
-            return "pnpm run test:e2e";
-        case "turbo-check":
-            return renderTurboRunCommand(["check"]);
-        case "turbo-package-typecheck":
-            return renderTurboRunCommand(["typecheck"], [renderTurboPackageFilter(component.owner)]);
-        case "turbo-package-build":
-            return renderTurboRunCommand(["build"], [renderTurboPackageFilter(component.owner)]);
-        case "turbo-package-test":
-            return renderTurboRunCommand(["test"], [renderTurboPackageFilter(component.owner)]);
-        case "turbo-package-e2e-test":
-            return renderTurboRunCommand(["test:e2e"], [renderTurboPackageFilter(component.owner)]);
-        case "turbo-package-check":
-            return renderTurboRunCommand(["check"], [renderTurboPackageFilter(component.owner)]);
-        case "rustfmt-check":
-            return "cargo fmt --all -- --check";
-        case "cargo-clippy":
-            return "cargo clippy --workspace --all-targets -- -D warnings";
-        case "cargo-test":
-            return "cargo test --workspace";
-    }
-}
-export function renderFixLeafCommand(component) {
-    switch (component.kind) {
-        case "oxc-format-write":
-            return "pnpm run format:write";
-        case "oxc-lint-fix":
-            return "pnpm run lint:fix";
-        case "turbo-fix":
-            return renderTurboRunCommand(["fix"]);
-        case "turbo-package-fix":
-            return renderTurboRunCommand(["fix"], [renderTurboPackageFilter(component.owner)]);
-        case "rustfmt-write":
-            return "cargo fmt --all";
+export function checkEnvironmentNeedFromFact(fact) {
+    switch (fact.kind) {
+        case "playwright-browser-assets":
+            return playwrightBrowserAssetsEnvironmentNeed({
+                browser: fact.browser,
+                owner: fact.owner,
+            });
+        case "shellcheck-command":
+            return shellCheckEnvironmentNeed(fact.owner);
+        case "rust-toolchain":
+            return rustToolchainEnvironmentNeed(fact.owner);
     }
 }
-export function renderRootCheckCommand(plan) {
-    return renderTurboRunCommand(uniqueTaskNames([
-        ...plan.components.flatMap(checkComponentTaskNames),
-        "check:run",
-    ]));
+export function deploymentEnvironmentNeedFact(need) {
+    return { kind: need.kind };
 }
-export function deploymentCheckEnvironmentNeeds(check) {
-    switch (check.kind) {
-        case "deployment-image":
-            return [{ kind: "docker-engine" }];
+export function deploymentEnvironmentNeedFromFact(fact) {
+    if (fact.kind !== "docker-engine") {
+        throw new Error("Unsupported Deployment Environment Need fact.");
     }
+    return dockerEngineEnvironmentNeed();
 }
-export function deploymentCheckTaskName(check) {
-    switch (check.kind) {
-        case "deployment-image":
-            return "check:deployment";
-    }
-}
-export function renderDeploymentCheckLeafCommand(check) {
-    return `pnpm --filter './${check.owner.path}' run ${deploymentCheckTaskName(check)}`;
+export function rustToolchainEnvironmentNeed(owner) {
+    return {
+        kind: "rust-toolchain",
+        owner,
+        toolchain: "stable",
+        nextStep: {
+            id: "install-rust-toolchain",
+            label: "Install Rust toolchain",
+            command: "rustup",
+            args: [
+                "toolchain",
+                "install",
+                "stable",
+                "--component",
+                "rustfmt",
+                "--component",
+                "clippy",
+            ],
+            display: "rustup toolchain install stable --component rustfmt --component clippy",
+            machineVerifiable: false,
+        },
+    };
 }
-export function renderDeploymentCheckCommand(plan) {
-    return uniqueTaskNames((plan.deploymentChecks ?? []).map(renderDeploymentCheckLeafCommand)).join(" && ");
+export function dockerEngineEnvironmentNeed() {
+    return {
+        kind: "docker-engine",
+        preparation: {
+            id: "verify-docker-engine",
+            label: "Verify Docker engine",
+            command: "docker",
+            args: ["version", "--format", "{{.Server.Version}}"],
+            display: "docker version --format {{.Server.Version}}",
+            machineVerifiable: true,
+        },
+    };
 }
-export function renderFixCommand(plan) {
-    return renderTurboRunCommand(uniqueTaskNames([
-        ...plan.components.flatMap(fixComponentTaskNames),
-        "fix:run",
-    ]));
+export const qualityTaskVocabulary = [
+    "boundaries",
+    "format:check",
+    "lint",
+    "typecheck",
+    "build",
+    "test",
+    "test:e2e",
+];
+export function renderTurboRunCommand(taskNames, args = [], options = {}) {
+    return [
+        "turbo run",
+        ...taskNames,
+        ...args,
+        ...(options.continueAfterFailure
+            ? ["--continue=dependencies-successful"]
+            : []),
+        `--output-logs=${options.outputLogs ?? "errors-only"}`,
+        "--log-order=grouped",
+        ...(options.taskPrefix ? ["--log-prefix=task"] : []),
+    ].join(" ");
+}
+export function renderRootCheckCommand() {
+    return renderTurboRunCommand(qualityTaskVocabulary, [], {
+        continueAfterFailure: true,
+        taskPrefix: true,
+    });
+}
+export function renderDeploymentCheckCommand() {
+    return renderTurboRunCommand(["deployment"], [], { taskPrefix: true });
+}
+export function renderFixCommand() {
+    return renderTurboRunCommand(["lint:fix", "format:write"], [], {
+        continueAfterFailure: true,
+        outputLogs: "full",
+        taskPrefix: true,
+    });
 }
 function playwrightBrowserInstallArgs(need, options = {}) {
     const installArgs = [
@@ -157,6 +122,9 @@ function playwrightBrowserInstallArgs(need, options = {}) {
     return installArgs;
 }
 export function renderPlaywrightBrowserInstallCommand(need, options = {}) {
+    if (need.kind !== "playwright-browser-assets") {
+        throw new Error("Playwright install requires browser assets.");
+    }
     return ["pnpm", ...playwrightBrowserInstallArgs(need, options)].join(" ");
 }
 export function playwrightBrowserAssetsNextStepDescriptor(owner) {
@@ -188,3 +156,17 @@ export function playwrightBrowserAssetsEnvironmentNeed(options) {
         },
     };
 }
+export function shellCheckEnvironmentNeed(owner) {
+    return {
+        kind: "shellcheck-command",
+        owner,
+        nextStep: {
+            id: "install-shellcheck",
+            label: "Install ShellCheck",
+            command: "sudo",
+            args: ["sh", "-c", "apt-get update && apt-get install -y shellcheck"],
+            display: "sudo apt-get update && sudo apt-get install -y shellcheck",
+            machineVerifiable: false,
+        },
+    };
+}

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

@@ -0,0 +1,41 @@
+import type { EditorCustomizationCapability } from "./editor-customization.ts";
+import type { CheckEnvironmentNeed, DeploymentEnvironmentNeed } from "./module-graph.ts";
+import type { PackageDefinition } from "./project-blueprint-v2.ts";
+import type { DependencyMaintenancePolicy } from "./project-github.ts";
+import type { RenderOperation } from "./renderer.ts";
+export type FoundationContribution = {
+    /** Toolchains the Foundation must install and project into coordinated root files. */
+    readonly toolchains: {
+        readonly rust?: {
+            readonly toolchain: string;
+            readonly components: readonly ("rustfmt" | "clippy")[];
+        };
+    };
+    /** Editor capabilities the Foundation must project into its coordinated editor files. */
+    readonly editorCapabilities: readonly EditorCustomizationCapability[];
+    /** Ecosystems and paths whose maintenance belongs in the coordinated root policy. */
+    readonly dependencyMaintenance: DependencyMaintenancePolicy;
+    /** Workspace membership patterns contributed by package boundaries. */
+    readonly workspacePackageGlobs?: readonly string[];
+    /** Dependency Catalog entries required by package-owned manifests. */
+    readonly dependencyCatalog?: Readonly<Record<string, string>>;
+};
+/** A preset-agnostic package-sized part of a Generated Repository Plan. */
+export type PackageContribution = {
+    readonly definition: PackageDefinition;
+    readonly manifest: Readonly<Record<string, unknown>>;
+    readonly exposure: {
+        readonly exports: Readonly<Record<string, unknown>>;
+        readonly imports: Readonly<Record<string, unknown>>;
+    };
+    readonly operations: readonly RenderOperation[];
+    /** Typed requirements consumed by the Foundation for coordinated root outputs. */
+    readonly foundation: FoundationContribution;
+    readonly environmentNeeds: readonly CheckEnvironmentNeed[];
+    /** Requirements prepared only by a focused deployment entrypoint. */
+    readonly deploymentEnvironmentNeeds?: readonly DeploymentEnvironmentNeed[];
+};
+export declare function assertPackageContribution(contribution: PackageContribution, provenance?: {
+    readonly definitionName?: string;
+    readonly planner?: string;
+}): PackageContribution;

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

@@ -0,0 +1,24 @@
+const operationPath = (operation) => {
+    if ("to" in operation)
+        return operation.to;
+    if ("path" in operation)
+        return operation.path;
+    return "";
+};
+export function assertPackageContribution(contribution, provenance = {}) {
+    if (contribution.definition.name !== contribution.manifest.name) {
+        throw new Error("Package Contribution manifest name must match its Package Definition");
+    }
+    const outsideOperation = contribution.operations.find((operation) => !operationPath(operation).startsWith(`${contribution.definition.path}/`));
+    if (outsideOperation) {
+        const target = operationPath(outsideOperation);
+        const rule = target.includes("/")
+            ? "Package Contribution may not write a sibling Package Boundary"
+            : "Package Contribution may not write a coordinated root output";
+        const owner = provenance.definitionName === undefined
+            ? ""
+            : `${provenance.definitionName}: ${provenance.planner ?? "Package Contribution"} `;
+        throw new Error(`${owner}${rule}; ${contribution.definition.path} attempted ${target}`);
+    }
+    return contribution;
+}

package/node_modules/@ykdz/template-core/dist/pnpm-workspace.yaml

@@ -1,11 +1,26 @@
 packages:
   - packages/*
 
-nodeLinker: hoisted
+nodeLinker: isolated
+
+autoInstallPeers: false
+
+injectWorkspacePackages: true
+
+dedupeInjectedDeps: false
+
+syncInjectedDepsAfterScripts:
+  - build
+
+minimumReleaseAge: 1440
+
+minimumReleaseAgeStrict: true
+
+overrides:
+  "pinia>typescript": "-"
+  "vue>typescript": "-"
 
 catalog:
-  "@typescript/native": npm:typescript@^7.0.2
-  "@typescript/typescript6": ^6.0.2
   "@hono/node-server": ^2.0.6
   "@playwright/test": ^1.61.1
   "@tailwindcss/vite": ^4.3.2
@@ -21,14 +36,16 @@ catalog:
   oxfmt: ^0.58.0
   oxlint: ^1.73.0
   oxlint-tsgolint: ^0.24.0
+  semver: ^7.8.5
+  "@types/semver": ^7.7.1
   pinia: ^3.0.4
   srvx: ^0.11.21
   tailwindcss: ^4.3.2
   telefunc: ^0.2.22
   tsc-alias: ^1.8.17
-  tsx: ^4.23.0
   turbo: 2.10.2
-  typescript: ^6.0.3
+  typescript: npm:@typescript/typescript6@^6.0.2
+  typescript-7: npm:typescript@^7.0.2
   valibot: ^1.4.2
   vite: ^8.1.4
   vike: ^0.4.260
@@ -40,6 +57,3 @@ catalog:
 
 allowBuilds:
   esbuild: true
-
-onlyBuiltDependencies:
-  - esbuild

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

@@ -0,0 +1,42 @@
+import type { PackageContribution } from "./package-contribution.ts";
+import type { ProjectBlueprintV2 } from "./project-blueprint-v2.ts";
+import type { TemplateSourceHandle } from "./renderer.ts";
+/** Stable, preset-agnostic input supplied after toolchain resolution. */
+export type GenerationContext = {
+    readonly targetDir: string;
+    readonly projectName: string;
+    readonly scope: string;
+    readonly toolchain: {
+        readonly nodeLtsMajor: string;
+        readonly packageManagerPin: string;
+    };
+};
+/** A side-effect-free Built-in Preset planner. */
+export type BuiltInPresetDefinition = {
+    readonly metadata: {
+        readonly name: string;
+        readonly title: string;
+        readonly description: string;
+    };
+    /** The Definition owns its Preset-local Self-Checking Template Source. */
+    readonly source: TemplateSourceHandle;
+    /** The owned planner source inspected by the Template Boundary Check. */
+    readonly plannerSourceFile: string;
+    blueprint(context: GenerationContext): ProjectBlueprintV2;
+    planInitialization(context: GenerationContext): PackageContribution;
+    /**
+     * Multi-package Definitions expose their complete owned topology directly,
+     * while single-package Definitions keep the compact tracer interface.
+     */
+    planInitializationContributions?(context: GenerationContext): readonly PackageContribution[];
+    /** Package layout is Preset-owned even when callers omit --path. */
+    defaultPackagePath?(options: {
+        readonly context: GenerationContext;
+        readonly packageLeafName: string;
+    }): string;
+    planPackageAddition?(options: {
+        readonly context: GenerationContext;
+        readonly packageLeafName: string;
+        readonly packagePath: string;
+    }): PackageContribution;
+};

package/node_modules/@ykdz/template-core/dist/preset-definition.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@ykdz/template-core/dist/project-blueprint-v2.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The durable, preset-agnostic topology used by local template follow-up
+ * operations. Preset provenance deliberately belongs in Generation Record.
+ */
+export type PackageRole = "runtime-service" | "shared-library" | "native-package";
+export type PackageDefinition = {
+    readonly name: string;
+    readonly path: string;
+    readonly role: PackageRole;
+};
+export type PackageLinkIntent = {
+    readonly consumerPackagePath: string;
+    readonly providerPackagePath: string;
+};
+export type ProjectBlueprintV2 = {
+    readonly schemaVersion: 2;
+    readonly packages: readonly PackageDefinition[];
+    readonly packageLinkIntents?: readonly PackageLinkIntent[];
+};
+export type BlueprintV2ValidationIssue = {
+    readonly path: string;
+    readonly message: string;
+};
+export type BlueprintV2ValidationResult = {
+    readonly ok: true;
+    readonly value: ProjectBlueprintV2;
+} | {
+    readonly ok: false;
+    readonly issues: readonly BlueprintV2ValidationIssue[];
+};
+/** Validates persisted metadata before it is used to plan or render changes. */
+export declare function validateProjectBlueprintV2(value: unknown): BlueprintV2ValidationResult;
+export declare function assertProjectBlueprintV2(value: unknown): ProjectBlueprintV2;

package/node_modules/@ykdz/template-core/dist/project-blueprint-v2.js

@@ -0,0 +1,161 @@
+const packageName = /^@[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/;
+const packagePath = /^[a-z0-9][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/;
+const roles = new Set([
+    "runtime-service",
+    "shared-library",
+    "native-package",
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function reportUnknownKeys(value, allowed, path, issues) {
+    for (const key of Object.keys(value)) {
+        if (!allowed.includes(key)) {
+            issues.push({
+                path: `${path}.${key}`,
+                message: "Unknown Blueprint v2 field",
+            });
+        }
+    }
+}
+/** Validates persisted metadata before it is used to plan or render changes. */
+export function validateProjectBlueprintV2(value) {
+    const issues = [];
+    if (!isRecord(value)) {
+        return {
+            ok: false,
+            issues: [
+                { path: ".", message: "Local Template Metadata must be an object" },
+            ],
+        };
+    }
+    reportUnknownKeys(value, ["schemaVersion", "packages", "packageLinkIntents"], ".", issues);
+    if (value.schemaVersion !== 2) {
+        issues.push({
+            path: ".schemaVersion",
+            message: `Unsupported Local Template Metadata schema version ${String(value.schemaVersion)}; expected 2`,
+        });
+    }
+    if (!Array.isArray(value.packages)) {
+        issues.push({
+            path: ".packages",
+            message: "Package Definitions must be an array",
+        });
+    }
+    const definitions = [];
+    if (Array.isArray(value.packages)) {
+        for (const [index, item] of value.packages.entries()) {
+            const itemPath = `.packages[${index}]`;
+            if (!isRecord(item)) {
+                issues.push({
+                    path: itemPath,
+                    message: "Package Definition must be an object",
+                });
+                continue;
+            }
+            reportUnknownKeys(item, ["name", "path", "role"], itemPath, issues);
+            if (typeof item.name !== "string" || !packageName.test(item.name)) {
+                issues.push({
+                    path: `${itemPath}.name`,
+                    message: "Package name must be a scoped lowercase package name",
+                });
+            }
+            if (typeof item.path !== "string" || !packagePath.test(item.path)) {
+                issues.push({
+                    path: `${itemPath}.path`,
+                    message: "Package Path must be exactly two safe path segments",
+                });
+            }
+            if (typeof item.role !== "string" ||
+                !roles.has(item.role)) {
+                issues.push({
+                    path: `${itemPath}.role`,
+                    message: "Package Role must be runtime-service, shared-library, or native-package",
+                });
+            }
+            if (typeof item.name === "string" &&
+                typeof item.path === "string" &&
+                typeof item.role === "string" &&
+                packageName.test(item.name) &&
+                packagePath.test(item.path) &&
+                roles.has(item.role)) {
+                definitions.push(item);
+            }
+        }
+    }
+    for (const [property, label] of [
+        ["name", "Package name"],
+        ["path", "Package Path"],
+    ]) {
+        const seen = new Set();
+        for (const definition of definitions) {
+            const member = definition[property];
+            if (seen.has(member))
+                issues.push({
+                    path: ".packages",
+                    message: `${label} must be unique: ${member}`,
+                });
+            seen.add(member);
+        }
+    }
+    if (value.packageLinkIntents !== undefined &&
+        !Array.isArray(value.packageLinkIntents)) {
+        issues.push({
+            path: ".packageLinkIntents",
+            message: "Package Link Intents must be an array",
+        });
+    }
+    const paths = new Set(definitions.map((definition) => definition.path));
+    const links = new Set();
+    if (Array.isArray(value.packageLinkIntents)) {
+        for (const [index, item] of value.packageLinkIntents.entries()) {
+            const itemPath = `.packageLinkIntents[${index}]`;
+            if (!isRecord(item)) {
+                issues.push({
+                    path: itemPath,
+                    message: "Package Link Intent must be an object",
+                });
+                continue;
+            }
+            reportUnknownKeys(item, ["consumerPackagePath", "providerPackagePath"], itemPath, issues);
+            const consumer = item.consumerPackagePath;
+            const provider = item.providerPackagePath;
+            if (typeof consumer !== "string" || !paths.has(consumer))
+                issues.push({
+                    path: `${itemPath}.consumerPackagePath`,
+                    message: "Package Link Intent references an unknown consumer package",
+                });
+            if (typeof provider !== "string" || !paths.has(provider))
+                issues.push({
+                    path: `${itemPath}.providerPackagePath`,
+                    message: "Package Link Intent references an unknown provider package",
+                });
+            if (consumer === provider && typeof consumer === "string")
+                issues.push({
+                    path: itemPath,
+                    message: "Package Link Intent cannot link a package to itself",
+                });
+            if (typeof consumer === "string" && typeof provider === "string") {
+                const key = `${consumer}\u0000${provider}`;
+                if (links.has(key))
+                    issues.push({
+                        path: itemPath,
+                        message: "Package Link Intent must be unique",
+                    });
+                links.add(key);
+            }
+        }
+    }
+    return issues.length === 0
+        ? { ok: true, value: value }
+        : { ok: false, issues };
+}
+export function assertProjectBlueprintV2(value) {
+    const result = validateProjectBlueprintV2(value);
+    if (!result.ok) {
+        throw new Error(result.issues
+            .map((issue) => `${issue.path}: ${issue.message}`)
+            .join("\n"));
+    }
+    return result.value;
+}

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

@@ -1,4 +1,4 @@
-import { type CheckPlan } from "./module-graph.js";
+import { type CheckEnvironmentNeed, type DeploymentEnvironmentNeed } from "./module-graph.ts";
 export type CiCapability = {
     readonly workflowName: "Check";
     readonly jobName: "check";
@@ -21,11 +21,26 @@ export type DependencyMaintenancePolicy = {
     readonly interval: "weekly";
 };
 type ProjectCheckWorkflowOptions = {
-    readonly checkPlan: CheckPlan;
+    readonly environment: {
+        readonly needs: readonly CheckEnvironmentNeed[];
+    };
+    readonly deploymentEnvironmentNeeds?: readonly DeploymentEnvironmentNeed[];
+    readonly hasDeploymentTask?: boolean | undefined;
     readonly capability?: CiCapability | undefined;
     readonly environmentPreparation?: Partial<CiEnvironmentPreparation> | undefined;
     readonly taskLayer?: PnpmTaskLayer | undefined;
 };
 export declare function projectCheckWorkflow(options: ProjectCheckWorkflowOptions): string;
+/** Limited substitutions for the Foundation-owned workflow Template Source. */
+export declare function projectCheckWorkflowTemplateReplacements(options: {
+    readonly environment: {
+        readonly needs: readonly CheckEnvironmentNeed[];
+    };
+    readonly deploymentEnvironmentNeeds?: readonly DeploymentEnvironmentNeed[];
+    readonly hasDeploymentTask?: boolean | undefined;
+    readonly environmentPreparation?: Partial<CiEnvironmentPreparation>;
+}): Record<string, string>;
 export declare function projectDependabotConfig(policy: DependencyMaintenancePolicy): string;
+/** Limited substitution for the Foundation-owned Dependabot Template Source. */
+export declare function projectDependabotTemplateReplacements(policy: DependencyMaintenancePolicy): Record<string, string>;
 export {};