fix(logging): name stripControlChars' param for the reference, and TEST the wiring

typescript is the ONE port that already had this right: `Logger.log` calls
`stripControlChars(serialized)` before merging (Logger.ts:339), so the scrub was
genuinely on the emission path. rust, cpp and java each shipped the same function
with ZERO call sites — public, correct, and protecting nothing. This commit does
not change ts behaviour; it closes the two gaps around it.

1. PARAM NAME. The reference's public contract is `strip_control_chars(event_dict)`
   (logging_config.py:33); this port recorded `data`. Renamed the parameter to
   `eventDict` — the enumerator's camelCase->snake_case fold turns that into
   `event_dict`, so the recorded signature now matches the oracle with NO
   rename-table entry needed. Verified by regenerating port_signatures.json:

     signalwire.core.logging_config [('event_dict', 'any')]

   The alternative was a free-function param-rename table, which does not exist in
   enumerate-signatures.ts (its rename tables are keyed by CLASS). Renaming in the
   port source is the smaller, more honest change: nothing about the reference is
   being reconciled away, the port simply says what it means. All three call sites
   are positional, so nothing else moved.

2. NO TEST COVERED THE WIRING. The protection was real but unguarded — the exact
   state in which rust/cpp/java's scrub rotted into a no-op without any gate
   noticing. The new test reads what the logger ACTUALLY emitted (via the existing
   console spies) rather than calling stripControlChars directly, so it fails when
   the wiring is removed. Verified by deleting the call from Logger.log — RED:

     × strips control characters from emitted log data
       Tests  1 failed | 48 passed (49)

   A helper-only test passes against that same break.

   The second test asserts tab/newline/CR SURVIVE: a scrub that ate them would
   satisfy "no control chars" while mangling every multi-line message.

Verified: run-tests.sh -> exit 0, 136 files / 2884 tests (2882 before; +2 new).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KKwgPbehDoAMdG3hPL79oi

Author: mjerris

port_signatures.json

@@ -5440,7 +5440,7 @@
         "strip_control_chars": {
           "params": [
             {
-              "name": "data",
+              "name": "event_dict",
               "type": "any",
               "required": true
             }

src/Logger.ts

@@ -231,13 +231,16 @@ const CONTROL_CHAR_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f]/g;
  * log injection attacks. Mirrors Python SDK's `strip_control_chars` structlog
  * processor. Processes nested objects and arrays recursively.
  *
- * @param data - The record whose string values should be sanitized.
- * @returns A shallow copy of `data` with control characters removed from strings.
+ * @param eventDict - The log event record whose string values should be sanitized.
+ *   Named for the reference's `event_dict` (`logging_config.py:33`) — the enumerator
+ *   camelCase->snake_case folds this to `event_dict`, so the recorded signature matches
+ *   the oracle without needing a rename-table entry.
+ * @returns A shallow copy of `eventDict` with control characters removed from strings.
  */
-export function stripControlChars<T extends Record<string, unknown>>(data: T): T {
+export function stripControlChars<T extends Record<string, unknown>>(eventDict: T): T {
   const result = {} as T;
-  for (const key of Object.keys(data) as (keyof T)[]) {
-    const value = data[key];
+  for (const key of Object.keys(eventDict) as (keyof T)[]) {
+    const value = eventDict[key];
     if (typeof value === 'string') {
       result[key] = value.replace(CONTROL_CHAR_RE, '') as T[keyof T];
     } else if (Array.isArray(value)) {

tests/Logger.test.ts

@@ -9,6 +9,7 @@ import {
   setGlobalLogStream,
   resetLoggingConfiguration,
   getExecutionMode,
+  stripControlChars,
 } from '../src/Logger.js';
 
 describe('Logger', () => {
@@ -472,4 +473,30 @@ describe('Logger', () => {
       expect(widensToDebug(log)).toBe(false);
     });
   });
+  // --- control-char scrub: WIRING ------------------------------------------
+  //
+  // typescript is the ONE port where the scrub was already on the emission path
+  // (Logger.log calls stripControlChars before merging) — but nothing tested
+  // that, so the protection was real yet unguarded. rust/cpp/java each shipped
+  // the same function with ZERO call sites; the only assertion that can tell the
+  // difference is one that reads what the logger ACTUALLY emitted.
+  describe('control-character scrub on the emission path', () => {
+    it('strips control characters from emitted log data', () => {
+      getLogger('inject.test').info('msg', { field: 'user\u0000said\u001b[31mRED\u0007' });
+
+      expect(spyInfo).toHaveBeenCalled();
+      const emitted = JSON.stringify(spyInfo.mock.calls);
+      expect(emitted).not.toContain('\u0000');
+      expect(emitted).not.toContain('\u001b');
+      expect(emitted).not.toContain('\u0007');
+      expect(emitted).toContain('usersaid[31mRED');
+    });
+
+    it('keeps tab/newline/carriage-return, which are legal in a log line', () => {
+      // A scrub that ate these would satisfy "no control chars" above while
+      // mangling every multi-line message.
+      const legal = 'line1\tcol\nline2\r end';
+      expect(stripControlChars({ field: legal })).toEqual({ field: legal });
+    });
+  });
 });