altium-toolkit 1.0.8 → 1.0.9

package/src/core/altium/AltiumParser.mjs

@@ -13,6 +13,8 @@ import { SchematicPinParser } from './SchematicPinParser.mjs'
 import { SchematicPrimitiveParser } from './SchematicPrimitiveParser.mjs'
 import { AltiumLayoutParser } from './AltiumLayoutParser.mjs'
 import { NormalizedModelSchema } from './NormalizedModelSchema.mjs'
+import { IntLibModelParser } from './IntLibModelParser.mjs'
+import { IntLibStreamExtractor } from './IntLibStreamExtractor.mjs'
 import { PcbModelParser } from './PcbModelParser.mjs'
 import { PcbLibModelParser } from './PcbLibModelParser.mjs'
 import { PcbLibStreamExtractor } from './PcbLibStreamExtractor.mjs'
@@ -25,8 +27,20 @@ import { SchematicJunctionParser } from './SchematicJunctionParser.mjs'
 import { SchematicBusEntryParser } from './SchematicBusEntryParser.mjs'
 import { SchematicImageParser } from './SchematicImageParser.mjs'
 import { SchematicNetlistBuilder } from './SchematicNetlistBuilder.mjs'
+import { SchematicRecordTypeRegistry } from './SchematicRecordTypeRegistry.mjs'
 import { SchematicComponentTextResolver } from './SchematicComponentTextResolver.mjs'
+import { SchematicComponentOwnerTextResolver } from './SchematicComponentOwnerTextResolver.mjs'
+import { SchematicOwnershipGraphParser } from './SchematicOwnershipGraphParser.mjs'
 import { SchematicStreamExtractor } from './SchematicStreamExtractor.mjs'
+import { SchematicTemplateParser } from './SchematicTemplateParser.mjs'
+import { SchematicHarnessParser } from './SchematicHarnessParser.mjs'
+import { SchematicImplementationParser } from './SchematicImplementationParser.mjs'
+import { SchematicCrossSheetConnectorParser } from './SchematicCrossSheetConnectorParser.mjs'
+import { SchematicRepeatedChannelParser } from './SchematicRepeatedChannelParser.mjs'
+import { SchematicDisplayModeCatalogParser } from './SchematicDisplayModeCatalogParser.mjs'
+import { SchematicBindingProvenanceParser } from './SchematicBindingProvenanceParser.mjs'
+import { SchematicConnectivityQaBuilder } from './SchematicConnectivityQaBuilder.mjs'
+import { SchematicQaReportBuilder } from './SchematicQaReportBuilder.mjs'
 import { SchematicWireNormalizer } from './SchematicWireNormalizer.mjs'
 import { CircuitJsonModelAdapter } from '../circuit-json/CircuitJsonModelAdapter.mjs'
 const {
@@ -41,6 +55,7 @@ const {
 } = ParserUtils
 const {
     extractSchematicFonts,
+    extractSchematicFontDiagnostics,
     extractSchematicMetadata,
     extractSchematicTitleBlock,
     normalizeSchematicTextRecord
@@ -74,7 +89,7 @@ export class AltiumParser {
      * Parses a native Altium buffer into the renderer compatibility model.
      * @param {string} fileName
      * @param {ArrayBuffer} arrayBuffer
-     * @returns {{ schema: string, kind: 'schematic' | 'pcb' | 'pcb-library' | 'project', fileType: 'SchDoc' | 'PcbDoc' | 'PcbLib' | 'PrjPcb', fileName: string, summary: Record<string, number | string>, diagnostics: { severity: 'info' | 'warning', message: string }[], schematic?: Record<string, unknown>, pcb?: Record<string, unknown>, pcbLibrary?: Record<string, unknown>, project?: Record<string, unknown>, bom: { designators: string[], quantity: number, pattern: string, source: string, value: string }[] }}
+     * @returns {{ schema: string, kind: 'schematic' | 'pcb' | 'pcb-library' | 'project' | 'integrated-library', fileType: 'SchDoc' | 'PcbDoc' | 'PcbLib' | 'PrjPcb' | 'IntLib', fileName: string, summary: Record<string, number | string>, diagnostics: { severity: 'info' | 'warning', message: string }[], schematic?: Record<string, unknown>, pcb?: Record<string, unknown>, pcbLibrary?: Record<string, unknown>, project?: Record<string, unknown>, integratedLibrary?: Record<string, unknown>, bom: { designators: string[], quantity: number, pattern: string, source: string, value: string }[] }}
      */
     static parseArrayBufferToRendererModel(fileName, arrayBuffer) {
         const records = AsciiRecordParser.parse(arrayBuffer)
@@ -85,7 +100,8 @@ export class AltiumParser {
             return AltiumParser.#parseSchematic(
                 fileName,
                 schematicExtraction?.records || records,
-                arrayBuffer
+                arrayBuffer,
+                schematicExtraction
             )
         }
         if (fileType === 'PcbDoc') {
@@ -106,6 +122,12 @@ export class AltiumParser {
         if (fileType === 'PrjPcb') {
             return PrjPcbModelParser.parse(fileName, arrayBuffer)
         }
+        if (fileType === 'IntLib') {
+            return IntLibModelParser.parse(
+                fileName,
+                IntLibStreamExtractor.extractFromArrayBuffer(arrayBuffer)
+            )
+        }
         throw new Error('Unsupported file type: ' + fileName)
     }
 
@@ -113,7 +135,7 @@ export class AltiumParser {
      * Chooses the format based on extension and content.
      * @param {string} fileName
      * @param {{ fields: Record<string, string | string[]> }[]} records
-     * @returns {'SchDoc' | 'PcbDoc' | 'PcbLib' | 'PrjPcb'}
+     * @returns {'SchDoc' | 'PcbDoc' | 'PcbLib' | 'PrjPcb' | 'IntLib'}
      */
     static #sniffFileType(fileName, records) {
         const normalized = String(fileName || '').toLowerCase()
@@ -121,6 +143,7 @@ export class AltiumParser {
         if (normalized.endsWith('.pcbdoc')) return 'PcbDoc'
         if (normalized.endsWith('.pcblib')) return 'PcbLib'
         if (normalized.endsWith('.prjpcb')) return 'PrjPcb'
+        if (normalized.endsWith('.intlib')) return 'IntLib'
 
         const hasSchematicHeader = records.some((record) =>
             getField(record.fields, 'HEADER').includes('Schematic')
@@ -132,12 +155,23 @@ export class AltiumParser {
      * @param {string} fileName
      * @param {{ raw: string, fields: Record<string, string | string[]> }[]} records
      * @param {ArrayBuffer} arrayBuffer
+     * @param {{ embeddedFiles?: object } | null} schematicExtraction
      * @returns {ReturnType<typeof AltiumParser.parseArrayBufferToRendererModel>}
      */
-    static #parseSchematic(fileName, records, arrayBuffer) {
-        const componentRecords = records.filter(
+    static #parseSchematic(
+        fileName,
+        records,
+        arrayBuffer,
+        schematicExtraction = null
+    ) {
+        const recordIndexAwareRecords = records.map((record, recordIndex) => ({
+            ...record,
+            recordIndex
+        }))
+        const componentRecords = recordIndexAwareRecords.filter(
             (record) => getField(record.fields, 'RECORD') === '1'
         )
+        const recordTypes = SchematicRecordTypeRegistry.summarize(records)
         const ownersWithImplicitDisplayMode =
             AltiumParser.#collectOwnersWithImplicitDisplayMode(records)
         const activeMultipartOwnerParts =
@@ -176,6 +210,10 @@ export class AltiumParser {
                 getField(record.fields, 'RECORD') !== '30' &&
                 getField(record.fields, 'RECORD') !== '37' &&
                 !SchematicPrimitiveParser.isRectangleRecord(record.fields) &&
+                !SchematicPrimitiveParser.isRoundedRectangleRecord(
+                    record.fields
+                ) &&
+                !SchematicPrimitiveParser.isIeeeSymbolRecord(record.fields) &&
                 !AltiumParser.#hasDisplayText(record.fields) &&
                 AltiumParser.#hasCoordinatePair(record.fields, 'Location') &&
                 AltiumParser.#hasCoordinatePair(record.fields, 'Corner')
@@ -192,12 +230,34 @@ export class AltiumParser {
                 AltiumParser.#hasCoordinatePair(record.fields, 'Location') &&
                 AltiumParser.#hasCoordinatePair(record.fields, 'Corner')
         )
+        const roundedRectangleRecords = drawableRecords.filter(
+            (record) =>
+                SchematicPrimitiveParser.isRoundedRectangleRecord(
+                    record.fields
+                ) &&
+                AltiumParser.#hasCoordinatePair(record.fields, 'Location') &&
+                AltiumParser.#hasCoordinatePair(record.fields, 'Corner')
+        )
+        const ieeeSymbolRecords = drawableRecords.filter(
+            (record) =>
+                SchematicPrimitiveParser.isIeeeSymbolRecord(record.fields) &&
+                AltiumParser.#hasCoordinatePair(record.fields, 'Location')
+        )
         const arcRecords = drawableRecords.filter(
             (record) =>
                 ['11', '12'].includes(getField(record.fields, 'RECORD')) &&
                 AltiumParser.#hasCoordinatePair(record.fields, 'Location') &&
                 parseNumericField(record.fields, 'Radius') !== null
         )
+        const bezierRecords = drawableRecords.filter(
+            (record) => getField(record.fields, 'RECORD') === '5'
+        )
+        const pieRecords = drawableRecords.filter(
+            (record) =>
+                getField(record.fields, 'RECORD') === '9' &&
+                AltiumParser.#hasCoordinatePair(record.fields, 'Location') &&
+                parseNumericField(record.fields, 'Radius') !== null
+        )
         const ellipseRecords = drawableRecords.filter(
             (record) =>
                 getField(record.fields, 'RECORD') === '8' &&
@@ -227,10 +287,26 @@ export class AltiumParser {
         const crossRecords = drawableRecords.filter(
             (record) => getField(record.fields, 'RECORD') === '22'
         )
-        const recordIndexAwareRecords = records.map((record, recordIndex) => ({
-            ...record,
-            recordIndex
-        }))
+        const ownership = SchematicOwnershipGraphParser.parse(
+            recordIndexAwareRecords
+        )
+        const harnesses = SchematicHarnessParser.parse(recordIndexAwareRecords)
+        const implementations = SchematicImplementationParser.parse(
+            recordIndexAwareRecords
+        )
+        const displayModes = SchematicDisplayModeCatalogParser.parse(
+            recordIndexAwareRecords
+        )
+        const bindings = SchematicBindingProvenanceParser.parse(
+            recordIndexAwareRecords,
+            implementations
+        )
+        const crossSheetConnectors = SchematicCrossSheetConnectorParser.parse(
+            recordIndexAwareRecords
+        )
+        const repeatedChannels = SchematicRepeatedChannelParser.parse(
+            recordIndexAwareRecords
+        )
         const relatedTexts = new Map()
 
         for (const record of records) {
@@ -244,6 +320,9 @@ export class AltiumParser {
 
         const metadataTexts = extractSchematicMetadata(textRecords)
         const schematicFonts = extractSchematicFonts(sheetRecord?.fields)
+        const schematicRenderDiagnostics = extractSchematicFontDiagnostics(
+            sheetRecord?.fields
+        )
         const sheetWidth =
             parseNumericField(sheetRecord?.fields, 'CustomX') || 1500
         const sheetHeight =
@@ -343,6 +422,9 @@ export class AltiumParser {
                 polygons
             ))
         const arcs = SchematicPrimitiveParser.parseSchematicArcs(arcRecords)
+        const beziers =
+            SchematicPrimitiveParser.parseSchematicBeziers(bezierRecords)
+        const pies = SchematicPrimitiveParser.parseSchematicPies(pieRecords)
         const ellipses =
             SchematicPrimitiveParser.parseSchematicEllipses(ellipseRecords)
         const rectangles =
@@ -358,8 +440,20 @@ export class AltiumParser {
             )
         const regions =
             SchematicPrimitiveParser.parseSchematicRegions(regionRecords)
+        const roundedRectangles =
+            SchematicPrimitiveParser.parseSchematicRoundedRectangles(
+                roundedRectangleRecords
+            )
+        const ieeeSymbols =
+            SchematicPrimitiveParser.parseSchematicIeeeSymbols(
+                ieeeSymbolRecords
+            )
         const directives =
             SchematicDirectiveParser.parseSchematicDirectives(directiveRecords)
+        const directiveSemantics =
+            SchematicDirectiveParser.parseDirectiveSemantics(
+                recordIndexAwareRecords
+            )
         const { sheetSymbols, sheetEntries } = SchematicSheetParser.parse(
             recordIndexAwareRecords
         )
@@ -371,6 +465,11 @@ export class AltiumParser {
                 recordIndexAwareRecords,
                 arrayBuffer
             )
+        const template = SchematicTemplateParser.parse(
+            recordIndexAwareRecords,
+            sheetRecord,
+            sheet
+        )
 
         const ports = parseSchematicPorts(portRecords, lines)
         const crosses = parseSchematicCrosses(crossRecords)
@@ -421,6 +520,8 @@ export class AltiumParser {
                 pins,
                 ports
             )
+        const textFrames =
+            SchematicTextParser.extractSchematicTextFrames(anchoredTexts)
 
         const components = componentRecords.map((record) => {
             const x = parseNumericField(record.fields, 'Location.X') || 0
@@ -428,25 +529,28 @@ export class AltiumParser {
             const libReference =
                 getField(record.fields, 'LibReference') ||
                 getField(record.fields, 'DesignItemId')
-            const ownerIndex = String(
-                (parseNumericField(record.fields, 'IndexInSheet') || 0) + 1
+            const ownerTexts =
+                SchematicComponentOwnerTextResolver.resolveOwnerTexts(
+                    record,
+                    recordIndexAwareRecords,
+                    relatedTexts
+                )
+
+            const designator = SchematicComponentTextResolver.resolveDesignator(
+                ownerTexts,
+                anchoredTexts,
+                {
+                    x,
+                    y,
+                    libReference
+                }
             )
-            const ownerTexts = relatedTexts.get(ownerIndex) || []
 
             return {
                 x,
                 y,
                 libReference,
-                designator:
-                    SchematicComponentTextResolver.resolveDesignator(
-                        ownerTexts,
-                        anchoredTexts,
-                        {
-                            x,
-                            y,
-                            libReference
-                        }
-                    ) || 'U?',
+                designator: designator === null ? 'U?' : designator,
                 value: SchematicComponentTextResolver.resolveValue(
                     ownerTexts,
                     anchoredTexts,
@@ -513,6 +617,16 @@ export class AltiumParser {
                     'Sheet metadata record 31 was not found. Using fallback dimensions.'
             })
         }
+        diagnostics.push(
+            ...schematicRenderDiagnostics.fontFallbacks.map((fallback) => ({
+                severity: fallback.severity,
+                code: fallback.code,
+                fontId: fallback.fontId,
+                sourceFamily: fallback.sourceFamily,
+                resolvedFamily: fallback.resolvedFamily,
+                message: fallback.message
+            }))
+        )
         diagnostics.push(...imageDiagnostics)
         const { nets, diagnostics: netDiagnostics } =
             SchematicNetlistBuilder.build({
@@ -520,11 +634,36 @@ export class AltiumParser {
                 texts: anchoredTexts,
                 pins,
                 ports,
+                crossSheetConnectors: crossSheetConnectors?.connectors || [],
                 junctions,
                 busEntries,
                 sheetEntries
             })
         diagnostics.push(...netDiagnostics)
+        const qa = SchematicQaReportBuilder.build({
+            records: recordIndexAwareRecords,
+            sheet: resolvedSheet,
+            lines: normalizedLines,
+            texts: anchoredTexts
+        })
+        const connectivityQa = SchematicConnectivityQaBuilder.build({
+            nets,
+            texts: anchoredTexts,
+            pins,
+            ports,
+            junctions
+        })
+        const embeddedFiles = schematicExtraction?.embeddedFiles || null
+
+        if (embeddedFiles?.diagnostics?.length) {
+            diagnostics.push(
+                ...embeddedFiles.diagnostics.map((issue) => ({
+                    severity: issue.severity === 'info' ? 'info' : 'warning',
+                    code: issue.code,
+                    message: issue.message
+                }))
+            )
+        }
 
         return NormalizedModelSchema.attach({
             kind: 'schematic',
@@ -535,19 +674,30 @@ export class AltiumParser {
                 componentCount: components.length,
                 lineCount: lines.length,
                 textCount: anchoredTexts.length,
+                recordTypeCount: recordTypes.length,
                 bomRowCount: bom.length
             },
             diagnostics,
             schematic: {
                 sheet: resolvedSheet,
+                recordTypes,
+                ...(schematicRenderDiagnostics.fontFallbacks.length
+                    ? { renderDiagnostics: schematicRenderDiagnostics }
+                    : {}),
                 lines: normalizedLines,
                 polygons,
                 rectangles,
+                roundedRectangles,
                 regions,
                 ellipses,
                 arcs,
+                beziers,
+                pies,
+                ieeeSymbols,
                 directives,
+                directiveSemantics,
                 texts: anchoredTexts,
+                textFrames,
                 components,
                 pins,
                 ports,
@@ -560,7 +710,22 @@ export class AltiumParser {
                 junctions,
                 busEntries,
                 images,
-                nets
+                nets,
+                ownership,
+                ...(template ? { template } : {}),
+                ...(harnesses ? { harnesses } : {}),
+                ...(implementations ? { implementations } : {}),
+                ...(displayModes ? { displayModes } : {}),
+                ...(bindings ? { bindings } : {}),
+                ...(crossSheetConnectors ? { crossSheetConnectors } : {}),
+                ...(repeatedChannels ? { repeatedChannels } : {}),
+                ...(embeddedFiles &&
+                (embeddedFiles.files?.length ||
+                    embeddedFiles.diagnostics?.length)
+                    ? { embeddedFiles }
+                    : {}),
+                qa,
+                connectivityQa
             },
             bom
         })
@@ -598,7 +763,9 @@ export class AltiumParser {
                 ownerPartId &&
                 ownerPartId !== '-1' &&
                 !getField(record.fields, 'OwnerPartDisplayMode') &&
-                AltiumParser.#isDisplayModeSelectablePrimitive(record.fields)
+                SchematicComponentOwnerTextResolver.isDisplayModeSelectablePrimitive(
+                    record.fields
+                )
             ) {
                 owners.add(ownerIndex)
             }
@@ -652,27 +819,6 @@ export class AltiumParser {
         )
     }
 
-    /**
-     * Returns true when a schematic primitive participates in owner display
-     * mode selection.
-     * @param {Record<string, string | string[]>} fields
-     * @returns {boolean}
-     */
-    static #isDisplayModeSelectablePrimitive(fields) {
-        const recordType = getField(fields, 'RECORD')
-
-        return (
-            recordType === '2' ||
-            recordType === '6' ||
-            recordType === '11' ||
-            recordType === '12' ||
-            recordType === '13' ||
-            recordType === '27' ||
-            (AltiumParser.#hasCoordinatePair(fields, 'Location') &&
-                AltiumParser.#hasCoordinatePair(fields, 'Corner'))
-        )
-    }
-
     /**
      * Groups designators into BOM rows.
      * @param {{ designator: string, pattern: string, source: string, value: string }[]} entries

package/src/core/altium/EmbeddedFileInventoryBuilder.mjs

@@ -0,0 +1,255 @@
+// SPDX-FileCopyrightText: 2026 André Fiedler
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/**
+ * Builds a generic inventory for embedded payload streams.
+ */
+export class EmbeddedFileInventoryBuilder {
+    static SCHEMA_ID = 'altium-toolkit.embedded-files.a1'
+
+    /**
+     * Builds an embedded-file inventory from a stream map.
+     * @param {Map<string, Uint8Array>} streams Compound-document streams.
+     * @param {{ skipStreamNames?: Iterable<string> }} [options] Inventory options.
+     * @returns {{ schema: string, files: object[], diagnostics: object[] }}
+     */
+    static buildFromStreams(streams, options = {}) {
+        const skipStreamNames = new Set(options.skipStreamNames || [])
+        const files = []
+        const diagnostics = []
+
+        for (const [sourceStream, bytes] of streams || []) {
+            if (
+                skipStreamNames.has(sourceStream) ||
+                !EmbeddedFileInventoryBuilder.#isEmbeddedPayloadStream(
+                    sourceStream
+                )
+            ) {
+                continue
+            }
+
+            if (!(bytes instanceof Uint8Array) || bytes.byteLength === 0) {
+                diagnostics.push({
+                    code: 'embedded-file.empty',
+                    severity: 'warning',
+                    sourceStream,
+                    message: 'Embedded payload stream was empty.'
+                })
+                continue
+            }
+
+            files.push(
+                EmbeddedFileInventoryBuilder.#fileRecord(sourceStream, bytes)
+            )
+        }
+
+        return {
+            schema: EmbeddedFileInventoryBuilder.SCHEMA_ID,
+            files: files.sort((left, right) =>
+                left.sourceStream.localeCompare(right.sourceStream)
+            ),
+            diagnostics: diagnostics.sort((left, right) =>
+                left.sourceStream.localeCompare(right.sourceStream)
+            )
+        }
+    }
+
+    /**
+     * Returns true when a stream name represents a payload-style embedded file.
+     * @param {string} sourceStream Stream name.
+     * @returns {boolean}
+     */
+    static #isEmbeddedPayloadStream(sourceStream) {
+        const normalized = String(sourceStream || '')
+        if (/\/(?:Data|Header)$/i.test(normalized)) {
+            return false
+        }
+
+        return (
+            /^(EmbeddedFiles|Embedded|Attachments|Images?)\//i.test(
+                normalized
+            ) ||
+            /^Models\/\d+$/i.test(normalized) ||
+            /\.[A-Za-z0-9]{2,8}$/.test(normalized)
+        )
+    }
+
+    /**
+     * Builds one file inventory row.
+     * @param {string} sourceStream Stream name.
+     * @param {Uint8Array} bytes Payload bytes.
+     * @returns {object}
+     */
+    static #fileRecord(sourceStream, bytes) {
+        return {
+            sourceStream,
+            name: EmbeddedFileInventoryBuilder.#basename(sourceStream),
+            format: EmbeddedFileInventoryBuilder.#format(sourceStream, bytes),
+            byteLength: bytes.byteLength,
+            checksum: {
+                algorithm: 'fnv1a32',
+                value: EmbeddedFileInventoryBuilder.#fnv1a32(bytes)
+            }
+        }
+    }
+
+    /**
+     * Resolves the payload basename from a stream path.
+     * @param {string} sourceStream Stream name.
+     * @returns {string}
+     */
+    static #basename(sourceStream) {
+        return (
+            String(sourceStream || '')
+                .split('/')
+                .filter(Boolean)
+                .pop() || ''
+        )
+    }
+
+    /**
+     * Classifies payload format from extension, magic bytes, and text probes.
+     * @param {string} sourceStream Stream name.
+     * @param {Uint8Array} bytes Payload bytes.
+     * @returns {string}
+     */
+    static #format(sourceStream, bytes) {
+        const lower =
+            EmbeddedFileInventoryBuilder.#basename(sourceStream).toLowerCase()
+
+        if (
+            lower.endsWith('.png') ||
+            EmbeddedFileInventoryBuilder.#hasPrefix(
+                bytes,
+                [0x89, 0x50, 0x4e, 0x47]
+            )
+        ) {
+            return 'png'
+        }
+        if (
+            lower.endsWith('.jpg') ||
+            lower.endsWith('.jpeg') ||
+            EmbeddedFileInventoryBuilder.#hasPrefix(bytes, [0xff, 0xd8, 0xff])
+        ) {
+            return 'jpeg'
+        }
+        if (
+            lower.endsWith('.gif') ||
+            EmbeddedFileInventoryBuilder.#asciiPrefix(bytes).startsWith('GIF')
+        ) {
+            return 'gif'
+        }
+        if (
+            lower.endsWith('.bmp') ||
+            EmbeddedFileInventoryBuilder.#asciiPrefix(bytes).startsWith('BM')
+        ) {
+            return 'bmp'
+        }
+        if (
+            lower.endsWith('.svg') ||
+            EmbeddedFileInventoryBuilder.#trimmedText(bytes).startsWith('<svg')
+        ) {
+            return 'svg'
+        }
+        if (
+            lower.endsWith('.step') ||
+            lower.endsWith('.stp') ||
+            EmbeddedFileInventoryBuilder.#trimmedText(bytes).startsWith(
+                'ISO-10303-21'
+            )
+        ) {
+            return 'step'
+        }
+        if (lower.endsWith('.sldprt') || lower.endsWith('.sldasm')) {
+            return 'solidworks'
+        }
+        if (lower.endsWith('.x_t') || lower.endsWith('.xmt_txt')) {
+            return 'parasolid-text'
+        }
+        if (lower.endsWith('.x_b') || lower.endsWith('.xmt_bin')) {
+            return 'parasolid-binary'
+        }
+        if (
+            lower.endsWith('.pdf') ||
+            EmbeddedFileInventoryBuilder.#asciiPrefix(bytes).startsWith('%PDF')
+        ) {
+            return 'pdf'
+        }
+        if (EmbeddedFileInventoryBuilder.#isLikelyText(bytes)) {
+            return 'text'
+        }
+
+        return 'binary'
+    }
+
+    /**
+     * Returns true when bytes start with a prefix.
+     * @param {Uint8Array} bytes Payload bytes.
+     * @param {number[]} prefix Prefix bytes.
+     * @returns {boolean}
+     */
+    static #hasPrefix(bytes, prefix) {
+        return prefix.every((value, index) => bytes[index] === value)
+    }
+
+    /**
+     * Decodes a short ASCII prefix.
+     * @param {Uint8Array} bytes Payload bytes.
+     * @returns {string}
+     */
+    static #asciiPrefix(bytes) {
+        return new TextDecoder('latin1').decode(bytes.slice(0, 8))
+    }
+
+    /**
+     * Decodes and trims a text probe.
+     * @param {Uint8Array} bytes Payload bytes.
+     * @returns {string}
+     */
+    static #trimmedText(bytes) {
+        return new TextDecoder('utf-8', { fatal: false })
+            .decode(bytes.slice(0, Math.min(bytes.byteLength, 256)))
+            .trim()
+    }
+
+    /**
+     * Returns true when a payload is printable enough to treat as text.
+     * @param {Uint8Array} bytes Payload bytes.
+     * @returns {boolean}
+     */
+    static #isLikelyText(bytes) {
+        let printable = 0
+        const length = Math.min(bytes.byteLength, 256)
+
+        for (let index = 0; index < length; index += 1) {
+            const value = bytes[index]
+            if (
+                value === 0x09 ||
+                value === 0x0a ||
+                value === 0x0d ||
+                (value >= 0x20 && value <= 0x7e)
+            ) {
+                printable += 1
+            }
+        }
+
+        return length > 0 && printable / length >= 0.9
+    }
+
+    /**
+     * Computes an FNV-1a 32-bit checksum.
+     * @param {Uint8Array} bytes Payload bytes.
+     * @returns {string}
+     */
+    static #fnv1a32(bytes) {
+        let hash = 0x811c9dc5
+
+        for (const value of bytes) {
+            hash ^= value
+            hash = Math.imul(hash, 0x01000193) >>> 0
+        }
+
+        return hash.toString(16).padStart(8, '0')
+    }
+}