openxiangda 1.0.159 → 1.0.161

package/lib/source-dependencies.js

@@ -0,0 +1,742 @@
+const fs = require('fs');
+const path = require('path');
+const ts = require('typescript');
+
+const SOURCE_EXTENSIONS = new Set([
+  '.ts',
+  '.tsx',
+  '.mts',
+  '.cts',
+  '.js',
+  '.jsx',
+  '.mjs',
+  '.cjs',
+]);
+
+const LOCAL_MODULE_EXTENSIONS = [
+  '',
+  '.ts',
+  '.tsx',
+  '.mts',
+  '.cts',
+  '.js',
+  '.jsx',
+  '.mjs',
+  '.cjs',
+  '.json',
+];
+
+const RESOURCE_BUCKETS = [
+  'forms',
+  'dataViews',
+  'connectors',
+  'notifications',
+  'functions',
+  'storageConfigs',
+];
+
+const RESOURCE_BUCKET_ALIASES = new Map([
+  ['forms', 'forms'],
+  ['form', 'forms'],
+  ['dataviews', 'dataViews'],
+  ['data-views', 'dataViews'],
+  ['dataview', 'dataViews'],
+  ['connectors', 'connectors'],
+  ['connector', 'connectors'],
+  ['notifications', 'notifications'],
+  ['notification', 'notifications'],
+  ['notificationtypes', 'notifications'],
+  ['notification-types', 'notifications'],
+  ['functions', 'functions'],
+  ['function', 'functions'],
+  ['storageconfigs', 'storageConfigs'],
+  ['storage-configs', 'storageConfigs'],
+  ['storage', 'storageConfigs'],
+]);
+
+const TARGET_MANIFEST_KEYS = [
+  ['functions', 'functions'],
+  ['automations', 'automations'],
+  ['workflows', 'workflows'],
+  ['jsCodeNodes', 'jsCodeNodes'],
+];
+
+function normalizeWorkspacePath(value) {
+  return String(value || '')
+    .split(path.sep)
+    .join('/')
+    .replace(/^\.\//, '');
+}
+
+function isPathInside(root, target) {
+  const relative = path.relative(root, target);
+  return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+
+function workspaceRelativePath(workspaceRoot, filePath) {
+  return normalizeWorkspacePath(path.relative(workspaceRoot, filePath));
+}
+
+function getScriptKind(filePath) {
+  switch (path.extname(filePath).toLowerCase()) {
+    case '.tsx':
+      return ts.ScriptKind.TSX;
+    case '.jsx':
+      return ts.ScriptKind.JSX;
+    case '.js':
+    case '.mjs':
+    case '.cjs':
+      return ts.ScriptKind.JS;
+    default:
+      return ts.ScriptKind.TS;
+  }
+}
+
+function loadCompilerOptions(workspaceRoot) {
+  const configPath = ts.findConfigFile(workspaceRoot, ts.sys.fileExists, 'tsconfig.json');
+  if (!configPath) {
+    return {
+      allowJs: true,
+      moduleResolution: ts.ModuleResolutionKind.Node10,
+      resolveJsonModule: true,
+    };
+  }
+  const config = ts.readConfigFile(configPath, ts.sys.readFile);
+  if (config.error) return { allowJs: true, resolveJsonModule: true };
+  const parsed = ts.parseJsonConfigFileContent(config.config, ts.sys, path.dirname(configPath));
+  return {
+    ...parsed.options,
+    allowJs: true,
+    resolveJsonModule: true,
+  };
+}
+
+function resolveFileCandidate(basePath) {
+  for (const extension of LOCAL_MODULE_EXTENSIONS) {
+    const candidate = `${basePath}${extension}`;
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return path.resolve(candidate);
+  }
+  for (const extension of LOCAL_MODULE_EXTENSIONS.slice(1)) {
+    const candidate = path.join(basePath, `index${extension}`);
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return path.resolve(candidate);
+  }
+  return null;
+}
+
+function resolveLocalModule(workspaceRoot, containingFile, specifier, compilerOptions) {
+  const value = String(specifier || '').trim();
+  if (!value) return null;
+  const localLooking = value.startsWith('.') || value.startsWith('@/') || value.startsWith('~/');
+  const resolved = ts.resolveModuleName(value, containingFile, compilerOptions, ts.sys).resolvedModule;
+  if (resolved?.resolvedFileName) {
+    const filePath = path.resolve(resolved.resolvedFileName);
+    if (isPathInside(workspaceRoot, filePath) && !filePath.includes(`${path.sep}node_modules${path.sep}`)) {
+      return filePath;
+    }
+  }
+  if (!localLooking) return null;
+  const fallbackBase = value.startsWith('@/') || value.startsWith('~/')
+    ? path.join(workspaceRoot, 'src', value.slice(2))
+    : path.resolve(path.dirname(containingFile), value);
+  return resolveFileCandidate(fallbackBase);
+}
+
+function unwrapExpression(expression) {
+  let current = expression;
+  while (
+    current &&
+    (ts.isParenthesizedExpression(current) ||
+      ts.isAsExpression(current) ||
+      ts.isTypeAssertionExpression(current) ||
+      ts.isNonNullExpression(current) ||
+      ts.isSatisfiesExpression?.(current))
+  ) {
+    current = current.expression;
+  }
+  return current;
+}
+
+function propertyNameText(name) {
+  if (!name) return '';
+  if (ts.isIdentifier(name) || ts.isPrivateIdentifier(name)) return name.text;
+  if (ts.isStringLiteralLike(name) || ts.isNumericLiteral(name)) return String(name.text);
+  return '';
+}
+
+function collectConstInitializers(sourceFile) {
+  const bindings = new Map();
+  const visit = node => {
+    if (
+      ts.isVariableStatement(node) &&
+      (node.declarationList.flags & ts.NodeFlags.Const) !== 0
+    ) {
+      for (const declaration of node.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name) && declaration.initializer) {
+          bindings.set(declaration.name.text, declaration.initializer);
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return bindings;
+}
+
+function readStaticString(expression, bindings, seen = new Set()) {
+  const value = unwrapExpression(expression);
+  if (!value) return null;
+  if (ts.isStringLiteralLike(value) || ts.isNoSubstitutionTemplateLiteral(value)) {
+    return value.text;
+  }
+  if (ts.isIdentifier(value)) {
+    if (seen.has(value.text)) return null;
+    const initializer = bindings.get(value.text);
+    if (!initializer) return null;
+    const nextSeen = new Set(seen);
+    nextSeen.add(value.text);
+    return readStaticString(initializer, bindings, nextSeen);
+  }
+  if (ts.isPropertyAccessExpression(value) || ts.isElementAccessExpression(value)) {
+    const owner = unwrapExpression(value.expression);
+    const property = ts.isPropertyAccessExpression(value)
+      ? value.name.text
+      : readStaticString(value.argumentExpression, bindings, seen);
+    if (!property) return null;
+    const ownerValue = ts.isIdentifier(owner) && bindings.has(owner.text)
+      ? unwrapExpression(bindings.get(owner.text))
+      : owner;
+    if (!ownerValue || !ts.isObjectLiteralExpression(ownerValue)) return null;
+    const entry = ownerValue.properties.find(item =>
+      (ts.isPropertyAssignment(item) || ts.isShorthandPropertyAssignment(item)) &&
+      propertyNameText(item.name) === property
+    );
+    if (!entry) return null;
+    if (ts.isPropertyAssignment(entry)) return readStaticString(entry.initializer, bindings, seen);
+    return readStaticString(bindings.get(entry.name.text), bindings, seen);
+  }
+  return null;
+}
+
+function getPropertyPath(expression, bindings) {
+  const value = unwrapExpression(expression);
+  if (!value) return null;
+  if (ts.isIdentifier(value)) return [value.text];
+  if (ts.isPropertyAccessExpression(value)) {
+    const parent = getPropertyPath(value.expression, bindings);
+    return parent ? [...parent, value.name.text] : null;
+  }
+  if (ts.isElementAccessExpression(value)) {
+    const parent = getPropertyPath(value.expression, bindings);
+    const key = readStaticString(value.argumentExpression, bindings);
+    return parent && key ? [...parent, key] : null;
+  }
+  return null;
+}
+
+function readStaticObjectProperty(expression, propertyNames, bindings) {
+  const value = unwrapExpression(expression);
+  if (!value || !ts.isObjectLiteralExpression(value)) return null;
+  for (const property of value.properties) {
+    if (!ts.isPropertyAssignment(property)) continue;
+    if (!propertyNames.includes(propertyNameText(property.name))) continue;
+    const result = readStaticString(property.initializer, bindings);
+    if (result) return result;
+  }
+  return null;
+}
+
+function sourceLocation(sourceFile, node, workspaceRoot) {
+  const start = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+  return {
+    file: workspaceRelativePath(workspaceRoot, sourceFile.fileName),
+    line: start.line + 1,
+    column: start.character + 1,
+  };
+}
+
+function addReference(references, sourceFile, node, workspaceRoot, bucket, code, api) {
+  const normalizedCode = String(code || '').trim();
+  if (!normalizedCode) return;
+  references.push({
+    bucket,
+    code: normalizedCode,
+    api,
+    ...sourceLocation(sourceFile, node, workspaceRoot),
+  });
+}
+
+function addDynamicReferenceWarning(warnings, sourceFile, node, workspaceRoot, api, expected) {
+  warnings.push({
+    code: 'dynamic-resource-reference',
+    api,
+    message: `${api} 使用动态资源 code，无法静态核对 manifest；请确认 resources.${expected} 已完整声明`,
+    ...sourceLocation(sourceFile, node, workspaceRoot),
+  });
+}
+
+function inspectResourceCall(node, sourceFile, workspaceRoot, bindings, references, warnings) {
+  if (!ts.isCallExpression(node)) return;
+  const callee = getPropertyPath(node.expression, bindings);
+  if (!callee || callee[0] !== 'ctx' || callee.length < 3) return;
+  const namespace = callee[1];
+  const method = callee[2];
+  const api = callee.join('.');
+  const firstArgument = node.arguments[0];
+
+  if (namespace === 'resources' && method.startsWith('resolve')) {
+    const bucket = {
+      resolveForm: 'forms',
+      resolveDataView: 'dataViews',
+      resolveConnector: 'connectors',
+      resolveNotification: 'notifications',
+      resolveNotificationType: 'notifications',
+      resolveTemplate: 'notifications',
+      resolveFunction: 'functions',
+      resolveStorage: 'storageConfigs',
+    }[method];
+    if (!bucket) return;
+    const code = readStaticString(firstArgument, bindings);
+    if (code) addReference(references, sourceFile, node, workspaceRoot, bucket, code, api);
+    else addDynamicReferenceWarning(warnings, sourceFile, node, workspaceRoot, api, bucket);
+    return;
+  }
+
+  if (namespace === 'form') {
+    const code = readStaticObjectProperty(firstArgument, ['formCode', 'code'], bindings) ||
+      readStaticString(firstArgument, bindings);
+    if (code) addReference(references, sourceFile, node, workspaceRoot, 'forms', code, api);
+    else if (firstArgument) addDynamicReferenceWarning(warnings, sourceFile, node, workspaceRoot, api, 'forms');
+    return;
+  }
+
+  if (namespace === 'dataView' && ['query', 'stats'].includes(method)) {
+    const code = readStaticString(firstArgument, bindings) ||
+      readStaticObjectProperty(firstArgument, ['dataViewCode', 'code'], bindings);
+    if (code) addReference(references, sourceFile, node, workspaceRoot, 'dataViews', code, api);
+    else if (firstArgument) addDynamicReferenceWarning(warnings, sourceFile, node, workspaceRoot, api, 'dataViews');
+    return;
+  }
+
+  if (namespace === 'connector' && ['invoke', 'call'].includes(method)) {
+    let code = readStaticObjectProperty(firstArgument, ['connector', 'connectorCode', 'code'], bindings);
+    if (!code && method === 'call') {
+      const callName = readStaticString(firstArgument, bindings);
+      code = callName ? callName.split('.')[0] : null;
+    }
+    if (code) addReference(references, sourceFile, node, workspaceRoot, 'connectors', code, api);
+    else if (firstArgument) addDynamicReferenceWarning(warnings, sourceFile, node, workspaceRoot, api, 'connectors');
+    return;
+  }
+
+  if (
+    namespace === 'notification' &&
+    [
+      'sendByType',
+      'batchSendByType',
+      'findConfig',
+      'previewTemplate',
+      'previewDingTalk',
+      'sendDingTalk',
+      'updateDingTalkCard',
+    ].includes(method)
+  ) {
+    const code = readStaticString(firstArgument, bindings) ||
+      readStaticObjectProperty(firstArgument, ['notificationType', 'templateCode', 'code'], bindings);
+    if (code) addReference(references, sourceFile, node, workspaceRoot, 'notifications', code, api);
+    else if (firstArgument) addDynamicReferenceWarning(warnings, sourceFile, node, workspaceRoot, api, 'notifications');
+  }
+}
+
+function collectModuleSpecifiers(sourceFile) {
+  const result = [];
+  const visit = node => {
+    if (
+      (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) &&
+      node.moduleSpecifier &&
+      ts.isStringLiteralLike(node.moduleSpecifier)
+    ) {
+      result.push({ value: node.moduleSpecifier.text, node: node.moduleSpecifier });
+    } else if (
+      ts.isImportEqualsDeclaration(node) &&
+      ts.isExternalModuleReference(node.moduleReference) &&
+      node.moduleReference.expression &&
+      ts.isStringLiteralLike(node.moduleReference.expression)
+    ) {
+      result.push({ value: node.moduleReference.expression.text, node: node.moduleReference.expression });
+    } else if (
+      ts.isCallExpression(node) &&
+      node.arguments.length > 0 &&
+      (node.expression.kind === ts.SyntaxKind.ImportKeyword ||
+        (ts.isIdentifier(node.expression) && node.expression.text === 'require')) &&
+      ts.isStringLiteralLike(node.arguments[0])
+    ) {
+      result.push({ value: node.arguments[0].text, node: node.arguments[0] });
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return result;
+}
+
+function dedupeDetails(values, keys) {
+  const seen = new Set();
+  return values.filter(value => {
+    const key = keys.map(name => value[name] || '').join('\0');
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function analyzeTypeScriptEntry(options = {}) {
+  const workspaceRoot = path.resolve(options.workspaceRoot || process.cwd());
+  const entryFile = path.resolve(workspaceRoot, options.entryFile || '');
+  const compilerOptions = options.compilerOptions || loadCompilerOptions(workspaceRoot);
+  const queue = [entryFile];
+  const visited = new Set();
+  const sourceDependencies = new Set();
+  const references = [];
+  const warnings = [];
+
+  while (queue.length > 0) {
+    const current = path.resolve(queue.shift());
+    if (visited.has(current)) continue;
+    visited.add(current);
+    if (!fs.existsSync(current) || !fs.statSync(current).isFile()) {
+      warnings.push({
+        code: 'missing-source-file',
+        file: workspaceRelativePath(workspaceRoot, current),
+        line: 1,
+        column: 1,
+        message: `本地 sourceFile 不存在: ${workspaceRelativePath(workspaceRoot, current)}`,
+      });
+      continue;
+    }
+    if (!isPathInside(workspaceRoot, current)) continue;
+    sourceDependencies.add(workspaceRelativePath(workspaceRoot, current));
+    if (!SOURCE_EXTENSIONS.has(path.extname(current).toLowerCase())) continue;
+
+    const content = fs.readFileSync(current, 'utf8');
+    const sourceFile = ts.createSourceFile(
+      current,
+      content,
+      ts.ScriptTarget.Latest,
+      true,
+      getScriptKind(current)
+    );
+    for (const diagnostic of sourceFile.parseDiagnostics || []) {
+      const position = diagnostic.start === undefined
+        ? { line: 0, character: 0 }
+        : sourceFile.getLineAndCharacterOfPosition(diagnostic.start);
+      warnings.push({
+        code: 'source-parse-diagnostic',
+        file: workspaceRelativePath(workspaceRoot, current),
+        line: position.line + 1,
+        column: position.character + 1,
+        message: ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'),
+      });
+    }
+
+    const bindings = collectConstInitializers(sourceFile);
+    const inspect = node => {
+      inspectResourceCall(node, sourceFile, workspaceRoot, bindings, references, warnings);
+      ts.forEachChild(node, inspect);
+    };
+    inspect(sourceFile);
+
+    for (const imported of collectModuleSpecifiers(sourceFile)) {
+      const localLooking = imported.value.startsWith('.') || imported.value.startsWith('@/') || imported.value.startsWith('~/');
+      const resolved = resolveLocalModule(workspaceRoot, current, imported.value, compilerOptions);
+      if (resolved) {
+        queue.push(resolved);
+      } else if (localLooking) {
+        warnings.push({
+          code: 'unresolved-local-import',
+          specifier: imported.value,
+          message: `无法解析本地 import: ${imported.value}`,
+          ...sourceLocation(sourceFile, imported.node, workspaceRoot),
+        });
+      }
+    }
+  }
+
+  const resourceReferenceDetails = dedupeDetails(
+    references,
+    ['bucket', 'code', 'file', 'line', 'column', 'api']
+  ).sort((left, right) =>
+    `${left.bucket}\0${left.code}\0${left.file}\0${left.line}`.localeCompare(
+      `${right.bucket}\0${right.code}\0${right.file}\0${right.line}`
+    )
+  );
+  const resourceReferences = Object.fromEntries(
+    RESOURCE_BUCKETS.map(bucket => [
+      bucket,
+      Array.from(
+        new Set(
+          resourceReferenceDetails
+            .filter(reference => reference.bucket === bucket)
+            .map(reference => reference.code)
+        )
+      ).sort(),
+    ])
+  );
+
+  return {
+    entryFile: workspaceRelativePath(workspaceRoot, entryFile),
+    sourceDependencies: Array.from(sourceDependencies).sort(),
+    resourceReferences,
+    resourceReferenceDetails,
+    warnings: dedupeDetails(warnings, ['code', 'file', 'line', 'column', 'api', 'message']),
+  };
+}
+
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function resolveManifestLocalPath(workspaceRoot, baseDir, localPath) {
+  const fromBase = path.resolve(baseDir || workspaceRoot, localPath);
+  if (fs.existsSync(fromBase)) return fromBase;
+  return path.resolve(workspaceRoot, localPath);
+}
+
+function collectManifestStructures(workspaceRoot, item) {
+  const sourceEntries = new Set();
+  const resourceContainers = [];
+  const visited = new Set();
+  const externalFiles = new Set();
+
+  const visit = (value, baseDir) => {
+    if (!value || typeof value !== 'object' || visited.has(value)) return;
+    visited.add(value);
+    if (Array.isArray(value)) {
+      for (const child of value) visit(child, baseDir);
+      return;
+    }
+    if (value.sourceFile?.localPath) {
+      sourceEntries.add(
+        resolveManifestLocalPath(workspaceRoot, baseDir, String(value.sourceFile.localPath))
+      );
+    }
+    if (value.resources && typeof value.resources === 'object') {
+      resourceContainers.push(value.resources);
+    }
+    if (value.resourceBindings && typeof value.resourceBindings === 'object') {
+      resourceContainers.push(value.resourceBindings);
+    }
+    for (const [key, child] of Object.entries(value)) {
+      if (key.startsWith('__')) continue;
+      if (key === 'definitionFile' && typeof child === 'string' && child.trim()) {
+        const definitionPath = path.resolve(baseDir || workspaceRoot, child);
+        if (!externalFiles.has(definitionPath) && fs.existsSync(definitionPath)) {
+          externalFiles.add(definitionPath);
+          const external = readJsonFile(definitionPath);
+          if (external) visit(external, path.dirname(definitionPath));
+        }
+        continue;
+      }
+      if (child && typeof child === 'object') visit(child, baseDir);
+    }
+  };
+
+  visit(item, item.__dir || workspaceRoot);
+  return {
+    sourceEntries: Array.from(sourceEntries).sort(),
+    resourceContainers,
+  };
+}
+
+function normalizeDeclaredCodes(value) {
+  if (value === undefined || value === null || value === false) return [];
+  if (Array.isArray(value)) {
+    return value.flatMap(normalizeDeclaredCodes);
+  }
+  if (typeof value === 'object') {
+    return Object.keys(value).map(key => String(key).trim()).filter(Boolean);
+  }
+  return String(value)
+    .split(',')
+    .map(item => item.trim())
+    .filter(Boolean);
+}
+
+function collectDeclaredResources(item, resourceContainers) {
+  const result = Object.fromEntries(RESOURCE_BUCKETS.map(bucket => [bucket, new Set()]));
+  for (const container of resourceContainers) {
+    for (const [rawBucket, value] of Object.entries(container || {})) {
+      const normalizedBucket = RESOURCE_BUCKET_ALIASES.get(
+        String(rawBucket).replace(/[_\s]+/g, '-').toLowerCase()
+      );
+      if (!normalizedBucket) continue;
+      for (const code of normalizeDeclaredCodes(value)) result[normalizedBucket].add(code);
+    }
+  }
+  if (item.formCode) result.forms.add(String(item.formCode));
+  return Object.fromEntries(
+    RESOURCE_BUCKETS.map(bucket => [bucket, Array.from(result[bucket]).sort()])
+  );
+}
+
+function getManifestItemCode(item) {
+  return String(
+    item?.code || item?.resourceCode || item?.functionCode || item?.scriptCode || item?.methodName || ''
+  ).trim();
+}
+
+function mergeAnalyses(workspaceRoot, entries) {
+  const analyses = entries.map(entryFile =>
+    analyzeTypeScriptEntry({ workspaceRoot, entryFile })
+  );
+  const sourceDependencies = Array.from(
+    new Set(analyses.flatMap(analysis => analysis.sourceDependencies))
+  ).sort();
+  const resourceReferenceDetails = dedupeDetails(
+    analyses.flatMap(analysis => analysis.resourceReferenceDetails),
+    ['bucket', 'code', 'file', 'line', 'column', 'api']
+  );
+  const resourceReferences = Object.fromEntries(
+    RESOURCE_BUCKETS.map(bucket => [
+      bucket,
+      Array.from(
+        new Set(
+          resourceReferenceDetails
+            .filter(reference => reference.bucket === bucket)
+            .map(reference => reference.code)
+        )
+      ).sort(),
+    ])
+  );
+  return {
+    entryFiles: entries.map(entry => workspaceRelativePath(workspaceRoot, entry)).sort(),
+    sourceDependencies,
+    resourceReferences,
+    resourceReferenceDetails,
+    warnings: dedupeDetails(
+      analyses.flatMap(analysis => analysis.warnings),
+      ['code', 'file', 'line', 'column', 'api', 'message']
+    ),
+  };
+}
+
+function analyzeManifestSourceDependencies(options = {}) {
+  const workspaceRoot = path.resolve(options.workspaceRoot || process.cwd());
+  const manifest = options.manifest || {};
+  const targets = [];
+  const byDependency = new Map();
+
+  for (const [manifestKey, targetKey] of TARGET_MANIFEST_KEYS) {
+    for (const item of manifest[manifestKey] || []) {
+      const code = getManifestItemCode(item);
+      if (!code) continue;
+      const structures = collectManifestStructures(workspaceRoot, item);
+      if (structures.sourceEntries.length === 0) continue;
+      const analysis = {
+        targetKey,
+        code,
+        declaredResources: collectDeclaredResources(item, structures.resourceContainers),
+        ...mergeAnalyses(workspaceRoot, structures.sourceEntries),
+      };
+      Object.defineProperty(item, '__sourceAnalysis', {
+        value: analysis,
+        configurable: true,
+        enumerable: false,
+        writable: true,
+      });
+      targets.push(analysis);
+      for (const dependency of analysis.sourceDependencies) {
+        if (!byDependency.has(dependency)) byDependency.set(dependency, []);
+        byDependency.get(dependency).push({ targetKey, code });
+      }
+    }
+  }
+
+  return { workspaceRoot, targets, byDependency };
+}
+
+function validateManifestSourceBindings(options = {}) {
+  const index = analyzeManifestSourceDependencies(options);
+  const errors = [];
+  const warnings = [];
+
+  for (const target of index.targets) {
+    const label = `${target.targetKey.replace(/s$/, '')} ${target.code}`;
+    const transitiveMissing = [];
+    for (const reference of target.resourceReferenceDetails) {
+      const declared = target.declaredResources[reference.bucket] || [];
+      if (declared.includes(reference.code)) continue;
+      if (reference.bucket === 'forms' && /^FORM[_-]/i.test(reference.code)) continue;
+      const message =
+        `${label}: ${reference.file}:${reference.line} ${reference.api} 引用 ${reference.bucket}.${reference.code}，` +
+        `但 manifest 未声明。请将 "${reference.code}" 加入 resources.${reference.bucket}`;
+      if (target.entryFiles.includes(reference.file)) {
+        errors.push(message);
+      } else {
+        transitiveMissing.push(reference);
+      }
+    }
+    if (transitiveMissing.length > 0) {
+      const codes = Array.from(
+        new Set(transitiveMissing.map(reference => `${reference.bucket}.${reference.code}`))
+      ).sort();
+      const visible = codes.slice(0, 12);
+      warnings.push(
+        `${label}: 传递依赖中发现 manifest 未声明的资源引用: ${visible.join(', ')}` +
+          `${codes.length > visible.length ? ` 等 ${codes.length} 项` : ''}。` +
+          '静态分析无法证明相关导出一定被当前入口调用；若会执行，请补充对应 resources 声明'
+      );
+    }
+    for (const warning of target.warnings) {
+      if (
+        warning.code === 'dynamic-resource-reference' &&
+        !target.entryFiles.includes(warning.file)
+      ) {
+        continue;
+      }
+      warnings.push(
+        `${label}: ${warning.file}:${warning.line} ${warning.message}`
+      );
+    }
+  }
+
+  return {
+    index,
+    errors: Array.from(new Set(errors)),
+    warnings: Array.from(new Set(warnings)),
+    sourceDependencies: index.targets.map(target => ({
+      kind: target.targetKey,
+      code: target.code,
+      entryFiles: target.entryFiles,
+      sourceDependencies: target.sourceDependencies,
+      resourceReferences: target.resourceReferences,
+    })),
+  };
+}
+
+function getImpactedResourceTargets(index, changedFiles = []) {
+  const result = {
+    functions: new Set(),
+    automations: new Set(),
+    workflows: new Set(),
+    jsCodeNodes: new Set(),
+  };
+  for (const rawFile of changedFiles) {
+    const file = normalizeWorkspacePath(rawFile);
+    for (const target of index?.byDependency?.get(file) || []) {
+      if (result[target.targetKey]) result[target.targetKey].add(target.code);
+    }
+  }
+  return Object.fromEntries(
+    Object.entries(result).map(([key, values]) => [key, Array.from(values).sort()])
+  );
+}
+
+module.exports = {
+  analyzeManifestSourceDependencies,
+  analyzeTypeScriptEntry,
+  getImpactedResourceTargets,
+  validateManifestSourceBindings,
+};