@puredesktop/puredesktop-ui-bridge 2.1.6 → 2.1.8

package/src/context/contextConfig.ts

@@ -0,0 +1,72 @@
+/**
+ * Declarative context configuration — the `app.context` block in plugin.json.
+ *
+ * Each app declares how its package objects map to a context document; the
+ * generic builder (`buildContextDocument`) interprets this config. The shell
+ * stays free of app-specific logic the same way catalog routing does with
+ * `openable*` and `createEntities` metadata.
+ */
+
+export interface PlatformContextContentSource {
+  /** Literal content file path relative to the package root. */
+  file?: string
+  /** Optional heading for a literal file's section (defaults to file name). */
+  section?: string
+  /**
+   * Read an ordered list of content entries from a manifest key instead of a
+   * literal path (e.g. book chapters). The key addresses an array of records.
+   */
+  fromManifestList?: string
+  /** Record key holding each entry's file path (default: 'file'). */
+  pathKey?: string
+  /** Record key holding each entry's section title (default: 'title'). */
+  titleKey?: string
+  /** Directory the list entries' paths are relative to, e.g. 'chapters'. */
+  baseDir?: string
+}
+
+export interface PlatformAppContextManifest {
+  /** Object kind — also the context file suffix: `<name>.<kind>.md`. */
+  kind: string
+  /** Package folder suffix this config applies to, e.g. '.manuscript'. */
+  packageSuffix: string
+  /** Manifest file inside the package (json or yaml by extension). */
+  manifestFile: string
+  /** Ordered content sources composing the body. */
+  content: PlatformContextContentSource[]
+  /** Assets directory relative to the package root, e.g. 'assets'. */
+  assetsDir?: string
+  /** Dot path to the object title inside the manifest (default: 'title'). */
+  titlePath?: string
+  /** Dot path to a stable object id (default: package folder base name). */
+  idPath?: string
+}
+
+/** Read a dot-path string value from a parsed manifest. */
+export function manifestStringAt(
+  manifest: unknown,
+  path: string | undefined,
+): string | undefined {
+  if (!path) return undefined
+  let current: unknown = manifest
+  for (const key of path.split('.')) {
+    if (typeof current !== 'object' || current === null) return undefined
+    current = (current as Record<string, unknown>)[key]
+  }
+  return typeof current === 'string' && current.length > 0
+    ? current
+    : undefined
+}
+
+const IMAGE_EXTENSIONS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp', 'avif', 'bmp', 'tiff'])
+
+/** Guess a context link kind from a file extension. */
+export function contextLinkKindForFile(fileName: string): string {
+  const extension = fileName.split('.').pop()?.toLowerCase() ?? ''
+  if (IMAGE_EXTENSIONS.has(extension)) return 'image'
+  if (extension === 'svg') return 'vector'
+  if (extension === 'mmd' || extension === 'mermaid') return 'mermaid'
+  if (extension === 'tex') return 'math'
+  if (extension === 'csv' || extension === 'tsv' || extension === 'json') return 'data'
+  return 'binary'
+}

package/src/context/contextDocument.test.ts

@@ -0,0 +1,155 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  PLATFORM_CONTEXT_SCHEMA_VERSION,
+  PlatformContextParseError,
+  contextFileName,
+  isContextFileName,
+  parseContextDocument,
+  serializeContextDocument,
+  type PlatformContextDocument,
+} from './contextDocument.js'
+
+function sampleDocument(): PlatformContextDocument {
+  return {
+    envelope: {
+      schemaVersion: PLATFORM_CONTEXT_SCHEMA_VERSION,
+      kind: 'manuscript',
+      appSlug: 'puremanuscript',
+      objectId: 'ms-001',
+      title: 'Effects of X on Y',
+      source: {
+        path: '/Users/example/MyPaper.manuscript',
+        manifestFile: 'manuscript.json',
+        contentFiles: ['manuscript.html'],
+      },
+      sourceHash: 'sha256:abc123',
+      generatedAt: '2026-07-02T10:00:00.000Z',
+      generator: 'on-access',
+      links: [
+        { relativePath: 'assets/fig-01.png', kind: 'image', label: 'Figure 1' },
+        { relativePath: 'references.json' },
+      ],
+      sections: [
+        { id: 'abstract', title: 'Abstract', level: 2, startLine: 2, endLine: 6 },
+        { id: 'body', title: 'Body', level: 2, startLine: 6, endLine: 40 },
+      ],
+    },
+    body: '# Effects of X on Y\n\n## Abstract\n\nText.\n',
+  }
+}
+
+describe('serializeContextDocument', () => {
+  it('is deterministic', () => {
+    const document = sampleDocument()
+    expect(serializeContextDocument(document)).toBe(
+      serializeContextDocument(document),
+    )
+  })
+
+  it('emits front matter followed by the body', () => {
+    const raw = serializeContextDocument(sampleDocument())
+    expect(raw.startsWith('---\n')).toBe(true)
+    expect(raw).toContain('\n---\n\n# Effects of X on Y')
+    expect(raw.endsWith('\n')).toBe(true)
+  })
+
+  it('omits empty optional fields', () => {
+    const document = sampleDocument()
+    delete document.envelope.sourceHash
+    document.envelope.links = []
+    const raw = serializeContextDocument(document)
+    expect(raw).not.toContain('sourceHash')
+  })
+})
+
+describe('parseContextDocument', () => {
+  it('round-trips the envelope and body', () => {
+    const document = sampleDocument()
+    const parsed = parseContextDocument(serializeContextDocument(document))
+    expect(parsed.envelope).toEqual(document.envelope)
+    expect(parsed.body).toBe('# Effects of X on Y\n\n## Abstract\n\nText.\n')
+  })
+
+  it('rejects documents without front matter', () => {
+    expect(() => parseContextDocument('# Just markdown\n')).toThrow(
+      PlatformContextParseError,
+    )
+  })
+
+  it('rejects unterminated front matter', () => {
+    expect(() => parseContextDocument('---\nkind: manuscript\n')).toThrow(
+      /not closed/,
+    )
+  })
+
+  it('rejects unsupported schema versions', () => {
+    const raw = serializeContextDocument(sampleDocument()).replace(
+      'schemaVersion: 1',
+      'schemaVersion: 99',
+    )
+    expect(() => parseContextDocument(raw)).toThrow(/schemaVersion/)
+  })
+
+  it('rejects missing required strings', () => {
+    const raw = serializeContextDocument(sampleDocument()).replace(
+      'appSlug: puremanuscript\n',
+      '',
+    )
+    expect(() => parseContextDocument(raw)).toThrow(/appSlug/)
+  })
+
+  it('rejects unknown generators', () => {
+    const raw = serializeContextDocument(sampleDocument()).replace(
+      'generator: on-access',
+      'generator: llm-magic',
+    )
+    expect(() => parseContextDocument(raw)).toThrow(/generator/)
+  })
+
+  it('rejects links without relativePath', () => {
+    const raw = serializeContextDocument(sampleDocument()).replace(
+      'relativePath: assets/fig-01.png',
+      'wrongKey: assets/fig-01.png',
+    )
+    expect(() => parseContextDocument(raw)).toThrow(/links\[0\]/)
+  })
+
+  it('defaults links and sections to empty lists', () => {
+    const raw = [
+      '---',
+      'schemaVersion: 1',
+      'kind: manuscript',
+      'appSlug: puremanuscript',
+      'objectId: ms-001',
+      'title: T',
+      'source:',
+      '  path: /tmp/x.manuscript',
+      'generatedAt: 2026-07-02T10:00:00.000Z',
+      'generator: on-access',
+      '---',
+      '',
+      'Body.',
+      '',
+    ].join('\n')
+    const parsed = parseContextDocument(raw)
+    expect(parsed.envelope.links).toEqual([])
+    expect(parsed.envelope.sections).toEqual([])
+  })
+})
+
+describe('context file naming', () => {
+  it('builds <name>.<kind>.md', () => {
+    expect(contextFileName('MyPaper', 'manuscript')).toBe(
+      'MyPaper.manuscript.md',
+    )
+  })
+
+  it('matches context file names', () => {
+    expect(isContextFileName('MyPaper.manuscript.md')).toBe(true)
+    expect(isContextFileName('MyPaper.manuscript.md', 'manuscript')).toBe(true)
+    expect(isContextFileName('MyPaper.manuscript.md', 'book')).toBe(false)
+    expect(isContextFileName('notes.md')).toBe(false)
+    expect(isContextFileName('manuscript.html')).toBe(false)
+  })
+})

package/src/context/contextDocument.ts

@@ -0,0 +1,300 @@
+/**
+ * Platform context document — the agent-facing markdown representation of one
+ * app object (`<name>.<kind>.md`, e.g. `MyPaper.manuscript.md`).
+ *
+ * The envelope (YAML front-matter) is platform-owned and fixed here; the
+ * markdown body is app-owned. See CONTEXT_FILES_PLAN.md.
+ */
+
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml'
+
+export const PLATFORM_CONTEXT_SCHEMA_VERSION = 1
+
+/** Marker for how the current file contents were produced. */
+export type PlatformContextGenerator = 'on-access' | 'app-save' | 'enrichment'
+
+/**
+ * Durable reference to an asset or binary belonging to the object.
+ * `relativePath` is relative to the object package root (`source.path`) —
+ * the same `(collectionPath, relativePath)` tuple the assets bridge uses.
+ * Never store ephemeral preview URLs here; they expire.
+ */
+export interface PlatformContextLink {
+  relativePath: string
+  /** Asset kind hint, e.g. 'image' | 'mermaid' | 'table' | 'math' | 'binary'. */
+  kind?: string
+  label?: string
+}
+
+/**
+ * One addressable section of the body. `id` is the durable key for segmented
+ * reads; line ranges are advisory and recomputed on every regeneration.
+ */
+export interface PlatformContextSection {
+  id: string
+  title: string
+  /** Heading level, 1–6. */
+  level: number
+  /** First body line of the section (0-based, inclusive), i.e. the heading line. */
+  startLine: number
+  /** End body line (0-based, exclusive). */
+  endLine: number
+}
+
+/** Where the object lives on disk and which files the body was derived from. */
+export interface PlatformContextSource {
+  /** Absolute path of the package folder (the assets collectionPath). */
+  path: string
+  manifestFile?: string
+  contentFiles?: string[]
+}
+
+export interface PlatformContextEnvelope {
+  schemaVersion: number
+  /** App-declared object kind, e.g. 'manuscript' | 'book' | 'document'. */
+  kind: string
+  appSlug: string
+  /** Stable object id (manifest id or store record id). */
+  objectId: string
+  title: string
+  source: PlatformContextSource
+  /** Hash of manifest + content files; drives staleness. */
+  sourceHash?: string
+  /**
+   * Cheap mtime+size fingerprint of the same file set — staleness checks
+   * short-circuit on this before re-hashing content (large packages).
+   */
+  sourceFingerprint?: string
+  /** ISO 8601 timestamp of generation. */
+  generatedAt: string
+  generator: PlatformContextGenerator
+  links: PlatformContextLink[]
+  sections: PlatformContextSection[]
+}
+
+export interface PlatformContextDocument {
+  envelope: PlatformContextEnvelope
+  /** Markdown body — app-owned schema. */
+  body: string
+}
+
+export class PlatformContextParseError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'PlatformContextParseError'
+  }
+}
+
+const FRONT_MATTER_OPEN = '---\n'
+const FRONT_MATTER_CLOSE = '\n---\n'
+
+const CONTEXT_GENERATORS: readonly PlatformContextGenerator[] = [
+  'on-access',
+  'app-save',
+  'enrichment',
+]
+
+/** Canonical context file name for an object: `<baseName>.<kind>.md`. */
+export function contextFileName(baseName: string, kind: string): string {
+  return `${baseName}.${kind}.md`
+}
+
+/** True when a file name matches the `<name>.<kind>.md` context convention. */
+export function isContextFileName(fileName: string, kind?: string): boolean {
+  if (kind) return fileName.endsWith(`.${kind}.md`)
+  const parts = fileName.split('.')
+  return parts.length >= 3 && parts[parts.length - 1] === 'md'
+}
+
+/**
+ * Serialize an envelope + body into the on-disk markdown document.
+ * Envelope keys are emitted in a fixed order so output is deterministic.
+ */
+export function serializeContextDocument(
+  document: PlatformContextDocument,
+): string {
+  const { envelope, body } = document
+  const ordered: Record<string, unknown> = {
+    schemaVersion: envelope.schemaVersion,
+    kind: envelope.kind,
+    appSlug: envelope.appSlug,
+    objectId: envelope.objectId,
+    title: envelope.title,
+    source: {
+      path: envelope.source.path,
+      ...(envelope.source.manifestFile
+        ? { manifestFile: envelope.source.manifestFile }
+        : {}),
+      ...(envelope.source.contentFiles?.length
+        ? { contentFiles: envelope.source.contentFiles }
+        : {}),
+    },
+    ...(envelope.sourceHash ? { sourceHash: envelope.sourceHash } : {}),
+    ...(envelope.sourceFingerprint
+      ? { sourceFingerprint: envelope.sourceFingerprint }
+      : {}),
+    generatedAt: envelope.generatedAt,
+    generator: envelope.generator,
+    links: envelope.links.map(link => ({
+      relativePath: link.relativePath,
+      ...(link.kind ? { kind: link.kind } : {}),
+      ...(link.label ? { label: link.label } : {}),
+    })),
+    sections: envelope.sections.map(section => ({
+      id: section.id,
+      title: section.title,
+      level: section.level,
+      startLine: section.startLine,
+      endLine: section.endLine,
+    })),
+  }
+  const frontMatter = stringifyYaml(ordered).trimEnd()
+  const trimmedBody = body.replace(/\s+$/, '')
+  return `---\n${frontMatter}\n---\n\n${trimmedBody}\n`
+}
+
+/** Parse an on-disk context document. Throws PlatformContextParseError. */
+export function parseContextDocument(raw: string): PlatformContextDocument {
+  if (!raw.startsWith(FRONT_MATTER_OPEN)) {
+    throw new PlatformContextParseError(
+      'Context document must start with YAML front matter (---)',
+    )
+  }
+  const closeIndex = raw.indexOf(FRONT_MATTER_CLOSE, FRONT_MATTER_OPEN.length)
+  if (closeIndex < 0) {
+    throw new PlatformContextParseError(
+      'Context document front matter is not closed (missing ---)',
+    )
+  }
+  const frontMatter = raw.slice(FRONT_MATTER_OPEN.length, closeIndex)
+  const body = raw
+    .slice(closeIndex + FRONT_MATTER_CLOSE.length)
+    .replace(/^\n+/, '')
+  let parsed: unknown
+  try {
+    parsed = parseYaml(frontMatter)
+  } catch (error) {
+    throw new PlatformContextParseError(
+      `Invalid YAML front matter: ${error instanceof Error ? error.message : String(error)}`,
+    )
+  }
+  return { envelope: readContextEnvelope(parsed), body }
+}
+
+/** Validate an unknown value as a context envelope. */
+export function readContextEnvelope(value: unknown): PlatformContextEnvelope {
+  if (!isRecord(value)) {
+    throw new PlatformContextParseError('Front matter must be a YAML mapping')
+  }
+  const schemaVersion = value.schemaVersion
+  if (schemaVersion !== PLATFORM_CONTEXT_SCHEMA_VERSION) {
+    throw new PlatformContextParseError(
+      `Unsupported context schemaVersion: ${String(schemaVersion)}`,
+    )
+  }
+  const source = value.source
+  if (!isRecord(source)) {
+    throw new PlatformContextParseError('Envelope source must be a mapping')
+  }
+  const generator = requireString(value, 'generator')
+  if (!CONTEXT_GENERATORS.includes(generator as PlatformContextGenerator)) {
+    throw new PlatformContextParseError(
+      `Unknown context generator: ${generator}`,
+    )
+  }
+  return {
+    schemaVersion: PLATFORM_CONTEXT_SCHEMA_VERSION,
+    kind: requireString(value, 'kind'),
+    appSlug: requireString(value, 'appSlug'),
+    objectId: requireString(value, 'objectId'),
+    title: requireString(value, 'title'),
+    source: {
+      path: requireString(source, 'source.path', source.path),
+      ...(typeof source.manifestFile === 'string'
+        ? { manifestFile: source.manifestFile }
+        : {}),
+      ...(isStringArray(source.contentFiles)
+        ? { contentFiles: source.contentFiles }
+        : {}),
+    },
+    ...(typeof value.sourceHash === 'string'
+      ? { sourceHash: value.sourceHash }
+      : {}),
+    ...(typeof value.sourceFingerprint === 'string'
+      ? { sourceFingerprint: value.sourceFingerprint }
+      : {}),
+    generatedAt: requireString(value, 'generatedAt'),
+    generator: generator as PlatformContextGenerator,
+    links: readLinks(value.links),
+    sections: readSections(value.sections),
+  }
+}
+
+function readLinks(value: unknown): PlatformContextLink[] {
+  if (value == null) return []
+  if (!Array.isArray(value)) {
+    throw new PlatformContextParseError('Envelope links must be a list')
+  }
+  return value.map((entry, index) => {
+    if (!isRecord(entry) || typeof entry.relativePath !== 'string') {
+      throw new PlatformContextParseError(
+        `Envelope links[${index}] must have a relativePath`,
+      )
+    }
+    return {
+      relativePath: entry.relativePath,
+      ...(typeof entry.kind === 'string' ? { kind: entry.kind } : {}),
+      ...(typeof entry.label === 'string' ? { label: entry.label } : {}),
+    }
+  })
+}
+
+function readSections(value: unknown): PlatformContextSection[] {
+  if (value == null) return []
+  if (!Array.isArray(value)) {
+    throw new PlatformContextParseError('Envelope sections must be a list')
+  }
+  return value.map((entry, index) => {
+    if (
+      !isRecord(entry) ||
+      typeof entry.id !== 'string' ||
+      typeof entry.title !== 'string' ||
+      typeof entry.level !== 'number' ||
+      typeof entry.startLine !== 'number' ||
+      typeof entry.endLine !== 'number'
+    ) {
+      throw new PlatformContextParseError(
+        `Envelope sections[${index}] must have id, title, level, startLine, endLine`,
+      )
+    }
+    return {
+      id: entry.id,
+      title: entry.title,
+      level: entry.level,
+      startLine: entry.startLine,
+      endLine: entry.endLine,
+    }
+  })
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function isStringArray(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every(item => typeof item === 'string')
+}
+
+function requireString(
+  record: Record<string, unknown>,
+  key: string,
+  raw?: unknown,
+): string {
+  const value = raw === undefined ? record[key] : raw
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new PlatformContextParseError(
+      `Envelope ${key} must be a non-empty string`,
+    )
+  }
+  return value
+}

package/src/context/contextSections.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  buildContextSections,
+  contextSectionId,
+  sliceContextSection,
+} from './contextSections.js'
+
+const BODY = [
+  '# Effects of X on Y', // 0
+  '', // 1
+  '## Abstract', // 2
+  '', // 3
+  'Short abstract.', // 4
+  '', // 5
+  '## Body', // 6
+  '', // 7
+  '### Methods', // 8
+  '', // 9
+  'Methods text.', // 10
+  '', // 11
+  '## References', // 12
+  '', // 13
+  '1. Someone (2020)', // 14
+].join('\n')
+
+describe('contextSectionId', () => {
+  it('slugifies titles', () => {
+    expect(contextSectionId('Abstract')).toBe('abstract')
+    expect(contextSectionId('Chapter 2: The Method!')).toBe(
+      'chapter-2-the-method',
+    )
+    expect(contextSectionId('  --  ')).toBe('section')
+  })
+})
+
+describe('buildContextSections', () => {
+  it('indexes headings with durable ids', () => {
+    const sections = buildContextSections(BODY)
+    expect(sections.map(section => section.id)).toEqual([
+      'effects-of-x-on-y',
+      'abstract',
+      'body',
+      'methods',
+      'references',
+    ])
+  })
+
+  it('spans a section through its own subsections', () => {
+    const sections = buildContextSections(BODY)
+    const body = sections.find(section => section.id === 'body')
+    expect(body).toMatchObject({ level: 2, startLine: 6, endLine: 12 })
+    const top = sections.find(section => section.id === 'effects-of-x-on-y')
+    expect(top?.endLine).toBe(15)
+  })
+
+  it('ignores headings inside fenced code blocks', () => {
+    const body = ['## Real', '', '```md', '# Not a heading', '```', ''].join(
+      '\n',
+    )
+    const sections = buildContextSections(body)
+    expect(sections.map(section => section.title)).toEqual(['Real'])
+  })
+
+  it('dedupes duplicate heading ids in document order', () => {
+    const body = ['## Notes', '', '## Notes', ''].join('\n')
+    const sections = buildContextSections(body)
+    expect(sections.map(section => section.id)).toEqual(['notes', 'notes-2'])
+  })
+})
+
+describe('sliceContextSection', () => {
+  it('returns the markdown for one section id', () => {
+    expect(sliceContextSection(BODY, 'abstract')).toBe(
+      '## Abstract\n\nShort abstract.',
+    )
+  })
+
+  it('includes subsections in a parent slice', () => {
+    const slice = sliceContextSection(BODY, 'body')
+    expect(slice).toContain('### Methods')
+    expect(slice).not.toContain('## References')
+  })
+
+  it('returns null for unknown ids', () => {
+    expect(sliceContextSection(BODY, 'missing')).toBeNull()
+  })
+})

package/src/context/contextSections.ts

@@ -0,0 +1,84 @@
+/**
+ * Section index for context documents. Sections are addressed by durable `id`
+ * (slugified heading, deduped); line ranges are advisory and recomputed on
+ * every regeneration. Supports segmented reads (`context.read` section mode).
+ */
+
+import type { PlatformContextSection } from './contextDocument.js'
+
+const HEADING_PATTERN = /^(#{1,6})\s+(.+?)\s*#*\s*$/
+const FENCE_PATTERN = /^(```|~~~)/
+
+/** Slugify a heading title into a stable section id. */
+export function contextSectionId(title: string): string {
+  const slug = title
+    .toLowerCase()
+    .normalize('NFKD')
+    .replace(/[̀-ͯ]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+  return slug || 'section'
+}
+
+/**
+ * Build the section index for a markdown body. A section spans from its
+ * heading line to the next heading of the same or shallower level (so a
+ * chapter includes its own subsections). Headings inside fenced code blocks
+ * are ignored. Duplicate ids get `-2`, `-3`, … suffixes in document order.
+ */
+export function buildContextSections(body: string): PlatformContextSection[] {
+  const lines = body.split('\n')
+  const headings: { line: number; level: number; title: string }[] = []
+  let fence: string | null = null
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]
+    const fenceMatch = FENCE_PATTERN.exec(line.trimStart())
+    if (fenceMatch) {
+      if (fence === null) fence = fenceMatch[1]
+      else if (line.trimStart().startsWith(fence)) fence = null
+      continue
+    }
+    if (fence !== null) continue
+    const match = HEADING_PATTERN.exec(line)
+    if (!match) continue
+    headings.push({ line: index, level: match[1].length, title: match[2] })
+  }
+
+  const usedIds = new Map<string, number>()
+  return headings.map((heading, headingIndex) => {
+    let endLine = lines.length
+    for (let next = headingIndex + 1; next < headings.length; next += 1) {
+      if (headings[next].level <= heading.level) {
+        endLine = headings[next].line
+        break
+      }
+    }
+    const base = contextSectionId(heading.title)
+    const seen = usedIds.get(base) ?? 0
+    usedIds.set(base, seen + 1)
+    return {
+      id: seen === 0 ? base : `${base}-${seen + 1}`,
+      title: heading.title,
+      level: heading.level,
+      startLine: heading.line,
+      endLine,
+    }
+  })
+}
+
+/**
+ * Extract one section's markdown from a body by durable section id.
+ * Recomputes the index from the body — stored ranges are advisory only.
+ * Returns null when the id does not exist.
+ */
+export function sliceContextSection(
+  body: string,
+  sectionId: string,
+): string | null {
+  const sections = buildContextSections(body)
+  const section = sections.find(entry => entry.id === sectionId)
+  if (!section) return null
+  const lines = body.split('\n')
+  return lines.slice(section.startLine, section.endLine).join('\n').trimEnd()
+}