@flighthq/vite-plugin-manifest 0.5.1-edge.1685.dc0e23a

package/src/manifestPlugin.test.ts

@@ -0,0 +1,212 @@
+import { mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { deflateSync } from 'node:zlib';
+
+import { sdkHostDecompressDeflate } from '@flighthq/compression/contract';
+import { createRequirementSet } from '@flighthq/requirement/contract';
+import { RequirementFacet } from '@flighthq/types/contract';
+
+import { MANIFEST_PARSER_BACKEND } from './manifestModuleSource';
+import { createManifestPlugin, MANIFEST_QUERY_SUFFIX } from './manifestPlugin';
+
+describe('createManifestPlugin', () => {
+  it('claims only ?manifest imports, resolving them against the importer directory', async () => {
+    const plugin = createManifestPlugin({ catalog: { entries: [] } });
+    expect(plugin.resolveId('./asset.swf')).toBeNull();
+    expect(plugin.resolveId('./styles.css')).toBeNull();
+    const resolved = plugin.resolveId(`./asset.swf${MANIFEST_QUERY_SUFFIX}`, '/project/src/main.ts')!;
+    expect(resolved.startsWith('\0flight-manifest:')).toBe(true);
+    expect(resolved.endsWith('/project/src/asset.swf')).toBe(true);
+  });
+
+  it('loads nothing for an id it did not resolve', async () => {
+    const plugin = createManifestPlugin({ catalog: { entries: [] } });
+    expect(await plugin.load('/project/src/main.ts')).toBeNull();
+  });
+
+  it('serves fragments for the one file imported, resolved across every backend', async () => {
+    const { dir, plugin } = await fixture();
+    const source = (await load(plugin, dir, 'a.swf'))!;
+    expect(source).toContain("import { glDefineShape } from '@acme/gl';");
+    expect(source).toContain("import { wgpuDefineShape } from '@acme/wgpu';");
+    expect(source).toContain(
+      "export const glOptions = {\n  nodeRenderers: new Map([\n    ['DefineShape', glDefineShape],",
+    );
+    expect(source).toContain(
+      "export const wgpuOptions = {\n  nodeRenderers: new Map([\n    ['DefineShape', wgpuDefineShape],",
+    );
+    // canvas and dom carry no kind-keyed options fields on base, so their fragments are empty and
+    // still exported — an application can spread every fragment unconditionally.
+    expect(source).toContain('export const canvasOptions = {};');
+    expect(source).toContain('export const domOptions = {};');
+  });
+
+  it('reads the exact file imported, so two documents give different modules', async () => {
+    const { dir, plugin } = await fixture();
+    await writeFile(join(dir, 'b.swf'), Buffer.from(createSwf(TAG_SET_BACKGROUND_COLOR)));
+    const a = await load(plugin, dir, 'a.swf');
+    const b = await load(plugin, dir, 'b.swf');
+    expect(a).not.toBe(b);
+    expect(a).toContain("['DefineShape', wgpuDefineShape]");
+    expect(b).toContain('export const wgpuOptions = {};');
+  });
+
+  it('invalidates per imported source, leaving other files cached', async () => {
+    const { dir, plugin } = await fixture();
+    await writeFile(join(dir, 'b.swf'), Buffer.from(createSwf(TAG_DEFINE_SHAPE)));
+    const beforeA = await load(plugin, dir, 'a.swf');
+    const beforeB = await load(plugin, dir, 'b.swf');
+
+    // Rewrite a.swf to content with no DefineShape, then invalidate ONLY a.swf.
+    await writeFile(join(dir, 'a.swf'), Buffer.from(createSwf(TAG_SET_BACKGROUND_COLOR)));
+    await writeFile(join(dir, 'b.swf'), Buffer.from(createSwf(TAG_SET_BACKGROUND_COLOR)));
+    plugin.handleHotUpdate({ file: join(dir, 'a.swf') });
+
+    expect(await load(plugin, dir, 'a.swf')).not.toBe(beforeA);
+    // b.swf changed on disk too, but nothing invalidated it, so its cached module must stand.
+    expect(await load(plugin, dir, 'b.swf')).toBe(beforeB);
+  });
+
+  it('reports an unsupported format and still serves a spreadable empty module', async () => {
+    const { dir, diagnostics, plugin } = await fixture();
+    await writeFile(join(dir, 'notes.txt'), 'not content');
+    const source = (await load(plugin, dir, 'notes.txt'))!;
+    expect(diagnostics.some((m) => m.includes('unsupported content format'))).toBe(true);
+    expect(source).toContain('export const canvasOptions = {};');
+    expect(source).toContain('export const parserOptions = {};');
+  });
+
+  // Downstream report: a CWS SWF and a deflate AWD produced `parserOptions = {}` with NO diagnostic,
+  // because nothing is "unresolved" when nothing was read. That is a bundle missing every handler the
+  // content needed — exactly what onDiagnostic exists to prevent.
+  it('REPORTS compressed content it cannot decode, instead of emitting an empty manifest silently', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'flight-vite-'));
+    await writeFile(join(dir, 'a.swf'), Buffer.from(compressedSwf()));
+    const diagnostics: string[] = [];
+    const plugin = createManifestPlugin({
+      catalog: { entries: [] },
+      onDiagnostic: (message) => diagnostics.push(message),
+    });
+    const source = (await load(plugin, dir, 'a.swf'))!;
+    expect(source).toContain('export const parserOptions = {};');
+    expect(diagnostics.some((m) => m.includes('unreadable content') && m.includes('deflate/lzma'))).toBe(true);
+  });
+
+  it('reads that same compressed file once a deflate capability is supplied', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'flight-vite-'));
+    await writeFile(join(dir, 'a.swf'), Buffer.from(compressedSwf()));
+    const diagnostics: string[] = [];
+    const plugin = createManifestPlugin({
+      catalog: {
+        entries: [entry(MANIFEST_PARSER_BACKEND, RequirementFacet.DocumentFormat, 'DefineShape', 'parserDefineShape')],
+      },
+      deflate: sdkHostDecompressDeflate,
+      onDiagnostic: (message) => diagnostics.push(message),
+    });
+    const source = (await load(plugin, dir, 'a.swf'))!;
+    expect(source).toContain('parserDefineShape,');
+    expect(diagnostics.filter((m) => m.includes('unreadable content'))).toEqual([]);
+  });
+
+  it('reports an unreadable file rather than failing the build', async () => {
+    const { dir, diagnostics, plugin } = await fixture();
+    expect(await load(plugin, dir, 'missing.swf')).toContain('export const glOptions = {};');
+    expect(diagnostics.some((m) => m.includes('analyzer failed'))).toBe(true);
+  });
+
+  it('reports a requirement no catalog entry satisfies', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'flight-vite-'));
+    await writeFile(join(dir, 'a.swf'), Buffer.from(createSwf(TAG_DEFINE_SHAPE)));
+    const diagnostics: string[] = [];
+    const plugin = createManifestPlugin({
+      catalog: { entries: [] },
+      onDiagnostic: (message) => diagnostics.push(message),
+    });
+    await load(plugin, dir, 'a.swf');
+    expect(diagnostics.some((m) => m.includes('no catalog entry for document.format DefineShape'))).toBe(true);
+  });
+
+  it('drives resolution through an EXTERNAL catalog, since the built-in catalog ships empty', async () => {
+    const { dir, plugin } = await fixture();
+    // BUILT_IN_REQUIREMENT_CATALOG_ENTRIES is deliberately empty on base, so every row that reaches a
+    // fragment came from the catalog the caller passed in. This pins that the external path is the
+    // real one rather than incidental.
+    expect(await load(plugin, dir, 'a.swf')).toContain("['DefineShape', glDefineShape]");
+
+    const empty = createManifestPlugin({ catalog: { entries: [] }, onDiagnostic: () => {} });
+    const source = (await load(empty, dir, 'a.swf'))!;
+    expect(source).toContain('export const glOptions = {};');
+    expect(source).not.toContain('glDefineShape');
+  });
+
+  it('reports every requirement no backend in the external catalog can satisfy', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'flight-vite-'));
+    await writeFile(join(dir, 'a.swf'), Buffer.from(createSwf(TAG_DEFINE_SHAPE)));
+    const diagnostics: string[] = [];
+    const plugin = createManifestPlugin({
+      catalog: { entries: [] },
+      onDiagnostic: (message) => diagnostics.push(message),
+    });
+    await load(plugin, dir, 'a.swf');
+    expect(diagnostics.some((m) => m.includes('no catalog entry for document.format DefineShape'))).toBe(true);
+  });
+});
+
+const TAG_DEFINE_SHAPE = 2;
+const TAG_SET_BACKGROUND_COLOR = 9;
+
+function entry(backend: string, facet: string, kind: string, symbol: string) {
+  return {
+    backend,
+    facet: facet as never,
+    implementationImport: `@acme/${backend}`,
+    implementationSymbol: symbol,
+    kind,
+    registrarImport: `@acme/${backend}`,
+    registrarSymbol: `register${kind}`,
+  };
+}
+
+async function fixture() {
+  const dir = await mkdtemp(join(tmpdir(), 'flight-vite-'));
+  await writeFile(join(dir, 'a.swf'), Buffer.from(createSwf(TAG_DEFINE_SHAPE)));
+  const diagnostics: string[] = [];
+  const plugin = createManifestPlugin({
+    catalog: {
+      entries: [
+        entry('wgpu', RequirementFacet.DocumentFormat, 'DefineShape', 'wgpuDefineShape'),
+        entry('gl', RequirementFacet.DocumentFormat, 'DefineShape', 'glDefineShape'),
+        entry(MANIFEST_PARSER_BACKEND, RequirementFacet.DocumentFormat, 'DefineShape', 'parserDefineShape'),
+      ],
+    },
+    onDiagnostic: (message) => diagnostics.push(message),
+  });
+  return { diagnostics, dir, plugin };
+}
+
+async function load(plugin: ReturnType<typeof createManifestPlugin>, dir: string, name: string) {
+  const id = plugin.resolveId(`./${name}${MANIFEST_QUERY_SUFFIX}`, join(dir, 'main.ts'))!;
+  return plugin.load(id);
+}
+
+// A minimal SWF carrying exactly one tag of the given code, built inline so the tests need no fixture.
+function createSwf(code: number): Uint8Array {
+  const tagHeader = code << 6;
+  const body = new Uint8Array([0x00, 0x00, 0x18, 0x01, 0x00, tagHeader & 0xff, (tagHeader >> 8) & 0xff, 0x00, 0x00]);
+  const file = new Uint8Array(8 + body.length);
+  file.set([0x46, 0x57, 0x53, 9], 0);
+  new DataView(file.buffer).setUint32(4, file.length, true);
+  file.set(body, 8);
+  return file;
+}
+
+function compressedSwf(): Uint8Array {
+  const uncompressed = createSwf(TAG_DEFINE_SHAPE);
+  const body = new Uint8Array(deflateSync(Buffer.from(uncompressed.subarray(8))));
+  const file = new Uint8Array(8 + body.length);
+  file.set(uncompressed.subarray(0, 8), 0);
+  file[0] = 0x43;
+  file.set(body, 8);
+  return file;
+}

package/src/manifestTreeShaking.test.ts

@@ -0,0 +1,172 @@
+import { mkdir, mkdtemp, readFile, readdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { RequirementFacet } from '@flighthq/types/contract';
+import { build } from 'vite';
+
+import { MANIFEST_PARSER_BACKEND } from './manifestModuleSource';
+import { createManifestPlugin, MANIFEST_QUERY_SUFFIX } from './manifestPlugin';
+
+// Tree shaking is a property of a BUNDLER, not of the emitted string. Reading the generated source
+// only shows what was offered; these tests run a real Vite production build and read what survived.
+const BUILD_TIMEOUT_MS = 60_000;
+
+describe('vite build', () => {
+  it(
+    'keeps only the backend fragment the entry imported, dropping the other implementations',
+    async () => {
+      const dir = await project();
+      await writeFile(
+        join(dir, 'src', 'main.js'),
+        `import { glOptions } from './asset.swf${MANIFEST_QUERY_SUFFIX}';\nglobalThis.out = glOptions;\n`,
+      );
+      const bundle = await bundleOf(dir);
+
+      expect(bundle).toContain('GL_IMPLEMENTATION_MARKER');
+      expect(bundle).not.toContain('CANVAS_IMPLEMENTATION_MARKER');
+      expect(bundle).not.toContain('WGPU_IMPLEMENTATION_MARKER');
+      expect(bundle).not.toContain('PARSER_IMPLEMENTATION_MARKER');
+    },
+    BUILD_TIMEOUT_MS,
+  );
+
+  it(
+    'keeps only the parser fragment when that is what the entry imported',
+    async () => {
+      const dir = await project();
+      await writeFile(
+        join(dir, 'src', 'main.js'),
+        `import { parserOptions } from './asset.swf${MANIFEST_QUERY_SUFFIX}';\nglobalThis.out = parserOptions;\n`,
+      );
+      const bundle = await bundleOf(dir);
+
+      expect(bundle).toContain('PARSER_IMPLEMENTATION_MARKER');
+      expect(bundle).not.toContain('GL_IMPLEMENTATION_MARKER');
+      expect(bundle).not.toContain('CANVAS_IMPLEMENTATION_MARKER');
+    },
+    BUILD_TIMEOUT_MS,
+  );
+
+  it(
+    'keeps every implementation an entry actually imports, across two backends',
+    async () => {
+      const dir = await project();
+      await writeFile(
+        join(dir, 'src', 'main.js'),
+        `import { glOptions, wgpuOptions } from './asset.swf${MANIFEST_QUERY_SUFFIX}';\n` +
+          'globalThis.out = [glOptions, wgpuOptions];\n',
+      );
+      const bundle = await bundleOf(dir);
+
+      expect(bundle).toContain('GL_IMPLEMENTATION_MARKER');
+      expect(bundle).toContain('WGPU_IMPLEMENTATION_MARKER');
+      expect(bundle).not.toContain('PARSER_IMPLEMENTATION_MARKER');
+    },
+    BUILD_TIMEOUT_MS,
+  );
+
+  it(
+    'produces a spreadable fragment carrying the kind the content required',
+    async () => {
+      const dir = await project();
+      await writeFile(
+        join(dir, 'src', 'main.js'),
+        `import { glOptions } from './asset.swf${MANIFEST_QUERY_SUFFIX}';\nglobalThis.out = glOptions;\n`,
+      );
+      const bundle = await bundleOf(dir);
+      // The fragment reaches the bundle as a real Map literal keyed by the requirement's kind, which is
+      // what lets an application spread it straight into createGlRenderState.
+      expect(bundle).toContain('DefineShape');
+      expect(bundle).toContain('nodeRenderers');
+    },
+    BUILD_TIMEOUT_MS,
+  );
+
+  it(
+    'retains BOTH canvas and gl when the entry imports both fragments',
+    async () => {
+      const dir = await project();
+      await writeFile(
+        join(dir, 'src', 'main.js'),
+        `import { canvasOptions, glOptions } from './asset.swf${MANIFEST_QUERY_SUFFIX}';\n` +
+          'globalThis.out = [canvasOptions, glOptions];\n',
+      );
+      const bundle = await bundleOf(dir);
+
+      // A canvas fragment is a Partial<CanvasRenderStateOptions> spread straight into
+      // createCanvasRenderState(options), so canvas carries real implementations and both survive.
+      // wgpu and the parser do not, which is what makes this a retention test rather than a tautology.
+      expect(bundle).toContain('CANVAS_IMPLEMENTATION_MARKER');
+      expect(bundle).toContain('GL_IMPLEMENTATION_MARKER');
+      expect(bundle).not.toContain('WGPU_IMPLEMENTATION_MARKER');
+      expect(bundle).not.toContain('PARSER_IMPLEMENTATION_MARKER');
+    },
+    BUILD_TIMEOUT_MS,
+  );
+});
+
+async function bundleOf(dir: string): Promise<string> {
+  await build({
+    build: {
+      minify: false,
+      outDir: join(dir, 'dist'),
+      rollupOptions: { input: join(dir, 'src', 'main.js') },
+      write: true,
+    },
+    configFile: false,
+    logLevel: 'silent',
+    plugins: [createManifestPlugin({ catalog: { entries: catalogEntries(dir) }, onDiagnostic: () => {} })],
+    root: dir,
+  });
+  const outDir = join(dir, 'dist');
+  const files = (await readdir(outDir, { recursive: true, withFileTypes: true }))
+    .filter((e) => e.isFile() && e.name.endsWith('.js'))
+    .map((e) => join(e.parentPath ?? outDir, e.name));
+  const contents = await Promise.all(files.map((file) => readFile(file, 'utf8')));
+  return contents.join('\n');
+}
+
+function catalogEntries(dir: string) {
+  const impl = (backend: string) => join(dir, 'src', `${backend}Impl.js`);
+  return [
+    entry('canvas', RequirementFacet.DocumentFormat, 'DefineShape', 'canvasDefineShape', impl('canvas')),
+    entry('gl', RequirementFacet.DocumentFormat, 'DefineShape', 'glDefineShape', impl('gl')),
+    entry('wgpu', RequirementFacet.DocumentFormat, 'DefineShape', 'wgpuDefineShape', impl('wgpu')),
+    entry(MANIFEST_PARSER_BACKEND, RequirementFacet.DocumentFormat, 'DefineShape', 'parserDefineShape', impl('parser')),
+  ];
+}
+
+function entry(backend: string, facet: string, kind: string, symbol: string, module: string) {
+  return {
+    backend,
+    facet: facet as never,
+    implementationImport: module,
+    implementationSymbol: symbol,
+    kind,
+    registrarImport: module,
+    registrarSymbol: `register${kind}`,
+  };
+}
+
+async function project(): Promise<string> {
+  const dir = await mkdtemp(join(tmpdir(), 'flight-vite-build-'));
+  await mkdir(join(dir, 'src'), { recursive: true });
+  await writeFile(join(dir, 'src', 'asset.swf'), Buffer.from(createSwfWithDefineShape()));
+  for (const backend of ['canvas', 'gl', 'wgpu', 'parser']) {
+    await writeFile(
+      join(dir, 'src', `${backend}Impl.js`),
+      `export const ${backend}DefineShape = '${backend.toUpperCase()}_IMPLEMENTATION_MARKER';\n`,
+    );
+  }
+  return dir;
+}
+
+function createSwfWithDefineShape(): Uint8Array {
+  const body = new Uint8Array([0x00, 0x00, 0x18, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00]);
+  const file = new Uint8Array(8 + body.length);
+  file.set([0x46, 0x57, 0x53, 9], 0);
+  new DataView(file.buffer).setUint32(4, file.length, true);
+  file.set(body, 8);
+  return file;
+}

package/src/manifestTypedConsumer.test.ts

@@ -0,0 +1,114 @@
+import { mergeDomRenderOptions } from '@flighthq/scene2d-dom/contract';
+import { mergeSwfParseOptions } from '@flighthq/swf/contract';
+import type {
+  Awd2ParseOptions,
+  CanvasRenderStateOptions,
+  DomRenderOptions,
+  GlRenderStateOptions,
+  Kind,
+  NodeRenderer,
+  SwfParseOptions,
+  SwfTagHandler,
+  WgpuRenderStateOptions,
+} from '@flighthq/types/contract';
+
+// THE POINT OF THIS FILE. The generated module is plain JS, so nothing in the emitted text proves a
+// fragment is spreadable into the API it names. These fixtures are TYPED: each declares a fragment in
+// exactly the shape the emitter produces and checks it against the real options type.
+//
+// The check is `Spreads<Fragment, Target>`, not a bare spread. Spreading a VARIABLE into a typed
+// binding does NOT trigger TypeScript's excess-property check — only a direct object literal does — so
+// `const o: CanvasRenderOptions = { ...fragment }` compiles happily even when the fragment carries a
+// field the target never declared. I verified that hole before writing this, and the key-subset
+// constraint below is what actually closes it: a fragment naming an unknown field resolves to `never`
+// and fails to compile.
+type Spreads<Fragment, Target> = keyof Fragment extends keyof Target ? true : never;
+describe('typed consumer fixtures', () => {
+  it('spreads glOptions into GlRenderStateOptions', () => {
+    const glOptions = {
+      nodeRenderers: new Map<Kind, NodeRenderer>([['ShowFrame', RENDERER]]),
+      blendRealizations: new Map(),
+    };
+    const fits: Spreads<typeof glOptions, GlRenderStateOptions> = true;
+    const options: GlRenderStateOptions = { ...glOptions, pixelRatio: 2 };
+    expect(fits).toBe(true);
+    expect(options.nodeRenderers!.get('ShowFrame')).toBe(RENDERER);
+    expect(options.blendRealizations).toBeDefined();
+  });
+
+  it('spreads wgpuOptions into WgpuRenderStateOptions', () => {
+    const wgpuOptions = { nodeRenderers: new Map<Kind, NodeRenderer>([['ShowFrame', RENDERER]]) };
+    const fits: Spreads<typeof wgpuOptions, WgpuRenderStateOptions> = true;
+    const options: WgpuRenderStateOptions = { ...wgpuOptions };
+    expect(fits).toBe(true);
+    expect(options.nodeRenderers!.get('ShowFrame')).toBe(RENDERER);
+  });
+
+  it('spreads parserOptions into SwfParseOptions, and composes across documents', () => {
+    const first: Partial<SwfParseOptions> = { tags: [TAG_HANDLER] };
+    const second: Partial<SwfParseOptions> = { tags: [TAG_HANDLER] };
+    const options: SwfParseOptions = mergeSwfParseOptions(first, second);
+    expect(options.tags).toHaveLength(2);
+  });
+
+  it('spreads parserOptions into Awd2ParseOptions', () => {
+    const parserOptions = { blocks: [] as Awd2ParseOptions['blocks'][number][] };
+    const fits: Spreads<typeof parserOptions, Awd2ParseOptions> = true;
+    const options: Awd2ParseOptions = { ...parserOptions };
+    expect(fits).toBe(true);
+    expect(options.blocks).toEqual([]);
+  });
+
+  // Canvas takes ONE options object now, like every other backend: registries and texture resolvers
+  // live inside CanvasRenderStateOptions, so the fragment spreads straight into
+  // createCanvasRenderState(options) with no separate registries argument.
+  it('spreads canvasOptions directly into CanvasRenderStateOptions', () => {
+    const canvasOptions = {
+      nodeRenderers: new Map<Kind, NodeRenderer>([['ShowFrame', RENDERER]]),
+      effects: new Map(),
+    };
+    const fits: Spreads<typeof canvasOptions, CanvasRenderStateOptions> = true;
+    const options: CanvasRenderStateOptions = { ...canvasOptions, pixelRatio: 2 };
+    expect(fits).toBe(true);
+    expect(options.nodeRenderers!.get('ShowFrame')).toBe(RENDERER);
+    expect(options.pixelRatio).toBe(2);
+  });
+
+  it('rejects a canvas fragment naming a field CanvasRenderStateOptions does not have', () => {
+    const rejected: Spreads<{ blendRealizations: Map<Kind, unknown> }, CanvasRenderStateOptions> extends never
+      ? true
+      : false = true;
+    expect(rejected).toBe(true);
+  });
+
+  // D3 — DomRenderOptions now declares registry fields, so a DOM fragment spreads into the options
+  // parameter and the constructor seeds the runtime registries from it.
+  it('spreads domOptions into DomRenderOptions', () => {
+    const domOptions = {
+      nodeRenderers: new Map<Kind, NodeRenderer>([['ShowFrame', RENDERER]]),
+      textureResolvers: new Map(),
+    };
+    const fits: Spreads<typeof domOptions, DomRenderOptions> = true;
+    const options: Partial<DomRenderOptions> = { ...domOptions, roundPixels: true };
+    expect(fits).toBe(true);
+    expect(options.nodeRenderers!.get('ShowFrame')).toBe(RENDERER);
+    expect(options.roundPixels).toBe(true);
+  });
+
+  it('rejects a DOM fragment naming a field DomRenderOptions does not have', () => {
+    const rejected: Spreads<{ materialRenderers: Map<Kind, unknown> }, DomRenderOptions> extends never ? true : false =
+      true;
+    expect(rejected).toBe(true);
+  });
+
+  it('composes DOM fragments with named semantics, not a generic merge', () => {
+    const merged = mergeDomRenderOptions(
+      { nodeRenderers: new Map<Kind, NodeRenderer>([['ShowFrame', RENDERER]]) },
+      { nodeRenderers: new Map<Kind, NodeRenderer>([['DefineShape', RENDERER]]) },
+    );
+    expect([...merged.nodeRenderers!.keys()]).toEqual(['ShowFrame', 'DefineShape']);
+  });
+});
+
+const RENDERER = { createData: () => null, submit: () => {} } as NodeRenderer;
+const TAG_HANDLER = { code: 1, read: () => {} } as unknown as SwfTagHandler;