@ifc-lite/parser 5.2.0 → 6.1.0

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,40 @@ 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.
+      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) {
+          // Unbalanced but 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8OrC,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"}

package/dist/schedule-extractor.js

@@ -2,17 +2,25 @@
  * 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/. */
 /**
- * Schedule (4D) extractor — parses IfcTask, IfcTaskTime, IfcRelSequence,
+ * Schedule (4D) extractor — walks IfcTask, IfcTaskTime, IfcRelSequence,
  * IfcRelAssignsToProcess, IfcRelAssignsToControl, IfcRelNests, IfcWorkSchedule,
- * IfcWorkPlan, IfcLagTime from a parsed IfcDataStore and returns a normalized
- * ScheduleExtraction that the viewer can drive a Gantt/4D animation from.
+ * IfcWorkPlan, IfcLagTime entities in a parsed IfcDataStore and assembles a
+ * normalized ScheduleExtraction that the viewer can drive a Gantt/4D
+ * animation from.
  *
  * Handles IFC4 / IFC4X3. IFC2X3 has a different IfcTask layout (no TaskTime
  * attribute, ScheduleStart/ScheduleFinish/TaskOwner instead) and is supported
  * with best-effort degradation.
+ *
+ * STEP attribute-index layouts, the record types themselves, and the small
+ * pure/single-entity helpers (`asString` et al., `extractTaskTime`,
+ * `extractLagTimeSeconds`) live in `schedule-types.ts` — this file owns only
+ * the cross-entity orchestration (the multi-pass walk below that wires those
+ * records together via their IFC relationships).
  */
 import { EntityExtractor } from './entity-extractor.js';
 import { parseIso8601Duration } from './iso8601-duration.js';
+import { TASK_ATTR, TASK_ATTR_2X3, REL_SEQUENCE_ATTR, REL_ASSIGNS_TO_PROCESS_ATTR, REL_ASSIGNS_TO_CONTROL_ATTR, REL_NESTS_ATTR, WORK_SCHEDULE_ATTR, WORK_PLAN_ATTR, asString, asNumber, asBoolean, asEnum, asRef, asRefList, sequenceTypeFromString, extractTaskTime, extractLagTimeSeconds, } from './schedule-types.js';
 // Re-exported for backward compatibility — this is where consumers
 // (including this package's own public surface, see index.ts) have always
 // imported it from. The implementation itself now lives in
@@ -20,222 +28,6 @@ import { parseIso8601Duration } from './iso8601-duration.js';
 // `secondsToIso8601Duration`, so the round-trip property between the two is
 // visible in one place.
 export { parseIso8601Duration };
-/** IFC4 STEP attribute indices for IfcTask. */
-const TASK_ATTR = {
-    GlobalId: 0,
-    Name: 2,
-    Description: 3,
-    ObjectType: 4,
-    Identification: 5,
-    LongDescription: 6,
-    Status: 7,
-    WorkMethod: 8,
-    IsMilestone: 9,
-    Priority: 10,
-    TaskTime: 11,
-    PredefinedType: 12,
-};
-/**
- * IFC2X3 IfcTask layout — the attributes IfcTask itself adds over IfcObject
- * (TaskId, Status, WorkMethod, IsMilestone, Priority). IFC2X3 schedule times
- * live on `IfcScheduleTimeControl` and link to IfcTask via `IfcRelAssignsTasks`
- * — we don't resolve those here yet; best-effort 2x3 models only surface task
- * metadata without dates.
- */
-const TASK_ATTR_2X3 = {
-    GlobalId: 0,
-    Name: 2,
-    Description: 3,
-    ObjectType: 4,
-    TaskId: 5,
-    Status: 6,
-    WorkMethod: 7,
-    IsMilestone: 8,
-    Priority: 9,
-};
-const TASK_TIME_ATTR = {
-    Name: 0,
-    DurationType: 3,
-    ScheduleDuration: 4,
-    ScheduleStart: 5,
-    ScheduleFinish: 6,
-    EarlyStart: 7,
-    EarlyFinish: 8,
-    LateStart: 9,
-    LateFinish: 10,
-    FreeFloat: 11,
-    TotalFloat: 12,
-    IsCritical: 13,
-    StatusTime: 14,
-    ActualDuration: 15,
-    ActualStart: 16,
-    ActualFinish: 17,
-    RemainingTime: 18,
-    Completion: 19,
-};
-const REL_SEQUENCE_ATTR = {
-    GlobalId: 0,
-    RelatingProcess: 4,
-    RelatedProcess: 5,
-    TimeLag: 6,
-    SequenceType: 7,
-    UserDefinedSequenceType: 8,
-};
-const REL_ASSIGNS_TO_PROCESS_ATTR = {
-    RelatedObjects: 4,
-    RelatingProcess: 6,
-};
-const REL_ASSIGNS_TO_CONTROL_ATTR = {
-    RelatedObjects: 4,
-    RelatingControl: 6,
-};
-const REL_NESTS_ATTR = {
-    RelatingObject: 4,
-    RelatedObjects: 5,
-};
-const WORK_SCHEDULE_ATTR = {
-    GlobalId: 0,
-    Name: 2,
-    Description: 3,
-    ObjectType: 4,
-    Identification: 5,
-    CreationDate: 6,
-    Purpose: 8,
-    Duration: 9,
-    TotalFloat: 10,
-    StartTime: 11,
-    FinishTime: 12,
-    PredefinedType: 13,
-};
-const WORK_PLAN_ATTR = WORK_SCHEDULE_ATTR;
-const LAG_TIME_ATTR = {
-    LagValue: 3,
-    DurationType: 4,
-};
-function asString(v) {
-    if (typeof v === 'string' && v.length > 0)
-        return v;
-    return undefined;
-}
-function asNumber(v) {
-    if (typeof v === 'number' && Number.isFinite(v))
-        return v;
-    return undefined;
-}
-function asBoolean(v) {
-    if (typeof v === 'boolean')
-        return v;
-    // STEP booleans are typically stored as '.T.' / '.F.' after parsing
-    if (typeof v === 'string') {
-        if (v === '.T.' || v === 'T')
-            return true;
-        if (v === '.F.' || v === 'F')
-            return false;
-    }
-    return undefined;
-}
-function asEnum(v) {
-    if (typeof v !== 'string' || v.length === 0)
-        return undefined;
-    // STEP enum looks like .PLANNED.
-    const match = v.match(/^\.([A-Z_]+)\.$/);
-    return match ? match[1] : undefined;
-}
-function asRef(v) {
-    if (typeof v === 'number' && Number.isInteger(v) && v > 0)
-        return v;
-    return undefined;
-}
-function asRefList(v) {
-    if (!Array.isArray(v))
-        return [];
-    const out = [];
-    for (const x of v) {
-        const id = asRef(x);
-        if (id !== undefined)
-            out.push(id);
-    }
-    return out;
-}
-function sequenceTypeFromString(s) {
-    switch (s) {
-        case 'START_START':
-        case 'START_FINISH':
-        case 'FINISH_START':
-        case 'FINISH_FINISH':
-        case 'USERDEFINED':
-        case 'NOTDEFINED':
-            return s;
-        default:
-            return 'FINISH_START';
-    }
-}
-function durationTypeFromString(s) {
-    switch (s) {
-        case 'WORKTIME':
-        case 'ELAPSEDTIME':
-        case 'NOTDEFINED':
-            return s;
-        default:
-            return undefined;
-    }
-}
-function extractTaskTime(extractor, store, taskTimeId) {
-    const ref = store.entityIndex.byId.get(taskTimeId);
-    if (!ref)
-        return undefined;
-    const entity = extractor.extractEntity(ref);
-    if (!entity)
-        return undefined;
-    const t = entity.type.toUpperCase();
-    if (t !== 'IFCTASKTIME' && t !== 'IFCTASKTIMERECURRING')
-        return undefined;
-    const a = entity.attributes || [];
-    return {
-        durationType: durationTypeFromString(asEnum(a[TASK_TIME_ATTR.DurationType])),
-        scheduleDuration: asString(a[TASK_TIME_ATTR.ScheduleDuration]),
-        scheduleStart: asString(a[TASK_TIME_ATTR.ScheduleStart]),
-        scheduleFinish: asString(a[TASK_TIME_ATTR.ScheduleFinish]),
-        earlyStart: asString(a[TASK_TIME_ATTR.EarlyStart]),
-        earlyFinish: asString(a[TASK_TIME_ATTR.EarlyFinish]),
-        lateStart: asString(a[TASK_TIME_ATTR.LateStart]),
-        lateFinish: asString(a[TASK_TIME_ATTR.LateFinish]),
-        freeFloat: asString(a[TASK_TIME_ATTR.FreeFloat]),
-        totalFloat: asString(a[TASK_TIME_ATTR.TotalFloat]),
-        isCritical: asBoolean(a[TASK_TIME_ATTR.IsCritical]),
-        statusTime: asString(a[TASK_TIME_ATTR.StatusTime]),
-        actualDuration: asString(a[TASK_TIME_ATTR.ActualDuration]),
-        actualStart: asString(a[TASK_TIME_ATTR.ActualStart]),
-        actualFinish: asString(a[TASK_TIME_ATTR.ActualFinish]),
-        remainingTime: asString(a[TASK_TIME_ATTR.RemainingTime]),
-        completion: asNumber(a[TASK_TIME_ATTR.Completion]),
-    };
-}
-function extractLagTimeSeconds(extractor, store, lagId) {
-    const ref = store.entityIndex.byId.get(lagId);
-    if (!ref)
-        return {};
-    const entity = extractor.extractEntity(ref);
-    if (!entity)
-        return {};
-    if (entity.type.toUpperCase() !== 'IFCLAGTIME')
-        return {};
-    const a = entity.attributes || [];
-    const lagValue = a[LAG_TIME_ATTR.LagValue];
-    // lagValue is an IfcTimeOrRatioSelect — either a typed wrapper like
-    // ['IFCDURATION', 'P1D'] or a direct ratio number.
-    if (Array.isArray(lagValue) && lagValue.length === 2) {
-        const typeName = String(lagValue[0]).toUpperCase();
-        const inner = lagValue[1];
-        if (typeName === 'IFCDURATION' && typeof inner === 'string') {
-            return { seconds: parseIso8601Duration(inner), duration: inner };
-        }
-    }
-    else if (typeof lagValue === 'string') {
-        return { seconds: parseIso8601Duration(lagValue), duration: lagValue };
-    }
-    return {};
-}
 /**
  * Extract all scheduling data from a parsed IFC store.
  *
@@ -344,18 +136,27 @@ export function extractScheduleOnDemand(store) {
             continue;
         const parentTask = taskByExpressId.get(parent);
         if (!parentTask)
-            continue; // nesting over non-task entities — ignore
+            continue; // parent isn't a task — task/subtask nesting only; IfcWorkPlan -> IfcWorkSchedule nesting is handled in a separate pass below, once schedules are extracted
         for (const childId of children) {
             const childTask = taskByExpressId.get(childId);
             if (!childTask)
                 continue;
-            parentTask.childGlobalIds.push(childTask.globalId);
+            // A source file may repeat the relation; guard as Pass 4b/5 do below.
+            if (!parentTask.childGlobalIds.includes(childTask.globalId)) {
+                parentTask.childGlobalIds.push(childTask.globalId);
+            }
             if (!childTask.parentGlobalId) {
                 childTask.parentGlobalId = parentTask.globalId;
             }
         }
     }
     // Pass 3: resolve IfcRelAssignsToProcess — products assigned to tasks.
+    // NOT deduped, deliberately: IfcRelAssignsToProcess carries a
+    // QuantityInProcess attribute (not extracted here, but real in the
+    // schema), so the same product can legitimately repeat across relations
+    // to the same task as separate quantity assignments. Unlike the identity
+    // lists elsewhere in this file, this pair is a multiset — dedup would
+    // silently drop a legitimate repeated assignment.
     for (const relId of relAssignsProcessIds) {
         const ref = store.entityIndex.byId.get(relId);
         if (!ref)
@@ -407,6 +208,7 @@ export function extractScheduleOnDemand(store) {
             finishTime: asString(a[layout.FinishTime]),
             predefinedType: asEnum(a[layout.PredefinedType]),
             taskGlobalIds: [],
+            childScheduleGlobalIds: [],
         };
         if (globalId)
             globalIdByExpressId.set(expressId, globalId);
@@ -426,7 +228,59 @@ export function extractScheduleOnDemand(store) {
             scheduleByExpressId.set(id, info);
         }
     }
-    // Pass 5: IfcRelAssignsToControl — map schedules to tasks.
+    // Pass 4b: walk IfcRelNests again — IfcWorkPlan nesting IfcWorkSchedule.
+    // Real-world files use IfcRelNests for this grouping (confirmed against the
+    // buildingSMART IFC4 spec's own reference example), distinct from Pass 2's
+    // task/subtask hierarchy above, which only resolves parents through
+    // taskByExpressId and silently skips a WorkPlan RelatingObject.
+    for (const relId of relNestsIds) {
+        const ref = store.entityIndex.byId.get(relId);
+        if (!ref)
+            continue;
+        const entity = extractor.extractEntity(ref);
+        if (!entity)
+            continue;
+        const a = entity.attributes || [];
+        const parent = asRef(a[REL_NESTS_ATTR.RelatingObject]);
+        const children = asRefList(a[REL_NESTS_ATTR.RelatedObjects]);
+        if (parent === undefined)
+            continue;
+        const parentPlan = scheduleByExpressId.get(parent);
+        if (!parentPlan || parentPlan.kind !== 'WorkPlan')
+            continue; // not a work-plan nest
+        for (const childId of children) {
+            const childSchedule = scheduleByExpressId.get(childId);
+            if (!childSchedule || childSchedule.kind !== 'WorkSchedule')
+                continue;
+            // This extractor is the sole producer of `parentPlan`: every
+            // WorkScheduleInfo it builds above sets `childScheduleGlobalIds: []`,
+            // so the field is never actually absent here. `??=` makes that
+            // invariant visible to the checker without a non-null assertion, and
+            // without treating "absent" any differently from "empty" — both still
+            // mean "no nested schedules yet" everywhere else that reads it.
+            // Two distinct IfcRelNests entities can nest the same WorkPlan/
+            // WorkSchedule pair (a source file may repeat the relation), so guard
+            // the push the same way Pass 5 below guards its own append.
+            const childGlobalIds = (parentPlan.childScheduleGlobalIds ??= []);
+            if (!childGlobalIds.includes(childSchedule.globalId)) {
+                childGlobalIds.push(childSchedule.globalId);
+            }
+            if (!childSchedule.parentPlanGlobalId) {
+                childSchedule.parentPlanGlobalId = parentPlan.globalId;
+            }
+        }
+    }
+    // Pass 5: IfcRelAssignsToControl — map schedules to tasks, and (a second,
+    // distinct grouping path from Pass 4b's IfcRelNests) IfcWorkPlan grouping
+    // IfcWorkSchedule. The SDK's scripting bridge
+    // (`assignSchedulesToWorkPlan` in packages/create/src/ifc-creator.ts)
+    // emits exactly this relation — RelatingControl the plan, RelatedObjects
+    // the schedules — not IfcRelNests, so a plan grouped through that bridge
+    // must resolve here too or the SDK-authored grouping never reads back.
+    // If a source file expresses the same WorkPlan->WorkSchedule pair through
+    // *both* relations, Pass 4b (IfcRelNests) runs first and wins:
+    // `parentPlanGlobalId` is set-once (guarded below and in Pass 4b), and
+    // `childScheduleGlobalIds` is deduped so the pair is not double-counted.
     for (const relId of relAssignsControlIds) {
         const ref = store.entityIndex.byId.get(relId);
         if (!ref)
@@ -444,10 +298,31 @@ export function extractScheduleOnDemand(store) {
             continue;
         for (const objId of objects) {
             const task = taskByExpressId.get(objId);
-            if (!task)
+            if (task) {
+                // A source file may repeat the relation; guard both paired arrays
+                // on one predicate to keep them in lockstep. IfcRelAssignsToControl
+                // carries no quantity attribute, so this pair is a pure identity
+                // edge, unlike Pass 3's productExpressIds/productGlobalIds above.
+                if (!schedule.taskGlobalIds.includes(task.globalId)) {
+                    schedule.taskGlobalIds.push(task.globalId);
+                    task.controllingScheduleGlobalIds.push(schedule.globalId);
+                }
                 continue;
-            schedule.taskGlobalIds.push(task.globalId);
-            task.controllingScheduleGlobalIds.push(schedule.globalId);
+            }
+            // Not a task — check whether this is a WorkPlan grouping a
+            // WorkSchedule via IfcRelAssignsToControl instead of IfcRelNests.
+            if (schedule.kind !== 'WorkPlan')
+                continue;
+            const childSchedule = scheduleByExpressId.get(objId);
+            if (!childSchedule || childSchedule.kind !== 'WorkSchedule')
+                continue;
+            const siblings = (schedule.childScheduleGlobalIds ??= []);
+            if (!siblings.includes(childSchedule.globalId)) {
+                siblings.push(childSchedule.globalId);
+            }
+            if (!childSchedule.parentPlanGlobalId) {
+                childSchedule.parentPlanGlobalId = schedule.globalId;
+            }
         }
     }
     // Pass 6: IfcRelSequence — dependency edges between tasks.