@flighthq/swf 0.3.0 → 0.3.1-next.1041.35b950c

package/src/swfDocument.test.ts

@@ -5,6 +5,8 @@ import {
 } from '@flighthq/compression/contract';
 import { createGlyphRasterizerBackendFromGlyphOutlineSource } from '@flighthq/font/contract';
 import { createGlyphAtlas, getGlyphAtlasEntry } from '@flighthq/glyphatlas/contract';
+import { clearImageDecoders } from '@flighthq/image-codec/contract';
+import { collectImportDiagnostics } from '@flighthq/importdiagnostics/contract';
 import {
   getMovieClipCurrentFrame,
   getMovieClipCurrentLabel,
@@ -26,6 +28,7 @@ import {
 import {
   createScene2DDocumentFromBytes,
   createScene2DDocumentImporterRegistry,
+  loadScene2DImageResources,
   resolveScene2DResources,
 } from '@flighthq/scene2d-resources/contract';
 import { createDisplayObject } from '@flighthq/scene2d/contract';
@@ -37,6 +40,7 @@ import type {
   TimelineAudioCue,
   MorphShape,
   MovieClip,
+  Node2D,
   RichText,
   Scale9Shape,
   Shape,
@@ -48,8 +52,10 @@ import {
   BitmapTextureSourceKind,
   BlendMode,
   Compression,
+  CompressionFraming,
   DisplayObjectKind,
   ImageResourceReferenceKind,
+  ImportDiagnosticSeverity,
   MorphShapeKind,
   MovieClipKind,
   ResourceResolutionState,
@@ -67,10 +73,18 @@ import {
   readSwfExportedSymbolNames,
   registerSwfScene2DDocumentImporter,
 } from './swfDocument';
+import { buildFrameScriptAbc } from './swfFrameActionTestHelper';
+import { registerSwfImageDecoders } from './swfImageDecoder';
 import { ShapeWriter } from './swfShapeTestHelper';
 
-beforeEach(() => unregisterDecompressor(Compression.Deflate));
-afterEach(() => unregisterDecompressor(Compression.Deflate));
+beforeEach(() => {
+  clearImageDecoders();
+  unregisterDecompressor(Compression.Deflate);
+});
+afterEach(() => {
+  clearImageDecoders();
+  unregisterDecompressor(Compression.Deflate);
+});
 
 describe('createGlyphOutlineSourcesFromSwf', () => {
   it('funnels a DefineFont2 outline and code table through the font adapter into glyphatlas', () => {
@@ -805,8 +819,9 @@ describe('createScene2DFromSwf', () => {
     // Without a decompressor the bytes are unreadable, and that reads as the document's null sentinel.
     expect(createScene2DFromSwf(compressed)).toBeNull();
 
-    registerDecompressor(Compression.Deflate, (body, uncompressedLength) => {
+    registerDecompressor(Compression.Deflate, (body, uncompressedLength, framing) => {
       expect(uncompressedLength).toBe(uncompressed.length - 8);
+      expect(framing).toBe(CompressionFraming.Rfc1950);
       return new Uint8Array(body).reverse();
     });
     try {
@@ -1054,7 +1069,7 @@ describe('createScene2DFromSwf', () => {
     expect(node.data.multiline).toBe(true);
     expect(node.data.wordWrap).toBe(true);
     expect(node.data.border).toBe(true);
-    expect(node.data.textColor).toBe(0x112233);
+    expect(node.data.textColor).toBe(0x112233ff);
     expect(node.data.width).toBe(200);
     expect(node.data.height).toBe(40);
     // Twips convert throughout: a 240-twip font height is 12px, and the 20/40/60/80-twip layout values
@@ -1193,8 +1208,7 @@ describe('createScene2DFromSwf', () => {
     expect(drawn.data.commands.filter((token) => token === 'lineTo')).toHaveLength(2);
   });
 
-  it('resolves a lossless bitmap fill to pixels at import, with no image resource left to load', () => {
-    registerDeflateDecompressor();
+  it('emits a lossless bitmap reference synchronously and resolves it only in the async resource pass', async () => {
     const art = new ShapeWriter();
     art.writeFillStyleCount(1);
     art.writeBitmapFillStyle(0x41, 9, 20);
@@ -1216,18 +1230,27 @@ describe('createScene2DFromSwf', () => {
         createTag(TAG_END),
       ]),
     );
-    unregisterDecompressor(Compression.Deflate);
-
     const drawn = getNodeChildren(document!.root)[0] as Shape;
     expect(drawn.data.commands[0]).toBe('beginTextureFill');
-    // A lossless payload is not an image file, so it resolves here rather than through @flighthq/image —
-    // which is why it leaves nothing on the document's image-resource contract.
     const texture = drawn.data.commands[2] as Texture2D;
+    const reference = document!.imageResources[0];
+    expect(document!.imageResources).toHaveLength(1);
+    expect(reference.mimeType).toBe('image/x-swf-lossless');
+    expect(reference.kind === ImageResourceReferenceKind.Embedded && reference.alphaType).toBe('opaque');
+    expect(reference.textures).toEqual([texture]);
+    expect(getTextureSource(texture)).toBeNull();
+
+    // Registration is caller-owned and happens after parsing; neither parsing nor reference creation
+    // secretly installs a decoder or starts async work.
+    registerDeflateDecompressor();
+    registerSwfImageDecoders();
+    const resources = await loadScene2DImageResources(document!);
+
+    expect(resources.resolved).toEqual([reference]);
     expectLosslessTexturePixel(texture);
-    expect(document!.imageResources).toEqual([]);
   });
 
-  it('leaves a lossless bitmap sourceless when no decompressor is registered', () => {
+  it('parses lossless bitmap reference data without requiring a registered decompressor', () => {
     const art = new ShapeWriter();
     art.writeFillStyleCount(1);
     art.writeBitmapFillStyle(0x41, 9, 20);
@@ -1253,6 +1276,44 @@ describe('createScene2DFromSwf', () => {
     const drawn = getNodeChildren(document!.root)[0] as Shape;
     expect(drawn.data.commands[0]).toBe('beginTextureFill');
     expect(getTextureSource(drawn.data.commands[2] as Texture2D)).toBeNull();
+    expect(document!.imageResources).toHaveLength(1);
+    expect(document!.imageResources[0].state).toBe(ResourceResolutionState.Unresolved);
+  });
+
+  it('carries premultiplied lossless-alpha bytes through the reference into the resolved Bitmap', async () => {
+    const art = new ShapeWriter();
+    art.writeFillStyleCount(1);
+    art.writeBitmapFillStyle(0x41, 9, 20);
+    art.writeLineStyleCount(0);
+    art.writeStyleBits(1, 0);
+    art.writeStyleChange({ fill1: 1, moveToX: 0, moveToY: 0 });
+    art.writeStraightEdge(800, 0);
+    art.writeStraightEdge(0, 800);
+    art.writeEndShape();
+    const pixels = losslessPayload(5, 1, 1, storedDeflate([0x80, 0x40, 0x20, 0x10]));
+    const document = createScene2DFromSwf(
+      createSwf([
+        createTag(TAG_DEFINE_BITS_LOSSLESS_2, joinBytes(uint16(9), pixels)),
+        createTag(TAG_DEFINE_SHAPE_3, joinBytes(uint16(7), createRectangle(0, 800, 0, 800), art.toBytes())),
+        createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(1), uint16(7))),
+        createTag(TAG_SHOW_FRAME),
+        createTag(TAG_END),
+      ]),
+    )!;
+    const reference = document.imageResources[0];
+    expect(reference.kind === ImageResourceReferenceKind.Embedded && reference.alphaType).toBe('premultiplied');
+
+    registerDeflateDecompressor();
+    registerSwfImageDecoders();
+    await loadScene2DImageResources(document);
+
+    const drawn = getNodeChildren(document.root)[0] as Shape;
+    const source = getTextureSource(drawn.data.commands[2] as Texture2D);
+    expect(source?.kind).toBe(BitmapTextureSourceKind);
+    if (source?.kind !== BitmapTextureSourceKind) throw new Error('expected a lossless bitmap source');
+    const bitmap = source as Bitmap;
+    expect(bitmap.alphaType).toBe('premultiplied');
+    expect([...bitmap.data]).toEqual([0x40, 0x20, 0x10, 0x80]);
   });
 
   it('samples one bitmap character through a texture per sampling variant', () => {
@@ -2439,51 +2500,169 @@ describe('createScene2DFromSwf', () => {
   });
 });
 
-describe('createScene2DFromSwf morph bounds', () => {
-  it('reports the box the morph occupies at its ratio, not the union of both endpoints', () => {
-    const startEdges = morphBox(200);
-    const endEdges = morphBox(400);
-    const styles = joinBytes(
-      new Uint8Array([1, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff]),
-      new Uint8Array([0]),
-    );
+describe('createScene2DFromSwf import diagnostics', () => {
+  // A clean parse is two claims: the values are right AND THE PARSER IS NOT COMPLAINING. Every other test
+  // in this file checks the first. This checks the second — the one that catches a tag walk that
+  // desynchronised and still left the asserted fields looking plausible, which is the failure mode a
+  // length-prefixed tag format has most of.
+  //
+  // Skip is excluded rather than the list asserted empty: a well-formed SWF may legitimately use a feature
+  // this importer does not model, and reporting that is correct behaviour on correct input. What must not
+  // appear is anything of higher severity — the importer may say "I do not model this", never "I could not
+  // read this".
+  it('raises no data-integrity diagnostic for a well-formed file', () => {
+    const crumbs = collectImportDiagnostics((sink) => {
+      createScene2DFromSwf(
+        createSwf([
+          createTag(TAG_FILE_ATTRIBUTES, new Uint8Array(4)),
+          createTag(TAG_SYMBOL_CLASS, joinBytes(uint16(1), uint16(7), swfString('Game.Avatar'))),
+          createTag(
+            TAG_PLACE_OBJECT_2,
+            joinBytes(
+              new Uint8Array([PLACE_HAS_NAME | PLACE_HAS_MATRIX | PLACE_HAS_CHARACTER]),
+              uint16(3),
+              uint16(7),
+              createMatrix(1.5, 0.25, -0.125, 0.5, 200, -40),
+              swfString('avatarSlot'),
+            ),
+          ),
+          createTag(TAG_SHOW_FRAME),
+          createTag(TAG_END),
+        ]),
+        sink,
+      );
+    });
+
+    const integrity = crumbs.filter((crumb) => crumb.severity !== ImportDiagnosticSeverity.Skip);
+    expect(
+      integrity.map((crumb) => crumb.kind),
+      `a good SWF made the importer complain: ${integrity.map((c) => c.kind).join(', ')}`,
+    ).toEqual([]);
+  });
+
+  it('reports an unreadable container as a Reject naming which check refused it', () => {
+    const notSwf = new Uint8Array([0x50, 0x4b, 0x03, 0x04, 0, 0, 0, 0]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(notSwf, sink)).toBeNull();
+    });
+
+    expect(diagnostics.map((entry) => entry.kind)).toEqual(['swf.invalid-signature']);
+    expect(diagnostics[0].severity).toBe(ImportDiagnosticSeverity.Reject);
+    expect(diagnostics[0].origin).toBe('uncompressSwfSource');
+  });
+
+  it('separates an unregistered decompressor from a corrupt body, which share one null sentinel', () => {
+    const uncompressed = createSwf([createTag(TAG_SHOW_FRAME), createTag(TAG_END)]);
+    const compressed = joinBytes(uncompressed.subarray(0, 8), uncompressed.subarray(8));
+    compressed[0] = 0x43;
+
+    // Nothing registered: the file is readable after one registration, which is not the same failure as
+    // a corrupt stream even though both come back null.
+    const unregistered = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(compressed, sink)).toBeNull();
+    });
+    expect(unregistered.map((entry) => entry.kind)).toEqual(['swf.no-decompressor-registered']);
+    expect(unregistered[0]!.severity).toBe(ImportDiagnosticSeverity.Reject);
+
+    registerDecompressor(Compression.Deflate, () => null);
+    try {
+      const failed = collectImportDiagnostics((sink) => {
+        expect(createScene2DFromSwf(compressed, sink)).toBeNull();
+      });
+      expect(failed.map((entry) => entry.kind)).toEqual(['swf.decompression-failed']);
+      expect(failed[0]!.severity).toBe(ImportDiagnosticSeverity.Reject);
+    } finally {
+      unregisterDecompressor(Compression.Deflate);
+    }
+  });
+
+  it('records nothing at all when the caller engages no collector', () => {
+    const notSwf = new Uint8Array([0x50, 0x4b, 0x03, 0x04, 0, 0, 0, 0]);
+    // The whole seam is opt-in: the ordinary call must not build a crumb, so this asserts the shape of
+    // the default path rather than any particular diagnostic.
+    expect(createScene2DFromSwf(notSwf)).toBeNull();
+    expect(collectImportDiagnostics(() => {})).toEqual([]);
+  });
+
+  it('reports a deliberately declined tag as a Skip, which is correct behaviour rather than failure', () => {
+    // VideoFrame payloads are codec packets this importer does not carry. The document still imports;
+    // what the crumb adds is that a caller can now tell "declined on purpose" from "silently lost".
+    const file = createSwf([
+      createTag(
+        TAG_DEFINE_VIDEO_STREAM,
+        joinBytes(uint16(4), uint16(1), uint16(16), uint16(16), new Uint8Array([0x01, 2])),
+      ),
+      createTag(61, joinBytes(uint16(4), uint16(0), new Uint8Array([0, 0, 0, 0]))),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const declined = diagnostics.filter((entry) => entry.kind === 'swf.video-frame-payload');
+    expect(declined).toHaveLength(1);
+    expect(declined[0].severity).toBe(ImportDiagnosticSeverity.Skip);
+    expect(declined[0].detail).toEqual({ capability: 'swf.video.video-frame', tag: 61 });
+  });
+
+  it('stays silent on metadata tags, whose absence costs a document nothing', () => {
+    // The line this asserts is the one that keeps the report usable: a caller filtering crumbs should not
+    // have to skip past authoring metadata to find the entries that mean something.
+    const file = createSwf([
+      createTag(69, new Uint8Array([0, 0, 0, 0])),
+      createTag(77, swfString('<rdf/>')),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    expect(diagnostics).toEqual([]);
+  });
+
+  it('reports an unreadable shape body as a Recover, since the placeholder still places and sizes', () => {
+    // A body the decoder cannot read costs that character's drawing and nothing else, so the honest
+    // outcome is Recover: the document still imports and the character still has its authored bounds.
+    const file = createSwf([
+      createTag(TAG_DEFINE_SHAPE, joinBytes(uint16(1), createRectangle(0, 20, 0, 20), new Uint8Array([0xff]))),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const recovered = diagnostics.filter((entry) => entry.kind === 'swf.shape-body-unreadable');
+    expect(recovered).toHaveLength(1);
+    expect(recovered[0].severity).toBe(ImportDiagnosticSeverity.Recover);
+    expect(recovered[0].detail).toEqual({ capability: 'swf.shape.define-shape', characterId: 1, version: 1 });
+  });
+
+  it('reports a morph definition that does not decode, which otherwise leaves no trace at all', () => {
+    // Header reads cleanly — id and both bounds — so the definition is accepted and only the morph body
+    // fails. That is the case with no signal: the character is absent and the import still succeeds.
     const body = joinBytes(
       uint16(7),
       createRectangle(0, 200, 0, 200),
       createRectangle(0, 400, 0, 400),
-      uint32(styles.length + startEdges.length),
-      styles,
-      startEdges,
-      endEdges,
-    );
-    const place = (depth: number, ratio: number): Uint8Array =>
-      createTag(
-        TAG_PLACE_OBJECT_2,
-        joinBytes(new Uint8Array([PLACE_HAS_CHARACTER | PLACE_HAS_RATIO]), uint16(depth), uint16(7), uint16(ratio)),
-      );
-
-    const document = createScene2DFromSwf(
-      createSwf([
-        createTag(TAG_DEFINE_MORPH_SHAPE, body),
-        place(1, 0),
-        place(2, 0x7fff),
-        place(3, 0xffff),
-        createTag(TAG_SHOW_FRAME),
-        createTag(TAG_END),
-      ]),
+      uint32(0xffff),
+      new Uint8Array([0]),
     );
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(createSwf([createTag(TAG_DEFINE_MORPH_SHAPE, body), createTag(TAG_END)]), sink),
+      ).not.toBeNull();
+    });
 
-    // The union would report 20 for all three. Each instance reports the box it is actually at, which is
-    // what layout and hit testing read.
-    const boxes = getNodeChildren(document!.root).map((node) => getNodeLocalBoundsRectangle(node).width);
-    expect(boxes[0]).toBeCloseTo(10);
-    expect(boxes[1]).toBeCloseTo(15, 1);
-    expect(boxes[2]).toBeCloseTo(20);
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.morph-shape-undecodable');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.morph.define-morph-shape', characterId: 7 });
   });
-});
 
-describe('createScene2DFromSwf morph shapes', () => {
-  it('places a morph character and drives its progress from the placement ratio', () => {
+  it('stays silent about a morph definition that decodes, so the drop entry carries information', () => {
     const startEdges = morphBox(200);
     const endEdges = morphBox(400);
     const styles = joinBytes(
@@ -2499,87 +2678,1367 @@ describe('createScene2DFromSwf morph shapes', () => {
       startEdges,
       endEdges,
     );
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(createSwf([createTag(TAG_DEFINE_MORPH_SHAPE, body), createTag(TAG_END)]), sink),
+      ).not.toBeNull();
+    });
 
-    const document = createScene2DFromSwf(
-      createSwf([
-        createTag(TAG_DEFINE_MORPH_SHAPE, body),
-        // Two placements of one character at different ratios: the case a single shared node cannot serve.
-        createTag(
-          TAG_PLACE_OBJECT_2,
-          joinBytes(new Uint8Array([PLACE_HAS_CHARACTER | PLACE_HAS_RATIO]), uint16(1), uint16(7), uint16(0)),
-        ),
-        createTag(
-          TAG_PLACE_OBJECT_2,
-          joinBytes(new Uint8Array([PLACE_HAS_CHARACTER | PLACE_HAS_RATIO]), uint16(2), uint16(7), uint16(0xffff)),
-        ),
-        createTag(TAG_SHOW_FRAME),
-        createTag(TAG_END),
-      ]),
+    expect(diagnostics.filter((entry) => entry.kind === 'swf.morph-shape-undecodable')).toEqual([]);
+  });
+
+  it('reports a static text body that does not compose, which the deferred pass would otherwise swallow', () => {
+    // A record header declaring a font and a colour, then nothing to read them from. Composition is
+    // deferred to after every font is parsed, so this failure surfaces far from the tag that carried it.
+    const record = new BitWriter();
+    record.writeUnsigned(1, 1);
+    record.writeUnsigned(0, 3);
+    record.writeUnsigned(1, 1);
+    record.writeUnsigned(1, 1);
+    record.writeUnsigned(0, 1);
+    record.writeUnsigned(0, 1);
+    const text = joinBytes(
+      uint16(6),
+      createRectangle(0, 1024, 0, 1024),
+      createMatrix(1, 0, 0, 1, 0, 0),
+      new Uint8Array([4, 8]),
+      record.toBytes(),
     );
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(createSwf([createTag(TAG_DEFINE_TEXT, text), createTag(TAG_END)]), sink),
+      ).not.toBeNull();
+    });
 
-    const [first, second] = getNodeChildren(document!.root) as MorphShape[];
-    expect(first.kind).toBe(MorphShapeKind);
-    expect(second.kind).toBe(MorphShapeKind);
-    // Distinct nodes, each sitting at its own point along the same definition.
-    expect(first).not.toBe(second);
-    expect(first.data.progress).toBe(0);
-    expect(second.data.progress).toBe(1);
-    expect(morphWidth(first)).toBeCloseTo(10);
-    expect(morphWidth(second)).toBeCloseTo(20);
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.text-shape-uncomposable');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.text.define-text', characterId: 6 });
   });
-});
 
-describe('createScene2DImportFromSwf', () => {
-  it('keeps an advanced blend mode off the node and reports it for a BlendEffect instead', () => {
-    const result = createScene2DImportFromSwf(
-      createSwf([
-        createTag(
-          TAG_PLACE_OBJECT_3,
-          joinBytes(
-            new Uint8Array([PLACE_HAS_NAME | PLACE_HAS_CHARACTER, PLACE3_HAS_BLEND_MODE]),
-            uint16(3),
-            uint16(7),
-            swfString('overlaid'),
-            new Uint8Array([SWF_BLEND_OVERLAY]),
-          ),
-        ),
-        createTag(TAG_SHOW_FRAME),
-        createTag(TAG_END),
-      ]),
+  it('stays silent about a static text body that composes, so the drop entry carries information', () => {
+    const glyphBytes = new Uint8Array([0x30, 0x28, 0x00, 0x00, 0x40, 0x00]);
+    const font = joinBytes(uint16(4), uint16(2), glyphBytes);
+    const record = new BitWriter();
+    record.writeUnsigned(1, 1);
+    record.writeUnsigned(0, 3);
+    record.writeUnsigned(1, 1);
+    record.writeUnsigned(1, 1);
+    record.writeUnsigned(0, 1);
+    record.writeUnsigned(0, 1);
+    const text = joinBytes(
+      uint16(6),
+      createRectangle(0, 1024, 0, 1024),
+      createMatrix(1, 0, 0, 1, 0, 0),
+      new Uint8Array([4, 8]),
+      record.toBytes(),
+      uint16(4),
+      new Uint8Array([0xff, 0x00, 0x00]),
+      uint16(1024),
+      new Uint8Array([1]),
+      packGlyphEntry(0, 600),
+      new Uint8Array([0]),
     );
+    let document: ReturnType<typeof createScene2DFromSwf> = null;
+    const diagnostics = collectImportDiagnostics((sink) => {
+      document = createScene2DFromSwf(
+        createSwf([
+          createTag(TAG_DEFINE_FONT, font),
+          createTag(TAG_DEFINE_TEXT, text),
+          createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(1), uint16(6))),
+          createTag(TAG_SHOW_FRAME),
+          createTag(TAG_END),
+        ]),
+        sink,
+      );
+    });
 
-    const overlaid = result!.document.slots[0].target;
-    // Assigning an advanced mode to the node would render as a silent Normal, which is the whole reason
-    // the two tiers are separate.
-    expect(overlaid.blendMode).toBe(BlendMode.Normal);
-    expect(result!.appearances).toEqual([
-      { advancedBlendMode: AdvancedBlendMode.Overlay, effects: [], frame: 1, node: overlaid },
-    ]);
+    // The silence is only informative if the composition it is silent about actually happened: a run
+    // that composed nothing would be silent for the wrong reason and prove nothing.
+    expect((getNodeChildren(document!.root)[0] as Shape).kind).toBe(ShapeKind);
+    expect(diagnostics.filter((entry) => entry.kind === 'swf.text-shape-uncomposable')).toEqual([]);
   });
 
-  it('does not invent a trailing blend mode from an unknown filter payload', () => {
-    const result = createScene2DImportFromSwf(
-      createSwf([
-        createTag(
-          TAG_PLACE_OBJECT_3,
-          joinBytes(
-            new Uint8Array([PLACE_HAS_NAME | PLACE_HAS_CHARACTER, PLACE3_HAS_FILTER_LIST | PLACE3_HAS_BLEND_MODE]),
-            uint16(3),
-            uint16(7),
-            swfString('unknown-filter'),
-            // Filter 0xfe is variable-width and unknown. Its first payload byte deliberately spells
-            // Overlay; the real blend byte after it spells Multiply. Neither offset is safely reachable.
-            new Uint8Array([1, 0xfe, SWF_BLEND_OVERLAY, SWF_BLEND_MULTIPLY]),
-          ),
-        ),
-        createTag(TAG_SHOW_FRAME),
-        createTag(TAG_END),
-      ]),
+  it('reports an edit text body that does not parse, which otherwise loses the field with no signal', () => {
+    // HasFont is set and the font id and height that must follow it are not there.
+    const field = joinBytes(uint16(12), createRectangle(0, 4000, 0, 800), new Uint8Array([0x80 | 0x01, 0x00]));
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(createSwf([createTag(TAG_DEFINE_EDIT_TEXT, field), createTag(TAG_END)]), sink),
+      ).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.edit-text-unparseable');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.text.define-edit-text', characterId: 12 });
+  });
+
+  it('stays silent about an edit text body that parses, so the drop entry carries information', () => {
+    const field = joinBytes(
+      uint16(12),
+      createRectangle(0, 4000, 0, 800),
+      new Uint8Array([0x80 | 0x40 | 0x20 | 0x04 | 0x01, 0x20 | 0x08]),
+      uint16(7),
+      uint16(240),
+      new Uint8Array([0x11, 0x22, 0x33, 0xff]),
+      new Uint8Array([2]),
+      uint16(20),
+      uint16(40),
+      uint16(60),
+      uint16(80),
+      swfString('varName'),
+      swfString('Hello'),
     );
+    let document: ReturnType<typeof createScene2DFromSwf> = null;
+    const diagnostics = collectImportDiagnostics((sink) => {
+      document = createScene2DFromSwf(
+        createSwf([
+          createTag(TAG_DEFINE_EDIT_TEXT, field),
+          createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(1), uint16(12))),
+          createTag(TAG_SHOW_FRAME),
+          createTag(TAG_END),
+        ]),
+        sink,
+      );
+    });
 
-    const node = result!.document.slots[0].target;
-    expect(node.blendMode).toBe(BlendMode.Normal);
-    expect(result!.appearances).toHaveLength(0);
+    // Non-vacuous: a run that parsed no edit text would be silent for the wrong reason.
+    expect(getNodeChildren(document!.root)).toHaveLength(1);
+    expect(diagnostics.filter((entry) => entry.kind === 'swf.edit-text-unparseable')).toEqual([]);
+  });
+
+  it('reports an ABC blob that yields no frame scripts, naming which of the two DoABC forms it was', () => {
+    // A DoABC payload whose ABC body is not readable. The two tag forms are separate capabilities, so
+    // the entry has to name which one it was or it cannot be joined to either.
+    const named = joinBytes(uint32(0), swfString('frame'), new Uint8Array([0xff, 0xff, 0xff, 0xff]));
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(createSwf([createTag(TAG_DO_ABC, named), createTag(TAG_END)]), sink)).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.abc-frame-scripts-unreadable');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.script.do-abc' });
+  });
+
+  it('names the anonymous DoABC form separately, since the two are different capabilities', () => {
+    const anonymous = new Uint8Array([0xff, 0xff, 0xff, 0xff]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(createSwf([createTag(TAG_DO_ABC_ANONYMOUS, anonymous), createTag(TAG_END)]), sink),
+      ).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.abc-frame-scripts-unreadable');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.script.do-abc-anonymous' });
+  });
+
+  it('reports a declared blend mode left unread behind a filter list that did not finish', () => {
+    // Filter id 0xff has no known payload width, so the list cannot be walked to its end and the blend
+    // byte behind it is unreachable. The placement keeps everything else, which is why this is silent.
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(
+          createSwf([
+            createTag(
+              TAG_PLACE_OBJECT_3,
+              joinBytes(
+                new Uint8Array([PLACE_HAS_NAME | PLACE_HAS_CHARACTER, PLACE3_HAS_FILTER_LIST | PLACE3_HAS_BLEND_MODE]),
+                uint16(3),
+                uint16(7),
+                swfString('filtered'),
+                new Uint8Array([1, 0xff]),
+                new Uint8Array([SWF_BLEND_MULTIPLY]),
+              ),
+            ),
+            createTag(TAG_SHOW_FRAME),
+            createTag(TAG_END),
+          ]),
+          sink,
+        ),
+      ).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.blend-mode-behind-unread-filters');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.placement.blend-mode' });
+  });
+
+  it('stays silent when a declared blend mode is reachable, so the drop entry carries information', () => {
+    let document: ReturnType<typeof createScene2DFromSwf> = null;
+    const diagnostics = collectImportDiagnostics((sink) => {
+      document = createScene2DFromSwf(
+        createSwf([
+          createTag(
+            TAG_PLACE_OBJECT_3,
+            joinBytes(
+              new Uint8Array([PLACE_HAS_NAME | PLACE_HAS_CHARACTER, PLACE3_HAS_BLEND_MODE]),
+              uint16(3),
+              uint16(7),
+              swfString('multiplied'),
+              new Uint8Array([SWF_BLEND_MULTIPLY]),
+            ),
+          ),
+          createTag(TAG_SHOW_FRAME),
+          createTag(TAG_END),
+        ]),
+        sink,
+      );
+    });
+
+    // Non-vacuous: the blend mode was actually read and applied.
+    expect(document!.slots[0].target.blendMode).toBe(BlendMode.Multiply);
+    expect(diagnostics.filter((entry) => entry.kind === 'swf.blend-mode-behind-unread-filters')).toEqual([]);
+  });
+
+  it('counts the children a sprite bounds union could not include, since the box survives smaller', () => {
+    // Character 7 is defined and character 9 is not. The union covers 7 alone, so the sprite's authored
+    // box is real and short — the diminished case a count catches and an existence check cannot.
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(
+          createSwf([
+            createTag(TAG_DEFINE_SHAPE, joinBytes(uint16(7), createRectangle(0, 200, 0, 100))),
+            createTag(
+              TAG_DEFINE_SPRITE,
+              joinBytes(
+                uint16(20),
+                uint16(1),
+                createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(1), uint16(7))),
+                createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(2), uint16(9))),
+                createTag(TAG_SHOW_FRAME),
+                createTag(TAG_END),
+              ),
+            ),
+            createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(1), uint16(20))),
+            createTag(TAG_SHOW_FRAME),
+            createTag(TAG_END),
+          ]),
+          sink,
+        ),
+      ).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.sprite-bounds-short');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail).toEqual({
+      capability: 'swf.timeline.define-sprite',
+      characterId: 20,
+      missingChildren: 1,
+    });
+  });
+
+  it('stays silent when every child of a sprite contributes its bounds', () => {
+    let document: ReturnType<typeof createScene2DFromSwf> = null;
+    const diagnostics = collectImportDiagnostics((sink) => {
+      document = createScene2DFromSwf(
+        createSwf([
+          createTag(TAG_DEFINE_SHAPE, joinBytes(uint16(7), createRectangle(0, 200, 0, 100))),
+          createTag(
+            TAG_DEFINE_SPRITE,
+            joinBytes(
+              uint16(20),
+              uint16(1),
+              createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(1), uint16(7))),
+              createTag(TAG_SHOW_FRAME),
+              createTag(TAG_END),
+            ),
+          ),
+          createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(1), uint16(20))),
+          createTag(TAG_SHOW_FRAME),
+          createTag(TAG_END),
+        ]),
+        sink,
+      );
+    });
+
+    // Non-vacuous: the sprite exists and its union was actually computed.
+    expect(getNodeChildren(document!.root)).toHaveLength(1);
+    expect(diagnostics.filter((entry) => entry.kind === 'swf.sprite-bounds-short')).toEqual([]);
+  });
+
+  it('reports an advanced blend that had no node to carry it, which the appearance report alone holds', () => {
+    // An unnamed placement of a character that was never defined earns no node, so the appearance report
+    // — the only carrier for advanced blends and filter lists — has nothing to attach to.
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(
+          createSwf([
+            createTag(
+              TAG_PLACE_OBJECT_3,
+              joinBytes(
+                new Uint8Array([PLACE_HAS_CHARACTER, PLACE3_HAS_BLEND_MODE]),
+                uint16(1),
+                uint16(7),
+                new Uint8Array([SWF_BLEND_OVERLAY]),
+              ),
+            ),
+            createTag(TAG_SHOW_FRAME),
+            createTag(TAG_END),
+          ]),
+          sink,
+        ),
+      ).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.appearance-without-node');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.placement.blend-mode', frame: 1 });
+  });
+
+  it('stays silent when an advanced blend has a node to carry it, so the drop entry carries information', () => {
+    const diagnostics = collectImportDiagnostics((sink) => {
+      const result = createScene2DImportFromSwf(
+        createSwf([
+          createTag(
+            TAG_PLACE_OBJECT_3,
+            joinBytes(
+              new Uint8Array([PLACE_HAS_NAME | PLACE_HAS_CHARACTER, PLACE3_HAS_BLEND_MODE]),
+              uint16(3),
+              uint16(7),
+              swfString('overlaid'),
+              new Uint8Array([SWF_BLEND_OVERLAY]),
+            ),
+          ),
+          createTag(TAG_SHOW_FRAME),
+          createTag(TAG_END),
+        ]),
+        sink,
+      );
+      // Non-vacuous: the appearance really was recorded against a node.
+      expect(result!.appearances).toHaveLength(1);
+    });
+
+    expect(diagnostics.filter((entry) => entry.kind === 'swf.appearance-without-node')).toEqual([]);
+  });
+
+  it('reports a reused font character id, the one case where the document imports and is simply wrong', () => {
+    // Two DefineFont tags claim id 4. The second replaces the first; the document imports, the font
+    // exists, and it is the wrong font — the substituted case no existence check and no count can see.
+    const glyphBytes = new Uint8Array([0x30, 0x28, 0x00, 0x00, 0x40, 0x00]);
+    const font = joinBytes(uint16(4), uint16(2), glyphBytes);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(
+          createSwf([createTag(TAG_DEFINE_FONT, font), createTag(TAG_DEFINE_FONT, font), createTag(TAG_END)]),
+          sink,
+        ),
+      ).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.font-character-id-reused');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.font.define-font', characterId: 4 });
+  });
+
+  it('stays silent about a font whose character id is used once, so the entry carries information', () => {
+    const glyphBytes = new Uint8Array([0x30, 0x28, 0x00, 0x00, 0x40, 0x00]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(
+          createSwf([
+            createTag(TAG_DEFINE_FONT, joinBytes(uint16(4), uint16(2), glyphBytes)),
+            createTag(TAG_DEFINE_FONT, joinBytes(uint16(5), uint16(2), glyphBytes)),
+            createTag(TAG_END),
+          ]),
+          sink,
+        ),
+      ).not.toBeNull();
+    });
+
+    expect(diagnostics.filter((entry) => entry.kind === 'swf.font-character-id-reused')).toEqual([]);
+  });
+
+  it('reports an edit text whose font id resolves to no name, leaving the field sized but unfamilied', () => {
+    // The field keeps its box, colour and size and simply has no font family. Asserting the box survives
+    // is what makes this the diminished case rather than a missing field.
+    const field = joinBytes(
+      uint16(12),
+      createRectangle(0, 4000, 0, 800),
+      new Uint8Array([0x80 | 0x40 | 0x20 | 0x04 | 0x01, 0x20 | 0x08]),
+      uint16(7),
+      uint16(240),
+      new Uint8Array([0x11, 0x22, 0x33, 0xff]),
+      new Uint8Array([2]),
+      uint16(20),
+      uint16(40),
+      uint16(60),
+      uint16(80),
+      swfString('varName'),
+      swfString('Hello'),
+    );
+    let document: ReturnType<typeof createScene2DFromSwf> = null;
+    const diagnostics = collectImportDiagnostics((sink) => {
+      document = createScene2DFromSwf(
+        createSwf([
+          createTag(TAG_DEFINE_EDIT_TEXT, field),
+          createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(1), uint16(12))),
+          createTag(TAG_SHOW_FRAME),
+          createTag(TAG_END),
+        ]),
+        sink,
+      );
+    });
+
+    expect(getNodeChildren(document!.root)).toHaveLength(1);
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.edit-text-font-name-unresolved');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.text.define-edit-text', fontId: 7 });
+  });
+
+  it('reports a declined frame script through the full import path, not only the reader in isolation', () => {
+    // A fire proof at the reader shows the wire fires; it does not show production reaches the branch.
+    // Family 8 was reachable only by a route other than the one predicted, so this asks the same question
+    // of the frame-script wire by carrying a real DoABC payload through createScene2DFromSwf.
+    const abc = buildFrameScriptAbc(1);
+    const payload = joinBytes(uint32(0), swfString('frame'), abc);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(createSwf([createTag(TAG_DO_ABC, payload), createTag(TAG_END)]), sink),
+      ).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.abc-frame-script-declined');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].detail).toEqual({ frame: 1, reason: 'commands-declined' });
+  });
+
+  it('reports an undecodable morph for DefineMorphShape2, not only the generation the wire was written on', () => {
+    // A wire carrying a version ternary is only proven for the branch a test exercises. This is the same
+    // check already applied to the shape generations, applied to the morph wire.
+    const body = joinBytes(
+      uint16(7),
+      createRectangle(0, 200, 0, 200),
+      createRectangle(0, 400, 0, 400),
+      createRectangle(0, 200, 0, 200),
+      createRectangle(0, 400, 0, 400),
+      new Uint8Array([0]),
+      uint32(0xffff),
+      new Uint8Array([0]),
+    );
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(createSwf([createTag(TAG_DEFINE_MORPH_SHAPE_2, body), createTag(TAG_END)]), sink),
+      ).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.morph-shape-undecodable');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.morph.define-morph-shape-2', characterId: 7 });
+  });
+
+  it('reports an uncomposable body for DefineText2, not only the generation the wire was written on', () => {
+    const record = new BitWriter();
+    record.writeUnsigned(1, 1);
+    record.writeUnsigned(0, 3);
+    record.writeUnsigned(1, 1);
+    record.writeUnsigned(1, 1);
+    record.writeUnsigned(0, 1);
+    record.writeUnsigned(0, 1);
+    const text = joinBytes(
+      uint16(6),
+      createRectangle(0, 1024, 0, 1024),
+      createMatrix(1, 0, 0, 1, 0, 0),
+      new Uint8Array([4, 8]),
+      record.toBytes(),
+    );
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(createSwf([createTag(TAG_DEFINE_TEXT_2, text), createTag(TAG_END)]), sink),
+      ).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.text-shape-uncomposable');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.text.define-text-2', characterId: 6 });
+  });
+
+  it('reports a reused character id for DefineFont2, not only the generation the wire was written on', () => {
+    // A glyph-less DefineFont2 still parses and still claims the id, which is all the duplicate needs.
+    const font2 = joinBytes(uint16(4), new Uint8Array([0, 0, 0]), uint16(0), uint16(0));
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(
+          createSwf([createTag(TAG_DEFINE_FONT_2, font2), createTag(TAG_DEFINE_FONT_2, font2), createTag(TAG_END)]),
+          sink,
+        ),
+      ).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.font-character-id-reused');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.font.define-font-2', characterId: 4 });
+  });
+
+  it('stays silent when an edit text font id does resolve, so the unresolved entry carries information', () => {
+    // Recorded earlier as an absent silence proof: it needs a DefineFont2 that parses, and none existed.
+    // The version-routing work produced one — a glyph-less DefineFont2 parses and carries a name — so the
+    // hole closes. Worth noting the fixture came from unrelated work rather than from trying harder.
+    const font2 = joinBytes(uint16(7), new Uint8Array([0, 0, 5]), swfBytes('Arial'), uint16(0), uint16(0));
+    const field = joinBytes(
+      uint16(12),
+      createRectangle(0, 4000, 0, 800),
+      new Uint8Array([0x80 | 0x40 | 0x20 | 0x04 | 0x01, 0x20 | 0x08]),
+      uint16(7),
+      uint16(240),
+      new Uint8Array([0x11, 0x22, 0x33, 0xff]),
+      new Uint8Array([2]),
+      uint16(20),
+      uint16(40),
+      uint16(60),
+      uint16(80),
+      swfString('varName'),
+      swfString('Hello'),
+    );
+    let document: ReturnType<typeof createScene2DFromSwf> = null;
+    const diagnostics = collectImportDiagnostics((sink) => {
+      document = createScene2DFromSwf(
+        createSwf([
+          createTag(TAG_DEFINE_FONT_2, font2),
+          createTag(TAG_DEFINE_EDIT_TEXT, field),
+          createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(1), uint16(12))),
+          createTag(TAG_SHOW_FRAME),
+          createTag(TAG_END),
+        ]),
+        sink,
+      );
+    });
+
+    // Non-vacuous: the field exists, so the resolver really ran against a font id that resolved.
+    expect(getNodeChildren(document!.root)).toHaveLength(1);
+    expect(diagnostics.filter((entry) => entry.kind === 'swf.edit-text-font-name-unresolved')).toEqual([]);
+  });
+
+  it('stays silent about an anonymous DoABC it does obey, so the drop entry carries information', () => {
+    // An anonymous DoABC carries the raw ABC with no flags-and-name header, so the shared builder is
+    // enough on its own. Recorded earlier as an absent silence proof; the helper closed it.
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(
+        createScene2DFromSwf(
+          createSwf([createTag(TAG_DO_ABC_ANONYMOUS, buildFrameScriptAbc()), createTag(TAG_END)]),
+          sink,
+        ),
+      ).not.toBeNull();
+    });
+
+    expect(diagnostics.filter((entry) => entry.kind === 'swf.abc-frame-scripts-unreadable')).toEqual([]);
+    expect(diagnostics.filter((entry) => entry.kind === 'swf.abc-frame-script-declined')).toEqual([]);
+  });
+
+  it('stays silent about a DefineText2 body that composes, so the drop entry carries information', () => {
+    const glyphBytes = new Uint8Array([0x30, 0x28, 0x00, 0x00, 0x40, 0x00]);
+    const font = joinBytes(uint16(4), uint16(2), glyphBytes);
+    const record = new BitWriter();
+    record.writeUnsigned(1, 1);
+    record.writeUnsigned(0, 3);
+    record.writeUnsigned(1, 1);
+    record.writeUnsigned(1, 1);
+    record.writeUnsigned(0, 1);
+    record.writeUnsigned(0, 1);
+    const text = joinBytes(
+      uint16(6),
+      createRectangle(0, 1024, 0, 1024),
+      createMatrix(1, 0, 0, 1, 0, 0),
+      new Uint8Array([4, 8]),
+      record.toBytes(),
+      uint16(4),
+      // DefineText2 records carry RGBA where DefineText carries RGB — the version difference that makes
+      // this a separate silence proof rather than the same one relabelled.
+      new Uint8Array([0xff, 0x00, 0x00, 0xff]),
+      uint16(1024),
+      new Uint8Array([1]),
+      packGlyphEntry(0, 600),
+      new Uint8Array([0]),
+    );
+    let document: ReturnType<typeof createScene2DFromSwf> = null;
+    const diagnostics = collectImportDiagnostics((sink) => {
+      document = createScene2DFromSwf(
+        createSwf([
+          createTag(TAG_DEFINE_FONT, font),
+          createTag(TAG_DEFINE_TEXT_2, text),
+          createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(1), uint16(6))),
+          createTag(TAG_SHOW_FRAME),
+          createTag(TAG_END),
+        ]),
+        sink,
+      );
+    });
+
+    // Non-vacuous: a run that composed nothing would be silent for the wrong reason.
+    expect((getNodeChildren(document!.root)[0] as Shape).kind).toBe(ShapeKind);
+    expect(diagnostics.filter((entry) => entry.kind === 'swf.text-shape-uncomposable')).toEqual([]);
+  });
+
+  it('reports each whole-document header rejection with its own cause, not one shared null', () => {
+    // Every case below loses the entire document. Before these wires the caller got one null and could
+    // not tell a truncated header from an unregistered decompressor, which IS reported upstream.
+    const kindFor = (file: Uint8Array): readonly string[] =>
+      collectImportDiagnostics((sink) => {
+        expect(createScene2DFromSwf(file, sink)).toBeNull();
+      }).map((entry) => entry.kind);
+
+    // Version 0 is invalid however well-formed the rest is.
+    const zeroVersion = joinBytes(new Uint8Array([0x46, 0x57, 0x53, 0]), uint32(64), createRectangle(0, 10, 0, 10));
+    expect(kindFor(zeroVersion)).toContain('swf.header-fields-invalid');
+
+    // A declared length that passes the minimum, and a stage RECT claiming 31 bits per field with far
+    // too few bytes behind it inside that length.
+    const noStage = joinBytes(new Uint8Array([0x46, 0x57, 0x53, 9]), uint32(12), new Uint8Array([0xf8, 0, 0, 0]));
+    expect(kindFor(noStage)).toContain('swf.stage-bounds-unreadable');
+
+    // A stage RECT that reads, then no frame rate or frame count behind it.
+    const stage = createRectangle(0, 2000, 0, 1000);
+    const noFrameRate = joinBytes(new Uint8Array([0x46, 0x57, 0x53, 9]), uint32(8 + stage.length), stage);
+    expect(kindFor(noFrameRate)).toContain('swf.header-truncated');
+  });
+
+  it('reports a discarded JPEG alpha stream as a Skip, since alpha compositing is not implemented yet', () => {
+    const jpeg3 = createJpegHeader(23, 17);
+    const file = createSwf([
+      createTag(TAG_DEFINE_BITS_JPEG_3, joinBytes(uint16(16), uint32(jpeg3.length), jpeg3, new Uint8Array([1, 2, 3]))),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.jpeg-alpha-stream');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Skip);
+    expect(dropped[0].detail).toEqual({
+      capability: 'swf.bitmap.define-bits-jpeg-3',
+      characterId: 16,
+      discardedBytes: 3,
+    });
+  });
+
+  it('reports a legacy split JPEG with no tables in the file as a Drop', () => {
+    const file = createSwf([
+      createTag(TAG_DEFINE_BITS, joinBytes(uint16(9), new Uint8Array([0xff, 0xd8, 0xff, 0xd9]))),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.jpeg-tables-missing');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.bitmap.define-bits-jpeg-tables', characterId: 9 });
+  });
+
+  it('reports scene names as a Skip, since labels import and the named range has no subject', () => {
+    const file = createSwf([
+      createTag(
+        TAG_DEFINE_SCENE_AND_FRAME_LABEL_DATA,
+        joinBytes(encodedUint32(1), encodedUint32(0), swfString('Scene 1'), encodedUint32(0)),
+      ),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const skipped = diagnostics.filter((entry) => entry.kind === 'swf.scene-names');
+    expect(skipped).toHaveLength(1);
+    expect(skipped[0].severity).toBe(ImportDiagnosticSeverity.Skip);
+    expect(skipped[0].detail).toEqual({
+      capability: 'swf.timeline.define-scene-and-frame-label-data',
+      sceneCount: 1,
+    });
+  });
+
+  it('reports a frame script declined for carrying more than playback commands', () => {
+    // 0x96 push, then a non-playback action: the block is declined WHOLE, because honouring the legible
+    // half would misrepresent the frame. The crumb is what tells a caller the frame had a script at all.
+    const file = createSwf([
+      createTag(TAG_DO_ACTION, new Uint8Array([0x96, 0x02, 0x00, 0x08, 0x00, 0x3d, 0x00])),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const skipped = diagnostics.filter((entry) => entry.kind === 'swf.frame-script-declined');
+    expect(skipped).toHaveLength(1);
+    expect(skipped[0].severity).toBe(ImportDiagnosticSeverity.Skip);
+    expect(skipped[0].detail).toEqual({ capability: 'swf.script.do-action', frame: 1 });
+  });
+
+  it('reports an init action declined the same way DoAction is, which it silently did not', () => {
+    // The identical decline four lines above the DoAction case reported nothing. Found by the silent-drop
+    // shape sweep, not by reading — three passes over this file read both branches and saw no asymmetry.
+    const file = createSwf([
+      createTag(TAG_DO_INIT_ACTION, joinBytes(uint16(20), new Uint8Array([0x96, 0x02, 0x00, 0x08, 0x00, 0x3d, 0x00]))),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const skipped = diagnostics.filter((entry) => entry.kind === 'swf.frame-script-declined');
+    expect(skipped).toHaveLength(1);
+    expect(skipped[0].severity).toBe(ImportDiagnosticSeverity.Skip);
+    expect(skipped[0].detail).toEqual({ capability: 'swf.script.do-init-action', characterId: 20 });
+  });
+
+  it('stays silent about an init action it does obey, so the skip entry carries information', () => {
+    const file = createSwf([
+      createTag(TAG_DO_INIT_ACTION, joinBytes(uint16(20), new Uint8Array([0x07, 0x00]))),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    expect(diagnostics.filter((entry) => entry.kind === 'swf.frame-script-declined')).toEqual([]);
+  });
+
+  it('reports nested masks collapsing, since the outer one is not applied at all', () => {
+    // Two clip depths covering one instance: Flight carries one clip per node, so the outer mask is
+    // simply not applied and the instance shows more than the file said. The crumb is the only signal.
+    const file = createSwf([
+      createTag(
+        TAG_PLACE_OBJECT_2,
+        joinBytes(new Uint8Array([PLACE_HAS_CLIP_DEPTH | PLACE_HAS_CHARACTER]), uint16(1), uint16(1), uint16(9)),
+      ),
+      createTag(
+        TAG_PLACE_OBJECT_2,
+        joinBytes(new Uint8Array([PLACE_HAS_CLIP_DEPTH | PLACE_HAS_CHARACTER]), uint16(2), uint16(2), uint16(9)),
+      ),
+      createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(3), uint16(3))),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      createScene2DFromSwf(file, sink);
+    });
+
+    const collapsed = diagnostics.filter((entry) => entry.kind === 'swf.nested-mask-collapsed');
+    expect(collapsed.length).toBeGreaterThan(0);
+    expect(collapsed[0].severity).toBe(ImportDiagnosticSeverity.Skip);
+    expect(collapsed[0].detail?.capability).toBe('swf.placement.clip-depth');
+    expect(collapsed[0].detail?.covering).toBe(2);
+
+    // The masks name characters with no decoded geometry, so the same fixture exercises clip-depth's
+    // other loss path. Both paths must be proven for the capability to count as instrumented.
+    const unmasked = diagnostics.filter((entry) => entry.kind === 'swf.mask-without-geometry');
+    expect(unmasked.length).toBeGreaterThan(0);
+    expect(unmasked[0].severity).toBe(ImportDiagnosticSeverity.Recover);
+    expect(unmasked[0].detail?.capability).toBe('swf.placement.clip-depth');
+  });
+
+  it('reports a button interaction state other than up, which a still scene does not hold', () => {
+    const file = createSwf([
+      createTag(
+        TAG_DEFINE_BUTTON_2,
+        joinBytes(
+          uint16(12),
+          new Uint8Array([0, 0, 0]),
+          new Uint8Array([0x02]),
+          uint16(7),
+          uint16(1),
+          createRectangle(0, 0, 0, 0),
+          new Uint8Array([0, 0]),
+        ),
+      ),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const skipped = diagnostics.filter((entry) => entry.kind === 'swf.button-interaction-state');
+    expect(skipped.length).toBeGreaterThan(0);
+    expect(skipped[0].severity).toBe(ImportDiagnosticSeverity.Skip);
+    // The PAYLOAD, not just the trigger: a crumb that fires correctly while recording something false
+    // is a clean positive that is not one. The fixture's non-up record names character 7 with state
+    // flags 0x02, and the crumb must say so rather than merely existing.
+    expect(skipped[0].detail).toEqual({ characterId: 7, flags: 0x02 });
+  });
+
+  it('reports a legacy split JPEG whose halves will not splice into a readable image', () => {
+    const file = createSwf([
+      createTag(TAG_JPEG_TABLES, new Uint8Array([0xff, 0xd8, 0xff, 0xd9])),
+      createTag(TAG_DEFINE_BITS, joinBytes(uint16(9), new Uint8Array([0x01, 0x02, 0x03, 0x04]))),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.jpeg-tables-unsplittable');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.bitmap.define-bits-jpeg-tables', characterId: 9 });
+  });
+
+  it('reports a font whose glyph table does not decode, which costs the whole font not one glyph', () => {
+    // Found by auditing my own trustworthy-silence claim rather than by a failing test: a font that
+    // vanishes entirely and a font that imports cleanly both produced no crumb before this.
+    const file = createSwf([
+      createTag(TAG_DEFINE_FONT_2, joinBytes(uint16(4), new Uint8Array([0xff, 0xff, 0xff, 0xff]))),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.font-glyph-table');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.font.define-font-2', characterId: 4 });
+  });
+
+  it('reports a non-MP3 sound stream, whose blocks do not concatenate', () => {
+    // Stream format 1 (ADPCM) in the high nibble of the stream flags, with a non-zero samples-per-frame
+    // so the header actually starts a stream. Only MP3 blocks concatenate, so the rest are a real loss.
+    const file = createSwf([
+      createTag(18, joinBytes(new Uint8Array([0, 1 << 4]), uint16(1152))),
+      createTag(19, new Uint8Array([1, 2, 3, 4])),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const skipped = diagnostics.filter((entry) => entry.kind === 'swf.stream-sound-format');
+    expect(skipped).toHaveLength(1);
+    expect(skipped[0].severity).toBe(ImportDiagnosticSeverity.Skip);
+    expect(skipped[0].detail).toEqual({ capability: 'swf.axis.sound-format-non-mp3', format: 1 });
+  });
+
+  it('reports one glyph whose outline does not decode, which costs that glyph and not the font', () => {
+    // Two glyphs: the first is a real square, the second is a body the shape reader cannot read. The
+    // font still imports — that is the point of the Drop rather than a whole-font failure.
+    const glyph = new ShapeWriter();
+    glyph.writeStyleBits(1, 0);
+    glyph.writeStyleChange({ fill1: 1, moveToX: 0, moveToY: 0 });
+    glyph.writeStraightEdge(256, 0);
+    glyph.writeStraightEdge(0, 256);
+    glyph.writeStraightEdge(-256, 0);
+    glyph.writeStraightEdge(0, -256);
+    glyph.writeEndShape();
+    const good = glyph.toBytes();
+    const bad = new Uint8Array([0xff]);
+    const offsets = joinBytes(uint16(6), uint16(6 + good.length), uint16(6 + good.length + bad.length));
+    const file = createSwf([
+      createTag(
+        TAG_DEFINE_FONT_2,
+        joinBytes(uint16(4), new Uint8Array([0, 0, 0]), uint16(2), offsets, good, bad, new Uint8Array([0x41, 0x42])),
+      ),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.font-glyph-outline');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail?.capability).toBe('swf.font.define-font-2');
+    expect(dropped[0].detail?.lostGlyphs).toBe(1);
+  });
+
+  it('stays silent about a shape, a video stream and a scene table that lose nothing', () => {
+    // A SILENCE PROOF IS VACUOUS UNLESS THE CAPABILITY WAS ACTUALLY EXERCISED — silence because the
+    // feature was absent proves nothing about the wire. So each assertion below is paired with a positive
+    // check that the construct really was imported.
+    const writer = new ShapeWriter();
+    writer.writeSolidFillStyles([0x3366cc]);
+    writer.writeLineStyleCount(0);
+    writer.writeStyleBits(1, 0);
+    writer.writeStyleChange({ fill1: 1, moveToX: 0, moveToY: 0 });
+    writer.writeStraightEdge(400, 0);
+    writer.writeStraightEdge(0, 400);
+    writer.writeStraightEdge(-400, 0);
+    writer.writeStraightEdge(0, -400);
+    writer.writeEndShape();
+
+    const file = createSwf([
+      createTag(TAG_DEFINE_SHAPE, joinBytes(uint16(7), createRectangle(0, 400, 0, 400), writer.toBytes())),
+      createTag(
+        TAG_DEFINE_VIDEO_STREAM,
+        joinBytes(uint16(4), uint16(1), uint16(16), uint16(16), new Uint8Array([0x01, 2])),
+      ),
+      // A scene table with zero scenes still carries its label, so the tag is exercised and loses nothing.
+      createTag(
+        TAG_DEFINE_SCENE_AND_FRAME_LABEL_DATA,
+        joinBytes(encodedUint32(0), encodedUint32(1), encodedUint32(0), swfString('start')),
+      ),
+      createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(1), uint16(7))),
+      createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(2), uint16(4))),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+
+    const diagnostics = collectImportDiagnostics((sink) => {
+      const document = createScene2DFromSwf(file, sink);
+      // The capabilities really were exercised: the shape drew, the video character materialized, and
+      // the label survived.
+      const children = getNodeChildren(document?.root as Node2D);
+      expect(children.length).toBe(2);
+      expect(getMovieClipCurrentLabel(document?.root as MovieClip)?.name).toBe('start');
+    });
+
+    const kinds = diagnostics.map((entry) => entry.kind);
+    expect(kinds).not.toContain('swf.shape-body-unreadable');
+    expect(kinds).not.toContain('swf.video-frame-payload');
+    expect(kinds).not.toContain('swf.scene-names');
+  });
+
+  it('stays silent about a frame script and a mask that lose nothing', () => {
+    const mask = new ShapeWriter();
+    mask.writeSolidFillStyles([0xffffff]);
+    mask.writeLineStyleCount(0);
+    mask.writeStyleBits(1, 0);
+    mask.writeStyleChange({ fill1: 1, moveToX: 0, moveToY: 0 });
+    mask.writeStraightEdge(200, 0);
+    mask.writeStraightEdge(0, 200);
+    mask.writeStraightEdge(-200, 0);
+    mask.writeStraightEdge(0, -200);
+    mask.writeEndShape();
+
+    const file = createSwf([
+      createTag(TAG_DEFINE_SHAPE, joinBytes(uint16(5), createRectangle(0, 200, 0, 200), mask.toBytes())),
+      // One mask with real geometry over one instance: clip-depth is exercised and neither of its two
+      // loss paths applies.
+      createTag(
+        TAG_PLACE_OBJECT_2,
+        joinBytes(new Uint8Array([PLACE_HAS_CLIP_DEPTH | PLACE_HAS_CHARACTER]), uint16(1), uint16(5), uint16(3)),
+      ),
+      createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(2), uint16(5))),
+      // A block that is ONLY playback commands is recognized whole, so nothing is declined.
+      createTag(TAG_DO_ACTION, new Uint8Array([0x07, 0x00])),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+
+    const diagnostics = collectImportDiagnostics((sink) => {
+      const document = createScene2DFromSwf(file, sink);
+      expect(getMovieClipFrameScript(document?.root as MovieClip, 1)).not.toBeNull();
+    });
+
+    const kinds = diagnostics.map((entry) => entry.kind);
+    expect(kinds).not.toContain('swf.frame-script-declined');
+    expect(kinds).not.toContain('swf.mask-without-geometry');
+    expect(kinds).not.toContain('swf.nested-mask-collapsed');
+  });
+
+  it('stays silent about a font, a spliced JPEG and a JPEG3 that lose nothing', () => {
+    // The three capabilities that fire on the corpus without a silence proof yet. Each assertion is
+    // paired with a positive check, so silence cannot come from the construct simply being absent.
+    const glyph = new ShapeWriter();
+    glyph.writeStyleBits(1, 0);
+    glyph.writeStyleChange({ fill1: 1, moveToX: 0, moveToY: 0 });
+    glyph.writeStraightEdge(256, 0);
+    glyph.writeStraightEdge(0, 256);
+    glyph.writeStraightEdge(-256, 0);
+    glyph.writeStraightEdge(0, -256);
+    glyph.writeEndShape();
+    const glyphBytes = glyph.toBytes();
+    const tables = new Uint8Array([0xff, 0xd8, 0xff, 0xdb, 0x00, 0x04, 0x11, 0x22, 0xff, 0xd9]);
+    const jpeg3 = createJpegHeader(23, 17);
+
+    const file = createSwf([
+      createTag(
+        TAG_DEFINE_FONT_2,
+        joinBytes(
+          uint16(4),
+          new Uint8Array([0, 0, 0]),
+          uint16(1),
+          joinBytes(uint16(4), uint16(4 + glyphBytes.length)),
+          glyphBytes,
+          new Uint8Array([0x41]),
+        ),
+      ),
+      createTag(TAG_JPEG_TABLES, tables),
+      createTag(TAG_DEFINE_BITS, joinBytes(uint16(9), createJpegHeader(11, 13))),
+      // alphaDataOffset equal to the payload length: the colour stream is the whole body, so there is
+      // no alpha block to discard and nothing is lost.
+      createTag(TAG_DEFINE_BITS_JPEG_3, joinBytes(uint16(16), uint32(jpeg3.length), jpeg3)),
+      // Placed, because an image earns a resource only when something samples it — without these the
+      // silence below would be silence about constructs that never entered the document.
+      createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(1), uint16(9))),
+      createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(2), uint16(16))),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+
+    const diagnostics = collectImportDiagnostics((sink) => {
+      const document = createScene2DFromSwf(file, sink);
+      // All three constructs really imported: two image resources plus a recoverable font.
+      expect(document?.imageResources.length).toBe(2);
+      expect(createGlyphOutlineSourcesFromSwf(file)?.size).toBe(1);
+    });
+
+    const kinds = diagnostics.map((entry) => entry.kind);
+    expect(kinds).not.toContain('swf.font-glyph-table');
+    expect(kinds).not.toContain('swf.font-glyph-outline');
+    expect(kinds).not.toContain('swf.jpeg-tables-missing');
+    expect(kinds).not.toContain('swf.jpeg-tables-unsplittable');
+    expect(kinds).not.toContain('swf.jpeg-alpha-stream');
+  });
+
+  it('stays silent about an MP3 stream, whose blocks do concatenate', () => {
+    // The last capability without a silence proof, and the only one that never fires on the sampled
+    // corpus — so it is last by the ordering rather than unimportant. Format 2 is MP3 in the high nibble.
+    const file = createSwf([
+      createTag(18, joinBytes(new Uint8Array([0, 2 << 4]), uint16(1152))),
+      createTag(19, joinBytes(uint16(1), uint16(0), new Uint8Array([0xff, 0xfb, 0x90, 0x00]))),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+
+    const diagnostics = collectImportDiagnostics((sink) => {
+      const document = createScene2DFromSwf(file, sink);
+      // The stream really was carried: an MP3 head plus a block produces an audio resource.
+      expect(document?.audioResources.length).toBe(1);
+    });
+
+    expect(diagnostics.map((entry) => entry.kind)).not.toContain('swf.stream-sound-format');
+  });
+
+  it('reports a label naming a frame the timeline never reaches, and stays silent when it does', () => {
+    // The second way DefineSceneAndFrameLabelData loses data, found by auditing the CLAIM rather than
+    // the wire: swf.scene-names covered the scene table only, while an out-of-range label was filtered
+    // out silently and the capability still claimed trustworthy silence.
+    const past = createSwf([
+      createTag(
+        TAG_DEFINE_SCENE_AND_FRAME_LABEL_DATA,
+        joinBytes(encodedUint32(0), encodedUint32(1), encodedUint32(40), swfString('never')),
+      ),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const dropped = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(past, sink)).not.toBeNull();
+    }).filter((entry) => entry.kind === 'swf.label-past-last-frame');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].severity).toBe(ImportDiagnosticSeverity.Drop);
+    expect(dropped[0].detail).toEqual({ capability: 'swf.timeline.frame-label', dropped: 1, frames: 1 });
+
+    // A label the timeline does reach loses nothing, so no crumb — and it really did import.
+    const reached = createSwf([
+      createTag(
+        TAG_DEFINE_SCENE_AND_FRAME_LABEL_DATA,
+        joinBytes(encodedUint32(0), encodedUint32(1), encodedUint32(0), swfString('start')),
+      ),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const quiet = collectImportDiagnostics((sink) => {
+      const document = createScene2DFromSwf(reached, sink);
+      expect(getMovieClipCurrentLabel(document?.root as MovieClip)?.name).toBe('start');
+    });
+    expect(quiet.map((entry) => entry.kind)).not.toContain('swf.label-past-last-frame');
+  });
+
+  it('reports an unreadable body for every shape generation, not just the one the wire was written on', () => {
+    // PROPERTY 4 APPLIED TO THE PROOF MAPPING: the shape wire was proven on DefineShape alone while the
+    // mapping claimed all four generations. The code path is shared and parameterised by version, so what
+    // was untested was the ROUTING — that each tag reaches it and reports its own capability id.
+    const file = createSwf([
+      createTag(TAG_DEFINE_SHAPE_2, joinBytes(uint16(2), createRectangle(0, 20, 0, 20), new Uint8Array([0xff]))),
+      createTag(TAG_DEFINE_SHAPE_3, joinBytes(uint16(3), createRectangle(0, 20, 0, 20), new Uint8Array([0xff]))),
+      createTag(
+        TAG_DEFINE_SHAPE_4,
+        joinBytes(uint16(4), createRectangle(0, 20, 0, 20), createRectangle(0, 20, 0, 20), new Uint8Array([0, 0xff])),
+      ),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const capabilities = diagnostics
+      .filter((entry) => entry.kind === 'swf.shape-body-unreadable')
+      .map((entry) => entry.detail?.capability);
+    expect(capabilities).toEqual(['swf.shape.define-shape-2', 'swf.shape.define-shape-3', 'swf.shape.define-shape-4']);
+  });
+
+  it('reports an unreadable glyph table for DefineFont and DefineFont3, not only DefineFont2', () => {
+    const file = createSwf([
+      createTag(TAG_DEFINE_FONT, joinBytes(uint16(6), new Uint8Array([0xff, 0xff]))),
+      createTag(TAG_DEFINE_FONT_3, joinBytes(uint16(7), new Uint8Array([0xff, 0xff, 0xff, 0xff]))),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const capabilities = diagnostics
+      .filter((entry) => entry.kind === 'swf.font-glyph-table')
+      .map((entry) => entry.detail?.capability);
+    expect(capabilities).toEqual(['swf.font.define-font', 'swf.font.define-font-3']);
+  });
+
+  it('reports a discarded alpha stream for DefineBitsJPEG4, whose header differs from JPEG3', () => {
+    const jpeg4 = createJpegHeader(31, 19);
+    const file = createSwf([
+      // JPEG4 carries a deblocking uint16 between the offset and the payload, so its routing is a
+      // genuinely different path from JPEG3's and needs its own proof.
+      createTag(
+        TAG_DEFINE_BITS_JPEG_4,
+        joinBytes(uint16(17), uint32(jpeg4.length + 2), uint16(0), jpeg4, new Uint8Array([4, 5, 6])),
+      ),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DFromSwf(file, sink)).not.toBeNull();
+    });
+
+    const dropped = diagnostics.filter((entry) => entry.kind === 'swf.jpeg-alpha-stream');
+    expect(dropped).toHaveLength(1);
+    expect(dropped[0].detail).toEqual({
+      capability: 'swf.bitmap.define-bits-jpeg-4',
+      characterId: 17,
+      discardedBytes: 3,
+    });
+  });
+
+  it('names the symbol a caller asked for that the file does not export', () => {
+    const file = createSwf([createTag(TAG_SHOW_FRAME), createTag(TAG_END)]);
+    const diagnostics = collectImportDiagnostics((sink) => {
+      expect(createScene2DSymbolFromSwf(file, 'absent', sink)).toBeNull();
+    });
+
+    expect(diagnostics.map((entry) => entry.kind)).toEqual(['swf.unknown-linkage-name']);
+    expect(diagnostics[0].detail).toEqual({ linkageName: 'absent' });
+  });
+});
+
+describe('createScene2DFromSwf morph bounds', () => {
+  it('reports the box the morph occupies at its ratio, not the union of both endpoints', () => {
+    const startEdges = morphBox(200);
+    const endEdges = morphBox(400);
+    const styles = joinBytes(
+      new Uint8Array([1, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff]),
+      new Uint8Array([0]),
+    );
+    const body = joinBytes(
+      uint16(7),
+      createRectangle(0, 200, 0, 200),
+      createRectangle(0, 400, 0, 400),
+      uint32(styles.length + startEdges.length),
+      styles,
+      startEdges,
+      endEdges,
+    );
+    const place = (depth: number, ratio: number): Uint8Array =>
+      createTag(
+        TAG_PLACE_OBJECT_2,
+        joinBytes(new Uint8Array([PLACE_HAS_CHARACTER | PLACE_HAS_RATIO]), uint16(depth), uint16(7), uint16(ratio)),
+      );
+
+    const document = createScene2DFromSwf(
+      createSwf([
+        createTag(TAG_DEFINE_MORPH_SHAPE, body),
+        place(1, 0),
+        place(2, 0x7fff),
+        place(3, 0xffff),
+        createTag(TAG_SHOW_FRAME),
+        createTag(TAG_END),
+      ]),
+    );
+
+    // The union would report 20 for all three. Each instance reports the box it is actually at, which is
+    // what layout and hit testing read.
+    const boxes = getNodeChildren(document!.root).map((node) => getNodeLocalBoundsRectangle(node).width);
+    expect(boxes[0]).toBeCloseTo(10);
+    expect(boxes[1]).toBeCloseTo(15, 1);
+    expect(boxes[2]).toBeCloseTo(20);
+  });
+});
+
+describe('createScene2DFromSwf morph shapes', () => {
+  it('places a morph character and drives its progress from the placement ratio', () => {
+    const startEdges = morphBox(200);
+    const endEdges = morphBox(400);
+    const styles = joinBytes(
+      new Uint8Array([1, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff]),
+      new Uint8Array([0]),
+    );
+    const body = joinBytes(
+      uint16(7),
+      createRectangle(0, 200, 0, 200),
+      createRectangle(0, 400, 0, 400),
+      uint32(styles.length + startEdges.length),
+      styles,
+      startEdges,
+      endEdges,
+    );
+
+    const document = createScene2DFromSwf(
+      createSwf([
+        createTag(TAG_DEFINE_MORPH_SHAPE, body),
+        // Two placements of one character at different ratios: the case a single shared node cannot serve.
+        createTag(
+          TAG_PLACE_OBJECT_2,
+          joinBytes(new Uint8Array([PLACE_HAS_CHARACTER | PLACE_HAS_RATIO]), uint16(1), uint16(7), uint16(0)),
+        ),
+        createTag(
+          TAG_PLACE_OBJECT_2,
+          joinBytes(new Uint8Array([PLACE_HAS_CHARACTER | PLACE_HAS_RATIO]), uint16(2), uint16(7), uint16(0xffff)),
+        ),
+        createTag(TAG_SHOW_FRAME),
+        createTag(TAG_END),
+      ]),
+    );
+
+    const [first, second] = getNodeChildren(document!.root) as MorphShape[];
+    expect(first.kind).toBe(MorphShapeKind);
+    expect(second.kind).toBe(MorphShapeKind);
+    // Distinct nodes, each sitting at its own point along the same definition.
+    expect(first).not.toBe(second);
+    expect(first.data.progress).toBe(0);
+    expect(second.data.progress).toBe(1);
+    expect(morphWidth(first)).toBeCloseTo(10);
+    expect(morphWidth(second)).toBeCloseTo(20);
+  });
+});
+
+describe('createScene2DImportFromSwf', () => {
+  it('retains exact zero-copy JPEG3 and JPEG4 colour and alpha ranges on the full import report', () => {
+    const jpeg3 = createJpegHeader(23, 17);
+    const alpha3 = new Uint8Array([0x78, 0x01, 0x31, 0x32, 0x33]);
+    const jpeg4 = createJpegHeader(31, 19);
+    const alpha4 = new Uint8Array([0x78, 0x01, 0x41, 0x42, 0x43]);
+    const deblockingParameterRaw = 0x81fe;
+    const file = createSwf([
+      createTag(TAG_DEFINE_BITS_JPEG_3, joinBytes(uint16(16), uint32(jpeg3.length), jpeg3, alpha3)),
+      createTag(
+        TAG_DEFINE_BITS_JPEG_4,
+        joinBytes(uint16(17), uint32(jpeg4.length + 2), uint16(deblockingParameterRaw), jpeg4, alpha4),
+      ),
+      // Only JPEG3 is placed. JPEG4 still belongs on the full report, but not in document resources.
+      createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(1), uint16(16))),
+      createTag(TAG_SHOW_FRAME),
+      createTag(TAG_END),
+    ]);
+
+    const result = createScene2DImportFromSwf(file)!;
+
+    expect(result.jpegAlphaPayloads).toHaveLength(2);
+    const [jpeg3Payload, jpeg4Payload] = result.jpegAlphaPayloads;
+    expect(jpeg3Payload).toMatchObject({
+      characterId: 16,
+      deblockingParameterRaw: null,
+      height: 17,
+      width: 23,
+    });
+    expect(jpeg4Payload).toMatchObject({
+      characterId: 17,
+      deblockingParameterRaw,
+      height: 19,
+      width: 31,
+    });
+    expect(jpeg3Payload.reference).toBe(result.document.imageResources[0]);
+    expect(jpeg4Payload.reference.textures).toEqual([]);
+
+    for (const [actual, expected] of [
+      [jpeg3Payload.reference.bytes, jpeg3],
+      [jpeg3Payload.compressedAlphaBytes, alpha3],
+      [jpeg4Payload.reference.bytes, jpeg4],
+      [jpeg4Payload.compressedAlphaBytes, alpha4],
+    ] as const) {
+      expect(actual).toEqual(expected);
+      expect(actual.buffer).toBe(file.buffer);
+      expect(actual.byteOffset).toBe(file.byteOffset + findBytes(file, expected));
+    }
+  });
+
+  it('rejects JPEG alpha offsets outside the tag colour range', () => {
+    const jpeg3 = createJpegHeader(23, 17);
+    const jpeg4 = createJpegHeader(31, 19);
+    const result = createScene2DImportFromSwf(
+      createSwf([
+        // JPEG3 points beyond the tag; JPEG4 points into its own two-byte deblocking field.
+        createTag(TAG_DEFINE_BITS_JPEG_3, joinBytes(uint16(16), uint32(jpeg3.length + 1), jpeg3)),
+        createTag(TAG_DEFINE_BITS_JPEG_4, joinBytes(uint16(17), uint32(1), uint16(0x1234), jpeg4)),
+        createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(1), uint16(16))),
+        createTag(TAG_PLACE_OBJECT_2, joinBytes(new Uint8Array([PLACE_HAS_CHARACTER]), uint16(2), uint16(17))),
+        createTag(TAG_SHOW_FRAME),
+        createTag(TAG_END),
+      ]),
+    );
+
+    expect(result).not.toBeNull();
+    expect(result!.jpegAlphaPayloads).toEqual([]);
+    expect(result!.document.imageResources).toEqual([]);
+  });
+
+  it('keeps an advanced blend mode off the node and reports it for a BlendEffect instead', () => {
+    const result = createScene2DImportFromSwf(
+      createSwf([
+        createTag(
+          TAG_PLACE_OBJECT_3,
+          joinBytes(
+            new Uint8Array([PLACE_HAS_NAME | PLACE_HAS_CHARACTER, PLACE3_HAS_BLEND_MODE]),
+            uint16(3),
+            uint16(7),
+            swfString('overlaid'),
+            new Uint8Array([SWF_BLEND_OVERLAY]),
+          ),
+        ),
+        createTag(TAG_SHOW_FRAME),
+        createTag(TAG_END),
+      ]),
+    );
+
+    const overlaid = result!.document.slots[0].target;
+    // Assigning an advanced mode to the node would render as a silent Normal, which is the whole reason
+    // the two tiers are separate.
+    expect(overlaid.blendMode).toBe(BlendMode.Normal);
+    expect(result!.appearances).toEqual([
+      { advancedBlendMode: AdvancedBlendMode.Overlay, effects: [], frame: 1, node: overlaid },
+    ]);
+  });
+
+  it('does not invent a trailing blend mode from an unknown filter payload', () => {
+    const result = createScene2DImportFromSwf(
+      createSwf([
+        createTag(
+          TAG_PLACE_OBJECT_3,
+          joinBytes(
+            new Uint8Array([PLACE_HAS_NAME | PLACE_HAS_CHARACTER, PLACE3_HAS_FILTER_LIST | PLACE3_HAS_BLEND_MODE]),
+            uint16(3),
+            uint16(7),
+            swfString('unknown-filter'),
+            // Filter 0xfe is variable-width and unknown. Its first payload byte deliberately spells
+            // Overlay; the real blend byte after it spells Multiply. Neither offset is safely reachable.
+            new Uint8Array([1, 0xfe, SWF_BLEND_OVERLAY, SWF_BLEND_MULTIPLY]),
+          ),
+        ),
+        createTag(TAG_SHOW_FRAME),
+        createTag(TAG_END),
+      ]),
+    );
+
+    const node = result!.document.slots[0].target;
+    expect(node.blendMode).toBe(BlendMode.Normal);
+    expect(result!.appearances).toHaveLength(0);
   });
 
   it('reports a placement filter list as effect descriptors and attaches nothing', () => {
@@ -2719,8 +4178,7 @@ describe('createScene2DSymbolFromSwf', () => {
     expect(symbol.slots[0].target).toBe(getNodeChildren(symbol.root)[0]);
   });
 
-  it('resolves the pixels of a bitmap the symbol draws, the way a placed one does', () => {
-    registerDeflateDecompressor();
+  it('carries a lossless bitmap reference the symbol resource pass can resolve', async () => {
     const art = new ShapeWriter();
     art.writeFillStyleCount(1);
     art.writeBitmapFillStyle(0x41, 9, 20);
@@ -2744,11 +4202,17 @@ describe('createScene2DSymbolFromSwf', () => {
       ]),
       'Art',
     );
-    unregisterDecompressor(Compression.Deflate);
-
     const drawn = symbol!.root as Shape;
     expect(drawn.data.commands[0]).toBe('beginTextureFill');
-    expectLosslessTexturePixel(drawn.data.commands[2] as Texture2D);
+    const texture = drawn.data.commands[2] as Texture2D;
+    expect(getTextureSource(texture)).toBeNull();
+    expect(symbol!.imageResources).toHaveLength(1);
+
+    registerDeflateDecompressor();
+    registerSwfImageDecoders();
+    await loadScene2DImageResources(symbol!);
+
+    expectLosslessTexturePixel(texture);
   });
 
   it('hands an encoded bitmap out on the image-resource contract, naming the waiting texture', () => {
@@ -3032,6 +4496,20 @@ function joinBytes(...parts: ReadonlyArray<Uint8Array>): Uint8Array {
   return result;
 }
 
+function findBytes(source: Uint8Array, expected: Uint8Array): number {
+  for (let offset = 0; offset <= source.length - expected.length; offset++) {
+    let matches = true;
+    for (let index = 0; index < expected.length; index++) {
+      if (source[offset + index] !== expected[index]) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) return offset;
+  }
+  throw new Error('Expected byte range was not found');
+}
+
 function signedBitCount(values: ReadonlyArray<number>): number {
   for (let bits = 1; bits < 32; bits++) {
     const minimum = -(2 ** (bits - 1));
@@ -3041,6 +4519,10 @@ function signedBitCount(values: ReadonlyArray<number>): number {
   return 32;
 }
 
+function swfBytes(value: string): Uint8Array {
+  return new TextEncoder().encode(value);
+}
+
 function swfString(value: string): Uint8Array {
   return joinBytes(_encoder.encode(value), new Uint8Array([0]));
 }
@@ -3095,15 +4577,23 @@ const TAG_DEFINE_BITS = 6;
 const TAG_DEFINE_BUTTON_2 = 34;
 const TAG_DEFINE_EDIT_TEXT = 37;
 const TAG_DEFINE_FONT = 10;
+const TAG_DEFINE_MORPH_SHAPE_2 = 84;
+const TAG_DEFINE_TEXT_2 = 33;
 const TAG_DEFINE_FONT_2 = 48;
+const TAG_DEFINE_FONT_3 = 75;
 const TAG_DEFINE_FONT_INFO = 13;
 const TAG_DEFINE_SHAPE = 2;
+const TAG_DEFINE_SHAPE_2 = 22;
 const TAG_DEFINE_SHAPE_3 = 32;
+const TAG_DEFINE_SHAPE_4 = 83;
 const TAG_DEFINE_SPRITE = 39;
 const TAG_DEFINE_TEXT = 11;
 const TAG_DEFINE_VIDEO_STREAM = 60;
 const TAG_VIDEO_FRAME = 61;
+const TAG_DO_ABC = 82;
+const TAG_DO_ABC_ANONYMOUS = 72;
 const TAG_DO_ACTION = 12;
+const TAG_DO_INIT_ACTION = 59;
 const TAG_EXPORT_ASSETS = 56;
 const TAG_FILE_ATTRIBUTES = 69;
 const TAG_JPEG_TABLES = 8;
@@ -3127,7 +4617,31 @@ function losslessPayload(format: number, width: number, height: number, pixels:
 // decompressor rather than a stub.
 function storedDeflate(bytes: readonly number[]): number[] {
   const length = bytes.length;
-  return [0x78, 0x01, 0x01, length & 0xff, length >> 8, ~length & 0xff, (~length >> 8) & 0xff, ...bytes, 0, 0, 0, 0];
+  const adler = testAdler32(bytes);
+  return [
+    0x78,
+    0x01,
+    0x01,
+    length & 0xff,
+    length >> 8,
+    ~length & 0xff,
+    (~length >> 8) & 0xff,
+    ...bytes,
+    adler >>> 24,
+    (adler >>> 16) & 0xff,
+    (adler >>> 8) & 0xff,
+    adler & 0xff,
+  ];
+}
+
+function testAdler32(bytes: readonly number[]): number {
+  let first = 1;
+  let second = 0;
+  for (const byte of bytes) {
+    first = (first + byte) % 65_521;
+    second = (second + first) % 65_521;
+  }
+  return ((second << 16) | first) >>> 0;
 }
 
 // One closed box `width` twips across under fill style 1, as a morph endpoint's bare SHAPE.