@pixel-point/toolcraft 0.0.17 → 0.0.19

package/templates/runtime/export/artifact-frame-renderer.ts

@@ -6,6 +6,7 @@ import {
   ToolcraftArtifactExportError,
 } from "./export-error";
 import type { ToolcraftProductExportFrameRenderer } from "./product-export-renderer";
+import { getToolcraftArtifactTimelineProgress } from "./artifact-frame-state";
 
 export type ToolcraftArtifactFrameRenderRequest = Readonly<{
   backgroundColor: string;
@@ -23,20 +24,6 @@ export type ToolcraftArtifactFrameRenderRequest = Readonly<{
   state: ToolcraftState;
 }>;
 
-function getTimelineProgress(state: ToolcraftState): number {
-  if (state.timeline.durationSeconds <= 0) {
-    return 0;
-  }
-
-  return Math.max(
-    0,
-    Math.min(
-      1,
-      state.timeline.currentTimeSeconds / state.timeline.durationSeconds,
-    ),
-  );
-}
-
 export async function renderToolcraftArtifactFrame(
   request: ToolcraftArtifactFrameRenderRequest,
 ): Promise<void> {
@@ -83,7 +70,7 @@ export async function renderToolcraftArtifactFrame(
       rendererPipeline: request.rendererPipeline,
       state: request.state,
       timeSeconds: request.state.timeline.currentTimeSeconds,
-      timelineProgress: getTimelineProgress(request.state),
+      timelineProgress: getToolcraftArtifactTimelineProgress(request.state),
     });
   } catch (error) {
     throw normalizeToolcraftExportError(error, {

package/templates/runtime/export/artifact-frame-state.ts

@@ -9,6 +9,22 @@ export type ToolcraftVideoArtifactFramePlanEntry = Readonly<{
   state: ToolcraftArtifactFrameState;
 }>;
 
+export function getToolcraftArtifactTimelineProgress(
+  state: ToolcraftState,
+): number {
+  if (state.timeline.durationSeconds <= 0) {
+    return 0;
+  }
+
+  return Math.max(
+    0,
+    Math.min(
+      1,
+      state.timeline.currentTimeSeconds / state.timeline.durationSeconds,
+    ),
+  );
+}
+
 export function createToolcraftArtifactFrameState(
   baseState: ToolcraftState,
   timeSeconds: number,

package/templates/runtime/export/artifact-scene-frame.test.ts

@@ -5,7 +5,7 @@ import { createToolcraftState } from "../state/create-template-state";
 import { createToolcraftRuntimeSceneVisibility } from "../scene";
 import { ToolcraftSceneExportError } from "./export-frame";
 import {
-  resolveToolcraftImageArtifactFrame,
+  resolveToolcraftStillArtifactFrame,
   resolveToolcraftVideoArtifactFrame,
 } from "./artifact-scene-frame";
 import { createToolcraftVideoArtifactFramePlan } from "./artifact-frame-state";
@@ -29,7 +29,7 @@ describe("artifact scene frame", () => {
     const boundsProvider = vi.fn(() => []);
 
     expect(
-      resolveToolcraftImageArtifactFrame({
+      resolveToolcraftStillArtifactFrame({
         boundsProvider,
         productSceneRequired: true,
         state,
@@ -73,7 +73,7 @@ describe("artifact scene frame", () => {
 
   it("fails visibly when an infinite product scene has no bounds provider", () => {
     expect(() =>
-      resolveToolcraftImageArtifactFrame({
+      resolveToolcraftStillArtifactFrame({
         boundsProvider: undefined,
         productSceneRequired: true,
         state: createState("infinite"),

package/templates/runtime/export/artifact-scene-frame.ts

@@ -21,7 +21,7 @@ type ToolcraftArtifactSceneFrameBaseRequest = Readonly<{
   visibility: ToolcraftRuntimeSceneVisibility;
 }>;
 
-export type ToolcraftImageArtifactSceneFrameRequest =
+export type ToolcraftStillArtifactSceneFrameRequest =
   ToolcraftArtifactSceneFrameBaseRequest &
     Readonly<{ state: ToolcraftState }>;
 
@@ -68,8 +68,8 @@ function isFiniteCanvas(state: ToolcraftState): boolean {
   return getToolcraftCanvasFrame(state.canvas).kind === "finite";
 }
 
-export function resolveToolcraftImageArtifactFrame(
-  request: ToolcraftImageArtifactSceneFrameRequest,
+export function resolveToolcraftStillArtifactFrame(
+  request: ToolcraftStillArtifactSceneFrameRequest,
 ): ToolcraftExportFrame {
   if (isFiniteCanvas(request.state)) {
     return requireFrame(resolveToolcraftExportFrame(request.state, null));

package/templates/runtime/export/export-background.ts

@@ -1,29 +1,10 @@
-import type { ResolvedToolcraftAppSchema } from "../schema/types";
 import type { ToolcraftState } from "../state/types";
 
-export type ToolcraftExportFormat = "png" | "video";
-
-export type ToolcraftExportBackgroundOptions = {
-  format: ToolcraftExportFormat;
-  schema: ResolvedToolcraftAppSchema;
-};
-
 export type ToolcraftPreviewBackgroundOptions = {
   includeBackgroundTarget?: string;
   state: ToolcraftState;
 };
 
-export function shouldIncludeToolcraftExportBackground({
-  format,
-  schema,
-}: ToolcraftExportBackgroundOptions): boolean {
-  if (format === "video") {
-    return true;
-  }
-
-  return schema.export.png.background !== "transparent";
-}
-
 export function shouldIncludeToolcraftPreviewBackground({
   includeBackgroundTarget = "export.includeBackground",
   state,

package/templates/runtime/export/export-error.ts

@@ -8,6 +8,11 @@ export type ToolcraftArtifactExportFailure = Readonly<{
     | "invalid-export-setting"
     | "product-frame-render-failed"
     | "runtime-scene-render-failed"
+    | "svg-content-empty"
+    | "svg-content-invalid"
+    | "svg-document-invalid"
+    | "svg-render-failed"
+    | "svg-serialization-failed"
     | "video-artifact-too-large"
     | "video-encode-failed"
     | "video-encoder-unavailable";

package/templates/runtime/export/export-renderer-coverage.ts

@@ -0,0 +1,54 @@
+import {
+  getToolcraftArtifactExportActions,
+} from "../schema/artifact-export-actions";
+import type { ResolvedToolcraftAppSchema } from "../schema/types";
+import type { ToolcraftProductExportRenderer } from "./product-export-renderer";
+import type { ToolcraftProductSvgExportRenderer } from "./product-svg-export-renderer";
+
+export function getToolcraftExportRendererCoverageErrors({
+  exportRenderer,
+  productSceneRequired,
+  schema,
+  svgExportRenderer,
+}: Readonly<{
+  exportRenderer: ToolcraftProductExportRenderer | undefined;
+  productSceneRequired: boolean;
+  schema: ResolvedToolcraftAppSchema;
+  svgExportRenderer: ToolcraftProductSvgExportRenderer | undefined;
+}>): string[] {
+  const errors: string[] = [];
+  const exportRoles = new Set(
+    getToolcraftArtifactExportActions(schema).map(({ role }) => role),
+  );
+  const hasRasterExportAction =
+    exportRoles.has("export-image") || exportRoles.has("export-video");
+  const hasSvgExportAction = exportRoles.has("export-svg");
+
+  if (hasRasterExportAction && productSceneRequired && !exportRenderer) {
+    errors.push("Product-owned image/video export actions require exportRenderer.");
+  }
+  if (exportRenderer && !productSceneRequired) {
+    errors.push("exportRenderer requires a product-owned scene.");
+  }
+  if (exportRenderer && !hasRasterExportAction) {
+    errors.push("exportRenderer requires a typed image or video export action.");
+  }
+  if (exportRenderer && exportRenderer.baseFileName.trim().length === 0) {
+    errors.push("exportRenderer.baseFileName must not be blank.");
+  }
+
+  if (hasSvgExportAction && !svgExportRenderer) {
+    errors.push("A typed SVG export action requires svgExportRenderer.");
+  }
+  if (svgExportRenderer && !hasSvgExportAction) {
+    errors.push("svgExportRenderer requires a typed SVG export action.");
+  }
+  if (
+    svgExportRenderer &&
+    svgExportRenderer.baseFileName.trim().length === 0
+  ) {
+    errors.push("svgExportRenderer.baseFileName must not be blank.");
+  }
+
+  return errors;
+}

package/templates/runtime/export/export.test.ts

@@ -1,9 +1,18 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, expectTypeOf, it } from "vitest";
 
+import * as toolcraftRuntimeRoot from "../index";
 import { defineToolcraft } from "../schema/define-toolcraft";
 import type { ToolcraftState } from "../state/types";
+import type {
+  ToolcraftArtifactSize,
+  ToolcraftExportFrame,
+  ToolcraftPreviewBackgroundOptions,
+  ToolcraftProductExportFrameContext,
+  ToolcraftProductExportFrameRenderer,
+  ToolcraftProductExportRenderer,
+  ToolcraftRetinaExportSize,
+} from "../index";
 import {
-  shouldIncludeToolcraftExportBackground,
   shouldIncludeToolcraftPreviewBackground,
 } from "./export-background";
 import {
@@ -50,29 +59,41 @@ function createState(schema = defineToolcraft({ canvas: { enabled: true }, panel
 }
 
 describe("Toolcraft export helpers", () => {
-  it("normalizes png export background to include by default", () => {
-    const schema = defineToolcraft({
-      canvas: { enabled: true },
-      panels: {},
+  it("keeps the runtime root limited to product-safe export primitives", () => {
+    expect(toolcraftRuntimeRoot).toMatchObject({
+      getToolcraftImageExportSize: expect.any(Function),
+      getToolcraftRetinaExportPixelRatio: expect.any(Function),
+      getToolcraftRetinaExportSize: expect.any(Function),
+      getToolcraftVideoExportSize: expect.any(Function),
+      shouldIncludeToolcraftPreviewBackground: expect.any(Function),
+      TOOLCRAFT_MAX_EXPORT_EDGE_PX: 8192,
+      TOOLCRAFT_MAX_EXPORT_PIXELS: 8192 * 8192,
+      toolcraftImageExportFormatTarget: "export.image.format",
+      toolcraftImageExportResolutionTarget: "export.image.resolution",
+      toolcraftVideoExportFormatTarget: "export.video.format",
+      toolcraftVideoExportResolutionTarget: "export.video.resolution",
+      validateToolcraftArtifactSize: expect.any(Function),
     });
-
-    expect(schema.export.png.background).toBe("include");
-  });
-
-  it("preserves transparent png export background option", () => {
-    const schema = defineToolcraft({
-      canvas: { enabled: true },
-      export: {
-        png: {
-          background: "transparent",
-        },
-      },
-      panels: {},
-    });
-
-    expect(schema.export.png.background).toBe("transparent");
-    expect(shouldIncludeToolcraftExportBackground({ format: "png", schema })).toBe(false);
-    expect(shouldIncludeToolcraftExportBackground({ format: "video", schema })).toBe(true);
+    expect(toolcraftRuntimeRoot).not.toHaveProperty("exportToolcraftImageArtifact");
+    expect(toolcraftRuntimeRoot).not.toHaveProperty("exportToolcraftVideoArtifact");
+    expect(toolcraftRuntimeRoot).not.toHaveProperty(
+      "createToolcraftVideoEncoderBackend",
+    );
+    expect(toolcraftRuntimeRoot).not.toHaveProperty(
+      "createToolcraftVideoFrameSchedule",
+    );
+
+    expectTypeOf<ToolcraftArtifactSize>().toMatchTypeOf<
+      Readonly<{ height: number; width: number }>
+    >();
+    expectTypeOf<ToolcraftExportFrame>().toMatchTypeOf<
+      Readonly<{ height: number; width: number; x: number; y: number }>
+    >();
+    expectTypeOf<ToolcraftPreviewBackgroundOptions>().toHaveProperty("state");
+    expectTypeOf<ToolcraftProductExportFrameContext>().toHaveProperty("frame");
+    expectTypeOf<ToolcraftProductExportFrameRenderer>().toBeFunction();
+    expectTypeOf<ToolcraftProductExportRenderer>().toHaveProperty("renderFrame");
+    expectTypeOf<ToolcraftRetinaExportSize>().toHaveProperty("pixelRatio");
   });
 
   it("uses include-background runtime state for live preview background", () => {
@@ -103,24 +124,6 @@ describe("Toolcraft export helpers", () => {
     expect(shouldIncludeToolcraftPreviewBackground({ state })).toBe(true);
   });
 
-  it("keeps video export background independent from preview include state", () => {
-    const schema = defineToolcraft({
-      canvas: { enabled: true },
-      export: {
-        png: {
-          background: "transparent",
-        },
-      },
-      panels: {},
-    });
-    const state = createState(schema);
-
-    state.values["export.includeBackground"] = false;
-
-    expect(shouldIncludeToolcraftPreviewBackground({ state })).toBe(false);
-    expect(shouldIncludeToolcraftExportBackground({ format: "video", schema })).toBe(true);
-  });
-
   it("uses at least 2x pixel ratio for retina export", () => {
     expect(getToolcraftRetinaExportPixelRatio(1)).toBe(2);
     expect(getToolcraftRetinaExportPixelRatio(1.5)).toBe(2);

package/templates/runtime/export/image-artifact-export.ts

@@ -11,7 +11,7 @@ import {
 import type { ToolcraftArtifactExportRequest } from "./artifact-export-request";
 import { resolveToolcraftImageExportSettings } from "./artifact-export-settings";
 import { renderToolcraftArtifactFrame } from "./artifact-frame-renderer";
-import { resolveToolcraftImageArtifactFrame } from "./artifact-scene-frame";
+import { resolveToolcraftStillArtifactFrame } from "./artifact-scene-frame";
 import { createToolcraftArtifactFrameState } from "./artifact-frame-state";
 import {
   ToolcraftSceneExportError,
@@ -80,7 +80,7 @@ export async function exportToolcraftImageArtifact(
     request.state,
     request.state.timeline.currentTimeSeconds,
   );
-  const frame = resolveToolcraftImageArtifactFrame({
+  const frame = resolveToolcraftStillArtifactFrame({
     boundsProvider: request.boundsProvider,
     productSceneRequired: request.productSceneRequired,
     state: frameState,

package/templates/runtime/export/index.ts

@@ -1,16 +1,57 @@
-export * from "./artifact-export-settings";
-export * from "./artifact-export-request";
-export * from "./artifact-download";
-export * from "./artifact-frame-renderer";
-export * from "./artifact-scene-frame";
-export * from "./artifact-frame-state";
-export * from "./export-error";
-export * from "./export-background";
-export * from "./export-frame";
-export * from "./export-sizing";
-export * from "./image-artifact-export";
-export * from "./product-export-renderer";
-export * from "./video-artifact-export";
-export * from "./video-encoding-backend";
-export * from "./video-encoding-policy";
-export * from "./video-frame-schedule";
+export {
+  toolcraftImageExportFormatTarget,
+  toolcraftImageExportResolutionTarget,
+  toolcraftVideoExportFormatTarget,
+  toolcraftVideoExportResolutionTarget,
+} from "./artifact-export-settings";
+export type {
+  ToolcraftImageExportFormat,
+  ToolcraftImageExportPresetResolution,
+  ToolcraftResolvedImageExportSettings,
+  ToolcraftResolvedVideoExportSettings,
+  ToolcraftVideoExportFormat,
+  ToolcraftVideoExportPresetResolution,
+} from "./artifact-export-settings";
+export { shouldIncludeToolcraftPreviewBackground } from "./export-background";
+export type { ToolcraftPreviewBackgroundOptions } from "./export-background";
+export {
+  TOOLCRAFT_MAX_EXPORT_EDGE_PX,
+  TOOLCRAFT_MAX_EXPORT_PIXELS,
+  validateToolcraftArtifactSize,
+} from "./export-frame";
+export type {
+  ToolcraftArtifactSize,
+  ToolcraftExportFrame,
+} from "./export-frame";
+export {
+  getToolcraftImageExportSize,
+  getToolcraftRetinaExportPixelRatio,
+  getToolcraftRetinaExportSize,
+  getToolcraftVideoExportSize,
+} from "./export-sizing";
+export type {
+  ToolcraftExportSizeOptions,
+  ToolcraftImageExportResolution,
+  ToolcraftImageExportSizeOptions,
+  ToolcraftRetinaExportSize,
+  ToolcraftVideoExportResolution,
+  ToolcraftVideoExportSizeOptions,
+} from "./export-sizing";
+export type {
+  ToolcraftProductExportFrameContext,
+  ToolcraftProductExportFrameRenderer,
+  ToolcraftProductExportRenderer,
+} from "./product-export-renderer";
+export type {
+  ToolcraftProductSvgExportFrameContext,
+  ToolcraftProductSvgExportFrameRenderer,
+  ToolcraftProductSvgExportRenderer,
+} from "./product-svg-export-renderer";
+export {
+  TOOLCRAFT_FORBIDDEN_SVG_ELEMENTS,
+  TOOLCRAFT_SVG_BACKGROUND_ATTRIBUTE,
+  TOOLCRAFT_SVG_NAMESPACE,
+  TOOLCRAFT_SVG_NON_RENDERING_CONTAINERS,
+  TOOLCRAFT_SVG_PRODUCT_SCENE_ATTRIBUTE,
+  TOOLCRAFT_SVG_VECTOR_PRIMITIVES,
+} from "./svg-policy";

package/templates/runtime/export/product-export-renderer.test.ts

@@ -1,9 +1,9 @@
 import { describe, expect, it, vi } from "vitest";
 
 import { defineToolcraft } from "../schema/define-toolcraft";
-import { getToolcraftExportRendererCoverageErrors } from "./product-export-renderer";
+import { getToolcraftExportRendererCoverageErrors } from "./export-renderer-coverage";
 
-function createSchema(role?: "export-image" | "export-video") {
+function createSchema(role?: "export-image" | "export-svg" | "export-video") {
   return defineToolcraft({
     canvas: { enabled: true },
     panels: role
@@ -37,8 +37,9 @@ describe("export renderer coverage", () => {
         exportRenderer: undefined,
         productSceneRequired: true,
         schema: createSchema("export-image"),
+        svgExportRenderer: undefined,
       }),
-    ).toContain("Product-owned export actions require exportRenderer.");
+    ).toContain("Product-owned image/video export actions require exportRenderer.");
   });
 
   it("allows runtime-only scenes to use runtime composition", () => {
@@ -47,6 +48,7 @@ describe("export renderer coverage", () => {
         exportRenderer: undefined,
         productSceneRequired: false,
         schema: createSchema("export-video"),
+        svgExportRenderer: undefined,
       }),
     ).toEqual([]);
   });
@@ -57,6 +59,7 @@ describe("export renderer coverage", () => {
         exportRenderer: renderer,
         productSceneRequired: false,
         schema: createSchema("export-image"),
+        svgExportRenderer: undefined,
       }),
     ).toContain("exportRenderer requires a product-owned scene.");
     expect(
@@ -64,6 +67,7 @@ describe("export renderer coverage", () => {
         exportRenderer: { ...renderer, baseFileName: "   " },
         productSceneRequired: true,
         schema: createSchema("export-image"),
+        svgExportRenderer: undefined,
       }),
     ).toContain("exportRenderer.baseFileName must not be blank.");
     expect(
@@ -71,7 +75,37 @@ describe("export renderer coverage", () => {
         exportRenderer: renderer,
         productSceneRequired: true,
         schema: createSchema(),
+        svgExportRenderer: undefined,
       }),
-    ).toContain("exportRenderer requires a typed export action.");
+    ).toContain("exportRenderer requires a typed image or video export action.");
+  });
+
+  it("requires SVG actions and renderers to correspond", () => {
+    expect(
+      getToolcraftExportRendererCoverageErrors({
+        exportRenderer: undefined,
+        productSceneRequired: false,
+        schema: createSchema("export-svg"),
+        svgExportRenderer: undefined,
+      }),
+    ).toContain("A typed SVG export action requires svgExportRenderer.");
+
+    expect(
+      getToolcraftExportRendererCoverageErrors({
+        exportRenderer: undefined,
+        productSceneRequired: false,
+        schema: createSchema(),
+        svgExportRenderer: renderer,
+      }),
+    ).toContain("svgExportRenderer requires a typed SVG export action.");
+
+    expect(
+      getToolcraftExportRendererCoverageErrors({
+        exportRenderer: undefined,
+        productSceneRequired: false,
+        schema: createSchema("export-svg"),
+        svgExportRenderer: { ...renderer, baseFileName: "   " },
+      }),
+    ).toContain("svgExportRenderer.baseFileName must not be blank.");
   });
 });

package/templates/runtime/export/product-export-renderer.ts

@@ -1,5 +1,4 @@
 import type { ToolcraftRendererPipelineClient } from "../rendering";
-import type { ResolvedToolcraftAppSchema } from "../schema/types";
 import type { ToolcraftState } from "../state/types";
 import type { ToolcraftExportFrame } from "./export-frame";
 
@@ -21,43 +20,3 @@ export type ToolcraftProductExportRenderer = Readonly<{
   baseFileName: string;
   renderFrame: ToolcraftProductExportFrameRenderer;
 }>;
-
-function hasTypedExportAction(schema: ResolvedToolcraftAppSchema): boolean {
-  return (schema.panels.controls?.sections ?? []).some((section) =>
-    Object.values(section.controls).some((control) =>
-      (control.actions ?? []).some(
-        (action) =>
-          typeof action !== "string" &&
-          (action.role === "export-image" || action.role === "export-video"),
-      ),
-    ),
-  );
-}
-
-export function getToolcraftExportRendererCoverageErrors({
-  exportRenderer,
-  productSceneRequired,
-  schema,
-}: Readonly<{
-  exportRenderer: ToolcraftProductExportRenderer | undefined;
-  productSceneRequired: boolean;
-  schema: ResolvedToolcraftAppSchema;
-}>): string[] {
-  const errors: string[] = [];
-  const hasExportAction = hasTypedExportAction(schema);
-
-  if (hasExportAction && productSceneRequired && !exportRenderer) {
-    errors.push("Product-owned export actions require exportRenderer.");
-  }
-  if (exportRenderer && !productSceneRequired) {
-    errors.push("exportRenderer requires a product-owned scene.");
-  }
-  if (exportRenderer && !hasExportAction) {
-    errors.push("exportRenderer requires a typed export action.");
-  }
-  if (exportRenderer && exportRenderer.baseFileName.trim().length === 0) {
-    errors.push("exportRenderer.baseFileName must not be blank.");
-  }
-
-  return errors;
-}

package/templates/runtime/export/product-svg-export-renderer.ts

@@ -0,0 +1,21 @@
+import type { ToolcraftRendererPipelineClient } from "../rendering";
+import type { ToolcraftState } from "../state/types";
+import type { ToolcraftExportFrame } from "./export-frame";
+
+export type ToolcraftProductSvgExportFrameContext = Readonly<{
+  container: SVGGElement;
+  frame: ToolcraftExportFrame;
+  rendererPipeline: ToolcraftRendererPipelineClient | null;
+  state: Readonly<ToolcraftState>;
+  timeSeconds: number;
+  timelineProgress: number;
+}>;
+
+export type ToolcraftProductSvgExportFrameRenderer = (
+  context: ToolcraftProductSvgExportFrameContext,
+) => PromiseLike<void> | void;
+
+export type ToolcraftProductSvgExportRenderer = Readonly<{
+  baseFileName: string;
+  renderFrame: ToolcraftProductSvgExportFrameRenderer;
+}>;

package/templates/runtime/export/svg-artifact-export.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { createToolcraftRuntimeSceneVisibility } from "../scene";
+import { defineToolcraft } from "../schema/define-toolcraft";
+import { createToolcraftState } from "../state/create-template-state";
+import type {
+  ToolcraftArtifactDownloadRequest,
+  ToolcraftArtifactDownloadResult,
+} from "./artifact-download";
+import { exportToolcraftSvgArtifact } from "./svg-artifact-export";
+import { TOOLCRAFT_SVG_NAMESPACE } from "./svg-policy";
+
+const visibility = createToolcraftRuntimeSceneVisibility({
+  renderDefaultImages: true,
+  suppressedModelTargets: [],
+});
+
+function createState() {
+  return createToolcraftState(
+    defineToolcraft({ canvas: { enabled: true }, panels: {} }),
+  );
+}
+
+describe("exportToolcraftSvgArtifact", () => {
+  it("renders current vectors, downloads SVG, and reports monotonic progress", async () => {
+    const progress: number[] = [];
+    const downloadArtifact = vi.fn(
+      (
+        _request: ToolcraftArtifactDownloadRequest,
+      ): ToolcraftArtifactDownloadResult => ({
+        fileName: "column-graph.svg",
+      }),
+    );
+    const state = createState();
+
+    const result = await exportToolcraftSvgArtifact({
+      boundsProvider: undefined,
+      downloadArtifact,
+      productSceneRequired: true,
+      rendererPipeline: null,
+      reportProgress: (value) => progress.push(value),
+      state,
+      svgExportRenderer: {
+        baseFileName: "column-graph",
+        renderFrame: ({ container, frame, state: frameState }) => {
+          expect(frameState).not.toBe(state);
+          const rect = container.ownerDocument.createElementNS(
+            TOOLCRAFT_SVG_NAMESPACE,
+            "rect",
+          );
+          rect.setAttribute("width", String(frame.width));
+          rect.setAttribute("height", String(frame.height));
+          rect.setAttribute("data-column-graph-background", "true");
+          container.append(rect);
+        },
+      },
+      visibility,
+    });
+
+    expect(progress).toEqual([0.1, 0.65, 0.9, 1]);
+    expect(result).toMatchObject({
+      extension: ".svg",
+      mediaType: "image/svg+xml",
+      vectorElementCount: 1,
+    });
+    expect(result.byteLength).toBeGreaterThan(0);
+    expect(downloadArtifact).toHaveBeenCalledOnce();
+    const request = downloadArtifact.mock.calls[0]?.[0];
+    expect(request?.extension).toBe(".svg");
+    expect(request?.rawBaseFileName).toBe("column-graph");
+    expect(request?.blob.type).toBe("image/svg+xml;charset=utf-8");
+    await expect(request?.blob.text()).resolves.toContain(
+      'data-column-graph-background="true"',
+    );
+  });
+
+  it("normalizes product renderer failures", async () => {
+    await expect(
+      exportToolcraftSvgArtifact({
+        boundsProvider: undefined,
+        downloadArtifact: vi.fn(),
+        productSceneRequired: false,
+        rendererPipeline: null,
+        reportProgress: vi.fn(),
+        state: createState(),
+        svgExportRenderer: {
+          baseFileName: "broken",
+          renderFrame: () => {
+            throw new Error("renderer exploded");
+          },
+        },
+        visibility,
+      }),
+    ).rejects.toMatchObject({
+      feedback: { code: "svg-render-failed" },
+    });
+  });
+});