@ykdz/template 0.0.41 → 0.1.0-experimental.0

package/node_modules/@ykdz/template-core/dist/dependency-catalog.js

@@ -1,238 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-const exactNpmPackageIdentityPattern = /^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*$/;
-const defaultGeneratedMinimumReleaseAgeExclusions = ["@ykdz/template"];
-function assertMinimumReleaseAgeExclusions(exclusions) {
-    if (exclusions.some((dependency) => dependency.length === 0)) {
-        throw new Error("Dependency maturity exclusions must be non-empty");
-    }
-    if (new Set(exclusions).size !== exclusions.length) {
-        throw new Error("Dependency maturity exclusions must be unique");
-    }
-    const invalid = exclusions.find((dependency) => dependency.length > 214 ||
-        !exactNpmPackageIdentityPattern.test(dependency));
-    if (invalid !== undefined) {
-        throw new Error(`Dependency maturity exclusions must be exact npm package identities: ${JSON.stringify(invalid)}`);
-    }
-}
-function templateRepositoryRoot() {
-    const moduleDir = path.dirname(fileURLToPath(import.meta.url));
-    const candidates = [
-        process.env.TEMPLATE_REPOSITORY_ROOT,
-        moduleDir,
-        path.resolve(moduleDir, ".."),
-        path.resolve(moduleDir, "..", ".."),
-        path.resolve(moduleDir, "..", "..", ".."),
-    ];
-    return (candidates.find((candidate) => candidate !== undefined &&
-        existsSync(path.join(candidate, "pnpm-workspace.yaml"))) ?? moduleDir);
-}
-function parseTemplateCatalogSection(workspaceYaml, sectionName) {
-    const catalog = {};
-    const lines = workspaceYaml.split(/\r?\n/);
-    const catalogStart = lines.findIndex((line) => line === `${sectionName}:`);
-    if (catalogStart === -1) {
-        return catalog;
-    }
-    for (const line of lines.slice(catalogStart + 1)) {
-        if (line.length > 0 && !line.startsWith("  ")) {
-            break;
-        }
-        const match = /^  (?:"([^"]+)"|([^:]+)): (.+)$/.exec(line);
-        if (!match) {
-            continue;
-        }
-        const key = match[1] ?? match[2];
-        const version = match[3];
-        if (key === undefined || version === undefined) {
-            continue;
-        }
-        catalog[key] = version;
-    }
-    return catalog;
-}
-function parseTemplateDependencyCatalog(workspaceYaml) {
-    return parseTemplateCatalogSection(workspaceYaml, "catalog");
-}
-export function loadTemplateDependencyCatalog() {
-    return parseTemplateDependencyCatalog(readFileSync(path.join(templateRepositoryRoot(), "pnpm-workspace.yaml"), "utf8"));
-}
-export function selectTemplateDependencyCatalogEntries(dependencies, catalog = loadTemplateDependencyCatalog()) {
-    const selected = {};
-    for (const dependency of dependencies.toSorted()) {
-        const version = catalog[dependency];
-        if (version === undefined) {
-            throw new Error(`Template Dependency Catalog is missing dependency: ${dependency}`);
-        }
-        selected[dependency] = version;
-    }
-    return selected;
-}
-function parseTemplateCargoDependencyVersions(cargoToml) {
-    const dependencies = {};
-    const lines = cargoToml.split(/\r?\n/);
-    const dependenciesStart = lines.findIndex((line) => line.trim() === "[dependencies]");
-    if (dependenciesStart === -1) {
-        return dependencies;
-    }
-    for (const line of lines.slice(dependenciesStart + 1)) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-            break;
-        }
-        if (trimmed.length === 0 || trimmed.startsWith("#")) {
-            continue;
-        }
-        const match = /^(?:"([^"]+)"|([A-Za-z0-9_-]+))\s*=\s*"([^"]+)"\s*$/.exec(trimmed);
-        if (!match) {
-            throw new Error(`Unsupported Template Cargo dependency declaration: ${trimmed}`);
-        }
-        const dependency = match[1] ?? match[2];
-        const version = match[3];
-        if (dependency === undefined || version === undefined) {
-            continue;
-        }
-        dependencies[dependency] = version;
-    }
-    return dependencies;
-}
-export function loadTemplateCargoDependencyVersions() {
-    return parseTemplateCargoDependencyVersions(readFileSync(path.join(templateRepositoryRoot(), "Cargo.toml"), "utf8"));
-}
-function loadTemplateCargoLock() {
-    return readFileSync(path.join(templateRepositoryRoot(), "Cargo.lock"), "utf8");
-}
-export function renderCargoLockForPackage(options) {
-    return loadTemplateCargoLock()
-        .replace('name = "template-cargo-dependencies"', `name = ${JSON.stringify(options.packageName)}`)
-        .replace('version = "0.0.0"', `version = ${JSON.stringify(options.packageVersion)}`);
-}
-export function selectTemplateCargoDependencyVersions(dependencies, catalog = loadTemplateCargoDependencyVersions()) {
-    const selected = {};
-    for (const dependency of dependencies.toSorted()) {
-        const version = catalog[dependency];
-        if (version === undefined) {
-            throw new Error(`Template Cargo dependency versions are missing dependency: ${dependency}`);
-        }
-        selected[dependency] = version;
-    }
-    return selected;
-}
-function renderTomlKey(key) {
-    return /^[A-Za-z0-9_-]+$/.test(key) ? key : JSON.stringify(key);
-}
-export function renderCargoDependencyTomlEntries(dependencies, catalog = loadTemplateCargoDependencyVersions()) {
-    return Object.entries(selectTemplateCargoDependencyVersions(dependencies, catalog)).map(([dependency, version]) => {
-        return `${renderTomlKey(dependency)} = ${JSON.stringify(version)}`;
-    });
-}
-export function collectGeneratedManifestCatalogReferences(manifests) {
-    const dependencies = new Set();
-    for (const manifest of manifests) {
-        for (const dependencyMap of [
-            manifest.dependencies,
-            manifest.devDependencies,
-            manifest.optionalDependencies,
-            manifest.peerDependencies,
-        ]) {
-            for (const [dependency, specifier] of Object.entries(dependencyMap ?? {})) {
-                if (specifier.startsWith("catalog:")) {
-                    dependencies.add(dependency);
-                }
-            }
-        }
-    }
-    return [...dependencies].toSorted();
-}
-function renderCatalogKey(key) {
-    return key.startsWith("@") ? JSON.stringify(key) : key;
-}
-export function pnpmWorkspaceYamlWithCatalogDependencies(workspaceYaml, dependencies, templateCatalog = loadTemplateDependencyCatalog()) {
-    const catalogStart = workspaceYaml
-        .split(/\r?\n/)
-        .findIndex((line) => line === "catalog:");
-    if (catalogStart === -1) {
-        throw new Error("Cannot update pnpm Dependency Catalog: missing catalog section");
-    }
-    const existingCatalog = parseTemplateDependencyCatalog(workspaceYaml);
-    const missingDependencies = dependencies.filter((dependency) => existingCatalog[dependency] === undefined);
-    if (missingDependencies.length === 0) {
-        return workspaceYaml;
-    }
-    const nextCatalog = {
-        ...existingCatalog,
-        ...selectTemplateDependencyCatalogEntries(missingDependencies, templateCatalog),
-    };
-    const lines = workspaceYaml.split(/\r?\n/);
-    const catalogEnd = lines.findIndex((line, index) => index > catalogStart && line.length > 0 && !line.startsWith("  "));
-    const replacementEnd = catalogEnd === -1 ? lines.length : catalogEnd;
-    const catalogLines = [
-        "catalog:",
-        ...Object.entries(nextCatalog)
-            .toSorted(([left], [right]) => left.localeCompare(right))
-            .map(([dependency, version]) => `  ${renderCatalogKey(dependency)}: ${version}`),
-        "",
-    ];
-    return [
-        ...lines.slice(0, catalogStart),
-        ...catalogLines,
-        ...lines.slice(replacementEnd),
-    ].join("\n");
-}
-export function renderGeneratedPnpmWorkspaceYaml(options) {
-    const configuredMinimumReleaseAgeExclusions = options.minimumReleaseAgeExclude ?? [];
-    assertMinimumReleaseAgeExclusions(configuredMinimumReleaseAgeExclusions);
-    const minimumReleaseAgeExclude = [
-        ...new Set([
-            ...defaultGeneratedMinimumReleaseAgeExclusions,
-            ...configuredMinimumReleaseAgeExclusions,
-        ]),
-    ];
-    if (options.dependencyLinker?.kind === "hoisted" &&
-        (options.dependencyLinker.evidence.trim().length === 0 ||
-            options.dependencyLinker.evidence.includes("\n"))) {
-        throw new Error("Hoisted linking requires single-line compatibility evidence");
-    }
-    const catalog = selectTemplateDependencyCatalogEntries(options.dependencies);
-    const packages = options.packages ?? ["."];
-    const dependencyLinker = options.dependencyLinker?.kind ?? "isolated";
-    const lines = [
-        "packages:",
-        ...packages.map((workspacePackage) => `  - ${workspacePackage}`),
-        "",
-        ...(options.dependencyLinker?.kind === "hoisted"
-            ? [
-                `# Hoisted linker compatibility evidence: ${options.dependencyLinker.evidence}`,
-            ]
-            : []),
-        `nodeLinker: ${dependencyLinker}`,
-        "autoInstallPeers: false",
-        "resolvePeersFromWorkspaceRoot: false",
-        "injectWorkspacePackages: false",
-        "dedupeInjectedDeps: false",
-        "syncInjectedDepsAfterScripts:",
-        "  - build",
-        "minimumReleaseAge: 1440",
-        "minimumReleaseAgeStrict: true",
-        "",
-    ];
-    if (minimumReleaseAgeExclude.length) {
-        lines.push("minimumReleaseAgeExclude:", ...minimumReleaseAgeExclude
-            .toSorted()
-            .map((dependency) => `  - ${JSON.stringify(dependency)}`), "");
-    }
-    if (options.allowBuilds) {
-        lines.push("allowBuilds:", ...Object.entries(options.allowBuilds)
-            .toSorted(([left], [right]) => left.localeCompare(right))
-            .map(([dependency, allowed]) => `  ${dependency}: ${allowed}`), "");
-    }
-    const overrides = options.overrides ?? {};
-    if (Object.keys(overrides).length > 0) {
-        lines.push("overrides:", ...Object.entries(overrides)
-            .toSorted(([left], [right]) => left.localeCompare(right))
-            .map(([dependency, version]) => `  ${JSON.stringify(dependency)}: ${JSON.stringify(version)}`), "");
-    }
-    lines.push("catalog:", ...Object.entries(catalog).map(([dependency, version]) => `  ${renderCatalogKey(dependency)}: ${version}`), "");
-    return lines.join("\n");
-}

package/node_modules/@ykdz/template-core/dist/development-container-tool-layer.d.ts

@@ -1,56 +0,0 @@
-import { type TemplateSourceHandle } from "./renderer.ts";
-export type DevelopmentContainerToolLayerBuildArgument = {
-    readonly name: string;
-    readonly value: string;
-};
-export type DevelopmentContainerToolLayerMount = {
-    readonly identity: string;
-    readonly type: "bind" | "volume";
-    readonly source: string;
-    readonly target: string;
-};
-export type DevelopmentContainerToolLayerProbe = {
-    readonly identity: string;
-    readonly command: string;
-    readonly args?: readonly string[] | undefined;
-    readonly failureMessage?: string | undefined;
-};
-export type DevelopmentContainerToolLayer = {
-    readonly identity: string;
-    readonly dockerfile: {
-        readonly source: TemplateSourceHandle;
-        readonly from: string;
-    };
-    readonly requires?: readonly string[] | undefined;
-    readonly buildArguments?: readonly DevelopmentContainerToolLayerBuildArgument[] | undefined;
-    readonly mounts?: readonly DevelopmentContainerToolLayerMount[] | undefined;
-    readonly probes?: readonly DevelopmentContainerToolLayerProbe[] | undefined;
-};
-export type PlannedDevelopmentContainerToolLayer = DevelopmentContainerToolLayer & {
-    readonly kind: "base" | "optional";
-};
-export type DevelopmentContainerToolLayerPlan = {
-    readonly layers: readonly PlannedDevelopmentContainerToolLayer[];
-    readonly buildArguments: readonly DevelopmentContainerToolLayerBuildArgument[];
-    readonly mounts: readonly DevelopmentContainerToolLayerMount[];
-    readonly probes: readonly DevelopmentContainerToolLayerProbe[];
-};
-type DevelopmentContainerDockerfileFragment = {
-    readonly identity: string;
-    readonly kind: "base" | "optional";
-    readonly from: string;
-    readonly text: string;
-};
-export declare function validateDevelopmentContainerDockerfileFragments(options: {
-    readonly baseFragment: Omit<DevelopmentContainerDockerfileFragment, "kind">;
-    readonly fragments?: readonly Omit<DevelopmentContainerDockerfileFragment, "kind">[];
-}): void;
-export declare function planDevelopmentContainerToolLayersSync(options: {
-    readonly baseLayer: DevelopmentContainerToolLayer;
-    readonly layers?: readonly DevelopmentContainerToolLayer[] | undefined;
-}): DevelopmentContainerToolLayerPlan;
-export declare function planDevelopmentContainerToolLayers(options: {
-    readonly baseLayer: DevelopmentContainerToolLayer;
-    readonly layers?: readonly DevelopmentContainerToolLayer[] | undefined;
-}): Promise<DevelopmentContainerToolLayerPlan>;
-export {};

package/node_modules/@ykdz/template-core/dist/development-container-tool-layer.js

@@ -1,361 +0,0 @@
-import { readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { resolveTemplateSource, } from "./renderer.js";
-function hasContinuation(line, escapeCharacter) {
-    const trimmed = line.trimEnd();
-    let escapeCount = 0;
-    for (let index = trimmed.length - 1; index >= 0 && trimmed[index] === escapeCharacter; index -= 1) {
-        escapeCount += 1;
-    }
-    return escapeCount % 2 === 1;
-}
-function parseLogicalDockerfileInstructions(text, sourceFile) {
-    const instructions = [];
-    let escapeCharacter = "\\";
-    let logicalLine = "";
-    for (const physicalLine of text.split(/\r?\n/u)) {
-        const trimmed = physicalLine.trim();
-        if (logicalLine.length === 0 && trimmed.startsWith("#")) {
-            const escapeDirective = trimmed.match(/^#\s*escape\s*=\s*([\\`])\s*$/iu);
-            if (escapeDirective?.[1] !== undefined) {
-                escapeCharacter = escapeDirective[1];
-            }
-            continue;
-        }
-        if (trimmed.length === 0 || trimmed.startsWith("#")) {
-            continue;
-        }
-        const continuation = hasContinuation(physicalLine, escapeCharacter);
-        const physicalContent = continuation
-            ? physicalLine.trimEnd().slice(0, -1)
-            : physicalLine;
-        logicalLine += physicalContent.trimStart();
-        if (continuation) {
-            continue;
-        }
-        const match = logicalLine.match(/^([A-Za-z]+)(?:[ \t]+(.*))?$/u);
-        if (match?.[1] === undefined) {
-            throw new Error(`Development Container Dockerfile fragment ${sourceFile} contains an invalid logical instruction: ${logicalLine}`);
-        }
-        instructions.push({
-            name: match[1].toUpperCase(),
-            arguments: match[2] ?? "",
-        });
-        logicalLine = "";
-    }
-    if (logicalLine.length > 0) {
-        throw new Error(`Development Container Dockerfile fragment ${sourceFile} ends with an unterminated line continuation.`);
-    }
-    return instructions;
-}
-function instructionNames(instructions, instruction) {
-    return new Set(instructions
-        .filter(({ name }) => name === instruction)
-        .map(({ arguments: value }) => value.trim().split(/[\s=]/u)[0])
-        .filter((name) => name.length > 0));
-}
-function dockerfileWords(value) {
-    const words = [];
-    let word = "";
-    let quote;
-    let escaped = false;
-    for (const character of value) {
-        if (escaped) {
-            word += character;
-            escaped = false;
-            continue;
-        }
-        if (character === "\\" && quote !== "'") {
-            escaped = true;
-            continue;
-        }
-        if (quote !== undefined) {
-            if (character === quote) {
-                quote = undefined;
-            }
-            else {
-                word += character;
-            }
-            continue;
-        }
-        if (character === '"' || character === "'") {
-            quote = character;
-            continue;
-        }
-        if (/\s/u.test(character)) {
-            if (word.length > 0) {
-                words.push(word);
-                word = "";
-            }
-            continue;
-        }
-        word += character;
-    }
-    if (escaped) {
-        word += "\\";
-    }
-    if (word.length > 0) {
-        words.push(word);
-    }
-    return words;
-}
-function environmentNames(instructions) {
-    const names = new Set();
-    for (const instruction of instructions) {
-        if (instruction.name !== "ENV") {
-            continue;
-        }
-        const words = dockerfileWords(instruction.arguments);
-        const first = words[0];
-        if (first === undefined) {
-            continue;
-        }
-        if (!first.includes("=")) {
-            names.add(first);
-            continue;
-        }
-        for (const assignment of words) {
-            const separator = assignment.indexOf("=");
-            if (separator > 0) {
-                names.add(assignment.slice(0, separator));
-            }
-        }
-    }
-    return names;
-}
-function validateDockerfileFragment(fragment) {
-    if (!fragment.from.endsWith(".Dockerfile")) {
-        throw new Error(`Development Container Tool Layer ${fragment.identity} must reference checked .Dockerfile template source; received ${fragment.from}.`);
-    }
-    const instructions = parseLogicalDockerfileInstructions(fragment.text, fragment.from);
-    const allowedInstructions = fragment.kind === "base"
-        ? new Set(["ARG", "ENV", "FROM", "RUN", "SHELL"])
-        : new Set(["ARG", "ENV", "RUN"]);
-    for (const instruction of instructions) {
-        if (!allowedInstructions.has(instruction.name)) {
-            const role = fragment.kind === "base" ? "base" : "optional";
-            const allowed = fragment.kind === "base"
-                ? "ARG, ENV, FROM, RUN, and SHELL"
-                : "ARG, ENV, and RUN";
-            throw new Error(`Development Container Tool Layer ${fragment.identity} ${role} fragment ${fragment.from} must not use Dockerfile instruction ${instruction.name}; allowed instructions are ${allowed}.`);
-        }
-    }
-    if (fragment.kind === "base") {
-        const fromCount = instructions.filter((instruction) => instruction.name === "FROM").length;
-        if (fromCount !== 1) {
-            throw new Error(`Development Container Tool Layer ${fragment.identity} base fragment ${fragment.from} must contain exactly one FROM instruction; found ${fromCount}.`);
-        }
-    }
-    return instructions;
-}
-export function validateDevelopmentContainerDockerfileFragments(options) {
-    validateDockerfileFragment({ ...options.baseFragment, kind: "base" });
-    for (const fragment of options.fragments ?? []) {
-        validateDockerfileFragment({ ...fragment, kind: "optional" });
-    }
-}
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function assertDockerfileTemplateSource(layer) {
-    if (!layer.dockerfile.from.endsWith(".Dockerfile")) {
-        throw new Error(`Development Container Tool Layer ${layer.identity} must reference checked .Dockerfile template source; received ${layer.dockerfile.from}.`);
-    }
-}
-function normalizeLayer(layer) {
-    assertDockerfileTemplateSource(layer);
-    const buildArgumentNames = new Set();
-    for (const argument of layer.buildArguments ?? []) {
-        if (buildArgumentNames.has(argument.name)) {
-            throw new Error(`Development Container Tool Layer ${layer.identity} declares build argument ${argument.name} more than once.`);
-        }
-        buildArgumentNames.add(argument.name);
-    }
-    return {
-        ...layer,
-        requires: [...new Set(layer.requires ?? [])].toSorted(compareText),
-        buildArguments: [...(layer.buildArguments ?? [])].toSorted((left, right) => compareText(left.name, right.name) ||
-            compareText(left.value, right.value)),
-        mounts: [...(layer.mounts ?? [])]
-            .map((mount) => ({
-            ...mount,
-            target: path.posix.normalize(mount.target),
-        }))
-            .toSorted((left, right) => compareText(left.identity, right.identity) ||
-            compareText(left.target, right.target)),
-        probes: [...(layer.probes ?? [])]
-            .map((probe) => ({
-            ...probe,
-            args: [...(probe.args ?? [])],
-        }))
-            .toSorted((left, right) => compareText(left.identity, right.identity) ||
-            compareText(left.command, right.command) ||
-            compareText(JSON.stringify(left.args), JSON.stringify(right.args))),
-    };
-}
-function layerFingerprint(layer, kind) {
-    return JSON.stringify({
-        kind,
-        identity: layer.identity,
-        dockerfile: resolveTemplateSource(layer.dockerfile.source, layer.dockerfile.from),
-        requires: layer.requires,
-        buildArguments: layer.buildArguments,
-        mounts: layer.mounts,
-        probes: layer.probes,
-    });
-}
-function findDependencyCycle(layers) {
-    const byIdentity = new Map(layers.map((layer) => [layer.identity, layer]));
-    const complete = new Set();
-    const active = [];
-    const activeSet = new Set();
-    const visit = (identity) => {
-        if (activeSet.has(identity)) {
-            return active.slice(active.indexOf(identity)).toSorted(compareText);
-        }
-        if (complete.has(identity)) {
-            return undefined;
-        }
-        active.push(identity);
-        activeSet.add(identity);
-        const layer = byIdentity.get(identity);
-        for (const dependency of layer?.requires ?? []) {
-            if (!byIdentity.has(dependency)) {
-                continue;
-            }
-            const cycle = visit(dependency);
-            if (cycle !== undefined) {
-                return cycle;
-            }
-        }
-        active.pop();
-        activeSet.delete(identity);
-        complete.add(identity);
-        return undefined;
-    };
-    for (const identity of [...byIdentity.keys()].toSorted(compareText)) {
-        const cycle = visit(identity);
-        if (cycle !== undefined) {
-            return cycle;
-        }
-    }
-    return undefined;
-}
-function orderLayers(baseLayer, optionalLayers) {
-    const normalizedBase = normalizeLayer(baseLayer);
-    if ((normalizedBase.requires?.length ?? 0) > 0) {
-        throw new Error(`Development Container Tool Layer ${normalizedBase.identity} is the base foundation and must not require other layers.`);
-    }
-    const base = {
-        ...normalizedBase,
-        kind: "base",
-    };
-    const identities = new Map([[base.identity, layerFingerprint(base, "base")]]);
-    const uniqueOptionalLayers = [];
-    for (const layer of optionalLayers) {
-        const normalized = normalizeLayer(layer);
-        const fingerprint = layerFingerprint(normalized, "optional");
-        const previous = identities.get(normalized.identity);
-        if (previous === fingerprint) {
-            continue;
-        }
-        if (previous !== undefined) {
-            throw new Error(`Development Container Tool Layer identity ${normalized.identity} has conflicting descriptors.`);
-        }
-        identities.set(normalized.identity, fingerprint);
-        uniqueOptionalLayers.push(normalized);
-    }
-    for (const layer of uniqueOptionalLayers) {
-        for (const requiredIdentity of layer.requires ?? []) {
-            if (!identities.has(requiredIdentity)) {
-                throw new Error(`Development Container Tool Layer ${layer.identity} requires missing layer ${requiredIdentity}.`);
-            }
-        }
-    }
-    const cycle = findDependencyCycle(uniqueOptionalLayers);
-    if (cycle !== undefined) {
-        throw new Error(`Development Container Tool Layer dependency cycle involves: ${cycle.join(", ")}.`);
-    }
-    const remaining = uniqueOptionalLayers
-        .map((layer) => ({
-        ...layer,
-        kind: "optional",
-    }))
-        .toSorted((left, right) => compareText(left.identity, right.identity));
-    const ordered = [base];
-    const resolved = new Set([base.identity]);
-    while (remaining.length > 0) {
-        const readyIndex = remaining.findIndex((layer) => (layer.requires ?? []).every((identity) => resolved.has(identity)));
-        if (readyIndex === -1) {
-            throw new Error("Development Container Tool Layer dependencies cannot be resolved.");
-        }
-        const [next] = remaining.splice(readyIndex, 1);
-        if (next === undefined) {
-            throw new Error("Development Container Tool Layer dependency resolution failed.");
-        }
-        ordered.push(next);
-        resolved.add(next.identity);
-    }
-    return ordered;
-}
-function completeDevelopmentContainerToolLayerPlan(layers, fragmentTexts) {
-    const buildArgumentOwners = new Map();
-    const environmentOwners = new Map();
-    const mountIdentityOwners = new Map();
-    const mountTargetOwners = new Map();
-    for (const [index, layer] of layers.entries()) {
-        for (const mount of layer.mounts ?? []) {
-            const previousIdentityOwner = mountIdentityOwners.get(mount.identity);
-            if (previousIdentityOwner !== undefined) {
-                throw new Error(`Development Container Tool Layer mount identity ${mount.identity} is declared by both ${previousIdentityOwner} and ${layer.identity}.`);
-            }
-            const previousTargetOwner = mountTargetOwners.get(mount.target);
-            if (previousTargetOwner !== undefined) {
-                throw new Error(`Development Container Tool Layer mount target ${mount.target} is declared by both ${previousTargetOwner} and ${layer.identity}.`);
-            }
-            mountIdentityOwners.set(mount.identity, layer.identity);
-            mountTargetOwners.set(mount.target, layer.identity);
-        }
-        const instructions = validateDockerfileFragment({
-            identity: layer.identity,
-            kind: layer.kind,
-            from: layer.dockerfile.from,
-            text: fragmentTexts[index],
-        });
-        const declaredArguments = instructionNames(instructions, "ARG");
-        for (const name of declaredArguments) {
-            const previousOwner = buildArgumentOwners.get(name);
-            if (previousOwner !== undefined) {
-                throw new Error(`Development Container Tool Layer build argument ${name} is declared by both ${previousOwner} and ${layer.identity}.`);
-            }
-            buildArgumentOwners.set(name, layer.identity);
-        }
-        for (const name of environmentNames(instructions)) {
-            const previousOwner = environmentOwners.get(name);
-            if (previousOwner !== undefined) {
-                throw new Error(`Development Container Tool Layer environment ${name} is declared by both ${previousOwner} and ${layer.identity}.`);
-            }
-            environmentOwners.set(name, layer.identity);
-        }
-        for (const argument of layer.buildArguments ?? []) {
-            if (!declaredArguments.has(argument.name)) {
-                throw new Error(`Development Container Tool Layer ${layer.identity} supplies build argument ${argument.name}, but ${layer.dockerfile.from} does not declare it with ARG.`);
-            }
-        }
-    }
-    return {
-        layers,
-        buildArguments: layers.flatMap((layer) => layer.buildArguments ?? []),
-        mounts: layers.flatMap((layer) => layer.mounts ?? []),
-        probes: layers.flatMap((layer) => layer.probes ?? []),
-    };
-}
-export function planDevelopmentContainerToolLayersSync(options) {
-    const layers = orderLayers(options.baseLayer, options.layers ?? []);
-    return completeDevelopmentContainerToolLayerPlan(layers, layers.map((layer) => readFileSync(resolveTemplateSource(layer.dockerfile.source, layer.dockerfile.from), "utf8")));
-}
-export async function planDevelopmentContainerToolLayers(options) {
-    const layers = orderLayers(options.baseLayer, options.layers ?? []);
-    return completeDevelopmentContainerToolLayerPlan(layers, await Promise.all(layers.map((layer) => readFile(resolveTemplateSource(layer.dockerfile.source, layer.dockerfile.from), "utf8"))));
-}

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

@@ -1,17 +0,0 @@
-/** Capability identities are supplied by the owning Built-in Presets policy. */
-export type EditorCustomizationCapability = string;
-export type EditorCustomization = {
-    readonly extensions: readonly string[];
-    readonly settings: Record<string, unknown>;
-};
-type CapabilityProjection = {
-    readonly extensions: readonly string[];
-    readonly settings: Record<string, unknown>;
-};
-export type EditorCustomizationDeclarations = {
-    readonly capabilityOrder: readonly EditorCustomizationCapability[];
-    readonly capabilities: Readonly<Record<EditorCustomizationCapability, CapabilityProjection>>;
-};
-export declare function loadEditorCustomizationDeclarations(resourcePath: string): EditorCustomizationDeclarations;
-export declare function editorCustomizationForCapabilities(capabilities: readonly EditorCustomizationCapability[], declarations: EditorCustomizationDeclarations): EditorCustomization;
-export {};