@ykdz/template 0.0.31 → 0.0.32

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

@@ -0,0 +1,361 @@
+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/package-contribution.d.ts

@@ -1,8 +1,9 @@
+import type { DevelopmentContainerToolLayer } from "./development-container-tool-layer.ts";
 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";
+import type { RenderOperation, TemplateSourceHandle } from "./renderer.ts";
 export type FoundationContribution = {
     /** Toolchains the Foundation must install and project into coordinated root files. */
     readonly toolchains: {
@@ -19,6 +20,16 @@ export type FoundationContribution = {
     readonly workspacePackageGlobs?: readonly string[];
     /** Dependency Catalog entries required by package-owned manifests. */
     readonly dependencyCatalog?: Readonly<Record<string, string>>;
+    /** Source-backed Development Container capabilities coordinated by Foundation. */
+    readonly developmentContainerToolLayers?: readonly DevelopmentContainerToolLayer[] | undefined;
+    /** Source-backed coordinated files projected by Foundation. */
+    readonly templateFiles?: readonly {
+        readonly identity: string;
+        readonly source: TemplateSourceHandle;
+        readonly from: string;
+        readonly to: string;
+        readonly replacements?: Readonly<Record<string, string>> | undefined;
+    }[] | undefined;
 };
 /** A preset-agnostic package-sized part of a Generated Repository Plan. */
 export type PackageContribution = {

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

@@ -21,6 +21,7 @@ overrides:
   "vue>typescript": "-"
 
 catalog:
+  "@devcontainers/cli": 0.88.0
   "@hono/node-server": ^2.0.12
   "@playwright/test": ^1.61.1
   "@tailwindcss/vite": ^4.3.3

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

@@ -1,4 +1,4 @@
-import { type CheckEnvironmentNeed, type DeploymentEnvironmentNeed } from "./module-graph.ts";
+import type { DeploymentEnvironmentNeed } from "./module-graph.ts";
 export type CiCapability = {
     readonly workflowName: "Check";
     readonly jobName: "check";
@@ -6,7 +6,6 @@ export type CiCapability = {
 };
 export type CiEnvironmentPreparation = {
     readonly nodeFromPackageMetadata: boolean;
-    readonly rustToolchain: boolean;
 };
 export type PnpmTaskLayer = {
     readonly installCommand: "pnpm install";
@@ -21,9 +20,6 @@ export type DependencyMaintenancePolicy = {
     readonly interval: "weekly";
 };
 type ProjectCheckWorkflowOptions = {
-    readonly environment: {
-        readonly needs: readonly CheckEnvironmentNeed[];
-    };
     readonly deploymentEnvironmentNeeds?: readonly DeploymentEnvironmentNeed[];
     readonly hasDeploymentTask?: boolean | undefined;
     readonly capability?: CiCapability | undefined;
@@ -33,12 +29,8 @@ type ProjectCheckWorkflowOptions = {
 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. */

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

@@ -1,4 +1,3 @@
-import { renderPlaywrightBrowserInstallCommand, } from "./module-graph.js";
 const defaultCiCapability = {
     workflowName: "Check",
     jobName: "check",
@@ -12,11 +11,8 @@ export function projectCheckWorkflow(options) {
     const capability = options.capability ?? defaultCiCapability;
     const environmentPreparation = {
         nodeFromPackageMetadata: true,
-        rustToolchain: false,
         ...options.environmentPreparation,
     };
-    const requiresRustToolchain = environmentPreparation.rustToolchain ||
-        options.environment.needs.some((need) => need.kind === "rust-toolchain");
     const taskLayer = options.taskLayer ?? pnpmTaskLayer;
     const hasDeploymentTask = options.hasDeploymentTask === true;
     const needsDocker = (options.deploymentEnvironmentNeeds ?? []).some((need) => need.kind === "docker-engine");
@@ -44,20 +40,7 @@ export function projectCheckWorkflow(options) {
     if (hasDeploymentTask && needsDocker) {
         lines.push("      - uses: docker/setup-buildx-action@v3", "        if: matrix.check == 'deployment'");
     }
-    if (requiresRustToolchain)
-        lines.push(...rustCiPreparationLines());
     lines.push(`      - run: ${taskLayer.installCommand}`);
-    const checkEnvironmentLines = [];
-    for (const need of options.environment.needs) {
-        if (need.kind === "rust-toolchain") {
-            continue;
-        }
-        checkEnvironmentLines.push(`      - run: ${renderCiEnvironmentNeedCommand(need)}`);
-        if (hasDeploymentTask && need.kind === "shellcheck-command") {
-            checkEnvironmentLines.push("        if: matrix.check == 'root'");
-        }
-    }
-    lines.push(...checkEnvironmentLines);
     lines.push(`      - run: ${taskLayer.checkCommand}`);
     if (hasDeploymentTask) {
         lines.push("        if: matrix.check == 'root'");
@@ -68,33 +51,11 @@ export function projectCheckWorkflow(options) {
     lines.push("");
     return lines.join("\n");
 }
-function rustCiPreparationLines() {
-    return [
-        "      - uses: dtolnay/rust-toolchain@stable",
-        "        with:",
-        "          components: rustfmt, clippy",
-        "      - uses: Swatinem/rust-cache@v2",
-    ];
-}
 /** Limited substitutions for the Foundation-owned workflow Template Source. */
 export function projectCheckWorkflowTemplateReplacements(options) {
-    const requiresRustToolchain = options.environmentPreparation?.rustToolchain === true ||
-        options.environment.needs.some((need) => need.kind === "rust-toolchain");
     const hasDeploymentTask = options.hasDeploymentTask === true;
     const needsDocker = (options.deploymentEnvironmentNeeds ?? []).some((need) => need.kind === "docker-engine");
-    const environmentSteps = options.environment.needs
-        .filter((need) => need.kind !== "rust-toolchain")
-        .map((need) => [
-        `      - run: ${renderCiEnvironmentNeedCommand(need)}`,
-        ...(hasDeploymentTask && need.kind === "shellcheck-command"
-            ? ["        if: matrix.check == 'root'"]
-            : []),
-    ].join("\n"));
     return {
-        RUST_CI_PREPARATION: requiresRustToolchain
-            ? `\n${rustCiPreparationLines().join("\n")}`
-            : "",
-        CHECK_ENVIRONMENT_PREPARATION: environmentSteps.length === 0 ? "" : `\n${environmentSteps.join("\n")}`,
         DEPLOYMENT_MATRIX: hasDeploymentTask
             ? "\n    strategy:\n      matrix:\n        check: [root, deployment]"
             : "",
@@ -152,13 +113,3 @@ function renderDependabotDirectory(ecosystem, directory) {
 function defaultDependabotDirectory(ecosystem) {
     return ecosystem === "docker" ? "/.devcontainer" : "/";
 }
-function renderCiEnvironmentNeedCommand(need) {
-    switch (need.kind) {
-        case "playwright-browser-assets":
-            return renderPlaywrightBrowserInstallCommand(need, { withDeps: true });
-        case "shellcheck-command":
-            return need.nextStep.display;
-        case "rust-toolchain":
-            return need.nextStep.display;
-    }
-}

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

@@ -17,6 +17,15 @@ export type StructuredIdentitySetPolicy = {
     } | {
         readonly kind: "fields";
         readonly fields: readonly string[];
+    } | {
+        readonly kind: "projection";
+        readonly members: readonly {
+            readonly identity: string;
+            readonly match: Readonly<Record<string, string | number | boolean | null>>;
+        }[];
+        readonly fallback: {
+            readonly fields: readonly string[];
+        };
     };
 };
 export type ProjectProjectionReconciliation = {

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

@@ -248,6 +248,21 @@ function memberIdentity(member, policy) {
         return scalarIdentity(member);
     if (!isStructuredObject(member))
         return undefined;
+    if (policy.identity.kind === "projection") {
+        const matches = policy.identity.members.filter(({ match }) => Object.entries(match).every(([field, value]) => Object.hasOwn(member, field) &&
+            structuredValuesEqual(member[field], value)));
+        const matchingIdentities = new Set(matches.map(({ identity }) => identity));
+        if (matchingIdentities.size > 1)
+            return undefined;
+        const [matchingIdentity] = matchingIdentities;
+        if (matchingIdentity !== undefined) {
+            return `projection:${JSON.stringify(matchingIdentity)}`;
+        }
+        const fallbackFields = policy.identity.fallback.fields.map((field) => Object.hasOwn(member, field) ? scalarIdentity(member[field]) : undefined);
+        return fallbackFields.every((field) => field !== undefined)
+            ? `fallback:${JSON.stringify(fallbackFields)}`
+            : undefined;
+    }
     const fields = policy.identity.fields.map((field) => Object.hasOwn(member, field) ? scalarIdentity(member[field]) : undefined);
     return fields.every((field) => field !== undefined)
         ? JSON.stringify(fields)
@@ -472,8 +487,52 @@ function assertProjectionContract(projection) {
     }
     return policies;
 }
-function reconciliationPoliciesEqual(left, right) {
-    return JSON.stringify(left) === JSON.stringify(right);
+function reconciliationPoliciesCompatible(left, right) {
+    if (left.path !== right.path ||
+        left.driver !== right.driver ||
+        left.driver !== "structured" ||
+        right.driver !== "structured") {
+        return JSON.stringify(left) === JSON.stringify(right);
+    }
+    const leftIdentitySets = left.identitySets ?? [];
+    const rightIdentitySets = right.identitySets ?? [];
+    if (leftIdentitySets.length !== rightIdentitySets.length)
+        return false;
+    return leftIdentitySets.every((leftPolicy, index) => {
+        const rightPolicy = rightIdentitySets[index];
+        if (rightPolicy === undefined ||
+            leftPolicy.location !== rightPolicy.location ||
+            leftPolicy.identity.kind !== rightPolicy.identity.kind) {
+            return false;
+        }
+        if (leftPolicy.identity.kind !== "projection" ||
+            rightPolicy.identity.kind !== "projection") {
+            return JSON.stringify(leftPolicy) === JSON.stringify(rightPolicy);
+        }
+        return (JSON.stringify(leftPolicy.identity.fallback) ===
+            JSON.stringify(rightPolicy.identity.fallback));
+    });
+}
+function combinedIdentitySets(before, after) {
+    const beforeIdentitySets = before?.driver === "structured" ? (before.identitySets ?? []) : [];
+    const afterIdentitySets = after?.driver === "structured" ? (after.identitySets ?? []) : [];
+    return afterIdentitySets.map((afterPolicy, index) => {
+        const beforePolicy = beforeIdentitySets[index];
+        if (beforePolicy?.identity.kind !== "projection" ||
+            afterPolicy.identity.kind !== "projection") {
+            return afterPolicy;
+        }
+        return {
+            ...afterPolicy,
+            identity: {
+                ...afterPolicy.identity,
+                members: [
+                    ...beforePolicy.identity.members,
+                    ...afterPolicy.identity.members,
+                ],
+            },
+        };
+    });
 }
 function structuredValueAtLocation(root, pathSegments) {
     let value = root;
@@ -521,6 +580,24 @@ function assertIdentitySetPolicies(entry, reconciliation) {
                 policy.identity.fields.some((field) => field.length === 0))) {
             throw new Error(`Project Projection identity-set fields must be unique non-empty names: ${entry.path} ${location}`);
         }
+        if (policy.identity.kind === "projection") {
+            const fallbackFields = policy.identity.fallback.fields;
+            if (fallbackFields.length === 0 ||
+                new Set(fallbackFields).size !== fallbackFields.length ||
+                fallbackFields.some((field) => field.length === 0)) {
+                throw new Error(`Project Projection identity-set projection fallback fields must be unique non-empty names: ${entry.path} ${location}`);
+            }
+            const memberIdentities = policy.identity.members.map((member) => member.identity);
+            if (memberIdentities.some((identity) => identity.length === 0) ||
+                new Set(memberIdentities).size !== memberIdentities.length ||
+                policy.identity.members.some((member) => Object.keys(member.match).length === 0 ||
+                    Object.values(member.match).some((value) => value !== null &&
+                        typeof value !== "string" &&
+                        typeof value !== "number" &&
+                        typeof value !== "boolean"))) {
+                throw new Error(`Project Projection identity-set projection members require unique non-empty identities and non-empty scalar matches: ${entry.path} ${location}`);
+            }
+        }
         const value = structuredValueAtLocation(parsed.value, pathSegments);
         if (!Array.isArray(value)) {
             throw new Error(`Project Projection identity-set location must reference an array: ${entry.path} ${location}`);
@@ -547,7 +624,7 @@ export async function reconcileProjectProjections(options) {
         }
         if (afterPolicy !== undefined &&
             beforePolicy !== undefined &&
-            !reconciliationPoliciesEqual(beforePolicy, afterPolicy)) {
+            !reconciliationPoliciesCompatible(beforePolicy, afterPolicy)) {
             throw new Error(`Project Projection reconciliation policy changed for ${projectionPath}`);
         }
     }
@@ -561,7 +638,9 @@ export async function reconcileProjectProjections(options) {
     for (const projectionPath of deltaPaths) {
         const before = beforeByPath.get(projectionPath);
         const after = afterByPath.get(projectionPath);
-        const policy = afterPolicies.get(projectionPath) ?? beforePolicies.get(projectionPath);
+        const beforePolicy = beforePolicies.get(projectionPath);
+        const afterPolicy = afterPolicies.get(projectionPath);
+        const policy = afterPolicy ?? beforePolicy;
         const driver = policy.driver;
         const current = await options.readCurrent(projectionPath);
         if (entriesEqual(current, after))
@@ -622,7 +701,7 @@ export async function reconcileProjectProjections(options) {
                 before,
                 current,
                 after,
-                identitySets: policy.identitySets ?? [],
+                identitySets: combinedIdentitySets(beforePolicy, afterPolicy),
             })
             : undefined;
         const text = driver === "text"

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

@@ -66,6 +66,7 @@ export type WriteTextFromFragmentsOperation = {
         from: string;
         source: TemplateSourceHandle;
     }[];
+    validation?: "development-container-dockerfile" | undefined;
     overwrite?: boolean;
     provenance?: RenderOperationProvenance;
 };