simple-dynamsoft-mcp 7.6.1 → 7.7.0

package/src/rag/search-utils.js

@@ -78,9 +78,11 @@ function chunkMarkdown(text, chunkSize, chunkOverlap, maxChunks) {
   const sections = [];
   let current = { path: "", lines: [] };
 
+  // Heading-only sections (e.g. index pages whose headings are links) are
+  // kept: their heading path is the only text that makes them findable.
   const flush = () => {
     const body = current.lines.join(" ").replace(/\s+/g, " ").trim();
-    if (body) sections.push({ path: current.path, body });
+    if (body || current.path) sections.push({ path: current.path, body });
   };
 
   let inFence = false;
@@ -116,6 +118,11 @@ function chunkMarkdown(text, chunkSize, chunkOverlap, maxChunks) {
   const chunks = [];
   for (const section of sections) {
     const prefix = section.path ? `${section.path}\n` : "";
+    if (!section.body) {
+      chunks.push(section.path);
+      if (maxChunks && chunks.length >= maxChunks) return chunks;
+      continue;
+    }
     const pieces = chunkText(section.body, chunkSize, chunkOverlap, maxChunks);
     for (const piece of pieces) {
       chunks.push(`${prefix}${piece}`.trim());
@@ -248,6 +255,7 @@ function buildIndexSignature({ pkgVersion, signatureData, ragConfig }) {
     dbrWebDocCount: signatureData.dbrWebDocCount,
     dbrMobileDocCount: signatureData.dbrMobileDocCount,
     dbrServerDocCount: signatureData.dbrServerDocCount,
+    dbrSharedDocCount: signatureData.dbrSharedDocCount,
     dwtDocCount: signatureData.dwtDocCount,
     ddvDocCount: signatureData.ddvDocCount,
     versions: signatureData.versions,
@@ -257,7 +265,9 @@ function buildIndexSignature({ pkgVersion, signatureData, ragConfig }) {
     maxChunksPerDoc: ragConfig.maxChunksPerDoc,
     maxTextChars: ragConfig.maxTextChars,
     // Bump when the chunking strategy changes so cached vector indexes rebuild.
-    chunkStrategy: "heading-aware-v1"
+    chunkStrategy: "heading-aware-v2",
+    // Bump when doc:// URIs change shape; cached vectors are keyed by URI.
+    docUriScheme: "source-path-v1"
   });
 }
 

package/src/rag/vector-cache.js

@@ -20,6 +20,70 @@ function makeCheckpointFileName(provider, model, cacheKey) {
   return `rag-${provider}-${safeModel}-${cacheKey.slice(0, 12)}.checkpoint.json`;
 }
 
+// Cache layout: a JSON header (`<name>.json`: cacheKey, meta, items, vector
+// count/dimensions) plus a sibling `<name>.f32` file holding all vectors as
+// packed little-endian float32. Serializing vectors into JSON overflowed V8's
+// ~512MB max string length once the index grew; neither file here is built as
+// one large string.
+const VECTOR_FORMAT = "float32-le-v1";
+
+function vectorFileFor(headerFile) {
+  return headerFile.replace(/\.json$/i, ".f32");
+}
+
+function writeVectorFiles(headerFile, payload) {
+  const { vectors, ...header } = payload;
+  const list = Array.isArray(vectors) ? vectors : [];
+  const dimensions = list.length > 0 ? list[0].length : 0;
+  const packed = new Float32Array(list.length * dimensions);
+  list.forEach((vector, index) => {
+    if (vector.length !== dimensions) {
+      throw new Error(`Vector ${index} has ${vector.length} dimensions; expected ${dimensions}`);
+    }
+    packed.set(vector, index * dimensions);
+  });
+  // Vectors first: a header always describes a complete vector file, and a
+  // stale header next to a newer vector file fails the size check on load.
+  writeFileSync(vectorFileFor(headerFile), Buffer.from(packed.buffer, packed.byteOffset, packed.byteLength));
+  writeFileSync(headerFile, JSON.stringify({
+    ...header,
+    vectorFormat: VECTOR_FORMAT,
+    vectorCount: list.length,
+    dimensions
+  }));
+}
+
+// Returns the parsed header with `vectors` as Float32Array views over one
+// buffer, or { error } describing why the files cannot be used.
+function readVectorFiles(headerFile) {
+  const header = JSON.parse(readFileSync(headerFile, "utf8"));
+  if (!header || header.vectorFormat !== VECTOR_FORMAT || !Array.isArray(header.items)) {
+    return { error: "invalid_payload" };
+  }
+  const vectorFile = vectorFileFor(headerFile);
+  if (!existsSync(vectorFile)) {
+    return { error: "vectors_missing" };
+  }
+  const count = Number(header.vectorCount) || 0;
+  const dimensions = Number(header.dimensions) || 0;
+  const raw = readFileSync(vectorFile);
+  if (raw.byteLength !== count * dimensions * Float32Array.BYTES_PER_ELEMENT) {
+    return { error: "vectors_size_mismatch" };
+  }
+  // Copy into an aligned buffer; Buffer offsets are not guaranteed 4-byte aligned.
+  const all = new Float32Array(raw.buffer.slice(raw.byteOffset, raw.byteOffset + raw.byteLength));
+  const vectors = new Array(count);
+  for (let i = 0; i < count; i += 1) {
+    vectors[i] = all.subarray(i * dimensions, (i + 1) * dimensions);
+  }
+  return { payload: { ...header, vectors } };
+}
+
+function removeVectorFiles(headerFile) {
+  rmSync(headerFile, { force: true });
+  rmSync(vectorFileFor(headerFile), { force: true });
+}
+
 function loadVectorIndexCache(
   cacheFile,
   { cacheKey, signature, provider, model, requireSignature = false } = {}
@@ -28,12 +92,12 @@ function loadVectorIndexCache(
     return { hit: false, reason: "missing", payload: null };
   }
   try {
-    const parsed = JSON.parse(readFileSync(cacheFile, "utf8"));
-    if (!parsed || (cacheKey && parsed.cacheKey !== cacheKey)) {
-      return { hit: false, reason: "cache_key_mismatch", payload: null };
+    const { payload: parsed, error } = readVectorFiles(cacheFile);
+    if (error) {
+      return { hit: false, reason: error, payload: null };
     }
-    if (!Array.isArray(parsed.items) || !Array.isArray(parsed.vectors)) {
-      return { hit: false, reason: "invalid_payload", payload: null };
+    if (cacheKey && parsed.cacheKey !== cacheKey) {
+      return { hit: false, reason: "cache_key_mismatch", payload: null };
     }
     const meta = parsed.meta || {};
     if (provider && meta.provider && meta.provider !== provider) {
@@ -59,23 +123,7 @@ function loadVectorIndexCache(
 
 function saveVectorIndexCache(cacheDir, cacheFile, payload) {
   ensureDirectory(cacheDir);
-  let serialized;
-  try {
-    serialized = JSON.stringify(payload);
-  } catch (error) {
-    // JSON.stringify throws "Invalid string length" once the serialized cache
-    // exceeds V8's ~512MB max string length (reached with a large index of
-    // high-dimensional vectors). Fail with an actionable message instead.
-    if (error instanceof RangeError) {
-      const itemCount = Array.isArray(payload?.items) ? payload.items.length : "unknown";
-      throw new Error(
-        `Vector cache too large to serialize (${itemCount} items) — exceeds the JSON string limit. ` +
-        "Lower RAG_MAX_CHUNKS_PER_DOC or adopt a ceiling-proof cache format."
-      );
-    }
-    throw error;
-  }
-  writeFileSync(cacheFile, serialized);
+  writeVectorFiles(cacheFile, payload);
 }
 
 function loadVectorIndexCheckpoint(checkpointFile, expectedKey, expectedItems) {
@@ -83,12 +131,12 @@ function loadVectorIndexCheckpoint(checkpointFile, expectedKey, expectedItems) {
     return { hit: false, reason: "missing", payload: null };
   }
   try {
-    const parsed = JSON.parse(readFileSync(checkpointFile, "utf8"));
-    if (!parsed || parsed.cacheKey !== expectedKey) {
-      return { hit: false, reason: "cache_key_mismatch", payload: null };
+    const { payload: parsed, error } = readVectorFiles(checkpointFile);
+    if (error) {
+      return { hit: false, reason: error, payload: null };
     }
-    if (!Array.isArray(parsed.items) || !Array.isArray(parsed.vectors)) {
-      return { hit: false, reason: "invalid_payload", payload: null };
+    if (parsed.cacheKey !== expectedKey) {
+      return { hit: false, reason: "cache_key_mismatch", payload: null };
     }
     if (parsed.items.length !== expectedItems.length) {
       return { hit: false, reason: "items_length_mismatch", payload: null };
@@ -109,13 +157,11 @@ function loadVectorIndexCheckpoint(checkpointFile, expectedKey, expectedItems) {
 
 function saveVectorIndexCheckpoint(cacheDir, checkpointFile, payload) {
   ensureDirectory(cacheDir);
-  writeFileSync(checkpointFile, JSON.stringify(payload));
+  writeVectorFiles(checkpointFile, payload);
 }
 
 function clearVectorIndexCheckpoint(checkpointFile) {
-  if (existsSync(checkpointFile)) {
-    rmSync(checkpointFile, { force: true });
-  }
+  removeVectorFiles(checkpointFile);
 }
 
 function listFilesRecursive(rootDir) {

package/src/server/resource-index/builders.js

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { extname, join } from "node:path";
 import { DDV_PREFERRED_ENTRY_FILES } from "./config.js";
+import { shortDocPath } from "./docs-loader.js";
 import { PRODUCT_SELECTION_GUIDANCE, PUBLIC_OFFERING_PRODUCTS } from "../public-offerings.js";
 
 const MRZ_MATCHER = /(?:\bmrz\b|machine[-\s]?readable[-\s]?zone|passport)/i;
@@ -201,6 +202,29 @@ function addPublicResourceToIndex(addResourceToIndex, entry) {
   }
 }
 
+function encodeDocSlug(slug) {
+  return String(slug).split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+
+// One doc:// slug per article: its short path, or (on a collision within the
+// same URI prefix + platform, e.g. `user-guide.md` vs `user-guide/index.md`)
+// its full source path. Shared pages keep their `slugPrefix` namespace
+// (`dcv`, `dcv-core`) in both forms.
+function assignDocSlugs(docs, defaultPlatform) {
+  const withPrefix = (article, slug) => (article.slugPrefix ? `${article.slugPrefix}/${slug}` : slug);
+  const keyFor = (article, slug) => `${article.platform || defaultPlatform}/${slug}`;
+  const shortSlugs = docs.map((article) => withPrefix(article, shortDocPath(article.path || article.title)));
+  const counts = new Map();
+  docs.forEach((article, i) => {
+    const key = keyFor(article, shortSlugs[i]);
+    counts.set(key, (counts.get(key) || 0) + 1);
+  });
+  return docs.map((article, i) => {
+    if (counts.get(keyFor(article, shortSlugs[i])) === 1) return shortSlugs[i];
+    return withPrefix(article, String(article.path || article.title).replace(/\\/g, "/").replace(/\.md$/i, ""));
+  });
+}
+
 function addMarkdownDocResources({
   addResourceToIndex,
   docs,
@@ -214,12 +238,18 @@ function addMarkdownDocResources({
   defaultSummary,
   baseTags
 }) {
+  const slugs = assignDocSlugs(docs, defaultPlatform);
   for (let i = 0; i < docs.length; i++) {
     const article = docs[i];
     if (!article?.title) continue;
-    const slug = `${encodeURIComponent(article.title)}-${i}`;
+    const slug = encodeDocSlug(slugs[i]);
     const platform = article.platform || defaultPlatform;
     const tags = [...baseTags, platform];
+    if (Array.isArray(article.platforms)) {
+      for (const extra of article.platforms) {
+        if (!tags.includes(extra)) tags.push(extra);
+      }
+    }
     if (article.breadcrumb) tags.push(...article.breadcrumb.toLowerCase().split(/\s*>\s*/));
     // Fold frontmatter keywords into tags so domain-vocabulary search hits (#142).
     if (Array.isArray(article.keywords)) {
@@ -239,7 +269,9 @@ function addMarkdownDocResources({
       product,
       edition,
       platform,
+      ...(Array.isArray(article.platforms) ? { platforms: article.platforms } : {}),
       version,
+      ...(article.sourceVersion ? { sourceVersion: article.sourceVersion } : {}),
       majorVersion,
       url: article.url,
       title: product === "mrz" || product === "mds"
@@ -601,6 +633,7 @@ function buildResourceIndex({
   dbrWebDocs,
   dbrMobileDocs,
   dbrServerDocs,
+  dbrSharedDocs,
   dwtDocs,
   ddvDocs,
   discoverDcvMobileSamples,
@@ -967,6 +1000,27 @@ function buildResourceIndex({
     baseTags: ["doc", "dbr", "server"]
   });
 
+  const sharedEditions = [
+    ["web", dbrWebVersion, "Web"],
+    ["mobile", dbrMobileVersion, "Mobile"],
+    ["server", dbrServerVersion, "Server/Desktop"]
+  ];
+  for (const [edition, version, label] of sharedEditions) {
+    addMarkdownDocResources({
+      addResourceToIndex,
+      docs: dbrSharedDocs?.[edition] || [],
+      idPrefix: `dbr-${edition}-shared-doc`,
+      uriPrefix: `doc://dbr/${edition}`,
+      product: "dbr",
+      edition,
+      version,
+      majorVersion: LATEST_MAJOR.dbr,
+      defaultPlatform: edition,
+      defaultSummary: `Shared Capture Vision API used by Dynamsoft Barcode Reader ${label}`,
+      baseTags: ["doc", "dbr", edition, "shared", "capture-vision"]
+    });
+  }
+
   for (const platform of getDbrMobilePlatforms()) {
     const samples = discoverMobileSamples(platform);
     for (const level of ["high-level", "low-level"]) {
@@ -1155,6 +1209,7 @@ function buildResourceIndex({
 }
 
 export {
+  assignDocSlugs,
   buildIndexData,
   buildResourceIndex
 };

package/src/server/resource-index/docs-loader.js

@@ -98,9 +98,56 @@ function markdownPathToUrl(baseUrl, relativePath) {
   return `${baseUrl}${normalized}`;
 }
 
-function loadMarkdownDocs({ rootDir, urlBase, includeDirNames = [], excludeDirs = [], excludeFiles = [] }) {
+// Path used in doc:// URIs. The platform is already a URI segment, so the
+// `programming/<lang>/` prefix is dropped, and a directory's index page is
+// addressed by the directory.
+function shortDocPath(relativePath) {
+  const withoutExt = String(relativePath || "").replace(/\\/g, "/").replace(/\.md$/i, "");
+  const withoutPlatform = withoutExt.replace(/^programming\/[^/]+\//, "");
+  const withoutIndex = withoutPlatform.replace(/(^|\/)index$/, "");
+  return withoutIndex || "index";
+}
+
+const SITE_ORIGIN = "https://www.dynamsoft.com";
+
+// Top-level `key: value` pairs from a Jekyll _config.yml. Only path/URL values
+// are kept: they are what docs interpolate as `{{ site.key }}` link prefixes.
+function loadSiteVariables(siteRoot) {
+  const vars = new Map();
+  const configPath = join(siteRoot || "", "_config.yml");
+  if (!siteRoot || !existsSync(configPath)) return vars;
+  for (const line of readFileSync(configPath, "utf8").split(/\r?\n/)) {
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*["']?([^"'#\s]+)["']?\s*(?:#.*)?$/);
+    if (!match) continue;
+    const [, key, value] = match;
+    if (value.startsWith("/")) {
+      vars.set(key, `${SITE_ORIGIN}${value}`);
+    } else if (/^https?:\/\//i.test(value)) {
+      vars.set(key, value);
+    }
+  }
+  return vars;
+}
+
+// Replace `{{ site.key }}` with the absolute URL from _config.yml so links in
+// returned docs (and the shared-doc link map) point at the real public pages.
+// Unknown keys are left untouched.
+function resolveSiteLinks(text, siteVars) {
+  if (!text || !siteVars || siteVars.size === 0) return text;
+  return String(text).replace(/\{\{\s*site\.([A-Za-z0-9_-]+)\s*\}\}/g, (whole, key) => siteVars.get(key) ?? whole);
+}
+
+function loadMarkdownDocs({
+  rootDir,
+  urlBase,
+  siteRoot = rootDir,
+  includeDirNames = [],
+  excludeDirs = [],
+  excludeFiles = []
+}) {
   if (!existsSync(rootDir)) return { articles: [] };
 
+  const siteVars = loadSiteVariables(siteRoot);
   const files = collectMarkdownFiles(rootDir, { includeDirNames, excludeDirs, excludeFiles });
   const articles = [];
 
@@ -108,6 +155,9 @@ function loadMarkdownDocs({ rootDir, urlBase, includeDirNames = [], excludeDirs
     const relativePath = relative(rootDir, filePath).replace(/\\/g, "/");
     const raw = readFileSync(filePath, "utf8");
     const parsed = parseFrontMatter(raw);
+    // Jekyll redirect stubs have no content of their own; indexing them yields
+    // empty hits whose URL only redirects elsewhere.
+    if (parsed.meta.redirect_to) continue;
     const title = parsed.meta.title || getHeadingTitle(parsed.body) || formatSegmentLabel(relativePath.replace(/\.md$/i, "").split("/").pop());
     if (!title) continue;
     const breadcrumb = parsed.meta.breadcrumbText || buildBreadcrumbFromPath(relativePath) || title;
@@ -121,7 +171,7 @@ function loadMarkdownDocs({ rootDir, urlBase, includeDirNames = [], excludeDirs
     articles.push({
       title,
       url: markdownPathToUrl(urlBase, relativePath),
-      content: parsed.body.trim(),
+      content: resolveSiteLinks(parsed.body.trim(), siteVars),
       breadcrumb,
       description,
       keywords,
@@ -129,9 +179,12 @@ function loadMarkdownDocs({ rootDir, urlBase, includeDirNames = [], excludeDirs
     });
   }
 
-  return { articles };
+  return { articles, siteVars };
 }
 
 export {
-  loadMarkdownDocs
+  loadMarkdownDocs,
+  loadSiteVariables,
+  resolveSiteLinks,
+  shortDocPath
 };

package/src/server/resource-index/shared-docs.js

@@ -0,0 +1,161 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { resolveSiteLinks } from "./docs-loader.js";
+
+// DBR's public API is built on shared Capture Vision (DCV) modules such as
+// CaptureVisionRouter, whose reference pages live only in the DCV docs. DBR's
+// own docs and navigation sidebars link to exactly the DCV pages DBR relies on,
+// so those links are the dependency map: only linked pages are indexed under
+// DBR, never the whole DCV corpus.
+
+const DCV_CURRENT_DOCS_PREFIX = "https://www.dynamsoft.com/capture-vision/docs/";
+
+// Sidebar include `sidelist-programming/programming-<segment>.html` scopes its
+// links to one DBR platform; other includes apply to the whole edition.
+const SIDEBAR_PLATFORM_BY_SEGMENT = {
+  javascript: "web",
+  android: "android",
+  oc: "ios",
+  ios: "ios",
+  flutter: "flutter",
+  maui: "maui",
+  "react-native": "react-native",
+  cpp: "cpp",
+  dotnet: "dotnet",
+  java: "java",
+  python: "python",
+  nodejs: "nodejs"
+};
+
+function normalizeDocUrl(url) {
+  // Some DBR links contain `//` inside the path (e.g. `api-reference//core/`).
+  let normalized = String(url || "").split("#")[0].split("?")[0].replace(/([^:])\/{2,}/g, "$1/");
+  if (!normalized) return "";
+  if (normalized.endsWith("/")) return `${normalized}index.html`;
+  const lastSegment = normalized.slice(normalized.lastIndexOf("/") + 1);
+  if (!lastSegment.includes(".")) normalized = `${normalized}.html`;
+  return normalized;
+}
+
+function extractDcvLinks(text) {
+  const links = new Set();
+  const pattern = /https:\/\/www\.dynamsoft\.com\/capture-vision\/docs\/[^\s)"'<>\]`]+/g;
+  for (const match of String(text || "").matchAll(pattern)) {
+    const normalized = normalizeDocUrl(match[0]);
+    if (normalized.startsWith(DCV_CURRENT_DOCS_PREFIX)) links.add(normalized);
+  }
+  return links;
+}
+
+function listIncludeFiles(dir) {
+  const files = [];
+  if (!existsSync(dir)) return files;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listIncludeFiles(fullPath));
+    } else if (/\.(html|md)$/i.test(entry.name)) {
+      files.push({ path: fullPath, name: entry.name });
+    }
+  }
+  return files;
+}
+
+function sidebarPlatform(fileName) {
+  const match = String(fileName).match(/^programming-(.+)\.html$/i);
+  return match ? SIDEBAR_PLATFORM_BY_SEGMENT[match[1].toLowerCase()] || "" : "";
+}
+
+// url -> Set of DBR platforms whose docs link to it ("*" = whole edition).
+function buildDcvLinkMap({ dbrArticles, dbrRoot, siteVars }) {
+  const linkMap = new Map();
+  const addLinks = (links, platform) => {
+    for (const url of links) {
+      if (!linkMap.has(url)) linkMap.set(url, new Set());
+      linkMap.get(url).add(platform);
+    }
+  };
+
+  for (const article of dbrArticles || []) {
+    addLinks(extractDcvLinks(article.content), article.platform || "*");
+  }
+  for (const file of listIncludeFiles(join(dbrRoot || "", "_includes"))) {
+    const text = resolveSiteLinks(readFileSync(file.path, "utf8"), siteVars);
+    addLinks(extractDcvLinks(text), sidebarPlatform(file.name) || "*");
+  }
+  return linkMap;
+}
+
+function parseVersionParts(version) {
+  return String(version || "").split(".").map((part) => Number.parseInt(part, 10));
+}
+
+// DBR and DCV ship in lockstep: 11.6.3200 pairs with 3.6.3200. Edition pages
+// must match minor and build; core reference pages are edition-neutral and
+// only need the same minor.
+function isCompatibleSharedVersion(dbrVersion, dcvVersion, { requireBuild }) {
+  const [, dbrMinor, dbrBuild] = parseVersionParts(dbrVersion);
+  const [, dcvMinor, dcvBuild] = parseVersionParts(dcvVersion);
+  if (!Number.isFinite(dbrMinor) || dbrMinor !== dcvMinor) return false;
+  if (requireBuild && dbrBuild !== dcvBuild) return false;
+  return true;
+}
+
+/**
+ * Select DCV pages linked from one DBR edition.
+ *
+ * @param {object} options
+ * @param {Array} options.dbrArticles DBR edition articles (with platform).
+ * @param {string} options.dbrRoot DBR docs repo root (for `_includes`).
+ * @param {Map} options.siteVars DBR repo `{{ site.* }}` variables.
+ * @param {string} options.dbrVersion DBR edition version.
+ * @param {Array<{articles: Array, version: string, editionSpecific: boolean, slugPrefix: string}>} options.sources
+ * @param {Function} [options.onSkip] Called with details when a source is version-incompatible.
+ * @returns {Array} Articles with `slugPrefix` (doc:// namespace), `platform`, `platforms`, `sourceVersion`.
+ */
+function selectSharedDcvDocs({ dbrArticles, dbrRoot, siteVars, dbrVersion, sources, onSkip }) {
+  const linkMap = buildDcvLinkMap({ dbrArticles, dbrRoot, siteVars });
+  const editionPlatforms = [...new Set((dbrArticles || []).map((article) => article.platform).filter(Boolean))].sort();
+  const selected = [];
+
+  for (const source of sources) {
+    if (!isCompatibleSharedVersion(dbrVersion, source.version, { requireBuild: source.editionSpecific })) {
+      onSkip?.({ dbrVersion, dcvVersion: source.version, slugPrefix: source.slugPrefix });
+      continue;
+    }
+    for (const article of source.articles || []) {
+      const linkedFrom = linkMap.get(normalizeDocUrl(article.url));
+      if (!linkedFrom) continue;
+
+      let platforms;
+      if (source.editionSpecific) {
+        // An edition page belongs to one platform (its programming/<lang>/ dir).
+        if (!editionPlatforms.includes(article.platform) && editionPlatforms.length > 0) continue;
+        platforms = [article.platform];
+      } else {
+        platforms = linkedFrom.has("*")
+          ? editionPlatforms
+          : [...linkedFrom].filter((platform) => editionPlatforms.includes(platform)).sort();
+      }
+      if (platforms.length === 0) continue;
+
+      selected.push({
+        ...article,
+        slugPrefix: source.slugPrefix,
+        platform: platforms.length === 1 ? platforms[0] : (source.defaultPlatform || platforms[0]),
+        platforms,
+        sourceVersion: source.version
+      });
+    }
+  }
+
+  return selected;
+}
+
+export {
+  buildDcvLinkMap,
+  extractDcvLinks,
+  isCompatibleSharedVersion,
+  normalizeDocUrl,
+  selectSharedDcvDocs
+};