@vmz/vmz 0.1.17 → 0.1.19

package/dist/document-enrich.js

@@ -1,16 +1,9 @@
-// @ts-nocheck
 /**
  * Document — enrich manifest with routes, anchors, nav; diagnose links.
  */
 import fs from 'node:fs';
 import path from 'node:path';
 import { DIAG } from './document-schema.js';
-/**
- * @param {string} routeBase e.g. /docs
- * @param {string} locale
- * @param {string} pageKey
- * @param {{ strategy?: string }} [routing]
- */
 export function pageRoute(routeBase, locale, pageKey, routing = {}) {
     const base = String(routeBase || '/').replace(/\/$/, '') || '';
     const key = pageKey === 'index' ? '' : pageKey.replace(/\\/g, '/');
@@ -22,12 +15,7 @@ export function pageRoute(routeBase, locale, pageKey, routing = {}) {
     const parts = [base.replace(/^\//, ''), locale, key].filter((p) => p !== '');
     return '/' + parts.join('/');
 }
-/**
- * Static file path relative to out dir (posix).
- * @param {string} routeBase
- * @param {string} locale
- * @param {string} pageKey
- */
+/** Static file path relative to out dir (posix). */
 export function pageHtmlRel(routeBase, locale, pageKey) {
     const base = String(routeBase || '/')
         .replace(/^\//, '')
@@ -35,18 +23,11 @@ export function pageHtmlRel(routeBase, locale, pageKey) {
     const file = pageKey === 'index' ? 'index.html' : `${pageKey.replace(/\\/g, '/')}.html`;
     return [base, locale, file].filter(Boolean).join('/');
 }
-/**
- * @param {import('./document-schema.js').DocumentManifest} manifest
- * @param {{ analyzeMarkdown: Function, projectRoot: string, designsCssHref?: string | null }} ctx
- */
 export function enrichDocumentContent(manifest, ctx) {
     const routeBase = manifest.mounts?.[0]?.routeBase || '/docs';
     const routing = ctx.routing || { strategy: 'prefix' };
-    /** @type {Map<string, { html: string, headings: any[], links: any[], title: string, route: string, anchors: string[] }>} */
     const byId = new Map();
-    /** @type {import('./document-schema.js').DocumentDiagnostic[]} */
     const diagnostics = [...(manifest.diagnostics || [])];
-    /** @type {Map<string, string>} */
     const routeOwners = new Map();
     for (const page of manifest.pages) {
         const abs = path.isAbsolute(page.sourcePath) ? page.sourcePath : path.join(manifest.root, page.sourcePath);
@@ -89,14 +70,13 @@ export function enrichDocumentContent(manifest, ctx) {
         byId.set(`${page.identity.locale}:${page.identity.pageKey}`, {
             html: analyzed.html,
             headings: analyzed.headings,
-            links: analyzed.links,
+            links: analyzed.links || [],
             title,
             route,
             anchors,
         });
     }
     // Nav per locale (directory order: pageKey sorted)
-    /** @type {Record<string, Array<{ pageKey: string, title: string, href: string }>>} */
     const navByLocale = {};
     for (const loc of manifest.locales) {
         const pages = manifest.pages
@@ -106,7 +86,7 @@ export function enrichDocumentContent(manifest, ctx) {
         navByLocale[loc] = pages.map((p) => ({
             pageKey: p.identity.pageKey,
             title: p.title || p.identity.pageKey,
-            href: p.route,
+            href: p.route || '',
         }));
     }
     // Link checks
@@ -142,7 +122,7 @@ export function enrichDocumentContent(manifest, ctx) {
                 continue;
             }
             const resolved = resolveDocHref(href, page.identity.pageKey, page.identity.locale, routeBase, pageKeySet);
-            if (!resolved.ok) {
+            if (resolved.ok === false) {
                 diagnostics.push({
                     code: DIAG.LINK_BROKEN,
                     severity: 'error',
@@ -166,13 +146,6 @@ export function enrichDocumentContent(manifest, ctx) {
     }
     return { byId, navByLocale, diagnostics, routeBase };
 }
-/**
- * @param {string} href
- * @param {string} fromPageKey
- * @param {string} locale
- * @param {string} routeBase
- * @param {Map<string, Set<string>>} pageKeySet
- */
 function resolveDocHref(href, fromPageKey, locale, routeBase, pageKeySet) {
     let pathPart = href;
     let anchor = null;
@@ -185,7 +158,6 @@ function resolveDocHref(href, fromPageKey, locale, routeBase, pageKeySet) {
     if (pathPart.startsWith('/')) {
         // Absolute site path under mount: /docs/zh-hans/guide/install
         const want = pathPart.replace(/\/$/, '') || '/';
-        const prefix = pageRoute(routeBase, locale, 'index').replace(/\/$/, '');
         // Accept full route or locale-relative
         for (const [loc, keys] of pageKeySet) {
             for (const pk of keys) {

package/dist/document-evidence.d.ts

@@ -1,49 +1,52 @@
-/**
- * @param {string} info
- * @returns {{ lang: string, run: string | null, source: string | null, playground: boolean }}
- */
-export declare function parseFenceInfo(info: any): {
+import { type DocumentDiagnostic, type DocumentEvidence, type DocumentManifest } from './document-schema.js';
+import type { AnalyzedMarkdown } from './document-enrich.js';
+export interface FenceInfoMeta {
     lang: string;
-    run: any;
-    source: any;
+    run: string | null;
+    source: string | null;
     playground: boolean;
+}
+export declare function parseFenceInfo(info: string | undefined | null): FenceInfoMeta;
+/** Symbol query (chunkId or name). */
+export declare function parseApiHref(href: string | undefined | null): string | null;
+export interface ProgramApiIndexRow {
+    chunkId: string;
+    name: string;
+    path: string;
+    capabilities: string[];
+    programPath: string;
+}
+export declare function loadProgramApiIndex(projectRoot: string): ProgramApiIndexRow[];
+/** Resolve API symbol against Program Graph index. */
+export declare function resolveApiSymbol(index: ProgramApiIndexRow[], query: string): {
+    status: 'ok' | 'missing' | 'ambiguous';
+    matches: ProgramApiIndexRow[];
 };
-/**
- * @param {string} href
- * @returns {string | null} symbol query (chunkId or name)
- */
-export declare function parseApiHref(href: any): string;
-/**
- * @param {string} projectRoot
- * @returns {Array<{ chunkId: string, name: string, path: string, capabilities: string[], programPath: string }>}
- */
-export declare function loadProgramApiIndex(projectRoot: any): any[];
-/**
- * Resolve API symbol against Program Graph index.
- * @param {ReturnType<typeof loadProgramApiIndex>} index
- * @param {string} query
- */
-export declare function resolveApiSymbol(index: any, query: any): {
-    status: string;
-    matches: any;
-};
-/**
- * @param {import('./document-schema.js').DocumentManifest} manifest
- * @param {{
- * analyzeMarkdown: Function,
- * projectRoot: string,
- * createWorkspace?: Function,
- * ensureProgramGraph?: boolean,
- * }} ctx
- */
-export declare function enrichDocumentEvidence(manifest: any, ctx: any): Promise<{
-    diagnostics: any[];
-    evidence: {
-        schema: string;
-        fences: any[];
-        apiRefs: any[];
-        testSelections: any[];
-        status: string;
+export interface EnrichDocumentEvidenceCtx {
+    analyzeMarkdown: (source: string) => AnalyzedMarkdown;
+    projectRoot: string;
+    createWorkspace?: (opts: {
+        root: string;
+        outDir: string;
+    }) => {
+        check: (strict?: boolean) => {
+            diagnostics?: Array<{
+                severity?: string;
+                message?: string;
+            }>;
+        };
+        build: (strict?: boolean) => {
+            diagnostics?: Array<{
+                severity?: string;
+                message?: string;
+            }>;
+        };
+        dispose?: () => void;
     };
+    ensureProgramGraph?: boolean;
+}
+export declare function enrichDocumentEvidence(manifest: DocumentManifest, ctx: EnrichDocumentEvidenceCtx): Promise<{
+    diagnostics: DocumentDiagnostic[];
+    evidence: DocumentEvidence;
 }>;
 /** Lazy note: callers pass `createWorkspace` from `./index.js` (see document-cmd / document-build). */

package/dist/document-evidence.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Document Evidence — fence check + API refs from Program Graph.
  *
@@ -8,21 +7,15 @@ import { createRequire } from 'node:module';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { DIAG, DOCUMENT_EVIDENCE_SCHEMA } from './document-schema.js';
+import { DIAG, DOCUMENT_EVIDENCE_SCHEMA, } from './document-schema.js';
 const require = createRequire(import.meta.url);
-/**
- * @param {string} info
- * @returns {{ lang: string, run: string | null, source: string | null, playground: boolean }}
- */
 export function parseFenceInfo(info) {
     const parts = String(info || '')
         .trim()
         .split(/\s+/)
         .filter(Boolean);
     const lang = (parts[0] || '').toLowerCase();
-    /** @type {string | null} */
     let run = null;
-    /** @type {string | null} */
     let source = null;
     let playground = false;
     for (const p of parts.slice(1)) {
@@ -37,10 +30,7 @@ export function parseFenceInfo(info) {
     }
     return { lang, run, source, playground };
 }
-/**
- * @param {string} href
- * @returns {string | null} symbol query (chunkId or name)
- */
+/** Symbol query (chunkId or name). */
 export function parseApiHref(href) {
     const h = String(href || '').trim();
     if (h.startsWith('vmz-api:'))
@@ -49,13 +39,8 @@ export function parseApiHref(href) {
         return h.slice('api:'.length).replace(/^\/+/, '');
     return null;
 }
-/**
- * @param {string} projectRoot
- * @returns {Array<{ chunkId: string, name: string, path: string, capabilities: string[], programPath: string }>}
- */
 export function loadProgramApiIndex(projectRoot) {
     const outDir = path.join(projectRoot, 'dist');
-    /** @type {Array<{ chunkId: string, name: string, path: string, capabilities: string[], programPath: string }>} */
     const rows = [];
     if (!fs.existsSync(outDir))
         return rows;
@@ -92,11 +77,7 @@ export function loadProgramApiIndex(projectRoot) {
     });
     return rows;
 }
-/**
- * Resolve API symbol against Program Graph index.
- * @param {ReturnType<typeof loadProgramApiIndex>} index
- * @param {string} query
- */
+/** Resolve API symbol against Program Graph index. */
 export function resolveApiSymbol(index, query) {
     const q = String(query || '').trim();
     if (!q)
@@ -113,27 +94,13 @@ export function resolveApiSymbol(index, query) {
         return { status: 'ambiguous', matches: loose };
     return { status: 'missing', matches: [] };
 }
-/**
- * @param {import('./document-schema.js').DocumentManifest} manifest
- * @param {{
- * analyzeMarkdown: Function,
- * projectRoot: string,
- * createWorkspace?: Function,
- * ensureProgramGraph?: boolean,
- * }} ctx
- */
 export async function enrichDocumentEvidence(manifest, ctx) {
     const projectRoot = path.resolve(ctx.projectRoot || manifest.root);
-    /** @type {import('./document-schema.js').DocumentDiagnostic[]} */
     const diagnostics = [...(manifest.diagnostics || [])];
-    /** @type {any[]} */
     const fenceRecords = [];
-    /** @type {any[]} */
     const apiRefs = [];
-    /** @type {any[]} */
     const testSelections = [];
     // Collect fences + api links from pages.
-    /** @type {Array<{ page: any, fences: any[], apiQueries: string[], sourcePath: string }>} */
     const pages = [];
     for (const page of manifest.pages) {
         const abs = path.isAbsolute(page.sourcePath) ? page.sourcePath : path.join(manifest.root, page.sourcePath);
@@ -157,7 +124,7 @@ export async function enrichDocumentEvidence(manifest, ctx) {
             diagnostics.push({
                 code: DIAG.FENCE_CHECK,
                 severity: 'error',
-                message: `project build for evidence failed: ${e.message || e}`,
+                message: `project build for evidence failed: ${e instanceof Error ? e.message : String(e)}`,
                 path: projectRoot,
             });
         }
@@ -268,11 +235,7 @@ export async function enrichDocumentEvidence(manifest, ctx) {
     };
     return { diagnostics, evidence };
 }
-/**
- * @param {{ projectRoot: string, fence: any, meta: any, createWorkspace?: Function, sourcePath: string }} opts
- */
 async function checkVmzFence(opts) {
-    /** @type {import('./document-schema.js').DocumentDiagnostic[]} */
     const diagnostics = [];
     const { fence, meta, projectRoot, sourcePath } = opts;
     let body = fence.content;
@@ -326,7 +289,6 @@ async function checkVmzFence(opts) {
             ws.dispose?.();
             return { record: { status: 'failed', detail: 'check' }, diagnostics, testSelection: null };
         }
-        /** @type {any} */
         let testSelection = null;
         if (meta.run) {
             const mode = meta.run === 'logic' || meta.run === 'browser' ? meta.run : 'compile';
@@ -385,11 +347,8 @@ function wrapVmzFragment(body) {
 function pageKeySafe(p) {
     return String(p || 'page').replace(/[^\w.-]+/g, '_');
 }
-/**
- * TS/JS fence: oxc-aligned surface via TypeScript parse (syntax only; no execute).
- */
-function checkScriptFence({ fence, meta, sourcePath, page }) {
-    /** @type {import('./document-schema.js').DocumentDiagnostic[]} */
+/** TS/JS fence: oxc-aligned surface via TypeScript parse (syntax only; no execute). */
+function checkScriptFence({ fence, meta, sourcePath, }) {
     const diagnostics = [];
     try {
         const ts = require('typescript');

package/dist/document-integrate.d.ts

@@ -2,33 +2,17 @@
  * Integrated DocumentMount — build /documents into the host app dist so
  * routeBase (e.g. /d) is served as static HTML next to SSR pages.
  */
-/**
- * @param {string} projectRoot
- */
-export declare function projectHasDocuments(projectRoot: any): boolean;
-/**
- * Build integrated documents into the application outDir (URL-aligned).
- * @param {{ projectRoot: string, outDir: string, strict?: boolean }} opts
- * @returns {Promise<{ ok: boolean, skipped?: boolean, pages?: number, error?: string }>}
- */
-export declare function buildIntegratedDocuments(opts: any): Promise<{
-    ok: boolean;
-    skipped: boolean;
-    error?: undefined;
-    pages?: undefined;
-} | {
-    ok: boolean;
-    error: string;
-    pages: number;
-    skipped?: undefined;
-} | {
-    ok: boolean;
-    pages: number;
-    skipped?: undefined;
-    error?: undefined;
-} | {
+export declare function projectHasDocuments(projectRoot: string): boolean;
+export interface BuildIntegratedDocumentsOpts {
+    projectRoot: string;
+    outDir: string;
+    strict?: boolean;
+}
+export interface BuildIntegratedDocumentsResult {
     ok: boolean;
-    error: string;
-    skipped?: undefined;
-    pages?: undefined;
-}>;
+    skipped?: boolean;
+    pages?: number;
+    error?: string;
+}
+/** Build integrated documents into the application outDir (URL-aligned). */
+export declare function buildIntegratedDocuments(opts: BuildIntegratedDocumentsOpts): Promise<BuildIntegratedDocumentsResult>;

package/dist/document-integrate.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Integrated DocumentMount — build /documents into the host app dist so
  * routeBase (e.g. /d) is served as static HTML next to SSR pages.
@@ -7,22 +6,15 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { buildDocuments } from './document-build.js';
 import { resolveDocumentsRoot } from './document-check.js';
-import { loadLocalesRouting } from './document-routing-config.js';
 import { pageHtmlRel } from './document-enrich.js';
+import { loadLocalesRouting } from './document-routing-config.js';
 import { log } from './log.js';
 import { requireNativeAddon } from './native-addon.js';
-/**
- * @param {string} projectRoot
- */
 export function projectHasDocuments(projectRoot) {
     const root = resolveDocumentsRoot(projectRoot);
     return fs.existsSync(root) && fs.statSync(root).isDirectory();
 }
-/**
- * Build integrated documents into the application outDir (URL-aligned).
- * @param {{ projectRoot: string, outDir: string, strict?: boolean }} opts
- * @returns {Promise<{ ok: boolean, skipped?: boolean, pages?: number, error?: string }>}
- */
+/** Build integrated documents into the application outDir (URL-aligned). */
 export async function buildIntegratedDocuments(opts) {
     const projectRoot = path.resolve(opts.projectRoot);
     const outDir = path.resolve(opts.outDir);
@@ -57,9 +49,6 @@ export async function buildIntegratedDocuments(opts) {
  * Emit `{routeBase}/index.html` for integrated mounts.
  * `routing.strategy: none` → copy default-locale docs index (LocaleId is Host state).
  * prefix strategy → redirect HTML to `{routeBase}/{defaultLocale}/`.
- * @param {import('./document-schema.js').DocumentManifest} manifest
- * @param {string} outDir
- * @param {string} projectRoot
  */
 function writeMountRootRedirects(manifest, outDir, projectRoot) {
     const defaultLocale = manifest.defaultLocale || manifest.locales?.[0];

package/dist/document-interactive.d.ts

@@ -1,69 +1,47 @@
-/**
- * Strip tags / collapse whitespace for search body text.
- * @param {string} html
- */
-export declare function htmlToSearchText(html: any): string;
-/**
- * @param {{
- * manifest: any,
- * enriched: { byId: Map<string, any> },
- * evidence: any,
- * version?: string | null,
- * }} opts
- */
-export declare function buildDocumentSearch(opts: any): {
-    schema: string;
-    status: string;
-    version: any;
-    records: any[];
-};
-/**
- * Island-only resume plan for document surfaces.
- * @param {{
- * evidence: any,
- * searchHref?: string,
- * fenceBodies?: Map<string, string>,
- * }} opts
- */
-export declare function buildDocumentIslands(opts: any): {
-    schema: string;
-    hydrate: string;
-    fullPageHydrate: boolean;
-    islands: {
-        name: string;
-        kind: string;
-        resume: string;
-        index: any;
-    }[];
-    status: string;
-};
-/**
- * Relative href from an HTML page to a root artifact (posix).
- * @param {string} htmlRel
- * @param {string} artifactName
- */
-export declare function artifactHrefFromHtml(htmlRel: any, artifactName: any): string;
-/**
- * Stable map key for fence body lookup.
- * @param {{ locale: string, pageKey: string, lineStart: number }} f
- */
-export declare function fenceBodyKey(f: any): string;
-/**
- * Collect fence bodies from analyzeMarkdown results for playground islands.
- * @param {Map<string, { fences?: any[] }>} analyzedByPageId locale:pageKey → analyze result
- * @param {any[]} pages manifest.pages
- */
-export declare function collectFenceBodies(analyzedByPageId: any, pages: any): Map<any, any>;
-/**
- * Render SSR island shells (no script — resume later).
- * @param {{
- * islands: any,
- * searchIndexHref: string,
- * pageKey: string,
- * locale: string,
- * }} opts
- */
-export declare function renderIslandShellsHtml(opts: any): {
+import type { EnrichDocumentContentResult } from './document-enrich.js';
+import { type DocumentEvidence, type DocumentIslandsPlan, type DocumentManifest, type DocumentSearchIndex, type PageRecord } from './document-schema.js';
+/** Strip tags / collapse whitespace for search body text. */
+export declare function htmlToSearchText(html: string): string;
+export interface BuildDocumentSearchOpts {
+    manifest: DocumentManifest;
+    enriched: Pick<EnrichDocumentContentResult, 'byId'>;
+    evidence: DocumentEvidence;
+    version?: string | null;
+}
+export declare function buildDocumentSearch(opts: BuildDocumentSearchOpts): DocumentSearchIndex;
+export interface BuildDocumentIslandsOpts {
+    evidence: DocumentEvidence;
+    searchHref?: string;
+    fenceBodies?: Map<string, string>;
+}
+/** Island-only resume plan for document surfaces. */
+export declare function buildDocumentIslands(opts: BuildDocumentIslandsOpts): DocumentIslandsPlan;
+/** Relative href from an HTML page to a root artifact (posix). */
+export declare function artifactHrefFromHtml(htmlRel: string, artifactName: string): string;
+/** Stable map key for fence body lookup. */
+export declare function fenceBodyKey(f: {
+    locale: string;
+    pageKey: string;
+    lineStart: number;
+}): string;
+export interface AnalyzedFence {
+    info?: string;
+    content?: string;
+    lineStart?: number;
+    lineEnd?: number;
+}
+/** Collect fence bodies from analyzeMarkdown results for playground islands. */
+export declare function collectFenceBodies(analyzedByPageId: Map<string, {
+    fences?: AnalyzedFence[];
+}>, pages: PageRecord[]): Map<string, string>;
+export interface RenderIslandShellsOpts {
+    islands: DocumentIslandsPlan;
+    searchIndexHref: string;
+    pageKey: string;
+    locale: string;
+}
+/** Render SSR island shells (no script — resume later). */
+export declare function renderIslandShellsHtml(opts: RenderIslandShellsOpts): {
     searchHtml: string;
-    playgroundHtml: any;
+    playgroundHtml: string;
 };

package/dist/document-interactive.js

@@ -1,16 +1,12 @@
-// @ts-nocheck
 /**
  * Document Interactive — search index + Island-only resume plan.
  *
  * Not a Doc IR: build artifacts + ResumeEntry-shaped island hosts.
  * Static HTML stays no-JS readable; islands resume later, never full-page hydrate.
  */
-import { DOCUMENT_ISLANDS_SCHEMA, DOCUMENT_SEARCH_SCHEMA } from './document-schema.js';
 import { parseFenceInfo } from './document-evidence.js';
-/**
- * Strip tags / collapse whitespace for search body text.
- * @param {string} html
- */
+import { DOCUMENT_ISLANDS_SCHEMA, DOCUMENT_SEARCH_SCHEMA, } from './document-schema.js';
+/** Strip tags / collapse whitespace for search body text. */
 export function htmlToSearchText(html) {
     return String(html || '')
         .replace(/<script[\s\S]*?<\/script>/gi, ' ')
@@ -24,18 +20,9 @@ export function htmlToSearchText(html) {
         .replace(/\s+/g, ' ')
         .trim();
 }
-/**
- * @param {{
- * manifest: any,
- * enriched: { byId: Map<string, any> },
- * evidence: any,
- * version?: string | null,
- * }} opts
- */
 export function buildDocumentSearch(opts) {
     const { manifest, enriched, evidence } = opts;
     const version = opts.version ?? null;
-    /** @type {any[]} */
     const records = [];
     for (const page of manifest.pages || []) {
         const id = `${page.identity.locale}:${page.identity.pageKey}`;
@@ -55,7 +42,7 @@ export function buildDocumentSearch(opts) {
         const apiSymbolIds = (evidence?.apiRefs || [])
             .filter((r) => r.locale === locale && r.pageKey === pageKey && r.status === 'ok')
             .flatMap((r) => (r.matches || []).map((m) => m.chunkId || m.name))
-            .filter(Boolean);
+            .filter((x) => Boolean(x));
         records.push({
             kind: 'page',
             id: `page:${locale}:${pageKey}`,
@@ -110,17 +97,9 @@ export function buildDocumentSearch(opts) {
         records,
     };
 }
-/**
- * Island-only resume plan for document surfaces.
- * @param {{
- * evidence: any,
- * searchHref?: string,
- * fenceBodies?: Map<string, string>,
- * }} opts
- */
+/** Island-only resume plan for document surfaces. */
 export function buildDocumentIslands(opts) {
     const searchHref = opts.searchHref || 'document.search.json';
-    /** @type {any[]} */
     const islands = [
         {
             name: 'DocumentSearch',
@@ -169,30 +148,18 @@ export function buildDocumentIslands(opts) {
         status: 'ready',
     };
 }
-/**
- * Relative href from an HTML page to a root artifact (posix).
- * @param {string} htmlRel
- * @param {string} artifactName
- */
+/** Relative href from an HTML page to a root artifact (posix). */
 export function artifactHrefFromHtml(htmlRel, artifactName) {
     const depth = String(htmlRel).replace(/\\/g, '/').split('/').length - 1;
     const prefix = depth > 0 ? '../'.repeat(depth) : './';
     return prefix + artifactName;
 }
-/**
- * Stable map key for fence body lookup.
- * @param {{ locale: string, pageKey: string, lineStart: number }} f
- */
+/** Stable map key for fence body lookup. */
 export function fenceBodyKey(f) {
     return `${f.locale}:${f.pageKey}:${f.lineStart}`;
 }
-/**
- * Collect fence bodies from analyzeMarkdown results for playground islands.
- * @param {Map<string, { fences?: any[] }>} analyzedByPageId locale:pageKey → analyze result
- * @param {any[]} pages manifest.pages
- */
+/** Collect fence bodies from analyzeMarkdown results for playground islands. */
 export function collectFenceBodies(analyzedByPageId, pages) {
-    /** @type {Map<string, string>} */
     const out = new Map();
     for (const page of pages || []) {
         const id = `${page.identity.locale}:${page.identity.pageKey}`;
@@ -206,21 +173,13 @@ export function collectFenceBodies(analyzedByPageId, pages) {
             out.set(fenceBodyKey({
                 locale: page.identity.locale,
                 pageKey: page.identity.pageKey,
-                lineStart: fence.lineStart,
+                lineStart: fence.lineStart ?? 0,
             }), String(fence.content || '').trim());
         }
     }
     return out;
 }
-/**
- * Render SSR island shells (no script — resume later).
- * @param {{
- * islands: any,
- * searchIndexHref: string,
- * pageKey: string,
- * locale: string,
- * }} opts
- */
+/** Render SSR island shells (no script — resume later). */
 export function renderIslandShellsHtml(opts) {
     const esc = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
     const search = `