@nipe-solutions/flex-layout-codemod 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/cli.js

@@ -1,17 +1,788 @@
 #!/usr/bin/env node
 
+// src/migrator/migration-path.validator.ts
+import { lstat, stat } from "fs/promises";
+import * as path from "path";
+
+// src/migrator/migration-application.error.ts
+var MigrationApplicationError = class extends Error {
+  constructor(code, message, paths = [], options) {
+    super(message, options);
+    this.code = code;
+    this.paths = paths;
+    this.name = "MigrationApplicationError";
+    this.paths = Object.freeze([...paths]);
+    this.recoveryFailures = Object.freeze([...options?.recoveryFailures ?? []]);
+  }
+  recoveryFailures;
+};
+
+// src/migrator/migration-path.validator.ts
+async function validateMigrationPaths(request, pathApi = path) {
+  const claims = normalizedClaims(request, pathApi);
+  await validateCollisions(claims, pathApi);
+  const destinations = claims.filter((claim) => claim.kind !== "template-input");
+  for (const destination of destinations) {
+    await validateDestination(destination.path);
+  }
+}
+async function validateStylesheetRootTopology(request, pathApi = path) {
+  if (request.stylesheetPath === void 0) return;
+  const stylesheetPath = pathApi.resolve(request.stylesheetPath);
+  const templateRoots = [request.inputPath, request.outputPath].map((claim) => pathApi.resolve(claim));
+  const reportPath = request.reportPath === void 0 ? void 0 : pathApi.resolve(request.reportPath);
+  const exactCollision = (await Promise.all(
+    [...templateRoots, reportPath].map(
+      (claim) => claim === void 0 ? Promise.resolve(false) : pathsEquivalentOnFileSystem(stylesheetPath, claim, pathApi)
+    )
+  )).some(Boolean);
+  const reportHierarchyCollision = reportPath !== void 0 && await pathsOverlapOnFileSystem(stylesheetPath, reportPath, pathApi);
+  if (exactCollision || reportHierarchyCollision) {
+    const collisionPaths = reportHierarchyCollision && reportPath !== void 0 && !await pathsEquivalentOnFileSystem(stylesheetPath, reportPath, pathApi) ? [stylesheetPath, reportPath] : [stylesheetPath];
+    throw new MigrationApplicationError(
+      "path-collision",
+      `Stylesheet path collides with another migration path: ${request.stylesheetPathInput ?? request.stylesheetPath}`,
+      collisionPaths
+    );
+  }
+  let stylesheetStat;
+  try {
+    stylesheetStat = await lstat(stylesheetPath);
+  } catch (error) {
+    if (isEnoent(error)) return;
+    throw error;
+  }
+  const sourcePath = request.stylesheetPathInput ?? request.stylesheetPath;
+  if (stylesheetStat.isSymbolicLink()) {
+    throw new MigrationApplicationError(
+      "unsupported-path-type",
+      `Stylesheet path must not be a symbolic link: ${sourcePath}`,
+      [stylesheetPath]
+    );
+  }
+  if (!stylesheetStat.isFile()) {
+    throw new MigrationApplicationError(
+      "unsupported-path-type",
+      `Stylesheet path must be a regular file: ${sourcePath}`,
+      [stylesheetPath]
+    );
+  }
+}
+function normalizedClaims(request, pathApi) {
+  return [
+    ...request.templates.flatMap((template, templateIndex) => [
+      { path: pathApi.resolve(template.inputPath), kind: "template-input", templateIndex },
+      { path: pathApi.resolve(template.outputPath), kind: "template-output", templateIndex }
+    ]),
+    ...request.stylesheetPath ? [{ path: pathApi.resolve(request.stylesheetPath), kind: "stylesheet" }] : [],
+    ...request.reportPath ? [{ path: pathApi.resolve(request.reportPath), kind: "report" }] : []
+  ];
+}
+async function validateCollisions(claims, pathApi) {
+  const observations = /* @__PURE__ */ new Map();
+  const observe = (candidate) => {
+    const normalized = pathApi.resolve(candidate);
+    const existing = observations.get(normalized);
+    if (existing) return existing;
+    const pending = observePath(normalized, pathApi);
+    observations.set(normalized, pending);
+    return pending;
+  };
+  for (let leftIndex = 0; leftIndex < claims.length; leftIndex++) {
+    const left = claims[leftIndex];
+    if (!left) continue;
+    for (let rightIndex = leftIndex + 1; rightIndex < claims.length; rightIndex++) {
+      const right = claims[rightIndex];
+      if (!right) continue;
+      const relationship = await fileSystemPathRelationship(left.path, right.path, pathApi, observe);
+      if (relationship === "distinct" || isIntentionalInPlacePair(left, right, pathApi)) continue;
+      const collisionPaths = relationship === "equivalent" ? [left.path] : [left.path, right.path];
+      throw new MigrationApplicationError(
+        "path-collision",
+        `Migration paths collide: ${collisionPaths.join(" and ")}`,
+        collisionPaths
+      );
+    }
+  }
+}
+function isIntentionalInPlacePair(left, right, pathApi) {
+  return pathsEquivalent(left.path, right.path, pathApi) && left.templateIndex !== void 0 && left.templateIndex === right.templateIndex && left.kind !== right.kind && left.kind.startsWith("template-") && right.kind.startsWith("template-");
+}
+function pathsEquivalent(left, right, pathApi = path) {
+  return normalizedPathsEquivalent(pathApi, pathApi.resolve(left), pathApi.resolve(right));
+}
+async function pathsEquivalentOnFileSystem(left, right, pathApi = path) {
+  return await fileSystemPathRelationship(left, right, pathApi) === "equivalent";
+}
+async function pathsOverlapOnFileSystem(left, right, pathApi = path) {
+  return await fileSystemPathRelationship(left, right, pathApi) !== "distinct";
+}
+function normalizedPathsEquivalent(pathApi, left, right) {
+  return pathApi.relative(left, right) === "";
+}
+function isAncestor(pathApi, ancestor, descendant) {
+  const relative3 = pathApi.relative(ancestor, descendant);
+  return relative3 !== "" && relative3 !== ".." && !relative3.startsWith(`..${pathApi.sep}`) && !pathApi.isAbsolute(relative3);
+}
+async function fileSystemPathRelationship(left, right, pathApi, observe = (candidate) => observePath(candidate, pathApi)) {
+  const normalizedLeft = pathApi.resolve(left);
+  const normalizedRight = pathApi.resolve(right);
+  if (normalizedPathsEquivalent(pathApi, normalizedLeft, normalizedRight)) return "equivalent";
+  if (isAncestor(pathApi, normalizedLeft, normalizedRight)) return "ancestor";
+  if (isAncestor(pathApi, normalizedRight, normalizedLeft)) return "descendant";
+  const [observedLeft, observedRight] = await Promise.all([observe(normalizedLeft), observe(normalizedRight)]);
+  if (observedLeft.exactIdentity && observedRight.exactIdentity) {
+    if (sameIdentity(observedLeft.exactIdentity, observedRight.exactIdentity)) return "equivalent";
+    if (hasIdentityBelow(observedRight, observedLeft.exactIdentity)) return "ancestor";
+    if (hasIdentityBelow(observedLeft, observedRight.exactIdentity)) return "descendant";
+    return "distinct";
+  }
+  return relationshipThroughExistingPrefixes(observedLeft, observedRight);
+}
+async function observePath(candidate, pathApi) {
+  const prefixes = [];
+  const suffix = [];
+  let current = candidate;
+  let exactIdentity;
+  while (true) {
+    try {
+      const currentStat = await stat(current, { bigint: true });
+      const currentIdentity = identity(currentStat);
+      if (suffix.length === 0) exactIdentity = currentIdentity;
+      prefixes.push({ identity: currentIdentity, suffix: [...suffix] });
+    } catch (error) {
+      if (!isMissingPath(error)) throw error;
+    }
+    const parent = pathApi.dirname(current);
+    if (parent === current) break;
+    suffix.unshift(pathApi.basename(current));
+    current = parent;
+  }
+  return { ...exactIdentity ? { exactIdentity } : {}, prefixes };
+}
+function relationshipThroughExistingPrefixes(left, right) {
+  for (const leftPrefix of left.prefixes) {
+    for (const rightPrefix of right.prefixes) {
+      if (!sameIdentity(leftPrefix.identity, rightPrefix.identity)) continue;
+      const relationship = suffixRelationship(leftPrefix.suffix, rightPrefix.suffix);
+      if (relationship !== "distinct") return relationship;
+    }
+  }
+  return "distinct";
+}
+function hasIdentityBelow(observed, candidate) {
+  return observed.prefixes.some((prefix) => prefix.suffix.length > 0 && sameIdentity(prefix.identity, candidate));
+}
+function suffixRelationship(left, right) {
+  const normalizedLeft = left.map(portablePathSegment);
+  const normalizedRight = right.map(portablePathSegment);
+  const sharedLength = Math.min(normalizedLeft.length, normalizedRight.length);
+  for (let index = 0; index < sharedLength; index++) {
+    if (normalizedLeft[index] !== normalizedRight[index]) return "distinct";
+  }
+  if (normalizedLeft.length === normalizedRight.length) return "equivalent";
+  return normalizedLeft.length < normalizedRight.length ? "ancestor" : "descendant";
+}
+function portablePathSegment(value) {
+  return value.normalize("NFC").toLowerCase();
+}
+function identity(value) {
+  return { device: String(value.dev), inode: String(value.ino) };
+}
+function sameIdentity(left, right) {
+  return left.device === right.device && left.inode === right.inode;
+}
+async function validateDestination(destination) {
+  let stat4;
+  try {
+    stat4 = await lstat(destination);
+  } catch (error) {
+    if (isEnoent(error)) return;
+    throw error;
+  }
+  if (stat4.isSymbolicLink()) {
+    throw new MigrationApplicationError(
+      "unsupported-path-type",
+      `Migration destination must not be a symbolic link: ${destination}`,
+      [destination]
+    );
+  }
+  if (!stat4.isFile()) {
+    throw new MigrationApplicationError(
+      "unsupported-path-type",
+      `Migration destination must be a regular file: ${destination}`,
+      [destination]
+    );
+  }
+}
+function isEnoent(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function isMissingPath(error) {
+  return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+
+// src/config/migration-config.ts
+import { readFile, realpath } from "fs/promises";
+import path2 from "path";
+import { createHash } from "crypto";
+import postcss2 from "postcss";
+
+// src/util/sha-256.ts
+var ROUND_CONSTANTS = Object.freeze([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var INITIAL_HASH = Object.freeze([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+function sha256(value) {
+  const source = new TextEncoder().encode(value);
+  const paddedLength = Math.ceil((source.length + 9) / 64) * 64;
+  const bytes = new Uint8Array(paddedLength);
+  bytes.set(source);
+  bytes[source.length] = 128;
+  const bitLength = source.length * 8;
+  const view = new DataView(bytes.buffer);
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
+  view.setUint32(paddedLength - 4, bitLength >>> 0);
+  const hash = [...INITIAL_HASH];
+  const schedule = new Uint32Array(64);
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    for (let index = 0; index < 16; index += 1) schedule[index] = view.getUint32(offset + index * 4);
+    for (let index = 16; index < schedule.length; index += 1) {
+      const earlier = schedule[index - 15];
+      const recent = schedule[index - 2];
+      const sigma0 = rotateRight(earlier, 7) ^ rotateRight(earlier, 18) ^ earlier >>> 3;
+      const sigma1 = rotateRight(recent, 17) ^ rotateRight(recent, 19) ^ recent >>> 10;
+      schedule[index] = schedule[index - 16] + sigma0 + schedule[index - 7] + sigma1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = hash;
+    for (let index = 0; index < schedule.length; index += 1) {
+      const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const choice = e & f ^ ~e & g;
+      const temporary1 = h + sum1 + choice + ROUND_CONSTANTS[index] + schedule[index] >>> 0;
+      const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const majority = a & b ^ a & c ^ b & c;
+      const temporary2 = sum0 + majority >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temporary1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temporary1 + temporary2 >>> 0;
+    }
+    const round = [a, b, c, d, e, f, g, h];
+    for (let index = 0; index < hash.length; index += 1) hash[index] = hash[index] + round[index] >>> 0;
+  }
+  return hash.map((word) => word.toString(16).padStart(8, "0")).join("");
+}
+function rotateRight(value, count) {
+  return value >>> count | value << 32 - count;
+}
+
+// src/config/tailwind-target-profile.ts
+import postcss from "postcss";
+var defaults = { sm: "40rem", md: "48rem", lg: "64rem", xl: "80rem", "2xl": "96rem" };
+function validBreakpoint(value) {
+  return /^(?:0|[1-9]\d*)(?:\.\d+)?(?:px|rem|em)$/.test(value) && Number.parseFloat(value) < 1e7;
+}
+function validPrefix(value) {
+  return /^[a-z]+$/.test(value);
+}
+function analyzeTailwindStylesheet(css, source = "pasted stylesheet") {
+  const operations = [];
+  const diagnostics = [];
+  const imports = [];
+  let tailwind = false;
+  let defaultTheme = false;
+  let utilities = false;
+  const warn = (code, message) => diagnostics.push({ code, message: `${source}: ${message}` });
+  if (css.length > 2e6) throw new Error("Stylesheet exceeds the 2 MB static analysis limit.");
+  const root = postcss.parse(css, { from: void 0 });
+  root.walkAtRules((rule) => {
+    if (rule.name === "custom-variant" || rule.name === "utility")
+      warn("tailwind-target-unknown", `@${rule.name} may change generated utility semantics and is not evaluated.`);
+    if (rule.name === "config" || rule.name === "plugin") {
+      warn(
+        rule.name === "config" ? "tailwind-config-external" : "tailwind-plugin-external",
+        `@${rule.name} ${rule.params} was not executed; additional configuration is unknown.`
+      );
+    }
+    if (rule.name === "source" && /^not\b/.test(rule.params)) {
+      warn("tailwind-source-excluded", `Source exclusion ${rule.params} may exclude migrated templates.`);
+    }
+    if (rule.name === "import") {
+      const match = /^(["'])([^"']+)\1(.*)$/.exec(rule.params);
+      if (!match) {
+        warn("tailwind-import-unresolved", `Import ${rule.params} was not loaded.`);
+        return;
+      }
+      const imported = match[2];
+      const modifiers = match[3];
+      if (/^tailwindcss(?:\/(?:theme|utilities|preflight)\.css)?$/.test(imported)) {
+        tailwind = true;
+        if (rule.parent?.type !== "root") {
+          warn("tailwind-target-unknown", "Conditional Tailwind import is unresolved.");
+          return;
+        }
+        let remaining = modifiers.trim();
+        let prefix = null;
+        let important = false;
+        const seen = /* @__PURE__ */ new Set();
+        while (remaining) {
+          const modifier = /^(prefix\(([^)]*)\)|important|source\((?:none|"[^"]*"|'[^']*')\)|layer\([a-zA-Z0-9_.-]+\))(?=\s|$)/.exec(
+            remaining
+          );
+          if (!modifier) {
+            warn("tailwind-target-unknown", `Unsupported Tailwind import modifiers: ${remaining}`);
+            break;
+          }
+          const name = modifier[1].split("(")[0];
+          if (seen.has(name)) warn("tailwind-target-unknown", `Repeated Tailwind import modifier ${name}.`);
+          seen.add(name);
+          if (name === "prefix") {
+            if (!validPrefix(modifier[2])) warn("tailwind-target-unknown", "Invalid Tailwind v4 prefix.");
+            else prefix = modifier[2];
+          }
+          if (name === "important") important = true;
+          if (modifier[1] === "source(none)")
+            warn("tailwind-source-excluded", "source(none) disables automatic template discovery.");
+          remaining = remaining.slice(modifier[0].length).trim();
+        }
+        if (imported === "tailwindcss" || imported === "tailwindcss/theme.css") defaultTheme = true;
+        if (imported !== "tailwindcss/preflight.css") operations.push({ kind: "prefix", value: prefix, source });
+        if (imported === "tailwindcss" || imported === "tailwindcss/utilities.css") {
+          utilities = true;
+          operations.push({ kind: "important", value: important ? "important" : "normal", source });
+        }
+      } else if (imported.startsWith("./") || imported.startsWith("../")) {
+        if (rule.parent?.type !== "root" || modifiers.trim())
+          warn("tailwind-import-unresolved", `Conditional import ${imported} was not loaded.`);
+        else imports.push(imported);
+      } else warn("tailwind-import-unresolved", `External import ${imported} was not loaded.`);
+    }
+    if (rule.name !== "theme") return;
+    if (rule.parent?.type !== "root" || rule.params.trim() && !/^(?:inline|static)(?:\s+(?:inline|static))*$/.test(rule.params.trim())) {
+      warn("tailwind-target-unknown", "Conditional or unsupported @theme block was not resolved.");
+      return;
+    }
+    rule.each((node) => {
+      if (node.type !== "decl") return;
+      if (node.prop === "--*") {
+        if (node.value.trim() === "initial" && !node.important) {
+          operations.push({ kind: "breakpoint", name: "*", value: null, source });
+        } else warn("tailwind-target-unknown", "Cannot resolve global theme reset.");
+        return;
+      }
+      if (!node.prop.startsWith("--breakpoint-")) return;
+      const name = node.prop.slice("--breakpoint-".length);
+      const value = node.value.trim();
+      if (!/^(?:\*|[a-zA-Z0-9][a-zA-Z0-9_-]*)$/.test(name) || node.important || value !== "initial" && (name === "*" || !validBreakpoint(value))) {
+        warn("tailwind-breakpoint-unknown", `Cannot resolve ${node.prop}: ${value}.`);
+        if (/^(?:\*|[a-zA-Z0-9][a-zA-Z0-9_-]*)$/.test(name))
+          operations.push({ kind: "breakpoint", name, value: null, source });
+        return;
+      }
+      operations.push({ kind: "breakpoint", name, value: value === "initial" ? null : value, source });
+    });
+  });
+  return { operations, diagnostics, imports, tailwind, defaultTheme, utilities, source };
+}
+function resolveTailwindTargetProfile(input = {}) {
+  let coreUtilities = {
+    value: "standard",
+    source: input.detected?.source ?? "default",
+    confidence: input.detected ? "detected" : "defaulted"
+  };
+  let prefix = { value: null, source: "default", confidence: "defaulted" };
+  let important = { value: "normal", source: "default", confidence: "defaulted" };
+  let breakpoints = Object.fromEntries(
+    Object.entries(input.detected && !input.detected.defaultTheme ? {} : defaults).map(([name, value]) => [
+      name,
+      { value, source: "default", confidence: "defaulted" }
+    ])
+  );
+  const diagnostics = [
+    ...input.detected?.diagnostics ?? [],
+    ...(input.detected?.imports ?? []).map((imported) => ({
+      code: "tailwind-import-unresolved",
+      message: `${input.detected.source}: Local import ${imported} was not loaded in this analysis.`
+    }))
+  ];
+  function apply(operation, confidence) {
+    const { value, source } = operation;
+    if (operation.kind === "prefix") {
+      if (value !== null && !validPrefix(value))
+        throw new Error("Tailwind v4 prefix must contain only lowercase letters.");
+      if (prefix.confidence !== "defaulted" && prefix.value !== value)
+        diagnostics.push({
+          code: "tailwind-prefix-conflict",
+          message: `Using prefix ${String(value)} from ${source}; ${prefix.source} declared ${String(prefix.value)}.`
+        });
+      prefix = { value, source, confidence };
+    } else if (operation.kind === "important") important = { value: operation.value, source, confidence };
+    else if (operation.name === "*" && value === null) breakpoints = {};
+    else if (value === null) delete breakpoints[operation.name];
+    else {
+      if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(operation.name) || !validBreakpoint(value))
+        throw new Error(`Invalid Tailwind breakpoint ${operation.name}: ${value}`);
+      breakpoints[operation.name] = { value, source, confidence };
+    }
+  }
+  input.detected?.operations.forEach((operation) => apply(operation, "detected"));
+  for (const [overrides, source] of [
+    [input.explicit, input.explicitSource ?? "migration profile"],
+    [input.cli, "CLI"]
+  ]) {
+    if (!overrides) continue;
+    if (overrides.version !== void 0 && overrides.version !== 4)
+      throw new Error("Only Tailwind v4 targets are supported.");
+    if (overrides.coreUtilities !== void 0) {
+      if (overrides.coreUtilities !== "standard")
+        throw new Error("coreUtilities must be standard when explicitly asserted.");
+      coreUtilities = { value: "standard", source, confidence: "explicit" };
+    }
+    if (overrides.prefix !== void 0) apply({ kind: "prefix", value: overrides.prefix, source }, "explicit");
+    if (overrides.important !== void 0) {
+      if (!["normal", "important"].includes(overrides.important)) throw new Error("Invalid Tailwind important mode.");
+      apply({ kind: "important", value: overrides.important, source }, "explicit");
+    }
+    const entries = Object.entries(overrides.breakpoints ?? {}).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    for (const [name, value] of entries)
+      apply({ kind: "breakpoint", name, value: value === "initial" ? null : value, source }, "explicit");
+  }
+  breakpoints = Object.fromEntries(Object.entries(breakpoints).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+  if (new Set(Object.values(breakpoints).map((setting) => setting.value.match(/[a-z]+$/)[0])).size > 1)
+    diagnostics.push({
+      code: "tailwind-mixed-breakpoint-units",
+      message: "Mixed breakpoint units may affect Tailwind variant ordering; units were preserved."
+    });
+  if (input.detected && !input.detected.utilities)
+    diagnostics.push({
+      code: "tailwind-target-unknown",
+      message: "The supplied stylesheet does not declare Tailwind utility generation."
+    });
+  if (input.detected && !input.detected.tailwind)
+    diagnostics.push({ code: "tailwind-target-unknown", message: "No supported Tailwind v4 import was detected." });
+  if (diagnostics.some(
+    (item) => [
+      "tailwind-config-external",
+      "tailwind-plugin-external",
+      "tailwind-import-unresolved",
+      "tailwind-target-unknown"
+    ].includes(item.code)
+  )) {
+    if (coreUtilities.confidence !== "explicit")
+      coreUtilities = { ...coreUtilities, value: "unknown", confidence: "unknown" };
+    breakpoints = Object.fromEntries(
+      Object.entries(breakpoints).map(([name, setting]) => [
+        name,
+        setting.confidence === "explicit" ? setting : { ...setting, confidence: "unknown" }
+      ])
+    );
+    if (prefix.confidence !== "explicit") prefix = { ...prefix, confidence: "unknown" };
+    if (important.confidence !== "explicit")
+      important = { value: "unknown", source: important.source, confidence: "unknown" };
+  }
+  const assumptions = [
+    "Custom application CSS is not globally analyzed.",
+    "Responsive source ranges are preserved, including screen and print conditions."
+  ];
+  if (!input.detected && !input.explicit && !input.cli)
+    assumptions.push("Target profile uses Tailwind v4 defaults; project configuration was not discovered.");
+  if (diagnostics.some((d) => d.code === "tailwind-config-external" || d.code === "tailwind-plugin-external"))
+    assumptions.push("Legacy JavaScript configuration and plugins were not executed.");
+  if (coreUtilities.confidence === "explicit")
+    assumptions.push(
+      "The migration profile explicitly asserts standard Tailwind core utility semantics; this assertion was not verified by executing project code."
+    );
+  if (important.value === "important")
+    assumptions.push("Generated Tailwind utilities are globally important; existing styles still require review.");
+  const canonical = JSON.stringify({
+    version: 4,
+    prefix: prefix.value,
+    important: important.value,
+    coreUtilities: coreUtilities.value,
+    breakpoints: Object.fromEntries(Object.entries(breakpoints).map(([name, setting]) => [name, setting.value]))
+  });
+  return deepFreeze({
+    target: "tailwind",
+    version: 4,
+    prefix,
+    important,
+    coreUtilities,
+    breakpoints,
+    diagnostics,
+    assumptions,
+    fingerprint: `tw4-${sha256(canonical)}`,
+    ...input.detected ? { stylesheet: input.detected.source } : {}
+  });
+}
+function deepFreeze(value) {
+  if (value && typeof value === "object") {
+    Object.values(value).forEach(deepFreeze);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+// src/config/source-breakpoints.ts
+function sourceBreakpointDefinition(alias, input) {
+  if (!/^[a-zA-Z][a-zA-Z0-9_.-]*$/.test(alias) || !Number.isSafeInteger(input.priority))
+    throw new Error(`Invalid source breakpoint ${alias}; an integer priority is required.`);
+  if (typeof input.mediaQuery !== "string") throw new Error(`Invalid source media query for ${alias}.`);
+  const parts = input.mediaQuery.trim().split(/\s+and\s+/);
+  if (parts.shift() !== "screen" || !parts.length)
+    throw new Error(`Source breakpoint ${alias} requires screen and explicit px width/orientation conditions.`);
+  const range2 = {};
+  for (const part of parts) {
+    const width = /^\((min|max)-width:\s*(\d+(?:\.\d+)?)px\)$/.exec(part);
+    const orientation = /^\(orientation:\s*(portrait|landscape)\)$/.exec(part);
+    if (width) {
+      const key = width[1];
+      if (range2[key] !== void 0 || !Number.isFinite(Number(width[2])))
+        throw new Error(`Duplicate or invalid source condition in ${alias}.`);
+      range2[key] = Number(width[2]);
+    } else if (orientation && range2.orientation === void 0)
+      range2.orientation = orientation[1];
+    else throw new Error(`Unsupported source media condition in ${alias}: ${part}`);
+  }
+  if ((range2.min ?? 0) > (range2.max ?? Infinity)) throw new Error(`Inverted source media range in ${alias}.`);
+  const clause = Object.freeze(range2);
+  return Object.freeze({
+    alias,
+    priority: input.priority,
+    range: clause,
+    media: Object.freeze({ type: "screen", clauses: Object.freeze([clause]) })
+  });
+}
+
+// src/config/migration-config.ts
+function object(value, allowed, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object.`);
+  for (const key of Object.keys(value)) if (!allowed.includes(key)) throw new Error(`Unknown ${label} setting: ${key}`);
+  return value;
+}
+function parseConfig(contents) {
+  const config = object(JSON.parse(contents), ["target", "tailwind", "source"], "migration config");
+  if (config.target !== void 0 && config.target !== "tailwind" && config.target !== "css")
+    throw new Error("Invalid migration target.");
+  if (config.tailwind !== void 0) {
+    const tw = object(
+      config.tailwind,
+      ["version", "stylesheet", "prefix", "breakpoints", "important", "coreUtilities"],
+      "tailwind"
+    );
+    if (tw.stylesheet !== void 0 && typeof tw.stylesheet !== "string")
+      throw new Error("Tailwind stylesheet must be a path.");
+    if (tw.prefix !== void 0 && tw.prefix !== null && typeof tw.prefix !== "string")
+      throw new Error("Tailwind prefix must be a string or null.");
+    if (tw.breakpoints !== void 0) {
+      if (!tw.breakpoints || typeof tw.breakpoints !== "object" || Array.isArray(tw.breakpoints))
+        throw new Error("Tailwind breakpoints must be an object.");
+      for (const value of Object.values(tw.breakpoints))
+        if (value !== null && typeof value !== "string")
+          throw new Error("Tailwind breakpoint values must be lengths or null.");
+    }
+  }
+  if (config.source !== void 0) {
+    const source = object(config.source, ["flexLayout"], "source");
+    if (source.flexLayout !== void 0) {
+      const flex = object(source.flexLayout, ["breakpoints"], "source.flexLayout");
+      if (flex.breakpoints !== void 0) {
+        if (!flex.breakpoints || typeof flex.breakpoints !== "object" || Array.isArray(flex.breakpoints))
+          throw new Error("Source breakpoints must be an object.");
+        for (const [alias, value] of Object.entries(flex.breakpoints)) {
+          object(value, ["mediaQuery", "priority"], `source breakpoint ${alias}`);
+          sourceBreakpointDefinition(alias, value);
+        }
+      }
+    }
+  }
+  return config;
+}
+var digest = (value) => createHash("sha256").update(value).digest("hex");
+function inside(root, candidate) {
+  const relative3 = path2.relative(root, candidate);
+  return relative3 !== ".." && !relative3.startsWith(`..${path2.sep}`) && !path2.isAbsolute(relative3);
+}
+async function assertConfigurationUnchanged(snapshots) {
+  for (const snapshot of snapshots) {
+    let current;
+    try {
+      if (await realpath(snapshot.path) !== snapshot.canonicalPath) throw new Error("Configuration path changed.");
+      current = digest(await readFile(snapshot.path, "utf8"));
+    } catch {
+      throw new Error(`Target configuration changed or disappeared since planning: ${snapshot.path}`);
+    }
+    if (current !== snapshot.digest) throw new Error(`Target configuration changed since planning: ${snapshot.path}`);
+  }
+}
+async function loadMigrationConfig(options) {
+  const root = await realpath(options.cwd ?? process.cwd());
+  const snapshots = [];
+  const read = async (file) => {
+    const contents = await readFile(file, "utf8");
+    if (contents.length > 2e6) throw new Error("Configuration file exceeds the 2 MB static analysis limit.");
+    if (!snapshots.some((snapshot) => snapshot.path === file))
+      snapshots.push(Object.freeze({ path: file, canonicalPath: await realpath(file), digest: digest(contents) }));
+    return contents;
+  };
+  const configPath = path2.resolve(root, options.config ?? "flex-layout-migrator.config.json");
+  if (!configPath.endsWith(".json")) throw new Error("Migration configuration must be declarative JSON.");
+  let config = {};
+  try {
+    config = parseConfig(await read(configPath));
+  } catch (error) {
+    if (options.config !== void 0 || !(error && typeof error === "object" && "code" in error && error.code === "ENOENT"))
+      throw error;
+  }
+  const stylesheet = options.stylesheet === void 0 ? config.tailwind?.stylesheet === void 0 ? void 0 : path2.resolve(path2.dirname(configPath), config.tailwind.stylesheet) : path2.resolve(root, options.stylesheet);
+  let detected;
+  if (stylesheet) {
+    const operations = [];
+    const diagnostics = [];
+    let tailwind = false;
+    let defaultTheme = false;
+    let utilities = false;
+    let visited = 0;
+    const relative3 = (file) => path2.relative(root, file).split(path2.sep).join("/");
+    const visit = async (file, ancestors, depth) => {
+      if (++visited > 128 || depth > 16)
+        throw new Error("CSS import analysis limit exceeded (128 imports / depth 16).");
+      const canonical = await realpath(file);
+      if (!inside(root, canonical)) throw new Error("CSS import is outside the project root.");
+      if (ancestors.includes(canonical)) throw new Error("CSS import cycle detected.");
+      const contents = await read(file);
+      const parsed2 = postcss2.parse(contents, { from: void 0 });
+      for (const node of parsed2.nodes) {
+        const analysis = analyzeTailwindStylesheet(node.toString(), relative3(canonical));
+        operations.push(...analysis.operations);
+        diagnostics.push(...analysis.diagnostics);
+        tailwind ||= analysis.tailwind;
+        defaultTheme ||= analysis.defaultTheme;
+        utilities ||= analysis.utilities;
+        for (const imported of analysis.imports) {
+          try {
+            await visit(path2.resolve(path2.dirname(canonical), imported), [...ancestors, canonical], depth + 1);
+          } catch (error) {
+            diagnostics.push({
+              code: "tailwind-import-unresolved",
+              message: `${relative3(canonical)}: ${imported}: ${error instanceof Error ? error.message : "Import unresolved"}`
+            });
+          }
+        }
+      }
+    };
+    await visit(stylesheet, [], 0);
+    detected = {
+      source: relative3(stylesheet),
+      operations,
+      diagnostics,
+      imports: [],
+      defaultTheme,
+      utilities,
+      tailwind
+    };
+  }
+  const targetProfile = resolveTailwindTargetProfile({
+    detected,
+    explicit: config.tailwind,
+    explicitSource: path2.relative(root, configPath).split(path2.sep).join("/"),
+    ...options.prefix !== void 0 ? { cli: { prefix: options.prefix || null } } : {}
+  });
+  return Object.freeze({
+    target: config.target,
+    targetProfile,
+    sourceBreakpoints: config.source?.flexLayout?.breakpoints,
+    snapshots: Object.freeze(snapshots)
+  });
+}
+
 // src/cli/run-cli.ts
 import { Command, CommanderError, InvalidArgumentError, Option } from "commander";
-import * as path17 from "path";
+import * as path18 from "path";
 
 // package.json
 var package_default = {
   name: "@nipe-solutions/flex-layout-codemod",
-  version: "2.0.0-beta.2",
+  version: "2.0.0-beta.4",
   description: "A safety-first codemod for migrating Angular Flex-Layout templates to native CSS or Tailwind CSS.",
   type: "module",
   engines: {
-    node: ">=24"
+    node: ">=22.12.0"
   },
   packageManager: "npm@11.19.0",
   files: [
@@ -45,7 +816,8 @@ var package_default = {
     format: "prettier --check .",
     "format:write": "prettier --write .",
     verify: "npm run format && npm run lint && npm run typecheck && npm run test:coverage && npm run build && npm run package:check",
-    "verify:website": "npm run format && npm run lint && npm run test:website && npm run typecheck:website && npm run verify:website-assets && npm run build:website && npm run verify:website-static && npm run test:e2e:website",
+    "verify:website": "npm run format && npm run lint && npm run test:website && npm run typecheck:website && npm run verify:website-assets && npm run verify:docs && npm run build:website && npm run verify:website-static && npm run test:e2e:website",
+    "verify:docs": "node scripts/verify-documentation-contract.mjs",
     "verify:website-static": "node scripts/verify-website-static.mjs",
     "package:check": "node scripts/verify-package.mjs",
     changeset: "changeset add",
@@ -54,7 +826,8 @@ var package_default = {
     "release:verify": "node scripts/release-artifact.mjs --verify-retained",
     "verify:website-assets": "node scripts/verify-website-assets.mjs",
     "release:version": "changeset version && npm install --package-lock-only --ignore-scripts --no-audit --no-fund",
-    prepare: "husky"
+    prepare: "husky",
+    check: "npm run verify && npm run verify:website"
   },
   repository: {
     type: "git",
@@ -79,6 +852,7 @@ var package_default = {
     commander: "^15.0.0",
     "fs-extra": "^11.4.0",
     ignore: "5.2.4",
+    postcss: "^8.5.26",
     winston: "^3.19.0"
   },
   bin: {
@@ -106,7 +880,6 @@ var package_default = {
     jsdom: "^30.0.1",
     "lint-staged": "^17.4.1",
     "mock-fs": "^5.5.0",
-    postcss: "^8.5.26",
     prettier: "^3.9.6",
     react: "^19.2.8",
     "react-dom": "^19.2.8",
@@ -219,130 +992,6 @@ function isKnownBreakpoint(value) {
   return breakpointNames.has(value);
 }
 
-// src/util/sha-256.ts
-var ROUND_CONSTANTS = Object.freeze([
-  1116352408,
-  1899447441,
-  3049323471,
-  3921009573,
-  961987163,
-  1508970993,
-  2453635748,
-  2870763221,
-  3624381080,
-  310598401,
-  607225278,
-  1426881987,
-  1925078388,
-  2162078206,
-  2614888103,
-  3248222580,
-  3835390401,
-  4022224774,
-  264347078,
-  604807628,
-  770255983,
-  1249150122,
-  1555081692,
-  1996064986,
-  2554220882,
-  2821834349,
-  2952996808,
-  3210313671,
-  3336571891,
-  3584528711,
-  113926993,
-  338241895,
-  666307205,
-  773529912,
-  1294757372,
-  1396182291,
-  1695183700,
-  1986661051,
-  2177026350,
-  2456956037,
-  2730485921,
-  2820302411,
-  3259730800,
-  3345764771,
-  3516065817,
-  3600352804,
-  4094571909,
-  275423344,
-  430227734,
-  506948616,
-  659060556,
-  883997877,
-  958139571,
-  1322822218,
-  1537002063,
-  1747873779,
-  1955562222,
-  2024104815,
-  2227730452,
-  2361852424,
-  2428436474,
-  2756734187,
-  3204031479,
-  3329325298
-]);
-var INITIAL_HASH = Object.freeze([
-  1779033703,
-  3144134277,
-  1013904242,
-  2773480762,
-  1359893119,
-  2600822924,
-  528734635,
-  1541459225
-]);
-function sha256(value) {
-  const source = new TextEncoder().encode(value);
-  const paddedLength = Math.ceil((source.length + 9) / 64) * 64;
-  const bytes = new Uint8Array(paddedLength);
-  bytes.set(source);
-  bytes[source.length] = 128;
-  const bitLength = source.length * 8;
-  const view = new DataView(bytes.buffer);
-  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
-  view.setUint32(paddedLength - 4, bitLength >>> 0);
-  const hash = [...INITIAL_HASH];
-  const schedule = new Uint32Array(64);
-  for (let offset = 0; offset < bytes.length; offset += 64) {
-    for (let index = 0; index < 16; index += 1) schedule[index] = view.getUint32(offset + index * 4);
-    for (let index = 16; index < schedule.length; index += 1) {
-      const earlier = schedule[index - 15];
-      const recent = schedule[index - 2];
-      const sigma0 = rotateRight(earlier, 7) ^ rotateRight(earlier, 18) ^ earlier >>> 3;
-      const sigma1 = rotateRight(recent, 17) ^ rotateRight(recent, 19) ^ recent >>> 10;
-      schedule[index] = schedule[index - 16] + sigma0 + schedule[index - 7] + sigma1 >>> 0;
-    }
-    let [a, b, c, d, e, f, g, h] = hash;
-    for (let index = 0; index < schedule.length; index += 1) {
-      const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
-      const choice = e & f ^ ~e & g;
-      const temporary1 = h + sum1 + choice + ROUND_CONSTANTS[index] + schedule[index] >>> 0;
-      const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
-      const majority = a & b ^ a & c ^ b & c;
-      const temporary2 = sum0 + majority >>> 0;
-      h = g;
-      g = f;
-      f = e;
-      e = d + temporary1 >>> 0;
-      d = c;
-      c = b;
-      b = a;
-      a = temporary1 + temporary2 >>> 0;
-    }
-    const round = [a, b, c, d, e, f, g, h];
-    for (let index = 0; index < hash.length; index += 1) hash[index] = hash[index] + round[index] >>> 0;
-  }
-  return hash.map((word) => word.toString(16).padStart(8, "0")).join("");
-}
-function rotateRight(value, count) {
-  return value >>> count | value << 32 - count;
-}
-
 // src/adapter/css/css-invariant.error.ts
 var CssInvariantError = class extends Error {
   constructor(message) {
@@ -426,8 +1075,8 @@ function canonicalIdentity(family, declarations, context) {
   });
 }
 var CssArtifactRegistry = class {
-  constructor(digest = sha256) {
-    this.digest = digest;
+  constructor(digest2 = sha256) {
+    this.digest = digest2;
   }
   rulesByCanonicalIdentity = /* @__PURE__ */ new Map();
   canonicalIdentityByDigest = /* @__PURE__ */ new Map();
@@ -649,7 +1298,8 @@ var CssRenderer = class {
   eligibility(input) {
     const family = this.cssFamily(input);
     if (family === void 0) return targetUnsupported(input);
-    if (input.breakpoint !== void 0 && !supportedBreakpoints.has(input.breakpoint)) return targetUnsupported(input);
+    if (input.breakpoint !== void 0 && !supportedBreakpoints.has(input.breakpoint) && !Object.hasOwn(this.breakpointConfig.sourceBreakpoints ?? {}, input.breakpoint))
+      return targetUnsupported(input);
     return void 0;
   }
   render(plan, _context) {
@@ -712,18 +1362,119 @@ var CssRenderer = class {
   }
 };
 
-// src/migrator/migration-application.error.ts
-var MigrationApplicationError = class extends Error {
-  constructor(code, message, paths = [], options) {
-    super(message, options);
-    this.code = code;
-    this.paths = paths;
-    this.name = "MigrationApplicationError";
-    this.paths = Object.freeze([...paths]);
-    this.recoveryFailures = Object.freeze([...options?.recoveryFailures ?? []]);
+// src/config/tailwind-builtin-variants.ts
+var tailwindBuiltinVariants = Object.freeze([
+  "*",
+  "**",
+  "@",
+  "@max",
+  "@min",
+  "active",
+  "after",
+  "any-pointer-coarse",
+  "any-pointer-fine",
+  "any-pointer-none",
+  "aria",
+  "autofill",
+  "backdrop",
+  "before",
+  "checked",
+  "contrast-less",
+  "contrast-more",
+  "dark",
+  "data",
+  "default",
+  "details-content",
+  "disabled",
+  "empty",
+  "enabled",
+  "even",
+  "file",
+  "first",
+  "first-letter",
+  "first-line",
+  "first-of-type",
+  "focus",
+  "focus-visible",
+  "focus-within",
+  "forced-colors",
+  "group",
+  "has",
+  "hover",
+  "in",
+  "in-range",
+  "indeterminate",
+  "inert",
+  "invalid",
+  "inverted-colors",
+  "landscape",
+  "last",
+  "last-of-type",
+  "ltr",
+  "marker",
+  "max",
+  "min",
+  "motion-reduce",
+  "motion-safe",
+  "noscript",
+  "not",
+  "nth",
+  "nth-last",
+  "nth-last-of-type",
+  "nth-of-type",
+  "odd",
+  "only",
+  "only-of-type",
+  "open",
+  "optional",
+  "out-of-range",
+  "peer",
+  "placeholder",
+  "placeholder-shown",
+  "pointer-coarse",
+  "pointer-fine",
+  "pointer-none",
+  "portrait",
+  "print",
+  "read-only",
+  "required",
+  "rtl",
+  "selection",
+  "starting",
+  "supports",
+  "target",
+  "user-invalid",
+  "user-valid",
+  "valid",
+  "visited"
+]);
+
+// src/config/tailwind-candidate-profile.ts
+function renderTargetCandidate(candidate, profile) {
+  const match = /^\[@media_screen_and_\(min-width:_(\d+(?:\.\d+)?)px\)\]:(.+)$/.exec(candidate);
+  if (match) {
+    const exact = Object.entries(profile.breakpoints).find(
+      ([name, setting]) => setting.confidence !== "unknown" && setting.value === `${match[1]}px` && isNamedBreakpoint(name)
+    );
+    if (exact) candidate = `[@media_screen]:${exact[0]}:${match[2]}`;
   }
-  recoveryFailures;
-};
+  return profile.prefix.value ? `${profile.prefix.value}:${candidate}` : candidate;
+}
+function normalizeTargetCandidate(candidate, profile) {
+  const prefix = profile.prefix.value;
+  if (prefix && candidate.startsWith(`${prefix}:`)) candidate = candidate.slice(prefix.length + 1);
+  const match = /^\[@media_screen\]:([^:]+):(.+)$/.exec(candidate);
+  if (match) {
+    const setting = profile.breakpoints[match[1]];
+    const width = setting?.value;
+    if (setting?.confidence !== "unknown" && isNamedBreakpoint(match[1]) && width?.endsWith("px"))
+      return `[@media_screen_and_(min-width:_${width})]:${match[2]}`;
+  }
+  return candidate;
+}
+function isNamedBreakpoint(name) {
+  return !tailwindBuiltinVariants.some((root) => name === root || name.startsWith(`${root}-`));
+}
 
 // src/edit/html-attribute-value.ts
 var htmlSourceWhitespace = /[\t\n\f\r ]/u;
@@ -897,7 +1648,10 @@ var BreakpointCatalog = class {
     this.configuredDefinitions = new Map([
       ...definitionsByAlias,
       ...config.orientationBreakpoints ? orientations.map((definition) => [definition.alias, definition]) : [],
-      ...config.printWithBreakpoints === void 0 ? [] : [[frozenPrintDefinition.alias, frozenPrintDefinition]]
+      ...config.printWithBreakpoints === void 0 ? [] : [[frozenPrintDefinition.alias, frozenPrintDefinition]],
+      ...Object.entries(config.sourceBreakpoints ?? {}).map(
+        ([alias, value]) => [alias, sourceBreakpointDefinition(alias, value)]
+      )
     ]);
   }
   classify(alias) {
@@ -2718,18 +3472,25 @@ var TailwindCandidateClassifier = class {
 
 // src/evidence/tailwind-source-property.evidence.ts
 var TailwindSourcePropertyEvidence = class {
+  constructor(profile) {
+    this.profile = profile;
+  }
   classifier = new TailwindCandidateClassifier();
   styleEncoder = new TailwindArbitraryPropertyEncoder();
   classifyClassToken(token) {
-    const classification = this.classifier.classify(token);
+    const prefix = this.profile?.prefix.value;
+    if (prefix && !token.startsWith(`${prefix}:`))
+      return { status: "unverified", reason: "Class is not a utility in the declared prefixed target." };
+    const normalized = prefix ? token.slice(prefix.length + 1) : token;
+    const classification = this.classifier.classify(normalized);
     if (classification.status === "unverified") return classification;
-    const display = describeTailwindDisplay(token);
+    const display = describeTailwindDisplay(normalized);
     return {
       status: "verified",
       evidence: {
         source: token,
         properties: classification.descriptor.cssProperties,
-        important: classification.descriptor.important,
+        important: classification.descriptor.important || this.profile?.important.value === "important",
         activation: classification.descriptor.activation,
         ...display === void 0 ? {} : { display: display.utility }
       }
@@ -3313,15 +4074,29 @@ function compatibleVisibilityClasses(plan, existingClassNames) {
 var TailwindRenderer = class {
   target = "tailwind";
   breakpointConfig;
-  sourcePropertyEvidence = new TailwindSourcePropertyEvidence();
+  sourcePropertyEvidence;
+  targetProfile;
   responsiveEmitter = new ResponsiveVariantEmitter();
   visibilityEmitter = new VisibilityEmitter();
   extendedEmitter = new ExtendedResponsiveEmitter();
   gridRenderer = new TailwindGridRenderer();
   constructor(config = { orientationBreakpoints: false }) {
+    this.targetProfile = config.targetProfile ?? resolveTailwindTargetProfile();
     this.breakpointConfig = Object.freeze({ ...config });
+    this.sourcePropertyEvidence = new TailwindSourcePropertyEvidence(this.targetProfile);
   }
   eligibility(input) {
+    const unresolved2 = this.targetProfile.diagnostics.filter(
+      (item) => item.code === "tailwind-prefix-conflict" || item.code === "tailwind-target-unknown" || ["tailwind-config-external", "tailwind-plugin-external", "tailwind-import-unresolved"].includes(item.code) && (this.targetProfile.coreUtilities.value === "unknown" || this.targetProfile.prefix.confidence !== "explicit" || this.targetProfile.important.confidence !== "explicit")
+    );
+    if (unresolved2.length)
+      return {
+        status: "review",
+        input,
+        code: "context-unverified",
+        reason: `Target configuration is unresolved: ${unresolved2.map((item) => item.message).join(" ")}`,
+        suggestion: "Resolve the target stylesheet or supply explicit migration profile settings before migrating."
+      };
     if (input.binding !== "property") {
       if (!sharedDirectives.has(input.directive) && !visibilityDirectives.has(input.directive) && !extendedDirectives.has(input.directive) && !gridDirectives.has(input.directive)) {
         return {
@@ -3335,7 +4110,12 @@ var TailwindRenderer = class {
     }
     return void 0;
   }
-  render(plan, _context) {
+  render(plan, context) {
+    const result2 = this.renderUnprefixed(plan, context);
+    if (result2.status !== "converted") return result2;
+    return { ...result2, classNames: result2.classNames.map((token) => renderTargetCandidate(token, this.targetProfile)) };
+  }
+  renderUnprefixed(plan, _context) {
     const inputFamily = directiveFamily(plan.input.directive);
     if (inputFamily !== plan.family) {
       throw new MigrationApplicationError(
@@ -3413,7 +4193,15 @@ var TailwindRenderer = class {
     };
   }
   resolveConflicts(plans, context) {
-    return this.resolveClassConflicts(plans, context.existingClassNames);
+    const normalize8 = (token) => normalizeTargetCandidate(token, this.targetProfile);
+    const normalized = plans.map(
+      (plan) => plan.status === "converted" ? { ...plan, classNames: plan.classNames.map((token) => normalize8(token)) } : plan
+    );
+    const resolved2 = this.resolveClassConflicts(
+      normalized,
+      context.existingClassNames.map((token) => normalize8(token))
+    );
+    return resolved2.map((plan, index) => plan.status === "converted" ? plans[index] : plan);
   }
   record(_plans) {
   }
@@ -3447,6 +4235,10 @@ var TailwindRenderer = class {
       } : plan
     );
   }
+  unprefix(token) {
+    const prefix = this.targetProfile.prefix.value;
+    return prefix && token.startsWith(`${prefix}:`) ? token.slice(prefix.length + 1) : token;
+  }
   decorate(classNames, plan) {
     return plan.activations.flatMap(
       (planActivation) => planActivation.kind === "base" ? classNames : classNames.flatMap((className) => this.responsiveEmitter.emit(planActivation.definition, className))
@@ -3489,7 +4281,7 @@ var TailwindRenderer = class {
             return this.extendedEmitter.emitClass({
               input: plan.input,
               activation: itemActivation,
-              value: { tokens: state.tokens.map((token) => token.source) }
+              value: { tokens: state.tokens.map((token) => this.unprefix(token.source)) }
             });
           })
         )
@@ -3615,7 +4407,7 @@ var AdapterFactory = class {
 };
 
 // src/pipeline/analyze/analyze-project.stage.ts
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 
 // src/analyzer/flex-layout-attribute.analyzer.ts
 var responsiveOnlyDirectives = /* @__PURE__ */ new Set(["class", "ngClass", "style", "ngStyle"]);
@@ -3801,10 +4593,10 @@ var AngularTemplateParser = class {
 };
 
 // src/pipeline/analyzed-project.ts
-import * as path2 from "path";
+import * as path4 from "path";
 
 // src/pipeline/project-manifest.ts
-import * as path from "path";
+import * as path3 from "path";
 function migrationInvocation(invocation) {
   return freezeMigrationInvocation({
     inputPath: invocation.inputPath,
@@ -3840,7 +4632,7 @@ function freezeMigrationInvocation(invocation) {
   });
 }
 function normalizedAbsolutePath(value) {
-  return path.normalize(path.resolve(value));
+  return path3.normalize(path3.resolve(value));
 }
 
 // src/pipeline/analyzed-project.ts
@@ -3935,7 +4727,7 @@ function freezeLocatedInput(input) {
   });
 }
 function normalizedAbsolutePath2(value) {
-  return path2.normalize(path2.resolve(value));
+  return path4.normalize(path4.resolve(value));
 }
 function sequenceInvariant(paths = []) {
   return internalInvariant(
@@ -3949,7 +4741,7 @@ function internalInvariant(message, paths = []) {
 
 // src/pipeline/analyze/analyze-project.stage.ts
 var nodeSourceReader = Object.freeze({
-  read: (path18) => readFile(path18, "utf8")
+  read: (path19) => readFile2(path19, "utf8")
 });
 var AnalyzeProjectStage = class {
   constructor(sourceReader = nodeSourceReader, parser = new AngularTemplateParser(), analyzer = new TemplateAnalyzer()) {
@@ -3996,13 +4788,13 @@ function runtimeArtifact(context, artifact) {
     [artifact.path]
   );
 }
-function identity(stat4) {
+function identity2(stat4) {
   return { dev: String(stat4.dev), ino: String(stat4.ino) };
 }
 function fileMode(stat4) {
   return Number(stat4.mode) & 4095;
 }
-function sameIdentity(left, right) {
+function sameIdentity2(left, right) {
   return left.dev === right.dev && left.ino === right.ino;
 }
 function sameArtifactState(left, right) {
@@ -4014,14 +4806,14 @@ function required(value) {
   if (value === void 0) throw new Error("Missing transaction state.");
   return value;
 }
-function isEnoent(error) {
+function isEnoent2(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function isDirectoryNotEmpty(error) {
   return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOTEMPTY" || error.code === "EEXIST");
 }
-function pathDepth(path18) {
-  return path18.split(/[\\/]/u).filter(Boolean).length;
+function pathDepth(path19) {
+  return path19.split(/[\\/]/u).filter(Boolean).length;
 }
 function recoveryOutcome(paths, failures) {
   return { paths: sortedUnique(paths), failures: Object.freeze([...failures]) };
@@ -4081,13 +4873,13 @@ var FileSystemCleanupUnit = class {
     try {
       await this.port.assertNamespace(item);
       const before = await this.port.lstat(owned.path);
-      if (!sameIdentity(identity(before), owned.identity) || before.isSymbolicLink() || !before.isFile()) {
+      if (!sameIdentity2(identity2(before), owned.identity) || before.isSymbolicLink() || !before.isFile()) {
         paths.add(owned.publicPath);
         failures.push(new Error("Invocation-owned file identity could not be confirmed."));
         return;
       }
     } catch (error) {
-      if (isEnoent(error)) {
+      if (isEnoent2(error)) {
         this.port.journal.markOwnedFileAbsent(item, owned.path);
         return;
       }
@@ -4098,13 +4890,13 @@ var FileSystemCleanupUnit = class {
     try {
       await this.port.unlink(owned.path);
     } catch (error) {
-      if (!isEnoent(error)) failures.push(error);
+      if (!isEnoent2(error)) failures.push(error);
     }
     try {
       await this.port.lstat(owned.path);
       paths.add(owned.publicPath);
     } catch (error) {
-      if (isEnoent(error)) this.port.journal.markOwnedFileAbsent(item, owned.path);
+      if (isEnoent2(error)) this.port.journal.markOwnedFileAbsent(item, owned.path);
       else {
         paths.add(owned.publicPath);
         failures.push(error);
@@ -4120,13 +4912,13 @@ var FileSystemCleanupUnit = class {
     }
     try {
       const namespaceStat = await this.port.lstat(namespace.path);
-      if (!sameIdentity(identity(namespaceStat), namespace.identity) || namespaceStat.isSymbolicLink() || !namespaceStat.isDirectory()) {
+      if (!sameIdentity2(identity2(namespaceStat), namespace.identity) || namespaceStat.isSymbolicLink() || !namespaceStat.isDirectory()) {
         paths.add(namespace.publicPath);
         failures.push(new Error("Invocation namespace identity could not be confirmed."));
         return;
       }
     } catch (error) {
-      if (isEnoent(error)) {
+      if (isEnoent2(error)) {
         this.port.journal.markNamespaceAbsent(item);
         return;
       }
@@ -4137,13 +4929,13 @@ var FileSystemCleanupUnit = class {
     try {
       await this.port.rmdir(namespace.path);
     } catch (error) {
-      if (!isDirectoryNotEmpty(error) && !isEnoent(error)) failures.push(error);
+      if (!isDirectoryNotEmpty(error) && !isEnoent2(error)) failures.push(error);
     }
     try {
       await this.port.lstat(namespace.path);
       paths.add(namespace.publicPath);
     } catch (error) {
-      if (isEnoent(error)) this.port.journal.markNamespaceAbsent(item);
+      if (isEnoent2(error)) this.port.journal.markNamespaceAbsent(item);
       else {
         paths.add(namespace.publicPath);
         failures.push(error);
@@ -4169,7 +4961,7 @@ var FileSystemCleanupUnit = class {
       try {
         before = await this.port.lstat(directory.path);
       } catch (error) {
-        if (isEnoent(error)) {
+        if (isEnoent2(error)) {
           this.port.journal.markCreatedDirectoryAbsent(directory.path);
           continue;
         }
@@ -4177,7 +4969,7 @@ var FileSystemCleanupUnit = class {
         failures.push(error);
         continue;
       }
-      if (!sameIdentity(identity(before), directory.identity) || before.isSymbolicLink() || !before.isDirectory()) {
+      if (!sameIdentity2(identity2(before), directory.identity) || before.isSymbolicLink() || !before.isDirectory()) {
         for (const publicPath of directory.publicPaths) paths.add(publicPath);
         continue;
       }
@@ -4192,17 +4984,17 @@ var FileSystemCleanupUnit = class {
         after = await this.port.lstatOrAbsent(directory.path);
       } catch (error) {
         for (const publicPath of directory.publicPaths) paths.add(publicPath);
-        if (removalFailure !== void 0 && !isEnoent(removalFailure)) failures.push(removalFailure);
+        if (removalFailure !== void 0 && !isEnoent2(removalFailure)) failures.push(removalFailure);
         failures.push(error);
         continue;
       }
       if (after === "absent") {
         this.port.journal.markCreatedDirectoryAbsent(directory.path);
-        if (removalFailure !== void 0 && !isEnoent(removalFailure)) failures.push(removalFailure);
+        if (removalFailure !== void 0 && !isEnoent2(removalFailure)) failures.push(removalFailure);
         continue;
       }
       for (const publicPath of directory.publicPaths) paths.add(publicPath);
-      if (removalFailure !== void 0 && !isEnoent(removalFailure)) failures.push(removalFailure);
+      if (removalFailure !== void 0 && !isEnoent2(removalFailure)) failures.push(removalFailure);
     }
   }
   async collectUnconfirmedPaths(paths, failures) {
@@ -4210,7 +5002,7 @@ var FileSystemCleanupUnit = class {
       try {
         await this.port.lstat(candidate);
       } catch (error) {
-        if (isEnoent(error)) continue;
+        if (isEnoent2(error)) continue;
         failures.push(error);
       }
       for (const publicPath of publicPaths) paths.add(publicPath);
@@ -4228,7 +5020,7 @@ var FileSystemCleanupUnit = class {
     if (!sameArtifactState(observed, item.artifact.original)) return false;
     if (observed.status === "absent") return true;
     return [item.originalIdentity, item.restoredIdentity].some(
-      (expected) => expected !== void 0 && sameIdentity(observed.identity, expected)
+      (expected) => expected !== void 0 && sameIdentity2(observed.identity, expected)
     );
   }
 };
@@ -4281,7 +5073,7 @@ var FileSystemCommitUnit = class {
   }
   async captureOriginal(item, signal) {
     const firstCapture = await this.port.observePublic(item);
-    if (!sameArtifactState(firstCapture, item.artifact.original) || firstCapture.status !== "present" || !item.originalIdentity || !sameIdentity(firstCapture.identity, item.originalIdentity)) {
+    if (!sameArtifactState(firstCapture, item.artifact.original) || firstCapture.status !== "present" || !item.originalIdentity || !sameIdentity2(firstCapture.identity, item.originalIdentity)) {
       throw this.port.concurrentModification(item.artifact.path);
     }
     const backup = await this.port.createBackupFile(item, firstCapture.contents, signal, firstCapture.mode);
@@ -4289,7 +5081,7 @@ var FileSystemCommitUnit = class {
       throw this.port.ownershipFailure(item.artifact.path);
     }
     const secondCapture = await this.port.observePublic(item);
-    if (secondCapture.status !== "present" || !sameIdentity(secondCapture.identity, firstCapture.identity) || secondCapture.contents !== firstCapture.contents) {
+    if (secondCapture.status !== "present" || !sameIdentity2(secondCapture.identity, firstCapture.identity) || secondCapture.contents !== firstCapture.contents) {
       throw this.port.concurrentModification(item.artifact.path);
     }
     await this.quarantineOriginal(item, firstCapture);
@@ -4298,7 +5090,7 @@ var FileSystemCommitUnit = class {
     await this.port.assertParentChain(item);
     await this.port.assertNamespace(item);
     const immediatelyBefore = await this.port.observePublic(item);
-    if (immediatelyBefore.status !== "present" || !sameIdentity(immediatelyBefore.identity, captured.identity) || immediatelyBefore.contents !== captured.contents) {
+    if (immediatelyBefore.status !== "present" || !sameIdentity2(immediatelyBefore.identity, captured.identity) || immediatelyBefore.contents !== captured.contents) {
       throw this.port.concurrentModification(item.artifact.path);
     }
     let quarantine = this.port.journal.addQuarantine(
@@ -4314,9 +5106,9 @@ var FileSystemCommitUnit = class {
     }
     const quarantinedStat = await this.port.lstatOrAbsent(quarantine.path);
     if (quarantinedStat !== "absent") {
-      quarantine = this.port.journal.confirmOwnedFile(item, quarantine.path, identity(quarantinedStat));
+      quarantine = this.port.journal.confirmOwnedFile(item, quarantine.path, identity2(quarantinedStat));
       const quarantinedContents = await this.port.readOwnedFile(item, quarantine.path);
-      if (!sameIdentity(required(quarantine.identity), captured.identity) || quarantinedContents !== captured.contents) {
+      if (!sameIdentity2(required(quarantine.identity), captured.identity) || quarantinedContents !== captured.contents) {
         this.port.journal.setOwnedFilePreserved(item, quarantine.path, true);
         await this.restorePreservedQuarantine(item, quarantine);
         throw this.port.concurrentModification(item.artifact.path, renameFailure);
@@ -4328,7 +5120,7 @@ var FileSystemCommitUnit = class {
       return;
     }
     const destination = await this.port.lstatOrAbsent(item.artifact.path);
-    if (renameFailure !== void 0 && destination !== "absent" && sameIdentity(identity(destination), captured.identity)) {
+    if (renameFailure !== void 0 && destination !== "absent" && sameIdentity2(identity2(destination), captured.identity)) {
       throw renameFailure;
     }
     throw this.port.concurrentModification(item.artifact.path, renameFailure);
@@ -4345,7 +5137,7 @@ var FileSystemCommitUnit = class {
       linkFailure = error;
     }
     const destination = await this.port.lstatOrAbsent(item.artifact.path);
-    if (destination !== "absent" && stage.identity && sameIdentity(identity(destination), stage.identity)) {
+    if (destination !== "absent" && stage.identity && sameIdentity2(identity2(destination), stage.identity)) {
       this.port.journal.recordInstalledIdentity(item, stage.identity);
       await this.port.assertParentChain(item);
       if (linkFailure !== void 0) throw linkFailure;
@@ -4364,7 +5156,7 @@ var FileSystemCommitUnit = class {
       this.port.journal.recordRecoveryFailure(error);
     }
     const destination = await this.port.lstatOrAbsent(item.artifact.path);
-    if (destination !== "absent" && sameIdentity(identity(destination), quarantineIdentity)) {
+    if (destination !== "absent" && sameIdentity2(identity2(destination), quarantineIdentity)) {
       this.port.journal.setOwnedFilePreserved(item, quarantine.path, false);
     }
   }
@@ -4426,8 +5218,8 @@ var FileSystemRollbackUnit = class {
     }
     if (current !== "unknown" && this.isConfirmedOriginal(item, current)) return;
     if (current !== "unknown" && current.status === "present") {
-      if (!item.installedIdentity || !sameIdentity(current.identity, item.installedIdentity) || item.artifact.proposed.status !== "present" || current.contents !== item.artifact.proposed.contents) {
-        if (item.stage && item.installedIdentity && sameIdentity(current.identity, item.installedIdentity)) {
+      if (!item.installedIdentity || !sameIdentity2(current.identity, item.installedIdentity) || item.artifact.proposed.status !== "present" || current.contents !== item.artifact.proposed.contents) {
+        if (item.stage && item.installedIdentity && sameIdentity2(current.identity, item.installedIdentity)) {
           this.port.journal.setOwnedFilePreserved(item, item.stage.path, true);
         }
         return;
@@ -4449,7 +5241,7 @@ var FileSystemRollbackUnit = class {
         failures.push(error);
       }
       const restored = await this.port.lstatOrAbsent(item.artifact.path);
-      if (restored !== "absent" && !restored.isSymbolicLink() && restored.isFile() && backup.identity && sameIdentity(identity(restored), backup.identity)) {
+      if (restored !== "absent" && !restored.isSymbolicLink() && restored.isFile() && backup.identity && sameIdentity2(identity2(restored), backup.identity)) {
         this.port.journal.recordRestoredIdentity(item, backup.identity);
       }
     } catch (error) {
@@ -4465,7 +5257,7 @@ var FileSystemRollbackUnit = class {
       await this.port.assertParentChain(item);
       await this.port.assertNamespace(item);
       const before = await this.port.observePublic(item);
-      if (before.status !== "present" || !sameIdentity(before.identity, current.identity) || before.contents !== current.contents) {
+      if (before.status !== "present" || !sameIdentity2(before.identity, current.identity) || before.contents !== current.contents) {
         return false;
       }
       await this.port.assertExpectedAbsent(quarantine.path, item.artifact.path);
@@ -4476,9 +5268,9 @@ var FileSystemRollbackUnit = class {
       }
       const quarantined = await this.port.lstatOrAbsent(quarantine.path);
       if (quarantined === "absent") return false;
-      quarantine = this.port.journal.confirmOwnedFile(item, quarantine.path, identity(quarantined));
+      quarantine = this.port.journal.confirmOwnedFile(item, quarantine.path, identity2(quarantined));
       this.port.journal.setOwnedFilePreserved(item, quarantine.path, true);
-      if (!sameIdentity(required(quarantine.identity), current.identity)) {
+      if (!sameIdentity2(required(quarantine.identity), current.identity)) {
         await this.restorePreservedQuarantine(item, quarantine, failures);
         return false;
       }
@@ -4502,7 +5294,7 @@ var FileSystemRollbackUnit = class {
       failures.push(error);
     }
     const destination = await this.port.lstatOrAbsent(item.artifact.path);
-    if (destination !== "absent" && sameIdentity(identity(destination), quarantineIdentity)) {
+    if (destination !== "absent" && sameIdentity2(identity2(destination), quarantineIdentity)) {
       this.port.journal.setOwnedFilePreserved(item, quarantine.path, false);
     }
   }
@@ -4518,7 +5310,7 @@ var FileSystemRollbackUnit = class {
     if (!sameArtifactState(observed, item.artifact.original)) return false;
     if (observed.status === "absent") return true;
     return [item.originalIdentity, item.restoredIdentity].some(
-      (expected) => expected !== void 0 && sameIdentity(observed.identity, expected)
+      (expected) => expected !== void 0 && sameIdentity2(observed.identity, expected)
     );
   }
 };
@@ -4593,7 +5385,7 @@ var FileSystemStagingUnit = class {
       if (createdStat.isSymbolicLink() || !createdStat.isDirectory()) {
         throw this.port.concurrentModification(item.artifact.path);
       }
-      this.port.journal.confirmCreatedDirectory(expectation.path, identity(createdStat));
+      this.port.journal.confirmCreatedDirectory(expectation.path, identity2(createdStat));
       if (parentExpectation) await this.port.assertExpectedDirectory(parentExpectation, item);
     }
     await this.port.assertParentChain(item);
@@ -4613,7 +5405,7 @@ var FileSystemStagingUnit = class {
     if (namespaceStat.isSymbolicLink() || !namespaceStat.isDirectory()) {
       throw this.port.concurrentModification(item.artifact.path);
     }
-    this.port.journal.confirmNamespace(item, identity(namespaceStat));
+    this.port.journal.confirmNamespace(item, identity2(namespaceStat));
     await this.port.assertParentChain(item);
   }
 };
@@ -4646,17 +5438,17 @@ var TransactionSignalRegistrar = class {
 
 // src/transaction/transaction-unit.session.ts
 import { constants } from "fs";
-import { access, link, lstat, mkdir, open, rename, rmdir, stat, unlink } from "fs/promises";
+import { access, link, lstat as lstat2, mkdir, open, rename, rmdir, stat as stat2, unlink } from "fs/promises";
 import { dirname as dirname2, join as join4, resolve as resolve3 } from "path";
 var nodeTransactionOperations = {
   access,
   link,
-  lstat,
+  lstat: lstat2,
   mkdir,
   open: (target, flags) => open(target, flags),
   rename,
   rmdir,
-  stat,
+  stat: stat2,
   unlink
 };
 var TransactionUnitSession = class {
@@ -4677,30 +5469,30 @@ var TransactionUnitSession = class {
     const journal = Object.freeze({
       prepare: (artifacts) => this.prepare(artifacts),
       artifacts: () => Object.freeze(this.context.items.map(stagingArtifactView)),
-      createdDirectory: (path18) => createdDirectoryView(this.context.createdDirectories.get(path18)),
-      addCreatedDirectoryPublicPath: (path18, publicPath) => required(this.context.createdDirectories.get(path18)).publicPaths.add(publicPath),
-      recordUnconfirmedEntry: (path18, publicPath) => this.recordUnconfirmedEntry(path18, publicPath),
-      recordCreatedDirectory: (path18, publicPath) => this.recordCreatedDirectory(path18, publicPath),
-      confirmCreatedDirectory: (path18, expected) => {
-        required(this.context.createdDirectories.get(path18)).identity = expected;
+      createdDirectory: (path19) => createdDirectoryView(this.context.createdDirectories.get(path19)),
+      addCreatedDirectoryPublicPath: (path19, publicPath) => required(this.context.createdDirectories.get(path19)).publicPaths.add(publicPath),
+      recordUnconfirmedEntry: (path19, publicPath) => this.recordUnconfirmedEntry(path19, publicPath),
+      recordCreatedDirectory: (path19, publicPath) => this.recordCreatedDirectory(path19, publicPath),
+      confirmCreatedDirectory: (path19, expected) => {
+        required(this.context.createdDirectories.get(path19)).identity = expected;
       },
-      recordNamespace: (item, path18) => this.recordNamespace(item.artifact, path18),
+      recordNamespace: (item, path19) => this.recordNamespace(item.artifact, path19),
       confirmNamespace: (item, expected) => {
         required(this.runtimeArtifact(item.artifact).namespace).identity = expected;
       }
     });
     return Object.freeze({
       journal,
-      assertDirectoryExpectation: (path18, expected, publicPath) => this.assertDirectoryExpectation(path18, expected, publicPath),
-      assertDirectoryIdentity: (path18, expected, publicPath) => this.assertDirectoryIdentity(path18, expected, publicPath),
-      assertExpectedAbsent: (path18, publicPath) => this.assertExpectedAbsent(path18, publicPath),
+      assertDirectoryExpectation: (path19, expected, publicPath) => this.assertDirectoryExpectation(path19, expected, publicPath),
+      assertDirectoryIdentity: (path19, expected, publicPath) => this.assertDirectoryIdentity(path19, expected, publicPath),
+      assertExpectedAbsent: (path19, publicPath) => this.assertExpectedAbsent(path19, publicPath),
       assertExpectedDirectory: (expectation, item) => this.assertExpectedDirectory(expectation, this.runtimeArtifact(item.artifact), this.context),
       assertNotInterrupted: (signal) => this.assertNotInterrupted(signal),
       assertParentChain: (item) => this.assertParentChain(this.runtimeArtifact(item.artifact), this.context),
       concurrentModification: (publicPath, cause) => this.concurrentModification(publicPath, cause),
       createStageFile: (item, contents, signal, mode) => this.createStageFile(this.runtimeArtifact(item.artifact), contents, signal, mode),
-      lstat: (path18) => this.operations.lstat(path18),
-      mkdir: (path18, options) => this.operations.mkdir(path18, options),
+      lstat: (path19) => this.operations.lstat(path19),
+      mkdir: (path19, options) => this.operations.mkdir(path19, options),
       readOwnedFile: (item, ownedPath) => {
         const runtime = this.runtimeArtifact(item.artifact);
         return this.readOwnedFile(runtime, this.ownedFile(runtime, ownedPath));
@@ -4712,7 +5504,7 @@ var TransactionUnitSession = class {
     const journal = Object.freeze({
       artifact: (artifact) => commitArtifactView(this.runtimeArtifact(artifact)),
       artifacts: () => Object.freeze(this.context.items.map(commitArtifactView)),
-      addQuarantine: (item, path18) => ownedFileView(this.addQuarantine(this.runtimeArtifact(item.artifact), path18)),
+      addQuarantine: (item, path19) => ownedFileView(this.addQuarantine(this.runtimeArtifact(item.artifact), path19)),
       confirmOwnedFile: (item, ownedPath, expected) => ownedFileView(this.confirmOwnedFile(this.runtimeArtifact(item.artifact), ownedPath, expected)),
       setOwnedFilePreserved: (item, ownedPath, preserve) => {
         this.ownedFile(this.runtimeArtifact(item.artifact), ownedPath).preserve = preserve;
@@ -4724,7 +5516,7 @@ var TransactionUnitSession = class {
     });
     return Object.freeze({
       journal,
-      assertExpectedAbsent: (path18, publicPath) => this.assertExpectedAbsent(path18, publicPath),
+      assertExpectedAbsent: (path19, publicPath) => this.assertExpectedAbsent(path19, publicPath),
       assertNamespace: (item) => this.assertNamespace(this.runtimeArtifact(item.artifact)),
       assertNotInterrupted: (signal) => this.assertNotInterrupted(signal),
       assertOwnedIdentity: (item, ownedPath) => {
@@ -4735,7 +5527,7 @@ var TransactionUnitSession = class {
       concurrentModification: (publicPath, cause) => this.concurrentModification(publicPath, cause),
       createBackupFile: (item, contents, signal, mode) => this.createBackupFile(this.runtimeArtifact(item.artifact), contents, signal, mode),
       link: (existingPath, newPath) => this.operations.link(existingPath, newPath),
-      lstatOrAbsent: (path18) => this.lstatOrAbsent(path18),
+      lstatOrAbsent: (path19) => this.lstatOrAbsent(path19),
       observePublic: (item) => this.observePublic(this.runtimeArtifact(item.artifact), this.context),
       ownershipFailure: (publicPath) => this.ownershipFailure(publicPath),
       readOwnedFile: (item, ownedPath) => {
@@ -4750,7 +5542,7 @@ var TransactionUnitSession = class {
       artifact: (artifact) => rollbackArtifactView(this.runtimeArtifact(artifact)),
       artifacts: () => Object.freeze(this.context.items.map(rollbackArtifactView)),
       recoveryFailures: () => Object.freeze([...this.context.recoveryFailures]),
-      addQuarantine: (item, path18) => ownedFileView(this.addQuarantine(this.runtimeArtifact(item.artifact), path18)),
+      addQuarantine: (item, path19) => ownedFileView(this.addQuarantine(this.runtimeArtifact(item.artifact), path19)),
       confirmOwnedFile: (item, ownedPath, expected) => ownedFileView(this.confirmOwnedFile(this.runtimeArtifact(item.artifact), ownedPath, expected)),
       setOwnedFilePreserved: (item, ownedPath, preserve) => {
         this.ownedFile(this.runtimeArtifact(item.artifact), ownedPath).preserve = preserve;
@@ -4764,11 +5556,11 @@ var TransactionUnitSession = class {
     });
     return Object.freeze({
       journal,
-      assertExpectedAbsent: (path18, publicPath) => this.assertExpectedAbsent(path18, publicPath),
+      assertExpectedAbsent: (path19, publicPath) => this.assertExpectedAbsent(path19, publicPath),
       assertNamespace: (item) => this.assertNamespace(this.runtimeArtifact(item.artifact)),
       assertParentChain: (item) => this.assertParentChain(this.runtimeArtifact(item.artifact), this.context),
       link: (existingPath, newPath) => this.operations.link(existingPath, newPath),
-      lstatOrAbsent: (path18) => this.lstatOrAbsent(path18),
+      lstatOrAbsent: (path19) => this.lstatOrAbsent(path19),
       observePublic: (item) => this.observePublic(this.runtimeArtifact(item.artifact), this.context),
       readOwnedFile: (item, ownedPath) => {
         const runtime = this.runtimeArtifact(item.artifact);
@@ -4790,8 +5582,8 @@ var TransactionUnitSession = class {
       markNamespaceAbsent: (item) => {
         required(this.runtimeArtifact(item.artifact).namespace).exists = false;
       },
-      markCreatedDirectoryAbsent: (path18) => {
-        required(this.context.createdDirectories.get(path18)).exists = false;
+      markCreatedDirectoryAbsent: (path19) => {
+        required(this.context.createdDirectories.get(path19)).exists = false;
         this.context.ownershipChanged();
       },
       finishArtifactCleanup: () => this.context.ownershipChanged()
@@ -4801,11 +5593,11 @@ var TransactionUnitSession = class {
       assertNamespace: (item) => this.assertNamespace(this.runtimeArtifact(item.artifact)),
       closeReadHandles: (item, failures) => this.closeReadHandles(this.runtimeArtifact(item.artifact), failures),
       closeOpenHandle: (item, failures) => this.closeOpenHandle(this.runtimeArtifact(item.artifact), failures),
-      lstat: (path18) => this.operations.lstat(path18),
-      lstatOrAbsent: (path18) => this.lstatOrAbsent(path18),
+      lstat: (path19) => this.operations.lstat(path19),
+      lstatOrAbsent: (path19) => this.lstatOrAbsent(path19),
       observePublic: (item) => this.observePublic(this.runtimeArtifact(item.artifact), this.context),
-      rmdir: (path18) => this.operations.rmdir(path18),
-      unlink: (path18) => this.operations.unlink(path18)
+      rmdir: (path19) => this.operations.rmdir(path19),
+      unlink: (path19) => this.operations.unlink(path19)
     });
   }
   async prepareForPreflight(artifacts) {
@@ -4880,16 +5672,16 @@ var TransactionUnitSession = class {
           result2.push({
             path: candidate,
             original: {
-              identity: identity(candidateStat),
+              identity: identity2(candidateStat),
               kind: "symbolic-link",
-              followedIdentity: identity(followed)
+              followedIdentity: identity2(followed)
             }
           });
         } else {
-          result2.push({ path: candidate, original: { identity: identity(candidateStat), kind: "directory" } });
+          result2.push({ path: candidate, original: { identity: identity2(candidateStat), kind: "directory" } });
         }
       } catch (error) {
-        if (!isEnoent(error)) throw error;
+        if (!isEnoent2(error)) throw error;
         missing = true;
         result2.push({ path: candidate, original: "absent" });
       }
@@ -4914,9 +5706,9 @@ var TransactionUnitSession = class {
     await this.writeOwnedFile(item, owned, contents, signal, mode);
     return ownedFileView(owned);
   }
-  registerOwnedFile(item, path18) {
+  registerOwnedFile(item, path19) {
     const owned = {
-      path: path18,
+      path: path19,
       publicPath: item.artifact.path,
       exists: false,
       preserve: false
@@ -4931,7 +5723,7 @@ var TransactionUnitSession = class {
     item.openHandle = handle;
     this.context.ownershipChanged();
     if (mode !== void 0) await handle.chmod(mode);
-    owned.identity = identity(await handle.stat());
+    owned.identity = identity2(await handle.stat());
     this.assertNotInterrupted(signal);
     await handle.writeFile(contents, "utf8");
     this.assertNotInterrupted(signal);
@@ -4945,48 +5737,48 @@ var TransactionUnitSession = class {
   runtimeArtifact(artifact) {
     return runtimeArtifact(this.context, artifact);
   }
-  ownedFile(item, path18) {
-    const owned = item.ownedFiles.find((candidate) => candidate.path === path18);
+  ownedFile(item, path19) {
+    const owned = item.ownedFiles.find((candidate) => candidate.path === path19);
     if (owned !== void 0) return owned;
     throw new MigrationApplicationError(
       "internal-invariant",
-      `Migration transaction journal contains an unknown invocation-owned file: ${path18}`,
+      `Migration transaction journal contains an unknown invocation-owned file: ${path19}`,
       [item.artifact.path]
     );
   }
-  addQuarantine(item, path18) {
-    const quarantine = this.registerOwnedFile(item, path18);
+  addQuarantine(item, path19) {
+    const quarantine = this.registerOwnedFile(item, path19);
     item.quarantines.push(quarantine);
     return quarantine;
   }
-  confirmOwnedFile(item, path18, expected) {
-    const owned = this.ownedFile(item, path18);
+  confirmOwnedFile(item, path19, expected) {
+    const owned = this.ownedFile(item, path19);
     owned.exists = true;
     owned.identity = expected;
     return owned;
   }
-  recordNamespace(artifact, path18) {
+  recordNamespace(artifact, path19) {
     const item = this.runtimeArtifact(artifact);
-    item.namespace = { path: path18, publicPath: item.artifact.path, exists: true };
+    item.namespace = { path: path19, publicPath: item.artifact.path, exists: true };
     this.context.ownershipChanged();
   }
-  recordCreatedDirectory(path18, publicPath) {
-    this.context.createdDirectories.set(path18, {
-      path: path18,
+  recordCreatedDirectory(path19, publicPath) {
+    this.context.createdDirectories.set(path19, {
+      path: path19,
       publicPaths: /* @__PURE__ */ new Set([publicPath]),
       exists: true
     });
     this.context.ownershipChanged();
   }
-  recordUnconfirmedEntry(path18, publicPath) {
-    const publicPaths = this.context.unconfirmedEntries.get(path18) ?? /* @__PURE__ */ new Set();
+  recordUnconfirmedEntry(path19, publicPath) {
+    const publicPaths = this.context.unconfirmedEntries.get(path19) ?? /* @__PURE__ */ new Set();
     publicPaths.add(publicPath);
-    this.context.unconfirmedEntries.set(path18, publicPaths);
+    this.context.unconfirmedEntries.set(path19, publicPaths);
   }
   unconfirmedEntryViews() {
     return Object.freeze(
       [...this.context.unconfirmedEntries].map(
-        ([path18, publicPaths]) => Object.freeze({ path: path18, publicPaths: Object.freeze([...publicPaths]) })
+        ([path19, publicPaths]) => Object.freeze({ path: path19, publicPaths: Object.freeze([...publicPaths]) })
       )
     );
   }
@@ -5018,18 +5810,18 @@ var TransactionUnitSession = class {
         [item.artifact.path]
       );
     }
-    const beforeIdentity = identity(before);
+    const beforeIdentity = identity2(before);
     const handle = await this.operations.open(item.artifact.path, "r");
     const contents = await this.readThroughHandle(item, handle, async () => {
-      const handleBefore = identity(await handle.stat());
-      if (!sameIdentity(beforeIdentity, handleBefore)) throw this.concurrentModification(item.artifact.path);
+      const handleBefore = identity2(await handle.stat());
+      if (!sameIdentity2(beforeIdentity, handleBefore)) throw this.concurrentModification(item.artifact.path);
       const read = await handle.readFile({ encoding: "utf8" });
-      const handleAfter = identity(await handle.stat());
-      if (!sameIdentity(handleBefore, handleAfter)) throw this.concurrentModification(item.artifact.path);
+      const handleAfter = identity2(await handle.stat());
+      if (!sameIdentity2(handleBefore, handleAfter)) throw this.concurrentModification(item.artifact.path);
       return read;
     });
     const after = await this.lstatOrAbsent(item.artifact.path);
-    if (after === "absent" || after.isSymbolicLink() || !after.isFile() || !sameIdentity(beforeIdentity, identity(after))) {
+    if (after === "absent" || after.isSymbolicLink() || !after.isFile() || !sameIdentity2(beforeIdentity, identity2(after))) {
       throw this.concurrentModification(item.artifact.path);
     }
     await this.assertParentChain(item, context);
@@ -5040,11 +5832,11 @@ var TransactionUnitSession = class {
     const expected = required(owned.identity);
     const handle = await this.operations.open(owned.path, "r");
     const contents = await this.readThroughHandle(item, handle, async () => {
-      const before = identity(await handle.stat());
-      if (!sameIdentity(before, expected)) throw this.ownershipFailure(owned.publicPath);
+      const before = identity2(await handle.stat());
+      if (!sameIdentity2(before, expected)) throw this.ownershipFailure(owned.publicPath);
       const read = await handle.readFile({ encoding: "utf8" });
-      const after = identity(await handle.stat());
-      if (!sameIdentity(after, expected)) throw this.ownershipFailure(owned.publicPath);
+      const after = identity2(await handle.stat());
+      if (!sameIdentity2(after, expected)) throw this.ownershipFailure(owned.publicPath);
       return read;
     });
     await this.assertOwnedIdentity(item, owned);
@@ -5103,7 +5895,7 @@ var TransactionUnitSession = class {
     await this.assertNamespace(item);
     if (!owned.identity) throw this.ownershipFailure(owned.publicPath);
     const ownedStat = await this.operations.lstat(owned.path);
-    if (ownedStat.isSymbolicLink() || !ownedStat.isFile() || !sameIdentity(identity(ownedStat), owned.identity)) {
+    if (ownedStat.isSymbolicLink() || !ownedStat.isFile() || !sameIdentity2(identity2(ownedStat), owned.identity)) {
       throw this.ownershipFailure(owned.publicPath);
     }
     await this.assertNamespace(item);
@@ -5112,7 +5904,7 @@ var TransactionUnitSession = class {
     const namespace = required(item.namespace);
     const expectedIdentity = required(namespace.identity);
     const namespaceStat = await this.operations.lstat(namespace.path);
-    if (namespaceStat.isSymbolicLink() || !namespaceStat.isDirectory() || !sameIdentity(identity(namespaceStat), expectedIdentity)) {
+    if (namespaceStat.isSymbolicLink() || !namespaceStat.isDirectory() || !sameIdentity2(identity2(namespaceStat), expectedIdentity)) {
       throw this.ownershipFailure(namespace.publicPath);
     }
   }
@@ -5131,54 +5923,54 @@ var TransactionUnitSession = class {
     }
     await this.assertDirectoryExpectation(expectation.path, expectation.original, item.artifact.path);
   }
-  async assertDirectoryExpectation(path18, expected, publicPath) {
+  async assertDirectoryExpectation(path19, expected, publicPath) {
     let pathStat;
     try {
-      pathStat = await this.operations.lstat(path18);
+      pathStat = await this.operations.lstat(path19);
     } catch (error) {
       throw this.concurrentModification(publicPath, error);
     }
     const kind = pathStat.isSymbolicLink() ? "symbolic-link" : pathStat.isDirectory() ? "directory" : void 0;
-    if (kind !== expected.kind || !sameIdentity(identity(pathStat), expected.identity)) {
+    if (kind !== expected.kind || !sameIdentity2(identity2(pathStat), expected.identity)) {
       throw this.concurrentModification(publicPath);
     }
     if (expected.kind === "symbolic-link") {
       let followed;
       try {
-        followed = await this.operations.stat(path18);
+        followed = await this.operations.stat(path19);
       } catch (error) {
         throw this.concurrentModification(publicPath, error);
       }
-      if (!followed.isDirectory() || !sameIdentity(identity(followed), expected.followedIdentity)) {
+      if (!followed.isDirectory() || !sameIdentity2(identity2(followed), expected.followedIdentity)) {
         throw this.concurrentModification(publicPath);
       }
     }
   }
-  async assertDirectoryIdentity(path18, expected, publicPath) {
+  async assertDirectoryIdentity(path19, expected, publicPath) {
     let pathStat;
     try {
-      pathStat = await this.operations.lstat(path18);
+      pathStat = await this.operations.lstat(path19);
     } catch (error) {
       throw this.concurrentModification(publicPath, error);
     }
-    if (pathStat.isSymbolicLink() || !pathStat.isDirectory() || !sameIdentity(identity(pathStat), expected)) {
+    if (pathStat.isSymbolicLink() || !pathStat.isDirectory() || !sameIdentity2(identity2(pathStat), expected)) {
       throw this.concurrentModification(publicPath);
     }
   }
-  async assertExpectedAbsent(path18, publicPath) {
+  async assertExpectedAbsent(path19, publicPath) {
     try {
-      await this.operations.lstat(path18);
+      await this.operations.lstat(path19);
     } catch (error) {
-      if (isEnoent(error)) return;
+      if (isEnoent2(error)) return;
       throw error;
     }
     throw this.concurrentModification(publicPath);
   }
-  async lstatOrAbsent(path18) {
+  async lstatOrAbsent(path19) {
     try {
-      return await this.operations.lstat(path18);
+      return await this.operations.lstat(path19);
     } catch (error) {
-      if (isEnoent(error)) return "absent";
+      if (isEnoent2(error)) return "absent";
       throw error;
     }
   }
@@ -5212,9 +6004,9 @@ var TransactionUnitSession = class {
     );
   }
 };
-function directoryChain(path18) {
+function directoryChain(path19) {
   const result2 = [];
-  let current = resolve3(path18);
+  let current = resolve3(path19);
   while (true) {
     result2.unshift(current);
     const parent = dirname2(current);
@@ -5401,7 +6193,7 @@ var MigrationTransaction = class {
     }
   }
   rejectParseErrors(plan) {
-    const paths = plan.files.flatMap((file) => file.results.filter((result2) => result2.status === "parse-error").map((result2) => result2.fileName)).filter((path18, index, all) => all.indexOf(path18) === index).sort(compareCodeUnits);
+    const paths = plan.files.flatMap((file) => file.results.filter((result2) => result2.status === "parse-error").map((result2) => result2.fileName)).filter((path19, index, all) => all.indexOf(path19) === index).sort(compareCodeUnits);
     if (paths.length === 0) return;
     throw new MigrationApplicationError(
       "internal-invariant",
@@ -5520,6 +6312,13 @@ var ApplyProjectStage = class {
       );
     }
     const plan = validated.plan;
+    const snapshots = validated.rendered.analyzed.manifest.invocation.options.configurationSnapshots ?? [];
+    await assertConfigurationUnchanged(snapshots);
+    for (const artifact of plan.artifacts)
+      for (const snapshot of snapshots) {
+        if (await pathsOverlapOnFileSystem(artifact.path, snapshot.path))
+          throw new Error(`Migration output collides with target configuration: ${artifact.path}`);
+      }
     const hasParseError = plan.files.some((file) => file.results.some((result2) => result2.status === "parse-error"));
     if (this.mode === "plan") {
       if (!hasParseError) await this.transaction.preflight(plan);
@@ -5529,27 +6328,28 @@ var ApplyProjectStage = class {
       return appliedProject({ validated, application: { status: "skipped", reason: "parse-errors" } });
     }
     await this.transaction.preflight(plan);
+    await assertConfigurationUnchanged(snapshots);
     if (plan.artifacts.length > 0) await this.transaction.apply(plan);
     return appliedProject({ validated, application: { status: "applied" } });
   }
 };
 
 // src/pipeline/discover/discover-project.stage.ts
-import { readdir, stat as stat2 } from "fs/promises";
-import * as path4 from "path";
+import { readdir, stat as stat3 } from "fs/promises";
+import * as path6 from "path";
 
 // src/lib/gitignore.helper.ts
 import fs from "fs-extra";
 import ignore from "ignore";
-import path3 from "path";
+import path5 from "path";
 async function createGitIgnoreMatcher(root, displayRoot = root) {
   const matcher = ignore();
-  const gitignorePath = path3.join(root, ".gitignore");
+  const gitignorePath = path5.join(root, ".gitignore");
   if (await fs.pathExists(gitignorePath)) {
     matcher.add(await fs.readFile(gitignorePath, "utf8"));
-    logger.debug(`Loaded .gitignore file from ${path3.join(displayRoot, ".gitignore")}`);
+    logger.debug(`Loaded .gitignore file from ${path5.join(displayRoot, ".gitignore")}`);
   }
-  const relativeIgnorePath = (candidate) => path3.relative(root, candidate).split(path3.sep).join("/");
+  const relativeIgnorePath = (candidate) => path5.relative(root, candidate).split(path5.sep).join("/");
   return Object.freeze({
     ignores: (candidate) => matcher.ignores(relativeIgnorePath(candidate)),
     ignoresDirectory: (candidate) => matcher.ignores(`${relativeIgnorePath(candidate)}/`)
@@ -5559,7 +6359,7 @@ async function createGitIgnoreMatcher(root, displayRoot = root) {
 // src/pipeline/discover/discover-project.stage.ts
 var nodeFileSystem = Object.freeze({
   async kind(candidate) {
-    const candidateStat = await stat2(candidate);
+    const candidateStat = await stat3(candidate);
     if (candidateStat.isFile()) return "file";
     if (candidateStat.isDirectory()) return "directory";
     return "other";
@@ -5594,10 +6394,10 @@ var DiscoverProjectStage = class {
     return projectManifest({ invocation, templates });
   }
   singleFile(invocation) {
-    if (path4.extname(invocation.canonicalInputPath).toLowerCase() !== ".html") {
+    if (path6.extname(invocation.canonicalInputPath).toLowerCase() !== ".html") {
       throw new Error(`Unsupported file type: ${invocation.inputPath}`);
     }
-    if (path4.extname(invocation.canonicalOutputPath).toLowerCase() !== ".html") {
+    if (path6.extname(invocation.canonicalOutputPath).toLowerCase() !== ".html") {
       throw new Error("Single-file output path must have a .html extension.");
     }
     return [{ inputPath: invocation.canonicalInputPath, outputPath: invocation.canonicalOutputPath }];
@@ -5610,7 +6410,7 @@ var DiscoverProjectStage = class {
     inputs.sort(compareCodeUnits);
     return inputs.map((inputPath) => ({
       inputPath,
-      outputPath: path4.join(invocation.canonicalOutputPath, path4.relative(root, inputPath))
+      outputPath: path6.join(invocation.canonicalOutputPath, path6.relative(root, inputPath))
     }));
   }
   async collectInputs(directory, displayDirectory, matcher, exclusions) {
@@ -5619,30 +6419,30 @@ var DiscoverProjectStage = class {
     );
     const inputs = [];
     for (const entry of entries) {
-      const candidate = path4.join(directory, entry.name);
-      const displayCandidate = path4.join(displayDirectory, entry.name);
+      const candidate = path6.join(directory, entry.name);
+      const displayCandidate = path6.join(displayDirectory, entry.name);
       logger.debug(`Processing ${displayCandidate}`);
       const ignored = entry.kind === "directory" ? matcher.ignoresDirectory(candidate) : matcher.ignores(candidate);
-      if (ignored || exclusions.has(path4.normalize(candidate))) continue;
+      if (ignored || exclusions.has(path6.normalize(candidate))) continue;
       const kind = entry.kind === "other" ? await this.fileSystem.kind(candidate) : entry.kind;
       if (entry.kind === "other" && kind === "directory" && matcher.ignoresDirectory(candidate)) continue;
       if (kind === "directory") {
         inputs.push(...await this.collectInputs(candidate, displayCandidate, matcher, exclusions));
-      } else if (kind === "file" && path4.extname(entry.name).toLowerCase() === ".html") {
-        inputs.push(path4.normalize(path4.resolve(candidate)));
+      } else if (kind === "file" && path6.extname(entry.name).toLowerCase() === ".html") {
+        inputs.push(path6.normalize(path6.resolve(candidate)));
       }
     }
     return inputs;
   }
   excludedPaths(invocation) {
-    const candidates = [invocation.options.stylesheetPath, invocation.options.reportPath].filter((candidate) => candidate !== void 0).map((candidate) => path4.normalize(path4.resolve(candidate)));
+    const candidates = [invocation.options.stylesheetPath, invocation.options.reportPath].filter((candidate) => candidate !== void 0).map((candidate) => path6.normalize(path6.resolve(candidate)));
     const outputRoot = invocation.canonicalOutputPath;
-    if (path4.relative(invocation.canonicalInputPath, outputRoot) !== "") candidates.push(outputRoot);
+    if (path6.relative(invocation.canonicalInputPath, outputRoot) !== "") candidates.push(outputRoot);
     return new Set(candidates);
   }
 };
 function preserveTrailingSeparator(canonicalPath, rawPath) {
-  return /[\\/]$/u.test(rawPath) && !/[\\/]$/u.test(canonicalPath) ? `${canonicalPath}${path4.sep}` : canonicalPath;
+  return /[\\/]$/u.test(rawPath) && !/[\\/]$/u.test(canonicalPath) ? `${canonicalPath}${path6.sep}` : canonicalPath;
 }
 
 // src/pipeline/pipeline-stage.error.ts
@@ -5684,7 +6484,7 @@ async function runStage(stage, action) {
 }
 
 // src/report/migration-report.builder.ts
-import path5 from "path";
+import path7 from "path";
 var MigrationReportBuilder = class {
   build(inputRoot, outputRoot, target, mode, application, durationMs, files, stylesheet) {
     const pathApi = this.pathApi(
@@ -5718,9 +6518,9 @@ var MigrationReportBuilder = class {
     return { path: this.forwardSlashes(pathApi, displayPath), change: stylesheet.change };
   }
   pathApi(...values) {
-    if (values.some((value) => /^[A-Za-z]:[\\/]/.test(value) || value.includes("\\"))) return path5.win32;
-    if (values.some((value) => value.includes("/"))) return path5.posix;
-    return path5;
+    if (values.some((value) => /^[A-Za-z]:[\\/]/.test(value) || value.includes("\\"))) return path7.win32;
+    if (values.some((value) => value.includes("/"))) return path7.posix;
+    return path7;
   }
   samePath(pathApi, left, right) {
     return this.absolutePath(pathApi, left) === this.absolutePath(pathApi, right);
@@ -5797,9 +6597,16 @@ var MigrationReportBuilder = class {
     };
   }
 };
+function withReportEnvironment(report, options) {
+  return {
+    ...report,
+    ...options.targetProfile ? { targetProfile: options.targetProfile } : {},
+    ...options.sourceBreakpoints ? { sourceBreakpoints: options.sourceBreakpoints } : {}
+  };
+}
 
 // src/pipeline/invocation-error-path.mapper.ts
-import * as path6 from "path";
+import * as path8 from "path";
 function remapInvocationErrorPaths(error, invocation) {
   if (!(error instanceof Error)) return error;
   const roots = invocationRoots(invocation);
@@ -5823,12 +6630,12 @@ function remapErrorPath(error, field, roots) {
   error[field] = mapped;
 }
 function mappedInvocationPath(candidate, roots) {
-  if (!path6.isAbsolute(candidate)) return candidate;
+  if (!path8.isAbsolute(candidate)) return candidate;
   for (const root of roots) {
-    const relativePath = path6.relative(root.canonical, candidate);
+    const relativePath = path8.relative(root.canonical, candidate);
     if (relativePath === "") return root.raw;
-    if (relativePath === ".." || relativePath.startsWith(`..${path6.sep}`) || path6.isAbsolute(relativePath)) continue;
-    return path6.join(root.raw, relativePath);
+    if (relativePath === ".." || relativePath.startsWith(`..${path8.sep}`) || path8.isAbsolute(relativePath)) continue;
+    return path8.join(root.raw, relativePath);
   }
   return candidate;
 }
@@ -5846,7 +6653,7 @@ var MigrationRunner = class {
     const durationMs = this.now() - startedAt;
     const { validated, application } = applied;
     const { plan, rendered, stylesheet } = validated;
-    return this.reports.build(
+    const report = this.reports.build(
       rendered.analyzed.manifest.invocation.inputPath,
       rendered.analyzed.manifest.invocation.outputPath,
       plan.target,
@@ -5856,6 +6663,7 @@ var MigrationRunner = class {
       plan.files,
       stylesheet
     );
+    return withReportEnvironment(report, invocation.options);
   }
   async execute(invocation) {
     try {
@@ -8898,7 +9706,7 @@ var ConversionPlanner = class {
 };
 
 // src/pipeline/rendered-project.ts
-import * as path7 from "path";
+import * as path9 from "path";
 function renderedProject(project) {
   const analyzed = analyzedProject(project.analyzed);
   if (project.files.length !== analyzed.templates.length) throw sequenceInvariant2();
@@ -9025,7 +9833,7 @@ function samePathPair2(left, right) {
   return normalizedAbsolutePath3(left.inputPath) === normalizedAbsolutePath3(right.inputPath) && normalizedAbsolutePath3(left.outputPath) === normalizedAbsolutePath3(right.outputPath);
 }
 function normalizedAbsolutePath3(value) {
-  return path7.normalize(path7.resolve(value));
+  return path9.normalize(path9.resolve(value));
 }
 function sameOwnedValue(left, right) {
   if (Object.is(left, right)) return true;
@@ -9114,10 +9922,10 @@ function parseErrorPlan(template) {
 }
 
 // src/pipeline/validate/validate-project.stage.ts
-import * as path14 from "path";
+import * as path15 from "path";
 
 // src/migrator/migration-plan.ts
-import * as path8 from "path";
+import * as path10 from "path";
 
 // src/migrator/file-migration-result.ts
 function fileMigrationResult(result2) {
@@ -9140,7 +9948,7 @@ function freezeValue2(value) {
 
 // src/migrator/migration-plan.ts
 function plannedOutputArtifact(artifact) {
-  if (!path8.isAbsolute(artifact.path)) {
+  if (!path10.isAbsolute(artifact.path)) {
     throw new Error(`Planned artifact paths must be absolute: ${artifact.path}`);
   }
   if (artifact.kind === "template" && artifact.proposed.status === "absent") {
@@ -9151,7 +9959,7 @@ function plannedOutputArtifact(artifact) {
   }
   return Object.freeze({
     kind: artifact.kind,
-    path: path8.resolve(artifact.path),
+    path: path10.resolve(artifact.path),
     original: artifactState(artifact.original),
     proposed: artifactState(artifact.proposed)
   });
@@ -9178,216 +9986,9 @@ function sameState(left, right) {
   return right.status === "present" && left.contents === right.contents;
 }
 
-// src/migrator/migration-path.validator.ts
-import { lstat as lstat2, stat as stat3 } from "fs/promises";
-import * as path9 from "path";
-async function validateMigrationPaths(request, pathApi = path9) {
-  const claims = normalizedClaims(request, pathApi);
-  await validateCollisions(claims, pathApi);
-  const destinations = claims.filter((claim) => claim.kind !== "template-input");
-  for (const destination of destinations) {
-    await validateDestination(destination.path);
-  }
-}
-async function validateStylesheetRootTopology(request, pathApi = path9) {
-  if (request.stylesheetPath === void 0) return;
-  const stylesheetPath = pathApi.resolve(request.stylesheetPath);
-  const templateRoots = [request.inputPath, request.outputPath].map((claim) => pathApi.resolve(claim));
-  const reportPath = request.reportPath === void 0 ? void 0 : pathApi.resolve(request.reportPath);
-  const exactCollision = (await Promise.all(
-    [...templateRoots, reportPath].map(
-      (claim) => claim === void 0 ? Promise.resolve(false) : pathsEquivalentOnFileSystem(stylesheetPath, claim, pathApi)
-    )
-  )).some(Boolean);
-  const reportHierarchyCollision = reportPath !== void 0 && await pathsOverlapOnFileSystem(stylesheetPath, reportPath, pathApi);
-  if (exactCollision || reportHierarchyCollision) {
-    const collisionPaths = reportHierarchyCollision && reportPath !== void 0 && !await pathsEquivalentOnFileSystem(stylesheetPath, reportPath, pathApi) ? [stylesheetPath, reportPath] : [stylesheetPath];
-    throw new MigrationApplicationError(
-      "path-collision",
-      `Stylesheet path collides with another migration path: ${request.stylesheetPathInput ?? request.stylesheetPath}`,
-      collisionPaths
-    );
-  }
-  let stylesheetStat;
-  try {
-    stylesheetStat = await lstat2(stylesheetPath);
-  } catch (error) {
-    if (isEnoent2(error)) return;
-    throw error;
-  }
-  const sourcePath = request.stylesheetPathInput ?? request.stylesheetPath;
-  if (stylesheetStat.isSymbolicLink()) {
-    throw new MigrationApplicationError(
-      "unsupported-path-type",
-      `Stylesheet path must not be a symbolic link: ${sourcePath}`,
-      [stylesheetPath]
-    );
-  }
-  if (!stylesheetStat.isFile()) {
-    throw new MigrationApplicationError(
-      "unsupported-path-type",
-      `Stylesheet path must be a regular file: ${sourcePath}`,
-      [stylesheetPath]
-    );
-  }
-}
-function normalizedClaims(request, pathApi) {
-  return [
-    ...request.templates.flatMap((template, templateIndex) => [
-      { path: pathApi.resolve(template.inputPath), kind: "template-input", templateIndex },
-      { path: pathApi.resolve(template.outputPath), kind: "template-output", templateIndex }
-    ]),
-    ...request.stylesheetPath ? [{ path: pathApi.resolve(request.stylesheetPath), kind: "stylesheet" }] : [],
-    ...request.reportPath ? [{ path: pathApi.resolve(request.reportPath), kind: "report" }] : []
-  ];
-}
-async function validateCollisions(claims, pathApi) {
-  const observations = /* @__PURE__ */ new Map();
-  const observe = (candidate) => {
-    const normalized = pathApi.resolve(candidate);
-    const existing = observations.get(normalized);
-    if (existing) return existing;
-    const pending = observePath(normalized, pathApi);
-    observations.set(normalized, pending);
-    return pending;
-  };
-  for (let leftIndex = 0; leftIndex < claims.length; leftIndex++) {
-    const left = claims[leftIndex];
-    if (!left) continue;
-    for (let rightIndex = leftIndex + 1; rightIndex < claims.length; rightIndex++) {
-      const right = claims[rightIndex];
-      if (!right) continue;
-      const relationship = await fileSystemPathRelationship(left.path, right.path, pathApi, observe);
-      if (relationship === "distinct" || isIntentionalInPlacePair(left, right, pathApi)) continue;
-      const collisionPaths = relationship === "equivalent" ? [left.path] : [left.path, right.path];
-      throw new MigrationApplicationError(
-        "path-collision",
-        `Migration paths collide: ${collisionPaths.join(" and ")}`,
-        collisionPaths
-      );
-    }
-  }
-}
-function isIntentionalInPlacePair(left, right, pathApi) {
-  return pathsEquivalent(left.path, right.path, pathApi) && left.templateIndex !== void 0 && left.templateIndex === right.templateIndex && left.kind !== right.kind && left.kind.startsWith("template-") && right.kind.startsWith("template-");
-}
-function pathsEquivalent(left, right, pathApi = path9) {
-  return normalizedPathsEquivalent(pathApi, pathApi.resolve(left), pathApi.resolve(right));
-}
-async function pathsEquivalentOnFileSystem(left, right, pathApi = path9) {
-  return await fileSystemPathRelationship(left, right, pathApi) === "equivalent";
-}
-async function pathsOverlapOnFileSystem(left, right, pathApi = path9) {
-  return await fileSystemPathRelationship(left, right, pathApi) !== "distinct";
-}
-function normalizedPathsEquivalent(pathApi, left, right) {
-  return pathApi.relative(left, right) === "";
-}
-function isAncestor(pathApi, ancestor, descendant) {
-  const relative3 = pathApi.relative(ancestor, descendant);
-  return relative3 !== "" && relative3 !== ".." && !relative3.startsWith(`..${pathApi.sep}`) && !pathApi.isAbsolute(relative3);
-}
-async function fileSystemPathRelationship(left, right, pathApi, observe = (candidate) => observePath(candidate, pathApi)) {
-  const normalizedLeft = pathApi.resolve(left);
-  const normalizedRight = pathApi.resolve(right);
-  if (normalizedPathsEquivalent(pathApi, normalizedLeft, normalizedRight)) return "equivalent";
-  if (isAncestor(pathApi, normalizedLeft, normalizedRight)) return "ancestor";
-  if (isAncestor(pathApi, normalizedRight, normalizedLeft)) return "descendant";
-  const [observedLeft, observedRight] = await Promise.all([observe(normalizedLeft), observe(normalizedRight)]);
-  if (observedLeft.exactIdentity && observedRight.exactIdentity) {
-    if (sameIdentity2(observedLeft.exactIdentity, observedRight.exactIdentity)) return "equivalent";
-    if (hasIdentityBelow(observedRight, observedLeft.exactIdentity)) return "ancestor";
-    if (hasIdentityBelow(observedLeft, observedRight.exactIdentity)) return "descendant";
-    return "distinct";
-  }
-  return relationshipThroughExistingPrefixes(observedLeft, observedRight);
-}
-async function observePath(candidate, pathApi) {
-  const prefixes = [];
-  const suffix = [];
-  let current = candidate;
-  let exactIdentity;
-  while (true) {
-    try {
-      const currentStat = await stat3(current, { bigint: true });
-      const currentIdentity = identity2(currentStat);
-      if (suffix.length === 0) exactIdentity = currentIdentity;
-      prefixes.push({ identity: currentIdentity, suffix: [...suffix] });
-    } catch (error) {
-      if (!isMissingPath(error)) throw error;
-    }
-    const parent = pathApi.dirname(current);
-    if (parent === current) break;
-    suffix.unshift(pathApi.basename(current));
-    current = parent;
-  }
-  return { ...exactIdentity ? { exactIdentity } : {}, prefixes };
-}
-function relationshipThroughExistingPrefixes(left, right) {
-  for (const leftPrefix of left.prefixes) {
-    for (const rightPrefix of right.prefixes) {
-      if (!sameIdentity2(leftPrefix.identity, rightPrefix.identity)) continue;
-      const relationship = suffixRelationship(leftPrefix.suffix, rightPrefix.suffix);
-      if (relationship !== "distinct") return relationship;
-    }
-  }
-  return "distinct";
-}
-function hasIdentityBelow(observed, candidate) {
-  return observed.prefixes.some((prefix) => prefix.suffix.length > 0 && sameIdentity2(prefix.identity, candidate));
-}
-function suffixRelationship(left, right) {
-  const normalizedLeft = left.map(portablePathSegment);
-  const normalizedRight = right.map(portablePathSegment);
-  const sharedLength = Math.min(normalizedLeft.length, normalizedRight.length);
-  for (let index = 0; index < sharedLength; index++) {
-    if (normalizedLeft[index] !== normalizedRight[index]) return "distinct";
-  }
-  if (normalizedLeft.length === normalizedRight.length) return "equivalent";
-  return normalizedLeft.length < normalizedRight.length ? "ancestor" : "descendant";
-}
-function portablePathSegment(value) {
-  return value.normalize("NFC").toLowerCase();
-}
-function identity2(value) {
-  return { device: String(value.dev), inode: String(value.ino) };
-}
-function sameIdentity2(left, right) {
-  return left.device === right.device && left.inode === right.inode;
-}
-async function validateDestination(destination) {
-  let stat4;
-  try {
-    stat4 = await lstat2(destination);
-  } catch (error) {
-    if (isEnoent2(error)) return;
-    throw error;
-  }
-  if (stat4.isSymbolicLink()) {
-    throw new MigrationApplicationError(
-      "unsupported-path-type",
-      `Migration destination must not be a symbolic link: ${destination}`,
-      [destination]
-    );
-  }
-  if (!stat4.isFile()) {
-    throw new MigrationApplicationError(
-      "unsupported-path-type",
-      `Migration destination must be a regular file: ${destination}`,
-      [destination]
-    );
-  }
-}
-function isEnoent2(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-function isMissingPath(error) {
-  return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
-}
-
 // src/migrator/stylesheet.planner.ts
-import { lstat as lstat3, readFile as readFile2 } from "fs/promises";
-import * as path10 from "path";
+import { lstat as lstat3, readFile as readFile3 } from "fs/promises";
+import * as path11 from "path";
 
 // src/adapter/css/stylesheet/css-stylesheet.error.ts
 var CssStylesheetError = class extends Error {
@@ -9916,7 +10517,7 @@ function mergeStylesheetContents(existing, rules, references = new Set(rules.map
 
 // src/migrator/stylesheet.planner.ts
 var nodeFileSystem2 = {
-  readFile: (target) => readFile2(target, "utf8"),
+  readFile: (target) => readFile3(target, "utf8"),
   lstat: lstat3
 };
 var StylesheetPlanner = class {
@@ -9924,7 +10525,7 @@ var StylesheetPlanner = class {
     this.fileSystem = fileSystem;
   }
   async plan(stylesheetPath, rules, references = new Set(rules.map((rule) => rule.className))) {
-    const outputPath = path10.resolve(stylesheetPath);
+    const outputPath = path11.resolve(stylesheetPath);
     const original = await this.originalState(outputPath);
     const existing = original.status === "present" ? original.contents : "";
     let merged;
@@ -9984,7 +10585,7 @@ function isEnoent3(error) {
 }
 
 // src/pipeline/validated-project-plan.ts
-import * as path11 from "path";
+import * as path12 from "path";
 function validatedProjectPlan(project) {
   const rendered = renderedProject(project.rendered);
   if (rendered.target !== rendered.session.target) {
@@ -10097,7 +10698,7 @@ function isPlainRecord2(value) {
   return prototype === Object.prototype || prototype === null;
 }
 function normalizedAbsolutePath4(value) {
-  return path11.normalize(path11.resolve(value));
+  return path12.normalize(path12.resolve(value));
 }
 function fileCongruenceInvariant() {
   return internalInvariant4(
@@ -10109,12 +10710,12 @@ function internalInvariant4(message) {
 }
 
 // src/pipeline/validate/css-reference.collector.ts
-import * as path12 from "path";
+import * as path13 from "path";
 
 // src/migrator/destination-template-source.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 var nodeDestinationTemplateSource = Object.freeze({
-  read: (path18) => readFile3(path18, "utf8")
+  read: (path19) => readFile4(path19, "utf8")
 });
 
 // src/pipeline/validate/css-reference.collector.ts
@@ -10133,10 +10734,10 @@ var CssReferenceCollector = class {
         if (file.artifact?.kind === "template" && file.artifact.proposed.status === "present") {
           return { contents: file.artifact.proposed.contents, complete: true };
         }
-        if (path12.resolve(file.file.inputPath) === path12.resolve(file.file.outputPath)) {
+        if (path13.resolve(file.file.inputPath) === path13.resolve(file.file.outputPath)) {
           return { contents: analyzedTemplate.source, complete: true };
         }
-        const outputPath = path12.normalize(path12.resolve(file.file.outputPath));
+        const outputPath = path13.normalize(path13.resolve(file.file.outputPath));
         const existing = destinationSources.get(outputPath);
         if (existing !== void 0) return existing;
         const pending = this.readDestination(outputPath);
@@ -10202,8 +10803,20 @@ function isEnoent4(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 
+// src/template/generated-template-validation.ts
+function generatedTemplateErrors(source, fileName, parser = new AngularTemplateParser()) {
+  const parsed2 = parser.parse(source, fileName);
+  return parsed2.status === "parse-error" ? parsed2.diagnostics.map((diagnostic2) => ({
+    status: "parse-error",
+    fileName,
+    code: "generated-template-parse-error",
+    reason: diagnostic2.message,
+    source: diagnostic2.source
+  })) : [];
+}
+
 // src/pipeline/validate/template-proposal.validator.ts
-import * as path13 from "path";
+import * as path14 from "path";
 var TemplateProposalValidator = class {
   constructor(validationParser = new AngularTemplateParser(), destinationTemplates = nodeDestinationTemplateSource) {
     this.validationParser = validationParser;
@@ -10218,21 +10831,8 @@ var TemplateProposalValidator = class {
       );
     }
     if (edited.output === template.source) return planResult(template, rendered, false, rendered.results);
-    const reparsed = this.validationParser.parse(edited.output, template.file.outputPath);
-    if (reparsed.status === "parse-error") {
-      return planResult(
-        template,
-        rendered,
-        false,
-        reparsed.diagnostics.map((diagnostic2) => ({
-          status: "parse-error",
-          fileName: template.file.outputPath,
-          code: "generated-template-parse-error",
-          reason: diagnostic2.message,
-          source: diagnostic2.source
-        }))
-      );
-    }
+    const errors = generatedTemplateErrors(edited.output, template.file.outputPath, this.validationParser);
+    if (errors.length) return planResult(template, rendered, false, errors);
     const original = await originalState(template, this.destinationTemplates);
     const proposed = { status: "present", contents: edited.output };
     if (sameState3(original, proposed)) return planResult(template, rendered, false, rendered.results);
@@ -10240,7 +10840,7 @@ var TemplateProposalValidator = class {
       file: result(template, rendered, true, rendered.results),
       artifact: plannedOutputArtifact({
         kind: "template",
-        path: path13.normalize(path13.resolve(template.file.outputPath)),
+        path: path14.normalize(path14.resolve(template.file.outputPath)),
         original,
         proposed
       })
@@ -10248,7 +10848,7 @@ var TemplateProposalValidator = class {
   }
 };
 async function originalState(template, destinationTemplates) {
-  if (path13.resolve(template.file.inputPath) === path13.resolve(template.file.outputPath)) {
+  if (path14.resolve(template.file.inputPath) === path14.resolve(template.file.outputPath)) {
     return { status: "present", contents: template.source };
   }
   try {
@@ -10316,7 +10916,7 @@ var ValidateProjectStage = class {
     let stylesheetArtifact;
     let stylesheet;
     if (rendered.session.target === "css" && stylesheetPath !== void 0) {
-      const canonicalStylesheetPath = path14.resolve(stylesheetPath);
+      const canonicalStylesheetPath = path15.resolve(stylesheetPath);
       const references = await this.cssReferences.collect(rendered, files);
       stylesheetArtifact = await this.stylesheetPlanner.plan(
         canonicalStylesheetPath,
@@ -10402,19 +11002,19 @@ var AtomicFileWriter = class {
       throw cleanupError(targetPath);
     }
   }
-  async captureNamespaceIdentity(path18, targetPath) {
-    const stat4 = await this.operations.lstat(path18);
+  async captureNamespaceIdentity(path19, targetPath) {
+    const stat4 = await this.operations.lstat(path19);
     if (stat4.isSymbolicLink() || !stat4.isDirectory()) throw ownershipError(targetPath);
     return identity3(stat4);
   }
-  async assertNamespaceIdentity(path18, expected, targetPath) {
-    const stat4 = await this.operations.lstat(path18);
+  async assertNamespaceIdentity(path19, expected, targetPath) {
+    const stat4 = await this.operations.lstat(path19);
     if (stat4.isSymbolicLink() || !stat4.isDirectory() || !sameIdentity3(identity3(stat4), expected)) {
       throw ownershipError(targetPath);
     }
   }
-  async assertTemporaryIdentity(path18, expected, targetPath) {
-    const stat4 = await this.operations.lstat(path18);
+  async assertTemporaryIdentity(path19, expected, targetPath) {
+    const stat4 = await this.operations.lstat(path19);
     if (stat4.isSymbolicLink() || !stat4.isFile() || !sameIdentity3(identity3(stat4), expected)) {
       throw ownershipError(targetPath);
     }
@@ -10478,19 +11078,19 @@ var JsonReportWriter = class {
   constructor(writer = new AtomicFileWriter()) {
     this.writer = writer;
   }
-  async write(path18, report, options = {}) {
+  async write(path19, report, options = {}) {
     for (const protectedPath of options.protectedPaths ?? []) {
-      if (!await pathsOverlapOnFileSystem(protectedPath, path18)) continue;
-      const collisionPaths = await pathsEquivalentOnFileSystem(protectedPath, path18) ? [protectedPath] : [protectedPath, path18];
+      if (!await pathsOverlapOnFileSystem(protectedPath, path19)) continue;
+      const collisionPaths = await pathsEquivalentOnFileSystem(protectedPath, path19) ? [protectedPath] : [protectedPath, path19];
       throw new MigrationApplicationError(
         "path-collision",
-        `Report path collides with a migration output: ${path18}`,
+        `Report path collides with a migration output: ${path19}`,
         collisionPaths
       );
     }
     const contents = `${JSON.stringify(report, null, 2)}
 `;
-    await this.writer.write(path18, contents);
+    await this.writer.write(path19, contents);
   }
 };
 
@@ -10508,8 +11108,23 @@ var TerminalPresenter = class {
     const diagnostics = report.files.flatMap(
       (file) => file.results.filter((result2) => result2.status !== "converted").map((result2) => `${file.path}:${result2.offset} [${result2.code}] ${result2.reason}`)
     );
+    const profile = report.targetProfile;
+    const environment = profile ? [
+      "Target environment",
+      `Tailwind: v${profile.version} (${profile.fingerprint})`,
+      `Stylesheet: ${profile.stylesheet ?? "not supplied"}`,
+      `Prefix: ${profile.prefix.value ?? "none"} (${profile.prefix.source}; ${profile.prefix.confidence})`,
+      `Important utilities: ${profile.important.value} (${profile.important.source})`,
+      `Core utilities: ${profile.coreUtilities.value} (${profile.coreUtilities.source}; ${profile.coreUtilities.confidence})`,
+      ...Object.entries(profile.breakpoints).map(
+        ([name, setting]) => `Breakpoint ${name}: ${setting.value} (${setting.source}; ${setting.confidence})`
+      ),
+      ...profile.diagnostics.map((item) => `[${item.code}] ${item.message}`),
+      ...profile.assumptions.map((item) => `Assumption: ${item}`),
+      ""
+    ] : [];
     output.write(
-      [presentation.outcome, totals, stylesheet, ...diagnostics, presentation.footer, ""].filter((line) => line !== void 0).join("\n")
+      [...environment, presentation.outcome, totals, stylesheet, ...diagnostics, presentation.footer, ""].filter((line) => line !== void 0).join("\n")
     );
   }
   applicationPresentation(report) {
@@ -10610,17 +11225,17 @@ function getErrorMessage(error) {
 // src/cli/exit-policy.ts
 function resolveExitCode(report, allowUnresolved) {
   if (report.summary.parseErrors > 0) return 1;
-  const hasUnresolved = report.summary.review > 0 || report.summary.unsupported > 0 || report.summary.invalid > 0;
+  const hasUnresolved = (report.targetProfile?.diagnostics.length ?? 0) > 0 || report.summary.review > 0 || report.summary.unsupported > 0 || report.summary.invalid > 0;
   return hasUnresolved && !allowUnresolved ? 2 : 0;
 }
 
 // src/cli/report-path.validator.ts
-import path15 from "path";
+import path16 from "path";
 function validateReportPath(reportPath) {
   if (reportPath.trim().length === 0) {
     throw new Error("Report path must not be empty.");
   }
-  if (path15.extname(reportPath).toLowerCase() !== ".json") {
+  if (path16.extname(reportPath).toLowerCase() !== ".json") {
     throw new Error("Report path must have a .json extension.");
   }
 }
@@ -10653,8 +11268,8 @@ function parsePrintWithBreakpoints(value, orientationEnabled) {
 }
 
 // src/cli/stylesheet-path.validator.ts
-import * as path16 from "path";
-async function validateStylesheetPath(request, pathApi = path16) {
+import * as path17 from "path";
+async function validateStylesheetPath(request, pathApi = path17) {
   if (request.target !== "css") {
     if (request.stylesheetPath !== void 0) {
       throw new MigrationApplicationError("invalid-configuration", "--stylesheet can only be used with --target css.", [
@@ -10684,6 +11299,7 @@ function resolveMigrationMode(argv, write) {
   if (optionArguments.filter((argument) => argument === "--write").length > 1) {
     throw new Error("--write may only be specified once.");
   }
+  if (write && optionArguments.includes("--plan")) throw new Error("--plan and --write cannot be combined.");
   return write ? "write" : "plan";
 }
 
@@ -10712,7 +11328,7 @@ async function runCli(argv, output = processOutput, dependencies = {}) {
     new Option("--stylesheet <path>", "companion stylesheet; required when --target css").argParser(
       parseSingleStylesheet
     )
-  ).option("--write", "apply the validated migration plan", false).option("--report <path>", "atomically write a JSON report; path must end in .json").option("--allow-unresolved", "return success when unresolved inputs remain", false).option("--orientation-breakpoints", "confirm the source enables the archived orientation breakpoints", false).option(
+  ).option("--config <path>", "declarative migration JSON configuration").option("--tailwind-stylesheet <path>", "statically analyze a Tailwind v4 target stylesheet").option("--tailwind-prefix <prefix>", "override Tailwind v4 prefix; empty string means none").option("--plan", "explicitly request the default review-only plan").option("--write", "apply the validated migration plan", false).option("--report <path>", "atomically write a JSON report; path must end in .json").option("--allow-unresolved", "return success when unresolved inputs remain", false).option("--orientation-breakpoints", "confirm the source enables the archived orientation breakpoints", false).option(
     "--responsive-images",
     "wrap eligible responsive images in picture elements; acknowledges selector and layout risk",
     false
@@ -10723,23 +11339,38 @@ async function runCli(argv, output = processOutput, dependencies = {}) {
     const mode = resolveMigrationMode(argv, options.write);
     debug = options.debug;
     logger.level = debug ? "debug" : "warn";
+    const configuration = await loadMigrationConfig({
+      config: options.config,
+      stylesheet: options.tailwindStylesheet,
+      prefix: options.tailwindPrefix
+    });
+    const target = program.getOptionValueSource("target") === "cli" ? options.target : configuration.target ?? options.target;
+    if (target !== "tailwind" && (options.tailwindStylesheet !== void 0 || options.tailwindPrefix !== void 0))
+      throw new Error("Tailwind target options require --target tailwind.");
     const destination = options.output ?? input;
     let reportPath;
     if (options.report !== void 0) {
       validateReportPath(options.report);
-      reportPath = path17.resolve(options.report);
+      reportPath = path18.resolve(options.report);
     }
+    if (reportPath)
+      for (const snapshot of configuration.snapshots) {
+        if (await pathsOverlapOnFileSystem(reportPath, snapshot.path))
+          throw new Error("Report path collides with a target configuration input.");
+      }
     const stylesheetPath = await validateStylesheetPath({
-      target: options.target,
+      target,
       stylesheetPath: options.stylesheet,
       inputPath: input,
       outputPath: destination,
       reportPath
     });
     const printWithBreakpoints = options.printWithBreakpoints === void 0 ? void 0 : parsePrintWithBreakpoints(options.printWithBreakpoints, options.orientationBreakpoints);
-    const session = AdapterFactory.createRenderSession(options.target, {
+    const session = AdapterFactory.createRenderSession(target, {
       orientationBreakpoints: options.orientationBreakpoints,
-      printWithBreakpoints
+      printWithBreakpoints,
+      targetProfile: target === "tailwind" ? configuration.targetProfile : void 0,
+      sourceBreakpoints: configuration.sourceBreakpoints
     });
     const render = new RenderProjectStage(session);
     const pipeline = new MigrationPipeline(
@@ -10756,6 +11387,9 @@ async function runCli(argv, output = processOutput, dependencies = {}) {
         outputPath: destination,
         options: {
           mode,
+          targetProfile: target === "tailwind" ? configuration.targetProfile : void 0,
+          sourceBreakpoints: configuration.sourceBreakpoints,
+          configurationSnapshots: configuration.snapshots,
           responsiveImages: options.responsiveImages,
           stylesheetPath,
           stylesheetPathInput: options.stylesheet,
@@ -10767,7 +11401,10 @@ async function runCli(argv, output = processOutput, dependencies = {}) {
     new TerminalPresenter().present(report, reportOutput);
     if (reportPath !== void 0) {
       await new JsonReportWriter().write(reportPath, report, {
-        protectedPaths: stylesheetPath === void 0 ? [] : [stylesheetPath]
+        protectedPaths: [
+          ...configuration.snapshots.map((snapshot) => snapshot.path),
+          ...stylesheetPath === void 0 ? [] : [stylesheetPath]
+        ]
       });
     }
     exitCode = resolveExitCode(report, options.allowUnresolved);