@cassiomc1/forgeloop 1.12.0 → 1.13.0

package/src/core/sql-project.js

@@ -0,0 +1,141 @@
+import { parseXmlStructure } from "./xml-structure.js";
+
+const SQL_STATEMENT_PATTERNS = Object.freeze([
+  /(?:^|[;\n])\s*select\b[\s\S]{0,240}\bfrom\s+[A-Za-z_][A-Za-z0-9_$]*(?:\s*\.\s*[A-Za-z_][A-Za-z0-9_$]*)*(?:\s*(?:;|$)|\s+(?:where|group|order|having|limit|offset|union|join|left|right|inner|outer|on)\b)/imu,
+  /(?:^|[;\n])\s*select\s+(?:distinct\s+)?[-+]?\d+(?:\s*,\s*[-+]?\d+)*\s*;?\s*(?:$|[\n])/imu,
+  /(?:^|[;\n])\s*insert\s+into\b/imu,
+  /(?:^|[;\n])\s*update\b[\s\S]{0,160}\bset\b/imu,
+  /(?:^|[;\n])\s*delete\s+from\b/imu,
+  /(?:^|[;\n])\s*merge\s+into\b/imu,
+  /(?:^|[;\n])\s*with\b[\s\S]{0,1024}\bas\s*\([\s\S]*\)\s*(?:select|insert|update|delete|merge)\b/imu,
+  /(?:^|[;\n])\s*create\s+(?:table|view|index|schema|database|function|procedure|trigger|type|sequence)\s+(?:if\s+not\s+exists\s+)?[A-Za-z_][A-Za-z0-9_$]*(?:\s*\.\s*[A-Za-z_][A-Za-z0-9_$]*)*(?:\s*(?:\(|;|$)|\s+(?:as|like)\b)/imu,
+  /(?:^|[;\n])\s*alter\s+(?:table|view|index|schema|database|function|procedure|trigger|type|sequence)\s+(?:if\s+exists\s+)?[A-Za-z_][A-Za-z0-9_$]*(?:\s*\.\s*[A-Za-z_][A-Za-z0-9_$]*)*(?:\s*(?:;|$)|\s+(?:add|drop|alter|rename|set|owner|enable|disable)\b)/imu,
+  /(?:^|[;\n])\s*drop\s+(?:table|view|index|schema|database|function|procedure|trigger|type|sequence)\s+(?:if\s+exists\s+)?[A-Za-z_][A-Za-z0-9_$]*(?:\s*\.\s*[A-Za-z_][A-Za-z0-9_$]*)*(?:\s*(?:;|$)|\s+(?:cascade|restrict)\b)/imu,
+  /(?:^|[;\n])\s*(?:grant|revoke)\b[\s\S]{0,240}\bon\b/imu,
+  /(?:^|[;\n])\s*begin(?:\s+(?:transaction|work))?\s*;?\s*(?:$|[\n])/imu,
+  /(?:^|[;\n])\s*(?:commit|rollback)(?:\s+(?:transaction|work))?\s*;?\s*(?:$|[\n])/imu,
+  /(?:^|[;\n])\s*savepoint\s+[A-Za-z_][A-Za-z0-9_$]*\s*;?/imu,
+  /(?:^|[;\n])\s*release\s+savepoint\s+[A-Za-z_][A-Za-z0-9_$]*\s*;?/imu,
+]);
+
+function maskSqlComment(text, start, block) {
+  const lineEnd = text.slice(start).search(/[\n\r]/u);
+  const end = block ? text.indexOf("*/", start + 2) : lineEnd < 0 ? -1 : start + lineEnd;
+  if (block && end < 0) return null;
+  const finish = block ? end + 2 : (end < 0 ? text.length : end);
+  const value = text.slice(start, finish);
+  return { text: value.replace(/[^\n\r]/gu, " "), next: finish };
+}
+
+function maskSqlQuoted(text, start, quote) {
+  let result = " ";
+  for (let index = start + 1; index < text.length; index += 1) {
+    const character = text[index];
+    const next = text[index + 1];
+    if (character === quote && next === quote) {
+      result += "  ";
+      index += 1;
+    } else if (character === quote) {
+      return { text: result + " ", next: index + 1 };
+    } else {
+      result += character === "\n" || character === "\r" ? character : " ";
+    }
+  }
+  return null;
+}
+
+function maskSqlQuotedIdentifier(text, start, quote) {
+  for (let index = start + 1; index < text.length; index += 1) {
+    const character = text[index];
+    const next = text[index + 1];
+    if (character === quote && next === quote) {
+      index += 1;
+    } else if (character === quote) {
+      return { text: "__identifier__", next: index + 1 };
+    }
+  }
+  return null;
+}
+
+function maskSqlBracketIdentifier(text, start) {
+  for (let index = start + 1; index < text.length; index += 1) {
+    if (text[index] === "]") {
+      if (text[index + 1] === "]") {
+        index += 1;
+      } else {
+        return { text: "__identifier__", next: index + 1 };
+      }
+    }
+  }
+  return null;
+}
+
+function maskSqlDollarQuote(text, start) {
+  const marker = text.slice(start).match(/^\$[A-Za-z_][A-Za-z0-9_]*\$|^\$\$/u)?.[0];
+  if (!marker) return null;
+  const end = text.indexOf(marker, start + marker.length);
+  if (end < 0) return { invalid: true };
+  const finish = end + marker.length;
+  return { text: text.slice(start, finish).replace(/[^\n\r]/gu, " "), next: finish };
+}
+
+function maskSqlToken(text, index) {
+  const character = text[index];
+  const next = text[index + 1];
+  if (character === "-" && next === "-") {
+    return maskSqlComment(text, index, false);
+  }
+  if (character === "/" && next === "*") return maskSqlComment(text, index, true);
+  if (character === "'") return maskSqlQuoted(text, index, character);
+  if (character === '"' || character === "`") return maskSqlQuotedIdentifier(text, index, character);
+  if (character === "[") return maskSqlBracketIdentifier(text, index);
+  if (character === "$") {
+    const dollarQuote = maskSqlDollarQuote(text, index);
+    if (dollarQuote?.invalid) return null;
+    return dollarQuote ?? { text: character, next: index + 1 };
+  }
+  return { text: character, next: index + 1 };
+}
+
+function maskSql(text) {
+  let result = "";
+  for (let index = 0; index < text.length;) {
+    const segment = maskSqlToken(text, index);
+    if (!segment) return null;
+    result += segment.text;
+    index = segment.next;
+  }
+  return result;
+}
+
+export function looksLikeSql(text) {
+  if (typeof text !== "string" || text.length > 512 * 1024 || /\r(?!\n)/u.test(text)) return false;
+  const masked = maskSql(text);
+  return masked !== null && SQL_STATEMENT_PATTERNS.some((pattern) => pattern.test(masked));
+}
+
+export function sqlSignal(text) {
+  if (!looksLikeSql(text)) return null;
+  const masked = maskSql(text);
+  return masked === null ? null : SQL_STATEMENT_PATTERNS.find((pattern) => pattern.test(masked))?.source ?? "statement";
+}
+
+function childValues(node, name) {
+  return node.children
+    .filter((child) => child.name.toLowerCase() === name)
+    .map((child) => child.text.trim())
+    .filter(Boolean);
+}
+
+export function parseSqlProject(text) {
+  const document = parseXmlStructure(text);
+  if (!document || document.root.name.toLowerCase() !== "project") return { valid: false, database: false };
+  const sdk = document.root.attributes.Sdk ?? document.root.attributes.sdk ?? "";
+  const databaseMarkers = [
+    sdk.toLowerCase().startsWith("microsoft.build.sql/"),
+    childValues(document.root, "dsp").length > 0,
+    document.nodes.some((node) => ["databaseproject", "sqlscript"].includes(node.name.toLowerCase())),
+  ];
+  const database = databaseMarkers.some(Boolean);
+  return { valid: database, database };
+}

package/src/core/swift-project.js

@@ -0,0 +1,200 @@
+import { createLanguageProject, C_SOURCE_EXTENSIONS, CPP_SOURCE_EXTENSIONS, SWIFT_SOURCE_EXTENSIONS, pathBelongsToRoot, portablePath } from "./multi-language-project.js";
+import { extractBuildCalls, maskBuildScript, quotedBuildArguments } from "./build-script.js";
+
+function invalidSwift() {
+  return { valid: false, swift: false, c: false, cpp: false };
+}
+
+function stripSwiftComments(text) {
+  let result = "";
+  let state = "code";
+  let escaped = false;
+  let blockDepth = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    const next = text[index + 1];
+    if (state === "string") {
+      result += character;
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === '"') state = "code";
+    } else if (state === "line-comment") {
+      if (character === "\n") {
+        result += character;
+        state = "code";
+      } else result += " ";
+    } else if (state === "block-comment") {
+      if (character === "/" && next === "*") {
+        blockDepth += 1;
+        result += "  ";
+        index += 1;
+      } else if (character === "*" && next === "/") {
+        blockDepth -= 1;
+        result += "  ";
+        index += 1;
+        if (blockDepth === 0) state = "code";
+      } else result += character === "\n" ? "\n" : " ";
+    } else if (character === '"') {
+      result += character;
+      state = "string";
+    } else if (character === "/" && next === "/") {
+      result += "  ";
+      index += 1;
+      state = "line-comment";
+    } else if (character === "/" && next === "*") {
+      result += "  ";
+      index += 1;
+      blockDepth = 1;
+      state = "block-comment";
+    } else result += character;
+  }
+  return state === "block-comment" ? null : result;
+}
+
+function maskSwiftStrings(text) {
+  let result = "";
+  let state = "code";
+  let escaped = false;
+  let delimiter = null;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    const rawMatch = character === "#" ? text.slice(index).match(/^(#+)("{1,3})/u) : null;
+    if (state === "string") {
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (text.startsWith(delimiter, index)) {
+        result += " ".repeat(delimiter.length);
+        index += delimiter.length - 1;
+        state = "code";
+        delimiter = null;
+        continue;
+      }
+      result += character === "\n" ? "\n" : " ";
+    } else if (character === '"') {
+      delimiter = text.startsWith('"""', index) ? '"""' : '"';
+      state = "string";
+      result += " ".repeat(delimiter.length);
+      index += delimiter.length - 1;
+    } else if (rawMatch) {
+      delimiter = `${rawMatch[2]}${rawMatch[1]}`;
+      state = "string";
+      result += " ".repeat(rawMatch[0].length);
+      index += rawMatch[0].length - 1;
+    } else {
+      result += character;
+    }
+  }
+  return state === "string" ? null : result;
+}
+
+function maskSwiftLexicalNoise(text) {
+  const withoutComments = stripSwiftComments(text);
+  return withoutComments === null ? null : maskSwiftStrings(withoutComments);
+}
+
+function hasBalancedSwiftDelimiters(source) {
+  const expectedClosers = new Map([
+    ["(", ")"],
+    ["{", "}"],
+    ["[", "]"],
+  ]);
+  const stack = [];
+  for (const character of source) {
+    if (expectedClosers.has(character)) {
+      stack.push(expectedClosers.get(character));
+    } else if (")]}".includes(character) && stack.pop() !== character) {
+      return false;
+    }
+  }
+  return stack.length === 0;
+}
+
+export function parseSwiftPackage(text) {
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) return invalidSwift();
+  const toolsVersion = /^\s*\/\/\s*swift-tools-version:\s*\d+(?:\.\d+){1,2}\s*$/mu.test(text);
+  const source = maskSwiftLexicalNoise(text);
+  const packageDescription = source !== null && /\bimport\s+PackageDescription\b/u.test(source);
+  const balanced = source !== null && hasBalancedSwiftDelimiters(source);
+  const packageDeclaration = source !== null && /\bPackage\s*\(/u.test(source);
+  return {
+    valid: toolsVersion && packageDescription && packageDeclaration && balanced,
+    swift: toolsVersion && packageDescription && packageDeclaration && balanced,
+    c: false,
+    cpp: false,
+  };
+}
+
+export function parseXcodeProject(text) {
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) return invalidSwift();
+  const source = stripSwiftComments(text);
+  const swift = source !== null && /\bSWIFT_VERSION\s*=/u.test(source) && /\.swift\b/u.test(source);
+  return { valid: swift, swift, c: false, cpp: false };
+}
+
+export function parseSwiftCMake(text) {
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) return invalidSwift();
+  const source = maskBuildScript(text);
+  const swift = source !== null && /\b(?:LANGUAGES[^\n)]*\bSwift\b|enable_language\s*\(\s*Swift\b)/iu.test(source);
+  return { valid: swift, swift, c: false, cpp: false };
+}
+
+export function parseSwiftMeson(text) {
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) return invalidSwift();
+  const calls = extractBuildCalls(text, ["project", "add_languages"]);
+  const swift = Boolean(calls?.some((call) => {
+    const values = quotedBuildArguments(call.body) ?? [];
+    return (call.name === "project" ? values.slice(1) : values)
+      .some((value) => value.toLowerCase() === "swift");
+  }));
+  return { valid: swift, swift, c: false, cpp: false };
+}
+
+function sourceEvidence(sourceFiles, targetRoot, projectRoot, projectRoots) {
+  const owns = (file) => pathBelongsToRoot(portablePath(targetRoot, file.path), projectRoot, projectRoots);
+  return {
+    swift: sourceFiles.some((file) => SWIFT_SOURCE_EXTENSIONS.has(file.extension) && owns(file)),
+    c: sourceFiles.some((file) => C_SOURCE_EXTENSIONS.has(file.extension) && owns(file)),
+    cpp: sourceFiles.some((file) => CPP_SOURCE_EXTENSIONS.has(file.extension) && owns(file)),
+  };
+}
+
+export function swiftSourceLooksExecutable(text) {
+  const source = maskSwiftLexicalNoise(text);
+  return source !== null && /\b(?:import|class|struct|enum|protocol|func|let|var)\b/u.test(source);
+}
+
+export function inspectSwiftProject({ projectRoot, manifestRelative, manifestText, manifestName, targetRoot, sourceFiles, projectRoots, directClaim = false }) {
+  const normalizedManifestName = manifestName.toLowerCase();
+  const parsed = normalizedManifestName === "package.swift"
+    ? parseSwiftPackage(manifestText)
+    : normalizedManifestName === "project.pbxproj"
+      ? parseXcodeProject(manifestText)
+      : normalizedManifestName === "meson.build"
+        ? parseSwiftMeson(manifestText)
+      : parseSwiftCMake(manifestText);
+  const source = sourceEvidence(sourceFiles, targetRoot, projectRoot, projectRoots);
+  const swift = parsed.swift
+    && (normalizedManifestName !== "package.swift" || source.swift || directClaim);
+  const frameworks = [];
+  if (swift) frameworks.push("swift");
+  if (normalizedManifestName === "package.swift" && parsed.valid && source.c) frameworks.push("c");
+  if (normalizedManifestName === "package.swift" && parsed.valid && source.cpp) frameworks.push("cpp");
+  const primary = frameworks.length > 0;
+  const primarySignals = [];
+  const manifestSignal = normalizedManifestName === "package.swift"
+    ? "package"
+    : normalizedManifestName === "project.pbxproj" ? "xcode" : "build";
+  if (swift) primarySignals.push(`${manifestRelative}:${manifestSignal}`);
+  if (normalizedManifestName === "package.swift" && parsed.valid && source.c) primarySignals.push(`${projectRoot}/source:c`);
+  if (normalizedManifestName === "package.swift" && parsed.valid && source.cpp) primarySignals.push(`${projectRoot}/source:cpp`);
+  return createLanguageProject({
+    kind: "swift",
+    root: projectRoot,
+    manifest: manifestRelative,
+    frameworks,
+    primary,
+    primarySignals,
+    supportingSignals: [],
+    internal: { ...parsed, valid: parsed.valid, source },
+  });
+}

package/src/core/typescript-project.js

@@ -0,0 +1,349 @@
+import path from "node:path";
+
+import { createLanguageProject } from "./multi-language-project.js";
+
+const TS_CONFIG_NAME = /^tsconfig(?:\.[^/]+)?\.json$/u;
+
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function invalidConfig() {
+  return {
+    valid: false,
+    references: [],
+    extends: [],
+    compilerOptions: {},
+  };
+}
+
+function maskJsonComments(text) {
+  let result = "";
+  let state = "code";
+  let escaped = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    const next = text[index + 1];
+    if (state === "string") {
+      result += character;
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === '"') state = "code";
+    } else if (state === "line-comment") {
+      if (character === "\n") {
+        result += character;
+        state = "code";
+      } else result += " ";
+    } else if (state === "block-comment") {
+      if (character === "*" && next === "/") {
+        result += "  ";
+        index += 1;
+        state = "code";
+      } else result += character === "\n" ? "\n" : " ";
+    } else if (character === '"') {
+      result += character;
+      state = "string";
+    } else if (character === "/" && next === "/") {
+      result += "  ";
+      index += 1;
+      state = "line-comment";
+    } else if (character === "/" && next === "*") {
+      result += "  ";
+      index += 1;
+      state = "block-comment";
+    } else result += character;
+  }
+  return state === "block-comment" ? null : result;
+}
+
+function removeTrailingCommas(text) {
+  let result = "";
+  let state = "code";
+  let escaped = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    if (state === "string") {
+      result += character;
+      if (escaped) escaped = false;
+      else if (character === "\\") escaped = true;
+      else if (character === '"') state = "code";
+      continue;
+    }
+    if (character === '"') {
+      result += character;
+      state = "string";
+    } else if (character === "," && /^[\s]*[}\]]/u.test(text.slice(index + 1))) {
+      continue;
+    } else result += character;
+  }
+  return result;
+}
+
+export function isTypeScriptConfigName(fileName) {
+  return typeof fileName === "string" && TS_CONFIG_NAME.test(fileName.toLowerCase());
+}
+
+function normalizedReferencePath(projectRoot, reference) {
+  return path.posix.normalize(path.posix.join(projectRoot, reference.replaceAll("\\", "/")));
+}
+
+function referenceMatchesConfig(projectRoot, reference, configRelative, allowBareReference = false) {
+  if (typeof reference !== "string" || reference.trim() === "") return false;
+  const normalizedReference = reference.replaceAll("\\", "/");
+  if ((!allowBareReference && !normalizedReference.startsWith("."))
+    || normalizedReference.startsWith("/")
+    || /^[A-Za-z]:\//u.test(normalizedReference)) return false;
+  const candidate = normalizedReferencePath(projectRoot, normalizedReference);
+  if (candidate === ".." || candidate.startsWith("../")) return false;
+  const normalizedConfig = configRelative.toLowerCase();
+  const normalizedCandidate = candidate.toLowerCase();
+  return normalizedConfig === normalizedCandidate
+    || normalizedConfig === normalizedCandidate + ".json"
+    || normalizedConfig === normalizedCandidate + "/tsconfig.json";
+}
+
+function isConfigCandidate(file) {
+  return file?.kind === "typescript" || file?.kind === "typescript-config";
+}
+
+function localConfigReferences(configRelative, projectFiles) {
+  return projectFiles.filter((file) => {
+    if (!isConfigCandidate(file)) return false;
+    const parsed = parseTypeScriptConfig(file.text, file.name);
+    return parsed.valid && (parsed.references
+      .some((reference) => referenceMatchesConfig(path.posix.dirname(file.relative), reference, configRelative, true))
+      || parsed.extends.some((reference) => referenceMatchesConfig(
+        path.posix.dirname(file.relative),
+        reference,
+        configRelative,
+      )));
+  });
+}
+
+function configRelationships(projectFiles) {
+  const entries = projectFiles
+    .filter(isConfigCandidate)
+    .map((file) => ({ file, parsed: parseTypeScriptConfig(file.text, file.name) }))
+    .filter(({ parsed }) => parsed.valid);
+  const forward = new Map();
+  const reverse = new Map();
+  for (const { file, parsed } of entries) {
+    const relations = [
+      ...parsed.references.map((value) => ({ value, kind: "reference", allowBare: true })),
+      ...parsed.extends.map((value) => ({ value, kind: "extends", allowBare: false })),
+    ];
+    for (const relation of relations) {
+      const target = entries.find(({ file: candidate }) => referenceMatchesConfig(
+        path.posix.dirname(file.relative), relation.value, candidate.relative, relation.allowBare,
+      ));
+      if (!target) continue;
+      const sourceRelative = file.relative.toLowerCase();
+      const targetRelative = target.file.relative.toLowerCase();
+      if (!forward.has(sourceRelative)) forward.set(sourceRelative, []);
+      if (!reverse.has(targetRelative)) reverse.set(targetRelative, []);
+      forward.get(sourceRelative).push({ relative: targetRelative, kind: relation.kind });
+      reverse.get(targetRelative).push({ relative: sourceRelative, kind: relation.kind });
+    }
+  }
+  return { entries, forward, reverse };
+}
+
+export function resolveTypeScriptConfigGraph(projectFiles = [], directClaims = []) {
+  const { entries, forward, reverse } = configRelationships(projectFiles);
+  const byRelative = new Map(entries.map((entry) => [entry.file.relative.toLowerCase(), entry]));
+  const active = new Set(entries
+    .filter(({ file }) => file.name.toLowerCase() === "tsconfig.json")
+    .map(({ file }) => file.relative.toLowerCase()));
+  for (const claim of directClaims) {
+    if (byRelative.has(claim.toLowerCase())) active.add(claim.toLowerCase());
+  }
+
+  const queue = [...active];
+  for (let index = 0; index < queue.length; index += 1) {
+    const current = byRelative.get(queue[index]);
+    const parsed = current?.parsed;
+    if (!parsed) continue;
+    for (const relation of forward.get(queue[index]) ?? []) {
+      if (!active.has(relation.relative)) {
+        active.add(relation.relative);
+        queue.push(relation.relative);
+      }
+    }
+    if (directClaims.length > 0) {
+      for (const relation of reverse.get(queue[index]) ?? []) {
+        if (!active.has(relation.relative)) {
+          active.add(relation.relative);
+          queue.push(relation.relative);
+        }
+      }
+    }
+  }
+  return active;
+}
+
+export function resolveTypeScriptConfigOwnershipRoots(projectFiles = [], activeConfigRelatives = new Set(), directClaims = []) {
+  const { entries, reverse } = configRelationships(projectFiles);
+  const candidates = entries.filter(({ file }) => activeConfigRelatives.has(file.relative.toLowerCase()));
+  const hasIndependentConfigSemantics = (parsed) => (parsed.compilerOptions
+    && Object.keys(parsed.compilerOptions).length > 0)
+    || parsed.references.length > 0
+    || parsed.extends.length > 0;
+  const roots = new Set(candidates
+    .filter(({ file, parsed }) => file.name.toLowerCase() === "tsconfig.json"
+      && (directClaims.length === 0 || hasIndependentConfigSemantics(parsed)))
+    .map(({ file }) => file.relative.toLowerCase()));
+  for (const claim of directClaims) {
+    const relative = claim.toLowerCase();
+    const consumers = (reverse.get(relative) ?? [])
+      .filter((relation) => relation.kind === "extends")
+      .map((relation) => relation.relative);
+    if (consumers.length === 0 && candidates.some(({ file }) => file.relative.toLowerCase() === relative)) {
+      roots.add(relative);
+    }
+    const queue = [...consumers];
+    const seen = new Set(queue);
+    for (let index = 0; index < queue.length; index += 1) {
+      const consumer = candidates.find(({ file }) => file.relative.toLowerCase() === queue[index]);
+      if (consumer?.file.name.toLowerCase() === "tsconfig.json") roots.add(queue[index]);
+      for (const relation of reverse.get(queue[index]) ?? []) {
+        if (relation.kind === "extends" && !seen.has(relation.relative)) {
+          seen.add(relation.relative);
+          queue.push(relation.relative);
+        }
+      }
+    }
+  }
+  for (const { file, parsed } of candidates) {
+    for (const reference of parsed.references) {
+      const target = candidates.find(({ file: candidate }) => referenceMatchesConfig(
+        path.posix.dirname(file.relative),
+        reference,
+        candidate.relative,
+        true,
+      ));
+      if (target) roots.add(target.file.relative.toLowerCase());
+    }
+  }
+  return roots;
+}
+
+export function shouldActivateTypeScriptConfig({
+  manifestName,
+  manifestRelative,
+  projectFiles = [],
+  directClaim = false,
+  configKind = "typescript",
+  activeConfigRelatives = null,
+  ownershipConfigRelatives = null,
+}) {
+  if (!isConfigCandidate({ kind: configKind }) || manifestName.toLowerCase() === "jsconfig.json") return false;
+  if (activeConfigRelatives) {
+    return activeConfigRelatives.has(manifestRelative.toLowerCase())
+      && (!ownershipConfigRelatives || ownershipConfigRelatives.has(manifestRelative.toLowerCase()));
+  }
+  if (manifestName.toLowerCase() === "tsconfig.json" || directClaim) return true;
+  return localConfigReferences(manifestRelative, projectFiles).length > 0;
+}
+
+export function parseJsonc(text) {
+  if (typeof text !== "string" || text.length > 1024 * 1024 || /\r(?!\n)/u.test(text)) return null;
+  try {
+    return JSON.parse(removeTrailingCommas(maskJsonComments(text)));
+  } catch {
+    return null;
+  }
+}
+
+export function parseTypeScriptConfig(text, fileName = "tsconfig.json") {
+  const value = parseJsonc(text);
+  if (!isPlainObject(value)) return invalidConfig();
+  const references = value.references === undefined
+    ? []
+    : Array.isArray(value.references) && value.references.every((reference) => isPlainObject(reference) && typeof reference.path === "string" && reference.path.trim() !== "")
+      ? value.references.map((reference) => reference.path)
+      : null;
+  const extendsValue = value.extends === undefined
+    ? []
+    : typeof value.extends === "string" && value.extends.trim() !== ""
+      ? [value.extends]
+      : Array.isArray(value.extends) && value.extends.every((reference) => typeof reference === "string" && reference.trim() !== "")
+        ? [...value.extends]
+        : undefined;
+  const compilerOptions = value.compilerOptions === undefined
+    ? {}
+    : isPlainObject(value.compilerOptions) ? value.compilerOptions : null;
+  if (references === null || extendsValue === undefined || compilerOptions === null) return invalidConfig();
+  for (const key of ["files", "include", "exclude"]) {
+    if (value[key] !== undefined && (!Array.isArray(value[key])
+      || value[key].some((entry) => typeof entry !== "string" || entry.trim() === ""))) return invalidConfig();
+  }
+  return {
+    valid: true,
+    references,
+    extends: extendsValue,
+    compilerOptions,
+    fileName,
+  };
+}
+
+export function inspectTypeScriptProject({
+  projectRoot,
+  manifestRelative,
+  manifestText,
+  manifestName,
+  targetRoot,
+  projectFiles,
+  directClaim = false,
+  configKind = "typescript",
+  activeConfigRelatives = null,
+  ownershipConfigRelatives = null,
+}) {
+  const parsed = parseTypeScriptConfig(manifestText, manifestName);
+  const isConfig = shouldActivateTypeScriptConfig({
+    manifestName,
+    manifestRelative,
+    projectFiles,
+    directClaim,
+    configKind,
+    activeConfigRelatives,
+    ownershipConfigRelatives,
+  });
+  const primary = parsed.valid && isConfig;
+  const primarySignals = primary ? [`${manifestRelative}:tsconfig`] : [];
+  const supportingSignals = [];
+  for (const reference of parsed.references) supportingSignals.push(`${manifestRelative}:reference=${reference}`);
+  for (const reference of parsed.extends) supportingSignals.push(`${manifestRelative}:extends=${reference}`);
+  const localReferences = parsed.references.filter((reference) => {
+    return projectFiles.some((file) => referenceMatchesConfig(
+      projectRoot,
+      reference,
+      path.posix.normalize(file.relative ?? ""),
+      true,
+    ));
+  });
+  const localExtends = parsed.extends.flatMap((reference) => projectFiles
+    .filter((file) => referenceMatchesConfig(path.posix.dirname(manifestRelative), reference, file.relative))
+    .map((file) => file.relative.toLowerCase()));
+  for (const reference of localReferences) supportingSignals.push(`${manifestRelative}:local-reference=${reference}`);
+  for (const reference of parsed.extends) {
+    if (projectFiles.some((file) => referenceMatchesConfig(
+      path.posix.dirname(manifestRelative),
+      reference,
+      file.relative,
+    ))) supportingSignals.push(`${manifestRelative}:local-extends=${reference}`);
+  }
+  return createLanguageProject({
+    kind: "typescript",
+    root: projectRoot,
+    manifest: manifestRelative,
+    frameworks: primary ? ["typescript"] : [],
+    primary,
+    primarySignals,
+    supportingSignals,
+    internal: { ...parsed, valid: parsed.valid, localReferences, localExtends },
+  });
+}
+
+export function isDeclarationFile(fileName) {
+  return typeof fileName === "string" && /\.d\.(?:ts|mts|cts)$/iu.test(fileName);
+}