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

package/dist/requirementOptionFields.js

@@ -0,0 +1,76 @@
+import { RequirementFacet } from '@flighthq/types/contract';
+/**
+ * The render-state options field that collects each facet's implementations.
+ *
+ * A catalog row names a facet, a kind and an implementation, but not the options field that holds it —
+ * deliberately, because a row is a fact about ownership and should not encode one consumer's option
+ * shape. This table is where the plugin decides.
+ *
+ * `document.format` maps to `nodeRenderers` for a render backend: a document's content kinds are the
+ * nodes the importer produces, so that is the field a renderer needs them in.
+ */
+export const REQUIREMENT_OPTION_FIELDS = Object.freeze({
+    [RequirementFacet.DocumentFormat]: 'nodeRenderers',
+    [RequirementFacet.SceneBlendMode]: 'blendRealizations',
+    [RequirementFacet.SceneMaterialKind]: 'materialRenderers',
+    [RequirementFacet.SceneModifierKind]: 'modifierSnippets',
+    [RequirementFacet.SceneNodeKind]: 'nodeRenderers',
+    [RequirementFacet.SceneShapeCommand]: 'canvasShapeCommands',
+    [RequirementFacet.SceneTextureSourceKind]: 'textureResolvers',
+});
+/**
+ * The kind-keyed fields each backend's options type ACTUALLY declares, taken from the types package.
+ *
+ * Backend sets are not interchangeable and the differences are real: `GlRenderStateOptions` has
+ * `blendRealizations`, `pbrExtensions` and `customEffectShaders`; `WgpuRenderStateOptions` has NONE of
+ * those three. Emitting one into the other would produce a fragment that typechecks nowhere and
+ * silently does nothing when spread, so routing is per backend and a row naming a field its backend
+ * does not accept is REPORTED rather than emitted.
+ *
+ * All four backends now take ONE options object, and every set below is derived from the options type
+ * that backend actually declares rather than from a guess about which fields it ought to have.
+ * `CanvasRenderStateOptions` carries the registries and texture resolvers directly, so a canvas
+ * fragment spreads into `createCanvasRenderState(options)` like every other backend's. DOM's registry
+ * fields are seeded into the runtime at construction. Neither canvas nor DOM declares
+ * `blendRealizations`, and DOM declares no material or effect tables, so a row naming one is reported
+ * rather than emitted into a field that does not exist.
+ */
+export const BACKEND_OPTION_FIELDS = Object.freeze({
+    // Derived from the landed CanvasRenderStateOptions: it extends RenderStateOptions and
+    // CanvasRenderOptions and adds effects and materialRenderers, so these are its kind-keyed fields.
+    canvas: new Set(['canvasShapeCommands', 'effectPaddingResolvers', 'effects', 'materialRenderers', 'nodeRenderers']),
+    // D3: DomRenderOptions declares registry fields, seeded into the runtime at construction.
+    dom: new Set(['canvasShapeCommands', 'effectPaddingResolvers', 'nodeRenderers', 'textureResolvers']),
+    gl: new Set([
+        'blendRealizations',
+        'canvasShapeCommands',
+        'customEffectShaders',
+        'customMaterialShaders',
+        'effectPaddingResolvers',
+        'effects',
+        'materialRenderers',
+        'modifierSnippets',
+        'nodeRenderers',
+        'pbrExtensions',
+        'textureResolvers',
+        'velocityWriters',
+    ]),
+    wgpu: new Set([
+        'canvasShapeCommands',
+        'customMaterialShaders',
+        'effectPaddingResolvers',
+        'effects',
+        'materialRenderers',
+        'modifierSnippets',
+        'nodeRenderers',
+        'textureResolvers',
+        'velocityWriters',
+    ]),
+});
+/** The parser options field each content format spreads its ordered handler list into. */
+export const PARSER_HANDLER_FIELDS = Object.freeze({
+    '.awd': 'blocks',
+    '.awd2': 'blocks',
+    '.swf': 'tags',
+});
+//# sourceMappingURL=requirementOptionFields.js.map

package/dist/requirementOptionFields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirementOptionFields.js","sourceRoot":"","sources":["../src/requirementOptionFields.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAE5D;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAqC,MAAM,CAAC,MAAM,CAAC;IACvF,CAAC,gBAAgB,CAAC,cAAc,CAAC,EAAE,eAAe;IAClD,CAAC,gBAAgB,CAAC,cAAc,CAAC,EAAE,mBAAmB;IACtD,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,EAAE,mBAAmB;IACzD,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,EAAE,kBAAkB;IACxD,CAAC,gBAAgB,CAAC,aAAa,CAAC,EAAE,eAAe;IACjD,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,EAAE,qBAAqB;IAC3D,CAAC,gBAAgB,CAAC,sBAAsB,CAAC,EAAE,kBAAkB;CAC9D,CAAC,CAAC;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAkD,MAAM,CAAC,MAAM,CAAC;IAChG,sFAAsF;IACtF,kGAAkG;IAClG,MAAM,EAAE,IAAI,GAAG,CAAC,CAAC,qBAAqB,EAAE,wBAAwB,EAAE,SAAS,EAAE,mBAAmB,EAAE,eAAe,CAAC,CAAC;IACnH,0FAA0F;IAC1F,GAAG,EAAE,IAAI,GAAG,CAAC,CAAC,qBAAqB,EAAE,wBAAwB,EAAE,eAAe,EAAE,kBAAkB,CAAC,CAAC;IACpG,EAAE,EAAE,IAAI,GAAG,CAAC;QACV,mBAAmB;QACnB,qBAAqB;QACrB,qBAAqB;QACrB,uBAAuB;QACvB,wBAAwB;QACxB,SAAS;QACT,mBAAmB;QACnB,kBAAkB;QAClB,eAAe;QACf,eAAe;QACf,kBAAkB;QAClB,iBAAiB;KAClB,CAAC;IACF,IAAI,EAAE,IAAI,GAAG,CAAC;QACZ,qBAAqB;QACrB,uBAAuB;QACvB,wBAAwB;QACxB,SAAS;QACT,mBAAmB;QACnB,kBAAkB;QAClB,eAAe;QACf,kBAAkB;QAClB,iBAAiB;KAClB,CAAC;CACH,CAAC,CAAC;AAEH,0FAA0F;AAC1F,MAAM,CAAC,MAAM,qBAAqB,GAAqC,MAAM,CAAC,MAAM,CAAC;IACnF,MAAM,EAAE,QAAQ;IAChB,OAAO,EAAE,QAAQ;IACjB,MAAM,EAAE,MAAM;CACf,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@flighthq/vite-plugin-manifest",
+  "version": "0.5.1-edge.1685.dc0e23a",
+  "author": "Joshua Granick and other contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/flighthq/flight.git",
+    "directory": "packages/vite-plugin-manifest"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./contract": {
+      "types": "./dist/contract.d.ts",
+      "default": "./dist/contract.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b && tsx ../../scripts/bundle-node-package.ts",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/log": "0.5.1-edge.1685.dc0e23a",
+    "@flighthq/requirement-codegen": "0.5.1-edge.1685.dc0e23a",
+    "@flighthq/scene3d-formats": "0.5.1-edge.1685.dc0e23a",
+    "@flighthq/swf": "0.5.1-edge.1685.dc0e23a",
+    "@flighthq/types": "0.5.1-edge.1685.dc0e23a"
+  },
+  "devDependencies": {
+    "@flighthq/compression": "*",
+    "@flighthq/render": "*",
+    "@flighthq/requirement": "*",
+    "@flighthq/scene2d-dom": "*",
+    "esbuild": "*",
+    "typescript": "^5.3.0",
+    "vite": "*"
+  },
+  "description": "Vite plugin serving generated Flight registration source from analyzed content",
+  "sideEffects": false,
+  "peerDependencies": {
+    "vite": "^7.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": false
+    }
+  }
+}

package/src/contentAnalyzers.test.ts

@@ -0,0 +1,106 @@
+import { deflateSync } from 'node:zlib';
+
+import { sdkHostDecompressDeflate } from '@flighthq/compression/contract';
+import { RequirementFacet } from '@flighthq/types/contract';
+
+import { DEFAULT_CONTENT_ANALYZERS } from './contentAnalyzers';
+
+// Regression for the downstream report: a CWS SWF and a deflate AWD analyzed to an EMPTY requirement
+// set with no diagnostic, which is a bundle missing every handler the content needed. isReadable is
+// what separates "requires nothing" from "could not be read".
+describe('compressed content readability', () => {
+  it('reports a CWS SWF as unreadable without a deflate capability, and readable with one', () => {
+    const compressed = compressedSwf();
+    expect(DEFAULT_CONTENT_ANALYZERS['.swf'].isReadable(compressed, NO_DECOMPRESSORS)).toBe(false);
+    expect(
+      DEFAULT_CONTENT_ANALYZERS['.swf'].isReadable(compressed, { deflate: sdkHostDecompressDeflate, lzma: null }),
+    ).toBe(true);
+  });
+
+  it('still reads what a compressed SWF requires once a decompressor is supplied', () => {
+    const set = DEFAULT_CONTENT_ANALYZERS['.swf'].analyze(compressedSwf(), {
+      deflate: sdkHostDecompressDeflate,
+      lzma: null,
+    });
+    expect(set.requirements.map((requirement) => requirement.key)).toEqual(['DefineShape']);
+  });
+
+  it('reports an uncompressed file as readable, so the probe does not reject good content', () => {
+    expect(DEFAULT_CONTENT_ANALYZERS['.swf'].isReadable(createSwfWithDefineShape(), NO_DECOMPRESSORS)).toBe(true);
+    expect(DEFAULT_CONTENT_ANALYZERS['.awd'].isReadable(createAwd2WithCamera(), NO_DECOMPRESSORS)).toBe(true);
+  });
+
+  it('reports a truncated file as unreadable rather than as requiring nothing', () => {
+    expect(DEFAULT_CONTENT_ANALYZERS['.swf'].isReadable(new Uint8Array([0x46]), NO_DECOMPRESSORS)).toBe(false);
+    expect(DEFAULT_CONTENT_ANALYZERS['.awd'].isReadable(new Uint8Array([0x41]), NO_DECOMPRESSORS)).toBe(false);
+  });
+});
+
+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;
+}
+
+function createAwd2WithCamera(): Uint8Array {
+  const file = new Uint8Array(12 + 11);
+  file.set([0x41, 0x57, 0x44, 2, 1, 0, 0, 0], 0);
+  const view = new DataView(file.buffer);
+  view.setUint32(8, 11, true);
+  view.setUint32(12, 1, true);
+  file[16] = 0;
+  file[17] = 42;
+  file[18] = 0;
+  view.setUint32(19, 0, true);
+  return file;
+}
+
+const NO_DECOMPRESSORS = { deflate: null, lzma: null };
+
+describe('DEFAULT_CONTENT_ANALYZERS', () => {
+  it('covers the formats Flight analyzes, keyed by lowercase extension', () => {
+    expect(Object.keys(DEFAULT_CONTENT_ANALYZERS).sort()).toEqual(['.awd', '.awd2', '.swf']);
+  });
+
+  it('is frozen, so one project cannot mutate the table another build reads', () => {
+    expect(Object.isFrozen(DEFAULT_CONTENT_ANALYZERS)).toBe(true);
+  });
+
+  it('delegates to the SWF analyzer rather than reimplementing the walk', () => {
+    const set = DEFAULT_CONTENT_ANALYZERS['.swf'].analyze(createSwfWithDefineShape(), NO_DECOMPRESSORS);
+    expect(set.covers).toEqual([RequirementFacet.DocumentFormat]);
+    expect(set.requirements).toEqual([{ facet: RequirementFacet.DocumentFormat, key: 'DefineShape' }]);
+  });
+
+  it('accepts either AWD suffix, resolving both to the same analyzer', () => {
+    const fromAwd = DEFAULT_CONTENT_ANALYZERS['.awd'].analyze(createAwd2WithCamera(), NO_DECOMPRESSORS);
+    const fromAwd2 = DEFAULT_CONTENT_ANALYZERS['.awd2'].analyze(createAwd2WithCamera(), NO_DECOMPRESSORS);
+    expect(fromAwd2.requirements).toEqual(fromAwd.requirements);
+  });
+
+  it('delegates to the AWD2 analyzer rather than reimplementing the walk', () => {
+    const set = DEFAULT_CONTENT_ANALYZERS['.awd'].analyze(createAwd2WithCamera(), NO_DECOMPRESSORS);
+    expect(set.covers).toEqual([RequirementFacet.DocumentFormat]);
+    expect(set.requirements).toEqual([{ facet: RequirementFacet.DocumentFormat, key: 'Camera' }]);
+  });
+
+  it('reports an empty but covered set for content it cannot read', () => {
+    const set = DEFAULT_CONTENT_ANALYZERS['.swf'].analyze(new Uint8Array(), NO_DECOMPRESSORS);
+    expect(set.requirements).toEqual([]);
+    expect(set.covers).toEqual([RequirementFacet.DocumentFormat]);
+  });
+});
+
+// A real zlib-compressed SWF: 'CWS', version, total uncompressed length, then the deflated body.
+function compressedSwf(): Uint8Array {
+  const uncompressed = createSwfWithDefineShape();
+  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; // 'C' — zlib-compressed container
+  file.set(body, 8);
+  return file;
+}

package/src/manifestComposition.test.ts

@@ -0,0 +1,33 @@
+import { mergeRenderOptions } from '@flighthq/render/contract';
+import { mergeSwfParseOptions } from '@flighthq/swf/contract';
+import type { RenderStateOptions, SwfParseOptions } from '@flighthq/types/contract';
+
+// A build that imports two documents gets two fragments per backend, and composes them with the merge
+// function the OWNING package exports — not with a generic merge living here. These tests pin that
+// composition end to end: the fragments are the shape the plugin emits, and the result is what an
+// application spreads into createRenderState / parseSwf.
+describe('multi-file composition', () => {
+  it('unions node renderers from two documents instead of letting the last file win', () => {
+    const firstDocument: RenderStateOptions = { nodeRenderers: new Map([['ShowFrame', 'showFrameImpl' as never]]) };
+    const secondDocument: RenderStateOptions = { nodeRenderers: new Map([['DefineShape', 'shapeImpl' as never]]) };
+    const composed = mergeRenderOptions(firstDocument, secondDocument);
+    expect([...composed.nodeRenderers!.keys()]).toEqual(['ShowFrame', 'DefineShape']);
+  });
+
+  it('concatenates parser handlers across documents, preserving import order', () => {
+    const firstDocument: SwfParseOptions = { tags: ['showFrameHandler' as never] };
+    const secondDocument: SwfParseOptions = { tags: ['shapeHandler' as never] };
+    expect(mergeSwfParseOptions(firstDocument, secondDocument).tags).toEqual(['showFrameHandler', 'shapeHandler']);
+  });
+
+  it('keeps a document whose fragment is empty from erasing another document’s contribution', () => {
+    const populated: RenderStateOptions = { nodeRenderers: new Map([['ShowFrame', 'impl' as never]]) };
+    expect([...mergeRenderOptions(populated, {}).nodeRenderers!.keys()]).toEqual(['ShowFrame']);
+    expect([...mergeRenderOptions({}, populated).nodeRenderers!.keys()]).toEqual(['ShowFrame']);
+  });
+
+  it('composes three documents in one call, in argument order', () => {
+    const composed = mergeSwfParseOptions({ tags: ['a' as never] }, { tags: ['b' as never] }, { tags: ['c' as never] });
+    expect(composed.tags).toEqual(['a', 'b', 'c']);
+  });
+});

package/src/manifestModuleSource.test.ts

@@ -0,0 +1,179 @@
+import {
+  generateManifestModuleSource,
+  MANIFEST_BACKEND_EXPORTS,
+  MANIFEST_PARSER_BACKEND,
+} from './manifestModuleSource';
+
+describe('generateManifestModuleSource', () => {
+  it('exports every backend fragment plus parserOptions, even when a backend needs nothing', () => {
+    const source = generateManifestModuleSource([row('gl', 'scene.node-kind', 'Shape')], '.swf').source;
+    for (const name of ['canvasOptions', 'domOptions', 'glOptions', 'wgpuOptions', 'parserOptions']) {
+      expect(source).toContain(`export const ${name} =`);
+    }
+    expect(source).toContain('export const canvasOptions = {};');
+  });
+
+  it('spreads a scene kind into the matching options field as a Map', () => {
+    const source = generateManifestModuleSource([row('gl', 'scene.node-kind', 'Shape')], '.swf').source;
+    expect(source).toContain('export const glOptions = {');
+    expect(source).toContain('nodeRenderers: new Map([');
+    expect(source).toContain("['Shape', glShapeImpl],");
+  });
+
+  it('writes a precise named import for every referenced symbol', () => {
+    const source = generateManifestModuleSource(
+      [row('gl', 'scene.node-kind', 'Shape'), row('wgpu', 'scene.material-kind', 'Standard')],
+      '.swf',
+    ).source;
+    const imports = source.split('\n').filter((line) => line.startsWith('import '));
+    expect(imports).toEqual([
+      "import { glShapeImpl } from '@acme/gl';",
+      "import { wgpuStandardImpl } from '@acme/wgpu';",
+    ]);
+    expect(source).not.toContain('import *');
+  });
+
+  // CanvasRenderOptions and DomRenderOptions declare NO kind-keyed fields on base: canvas takes its
+  // registries as a separate constructor parameter and DOM accepts none. So a row aimed at either is
+  // reported rather than emitted into a field that does not exist. Pending an API ruling, this pins
+  // what the plugin does today instead of pretending the fragment would spread.
+  it.each(['canvas', 'dom', 'gl', 'wgpu'])('emits a nodeRenderers fragment for %s', (backend) => {
+    const result = generateManifestModuleSource([row(backend, 'scene.node-kind', 'Shape')], '.swf');
+    expect(result.source).toContain(`export const ${backend}Options = {\n  nodeRenderers: new Map([`);
+    expect(result.problems).toEqual([]);
+  });
+
+  // The backend sets are NOT interchangeable, and these are the real differences on base.
+  it('reports materialRenderers aimed at dom, which DomRenderOptions does not declare', () => {
+    const result = generateManifestModuleSource([row('dom', 'scene.material-kind', 'Standard')], '.swf');
+    expect(result.source).toContain('export const domOptions = {};');
+    expect(result.problems).toEqual([
+      'backend dom has no materialRenderers field: dropped scene.material-kind Standard',
+    ]);
+  });
+
+  it('reports blendRealizations aimed at canvas, which CanvasRenderStateOptions does not declare', () => {
+    const result = generateManifestModuleSource([row('canvas', 'scene.blend-mode', 'Multiply')], '.swf');
+    expect(result.problems).toEqual([
+      'backend canvas has no blendRealizations field: dropped scene.blend-mode Multiply',
+    ]);
+  });
+
+  it('keeps each backend in its own fragment', () => {
+    const source = generateManifestModuleSource(
+      [row('gl', 'scene.node-kind', 'Shape'), row('wgpu', 'scene.node-kind', 'Shape')],
+      '.swf',
+    ).source;
+    expect(source).toContain("export const glOptions = {\n  nodeRenderers: new Map([\n    ['Shape', glShapeImpl],");
+    expect(source).toContain("export const wgpuOptions = {\n  nodeRenderers: new Map([\n    ['Shape', wgpuShapeImpl],");
+  });
+
+  it('routes parser-backend rows to parserOptions under the format\u2019s own field', () => {
+    expect(
+      generateManifestModuleSource([row(MANIFEST_PARSER_BACKEND, 'document.format', 'DefineShape')], '.swf').source,
+    ).toContain('export const parserOptions = {\n  tags: [');
+    expect(
+      generateManifestModuleSource([row(MANIFEST_PARSER_BACKEND, 'document.format', 'Camera')], '.awd2').source,
+    ).toContain('export const parserOptions = {\n  blocks: [');
+  });
+
+  it('sends the same facet to a render fragment or to the parser by the row\u2019s backend', () => {
+    const source = generateManifestModuleSource(
+      [row(MANIFEST_PARSER_BACKEND, 'document.format', 'DefineShape'), row('gl', 'document.format', 'DefineShape')],
+      '.swf',
+    ).source;
+    expect(source).toContain('export const parserOptions = {\n  tags: [\n    parserDefineShapeImpl,');
+    expect(source).toContain(
+      "export const glOptions = {\n  nodeRenderers: new Map([\n    ['DefineShape', glDefineShapeImpl],",
+    );
+  });
+
+  it('preserves catalog order for handlers, because a handler list is ordered', () => {
+    const source = generateManifestModuleSource(
+      [
+        row(MANIFEST_PARSER_BACKEND, 'document.format', 'Second'),
+        row(MANIFEST_PARSER_BACKEND, 'document.format', 'First'),
+      ],
+      '.swf',
+    ).source;
+    // Measured inside the fragment: the import lines above it are sorted, so a whole-file indexOf
+    // would be testing the import order instead of the handler order.
+    const fragment = source.slice(source.indexOf('export const parserOptions'));
+    expect(fragment.indexOf('parserSecondImpl')).toBeLessThan(fragment.indexOf('parserFirstImpl'));
+  });
+
+  it('sorts map entries by kind so the same rows always emit the same bytes', () => {
+    const a = row('gl', 'scene.node-kind', 'Alpha');
+    const b = row('gl', 'scene.node-kind', 'Beta');
+    expect(generateManifestModuleSource([a, b], '.swf').source).toBe(
+      generateManifestModuleSource([b, a], '.swf').source,
+    );
+  });
+
+  it('REPORTS an unmapped facet rather than skipping it silently', () => {
+    const result = generateManifestModuleSource([row('gl', 'compression.kind', 'Deflate')], '.swf');
+    expect(result.source).toContain('export const glOptions = {};');
+    expect(result.source).not.toContain('glDeflateImpl');
+    expect(result.problems).toEqual([
+      'facet compression.kind has no render-state options field: dropped Deflate for gl',
+    ]);
+  });
+
+  it.each(['compression.kind', 'physics2d.joint-kind', 'scene.resource-mime-type'])(
+    'reports %s, the facets with no render-state field',
+    (facet) => {
+      const result = generateManifestModuleSource([row('gl', facet, 'Thing')], '.swf');
+      expect(result.problems).toHaveLength(1);
+      expect(result.problems[0]).toContain(facet);
+    },
+  );
+
+  it('does not leak a GL-only field into wgpu, and says so', () => {
+    const result = generateManifestModuleSource(
+      [row('gl', 'scene.blend-mode', 'Multiply'), row('wgpu', 'scene.blend-mode', 'Multiply')],
+      '.swf',
+    );
+    expect(result.source).toContain('export const glOptions = {\n  blendRealizations: new Map([');
+    expect(result.source).toContain('export const wgpuOptions = {};');
+    expect(result.problems).toEqual(['backend wgpu has no blendRealizations field: dropped scene.blend-mode Multiply']);
+    expect(result.source).not.toContain('wgpuMultiplyImpl');
+  });
+
+  it('reports a row naming a backend it does not know', () => {
+    const result = generateManifestModuleSource([row('metal', 'scene.node-kind', 'Shape')], '.swf');
+    expect(result.problems).toEqual(['unknown backend metal: dropped scene.node-kind Shape']);
+  });
+
+  it('emits a valid module with no imports when nothing resolved', () => {
+    const source = generateManifestModuleSource([], '.swf').source;
+    expect(source).not.toContain('import ');
+    expect(source).toContain('export const parserOptions = {};');
+  });
+});
+
+describe('MANIFEST_BACKEND_EXPORTS', () => {
+  it('names one flat export per backend', () => {
+    expect(MANIFEST_BACKEND_EXPORTS).toEqual({
+      canvas: 'canvasOptions',
+      dom: 'domOptions',
+      gl: 'glOptions',
+      wgpu: 'wgpuOptions',
+    });
+  });
+});
+
+function row(backend: string, facet: string, kind: string) {
+  const symbol = `${backend}${kind}Impl`;
+  return {
+    entry: {
+      backend,
+      facet: facet as never,
+      implementationImport: `@acme/${backend}`,
+      implementationSymbol: symbol,
+      kind,
+      registrarImport: `@acme/${backend}`,
+      registrarSymbol: `register${kind}`,
+    },
+    kind,
+  };
+}