@ifc-lite/parser 5.2.0 → 6.2.1

package/dist/scan-worker-source.d.ts

@@ -5,5 +5,5 @@
  */
 /** Exported for direct testing (run inside a mock `self`); the runtime path
  *  wraps it in a Blob worker in `scan-worker-inline.ts`. */
-export declare const WORKER_CODE = "\n'use strict';\nself.onmessage = function(e) {\n  var buf = new Uint8Array(e.data);\n  var len = buf.length;\n  var pos = 0;\n  var line = 1;\n\n  // Pre-allocate result array (estimate ~13,500 entities per MB)\n  var estimatedCount = Math.max((len / 1024 / 1024) * 13500, 1000) | 0;\n  // Pack results into typed arrays for fast transfer. Uint32Array for the ids:\n  // that is the express-id storage contract every consumer of this scan holds\n  // to (CompactEntityIndex, the entity/property/quantity tables, the wasm\n  // boundary, Rust's ColumnarIndex), so the guard below refuses anything wider\n  // rather than carrying it one buffer further and truncating downstream\n  // (#3395). The worker runs from a Blob URL and cannot import at runtime, so\n  // the bound below is interpolated from express-id.ts when this template is\n  // evaluated -- one home for the number, not a copy that can drift.\n  // Whether a STEP comment opens at p.\n  function opensCommentAt(p) {\n    return p + 1 < len && buf[p] === 0x2F && buf[p + 1] === 0x2A;\n  }\n\n  // Index just past the '*/' closing the comment at p, or -1 when it never\n  // closes. Counts the newlines it crosses so line numbers stay in step.\n  //\n  // Kept behaviourally identical to skipComment/skipTrivia in step-lexing.ts,\n  // which this cannot import: the worker source is a string, so this copy of\n  // the rule has to live here. Comments do not nest, per ISO 10303-21.\n  function skipCommentAt(p) {\n    var q = p + 2;\n    while (q + 1 < len) {\n      if (buf[q] === 0x2A && buf[q + 1] === 0x2F) return q + 2;\n      if (buf[q] === 0x0A) line++;\n      q++;\n    }\n    return -1;\n  }\n\n  // Skip whitespace, comments, and any run of the two -- 10303-21 allows a\n  // comment wherever whitespace is allowed, INCLUDING inside a record.\n  // Returns -1 when a comment opens and never closes: everything from there on\n  // is inside it, so there is nothing left to find.\n  //\n  // The whitespace byte set (space, tab, CR, LF, form feed, vertical tab) is\n  // kept byte-for-byte in sync with isSpaceByte in step-lexing.ts and its\n  // three inline twins in tokenizer.ts's scanEntitiesFast -- this file is a\n  // string because a Blob worker cannot import at runtime, not a reason for\n  // the rule itself to drift.\n  function skipTriviaAt(p) {\n    for (;;) {\n      while (p < len) {\n        var t = buf[p];\n        if (t === 0x20 || t === 0x09 || t === 0x0D || t === 0x0C || t === 0x0B) { p++; }\n        else if (t === 0x0A) { line++; p++; }\n        else break;\n      }\n      if (!opensCommentAt(p)) return p;\n      var e = skipCommentAt(p);\n      if (e < 0) return -1;\n      p = e;\n    }\n  }\n\n  var ids = new Uint32Array(estimatedCount);\n  var offsets = new Uint32Array(estimatedCount);\n  var lengths = new Uint32Array(estimatedCount);\n  var lines = new Uint32Array(estimatedCount);\n  // Type names stored separately (strings)\n  var types = new Array(estimatedCount);\n  var count = 0;\n  // Records refused by the express-id bound, reported back to the caller.\n  var oversizedIds = 0;\n  // 0 or 1, never a count of how many: whether this scan stopped early on an\n  // unclosed string, an unclosed comment, or a declaration cut off before its\n  // own '(' -- set once, by the single post-loop check at the bottom of this\n  // function. Reported back to the caller. Mirrors tokenizer.ts's\n  // scanEntitiesFast contract exactly, including the 0-or-1 shape.\n  var malformedRecords = 0;\n  // Set on the way to that post-loop check, not counted at each site:\n  // 'stopped' for an unclosed string or comment that ran to end of buffer\n  // with nothing left to find, 'declOpen' while a #id=TYPE( header is\n  // incomplete. 'declOpen' stays armed ONLY when the reason for abandoning\n  // is running out of buffer (pos >= len); a mismatch with buffer still\n  // left (bad byte, oversized id) clears it, because the scan resumes\n  // byte-by-byte from wherever it gave up, and a #ref token inside the\n  // abandoned record's own argument list reads as a fresh, equally\n  // incomplete attempt that must not report \"cut off\" just because\n  // nothing later happens to clear it.\n  var stopped = false;\n  var declOpen = false;\n\n  // Type name cache (IFC files have ~776 unique types across millions of entities)\n  var typeCache = new Map();\n\n  function growArrays() {\n    var newSize = (count * 2) | 0;\n    var newIds = new Uint32Array(newSize);\n    newIds.set(ids);\n    ids = newIds;\n    var newOffsets = new Uint32Array(newSize);\n    newOffsets.set(offsets);\n    offsets = newOffsets;\n    var newLengths = new Uint32Array(newSize);\n    newLengths.set(lengths);\n    lengths = newLengths;\n    var newLines = new Uint32Array(newSize);\n    newLines.set(lines);\n    lines = newLines;\n    types.length = newSize;\n  }\n\n  while (pos < len) {\n    var ch = buf[pos];\n\n    if (ch === 0x23) { // '#'\n      var startOffset = pos;\n      var startLine = line;\n      pos++;\n\n      // Read express ID\n      var expressId = 0;\n      var hasDigits = false;\n      while (pos < len) {\n        var c = buf[pos];\n        if (c >= 0x30 && c <= 0x39) {\n          expressId = expressId * 10 + (c - 0x30);\n          hasDigits = true;\n          pos++;\n        } else {\n          break;\n        }\n      }\n      if (!hasDigits) continue;\n      declOpen = true;\n\n      // Whitespace AND comments: '#1 /* was #7 */ =' is a declaration. The\n      // inline loop stays for the common case; skipTriviaAt runs only once a\n      // comment actually opens. Mirrors tokenizer.ts's scanEntitiesFast.\n      while (pos < len) {\n        var c2 = buf[pos];\n        if (c2 === 0x20 || c2 === 0x09 || c2 === 0x0D || c2 === 0x0C || c2 === 0x0B) { pos++; }\n        else if (c2 === 0x0A) { line++; pos++; }\n        else break;\n      }\n      if (opensCommentAt(pos)) { pos = skipTriviaAt(pos); if (pos < 0) { stopped = true; break; } }\n\n      // Check for '='. A byte that is not '=' with buffer left to scan is\n      // not a truncation -- clear declOpen so a reference token inside a\n      // LATER abandoned record's argument list (see the oversized-id note\n      // below) cannot leave it stuck armed with nothing left to clear it.\n      if (pos >= len) continue;\n      if (buf[pos] !== 0x3D) { declOpen = false; continue; }\n      pos++;\n\n      // Express-id bound, identical to StepTokenizer.scanEntitiesFast -- this\n      // worker is that scan's twin and must reject the same records, and count\n      // the same ones, or which scan path ran decides both whether an id\n      // collides with another and what the user is told was dropped. The\n      // single '>' subsumes a safe-integer check: a digit run accumulated as a\n      // double is non-negative and integral, and every value past 2^32 --\n      // including one past 2^53, where two distinct ids collide onto one\n      // double -- fails it. Tested only after '=' has matched, because that is\n      // the DECLARATION shape Rust's EntityScanner validates before refusing:\n      // the 'continue' below resumes inside the refused record's argument\n      // list, so an oversized '#ref' in there arrives here too and would be\n      // counted as a second dropped record. Count the refusal; a record that\n      // vanishes without a trace is the same defect wearing a different hat.\n      if (expressId > 4294967295) { oversizedIds++; declOpen = false; continue; }\n\n      // Skip whitespace and comments\n      while (pos < len) {\n        var c3 = buf[pos];\n        if (c3 === 0x20 || c3 === 0x09 || c3 === 0x0D || c3 === 0x0C || c3 === 0x0B) { pos++; }\n        else if (c3 === 0x0A) { line++; pos++; }\n        else break;\n      }\n      if (opensCommentAt(pos)) { pos = skipTriviaAt(pos); if (pos < 0) { stopped = true; break; } }\n\n      // Read type name. Must start A-Z; a bad start byte with buffer left\n      // clears declOpen for the same reason as the '=' check.\n      var typeStart = pos;\n      if (pos >= len) continue;\n      if (buf[pos] < 0x41 || buf[pos] > 0x5A) { declOpen = false; continue; }\n\n      while (pos < len) {\n        var c4 = buf[pos];\n        if ((c4 >= 0x41 && c4 <= 0x5A) || (c4 >= 0x61 && c4 <= 0x7A) ||\n            (c4 >= 0x30 && c4 <= 0x39) || c4 === 0x5F) {\n          pos++;\n        } else {\n          break;\n        }\n      }\n      if (pos === typeStart) continue;\n\n      // Cache type name \u2014 use length + hash compound key and verify the actual\n      // bytes on a hit. Length alone can't disambiguate a 32-bit hash collision\n      // (e.g. \"Aa\"/\"BB\"), so without the byte compare a crafted/unlucky file\n      // could have one type silently misread as another. Mirrors tokenizer.ts.\n      var typeLen = pos - typeStart;\n      var typeHash = typeLen;\n      for (var i = typeStart; i < pos; i++) {\n        typeHash = (typeHash * 31 + buf[i]) | 0;\n      }\n      var cacheKey = typeLen + ':' + typeHash;\n      var typeName = typeCache.get(cacheKey);\n      var cacheHitMatches = false;\n      if (typeName !== undefined && typeName.length === typeLen) {\n        cacheHitMatches = true;\n        for (var v = 0; v < typeLen; v++) {\n          if (typeName.charCodeAt(v) !== buf[typeStart + v]) {\n            cacheHitMatches = false;\n            break;\n          }\n        }\n      }\n      if (typeName === undefined || !cacheHitMatches) {\n        typeName = String.fromCharCode.apply(null, buf.subarray(typeStart, pos));\n        typeCache.set(cacheKey, typeName);\n      }\n\n      // Skip whitespace and comments\n      while (pos < len) {\n        var c5 = buf[pos];\n        if (c5 === 0x20 || c5 === 0x09 || c5 === 0x0D || c5 === 0x0C || c5 === 0x0B) { pos++; }\n        else if (c5 === 0x0A) { line++; pos++; }\n        else break;\n      }\n      if (opensCommentAt(pos)) { pos = skipTriviaAt(pos); if (pos < 0) { stopped = true; break; } }\n\n      // Check for '('. Same EOF-vs-mismatch split as '=' and the type name.\n      if (pos >= len) continue;\n      if (buf[pos] !== 0x28) { declOpen = false; continue; }\n      declOpen = false; // Header complete: '(' found.\n\n      // Skip to semicolon (handling strings)\n      var inString = false;\n      var foundTerminator = false;\n      while (pos < len) {\n        var c6 = buf[pos];\n        if (c6 === 0x27) { // quote\n          if (inString && pos + 1 < len && buf[pos + 1] === 0x27) {\n            pos += 2;\n            continue;\n          }\n          inString = !inString;\n        } else if (c6 === 0x2F && !inString && opensCommentAt(pos)) {\n          // The ';' that ends a record can be preceded by a comment holding\n          // its own ';'. Take the comment whole, which also makes the quotes\n          // and parens inside it text -- the other direction of the rule the\n          // quote branch above gives for a '/*' inside a literal.\n          var ce = skipCommentAt(pos);\n          if (ce < 0) {\n            // Unterminated: this record has no terminator, and neither has\n            // anything after it. Drop it and stop.\n            pos = len;\n            break;\n          }\n          pos = ce;\n          continue;\n        } else if (c6 === 0x3B && !inString) { // semicolon\n          var entityLength = pos - startOffset + 1;\n\n          // Grow if needed\n          if (count >= ids.length) growArrays();\n\n          ids[count] = expressId;\n          offsets[count] = startOffset;\n          lengths[count] = entityLength;\n          lines[count] = startLine;\n          types[count] = typeName;\n          count++;\n\n          pos++;\n          foundTerminator = true;\n          break;\n        } else if (c6 === 0x0A) {\n          line++;\n        }\n        pos++;\n      }\n\n      // Ran off the end without an unquoted ';' -- usually an unescaped\n      // quote left open, or the unterminated-comment break above (mirrors\n      // tokenizer.ts's scanEntitiesFast). Not resynced: with no known\n      // terminator, guessing a resume point risks fabricating entities from\n      // misaligned bytes. Recorded in 'stopped', not incremented here -- see\n      // the post-loop check below.\n      if (!foundTerminator) { stopped = true; }\n    } else if (ch === 0x0A) {\n      line++;\n      pos++;\n    } else if (ch === 0x27) { // quote\n      // Consume a string literal whole. HEADER records carry no '#', so this\n      // loop walks them byte by byte, and a '/*' inside a description would\n      // otherwise open a comment that never closes and take DATA with it.\n      var sp = pos + 1;\n      var closed = false;\n      while (sp < len) {\n        if (buf[sp] === 0x27) {\n          if (sp + 1 < len && buf[sp + 1] === 0x27) { sp += 2; continue; }\n          sp++;\n          closed = true;\n          break;\n        }\n        if (buf[sp] === 0x0A) { line++; }\n        sp++;\n      }\n      pos = sp;\n      // Ran off the end without a closing quote: everything from the open\n      // quote to EOF was consumed looking for one, so nothing after it was\n      // ever a candidate '#' -- the same \"no terminator\" shape as inside a\n      // record, just outside one (a HEADER string, most often).\n      if (!closed) { stopped = true; break; }\n    } else if (opensCommentAt(pos)) {\n      // Skip a comment region BETWEEN records. A record that is commented out\n      // is still a well-formed #id = TYPE(...), so every check above accepts\n      // it and only skipping the region rejects it.\n      var cp = skipCommentAt(pos);\n      if (cp < 0) {\n        // Unterminated: everything to EOF is commented out.\n        pos = len;\n        stopped = true;\n        break;\n      }\n      pos = cp;\n    } else {\n      pos++;\n    }\n  }\n\n  // ONE post-loop check, not an increment at every exit site above: the scan\n  // stopped early if it hit an explicit \"no terminator\" boundary ('stopped'),\n  // or the last #id=TYPE( header was cut short before its own '(' was found\n  // ('declOpen'). Always 0 or 1 -- the scan stops at the first one, so there\n  // is nothing further to accumulate.\n  if (stopped || declOpen) { malformedRecords = 1; }\n\n  // Trim arrays once, reuse for both message and transfer list\n  var needsTrim = ids.buffer.byteLength > count * 4;\n  var trimmedIds = needsTrim ? ids.slice(0, count) : ids;\n  var trimmedOffsets = needsTrim ? offsets.slice(0, count) : offsets;\n  var trimmedLengths = needsTrim ? lengths.slice(0, count) : lengths;\n  var trimmedLines = needsTrim ? lines.slice(0, count) : lines;\n  self.postMessage({\n    ids: trimmedIds.buffer,\n    offsets: trimmedOffsets.buffer,\n    lengths: trimmedLengths.buffer,\n    lines: trimmedLines.buffer,\n    types: types.slice(0, count),\n    count: count,\n    oversizedIds: oversizedIds,\n    malformedRecords: malformedRecords,\n  }, [\n    trimmedIds.buffer,\n    trimmedOffsets.buffer,\n    trimmedLengths.buffer,\n    trimmedLines.buffer,\n  ]);\n};\n";
+export declare const WORKER_CODE = "\n'use strict';\nself.onmessage = function(e) {\n  var buf = new Uint8Array(e.data);\n  var len = buf.length;\n  var pos = 0;\n  var line = 1;\n\n  // Pre-allocate result array (estimate ~13,500 entities per MB)\n  var estimatedCount = Math.max((len / 1024 / 1024) * 13500, 1000) | 0;\n  // Pack results into typed arrays for fast transfer. Uint32Array for the ids:\n  // that is the express-id storage contract every consumer of this scan holds\n  // to (CompactEntityIndex, the entity/property/quantity tables, the wasm\n  // boundary, Rust's ColumnarIndex), so the guard below refuses anything wider\n  // rather than carrying it one buffer further and truncating downstream\n  // (#3395). The worker runs from a Blob URL and cannot import at runtime, so\n  // the bound below is interpolated from express-id.ts when this template is\n  // evaluated -- one home for the number, not a copy that can drift.\n\n  // The STEP whitespace set: space, tab, CR, LF, form feed, vertical tab.\n  // The matched half is the now-exported isSpaceByte in step-lexing.ts; a\n  // member going missing from one copy is what #3733 was.\n  function isSpaceByteAt(p) {\n    var t = buf[p];\n    return t === 0x20 || t === 0x09 || t === 0x0A || t === 0x0D || t === 0x0C || t === 0x0B;\n  }\n\n  // Whether a STEP comment opens at p.\n  function opensCommentAt(p) {\n    return p + 1 < len && buf[p] === 0x2F && buf[p + 1] === 0x2A;\n  }\n\n  // Index just past the '*/' closing the comment at p, or -1 when it never\n  // closes. Counts the newlines it crosses so line numbers stay in step.\n  //\n  // Kept behaviourally identical to skipComment/skipTrivia in step-lexing.ts,\n  // which this cannot import: the worker source is a string, so this copy of\n  // the rule has to live here. Comments do not nest, per ISO 10303-21.\n  function skipCommentAt(p) {\n    var q = p + 2;\n    while (q + 1 < len) {\n      if (buf[q] === 0x2A && buf[q + 1] === 0x2F) return q + 2;\n      if (buf[q] === 0x0A) line++;\n      q++;\n    }\n    return -1;\n  }\n\n  // Skip whitespace, comments, and any run of the two -- 10303-21 allows a\n  // comment wherever whitespace is allowed, INCLUDING inside a record.\n  // Returns -1 when a comment opens and never closes: everything from there on\n  // is inside it, so there is nothing left to find.\n  //\n  // The whitespace byte set (space, tab, CR, LF, form feed, vertical tab) is\n  // kept byte-for-byte in sync with isSpaceByte in step-lexing.ts and its\n  // three inline twins in tokenizer.ts's scanEntitiesFast -- this file is a\n  // string because a Blob worker cannot import at runtime, not a reason for\n  // the rule itself to drift.\n  function skipTriviaAt(p) {\n    for (;;) {\n      while (p < len) {\n        var t = buf[p];\n        if (t === 0x20 || t === 0x09 || t === 0x0D || t === 0x0C || t === 0x0B) { p++; }\n        else if (t === 0x0A) { line++; p++; }\n        else break;\n      }\n      if (!opensCommentAt(p)) return p;\n      var e = skipCommentAt(p);\n      if (e < 0) return -1;\n      p = e;\n    }\n  }\n\n  // Byte length from startOffset through the ')' balancing the '(' at p, or a\n  // CLASSIFIED failure: -1 unbalanced but readable, -2 a literal or comment\n  // that never closed. The RECOVERY point for a record with no ';' of its own\n  // (#4179), and the exact answer for whether a ';' is the record's own.\n  // Mirrors findEntityLength in step-record-boundary.ts; a literal is jumped\n  // whole and a comment after it, in that order, so a paren inside either is\n  // text. A top-level '=' is the NEXT declaration's, so the walk stops there\n  // and answers -1 rather than balancing across a record it has not read;\n  // that stop is also what keeps a file of unbalanced records linear instead\n  // of quadratic (#4573; the argument is on findEntityLength). NOTE:\n  // skipCommentAt advances the line counter, so a caller that re-walks the\n  // record must save and restore it.\n  function findEntityLengthAt(p, startOffset) {\n    var d = 0;\n    while (p < len) {\n      var b = buf[p];\n      if (b === 0x27) {\n        p++;\n        for (;;) {\n          if (p >= len) return -2;\n          if (buf[p] === 0x27) { if (buf[p + 1] === 0x27) { p += 2; continue; } p++; break; }\n          p++;\n        }\n      } else if (opensCommentAt(p)) {\n        var q = skipCommentAt(p);\n        if (q < 0) return -2;\n        p = q;\n      } else if (b === 0x3D) { return -1; }\n      else if (b === 0x28) { d++; p++; }\n      else if (b === 0x29) { if (d === 0) return -1; d--; p++; if (d === 0) return p - startOffset; }\n      else { p++; }\n    }\n    return -1;\n  }\n\n\n  var ids = new Uint32Array(estimatedCount);\n  var offsets = new Uint32Array(estimatedCount);\n  var lengths = new Uint32Array(estimatedCount);\n  var lines = new Uint32Array(estimatedCount);\n  // Type names stored separately (strings)\n  var types = new Array(estimatedCount);\n  var count = 0;\n  // Records refused by the express-id bound, reported back to the caller.\n  var oversizedIds = 0;\n  // 0 or 1, never a count of how many: whether this scan stopped early on an\n  // unclosed string, an unclosed comment, or a declaration cut off before its\n  // own '(' -- set once, by the single post-loop check at the bottom of this\n  // function. Reported back to the caller. Mirrors tokenizer.ts's\n  // scanEntitiesFast contract exactly, including the 0-or-1 shape.\n  var malformedRecords = 0;\n  // Set on the way to that post-loop check, not counted at each site:\n  // 'stopped' for an unclosed string or comment that ran to end of buffer\n  // with nothing left to find, 'declOpen' while a #id=TYPE( header is\n  // incomplete. 'declOpen' stays armed ONLY when the reason for abandoning\n  // is running out of buffer (pos >= len); a mismatch with buffer still\n  // left (bad byte, oversized id) clears it, because the scan resumes\n  // byte-by-byte from wherever it gave up, and a #ref token inside the\n  // abandoned record's own argument list reads as a fresh, equally\n  // incomplete attempt that must not report \"cut off\" just because\n  // nothing later happens to clear it.\n  var stopped = false;\n  var declOpen = false;\n\n  // Type name cache (IFC files have ~776 unique types across millions of entities)\n  var typeCache = new Map();\n\n  function growArrays() {\n    var newSize = (count * 2) | 0;\n    var newIds = new Uint32Array(newSize);\n    newIds.set(ids);\n    ids = newIds;\n    var newOffsets = new Uint32Array(newSize);\n    newOffsets.set(offsets);\n    offsets = newOffsets;\n    var newLengths = new Uint32Array(newSize);\n    newLengths.set(lengths);\n    lengths = newLengths;\n    var newLines = new Uint32Array(newSize);\n    newLines.set(lines);\n    lines = newLines;\n    types.length = newSize;\n  }\n\n  while (pos < len) {\n    var ch = buf[pos];\n\n    if (ch === 0x23) { // '#'\n      var startOffset = pos;\n      var startLine = line;\n      pos++;\n\n      // Read express ID\n      var expressId = 0;\n      var hasDigits = false;\n      while (pos < len) {\n        var c = buf[pos];\n        if (c >= 0x30 && c <= 0x39) {\n          expressId = expressId * 10 + (c - 0x30);\n          hasDigits = true;\n          pos++;\n        } else {\n          break;\n        }\n      }\n      if (!hasDigits) continue;\n      declOpen = true;\n\n      // Whitespace AND comments: '#1 /* was #7 */ =' is a declaration. The\n      // inline loop stays for the common case; skipTriviaAt runs only once a\n      // comment actually opens. Mirrors tokenizer.ts's scanEntitiesFast.\n      while (pos < len) {\n        var c2 = buf[pos];\n        if (c2 === 0x20 || c2 === 0x09 || c2 === 0x0D || c2 === 0x0C || c2 === 0x0B) { pos++; }\n        else if (c2 === 0x0A) { line++; pos++; }\n        else break;\n      }\n      if (opensCommentAt(pos)) { pos = skipTriviaAt(pos); if (pos < 0) { stopped = true; break; } }\n\n      // Check for '='. A byte that is not '=' with buffer left to scan is\n      // not a truncation -- clear declOpen so a reference token inside a\n      // LATER abandoned record's argument list (see the oversized-id note\n      // below) cannot leave it stuck armed with nothing left to clear it.\n      if (pos >= len) continue;\n      if (buf[pos] !== 0x3D) { declOpen = false; continue; }\n      pos++;\n\n      // Express-id bound, identical to StepTokenizer.scanEntitiesFast -- this\n      // worker is that scan's twin and must reject the same records, and count\n      // the same ones, or which scan path ran decides both whether an id\n      // collides with another and what the user is told was dropped. The\n      // single '>' subsumes a safe-integer check: a digit run accumulated as a\n      // double is non-negative and integral, and every value past 2^32 --\n      // including one past 2^53, where two distinct ids collide onto one\n      // double -- fails it. Tested only after '=' has matched, because that is\n      // the DECLARATION shape Rust's EntityScanner validates before refusing:\n      // the 'continue' below resumes inside the refused record's argument\n      // list, so an oversized '#ref' in there arrives here too and would be\n      // counted as a second dropped record. Count the refusal; a record that\n      // vanishes without a trace is the same defect wearing a different hat.\n      if (expressId > 4294967295) { oversizedIds++; declOpen = false; continue; }\n\n      // Skip whitespace and comments\n      while (pos < len) {\n        var c3 = buf[pos];\n        if (c3 === 0x20 || c3 === 0x09 || c3 === 0x0D || c3 === 0x0C || c3 === 0x0B) { pos++; }\n        else if (c3 === 0x0A) { line++; pos++; }\n        else break;\n      }\n      if (opensCommentAt(pos)) { pos = skipTriviaAt(pos); if (pos < 0) { stopped = true; break; } }\n\n      // Read type name. Must start A-Z; a bad start byte with buffer left\n      // clears declOpen for the same reason as the '=' check.\n      var typeStart = pos;\n      if (pos >= len) continue;\n      if (buf[pos] < 0x41 || buf[pos] > 0x5A) { declOpen = false; continue; }\n\n      while (pos < len) {\n        var c4 = buf[pos];\n        if ((c4 >= 0x41 && c4 <= 0x5A) || (c4 >= 0x61 && c4 <= 0x7A) ||\n            (c4 >= 0x30 && c4 <= 0x39) || c4 === 0x5F) {\n          pos++;\n        } else {\n          break;\n        }\n      }\n      if (pos === typeStart) continue;\n\n      // Cache type name \u2014 use length + hash compound key and verify the actual\n      // bytes on a hit. Length alone can't disambiguate a 32-bit hash collision\n      // (e.g. \"Aa\"/\"BB\"), so without the byte compare a crafted/unlucky file\n      // could have one type silently misread as another. Mirrors tokenizer.ts.\n      var typeLen = pos - typeStart;\n      var typeHash = typeLen;\n      for (var i = typeStart; i < pos; i++) {\n        typeHash = (typeHash * 31 + buf[i]) | 0;\n      }\n      var cacheKey = typeLen + ':' + typeHash;\n      var typeName = typeCache.get(cacheKey);\n      var cacheHitMatches = false;\n      if (typeName !== undefined && typeName.length === typeLen) {\n        cacheHitMatches = true;\n        for (var v = 0; v < typeLen; v++) {\n          if (typeName.charCodeAt(v) !== buf[typeStart + v]) {\n            cacheHitMatches = false;\n            break;\n          }\n        }\n      }\n      if (typeName === undefined || !cacheHitMatches) {\n        typeName = String.fromCharCode.apply(null, buf.subarray(typeStart, pos));\n        typeCache.set(cacheKey, typeName);\n      }\n\n      // Skip whitespace and comments\n      while (pos < len) {\n        var c5 = buf[pos];\n        if (c5 === 0x20 || c5 === 0x09 || c5 === 0x0D || c5 === 0x0C || c5 === 0x0B) { pos++; }\n        else if (c5 === 0x0A) { line++; pos++; }\n        else break;\n      }\n      if (opensCommentAt(pos)) { pos = skipTriviaAt(pos); if (pos < 0) { stopped = true; break; } }\n\n      // Check for '('. Same EOF-vs-mismatch split as '=' and the type name.\n      if (pos >= len) continue;\n      if (buf[pos] !== 0x28) { declOpen = false; continue; }\n      declOpen = false; // Header complete: '(' found.\n\n      // Skip to semicolon (handling strings), bounded to THIS record's own\n      // body so a record missing its ';' cannot latch onto a later one and\n      // swallow what lies between (#4179): the ';' must be preceded, modulo\n      // trivia, by the ')' closing the parameter list, and no '=' may come\n      // before it outside a string or comment. On either failure the record is\n      // DROPPED and the scan resumes at that ')' rather than abandoning the\n      // file's tail. close_step_record in rust/core/src/parser/lexical.rs\n      // argues both rules and the recovery; this is a hand-duplicated copy\n      // because a Blob worker cannot import at runtime. Change them together.\n      var parenPos = pos;\n      var inString = false;\n      var foundTerminator = false;\n      // Memoised across the exact ';' check and the recovery below, which\n      // would otherwise balance the same record twice. -3 = not computed;\n      // -1 = unbalanced but readable; -2 = a literal/comment never closed.\n      var recordClose = -3;\n      while (pos < len) {\n        var c6 = buf[pos];\n        if (c6 === 0x27) { // quote\n          if (inString && pos + 1 < len && buf[pos + 1] === 0x27) {\n            pos += 2;\n            continue;\n          }\n          inString = !inString;\n        } else if (c6 === 0x2F && !inString && opensCommentAt(pos)) {\n          // The ';' that ends a record can be preceded by a comment holding\n          // its own ';'. Take the comment whole, which also makes the quotes\n          // and parens inside it text -- the other direction of the rule the\n          // quote branch above gives for a '/*' inside a literal.\n          var ce = skipCommentAt(pos);\n          if (ce < 0) break; // Unterminated: recovery below finds no ')'.\n          pos = ce;\n          continue;\n        } else if (c6 === 0x3B && !inString) { // semicolon\n          // ')' modulo whitespace settles it for every record a real file\n          // holds. Anything else -- including the '/' of a trailing '*/',\n          // which a backwards walk cannot see through -- goes to the cold,\n          // exact balance-and-skip-trivia check.\n          var w = pos;\n          while (w > parenPos && isSpaceByteAt(w - 1)) w--;\n          if (buf[w - 1] !== 0x29) {\n            var savedBalLine = line;\n            recordClose = findEntityLengthAt(parenPos, startOffset);\n            line = savedBalLine;\n            if (recordClose <= 0) break;\n            recordClose += startOffset;\n            var after = skipTriviaAt(recordClose);\n            line = savedBalLine;\n            if (after < 0 || after !== pos) break;\n          }\n          var entityLength = pos - startOffset + 1;\n\n          // Grow if needed\n          if (count >= ids.length) growArrays();\n\n          ids[count] = expressId;\n          offsets[count] = startOffset;\n          lengths[count] = entityLength;\n          lines[count] = startLine;\n          types[count] = typeName;\n          count++;\n\n          pos++;\n          foundTerminator = true;\n          break;\n        } else if (c6 === 0x3D && !inString) {\n          break; // '=': the NEXT declaration already started.\n        } else if (c6 === 0x0A) {\n          line++;\n        }\n        pos++;\n      }\n\n      // No ';' of this record's own. EVERY such exit lands here, so the\n      // recovery lives here once rather than at each break -- mirrors\n      // tokenizer.ts's scanEntitiesFast. Resume at the ')' balancing this\n      // record's own '(' when there is one, dropping just this record;\n      // otherwise run to len, ending the scan un-resynced rather than guessing\n      // a resume point from misaligned bytes. The balance walk stops at the\n      // next declaration's '=' (#4573), so a refusal costs this record's\n      // bytes, never a re-walk of the remainder per refusal.\n      if (!foundTerminator) {\n        stopped = true;\n        if (recordClose === -3) {\n          var savedRecLine = line;\n          recordClose = findEntityLengthAt(parenPos, startOffset);\n          line = savedRecLine;\n          if (recordClose > 0) recordClose += startOffset;\n        }\n        if (recordClose > 0) {\n          pos = recordClose;\n          line = startLine;\n          for (var q = startOffset; q < pos; q++) if (buf[q] === 0x0A) line++;\n        } else if (recordClose === -1) {\n          // No ')' before the next '=' (or EOF), bytes after readable:\n          // re-hunt from past this record's '#'.\n          pos = startOffset + 1;\n          line = startLine;\n        } else {\n          pos = len; // Nothing to resume from (#3695).\n        }\n      }\n    } else if (ch === 0x0A) {\n      line++;\n      pos++;\n    } else if (ch === 0x27) { // quote\n      // Consume a string literal whole. HEADER records carry no '#', so this\n      // loop walks them byte by byte, and a '/*' inside a description would\n      // otherwise open a comment that never closes and take DATA with it.\n      var sp = pos + 1;\n      var closed = false;\n      while (sp < len) {\n        if (buf[sp] === 0x27) {\n          if (sp + 1 < len && buf[sp + 1] === 0x27) { sp += 2; continue; }\n          sp++;\n          closed = true;\n          break;\n        }\n        if (buf[sp] === 0x0A) { line++; }\n        sp++;\n      }\n      pos = sp;\n      // Ran off the end without a closing quote: everything from the open\n      // quote to EOF was consumed looking for one, so nothing after it was\n      // ever a candidate '#' -- the same \"no terminator\" shape as inside a\n      // record, just outside one (a HEADER string, most often).\n      if (!closed) { stopped = true; break; }\n    } else if (opensCommentAt(pos)) {\n      // Skip a comment region BETWEEN records. A record that is commented out\n      // is still a well-formed #id = TYPE(...), so every check above accepts\n      // it and only skipping the region rejects it.\n      var cp = skipCommentAt(pos);\n      if (cp < 0) {\n        // Unterminated: everything to EOF is commented out.\n        pos = len;\n        stopped = true;\n        break;\n      }\n      pos = cp;\n    } else {\n      pos++;\n    }\n  }\n\n  // ONE post-loop check, not an increment at every exit site above: the scan\n  // stopped early if it hit an explicit \"no terminator\" boundary ('stopped'),\n  // or the last #id=TYPE( header was cut short before its own '(' was found\n  // ('declOpen'). Always 0 or 1 -- the scan stops at the first one, so there\n  // is nothing further to accumulate.\n  if (stopped || declOpen) { malformedRecords = 1; }\n\n  // Trim arrays once, reuse for both message and transfer list\n  var needsTrim = ids.buffer.byteLength > count * 4;\n  var trimmedIds = needsTrim ? ids.slice(0, count) : ids;\n  var trimmedOffsets = needsTrim ? offsets.slice(0, count) : offsets;\n  var trimmedLengths = needsTrim ? lengths.slice(0, count) : lengths;\n  var trimmedLines = needsTrim ? lines.slice(0, count) : lines;\n  self.postMessage({\n    ids: trimmedIds.buffer,\n    offsets: trimmedOffsets.buffer,\n    lengths: trimmedLengths.buffer,\n    lines: trimmedLines.buffer,\n    types: types.slice(0, count),\n    count: count,\n    oversizedIds: oversizedIds,\n    malformedRecords: malformedRecords,\n  }, [\n    trimmedIds.buffer,\n    trimmedOffsets.buffer,\n    trimmedLengths.buffer,\n    trimmedLines.buffer,\n  ]);\n};\n";
 //# sourceMappingURL=scan-worker-source.d.ts.map

package/dist/scan-worker-source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scan-worker-source.d.ts","sourceRoot":"","sources":["../src/scan-worker-source.ts"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH;4DAC4D;AAC5D,eAAO,MAAM,WAAW,uodAyWvB,CAAC"}
+{"version":3,"file":"scan-worker-source.d.ts","sourceRoot":"","sources":["../src/scan-worker-source.ts"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH;4DAC4D;AAC5D,eAAO,MAAM,WAAW,4lmBA6WvB,CAAC"}

package/dist/scan-worker-source.js

@@ -11,6 +11,7 @@
  * function each mirrors.
  */
 import { MAX_EXPRESS_ID } from './express-id.js';
+import { WORKER_LEXING } from './scan-worker-lexing.js';
 /**
  * Self-contained entity scanner code (runs inside Web Worker).
  * This is the same algorithm as StepTokenizer.scanEntitiesFast() but
@@ -36,51 +37,7 @@ self.onmessage = function(e) {
   // (#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;
-    }
-  }
+${WORKER_LEXING}
 
   var ids = new Uint32Array(estimatedCount);
   var offsets = new Uint32Array(estimatedCount);
@@ -254,9 +211,22 @@ self.onmessage = function(e) {
       if (buf[pos] !== 0x28) { declOpen = false; continue; }
       declOpen = false; // Header complete: '(' found.
 
-      // Skip to semicolon (handling strings)
+      // Skip to semicolon (handling strings), bounded to THIS record's own
+      // body so a record missing its ';' cannot latch onto a later one and
+      // swallow what lies between (#4179): the ';' must be preceded, modulo
+      // trivia, by the ')' closing the parameter list, and no '=' may come
+      // before it outside a string or comment. On either failure the record is
+      // DROPPED and the scan resumes at that ')' rather than abandoning the
+      // file's tail. close_step_record in rust/core/src/parser/lexical.rs
+      // argues both rules and the recovery; this is a hand-duplicated copy
+      // because a Blob worker cannot import at runtime. Change them together.
+      var parenPos = pos;
       var inString = false;
       var foundTerminator = false;
+      // Memoised across the exact ';' check and the recovery below, which
+      // would otherwise balance the same record twice. -3 = not computed;
+      // -1 = unbalanced but readable; -2 = a literal/comment never closed.
+      var recordClose = -3;
       while (pos < len) {
         var c6 = buf[pos];
         if (c6 === 0x27) { // quote
@@ -271,15 +241,26 @@ self.onmessage = function(e) {
           // 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;
-          }
+          if (ce < 0) break; // Unterminated: recovery below finds no ')'.
           pos = ce;
           continue;
         } else if (c6 === 0x3B && !inString) { // semicolon
+          // ')' modulo whitespace settles it for every record a real file
+          // holds. Anything else -- including the '/' of a trailing '*/',
+          // which a backwards walk cannot see through -- goes to the cold,
+          // exact balance-and-skip-trivia check.
+          var w = pos;
+          while (w > parenPos && isSpaceByteAt(w - 1)) w--;
+          if (buf[w - 1] !== 0x29) {
+            var savedBalLine = line;
+            recordClose = findEntityLengthAt(parenPos, startOffset);
+            line = savedBalLine;
+            if (recordClose <= 0) break;
+            recordClose += startOffset;
+            var after = skipTriviaAt(recordClose);
+            line = savedBalLine;
+            if (after < 0 || after !== pos) break;
+          }
           var entityLength = pos - startOffset + 1;
 
           // Grow if needed
@@ -295,19 +276,43 @@ self.onmessage = function(e) {
           pos++;
           foundTerminator = true;
           break;
+        } else if (c6 === 0x3D && !inString) {
+          break; // '=': the NEXT declaration already started.
         } 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; }
+      // No ';' of this record's own. EVERY such exit lands here, so the
+      // recovery lives here once rather than at each break -- mirrors
+      // tokenizer.ts's scanEntitiesFast. Resume at the ')' balancing this
+      // record's own '(' when there is one, dropping just this record;
+      // otherwise run to len, ending the scan un-resynced rather than guessing
+      // a resume point from misaligned bytes. The balance walk stops at the
+      // next declaration's '=' (#4573), so a refusal costs this record's
+      // bytes, never a re-walk of the remainder per refusal.
+      if (!foundTerminator) {
+        stopped = true;
+        if (recordClose === -3) {
+          var savedRecLine = line;
+          recordClose = findEntityLengthAt(parenPos, startOffset);
+          line = savedRecLine;
+          if (recordClose > 0) recordClose += startOffset;
+        }
+        if (recordClose > 0) {
+          pos = recordClose;
+          line = startLine;
+          for (var q = startOffset; q < pos; q++) if (buf[q] === 0x0A) line++;
+        } else if (recordClose === -1) {
+          // No ')' before the next '=' (or EOF), bytes after readable:
+          // re-hunt from past this record's '#'.
+          pos = startOffset + 1;
+          line = startLine;
+        } else {
+          pos = len; // Nothing to resume from (#3695).
+        }
+      }
     } else if (ch === 0x0A) {
       line++;
       pos++;

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

@@ -1 +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"}
+{"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;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAExD;;;;GAIG;AACH;4DAC4D;AAC5D,MAAM,CAAC,MAAM,WAAW,GAAG;;;;;;;;;;;;;;;;;;EAkBzB,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA0GS,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiPrC,CAAC"}

package/dist/schedule-extractor.d.ts

@@ -1,86 +1,8 @@
 import type { IfcDataStore } from './columnar-parser.js';
 import { parseIso8601Duration } from './iso8601-duration.js';
+import type { SequenceTypeEnum, TaskDurationType, ScheduleTaskTimeInfo, ScheduleTaskInfo, ScheduleSequenceInfo, WorkScheduleInfo, ScheduleExtraction } from './schedule-types.js';
 export { parseIso8601Duration };
-export type SequenceTypeEnum = 'START_START' | 'START_FINISH' | 'FINISH_START' | 'FINISH_FINISH' | 'USERDEFINED' | 'NOTDEFINED';
-export type TaskDurationType = 'WORKTIME' | 'ELAPSEDTIME' | 'NOTDEFINED';
-export interface ScheduleTaskTimeInfo {
-    scheduleStart?: string;
-    scheduleFinish?: string;
-    scheduleDuration?: string;
-    actualStart?: string;
-    actualFinish?: string;
-    actualDuration?: string;
-    earlyStart?: string;
-    earlyFinish?: string;
-    lateStart?: string;
-    lateFinish?: string;
-    freeFloat?: string;
-    totalFloat?: string;
-    remainingTime?: string;
-    durationType?: TaskDurationType;
-    statusTime?: string;
-    isCritical?: boolean;
-    completion?: number;
-}
-export interface ScheduleTaskInfo {
-    expressId: number;
-    globalId: string;
-    name: string;
-    description?: string;
-    objectType?: string;
-    identification?: string;
-    longDescription?: string;
-    status?: string;
-    workMethod?: string;
-    isMilestone: boolean;
-    priority?: number;
-    predefinedType?: string;
-    taskTime?: ScheduleTaskTimeInfo;
-    /** Parent task globalId (from IfcRelNests where this task is in RelatedObjects). */
-    parentGlobalId?: string;
-    /** Child task globalIds (from IfcRelNests where this task is RelatingObject). */
-    childGlobalIds: string[];
-    /** expressIds of products assigned to this task via IfcRelAssignsToProcess. */
-    productExpressIds: number[];
-    /** globalIds of the same products (aligned with productExpressIds by index). */
-    productGlobalIds: string[];
-    /** WorkSchedule globalIds that control this task via IfcRelAssignsToControl. */
-    controllingScheduleGlobalIds: string[];
-}
-export interface ScheduleSequenceInfo {
-    globalId: string;
-    relatingTaskGlobalId: string;
-    relatedTaskGlobalId: string;
-    sequenceType: SequenceTypeEnum;
-    userDefinedSequenceType?: string;
-    /** Lag value expressed in seconds if it resolves to an IfcDuration; otherwise undefined. */
-    timeLagSeconds?: number;
-    /** Original lag duration string (ISO 8601 like 'P1D'), if available. */
-    timeLagDuration?: string;
-}
-export interface WorkScheduleInfo {
-    expressId: number;
-    globalId: string;
-    kind: 'WorkSchedule' | 'WorkPlan';
-    name: string;
-    description?: string;
-    identification?: string;
-    creationDate?: string;
-    purpose?: string;
-    duration?: string;
-    startTime?: string;
-    finishTime?: string;
-    predefinedType?: string;
-    /** Root task globalIds directly assigned via IfcRelAssignsToControl. */
-    taskGlobalIds: string[];
-}
-export interface ScheduleExtraction {
-    workSchedules: WorkScheduleInfo[];
-    tasks: ScheduleTaskInfo[];
-    sequences: ScheduleSequenceInfo[];
-    /** True if we encountered any scheduling entity (useful for empty-state UI). */
-    hasSchedule: boolean;
-}
+export type { SequenceTypeEnum, TaskDurationType, ScheduleTaskTimeInfo, ScheduleTaskInfo, ScheduleSequenceInfo, WorkScheduleInfo, ScheduleExtraction, };
 /**
  * Extract all scheduling data from a parsed IFC store.
  *

package/dist/schedule-extractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schedule-extractor.d.ts","sourceRoot":"","sources":["../src/schedule-extractor.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schedule-extractor.d.ts","sourceRoot":"","sources":["../src/schedule-extractor.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAoB7D,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,qBAAqB,CAAC;AAQ7B,OAAO,EAAE,oBAAoB,EAAE,CAAC;AAKhC,YAAY,EACV,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,GACnB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,YAAY,GAAG,kBAAkB,CA4T/E"}