@docx-editor.dev/core/export

acquireSharedExportShapingfunctionSource ↗

Acquire one process-wide shaped measurement substrate for a host configuration.

Failed initialization is evicted so a corrected transient resource can retry. Successful native shaping and admitted font bytes intentionally live for the process lifetime; export sessions retain only their own layout caches and remain independently disposable.

declare function acquireSharedExportShaping(prepared: PreparedLayoutFontConfiguration, instrumentation?: LayoutShapingInstrumentation): Promise<SharedExportShapingCapabilities>;

createNodeImageDecodePortfunctionSource ↗

Decode raster dimensions from validated headers, with no native image dependency or DOM. SVG sizing is handled by the resource registry; preserved formats stay placeholders unless the caller supplies convertPreserved.

declare function createNodeImageDecodePort(options?: {
    readonly convertPreserved?: PreservedImageConverter;
}): ImageDecodePort;

createPackagedFileFetchfunctionSource ↗

Build the packaged-asset fetch adapter shared by headless exporters. File reads stay inside the host-chosen trustedRoot list and never allocate more than maxBytes. Kept injectable for lifecycle and host-fetch tests.

declare function createPackagedFileFetch(options: PackagedFileFetchOptions): typeof fetch;

exportDestinationNamedfunctionSource ↗

Resolve one internal destination name from a Core-produced export layout.

declare function exportDestinationNamed(layout: {
    readonly destinations?: readonly ExportDestinationGeometry[];
}, name: string): ExportDestinationGeometry | undefined;

hasExportAdmittedFontfunctionSource ↗

Whether a value publishes [ExportAdmittedFontApi](ExportAdmittedFontApi).

declare function hasExportAdmittedFont<T extends object>(value: T): value is T & ExportAdmittedFontApi;

hasExportLaidOutTextfunctionSource ↗

Whether a value publishes [ExportLaidOutTextApi](ExportLaidOutTextApi).

declare function hasExportLaidOutText<T extends object>(value: T): value is T & ExportLaidOutTextApi;

hasFontBackedExportCapabilitiesfunctionSource ↗

Whether a value publishes both font-backed session capabilities.

declare function hasFontBackedExportCapabilities<T extends object>(value: T): value is T & ExportAdmittedFontApi & ExportLaidOutTextApi;

openDocumentForExportfunctionSource ↗

Open bytes or a live neutral view into one reusable layout session.

declare function openDocumentForExport(source: ExportDocumentSource, options?: OpenDocumentForExportOptions): OpenDocumentForExportResult;

openFontBackedDocumentForExportfunctionSource ↗

Open immutable DOCX bytes with document-aware, session-owned font shaping.

This is the composition root exporters should use. It parses before requesting fonts, applies cancellation/deadlines to provisioning, atomically binds the resulting measurer to that parsed view, and releases the document-specific font lease with the returned session. When best-effort resolution admits no source, the session retains Core's deterministic fixed measurer; strict policy already refuses that incomplete coverage. Mutable views are intentionally excluded: a live editor host must supply its own revision-stable measurer.

declare function openFontBackedDocumentForExport(source: Uint8Array, options: OpenFontBackedDocumentForExportOptions): Promise<OpenFontBackedDocumentForExportResult>;

ExportResourceErrorclassSource ↗

Bounded failure from a headless export session.

declare class ExportResourceError extends Error

ExportAdmittedFontApiinterfaceSource ↗

Session capability that yields admitted face bytes on demand.

interface ExportAdmittedFontApi

ExportAdmittedFontFaceinterfaceSource ↗

Session-visible admitted face whose bytes are shared with the session shaper and content-hashed shaping cache. Treat [ExportAdmittedFontFace.bytes](ExportAdmittedFontFace.bytes) as strictly read-only; in-place mutation can corrupt later shaping after cache eviction or before the first shape for that face.

interface ExportAdmittedFontFace extends ExportAdmittedFontIdentity

ExportAdmittedFontIdentityinterfaceSource ↗

Byte-free admitted face identity for laid-out text and evidence.

interface ExportAdmittedFontIdentity

ExportDestinationAnchorinterfaceSource ↗

Model address shared by bookmarks and internal hyperlinks.

interface ExportDestinationAnchor

ExportDestinationGeometryinterfaceSource ↗

Laid-out jump target in the coordinate spaces export traversal uses.

interface ExportDestinationGeometry

ExportDroppedEmbeddedFontinterfaceSource ↗

One document-embedded face the export mapper refused before composition.

interface ExportDroppedEmbeddedFont

ExportFontFaceResolutioninterfaceSource ↗

One paintable face in an export font-resolution report.

interface ExportFontFaceResolution

ExportFontFamilyResolutioninterfaceSource ↗

Coverage of one family Core layout may request.

interface ExportFontFamilyResolution

ExportFontResolutionReportinterfaceSource ↗

Exporter-neutral evidence for the font policy behind one layout session.

interface ExportFontResolutionReport

ExportLaidOutTextinterfaceSource ↗

Exact shaped glyph run and admitted font identity for one published span.

The run is shaped at the base size measurement uses. Callers apply the span's drawn-size factor, horizontal scale, and character spacing from [StyleSpanRecord.style](StyleSpanRecord.style). font is a frozen byte-free descriptor; obtain bytes from the session font capability.

interface ExportLaidOutText

ExportLaidOutTextApiinterfaceSource ↗

Additive laid-out text shaping for font-backed export sessions and shared shaping.

interface ExportLaidOutTextApi

ExportSemanticLayoutinterfaceSource ↗

Export-ready semantic snapshot. Core guarantees normalized review artifacts for every session, including an empty immutable array when the source has none. A resolved snapshot is recursively immutable and remains traversable after its producer session is disposed; disposal only revokes session-owned work and capabilities such as [ExportSession.validatedImageBytes](ExportSession.validatedImageBytes).

interface ExportSemanticLayout extends SemanticLayout

ExportSessioninterfaceSource ↗

A single semantic-layout substrate reusable by Markdown and later exporters. Pagination fidelity is determined by the session's measurer; core's default is deterministic, not font-accurate.

interface ExportSession

FontBackedExportCapabilitiesinterfaceSource ↗

Core-produced font-backed session with admitted-face and laid-out-text capabilities.

interface FontBackedExportCapabilities extends FontBackedExportSession, ExportAdmittedFontApi, ExportLaidOutTextApi

FontBackedExportSessioninterfaceSource ↗

Export session retaining the exact font evidence used to construct its measurer.

interface FontBackedExportSession extends ExportSession

FontOriginFailureinterfaceSource ↗

One font origin that could not contribute a valid fragment.

interface FontOriginFailure

FontRequestinterfaceSource ↗

A face, as something asks for it: family plus the two axes this engine admits.

Only static weights and slants. Variable-font axes are deliberately outside this vocabulary — the shaper refuses variation axes, and a variable file admitted here would render bold at regular weight.

interface FontRequest

FontSubstitutioninterfaceSource ↗

A request that was answered by a DIFFERENT face than the one asked for.

Recorded rather than silently applied, because a substitution changes measurement: it is part of the shaping fingerprint, so a cached run shaped against a substitute is never reused for the real face.

interface FontSubstitution

OpenDocumentForExportOptionsinterfaceSource ↗

Shared session options; translators add their own format-specific options.

interface OpenDocumentForExportOptions

OpenFontBackedDocumentForExportOptionsinterfaceSource ↗

Font-backed one-shot session options shared by Markdown and future exporters.

interface OpenFontBackedDocumentForExportOptions extends Omit<OpenDocumentForExportOptions, 'measurer' | 'reuseAcrossRevisions'>

PackagedFileFetchOptionsinterfaceSource ↗

Bounds for [createPackagedFileFetch](createPackagedFileFetch). trustedRoot is one directory or a short host-chosen list of directories of allowed file: URLs. maxBytes is the per-file allocation ceiling and cannot exceed the engine font-byte ceiling.

interface PackagedFileFetchOptions

SharedExportShapinginterfaceSource ↗

Immutable handle over process-wide measurement state reusable by every exporter.

interface SharedExportShaping

ExportDocumentMetadatatypeSource ↗

Bounded package metadata for exporter output dictionaries.

type ExportDocumentMetadata = Readonly<DocumentProperties>;

ExportDocumentSourcetypeSource ↗

Source accepted by every exporter: untrusted bytes or an already-open live view.

type ExportDocumentSource = Uint8Array | HeadlessDocumentView;

FontOrigintypeSource ↗

ONE font origin, in the one shape every origin takes: a finished configuration, a fragment, a promise for either, or a marked resolver that answers per document.

The point of the union is that packagedFonts(), googleFonts(), await defaultFonts() and a hand-built { sources } are all the same kind of thing, so a list of them needs no ordering rule beyond "first wins".

The resolver arm is [MarkedFontResolver](MarkedFontResolver), not bare FontResolver: a list may also hold a zero-argument loader, and only the mark separates the two.

type FontOrigin = FontConfiguration | FontConfigurationFragment | MarkedFontResolver | Promise<FontConfiguration | FontConfigurationFragment | undefined> | undefined;

OpenDocumentForExportResulttypeSource ↗

Typed refusal for bytes that cannot become a document view, or an already-aborted open.

type OpenDocumentForExportResult = {
    readonly ok: true;
    readonly session: ExportSession;
} | {
    readonly ok: false;
    readonly reason: HeadlessDocumentRejection | 'aborted';
    readonly detail?: string;
};

OpenFontBackedDocumentForExportResulttypeSource ↗

Result of opening immutable bytes through Core's document-aware font composition root.

type OpenFontBackedDocumentForExportResult = {
    readonly ok: true;
    readonly session: FontBackedExportCapabilities;
} | Exclude<OpenDocumentForExportResult, {
    readonly ok: true;
}>;

PackagedFileReadtypeSource ↗

Read packaged bytes from a confined local file: URL. Kept injectable for tests.

type PackagedFileRead = (path: string | URL, options: {
    readonly signal?: AbortSignal;
    readonly maxBytes: number;
}) => Promise<Uint8Array>;

PreservedImageConvertertypeSource ↗

Optional caller conversion for preserved formats such as EMF/WMF/TIFF.

type PreservedImageConverter = (bytes: Uint8Array, mime: PreservedImageMime, limits: ImageResourceLimits, 
signal?: AbortSignal) => Promise<Readonly<{
    bytes: Uint8Array;
    mime: SupportedImageMime;
}> | null>;

SharedExportShapingCapabilitiestypeSource ↗

Core-produced shared shaping with exact laid-out text.

type SharedExportShapingCapabilities = SharedExportShaping & ExportLaidOutTextApi;

MAX_SHARED_EXPORT_SHAPING_CONFIGURATIONSconstSource ↗

Process-wide ceiling preventing host-derived cache keys from retaining unbounded font sets.

MAX_SHARED_EXPORT_SHAPING_CONFIGURATIONS = 32