@ifc-lite/viewer 1.17.4 → 1.18.0

package/src/sdk/adapters/export-adapter.ts

@@ -8,6 +8,8 @@ import { EntityNode } from '@ifc-lite/query';
 import { StepExporter, type StepExportOptions } from '@ifc-lite/export';
 import { getModelForRef, LEGACY_MODEL_ID } from './model-compat.js';
 import { applyAttributeMutationsToEntityData, getMutationViewForModel } from './mutation-view.js';
+import { serializeScheduleToStep, type ScheduleExtraction, type IfcDataStore } from '@ifc-lite/parser';
+import { spliceScheduleIntoExport } from './export-schedule-splice.js';
 
 /** Options for CSV export */
 interface CsvOptions {
@@ -379,7 +381,18 @@ export function createExportAdapter(store: StoreApi): ExportBackendMethods {
         georefMutations,
       };
 
-      return exporter.export(exportOptions).content;
+      // Splice any in-memory schedule (parsed-and-cached, or generated
+      // via the Gantt panel's "Generate from storeys" dialog) into the
+      // STEP output via the shared splice helper. Keeps this adapter
+      // in lockstep with the viewer's ExportDialog / ExportChangesButton
+      // so bugs can't differ across surfaces.
+      const exportResult = exporter.export(exportOptions);
+      const spliced = spliceScheduleIntoExport(exportResult, modelId, model.ifcDataStore as IfcDataStore, {
+        scheduleData: state.scheduleData ?? null,
+        scheduleIsEdited: state.scheduleIsEdited === true,
+        scheduleSourceModelId: state.scheduleSourceModelId ?? null,
+      });
+      return spliced.content;
     },
 
     download(content: string | Uint8Array, filename: string, mimeType?: string) {
@@ -389,6 +402,396 @@ export function createExportAdapter(store: StoreApi): ExportBackendMethods {
   };
 }
 
+/**
+ * Splice an in-memory `ScheduleExtraction` into a STEP file's DATA section.
+ *
+ * Three cases:
+ *   1. Schedule is purely parsed and untouched — leave the STEP alone.
+ *   2. Schedule has generated-only tail (pre-existing behaviour) — append
+ *      the generated tasks + sequences + schedules just before ENDSEC.
+ *   3. Schedule has been *edited* (rename / reschedule / reassign / delete
+ *      on ANY task, generated or parsed) — strip EVERY schedule entity
+ *      from the STEP body and re-emit the whole `scheduleData` fresh.
+ *      Dependent entities (`IfcTaskTime`, `IfcLagTime`, `IfcRel*`) cascade
+ *      cleanly on deletion because we serialize the whole block at once.
+ *
+ * We also use the source model's existing IfcOwnerHistory (when present)
+ * for the inserted entities so they share ownership metadata.
+ */
+export interface InjectScheduleOptions {
+  /**
+   * When true, the caller has edited the in-memory schedule — enter
+   * rewrite mode (case 3 above). The flag is the scheduleSlice's
+   * `scheduleIsEdited` value; threading it here keeps injection logic
+   * free of store knowledge.
+   */
+  scheduleIsEdited?: boolean;
+}
+
+export function injectScheduleIntoStep(
+  stepContent: string,
+  scheduleData: ScheduleExtraction | null,
+  ifcDataStore: IfcDataStore,
+  options?: InjectScheduleOptions,
+): string {
+  if (!scheduleData || scheduleData.tasks.length === 0) {
+    // No schedule in memory. If the caller flagged "edited", the user
+    // deleted every task in what used to be a parsed schedule — we
+    // still want to strip the stale entities from the STEP.
+    if (options?.scheduleIsEdited) {
+      return stripScheduleEntities(stepContent);
+    }
+    return stepContent;
+  }
+
+  const hasGenerated = scheduleData.tasks.some(t => !t.expressId || t.expressId <= 0);
+  const edited = options?.scheduleIsEdited === true;
+
+  if (!edited && !hasGenerated) return stepContent;
+
+  // Shared resolution helpers for both injection paths.
+  const resolveProduct = (gid: string): number | undefined => {
+    if (!gid) return undefined;
+    return ifcDataStore.entities?.getExpressIdByGlobalId?.(gid) ?? undefined;
+  };
+
+  // ── Rewrite path: strip + re-emit the full schedule ─────────────
+  if (edited) {
+    const stripped = stripScheduleEntities(stepContent);
+    const maxId = findMaxExpressId(stripped);
+    const ownerHistoryId = findFirstOwnerHistoryId(stripped) ?? undefined;
+
+    const result = serializeScheduleToStep(scheduleData, {
+      nextId: maxId + 1,
+      ownerHistoryId,
+      resolveProductExpressId: resolveProduct,
+    });
+    if (result.lines.length === 0) return stripped;
+    return spliceBeforeEndSec(stripped, result.lines);
+  }
+
+  // ── Append-only path: only generated tasks (legacy behaviour) ───
+  const generatedTasks = scheduleData.tasks.filter(t => !t.expressId || t.expressId <= 0);
+  const generatedTaskGids = new Set(generatedTasks.map(t => t.globalId));
+  const generatedSequences = scheduleData.sequences.filter(
+    s => generatedTaskGids.has(s.relatingTaskGlobalId) && generatedTaskGids.has(s.relatedTaskGlobalId),
+  );
+  const generatedWorkSchedules = scheduleData.workSchedules.filter(ws => !ws.expressId || ws.expressId <= 0);
+
+  const partitioned: ScheduleExtraction = {
+    hasSchedule: true,
+    workSchedules: generatedWorkSchedules,
+    tasks: generatedTasks,
+    sequences: generatedSequences,
+  };
+
+  const maxId = findMaxExpressId(stepContent);
+  const ownerHistoryId = findFirstOwnerHistoryId(stepContent) ?? undefined;
+
+  const result = serializeScheduleToStep(partitioned, {
+    nextId: maxId + 1,
+    ownerHistoryId,
+    resolveProductExpressId: resolveProduct,
+  });
+  if (result.lines.length === 0) return stepContent;
+  return spliceBeforeEndSec(stepContent, result.lines);
+}
+
+/**
+ * Splice fresh STEP lines just before the DATA-section's closing
+ * `ENDSEC;`. Anchored on the LAST `ENDSEC;` because the header section
+ * also ends with one — we want the data end.
+ */
+function spliceBeforeEndSec(stepContent: string, lines: string[]): string {
+  const endSecIdx = stepContent.lastIndexOf('ENDSEC;');
+  if (endSecIdx < 0) {
+    // Malformed STEP — surface the original file unchanged rather than
+    // corrupting it.
+    console.warn('[export] schedule injection: ENDSEC not found in STEP output');
+    return stepContent;
+  }
+  const head = stepContent.slice(0, endSecIdx);
+  const tail = stepContent.slice(endSecIdx);
+  return `${head}${lines.join('\n')}\n${tail}`;
+}
+
+/**
+ * Remove every schedule-related entity declaration from the STEP body.
+ *
+ * Two-pass:
+ *   1. Identify every express ID whose entity type is in the "always a
+ *      schedule entity" set (`IfcTask`, `IfcWorkSchedule`, `IfcWorkPlan`,
+ *      `IfcTaskTime`, `IfcLagTime`).
+ *   2. Drop lines whose ID is in that set OR whose entity type is one of
+ *      the sometimes-schedule types (`IfcRelSequence`, `IfcRelAssignsTo-
+ *      Process`, `IfcRelAssignsToControl`) OR `IfcRelNests` lines that
+ *      reference any ID from step 1.
+ *
+ * The IfcRelNests check prevents us from stripping cost-item/resource
+ * nests, which share the entity but aren't schedule-owned.
+ */
+const ALWAYS_SCHEDULE_TYPES: ReadonlySet<string> = new Set([
+  'IFCTASK',
+  'IFCWORKSCHEDULE',
+  'IFCWORKPLAN',
+  'IFCTASKTIME',
+  'IFCTASKTIMERECURRING',
+  'IFCLAGTIME',
+]);
+
+const SOMETIMES_SCHEDULE_TYPES: ReadonlySet<string> = new Set([
+  'IFCRELSEQUENCE',
+  'IFCRELASSIGNSTOPROCESS',
+  'IFCRELASSIGNSTOCONTROL',
+]);
+
+function stripScheduleEntities(stepContent: string): string {
+  // Pass 1: collect schedule-entity IDs by tokenizing declarations.
+  //
+  // We walk the STEP content at the STATEMENT level (terminated by `;`
+  // outside string literals), not line-by-line. Line-based splitting
+  // breaks when a writer spans an entity across multiple lines —
+  // valid STEP allows whitespace and newlines anywhere outside string
+  // literals. Statement-based walking handles multi-line entities
+  // transparently.
+  const statements = tokenizeStepStatements(stepContent);
+  const scheduleIds = new Set<number>();
+  for (const stmt of statements) {
+    if (stmt.kind !== 'entity') continue;
+    if (ALWAYS_SCHEDULE_TYPES.has(stmt.typeUpper)) scheduleIds.add(stmt.id);
+  }
+
+  if (scheduleIds.size === 0) {
+    // No "always" schedule entities. There can't be any schedule-related
+    // relationship entities either; nothing to strip.
+    return stepContent;
+  }
+
+  // Pass 2: walk statements and emit non-schedule text ranges. We keep
+  // byte ranges (start/end offsets in `stepContent`) rather than
+  // reassembling, so leading/trailing whitespace between statements
+  // survives byte-identical when every statement is kept.
+  const keptRanges: Array<{ start: number; end: number }> = [];
+  let cursor = 0;
+  for (const stmt of statements) {
+    if (stmt.kind !== 'entity') {
+      // Non-entity text (header, section markers, whitespace) — always keep.
+      continue;
+    }
+    if (shouldStripStatement(stmt, scheduleIds)) {
+      // Push the range from `cursor` up to the statement start, then
+      // advance past the statement (including trailing whitespace /
+      // newline so we don't leave a gap).
+      if (stmt.start > cursor) keptRanges.push({ start: cursor, end: stmt.start });
+      cursor = stmt.end;
+      // Also consume a trailing newline so we don't leave blank lines
+      // scattered where schedule statements used to live.
+      if (stepContent[cursor] === '\r') cursor++;
+      if (stepContent[cursor] === '\n') cursor++;
+    }
+  }
+  if (cursor < stepContent.length) {
+    keptRanges.push({ start: cursor, end: stepContent.length });
+  }
+
+  // Concatenate kept ranges.
+  if (keptRanges.length === 1 && keptRanges[0].start === 0 && keptRanges[0].end === stepContent.length) {
+    return stepContent; // No-op path — nothing was stripped.
+  }
+  let out = '';
+  for (const r of keptRanges) out += stepContent.slice(r.start, r.end);
+  return out;
+}
+
+/** Per-statement classification: should we drop this record? */
+function shouldStripStatement(
+  stmt: { typeUpper: string; id: number; attributesText: string },
+  scheduleIds: ReadonlySet<number>,
+): boolean {
+  if (scheduleIds.has(stmt.id)) return true; // Always-schedule entity itself.
+  if (SOMETIMES_SCHEDULE_TYPES.has(stmt.typeUpper)) {
+    // Relationship entity; strip only if it references a schedule id.
+    return referencesAnyId(stmt.attributesText, scheduleIds);
+  }
+  if (stmt.typeUpper === 'IFCRELNESTS') {
+    // Only strip when the referenced set includes a schedule id (the
+    // nest ties a task to its children). False-positives (a nests that
+    // mixes task + non-task in a single record) are vanishingly rare.
+    return referencesAnyId(stmt.attributesText, scheduleIds);
+  }
+  return false;
+}
+
+interface StepEntityStatement {
+  kind: 'entity';
+  /** Byte offset of the `#` in `#ID=…`. */
+  start: number;
+  /** Byte offset just past the terminating `;`. */
+  end: number;
+  id: number;
+  typeUpper: string;
+  /** The parenthesised attribute list text including the outer parens. */
+  attributesText: string;
+}
+
+/**
+ * Tokenize `stepContent` into entity statements. Skips HEADER / DATA
+ * section markers and whitespace; returns only `#ID=TYPE(…);` records.
+ * Respects `'…'` string literals (STEP uses `''` to escape a quote).
+ */
+function tokenizeStepStatements(stepContent: string): StepEntityStatement[] {
+  const out: StepEntityStatement[] = [];
+  const len = stepContent.length;
+  let i = 0;
+  while (i < len) {
+    // Skip whitespace.
+    while (i < len && (stepContent[i] === ' ' || stepContent[i] === '\t' || stepContent[i] === '\n' || stepContent[i] === '\r')) i++;
+    if (i >= len) break;
+    // Only interested in `#N=…;` records. Anything else — header keywords,
+    // section markers, end markers — gets scanned to the next `;` and
+    // discarded as non-entity text.
+    if (stepContent[i] !== '#') {
+      // Scan to next `;` (STEP statements are `;`-terminated).
+      i = scanToStatementEnd(stepContent, i);
+      continue;
+    }
+    const declStart = i;
+    i++; // past '#'
+    // Read id digits.
+    const idStart = i;
+    while (i < len && stepContent.charCodeAt(i) >= 0x30 && stepContent.charCodeAt(i) <= 0x39) i++;
+    if (i === idStart) {
+      // `#` not followed by a digit — not an entity reference. Skip to `;`.
+      i = scanToStatementEnd(stepContent, declStart + 1);
+      continue;
+    }
+    const id = parseInt(stepContent.slice(idStart, i), 10);
+    // Allow whitespace before `=`.
+    while (i < len && (stepContent[i] === ' ' || stepContent[i] === '\t')) i++;
+    if (stepContent[i] !== '=') {
+      // `#N` without `=` — reference inside an attribute list; bail.
+      i = scanToStatementEnd(stepContent, declStart + 1);
+      continue;
+    }
+    i++; // past '='
+    while (i < len && (stepContent[i] === ' ' || stepContent[i] === '\t')) i++;
+    // Type name: uppercase letters, digits, underscore.
+    const typeStart = i;
+    while (i < len) {
+      const c = stepContent[i];
+      if ((c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c === '_' || (c >= 'a' && c <= 'z')) i++;
+      else break;
+    }
+    if (i === typeStart) {
+      i = scanToStatementEnd(stepContent, declStart + 1);
+      continue;
+    }
+    const typeUpper = stepContent.slice(typeStart, i).toUpperCase();
+    // Optional whitespace before attribute list.
+    while (i < len && (stepContent[i] === ' ' || stepContent[i] === '\t' || stepContent[i] === '\n' || stepContent[i] === '\r')) i++;
+    // Attribute list starts with `(`. Read until matching `)`, respecting
+    // string literals and nested parens.
+    const attrStart = i;
+    if (stepContent[i] !== '(') {
+      i = scanToStatementEnd(stepContent, declStart + 1);
+      continue;
+    }
+    i++; // past '('
+    let depth = 1;
+    let inString = false;
+    while (i < len && depth > 0) {
+      const c = stepContent[i];
+      if (inString) {
+        if (c === "'") {
+          // Peek for escape `''`.
+          if (stepContent[i + 1] === "'") { i += 2; continue; }
+          inString = false;
+          i++;
+          continue;
+        }
+        i++;
+        continue;
+      }
+      if (c === "'") { inString = true; i++; continue; }
+      if (c === '(') { depth++; i++; continue; }
+      if (c === ')') { depth--; i++; continue; }
+      i++;
+    }
+    const attrEnd = i;
+    // Expect `;` terminator (optionally preceded by whitespace).
+    while (i < len && (stepContent[i] === ' ' || stepContent[i] === '\t')) i++;
+    if (stepContent[i] !== ';') {
+      // Malformed — scan to next `;` and skip this record.
+      i = scanToStatementEnd(stepContent, attrEnd);
+      continue;
+    }
+    i++; // past ';'
+    const end = i;
+    out.push({
+      kind: 'entity',
+      start: declStart,
+      end,
+      id,
+      typeUpper,
+      attributesText: stepContent.slice(attrStart, attrEnd),
+    });
+  }
+  return out;
+}
+
+/** Advance past the next `;` outside string literals. Never walks backwards. */
+function scanToStatementEnd(s: string, from: number): number {
+  const len = s.length;
+  let i = from;
+  let inString = false;
+  while (i < len) {
+    const c = s[i];
+    if (inString) {
+      if (c === "'") {
+        if (s[i + 1] === "'") { i += 2; continue; }
+        inString = false;
+      }
+      i++;
+      continue;
+    }
+    if (c === "'") { inString = true; i++; continue; }
+    if (c === ';') return i + 1;
+    i++;
+  }
+  return len;
+}
+
+/** True iff any `#N` token in `rest` has N in the given set. */
+function referencesAnyId(rest: string, ids: ReadonlySet<number>): boolean {
+  const refRegex = /#(\d+)/g;
+  let m: RegExpExecArray | null;
+  while ((m = refRegex.exec(rest)) !== null) {
+    const n = parseInt(m[1], 10);
+    if (ids.has(n)) return true;
+  }
+  return false;
+}
+
+/** Scan the STEP body for the highest `#N=` declaration. Returns 0 when none. */
+function findMaxExpressId(stepContent: string): number {
+  let max = 0;
+  // Pattern: line starts with `#NNN=` (newline-anchored to avoid matching
+  // refs inside attribute lists).
+  const regex = /(?:^|\n)\s*#(\d+)\s*=/g;
+  let m: RegExpExecArray | null;
+  while ((m = regex.exec(stepContent)) !== null) {
+    const n = parseInt(m[1], 10);
+    if (Number.isFinite(n) && n > max) max = n;
+  }
+  return max;
+}
+
+/** Find the first IfcOwnerHistory's express ID in the STEP file, if any. */
+function findFirstOwnerHistoryId(stepContent: string): number | null {
+  const m = stepContent.match(/(?:^|\n)\s*#(\d+)\s*=\s*IFCOWNERHISTORY\b/i);
+  return m ? parseInt(m[1], 10) : null;
+}
+
 /** Trigger a browser file download */
 function triggerDownload(content: string | Uint8Array, filename: string, mimeType: string): void {
   if (typeof document === 'undefined') {

package/src/sdk/adapters/export-schedule-splice.test.ts

@@ -0,0 +1,127 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Integration tests for `spliceScheduleIntoExport` — the single entry
+ * point every export surface routes through.
+ *
+ * Guards the bug classes that hit production:
+ *   • Uint8Array content path silently skipping injection
+ *   • `scheduleSourceModelId === null` single-model sessions not
+ *     matching the model id
+ *   • Edited parsed schedules not triggering the rewrite branch
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spliceScheduleIntoExport } from './export-schedule-splice.js';
+import type { ScheduleExtraction, IfcDataStore } from '@ifc-lite/parser';
+
+const SAMPLE_STEP = `ISO-10303-21;
+HEADER;
+FILE_DESCRIPTION(('test'),'2;1');
+FILE_NAME('','',(''),(''),'','','');
+FILE_SCHEMA(('IFC4'));
+ENDSEC;
+DATA;
+#1=IFCPROJECT('proj',$,'P',$,$,$,$,(#2),#3);
+#10=IFCOWNERHISTORY($,$,$,.NOCHANGE.,$,$,$,0);
+#11=IFCWALL('wall-A',#10,'A',$,$,$,$,$,$);
+ENDSEC;
+END-ISO-10303-21;
+`;
+
+const STUB_STORE: IfcDataStore = {
+  entities: {
+    getExpressIdByGlobalId: (gid: string) => (gid === 'wall-A' ? 11 : -1),
+  } as unknown as IfcDataStore['entities'],
+} as unknown as IfcDataStore;
+
+function genSchedule(): ScheduleExtraction {
+  return {
+    hasSchedule: true,
+    workSchedules: [{
+      expressId: 0, globalId: 'ws', kind: 'WorkSchedule',
+      name: 'Gen', startTime: '2024-05-01T08:00:00',
+      taskGlobalIds: ['t1'],
+    }],
+    tasks: [{
+      expressId: 0, globalId: 't1', name: 'Install',
+      isMilestone: false, predefinedType: 'INSTALLATION',
+      childGlobalIds: [],
+      productExpressIds: [0],
+      productGlobalIds: ['wall-A'],
+      controllingScheduleGlobalIds: ['ws'],
+      taskTime: {
+        scheduleStart: '2024-05-01T08:00:00',
+        scheduleFinish: '2024-05-05T17:00:00',
+      },
+    }],
+    sequences: [],
+  };
+}
+
+// ─── the bug we actually shipped ──────────────────────────────────────
+
+test('splices into Uint8Array content (the regression that shipped)', () => {
+  // StepExporter sometimes returns bytes; every string-only short
+  // circuit we shipped silently dropped the splice on this path.
+  const bytes = new TextEncoder().encode(SAMPLE_STEP);
+  const result = { content: bytes as string | Uint8Array };
+  const out = spliceScheduleIntoExport(result, 'modelA', STUB_STORE, {
+    scheduleData: genSchedule(),
+    scheduleIsEdited: false,
+    scheduleSourceModelId: 'modelA',
+  });
+  // Output must remain bytes (contract: preserve caller's content type)…
+  assert.ok(out.content instanceof Uint8Array, 'bytes in → bytes out');
+  // …and the schedule lines must be present in the decoded text.
+  const decoded = new TextDecoder('utf-8').decode(out.content as Uint8Array);
+  assert.match(decoded, /=IFCWORKSCHEDULE\(/);
+  assert.match(decoded, /=IFCTASK\(/);
+});
+
+test('preserves string content type when exporter returns text', () => {
+  const result = { content: SAMPLE_STEP as string | Uint8Array };
+  const out = spliceScheduleIntoExport(result, 'modelA', STUB_STORE, {
+    scheduleData: genSchedule(),
+    scheduleIsEdited: false,
+    scheduleSourceModelId: 'modelA',
+  });
+  assert.strictEqual(typeof out.content, 'string', 'string in → string out');
+  assert.match(out.content as string, /=IFCWORKSCHEDULE\(/);
+});
+
+test('null sourceModelId + in-memory schedule still splices (single-model fallback)', () => {
+  // Regression: single-model sessions generated with the Generate
+  // dialog left sourceModelId as null. Strict equality against the
+  // export target's model id missed every time.
+  const result = { content: SAMPLE_STEP as string | Uint8Array };
+  const out = spliceScheduleIntoExport(result, '__legacy__', STUB_STORE, {
+    scheduleData: genSchedule(),
+    scheduleIsEdited: false,
+    scheduleSourceModelId: null,
+  });
+  assert.match(out.content as string, /=IFCTASK\(/);
+});
+
+test('sourceModelId mismatch skips the splice (federation safety)', () => {
+  const result = { content: SAMPLE_STEP as string | Uint8Array };
+  const out = spliceScheduleIntoExport(result, 'modelB', STUB_STORE, {
+    scheduleData: genSchedule(),
+    scheduleIsEdited: false,
+    scheduleSourceModelId: 'modelA', // different model!
+  });
+  assert.strictEqual(out.content, SAMPLE_STEP, 'foreign schedule is not spliced');
+});
+
+test('no schedule + no edit flag is a no-op', () => {
+  const result = { content: SAMPLE_STEP as string | Uint8Array };
+  const out = spliceScheduleIntoExport(result, 'modelA', STUB_STORE, {
+    scheduleData: null,
+    scheduleIsEdited: false,
+    scheduleSourceModelId: null,
+  });
+  assert.strictEqual(out.content, SAMPLE_STEP);
+});

package/src/sdk/adapters/export-schedule-splice.ts

@@ -0,0 +1,87 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Shared helper for splicing an in-memory schedule into a STEP export.
+ *
+ * Three export surfaces (ExportChangesButton, ExportDialog, SDK
+ * adapter) previously re-implemented the same decode-inject-re-encode
+ * dance. Two of the three shipped a bug at different times:
+ *   • gate on `typeof result.content === 'string'` silently dropped
+ *     the splice when `StepExporter.export()` returned `Uint8Array`
+ *   • gate on `scheduleSourceModelId === selectedModelId` missed
+ *     single-model sessions where `sourceModelId` was `null`
+ *
+ * Centralising into one function kills both bug classes — the three
+ * surfaces become one-liners over the same contract.
+ */
+
+import type { IfcDataStore, ScheduleExtraction } from '@ifc-lite/parser';
+import { injectScheduleIntoStep } from './export-adapter.js';
+
+export interface ExportScheduleState {
+  /** In-memory schedule — generated tasks, edits, or parsed+untouched. */
+  scheduleData: ScheduleExtraction | null;
+  /** True when the user has edited the schedule since load / generation. */
+  scheduleIsEdited: boolean;
+  /**
+   * Model the schedule is attributed to. Null for purely-parsed schedules
+   * that haven't been touched (or for single-model sessions where the
+   * generate dialog didn't explicitly attribute one).
+   */
+  scheduleSourceModelId: string | null;
+}
+
+export interface ExportResultLike {
+  content: string | Uint8Array;
+}
+
+/**
+ * Splice the pending schedule into the exporter's output.
+ *
+ * Input: the raw `result.content` from `StepExporter.export()` (which
+ * may be text or bytes) + the model + the current schedule state.
+ *
+ * Output: the same `content` shape (string → string, Uint8Array →
+ * Uint8Array) with the schedule either (a) left alone — no pending
+ * schedule, or source-model doesn't match the export target, (b)
+ * appended for a generated schedule, or (c) strip-and-rewritten for an
+ * edited schedule.
+ *
+ * Gate logic:
+ *   • match if `scheduleSourceModelId === modelId` (federated session)
+ *   • match if `scheduleSourceModelId === null` AND we have tasks
+ *     (single-model session where the generate dialog didn't attribute)
+ */
+export function spliceScheduleIntoExport(
+  result: ExportResultLike,
+  modelId: string,
+  dataStore: IfcDataStore,
+  state: ExportScheduleState,
+): ExportResultLike {
+  const taskCount = state.scheduleData?.tasks.length ?? 0;
+  const sourceMatches = state.scheduleSourceModelId === modelId;
+  const singleModelFallback = state.scheduleSourceModelId === null && taskCount > 0;
+  const shouldInject = sourceMatches || singleModelFallback;
+  if (!shouldInject) return result;
+
+  // STEP is textual by spec but the underlying exporter sometimes
+  // returns Uint8Array (pre-encoded bytes). Decode on the way in,
+  // splice, re-encode on the way out so the caller's content-type
+  // contract is preserved.
+  const raw = result.content;
+  const stepText = typeof raw === 'string'
+    ? raw
+    : new TextDecoder('utf-8', { fatal: false }).decode(raw);
+  const injected = injectScheduleIntoStep(
+    stepText,
+    state.scheduleData ?? null,
+    dataStore,
+    { scheduleIsEdited: state.scheduleIsEdited === true },
+  );
+  return {
+    ...result,
+    content: typeof raw === 'string' ? injected : new TextEncoder().encode(injected),
+  };
+}

package/src/sdk/adapters/model-compat.ts

@@ -21,11 +21,17 @@ import type { ViewerState } from '../../store/index.js';
 /** Sentinel model ID used for the legacy single-model path */
 export const LEGACY_MODEL_ID = 'default';
 
-/** Minimal model shape needed by the SDK adapters */
+/** Minimal model shape needed by the SDK adapters.
+ *
+ * `ifcDataStore` is nullable because the federated model store also
+ * carries native-metadata-only entries (loaded through Tauri without a
+ * full STEP parse). Adapters that need the data store check for null
+ * before using it.
+ */
 export interface ModelLike {
   id: string;
   name: string;
-  ifcDataStore: IfcDataStore;
+  ifcDataStore: IfcDataStore | null;
   schemaVersion: SchemaVersion;
   fileSize: number;
   loadedAt: number;