@bldrs-ai/conway 1.378.1185 → 1.381.1195

package/compiled/examples/browser-bundled.cjs

@@ -29,6 +29,566 @@ var import_process = require("process");
 var import_node_process = require("node:process");
 var readline = __toESM(require("node:readline"), 1);
 
+// compiled/src/version/version.js
+var versionString = "Conway v1.381.1195";
+
+// compiled/dependencies/conway-geom/interface/conway_geometry.js
+var wasmType = "";
+var dynamicImport = new Function("module", "return import(module)");
+
+// compiled/dependencies/conway-geom/interface/material_object.js
+var BlendMode;
+(function(BlendMode2) {
+  BlendMode2[BlendMode2["OPAQUE"] = 0] = "OPAQUE";
+  BlendMode2[BlendMode2["BLEND"] = 1] = "BLEND";
+  BlendMode2[BlendMode2["MASK"] = 2] = "MASK";
+})(BlendMode || (BlendMode = {}));
+
+// compiled/src/statistics/statistics.js
+var Statistics = class {
+  // Getters and setters
+  /**
+   *
+   * @return {string | undefined} - load status or undefined
+   */
+  getLoadStatus() {
+    return this.loadStatus;
+  }
+  /**
+   *
+   * @param value - load status
+   */
+  setLoadStatus(value) {
+    this.loadStatus = value;
+  }
+  /**
+   *
+   * @return {string | undefined} - project name or undefined
+   */
+  getProjectName() {
+    return this.projectName;
+  }
+  /**
+   *
+   * @param value - project name
+   */
+  setProjectName(value) {
+    this.projectName = value;
+  }
+  /**
+   *
+   * @return {string | undefined} - version or undefined
+   */
+  getVersion() {
+    return this.version;
+  }
+  /**
+   *
+   * @param value - version
+   */
+  setVersion(value) {
+    this.version = value;
+  }
+  /**
+   *
+   * @return {number | undefined} - parse time or undefined
+   */
+  getParseTime() {
+    return this.parseTime;
+  }
+  /**
+   *
+   * @param value - parse time
+   */
+  setParseTime(value) {
+    this.parseTime = value;
+  }
+  /**
+   *
+   * @return {number | undefined} - geometry parse time or undefined
+   */
+  getGeometryTime() {
+    return this.geometryTime;
+  }
+  /**
+   *
+   * @param value - geometry parse time
+   */
+  setGeometryTime(value) {
+    this.geometryTime = value;
+  }
+  /**
+   *
+   * @return {number | undefined} - total execution time or undefined
+   */
+  getTotalTime() {
+    return this.totalTime;
+  }
+  /**
+   *
+   * @param value - total execution time
+   */
+  setTotalTime(value) {
+    this.totalTime = value;
+  }
+  /**
+   *
+   * @return {number | undefined} - geometry memory or undefined
+   */
+  getGeometryMemory() {
+    return this.geometryMemory;
+  }
+  /**
+   *
+   * @param value - geometry memory
+   */
+  setGeometryMemory(value) {
+    this.geometryMemory = value;
+  }
+  /**
+   *
+   * @return {string | undefined} - preprocessor version or undefined
+   */
+  getPreprocessorVersion() {
+    return this.preprocessorVersion;
+  }
+  /**
+   *
+   * @param value - preprocessor version
+   */
+  setPreprocessorVersion(value) {
+    this.preprocessorVersion = value;
+  }
+  /**
+   *
+   * @return {string | undefined} - originating system or undefined
+   */
+  getOriginatingSystem() {
+    return this.originatingSystem;
+  }
+  /**
+   *
+   * @param value - originating system
+   */
+  setOriginatingSystem(value) {
+    this.originatingSystem = value;
+  }
+  /**
+   *
+   * @return {string | undefined} - memory statistics or undefined
+   */
+  getMemoryStatistics() {
+    return this.memoryStatistics;
+  }
+  /**
+   *
+   * @param value - memory statistics
+   */
+  setMemoryStatistics(value) {
+    this.memoryStatistics = value;
+  }
+  /**
+   *
+   * @return {number | undefined} - number of products extracted
+   */
+  getProductCount() {
+    return this.productCount;
+  }
+  /**
+   *
+   * @param value - number of products extracted
+   */
+  setProductCount(value) {
+    this.productCount = value;
+  }
+  /**
+   *
+   * @return {Map<string, number> | undefined} - geometry type breakdown
+   * (entity type name -> count of unique geometry definitions extracted)
+   */
+  getGeometryTypeCounts() {
+    return this.geometryTypeCounts;
+  }
+  /**
+   *
+   * @param value - geometry type breakdown map
+   */
+  setGeometryTypeCounts(value) {
+    this.geometryTypeCounts = value;
+  }
+  /**
+   * Format the geometry-type breakdown as a compact sorted list, e.g.
+   * "IFCEXTRUDEDAREASOLID×3421 IFCFACETEDBREP×212 (+3 more)".
+   *
+   * @param maxEntries - cap on listed types (rest summarized)
+   * @return {string | undefined} the formatted breakdown, if any
+   */
+  // eslint-disable-next-line no-magic-numbers
+  formatGeometryTypeCounts(maxEntries = 12) {
+    if (this.geometryTypeCounts === void 0 || this.geometryTypeCounts.size === 0) {
+      return void 0;
+    }
+    const sorted = Array.from(this.geometryTypeCounts.entries()).sort((leftEntry, rightEntry) => rightEntry[1] - leftEntry[1]);
+    const shown = sorted.slice(0, maxEntries).map(([name, count]) => `${name}\xD7${count}`).join(" ");
+    const remainder = sorted.length - maxEntries;
+    return remainder > 0 ? `${shown} (+${remainder} more)` : shown;
+  }
+  /**
+   * prints statistics
+   */
+  printStatistics() {
+    console.log(this.format());
+  }
+  /**
+   * Format the load-summary line (Logger routes this through its sink so
+   * the CLI can keep stdout clean — issue #301).
+   *
+   * @return {string} the single-line load summary
+   */
+  format() {
+    const date = /* @__PURE__ */ new Date();
+    const options = {
+      year: "numeric",
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      timeZone: "UTC"
+    };
+    const dateString = date.toLocaleDateString("en-US", options).replace(/,/g, "");
+    const versionMatch = versionString.match(/v(\d+\.\d+\.\d+)/);
+    let conwayVersionNumber;
+    if (versionMatch !== null) {
+      conwayVersionNumber = versionMatch[1];
+    } else {
+      conwayVersionNumber = "Version Not Found";
+    }
+    let versionStr;
+    if (this.version !== void 0) {
+      const match = this.version.match(/'([^']+)'/);
+      if (match) {
+        versionStr = match[1];
+      } else {
+        versionStr = "No match found";
+      }
+    } else {
+      versionStr = "Version not defined";
+    }
+    const products = this.productCount !== void 0 ? `Products: ${this.productCount}, ` : "";
+    const breakdown = this.formatGeometryTypeCounts();
+    const geometryTypes = breakdown !== void 0 ? `, Geometry Types: ${breakdown}` : "";
+    return `[${dateString}]: Load Status: ${this.loadStatus}, Project Name: ${this.projectName}, Version: ${versionStr}, Conway Version: ${conwayVersionNumber}-${wasmType}, Parse Time: ${this.parseTime} ms, Geometry Time: ${this.geometryTime} ms, Total Time: ${this.totalTime} ms, Geometry Memory: ${this.geometryMemory?.toFixed(3)} MB, ` + products + `Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}` + geometryTypes;
+  }
+};
+
+// compiled/src/logging/logger.js
+var LogLevel;
+(function(LogLevel2) {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARNING"] = 2] = "WARNING";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+  LogLevel2[LogLevel2["OFF"] = 4] = "OFF";
+})(LogLevel || (LogLevel = {}));
+var LOG_LEVEL_BY_NAME = {
+  "debug": LogLevel.DEBUG,
+  "info": LogLevel.INFO,
+  "warning": LogLevel.WARNING,
+  "error": LogLevel.ERROR
+};
+var defaultSink = (level, message) => {
+  switch (level) {
+    case "error":
+      console.error(message);
+      break;
+    case "warning":
+      console.warn(message);
+      break;
+    default:
+      console.log(message);
+  }
+};
+var Logger = class _Logger {
+  /**
+   * Detects environment and initializes wasm callbacks
+   */
+  static initializeWasmCallbacks() {
+    const environment = environment_default.environmentType;
+    if (environment === EnvironmentType.BROWSER) {
+      const globalScope = window;
+      globalScope.logInfo = _Logger.info;
+      globalScope.logWarning = _Logger.warning;
+      globalScope.logError = _Logger.error;
+    } else if (environment === EnvironmentType.NODE || environment === EnvironmentType.BOTH_FEATURES) {
+      const globalScope = global;
+      globalScope.logInfo = _Logger.info;
+      globalScope.logWarning = _Logger.warning;
+      globalScope.logError = _Logger.error;
+    }
+  }
+  /**
+   * Set the console-echo threshold. Embedders (e.g. Share) call this to
+   * quiet or expand conway's console output; the CLI maps -q/-v/-vv here.
+   *
+   * @param level - new threshold
+   */
+  static setLogLevel(level) {
+    _Logger.threshold = level;
+  }
+  /**
+   *
+   * @return {LogLevel} the current console-echo threshold
+   */
+  static getLogLevel() {
+    return _Logger.threshold;
+  }
+  /**
+   * Is a given level at or above the current threshold?
+   *
+   * @param level - level to test
+   * @return {boolean} true when messages at this level echo to the console
+   */
+  static isLevelEnabled(level) {
+    return level >= _Logger.threshold && _Logger.threshold !== LogLevel.OFF;
+  }
+  /**
+   * Replace the console sink (e.g. the CLI routes all echoes to stderr so
+   * stdout stays parseable). Pass undefined to restore the default.
+   *
+   * @param sink - replacement sink or undefined
+   */
+  static setSink(sink) {
+    _Logger.sink = sink ?? defaultSink;
+  }
+  /**
+   *
+   * @param message - log message
+   * @param level - log level
+   * @return {number} log index
+   */
+  static findLogIndex(message, level) {
+    return _Logger.logs.findIndex((log) => log.message === message && log.level === level);
+  }
+  /**
+   *
+   * @param level - log level
+   * @param message - log message
+   */
+  static log(level, message) {
+    const baseMessage = message.split(" expressID: ")[0];
+    const data = message.split(" expressID: ")[1];
+    const index = _Logger.findLogIndex(baseMessage, level);
+    let logEntry;
+    let firstOccurrence = false;
+    if (index >= 0) {
+      _Logger.logs[index].count += 1;
+      if (data !== void 0) {
+        _Logger.logs[index].expressIDs = _Logger.logs[index].expressIDs || /* @__PURE__ */ new Set();
+        _Logger.logs[index].expressIDs.add(data);
+      }
+      logEntry = _Logger.logs[index];
+    } else {
+      firstOccurrence = true;
+      logEntry = {
+        level,
+        message: baseMessage,
+        count: 1,
+        expressIDs: data ? /* @__PURE__ */ new Set([data]) : /* @__PURE__ */ new Set()
+      };
+      _Logger.logs.push(logEntry);
+    }
+    if (firstOccurrence && _Logger.isLevelEnabled(LOG_LEVEL_BY_NAME[level])) {
+      _Logger.sink(level, baseMessage);
+    }
+    _Logger.proxies.forEach((proxy) => proxy.log(logEntry));
+  }
+  /**
+   * Compresses similar logs to a single line
+   */
+  static compressLogs() {
+    const compressedLogs = [];
+    _Logger.logs.forEach((log) => {
+      const existingLog = compressedLogs.find((l) => l.message === log.message && l.level === log.level);
+      if (existingLog !== void 0) {
+        existingLog.count += log.count;
+        if (log.expressIDs !== void 0) {
+          log.expressIDs.forEach((d) => existingLog.expressIDs?.add(d));
+        }
+      } else {
+        compressedLogs.push({
+          ...log,
+          expressIDs: log.expressIDs ? new Set(log.expressIDs) : /* @__PURE__ */ new Set()
+        });
+      }
+    });
+    _Logger.logs = compressedLogs;
+  }
+  /**
+   *
+   * @param proxy - a log proxy
+   */
+  static addProxy(proxy) {
+    _Logger.proxies.push(proxy);
+  }
+  /**
+   * Remove a previously added proxy (no-op if absent).
+   *
+   * @param proxy - the proxy to remove
+   */
+  static removeProxy(proxy) {
+    const index = _Logger.proxies.indexOf(proxy);
+    if (index >= 0) {
+      _Logger.proxies.splice(index, 1);
+    }
+  }
+  /**
+   *
+   * @param message - log message
+   */
+  static debug(message) {
+    _Logger.log("debug", message);
+  }
+  /**
+   *
+   * @param message - log message
+   */
+  static info(message) {
+    _Logger.log("info", message);
+  }
+  /**
+   *
+   * @param modelID
+   * @return {Statistics | undefined}
+   */
+  static getStatistics(modelID) {
+    return this.statistics.get(modelID);
+  }
+  /**
+   * Create the statistics for a model ID.
+   *
+   * @param modelID The model ID to create statistics for
+   *
+   * @return {Statistics} The created statistics object.
+   */
+  static createStatistics(modelID) {
+    const statistics = new Statistics();
+    this.statistics.set(modelID, statistics);
+    return statistics;
+  }
+  /**
+   *
+   * @param modelID
+   */
+  static printStatistics(modelID) {
+    if (!_Logger.isLevelEnabled(LogLevel.INFO)) {
+      return;
+    }
+    const statistics_ = this.statistics.get(modelID);
+    if (statistics_ !== void 0) {
+      _Logger.sink("info", statistics_.format());
+    } else {
+      _Logger.error(`No statistics for modelID: ${modelID}`);
+    }
+  }
+  /**
+   * Compresses the logs if they haven't been compressed,
+   * then returns a list of just the errors.
+   *
+   * @return {LogEntry[]} The errors.
+   */
+  static getErrors() {
+    _Logger.compressLogs();
+    return this.logs.filter((where) => where.level === "error");
+  }
+  /**
+   *
+   * @param message - log message
+   */
+  static warning(message) {
+    _Logger.log("warning", message);
+  }
+  /**
+   *
+   * @param message - log message
+   */
+  static error(message) {
+    _Logger.log("error", message);
+  }
+  /**
+   *
+   * @return {LogEntry[]} - list of logs
+   */
+  static getLogs() {
+    return _Logger.logs;
+  }
+  /**
+   * Display the deduplicated log buffer in a table.
+   *
+   * Gated behind the DEBUG threshold by default — a clean load should leave
+   * a quiet console (issue #301); pass force for explicit dumps (CLI -v).
+   *
+   * @param force - dump regardless of the current threshold
+   */
+  static displayLogs(force = false) {
+    if (!force && !_Logger.isLevelEnabled(LogLevel.DEBUG)) {
+      return;
+    }
+    _Logger.compressLogs();
+    console.table(_Logger.logs);
+  }
+  /**
+   * clear logs
+   */
+  static clearLogs() {
+    _Logger.logs = [];
+  }
+};
+Logger.logs = [];
+Logger.proxies = [];
+Logger.statistics = /* @__PURE__ */ new Map();
+Logger.threshold = LogLevel.INFO;
+Logger.sink = defaultSink;
+var logger_default = Logger;
+
+// compiled/src/utilities/environment.js
+var EnvironmentType;
+(function(EnvironmentType2) {
+  EnvironmentType2[EnvironmentType2["BROWSER"] = 0] = "BROWSER";
+  EnvironmentType2[EnvironmentType2["NODE"] = 1] = "NODE";
+  EnvironmentType2[EnvironmentType2["BOTH_FEATURES"] = 2] = "BOTH_FEATURES";
+  EnvironmentType2[EnvironmentType2["UNKNOWN"] = 3] = "UNKNOWN";
+})(EnvironmentType || (EnvironmentType = {}));
+var Environment = class {
+  /**
+   * determines the runtime environment
+   */
+  static checkEnvironment() {
+    const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+    const isNode = typeof global !== "undefined" && typeof global.process !== "undefined" && global.process.versions && global.process.versions.node;
+    if (isBrowser && isNode) {
+      logger_default.info("This environment has features of both Node.js and a web browser.");
+      this.environmentType = EnvironmentType.BOTH_FEATURES;
+    } else if (isNode) {
+      this.environmentType = EnvironmentType.NODE;
+    } else if (isBrowser) {
+      this.environmentType = EnvironmentType.BROWSER;
+    } else {
+      logger_default.info("ENVIRONMENT === unknown");
+      this.environmentType = EnvironmentType.UNKNOWN;
+    }
+  }
+};
+Environment.environmentType = EnvironmentType.UNKNOWN;
+var environment_default = Environment;
+
+// compiled/src/core/progress.js
+function yieldToEventLoop() {
+  return new Promise((resolve) => {
+    setTimeout(resolve, 0);
+  });
+}
+
 // compiled/src/parsing/token_parsing.js
 var encoder = new TextEncoder();
 function encodeToken(from) {
@@ -1734,6 +2294,8 @@ var binaryParser = hex_parser_default.Instance.step;
 var attributeMap = step_attribute_map_default.Instance.get;
 var commentParser2 = step_comment_parser_default.Instance.match;
 var stringParser2 = step_string_parser_default.Instance.match;
+var PARSE_PROGRESS_ELEMENT_MASK = 4095;
+var DEFAULT_PARSE_YIELD_INTERVAL_MS = 50;
 var StepHeaderParser = class _StepHeaderParser {
   /**
    * Get the singleton static instance of this.
@@ -1956,12 +2518,64 @@ var StepParser = class extends StepHeaderParser {
     return vtableBuilder.complete(cursor);
   }
   /**
-   * Parse the data block of a step file, indexing it.,
+   * Parse the data block of a step file, indexing it.
+   *
+   * Synchronous driver over parseDataBlockIncremental — see
+   * parseDataBlockAsync for the cooperative (repaint-friendly) variant.
+   *
+   * @param input The input parsing buffer, in the data section.
+   * @param onProgress Optional byte-cursor progress callback, invoked
+   * roughly every PARSE_PROGRESS_ELEMENT_MASK + 1 elements.
+   * @return {BlockParseResult} The parsing result, including the index and result enum.
+   */
+  parseDataBlock(input2, onProgress) {
+    const parser211 = this.parseDataBlockIncremental(input2);
+    while (true) {
+      const next = parser211.next();
+      if (next.done === true) {
+        return next.value;
+      }
+      onProgress?.(next.value);
+    }
+  }
+  /**
+   * Cooperative variant of parseDataBlock: identical parse (same generator
+   * body), but periodically awaits a macrotask so the event loop can run —
+   * browsers repaint progress UI, watchdog timers fire, and the tab is not
+   * flagged as stalled during a large parse. Issue #301 §2.
    *
    * @param input The input parsing buffer, in the data section.
+   * @param onProgress Optional byte-cursor progress callback.
+   * @param yieldIntervalMs Minimum ms between event-loop yields.
+   * @return {Promise<BlockParseResult>} The parsing result, including the
+   * index and result enum.
+   */
+  async parseDataBlockAsync(input2, onProgress, yieldIntervalMs = DEFAULT_PARSE_YIELD_INTERVAL_MS) {
+    const parser211 = this.parseDataBlockIncremental(input2);
+    let lastYield = Date.now();
+    while (true) {
+      const next = parser211.next();
+      if (next.done === true) {
+        return next.value;
+      }
+      onProgress?.(next.value);
+      if (Date.now() - lastYield >= yieldIntervalMs) {
+        await yieldToEventLoop();
+        lastYield = Date.now();
+      }
+    }
+  }
+  /**
+   * Parse the data block of a step file, indexing it, suspending with the
+   * current byte cursor every PARSE_PROGRESS_ELEMENT_MASK + 1 elements so
+   * drivers can report progress (and optionally yield to the event loop)
+   * without the loop body diverging between sync and async paths.
+   *
+   * @param input The input parsing buffer, in the data section.
+   * @yields {number} The current byte cursor within the input buffer.
    * @return {BlockParseResult} The parsing result, including the index and result enum.
    */
-  parseDataBlock(input2) {
+  *parseDataBlockIncremental(input2) {
     const indexResult = { elements: [] };
     const match = input2.match;
     const comment = () => match(commentParser2);
@@ -2097,7 +2711,11 @@ var StepParser = class extends StepHeaderParser {
         });
       }
     };
+    let parsedElementCount = 0;
     while (input2.unfinished) {
+      if ((++parsedElementCount & PARSE_PROGRESS_ELEMENT_MASK) === 0) {
+        yield input2.cursor;
+      }
       if (!charws(HASH2)) {
         if (tokenws(END_SECTION)) {
           return parseResult2(ParseResult.COMPLETE);
@@ -4820,6 +5438,20 @@ var StepModelBase = class {
     const distinctTypes = types.length === 1 ? types[0].query : new Set(types.flatMap((type) => type.query));
     return this.from(this.typeIndex.cursor(...distinctTypes), true);
   }
+  /**
+   * Count entities of a set of types (including sub-types) without iterating
+   * or materializing them — reads the type index's prefix sums, so it's cheap
+   * enough to call up front for progress totals (see core/progress.ts).
+   * Multi-mapped elements can be counted once per matching mapping, so treat
+   * this as an upper bound; see MultiIndexSet.count.
+   *
+   * @param types The list of types to count.
+   * @return {number} The number of matching entities.
+   */
+  typeCount(...types) {
+    const distinctTypes = types.length === 1 ? types[0].query : new Set(types.flatMap((type) => type.query));
+    return this.typeIndex.count(...distinctTypes);
+  }
   /**
    * Get the non empty type IDs for this.
    *
@@ -69269,6 +69901,12 @@ var SingleIndexSetCursor = class _SingleIndexSetCursor {
 };
 
 // compiled/src/indexing/multi_index_set.js
+function popCount32(value) {
+  let result = value - (value >> 1 & 1431655765);
+  result = (result & 858993459) + (result >> 2 & 858993459);
+  result = result + (result >> 4) & 252645135;
+  return result * 16843009 >> 24;
+}
 var MultiIndexSet = class {
   /**
    * Construct this with a prefix sum table and matching elements table.
@@ -69314,6 +69952,34 @@ var MultiIndexSet = class {
     const indexEnd = prefixSum[indexType + 1] * 2;
     return indexSetPointQuery32(localID, this.elements_, indexOffset, indexEnd);
   }
+  /**
+   * Count of items for a set of types without materializing entities —
+   * popcounts the packed one-hot blocks per type (the prefix sums index
+   * 32-element blocks, not items), so it's O(blocks), thousands of times
+   * cheaper than iterating a cursor. Per-type ranges are disjoint, but an
+   * element multi-mapped under several of the queried types counts once per
+   * mapping (matching what a cursor union would visit), so treat multi-type
+   * counts as an upper bound (fine for progress totals, its motivating use).
+   *
+   * @param indexTypes The list of types to count.
+   * @return {number} The summed count for the given types.
+   */
+  count(...indexTypes) {
+    const prefixSum = this.prefixSumTable_;
+    const elements = this.elements_;
+    let result = 0;
+    for (const indexType of indexTypes) {
+      if (indexType >= prefixSum.length - 1) {
+        continue;
+      }
+      const blockStart = prefixSum[indexType] * 2;
+      const blockEnd = prefixSum[indexType + 1] * 2;
+      for (let where = blockStart; where < blockEnd; where += 2) {
+        result += popCount32(elements[where + 1]);
+      }
+    }
+    return result;
+  }
   /**
    * Get a cursor that lets you iterate over the union of the sets of multiple indices.
    *
@@ -69411,18 +70077,6 @@ var CanonicalMeshType;
   CanonicalMeshType2[CanonicalMeshType2["BUFFER_GEOMETRY"] = 0] = "BUFFER_GEOMETRY";
 })(CanonicalMeshType || (CanonicalMeshType = {}));
 
-// compiled/dependencies/conway-geom/interface/conway_geometry.js
-var wasmType = "";
-var dynamicImport = new Function("module", "return import(module)");
-
-// compiled/dependencies/conway-geom/interface/material_object.js
-var BlendMode;
-(function(BlendMode2) {
-  BlendMode2[BlendMode2["OPAQUE"] = 0] = "OPAQUE";
-  BlendMode2[BlendMode2["BLEND"] = 1] = "BLEND";
-  BlendMode2[BlendMode2["MASK"] = 2] = "MASK";
-})(BlendMode || (BlendMode = {}));
-
 // compiled/src/core/canonical_material.js
 var ROUGNESS_CONVERSION_FACTOR = 2;
 function roughnessToExponent(roughness) {
@@ -70035,403 +70689,30 @@ var IfcStepParser = class extends StepParser {
    * Parse data to the model
    *
    * @param input The parsing buffer, set to user data, to read.
+   * @param onProgress Optional byte-cursor progress callback for the data parse.
    * @return {[ParseResult, IfcStepModel | undefined]} The parse result as well as the model,
    * if it can be extracted.
    */
-  parseDataToModel(input2) {
-    const [itemIndex, parseResult2] = this.parseDataBlock(input2);
+  parseDataToModel(input2, onProgress) {
+    const [itemIndex, parseResult2] = this.parseDataBlock(input2, onProgress);
     return [parseResult2, new IfcStepModel(input2.buffer, itemIndex.elements)];
   }
-};
-IfcStepParser.Instance = new IfcStepParser();
-var ifc_step_parser_default = IfcStepParser;
-
-// compiled/src/version/version.js
-var versionString = "Conway Web-Ifc Shim v1.378.1185";
-
-// compiled/src/statistics/statistics.js
-var Statistics = class {
-  // Getters and setters
-  /**
-   *
-   * @return {string | undefined} - load status or undefined
-   */
-  getLoadStatus() {
-    return this.loadStatus;
-  }
-  /**
-   *
-   * @param value - load status
-   */
-  setLoadStatus(value) {
-    this.loadStatus = value;
-  }
-  /**
-   *
-   * @return {string | undefined} - project name or undefined
-   */
-  getProjectName() {
-    return this.projectName;
-  }
-  /**
-   *
-   * @param value - project name
-   */
-  setProjectName(value) {
-    this.projectName = value;
-  }
-  /**
-   *
-   * @return {string | undefined} - version or undefined
-   */
-  getVersion() {
-    return this.version;
-  }
-  /**
-   *
-   * @param value - version
-   */
-  setVersion(value) {
-    this.version = value;
-  }
-  /**
-   *
-   * @return {number | undefined} - parse time or undefined
-   */
-  getParseTime() {
-    return this.parseTime;
-  }
-  /**
-   *
-   * @param value - parse time
-   */
-  setParseTime(value) {
-    this.parseTime = value;
-  }
-  /**
-   *
-   * @return {number | undefined} - geometry parse time or undefined
-   */
-  getGeometryTime() {
-    return this.geometryTime;
-  }
-  /**
-   *
-   * @param value - geometry parse time
-   */
-  setGeometryTime(value) {
-    this.geometryTime = value;
-  }
-  /**
-   *
-   * @return {number | undefined} - total execution time or undefined
-   */
-  getTotalTime() {
-    return this.totalTime;
-  }
-  /**
-   *
-   * @param value - total execution time
-   */
-  setTotalTime(value) {
-    this.totalTime = value;
-  }
-  /**
-   *
-   * @return {number | undefined} - geometry memory or undefined
-   */
-  getGeometryMemory() {
-    return this.geometryMemory;
-  }
-  /**
-   *
-   * @param value - geometry memory
-   */
-  setGeometryMemory(value) {
-    this.geometryMemory = value;
-  }
-  /**
-   *
-   * @return {string | undefined} - preprocessor version or undefined
-   */
-  getPreprocessorVersion() {
-    return this.preprocessorVersion;
-  }
-  /**
-   *
-   * @param value - preprocessor version
-   */
-  setPreprocessorVersion(value) {
-    this.preprocessorVersion = value;
-  }
-  /**
-   *
-   * @return {string | undefined} - originating system or undefined
-   */
-  getOriginatingSystem() {
-    return this.originatingSystem;
-  }
-  /**
-   *
-   * @param value - originating system
-   */
-  setOriginatingSystem(value) {
-    this.originatingSystem = value;
-  }
-  /**
-   *
-   * @return {string | undefined} - memory statistics or undefined
-   */
-  getMemoryStatistics() {
-    return this.memoryStatistics;
-  }
-  /**
-   *
-   * @param value - memory statistics
-   */
-  setMemoryStatistics(value) {
-    this.memoryStatistics = value;
-  }
-  /**
-   * prints statistics
-   */
-  printStatistics() {
-    const date = /* @__PURE__ */ new Date();
-    const options = {
-      year: "numeric",
-      month: "short",
-      day: "numeric",
-      hour: "2-digit",
-      minute: "2-digit",
-      second: "2-digit",
-      timeZone: "UTC"
-    };
-    const dateString = date.toLocaleDateString("en-US", options).replace(/,/g, "");
-    const versionMatch = versionString.match(/v(\d+\.\d+\.\d+)/);
-    let conwayVersionNumber;
-    if (versionMatch !== null) {
-      conwayVersionNumber = versionMatch[1];
-    } else {
-      conwayVersionNumber = "Version Not Found";
-    }
-    let versionStr;
-    if (this.version !== void 0) {
-      const match = this.version.match(/'([^']+)'/);
-      if (match) {
-        versionStr = match[1];
-      } else {
-        versionStr = "No match found";
-      }
-    } else {
-      versionStr = "Version not defined";
-    }
-    console.log(`[${dateString}]: Load Status: ${this.loadStatus}, Project Name: ${this.projectName}, Version: ${versionStr}, Conway Version: ${conwayVersionNumber}-${wasmType}, Parse Time: ${this.parseTime} ms, Geometry Time: ${this.geometryTime} ms, Total Time: ${this.totalTime} ms, Geometry Memory: ${this.geometryMemory?.toFixed(3)} MB, Memory Statistics: ${this.memoryStatistics}, Preprocessor Version: ${this.preprocessorVersion}, Originating System: ${this.originatingSystem}`);
-  }
-};
-
-// compiled/src/utilities/environment.js
-var EnvironmentType;
-(function(EnvironmentType2) {
-  EnvironmentType2[EnvironmentType2["BROWSER"] = 0] = "BROWSER";
-  EnvironmentType2[EnvironmentType2["NODE"] = 1] = "NODE";
-  EnvironmentType2[EnvironmentType2["BOTH_FEATURES"] = 2] = "BOTH_FEATURES";
-  EnvironmentType2[EnvironmentType2["UNKNOWN"] = 3] = "UNKNOWN";
-})(EnvironmentType || (EnvironmentType = {}));
-var Environment = class {
-  /**
-   * determines the runtime environment
-   */
-  static checkEnvironment() {
-    const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
-    const isNode = typeof global !== "undefined" && typeof global.process !== "undefined" && global.process.versions && global.process.versions.node;
-    if (isBrowser && isNode) {
-      logger_default.info("This environment has features of both Node.js and a web browser.");
-      this.environmentType = EnvironmentType.BOTH_FEATURES;
-    } else if (isNode) {
-      this.environmentType = EnvironmentType.NODE;
-    } else if (isBrowser) {
-      this.environmentType = EnvironmentType.BROWSER;
-    } else {
-      logger_default.info("ENVIRONMENT === unknown");
-      this.environmentType = EnvironmentType.UNKNOWN;
-    }
-  }
-};
-Environment.environmentType = EnvironmentType.UNKNOWN;
-var environment_default = Environment;
-
-// compiled/src/logging/logger.js
-var Logger = class _Logger {
-  /**
-   * Detects environment and initializes wasm callbacks
-   */
-  static initializeWasmCallbacks() {
-    const environment = environment_default.environmentType;
-    if (environment === EnvironmentType.BROWSER) {
-      const globalScope = window;
-      globalScope.logInfo = _Logger.info;
-      globalScope.logWarning = _Logger.warning;
-      globalScope.logError = _Logger.error;
-    } else if (environment === EnvironmentType.NODE || environment === EnvironmentType.BOTH_FEATURES) {
-      const globalScope = global;
-      globalScope.logInfo = _Logger.info;
-      globalScope.logWarning = _Logger.warning;
-      globalScope.logError = _Logger.error;
-    }
-  }
-  /**
-   *
-   * @param message - log message
-   * @param level - log level
-   * @return {number} log index
-   */
-  static findLogIndex(message, level) {
-    return _Logger.logs.findIndex((log) => log.message === message && log.level === level);
-  }
-  /**
-   *
-   * @param level - log level
-   * @param message - log message
-   */
-  static log(level, message) {
-    const baseMessage = message.split(" expressID: ")[0];
-    const data = message.split(" expressID: ")[1];
-    const index = _Logger.findLogIndex(baseMessage, level);
-    let logEntry;
-    if (index >= 0) {
-      _Logger.logs[index].count += 1;
-      if (data !== void 0) {
-        _Logger.logs[index].expressIDs = _Logger.logs[index].expressIDs || /* @__PURE__ */ new Set();
-        _Logger.logs[index].expressIDs.add(data);
-      }
-      logEntry = _Logger.logs[index];
-    } else {
-      logEntry = {
-        level,
-        message: baseMessage,
-        count: 1,
-        expressIDs: data ? /* @__PURE__ */ new Set([data]) : /* @__PURE__ */ new Set()
-      };
-      _Logger.logs.push(logEntry);
-    }
-    _Logger.proxies.forEach((proxy) => proxy.log(logEntry));
-  }
-  /**
-   * Compresses similar logs to a single line
-   */
-  static compressLogs() {
-    const compressedLogs = [];
-    _Logger.logs.forEach((log) => {
-      const existingLog = compressedLogs.find((l) => l.message === log.message && l.level === log.level);
-      if (existingLog !== void 0) {
-        existingLog.count += log.count;
-        if (log.expressIDs !== void 0) {
-          log.expressIDs.forEach((d) => existingLog.expressIDs?.add(d));
-        }
-      } else {
-        compressedLogs.push({
-          ...log,
-          expressIDs: log.expressIDs ? new Set(log.expressIDs) : /* @__PURE__ */ new Set()
-        });
-      }
-    });
-    _Logger.logs = compressedLogs;
-  }
-  /**
-   *
-   * @param proxy - a log proxy
-   */
-  static addProxy(proxy) {
-    _Logger.proxies.push(proxy);
-  }
-  /**
-   *
-   * @param message - log message
-   */
-  static info(message) {
-    _Logger.log("info", message);
-  }
-  /**
-   *
-   * @param modelID
-   * @return {Statistics | undefined}
-   */
-  static getStatistics(modelID) {
-    return this.statistics.get(modelID);
-  }
-  /**
-   * Create the statistics for a model ID.
-   *
-   * @param modelID The model ID to create statistics for
-   *
-   * @return {Statistics} The created statistics object.
-   */
-  static createStatistics(modelID) {
-    const statistics = new Statistics();
-    this.statistics.set(modelID, statistics);
-    return statistics;
-  }
-  /**
-   *
-   * @param modelID
-   */
-  static printStatistics(modelID) {
-    const statistics_ = this.statistics.get(modelID);
-    if (statistics_ !== void 0) {
-      statistics_.printStatistics();
-    } else {
-      _Logger.error(`No statistics for modelID: ${modelID}`);
-    }
-  }
-  /**
-   * Compresses the logs if they haven't been compressed,
-   * then returns a list of just the errors.
-   *
-   * @return {LogEntry[]} The errors.
-   */
-  static getErrors() {
-    _Logger.compressLogs();
-    return this.logs.filter((where) => where.level === "error");
-  }
   /**
+   * Cooperative variant of parseDataToModel — periodically yields to the
+   * event loop mid-parse (see StepParser.parseDataBlockAsync, issue #301 §2).
    *
-   * @param message - log message
-   */
-  static warning(message) {
-    _Logger.log("warning", message);
-  }
-  /**
-   *
-   * @param message - log message
-   */
-  static error(message) {
-    _Logger.log("error", message);
-  }
-  /**
-   *
-   * @return {LogEntry[]} - list of logs
-   */
-  static getLogs() {
-    return _Logger.logs;
-  }
-  /**
-   * display logs in a table
-   */
-  static displayLogs() {
-    _Logger.compressLogs();
-    console.table(_Logger.logs);
-  }
-  /**
-   * clear logs
+   * @param input The parsing buffer, set to user data, to read.
+   * @param onProgress Optional byte-cursor progress callback for the data parse.
+   * @return {Promise<[ParseResult, IfcStepModel | undefined]>} The parse result as well
+   * as the model, if it can be extracted.
    */
-  static clearLogs() {
-    _Logger.logs = [];
+  async parseDataToModelAsync(input2, onProgress) {
+    const [itemIndex, parseResult2] = await this.parseDataBlockAsync(input2, onProgress);
+    return [parseResult2, new IfcStepModel(input2.buffer, itemIndex.elements)];
   }
 };
-Logger.logs = [];
-Logger.proxies = [];
-Logger.statistics = /* @__PURE__ */ new Map();
-var logger_default = Logger;
+IfcStepParser.Instance = new IfcStepParser();
+var ifc_step_parser_default = IfcStepParser;
 
 // compiled/examples/browser.js
 environment_default.checkEnvironment();