@cassiomc1/forgeloop 1.12.0 → 1.13.0

package/src/core/reconcile-closure.js

@@ -7,6 +7,7 @@ import { createReceipt } from "./receipt.js";
 import { currentRepositoryFingerprint } from "./repository.js";
 import { taskArtifactPath } from "./task-paths.js";
 import { classifyLoadedWorkState, readWorkState, mutateWorkState } from "./work-state.js";
+import { classifyRequirement } from "./evidence-readiness.js";
 
 export const RECONCILE_EVENT = "CHECKPOINT_RECONCILED";
 
@@ -133,7 +134,9 @@ export async function runReconcileClosure({
     if (typeof item === "string") {
       return item === requirement;
     }
-    return item.type === "VERIFICATION" && item.id === checkId && item.text === requirement;
+    return classifyRequirement(item).type === "VERIFICATION"
+      && item.id === checkId
+      && item.text === requirement;
   });
   if (!verificationItem) {
     throw reconcileError(

package/src/core/router.js

@@ -62,7 +62,21 @@ const SIGNALS = Object.freeze({
   platforms: new Set(["web", "mobile", "desktop", "server", "ci", "cross-platform"]),
 });
 
-const PROJECT_FRAMEWORKS = new Set(["flutter"]);
+const PROJECT_FRAMEWORKS = new Set([
+  "flutter", "dotnet", "aspnetcore", "abp", "nodejs", "rust",
+  "c", "cpp", "java", "sql", "go", "typescript", "php", "swift",
+]);
+
+const LANGUAGE_PROJECT_GUIDES = Object.freeze([
+  ["c", "PROJECT_C_CONFIRMED"],
+  ["cpp", "PROJECT_CPP_CONFIRMED"],
+  ["java", "PROJECT_JAVA_CONFIRMED"],
+  ["go", "PROJECT_GO_CONFIRMED"],
+  ["typescript", "PROJECT_TYPESCRIPT_CONFIRMED"],
+  ["php", "PROJECT_PHP_CONFIRMED"],
+  ["swift", "PROJECT_SWIFT_CONFIRMED"],
+  ["sql", "PROJECT_SQL_CONFIRMED"],
+]);
 
 export const PLATFORM_SEMANTICS = Object.freeze({
   web: Object.freeze({
@@ -134,8 +148,100 @@ function addFlutterProjectGuides(input, add) {
     || !["MATCH", "UNSCOPED"].includes(projectEvidence.scope)
     || !hasFlutterWorkContext(input.workType)) return;
   add("flutter", "PROJECT_FLUTTER_SDK_DEPENDENCY");
-  add("clean", "PROJECT_FLUTTER_BASELINE");
-  add("test", "PROJECT_FLUTTER_BASELINE");
+}
+
+function hasDotNetWorkContext(workType) {
+  return !["documentation", "ui-copy"].includes(workType);
+}
+
+function addDotNetProjectGuides(input, add) {
+  const projectEvidence = input.projectEvidence;
+  if (!projectEvidence?.frameworks.includes("dotnet")
+    || !["MATCH", "UNSCOPED"].includes(projectEvidence.scope)
+    || !hasDotNetWorkContext(input.workType)) return;
+  add("dotnet", "PROJECT_DOTNET_SDK_PROJECT");
+  if (projectEvidence.frameworks.includes("aspnetcore")) add("dotnet", "PROJECT_ASPNETCORE_CONFIRMED");
+  if (projectEvidence.frameworks.includes("abp")) add("dotnet", "PROJECT_ABP_CONFIRMED");
+}
+
+function hasNodeJsWorkContext(workType) {
+  return !["documentation", "ui-copy", "mobile-ui"].includes(workType);
+}
+
+function addNodeJsProjectGuides(input, add) {
+  const projectEvidence = input.projectEvidence;
+  if (!projectEvidence?.frameworks.includes("nodejs")
+    || !["MATCH", "UNSCOPED"].includes(projectEvidence.scope)
+    || !hasNodeJsWorkContext(input.workType)) return;
+  add("nodejs", "PROJECT_NODEJS_CONFIRMED");
+  if (projectEvidence.primarySignals.some((signal) => signal.includes(":dependencies.") || signal.includes(":optionalDependencies."))) {
+    add("nodejs", "PROJECT_NODEJS_BACKEND_FRAMEWORK");
+  }
+  if (projectEvidence.primarySignals.some((signal) => signal.includes(":scripts."))) {
+    add("nodejs", "PROJECT_NODEJS_RUNTIME_SCRIPT");
+  }
+  if (projectEvidence.primarySignals.some((signal) => signal.includes(":import="))) {
+    add("nodejs", "PROJECT_NODEJS_SERVER_RUNTIME");
+  }
+}
+
+function hasRustWorkContext(workType) {
+  return !["documentation", "ui-copy", "mobile-ui"].includes(workType);
+}
+
+function addRustProjectGuides(input, add) {
+  const projectEvidence = input.projectEvidence;
+  if (!projectEvidence?.frameworks.includes("rust")
+    || !["MATCH", "UNSCOPED"].includes(projectEvidence.scope)
+    || !hasRustWorkContext(input.workType)) return;
+  add("rust", "PROJECT_RUST_CONFIRMED");
+  if (projectEvidence.primarySignals.some((signal) => signal.endsWith(":package"))) {
+    add("rust", "PROJECT_RUST_CARGO_PACKAGE");
+  }
+  if (projectEvidence.primarySignals.some((signal) => signal.endsWith(":workspace"))) {
+    add("rust", "PROJECT_RUST_CARGO_WORKSPACE");
+  }
+}
+
+function hasLanguageWorkContext(workType) {
+  return !["documentation", "ui-copy"].includes(workType);
+}
+
+function addLanguageProjectGuides(input, add) {
+  const projectEvidence = input.projectEvidence;
+  if (!projectEvidence || !["MATCH", "UNSCOPED"].includes(projectEvidence.scope)
+    || !hasLanguageWorkContext(input.workType)) return;
+  for (const [guide, reason] of LANGUAGE_PROJECT_GUIDES) {
+    if (projectEvidence.frameworks.includes(guide)) add(guide, reason);
+  }
+}
+
+function addProjectBaselineGuides(input, add) {
+  const projectEvidence = input.projectEvidence;
+  if (!projectEvidence || !["MATCH", "UNSCOPED"].includes(projectEvidence.scope)) return;
+  if (projectEvidence.frameworks.includes("flutter") && hasFlutterWorkContext(input.workType)) {
+    add("clean", "PROJECT_FLUTTER_BASELINE");
+    add("test", "PROJECT_FLUTTER_BASELINE");
+  }
+  if (projectEvidence.frameworks.includes("dotnet") && hasDotNetWorkContext(input.workType)) {
+    add("clean", "PROJECT_DOTNET_BASELINE");
+    add("test", "PROJECT_DOTNET_BASELINE");
+  }
+  if (projectEvidence.frameworks.includes("nodejs") && hasNodeJsWorkContext(input.workType)) {
+    add("clean", "PROJECT_NODEJS_BASELINE");
+    add("test", "PROJECT_NODEJS_BASELINE");
+  }
+  if (projectEvidence.frameworks.includes("rust") && hasRustWorkContext(input.workType)) {
+    add("clean", "PROJECT_RUST_BASELINE");
+    add("test", "PROJECT_RUST_BASELINE");
+  }
+  if (hasLanguageWorkContext(input.workType)) {
+    for (const [language] of LANGUAGE_PROJECT_GUIDES) {
+      if (!projectEvidence.frameworks.includes(language)) continue;
+      add("clean", `PROJECT_${language.toUpperCase()}_BASELINE`);
+      add("test", `PROJECT_${language.toUpperCase()}_BASELINE`);
+    }
+  }
 }
 
 function flutterExclusionReason(projectEvidence, workType) {
@@ -146,6 +252,30 @@ function flutterExclusionReason(projectEvidence, workType) {
   return "NO_FLUTTER_PRIMARY_EVIDENCE";
 }
 
+function dotNetExclusionReason(projectEvidence, workType) {
+  if (!projectEvidence) return "NO_DOTNET_PROJECT_EVIDENCE";
+  if (projectEvidence.scope === "NO_MATCH") return "NO_DOTNET_SCOPE_MATCH";
+  if (!projectEvidence.frameworks.includes("dotnet")) return "NO_DOTNET_PRIMARY_EVIDENCE";
+  if (!hasDotNetWorkContext(workType)) return "NO_DOTNET_EXECUTABLE_WORK";
+  return "NO_DOTNET_PRIMARY_EVIDENCE";
+}
+
+function nodeJsExclusionReason(projectEvidence, workType) {
+  if (!projectEvidence) return "NO_NODEJS_PROJECT_EVIDENCE";
+  if (projectEvidence.scope === "NO_MATCH") return "NO_NODEJS_SCOPE_MATCH";
+  if (!projectEvidence.frameworks.includes("nodejs")) return "NO_NODEJS_PRIMARY_EVIDENCE";
+  if (!hasNodeJsWorkContext(workType)) return "NO_NODEJS_EXECUTABLE_WORK";
+  return "NO_NODEJS_PRIMARY_EVIDENCE";
+}
+
+function rustExclusionReason(projectEvidence, workType) {
+  if (!projectEvidence) return "NO_RUST_PROJECT_EVIDENCE";
+  if (projectEvidence.scope === "NO_MATCH") return "NO_RUST_SCOPE_MATCH";
+  if (!projectEvidence.frameworks.includes("rust")) return "NO_RUST_PRIMARY_EVIDENCE";
+  if (!hasRustWorkContext(workType)) return "NO_RUST_EXECUTABLE_WORK";
+  return "NO_RUST_PRIMARY_EVIDENCE";
+}
+
 function exclusionReasonForGuide(guide, projectEvidence, workType) {
   if (guide === "security") return "NO_TRUST_BOUNDARY";
   if (guide === "performance") return "NO_MEASURABLE_PERFORMANCE_RISK";
@@ -154,6 +284,16 @@ function exclusionReasonForGuide(guide, projectEvidence, workType) {
   if (guide === "taste") return "NO_TASTE_FRONTEND_CONTEXT";
   if (guide === "documentation") return "NO_DOCUMENTATION_SURFACE";
   if (guide === "flutter") return flutterExclusionReason(projectEvidence, workType);
+  if (guide === "dotnet") return dotNetExclusionReason(projectEvidence, workType);
+  if (guide === "nodejs") return nodeJsExclusionReason(projectEvidence, workType);
+  if (guide === "rust") return rustExclusionReason(projectEvidence, workType);
+  if (LANGUAGE_PROJECT_GUIDES.some(([language]) => language === guide)) {
+    if (!projectEvidence) return `NO_${guide.toUpperCase()}_PROJECT_EVIDENCE`;
+    if (projectEvidence.scope === "NO_MATCH") return `NO_${guide.toUpperCase()}_SCOPE_MATCH`;
+    if (!projectEvidence.frameworks.includes(guide)) return `NO_${guide.toUpperCase()}_PRIMARY_EVIDENCE`;
+    if (!hasLanguageWorkContext(workType)) return `NO_${guide.toUpperCase()}_EXECUTABLE_WORK`;
+    return `NO_${guide.toUpperCase()}_PRIMARY_EVIDENCE`;
+  }
   return "NO_BEHAVIOR_OR_EXECUTABLE_CHANGE";
 }
 
@@ -209,6 +349,14 @@ function normalizeProjectEvidence(value) {
     throw new RouteInputError(`Unsupported projectEvidence schema version: ${value.schemaVersion}`);
   }
   const frameworks = normalizeArray(value.frameworks, "frameworks", PROJECT_FRAMEWORKS);
+  const hasDotnet = frameworks.includes("dotnet");
+  const invalidOverlays = frameworks.filter((framework) => framework === "aspnetcore" || framework === "abp");
+  if (!hasDotnet && invalidOverlays.length > 0) {
+    const noun = invalidOverlays.length === 1 ? "framework" : "frameworks";
+    const verb = invalidOverlays.length === 1 ? "requires" : "require";
+    const labels = invalidOverlays.map((framework) => `"${framework}"`).join(", ");
+    throw new RouteInputError(`projectEvidence ${noun} ${labels} ${verb} "dotnet"`);
+  }
   const scope = value.scope ?? (frameworks.length > 0 ? "UNSCOPED" : "NONE");
   if (!PROJECT_EVIDENCE_SCOPES.includes(scope)) {
     throw new RouteInputError(`Unknown project evidence scope: ${scope}`);
@@ -264,6 +412,11 @@ export function evaluateRoute(input = {}, profileOptions = {}) {
 
   const projectEvidence = normalized.projectEvidence;
   addFlutterProjectGuides(normalized, add);
+  addDotNetProjectGuides(normalized, add);
+  addNodeJsProjectGuides(normalized, add);
+  addRustProjectGuides(normalized, add);
+  addLanguageProjectGuides(normalized, add);
+  addProjectBaselineGuides(normalized, add);
 
   const workReason = reasonForWorkType(normalized.workType);
   for (const guide of WORK_GUIDES[normalized.workType]) add(guide, workReason);

package/src/core/rust-project.js

@@ -0,0 +1,400 @@
+import path from "node:path";
+
+import { parse as parseToml } from "smol-toml";
+
+export const CARGO_MANIFEST_MAX_BYTES = 1024 * 1024;
+
+export const RUST_SHARED_FILES = Object.freeze([
+  "Cargo.lock",
+  "rust-toolchain.toml",
+  "rust-toolchain",
+  "rustfmt.toml",
+  ".rustfmt.toml",
+  "clippy.toml",
+  ".clippy.toml",
+]);
+
+const RUST_BACKEND_CONTEXTS = new Set([
+  "actix-web",
+  "axum",
+  "hyper",
+  "poem",
+  "rocket",
+  "tokio",
+  "tonic",
+  "tower",
+  "warp",
+]);
+
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function uniqueSorted(values) {
+  return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))]
+    .sort((left, right) => left.localeCompare(right));
+}
+
+function invalidCargoManifest() {
+  return {
+    valid: false,
+    rust: false,
+    package: { present: false, name: null, edition: null, rustVersion: null },
+    workspace: { present: false, members: [], exclude: [], defaultMembers: [], resolver: null },
+    dependencies: [],
+    workspaceDependencies: [],
+    devDependencies: [],
+    buildDependencies: [],
+    targetDependencies: [],
+    pathDependencies: [],
+    workspaceDependencyPaths: [],
+    workspaceDependencyUses: [],
+    features: [],
+    backendContexts: [],
+  };
+}
+
+function optionalString(object, key) {
+  if (object[key] === undefined) return null;
+  return typeof object[key] === "string" && object[key].trim() !== "" ? object[key] : undefined;
+}
+
+function cargoPackageString(object, key) {
+  if (object[key] === undefined) return { value: null, inherited: false };
+  if (typeof object[key] === "string" && object[key].trim() !== "") {
+    return { value: object[key], inherited: false };
+  }
+  if (isPlainObject(object[key])
+    && object[key].workspace === true
+    && Object.keys(object[key]).every((property) => property === "workspace")) {
+    return { value: null, inherited: true };
+  }
+  return null;
+}
+
+function optionalStringArray(object, key) {
+  if (object[key] === undefined) return [];
+  if (!Array.isArray(object[key]) || object[key].some((value) => typeof value !== "string" || value.trim() === "")) {
+    return null;
+  }
+  return [...object[key]];
+}
+
+function dependencyNamesFromTable(value) {
+  if (value === undefined) return [];
+  if (!isPlainObject(value)) return null;
+  return Object.keys(value);
+}
+
+function pathDependenciesFromTable(value) {
+  if (value === undefined) return [];
+  if (!isPlainObject(value)) return null;
+  return Object.entries(value)
+    .filter(([, specification]) => isPlainObject(specification)
+      && specification.workspace !== true
+      && typeof specification.path === "string"
+      && specification.path.trim() !== "")
+    .map(([name, specification]) => ({ name, path: specification.path }));
+}
+
+function workspaceDependencyUsesFromTable(value) {
+  if (value === undefined) return [];
+  if (!isPlainObject(value)) return null;
+  return Object.entries(value)
+    .filter(([, specification]) => isPlainObject(specification) && specification.workspace === true)
+    .map(([name]) => name);
+}
+
+function dependencyMetadataFromTable(value) {
+  const names = dependencyNamesFromTable(value);
+  const pathDependencies = pathDependenciesFromTable(value);
+  const workspaceDependencyUses = workspaceDependencyUsesFromTable(value);
+  if (names === null || pathDependencies === null || workspaceDependencyUses === null) return null;
+  return { names, pathDependencies, workspaceDependencyUses };
+}
+
+function uniquePathDependencies(values) {
+  const entries = new Map();
+  for (const dependency of values) {
+    if (!dependency || typeof dependency.name !== "string" || typeof dependency.path !== "string") continue;
+    const name = dependency.name.trim();
+    const dependencyPath = dependency.path.trim();
+    if (name === "" || dependencyPath === "") continue;
+    entries.set(`${name}\u0000${dependencyPath}`, { name, path: dependencyPath });
+  }
+  return [...entries.values()].sort((left, right) => {
+    const byName = left.name.localeCompare(right.name);
+    return byName || left.path.localeCompare(right.path);
+  });
+}
+
+function dependencyMetadataFromTargets(value) {
+  if (value === undefined) return { names: [], pathDependencies: [], workspaceDependencyUses: [] };
+  if (!isPlainObject(value)) return null;
+  const names = [];
+  const pathDependencies = [];
+  const workspaceDependencyUses = [];
+  for (const target of Object.values(value)) {
+    if (!isPlainObject(target)) return null;
+    for (const section of ["dependencies", "dev-dependencies", "build-dependencies"]) {
+      const dependencies = dependencyMetadataFromTable(target[section]);
+      if (dependencies === null) return null;
+      names.push(...dependencies.names);
+      pathDependencies.push(...dependencies.pathDependencies);
+      workspaceDependencyUses.push(...dependencies.workspaceDependencyUses);
+    }
+  }
+  return { names: uniqueSorted(names), pathDependencies, workspaceDependencyUses };
+}
+
+function parseCargoSections(document) {
+  const dependencies = dependencyMetadataFromTable(document.dependencies);
+  const workspaceDependencies = dependencyMetadataFromTable(document.workspace?.dependencies);
+  const devDependencies = dependencyMetadataFromTable(document["dev-dependencies"]);
+  const buildDependencies = dependencyMetadataFromTable(document["build-dependencies"]);
+  const targetDependencies = dependencyMetadataFromTargets(document.target);
+  const features = document.features === undefined
+    ? []
+    : isPlainObject(document.features) ? Object.keys(document.features) : null;
+  if ([dependencies, workspaceDependencies, devDependencies, buildDependencies, targetDependencies, features]
+    .some((value) => value === null)) return null;
+  return {
+    dependencies: uniqueSorted(dependencies.names),
+    workspaceDependencies: uniqueSorted(workspaceDependencies.names),
+    devDependencies: uniqueSorted(devDependencies.names),
+    buildDependencies: uniqueSorted(buildDependencies.names),
+    targetDependencies: targetDependencies.names,
+    pathDependencies: uniquePathDependencies([
+      ...dependencies.pathDependencies,
+      ...devDependencies.pathDependencies,
+      ...buildDependencies.pathDependencies,
+      ...targetDependencies.pathDependencies,
+    ]),
+    workspaceDependencyPaths: uniquePathDependencies(workspaceDependencies.pathDependencies),
+    workspaceDependencyUses: uniqueSorted([
+      ...dependencies.workspaceDependencyUses,
+      ...devDependencies.workspaceDependencyUses,
+      ...buildDependencies.workspaceDependencyUses,
+      ...targetDependencies.workspaceDependencyUses,
+    ]),
+    features: uniqueSorted(features),
+  };
+}
+
+function parseCargoPackage(document) {
+  if (document.package === undefined) {
+    return { present: false, name: null, edition: null, rustVersion: null };
+  }
+  if (!isPlainObject(document.package)) return null;
+  const name = optionalString(document.package, "name");
+  const edition = cargoPackageString(document.package, "edition");
+  const rustVersion = cargoPackageString(document.package, "rust-version");
+  const workspace = optionalString(document.package, "workspace");
+  if (name === undefined || name === null || edition === null || rustVersion === null || workspace === undefined) return null;
+  const metadata = {
+    present: true,
+    name,
+    edition: edition.value,
+    rustVersion: rustVersion.value,
+  };
+  if (edition.inherited) metadata.editionInherited = true;
+  if (rustVersion.inherited) metadata.rustVersionInherited = true;
+  if (workspace !== null) metadata.workspace = workspace;
+  return metadata;
+}
+
+function parseCargoWorkspacePackage(workspace) {
+  if (workspace.package === undefined) return null;
+  if (!isPlainObject(workspace.package)) return undefined;
+  const edition = optionalString(workspace.package, "edition");
+  const rustVersion = optionalString(workspace.package, "rust-version");
+  if (edition === undefined || rustVersion === undefined) return undefined;
+  return { present: true, edition, rustVersion };
+}
+
+function parseCargoWorkspace(document) {
+  if (document.workspace === undefined) {
+    return { present: false, members: [], exclude: [], defaultMembers: [], resolver: null };
+  }
+  if (!isPlainObject(document.workspace)) return null;
+  const members = optionalStringArray(document.workspace, "members");
+  const exclude = optionalStringArray(document.workspace, "exclude");
+  const defaultMembers = optionalStringArray(document.workspace, "default-members");
+  const resolver = optionalString(document.workspace, "resolver");
+  if (members === null || exclude === null || defaultMembers === null || resolver === undefined) return null;
+  if (document.workspace.dependencies !== undefined && !isPlainObject(document.workspace.dependencies)) return null;
+  const workspacePackage = parseCargoWorkspacePackage(document.workspace);
+  if (workspacePackage === undefined) return null;
+  const metadata = { present: true, members, exclude, defaultMembers, resolver };
+  if (workspacePackage) metadata.package = workspacePackage;
+  return metadata;
+}
+
+export function parseCargoManifest(text) {
+  const invalid = invalidCargoManifest();
+  if (typeof text !== "string" || text.length > CARGO_MANIFEST_MAX_BYTES || /\r(?!\n)/u.test(text)) return invalid;
+
+  let document;
+  try {
+    document = parseToml(text);
+  } catch {
+    return invalid;
+  }
+  if (!isPlainObject(document)) return invalid;
+
+  const packageMetadata = parseCargoPackage(document);
+  const workspaceMetadata = parseCargoWorkspace(document);
+  const sections = parseCargoSections(document);
+  if (packageMetadata?.present
+    && Object.prototype.hasOwnProperty.call(packageMetadata, "workspace")
+    && workspaceMetadata?.present) return invalid;
+  if (!packageMetadata || !workspaceMetadata || !sections
+    || (!packageMetadata.present && !workspaceMetadata.present)) return invalid;
+
+  const allDependencies = [
+    ...sections.dependencies,
+    ...sections.workspaceDependencies,
+    ...sections.devDependencies,
+    ...sections.buildDependencies,
+    ...sections.targetDependencies,
+  ];
+  return {
+    valid: true,
+    rust: true,
+    package: packageMetadata,
+    workspace: workspaceMetadata,
+    ...sections,
+    backendContexts: uniqueSorted(allDependencies.filter((name) => RUST_BACKEND_CONTEXTS.has(name))),
+  };
+}
+
+function normalizedRelativePath(root, candidate) {
+  if (typeof root !== "string" || typeof candidate !== "string") return null;
+  if (root === candidate) return ".";
+  if (root === ".") return candidate.startsWith("./") ? candidate.slice(2) : candidate;
+  if (!candidate.startsWith(`${root}/`)) return null;
+  return candidate.slice(root.length + 1);
+}
+
+function normalizedCargoPath(root, relativePath) {
+  if (typeof root !== "string" || typeof relativePath !== "string" || relativePath.trim() === "") return null;
+  const portable = relativePath.trim().replaceAll("\\", "/");
+  if (portable.startsWith("/") || /^[A-Za-z]:\//u.test(portable)) return null;
+  const joined = path.posix.normalize(path.posix.join(root === "." ? "" : root, portable));
+  if (joined === ".." || joined.startsWith("../")) return null;
+  return joined.replace(/^\.\//u, "") || ".";
+}
+
+function normalizedCargoPattern(pattern) {
+  if (typeof pattern !== "string" || pattern.trim() === "") return null;
+  const portable = pattern.trim().replaceAll("\\", "/");
+  if (portable.startsWith("/") || /^[A-Za-z]:\//u.test(portable)) return null;
+  const normalized = path.posix.normalize(portable).replace(/^\.\//u, "");
+  if (normalized === ".." || normalized.startsWith("../")) return null;
+  return normalized;
+}
+
+function cargoPatternRegex(pattern) {
+  const normalized = normalizedCargoPattern(pattern);
+  if (!normalized) return null;
+  let expression = "^";
+  for (let index = 0; index < normalized.length; index += 1) {
+    const character = normalized[index];
+    if (character === "*" && normalized[index + 1] === "*") {
+      expression += ".*";
+      index += 1;
+    } else if (character === "*") {
+      expression += "[^/]*";
+    } else if (character === "?") {
+      expression += "[^/]";
+    } else {
+      expression += character.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+    }
+  }
+  return new RegExp(`${expression}$`, "u");
+}
+
+function cargoPatternMatches(patterns, relativePath) {
+  return patterns.some((pattern) => cargoPatternRegex(pattern)?.test(relativePath));
+}
+
+function isDescendant(root, candidate) {
+  return root !== candidate && candidate.startsWith(`${root}/`);
+}
+
+function hasNestedWorkspaceBetween(workspaceProject, candidateProject, projects) {
+  return projects.some((project) => project !== workspaceProject
+    && project !== candidateProject
+    && project.kind === "rust"
+    && project.rust
+    && project.workspaceRoot
+    && isDescendant(workspaceProject.root, project.root)
+    && (project.root === candidateProject.root || isDescendant(project.root, candidateProject.root)));
+}
+
+function cargoPackageWorkspaceMatches(workspaceProject, candidateProject) {
+  const association = candidateProject.internal?.package?.workspace;
+  return typeof association === "string"
+    && normalizedCargoPath(candidateProject.root, association) === workspaceProject.root;
+}
+
+function cargoPackageHasExplicitWorkspace(candidateProject) {
+  return typeof candidateProject.internal?.package?.workspace === "string";
+}
+
+function cargoWorkspaceDependencyMatches(workspaceProject, sourceProject, candidateProject) {
+  const definitions = workspaceProject.internal?.workspaceDependencyPaths ?? [];
+  const uses = sourceProject.internal?.workspaceDependencyUses ?? [];
+  return uses.some((name) => definitions.some((dependency) => dependency.name === name
+    && normalizedCargoPath(workspaceProject.root, dependency.path) === candidateProject.root));
+}
+
+function cargoPathDependencyMatches(sourceProject, candidateProject, workspaceProject) {
+  const packagePathMatch = (sourceProject.internal?.pathDependencies ?? [])
+    .some((dependency) => normalizedCargoPath(sourceProject.root, dependency.path) === candidateProject.root);
+  return packagePathMatch || cargoWorkspaceDependencyMatches(workspaceProject, sourceProject, candidateProject);
+}
+
+function cargoWorkspaceContainsInternal(workspaceProject, candidateProject, projects, resolving) {
+  if (!workspaceProject?.rust || !workspaceProject.workspaceRoot
+    || !candidateProject?.rust || !candidateProject.packageRoot) return false;
+  if (workspaceProject.root === candidateProject.root) return true;
+  if (candidateProject.workspaceRoot) return false;
+  if (cargoPackageHasExplicitWorkspace(candidateProject)) return cargoPackageWorkspaceMatches(workspaceProject, candidateProject);
+  const relative = normalizedRelativePath(workspaceProject.root, candidateProject.root);
+  if (!relative || hasNestedWorkspaceBetween(workspaceProject, candidateProject, projects)) return false;
+  const workspace = workspaceProject.internal.workspace;
+  if (workspace.exclude.some((pattern) => cargoPatternMatches([pattern], relative))) return false;
+  if (cargoPatternMatches(workspace.members, relative)) return true;
+  if (resolving.has(candidateProject.root)) return false;
+  resolving.add(candidateProject.root);
+  const contained = projects.some((project) => project !== candidateProject
+    && cargoWorkspaceContainsInternal(workspaceProject, project, projects, resolving)
+    && cargoPathDependencyMatches(project, candidateProject, workspaceProject));
+  resolving.delete(candidateProject.root);
+  return contained;
+}
+
+export function cargoWorkspaceContains(workspaceProject, candidateProject, projects = []) {
+  return cargoWorkspaceContainsInternal(workspaceProject, candidateProject, projects, new Set());
+}
+
+export function isRustSharedFile(relativePath) {
+  const normalized = relativePath.replaceAll("\\", "/");
+  const fileName = path.posix.basename(normalized).toLowerCase();
+  if (RUST_SHARED_FILES.some((name) => name.toLowerCase() === fileName)) return true;
+  const parent = path.posix.basename(path.posix.dirname(normalized)).toLowerCase();
+  return parent === ".cargo" && ["config", "config.toml"].includes(fileName);
+}
+
+export function rustSharedScopeDirectory(relativePath) {
+  const normalized = relativePath.replaceAll("\\", "/");
+  const parent = path.posix.dirname(normalized);
+  if (path.posix.basename(parent).toLowerCase() === ".cargo") return path.posix.dirname(parent) || ".";
+  return parent || ".";
+}
+
+export function rustSharedFileKind(relativePath) {
+  if (!isRustSharedFile(relativePath)) return null;
+  return path.posix.basename(relativePath).toLowerCase() === "cargo.lock" ? "lockfile" : "configuration";
+}