@pascal-app/editor 1.0.0-beta.4 → 1.0.0

package/src/lib/floorplan/floorplan-export.test.ts

@@ -1,11 +1,24 @@
 import { describe, expect, test } from 'bun:test'
-import type { FloorplanGeometry } from '@pascal-app/core'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  type FloorplanGeometry,
+  type GeometryContext,
+  loadPlugin,
+  type NodeCategory,
+  nodeRegistry,
+  registerNode,
+} from '@pascal-app/core'
+import PDFDocument from 'pdfkit'
+import { z } from 'zod'
 import { splitFloorplanOverlay } from '../../components/editor-2d/renderers/floorplan-registry-layer'
 import { DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY } from './annotation-visibility'
 import {
+  collectFloorplanGeometry,
   filterFloorplanExportOverlay,
   fitPlanToBox,
   isFloorplanExportAnnotationGeometry,
+  isFloorplanNodeInExportScope,
   partitionFloorplanExportOverlay,
   resolveFloorplanExportAnnotationVisibility,
   resolveFloorplanExportNodeGeometry,
@@ -19,6 +32,63 @@ import {
   rotateFloorplanExportBounds,
 } from './floorplan-export'
 import { floorplanGeometryMetadata } from './floorplan-extension'
+import { FloorplanPdfDocument } from './floorplan-pdfkit-document'
+import { renderFloorplanGeometryToPdfKit } from './floorplan-pdfkit-renderer'
+
+type GroupGeometry = Extract<FloorplanGeometry, { kind: 'group' }>
+type GroupTransform = NonNullable<GroupGeometry['transform']>
+
+function flattenGeometry(geometry: FloorplanGeometry | null): FloorplanGeometry[] {
+  if (!geometry) return []
+  if (geometry.kind !== 'group') return [geometry]
+  return [geometry, ...geometry.children.flatMap(flattenGeometry)]
+}
+
+function applyGeometryTransforms(
+  point: readonly [number, number],
+  transforms: readonly GroupTransform[],
+): [number, number] {
+  let x = point[0]
+  let y = point[1]
+  for (let index = transforms.length - 1; index >= 0; index -= 1) {
+    const transform = transforms[index]!
+    if (transform.rotate !== undefined) {
+      const cos = Math.cos(transform.rotate)
+      const sin = Math.sin(transform.rotate)
+      const rotatedX = x * cos - y * sin
+      y = x * sin + y * cos
+      x = rotatedX
+    }
+    if (transform.translate) {
+      x += transform.translate[0]
+      y += transform.translate[1]
+    }
+  }
+  return [x, y]
+}
+
+function projectedGeometryPoint(
+  geometry: FloorplanGeometry,
+  target: 'circle' | 'image',
+  transforms: readonly GroupTransform[] = [],
+): [number, number] | null {
+  if (geometry.kind === target) {
+    const point =
+      geometry.kind === 'circle'
+        ? ([geometry.cx, geometry.cy] as const)
+        : geometry.kind === 'image'
+          ? geometry.center
+          : null
+    return point ? applyGeometryTransforms(point, transforms) : null
+  }
+  if (geometry.kind !== 'group') return null
+  const nestedTransforms = geometry.transform ? [...transforms, geometry.transform] : transforms
+  for (const child of geometry.children) {
+    const point = projectedGeometryPoint(child, target, nestedTransforms)
+    if (point) return point
+  }
+  return null
+}
 
 describe('filterFloorplanExportOverlay', () => {
   test('preserves annotation metadata while splitting geometry passes', () => {
@@ -317,3 +387,329 @@ describe('resolveFloorplanPageLayout', () => {
     })
   })
 })
+
+describe('isFloorplanNodeInExportScope', () => {
+  const definition = (category?: NodeCategory) => ({ category })
+
+  test('includes structure-category nodes under structure and full', () => {
+    expect(isFloorplanNodeInExportScope(definition('structure'), 'structure')).toBe(true)
+    expect(isFloorplanNodeInExportScope(definition('structure'), 'full')).toBe(true)
+  })
+
+  test('excludes utility-category nodes under structure', () => {
+    expect(isFloorplanNodeInExportScope(definition('utility'), 'full')).toBe(true)
+    expect(isFloorplanNodeInExportScope(definition('utility'), 'structure')).toBe(false)
+  })
+
+  test('includes furnish-category nodes only under full', () => {
+    expect(isFloorplanNodeInExportScope(definition('furnish'), 'full')).toBe(true)
+    expect(isFloorplanNodeInExportScope(definition('furnish'), 'structure')).toBe(false)
+  })
+
+  test('includes analysis and site-category nodes only under full', () => {
+    for (const category of ['analysis', 'site'] as const) {
+      expect(isFloorplanNodeInExportScope(definition(category), 'full')).toBe(true)
+      expect(isFloorplanNodeInExportScope(definition(category), 'structure')).toBe(false)
+    }
+  })
+
+  test('excludes nodes with no category except under full', () => {
+    expect(isFloorplanNodeInExportScope(definition(undefined), 'full')).toBe(true)
+    expect(isFloorplanNodeInExportScope(definition(undefined), 'structure')).toBe(false)
+  })
+
+  test('handles an undefined definition like a no-category node', () => {
+    expect(isFloorplanNodeInExportScope(undefined, 'full')).toBe(true)
+    expect(isFloorplanNodeInExportScope(undefined, 'structure')).toBe(false)
+  })
+})
+
+describe('collectFloorplanGeometry', () => {
+  test('collects the active Site once below architecture with semantic context and projection', async () => {
+    const restoreRegistry = nodeRegistry._snapshot()
+    const activeSiteId = 'site_active'
+    const otherSiteId = 'site_other'
+    const enabledPluginId = 'test:site-pdf-enabled'
+    const disabledPluginId = 'test:site-pdf-disabled'
+    const enabledKind = 'test:site-pdf-overlay'
+    const disabledKind = 'test:site-pdf-disabled-overlay'
+    const architectureKind = 'test:level-architecture'
+    const semanticChildId = 'site_overlay_detail'
+    const referencedNodeId = 'site_reference'
+    const inlinePng =
+      'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII='
+
+    const siteDefinition = (
+      kind: string,
+      floorplan: (node: Record<string, unknown>, context: GeometryContext) => FloorplanGeometry,
+    ): AnyNodeDefinition =>
+      ({
+        kind,
+        schemaVersion: 1,
+        schema: z.object({ type: z.literal(kind) }) as never,
+        category: 'utility',
+        defaults: () => ({}) as never,
+        capabilities: {},
+        floorplanScope: 'site',
+        floorplan,
+      }) as AnyNodeDefinition
+
+    const enabledDefinition = siteDefinition(enabledKind, (siteOverlay, context) => ({
+      kind: 'group',
+      children: [
+        {
+          kind: 'rect',
+          x: 10,
+          y: 3,
+          width: context.children[0]?.id === semanticChildId ? 3 : -3,
+          height: context.siblings.some(({ id }) => id === 'site_overlay_hidden') ? 4 : -4,
+          fill:
+            siteOverlay.id === 'site_overlay' &&
+            context.parent?.id === activeSiteId &&
+            context.resolve(referencedNodeId)?.id === referencedNodeId
+              ? '#102030'
+              : '#ff0000',
+        },
+        {
+          kind: 'path',
+          d: 'M0,0H4V4H0ZM1,1H3V3H1Z',
+          fill: '#3f6b2f',
+          fillRule: 'evenodd',
+        },
+        {
+          kind: 'image',
+          url: inlinePng,
+          center: [10, 3],
+          width: 1,
+          height: 1,
+        },
+        { kind: 'circle', cx: 12, cy: 5, r: 0.5 },
+      ],
+    }))
+
+    try {
+      nodeRegistry._reset()
+      registerNode({
+        kind: architectureKind,
+        schemaVersion: 1,
+        schema: z.object({ type: z.literal(architectureKind) }) as never,
+        category: 'structure',
+        defaults: () => ({}) as never,
+        capabilities: {},
+        floorplan: () => ({
+          kind: 'polygon',
+          points: [
+            [0, 0],
+            [4, 0],
+            [4, 4],
+          ],
+        }),
+      } as AnyNodeDefinition)
+      await loadPlugin({
+        id: enabledPluginId,
+        apiVersion: 1,
+        nodes: [enabledDefinition],
+      })
+      await loadPlugin({
+        id: disabledPluginId,
+        apiVersion: 1,
+        nodes: [siteDefinition(disabledKind, () => ({ kind: 'circle', cx: 0, cy: 0, r: 1 }))],
+      })
+
+      const activeSite = {
+        id: activeSiteId,
+        type: 'site',
+        parentId: null,
+        visible: true,
+        children: [
+          'building_active',
+          'site_overlay',
+          'site_overlay_hidden',
+          'site_overlay_disabled',
+        ],
+      } as unknown as AnyNode
+      const activeBuilding = {
+        id: 'building_active',
+        type: 'building',
+        parentId: activeSiteId,
+        children: ['level_active', 'level_upper'],
+        position: [10, 0, 5],
+        rotation: [0, Math.PI / 2, 0],
+      } as unknown as AnyNode
+      const activeLevel = {
+        id: 'level_active',
+        type: 'level',
+        parentId: activeBuilding.id,
+        children: ['level_architecture'],
+      } as unknown as AnyNode
+      const upperLevel = {
+        id: 'level_upper',
+        type: 'level',
+        parentId: activeBuilding.id,
+        children: ['level_upper_architecture'],
+      } as unknown as AnyNode
+      const nodes = {
+        [activeSite.id]: activeSite,
+        [activeBuilding.id]: activeBuilding,
+        [activeLevel.id]: activeLevel,
+        [upperLevel.id]: upperLevel,
+        level_upper_architecture: {
+          id: 'level_upper_architecture',
+          type: architectureKind,
+          parentId: upperLevel.id,
+          visible: true,
+        } as unknown as AnyNode,
+        level_architecture: {
+          id: 'level_architecture',
+          type: architectureKind,
+          parentId: activeLevel.id,
+          visible: true,
+        } as unknown as AnyNode,
+        site_overlay: {
+          id: 'site_overlay',
+          type: enabledKind,
+          parentId: null,
+          children: [semanticChildId],
+          visible: true,
+        } as unknown as AnyNode,
+        [semanticChildId]: {
+          id: semanticChildId,
+          type: 'test:site-detail',
+          parentId: 'site_overlay',
+        } as unknown as AnyNode,
+        [referencedNodeId]: {
+          id: referencedNodeId,
+          type: 'test:site-reference',
+          parentId: activeSiteId,
+        } as unknown as AnyNode,
+        site_overlay_hidden: {
+          id: 'site_overlay_hidden',
+          type: enabledKind,
+          parentId: activeSiteId,
+          visible: false,
+        } as unknown as AnyNode,
+        site_overlay_disabled: {
+          id: 'site_overlay_disabled',
+          type: disabledKind,
+          parentId: activeSiteId,
+          visible: true,
+        } as unknown as AnyNode,
+        [otherSiteId]: {
+          id: otherSiteId,
+          type: 'site',
+          parentId: null,
+          children: ['site_overlay_other'],
+        } as unknown as AnyNode,
+        site_overlay_other: {
+          id: 'site_overlay_other',
+          type: enabledKind,
+          parentId: otherSiteId,
+          visible: true,
+        } as unknown as AnyNode,
+      }
+
+      const full = collectFloorplanGeometry(
+        nodes,
+        activeLevel.id,
+        'full',
+        'metric',
+        'meters',
+        DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        'floor-plan',
+        'finished-faces',
+        [enabledPluginId],
+      )
+
+      expect(full.map(({ id }) => id)).toEqual(['site_overlay', 'level_architecture'])
+      const siteModel = full[0]?.model
+      if (!siteModel) throw new Error('Expected Site geometry')
+      const siteParts = flattenGeometry(siteModel)
+      expect(siteParts).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            kind: 'rect',
+            width: 3,
+            height: 4,
+            fill: '#102030',
+          }),
+          expect.objectContaining({ kind: 'path', fillRule: 'evenodd' }),
+          expect.objectContaining({ kind: 'image', url: inlinePng }),
+        ]),
+      )
+      expect(projectedGeometryPoint(siteModel, 'image')).toEqual([
+        expect.closeTo(2),
+        expect.closeTo(0),
+      ])
+      expect(projectedGeometryPoint(siteModel, 'circle')).toEqual([
+        expect.closeTo(0),
+        expect.closeTo(2),
+      ])
+
+      const rawPdf = new PDFDocument({ autoFirstPage: false, compress: false })
+      const chunks: Buffer[] = []
+      rawPdf.on('data', (chunk: Buffer) => chunks.push(chunk))
+      const completedPdf = Promise.withResolvers<string>()
+      rawPdf.on('end', () => completedPdf.resolve(Buffer.concat(chunks).toString('latin1')))
+      const pdf = new FloorplanPdfDocument(rawPdf, [200, 200])
+      pdf.addPage()
+      for (const { model } of full) {
+        if (!model) continue
+        await renderFloorplanGeometryToPdfKit(pdf, model, {
+          annotationLayer: false,
+          placement: { x: 20, y: 20, width: 100, height: 100 },
+          rotationDeg: 0,
+          viewport: { x: -4, y: -4, width: 20, height: 20 },
+        })
+      }
+      rawPdf.end()
+      const renderedPdf = await completedPdf.promise
+      expect(renderedPdf).toMatch(/f\*/)
+      expect(renderedPdf).toContain('/Subtype /Image')
+
+      const upper = collectFloorplanGeometry(
+        nodes,
+        upperLevel.id,
+        'full',
+        'metric',
+        'meters',
+        DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        'floor-plan',
+        'finished-faces',
+        [enabledPluginId],
+      )
+      expect(upper.map(({ id }) => id)).toEqual(['site_overlay', 'level_upper_architecture'])
+
+      const hiddenSiteNodes = {
+        ...nodes,
+        [activeSite.id]: { ...activeSite, visible: false } as AnyNode,
+      }
+      const hiddenSite = collectFloorplanGeometry(
+        hiddenSiteNodes,
+        activeLevel.id,
+        'full',
+        'metric',
+        'meters',
+        DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        'floor-plan',
+        'finished-faces',
+        [enabledPluginId],
+      )
+      expect(hiddenSite.map(({ id }) => id)).toEqual(['level_architecture'])
+
+      const structure = collectFloorplanGeometry(
+        nodes,
+        activeLevel.id,
+        'structure',
+        'metric',
+        'meters',
+        DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+        'floor-plan',
+        'finished-faces',
+        [enabledPluginId],
+      )
+      expect(structure.map(({ id }) => id)).toEqual(['level_architecture'])
+    } finally {
+      restoreRegistry()
+    }
+  })
+})

package/src/lib/floorplan/floorplan-export.tsx

@@ -7,7 +7,9 @@ import {
   type FloorplanGeometry,
   type FloorplanPalette,
   type FloorplanPoint,
+  isNodeKindEnabled,
   type LiveNodeOverrides,
+  type NodeCategory,
   nodeRegistry,
   resolveBuildingForLevel,
   useScene,
@@ -20,10 +22,13 @@ import { resolveSvgAnnotationCollisions } from '../../components/editor-2d/rende
 import { FloorplanGeometryRenderer } from '../../components/editor-2d/renderers/floorplan-geometry-renderer'
 import {
   buildContext,
+  collectDirectFloorplanScopeNodes,
   collectFloorplanLinkedLevelNodes,
   floorplanLayerRank,
   getFloorplanLevelData,
+  isFloorplanHierarchyVisible,
   isFloorplanNodeVisible,
+  siteToFloorplanTransform,
   splitFloorplanOverlay,
 } from '../../components/editor-2d/renderers/floorplan-registry-layer'
 import useDrawingView, { DRAWING_TYPE_OPTIONS } from '../../store/use-drawing-view'
@@ -69,6 +74,20 @@ import { FLOORPLAN_VIEW_ROTATION_DEG } from './geometry'
  */
 export type FloorplanExportScope = 'full' | 'structure'
 
+/**
+ * Whether a node belongs in the given export scope. `'full'` short-circuits
+ * and admits every node; `'structure'` admits only `structure`-category
+ * nodes. An `undefined` definition (unregistered node type) behaves like a
+ * node with no category.
+ */
+export function isFloorplanNodeInExportScope(
+  definition: { category?: NodeCategory } | undefined,
+  scope: FloorplanExportScope,
+): boolean {
+  if (scope === 'full') return true
+  return definition?.category === 'structure'
+}
+
 const SVG_NS = 'http://www.w3.org/2000/svg'
 /** Minimum and proportional margin around the structural drawing bounds. */
 const MIN_PLAN_PADDING_M = 1
@@ -131,12 +150,27 @@ type ExportGeometry = {
   annotations: FloorplanGeometry | null
 }
 
+type ExportGeometryContext = {
+  children: AnyNode[]
+  siblings: AnyNode[]
+  parent: AnyNode
+  outputTransform: { translate: FloorplanPoint; rotate: number }
+}
+
+type ExportGeometryEntry = {
+  id: AnyNodeId
+  node: AnyNode
+  parentOverride?: AnyNode
+  context?: ExportGeometryContext
+  scopeRank?: number
+}
+
 export type FloorplanPageLayout = {
   planBox: { x: number; y: number; width: number; height: number }
 }
 
 export async function exportFloorplanPdf(scope: FloorplanExportScope): Promise<void> {
-  const nodes = useScene.getState().nodes
+  const { nodes, installedPlugins } = useScene.getState()
   const viewer = useViewer.getState()
   const unit = viewer.unit
   const metricNotation = viewer.metricNotation
@@ -183,6 +217,7 @@ export async function exportFloorplanPdf(scope: FloorplanExportScope): Promise<v
         annotationVisibility,
         drawingType,
         wallDimensionReference,
+        installedPlugins,
       )
       const schedules = collectFloorplanSchedules(nodes, level.id, unit)
       if (geometries.length === 0 && schedules.length === 0) continue
@@ -721,7 +756,7 @@ function applyFloorplanViewport(
   mounted.svg.insertBefore(background, mounted.svg.firstChild)
 }
 
-function collectFloorplanGeometry(
+export function collectFloorplanGeometry(
   nodes: Record<string, AnyNode>,
   levelId: AnyNodeId,
   scope: FloorplanExportScope,
@@ -730,10 +765,11 @@ function collectFloorplanGeometry(
   annotationVisibility: FloorplanAnnotationVisibility,
   drawingType: ConstructionDrawingType,
   wallDimensionReference: FloorplanWallDimensionReference,
+  installedPlugins: readonly string[],
 ): ExportGeometry[] {
   const noLiveOverrides = new Map<string, LiveNodeOverrides>()
   const levelNodeIdsByType = new Map<string, AnyNodeId[]>()
-  const entries: { id: AnyNodeId; node: AnyNode; parentOverride?: AnyNode }[] = []
+  const entries: ExportGeometryEntry[] = []
 
   const visit = (id: AnyNodeId) => {
     const node = nodes[id]
@@ -747,7 +783,7 @@ function collectFloorplanGeometry(
     if (
       def?.floorplan &&
       isFloorplanNodeVisible(node) &&
-      (scope === 'full' || def.category === 'structure')
+      isFloorplanNodeInExportScope(def, scope)
     ) {
       const drawingNode = resolveNodeForDrawingType(node, nodes, drawingType)
       if (drawingNode) entries.push({ id, node: drawingNode })
@@ -758,31 +794,74 @@ function collectFloorplanGeometry(
   visit(levelId)
 
   const activeLevelNode = nodes[levelId]
+  const collectedIds = new Set(entries.map((entry) => entry.id))
   if (activeLevelNode) {
-    const collectedIds = new Set(entries.map((entry) => entry.id))
     for (const linked of collectFloorplanLinkedLevelNodes(nodes, levelId, collectedIds)) {
       const definition = nodeRegistry.get(linked.node.type)
-      if (
-        isFloorplanNodeVisible(linked.node) &&
-        (scope === 'full' || definition?.category === 'structure')
-      ) {
+      if (isFloorplanNodeVisible(linked.node) && isFloorplanNodeInExportScope(definition, scope)) {
         const drawingNode = resolveNodeForDrawingType(linked.node, nodes, drawingType)
         if (drawingNode) {
           entries.push({ id: linked.id, node: drawingNode, parentOverride: activeLevelNode })
+          collectedIds.add(linked.id)
         }
       }
     }
   }
 
-  // Document order is paint order — sort the same way the live layer does so
-  // zones sit under walls/slabs/furniture rather than on top of them.
-  entries.sort((a, b) => floorplanLayerRank(a.node.type) - floorplanLayerRank(b.node.type))
+  const buildingId = resolveBuildingForLevel(levelId, nodes as Record<AnyNodeId, AnyNode>)
+  const buildingNode = buildingId ? nodes[buildingId] : undefined
+  const siteNode =
+    buildingNode?.type === 'building' && buildingNode.parentId
+      ? nodes[buildingNode.parentId as AnyNodeId]
+      : undefined
+  if (siteNode?.type === 'site' && buildingNode?.type === 'building') {
+    const siteScopedNodes = collectDirectFloorplanScopeNodes(nodes, siteNode, 'site')
+    const outputTransform = siteToFloorplanTransform(
+      buildingNode.position,
+      buildingNode.rotation[1],
+    )
+    for (const node of siteScopedNodes) {
+      if (collectedIds.has(node.id) || !isNodeKindEnabled(node.type, installedPlugins)) continue
+      const drawingNode = resolveNodeForDrawingType(node, nodes, drawingType)
+      if (!drawingNode) continue
+      const definition = nodeRegistry.get(drawingNode.type)
+      if (
+        !definition?.floorplan ||
+        !isFloorplanNodeInExportScope(definition, scope) ||
+        !isFloorplanHierarchyVisible(drawingNode, nodes, noLiveOverrides, siteNode.id)
+      ) {
+        continue
+      }
+      const childIds = 'children' in node ? node.children : undefined
+      const children = Array.isArray(childIds)
+        ? childIds.map((childId) => nodes[childId]).filter((child): child is AnyNode => !!child)
+        : []
+      const siblings = siteScopedNodes.filter(
+        (candidate) => candidate.id !== node.id && candidate.type === node.type,
+      )
+      entries.push({
+        id: node.id,
+        node: drawingNode,
+        context: { children, siblings, parent: siteNode, outputTransform },
+        scopeRank: -1,
+      })
+      collectedIds.add(node.id)
+    }
+  }
+
+  // Document order is paint order. Site context sits below level
+  // architecture, then each scope retains the live layer's z-order.
+  entries.sort(
+    (a, b) =>
+      (a.scopeRank ?? 0) - (b.scopeRank ?? 0) ||
+      floorplanLayerRank(a.node.type) - floorplanLayerRank(b.node.type),
+  )
 
   // One-shot per-type cache for `computeFloorplanLevelData`; value type is
   // module-private to the registry layer, so let it infer.
   const levelDataCache = new Map()
   const out: ExportGeometry[] = []
-  for (const { id, node, parentOverride } of entries) {
+  for (const { id, node, parentOverride, context } of entries) {
     const builder = nodeRegistry.get(node.type)?.floorplan
     if (!builder) continue
     const levelData = getFloorplanLevelData(
@@ -803,9 +882,25 @@ function collectFloorplanGeometry(
       ),
       levelData,
     )
-    const ctx = parentOverride ? { ...baseContext, parent: parentOverride } : baseContext
-    const geometry = builder(node, ctx)
-    if (!geometry) continue
+    const ctx = context
+      ? {
+          ...baseContext,
+          children: context.children,
+          siblings: context.siblings,
+          parent: context.parent,
+        }
+      : parentOverride
+        ? { ...baseContext, parent: parentOverride }
+        : baseContext
+    const builtGeometry = builder(node, ctx)
+    if (!builtGeometry) continue
+    const geometry = context
+      ? {
+          kind: 'group' as const,
+          children: [builtGeometry],
+          transform: context.outputTransform,
+        }
+      : builtGeometry
     const visibleGeometry = filterFloorplanAnnotationGeometry(geometry, annotationVisibility)
     if (!visibleGeometry) continue
     const { base, overlay } = splitFloorplanOverlay(visibleGeometry)

package/src/lib/floorplan/floorplan-pdfkit-renderer.test.ts

@@ -85,6 +85,32 @@ describe('renderFloorplanGeometryToPdfKit', () => {
     expect([...new Set(baseFonts)]).toEqual(['Courier'])
     expect([...new Set(fontSizes)]).toEqual(['1.6'])
   })
+  test('uses even-odd fill for compound plugin paths', async () => {
+    const geometry = {
+      kind: 'path',
+      d: 'M0,0H4V4H0ZM1,1H3V3H1Z',
+      fill: '#3f6b2f',
+      fillRule: 'evenodd',
+    } satisfies FloorplanGeometry
+
+    const pdf = await renderTestPdf(geometry)
+
+    expect(pdf).toMatch(/f\*/)
+  })
+
+  test('writes a data-url PNG image without resolving it as an asset', async () => {
+    const geometry = {
+      kind: 'image',
+      url: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
+      center: [2, 2],
+      width: 1,
+      height: 1,
+    } satisfies FloorplanGeometry
+
+    const pdf = await renderTestPdf(geometry)
+
+    expect(pdf).toContain('/Subtype /Image')
+  })
 })
 
 async function renderTestPdf(geometry: FloorplanGeometry, rotationDeg = 0): Promise<string> {