@ifc-lite/parser 4.3.1 → 5.0.0

package/dist/scan-worker-source.js

@@ -0,0 +1,383 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * The scan worker's source, as a string.
+ *
+ * Split from `scan-worker-inline.ts`, which owns the Blob/Worker plumbing and
+ * the result decoding. The scanner is a string because a Blob worker cannot
+ * import at runtime, so this file is the one place the third copy of the STEP
+ * scan rules lives -- see the comments inside for which `step-lexing.ts`
+ * function each mirrors.
+ */
+import { MAX_EXPRESS_ID } from './express-id.js';
+/**
+ * Self-contained entity scanner code (runs inside Web Worker).
+ * This is the same algorithm as StepTokenizer.scanEntitiesFast() but
+ * written as a standalone function for worker embedding.
+ */
+/** Exported for direct testing (run inside a mock `self`); the runtime path
+ *  wraps it in a Blob worker in `scan-worker-inline.ts`. */
+export const WORKER_CODE = `
+'use strict';
+self.onmessage = function(e) {
+  var buf = new Uint8Array(e.data);
+  var len = buf.length;
+  var pos = 0;
+  var line = 1;
+
+  // Pre-allocate result array (estimate ~13,500 entities per MB)
+  var estimatedCount = Math.max((len / 1024 / 1024) * 13500, 1000) | 0;
+  // Pack results into typed arrays for fast transfer. Uint32Array for the ids:
+  // that is the express-id storage contract every consumer of this scan holds
+  // to (CompactEntityIndex, the entity/property/quantity tables, the wasm
+  // boundary, Rust's ColumnarIndex), so the guard below refuses anything wider
+  // rather than carrying it one buffer further and truncating downstream
+  // (#3395). The worker runs from a Blob URL and cannot import at runtime, so
+  // the bound below is interpolated from express-id.ts when this template is
+  // evaluated -- one home for the number, not a copy that can drift.
+  // Whether a STEP comment opens at p.
+  function opensCommentAt(p) {
+    return p + 1 < len && buf[p] === 0x2F && buf[p + 1] === 0x2A;
+  }
+
+  // Index just past the '*/' closing the comment at p, or -1 when it never
+  // closes. Counts the newlines it crosses so line numbers stay in step.
+  //
+  // Kept behaviourally identical to skipComment/skipTrivia in step-lexing.ts,
+  // which this cannot import: the worker source is a string, so this copy of
+  // the rule has to live here. Comments do not nest, per ISO 10303-21.
+  function skipCommentAt(p) {
+    var q = p + 2;
+    while (q + 1 < len) {
+      if (buf[q] === 0x2A && buf[q + 1] === 0x2F) return q + 2;
+      if (buf[q] === 0x0A) line++;
+      q++;
+    }
+    return -1;
+  }
+
+  // Skip whitespace, comments, and any run of the two -- 10303-21 allows a
+  // comment wherever whitespace is allowed, INCLUDING inside a record.
+  // Returns -1 when a comment opens and never closes: everything from there on
+  // is inside it, so there is nothing left to find.
+  //
+  // The whitespace byte set (space, tab, CR, LF, form feed, vertical tab) is
+  // kept byte-for-byte in sync with isSpaceByte in step-lexing.ts and its
+  // three inline twins in tokenizer.ts's scanEntitiesFast -- this file is a
+  // string because a Blob worker cannot import at runtime, not a reason for
+  // the rule itself to drift.
+  function skipTriviaAt(p) {
+    for (;;) {
+      while (p < len) {
+        var t = buf[p];
+        if (t === 0x20 || t === 0x09 || t === 0x0D || t === 0x0C || t === 0x0B) { p++; }
+        else if (t === 0x0A) { line++; p++; }
+        else break;
+      }
+      if (!opensCommentAt(p)) return p;
+      var e = skipCommentAt(p);
+      if (e < 0) return -1;
+      p = e;
+    }
+  }
+
+  var ids = new Uint32Array(estimatedCount);
+  var offsets = new Uint32Array(estimatedCount);
+  var lengths = new Uint32Array(estimatedCount);
+  var lines = new Uint32Array(estimatedCount);
+  // Type names stored separately (strings)
+  var types = new Array(estimatedCount);
+  var count = 0;
+  // Records refused by the express-id bound, reported back to the caller.
+  var oversizedIds = 0;
+  // 0 or 1, never a count of how many: whether this scan stopped early on an
+  // unclosed string, an unclosed comment, or a declaration cut off before its
+  // own '(' -- set once, by the single post-loop check at the bottom of this
+  // function. Reported back to the caller. Mirrors tokenizer.ts's
+  // scanEntitiesFast contract exactly, including the 0-or-1 shape.
+  var malformedRecords = 0;
+  // Set on the way to that post-loop check, not counted at each site:
+  // 'stopped' for an unclosed string or comment that ran to end of buffer
+  // with nothing left to find, 'declOpen' while a #id=TYPE( header is
+  // incomplete. 'declOpen' stays armed ONLY when the reason for abandoning
+  // is running out of buffer (pos >= len); a mismatch with buffer still
+  // left (bad byte, oversized id) clears it, because the scan resumes
+  // byte-by-byte from wherever it gave up, and a #ref token inside the
+  // abandoned record's own argument list reads as a fresh, equally
+  // incomplete attempt that must not report "cut off" just because
+  // nothing later happens to clear it.
+  var stopped = false;
+  var declOpen = false;
+
+  // Type name cache (IFC files have ~776 unique types across millions of entities)
+  var typeCache = new Map();
+
+  function growArrays() {
+    var newSize = (count * 2) | 0;
+    var newIds = new Uint32Array(newSize);
+    newIds.set(ids);
+    ids = newIds;
+    var newOffsets = new Uint32Array(newSize);
+    newOffsets.set(offsets);
+    offsets = newOffsets;
+    var newLengths = new Uint32Array(newSize);
+    newLengths.set(lengths);
+    lengths = newLengths;
+    var newLines = new Uint32Array(newSize);
+    newLines.set(lines);
+    lines = newLines;
+    types.length = newSize;
+  }
+
+  while (pos < len) {
+    var ch = buf[pos];
+
+    if (ch === 0x23) { // '#'
+      var startOffset = pos;
+      var startLine = line;
+      pos++;
+
+      // Read express ID
+      var expressId = 0;
+      var hasDigits = false;
+      while (pos < len) {
+        var c = buf[pos];
+        if (c >= 0x30 && c <= 0x39) {
+          expressId = expressId * 10 + (c - 0x30);
+          hasDigits = true;
+          pos++;
+        } else {
+          break;
+        }
+      }
+      if (!hasDigits) continue;
+      declOpen = true;
+
+      // Whitespace AND comments: '#1 /* was #7 */ =' is a declaration. The
+      // inline loop stays for the common case; skipTriviaAt runs only once a
+      // comment actually opens. Mirrors tokenizer.ts's scanEntitiesFast.
+      while (pos < len) {
+        var c2 = buf[pos];
+        if (c2 === 0x20 || c2 === 0x09 || c2 === 0x0D || c2 === 0x0C || c2 === 0x0B) { pos++; }
+        else if (c2 === 0x0A) { line++; pos++; }
+        else break;
+      }
+      if (opensCommentAt(pos)) { pos = skipTriviaAt(pos); if (pos < 0) { stopped = true; break; } }
+
+      // Check for '='. A byte that is not '=' with buffer left to scan is
+      // not a truncation -- clear declOpen so a reference token inside a
+      // LATER abandoned record's argument list (see the oversized-id note
+      // below) cannot leave it stuck armed with nothing left to clear it.
+      if (pos >= len) continue;
+      if (buf[pos] !== 0x3D) { declOpen = false; continue; }
+      pos++;
+
+      // Express-id bound, identical to StepTokenizer.scanEntitiesFast -- this
+      // worker is that scan's twin and must reject the same records, and count
+      // the same ones, or which scan path ran decides both whether an id
+      // collides with another and what the user is told was dropped. The
+      // single '>' subsumes a safe-integer check: a digit run accumulated as a
+      // double is non-negative and integral, and every value past 2^32 --
+      // including one past 2^53, where two distinct ids collide onto one
+      // double -- fails it. Tested only after '=' has matched, because that is
+      // the DECLARATION shape Rust's EntityScanner validates before refusing:
+      // the 'continue' below resumes inside the refused record's argument
+      // list, so an oversized '#ref' in there arrives here too and would be
+      // counted as a second dropped record. Count the refusal; a record that
+      // vanishes without a trace is the same defect wearing a different hat.
+      if (expressId > ${MAX_EXPRESS_ID}) { oversizedIds++; declOpen = false; continue; }
+
+      // Skip whitespace and comments
+      while (pos < len) {
+        var c3 = buf[pos];
+        if (c3 === 0x20 || c3 === 0x09 || c3 === 0x0D || c3 === 0x0C || c3 === 0x0B) { pos++; }
+        else if (c3 === 0x0A) { line++; pos++; }
+        else break;
+      }
+      if (opensCommentAt(pos)) { pos = skipTriviaAt(pos); if (pos < 0) { stopped = true; break; } }
+
+      // Read type name. Must start A-Z; a bad start byte with buffer left
+      // clears declOpen for the same reason as the '=' check.
+      var typeStart = pos;
+      if (pos >= len) continue;
+      if (buf[pos] < 0x41 || buf[pos] > 0x5A) { declOpen = false; continue; }
+
+      while (pos < len) {
+        var c4 = buf[pos];
+        if ((c4 >= 0x41 && c4 <= 0x5A) || (c4 >= 0x61 && c4 <= 0x7A) ||
+            (c4 >= 0x30 && c4 <= 0x39) || c4 === 0x5F) {
+          pos++;
+        } else {
+          break;
+        }
+      }
+      if (pos === typeStart) continue;
+
+      // Cache type name — use length + hash compound key and verify the actual
+      // bytes on a hit. Length alone can't disambiguate a 32-bit hash collision
+      // (e.g. "Aa"/"BB"), so without the byte compare a crafted/unlucky file
+      // could have one type silently misread as another. Mirrors tokenizer.ts.
+      var typeLen = pos - typeStart;
+      var typeHash = typeLen;
+      for (var i = typeStart; i < pos; i++) {
+        typeHash = (typeHash * 31 + buf[i]) | 0;
+      }
+      var cacheKey = typeLen + ':' + typeHash;
+      var typeName = typeCache.get(cacheKey);
+      var cacheHitMatches = false;
+      if (typeName !== undefined && typeName.length === typeLen) {
+        cacheHitMatches = true;
+        for (var v = 0; v < typeLen; v++) {
+          if (typeName.charCodeAt(v) !== buf[typeStart + v]) {
+            cacheHitMatches = false;
+            break;
+          }
+        }
+      }
+      if (typeName === undefined || !cacheHitMatches) {
+        typeName = String.fromCharCode.apply(null, buf.subarray(typeStart, pos));
+        typeCache.set(cacheKey, typeName);
+      }
+
+      // Skip whitespace and comments
+      while (pos < len) {
+        var c5 = buf[pos];
+        if (c5 === 0x20 || c5 === 0x09 || c5 === 0x0D || c5 === 0x0C || c5 === 0x0B) { pos++; }
+        else if (c5 === 0x0A) { line++; pos++; }
+        else break;
+      }
+      if (opensCommentAt(pos)) { pos = skipTriviaAt(pos); if (pos < 0) { stopped = true; break; } }
+
+      // Check for '('. Same EOF-vs-mismatch split as '=' and the type name.
+      if (pos >= len) continue;
+      if (buf[pos] !== 0x28) { declOpen = false; continue; }
+      declOpen = false; // Header complete: '(' found.
+
+      // Skip to semicolon (handling strings)
+      var inString = false;
+      var foundTerminator = false;
+      while (pos < len) {
+        var c6 = buf[pos];
+        if (c6 === 0x27) { // quote
+          if (inString && pos + 1 < len && buf[pos + 1] === 0x27) {
+            pos += 2;
+            continue;
+          }
+          inString = !inString;
+        } else if (c6 === 0x2F && !inString && opensCommentAt(pos)) {
+          // The ';' that ends a record can be preceded by a comment holding
+          // its own ';'. Take the comment whole, which also makes the quotes
+          // and parens inside it text -- the other direction of the rule the
+          // quote branch above gives for a '/*' inside a literal.
+          var ce = skipCommentAt(pos);
+          if (ce < 0) {
+            // Unterminated: this record has no terminator, and neither has
+            // anything after it. Drop it and stop.
+            pos = len;
+            break;
+          }
+          pos = ce;
+          continue;
+        } else if (c6 === 0x3B && !inString) { // semicolon
+          var entityLength = pos - startOffset + 1;
+
+          // Grow if needed
+          if (count >= ids.length) growArrays();
+
+          ids[count] = expressId;
+          offsets[count] = startOffset;
+          lengths[count] = entityLength;
+          lines[count] = startLine;
+          types[count] = typeName;
+          count++;
+
+          pos++;
+          foundTerminator = true;
+          break;
+        } else if (c6 === 0x0A) {
+          line++;
+        }
+        pos++;
+      }
+
+      // Ran off the end without an unquoted ';' -- usually an unescaped
+      // quote left open, or the unterminated-comment break above (mirrors
+      // tokenizer.ts's scanEntitiesFast). Not resynced: with no known
+      // terminator, guessing a resume point risks fabricating entities from
+      // misaligned bytes. Recorded in 'stopped', not incremented here -- see
+      // the post-loop check below.
+      if (!foundTerminator) { stopped = true; }
+    } else if (ch === 0x0A) {
+      line++;
+      pos++;
+    } else if (ch === 0x27) { // quote
+      // Consume a string literal whole. HEADER records carry no '#', so this
+      // loop walks them byte by byte, and a '/*' inside a description would
+      // otherwise open a comment that never closes and take DATA with it.
+      var sp = pos + 1;
+      var closed = false;
+      while (sp < len) {
+        if (buf[sp] === 0x27) {
+          if (sp + 1 < len && buf[sp + 1] === 0x27) { sp += 2; continue; }
+          sp++;
+          closed = true;
+          break;
+        }
+        if (buf[sp] === 0x0A) { line++; }
+        sp++;
+      }
+      pos = sp;
+      // Ran off the end without a closing quote: everything from the open
+      // quote to EOF was consumed looking for one, so nothing after it was
+      // ever a candidate '#' -- the same "no terminator" shape as inside a
+      // record, just outside one (a HEADER string, most often).
+      if (!closed) { stopped = true; break; }
+    } else if (opensCommentAt(pos)) {
+      // Skip a comment region BETWEEN records. A record that is commented out
+      // is still a well-formed #id = TYPE(...), so every check above accepts
+      // it and only skipping the region rejects it.
+      var cp = skipCommentAt(pos);
+      if (cp < 0) {
+        // Unterminated: everything to EOF is commented out.
+        pos = len;
+        stopped = true;
+        break;
+      }
+      pos = cp;
+    } else {
+      pos++;
+    }
+  }
+
+  // ONE post-loop check, not an increment at every exit site above: the scan
+  // stopped early if it hit an explicit "no terminator" boundary ('stopped'),
+  // or the last #id=TYPE( header was cut short before its own '(' was found
+  // ('declOpen'). Always 0 or 1 -- the scan stops at the first one, so there
+  // is nothing further to accumulate.
+  if (stopped || declOpen) { malformedRecords = 1; }
+
+  // Trim arrays once, reuse for both message and transfer list
+  var needsTrim = ids.buffer.byteLength > count * 4;
+  var trimmedIds = needsTrim ? ids.slice(0, count) : ids;
+  var trimmedOffsets = needsTrim ? offsets.slice(0, count) : offsets;
+  var trimmedLengths = needsTrim ? lengths.slice(0, count) : lengths;
+  var trimmedLines = needsTrim ? lines.slice(0, count) : lines;
+  self.postMessage({
+    ids: trimmedIds.buffer,
+    offsets: trimmedOffsets.buffer,
+    lengths: trimmedLengths.buffer,
+    lines: trimmedLines.buffer,
+    types: types.slice(0, count),
+    count: count,
+    oversizedIds: oversizedIds,
+    malformedRecords: malformedRecords,
+  }, [
+    trimmedIds.buffer,
+    trimmedOffsets.buffer,
+    trimmedLengths.buffer,
+    trimmedLines.buffer,
+  ]);
+};
+`;
+//# sourceMappingURL=scan-worker-source.js.map

package/dist/scan-worker-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan-worker-source.js","sourceRoot":"","sources":["../src/scan-worker-source.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;GAQG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;;GAIG;AACH;4DAC4D;AAC5D,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwKH,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiMrC,CAAC"}

package/dist/source-header.d.ts

@@ -8,7 +8,7 @@
  * strings (e.g. `'CoordinateReference [..., ProjectSite: Origin]'`), which a
  * splitter that ignores quote state would mis-split.
  */
-import type { IfcSourceHeader } from '@ifc-lite/data';
+import type { IfcSourceHeader, IfcStoreBase } from '@ifc-lite/data';
 import { type IfcSourceBytes } from './source-bytes.js';
 /**
  * Parse the HEADER section of a STEP/IFC buffer into {@link IfcSourceHeader}.
@@ -17,4 +17,26 @@ import { type IfcSourceBytes } from './source-bytes.js';
  * truncated at the first `ENDSEC` so the DATA section is never scanned.
  */
 export declare function parseSourceHeader(buffer: Uint8Array | IfcSourceBytes): IfcSourceHeader | undefined;
+/**
+ * Determine which IFC schema a STEP buffer declares (issue #3278).
+ *
+ * The `FILE_SCHEMA` declaration is authoritative and is read from the
+ * already-parsed {@link IfcSourceHeader}; free text elsewhere in the header is
+ * not. That distinction is the whole point. `FILE_DESCRIPTION` and `FILE_NAME`
+ * carry author, organisation, preprocessor and originating-system strings, and
+ * exporters routinely stamp a schema token into their product name ("SomeApp
+ * IFC4 Exporter") — which a raw substring scan of the header bytes cannot tell
+ * apart from a declaration. Reading the record also reaches declarations that
+ * sit past the first 2 KB: ISO 10303-21 puts `FILE_SCHEMA` *after* `FILE_NAME`,
+ * and a long author or organisation list pushes it out of a small fixed window.
+ *
+ * Free on the hot path: {@link parseSourceHeader} already runs on every parse,
+ * so nothing extra is scanned. The raw decode below now happens only for a file
+ * that declares no schema at all.
+ *
+ * When no `FILE_SCHEMA` identifier resolves, fall back to the historical raw
+ * scan of the first 2000 bytes rather than refusing, so every file that
+ * resolves today keeps resolving the same way.
+ */
+export declare function detectSchemaVersion(buffer: Uint8Array | IfcSourceBytes, header: IfcSourceHeader | undefined): IfcStoreBase['schemaVersion'];
 //# sourceMappingURL=source-header.d.ts.map

package/dist/source-header.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source-header.d.ts","sourceRoot":"","sources":["../src/source-header.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGtD,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AA+IvE;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,UAAU,GAAG,cAAc,GAClC,eAAe,GAAG,SAAS,CA2D7B"}
+{"version":3,"file":"source-header.d.ts","sourceRoot":"","sources":["../src/source-header.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAGpE,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AA4JvE;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,UAAU,GAAG,cAAc,GAClC,eAAe,GAAG,SAAS,CA2D7B;AA8BD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,UAAU,GAAG,cAAc,EACnC,MAAM,EAAE,eAAe,GAAG,SAAS,GAClC,YAAY,CAAC,eAAe,CAAC,CAuB/B"}

package/dist/source-header.js

@@ -3,38 +3,33 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 import { decodeStepStringLiteral } from '@ifc-lite/encoding';
 import { asSourceBytes } from './source-bytes.js';
+import { matchesKeywordAt, StepTextScan } from './step-lexing.js';
 /** Headers are tiny; cap the decode so a huge file's body is never scanned. */
 const MAX_HEADER_BYTES = 64 * 1024;
 /**
  * Split STEP record arguments at top-level commas, respecting paren/bracket
- * nesting and single-quoted strings (with `''` escapes). Returns the raw,
- * still-escaped argument substrings (trimmed).
+ * nesting, single-quoted strings (with `''` escapes) and comments. Returns the
+ * raw, still-escaped argument substrings (trimmed).
+ *
+ * A comment is dropped rather than copied through: it is not part of the
+ * argument's value, and its commas are not separators.
  */
 function splitTopLevel(inner) {
     const args = [];
     let depth = 0;
-    let inString = false;
     let current = '';
+    const scan = new StepTextScan(inner);
     for (let i = 0; i < inner.length; i++) {
-        const ch = inner[i];
-        if (inString) {
-            current += ch;
-            if (ch === "'") {
-                if (inner[i + 1] === "'") {
-                    current += "'";
-                    i++;
-                }
-                else {
-                    inString = false;
-                }
-            }
+        const skip = scan.skipLexicalAt(i);
+        if (skip >= 0) {
+            // A literal is part of the argument's text; a comment is not.
+            if (inner[i] === "'")
+                current += inner.slice(i, skip);
+            i = skip - 1;
             continue;
         }
-        if (ch === "'") {
-            inString = true;
-            current += ch;
-        }
-        else if (ch === '(' || ch === '[') {
+        const ch = inner[i];
+        if (ch === '(' || ch === '[') {
             depth++;
             current += ch;
         }
@@ -111,38 +106,56 @@ function decodeStringList(arg) {
         .filter((v) => v !== undefined);
 }
 /**
- * Extract the argument substring inside the parentheses of `KEYWORD( ... )`,
- * starting the search at `fromIndex`. Quote- and nesting-aware so a quoted
- * `)` never closes the record early. Returns `null` if not found.
+ * Index of `keyword` occurring as a RECORD, outside any string or comment, or
+ * -1.
+ *
+ * A plain `indexOf` is not enough here and the reason is the same one #3278 is
+ * about, one level down: header FREE TEXT is not a declaration. STEP strings
+ * are single-quoted with `''` as the escape, and a `FILE_DESCRIPTION` item is
+ * free to contain the literal text `FILE_SCHEMA(('IFC2X3'))` -- an exporter
+ * stamping its own header into a description, a file round-tripped through a
+ * tool that quotes what it read. `indexOf` would take that quoted copy as the
+ * declaration and answer IFC2X3 for an IFC4X3 file. The same applies to
+ * `ENDSEC`: a quoted one would truncate the header before the real
+ * `FILE_SCHEMA` record, losing the declaration entirely.
  */
-function extractRecordArgs(text, keyword, fromIndex = 0) {
-    const upper = text.toUpperCase();
-    const at = upper.indexOf(keyword, fromIndex);
+function indexOfRecord(text, keyword) {
+    const scan = new StepTextScan(text);
+    for (let i = 0; i < text.length; i++) {
+        const skip = scan.skipLexicalAt(i);
+        if (skip >= 0) {
+            i = skip - 1;
+            continue;
+        }
+        if (matchesKeywordAt(text, i, keyword))
+            return i;
+    }
+    return -1;
+}
+/**
+ * Extract the argument substring inside the parentheses of `KEYWORD( ... )`.
+ * Quote-, comment- and nesting-aware so a quoted
+ * `)` never closes the record early, and so a quoted KEYWORD is never mistaken
+ * for the record itself. Returns `null` if not found.
+ */
+function extractRecordArgs(text, keyword) {
+    const at = indexOfRecord(text, keyword);
     if (at < 0)
         return null;
-    let i = at + keyword.length;
-    while (i < text.length && /\s/.test(text[i]))
-        i++;
+    const scan = new StepTextScan(text);
+    let i = scan.skipTrivia(at + keyword.length);
     if (text[i] !== '(')
         return null;
     const start = i;
     let depth = 0;
-    let inString = false;
     for (; i < text.length; i++) {
-        const ch = text[i];
-        if (inString) {
-            if (ch === "'") {
-                if (text[i + 1] === "'")
-                    i++;
-                else
-                    inString = false;
-            }
+        const skip = scan.skipLexicalAt(i);
+        if (skip >= 0) {
+            i = skip - 1;
             continue;
         }
-        if (ch === "'") {
-            inString = true;
-        }
-        else if (ch === '(') {
+        const ch = text[i];
+        if (ch === '(') {
             depth++;
         }
         else if (ch === ')') {
@@ -163,7 +176,7 @@ export function parseSourceHeader(buffer) {
     const src = asSourceBytes(buffer);
     const cap = Math.min(src.byteLength, MAX_HEADER_BYTES);
     let text = src.decodeUtf8(0, cap);
-    const endSec = text.toUpperCase().indexOf('ENDSEC');
+    const endSec = indexOfRecord(text, 'ENDSEC');
     if (endSec >= 0)
         text = text.slice(0, endSec);
     const descRecord = extractRecordArgs(text, 'FILE_DESCRIPTION');
@@ -216,4 +229,81 @@ export function parseSourceHeader(buffer) {
         schemaIdentifiers,
     };
 }
+/**
+ * Resolve one `FILE_SCHEMA` identifier to the schema version a store carries.
+ *
+ * Matched by PREFIX, longest first: the spellings that reach us in the wild
+ * carry addendum/corrigendum suffixes (`IFC4X3_ADD2`, `IFC4X1`, `IFC2X3_TC1`),
+ * and `IFC4X3` itself begins with `IFC4`, so the `IFC4X3` branch has to be
+ * tried before the `IFC4` one. Returns `undefined` for an identifier naming no
+ * schema we model, so the caller can keep looking.
+ */
+function schemaFromIdentifier(identifier) {
+    const token = identifier.trim().toUpperCase();
+    if (token.startsWith('IFC5'))
+        return 'IFC5';
+    if (token.startsWith('IFC4X3'))
+        return 'IFC4X3';
+    if (token.startsWith('IFC4'))
+        return 'IFC4';
+    if (token.startsWith('IFC2X3'))
+        return 'IFC2X3';
+    return undefined;
+}
+/** Upper-case the ASCII letters and nothing else. See `detectSchemaVersion`. */
+function asciiUpper(text) {
+    let out = '';
+    for (let i = 0; i < text.length; i++) {
+        const c = text.charCodeAt(i);
+        out += c >= 97 && c <= 122 ? String.fromCharCode(c - 32) : text[i];
+    }
+    return out;
+}
+/**
+ * Determine which IFC schema a STEP buffer declares (issue #3278).
+ *
+ * The `FILE_SCHEMA` declaration is authoritative and is read from the
+ * already-parsed {@link IfcSourceHeader}; free text elsewhere in the header is
+ * not. That distinction is the whole point. `FILE_DESCRIPTION` and `FILE_NAME`
+ * carry author, organisation, preprocessor and originating-system strings, and
+ * exporters routinely stamp a schema token into their product name ("SomeApp
+ * IFC4 Exporter") — which a raw substring scan of the header bytes cannot tell
+ * apart from a declaration. Reading the record also reaches declarations that
+ * sit past the first 2 KB: ISO 10303-21 puts `FILE_SCHEMA` *after* `FILE_NAME`,
+ * and a long author or organisation list pushes it out of a small fixed window.
+ *
+ * Free on the hot path: {@link parseSourceHeader} already runs on every parse,
+ * so nothing extra is scanned. The raw decode below now happens only for a file
+ * that declares no schema at all.
+ *
+ * When no `FILE_SCHEMA` identifier resolves, fall back to the historical raw
+ * scan of the first 2000 bytes rather than refusing, so every file that
+ * resolves today keeps resolving the same way.
+ */
+export function detectSchemaVersion(buffer, header) {
+    for (const identifier of header?.schemaIdentifiers ?? []) {
+        const version = schemaFromIdentifier(identifier);
+        if (version !== undefined)
+            return version;
+    }
+    const src = asSourceBytes(buffer);
+    const headerEnd = Math.min(src.byteLength, 2000);
+    // ASCII-only, for the same reason `matchesKeywordAt` is. `toUpperCase()`
+    // maps `ı` (dotless i) to `I`, so a FILE_DESCRIPTION mentioning `ıFC5` chose
+    // IFC5 for a file that never said so. This scan is already a loose
+    // last-resort substring match -- it only runs when no FILE_SCHEMA identifier
+    // resolved at all -- but loose is not a reason to accept a fold 10303-21
+    // does not use. Offsets are not taken from this copy, so a copy is fine here
+    // where it was not in the record scan.
+    const headerText = asciiUpper(src.decodeUtf8(0, headerEnd));
+    if (headerText.includes('IFC5'))
+        return 'IFC5';
+    if (headerText.includes('IFC4X3'))
+        return 'IFC4X3';
+    if (headerText.includes('IFC4'))
+        return 'IFC4';
+    if (headerText.includes('IFC2X3'))
+        return 'IFC2X3';
+    return 'IFC4'; // Default fallback
+}
 //# sourceMappingURL=source-header.js.map