diff --git a/packages/editor/src/components/ui/sidebar/panels/settings-panel/print-export-card.test.ts b/packages/editor/src/components/ui/sidebar/panels/settings-panel/print-export-card.test.ts
new file mode 100644
index 0000000000..9998c2309f
--- /dev/null
+++ b/packages/editor/src/components/ui/sidebar/panels/settings-panel/print-export-card.test.ts
@@ -0,0 +1,233 @@
+import { describe, expect, test } from 'bun:test'
+import type { PrintLevelBundleReport } from '../../../../../lib/level-print-export'
+import type { ModelExport, ModelExportOptions } from '../../../../../lib/model-export'
+import type { PrintExportReport } from '../../../../../lib/print-export'
+import { preparePrintExport } from './print-export-card'
+
+const report: PrintExportReport = {
+ kind: 'print-export-report',
+ version: 2,
+ format: '3mf',
+ scale: 50,
+ units: 'millimeter',
+ orientation: 'z-up',
+ status: 'pass',
+ bounds: {
+ min: { x: -50, y: -30, z: 0 },
+ max: { x: 50, y: 30, z: 40 },
+ width: 100,
+ depth: 60,
+ height: 40,
+ },
+ triangleCount: 12,
+ invalidTriangleCount: 0,
+ degenerateTriangleCount: 0,
+ boundaryEdgeCount: 0,
+ nonManifoldEdgeCount: 0,
+ connectedComponentCount: 1,
+ solidComponentCount: 1,
+ invertedWinding: false,
+ volumeMm3: 240_000,
+ diagnostics: [],
+}
+
+const stlReport: PrintExportReport = { ...report, format: 'stl' }
+
+const levelReport: PrintLevelBundleReport = {
+ kind: 'print-level-export-report',
+ version: 2,
+ format: 'stl',
+ scale: 50,
+ units: 'millimeter',
+ orientation: 'z-up',
+ status: 'pass',
+ partCount: 1,
+ parts: [
+ {
+ kind: 'level',
+ levelId: 'level_ground',
+ label: 'Ground',
+ objectName: '01 Ground',
+ filename: '01_ground.stl',
+ sourceBaseMeters: 0,
+ report: stlReport,
+ },
+ ],
+ excludedNodeIds: [],
+ diagnostics: [],
+}
+
+describe('print export card contract', () => {
+ test('prepares a visible-only scaled artifact without downloading immediately', async () => {
+ const calls: { format?: string; options?: ModelExportOptions }[] = []
+ const artifact = { blob: new Blob(['3mf']), filename: 'house.3mf', metadata: report }
+ const modelExport: ModelExport = async (format, options) => {
+ calls.push({ format, options })
+ return artifact
+ }
+
+ const prepared = await preparePrintExport(
+ modelExport,
+ true,
+ '50',
+ 'whole',
+ '3mf',
+ 'structure',
+ 'none',
+ '2',
+ '2',
+ '1.8',
+ )
+
+ expect(calls).toEqual([
+ {
+ format: 'print-3mf',
+ options: {
+ onlyVisible: true,
+ download: false,
+ printScale: 50,
+ printScope: 'whole',
+ printContent: 'structure',
+ printBase: 'none',
+ printMinimumFeatureMm: 1.8,
+ },
+ },
+ ])
+ expect(prepared).toEqual({ artifact, report })
+ })
+
+ test('rejects invalid scale input before invoking the exporter', async () => {
+ let invoked = false
+ const modelExport: ModelExport = async () => {
+ invoked = true
+ return null
+ }
+
+ await expect(
+ preparePrintExport(
+ modelExport,
+ true,
+ '0',
+ 'levels',
+ '3mf',
+ 'structure',
+ 'none',
+ '2',
+ '2',
+ '',
+ ),
+ ).rejects.toThrow(
+ 'Enter a positive scale denominator',
+ )
+ expect(invoked).toBe(false)
+ })
+
+ test('accepts the per-level archive report contract', async () => {
+ const calls: { format?: string; options?: ModelExportOptions }[] = []
+ const artifact = { blob: new Blob(['zip']), filename: 'levels.zip', metadata: levelReport }
+ const modelExport: ModelExport = async (format, options) => {
+ calls.push({ format, options })
+ return artifact
+ }
+
+ const prepared = await preparePrintExport(
+ modelExport,
+ true,
+ '50',
+ 'levels',
+ 'stl',
+ 'everything',
+ 'plinth',
+ '3',
+ '2.5',
+ '',
+ )
+
+ expect(calls).toEqual([
+ {
+ format: 'print-stl',
+ options: {
+ onlyVisible: true,
+ download: false,
+ printScale: 50,
+ printScope: 'levels',
+ printContent: 'everything',
+ printBase: 'plinth',
+ printPlinthMarginMm: 3,
+ printPlinthThicknessMm: 2.5,
+ },
+ },
+ ])
+ expect(prepared).toEqual({ artifact, report: levelReport })
+ })
+
+ test('rejects invalid plinth dimensions before invoking the exporter', async () => {
+ let invoked = false
+ const modelExport: ModelExport = async () => {
+ invoked = true
+ return null
+ }
+
+ await expect(
+ preparePrintExport(
+ modelExport,
+ true,
+ '50',
+ 'levels',
+ '3mf',
+ 'structure',
+ 'plinth',
+ '-1',
+ '2',
+ '',
+ ),
+ ).rejects.toThrow('non-negative plinth margin')
+ expect(invoked).toBe(false)
+ })
+
+ test('rejects an invalid custom minimum feature target before invoking the exporter', async () => {
+ let invoked = false
+ const modelExport: ModelExport = async () => {
+ invoked = true
+ return null
+ }
+
+ await expect(
+ preparePrintExport(
+ modelExport,
+ true,
+ '50',
+ 'levels',
+ '3mf',
+ 'structure',
+ 'none',
+ '2',
+ '2',
+ '0',
+ ),
+ ).rejects.toThrow('positive minimum feature target')
+ expect(invoked).toBe(false)
+ })
+
+ test('rejects an artifact without the print preflight contract', async () => {
+ const modelExport: ModelExport = async () => ({
+ blob: new Blob(['stl']),
+ filename: 'house.stl',
+ })
+
+ await expect(
+ preparePrintExport(
+ modelExport,
+ false,
+ '100',
+ 'whole',
+ '3mf',
+ 'structure',
+ 'none',
+ '2',
+ '2',
+ '',
+ ),
+ ).rejects.toThrow('did not return a preflight report')
+ })
+})
diff --git a/packages/editor/src/components/ui/sidebar/panels/settings-panel/print-export-card.tsx b/packages/editor/src/components/ui/sidebar/panels/settings-panel/print-export-card.tsx
new file mode 100644
index 0000000000..38cac03376
--- /dev/null
+++ b/packages/editor/src/components/ui/sidebar/panels/settings-panel/print-export-card.tsx
@@ -0,0 +1,475 @@
+import { useScene } from '@pascal-app/core'
+import { AlertTriangle, CheckCircle2, Download, Printer, XCircle } from 'lucide-react'
+import { useEffect, useId, useRef, useState } from 'react'
+import { Button } from '../../../../../components/ui/primitives/button'
+import {
+ isPrintLevelBundleReport,
+ type PrintBaseMode,
+ type PrintLevelBundleReport,
+} from '../../../../../lib/level-print-export'
+import type { PrintContentScope } from '../../../../../lib/print-content-scope'
+import type { ModelExport, ModelExportArtifact } from '../../../../../lib/model-export'
+import {
+ isPrintExportReport,
+ type PrintArtifactFormat,
+ type PrintExportReport,
+} from '../../../../../lib/print-export'
+import useEditor from '../../../../../store/use-editor'
+
+export type PreparedPrintExport = {
+ artifact: ModelExportArtifact
+ report: PrintExportReport | PrintLevelBundleReport
+}
+
+function formatMillimeters(value: number): string {
+ if (value >= 100) return value.toFixed(1)
+ if (value >= 10) return value.toFixed(2)
+ return value.toFixed(3)
+}
+
+function downloadArtifact(artifact: ModelExportArtifact) {
+ const url = URL.createObjectURL(artifact.blob)
+ const link = document.createElement('a')
+ link.href = url
+ link.download = artifact.filename
+ link.click()
+ URL.revokeObjectURL(url)
+}
+
+export async function preparePrintExport(
+ modelExport: ModelExport,
+ onlyVisible: boolean,
+ scaleInput: string,
+ scope: 'whole' | 'levels',
+ format: PrintArtifactFormat,
+ content: PrintContentScope,
+ base: PrintBaseMode,
+ plinthMarginInput: string,
+ plinthThicknessInput: string,
+ minimumFeatureInput: string,
+): Promise
{
+ const scale = Number(scaleInput)
+ if (!Number.isFinite(scale) || scale <= 0) {
+ throw new RangeError('Enter a positive scale denominator, such as 25, 50, or 100.')
+ }
+
+ let minimumFeatureMm: number | undefined
+ if (content === 'structure' && minimumFeatureInput.trim() !== '') {
+ minimumFeatureMm = Number(minimumFeatureInput)
+ if (!Number.isFinite(minimumFeatureMm) || minimumFeatureMm <= 0) {
+ throw new RangeError('Enter a positive minimum feature target in millimeters.')
+ }
+ }
+
+ let plinthMarginMm: number | undefined
+ let plinthThicknessMm: number | undefined
+ if (base === 'plinth') {
+ if (scope !== 'levels') {
+ throw new RangeError('A plinth is available only for per-level print packages.')
+ }
+ plinthMarginMm = Number(plinthMarginInput)
+ plinthThicknessMm = Number(plinthThicknessInput)
+ if (!Number.isFinite(plinthMarginMm) || plinthMarginMm < 0) {
+ throw new RangeError('Enter a non-negative plinth margin in millimeters.')
+ }
+ if (!Number.isFinite(plinthThicknessMm) || plinthThicknessMm <= 0) {
+ throw new RangeError('Enter a positive plinth thickness in millimeters.')
+ }
+ }
+
+ const artifact = await modelExport(format === '3mf' ? 'print-3mf' : 'print-stl', {
+ onlyVisible,
+ download: false,
+ printScale: scale,
+ printScope: scope,
+ printContent: content,
+ printBase: base,
+ ...(minimumFeatureMm === undefined ? {} : { printMinimumFeatureMm: minimumFeatureMm }),
+ ...(plinthMarginMm === undefined ? {} : { printPlinthMarginMm: plinthMarginMm }),
+ ...(plinthThicknessMm === undefined ? {} : { printPlinthThicknessMm: plinthThicknessMm }),
+ })
+ if (
+ !artifact ||
+ (!isPrintExportReport(artifact.metadata) && !isPrintLevelBundleReport(artifact.metadata))
+ ) {
+ throw new Error('The print exporter did not return a preflight report.')
+ }
+ return { artifact, report: artifact.metadata }
+}
+
+export function PrintExportCard({ onlyVisible }: { onlyVisible: boolean }) {
+ const scaleInputId = useId()
+ const minimumFeatureInputId = useId()
+ const nodes = useScene((state) => state.nodes)
+ const modelExport = useEditor((state) => state.modelExport)
+ const generationRef = useRef(0)
+ const [printScale, setPrintScale] = useState('100')
+ const [scope, setScope] = useState<'whole' | 'levels'>('levels')
+ const [format, setFormat] = useState('3mf')
+ const [content, setContent] = useState('structure')
+ const [base, setBase] = useState('none')
+ const [plinthMargin, setPlinthMargin] = useState('2')
+ const [plinthThickness, setPlinthThickness] = useState('2')
+ const [minimumFeature, setMinimumFeature] = useState('')
+ const [isPreparing, setIsPreparing] = useState(false)
+ const [prepared, setPrepared] = useState(null)
+ const [error, setError] = useState(null)
+
+ useEffect(() => {
+ generationRef.current += 1
+ setIsPreparing(false)
+ setPrepared(null)
+ setError(null)
+ }, [
+ nodes,
+ onlyVisible,
+ printScale,
+ scope,
+ format,
+ content,
+ base,
+ plinthMargin,
+ plinthThickness,
+ minimumFeature,
+ modelExport,
+ ])
+
+ useEffect(
+ () => () => {
+ generationRef.current += 1
+ },
+ [],
+ )
+
+ const handlePrepare = async () => {
+ if (!modelExport) {
+ setError('The 3D exporter is still loading.')
+ return
+ }
+
+ const generation = generationRef.current + 1
+ generationRef.current = generation
+ setIsPreparing(true)
+ setPrepared(null)
+ setError(null)
+ try {
+ const next = await preparePrintExport(
+ modelExport,
+ onlyVisible,
+ printScale,
+ scope,
+ format,
+ content,
+ scope === 'levels' ? base : 'none',
+ plinthMargin,
+ plinthThickness,
+ minimumFeature,
+ )
+ if (generation === generationRef.current) setPrepared(next)
+ } catch (reason) {
+ if (generation === generationRef.current) {
+ setError(reason instanceof Error ? reason.message : 'Print export failed.')
+ }
+ } finally {
+ if (generation === generationRef.current) setIsPreparing(false)
+ }
+ }
+
+ return (
+
+
+
+
+
Print files
+
+ Experimental millimeter, Z-up export normalized to the print bed
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {scope === 'levels' && base === 'plinth' && (
+
+
+
+
+ )}
+
+
+
+
+
+ {error && (
+
+
+ {error}
+
+ )}
+
+ {prepared && (
+
+
+ {prepared.report.status === 'blocked' ? (
+
+ ) : prepared.report.status === 'warning' ? (
+
+ ) : (
+
+ )}
+
+ {prepared.report.status === 'blocked'
+ ? 'Basic preflight blocked this download.'
+ : prepared.report.status === 'warning'
+ ? 'Prepared with printability warnings.'
+ : 'Basic surface checks passed.'}
+
+
+
+ {isPrintLevelBundleReport(prepared.report) ? (
+
+
+ Print parts
+ {prepared.report.partCount}
+
+ {prepared.report.parts.map((part) => (
+
+
+ {part.label}
+
+ {part.report.bounds
+ ? `${formatMillimeters(part.report.bounds.width)} × ${formatMillimeters(
+ part.report.bounds.depth,
+ )} × ${formatMillimeters(part.report.bounds.height)} mm`
+ : 'No geometry'}
+
+
+
+ {part.report.triangleCount.toLocaleString()} triangles ·{' '}
+ {part.report.status === 'pass' ? 'basic checks passed' : part.report.status}
+
+
+ Solid components ·{' '}
+ {part.report.solidComponentCount?.toLocaleString() ?? 'Not checked'} · Surface
+ shells · {part.report.connectedComponentCount?.toLocaleString() ?? 'Not checked'}
+
+ {part.report.minimumFeatureThicknessMm !== undefined && (
+
+ Minimum known feature ·{' '}
+ {part.report.minimumFeatureThicknessMm === null
+ ? 'Not measured'
+ : `${formatMillimeters(part.report.minimumFeatureThicknessMm)} mm`}
+
+ )}
+
+ ))}
+
+ ) : (
+
+ - Physical size
+ -
+ {prepared.report.bounds
+ ? `${formatMillimeters(prepared.report.bounds.width)} × ${formatMillimeters(
+ prepared.report.bounds.depth,
+ )} × ${formatMillimeters(prepared.report.bounds.height)} mm`
+ : '—'}
+
+ - Triangles
+ -
+ {prepared.report.triangleCount.toLocaleString()}
+
+ - Boundary edges
+ -
+ {prepared.report.boundaryEdgeCount?.toLocaleString() ?? 'Not checked'}
+
+ - Non-manifold edges
+ -
+ {prepared.report.nonManifoldEdgeCount?.toLocaleString() ?? 'Not checked'}
+
+ - Solid components
+ -
+ {prepared.report.solidComponentCount?.toLocaleString() ?? 'Not checked'}
+
+ - Surface shells
+ -
+ {prepared.report.connectedComponentCount?.toLocaleString() ?? 'Not checked'}
+
+ - Face winding
+ -
+ {prepared.report.invertedWinding === null
+ ? 'Not checked'
+ : prepared.report.invertedWinding
+ ? 'Inverted'
+ : 'Outward'}
+
+ {prepared.report.minimumFeatureThicknessMm !== undefined && (
+ <>
+ - Minimum known feature
+ -
+ {prepared.report.minimumFeatureThicknessMm === null
+ ? 'Not measured'
+ : `${formatMillimeters(prepared.report.minimumFeatureThicknessMm)} mm`}
+
+
+ )}
+
+ )}
+
+
+ {prepared.report.diagnostics.map((diagnostic, index) => (
+ - · {diagnostic.message}
+ ))}
+
+
+
+
+ )}
+