dwf-viewer 0.5.0

package/dist/format/emodelMetadata.js

@@ -0,0 +1,368 @@
+import { decodeUtf8, localName, parseXml } from './util.js';
+import { diag } from './types.js';
+export async function enrichW3dModelFromEModelResources(model, resources, opc) {
+    const diagnostics = model.diagnostics;
+    model.metadata ?? (model.metadata = {});
+    model.materials ?? (model.materials = []);
+    model.textures ?? (model.textures = []);
+    model.sceneTree ?? (model.sceneTree = []);
+    model.pmi ?? (model.pmi = []);
+    model.views ?? (model.views = []);
+    model.animations ?? (model.animations = []);
+    await collectTextures(model, resources, opc, diagnostics);
+    const descriptor = resources.find(r => /descriptor/i.test(r.role ?? '') || /descriptor\.xml$/i.test(r.path));
+    if (descriptor && opc.zip.has(descriptor.path)) {
+        try {
+            parseDescriptor(model, decodeUtf8(await opc.readBytes(descriptor.path)), descriptor.path);
+        }
+        catch (err) {
+            diagnostics.push(diag('warning', 'EMODEL_DESCRIPTOR_PARSE_FAILED', `Failed to parse eModel descriptor: ${String(err)}`, descriptor.path));
+        }
+    }
+    const contentDef = resources.find(r => /content\s+definition/i.test(r.role ?? ''));
+    const instanceInfos = contentDef && opc.zip.has(contentDef.path)
+        ? parseContentDefinitionSafe(model, decodeUtf8(await opc.readBytes(contentDef.path)), contentDef.path, diagnostics)
+        : [];
+    const presentation = resources.find(r => /content\s+presentation/i.test(r.role ?? ''));
+    const labelByContentRef = new Map();
+    let instanceMaterials = new Map();
+    if (presentation && opc.zip.has(presentation.path)) {
+        try {
+            const { nodes, pmi, views, animations, materials } = parseContentPresentation(decodeUtf8(await opc.readBytes(presentation.path)), presentation.path, labelByContentRef);
+            instanceMaterials = materials;
+            model.sceneTree = nodes;
+            model.pmi = pmi;
+            model.views = mergeViews(model.views ?? [], views);
+            model.animations = animations;
+            const existing = new Map((model.materials ?? []).map(m => [m.id, m]));
+            for (const mat of materials.values())
+                existing.set(mat.id, bindTextureByName(mat, model.textures ?? []));
+            model.materials = Array.from(existing.values());
+        }
+        catch (err) {
+            diagnostics.push(diag('warning', 'EMODEL_PRESENTATION_PARSE_FAILED', `Failed to parse eModel presentation: ${String(err)}`, presentation.path));
+        }
+    }
+    attachSelectionMetadata(model, instanceInfos, labelByContentRef, instanceMaterials);
+    const nodeCount = countSceneNodes(model.sceneTree ?? []);
+    if ((model.views?.length ?? 0) > 0 && !model.initialView)
+        model.initialView = model.views[0];
+    model.stats.materialCount = model.materials?.length ?? 0;
+    model.stats.textureCount = model.textures?.length ?? 0;
+    model.stats.pmiCount = model.pmi?.length ?? 0;
+    model.stats.nodeCount = nodeCount;
+}
+async function collectTextures(model, resources, opc, diagnostics) {
+    const textures = [];
+    for (const r of resources.filter(x => /texture/i.test(x.role ?? '') || /texture/i.test(x.title ?? ''))) {
+        if (!opc.zip.has(r.path))
+            continue;
+        let width;
+        let height;
+        try {
+            const size = imageSizeFromBytes(await opc.readBytes(r.path));
+            width = size?.width;
+            height = size?.height;
+        }
+        catch (err) {
+            diagnostics.push(diag('warning', 'EMODEL_TEXTURE_SIZE_FAILED', `Failed to read texture size: ${String(err)}`, r.path));
+        }
+        textures.push({ id: r.path, name: cleanTitle(r.title) ?? basename(r.path), path: r.path, mediaType: r.mediaType, width, height, role: r.role });
+    }
+    model.textures = textures;
+    if (textures.length > 0) {
+        const tex = textures.find(t => /thread/i.test(t.name ?? '')) ?? textures.find(t => !/environment/i.test(t.name ?? '')) ?? textures[0];
+        if (tex) {
+            const defaultMat = { id: 'dwfx-default-textured', name: 'DWFx default material', color: [0.72, 0.74, 0.78], textureId: tex.id, roughness: 0.6, metalness: 0.03, doubleSided: true, source: tex.path };
+            model.materials = [defaultMat];
+            // Do not forcibly assign the texture to every mesh; many DWFx files use environment maps or icons.
+        }
+    }
+}
+function parseDescriptor(model, xml, sourcePath) {
+    const doc = parseXml(xml, sourcePath);
+    const root = doc.documentElement;
+    if (root) {
+        const units = Array.from(root.getElementsByTagName('*')).find(e => localName(e) === 'Units');
+        const unitType = units?.getAttribute('type');
+        if (unitType)
+            model.metadata.units = unitType;
+        const spaceName = root.getAttribute('name');
+        if (spaceName)
+            model.metadata.spaceName = spaceName;
+    }
+    for (const prop of Array.from(doc.getElementsByTagName('*')).filter(e => localName(e) === 'Property')) {
+        const name = prop.getAttribute('name');
+        const value = prop.getAttribute('value');
+        if (name && value)
+            model.metadata[name] = value;
+    }
+    const home = makeViewFromDescriptorProperties(model.metadata);
+    if (home) {
+        model.views = mergeViews(model.views ?? [], [home]);
+        model.initialView = home;
+    }
+}
+function makeViewFromDescriptorProperties(meta) {
+    const position = vector3(meta._ViewCubeHomeCameraPosition);
+    const target = vector3(meta._ViewCubeHomeCameraTarget);
+    const up = vector3(meta._ViewCubeHomeCameraUpVector);
+    const field = vector3(meta._ViewCubeHomeCameraField);
+    if (!position && !target && !up)
+        return undefined;
+    return { id: 'descriptor-home-view', label: 'Home', camera: { position, target, up, field, projection: meta._ViewCubeHomeCameraProjection === '1' ? 'perspective' : 'orthographic' } };
+}
+function parseContentDefinitionSafe(model, xml, sourcePath, diagnostics) {
+    try {
+        const doc = parseXml(xml, sourcePath);
+        const instances = [];
+        for (const el of Array.from(doc.getElementsByTagName('*')).filter(e => localName(e) === 'Instance')) {
+            const id = el.getAttribute('id') ?? '';
+            if (!id)
+                continue;
+            instances.push({ id, renderableRef: el.getAttribute('renderableRef') ?? undefined, node: el.getAttribute('node') ?? undefined, geometricVariation: el.getAttribute('geometricVariation') ?? undefined });
+        }
+        model.metadata.contentInstanceCount = String(instances.length);
+        return instances;
+    }
+    catch (err) {
+        diagnostics.push(diag('warning', 'EMODEL_CONTENTDEF_PARSE_FAILED', `Failed to parse eModel content definition: ${String(err)}`, sourcePath));
+        return [];
+    }
+}
+function parseContentPresentation(xml, sourcePath, labelByContentRef) {
+    const doc = parseXml(xml, sourcePath);
+    const topContainers = Array.from(doc.getElementsByTagName('*')).filter(e => localName(e) === 'View');
+    const nodes = [];
+    for (const view of topContainers) {
+        const viewNodes = nodeChildrenUnder(view);
+        for (const n of viewNodes)
+            nodes.push(parseSceneNode(n, labelByContentRef));
+    }
+    if (nodes.length === 0) {
+        for (const n of Array.from(doc.getElementsByTagName('*')).filter(e => localName(e) === 'ReferenceNode' && !hasAncestorReferenceNode(e)))
+            nodes.push(parseSceneNode(n, labelByContentRef));
+    }
+    const views = [];
+    for (const modelView of Array.from(doc.getElementsByTagName('*')).filter(e => /ModelViewNode|View/i.test(localName(e)))) {
+        const id = modelView.getAttribute('id') ?? `view-${views.length + 1}`;
+        const label = modelView.getAttribute('label') ?? modelView.getAttribute('name') ?? id;
+        const camEl = directChildren(modelView).find(e => localName(e) === 'Camera') ?? Array.from(modelView.getElementsByTagName('*')).find(e => localName(e) === 'Camera');
+        const camera = camEl ? cameraFromElement(camEl) : undefined;
+        if (camera || /ModelViewNode/i.test(localName(modelView)))
+            views.push({ id, label, camera });
+    }
+    const pmi = [];
+    for (const el of Array.from(doc.getElementsByTagName('*'))) {
+        const ln = localName(el);
+        if (!/PMI|Markup|Dimension|Annotation|Callout|Leader|Note/i.test(ln))
+            continue;
+        pmi.push({ id: el.getAttribute('id') ?? `pmi-${pmi.length + 1}`, type: /Leader/i.test(ln) ? 'leader' : /Text|Note|Dimension/i.test(ln) ? 'text' : 'markup', label: el.getAttribute('label') ?? el.getAttribute('name') ?? ln, text: el.getAttribute('text') ?? el.textContent?.trim() ?? undefined, targetRef: el.getAttribute('contentElementRefs') ?? el.getAttribute('target') ?? undefined, properties: attributesToRecord(el) });
+    }
+    const animations = [];
+    for (const el of Array.from(doc.getElementsByTagName('*')).filter(e => /Animation|Sequence|Timeline/i.test(localName(e)))) {
+        animations.push({ id: el.getAttribute('id') ?? `animation-${animations.length + 1}`, name: el.getAttribute('label') ?? el.getAttribute('name') ?? localName(el), targetRef: el.getAttribute('target') ?? undefined });
+    }
+    const materials = parseInstanceMaterials(doc);
+    return { nodes, pmi, views: dedupeViews(views), animations, materials };
+}
+function parseInstanceMaterials(doc) {
+    const out = new Map();
+    for (const inst of Array.from(doc.getElementsByTagName('*')).filter(e => localName(e) === 'InstanceAttributes')) {
+        const id = inst.getAttribute('id');
+        if (!id)
+            continue;
+        const colorEl = directChildren(inst).find(e => localName(e) === 'Color') ?? Array.from(inst.getElementsByTagName('*')).find(e => localName(e) === 'Color');
+        if (!colorEl)
+            continue;
+        const diffuse = Array.from(colorEl.getElementsByTagName('*')).find(e => localName(e) === 'Channel' && /diffuse/i.test(e.getAttribute('type') ?? ''));
+        const env = Array.from(colorEl.getElementsByTagName('*')).find(e => localName(e) === 'Channel' && /environment/i.test(e.getAttribute('type') ?? ''));
+        const red = Number(diffuse?.getAttribute('red'));
+        const green = Number(diffuse?.getAttribute('green'));
+        const blue = Number(diffuse?.getAttribute('blue'));
+        if (![red, green, blue].every(Number.isFinite))
+            continue;
+        const gloss = Number(colorEl.getAttribute('gloss'));
+        const textureName = cleanTitle(env?.getAttribute('name') ?? undefined);
+        out.set(id, {
+            id: `material-${id}`,
+            name: `Material ${id}`,
+            color: [red, green, blue],
+            opacity: 1,
+            roughness: Number.isFinite(gloss) ? Math.max(0.12, Math.min(0.92, 1 - gloss / 128)) : 0.58,
+            metalness: 0.03,
+            textureName,
+            doubleSided: true,
+            source: 'content-presentation'
+        });
+    }
+    return out;
+}
+function bindTextureByName(material, textures) {
+    if (material.textureId || !material.textureName)
+        return material;
+    const norm = normalizeMaterialName(material.textureName);
+    const match = textures.find(t => normalizeMaterialName(t.name ?? '').includes(norm) || norm.includes(normalizeMaterialName(t.name ?? '')));
+    return match ? { ...material, textureId: match.id } : material;
+}
+function normalizeMaterialName(s) {
+    return s.replace(/"/g, '').replace(/["{}]/g, '').toLowerCase();
+}
+function parseSceneNode(el, labelByContentRef) {
+    const refs = splitRefs(el.getAttribute('contentElementRefs') ?? el.getAttribute('contentRefs') ?? '');
+    const node = {
+        id: el.getAttribute('id') ?? `node-${Math.random().toString(36).slice(2)}`,
+        label: el.getAttribute('label') ?? el.getAttribute('name') ?? localName(el),
+        contentRefs: refs,
+        meshIds: [],
+        children: [],
+        properties: attributesToRecord(el)
+    };
+    for (const ref of refs)
+        labelByContentRef.set(ref, node);
+    for (const child of nodeChildrenUnder(el))
+        node.children.push(parseSceneNode(child, labelByContentRef));
+    return node;
+}
+function attachSelectionMetadata(model, instances, labelByContentRef, instanceMaterials) {
+    const labelForRef = new Map(labelByContentRef);
+    instances.forEach((inst, i) => {
+        const mesh = model.meshes[i];
+        if (!mesh)
+            return;
+        const refs = [inst.renderableRef, inst.id].filter(Boolean);
+        mesh.selectionRefs = refs;
+        mesh.nodeId = inst.node;
+        const mat = instanceMaterials.get(inst.id) ?? (inst.renderableRef ? instanceMaterials.get(inst.renderableRef) : undefined);
+        if (mat) {
+            mesh.materialId = mat.id;
+            mesh.color = mat.color;
+        }
+        for (const ref of refs) {
+            const node = labelForRef.get(ref);
+            if (node) {
+                mesh.name = node.label || mesh.name;
+                node.meshIds.push(mesh.id);
+                break;
+            }
+        }
+    });
+}
+function cameraFromElement(el) {
+    const pos = attrsVector3(el, 'positionX', 'positionY', 'positionZ');
+    const target = attrsVector3(el, 'targetX', 'targetY', 'targetZ');
+    const up = attrsVector3(el, 'upVectorX', 'upVectorY', 'upVectorZ');
+    const field = attrsVector3(el, 'fieldWidth', 'fieldHeight', 'fieldDepth');
+    return { position: pos, target, up, field, projection: el.getAttribute('projectionType') ?? undefined };
+}
+function attrsVector3(el, x, y, z) {
+    const nums = [Number(el.getAttribute(x)), Number(el.getAttribute(y)), Number(el.getAttribute(z))];
+    return nums.every(Number.isFinite) ? nums : undefined;
+}
+function vector3(raw) {
+    if (!raw)
+        return undefined;
+    const n = raw.trim().split(/[\s,]+/).map(Number).filter(Number.isFinite);
+    return n.length >= 3 ? [n[0], n[1], n[2]] : undefined;
+}
+function directChildren(el) {
+    return Array.from(el.children);
+}
+function nodeChildrenUnder(el) {
+    const out = [];
+    for (const child of directChildren(el)) {
+        const ln = localName(child);
+        if (ln.endsWith('Node'))
+            out.push(child);
+        else if (ln === 'Nodes' || ln === 'Views') {
+            for (const grand of directChildren(child))
+                if (localName(grand).endsWith('Node'))
+                    out.push(grand);
+        }
+    }
+    return out;
+}
+function hasAncestorReferenceNode(el) {
+    let p = parentElementOf(el);
+    while (p) {
+        if (localName(p) === 'ReferenceNode')
+            return true;
+        p = parentElementOf(p);
+    }
+    return false;
+}
+function parentElementOf(el) {
+    return (el.parentElement ?? el.parentNode) || undefined;
+}
+function attributesToRecord(el) {
+    const out = {};
+    for (const a of Array.from(el.attributes))
+        out[a.localName || a.name] = a.value;
+    return out;
+}
+function splitRefs(raw) {
+    return raw.trim().split(/[\s,]+/).filter(Boolean);
+}
+function mergeViews(a, b) {
+    return dedupeViews([...a, ...b]);
+}
+function dedupeViews(views) {
+    const seen = new Set();
+    const out = [];
+    for (const v of views) {
+        const key = v.id || v.label;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(v);
+    }
+    return out;
+}
+function countSceneNodes(nodes) {
+    let n = 0;
+    for (const node of nodes)
+        n += 1 + countSceneNodes(node.children);
+    return n;
+}
+function basename(path) {
+    const i = path.lastIndexOf('/');
+    return i >= 0 ? path.slice(i + 1) : path;
+}
+function cleanTitle(raw) {
+    if (!raw)
+        return undefined;
+    return raw.replace(/^"|"$/g, '').replace(/"/g, '"');
+}
+function imageSizeFromBytes(bytes) {
+    if (bytes.length >= 24 && bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47) {
+        return { width: be32(bytes, 16), height: be32(bytes, 20) };
+    }
+    if (bytes.length >= 4 && bytes[0] === 0xff && bytes[1] === 0xd8) {
+        let p = 2;
+        while (p + 9 < bytes.length) {
+            if (bytes[p] !== 0xff) {
+                p++;
+                continue;
+            }
+            const marker = bytes[p + 1];
+            p += 2;
+            while (bytes[p] === 0xff)
+                p++;
+            if (marker === 0xd9 || marker === 0xda)
+                break;
+            if (p + 2 > bytes.length)
+                break;
+            const len = (bytes[p] << 8) | bytes[p + 1];
+            if (len < 2 || p + len > bytes.length)
+                break;
+            if ((marker >= 0xc0 && marker <= 0xc3) || (marker >= 0xc5 && marker <= 0xc7) || (marker >= 0xc9 && marker <= 0xcb) || (marker >= 0xcd && marker <= 0xcf)) {
+                return { width: (bytes[p + 5] << 8) | bytes[p + 6], height: (bytes[p + 3] << 8) | bytes[p + 4] };
+            }
+            p += len;
+        }
+    }
+    return undefined;
+}
+function be32(bytes, offset) {
+    return ((bytes[offset] << 24) | (bytes[offset + 1] << 16) | (bytes[offset + 2] << 8) | bytes[offset + 3]) >>> 0;
+}

package/dist/format/inflate.d.ts

@@ -0,0 +1,4 @@
+import type { InflateProvider } from './types.js';
+export declare class BrowserInflateProvider implements InflateProvider {
+    inflateRaw(data: Uint8Array): Promise<Uint8Array>;
+}

package/dist/format/inflate.js

@@ -0,0 +1,28 @@
+function getDecompressionStreamCtor() {
+    return globalThis.DecompressionStream;
+}
+export class BrowserInflateProvider {
+    async inflateRaw(data) {
+        const DS = getDecompressionStreamCtor();
+        if (!DS) {
+            throw new Error('This browser does not expose DecompressionStream. Provide a custom InflateProvider, or pre-bundle a WASM/JS inflater.');
+        }
+        try {
+            return await decompressWithFormat(data, 'deflate-raw', DS);
+        }
+        catch (rawError) {
+            try {
+                return await decompressWithFormat(data, 'deflate', DS);
+            }
+            catch {
+                throw rawError instanceof Error ? rawError : new Error(String(rawError));
+            }
+        }
+    }
+}
+async function decompressWithFormat(data, format, DS) {
+    const blobStream = new Blob([data]).stream();
+    const decompressedStream = blobStream.pipeThrough(new DS(format));
+    const ab = await new Response(decompressedStream).arrayBuffer();
+    return new Uint8Array(ab);
+}

package/dist/format/opc.d.ts

@@ -0,0 +1,28 @@
+import type { ResourceRef } from './types.js';
+import { ZipPackage } from './zip.js';
+export interface OpcRelationship {
+    id: string;
+    type: string;
+    target: string;
+    targetMode?: string;
+    source: string;
+    resolvedTarget: string;
+}
+export interface ContentTypeOverride {
+    partName: string;
+    contentType: string;
+}
+export interface OpcPackageView {
+    zip: ZipPackage;
+    contentTypes: Map<string, string>;
+    defaults: Map<string, string>;
+    overrides: ContentTypeOverride[];
+    relationships: Map<string, OpcRelationship[]>;
+    resources: ResourceRef[];
+    readText(path: string): Promise<string>;
+    readBytes(path: string): Promise<Uint8Array>;
+    getContentType(path: string): string | undefined;
+    getRelationships(sourcePath?: string): Promise<OpcRelationship[]>;
+}
+export declare function createOpcView(zip: ZipPackage): Promise<OpcPackageView>;
+export declare function relationshipPartName(sourcePath: string): string;

package/dist/format/opc.js

@@ -0,0 +1,85 @@
+import { decodeUtf8, parseXml, normalizePath, resolvePart, localName } from './util.js';
+export async function createOpcView(zip) {
+    const contentTypes = new Map();
+    const defaults = new Map();
+    const overrides = [];
+    if (zip.has('[Content_Types].xml')) {
+        const doc = parseXml(decodeUtf8(await zip.read('[Content_Types].xml')), '[Content_Types].xml');
+        for (const el of Array.from(doc.documentElement.children)) {
+            const name = localName(el);
+            if (name === 'Default') {
+                const ext = el.getAttribute('Extension')?.toLowerCase();
+                const ct = el.getAttribute('ContentType');
+                if (ext && ct)
+                    defaults.set(ext, ct);
+            }
+            else if (name === 'Override') {
+                const partName = normalizePath((el.getAttribute('PartName') ?? '').replace(/^\//, ''));
+                const ct = el.getAttribute('ContentType');
+                if (partName && ct) {
+                    contentTypes.set(partName, ct);
+                    overrides.push({ partName, contentType: ct });
+                }
+            }
+        }
+    }
+    const relationships = new Map();
+    const view = {
+        zip,
+        contentTypes,
+        defaults,
+        overrides,
+        relationships,
+        resources: zip.entries.map(e => ({ path: e.name, mediaType: getContentTypeFor(contentTypes, defaults, e.name), size: e.uncompressedSize })),
+        readText: async (path) => decodeUtf8(await zip.read(normalizePath(path))),
+        readBytes: async (path) => zip.read(normalizePath(path)),
+        getContentType: (path) => getContentTypeFor(contentTypes, defaults, path),
+        getRelationships: async (sourcePath = '') => {
+            const key = normalizePath(sourcePath);
+            const existing = relationships.get(key);
+            if (existing)
+                return existing;
+            const relsPath = relationshipPartName(key);
+            if (!zip.has(relsPath)) {
+                relationships.set(key, []);
+                return [];
+            }
+            const xml = decodeUtf8(await zip.read(relsPath));
+            const doc = parseXml(xml, relsPath);
+            const rels = [];
+            for (const el of Array.from(doc.documentElement.children)) {
+                if (localName(el) !== 'Relationship')
+                    continue;
+                const id = el.getAttribute('Id') ?? '';
+                const type = el.getAttribute('Type') ?? '';
+                const target = el.getAttribute('Target') ?? '';
+                const targetMode = el.getAttribute('TargetMode') ?? undefined;
+                if (!id || !target)
+                    continue;
+                rels.push({ id, type, target, targetMode, source: key, resolvedTarget: targetMode === 'External' ? target : resolvePart(key, target) });
+            }
+            relationships.set(key, rels);
+            return rels;
+        }
+    };
+    return view;
+}
+export function relationshipPartName(sourcePath) {
+    const source = normalizePath(sourcePath);
+    if (!source)
+        return '_rels/.rels';
+    const slash = source.lastIndexOf('/');
+    if (slash < 0)
+        return `_rels/${source}.rels`;
+    return `${source.slice(0, slash)}/_rels/${source.slice(slash + 1)}.rels`;
+}
+function getContentTypeFor(overrides, defaults, path) {
+    const n = normalizePath(path);
+    const o = overrides.get(n);
+    if (o)
+        return o;
+    const dot = n.lastIndexOf('.');
+    if (dot >= 0)
+        return defaults.get(n.slice(dot + 1).toLowerCase());
+    return undefined;
+}

package/dist/format/open.d.ts

@@ -0,0 +1,3 @@
+import { type OpenOptions } from './types.js';
+import { type LoadedDwfDocument } from './document.js';
+export declare function openDwfDocument(input: ArrayBuffer | Uint8Array | Blob | File, options?: OpenOptions): Promise<LoadedDwfDocument>;

package/dist/format/open.js

@@ -0,0 +1,69 @@
+import { diag } from './types.js';
+import { looksLikeZip, ZipPackage } from './zip.js';
+import { isProbablyDwfx, openDwfx } from './dwfx.js';
+import { isProbablyClassicDwf, openClassicDwf } from './dwf.js';
+import { bytesLookTextual } from './util.js';
+import { parseW2dText } from './w2dText.js';
+import { makeLoadedDocument } from './document.js';
+export async function openDwfDocument(input, options = {}) {
+    const bytes = await toBytes(input);
+    const fileName = options.fileName ?? ((input instanceof File) ? input.name : undefined) ?? 'document.dwf';
+    if (looksLikeZip(bytes)) {
+        const zip = ZipPackage.open(bytes, options.inflater);
+        if (isProbablyDwfx(zip))
+            return await openDwfx(zip);
+        if (isProbablyClassicDwf(zip))
+            return await openClassicDwf(zip);
+        // Mixed or unknown ZIP: try DWFx first if fixed pages exist, then classic discovery.
+        if (zip.entries.some(e => /\.fpage$/i.test(e.name)))
+            return await openDwfx(zip);
+        return await openClassicDwf(zip);
+    }
+    if (bytesLookTextual(bytes)) {
+        const parsed = parseW2dText(bytes, fileName);
+        const pageData = [{
+                id: 'page-1',
+                name: fileName,
+                kind: 'w2d-text',
+                width: parsed.bounds ? Math.max(1, parsed.bounds.maxX - parsed.bounds.minX) : 1000,
+                height: parsed.bounds ? Math.max(1, parsed.bounds.maxY - parsed.bounds.minY) : 1000,
+                sourcePath: fileName,
+                primitives: parsed.primitives,
+                bounds: parsed.bounds,
+                diagnostics: parsed.diagnostics
+            }];
+        const base = {
+            kind: 'unknown',
+            pages: [],
+            resources: [{ path: fileName, mediaType: 'text/plain', size: bytes.byteLength }],
+            diagnostics: [diag('warning', 'RAW_TEXT_W2D_MODE', 'Input is not a DWF ZIP package; opened it as a textual W2D-like vector stream.', fileName)],
+            packageEntries: [fileName]
+        };
+        return makeLoadedDocument(base, pageData);
+    }
+    const unsupported = {
+        id: 'unsupported-raw',
+        name: fileName,
+        kind: 'unsupported',
+        width: 1000,
+        height: 1000,
+        sourcePath: fileName,
+        reason: 'Input is neither a ZIP-based DWF/DWFx package nor a supported textual W2D stream.',
+        diagnostics: [diag('error', 'UNSUPPORTED_RAW_FORMAT', 'Unsupported raw DWF input. DWF 6+/DWFx ZIP packages are required for this build.', fileName)]
+    };
+    const base = {
+        kind: 'unknown',
+        pages: [],
+        resources: [{ path: fileName, size: bytes.byteLength }],
+        diagnostics: unsupported.diagnostics,
+        packageEntries: [fileName]
+    };
+    return makeLoadedDocument(base, [unsupported]);
+}
+async function toBytes(input) {
+    if (input instanceof Uint8Array)
+        return input;
+    if (input instanceof ArrayBuffer)
+        return new Uint8Array(input);
+    return new Uint8Array(await input.arrayBuffer());
+}

package/dist/format/types.d.ts

@@ -0,0 +1,61 @@
+export type DiagnosticLevel = 'info' | 'warning' | 'error';
+export interface Diagnostic {
+    level: DiagnosticLevel;
+    code: string;
+    message: string;
+    source?: string;
+}
+export interface ResourceRef {
+    path: string;
+    mediaType?: string;
+    role?: string;
+    size?: number;
+}
+export interface RenderViewport {
+    width: number;
+    height: number;
+    scale: number;
+    offsetX: number;
+    offsetY: number;
+    devicePixelRatio: number;
+}
+export type PageKind = 'xps-fixed-page' | 'w2d-text' | 'image' | 'w3d-model' | 'unsupported';
+export interface RenderablePage {
+    id: string;
+    name: string;
+    kind: PageKind;
+    width: number;
+    height: number;
+    sourcePath?: string;
+    diagnostics: Diagnostic[];
+}
+export interface DwfDocument {
+    kind: 'dwf' | 'dwfx' | 'zip-dwf' | 'unknown';
+    pages: RenderablePage[];
+    resources: ResourceRef[];
+    diagnostics: Diagnostic[];
+    packageEntries: string[];
+}
+export interface OpenOptions {
+    fileName?: string;
+    inflater?: InflateProvider;
+}
+export interface InflateProvider {
+    inflateRaw(data: Uint8Array): Promise<Uint8Array>;
+}
+export interface PageRenderOptions {
+    pageIndex?: number;
+    preferWebgl?: boolean;
+    preferWasm?: boolean;
+    wasmUrl?: string;
+    background?: string;
+    maxGpuCacheBytes?: number;
+    maxCachedScenes?: number;
+}
+export interface RenderStats {
+    backend: 'canvas2d' | 'wasm-raster' | 'webgl' | 'threejs-webgl' | 'image' | 'unsupported';
+    commands: number;
+    warnings: Diagnostic[];
+}
+export declare function diag(level: DiagnosticLevel, code: string, message: string, source?: string): Diagnostic;
+export declare function actionableDiagnostics(diagnostics: readonly Diagnostic[] | undefined): Diagnostic[];

package/dist/format/types.js

@@ -0,0 +1,6 @@
+export function diag(level, code, message, source) {
+    return source === undefined ? { level, code, message } : { level, code, message, source };
+}
+export function actionableDiagnostics(diagnostics) {
+    return (diagnostics ?? []).filter(d => d.level !== 'info');
+}

package/dist/format/util.d.ts

@@ -0,0 +1,18 @@
+export declare const textDecoder: TextDecoder;
+export declare const asciiDecoder: TextDecoder;
+export declare function decodeUtf8(bytes: Uint8Array): string;
+export declare function decodeUtf16Le(bytes: Uint8Array): string;
+export declare function normalizePath(path: string): string;
+export declare function dirname(path: string): string;
+export declare function resolvePart(basePath: string, target: string): string;
+export declare function stripNamespace(name: string): string;
+export declare function localName(el: Element): string;
+export declare function getAttr(el: Element, name: string): string | undefined;
+export declare function childElements(el: ParentNode): Element[];
+export declare function parseXml(xml: string, source?: string): Document;
+export declare function bytesLookTextual(bytes: Uint8Array, sampleLength?: number): boolean;
+export declare function extname(path: string): string;
+export declare function mimeFromPath(path: string): string | undefined;
+export declare function blobToImage(bytes: Uint8Array, type: string): Promise<HTMLImageElement | ImageBitmap>;
+export declare function clamp(n: number, lo: number, hi: number): number;
+export declare function parseNumberList(input: string): number[];