feat(voyage): vendor markdown-it/highlight.js + playground render-pipeline + scripts/render-artifact.mjs CLI — v4.2 Step 8 [skip-docs]

Vendored libs (locked headless via scripts/vendor-playground-libs.mjs;
plan-critic B3 — never use highlightjs.org website builder):
  - playground/lib/markdown-it.min.js           — markdown-it@14.1.0 UMD bundle
  - playground/lib/markdown-it-front-matter.min.js — markdown-it-front-matter@0.2.4 IIFE-wrapped
  - playground/lib/highlight.min.js             — highlight.js@11.11.1 (5-lang bundle:
                                                   yaml/json/javascript/bash/markdown/diff)
  - playground/lib/VENDOR-MANIFEST.json         — pin record + audit trail

scripts/vendor-playground-libs.mjs implements the reproducible
CommonJS-to-IIFE wrapping. Re-vendoring requires only:
  node scripts/vendor-playground-libs.mjs

Render pipeline in playground/voyage-playground.html (~330 LoC total):
  - inline <script src=lib/...> for the three vendored bundles
  - markdown-it init with html: true (preserves voyage:anchor comments)
  - front-matter plugin with pre-render-then-wrap pattern (research/03)
  - paste-import-row textarea + Render/Sample/Clear buttons
  - voyage-viewport region with role + aria-live for A11Y
  - localStorage key pattern: voyage_ann_<project>__<slug> (risk-assessor H7)
  - inline sample plan (mirrors annotation-plan.md fixture)

scripts/render-artifact.mjs CLI (~200 LoC) — brief SC1 + SC11:
  - reads input.md, runs same vendored pipeline server-side
  - inlines DS CSS + (URL-stripped) highlight.js into output
  - zero http://https:// URLs in output (verified by test)
  - deterministic: two invocations -> byte-identical sha256
  - default output: <input>.html next to input

Test coverage:
  - tests/scripts/render-artifact.test.mjs — 5 cases (SC1/SC11)
  - tests/playground/voyage-playground.test.mjs — +5 cases (Step 8 extension)

Verify: node --test tests/playground/voyage-playground.test.mjs
       tests/scripts/render-artifact.test.mjs -> 18 pass / 0 fail.
Full npm test: 587 pass / 0 fail / 2 skipped (Docker).

Refs plan.md Step 8 + plan-critic B3 + scope-guardian B1.

plugins/voyage/playground/lib/VENDOR-MANIFEST.json

@@ -0,0 +1,21 @@
+{
+  "generated_at": "2026-05-09T13:16:03.483Z",
+  "pins": {
+    "markdown-it": "14.1.0",
+    "markdown-it-front-matter": "0.2.4",
+    "highlight.js": "11.11.1"
+  },
+  "highlight_languages": [
+    "yaml",
+    "json",
+    "javascript",
+    "bash",
+    "markdown",
+    "diff"
+  ],
+  "output_files": [
+    "markdown-it.min.js",
+    "markdown-it-front-matter.min.js",
+    "highlight.min.js"
+  ]
+}

plugins/voyage/playground/lib/markdown-it-front-matter.min.js

@@ -0,0 +1,152 @@
+// vendored by scripts/vendor-playground-libs.mjs — DO NOT EDIT
+// global: markdownitFrontMatter
+(function (root, factory) {
+  var __mod = { exports: {} };
+  (function (module, exports) {
+    // Process front matter and pass to cb
+    'use strict';
+    
+    module.exports = function front_matter_plugin(md, cb) {
+      var min_markers = 3,
+          marker_str  = '-',
+          marker_char = marker_str.charCodeAt(0),
+          marker_len  = marker_str.length;
+    
+      function frontMatter(state, startLine, endLine, silent) {
+        var pos,
+            nextLine,
+            marker_count,
+            token,
+            old_parent,
+            old_line_max,
+            start_content,
+            auto_closed = false,
+            start = state.bMarks[startLine] + state.tShift[startLine],
+            max = state.eMarks[startLine];
+    
+        // Check out the first character of the first line quickly,
+        // this should filter out non-front matter
+        if (startLine !== 0 || marker_char !== state.src.charCodeAt(0)) {
+          return false;
+        }
+    
+        // Check out the rest of the marker string
+        // while pos <= 3
+        for (pos = start + 1; pos <= max; pos++) {
+          if (marker_str[(pos - start) % marker_len] !== state.src[pos]) {
+            start_content = pos + 1;
+            break;
+          }
+        }
+    
+        marker_count = Math.floor((pos - start) / marker_len);
+    
+        if (marker_count < min_markers) {
+          return false;
+        }
+        pos -= (pos - start) % marker_len;
+    
+        // Since start is found, we can report success here in validation mode
+        if (silent) {
+          return true;
+        }
+    
+        // Search for the end of the block
+        nextLine = startLine;
+    
+        for (;;) {
+          nextLine++;
+          if (nextLine >= endLine) {
+            // unclosed block should be autoclosed by end of document.
+            // also block seems to be autoclosed by end of parent
+            break;
+          }
+    
+          if (state.src.slice(start, max) === '...') {
+            break;
+          }
+    
+          start = state.bMarks[nextLine] + state.tShift[nextLine];
+          max = state.eMarks[nextLine];
+    
+          if (start < max && state.sCount[nextLine] < state.blkIndent) {
+            // non-empty line with negative indent should stop the list:
+            // - ```
+            //  test
+            break;
+          }
+    
+          if (marker_char !== state.src.charCodeAt(start)) {
+            continue;
+          }
+    
+          if (state.sCount[nextLine] - state.blkIndent >= 4) {
+            // closing fence should be indented less than 4 spaces
+            continue;
+          }
+    
+          for (pos = start + 1; pos <= max; pos++) {
+            if (marker_str[(pos - start) % marker_len] !== state.src[pos]) {
+              break;
+            }
+          }
+    
+          // closing code fence must be at least as long as the opening one
+          if (Math.floor((pos - start) / marker_len) < marker_count) {
+            continue;
+          }
+    
+          // make sure tail has spaces only
+          pos -= (pos - start) % marker_len;
+          pos = state.skipSpaces(pos);
+    
+          if (pos < max) {
+            continue;
+          }
+    
+          // found!
+          auto_closed = true;
+          break;
+        }
+    
+        old_parent = state.parentType;
+        old_line_max = state.lineMax;
+        state.parentType = 'container';
+    
+        // this will prevent lazy continuations from ever going past our end marker
+        state.lineMax = nextLine;
+    
+        token        = state.push('front_matter', null, 0);
+        token.hidden = true;
+        token.markup = state.src.slice(startLine, pos);
+        token.block  = true;
+        token.map    = [ startLine, nextLine + (auto_closed ? 1 : 0) ];
+        token.meta   = state.src.slice(start_content, start - 1);
+    
+        state.parentType = old_parent;
+        state.lineMax = old_line_max;
+        state.line = nextLine + (auto_closed ? 1 : 0);
+    
+        cb(token.meta);
+    
+        return true;
+      }
+    
+      md.block.ruler.before(
+        'table',
+        'front_matter',
+        frontMatter,
+        {
+          alt: [
+            'paragraph',
+            'reference',
+            'blockquote',
+            'list' 
+          ]
+        }
+      );
+    };
+    
+  })(__mod, __mod.exports);
+  root["markdownitFrontMatter"] = __mod.exports;
+})(typeof window !== 'undefined' ? window : globalThis);