@bendyline/squisq 1.5.2 → 2.0.0

package/src/__tests__/templates.test.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect } from 'vitest';
 import {
-  expandTemplateBlock,
   expandDocBlocks,
   getAvailableTemplates,
   hasTemplate,
@@ -10,11 +9,41 @@ import {
   VIEWPORT_PRESETS,
 } from '../doc/templates/index';
 import type { TemplateBlock } from '../schemas/BlockTemplates';
-import type { TextLayer } from '../schemas/Doc';
-import { getLayers } from '../doc/getLayers';
+import type { Block, Layer, TextLayer } from '../schemas/Doc';
+import type { RuntimeTemplateRegistry } from '../doc/templates/index';
+import { materializeBlockLayersWithRuntime } from '../doc/materializeBlockLayers';
+import { materializeLayers } from './materializeTestUtils';
 import { markdownToDoc } from '../doc/markdownToDoc';
 import { parseMarkdown } from '../markdown/parse';
 
+function materializeTemplateForTest(
+  block: TemplateBlock,
+  context: ReturnType<typeof createTemplateContext>,
+  registry: RuntimeTemplateRegistry = templateRegistry as unknown as RuntimeTemplateRegistry,
+): Block {
+  const { layers } = materializeBlockLayersWithRuntime(
+    block,
+    {
+      theme: context.theme,
+      viewport: context.viewport,
+      persistentLayers: false,
+      blockIndex: context.blockIndex,
+      totalBlocks: context.totalBlocks,
+      failureMode: 'empty',
+    },
+    { registry, templateContext: context, applyRenderStyle: false },
+  );
+  return {
+    id: block.id,
+    startTime: 0,
+    duration: block.duration,
+    audioSegment: block.audioSegment,
+    ...(layers.length > 0 ? { layers } : {}),
+    transition: block.transition,
+    template: block.template,
+  };
+}
+
 describe('templateRegistry', () => {
   it('contains all expected templates', () => {
     const expected = [
@@ -66,7 +95,7 @@ describe('hasTemplate', () => {
   });
 });
 
-describe('expandTemplateBlock', () => {
+describe('canonical template materialization', () => {
   it('expands titleSlide template into layers', () => {
     const block: TemplateBlock = {
       template: 'title',
@@ -77,7 +106,7 @@ describe('expandTemplateBlock', () => {
       subtitle: 'Test Subtitle',
     };
     const context = createTemplateContext(DEFAULT_THEME, 0, 5, VIEWPORT_PRESETS.landscape);
-    const result = expandTemplateBlock(block, context);
+    const result = materializeTemplateForTest(block, context);
 
     expect(result.id).toBe('title-1');
     expect(result.duration).toBe(10);
@@ -97,7 +126,7 @@ describe('expandTemplateBlock', () => {
       body: 'I love building software platforms.',
     };
     const context = createTemplateContext(DEFAULT_THEME, 0, 1, VIEWPORT_PRESETS.landscape);
-    const result = expandTemplateBlock(block, context);
+    const result = materializeTemplateForTest(block, context);
     const layers = result.layers ?? [];
     const imageLayer = layers.find((l) => l.type === 'image');
     expect(imageLayer).toBeDefined();
@@ -130,7 +159,7 @@ describe('expandTemplateBlock', () => {
       title: 'Sized',
     };
     const context = createTemplateContext(DEFAULT_THEME, 0, 1, VIEWPORT_PRESETS.landscape);
-    const result = expandTemplateBlock(block, context);
+    const result = materializeTemplateForTest(block, context);
     const imageLayer = (result.layers ?? []).find((l) => l.type === 'image');
     expect(imageLayer).toBeDefined();
     expect((imageLayer!.content as { fit?: string }).fit).toBe('contain');
@@ -153,7 +182,7 @@ describe('expandTemplateBlock', () => {
       body: 'A list of things.',
     };
     const context = createTemplateContext(DEFAULT_THEME, 0, 1, VIEWPORT_PRESETS.landscape);
-    const result = expandTemplateBlock(block, context);
+    const result = materializeTemplateForTest(block, context);
     const layers = result.layers ?? [];
     const imageLayer = layers.find((l) => l.type === 'image');
     expect(imageLayer).toBeDefined();
@@ -179,7 +208,7 @@ describe('expandTemplateBlock', () => {
       description: 'drop in salmon',
     };
     const context = createTemplateContext(DEFAULT_THEME, 0, 5, VIEWPORT_PRESETS.landscape);
-    const result = expandTemplateBlock(block, context);
+    const result = materializeTemplateForTest(block, context);
 
     expect((result.layers ?? []).length).toBeGreaterThan(0);
     // Should have at least a shape background + text layers
@@ -195,7 +224,7 @@ describe('expandTemplateBlock', () => {
       audioSegment: 0,
     } as unknown as TemplateBlock;
     const context = createTemplateContext(DEFAULT_THEME, 0, 1, VIEWPORT_PRESETS.landscape);
-    const result = expandTemplateBlock(block, context);
+    const result = materializeTemplateForTest(block, context);
     expect(result.layers ?? []).toEqual([]);
   });
 
@@ -241,7 +270,7 @@ describe('expandTemplateBlock', () => {
         leftValue: 50,
         rightValue: 50,
       } as unknown as TemplateBlock;
-      const result = expandTemplateBlock(block, context);
+      const result = materializeTemplateForTest(block, context);
       expect(result.id).toBe(`test-${name}`);
       expect(result.layers ?? []).toBeInstanceOf(Array);
       // Each template should produce at least 1 layer
@@ -265,7 +294,7 @@ describe('expandTemplateBlock', () => {
     };
 
     const context = createTemplateContext(DEFAULT_THEME, 0, 10, VIEWPORT_PRESETS.landscape);
-    const result = expandTemplateBlock(block, context);
+    const result = materializeTemplateForTest(block, context);
     const layers = result.layers ?? [];
     const captionLayer = layers.find(
       (layer): layer is TextLayer => layer.type === 'text' && layer.id === 'caption',
@@ -301,10 +330,10 @@ describe('expandTemplateBlock', () => {
     };
 
     const context = createTemplateContext(DEFAULT_THEME, 0, 10, VIEWPORT_PRESETS.landscape);
-    const imageCaption = (expandTemplateBlock(imageBlock, context).layers ?? []).find(
+    const imageCaption = (materializeTemplateForTest(imageBlock, context).layers ?? []).find(
       (layer): layer is TextLayer => layer.type === 'text' && layer.id === 'caption',
     );
-    const videoCaption = (expandTemplateBlock(videoBlock, context).layers ?? []).find(
+    const videoCaption = (materializeTemplateForTest(videoBlock, context).layers ?? []).find(
       (layer): layer is TextLayer => layer.type === 'text' && layer.id === 'caption',
     );
 
@@ -370,6 +399,85 @@ describe('expandDocBlocks', () => {
     expect(result[0].startTime).toBe(0);
   });
 
+  it('never mutates or aliases raw blocks and persistent layers', () => {
+    const rawLayer: Layer = {
+      type: 'shape',
+      id: 'raw-shape',
+      content: { shape: 'rect', fill: '#112233' },
+      position: { x: 0, y: 0, width: '100%', height: '100%' },
+    };
+    const rawBlock: Block = {
+      id: 'raw',
+      startTime: 99,
+      duration: 6,
+      audioSegment: 0,
+      layers: [rawLayer],
+    };
+    const persistentLayer: Layer = {
+      type: 'shape',
+      id: 'persistent',
+      content: { shape: 'rect', fill: '#445566' },
+      position: { x: 0, y: 0, width: '100%', height: '100%' },
+    };
+    const beforeBlock = JSON.stringify(rawBlock);
+    const beforePersistent = JSON.stringify(persistentLayer);
+
+    const [expanded] = expandDocBlocks([rawBlock], {
+      persistentLayers: { bottomLayers: [persistentLayer] },
+      audioSegments: [{ startTime: 10, duration: 6 }],
+    });
+
+    expect(JSON.stringify(rawBlock)).toBe(beforeBlock);
+    expect(JSON.stringify(persistentLayer)).toBe(beforePersistent);
+    expect(expanded).not.toBe(rawBlock);
+    expect(expanded.layers?.[0]).not.toBe(persistentLayer);
+    expect(expanded.layers?.[1]).not.toBe(rawLayer);
+
+    (expanded.layers?.[0] as Layer & { content: { fill: string } }).content.fill = '#ffffff';
+    expect(JSON.stringify(persistentLayer)).toBe(beforePersistent);
+    expect(expandDocBlocks([rawBlock])[0].layers).toHaveLength(1);
+  });
+
+  it('protects template inputs from mutating registry implementations', () => {
+    const source: TemplateBlock = {
+      template: 'title',
+      id: 'title-safe',
+      duration: 5,
+      audioSegment: 0,
+      title: 'Original',
+    };
+    const sharedLayer: Layer = {
+      type: 'shape',
+      id: 'shared-layer',
+      content: { shape: 'rect', fill: '#112233' },
+      position: { x: 0, y: 0, width: '100%', height: '100%' },
+    };
+    const registry: RuntimeTemplateRegistry = {
+      title: (input) => {
+        (input as { title: string }).title = 'Mutated';
+        return [sharedLayer];
+      },
+    };
+    const first = materializeTemplateForTest(
+      source,
+      createTemplateContext(DEFAULT_THEME, 0, 1),
+      registry,
+    );
+    const second = materializeTemplateForTest(
+      source,
+      createTemplateContext(DEFAULT_THEME, 0, 1),
+      registry,
+    );
+    expect(source.title).toBe('Original');
+    expect(first.layers?.[0]).not.toBe(sharedLayer);
+    expect(first.layers?.[0]).not.toBe(second.layers?.[0]);
+    (first.layers?.[0] as Layer & { content: { fill: string } }).content.fill = '#ffffff';
+    expect((sharedLayer as Layer & { content: { fill: string } }).content.fill).toBe('#112233');
+    expect((second.layers?.[0] as Layer & { content: { fill: string } }).content.fill).toBe(
+      '#112233',
+    );
+  });
+
   it('supports landscape and portrait viewports', () => {
     const blocks: TemplateBlock[] = [
       { template: 'title', id: 'title-1', duration: 5, audioSegment: 0, title: 'Test' },
@@ -533,7 +641,7 @@ describe('DEFAULT_THEME', () => {
   });
 });
 
-describe('inline-param coercion → getLayers', () => {
+describe('inline-param coercion → materializeBlockLayers', () => {
   function firstBlock(md: string) {
     return markdownToDoc(parseMarkdown(md), { generateCoverBlock: false }).blocks[0];
   }
@@ -547,7 +655,7 @@ describe('inline-param coercion → getLayers', () => {
       mapStyle: 'road',
     });
 
-    const layers = getLayers(block, {});
+    const layers = materializeLayers(block, {});
     const mapLayer = layers.find((l) => l.type === 'map');
     expect(mapLayer).toBeDefined();
     // Coerced center/zoom flow into the map layer's content — not empty strings.
@@ -558,7 +666,7 @@ describe('inline-param coercion → getLayers', () => {
 
   it('renders a twoColumn from pure-inline labeled-pair annotation', () => {
     const block = firstBlock('# Coffee {[twoColumn left="Espresso|Bold" right="Filter|Smooth"]}\n');
-    const layers = getLayers(block, {});
+    const layers = materializeLayers(block, {});
     // Guard requires both labels — a non-empty layer set proves coercion worked.
     expect(layers.length).toBeGreaterThan(0);
     const texts = layers
@@ -572,6 +680,24 @@ describe('inline-param coercion → getLayers', () => {
   });
 });
 
+describe('shared template materialization', () => {
+  it('keeps on-demand and timed expansion layer output in lockstep', () => {
+    const block: TemplateBlock = {
+      template: 'title',
+      id: 'shared-title',
+      duration: 7,
+      audioSegment: 0,
+      title: 'One materializer',
+      subtitle: 'Two orchestration modes',
+    };
+
+    const onDemand = materializeLayers(block, { theme: DEFAULT_THEME });
+    const [expanded] = expandDocBlocks([block], { theme: DEFAULT_THEME });
+
+    expect(expanded.layers).toEqual(onDemand);
+  });
+});
+
 describe('VIEWPORT_PRESETS', () => {
   it('has landscape and portrait presets', () => {
     expect(VIEWPORT_PRESETS).toHaveProperty('landscape');

package/src/__tests__/themeCompile.test.ts

@@ -6,7 +6,8 @@ import {
   STARTER_THEME,
   deriveColorPalette,
 } from '../schemas/themeCompile.js';
-import { registerTheme, unregisterTheme, getRegisteredThemes } from '../schemas/Theme.js';
+import { createThemeRegistry } from '../schemas/Theme.js';
+import type { Theme } from '../schemas/Theme.js';
 import { resolveTheme, DEFAULT_THEME, THEMES } from '../schemas/themeLibrary.js';
 import { resolveFontFamily } from '../schemas/fontStacks.js';
 
@@ -132,46 +133,72 @@ describe('parseTheme / serializeTheme round-trip', () => {
   });
 });
 
-describe('registerTheme / resolveTheme', () => {
-  it('registered theme takes precedence over built-in with same id', () => {
+describe('caller-owned theme registries', () => {
+  it('an explicit registry can override a built-in without process-global leakage', () => {
     const overlay = compileTheme({
       id: 'standard',
       name: 'Standard Override',
       seedColors: { primary: '#ff0000' },
     });
-    registerTheme(overlay);
-    try {
-      const resolved = resolveTheme('standard');
-      expect(resolved.name).toBe('Standard Override');
-      expect(resolved.colors.primary).toBe('#ff0000');
-    } finally {
-      unregisterTheme('standard');
-    }
-    // After cleanup, built-in is restored
+    const registry = createThemeRegistry([overlay]);
+    const resolved = resolveTheme('standard', registry);
+    expect(resolved.name).toBe('Standard Override');
+    expect(resolved.colors.primary).toBe('#ff0000');
     expect(resolveTheme('standard').name).toBe('Standard Light');
   });
 
-  it('registered custom-id theme is resolvable via Doc.themeId', () => {
+  it('resolves a custom id only through the registry that owns it', () => {
     const custom = compileTheme({
       id: 'custom-test-1',
       name: 'Custom Test One',
       seedColors: { primary: '#00aabb' },
     });
-    registerTheme(custom);
-    try {
-      const resolved = resolveTheme('custom-test-1');
-      expect(resolved.id).toBe('custom-test-1');
-      expect(resolved.name).toBe('Custom Test One');
-      expect(getRegisteredThemes().some((t) => t.id === 'custom-test-1')).toBe(true);
-    } finally {
-      unregisterTheme('custom-test-1');
-    }
+    const registry = createThemeRegistry([custom]);
+    expect(resolveTheme('custom-test-1', registry).name).toBe('Custom Test One');
+    expect(resolveTheme('custom-test-1')).toBe(DEFAULT_THEME);
+    expect(registry.list().map((theme) => theme.id)).toContain('custom-test-1');
   });
 
   it('resolveTheme falls back to default for unknown ids', () => {
     expect(resolveTheme('nonexistent-theme')).toBe(DEFAULT_THEME);
     expect(resolveTheme(undefined)).toBe(DEFAULT_THEME);
   });
+
+  it('validates and stores an immutable snapshot', () => {
+    const registry = createThemeRegistry();
+    const source = compileTheme({
+      id: 'isolated-theme',
+      name: 'Isolated',
+      seedColors: { primary: '#336699' },
+    });
+    registry.register(source);
+    source.name = 'Changed later';
+    source.colors.primary = '#ffffff';
+
+    const stored = registry.get('isolated-theme')!;
+    expect(stored.name).toBe('Isolated');
+    expect(stored.colors.primary).toBe('#336699');
+    expect(Object.isFrozen(stored)).toBe(true);
+    expect(Object.isFrozen(stored.colors)).toBe(true);
+    expect(() => registry.register({ id: 'invalid' } as Theme)).toThrow(/invalid theme/i);
+  });
+
+  it('supports caller-owned registries with isolated state', () => {
+    const source = compileTheme({
+      id: 'tenant-theme',
+      name: 'Tenant',
+      seedColors: { primary: '#123456' },
+    });
+    const tenantA = createThemeRegistry([source]);
+    const tenantB = createThemeRegistry();
+    expect(tenantA.get('tenant-theme')?.name).toBe('Tenant');
+    expect(tenantB.get('tenant-theme')).toBeUndefined();
+  });
+
+  it('freezes built-ins so lookup ergonomics do not expose mutable global state', () => {
+    expect(Object.isFrozen(THEMES)).toBe(true);
+    expect(Object.isFrozen(resolveTheme('cinematic'))).toBe(true);
+  });
 });
 
 describe('FontFamily resolution', () => {

package/src/__tests__/transformProvenance.test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect } from 'vitest';
+import { parseMarkdown } from '../markdown/parse';
+import { markdownToDoc, flattenRenderableBlocks } from '../doc/markdownToDoc';
+import { applyTransform } from '../transform/applyTransform';
+import { allocateTiming } from '../transform/timingAllocator';
+import { isTemplateBlock, type TemplateBlock } from '../schemas/BlockTemplates';
+import type { Block, Doc } from '../schemas/Doc';
+
+const MD = `# The Numbers
+
+Revenue grew to 4,200 units in 2019 which was a big jump for the small team.
+"We never expected this kind of growth," said the founder about the year.
+
+# The Turning Point
+
+By 2021 the company had 87 employees across three offices and a plan.
+The expansion cost 1,500,000 dollars and took fourteen months to finish.
+
+# The Result
+
+Today the product ships to 40 countries and the team keeps growing steadily.
+`;
+
+function makeDoc(): Doc {
+  return markdownToDoc(parseMarkdown(MD));
+}
+
+/** Blocks a transform produced (positional transform-* ids). */
+function transformedBlocks(doc: Doc): Block[] {
+  return doc.blocks.filter((b) => b.id.startsWith('transform-'));
+}
+
+describe('transform provenance', () => {
+  it('every extraction-derived slide carries a sourceBlockId from the input doc', () => {
+    const source = makeDoc();
+    const sourceIds = new Set(flattenRenderableBlocks(source.blocks).map((b) => b.id));
+    const { doc } = applyTransform(source, 'data-driven');
+
+    const produced = transformedBlocks(doc).filter(
+      (b) => b.id !== 'transform-intro' && b.id !== 'transform-outro',
+    );
+    expect(produced.length).toBeGreaterThan(0);
+    for (const block of produced) {
+      expect(block.sourceBlockId, `block ${block.id} missing provenance`).toBeTruthy();
+      expect(sourceIds.has(block.sourceBlockId!)).toBe(true);
+    }
+  });
+
+  it('sourceStartTime is SECONDS on the doc timeline, not a char offset (regression)', () => {
+    const source = makeDoc();
+    const sourceEnd = Math.max(
+      ...flattenRenderableBlocks(source.blocks).map((b) => b.startTime + b.duration),
+    );
+    const { doc } = applyTransform(source, 'data-driven');
+
+    for (const block of doc.blocks) {
+      const tb = block as unknown as TemplateBlock;
+      if (typeof tb.sourceStartTime !== 'number') continue;
+      // The old bug put char offsets (hundreds) here; real seconds must
+      // stay inside the source timeline.
+      expect(tb.sourceStartTime).toBeLessThanOrEqual(sourceEnd + 1);
+      expect(tb.sourceStartTime).toBeGreaterThanOrEqual(0);
+      // The raw char offset is preserved separately as provenance.
+      expect(typeof tb.sourceCharOffset).toBe('number');
+    }
+  });
+
+  it('narration-timed source blocks anchor their slides inside the source range', () => {
+    const source = makeDoc();
+    // Simulate applyNarrationTiming: give the source blocks recorded times.
+    const flat = flattenRenderableBlocks(source.blocks);
+    const bounds = [0, 20, 45, 70];
+    flat.forEach((block, i) => {
+      block.startTime = bounds[i] ?? 70;
+      block.duration = (bounds[i + 1] ?? 70) - (bounds[i] ?? 70);
+    });
+    source.duration = 70;
+
+    const { doc } = applyTransform(source, 'data-driven');
+    const bySource = new Map(flat.map((b) => [b.id, b]));
+    let anchoredChecked = 0;
+    for (const block of transformedBlocks(doc)) {
+      // Only ANCHORED slides (real narration seconds) must sit inside
+      // their source range; floats (section headers, images) are placed
+      // approximately by design.
+      const tb = block as unknown as TemplateBlock;
+      if (!block.sourceBlockId || typeof tb.sourceStartTime !== 'number') continue;
+      const origin = bySource.get(block.sourceBlockId);
+      if (!origin || origin.duration <= 0) continue;
+      expect(block.startTime).toBeGreaterThanOrEqual(origin.startTime - 1e-6);
+      expect(block.startTime).toBeLessThan(origin.startTime + origin.duration + 1e-6);
+      anchoredChecked++;
+    }
+    expect(anchoredChecked).toBeGreaterThan(0);
+  });
+
+  it('transformed timelines stay contiguous (no uncovered narration seconds)', () => {
+    const source = makeDoc();
+    const { doc } = applyTransform(source, 'data-driven');
+    const sorted = [...doc.blocks].sort((a, b) => a.startTime - b.startTime);
+    for (let i = 0; i < sorted.length - 1; i++) {
+      const end = sorted[i].startTime + sorted[i].duration;
+      expect(end).toBeCloseTo(sorted[i + 1].startTime, 5);
+    }
+  });
+});
+
+describe('allocateTiming fallback', () => {
+  it('keeps the historical rescale behavior when no anchors exist', () => {
+    const floats: TemplateBlock[] = [
+      { template: 'sectionHeader', id: 'a', duration: 5, audioSegment: 0, title: 'A' },
+      { template: 'sectionHeader', id: 'b', duration: 5, audioSegment: 0, title: 'B' },
+    ];
+    const result = allocateTiming(floats, 20);
+    expect(result[0].startTime).toBe(0);
+    expect(result[0].duration).toBe(10);
+    expect(result[1].startTime).toBe(10);
+    expect(result[1].duration).toBe(10);
+  });
+
+  it('anchored blocks keep their positions; floats fill the gaps', () => {
+    const blocks: TemplateBlock[] = [
+      // A floating intro before the first anchor.
+      { template: 'title', id: 'intro', duration: 4, audioSegment: 0, title: 'T' },
+      {
+        template: 'statHighlight',
+        id: 's1',
+        duration: 6,
+        audioSegment: 0,
+        stat: '42',
+        description: 'd',
+        sourceStartTime: 10,
+        sourceDuration: 6,
+      },
+      {
+        template: 'statHighlight',
+        id: 's2',
+        duration: 6,
+        audioSegment: 0,
+        stat: '87',
+        description: 'd',
+        sourceStartTime: 30,
+        sourceDuration: 6,
+      },
+    ];
+    const result = allocateTiming(blocks, 40);
+    // Intro fills [0, 10) up to the first anchor.
+    expect(result[0].startTime).toBe(0);
+    expect(result[0].duration).toBeCloseTo(10, 5);
+    // Anchors sit at their narration positions; s1 holds until s2 starts.
+    expect(result[1].startTime).toBe(10);
+    expect(result[1].duration).toBeCloseTo(20, 5);
+    expect(result[2].startTime).toBe(30);
+    // The final block covers through the total duration.
+    expect(result[2].startTime + result[2].duration).toBeCloseTo(40, 5);
+    for (const b of result) {
+      expect(isTemplateBlock(b as unknown as TemplateBlock) || true).toBe(true);
+    }
+  });
+});

package/src/__tests__/transformV2.test.ts

@@ -1,10 +1,9 @@
-import { describe, it, expect, afterEach } from 'vitest';
+import { describe, it, expect } from 'vitest';
 import {
   applyTransform,
   resolveTransformStyle,
-  registerTransformStyle,
-  unregisterTransformStyle,
   getTransformStyleIds,
+  createTransformStyleRegistry,
 } from '../transform/index.js';
 import type { TransformStyleConfig } from '../transform/index.js';
 import type { Doc, Block } from '../schemas/Doc.js';
@@ -49,8 +48,6 @@ function sampleDoc(): Doc {
 }
 
 describe('transform style contract v2', () => {
-  afterEach(() => unregisterTransformStyle('custom-test'));
-
   it('suggestedThemeId applies only when the doc declares no theme', () => {
     const { doc } = applyTransform(sampleDoc(), 'magazine');
     expect(doc.themeId).toBe('magazine');
@@ -88,23 +85,53 @@ describe('transform style contract v2', () => {
     expect(last.template).toBe('sectionHeader');
   });
 
-  it('registerTransformStyle adds a resolvable style that wins over unknown fallback', () => {
+  it('resolves custom styles only through their caller-owned registry', () => {
     const custom: TransformStyleConfig = {
       ...resolveTransformStyle('minimal'),
       id: 'custom-test',
       name: 'Custom Test',
       description: 'test style',
     };
-    registerTransformStyle(custom);
-    expect(getTransformStyleIds()).toContain('custom-test');
-    expect(resolveTransformStyle('custom-test').name).toBe('Custom Test');
-    unregisterTransformStyle('custom-test');
-    // Unknown id falls back to the default (documentary)
+    const registry = createTransformStyleRegistry([custom]);
+    expect(getTransformStyleIds(registry)).toContain('custom-test');
+    expect(resolveTransformStyle('custom-test', registry).name).toBe('Custom Test');
     expect(resolveTransformStyle('custom-test').id).toBe('documentary');
+    expect(
+      applyTransform(sampleDoc(), 'custom-test', { registry }).doc.blocks.length,
+    ).toBeGreaterThan(0);
   });
 
-  it("accepts 'dataDriven' as an alias for the hyphenated registry id", () => {
+  it('normalizes the stored legacy dataDriven id without advertising it', () => {
+    expect(resolveTransformStyle('data-driven').id).toBe('data-driven');
     expect(resolveTransformStyle('dataDriven').id).toBe('data-driven');
+    expect(getTransformStyleIds()).not.toContain('dataDriven');
+  });
+
+  it('validates and stores immutable style snapshots in isolated registries', () => {
+    const base = resolveTransformStyle('minimal');
+    const source: TransformStyleConfig = {
+      ...base,
+      id: 'tenant-style',
+      name: 'Tenant Style',
+      preferredTypes: [...base.preferredTypes],
+      colorSchemes: [...base.colorSchemes],
+      blocksPerSection: { ...base.blocksPerSection },
+    };
+    const tenantA = createTransformStyleRegistry([source]);
+    const tenantB = createTransformStyleRegistry();
+    source.name = 'Changed later';
+    source.colorSchemes[0] = 'red';
+
+    const stored = tenantA.get('tenant-style')!;
+    expect(stored.name).toBe('Tenant Style');
+    expect(stored.colorSchemes[0]).toBe(base.colorSchemes[0]);
+    expect(Object.isFrozen(stored)).toBe(true);
+    expect(Object.isFrozen(stored.colorSchemes)).toBe(true);
+    expect(tenantB.get('tenant-style')).toBeUndefined();
+
+    expect(() => tenantA.register({ ...source, id: 'bad-style', transformRatio: 2 })).toThrow(
+      /transformRatio/,
+    );
   });
 
   it('budget.slidesPerMinute caps promotions on long docs', () => {
@@ -127,9 +154,8 @@ describe('transform style contract v2', () => {
       id: 'custom-test',
       budget: { slidesPerMinute: 2 },
     };
-    registerTransformStyle(budgeted);
     const loose = applyTransform(manyBlocks, 'data-driven');
-    const tight = applyTransform(manyBlocks, 'custom-test');
+    const tight = applyTransform(manyBlocks, budgeted);
     expect(tight.stats.transformedBlocks).toBeLessThan(loose.stats.transformedBlocks);
     // 12 blocks x 5s = 60s → 2/minute → at most 2 promotions
     expect(tight.stats.transformedBlocks).toBeLessThanOrEqual(2);