@pascal-app/editor 1.0.3 → 1.0.5

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

@@ -2,7 +2,7 @@ import { describe, expect, test } from 'bun:test'
 import type { FloorplanGeometry } from '@pascal-app/core'
 import PDFDocument from 'pdfkit'
 import { floorplanGeometryMetadata } from './floorplan-extension'
-import { FloorplanPdfDocument } from './floorplan-pdfkit-document'
+import { FloorplanPdfDocument, loadFloorplanPdfFonts } from './floorplan-pdfkit-document'
 import { renderFloorplanGeometryToPdfKit } from './floorplan-pdfkit-renderer'
 
 describe('renderFloorplanGeometryToPdfKit', () => {
@@ -20,7 +20,7 @@ describe('renderFloorplanGeometryToPdfKit', () => {
     const pdf = await renderTestPdf(geometry)
 
     expect(pdf).toContain('BT')
-    expect(pdf).toContain(`[<${Buffer.from('13m').toString('hex')}> 0] TJ`)
+    expect(extractPdfText(pdf)).toBe('13m')
     expect(pdf).toMatch(/0\.1 w/)
     expect(pdf).toMatch(/0\.15 w/)
     expect(pdf).not.toMatch(/ c\n/)
@@ -40,7 +40,7 @@ describe('renderFloorplanGeometryToPdfKit', () => {
 
     const pdf = await renderTestPdf(geometry, 45)
 
-    expect(pdf).toContain(`<${Buffer.from('OOM 101').toString('hex')}>`)
+    expect(extractPdfText(pdf)).toBe('ROOM 101')
     expect(pdf).toContain('BT')
   })
 
@@ -76,13 +76,13 @@ describe('renderFloorplanGeometryToPdfKit', () => {
 
     const pdfs = await Promise.all(geometries.map((geometry) => renderTestPdf(geometry)))
     const baseFonts = pdfs.flatMap((pdf) =>
-      [...pdf.matchAll(/\/BaseFont \/([^\n]+)/g)].map((match) => match[1]),
+      [...pdf.matchAll(/\/BaseFont \/(?:[A-Z]{6}\+)?([^\n]+)/g)].map((match) => match[1]),
     )
     const fontSizes = pdfs.flatMap((pdf) =>
       [...pdf.matchAll(/\/F\d+ ([\d.]+) Tf/g)].map((match) => match[1]),
     )
 
-    expect([...new Set(baseFonts)]).toEqual(['Courier'])
+    expect([...new Set(baseFonts)]).toEqual(['GeistMono-Regular'])
     expect([...new Set(fontSizes)]).toEqual(['1.6'])
   })
   test('uses even-odd fill for compound plugin paths', async () => {
@@ -98,6 +98,45 @@ describe('renderFloorplanGeometryToPdfKit', () => {
     expect(pdf).toMatch(/f\*/)
   })
 
+  test('ends an unpainted shape so the next fill does not paint it', async () => {
+    // Zones emit fill/stroke 'none' outlines; walls fill right after them.
+    const geometry = {
+      kind: 'group',
+      children: [
+        {
+          kind: 'polygon',
+          points: [
+            [0, 0],
+            [4, 0],
+            [4, 4],
+            [0, 4],
+          ],
+          fill: 'none',
+          stroke: 'none',
+        },
+        {
+          kind: 'polygon',
+          points: [
+            [0, 0],
+            [1, 0],
+            [1, 0.2],
+            [0, 0.2],
+          ],
+          fill: '#374151',
+        },
+      ],
+    } as FloorplanGeometry
+
+    const pdf = await renderTestPdf(geometry)
+    const ops = pdf.split('\n')
+    const firstClose = ops.indexOf('h')
+
+    // the unpainted outline is closed and discarded ('n') before the filled one starts
+    expect(firstClose).toBeGreaterThan(-1)
+    expect(ops[firstClose + 1]).toBe('n')
+    expect(pdf).toMatch(/\bf\n/)
+  })
+
   test('writes a data-url PNG image without resolving it as an asset', async () => {
     const geometry = {
       kind: 'image',
@@ -113,17 +152,101 @@ describe('renderFloorplanGeometryToPdfKit', () => {
   })
 })
 
-async function renderTestPdf(geometry: FloorplanGeometry, rotationDeg = 0): Promise<string> {
+describe('embedded PDF fonts', () => {
+  // what the permit set prints: code limits, dimension strings, schedule
+  // callouts, revision deltas — none of them in pdfkit's WinAnsi standard fonts
+  const PROBLEM_TEXT =
+    'Vult ≤ 195 mph, runs ≥ 24" · VERIFY ≈ 3\'-2" × 6\'-10 ½" — 29.69°N ¼ ¾ ⅛ 5′ 6″ △ ΔT → √0.6'
+
+  const textAt = (text: string, fontFamily?: string, fontWeight?: number) =>
+    ({
+      kind: 'text',
+      x: 1,
+      y: 1,
+      text,
+      fontSize: 0.5,
+      fontFamily,
+      fontWeight,
+      dominantBaseline: 'alphabetic',
+    }) satisfies FloorplanGeometry
+
+  test('the problem glyphs round-trip through the text layer in the sans and mono families', async () => {
+    for (const [family, weight] of [
+      ['"IBM Plex Sans", Helvetica, Arial, sans-serif', 400],
+      ['"IBM Plex Sans", Helvetica, Arial, sans-serif', 700],
+      ['"IBM Plex Mono", Menlo, monospace', 400],
+      ['"IBM Plex Mono", Menlo, monospace', 700],
+    ] as const) {
+      const pdf = await renderTestPdf(textAt(PROBLEM_TEXT, family, weight), 0, false)
+      expect(extractPdfText(pdf)).toBe(PROBLEM_TEXT)
+    }
+  })
+
+  test('embeds subset TrueType faces, never the unembedded standard 14', async () => {
+    const pdf = await renderTestPdf(textAt(PROBLEM_TEXT), 0, false)
+    const baseFonts = [...pdf.matchAll(/\/BaseFont \/([^\n]+)/g)].map((match) => match[1])
+    expect(baseFonts.length).toBeGreaterThan(0)
+    for (const name of baseFonts) expect(name).toMatch(/^[A-Z]{6}\+(LiberationSans|GeistMono)/)
+    expect(pdf).toContain('/FontFile2')
+    expect(pdf).not.toMatch(/\/BaseFont \/(Helvetica|Courier)/)
+  })
+
+  test('draws the symbols neither face carries — warning, pointer, angle — as linework', async () => {
+    const pdf = await renderTestPdf(textAt('∠ 45° ⚠ open porch ▸ note'), 0, false)
+    // the warning keeps a real "!" in the text layer; nothing falls to the .notdef glyph
+    expect(extractPdfText(pdf)).toBe(' 45° ! open porch  note')
+    expect(extractPdfText(pdf)).not.toContain('\u0000')
+    // the triangle's ring is an even-odd fill; the pointer and the angle's strokes are plain fills
+    expect(pdf).toMatch(/f\*/)
+    expect(pdf.match(/\nf\n/g)?.length).toBeGreaterThanOrEqual(2)
+  })
+
+  test('collapses runs of white space the way SVG text does', async () => {
+    const pdf = await renderTestPdf(
+      { ...textAt('  APN  06075 \t  030\n062  '), textAnchor: 'end' },
+      0,
+      false,
+    )
+    expect(extractPdfText(pdf)).toBe('APN 06075 030 062')
+
+    const raw = new PDFDocument({ autoFirstPage: false, compress: false })
+    const doc = new FloorplanPdfDocument(raw, [200, 200], await loadFloorplanPdfFonts())
+    const style = { fontFamily: 'sans-serif', fontSize: 10 }
+    expect(doc.measureText(`RIDGE   20'-1"`, style)).toBe(doc.measureText(`RIDGE 20'-1"`, style))
+    // a no-break space is content, not white space
+    expect(doc.measureText('A\u00a0\u00a0B', style)).toBeGreaterThan(doc.measureText('A B', style))
+    raw.end()
+  })
+
+  test('measures a mixed-face string as the sum of the runs it draws', async () => {
+    const raw = new PDFDocument({ autoFirstPage: false, compress: false })
+    const doc = new FloorplanPdfDocument(raw, [200, 200], await loadFloorplanPdfFonts())
+    const style = { fontFamily: 'sans-serif', fontSize: 10 }
+    const whole = doc.measureText('≤3△', style)
+    const parts =
+      doc.measureText('≤3', style) + doc.measureText('△', { ...style, fontFamily: 'monospace' })
+    expect(whole).toBeCloseTo(parts, 6)
+    // Liberation Sans keeps Helvetica's advance widths (the sheets were laid out against them)
+    expect(doc.measureText('0', style)).toBeCloseTo(5.56, 2)
+    raw.end()
+  })
+})
+
+async function renderTestPdf(
+  geometry: FloorplanGeometry,
+  rotationDeg = 0,
+  annotationLayer = true,
+): Promise<string> {
   const raw = new PDFDocument({ autoFirstPage: false, compress: false })
   const chunks: Buffer[] = []
   raw.on('data', (chunk: Buffer) => chunks.push(chunk))
   const completed = new Promise<string>((resolve) => {
     raw.on('end', () => resolve(Buffer.concat(chunks).toString('latin1')))
   })
-  const doc = new FloorplanPdfDocument(raw, [200, 200])
+  const doc = new FloorplanPdfDocument(raw, [200, 200], await loadFloorplanPdfFonts())
   doc.addPage()
   await renderFloorplanGeometryToPdfKit(doc, geometry, {
-    annotationLayer: true,
+    annotationLayer,
     placement: { x: 20, y: 20, width: 100, height: 100 },
     rotationDeg,
     viewport: { x: 0, y: -2, width: 20, height: 20 },
@@ -131,3 +254,49 @@ async function renderTestPdf(geometry: FloorplanGeometry, rotationDeg = 0): Prom
   raw.end()
   return completed
 }
+
+/**
+ * The text an uncompressed pdfkit file carries, in drawing order: every TJ's
+ * glyph ids decoded through its font's ToUnicode CMap — what a PDF reader's
+ * text layer (search, copy, pdftotext) reads back.
+ */
+function extractPdfText(pdf: string): string {
+  const objects = new Map<string, string>()
+  for (const match of pdf.matchAll(/(\d+) 0 obj\n([\s\S]*?)\nendobj/g)) {
+    objects.set(match[1]!, match[2]!)
+  }
+  const fontObjects = new Map<string, string>()
+  for (const match of pdf.matchAll(/\/(F\d+) (\d+) 0 R/g)) fontObjects.set(match[1]!, match[2]!)
+  const cmaps = new Map<string, Map<number, string>>()
+  const cmapFor = (resource: string) => {
+    let cmap = cmaps.get(resource)
+    if (cmap) return cmap
+    cmap = new Map()
+    const font = objects.get(fontObjects.get(resource) ?? '') ?? ''
+    const stream = objects.get(font.match(/\/ToUnicode (\d+) 0 R/)?.[1] ?? '') ?? ''
+    for (const range of stream.matchAll(/<([0-9a-f]{4})> <[0-9a-f]{4}> \[([^\]]*)\]/g)) {
+      let gid = Number.parseInt(range[1]!, 16)
+      for (const entry of range[2]!.matchAll(/<([0-9a-f ]+)>/g)) {
+        const units = entry[1]!.split(' ').map((hex) => Number.parseInt(hex, 16))
+        cmap.set(gid++, String.fromCharCode(...units))
+      }
+    }
+    cmaps.set(resource, cmap)
+    return cmap
+  }
+  let text = ''
+  let font = ''
+  for (const op of pdf.matchAll(/\/(F\d+) [\d.]+ Tf|\[([^\]]*)\] TJ/g)) {
+    if (op[1]) {
+      font = op[1]
+      continue
+    }
+    const cmap = cmapFor(font)
+    for (const hex of op[2]!.matchAll(/<([0-9a-f]+)>/g)) {
+      for (let i = 0; i < hex[1]!.length; i += 4) {
+        text += cmap.get(Number.parseInt(hex[1]!.slice(i, i + 4), 16)) ?? '\uFFFD'
+      }
+    }
+  }
+  return text
+}

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

@@ -11,11 +11,11 @@ import {
 import { resolveFloorplanLabelAngle } from '../../components/editor-2d/renderers/floorplan-label-angle'
 import type { FloorplanExportBounds } from './floorplan-export'
 import { readFloorplanGeometryMetadata } from './floorplan-extension'
-import type { FloorplanPdfDocument } from './floorplan-pdfkit-document'
+import type { FloorplanPdfBaseline, FloorplanPdfDocument } from './floorplan-pdfkit-document'
 
 const DIMENSION_LINE_WIDTH_PT = 0.5
 const DIMENSION_TICK_WIDTH_PT = 0.75
-const DIMENSION_TEXT_FONT_FAMILY = 'Courier'
+const DIMENSION_TEXT_FONT_FAMILY = 'monospace'
 const DIMENSION_TEXT_FONT_SIZE_PT = 8
 const DIMENSION_TEXT_FONT_WEIGHT = 400
 const DIMENSION_BASELINE_OFFSET_PT = 5
@@ -35,6 +35,7 @@ type RenderContext = {
   annotationLabelShiftIndex: number
   annotationLabelShifts: readonly FloorplanPoint[]
   annotationLayer: boolean
+  dimensionTextSizePt: number
   sceneRotationDeg: number
   unitsPerPoint: number
 }
@@ -52,6 +53,8 @@ export async function renderFloorplanGeometryToPdfKit(
   options: {
     annotationLabelShifts?: readonly FloorplanPoint[]
     annotationLayer: boolean
+    /** Paper size of dimension strings; a drafted sheet prints them larger. */
+    dimensionTextSizePt?: number
     placement: FloorplanPdfKitPlacement
     rotationDeg: number
     viewport: FloorplanExportBounds
@@ -70,6 +73,7 @@ export async function renderFloorplanGeometryToPdfKit(
     annotationLabelShiftIndex: 0,
     annotationLabelShifts: options.annotationLabelShifts ?? [],
     annotationLayer: options.annotationLayer,
+    dimensionTextSizePt: options.dimensionTextSizePt ?? DIMENSION_TEXT_FONT_SIZE_PT,
     sceneRotationDeg: options.rotationDeg,
     unitsPerPoint: 1 / pointsPerUnit,
   })
@@ -186,8 +190,11 @@ function paintStyledGeometry(
   geometry: StyledGeometry,
   context: RenderContext,
 ): void {
-  const fill = geometry.fill && geometry.fill !== 'none' ? geometry.fill : null
-  const stroke = geometry.stroke && geometry.stroke !== 'none' ? geometry.stroke : null
+  // SVG's `transparent` / `none` mean "no paint" — pdfkit would read either
+  // as a colour name it does not know and paint black (the furniture sprites'
+  // hit-target polygons printed as black boxes).
+  const fill = isPaint(geometry.fill) ? (geometry.fill as string) : null
+  const stroke = isPaint(geometry.stroke) ? (geometry.stroke as string) : null
   const opacity = geometry.opacity ?? 1
   const fillOpacity = (geometry.fillOpacity ?? 1) * opacity
   const strokeOpacity = (geometry.strokeOpacity ?? 1) * opacity
@@ -210,6 +217,22 @@ function paintStyledGeometry(
   if (fill && stroke) raw.fillAndStroke(fill, stroke, fillRule)
   else if (fill) raw.fill(fill, fillRule)
   else if (stroke) raw.stroke(stroke)
+  // Unpainted shape (fill and stroke both none, e.g. zone hit areas): end the
+  // path without painting ('n'). Otherwise the open path is carried into the
+  // next fill and printed in that shape's colour.
+  else raw.addContent('n')
+}
+
+function isPaint(value: unknown): boolean {
+  if (typeof value !== 'string') return false
+  const v = value.trim().toLowerCase()
+  return (
+    v !== '' &&
+    v !== 'none' &&
+    v !== 'transparent' &&
+    !v.startsWith('url(') &&
+    !v.startsWith('var(')
+  )
 }
 
 function resolveStrokeWidth(geometry: StyledGeometry, context: RenderContext): number {
@@ -247,7 +270,7 @@ function drawGeometryText(
   const dimensionValue =
     readFloorplanGeometryMetadata(geometry).annotationRole === 'automatic-dimension'
   const fontSize = context.annotationLayer
-    ? (dimensionValue ? DIMENSION_TEXT_FONT_SIZE_PT : annotationTextSizePt(geometry)) *
+    ? (dimensionValue ? context.dimensionTextSizePt : annotationTextSizePt(geometry)) *
       context.unitsPerPoint
     : geometry.fontSize
   const outlinedForScreen = geometry.paintOrder === 'stroke' && !!geometry.stroke
@@ -258,6 +281,7 @@ function drawGeometryText(
   drawNativeText(doc, {
     angleDeg: geometry.upright ? -context.sceneRotationDeg : 0,
     anchor: geometry.textAnchor ?? 'start',
+    baseline: geometry.dominantBaseline ?? 'middle',
     fill,
     fontFamily: dimensionValue ? DIMENSION_TEXT_FONT_FAMILY : geometry.fontFamily,
     fontSize,
@@ -270,7 +294,10 @@ function drawGeometryText(
 }
 
 function annotationTextSizePt(geometry: Extract<FloorplanGeometry, { kind: 'text' }>): number {
-  switch (readFloorplanGeometryMetadata(geometry).annotationRole) {
+  const metadata = readFloorplanGeometryMetadata(geometry)
+  // an explicit paper size wins over the role's (a sheet's room tag sets its own)
+  if (typeof metadata.textSizePt === 'number' && metadata.textSizePt > 0) return metadata.textSizePt
+  switch (metadata.annotationRole) {
     case 'room-label':
       if (geometry.fontSize >= 0.18) return DEFAULT_ANNOTATION_FONT_SIZE_PT
       if (geometry.fontSize >= 0.145) return ROOM_NUMBER_FONT_SIZE_PT
@@ -480,7 +507,7 @@ function drawDimensionText(
   stroke: string,
   context: RenderContext,
 ): void {
-  const fontSize = DIMENSION_TEXT_FONT_SIZE_PT * context.unitsPerPoint
+  const fontSize = context.dimensionTextSizePt * context.unitsPerPoint
   const y =
     geometry.textPosition === 'centered'
       ? fontSize * 0.35
@@ -495,6 +522,7 @@ function drawDimensionText(
     .translate(shift[0], shift[1])
   drawNativeText(doc, {
     anchor: 'middle',
+    baseline: 'alphabetic',
     fill: stroke,
     fontFamily: DIMENSION_TEXT_FONT_FAMILY,
     fontSize,
@@ -512,7 +540,7 @@ function drawDimensionLabel(
   context: RenderContext,
 ): void {
   const unitsPerPoint = context.unitsPerPoint
-  const fontSize = DIMENSION_TEXT_FONT_SIZE_PT * unitsPerPoint
+  const fontSize = context.dimensionTextSizePt * unitsPerPoint
   const padX = 6 * unitsPerPoint
   const padY = 3 * unitsPerPoint
   const textWidth = geometry.text.length * 6.2 * unitsPerPoint
@@ -538,6 +566,7 @@ function drawDimensionLabel(
     .fill()
   drawNativeText(doc, {
     anchor: 'middle',
+    baseline: 'middle',
     fill: '#111827',
     fontFamily: DIMENSION_TEXT_FONT_FAMILY,
     fontSize,
@@ -569,8 +598,9 @@ function drawEqualSpacingBadge(
     .fill()
   drawNativeText(doc, {
     anchor: 'middle',
+    baseline: 'middle',
     fill: '#334155',
-    fontFamily: 'Courier',
+    fontFamily: DIMENSION_TEXT_FONT_FAMILY,
     fontSize,
     fontWeight: 600,
     text: geometry.text,
@@ -585,6 +615,7 @@ function drawNativeText(
   options: {
     angleDeg?: number
     anchor: 'start' | 'middle' | 'end'
+    baseline: FloorplanPdfBaseline
     fill: string
     fontFamily?: string
     fontSize: number
@@ -596,24 +627,17 @@ function drawNativeText(
   },
 ): void {
   const raw = doc.raw
-  const normalizedFamily = options.fontFamily?.toLocaleLowerCase() ?? ''
-  const family =
-    normalizedFamily.includes('mono') || normalizedFamily.includes('courier')
-      ? 'Courier'
-      : 'Helvetica'
-  const numericWeight = Number.parseInt(String(options.fontWeight ?? 400), 10)
-  const bold =
-    options.fontWeight === 'bold' || (Number.isFinite(numericWeight) && numericWeight >= 500)
   raw.save().translate(options.x, options.y)
   if (options.angleDeg) raw.rotate(options.angleDeg)
-  raw
-    .font(bold ? `${family}-Bold` : family)
-    .fontSize(options.fontSize)
-    .fillColor(options.fill)
+  raw.fillColor(options.fill)
   raw.fillOpacity(options.opacity ?? 1)
-  const width = raw.widthOfString(options.text, { lineBreak: false })
-  const x = options.anchor === 'middle' ? -width / 2 : options.anchor === 'end' ? -width : 0
-  raw.text(options.text, x, -options.fontSize * 0.42, { lineBreak: false })
+  doc.drawText(
+    options.text,
+    0,
+    0,
+    { fontFamily: options.fontFamily, fontSize: options.fontSize, fontWeight: options.fontWeight },
+    { anchor: options.anchor, baseline: options.baseline },
+  )
   raw.restore()
 }
 
@@ -653,7 +677,18 @@ async function drawImage(
   raw.restore()
 }
 
-function blobToDataUrl(blob: Blob): Promise<string> {
+async function blobToDataUrl(blob: Blob): Promise<string> {
+  // FileReader exists only in browsers; the headless export (scripts/demo/
+  // print-set.ts) runs the same renderer under Bun, where the bytes are
+  // base64-encoded directly instead.
+  if (typeof FileReader === 'undefined') {
+    const bytes = new Uint8Array(await blob.arrayBuffer())
+    let binary = ''
+    for (let i = 0; i < bytes.length; i += 0x8000) {
+      binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000))
+    }
+    return `data:${blob.type || 'image/png'};base64,${btoa(binary)}`
+  }
   return new Promise((resolve, reject) => {
     const reader = new FileReader()
     reader.onerror = () => reject(reader.error)

package/src/lib/floorplan/floorplan-plugin-install.test.tsx

@@ -0,0 +1,138 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  LevelNode,
+  loadPlugin,
+  nodeRegistry,
+} from '@pascal-app/core'
+import { renderToStaticMarkup } from 'react-dom/server'
+import { z } from 'zod'
+import { FloorplanPreview } from '../../components/viewer/floorplan-preview'
+import { DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY } from './annotation-visibility'
+import { collectFloorplanGeometry, floorplanExportInstalledPlugins } from './floorplan-export'
+import { FLOORPLAN_NODE_EXTENSION_KEY } from './floorplan-extension'
+
+// Plugin API v1, no-install case: a plugin kind's floor-plan output appears in
+// the read-only preview and the PDF export only while the project has the
+// plugin installed.
+
+const PLUGIN_ID = 'fixture:floorplan'
+const KIND = 'fixture:bed'
+const LINKED_KIND = 'fixture:shaft'
+const MARKER_FILL = '#a09a09'
+
+const level = LevelNode.parse({ id: 'level_plugin_plan', children: ['fxbed_plan'] })
+const bed = {
+  object: 'node',
+  id: 'fxbed_plan',
+  type: KIND,
+  parentId: level.id,
+  visible: true,
+  metadata: {},
+} as unknown as AnyNode
+// Lives on the upper level but draws on this one through `linkedLevelIds`.
+const upper = LevelNode.parse({ id: 'level_plugin_upper', level: 1, children: ['fxshaft_plan'] })
+const shaft = {
+  object: 'node',
+  id: 'fxshaft_plan',
+  type: LINKED_KIND,
+  parentId: upper.id,
+  visible: true,
+  metadata: {},
+} as unknown as AnyNode
+const nodes = { [level.id]: level, [bed.id]: bed, [upper.id]: upper, [shaft.id]: shaft } as Record<
+  string,
+  AnyNode
+>
+
+let restoreRegistry: () => void
+
+beforeEach(async () => {
+  restoreRegistry = nodeRegistry._snapshot()
+  await loadPlugin({
+    id: PLUGIN_ID,
+    apiVersion: 1,
+    nodes: [
+      {
+        kind: KIND,
+        schemaVersion: 1,
+        schema: z.looseObject({ id: z.string(), type: z.literal(KIND) }),
+        category: 'structure',
+        defaults: () => ({}),
+        capabilities: {},
+        floorplan: () => ({ kind: 'rect', x: 0, y: 0, width: 2, height: 1, fill: MARKER_FILL }),
+      } as unknown as AnyNodeDefinition,
+      {
+        kind: LINKED_KIND,
+        schemaVersion: 1,
+        schema: z.looseObject({ id: z.string(), type: z.literal(LINKED_KIND) }),
+        category: 'structure',
+        defaults: () => ({}),
+        capabilities: {},
+        extensions: { [FLOORPLAN_NODE_EXTENSION_KEY]: { linkedLevelIds: () => [level.id] } },
+        floorplan: () => ({ kind: 'rect', x: 3, y: 0, width: 1, height: 1 }),
+      } as unknown as AnyNodeDefinition,
+    ],
+  })
+})
+
+afterEach(() => {
+  restoreRegistry()
+})
+
+function exportedIds(installedPlugins: readonly string[] | undefined) {
+  return collectFloorplanGeometry(
+    nodes,
+    level.id,
+    'full',
+    'metric',
+    'meters',
+    DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY,
+    'floor-plan',
+    'finished-faces',
+    installedPlugins,
+  ).map(({ id }) => id)
+}
+
+function previewMarkup(installedPlugins: readonly string[]) {
+  return renderToStaticMarkup(
+    <FloorplanPreview
+      levelId={level.id}
+      scene={{ nodes, installedPlugins }}
+      showCompass={false}
+      showLevelSelector={false}
+    />,
+  )
+}
+
+describe('floor-plan output of a plugin kind', () => {
+  test('the read-only preview draws it only while the plugin is installed', () => {
+    expect(previewMarkup([PLUGIN_ID])).toContain(MARKER_FILL)
+    expect(previewMarkup([])).not.toContain(MARKER_FILL)
+  })
+
+  test('the PDF export draws level and linked-level kinds while the plugin is installed', () => {
+    expect(exportedIds([PLUGIN_ID]).sort()).toEqual([bed.id, shaft.id].sort())
+  })
+
+  test('the PDF export omits level and linked-level kinds while the plugin is not installed', () => {
+    expect(exportedIds([])).toEqual([])
+  })
+
+  test('a legacy scene without explicit install state draws every loaded plugin kind', () => {
+    const legacy = floorplanExportInstalledPlugins({
+      installedPlugins: ['host:default-panel'],
+      hasExplicitPluginInstallState: false,
+    })
+
+    expect(legacy).toBeUndefined()
+    expect(exportedIds(legacy).sort()).toEqual([bed.id, shaft.id].sort())
+    expect(
+      floorplanExportInstalledPlugins({
+        installedPlugins: [],
+        hasExplicitPluginInstallState: true,
+      }),
+    ).toEqual([])
+  })
+})

package/src/lib/floorplan/floorplan-readonly.ts

@@ -10,6 +10,10 @@ export type FloorplanViewState = {
   unit: 'metric' | 'imperial'
   metricNotation?: 'meters' | 'millimeters'
   purpose?: 'edit' | 'document'
+  /** Sheet drafting conventions (see `FloorplanContextExtension.drafting`). */
+  drafting?: boolean
+  /** Room labels drawn as screen pills (see `FloorplanContextExtension.roomLabelOverlay`). */
+  roomLabelOverlay?: boolean
   wallDimensionReference?: FloorplanWallDimensionReference
   highlighted: boolean
   hovered: boolean
@@ -59,6 +63,8 @@ export function buildFloorplanContext(
       automaticDimensions: viewState.automaticDimensions,
       metricNotation: viewState.metricNotation ?? 'meters',
       purpose: viewState.purpose ?? 'edit',
+      drafting: viewState.drafting === true,
+      roomLabelOverlay: viewState.roomLabelOverlay === true,
       wallDimensionReference: viewState.wallDimensionReference,
     }),
     viewState: viewState.palette

package/src/lib/floorplan/geometry.ts

@@ -1,4 +1,5 @@
 import type { Point2D } from '@pascal-app/core'
+import { getWallFaceOffsets, type WallJustification } from '@pascal-app/core'
 import type { FloorplanLineSegment, FloorplanSelectionBounds } from './types'
 
 // Baseline rotation (deg) that orients the plan-local scene "north up" on
@@ -107,7 +108,11 @@ export function movePlanPointTowards(start: Point2D, end: Point2D, distance: num
   return interpolatePlanPoint(start, end, Math.min(1, distance / totalDistance))
 }
 
-export function getThickPlanLinePolygon(line: FloorplanLineSegment, thickness: number): Point2D[] {
+export function getThickPlanLinePolygon(
+  line: FloorplanLineSegment,
+  thickness: number,
+  justification?: WallJustification,
+): Point2D[] {
   const dx = line.end.x - line.start.x
   const dy = line.end.y - line.start.y
   const length = Math.hypot(dx, dy)
@@ -116,15 +121,17 @@ export function getThickPlanLinePolygon(line: FloorplanLineSegment, thickness: n
     return [line.start, line.end, line.end, line.start]
   }
 
-  const halfThickness = thickness / 2
-  const normalX = (-dy / length) * halfThickness
-  const normalY = (dx / length) * halfThickness
+  const { a, b } = getWallFaceOffsets({ thickness, justification })
+  const normalX = (-dy / length) * a
+  const normalY = (dx / length) * a
 
+  const backX = (-dy / length) * -b
+  const backY = (dx / length) * -b
   return [
     { x: line.start.x + normalX, y: line.start.y + normalY },
     { x: line.end.x + normalX, y: line.end.y + normalY },
-    { x: line.end.x - normalX, y: line.end.y - normalY },
-    { x: line.start.x - normalX, y: line.start.y - normalY },
+    { x: line.end.x - backX, y: line.end.y - backY },
+    { x: line.start.x - backX, y: line.start.y - backY },
   ]
 }
 

package/src/lib/floorplan/index.ts

@@ -29,20 +29,11 @@ export {
   collectLevelDescendants,
   getItemFloorplanTransform,
 } from './items'
-export {
-  buildFloorplanStairEntry,
-  computeFloorplanStairSegmentTransforms,
-  getFloorplanStairSegmentPolygon,
-} from './stairs'
 export type {
   FloorplanItemEntry,
   FloorplanLineSegment,
   FloorplanNodeTransform,
   FloorplanSelectionBounds,
-  FloorplanStairArrowEntry,
-  FloorplanStairEntry,
-  FloorplanStairSegmentEntry,
   LevelDescendantMap,
-  StairSegmentTransform,
 } from './types'
 export { getFloorplanWall, getFloorplanWallThickness } from './walls'