@gmickel/gno 2.8.1 → 2.8.2

package/README.md

@@ -139,7 +139,7 @@ See the [guide](docs/COMPILED-CONTEXT.md).
 
 <!-- public-truth:current-version -->
 
-> Current source version: **v2.8.1**. See [CHANGELOG.md](./CHANGELOG.md).
+> Current source version: **v2.8.2**. See [CHANGELOG.md](./CHANGELOG.md).
 
 <!-- /public-truth -->
 

package/assets/skill/SKILL.md

@@ -356,8 +356,10 @@ rewrite, persist findings, judge factual truth, or replace retrieval.
 finding. Link findings carry `referenceKind`, `resolutionStatus`, and
 `resolvedScope` in their evidence detail; ambiguous vault links list the tied
 `candidates`. `links.outside-index` `info` findings are link targets that
-exist in the vault but are not indexed (attachments, excluded or unindexed
-folders); Obsidian resolves them, so do not report them as broken links.
+exist in the vault but are not indexed (attachments, files a Markdown link
+names by path, excluded or unindexed folders); Obsidian resolves them, so do
+not report them as broken links. Links are read only from Markdown notes,
+never from code spans, code blocks, or non-Markdown files.
 Report `truncation.snapshotTruncated` as "totals cover the bounded snapshot,
 not the whole index".
 

package/browser-extension/artifacts/gno-browser-clipper-v2.8.2.zip.sha256

@@ -0,0 +1 @@
+7bc830276cb923a482b662b980208b0978bf8ddbfbade0873e67d9757cf9c989  gno-browser-clipper-v2.8.2.zip

package/browser-extension/dist/manifest.json

@@ -21,5 +21,5 @@
   "content_security_policy": {
     "extension_pages": "script-src 'self'; object-src 'none'; connect-src http://127.0.0.1:*"
   },
-  "version": "2.8.1"
+  "version": "2.8.2"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "2.8.1",
+  "version": "2.8.2",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",

package/spec/cli.md

@@ -965,18 +965,29 @@ Orphans stay "no incoming or outgoing resolved links", with connectivity drawn
 from the whole index even when the audited documents are scoped; a tied link
 connects nothing.
 
-A plain wiki link or embed from a document in a link workspace whose target
-is not an indexed document but exists as a file inside the workspace root (a
-non-Markdown attachment, a note in an unindexed folder, a note excluded by a
-collection pattern) is not reported by `links.local-targets`. It is an `info`
+Links are parsed only from documents converted by the Markdown converter
+(`native/markdown`); plain text, source code, data files and converted
+documents store no links and produce no link findings, while staying
+searchable. The parser skips frontmatter, HTML comments, and code as a
+CommonMark + GFM parser reads it: inline code spans, fenced code blocks and
+indented code blocks, inside blockquotes and list items too (an indented list
+paragraph is not code). A link outside code on the same line still counts.
+
+A plain wiki link, embed, or relative Markdown link from a document in a link
+workspace whose target is not an indexed document but exists as a file inside
+the workspace root (a non-Markdown attachment, a script beside the note, a
+note in an unindexed folder, a note excluded by a collection pattern) is not
+reported by `links.local-targets`. It is an `info`
 finding of `links.outside-index` (evidence kind `outside-index-target`,
 `resolutionStatus: "outside-index"`). That rule stays `pass`, so these
 findings never change the exit code. The check is existence-only: each
 involved workspace root is listed once per run (hidden files and folders
 skipped, symlinked folders not descended, a symlink counted only when it
 resolves to a regular file inside the workspace, at most 200,000 files), no
-file is opened, and no graph edge is created. Targets match files by the workspace
+file is opened, and no graph edge is created. Wiki targets match files by the workspace
 link rules; a non-Markdown target needs its extension, `.md` is optional. A
+Markdown link matches only the file at its resolved path (NFC,
+case-insensitive). A
 target missing from the listing stays unresolved; an unreadable folder or the
 file bound makes the listing incomplete, which the `links.outside-index` rule
 message states once.

package/src/converters/native/markdown.ts

@@ -8,7 +8,9 @@ import type { Converter, ConvertInput, ConvertResult } from "../types";
 import { basenameWithoutExt } from "../path";
 import { NATIVE_VERSIONS } from "../versions";
 
-const CONVERTER_ID = "native/markdown" as const;
+/** Converter id of Markdown sources, the only documents with link edges. */
+export const MARKDOWN_CONVERTER_ID = "native/markdown" as const;
+const CONVERTER_ID = MARKDOWN_CONVERTER_ID;
 const CONVERTER_VERSION = NATIVE_VERSIONS.markdown;
 
 /** UTF-8 BOM character */

package/src/core/audit-links.ts

@@ -16,8 +16,9 @@ import {
 /**
  * 1.1: workspace-wide resolution and reference/resolution/scope evidence.
  * 1.2: `links.outside-index` for workspace files that are not indexed.
+ * 1.3: relative Markdown links to such files are `outside-index` too.
  */
-export const LINK_AUDIT_RULE_VERSION = "1.2" as const;
+export const LINK_AUDIT_RULE_VERSION = "1.3" as const;
 /** Default per-rule cap; runs pass the effective `maxFindings` instead. */
 export const LINK_AUDIT_MAX_FINDINGS_PER_RULE = 1000;
 

package/src/core/audit-outside-index.ts

@@ -1,7 +1,8 @@
 /**
- * Existence-only classification of unresolved workspace wiki links whose
- * target is a file inside the link workspace that is not an indexed document
- * (an attachment, or a note in an unindexed or excluded folder). Obsidian
+ * Existence-only classification of unresolved workspace wiki links and
+ * relative Markdown links whose target is a file inside the link workspace
+ * that is not an indexed document (an attachment, a script beside a note, or
+ * a note in an unindexed or excluded folder). Obsidian
  * resolves such links, so the link audit reports them as `outside-index`
  * instead of unresolved. Only file names are listed: no file is opened,
  * indexed, or returned, and no graph edge is created.
@@ -26,6 +27,9 @@ import {
 } from "../store/sqlite/workspace-link-resolver";
 import { pathContains, placeDocument } from "./link-workspace";
 
+/** Path identity for exact-path matching: NFC, case-insensitive. */
+const pathKey = (path: string): string => path.normalize("NFC").toLowerCase();
+
 /** Upper bound of files listed per workspace; beyond it the listing is partial. */
 export const WORKSPACE_FILE_LISTING_MAX_FILES = 200_000;
 
@@ -145,8 +149,10 @@ export const listWorkspaceFiles = async (
 };
 
 /**
- * Mark unresolved plain wiki links of audited documents inside a link
- * workspace whose target exists as a workspace file. Each involved workspace
+ * Mark unresolved plain wiki links and relative Markdown links of audited
+ * documents inside a link workspace whose target exists as a workspace file.
+ * A wiki link matches under workspace resolution rules; a Markdown link must
+ * name the file's exact path (NFC, case-insensitive). Each involved workspace
  * is listed once per call. A failed or partial listing never marks a link
  * that is not in it; the snapshot then carries one diagnostic.
  */
@@ -163,8 +169,8 @@ export const markOutsideIndexLinks = async (
     .filter(
       ({ link }) =>
         link.resolved === null &&
-        link.linkType === "wiki" &&
-        link.explicitCollection !== true &&
+        (link.linkType === "markdown" ||
+          (link.linkType === "wiki" && link.explicitCollection !== true)) &&
         (audited === null || audited.has(link.sourceId))
     );
   if (candidates.length === 0) return snapshot;
@@ -172,19 +178,34 @@ export const markOutsideIndexLinks = async (
   const documentRelPaths = new Map(
     snapshot.documents.map((document) => [document.id, document.relPath])
   );
-  const placed = candidates.flatMap(({ link, index }) => {
+  type PlacedLink = {
+    link: AuditLinkSnapshot["links"][number];
+    index: number;
+    key: string;
+  } & ({ sourcePath: string } | { targetPath: string });
+  const placed = candidates.flatMap(({ link, index }): PlacedLink[] => {
+    const membership = memberships.get(link.sourceCollection);
     const placement = placeDocument(
-      memberships.get(link.sourceCollection),
+      membership,
       documentRelPaths.get(link.sourceId) ?? link.sourceRelPath
     );
-    return placement.key === null
-      ? []
-      : [{ link, index, key: placement.key, sourcePath: placement.path }];
+    if (placement.key === null) return [];
+    if (link.linkType === "wiki") {
+      return [{ link, index, key: placement.key, sourcePath: placement.path }];
+    }
+    // A Markdown target is stored collection-relative; place it the same way.
+    const target = placeDocument(membership, link.targetRefNorm);
+    return target.key === placement.key
+      ? [{ link, index, key: placement.key, targetPath: target.path }]
+      : [];
   });
   if (placed.length === 0) return snapshot;
-  const matchers = new Map<
+  const listings = new Map<
     string,
-    ReturnType<typeof createWorkspaceFileMatcher>
+    {
+      matches: ReturnType<typeof createWorkspaceFileMatcher>;
+      paths: Set<string>;
+    }
   >();
   const maxFiles = options.maxFiles ?? WORKSPACE_FILE_LISTING_MAX_FILES;
   let incomplete = 0;
@@ -194,12 +215,19 @@ export const markOutsideIndexLinks = async (
       signal: options.signal,
     });
     if (!listing.complete) incomplete += 1;
-    matchers.set(key, createWorkspaceFileMatcher(listing.files));
+    listings.set(key, {
+      matches: createWorkspaceFileMatcher(listing.files),
+      paths: new Set(listing.files.map(pathKey)),
+    });
   }
   const links = [...snapshot.links];
   for (const entry of placed) {
-    const matches = matchers.get(entry.key);
-    if (matches?.(entry.link.targetRefNorm, entry.sourcePath)) {
+    const listing = listings.get(entry.key);
+    const exists =
+      "targetPath" in entry
+        ? listing?.paths.has(pathKey(entry.targetPath)) === true
+        : listing?.matches(entry.link.targetRefNorm, entry.sourcePath) === true;
+    if (exists) {
       links[entry.index] = { ...entry.link, outsideIndex: true };
     }
   }

package/src/core/change-diff.ts

@@ -12,7 +12,7 @@ import type {
 
 import { parseFrontmatter } from "../ingestion/frontmatter";
 import { buildLineOffsets } from "../ingestion/position";
-import { getExcludedRanges } from "../ingestion/strip";
+import { type ExcludedRange, getExcludedRanges } from "../ingestion/strip";
 import { normalizeMarkdownPath, normalizeWikiName, parseLinks } from "./links";
 import { extractSections } from "./sections";
 
@@ -107,9 +107,9 @@ const extractTypedEdges = (markdown: string): string[] => {
 export const extractDocumentStructure = (
   markdown: string,
   relPath: string,
-  dateFields: Readonly<Record<string, string>> | null | undefined
+  dateFields: Readonly<Record<string, string>> | null | undefined,
+  excludedRanges: ExcludedRange[] = getExcludedRanges(markdown)
 ): DocumentStructureSnapshot => {
-  const excludedRanges = getExcludedRanges(markdown);
   const links = parseLinks(markdown, buildLineOffsets(markdown), excludedRanges)
     .map((link) => linkSummary(link, relPath))
     .filter((value): value is string => value !== null);

package/src/core/link-inventory-opaque.ts

@@ -81,7 +81,9 @@ export function findExcludedKind(
 export function codeContextReason(
   kind: ExcludedRange["kind"] | null
 ): "code_fence_context" | "inline_code_context" | null {
-  if (kind === "fenced_code") return "code_fence_context";
+  if (kind === "fenced_code" || kind === "indented_code") {
+    return "code_fence_context";
+  }
   if (kind === "inline_code") return "inline_code_context";
   return null;
 }

package/src/ingestion/strip.ts

@@ -4,6 +4,7 @@
  * Identifies regions to exclude from link/tag extraction:
  * - YAML frontmatter
  * - Fenced code blocks (CommonMark backtick and tilde fences)
+ * - Indented code blocks
  * - Inline code
  * - HTML comments
  *
@@ -13,6 +14,10 @@
  * @module src/ingestion/strip
  */
 
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { gfm } from "micromark-extension-gfm";
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Types
 // ─────────────────────────────────────────────────────────────────────────────
@@ -20,6 +25,7 @@
 export type ExcludedRangeKind =
   | "frontmatter"
   | "fenced_code"
+  | "indented_code"
   | "inline_code"
   | "html_comment";
 
@@ -39,150 +45,100 @@ export interface ExcludedRange {
 /** Frontmatter at start of file (YAML between --- delimiters) */
 const FRONTMATTER_REGEX = /^---\r?\n[\s\S]*?(?:\r?\n)?---(?:\r?\n|$)/;
 
-/** CommonMark fence opener: 0–3 spaces, then 3+ backticks or tildes + info. */
-const FENCE_OPEN_REGEX = /^ {0,3}(`{3,}|~{3,})(.*)$/u;
-
-/** CommonMark fence closer: matching character, length ≥ opener, trailing space/tabs only. */
-const FENCE_CLOSE_REGEX = /^ {0,3}(`{3,}|~{3,})[\t ]*$/u;
-
 /** HTML comments */
 const HTML_COMMENT_REGEX = /<!--[\s\S]*?-->/g;
 
-interface OpenFence {
-  marker: "`" | "~";
-  length: number;
-  start: number;
-}
-
+/** Backtick (code span or fence) or tilde fence anywhere in the text. */
+const INLINE_OR_FENCE_TRIGGER_REGEX = /`|~~~/;
+/** Blockquote markers and indentation before a line's content. */
+const CONTAINER_PREFIX_REGEX = /^[\t >]*/;
+/** Four columns of indentation after any blockquote markers. */
+const INDENTED_LINE_REGEX = /^(?:>[\t ]?)*(?:\t| {4})/;
 /**
- * Collect CommonMark fenced code ranges (backtick and tilde). A closer must
- * use the same character and be at least as long as the opener; when omitted,
- * CommonMark extends the fenced block through end of input.
+ * Lines after which an indented line may start an indented code block: an
+ * ATX heading, table row, HTML or definition line, or a thematic break or
+ * setext underline. After prose or a list item it continues the paragraph.
  */
-const collectFencedCodeRanges = (markdown: string): ExcludedRange[] => {
-  const ranges: ExcludedRange[] = [];
-  let offset = 0;
-  let open: OpenFence | null = null;
-
-  while (offset <= markdown.length) {
-    const nextNl = markdown.indexOf("\n", offset);
-    const lineEnd = nextNl === -1 ? markdown.length : nextNl;
-    const rawLine = markdown.slice(offset, lineEnd);
-    const logical = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+const BLOCK_END_LINE_REGEX =
+  /^(?:[#|<[]|([-*_=])[\t ]*(?:\1[\t ]*){2,}$)|>[\t ]*$/u;
 
-    if (open) {
-      const closeRun = FENCE_CLOSE_REGEX.exec(logical)?.[1];
-      if (
-        closeRun &&
-        closeRun[0] === open.marker &&
-        closeRun.length >= open.length
-      ) {
-        const end = nextNl === -1 ? markdown.length : nextNl + 1;
-        ranges.push({ start: open.start, end, kind: "fenced_code" });
-        open = null;
-      }
-    } else {
-      const openMatch = FENCE_OPEN_REGEX.exec(logical);
-      const run = openMatch?.[1];
-      const suffix = openMatch?.[2] ?? "";
-      // Backtick info strings cannot contain backticks (CommonMark).
-      if (run && !(run[0] === "`" && suffix.includes("`"))) {
-        open = {
-          marker: run[0] as OpenFence["marker"],
-          length: run.length,
-          start: offset,
-        };
-      }
+/**
+ * Cheap superset test for code: a backtick, a tilde fence, or an indented
+ * line that can open an indented code block (not a list continuation). When
+ * it fails the note has no code and the parser is skipped.
+ */
+const mayContainCode = (markdown: string): boolean => {
+  if (INLINE_OR_FENCE_TRIGGER_REGEX.test(markdown)) return true;
+  let previous: string | null = null;
+  for (const rawLine of markdown.split("\n")) {
+    const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+    const content = line.replace(CONTAINER_PREFIX_REGEX, "");
+    if (
+      content !== "" &&
+      INDENTED_LINE_REGEX.test(line) &&
+      (previous === null ||
+        previous === "" ||
+        BLOCK_END_LINE_REGEX.test(previous))
+    ) {
+      return true;
     }
-
-    if (nextNl === -1) break;
-    offset = nextNl + 1;
-  }
-
-  if (open) {
-    ranges.push({
-      start: open.start,
-      end: markdown.length,
-      kind: "fenced_code",
-    });
+    previous = content;
   }
-
-  return ranges;
+  return false;
 };
 
-interface BacktickRun {
-  end: number;
-  length: number;
-  start: number;
+/** Opening fence at the start of a code node: backtick or tilde fence. */
+const FENCE_START_REGEX = /^[\t ]*(?:`{3,}|~{3,})/;
+
+interface CodeNode {
+  children?: CodeNode[];
+  position?: { start: { offset?: number }; end: { offset?: number } };
+  type: string;
 }
 
-/** CommonMark code spans close only on a backtick run of equal length. */
-const collectInlineCodeRanges = (
+/**
+ * Code regions as the CommonMark + GFM parser sees them: inline code spans,
+ * fenced code blocks and indented code blocks, with their block context
+ * (paragraphs, blockquotes, list items) handled by the parser. Frontmatter is
+ * blanked first (same length, newlines kept) so it cannot open a fence.
+ */
+const collectCodeRanges = (
   markdown: string,
-  excludedRanges: ExcludedRange[]
+  frontmatterEnd: number
 ): ExcludedRange[] => {
-  const runs: BacktickRun[] = [];
-  let cursor = 0;
-  let excludedIndex = 0;
-  while (cursor < markdown.length) {
-    while (
-      excludedRanges[excludedIndex] &&
-      excludedRanges[excludedIndex]!.end <= cursor
-    ) {
-      excludedIndex += 1;
-    }
-    const excluded = excludedRanges[excludedIndex];
-    if (excluded && cursor >= excluded.start && cursor < excluded.end) {
-      cursor = excluded.end;
-      continue;
-    }
-    if (markdown[cursor] !== "`") {
-      cursor += 1;
-      continue;
-    }
-    const start = cursor;
-    while (markdown[cursor] === "`") cursor += 1;
-    let backslashes = 0;
-    for (let i = start - 1; i >= 0 && markdown[i] === "\\"; i -= 1) {
-      backslashes += 1;
-    }
-    if (backslashes % 2 === 0) {
-      runs.push({ start, end: cursor, length: cursor - start });
-    }
-  }
-
-  const nextMatchingRun = Array.from<number | undefined>({
-    length: runs.length,
-  });
-  const latestByLength = new Map<number, number>();
-  for (let index = runs.length - 1; index >= 0; index -= 1) {
-    const run = runs[index];
-    if (!run) continue;
-    nextMatchingRun[index] = latestByLength.get(run.length);
-    latestByLength.set(run.length, index);
-  }
-
+  if (!mayContainCode(markdown.slice(frontmatterEnd))) return [];
+  const source =
+    frontmatterEnd > 0
+      ? markdown.slice(0, frontmatterEnd).replace(/[^\r\n]/gu, " ") +
+        markdown.slice(frontmatterEnd)
+      : markdown;
+  const root = fromMarkdown(source, {
+    extensions: [gfm()],
+    mdastExtensions: [gfmFromMarkdown()],
+  }) as CodeNode;
   const ranges: ExcludedRange[] = [];
-  let index = 0;
-  while (index < runs.length) {
-    const closeIndex = nextMatchingRun[index];
-    const opener = runs[index];
-    if (closeIndex === undefined || !opener) {
-      index += 1;
-      continue;
-    }
-    const closer = runs[closeIndex];
-    if (!closer) {
-      index += 1;
-      continue;
+  const visit = (node: CodeNode): void => {
+    const start = node.position?.start.offset;
+    const end = node.position?.end.offset;
+    if (start !== undefined && end !== undefined && end > start) {
+      if (node.type === "inlineCode") {
+        ranges.push({ start, end, kind: "inline_code" });
+        return;
+      }
+      if (node.type === "code") {
+        ranges.push({
+          start,
+          end,
+          kind: FENCE_START_REGEX.test(source.slice(start, end))
+            ? "fenced_code"
+            : "indented_code",
+        });
+        return;
+      }
     }
-    ranges.push({
-      start: opener.start,
-      end: closer.end,
-      kind: "inline_code",
-    });
-    index = closeIndex + 1;
-  }
+    for (const child of node.children ?? []) visit(child);
+  };
+  visit(root);
   return ranges;
 };
 
@@ -208,10 +164,7 @@ export function getExcludedRanges(markdown: string): ExcludedRange[] {
     });
   }
 
-  // 2. Fenced code blocks (backtick + tilde, CommonMark matching rules)
-  ranges.push(...collectFencedCodeRanges(markdown));
-
-  // 3. HTML comments
+  // 2. HTML comments
   HTML_COMMENT_REGEX.lastIndex = 0;
   let match: RegExpExecArray | null;
   while ((match = HTML_COMMENT_REGEX.exec(markdown)) !== null) {
@@ -222,10 +175,10 @@ export function getExcludedRanges(markdown: string): ExcludedRange[] {
     });
   }
 
-  // 4. Inline code. Pair delimiters only in visible prose so unmatched
-  // backticks inside already-excluded blocks cannot consume later content.
-  ranges.sort((a, b) => a.start - b.start);
-  ranges.push(...collectInlineCodeRanges(markdown, ranges));
+  // 3. Code spans and fenced or indented code blocks, from the parser.
+  ranges.push(
+    ...collectCodeRanges(markdown, frontmatterMatch?.[0].length ?? 0)
+  );
 
   // Sort by start position for efficient lookup
   ranges.sort((a, b) => a.start - b.start);

package/src/ingestion/sync.ts

@@ -40,6 +40,7 @@ import {
 import { createJsonlAdapter } from "../converters/adapters/jsonl/adapter";
 import { createTranscriptAdapter } from "../converters/adapters/transcript/adapter";
 import { getDefaultMimeDetector, type MimeDetector } from "../converters/mime";
+import { MARKDOWN_CONVERTER_ID } from "../converters/native/markdown";
 import {
   type ConversionPipeline,
   getDefaultPipeline,
@@ -84,7 +85,7 @@ import {
   type SourceContentReaderPort,
   type SourceReadFailure,
 } from "./source-availability";
-import { getExcludedRanges } from "./strip";
+import { type ExcludedRange, getExcludedRanges } from "./strip";
 import { extractTypedMetadata } from "./typed-metadata";
 import { collectionToWalkConfig, DEFAULT_CHUNK_PARAMS } from "./types";
 import { defaultWalker } from "./walker";
@@ -105,8 +106,10 @@ const MAX_CONCURRENCY = 16;
  * will be re-processed. Must stay >= TYPED_METADATA_INGEST_VERSION (tested).
  * 8: wiki links with a table-escaped alias (`[[Note\|Alias]]`) and Markdown
  * link text with square brackets parse the way Obsidian renders them.
+ * 9: links are extracted from Markdown sources only, and never from code
+ * spans or indented code blocks.
  */
-export const INGEST_VERSION = 8;
+export const INGEST_VERSION = 9;
 const EMPTY_CONTENT_TYPE_RULES_FINGERPRINT =
   fingerprintContentTypeMetadataRules([]);
 const NON_RETRYABLE_CONVERSION_ERROR_CODES = new Set([
@@ -901,14 +904,19 @@ export class SyncService {
         mime.ext,
         contentTypeRules
       );
+      // Code ranges come from a full Markdown parse: compute them once and
+      // share them with the change journal and link extraction.
+      const excludedRanges = getExcludedRanges(artifact.markdown);
       const previousStructure = await this.readPreviousStructure(
         store,
-        existing
+        existing,
+        { markdown: artifact.markdown, excludedRanges }
       );
       const nextStructure = extractDocumentStructure(
         artifact.markdown,
         entry.relPath,
-        extractedMetadata.dateFields
+        extractedMetadata.dateFields,
+        excludedRanges
       );
       const structureDelta = diffDocumentStructure(
         previousStructure,
@@ -1019,14 +1027,17 @@ export class SyncService {
           });
         }
 
-        // 14. Extract and store links (wiki and markdown links)
-        const excludedRanges = getExcludedRanges(artifact.markdown);
-        const lineOffsets = buildLineOffsets(artifact.markdown);
-        const parsedLinks = parseLinks(
-          artifact.markdown,
-          lineOffsets,
-          excludedRanges
-        );
+        // 14. Extract and store links (wiki and markdown links). Only
+        // Markdown sources carry links, as in Obsidian: link-shaped text in
+        // code, plain text or converted documents stays searchable prose.
+        const parsedLinks =
+          artifact.meta.converterId === MARKDOWN_CONVERTER_ID
+            ? parseLinks(
+                artifact.markdown,
+                buildLineOffsets(artifact.markdown),
+                excludedRanges
+              )
+            : [];
 
         const linkInputs: DocLinkInput[] = [];
         for (const link of parsedLinks) {
@@ -1183,7 +1194,8 @@ export class SyncService {
 
   private async readPreviousStructure(
     store: StorePort,
-    existing: DocumentRow | null
+    existing: DocumentRow | null,
+    current?: { markdown: string; excludedRanges: ExcludedRange[] }
   ): Promise<ReturnType<typeof extractDocumentStructure> | null | undefined> {
     if (!existing) return null;
     if (!existing.mirrorHash) return undefined;
@@ -1198,7 +1210,11 @@ export class SyncService {
     return extractDocumentStructure(
       content.value,
       existing.relPath,
-      existing.dateFields
+      existing.dateFields,
+      // Unchanged content (a re-ingest) reuses the current parse.
+      current !== undefined && content.value === current.markdown
+        ? current.excludedRanges
+        : getExcludedRanges(content.value)
     );
   }
 

package/browser-extension/artifacts/gno-browser-clipper-v2.8.1.zip.sha256

@@ -1 +0,0 @@
-3f23832d1ed8b19e24eef29d6ea888a8c84009e39c61981d0b665c95cd7d792e  gno-browser-clipper-v2.8.1.zip