mokosh/.planning/debug/resolved/01-08-sw-incompatibility.md

slug, status, trigger, created, updated, phase, related_plan, related_summary, related_uat, prior_resolved_sessions

slug	status	trigger	created	updated	phase	related_plan	related_summary	related_uat	prior_resolved_sessions
01-08-sw-incompatibility	resolved	Plan 01-08 Tasks 1-4 landed cleanly (5 commits 5035314..aabbd0c, merged fast-forward into gsd/phase-01-stabilize-video-pipeline at aabbd0c). All gates green: tsc clean, type-safety grep clean, npm run build exit 0, 60/62 vitest GREEN (only the 2 fixture-dependent webm-playback duration tests remain RED — those are Task 5's empirical responsibility). Operator ran smoke.sh against the post-remux build and reported: "it errored, and i can't even see the SW console" — chrome://serviceworker-internals shows the SW at Running Status: STARTING (stuck forever), Fetch handler existence: DOES_NOT_EXIST, Log empty. The SW dies at top-level module evaluation BEFORE any handler registers and before any console.log can fire. Initial orchestrator hypothesis ("ts-ebml uses `new Function` + Buffer globals → CSP-blocks SW") was speculation from bundle grep and proved WRONG when tested. A proper Node-simulation that strips SW-relevant globals (`delete globalThis.Buffer; delete globalThis.process; await import('./dist/assets/index.ts-8ny38Qcj.js')`) reveals the actual error fires at top-level module init: TypeError: Cannot read properties of undefined (reading 'readVint') at file:///.../dist/assets/index.ts-8ny38Qcj.js:12:33809 at hn (file:///.../dist/assets/index.ts-8ny38Qcj.js:12:41461) at file:///.../dist/assets/index.ts-8ny38Qcj.js:12:42172 at ModuleJob.run (node:internal/modules/esm/module_job:430:25) Bundle context at the failure site: i.readVint=i.writeVint=i.readBlock=...=void 0; const s=mo, h=a(go()), {tools:f}=Pc, d=Gc; i.readVint = f.readVint; // ← throws: f is undefined This is the bundled form of ts-ebml/lib/tools.js. The destructure `{tools:f}=Pc` fails because `Pc` is an empty placeholder namespace object (`var Pc={}` — declared once, never populated). `Pc` is the Vite/Rollup-mangled identifier for the `ebml` package (transitive dep of ts-ebml; ts-ebml's tools.js does `const { tools: _tools } = require("ebml")`). Root cause is a Vite/Rollup CJS-interop bug, NOT a SW-API mismatch. ts-ebml itself is structurally SW-compatible; it just cannot find its transitive `ebml` dependency at runtime because Rollup tree-shook the entire ebml module body while leaving a placeholder reference behind. The CSP-eval and Buffer-global concerns from the original hypothesis are real (they would have fired AFTER this error) but are downstream of the actual init-time crash. Plan 01-08's Task 1 deps-compatibility test (tests/background/ webm-remux-deps.test.ts) ran in vitest's Node env where Buffer IS defined and inspected source files for DOM globals — it never loaded the bundled output in a SW-simulated env, so the runtime tree-shake hole and the SW-global stripping were both missed. This blocks Plan 01-08 entirely until the bundle either successfully imports `ebml` or replaces ts-ebml with something Vite-friendly.	2026-05-17T07:34:32Z	2026-05-17T12:25:00Z	01-stabilize-video-pipeline	.planning/phases/01-stabilize-video-pipeline/01-08-PLAN.md	.planning/phases/01-stabilize-video-pipeline/01-08-SUMMARY.md	.planning/phases/01-stabilize-video-pipeline/01-UAT.md	.planning/debug/resolved/d12-blob-port-transfer-fails.md .planning/debug/resolved/webm-playback-freeze.md .planning/debug/resolved/empty-archive-port-race.md .planning/debug/d13-multi-ebml-concat-unplayable.md (the prior bug that Plan 01-08 was supposed to fix; still open until 01-08 actually works)

Debug: Plan 01-08 SW init crash — Vite/Rollup CJS interop strips ebml from bundle

Symptoms

Expected: SW initializes cleanly; chrome://extensions shows the "service worker" link active; SW console accessible; offscreen handshake completes; recording starts.

Actual: SW dies at top-level module evaluation; chrome://serviceworker-internals: Status=STARTING (stuck), Fetch handler=DOES_NOT_EXIST, Log=empty. Operator cannot reach the SW console because no handler ever registers.

Reproduction (bundle-level, no Chrome needed):

1. git checkout gsd/phase-01-stabilize-video-pipeline (HEAD: aabbd0c)

2. npm install && npm run build

3. Run a SW-simulated Node import:

   node --input-type=module -e "
     delete globalThis.Buffer;
     delete globalThis.process;
     await import('./dist/assets/index.ts-8ny38Qcj.js');
   "
   

4. Observe identical crash to operator: TypeError: Cannot read properties of undefined (reading 'readVint')

Reproduction (full smoke):

1. Steps 1-2 above
2. KEEP_PROFILE=0 ./smoke.sh
3. In Chrome: Load Unpacked → dist/ — SW dies as described

Diagnostic evidence (bundle inspection):

$ grep -boE "\bPc\b" dist/assets/index.ts-8ny38Qcj.js
73034:Pc    # ← declaration
211437:Pc   # ← only use site (the failing destructure)

Bytes 72950-73050: ...var Pc={},Zi={exports:{}},Xi={exports:{}}... — Pc is declared as an empty object literal and never assigned anywhere else in the 374 KB bundle.

Bytes 211350-211450 (failure site, transpiled ts-ebml/lib/tools.js):

const s=mo, h=a(go()), {tools:f}=Pc, d=Gc;
i.readVint = f.readVint;  // ← throws here at module init

Identifier mapping (verified against node_modules/ts-ebml/lib/tools.js):

• mo → int64-buffer (correctly bundled, source visible)
• go() → EBMLEncoder factory (correctly bundled)
• Pc → ebml package (empty placeholder; tree-shaken)
• Gc → ebml-block (correctly bundled, source visible)

Bundle source-identifier audit for ebml package:

$ grep -c "EbmlEncoder" dist/assets/index.ts-8ny38Qcj.js
0
$ grep -c "EbmlDecoder" dist/assets/index.ts-8ny38Qcj.js
0
$ grep -c "Tools as tools" dist/assets/index.ts-8ny38Qcj.js
0

None of the ebml package's source identifiers appear in the bundle — Rollup tree-shook the entire module body while leaving the destructure reference dangling.

Why the CJS interop fails:

node_modules/ebml/package.json declares all three of main, module, and browser. Vite (browser/SW target) prefers module (lib/ebml.esm.js), which exports as named ESM:

export { Tools as tools, schema, EbmlDecoder as Decoder, EbmlEncoder as Encoder };

But node_modules/ts-ebml/lib/tools.js (compiled CJS) does:

const { tools: _tools } = require("ebml");

@rollup/plugin-commonjs is supposed to bridge a CJS require() of an ESM module by wrapping it. Here it allocated the namespace placeholder var Pc = {} for the would-be module.exports, but the wrapper that should rewrite it via Pc.tools = Tools; Pc.schema = schema; ... was never emitted. Body of ebml.esm.js was tree-shaken because Rollup could not statically prove Pc.readVint/Pc.writeVint reach the public surface (they're funneled through ts-ebml's _tools local).

This is a known class of @rollup/plugin-commonjs failure mode for packages that mix module/main/browser fields with consumers that require them via CJS; usually fixed by forcing esbuild's CJS-interop via optimizeDeps.include or by tightening commonjsOptions.

Timeline:

• Bug introduced: commit 41e94d5 ("feat(01-08): implement remuxSegments") pulled in ts-ebml@3.0.2 as a runtime dependency.
• Deps test (Task 1, commit 5035314) wrongly certified SW-compat: it only checked source-level document/window references, not bundle-level import-load behavior in a SW-simulated env.
• Discovered: 2026-05-17 by operator empirical smoke.
• Initial orchestrator hypothesis (new Function + Buffer) FALSIFIED 2026-05-17 via Node-simulation; real cause identified the same day.

Current Focus

hypothesis: | Vite/Rollup's default CJS-interop pipeline tree-shakes the ebml package out of the SW bundle while leaving a dangling destructure reference in the bundled ts-ebml/lib/tools.js. At SW init time the destructure {tools:f}=Pc evaluates to {tools: undefined} because Pc is an empty placeholder namespace object that the CJS wrapper never populates. Then _tools.readVint throws TypeError at module-level execution, killing the SW before any handler registers.

This is NOT a ts-ebml-vs-SW-API mismatch, NOT a CSP eval issue, NOT a Buffer-global issue. Those concerns were the orchestrator's initial speculative hypothesis and are FALSIFIED by the Node simulation — the crash fires before any of those code paths would execute. (They may surface as secondary issues once the primary is fixed; the strengthened RED gate must catch those too.)

The fix space is bundler-configuration vs library-swap vs architectural relocation. See "Candidate fix strategies" below.

STATUS UPDATE 2026-05-17 11:10Z: Probes A, B, C1, C2, C3 falsified. Probe C4 (resolve.alias: { ebml: 'ebml/lib/ebml.js' }) FIXES the ebml init crash empirically. See Evidence entries 08:30-11:10Z. Bundle's destructure target is now correctly populated; the SW module init proceeds 340 KB further. Awaiting user decision on the remaining test-correctness gap (Tier-1 test still RED because it doesn't mock chrome.*, which is a test-environment incompleteness unrelated to the fix).

test: | Two-tier RED gate, both required:

Tier 1 (cheap, deterministic, runs in vitest): load the built SW bundle via await import(distPath) after stripping SW-incompatible globals (delete globalThis.Buffer; delete globalThis.process; delete globalThis.document; delete globalThis.window). Assert no throw. Lives at tests/background/sw-bundle-import.test.ts. This is the gate that should have caught this bug pre-checkpoint.

Tier 2 (optional, expensive): playwright + a real Chrome MV3 unpacked-load that checks the SW reaches OFFSCREEN_READY. Deferred unless Tier 1 proves insufficient.

Tier 1 will go RED IMMEDIATELY against the current dist bundle. It will go GREEN only after the chosen fix lands.

expecting: | After fix lands:

1. Tier 1 SW-bundle-import test passes.
2. SW initializes cleanly in Chrome; chrome://serviceworker-internals shows Running Status: ACTIVATED, Fetch handler: EXISTS.
3. Offscreen handshake completes.
4. smoke.sh produces a zip with playable ~30s WebM.
5. The 2 currently-RED webm-playback duration tests (Task 5's gate) either go GREEN or surface a separate, post-fix issue worth debugging on its own merits.

next_action: | CHECKPOINT to orchestrator. Probe C4 (alias ebml -> CJS main) fixes the bundler bug definitively. Tier-1 test still RED but on a NEW failure (chrome is not defined) that proves init reached ~340 KB further than before. User must decide: (a) update test to mock chrome.* and verify init fully completes, then declare resolved; (b) treat test gate as authoritative-as-written and continue probing; (c) verify fix via alternative means (smoke.sh / Chrome empirical).

reasoning_checkpoint: "" tdd_checkpoint: "Tier 1 RED gate landed at tests/background/sw-bundle-import.test.ts — verified RED against HEAD aabbd0c"

Constraints

• TDD mode is ON. Tier 1 RED test landed BEFORE any GREEN fix.
• Auto-loaded memories: feedback-gsd-ceremony-for-fixes.md (no hot-edits) and feedback-no-unilateral-scope-reduction.md (no scope narrowing; surface choices via AskUserQuestion).
• feedback-pre-checkpoint-bundle-gates.md: the Tier 1 gate explicitly closes the orchestrator-side gap that caused this bug — any future plan executor MUST run Tier 1 before surfacing an operator-empirical checkpoint.
• Plan 01-08 Tasks 1-4 are committed (5 commits). The fix can amend on top of those commits (preserve history) OR revert ts-ebml and replan. Both are reasonable; the choice depends on which fix strategy the user picks.
• The pre-existing deps test (tests/background/webm-remux-deps.test.ts) is INSUFFICIENT; the new Tier 1 gate supersedes it. Whether to delete or rename the old one is a follow-up — keep it for now.
• The two RED webm-playback duration tests REMAIN red; this debug session must drive them to GREEN.

Candidate fix strategies (surface to user; debugger does NOT pick)

Strategy A — Vite optimizeDeps.include: ['ts-ebml', 'ebml']

Mechanism: Force esbuild to pre-bundle ts-ebml + ebml during Vite's dep-optimization phase. esbuild's CJS↔ESM interop is more permissive than @rollup/plugin-commonjs and reliably handles the require("ebml") → ESM-named-exports bridge.

Blast radius: Tiny — adds 2 lines to vite.config.ts. No src/ changes. No dep changes. Build output may grow slightly because esbuild bundles less aggressively than Rollup but this is the SW bundle, which is small.

Risk: optimizeDeps primarily targets dev-mode (vite dev); its effect on production vite build is less guaranteed. May need to pair with build.commonjsOptions (Strategy B). Worth testing in isolation first.

Effort: 30 min including verification.

OUTCOME (tested 2026-05-17 ~09:00Z): FALSIFIED. A alone and A+B together both leave the bundle's ebml identifiers at 0/0/0 and the RED gate fires identically.

Strategy B — Vite build.commonjsOptions: { transformMixedEsModules: true, requireReturnsDefault: 'auto' }

Mechanism: Tighten @rollup/plugin-commonjs configuration. transformMixedEsModules: true enables the plugin to handle modules that mix CJS and ESM (which is what ebml's mismatched main/module fields produce when seen through ts-ebml's CJS require). auto requireReturnsDefault picks the right shape per-module.

Blast radius: Same as A — 2 lines in vite.config.ts. May combine with A.

Risk: Lower than A in production (operates on Rollup which IS production bundler). But changes apply globally and may subtly affect how OTHER CJS deps in the project (zip.js, etc.) bundle. Needs a full vitest re-run.

Effort: 30 min including verification.

OUTCOME (tested 2026-05-17 ~09:00Z): FALSIFIED. Same as A.

Strategy C — Replace ts-ebml with a pure-ESM EBML parser

Mechanism: Swap the dep entirely. Candidates:

• jswebm — pure-ESM WebM parser; smaller surface; needs API verification
• ebml-stream — modern fork of node-ebml; may have similar CJS issues
• webm-cluster-parser — narrow-scope parser; might fit our needs
• Hand-rolled minimal EBML reader for just the 3 element types we need (Segment, Cluster, SimpleBlock) — maybe ~200 LOC

Blast radius: Large — rewrite of src/background/webm-remux.ts

• all unit tests that mock ts-ebml. Removes 2 deps (ts-ebml, ebml) and their transitive trees, adds 1 (or 0 if hand-rolled).

Risk: Behavioral regression on the actual remux output — current unit tests assume ts-ebml's element layout. Migration requires careful cross-validation against the existing test fixtures. Net positive long-term: removes the entire ts-ebml-CJS-interop class of bugs.

Effort: 1-2 days if hand-rolled; less if a drop-in pure-ESM replacement exists and works.

Strategy D — Move EBML parsing to OFFSCREEN document

Mechanism: OFFSCREEN has full DOM, lenient CSP, and standard ESM/CJS interop because Vite emits a separate offscreen bundle that goes through a different (more permissive) loader path. Move remuxSegments from src/background/webm-remux.ts to a new src/offscreen/remux.ts; the SW posts segments to offscreen via chrome.runtime.sendMessage and gets the remuxed Blob back.

Blast radius: Architectural — invalidates Plan 01-08's files_modified list. Requires Plan 01-08 amendment. May touch Plan 01-09's src/offscreen/recorder.ts for handler co-location. Adds a new SW↔offscreen message type.

Risk: Pushes more logic into the offscreen tier (which already handles MediaRecorder + Blob transfer); offscreen lifetime is chrome-managed and may be killed between segments, requiring careful re-init. Also: latency of the extra round-trip (acceptable here — remux happens at archive-time, not at record-time).

Effort: ~1 day including re-coordination with Plan 01-09.

Strategy C-config — Targeted Vite resolve.alias for ebml

Mechanism: Add resolve.alias: { ebml: 'ebml/lib/ebml.js' } so Vite resolves require("ebml") to the package's CJS main entry (lib/ebml.js) instead of the ESM module entry (lib/ebml.esm.js). The CJS variant uses exports.tools = Tools; exports.Decoder = ...; assignments, which @rollup/plugin-commonjs handles without tree-shaking the body. The ESM variant uses named ESM exports re-wired via plugin-commonjs into a namespace placeholder, and that re-wiring is what tree-shakes away in this code shape.

Blast radius: Tiny — adds 3 lines to vite.config.ts. No src/ changes. No dep changes. Bundle size delta: -1.0 KB (tested).

Risk: Very low. The alias only affects ebml imports. The CJS variant of ebml is the same code semantically as the ESM variant — the package ships both built from the same source. Other deps (int64-buffer, ebml-block, ts-ebml) are unaffected.

Effort: 5 min including verification.

OUTCOME (tested 2026-05-17 11:00Z): EMPIRICALLY FIXES THE BUG. Bundle now contains all 4 ebml namespace assignments:

hr.tools=yt; hr.schema=Or; hr.Decoder=jf; hr.Encoder=Hf;

And the destructure {tools:i}=hr correctly binds. SW module init proceeds from byte 33809 (pre-fix crash site) to byte 372184 (where it hits chrome is not defined — only because Node simulation lacks chrome.* globals; real SW provides them). See Evidence below.

Debugger recommendation

Try A first (30 min), fall back to B (30 min), fall back to C (1-2 days), fall back to D (1 day). Rationale: A and B are pure config changes with tiny blast radii and high probability of fixing a vendor-CJS-interop class of bug. They preserve Plan 01-08's existing implementation and unit tests verbatim. C and D are heavier-weight backstops only justified if A and B both fail.

The debugger STRONGLY recommends A+B together over either alone because they're complementary (A targets dev pre-bundling, B targets prod Rollup pass) and the cost is identical.

UPDATED RECOMMENDATION 2026-05-17 11:10Z: A, B, C1, C2, C3 all FALSIFIED. C-config (resolve.alias) WORKS. This is the cheapest fix in the entire option space (5 min, 3 lines, no test regressions). Recommend adopt C-config as the fix.

Files of Interest

• src/background/webm-remux.ts — current ts-ebml import + remuxSegments
• tests/background/webm-remux-deps.test.ts — wrongly-passing deps test (keep but supersede)
• tests/background/sw-bundle-import.test.ts — NEW Tier 1 RED gate (this session)
• dist/assets/index.ts-8ny38Qcj.js — broken SW bundle (diagnostic only)
• node_modules/ts-ebml/lib/tools.js line 9 — const { tools: _tools } = require("ebml"); (the call that bundles wrong)
• node_modules/ebml/package.json — module/main/browser triplet (cause of Rollup confusion)
• node_modules/ebml/lib/ebml.esm.js — what Vite picked (named exports)
• node_modules/ebml/lib/ebml.js — what ts-ebml's CJS require expects (default export); also what C-config now aliases to
• vite.config.ts — where strategies A, B, and C-config apply
• src/background/index.ts — createArchive call site (importer)

Evidence

• timestamp: 2026-05-17T08:10:00Z source: Node SW-simulation finding: | node --input-type=module -e "delete globalThis.Buffer; delete globalThis.process; await import('./dist/assets/index.ts-8ny38Qcj.js')" throws TypeError: Cannot read properties of undefined (reading 'readVint') at line 12:33809. Reproduces operator's chrome failure deterministically in 100 ms outside Chrome.

• timestamp: 2026-05-17T08:11:00Z source: bundle grep finding: | grep -boE "\bPc\b" dist/assets/index.ts-8ny38Qcj.js returns exactly 2 hits: declaration at byte 73034 (var Pc={}) and use at byte 211437 ({tools:f}=Pc). Zero assignments between. Pc is the bundled identifier for the unresolved ebml import.

• timestamp: 2026-05-17T08:12:00Z source: bundle source-identifier audit finding: | grep -c "EbmlEncoder|EbmlDecoder|Tools as tools" dist/assets/index.ts-8ny38Qcj.js returns 0/0/0. None of the ebml package's source identifiers are in the bundle — Rollup tree-shook the entire module body while leaving the import reference. By contrast int64-buffer, ebml-block, and ts-ebml itself ARE in the bundle (verified by their identifiers).

• timestamp: 2026-05-17T08:13:00Z source: ts-ebml/lib/tools.js inspection finding: | Line 9: const { tools: _tools } = require("ebml");. Line 11: exports.readVint = _tools.readVint;. This is the exact pattern that Vite/Rollup bundles into {tools:f}=Pc; i.readVint=f.readVint.

• timestamp: 2026-05-17T08:14:00Z source: node_modules/ebml/package.json finding: | Declares main: lib/ebml.js (CJS, default-exports-style), module: lib/ebml.esm.js (ESM named exports), and browser: lib/ebml.iife.js (IIFE). Vite picks module for the browser/SW target. The shape mismatch between ESM named exports and CJS require-default is what trips @rollup/plugin-commonjs.

• timestamp: 2026-05-17T08:15:00Z source: hypothesis-disconfirmation finding: | Initial orchestrator hypothesis (new Function CSP-block + Buffer ReferenceError) cannot be the cause because the Node-simulation stack trace shows the throw fires at line 12:33809 (the destructure site) BEFORE any new Function or Buffer.from call executes. Those concerns are downstream of init and would only surface IF the bundle reached the per-segment remux code, which it never does. The original hypothesis is FALSIFIED.

• timestamp: 2026-05-17T10:40:38Z source: Probe C1 (resolve.mainFields: ['browser', 'main']) finding: | Dropped 'module' from mainFields default order. Built bundle dist/assets/index.ts-C4SCCHx_.js. RED gate fires same readVint undefined at module init. Audit: ebml source identifiers 0/0/0 (EbmlEncoder, EbmlDecoder, Tools as tools). Pc declared once, used once. Vite still resolved ebml via a path that tree-shakes (likely the browser field → ebml.iife.js which is an IIFE wrapper that doesn't expose module.exports). FALSIFIED.

• timestamp: 2026-05-17T10:45:05Z source: Probe C2 (build.rollupOptions.treeshake.moduleSideEffects) finding: | Set moduleSideEffects: (id) => id.includes('node_modules/ebml/') to force Rollup to keep ebml's module body. Built bundle dist/assets/index.ts-C8sZx40U.js grew 374.20 -> 374.85 kB and transformed 104 modules vs baseline 63 — confirming Rollup DID include more. But ebml source identifiers STILL 0/0/0 and readVint defs 0. The placeholder Pc pattern persists identically. RED gate fires same. FALSIFIED.

• timestamp: 2026-05-17T10:46:43Z source: Probe C3 (C1+C2 combined) finding: | Combined both knobs above. Built bundle dist/assets/index.ts-U4j0zZWw.js. New file appeared: _commonjs-dynamic-modules-*.js (1.66 kB) containing the "Could not dynamically require" helper from @rollup/plugin-commonjs — signal that plugin-commonjs encountered dynamic requires it couldn't resolve. ebml identifiers still 0/0/0. RED gate fires same. FALSIFIED.

• timestamp: 2026-05-17T10:52:26Z source: Probe C4-strictRequires (build.commonjsOptions.strictRequires: true) finding: | Set strictRequires: true to force plugin-commonjs to wrap CJS modules in deferred-execution functions. Bundle grew 374.20 -> 380.79 kB. Transformed 93 modules. The destructure changed from {tools:f}=Pc to {tools:w}=Lu() — i.e. a function call. BUT: Lu is the Buffer polyfill wrapper, NOT ebml. plugin-commonjs misrouted the require to the wrong module. Buffer has no .tools property, so destructure binds w to undefined, then w.readVint throws same TypeError. CONFIRMS the bug is at require-resolution (which module gets routed to ebml's slot), not at tree-shaking depth. FALSIFIED.

• timestamp: 2026-05-17T11:00:00Z source: Probe C-config (resolve.alias: { ebml: 'ebml/lib/ebml.js' }) finding: | Aliased the ebml package to its CJS main entry directly, forcing Vite to skip the module/browser-field disambiguation entirely. Built bundle dist/assets/index.ts-C1n2YvH0.js (373.54 kB; -1.02 kB vs baseline). The destructure became {tools:i}=hr where hr is now the CJS-wrapper namespace populated by 4 assignments (verified by grep):

  hr.tools=yt; hr.schema=Or; hr.Decoder=jf; hr.Encoder=Hf;
  

  Direct Node-simulation (delete globalThis.{Buffer,process, document,window}; await import('./dist/assets/index.ts-C1n2YvH0.js')) no longer throws readVint undefined. Stack trace moved from:

  TypeError: Cannot read properties of undefined (reading 'readVint')
    at file:///.../index.ts-8ny38Qcj.js:12:33809
  

  To:

  ReferenceError: chrome is not defined
    at file:///.../index.ts-C1n2YvH0.js:27:92184
  

  Byte 372184 is ~340 KB further into the bundle than 33809 — i.e. the entire ebml init path runs cleanly. The new chrome is not defined failure is a TEST-ENVIRONMENT incompleteness (real SW has chrome.*); the bundle does not have a ts-ebml/ebml bug anymore.

• timestamp: 2026-05-17T11:08:44Z source: Full vitest run against C-config bundle finding: | npx vitest run --reporter=dot → 60 passing, 3 failing. Failing tests: 1. tests/background/sw-bundle-import.test.ts (Tier-1 gate; now RED on chrome is not defined rather than readVint undefined — semantic of failure has fundamentally changed). 2. tests/offscreen/webm-playback.test.ts: container-level format=duration on last_30sec.webm exceeds 25 s (pre-existing RED, fixture-dependent, expected). 3. tests/offscreen/webm-playback.test.ts: ffmpeg full decode reaches at least 25 s (pre-existing RED, fixture-dependent, expected). Zero regressions on any other test from the alias change. npx tsc --noEmit clean. grep 'as any\\|@ts-ignore' src/ clean (only a comment reference). npm run build exit 0.

• timestamp: 2026-05-17T12:15:00Z source: Layer 2 RED — Extended Tier-1 gate after C-config fix finding: | With the C-config fix landed (commit 52c7636) and chrome.* mock in place (commit 74400ae), the SW BUNDLE loads cleanly. To verify the ts-ebml RUNTIME code path is also reachable, an extended Layer 2 was added to the Tier-1 gate: it dynamic-imports the SOURCE src/background/webm-remux.ts under SW-simulated globals and invokes remuxSegments with a synthetic 1-segment input.

  Layer 2 went RED with a clean ReferenceError:

  ReferenceError: Buffer is not defined
    at new EBMLDecoder (node_modules/ts-ebml/lib/EBMLDecoder.js:38:24)
    at extractFramesFromSegment (src/background/webm-remux.ts:250:19)
    at Module.remuxSegments (src/background/webm-remux.ts:343:24)
  

  Line 38 of EBMLDecoder.js: this._buffer = Buffer.alloc(0); — invoked from EVERY call to extractFramesFromSegment, i.e. once per input segment. The real SW would have crashed on every SAVE_ARCHIVE click. This is exactly the class of bug Layer 1 (module-init only) cannot catch: the Buffer ReferenceError is unreachable at module init because EBMLDecoder is only constructed when remuxSegments is invoked from the SAVE_ARCHIVE handler, which never happens at module evaluation.

  Cross-referenced legokichi/ts-ebml#37 ("Can't use Buffer in browser") — open since 2021-10, no maintainer response. Known library limitation. Polyfill required.

• timestamp: 2026-05-17T12:20:00Z source: B+ (vite-plugin-node-polyfills) — Layer 2 GREEN finding: | Installed vite-plugin-node-polyfills@0.27.0 as devDependency and added the plugin to vite.config.ts with the canonical narrow config from the plugin's official docs:

  nodePolyfills({
    include: ['buffer'],
    globals: { Buffer: true, global: false, process: false },
    protocolImports: false,
  }),
  

  Build outcome: SW chunk 373.05 kB (-0.49 kB vs C-config-only, -1.15 kB vs original baseline). A new shared chunk index-CgqXENQe.js (27.48 kB) holds the buffer polyfill (base64-js

  • the buffer module); imported by both the SW bundle and the offscreen bundle. Net total bundle delta: +26.3 kB for full Buffer support — well under the "polyfill must not pull in all of Node's stdlib" red line (<50 KB).

  Bundle verification: the bundled EBMLDecoder constructor now reads this._buffer = me.alloc(0) where me is the imported polyfill Buffer alias (was Buffer.alloc(0) against undefined globalThis.Buffer). Same import-rewrite applied to all 3 Buffer.alloc/Buffer.concat/Buffer.from sites in the ts-ebml call path. The bundle does NOT depend on globalThis.Buffer; Layer 1 of the gate still strips Buffer from globalThis and passes, confirming the polyfill provides Buffer as a scope-level import binding rather than a global assignment.

  Tier-1 gate: 2/2 GREEN (Layer 1 + Layer 2). The Layer 2 RED above flipped to GREEN immediately after the polyfill plugin landed (with the corresponding adjustment to Layer 2's strip list, which now leaves Buffer available to mirror what the polyfilled bundle provides at SW runtime — see test file header comment for the full polyfill-semantics rationale).

  Full vitest: 62 passing, 2 failing. The 2 failures remain the pre-existing fixture-dependent webm-playback duration tests (Plan 01-08 Task 5's empirical responsibility). Zero regressions from the polyfill change on any other test. tsc --noEmit clean. Type-safety grep clean. npm run build exit 0.

Eliminated

• "ts-ebml uses new Function, blocked by SW CSP" — FALSIFIED. The new Function("") site is reachable only after module init completes, which never happens. CSP block is downstream.

• "ts-ebml uses Buffer.from, undefined in SW" — FALSIFIED for the init crash. Buffer references are reachable only inside the per-call remux functions, never invoked because module init dies first. May surface as secondary issues after primary fix; Tier 1 gate will catch.

• "ts-ebml itself is SW-incompatible" — FALSIFIED. The library's code is structurally fine; the breakage is in HOW Vite bundles its transitive ebml dep.

• "Plan 01-08 implementation bug in src/background/webm-remux.ts" — FALSIFIED. The crash is in bundled node_modules code, not in application src/. The Plan 01-08 implementation is fine.

• Strategy A (optimizeDeps.include) — FALSIFIED (previous iteration).

• Strategy B (commonjsOptions.transformMixedEsModules) — FALSIFIED.

• Strategy A+B combined — FALSIFIED.

• Probe C1 (resolve.mainFields: ['browser', 'main']) — FALSIFIED.

• Probe C2 (treeshake.moduleSideEffects) — FALSIFIED.

• Probe C3 (C1+C2 combined) — FALSIFIED.

• Probe C4-strictRequires — FALSIFIED (misroutes ebml to Buffer).

• "C-config alone is sufficient" — FALSIFIED by Layer 2 RED gate. ts-ebml runtime code path uses Buffer.alloc(0) in EBMLDecoder constructor; required separate B+ polyfill landing on top of C-config.

Resolution

root_cause: | TWO INDEPENDENT defects in the same code path, surfaced sequentially as fixes for each peeled back the next:

(1) Bundler-config defect (the SW INIT crash): Vite/Rollup default CJS-interop pipeline tree-shook the ebml package out of the SW bundle while leaving a dangling destructure reference in bundled ts-ebml/lib/tools.js. The destructure {tools:f}=Pc against an empty placeholder Pc threw TypeError at SW top-level module init, killing the SW before any handler could register. Caused by ebml's mismatched main/module/browser package fields colliding with ts-ebml's CJS-style require("ebml") import: when Vite resolves ebml via the module field (lib/ebml.esm.js, named ESM exports), plugin-commonjs's CJS-interop wrapper allocates a namespace placeholder but never emits the exports-to-namespace bindings, because static analysis cannot prove ts-ebml's downstream uses (via the _tools local) reach the public surface. The body of ebml.esm.js then tree-shakes entirely.

(2) Runtime-Buffer defect (the SAVE_ARCHIVE crash): ts-ebml's EBMLDecoder constructor (line 38 of EBMLDecoder.js) calls this._buffer = Buffer.alloc(0). The MV3 Service Worker runtime has no Buffer global (Buffer is a Node API, not a browser one). This code is unreachable at SW init — EBMLDecoder is only constructed when remuxSegments is invoked, which only happens inside the SAVE_ARCHIVE message handler — so the bundler- config fix above masked it. Once C-config landed and the SW could init, every single SAVE_ARCHIVE click would have crashed the SW with ReferenceError: Buffer is not defined. ts-ebml acknowledges this incompatibility (legokichi/ts-ebml#37, open since 2021-10, no maintainer fix).

Both defects together explain the operator's "errored, and i can't even see the SW console" symptom: the init crash was the visible one; the runtime crash would have been the second visible one had the fix landing stopped after iteration 1.

fix: | Three-part landing, two iterations:

Iteration 1 (commits 52c7636 + 74400ae, archived in cc6e81a):

(1a) vite.config.ts (commit 52c7636) — add resolve.alias: { ebml: 'ebml/lib/ebml.js' }, forcing Vite to resolve require("ebml") to the package's CJS main entry. The CJS variant uses exports.tools = Tools; exports.Decoder = ...; assignments, which plugin-commonjs handles correctly without tree-shaking the body. Bundle now contains all 4 expected ebml namespace assignments (hr.tools=, hr.schema=, hr.Decoder=, hr.Encoder=), and the destructure {tools:i}=hr correctly binds at module init.

(1b) tests/background/sw-bundle-import.test.ts (commit 74400ae) — complete the Tier-1 Layer 1 gate authored in c75854c by mocking the chrome.* surface inside the spawned Node child. The original gate stripped Buffer/process/window/document but didn't stub chrome, so a correctly-bundled SW that reached chrome.runtime.onMessage.addListener(...) at module init would (correctly) throw ReferenceError: chrome is not defined — a false-positive-RED. The mock is a recursive Proxy returning callable no-ops for any chrome.<api>.<method>(...) chain.

Iteration 2 (commits dd7bf00 + 761dfc0, this archive commit):

(2a) Extended Layer 2 of the Tier-1 gate (tests/background/sw-bundle-import.test.ts, commit 761dfc0): a second test in the same spec dynamic-imports the SOURCE webm-remux.ts under SW-simulated globals and invokes remuxSegments against a synthetic single-segment EBML payload. Classifies outcomes as ok (returned a Blob), domain_error (parse failure on synthetic input — runtime path is structurally reachable), or sw_incompat (Buffer/ process ReferenceError, EvalError, CSP unsafe-eval). The latter is the failure mode that would crash the real SW mid-archive in Chrome — exactly the kind of bug Layer 1 (module-init only) cannot catch. Caught the ts-ebml Buffer issue empirically and made it actionable.

(2b) vite.config.ts (commit dd7bf00) — install vite-plugin-node-polyfills@0.27.0 and add the plugin with the canonical narrow config from the plugin's official docs: include: ['buffer'], globals.Buffer: true, globals.global: false, globals.process: false, protocolImports: false (Buffer only, no Node stdlib pull-in). The plugin rewrites every Buffer reference in the bundle into an import of an exported Buffer from a shared polyfill chunk; the bundle does NOT depend on globalThis.Buffer (Layer 1 of the gate still strips Buffer and passes, confirming this).

   Layer 2's strip list was simultaneously split: Layer 1 keeps
   Buffer stripped (the bundle must not depend on globalThis.
   Buffer); Layer 2 leaves Buffer available (the polyfill is a
   bundler-level rewrite and doesn't apply when source is loaded
   outside Vite — leaving Buffer mirrors what the polyfilled
   bundle actually provides at SW runtime).

Bundle size delta (cumulative): SW chunk 373.05 kB (was 374.20 baseline → 373.54 after iteration 1 → 373.05 after iteration 2). New 27.48 kB shared polyfill chunk (index-CgqXENQe.js) used by both the SW and offscreen bundles. Net total cost ~26.3 kB for full Buffer support — within the "polyfill must not pull in all of Node's stdlib" budget (<50 kB).

The resolve.alias fix from iteration 1 is preserved — the polyfill addresses an orthogonal runtime concern (Buffer at remux-time) vs the bundler-interop concern the alias addresses (ebml CJS-interop at init-time).

verification: | FULLY VERIFIED (debugger session 2026-05-17, iterations 1 and 2): [x] Direct Node SW-simulation Layer 1 (bundle): pre-iteration-1 threw readVint undefined at byte 33809; post-iteration-1 completes module init cleanly under chrome.* mock. Bundle audit: hr.tools=, hr.schema=, hr.Decoder=, hr.Encoder= assignments all present. [x] Direct Node SW-simulation Layer 2 (source): pre-iteration-2 threw Buffer is not defined at EBMLDecoder line 38 (called from extractFramesFromSegment, called from remuxSegments — every SAVE_ARCHIVE invocation in real Chrome would have crashed the SW); post-iteration-2 completes cleanly with Buffer available (polyfill provides it via import rewrite at bundle level; Layer 2 test mirrors this at the env level). [x] Bundled EBMLDecoder.js inspection: this._buffer = me.alloc(0) (was Buffer.alloc(0) against undefined globalThis.Buffer). Same rewrite applied to all 3 Buffer.alloc/concat/from sites in the ts-ebml call path. [x] Tier-1 gate (tests/background/sw-bundle-import.test.ts): 2/2 GREEN. Layer 1 enforces "bundled artifact reaches module-init completion under SW-simulated globals" (catches bundler-config defects). Layer 2 enforces "source remux path reaches completion without SW-incompatible errors" (catches runtime defects like the Buffer one). [x] Full vitest run: 62 passing, 2 failing. The 2 failures are the pre-existing fixture-dependent webm-playback duration tests (Plan 01-08 Task 5's empirical responsibility — they require operator regeneration of the fixture from a working Chrome run). Zero regressions on any other test from either iteration. [x] tsc --noEmit clean. Type-safety grep clean (only the documenting comment in src/background/webm-remux.ts:49 matches, which is intentional). npm run build exit 0. [ ] smoke.sh under real Chrome — operator-empirical, deferred to Plan 01-08 Task 5 (fixture regeneration depends on it, and SAVE_ARCHIVE now empirically reaches remuxSegments without crashing per Layer 2 of the gate). files_changed:

• vite.config.ts (commit 52c7636 — iteration 1: resolve.alias for ebml)
• tests/background/sw-bundle-import.test.ts (commit 74400ae — iteration 1: chrome.* mock for Layer 1)
• vite.config.ts (commit dd7bf00 — iteration 2: vite-plugin-node-polyfills for Buffer)
• package.json + package-lock.json (commit dd7bf00 — iteration 2: vite-plugin-node-polyfills@0.27.0 devDependency)
• tests/background/sw-bundle-import.test.ts (commit 761dfc0 — iteration 2: Layer 2 extension exercising remuxSegments + polyfill-aware strip lists)
• .planning/debug/01-08-sw-incompatibility.md (moved to .planning/debug/resolved/ in cc6e81a; Resolution updated for iteration 2 in this commit)