@ifc-lite/export 2.9.4 → 3.0.0

package/dist/step-overlay-entities.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The overlay-created-entities phase of `StepExporter.export()` (#2475 step
+ * 2e): the pass that writes one line per entity the OVERLAY created
+ * (`store.addEntity` / `mutationView.createEntity`), as opposed to
+ * `step-source-iteration.ts`, which writes lines for records the SOURCE file
+ * already holds.
+ *
+ * It runs last among the four output passes — after georeferencing
+ * (`step-georeferencing.ts`), property/quantity-set generation
+ * (`step-property-sets.ts`) and source iteration — and reads what two of them
+ * wrote: `pass.modifiedAttributes` (attribute-collection phase, applied here
+ * as an overlay-created entity's post-create edits) and
+ * `pass.overlayTypeOwnedPsets` (`step-property-sets.ts`, a created TYPE
+ * object's generated pset ids, arriving as one more positional override).
+ * Nothing downstream of this phase reads anything it writes except the
+ * settle/assemble tail, so it moves cleanly.
+ *
+ * What is injected rather than read off the pass, and why: `isGeometryEntity`
+ * is shared with the setup closure and with `step-source-iteration.ts`.
+ * `relationshipWithheldWarning` is the same pure string formatter
+ * `step-source-iteration.ts` already injects, not duplicated here.
+ * `applyOverlayEntityOverrides` is injected as `OverlayEntitiesContext`'s
+ * field even though, since #2475's "remaining private helpers" step, it is
+ * an ordinary export of `step-attribute-mutations.ts` this file could import
+ * directly — kept as an injected field for symmetry with the other two and
+ * because `StepExporter.overlayEntitiesContext()` is still the one
+ * construction site for this context, exactly as before that step.
+ *
+ * `mutationView` is passed through as-is (not narrowed to an interface of the
+ * three optional methods this phase calls) because the original code guards
+ * every one of them with its own `typeof x === 'function'` check rather than
+ * assuming the shape — a real-store `MutablePropertyView` versus a bare mock
+ * used by some tests. Narrowing the type here would not remove those checks
+ * without also changing what a test double is allowed to omit.
+ */
+import type { IfcAttributeValue } from '@ifc-lite/parser';
+import type { MutablePropertyView } from '@ifc-lite/mutations';
+import type { ExportPass, StepExportOptions } from './step-exporter.js';
+/**
+ * The exporter state this phase cannot read off the {@link ExportPass}.
+ */
+export interface OverlayEntitiesContext {
+    readonly mutationView: MutablePropertyView | null;
+    /** `step-attribute-mutations.ts`'s `applyOverlayEntityOverrides`: resolves
+     *  named/positional overrides against the overlay-created entity's
+     *  EFFECTIVE class. */
+    readonly applyOverlayEntityOverrides: (argsText: string, entityType: string, attributeOverrides: Map<string, string> | null, positionalOverrides: Map<number, IfcAttributeValue> | null, schemaVersion: ExportPass['sourceSchema'], onRejected?: (attrName: string, value: string) => void) => string;
+    /** `isGeometryEntity` (`step-geometry-types.ts`), also read by the setup closure and by
+     *  `step-source-iteration.ts`. */
+    readonly isGeometryEntity: (type: string) => boolean;
+    /** The `relationshipWithheldWarning` message builder (`step-exporter.ts`):
+     *  a pure string formatter with no pass dependency, injected here as it is
+     *  into `step-source-iteration.ts`. */
+    readonly relationshipWithheldWarning: (expressId: number, type: string) => string;
+}
+/**
+ * Add overlay-created entities (store.addEntity / mutationView.createEntity).
+ * Apply the same filters as the source-iteration pass so newly-created
+ * beams/slabs don't smuggle their geometry helpers (IfcCartesianPoint,
+ * IfcExtrudedAreaSolid, etc.) past `includeGeometry:false` /
+ * `exportPropertiesOnly()` modes.
+ */
+export declare function writeOverlayCreatedEntities(pass: ExportPass, options: StepExportOptions, excludeGeometry: boolean, applyMutations: boolean, mayNameOmittedRefs: boolean, isOmittedFromOutput: (id: number) => boolean, ctx: OverlayEntitiesContext): void;
+//# sourceMappingURL=step-overlay-entities.d.ts.map

package/dist/step-overlay-entities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-overlay-entities.d.ts","sourceRoot":"","sources":["../src/step-overlay-entities.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAM/D,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAClD;;2BAEuB;IACvB,QAAQ,CAAC,2BAA2B,EAAE,CACpC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,EAC9C,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,IAAI,EAC1D,aAAa,EAAE,UAAU,CAAC,cAAc,CAAC,EACzC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,KACnD,MAAM,CAAC;IACZ;sCACkC;IAClC,QAAQ,CAAC,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IACrD;;2CAEuC;IACvC,QAAQ,CAAC,2BAA2B,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CACnF;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,iBAAiB,EAC1B,eAAe,EAAE,OAAO,EACxB,cAAc,EAAE,OAAO,EACvB,kBAAkB,EAAE,OAAO,EAC3B,mBAAmB,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,EAC5C,GAAG,EAAE,sBAAsB,GAC1B,IAAI,CA4HN"}

package/dist/step-overlay-entities.js

@@ -0,0 +1,119 @@
+/* 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/. */
+import { filterHiddenRefsFromRelationshipLine } from './reference-collector.js';
+import { convertStepLine } from './schema-converter.js';
+import { retypeArgTokens } from './retype.js';
+import { HAS_PROPERTY_SETS_SLOT } from './type-owned-psets.js';
+import { serializeEntityArgs, serializeAttributeSlot } from './attribute-real-slots.js';
+/**
+ * Add overlay-created entities (store.addEntity / mutationView.createEntity).
+ * Apply the same filters as the source-iteration pass so newly-created
+ * beams/slabs don't smuggle their geometry helpers (IfcCartesianPoint,
+ * IfcExtrudedAreaSolid, etc.) past `includeGeometry:false` /
+ * `exportPropertiesOnly()` modes.
+ */
+export function writeOverlayCreatedEntities(pass, options, excludeGeometry, applyMutations, mayNameOmittedRefs, isOmittedFromOutput, ctx) {
+    if (!ctx.mutationView
+        || !applyMutations
+        || typeof ctx.mutationView.getNewEntities !== 'function') {
+        return;
+    }
+    const getTypeMut = typeof ctx.mutationView.getEntityTypeMutation === 'function'
+        ? ctx.mutationView.getEntityTypeMutation.bind(ctx.mutationView)
+        : null;
+    for (const entity of ctx.mutationView.getNewEntities()) {
+        // A retyped overlay entity keeps its AUTHORED type on `entity.type`
+        // (the overlay typeMutation is the source of truth for the effective
+        // class). Resolve the effective class, then re-lay-out the authored
+        // attributes from the authored layout up to it.
+        const typeMut = getTypeMut ? getTypeMut(entity.expressId) : null;
+        const effectiveType = typeMut?.newType ?? entity.type;
+        // STEP requires UPPERCASE entity type tokens; the upper-case happens
+        // here at the file-format boundary.
+        const upperType = effectiveType.toUpperCase();
+        if (excludeGeometry && ctx.isGeometryEntity(upperType)) {
+            continue;
+        }
+        if (pass.allowedEntityIds !== null && !pass.allowedEntityIds.has(entity.expressId)) {
+            continue;
+        }
+        // Re-lay-out by name against the effective class (identity for
+        // compatible layouts). Runs whenever a retype intent exists — even a
+        // same-class retype, which carries a PredefinedType override
+        // (e.g. setEntityType(id, 'IfcColumn', 'PILASTER')).
+        let argsText;
+        if (typeMut) {
+            // Serialize against the AUTHORED layout (`entity.type`); retypeArgTokens
+            // then re-lays the tokens out by name up to the effective class.
+            const srcTokens = entity.attributes.map((value, i) => serializeAttributeSlot(entity.type, i, value, pass.sourceSchema));
+            const { tokens } = retypeArgTokens(srcTokens, entity.type, effectiveType, typeMut.predefinedType ?? null, pass.sourceSchema);
+            argsText = tokens.join(',');
+        }
+        else {
+            argsText = serializeEntityArgs(entity.type, entity.attributes, pass.sourceSchema);
+        }
+        // Edits made AFTER the create live in the overlay, never in the
+        // authored payload (#2006). The source-iteration pass applies them to
+        // source records via applyAttributeMutations / applyPositionalMutations;
+        // an overlay-created entity has no source record, so without this it was
+        // written from its creation payload alone and every later
+        // `setAttribute` / `setPositionalAttribute` was silently dropped on
+        // save — data loss with no error and no warning.
+        //
+        // Order mirrors the source pass: retype (above) -> named attributes ->
+        // positional overrides, all resolved against the EFFECTIVE class.
+        const attributeOverrides = pass.modifiedAttributes.get(entity.expressId) ?? null;
+        const queuedPositional = typeof ctx.mutationView.getPositionalMutationsForEntity === 'function'
+            ? ctx.mutationView.getPositionalMutationsForEntity(entity.expressId)
+            : null;
+        // A created TYPE object owns its psets through HasPropertySets, and the
+        // ids of the psets this export generated are only known now — so they
+        // arrive as one more slot override rather than through the overlay.
+        // `has`, not `??`, for the same reason `overlaySlotValue` gives: the
+        // stored value is deliberately null when the resolved list is empty.
+        const positionalOverrides = pass.overlayTypeOwnedPsets.has(entity.expressId)
+            ? new Map(queuedPositional).set(HAS_PROPERTY_SETS_SLOT, pass.overlayTypeOwnedPsets.get(entity.expressId) ?? null)
+            : queuedPositional;
+        if ((attributeOverrides && attributeOverrides.size > 0)
+            || (positionalOverrides && positionalOverrides.size > 0)) {
+            argsText = ctx.applyOverlayEntityOverrides(argsText, upperType, attributeOverrides, positionalOverrides, pass.sourceSchema, 
+            // Overlay-created entities report a rejected REAL edit exactly as
+            // source-backed ones do. Without this the slot was kept and NOTHING
+            // was said - the silent discard this whole change exists to
+            // prevent, surviving in the one path that had no test.
+            (attr, value) => pass.warnings.push(`entity #${entity.expressId}: attribute ${attr} not written - ` +
+                `${JSON.stringify(value)} is not a number and the slot is REAL-typed`));
+        }
+        let line = `#${entity.expressId}=${upperType}(${argsText});`;
+        // Same gap as the source-iteration pass, for an overlay-authored
+        // relationship instead of a parsed one (#2398).
+        //
+        // `mayNameOmittedRefs` is provably TRUE wherever this line executes:
+        // the block enclosing this pass requires `ctx.mutationView` and
+        // `applyMutations`, which is `pass.overlayActive`, which is one of the
+        // gate's own disjuncts. Spelled out anyway so both filter sites read the
+        // same — the previous gate's failure was one site's condition drifting
+        // from what the filter needed, and a pass reachable without an overlay
+        // would otherwise silently need the gate re-derived here.
+        if (mayNameOmittedRefs && upperType.startsWith('IFCREL')) {
+            line = filterHiddenRefsFromRelationshipLine(line, isOmittedFromOutput);
+            if (line === null) {
+                pass.warnings.push(ctx.relationshipWithheldWarning(entity.expressId, upperType));
+                continue;
+            }
+        }
+        if (pass.converting) {
+            const converted = convertStepLine(line, pass.sourceSchema, pass.schema, options.guidRandom);
+            if (converted !== null) {
+                pass.entities.push(converted);
+                pass.newEntityCount++;
+            }
+        }
+        else {
+            pass.entities.push(line);
+            pass.newEntityCount++;
+        }
+    }
+}
+//# sourceMappingURL=step-overlay-entities.js.map

package/dist/step-overlay-entities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-overlay-entities.js","sourceRoot":"","sources":["../src/step-overlay-entities.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAwC/D,OAAO,EAAE,oCAAoC,EAAE,MAAM,0BAA0B,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AA4BxF;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CACzC,IAAgB,EAChB,OAA0B,EAC1B,eAAwB,EACxB,cAAuB,EACvB,kBAA2B,EAC3B,mBAA4C,EAC5C,GAA2B;IAE3B,IACE,CAAC,GAAG,CAAC,YAAY;WACd,CAAC,cAAc;WACf,OAAO,GAAG,CAAC,YAAY,CAAC,cAAc,KAAK,UAAU,EACxD,CAAC;QACD,OAAO;IACT,CAAC;IACD,MAAM,UAAU,GAAG,OAAO,GAAG,CAAC,YAAY,CAAC,qBAAqB,KAAK,UAAU;QAC7E,CAAC,CAAC,GAAG,CAAC,YAAY,CAAC,qBAAqB,CAAC,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC;QAC/D,CAAC,CAAC,IAAI,CAAC;IACT,KAAK,MAAM,MAAM,IAAI,GAAG,CAAC,YAAY,CAAC,cAAc,EAAE,EAAE,CAAC;QACvD,oEAAoE;QACpE,qEAAqE;QACrE,oEAAoE;QACpE,gDAAgD;QAChD,MAAM,OAAO,GAAG,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QACjE,MAAM,aAAa,GAAG,OAAO,EAAE,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC;QACtD,qEAAqE;QACrE,oCAAoC;QACpC,MAAM,SAAS,GAAG,aAAa,CAAC,WAAW,EAAE,CAAC;QAC9C,IAAI,eAAe,IAAI,GAAG,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,CAAC;YACvD,SAAS;QACX,CAAC;QACD,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;YACnF,SAAS;QACX,CAAC;QACD,+DAA+D;QAC/D,qEAAqE;QACrE,6DAA6D;QAC7D,qDAAqD;QACrD,IAAI,QAAgB,CAAC;QACrB,IAAI,OAAO,EAAE,CAAC;YACZ,yEAAyE;YACzE,iEAAiE;YACjE,MAAM,SAAS,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,CACrC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,sBAAsB,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,YAAY,CAAC,CAC/E,CAAC;YACF,MAAM,EAAE,MAAM,EAAE,GAAG,eAAe,CAChC,SAAS,EACT,MAAM,CAAC,IAAI,EACX,aAAa,EACb,OAAO,CAAC,cAAc,IAAI,IAAI,EAC9B,IAAI,CAAC,YAAY,CAClB,CAAC;YACF,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC9B,CAAC;aAAM,CAAC;YACN,QAAQ,GAAG,mBAAmB,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QACpF,CAAC;QACD,gEAAgE;QAChE,sEAAsE;QACtE,yEAAyE;QACzE,yEAAyE;QACzE,0DAA0D;QAC1D,oEAAoE;QACpE,iDAAiD;QACjD,EAAE;QACF,uEAAuE;QACvE,kEAAkE;QAClE,MAAM,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC;QACjF,MAAM,gBAAgB,GAAG,OAAO,GAAG,CAAC,YAAY,CAAC,+BAA+B,KAAK,UAAU;YAC7F,CAAC,CAAC,GAAG,CAAC,YAAY,CAAC,+BAA+B,CAAC,MAAM,CAAC,SAAS,CAAC;YACpE,CAAC,CAAC,IAAI,CAAC;QACT,wEAAwE;QACxE,sEAAsE;QACtE,oEAAoE;QACpE,qEAAqE;QACrE,qEAAqE;QACrE,MAAM,mBAAmB,GAAG,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC;YAC1E,CAAC,CAAC,IAAI,GAAG,CAAC,gBAAgB,CAAC,CAAC,GAAG,CAC3B,sBAAsB,EACtB,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,IAAI,CACzD;YACH,CAAC,CAAC,gBAAgB,CAAC;QACrB,IACE,CAAC,kBAAkB,IAAI,kBAAkB,CAAC,IAAI,GAAG,CAAC,CAAC;eAChD,CAAC,mBAAmB,IAAI,mBAAmB,CAAC,IAAI,GAAG,CAAC,CAAC,EACxD,CAAC;YACD,QAAQ,GAAG,GAAG,CAAC,2BAA2B,CACxC,QAAQ,EACR,SAAS,EACT,kBAAkB,EAClB,mBAAmB,EACnB,IAAI,CAAC,YAAY;YACjB,kEAAkE;YAClE,oEAAoE;YACpE,4DAA4D;YAC5D,uDAAuD;YACvD,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CACd,IAAI,CAAC,QAAQ,CAAC,IAAI,CAChB,WAAW,MAAM,CAAC,SAAS,eAAe,IAAI,iBAAiB;gBAC7D,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,6CAA6C,CACxE,CACJ,CAAC;QACJ,CAAC;QACD,IAAI,IAAI,GAAkB,IAAI,MAAM,CAAC,SAAS,IAAI,SAAS,IAAI,QAAQ,IAAI,CAAC;QAC5E,iEAAiE;QACjE,gDAAgD;QAChD,EAAE;QACF,qEAAqE;QACrE,gEAAgE;QAChE,uEAAuE;QACvE,yEAAyE;QACzE,uEAAuE;QACvE,uEAAuE;QACvE,0DAA0D;QAC1D,IAAI,kBAAkB,IAAI,SAAS,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YACzD,IAAI,GAAG,oCAAoC,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAC;YACvE,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;gBAClB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,2BAA2B,CAAC,MAAM,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC;gBACjF,SAAS;YACX,CAAC;QACH,CAAC;QACD,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,MAAM,SAAS,GAAG,eAAe,CAAC,IAAI,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;YAC5F,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;gBACvB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gBAC9B,IAAI,CAAC,cAAc,EAAE,CAAC;YACxB,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACzB,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/step-pass-builder.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Builds the `ExportPass` one `export()` call threads through its phases.
+ *
+ * Split out of `step-exporter.ts` for #2475. The literal moved verbatim; the
+ * only edits are that the three things it used to read off the exporter
+ * (`dataStore`, `mutationView`, `isGeometryEntity`) now arrive as fields of
+ * {@link PassBuildInput}.
+ *
+ * ONE RULE GOVERNS THIS FILE, and it is easy to break by tidying. The
+ * predicates below are closures over `pass` ITSELF, and `pass.allowedEntityIds`
+ * / `pass.hiddenProductIds` are still `null` when this function returns --
+ * `collectModifications` assigns them afterwards, on this very object. So this
+ * must `return pass` and nothing else. A spread, a `structuredClone`, an
+ * `Object.freeze`, or a caller that stores a copy detaches every predicate from
+ * the object that later gets written, and each one silently answers from a
+ * snapshot that never fills in. That is #2637, and the failure mode is a
+ * `visibleOnly` export shipping a structurally wrong file rather than throwing.
+ */
+import type { IfcDataStore, IfcSourceHeader } from '@ifc-lite/parser';
+import type { MutablePropertyView } from '@ifc-lite/mutations';
+import type { IfcSchemaVersion } from './schema-converter.js';
+import type { ExportPass, StepExportOptions } from './step-export-types.js';
+/**
+ * Everything the pass literal reads that is not its own field.
+ *
+ * The first three are the exporter's, injected rather than reached for.
+ * `isGeometryEntity` is passed as a bound callback for the same reason it is a
+ * method there: it closes over the exporter's own type set.
+ */
+export interface PassBuildInput {
+    readonly dataStore: IfcDataStore;
+    readonly mutationView: MutablePropertyView | null;
+    readonly isGeometryEntity: (type: string) => boolean;
+    readonly options: StepExportOptions;
+    readonly schema: IfcSchemaVersion;
+    readonly sourceSchema: IfcSchemaVersion;
+    readonly converting: boolean;
+    readonly applyMutations: boolean;
+    readonly excludeGeometry: boolean;
+    readonly sourceHeader: IfcSourceHeader | undefined;
+    readonly schemaToken: string;
+}
+export declare function buildExportPass(input: PassBuildInput): ExportPass;
+//# sourceMappingURL=step-pass-builder.d.ts.map

package/dist/step-pass-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-pass-builder.d.ts","sourceRoot":"","sources":["../src/step-pass-builder.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAqB,YAAY,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACzF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAM5E;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAClD,QAAQ,CAAC,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IACrD,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;IACpC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;IACxC,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,eAAe,GAAG,SAAS,CAAC;IACnD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,cAAc,GAAG,UAAU,CA2QjE"}

package/dist/step-pass-builder.js

@@ -0,0 +1,249 @@
+/* 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/. */
+import { getEffectiveEntityIndex } from './effective-index.js';
+import { createModificationLedger } from './delta-modification-ledger.js';
+import { createSourceRefReader } from './source-ref-bounds.js';
+import { buildStepHeader } from './step-header.js';
+export function buildExportPass(input) {
+    const { dataStore, mutationView, isGeometryEntity, options, schema, sourceSchema, converting, applyMutations, excludeGeometry, sourceHeader, schemaToken, } = input;
+    const pass = {
+        entities: [],
+        newEntityCount: 0,
+        schema,
+        sourceSchema,
+        converting,
+        sourceHeader,
+        schemaToken,
+        overlayActive: !!mutationView && applyMutations,
+        // Built once entity counts are known, so the provenance item can report the
+        // actual modification count. See the two call sites (empty delta + final).
+        // Body lives in `step-header.ts` (#2475 header/assembly tail): the
+        // closure still has to be built here, because it closes over this
+        // call's own `options`/`sourceHeader`/`schemaToken`, and both call
+        // sites still read it as `pass.buildHeader`.
+        buildHeader: (modifications) => buildStepHeader(options, sourceHeader, schemaToken, modifications),
+        // The one authority for exists / class / deleted, overlay first and source
+        // buffer second. Every pass below asks this instead of `dataStore`,
+        // which answers only for the file as parsed (#2012).
+        effective: getEffectiveEntityIndex(dataStore, mutationView, applyMutations),
+        // Does this id belong to an entity the OVERLAY created (`createEntity` /
+        // `store.addEntity`) rather than to a record in the source buffer? Such an
+        // entity has no source bytes, so the source-iteration pass below never sees
+        // it and the new-entities pass at the end owns its line entirely (#2006).
+        isOverlayCreated: (entityId) => pass.effective.isOverlayCreated(entityId),
+        // Does this record describe a line this export can actually READ out of the
+        // source? One predicate for every byte-range gate below, so they cannot
+        // disagree — see `source-ref-bounds.ts` for the corrupt file the weaker
+        // "is there a source / does the ref claim bytes" pair let through (#2491).
+        isReadableSourceRef: createSourceRefReader(dataStore.source),
+        // Build visible-only closure if requested. Classification, the closure walk
+        // and the style pass all run over the EFFECTIVE index: an overlay-created
+        // product becomes a root by the same type rules as a parsed one, the walk
+        // follows its authored references into the geometry it alone owns, and a
+        // tombstoned entity is simply not there. Run over the source buffer, a
+        // created wall could never be a root and nothing referenced it, so
+        // `visibleOnly` wrote a file without it and said nothing (#2012).
+        //
+        // Computed here, ahead of the modification-count passes below, because
+        // `hasEmittableHostBytes` needs it: a source-backed host EXCLUDED by
+        // `visibleOnly` never gets its line written by the source-iteration pass
+        // either, so counting it as "modified" would make the header claim a
+        // change the DATA section does not contain (CodeRabbit finding on #2414).
+        allowedEntityIds: null,
+        // Populated alongside `allowedEntityIds` below. `getVisibleEntityIds`
+        // excludes a hidden PRODUCT's own line from the closure, but `IFCREL*` is
+        // an unconditional root a few lines down and its bytes are copied verbatim
+        // by the source-iteration pass — nothing there filters a `#N` the closure
+        // just excluded out of the relationship's own attribute list. Kept because
+        // the closure walk's `isRefExcludedDuringClosureWalk` needs a notion of
+        // "hidden" that does not read `allowedEntityIds` — the set that walk is
+        // producing (#2398). The two OUTPUT passes no longer read this directly:
+        // they filter on `isOmittedFromOutput`, which subsumes it via
+        // `allowedEntityIds`.
+        hiddenProductIds: null,
+        // A relationship can name an excluded entity two ways that have nothing
+        // to do with each other: a `visibleOnly` hidden PRODUCT (`hiddenProductIds`,
+        // below), and a TOMBSTONED one — `editor.removeEntity` on a related object
+        // named by a relationship the deletion sweep below does not reach (that
+        // sweep only withholds an `IfcRelDefinesByProperties` when EVERY related
+        // object is gone, and only for that one relationship class). Left alone, a
+        // relationship still naming a deleted entity ships the identical `#N` with
+        // no `#N=` line, on a path with no `visibleOnly` involved at all (#2398).
+        // `effective.isDeleted` answers for every id, not just a precomputed set,
+        // so this predicate covers both sources without a second exclusion set.
+        //
+        // Declared here, ahead of the closure walk below, and passed into
+        // `collectReferencedEntityIds` as its `isRefExcluded` — rather than the
+        // walk inventing its own `!entityIndex.has` proxy for "deleted" that could
+        // disagree on an id that never existed in the file at all
+        // (maintainer-found regression on #2637: such an id blocked the bridge but
+        // did not stop the relationship's own line from shipping, dropping a
+        // VISIBLE sibling's pset while adding a fresh dangling ref). A closure over
+        // `pass.hiddenProductIds`, not a value snapshot — correct because nothing
+        // reads it before the closure walk assigns it just below.
+        //
+        // ## Why this is NOT the predicate the OUTPUT-line filter uses
+        //
+        // The name says walk, and only walk. The two passes that write a
+        // relationship's line ask `isOmittedFromOutput` (further below, derived
+        // from `pass.willBeEmitted`), which is strictly stronger — it also answers
+        // for the closure, for an unreadable source ref and for a geometry
+        // exclusion.
+        //
+        // This one CANNOT be `willBeEmitted`, and the difference is structural
+        // rather than stylistic: `willBeEmitted`'s first act is to consult
+        // `allowedEntityIds`, and `allowedEntityIds` is precisely what the call
+        // below is computing. Wiring it in here is circular: it would answer "not
+        // in the closure" as `false` while the closure is still being built and
+        // `true` for the same id afterwards.
+        //
+        // That is a genuine departure from the contract #2637 was closed on —
+        // `reference-collector.ts` still documents the bridge as taking the
+        // caller's OWN output predicate, "not two expressions that happened to
+        // agree". It has an OBSERVABLE consequence, not just a naming one: for an
+        // unreadable source ref this admits, the walk bridges through a
+        // relationship the output then withholds, leaving the relationship's other
+        // target in the closure with nothing naming it — an orphan, pinned by
+        // `unreadable-ref-dangling.test.ts` ("walk and output predicates diverge").
+        // The reverse direction is closed: every id this excludes,
+        // `isOmittedFromOutput` excludes too, so the #2548 leak cannot return.
+        isRefExcludedDuringClosureWalk: (id) => (pass.hiddenProductIds !== null && pass.hiddenProductIds.has(id))
+            || pass.effective.isDeleted(id),
+        // Will THIS entity's own line ever land in the file? The same byte-range
+        // test `willBeEmitted` uses (defined further below) and the source-
+        // iteration pass's own skip at `entityRef.byteLength === 0` — a source
+        // entity with no bytes (a point-cloud / GLB "entity" from
+        // `createSyntheticDataStore`, not an overlay-created one) never gets a
+        // defining line written, source-iteration or otherwise, so a pset/attribute
+        // edit against it must not count as a modification either: the header
+        // would describe a change the file does not contain (out-of-scope finding
+        // in #2398). Also excludes a source-backed host the visible-only closure
+        // above drops — same reasoning, different reason the line never lands.
+        //
+        // And, like `willBeEmitted` below, excludes a geometry-classified SOURCE
+        // host under `includeGeometry: false`: the source-iteration pass's own
+        // `isGeometryEntity` skip (further below) drops that line too, so this
+        // predicate must agree or a geometry entity's attribute edit inflates the
+        // count over an omitted line (CodeRabbit finding on #2414). Guarded by
+        // `!deltaOnly` for the same reason `willBeEmitted` is: under `deltaOnly`
+        // the source-iteration pass — and its geometry skip — never runs at all,
+        // so a source entity's line is assumed to already exist in the file being
+        // patched, geometry or not.
+        isGeometryExcluded: (entityId, recordType) => excludeGeometry
+            && isGeometryEntity(pass.effective.effectiveType(entityId, recordType)),
+        hasEmittableHostBytes: (entityId) => {
+            if (pass.allowedEntityIds !== null && !pass.allowedEntityIds.has(entityId))
+                return false;
+            const ref = pass.effective.get(entityId);
+            // The ref must be READABLE, not merely non-empty: a range this source
+            // cannot address decodes to the empty string, which used to be pushed
+            // into the file as a blank line while everything generated FOR the host
+            // still named it (#2491).
+            if (!ref || !pass.isReadableSourceRef(ref))
+                return false;
+            if (options.deltaOnly !== true && pass.isGeometryExcluded(entityId, ref.type))
+                return false;
+            return true;
+        },
+        /**
+         * Will this id have a defining STEP line in the output at all?
+         *
+         * The predicate is #2030's, and it is the right one: the pset, quantity and
+         * type-owned passes below are built from unfiltered mutation history, and
+         * what each of them needs to know before emitting an
+         * `IFCRELDEFINESBYPROPERTIES` is not "was this deleted" or "is this hidden"
+         * but the general question those are two answers to. A relation naming an
+         * expressId that never gets written is a dangling reference and an invalid
+         * file, whichever route dropped the line.
+         *
+         * #2030 had to reach for four things to answer it — a tombstone probe, a
+         * visibility set, a byte-range test on `completeIndex`, and a `getNewEntity`
+         * fallback whose stated purpose was that `deleteEntity` FORGOT an
+         * overlay-created entity instead of tombstoning it, so `isDeleted` could not
+         * answer for one. That fallback was documented on main as a workaround for
+         * exactly the model-level defect this branch fixes: `deleteEntity` now
+         * tombstones as well as forgets, so the effective index answers existence
+         * for source and overlay ids alike and the workaround collapses into it.
+         *
+         * The overlay branch does NOT disappear with it, and the distinction matters:
+         * `isOverlayCreated` is still load-bearing here, because a live
+         * overlay-created entity has no source bytes and would fail the byte-range
+         * test that a source record passes. What the tombstone fix removed is the
+         * need for that branch to double as a deletion detector.
+         *
+         * Deliberately unchanged from #2030 for source records under `deltaOnly` /
+         * `exportPropertiesOnly`: the source-iteration pass is skipped wholesale in
+         * those modes, yet a source entity still answers true here. A delta is a
+         * patch against a file that already has the line, not a standalone model.
+         */
+        willBeEmitted: (entityId) => {
+            if (pass.allowedEntityIds !== null && !pass.allowedEntityIds.has(entityId))
+                return false;
+            // Undefined for a tombstoned id and for one neither the file nor the
+            // session ever had — a stale mutation must not conjure a relation either.
+            const ref = pass.effective.get(entityId);
+            if (!ref)
+                return false;
+            // An overlay-created record carries the placeholder byte range and is
+            // written by the new-entities pass; a source record needs real bytes.
+            if (pass.effective.isOverlayCreated(entityId)) {
+                // The overlay new-entities pass applies its OWN `isGeometryEntity`
+                // filter unconditionally — deltaOnly or not (see the comment at that
+                // loop, further below) — so this branch mirrors it without the
+                // deltaOnly carve-out the source branch gets.
+                return !pass.isGeometryExcluded(entityId, ref.type);
+            }
+            // Same readability test as `hasEmittableHostBytes`, and for the reason
+            // that predicate names: a ref this source cannot address is not a line
+            // this export can write, so nothing may be generated naming it (#2491).
+            if (!pass.isReadableSourceRef(ref))
+                return false;
+            // Mirrors `hasEmittableHostBytes`: under `deltaOnly` the source-
+            // iteration pass — and its geometry skip — never runs, so a source
+            // entity's line is assumed to already exist in the file being patched.
+            if (options.deltaOnly === true)
+                return true;
+            return !pass.isGeometryExcluded(entityId, ref.type);
+        },
+        // Under `deltaOnly` a nomination only becomes a count once some pass has
+        // actually written content that delivers THAT KIND of edit for the host —
+        // see `delta-modification-ledger.ts` for why the two are not the same event
+        // in that mode, and why the pair is (entity, kind) rather than the entity
+        // (#2462).
+        modifications: createModificationLedger(options.deltaOnly === true),
+        /**
+         * Hosts whose in-place named-attribute edits a FULL export may count, per
+         * kind. Filled by the collection passes below and read by the two passes
+         * that write a rewritten source line — see `in-place-nomination.ts` for why
+         * the nomination waits for the rewrite in this mode and not under
+         * `deltaOnly` (#2483).
+         */
+        inPlaceNominees: {
+            attribute: new Set(),
+            georeferencing: new Set(),
+        },
+        // Collect entities that need to be modified or created
+        modifiedEntities: new Set(),
+        modifiedAttributes: new Map(),
+        newPropertySets: [],
+        newQuantitySets: [],
+        typeOwnedPsetNamesByEntity: new Map(),
+        typeOwnedPsetIdsByEntity: new Map(),
+        rewrittenEntityIds: new Set(),
+        rewrittenEntityLines: new Map(),
+        /** HasPropertySets slot value for an OVERLAY-CREATED type object, applied
+         *  by the new-entities pass (there is no source line to rewrite). */
+        overlayTypeOwnedPsets: new Map(),
+        // Track property set IDs and relationship IDs to skip
+        skipPropertySetIds: new Set(),
+        skipRelationshipIds: new Set(),
+        // Written by the georeferencing pass and read again by the final
+        // assembly, which is why they are pass state and not phase locals.
+        newGeorefLines: [],
+        warnings: [],
+    };
+    // The same object, deliberately. See the file header.
+    return pass;
+}
+//# sourceMappingURL=step-pass-builder.js.map

package/dist/step-pass-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-pass-builder.js","sourceRoot":"","sources":["../src/step-pass-builder.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAyB/D,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAuBnD,MAAM,UAAU,eAAe,CAAC,KAAqB;IACnD,MAAM,EACJ,SAAS,EACT,YAAY,EACZ,gBAAgB,EAChB,OAAO,EACP,MAAM,EACN,YAAY,EACZ,UAAU,EACV,cAAc,EACd,eAAe,EACf,YAAY,EACZ,WAAW,GACZ,GAAG,KAAK,CAAC;IAEV,MAAM,IAAI,GAAe;QACvB,QAAQ,EAAE,EAAE;QACZ,cAAc,EAAE,CAAC;QACjB,MAAM;QACN,YAAY;QACZ,UAAU;QACV,YAAY;QACZ,WAAW;QACX,aAAa,EAAE,CAAC,CAAC,YAAY,IAAI,cAAc;QAE/C,4EAA4E;QAC5E,2EAA2E;QAC3E,mEAAmE;QACnE,kEAAkE;QAClE,mEAAmE;QACnE,6CAA6C;QAC7C,WAAW,EAAE,CAAC,aAAqB,EAAU,EAAE,CAC7C,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,aAAa,CAAC;QAEpE,2EAA2E;QAC3E,oEAAoE;QACpE,qDAAqD;QACrD,SAAS,EAAE,uBAAuB,CAChC,SAAS,EACT,YAAY,EACZ,cAAc,CACf;QAED,yEAAyE;QACzE,2EAA2E;QAC3E,4EAA4E;QAC5E,0EAA0E;QAC1E,gBAAgB,EAAE,CAAC,QAAgB,EAAW,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,QAAQ,CAAC;QAE1F,4EAA4E;QAC5E,wEAAwE;QACxE,wEAAwE;QACxE,2EAA2E;QAC3E,mBAAmB,EAAE,qBAAqB,CAAC,SAAS,CAAC,MAAM,CAAC;QAE5D,4EAA4E;QAC5E,0EAA0E;QAC1E,0EAA0E;QAC1E,yEAAyE;QACzE,uEAAuE;QACvE,mEAAmE;QACnE,kEAAkE;QAClE,EAAE;QACF,uEAAuE;QACvE,qEAAqE;QACrE,yEAAyE;QACzE,qEAAqE;QACrE,0EAA0E;QAC1E,gBAAgB,EAAE,IAAI;QAEtB,sEAAsE;QACtE,0EAA0E;QAC1E,2EAA2E;QAC3E,0EAA0E;QAC1E,2EAA2E;QAC3E,wEAAwE;QACxE,wEAAwE;QACxE,yEAAyE;QACzE,8DAA8D;QAC9D,sBAAsB;QACtB,gBAAgB,EAAE,IAAI;QAEtB,wEAAwE;QACxE,6EAA6E;QAC7E,2EAA2E;QAC3E,wEAAwE;QACxE,yEAAyE;QACzE,2EAA2E;QAC3E,2EAA2E;QAC3E,0EAA0E;QAC1E,0EAA0E;QAC1E,wEAAwE;QACxE,EAAE;QACF,kEAAkE;QAClE,wEAAwE;QACxE,2EAA2E;QAC3E,0DAA0D;QAC1D,2EAA2E;QAC3E,qEAAqE;QACrE,4EAA4E;QAC5E,0EAA0E;QAC1E,0DAA0D;QAC1D,EAAE;QACF,+DAA+D;QAC/D,EAAE;QACF,iEAAiE;QACjE,wEAAwE;QACxE,2EAA2E;QAC3E,mEAAmE;QACnE,aAAa;QACb,EAAE;QACF,uEAAuE;QACvE,mEAAmE;QACnE,wEAAwE;QACxE,0EAA0E;QAC1E,wEAAwE;QACxE,qCAAqC;QACrC,EAAE;QACF,sEAAsE;QACtE,oEAAoE;QACpE,uEAAuE;QACvE,0EAA0E;QAC1E,gEAAgE;QAChE,2EAA2E;QAC3E,sEAAsE;QACtE,4EAA4E;QAC5E,2DAA2D;QAC3D,uEAAuE;QACvE,8BAA8B,EAAE,CAAC,EAAU,EAAW,EAAE,CACtD,CAAC,IAAI,CAAC,gBAAgB,KAAK,IAAI,IAAI,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;eAC9D,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC;QAEjC,yEAAyE;QACzE,oEAAoE;QACpE,uEAAuE;QACvE,0DAA0D;QAC1D,uEAAuE;QACvE,4EAA4E;QAC5E,sEAAsE;QACtE,0EAA0E;QAC1E,yEAAyE;QACzE,uEAAuE;QACvE,EAAE;QACF,yEAAyE;QACzE,uEAAuE;QACvE,uEAAuE;QACvE,0EAA0E;QAC1E,uEAAuE;QACvE,yEAAyE;QACzE,yEAAyE;QACzE,0EAA0E;QAC1E,4BAA4B;QAC5B,kBAAkB,EAAE,CAAC,QAAgB,EAAE,UAAkB,EAAW,EAAE,CACpE,eAAe;eACZ,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QACzE,qBAAqB,EAAE,CAAC,QAAgB,EAAW,EAAE;YACnD,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,QAAQ,CAAC;gBAAE,OAAO,KAAK,CAAC;YACzF,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACzC,sEAAsE;YACtE,sEAAsE;YACtE,wEAAwE;YACxE,0BAA0B;YAC1B,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC;gBAAE,OAAO,KAAK,CAAC;YACzD,IAAI,OAAO,CAAC,SAAS,KAAK,IAAI,IAAI,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,CAAC;gBAAE,OAAO,KAAK,CAAC;YAC5F,OAAO,IAAI,CAAC;QACd,CAAC;QAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA8BG;QACH,aAAa,EAAE,CAAC,QAAgB,EAAW,EAAE;YAC3C,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,QAAQ,CAAC;gBAAE,OAAO,KAAK,CAAC;YACzF,qEAAqE;YACrE,0EAA0E;YAC1E,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACzC,IAAI,CAAC,GAAG;gBAAE,OAAO,KAAK,CAAC;YACvB,sEAAsE;YACtE,sEAAsE;YACtE,IAAI,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC9C,mEAAmE;gBACnE,qEAAqE;gBACrE,+DAA+D;gBAC/D,8CAA8C;gBAC9C,OAAO,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;YACtD,CAAC;YACD,uEAAuE;YACvE,uEAAuE;YACvE,wEAAwE;YACxE,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC;gBAAE,OAAO,KAAK,CAAC;YACjD,iEAAiE;YACjE,mEAAmE;YACnE,uEAAuE;YACvE,IAAI,OAAO,CAAC,SAAS,KAAK,IAAI;gBAAE,OAAO,IAAI,CAAC;YAC5C,OAAO,CAAC,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;QACtD,CAAC;QAED,yEAAyE;QACzE,0EAA0E;QAC1E,4EAA4E;QAC5E,0EAA0E;QAC1E,WAAW;QACX,aAAa,EAAE,wBAAwB,CAAC,OAAO,CAAC,SAAS,KAAK,IAAI,CAAC;QAEnE;;;;;;WAMG;QACH,eAAe,EAAE;YACf,SAAS,EAAE,IAAI,GAAG,EAAU;YAC5B,cAAc,EAAE,IAAI,GAAG,EAAU;SAClC;QAED,uDAAuD;QACvD,gBAAgB,EAAE,IAAI,GAAG,EAAU;QACnC,kBAAkB,EAAE,IAAI,GAAG,EAA+B;QAC1D,eAAe,EAAE,EAAE;QACnB,eAAe,EAAE,EAAE;QACnB,0BAA0B,EAAE,IAAI,GAAG,EAAuB;QAC1D,wBAAwB,EAAE,IAAI,GAAG,EAAoB;QACrD,kBAAkB,EAAE,IAAI,GAAG,EAAU;QACrC,oBAAoB,EAAE,IAAI,GAAG,EAAkB;QAC/C;6EACqE;QACrE,qBAAqB,EAAE,IAAI,GAAG,EAA6B;QAE3D,sDAAsD;QACtD,kBAAkB,EAAE,IAAI,GAAG,EAAU;QACrC,mBAAmB,EAAE,IAAI,GAAG,EAAU;QAEtC,iEAAiE;QACjE,mEAAmE;QACnE,cAAc,EAAE,EAAE;QAClB,QAAQ,EAAE,EAAE;KACb,CAAC;IACF,sDAAsD;IACtD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/step-property-sets.d.ts

@@ -29,8 +29,10 @@
  * exported for the mirror-image reason: the collection loops consume its
  * `byEntity` half, but `export()` reads `relatedByRel` for the deleted-host
  * relationship sweep, which is neither phase's work.
- * `StepExporter.applySourceLineMutations` is shared with the source-iteration
- * pass, so it is injected on the context rather than moved.
+ * `step-attribute-mutations.ts`'s `applySourceLineMutations` (moved off
+ * `StepExporter` by #2475's "remaining private helpers" step) is shared with
+ * the source-iteration pass, so it is injected on the context rather than
+ * imported directly.
  *
  * ## The state these phases cannot read off the pass
  *
@@ -83,9 +85,9 @@ export interface PropertySetContext {
     /** `() => this.nextExpressId++` on the exporter. */
     readonly allocateExpressId: () => number;
     readonly ownerHistory: OwnerHistoryCache;
-    /** `StepExporter.applySourceLineMutations`: the ONE pipeline the
-     *  source-iteration pass and the type-object rewrite share, so it belongs to
-     *  neither phase and is injected instead of moved. */
+    /** `step-attribute-mutations.ts`'s `applySourceLineMutations`: the ONE
+     *  pipeline the source-iteration pass and the type-object rewrite share, so
+     *  it belongs to neither phase and is injected. */
     readonly applySourceLineMutations: (expressId: number, entityText: string, recordType: string, attributeMutations: Map<string, string> | undefined, sourceSchema: IfcSchemaVersion, overlayActive: boolean, onRejected?: (attrName: string, value: string) => void) => SourceLineMutations;
 }
 /** The mutation groupings `export()` builds before the collection phase runs. */

package/dist/step-property-sets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step-property-sets.d.ts","sourceRoot":"","sources":["../src/step-property-sets.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"step-property-sets.d.ts","sourceRoot":"","sources":["../src/step-property-sets.ts"],"names":[],"mappings":"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"}