@nowline/export 0.8.6 → 0.10.0

package/src/index.ts

@@ -1,7 +1,8 @@
 // @nowline/export — the shared export kernel.
 //
 // The single code path from `.nowline` source to any of the eight export
-// artifacts (parse → resolve includes → layout → renderSvg → format adapter).
+// artifacts (stageRoadmap: parse → resolve includes → load logo → schedule →
+// layout; then renderSvg → format adapter).
 // Every surface — the CLI, the `@nowline/mcp` server, the VS Code extension,
 // and the Free/Pro web apps — runs this same code with the same inputs, so
 // they all produce byte-for-byte identical output for the same source and the
@@ -10,24 +11,33 @@
 // Spec: specs/export-determinism.md (the byte-identity precedent and the
 // HostEnv / RenderInputs contract this surface implements).
 //
-// Plan: s2 implements the kernel pipeline (parse → resolve → layout →
-// renderSvg → format dispatch). s4 swaps export-png to resvg-wasm.
+// Staging is `@nowline/renderer`'s `stageRoadmap` (specs/surface-options.md
+// §3.3); `exportStaged` exports a roadmap a caller already staged.
 
 import {
-    collectDocumentDiagnostics,
     createNowlineServices,
     type NowlineFile,
     type NowlineServices,
-    resolveIncludes,
+    type RawDiagnostic,
+    type ResolveDiagnostic,
+    serializeToJson,
 } from '@nowline/core';
 import type { ExportInputs, ResolvedFontPair } from '@nowline/export-core';
-import { layoutRoadmap, type ThemeName } from '@nowline/layout';
-import { type AssetResolver, type FontFamilies, renderSvg } from '@nowline/renderer';
-import type { AstNode, LangiumDocument } from 'langium';
-import { URI } from 'langium';
+import type { NonWorkingDisplay, ThemeName } from '@nowline/layout';
+import {
+    type AssetResolver,
+    type FontFamilies,
+    renderSvg,
+    type StagedRoadmap,
+    type StageInputs,
+    type StageLayout,
+    type StageResult,
+    stageRoadmap,
+} from '@nowline/renderer';
+import type { LangiumDocument } from 'langium';
 
 export type { PdfOrientation, ResolvedFontPair } from '@nowline/export-core';
-export type { ThemeName } from '@nowline/layout';
+export type { NonWorkingDisplay, ThemeName } from '@nowline/layout';
 export {
     civilDateInZone,
     type NormalizedZone,
@@ -36,6 +46,26 @@ export {
     resolveToday,
     TimezoneError,
 } from '@nowline/layout';
+export type { StagedRoadmap, StageResult } from '@nowline/renderer';
+
+/**
+ * Thrown when include resolution reports a wave-rule error (a coded or
+ * `rule: 'wave'` diagnostic, specs/waves.md §6.1) and no other include error.
+ * `message` is the same `@nowline/export: include error in …` text as the
+ * plain include error; `diagnostics` carries every resolver diagnostic, errors
+ * and warnings, so a surface can report the routed ones (see
+ * `isRoutedResolveDiagnostic`) with file and line, like validator diagnostics.
+ * Every other include error stays a plain `Error`.
+ */
+export class IncludeResolveError extends Error {
+    readonly diagnostics: ResolveDiagnostic[];
+
+    constructor(message: string, diagnostics: ResolveDiagnostic[]) {
+        super(message);
+        this.name = 'IncludeResolveError';
+        this.diagnostics = diagnostics;
+    }
+}
 
 /** The eight canonical export formats. Every surface produces exactly these. */
 export type ExportFormat = 'svg' | 'png' | 'pdf' | 'html' | 'mermaid' | 'xlsx' | 'msproj' | 'json';
@@ -84,16 +114,28 @@ export interface RenderInputs {
     fonts?: ResolvedFontPair;
 
     // ---- layout / render knobs ------------------------------------------
-    /** Optional fixed canvas width in px. */
+    /** Optional best-effort maximum canvas width in px; unset fits the content. */
     width?: number;
+    /**
+     * How the chart shows a calendar's non-working days (`hide` collapses them,
+     * `show` draws shaded bands). Wins over the file's
+     * `default roadmap non-working:` key; leave it unset (undefined) to let the
+     * key apply, then `hide`. The schedule exporters (mermaid, msproj, xlsx)
+     * take no display input, so their bytes are the same in both views.
+     */
+    nonWorking?: NonWorkingDisplay;
     /** Drop `<a>` links from the rendered SVG. */
     noLinks?: boolean;
     /** Treat render warnings (e.g. missing assets) as hard errors. */
     strict?: boolean;
 
     // ---- format-specific options ----------------------------------------
-    /** PDF page size — a preset name or a custom dimensions string. */
-    pageSize?: string;
+    /**
+     * PDF page size: a preset name, a custom dimensions string, or a value
+     * already parsed with `parsePageSize` (so a caller can reject a bad one
+     * before rendering).
+     */
+    pageSize?: import('@nowline/export-core').PdfPageSize | string;
     /** PDF orientation. */
     orientation?: import('@nowline/export-core').PdfOrientation;
     /** PDF margin in points. */
@@ -102,6 +144,27 @@ export interface RenderInputs {
     pngScale?: number;
     /** MS Project start-date override (YYYY-MM-DD). */
     msprojStart?: string;
+
+    // ---- host callbacks ---------------------------------------------------
+    /**
+     * Called before layout with the routed (wave-rule) resolver diagnostics
+     * when include resolution succeeds, which leaves only warnings (possibly
+     * none). Errors throw `IncludeResolveError` instead. Never affects output.
+     */
+    onResolveDiagnostics?: (diagnostics: ResolveDiagnostic[]) => void;
+    /**
+     * Receives non-fatal notices about the artifact, such as the MS Project
+     * lossy-feature summary. Never affects output. Omit to keep each
+     * exporter's default (stderr), as before.
+     */
+    onNotice?: (message: string) => void;
+    /**
+     * Receives asset warnings, such as a `logo:` file that is missing or
+     * unreadable (the render then proceeds without the logo) or SVG logo
+     * content the sanitizer removed. Under `strict` they throw instead and
+     * this is not called.
+     */
+    onWarning?: (message: string) => void;
 }
 
 // ---- Langium services singleton -----------------------------------------------
@@ -115,88 +178,30 @@ type Services = {
 };
 
 let cachedServices: Services | undefined;
-let docCounter = 0;
 
 function getExportServices(): Services {
     if (!cachedServices) cachedServices = createNowlineServices();
     return cachedServices;
 }
 
-function freshUri(): URI {
-    // Always mint a fresh URI — re-using one lets Langium mutate the prior
-    // document in place, causing spurious diagnostics on repeated exports.
-    return URI.parse(`memory:///kernel-${++docCounter}.nowline`);
-}
-
-// ---- Inline JSON serializer ---------------------------------------------------
+// ---- JSON serializer ---------------------------------------------------------
 //
-// Equivalent to packages/cli/src/convert/schema.ts. Inlined here so the kernel
-// has no dependency on @nowline/cli.
-
-const JSON_SCHEMA_VERSION = '1';
-const CONTAINER_KEYS = new Set(['$container', '$containerProperty', '$containerIndex']);
-const RUNTIME_KEYS = new Set(['$cstNode', '$document']);
-
-function isAstNode(v: unknown): v is AstNode {
-    return (
-        v !== null && typeof v === 'object' && typeof (v as { $type?: unknown }).$type === 'string'
-    );
-}
-
-function serializeNode(node: AstNode, includePositions: boolean): Record<string, unknown> {
-    const out: Record<string, unknown> = { $type: node.$type };
-    if (includePositions && node.$cstNode) {
-        const cst = node.$cstNode;
-        out.$position = {
-            start: {
-                line: cst.range.start.line + 1,
-                column: cst.range.start.character + 1,
-                offset: cst.offset,
-            },
-            end: {
-                line: cst.range.end.line + 1,
-                column: cst.range.end.character + 1,
-                offset: cst.end,
-            },
-        };
-    }
-    for (const [key, value] of Object.entries(node)) {
-        if (key.startsWith('$') || CONTAINER_KEYS.has(key) || RUNTIME_KEYS.has(key)) continue;
-        out[key] = serializeValue(value, includePositions);
-    }
-    return out;
-}
-
-function serializeValue(value: unknown, includePositions: boolean): unknown {
-    if (value === null || value === undefined) return value;
-    if (Array.isArray(value)) return value.map((v) => serializeValue(v, includePositions));
-    if (isAstNode(value)) return serializeNode(value, includePositions);
-    if (typeof value === 'object') {
-        const out: Record<string, unknown> = {};
-        for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
-            if (k.startsWith('$') || CONTAINER_KEYS.has(k) || RUNTIME_KEYS.has(k)) continue;
-            out[k] = serializeValue(v, includePositions);
-        }
-        return out;
-    }
-    return value;
-}
+// Delegates to core's `serializeToJson`. The one envelope difference: the
+// stage parses from a synthetic `memory:///stage-N.nowline` URI, so it
+// overrides `file.uri` with the raw `file://${sourcePath}` concatenation —
+// not `URI.file()`, which would percent-encode and change the bytes the
+// determinism gate hashes.
 
 function serializeDocumentToJson(
     document: LangiumDocument<NowlineFile>,
     source: string,
     sourcePath: string,
 ): string {
-    const ast = document.parseResult.value;
-    return JSON.stringify(
-        {
-            $nowlineSchema: JSON_SCHEMA_VERSION,
-            file: { uri: `file://${sourcePath}`, source },
-            ast: serializeNode(ast, true),
-        },
-        null,
-        2,
-    );
+    const doc = serializeToJson(document, source, {
+        includePositions: true,
+        uri: `file://${sourcePath}`,
+    });
+    return JSON.stringify(doc, null, 2);
 }
 
 // ---- MIME inference ----------------------------------------------------------
@@ -210,50 +215,59 @@ function guessMime(ref: string): string {
     return 'application/octet-stream';
 }
 
-// ---- Staged pipeline ---------------------------------------------------------
+function hostAssetResolver(host: HostEnv): AssetResolver {
+    return async (ref: string) => {
+        const bytes = await host.readAsset(ref);
+        return { bytes, mime: guessMime(ref) };
+    };
+}
+
+// ---- Argument checks ---------------------------------------------------------
 
-interface StageResult {
-    /** SVG rendered with the portable FONT_STACK (for `svg` / `html` exports). */
-    svg: string;
-    /**
-     * Re-render the already-laid-out model with a pinned `font-family` map.
-     * Used by the raster paths (png/pdf) so the exported pixels name exactly
-     * the bundled font and match the live preview (WYSIWYG). Reuses the same
-     * asset resolver and strict/warn handling as the portable render.
-     */
-    renderWith: (fontFamilies: FontFamilies) => Promise<string>;
-    exportInputs: ExportInputs;
-    document: LangiumDocument<NowlineFile>;
-    source: string;
+function checkHostAndInputs(host: HostEnv, inputs: RenderInputs): void {
+    if (
+        typeof host?.readSource !== 'function' ||
+        typeof host.readAsset !== 'function' ||
+        typeof host.loadWasm !== 'function'
+    ) {
+        throw new TypeError('@nowline/export: host must implement the HostEnv interface.');
+    }
+    if (!(inputs?.today instanceof Date) && inputs?.today !== undefined) {
+        throw new TypeError(
+            '@nowline/export: inputs.today must be a Date (UTC midnight) or undefined.',
+        );
+    }
+    if (typeof inputs?.sourcePath !== 'string' || inputs.sourcePath.length === 0) {
+        throw new TypeError('@nowline/export: inputs.sourcePath must be a non-empty string.');
+    }
 }
 
-/**
- * Pin the renderer's per-role families to the resolved fonts' real family
- * names so raster/preview SVG names exactly the bundled face. `serif` maps to
- * the sans family: the resolver has no serif role and raster already falls
- * back serif->sans (resvg has no serif face loaded), so this is behavior-
- * preserving while making the SVG explicit.
- */
-function pinnedFamilies(fonts: ResolvedFontPair): FontFamilies {
-    return { sans: fonts.sans.name, serif: fonts.sans.name, mono: fonts.mono.name };
+const STAGE_LAYOUT_KEYS = ['theme', 'today', 'width', 'locale', 'nonWorking'] as const;
+
+function sameLayoutValue(a: StageLayout[keyof StageLayout], b: unknown): boolean {
+    if (a instanceof Date || b instanceof Date) {
+        return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+    }
+    return a === b;
 }
 
-async function stageDocument(
-    source: string,
-    inputs: RenderInputs,
-    host: HostEnv,
-): Promise<StageResult> {
-    const services = getExportServices();
-    const uri = freshUri();
+/** A stage laid out with other options would export a different chart than `inputs` asks for. */
+function checkStageMatches(stage: StagedRoadmap, inputs: RenderInputs): void {
+    for (const key of STAGE_LAYOUT_KEYS) {
+        if (!sameLayoutValue(stage.layout[key], inputs[key])) {
+            throw new Error(
+                `@nowline/export: the staged roadmap was laid out with a different ${key} than inputs.${key}.`,
+            );
+        }
+    }
+}
 
-    const doc = services.shared.workspace.LangiumDocumentFactory.fromString<NowlineFile>(
-        source,
-        uri,
-    );
-    await services.shared.workspace.DocumentBuilder.build([doc], { validation: true });
+// ---- Staging -----------------------------------------------------------------
 
+/** Lexer, parser and validator error messages, in document order. */
+function errorMessages(diagnostics: RawDiagnostic[]): string[] {
     const errors: string[] = [];
-    for (const raw of collectDocumentDiagnostics(doc)) {
+    for (const raw of diagnostics) {
         if (raw.origin === 'lexer') {
             errors.push(raw.error.message);
         } else if (raw.origin === 'parser') {
@@ -262,69 +276,124 @@ async function stageDocument(
             errors.push(raw.diagnostic.message);
         }
     }
-    if (errors.length > 0) {
+    return errors;
+}
+
+/** What a caller that has already parsed `source` may hand to {@link stageForExport}. */
+export interface StageForExportOptions {
+    /** A document the caller already parsed and validated from `source`. */
+    document?: StageInputs['document'];
+    /** The caller's Langium services, which built `document`. Omitted: the kernel's own. */
+    services?: StageInputs['services'];
+}
+
+/**
+ * Stage `source` the way the kernel does (`stageRoadmap` with the host's
+ * source and asset reads, laid out with `inputs`) and return the raw result:
+ * `invalid`, `include-error` or `staged`. A surface that reports the stage's
+ * own diagnostics maps them itself, then hands a `staged` result to
+ * {@link exportStaged}; {@link acceptStagedRoadmap} is the kernel's mapping.
+ */
+export function stageForExport(
+    source: string,
+    inputs: RenderInputs,
+    host: HostEnv,
+    options: StageForExportOptions = {},
+): Promise<StageResult> {
+    return stageRoadmap({
+        source,
+        sourcePath: inputs.sourcePath,
+        services: options.services ?? getExportServices(),
+        readSource: host.readSource.bind(host),
+        assetResolver: hostAssetResolver(host),
+        document: options.document,
+        layout: inputs,
+    });
+}
+
+/**
+ * Map a stage result to the kernel's contract: validation and include errors
+ * throw, routed warnings reach `onResolveDiagnostics`, and logo warnings
+ * reach `onWarning` (or throw under `strict`). Returns the staged roadmap.
+ */
+export function acceptStagedRoadmap(stage: StageResult, inputs: RenderInputs): StagedRoadmap {
+    if (stage.kind === 'invalid') {
         throw new Error(
-            `@nowline/export: validation errors in ${inputs.sourcePath}: ${errors.join('; ')}`,
+            `@nowline/export: validation errors in ${inputs.sourcePath}: ${errorMessages(stage.diagnostics).join('; ')}`,
         );
     }
 
-    const ast = doc.parseResult.value;
+    // Include errors are more fundamental than wave-rule errors: any of them
+    // keeps the plain throw. Wave-rule errors alone travel on a typed error.
+    const includeError = (diag: ResolveDiagnostic): string =>
+        `@nowline/export: include error in ${inputs.sourcePath}: ${diag.message}`;
+    if (stage.kind === 'include-error') {
+        if (stage.legacy) throw new Error(includeError(stage.legacy));
+        const firstError = stage.routed.filter((d) => d.severity === 'error')[0];
+        throw new IncludeResolveError(includeError(firstError), stage.resolved.diagnostics);
+    }
+    inputs.onResolveDiagnostics?.(stage.routed);
 
-    const resolved = await resolveIncludes(ast, inputs.sourcePath, {
-        services: services.Nowline,
-        readFile: host.readSource.bind(host),
-    });
-    for (const diag of resolved.diagnostics) {
-        if (diag.severity === 'error') {
-            throw new Error(
-                `@nowline/export: include error in ${inputs.sourcePath}: ${diag.message}`,
-            );
-        }
+    // A failed logo load warns (throws under strict); the stage laid out as
+    // if no logo were declared.
+    if (inputs.strict && stage.warnings.length > 0) {
+        throw new Error(
+            `@nowline/export: render warnings (--strict): ${stage.warnings.join('; ')}`,
+        );
     }
+    for (const msg of stage.warnings) inputs.onWarning?.(msg);
 
-    const model = layoutRoadmap(ast, resolved, {
-        theme: inputs.theme,
-        today: inputs.today,
-        width: inputs.width,
-        locale: inputs.locale,
-    });
+    return stage;
+}
 
-    const assetResolver: AssetResolver = async (ref: string) => {
-        const bytes = await host.readAsset(ref);
-        return { bytes, mime: guessMime(ref) };
-    };
+/** Stage `source` and map the result to the kernel's contract. */
+async function stageDocument(
+    source: string,
+    inputs: RenderInputs,
+    host: HostEnv,
+): Promise<StagedRoadmap> {
+    return acceptStagedRoadmap(await stageForExport(source, inputs, host), inputs);
+}
 
-    const renderWith = async (fontFamilies?: FontFamilies): Promise<string> => {
-        const warnings: string[] = [];
-        const svg = await renderSvg(model, {
-            assetResolver,
-            noLinks: inputs.noLinks ?? false,
-            strict: inputs.strict ?? false,
-            warn: (msg) => warnings.push(msg),
-            fontFamilies,
-        });
-        if (inputs.strict && warnings.length > 0) {
-            throw new Error(`@nowline/export: render warnings (--strict): ${warnings.join('; ')}`);
-        }
-        return svg;
-    };
+// ---- Rendering ---------------------------------------------------------------
 
-    // Portable render (FONT_STACK) for the svg/html file exports.
-    const svg = await renderWith();
-
-    return {
-        svg,
-        renderWith: (fontFamilies: FontFamilies) => renderWith(fontFamilies),
-        exportInputs: {
-            model,
-            ast,
-            resolved,
-            sourcePath: inputs.sourcePath,
-            today: inputs.today,
-        },
-        document: doc,
-        source,
-    };
+/**
+ * Pin the renderer's per-role families to the resolved fonts' real family
+ * names so raster/preview SVG names exactly the bundled face. `serif` maps to
+ * the sans family: the resolver has no serif role and raster already falls
+ * back serif->sans (resvg has no serif face loaded), so this is behavior-
+ * preserving while making the SVG explicit.
+ */
+function pinnedFamilies(fonts: ResolvedFontPair): FontFamilies {
+    return { sans: fonts.sans.name, serif: fonts.sans.name, mono: fonts.mono.name };
+}
+
+/**
+ * Render the staged model. The portable render (no `fontFamilies`, the
+ * FONT_STACK) reports non-strict warnings to `onWarning`; a font-pinned
+ * raster re-render does not repeat them. Every render embeds the stage's
+ * logo bytes, so the logo is read once.
+ */
+async function renderStaged(
+    stage: StagedRoadmap,
+    inputs: RenderInputs,
+    assetResolver: AssetResolver,
+    fontFamilies?: FontFamilies,
+): Promise<string> {
+    const warnings: string[] = [];
+    const svg = await renderSvg(stage.model, {
+        assetResolver,
+        logo: stage.logo,
+        noLinks: inputs.noLinks ?? false,
+        strict: inputs.strict ?? false,
+        warn: (msg) => warnings.push(msg),
+        fontFamilies,
+    });
+    if (inputs.strict && warnings.length > 0) {
+        throw new Error(`@nowline/export: render warnings (--strict): ${warnings.join('; ')}`);
+    }
+    if (!fontFamilies) for (const msg of warnings) inputs.onWarning?.(msg);
+    return svg;
 }
 
 // ---- Text encoding -----------------------------------------------------------
@@ -340,15 +409,12 @@ function toUtf8(text: string): Uint8Array {
 /**
  * Produce the export artifact for `source` in `format`. This is the single
  * code path to any exported artifact — no surface re-implements a stage.
+ * It is `stageRoadmap` plus the kernel's error mapping, then `exportStaged`.
  *
  * Text formats (svg / json / html / mermaid / msproj) are returned as UTF-8
  * bytes; binary formats (png / pdf / xlsx) as their native bytes. Returning
  * Uint8Array for every format keeps the determinism gate able to `sha256` one
  * value per (fixture, format).
- *
- * Note: PNG rasterizes via @nowline/export-png (native resvg-js) until s4
- * swaps it to @resvg/resvg-wasm. The `host.loadWasm()` seam is reserved for
- * that swap and is not called here yet.
  */
 export async function exportDocument(
     source: string,
@@ -359,59 +425,85 @@ export async function exportDocument(
     if (typeof source !== 'string') {
         throw new TypeError('@nowline/export: source must be a string.');
     }
-    if (
-        typeof host?.readSource !== 'function' ||
-        typeof host.readAsset !== 'function' ||
-        typeof host.loadWasm !== 'function'
-    ) {
-        throw new TypeError('@nowline/export: host must implement the HostEnv interface.');
-    }
-    if (!(inputs?.today instanceof Date) && inputs?.today !== undefined) {
-        throw new TypeError(
-            '@nowline/export: inputs.today must be a Date (UTC midnight) or undefined.',
-        );
-    }
-    if (typeof inputs?.sourcePath !== 'string' || inputs.sourcePath.length === 0) {
-        throw new TypeError('@nowline/export: inputs.sourcePath must be a non-empty string.');
-    }
-
+    checkHostAndInputs(host, inputs);
     const stage = await stageDocument(source, inputs, host);
+    return exportStaged(stage, format, inputs, host);
+}
+
+/**
+ * Export a roadmap the caller already staged with `stageRoadmap`, so a
+ * surface that stages once (for diagnostics or layout insights) does not
+ * parse and lay out again. The stage must have been laid out with the same
+ * theme, today, width, locale and non-working display as `inputs`; a
+ * mismatch throws. The caller owns the stage's own errors and warnings
+ * (`exportDocument` maps them to the kernel's contract first); this applies
+ * `noLinks`, `strict` and `onWarning` to the render only.
+ *
+ * The SVG is rendered only for the formats that use it (svg, html, png, pdf).
+ */
+export async function exportStaged(
+    stage: StagedRoadmap,
+    format: ExportFormat,
+    inputs: RenderInputs,
+    host: HostEnv,
+): Promise<Uint8Array> {
+    checkHostAndInputs(host, inputs);
+    checkStageMatches(stage, inputs);
+
+    const assetResolver = hostAssetResolver(host);
+    const portableSvg = (): Promise<string> => renderStaged(stage, inputs, assetResolver);
+    const rasterSvg = (fonts: ResolvedFontPair): Promise<string> =>
+        renderStaged(stage, inputs, assetResolver, pinnedFamilies(fonts));
+    const exportInputs: ExportInputs = {
+        model: stage.model,
+        ast: stage.ast,
+        resolved: stage.resolved,
+        schedule: stage.schedule,
+        sourcePath: inputs.sourcePath,
+        today: inputs.today,
+    };
 
     if (format === 'svg') {
-        return toUtf8(stage.svg);
+        return toUtf8(await portableSvg());
     }
 
     if (format === 'json') {
-        return toUtf8(serializeDocumentToJson(stage.document, stage.source, inputs.sourcePath));
+        const source = stage.document.textDocument.getText();
+        return toUtf8(serializeDocumentToJson(stage.document, source, inputs.sourcePath));
     }
 
     if (format === 'html') {
+        const svg = await portableSvg();
         const mod = await import('@nowline/export-html');
-        const html = await mod.exportHtml(stage.exportInputs, stage.svg);
+        const html = await mod.exportHtml(exportInputs, svg);
         return toUtf8(html);
     }
 
     if (format === 'mermaid') {
         const mod = await import('@nowline/export-mermaid');
-        const md = mod.exportMermaid(stage.exportInputs);
+        const md = mod.exportMermaid(exportInputs);
         return toUtf8(md);
     }
 
     if (format === 'msproj') {
         const mod = await import('@nowline/export-msproj');
-        const xml = mod.exportMsProjXml(stage.exportInputs, {
+        const xml = mod.exportMsProjXml(exportInputs, {
             startDate: inputs.msprojStart,
+            onLossy: inputs.onNotice,
         });
         return toUtf8(xml);
     }
 
     if (format === 'xlsx') {
         const mod = await import('@nowline/export-xlsx');
-        const bytes = await mod.exportXlsx(stage.exportInputs, { generated: inputs.today });
+        const bytes = await mod.exportXlsx(exportInputs, { generated: inputs.today });
         return bytes;
     }
 
     if (format === 'png') {
+        // The portable render still runs first: its warnings reach
+        // `onWarning` (or throw under strict) before any raster work.
+        await portableSvg();
         if (!inputs.fonts) {
             throw new TypeError('@nowline/export: inputs.fonts is required for png format.');
         }
@@ -420,8 +512,8 @@ export async function exportDocument(
         await pngMod.initPngWasm(wasmBytes);
         // Raster with the pinned bundled family so the SVG resvg rasterizes
         // names exactly the embedded font (matches the live preview).
-        const rasterSvg = await stage.renderWith(pinnedFamilies(inputs.fonts));
-        const bytes = await pngMod.exportPng(stage.exportInputs, rasterSvg, {
+        const svg = await rasterSvg(inputs.fonts);
+        const bytes = await pngMod.exportPng(exportInputs, svg, {
             scale: inputs.pngScale ?? 2,
             fonts: inputs.fonts,
         });
@@ -429,14 +521,15 @@ export async function exportDocument(
     }
 
     if (format === 'pdf') {
+        await portableSvg();
         if (!inputs.fonts) {
             throw new TypeError('@nowline/export: inputs.fonts is required for pdf format.');
         }
         const mod = await import('@nowline/export-pdf');
         // Same pinned-family raster SVG as PNG so PDF text names the embedded
         // font explicitly and stays consistent with preview + PNG.
-        const rasterSvg = await stage.renderWith(pinnedFamilies(inputs.fonts));
-        const bytes = await mod.exportPdf(stage.exportInputs, rasterSvg, {
+        const svg = await rasterSvg(inputs.fonts);
+        const bytes = await mod.exportPdf(exportInputs, svg, {
             pageSize: inputs.pageSize,
             orientation: inputs.orientation,
             marginPt: inputs.marginPt,