@ykdz/template 0.0.35 → 0.0.37

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

@@ -1,182 +0,0 @@
-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 reservedWorkspaceCollections = new Set([
-    ".git",
-    ".github",
-    ".devcontainer",
-    ".template",
-    "node_modules",
-    "dist",
-    "target",
-]);
-const roles = new Set([
-    "cli-tool",
-    "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);
-            const workspaceCollection = typeof item.path === "string" ? item.path.split("/", 1)[0] : undefined;
-            const usesReservedWorkspaceCollection = workspaceCollection !== undefined &&
-                reservedWorkspaceCollections.has(workspaceCollection);
-            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 (usesReservedWorkspaceCollection) {
-                issues.push({
-                    path: `${itemPath}.path`,
-                    message: `Package Path ${item.path} uses reserved workspace collection ${workspaceCollection}`,
-                });
-            }
-            else 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 cli-tool, 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) &&
-                !usesReservedWorkspaceCollection &&
-                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/toolchain-baseline-update.d.ts

@@ -1,45 +0,0 @@
-export type ToolchainBaseline = {
-    readonly nodeLtsMajor: string;
-    readonly packageManagerPin: `pnpm@${string}`;
-};
-export type ToolchainPullRequestCandidate = {
-    readonly kind: "absent";
-} | {
-    readonly kind: "open";
-    readonly pullRequestNumber: number;
-};
-export type ToolchainRemoteBranch = {
-    readonly kind: "absent";
-} | {
-    readonly kind: "present";
-    readonly sha: string;
-};
-export type ToolchainUpdateCandidate = {
-    readonly pullRequest: ToolchainPullRequestCandidate;
-    readonly remoteBranch: ToolchainRemoteBranch;
-};
-export type ToolchainBaselineUpdatePlan = {
-    readonly kind: "no-drift";
-} | {
-    readonly kind: "cleanup-stale";
-    readonly pullRequestNumber?: number;
-    readonly deleteBranch: true;
-} | {
-    readonly kind: "update";
-    readonly mode: "create";
-    readonly desired: ToolchainBaseline;
-} | {
-    readonly kind: "update";
-    readonly mode: "replace";
-    readonly pullRequestNumber: number;
-    readonly desired: ToolchainBaseline;
-};
-type PlanToolchainBaselineUpdateOptions = {
-    readonly current: ToolchainBaseline & {
-        readonly materialConsistent?: boolean;
-    };
-    readonly desired: ToolchainBaseline;
-    readonly candidate: ToolchainUpdateCandidate;
-};
-export declare function planToolchainBaselineUpdate(options: PlanToolchainBaselineUpdateOptions): ToolchainBaselineUpdatePlan;
-export {};

package/node_modules/@ykdz/template-core/dist/toolchain-baseline-update.js

@@ -1,27 +0,0 @@
-export function planToolchainBaselineUpdate(options) {
-    const hasDrift = options.current.materialConsistent === false ||
-        options.current.nodeLtsMajor !== options.desired.nodeLtsMajor ||
-        options.current.packageManagerPin !== options.desired.packageManagerPin;
-    if (!hasDrift) {
-        return options.candidate.pullRequest.kind === "absent" &&
-            options.candidate.remoteBranch.kind === "absent"
-            ? { kind: "no-drift" }
-            : {
-                kind: "cleanup-stale",
-                ...(options.candidate.pullRequest.kind === "open"
-                    ? {
-                        pullRequestNumber: options.candidate.pullRequest.pullRequestNumber,
-                    }
-                    : {}),
-                deleteBranch: true,
-            };
-    }
-    return options.candidate.pullRequest.kind === "absent"
-        ? { kind: "update", mode: "create", desired: options.desired }
-        : {
-            kind: "update",
-            mode: "replace",
-            pullRequestNumber: options.candidate.pullRequest.pullRequestNumber,
-            desired: options.desired,
-        };
-}

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

@@ -1,35 +0,0 @@
-export type ToolchainResolutionSource = "online" | "bundled-fallback";
-export type NodeLtsMajor = {
-    readonly kind: "NodeLtsMajor";
-    readonly value: string;
-};
-export type PackageManagerPin = {
-    readonly kind: "PackageManagerPin";
-    readonly value: `pnpm@${string}`;
-};
-export type ResolvedToolchainVersions = {
-    readonly nodeLtsMajor: NodeLtsMajor;
-    readonly packageManagerPin: PackageManagerPin;
-    readonly source: ToolchainResolutionSource;
-    readonly diagnostics: string[];
-};
-export type ResolveToolchainVersionsOptions = {
-    readonly source?: ToolchainResolutionSource | "auto" | undefined;
-    readonly fetchJson?: ((url: string) => Promise<unknown>) | undefined;
-    readonly nodeReleaseIndexUrl?: string | undefined;
-    readonly pnpmRegistryUrl?: string | undefined;
-    readonly now?: Date | 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>) | undefined;
-};
-export type OnlineToolchainResolutionContractResult = {
-    readonly nodeLtsMajor: NodeLtsMajor;
-    readonly packageManagerPin: PackageManagerPin;
-    readonly diagnostics: string[];
-};
-export declare function resolveToolchainVersions(options?: ResolveToolchainVersionsOptions): Promise<ResolvedToolchainVersions>;
-export declare function checkOnlineToolchainResolutionContract(options?: OnlineToolchainResolutionContractOptions): Promise<OnlineToolchainResolutionContractResult>;
-export {};

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

@@ -1,189 +0,0 @@
-export const nodeReleaseIndexUrl = "https://nodejs.org/dist/index.json";
-export const pnpmRegistryUrl = "https://registry.npmjs.org/pnpm";
-const bundledFallbackToolchain = {
-    nodeLtsMajor: nodeLtsMajor("24"),
-    packageManagerPin: packageManagerPin("11.11.0"),
-};
-export async function resolveToolchainVersions(options = {}) {
-    const source = options.source ?? "online";
-    if (source === "bundled-fallback") {
-        return fallbackResult([]);
-    }
-    try {
-        const fetchJson = options.fetchJson ?? fetchOfficialJson;
-        const nodeReleases = parseNodeReleaseIndex(await fetchJson(options.nodeReleaseIndexUrl ?? nodeReleaseIndexUrl));
-        const nodeMajor = latestLtsMajor(nodeReleases);
-        const pnpmMetadata = parsePnpmRegistryMetadata(await fetchJson(options.pnpmRegistryUrl ?? pnpmRegistryUrl));
-        const nodeVersion = latestLtsVersion(nodeReleases, nodeMajor);
-        const pnpmVersion = latestCompatiblePnpmVersion(pnpmMetadata, nodeVersion, instant(options.now ?? new Date()));
-        return {
-            nodeLtsMajor: nodeMajor,
-            packageManagerPin: packageManagerPin(pnpmVersion),
-            source: "online",
-            diagnostics: [],
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return fallbackResult([
-            `Using bundled fallback toolchain metadata because online resolution failed: ${message}`,
-        ]);
-    }
-}
-export async function checkOnlineToolchainResolutionContract(options = {}) {
-    const fetchJson = options.fetchJson ?? fetchOfficialJson;
-    const nodeSource = await contractPhase("Node source parsing", async () => {
-        const releases = parseNodeReleaseIndex(await fetchJson(nodeReleaseIndexUrl));
-        const major = latestLtsMajor(releases);
-        return { major, version: latestLtsVersion(releases, major) };
-    });
-    const pnpmMetadata = await contractPhase("pnpm source parsing", async () => parsePnpmRegistryMetadata(await fetchJson(pnpmRegistryUrl)));
-    const pnpmVersion = await contractPhase("compatibility selection", async () => latestCompatiblePnpmVersion(pnpmMetadata, nodeSource.version));
-    return {
-        nodeLtsMajor: nodeSource.major,
-        packageManagerPin: packageManagerPin(pnpmVersion),
-        diagnostics: [
-            `Node source parsing succeeded; latest LTS major is ${nodeSource.major.value}.`,
-            `pnpm source parsing succeeded; latest compatible pnpm release is ${pnpmVersion}.`,
-            `Compatibility selection succeeded for pnpm@${pnpmVersion} on Node ${nodeSource.major.value}.`,
-        ],
-    };
-}
-async function contractPhase(phase, operation) {
-    try {
-        return await operation();
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Online toolchain resolution contract failed during ${phase}: ${message}`, { cause: error });
-    }
-}
-function fallbackResult(diagnostics) {
-    return {
-        nodeLtsMajor: bundledFallbackToolchain.nodeLtsMajor,
-        packageManagerPin: bundledFallbackToolchain.packageManagerPin,
-        source: "bundled-fallback",
-        diagnostics,
-    };
-}
-function nodeLtsMajor(value) {
-    if (!/^\d+$/.test(value)) {
-        throw new Error(`Invalid Node LTS major: ${value}`);
-    }
-    return { kind: "NodeLtsMajor", value };
-}
-function packageManagerPin(version) {
-    if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version)) {
-        throw new Error(`Invalid pnpm version: ${version}`);
-    }
-    return { kind: "PackageManagerPin", value: `pnpm@${version}` };
-}
-async function fetchOfficialJson(url) {
-    const response = await fetch(url, {
-        headers: { accept: "application/json" },
-    });
-    if (!response.ok) {
-        throw new Error(`GET ${url} failed with HTTP ${response.status}`);
-    }
-    return response.json();
-}
-function parseNodeReleaseIndex(value) {
-    if (!Array.isArray(value)) {
-        throw new Error("Node release index was not an array");
-    }
-    return value.map((entry) => {
-        if (!isRecord(entry)) {
-            throw new Error("Node release entry was not an object");
-        }
-        const version = entry.version;
-        const lts = entry.lts;
-        if (typeof version !== "string" ||
-            (typeof lts !== "string" && typeof lts !== "boolean")) {
-            throw new Error("Node release entry is missing version or lts");
-        }
-        return { version, lts };
-    });
-}
-function latestLtsMajor(releases) {
-    const majors = releases
-        .filter((release) => release.lts !== false)
-        .map((release) => release.version.match(/^v(\d+)\./)?.[1])
-        .filter((major) => major !== undefined)
-        .map(Number);
-    if (majors.length === 0) {
-        throw new Error("Node release index did not contain any LTS releases");
-    }
-    return nodeLtsMajor(String(Math.max(...majors)));
-}
-function latestLtsVersion(releases, major) {
-    const versions = releases
-        .filter((release) => release.lts !== false)
-        .map((release) => release.version.replace(/^v/, ""))
-        .filter((version) => valid(version) !== null && version.startsWith(`${major.value}.`))
-        .toSorted(compare);
-    const latest = versions.at(-1);
-    if (!latest) {
-        throw new Error(`Node release index did not contain Node ${major.value}`);
-    }
-    return latest;
-}
-function parsePnpmRegistryMetadata(value) {
-    if (!isRecord(value) || !isRecord(value.versions) || !isRecord(value.time)) {
-        throw new Error("pnpm registry metadata is missing versions or time");
-    }
-    const versions = {};
-    for (const [version, metadata] of Object.entries(value.versions)) {
-        if (!isRecord(metadata)) {
-            continue;
-        }
-        const nodeRange = isRecord(metadata.engines)
-            ? metadata.engines.node
-            : undefined;
-        versions[version] = isRecord(metadata.engines)
-            ? {
-                engines: typeof nodeRange === "string" ? { node: nodeRange } : {},
-            }
-            : {};
-    }
-    const time = Object.fromEntries(Object.entries(value.time).filter((entry) => typeof entry[1] === "string"));
-    return { time, versions };
-}
-function latestCompatiblePnpmVersion(metadata, nodeVersion, now = Date.now()) {
-    const candidates = Object.entries(metadata.versions)
-        .filter(([version]) => /^\d+\.\d+\.\d+$/.test(version))
-        .filter(([, packageMetadata]) => nodeSatisfiesRange(nodeVersion, packageMetadata.engines?.node))
-        .filter(([version]) => isMatureRelease(metadata.time[version], now))
-        .map(([version]) => version)
-        .toSorted(compare);
-    const latest = candidates.at(-1);
-    if (!latest) {
-        throw new Error(`pnpm registry metadata did not contain a release compatible with Node ${nodeVersion}`);
-    }
-    return latest;
-}
-const pnpmMaturityWindowMilliseconds = 24 * 60 * 60 * 1_000;
-function isMatureRelease(publishedAt, now) {
-    if (publishedAt === undefined) {
-        return false;
-    }
-    const publishedAtMilliseconds = Date.parse(publishedAt);
-    return (Number.isFinite(publishedAtMilliseconds) &&
-        now - publishedAtMilliseconds >= pnpmMaturityWindowMilliseconds);
-}
-function instant(value) {
-    const milliseconds = value instanceof Date ? value.getTime() : Date.parse(value);
-    if (!Number.isFinite(milliseconds)) {
-        throw new Error(`Invalid resolution time: ${String(value)}`);
-    }
-    return milliseconds;
-}
-function nodeSatisfiesRange(nodeVersion, range) {
-    if (!range) {
-        return true;
-    }
-    return satisfies(nodeVersion, range, { includePrerelease: false });
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-import { compare, satisfies, valid } from "semver";