@pipeworx/mcp-guam-code 0.1.1 → 0.1.3

package/README.md

@@ -3,7 +3,7 @@
 Guam Code Annotated (GCA) — Guam territorial statutes, by citation and by
 topic/keyword search. Keyless.
 
-Part of [Pipeworx](https://pipeworx.io) — an MCP gateway connecting AI agents to 1784+ live data sources. This is an independent, unofficial integration — not affiliated with, endorsed by, or published by the upstream provider.
+Part of [Pipeworx](https://pipeworx.io) — an MCP gateway connecting AI agents to 1819+ live data sources. This is an independent, unofficial integration — not affiliated with, endorsed by, or published by the upstream provider.
 
 ## Tools
 
@@ -224,7 +224,7 @@ directly, instead of just this one's:
 }
 ```
 
-Both URLs reach the same gateway and the same 1784+ data sources. The
+Both URLs reach the same gateway and the same 1819+ data sources. The
 only difference is which pack's tools are listed **directly**; `ask_pipeworx`
 reaches all of them from either one.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipeworx/mcp-guam-code",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Guam Code Annotated (GCA) — section lookup and search. Fleet #2888.",
   "type": "module",
   "main": "src/index.ts",
@@ -26,7 +26,7 @@
     "@cloudflare/workers-types": "^4.20260405.1"
   },
   "pipeworx": {
-    "sourceHash": "v1-964fe40aed9923b374141088f42860d68ffb5efa97b3c7c3fc37b9902c46c79f",
-    "sourceCommit": "3723e46c6d115bd4a1fd2175e6bf758555e7cb50"
+    "sourceHash": "v1-e101ffcf2c7ba1d5bce6f1a3825e124694dc1e346ebf10ef701f4239c45c5202",
+    "sourceCommit": "a03f96ed672b8c149593c64ecbf30280cabf084c"
   }
 }

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.pipeworx-io/guam-code",
   "title": "Guam Code",
   "description": "Guam Code Annotated (GCA) — section lookup and search. Fleet #2888.",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "websiteUrl": "https://pipeworx.io/packs/guam-code",
   "repository": {
     "url": "https://github.com/pipeworx-io/mcp-guam-code",

package/src/index.ts

@@ -935,6 +935,48 @@ function unescapePdfLiteral(s: string): string {
   return out;
 }
 
+/**
+ * Recover the ORIGINAL raw byte (0-255) that `new TextDecoder('latin1')`
+ * produced a given codepoint for. This exists because the WHATWG Encoding
+ * Standard makes "latin1" an ALIAS for "windows-1252", not true ISO-8859-1 —
+ * every browser and Node's TextDecoder follow that spec. Bytes 0x00-0x7F and
+ * 0xA0-0xFF decode as identity either way, but bytes 0x80-0x9F come back as
+ * windows-1252's typographic symbols (0x99 -> U+2122 "™", 0x87 -> U+2021
+ * "‡", …) instead of themselves — so `charCodeAt(i) & 0xff`, used everywhere
+ * else in this file to recover a raw byte from a decoded string, silently
+ * returns the WRONG byte for any of those 32 codepoints (U+2122 & 0xff is
+ * 0x22, not the real 0x99).
+ *
+ * This only matters where the decoded character is being used as DATA (a
+ * CID half-byte, a `mapped1` font's 1-byte code) rather than as the actual
+ * text it renders (a true WinAnsi-encoded character, where the windows-1252
+ * reading IS the correct glyph — see `fontDecoderFor`'s `'winansi'` kind,
+ * which returns the decoded string unchanged on purpose and must NOT be
+ * routed through this function). Found on mainland China's NPC/MOJ law PDFs
+ * (cn-law, fleet #3136): Founder PDFGenerator (方正) writes CJK body text as
+ * LITERAL strings under a Type0/Identity-H CID font, and roughly an eighth
+ * of all 2-byte CIDs have at least one half-byte landing in 0x80-0x9F —
+ * `合` (U+5408, CID 0x0F87) was coming back as `骨` (U+9AA8) because its low
+ * byte 0x87 decoded to U+2021, and `U+2021 & 0xff` (0x21) is a different,
+ * also-valid CID that happens to mean `骨` in the same font.
+ */
+function rawByteFromLatin1Char(code: number): number {
+  const b = WIN1252_HIGH_TO_BYTE.get(code);
+  return b !== undefined ? b : code & 0xff;
+}
+// windows-1252's 0x80-0x9F table (the WHATWG "windows-1252" index), inverted
+// codepoint -> original byte. 0x81/0x8D/0x8F/0x90/0x9D are undefined in that
+// table and decode as themselves (identity), so they need no entry here.
+const WIN1252_HIGH_TO_BYTE = new Map<number, number>([
+  [0x20ac, 0x80], [0x201a, 0x82], [0x0192, 0x83], [0x201e, 0x84],
+  [0x2026, 0x85], [0x2020, 0x86], [0x2021, 0x87], [0x02c6, 0x88],
+  [0x2030, 0x89], [0x0160, 0x8a], [0x2039, 0x8b], [0x0152, 0x8c],
+  [0x017d, 0x8e], [0x2018, 0x91], [0x2019, 0x92], [0x201c, 0x93],
+  [0x201d, 0x94], [0x2022, 0x95], [0x2013, 0x96], [0x2014, 0x97],
+  [0x02dc, 0x98], [0x2122, 0x99], [0x0161, 0x9a], [0x203a, 0x9b],
+  [0x0153, 0x9c], [0x017e, 0x9e], [0x0178, 0x9f],
+]);
+
 interface RawObject {
   dict: string;
   streamBytes: Uint8Array | null;
@@ -1283,7 +1325,18 @@ async function extractPdfText(buf: ArrayBuffer, options?: PdfExtractOptions): Pr
 
   const TOKEN_RE =
     /\/(\S+)\s+[\d.]+\s+Tf|\[((?:\\.|[^\]])*)\]\s*TJ|<([0-9A-Fa-f\s]*)>\s*Tj|\(((?:\\.|[^()])*)\)\s*Tj|1\s+0\s+0\s+1\s+[\d.-]+\s+([\d.-]+)\s+Tm/g;
-  const TJ_PIECE_RE = /\(((?:\\.|[^()])*)\)|<([0-9A-Fa-f\s]*)>/g;
+  // Third alternative (bare number) added for Indonesia's JDIH statute PDFs
+  // (jdih.setneg.go.id, fleet #3121): that producer never writes a literal
+  // space byte between words — "REPUBLIK INDONESIA" is encoded as one TJ run
+  // `[(…K)-269.0(I)…]`, where the -269 IS the word gap, not kerning. Every
+  // sampled font's intra-word kerning tops out around +-30 (observed: 2.0,
+  // -2.9, -14.0, -24.0); the real word gaps in the same document measured
+  // -269, -286, -290, -692, -1396, -1400 — two clusters with nothing between
+  // them, so a flat threshold cleanly separates "kerning" from "space" without
+  // needing the current font size (the TJ number is already in thousandths of
+  // text space, before the Tfs/Th scale-up ISO 32000 §9.4.3 applies).
+  const TJ_PIECE_RE = /\(((?:\\.|[^()])*)\)|<([0-9A-Fa-f\s]*)>|(-?\d+(?:\.\d+)?)/g;
+  const TJ_WORD_GAP_THRESHOLD = -100;
 
   function decodeRun(dec: FontDecoder, literal: string | undefined, hex: string | undefined): string {
     if (literal !== undefined) {
@@ -1298,10 +1351,38 @@ async function extractPdfText(buf: ArrayBuffer, options?: PdfExtractOptions): Pr
       // font's /ToUnicode map entirely and produces line-noise control
       // characters instead of the real character -- route it through the
       // SAME decoder a hex run below already uses.
+      //
+      // 'cid' (Type0/Identity-H) is a 2-BYTE code space, same as the hex-
+      // string path below -- a literal string's BYTES must be paired up
+      // big-endian into one CID per pair, not looked up one byte at a time.
+      // Found on mainland China's NPC/MOJ law PDFs (cn-law, fleet #3136):
+      // Founder PDFGenerator (方正), the producer behind flk.npc.gov.cn's
+      // and xzfg.moj.gov.cn's statute PDFs, writes most CJK body text as
+      // literal strings like `(\000I)Tj` under a Type0 CID font rather than
+      // as hex strings -- the shape this branch was missing. Decoding each
+      // byte separately (the pre-fix behavior) looks up CID 0x00 and CID
+      // 0x49 independently instead of the real CID 0x0049, so virtually
+      // every CJK glyph misses its ToUnicode entry and comes back as
+      // U+FFFD -- silently: no warning, a non-empty result, just wrong.
+      // Measured against 中华人民共和国个人信息保护法 (PIPL)'s official
+      // gazette PDF: 18,929 of 19,858 extracted characters were U+FFFD
+      // before this fix (95%), 0 after, and `第十三条` (Article 13) and its
+      // neighbors read correctly. If the literal string has an odd byte
+      // count (shouldn't happen for a well-formed 2-byte-code run), the
+      // trailing lone byte is silently dropped rather than guessed at.
       if (dec.kind === 'winansi') return unescaped;
+      if (dec.kind === 'cid') {
+        let out = '';
+        for (let i = 0; i + 2 <= unescaped.length; i += 2) {
+          const code =
+            (rawByteFromLatin1Char(unescaped.charCodeAt(i)) << 8) | rawByteFromLatin1Char(unescaped.charCodeAt(i + 1));
+          out += String.fromCodePoint(dec.map.get(code) ?? 0xfffd);
+        }
+        return out;
+      }
       let out = '';
       for (let i = 0; i < unescaped.length; i++) {
-        const code = unescaped.charCodeAt(i) & 0xff;
+        const code = rawByteFromLatin1Char(unescaped.charCodeAt(i));
         out += String.fromCodePoint(dec.map.get(code) ?? 0xfffd);
       }
       return out;
@@ -1380,7 +1461,17 @@ async function extractPdfText(buf: ArrayBuffer, options?: PdfExtractOptions): Pr
       }
       const dec = (currentFont && fontMap.get(currentFont)) || { kind: 'winansi' as const };
       if (m[2] !== undefined) {
-        for (const piece of m[2].matchAll(TJ_PIECE_RE)) out += decodeRun(dec, piece[1], piece[2]);
+        for (const piece of m[2].matchAll(TJ_PIECE_RE)) {
+          if (piece[3] !== undefined) {
+            // A big negative adjustment between two TJ pieces with no
+            // literal space byte at all — see TJ_PIECE_RE's comment above.
+            // Skip if `out` already ends in whitespace so a producer that
+            // DOES write literal spaces never gets a doubled one.
+            if (parseFloat(piece[3]) <= TJ_WORD_GAP_THRESHOLD && !/\s$/.test(out)) out += ' ';
+            continue;
+          }
+          out += decodeRun(dec, piece[1], piece[2]);
+        }
       } else if (m[3] !== undefined) {
         out += decodeRun(dec, undefined, m[3]);
       } else if (m[4] !== undefined) {

package/src/server.ts

@@ -11,7 +11,7 @@ import * as bakedIndexModule from './gu-baked-data.js';
 const bakedIndex = Object.fromEntries(Object.entries(bakedIndexModule));
 
 const server = new Server(
-  { name: '@pipeworx/mcp-guam-code', version: '0.1.1' },
+  { name: '@pipeworx/mcp-guam-code', version: '0.1.3' },
   { capabilities: { tools: {} } },
 );