@ifc-lite/export 2.9.4 → 3.0.1

package/dist/step-attribute-mutations.d.ts

@@ -0,0 +1,49 @@
+import type { MutablePropertyView } from '@ifc-lite/mutations';
+import type { IfcSchemaVersion } from './schema-converter.js';
+import type { SourceLineMutations } from './step-exporter.js';
+/**
+ * THE mutation pipeline for a line read out of the source buffer: retype,
+ * then named attribute edits, then positional edits.
+ *
+ * **One implementation, two call sites**, and that is the whole point. Two
+ * passes can write the defining line of a source entity — the
+ * source-iteration pass, and the type-object `HasPropertySets` rewrite that
+ * REPLACES it (`rewrittenEntityIds` makes the source pass skip those ids).
+ * The rewrite used to do its own thing (replace slot 5, nothing else), so
+ * every other edit to a type object with a type-owned pset edit was dropped
+ * in silence: first the renames (#2462 follow-up), and after those were
+ * special-cased here, still the retypes and the positional edits. Whatever
+ * the source pass applies, the rewrite has to apply too, or the next edit
+ * kind added to one site goes missing at the other.
+ *
+ * The order is load-bearing:
+ *
+ *   - the retype runs FIRST so named attribute edits resolve against the
+ *     TARGET class's attribute names, and so positional slots are indexed
+ *     into the retyped argument list;
+ *   - the `HasPropertySets` replacement (rewrite path only) runs LAST, on
+ *     the text this returns. Run it first and a positional edit to slot 5 —
+ *     or a retype's argument-list rebuild — overwrites the resolved pset
+ *     list with the stale one, which is the same silent drop one slot over.
+ *
+ * The expressId is unchanged by all of this, so geometry / placement /
+ * representation and every IfcRel* reference (keyed by #id) carry over.
+ *
+ * All three flags report EFFECT, not intent — each is the answer to "did this
+ * operation change the line", measured across that operation alone. The count
+ * and the ledger are claims about the FILE, so an edit that resolves to the
+ * text already there has delivered nothing and must not be reported: retyping
+ * an entity to the class it already is, or writing a positional slot the token
+ * it already holds, used to count as a modification and reach the ledger as a
+ * landed edit, over a byte-identical line. Discarded edits read the same way:
+ * `applyAttributeMutations` drops a name its class has no slot for and
+ * `retypeStepLine` returns an unparseable line untouched, and neither is a
+ * modification of anything.
+ *
+ * `retyped` / `positional` matter most in a FULL export, which is where the
+ * two are nominated (their edits have no earlier nomination site); named
+ * attribute edits are nominated by the collection pass and `attributed` only
+ * settles their delivery.
+ */
+export declare function applySourceLineMutations(mutationView: MutablePropertyView | null, expressId: number, entityText: string, recordType: string, attributeMutations: Map<string, string> | undefined, sourceSchema: IfcSchemaVersion, overlayActive: boolean, onRejected?: (attrName: string, value: string) => void): SourceLineMutations;
+//# sourceMappingURL=step-attribute-mutations.d.ts.map

package/dist/step-attribute-mutations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-attribute-mutations.d.ts","sourceRoot":"","sources":["../src/step-attribute-mutations.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,mBAAmB,GAAG,IAAI,EACxC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACnD,YAAY,EAAE,gBAAgB,EAC9B,aAAa,EAAE,OAAO,EACtB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GACrD,mBAAmB,CAmDrB"}

package/dist/step-attribute-mutations.js

@@ -0,0 +1,172 @@
+/* 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/. */
+/**
+ * THE source-buffer attribute-mutation pipeline: retype, then named
+ * attribute edits, then positional edits, applied to a line read out of the
+ * STEP source. Both {@link applySourceLineMutations}'s call sites — the
+ * source-iteration pass and the type-object `HasPropertySets` rewrite that
+ * REPLACES it — are documented on the function itself.
+ *
+ * This file used to also hold the overlay-created sibling pipeline and the
+ * two per-slot serialize helpers both pipelines share; #3184 split those out
+ * along the line this module's own doc already drew — the overlay-created
+ * pipeline is now `step-overlay-attribute-overrides.ts`, and the shared
+ * serializers are `step-attribute-serializers.ts`.
+ */
+import { splitTopLevelArgs } from './step-argument-parser.js';
+import { getRealTypedSlots } from './attribute-real-slots.js';
+import { retypeStepLine } from './retype.js';
+import { getAttributeNamesAcrossSchemas } from '@ifc-lite/parser';
+import { serializeNamedAttribute, serializePositionalOverride } from './step-attribute-serializers.js';
+/**
+ * THE mutation pipeline for a line read out of the source buffer: retype,
+ * then named attribute edits, then positional edits.
+ *
+ * **One implementation, two call sites**, and that is the whole point. Two
+ * passes can write the defining line of a source entity — the
+ * source-iteration pass, and the type-object `HasPropertySets` rewrite that
+ * REPLACES it (`rewrittenEntityIds` makes the source pass skip those ids).
+ * The rewrite used to do its own thing (replace slot 5, nothing else), so
+ * every other edit to a type object with a type-owned pset edit was dropped
+ * in silence: first the renames (#2462 follow-up), and after those were
+ * special-cased here, still the retypes and the positional edits. Whatever
+ * the source pass applies, the rewrite has to apply too, or the next edit
+ * kind added to one site goes missing at the other.
+ *
+ * The order is load-bearing:
+ *
+ *   - the retype runs FIRST so named attribute edits resolve against the
+ *     TARGET class's attribute names, and so positional slots are indexed
+ *     into the retyped argument list;
+ *   - the `HasPropertySets` replacement (rewrite path only) runs LAST, on
+ *     the text this returns. Run it first and a positional edit to slot 5 —
+ *     or a retype's argument-list rebuild — overwrites the resolved pset
+ *     list with the stale one, which is the same silent drop one slot over.
+ *
+ * The expressId is unchanged by all of this, so geometry / placement /
+ * representation and every IfcRel* reference (keyed by #id) carry over.
+ *
+ * All three flags report EFFECT, not intent — each is the answer to "did this
+ * operation change the line", measured across that operation alone. The count
+ * and the ledger are claims about the FILE, so an edit that resolves to the
+ * text already there has delivered nothing and must not be reported: retyping
+ * an entity to the class it already is, or writing a positional slot the token
+ * it already holds, used to count as a modification and reach the ledger as a
+ * landed edit, over a byte-identical line. Discarded edits read the same way:
+ * `applyAttributeMutations` drops a name its class has no slot for and
+ * `retypeStepLine` returns an unparseable line untouched, and neither is a
+ * modification of anything.
+ *
+ * `retyped` / `positional` matter most in a FULL export, which is where the
+ * two are nominated (their edits have no earlier nomination site); named
+ * attribute edits are nominated by the collection pass and `attributed` only
+ * settles their delivery.
+ */
+export function applySourceLineMutations(mutationView, expressId, entityText, recordType, attributeMutations, sourceSchema, overlayActive, onRejected) {
+    let text = entityText;
+    let workingType = recordType.toUpperCase();
+    const typeMutation = overlayActive && typeof mutationView.getEntityTypeMutation === 'function'
+        ? mutationView.getEntityTypeMutation(expressId)
+        : null;
+    let retyped = false;
+    if (typeMutation) {
+        const beforeRetype = text;
+        text = retypeStepLine(text, recordType, typeMutation.newType, typeMutation.predefinedType ?? null, sourceSchema);
+        retyped = text !== beforeRetype;
+        // Set even for a no-op retype: the entity IS the target class from here
+        // on, so the named and positional edits below must resolve against it.
+        workingType = typeMutation.newType.toUpperCase();
+    }
+    // `applyAttributeMutations` returns its input UNCHANGED when it wrote
+    // nothing — no slot resolved for any of the names, or the line does not
+    // parse — so comparing is what tells the ledger whether a named attribute
+    // edit was really carried, rather than merely attempted.
+    let attributed = false;
+    if (attributeMutations && attributeMutations.size > 0) {
+        const beforeAttributes = text;
+        text = applyAttributeMutations(text, workingType, attributeMutations, sourceSchema, onRejected);
+        attributed = text !== beforeAttributes;
+    }
+    const positionals = overlayActive && typeof mutationView.getPositionalMutationsForEntity === 'function'
+        ? mutationView.getPositionalMutationsForEntity(expressId)
+        : null;
+    let positional = false;
+    if (positionals && positionals.size > 0) {
+        const beforePositionals = text;
+        text = applyPositionalMutations(text, positionals, workingType, sourceSchema);
+        positional = text !== beforePositionals;
+    }
+    return { text, attributed, retyped, positional };
+}
+/**
+ * Rewrite root IFC attributes directly on the original STEP entity line.
+ */
+function applyAttributeMutations(entityText, entityType, attributeMutations, schemaVersion, onRejected) {
+    const openParen = entityText.indexOf('(');
+    const closeParen = entityText.lastIndexOf(');');
+    if (openParen < 0 || closeParen < openParen) {
+        return entityText;
+    }
+    // Cross-schema, not the IFC4 pin: an IFC4X3-only class (IfcCourse, IfcRoad,
+    // IfcBridge, …) resolves no slots under the pin, so every named edit on one
+    // was silently discarded here too. Identical for the 755 pinned classes
+    // that declare attributes — `attribute-slot-types.test.ts` measures that —
+    // so no IFC4 export changes; this only stops dropping edits it used to drop.
+    const attrNames = getAttributeNamesAcrossSchemas(entityType);
+    if (attrNames.length === 0) {
+        return entityText;
+    }
+    const args = splitTopLevelArgs(entityText.slice(openParen + 1, closeParen));
+    // A source line NEVER pads (unlike the overlay-created path): a short
+    // argument list here means the file speaks a different schema, and growing
+    // a record we did not author would corrupt it.
+    let changed = false;
+    const realSlots = getRealTypedSlots(entityType, schemaVersion);
+    for (const [attrName, value] of attributeMutations) {
+        const index = attrNames.indexOf(attrName);
+        if (index < 0 || index >= args.length)
+            continue;
+        // The source path shares every `$`-slot hole with the overlay-created
+        // path, because a source record has plenty of `$` slots of its own. Both
+        // go through the one helper below.
+        const serialized = serializeNamedAttribute(entityType, index, value, args[index], realSlots);
+        if (serialized === null) {
+            // Slot untouched AND reported. Not counted as a change: claiming a
+            // modification we did not make is the failure this avoids.
+            onRejected?.(attrName, value);
+            continue;
+        }
+        args[index] = serialized;
+        changed = true;
+    }
+    if (!changed) {
+        return entityText;
+    }
+    return `${entityText.slice(0, openParen + 1)}${args.join(',')}${entityText.slice(closeParen)}`;
+}
+/**
+ * Apply positional STEP argument overrides to an entity line.
+ * Used for non-IfcRoot edits (e.g. profile dimensions) where attributes
+ * have no symbolic names. Indexes that fall outside the existing arg list
+ * are silently ignored.
+ */
+function applyPositionalMutations(entityText, positionals, entityType, schemaVersion) {
+    const openParen = entityText.indexOf('(');
+    const closeParen = entityText.lastIndexOf(');');
+    if (openParen < 0 || closeParen < openParen)
+        return entityText;
+    const args = splitTopLevelArgs(entityText.slice(openParen + 1, closeParen));
+    const realSlots = getRealTypedSlots(entityType, schemaVersion);
+    let changed = false;
+    for (const [index, value] of positionals) {
+        if (index < 0 || index >= args.length)
+            continue;
+        args[index] = serializePositionalOverride(entityType, index, value, args[index], realSlots, schemaVersion);
+        changed = true;
+    }
+    if (!changed)
+        return entityText;
+    return `${entityText.slice(0, openParen + 1)}${args.join(',')}${entityText.slice(closeParen)}`;
+}
+//# sourceMappingURL=step-attribute-mutations.js.map

package/dist/step-attribute-mutations.js.map

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

package/dist/step-attribute-serializers.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The two per-slot serialize helpers `step-attribute-mutations.ts`'s
+ * source-buffer pipeline and `step-overlay-attribute-overrides.ts`'s
+ * overlay-created pipeline both go through — the single point where a named
+ * or positional override becomes a STEP token. Split out of
+ * `step-attribute-mutations.ts` (#3184).
+ */
+import type { IfcAttributeValue } from '@ifc-lite/parser';
+import type { IfcSchemaVersion } from './schema-converter.js';
+/**
+ * Serialize one NAMED attribute override into its slot — the single point
+ * both the source-buffer rewrite and the overlay-created rewrite go through.
+ *
+ * `serializeAttributeValue` decides the STEP form by reading the token being
+ * replaced, which is sound only while that token carries type information. A
+ * `$` slot carries none, and both paths have plenty: a source record's
+ * optional attributes are `$`, and overlay-created records pad missing slots
+ * with `$`. So the declared type decides first, and inference is the fallback
+ * for slots the schema does not classify (references, SELECTs, numerics),
+ * where reading the old token is exactly the right heuristic.
+ *
+ * Before this REAL check existed, "the declared type decides first" was true
+ * for enum/string slots only — a REAL-backed slot (`IfcMapConversion.
+ * OrthogonalHeight`, any other `IfcLengthMeasure`/`IfcReal`-typed attribute)
+ * fell straight to `serializeAttributeValue`'s token inference, which quotes
+ * anything it cannot recognize as numeric. A schema-legal `$` placeholder
+ * carries no digits to recognize, so setting such a field for the first time
+ * wrote `'12345'` in a slot ISO 10303-21 requires to be an unquoted REAL —
+ * silently invalid output (#2724, LTplus-AG/ifc-lite#2475).
+ */
+export declare function serializeNamedAttribute(entityType: string, index: number, value: string, currentToken: string, realSlots: ReadonlySet<number>): string | null;
+/**
+ * Serialize one positional override, composing the schema-aware passes:
+ * explicit `{ real }`/`{ typed }` marker → SELECT auto-qualification
+ * (`IFCBOOLEAN(.T.)`) → REAL forcing. For REAL forcing the current source
+ * token is a secondary signal: replacing a value that was already a REAL
+ * (`0.4`, `1.5E-7`) keeps it REAL even for entities the XSD index doesn't
+ * cover, so a whole-number edit can't silently downgrade the slot.
+ */
+export declare function serializePositionalOverride(entityType: string, index: number, value: IfcAttributeValue, currentToken: string, realSlots: ReadonlySet<number>, schemaVersion: IfcSchemaVersion): string;
+//# sourceMappingURL=step-attribute-serializers.d.ts.map

package/dist/step-attribute-serializers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-attribute-serializers.d.ts","sourceRoot":"","sources":["../src/step-attribute-serializers.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAU1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,GAC7B,MAAM,GAAG,IAAI,CAuBf;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,iBAAiB,EACxB,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,EAC9B,aAAa,EAAE,gBAAgB,GAC9B,MAAM,CAMR"}

package/dist/step-attribute-serializers.js

@@ -0,0 +1,74 @@
+/* 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 { getEnumTypedSlots, getStringTypedSlots, serializeEnumToken, serializeStringSlot } from './attribute-slot-types.js';
+import { isTypedMarker } from './attribute-real-slots.js';
+import { serializeQualifiedSelectSlot } from './select-qualification.js';
+import { toStepReal, serializeAttributeValue, serializeStepValue, tokenIsRealLiteral, } from './step-serialization.js';
+/**
+ * Serialize one NAMED attribute override into its slot — the single point
+ * both the source-buffer rewrite and the overlay-created rewrite go through.
+ *
+ * `serializeAttributeValue` decides the STEP form by reading the token being
+ * replaced, which is sound only while that token carries type information. A
+ * `$` slot carries none, and both paths have plenty: a source record's
+ * optional attributes are `$`, and overlay-created records pad missing slots
+ * with `$`. So the declared type decides first, and inference is the fallback
+ * for slots the schema does not classify (references, SELECTs, numerics),
+ * where reading the old token is exactly the right heuristic.
+ *
+ * Before this REAL check existed, "the declared type decides first" was true
+ * for enum/string slots only — a REAL-backed slot (`IfcMapConversion.
+ * OrthogonalHeight`, any other `IfcLengthMeasure`/`IfcReal`-typed attribute)
+ * fell straight to `serializeAttributeValue`'s token inference, which quotes
+ * anything it cannot recognize as numeric. A schema-legal `$` placeholder
+ * carries no digits to recognize, so setting such a field for the first time
+ * wrote `'12345'` in a slot ISO 10303-21 requires to be an unquoted REAL —
+ * silently invalid output (#2724, LTplus-AG/ifc-lite#2475).
+ */
+export function serializeNamedAttribute(entityType, index, value, currentToken, realSlots) {
+    if (getEnumTypedSlots(entityType).has(index))
+        return serializeEnumToken(value);
+    if (getStringTypedSlots(entityType).has(index))
+        return serializeStringSlot(value);
+    if (realSlots.has(index)) {
+        const trimmed = value.trim();
+        if (trimmed === '')
+            return '$';
+        const numberValue = Number(trimmed);
+        if (Number.isFinite(numberValue))
+            return toStepReal(numberValue);
+        // A non-numeric value in a REAL slot used to fall through and be QUOTED,
+        // producing the same ISO 10303-21 violation #2725 exists to prevent
+        // (#2741). `StoreEditor.setAttribute` takes a string, so any UI text
+        // field bound to a georeferencing REAL can deliver one; it does not need
+        // a corrupt file.
+        //
+        // `null` means "leave the slot as the file had it". Simply returning
+        // `currentToken` here would stop the invalid output but SILENTLY DISCARD
+        // the edit - the exporter would then claim a modification it did not
+        // carry, which is the exact misreport #2723/#2724/#2726 were written to
+        // pin. The caller turns this into a warning, so a dropped edit is visible
+        // rather than inferred from absence.
+        return null;
+    }
+    return serializeAttributeValue(value, currentToken);
+}
+/**
+ * Serialize one positional override, composing the schema-aware passes:
+ * explicit `{ real }`/`{ typed }` marker → SELECT auto-qualification
+ * (`IFCBOOLEAN(.T.)`) → REAL forcing. For REAL forcing the current source
+ * token is a secondary signal: replacing a value that was already a REAL
+ * (`0.4`, `1.5E-7`) keeps it REAL even for entities the XSD index doesn't
+ * cover, so a whole-number edit can't silently downgrade the slot.
+ */
+export function serializePositionalOverride(entityType, index, value, currentToken, realSlots, schemaVersion) {
+    if (isTypedMarker(value))
+        return serializeStepValue(value);
+    const qualified = serializeQualifiedSelectSlot(entityType, index, value);
+    if (qualified !== null)
+        return qualified;
+    const forceReal = realSlots.has(index) || tokenIsRealLiteral(currentToken);
+    return serializeStepValue(value, forceReal);
+}
+//# sourceMappingURL=step-attribute-serializers.js.map

package/dist/step-attribute-serializers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-attribute-serializers.js","sourceRoot":"","sources":["../src/step-attribute-serializers.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAW/D,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAC5H,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,4BAA4B,EAAE,MAAM,2BAA2B,CAAC;AACzE,OAAO,EACL,UAAU,EACV,uBAAuB,EACvB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,yBAAyB,CAAC;AAGjC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,uBAAuB,CACrC,UAAkB,EAClB,KAAa,EACb,KAAa,EACb,YAAoB,EACpB,SAA8B;IAE9B,IAAI,iBAAiB,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,OAAO,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAC/E,IAAI,mBAAmB,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,OAAO,mBAAmB,CAAC,KAAK,CAAC,CAAC;IAClF,IAAI,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;QAC7B,IAAI,OAAO,KAAK,EAAE;YAAE,OAAO,GAAG,CAAC;QAC/B,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;QACpC,IAAI,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC;YAAE,OAAO,UAAU,CAAC,WAAW,CAAC,CAAC;QACjE,yEAAyE;QACzE,oEAAoE;QACpE,qEAAqE;QACrE,yEAAyE;QACzE,kBAAkB;QAClB,EAAE;QACF,qEAAqE;QACrE,yEAAyE;QACzE,qEAAqE;QACrE,wEAAwE;QACxE,0EAA0E;QAC1E,qCAAqC;QACrC,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,uBAAuB,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,2BAA2B,CACzC,UAAkB,EAClB,KAAa,EACb,KAAwB,EACxB,YAAoB,EACpB,SAA8B,EAC9B,aAA+B;IAE/B,IAAI,aAAa,CAAC,KAAK,CAAC;QAAE,OAAO,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAC3D,MAAM,SAAS,GAAG,4BAA4B,CAAC,UAAU,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IACzE,IAAI,SAAS,KAAK,IAAI;QAAE,OAAO,SAAS,CAAC;IACzC,MAAM,SAAS,GAAG,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,kBAAkB,CAAC,YAAY,CAAC,CAAC;IAC3E,OAAO,kBAAkB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;AAC9C,CAAC"}

package/dist/step-collection.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The collection phase of `StepExporter.export()` (#2475, the collection
+ * block): builds the visible-only closure (`pass.allowedEntityIds` /
+ * `hiddenProductIds`), groups the overlay's mutation history by entity and
+ * kind, and applies the georeferencing edits. Nothing here WRITES a STEP
+ * line — every write happens in a later phase (`step-source-iteration.ts`,
+ * `step-property-sets.ts`, `step-georeferencing.ts`'s own new-entity lines,
+ * `step-overlay-entities.ts`) that reads what this phase left on `pass`.
+ *
+ * `PropertyMutationGroups` (`step-property-set-collection.ts`) already names the
+ * boundary this module sits behind: "the mutation groupings `export()`
+ * builds before the collection phase runs." This is that builder, plus the
+ * two collection calls (`buildRelDefinesByPropertiesIndex` /
+ * `collectPropertyAndQuantitySetMutations`) it was already handing them to.
+ *
+ * `hasAnyUnreadableSourceRef` and the `mayNameOmittedRefs` /
+ * `isOmittedFromOutput` predicates it feeds do NOT live here: they read
+ * `pass.effective` and this phase's OUTPUT (`allowedEntityIds`,
+ * `overlayActive`), but nothing in THIS module reads them back, so moving them
+ * here would not shrink a dependency, only relocate it. That argument was
+ * always about this module specifically. They live in
+ * `step-omission-predicates.ts`, called from `export()` immediately after this
+ * phase returns (#2475).
+ */
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { MutablePropertyView } from '@ifc-lite/mutations';
+import { type PropertySetContext } from './step-property-set-readers.js';
+import { type GeorefContext } from './step-georeferencing.js';
+import type { ExportPass, StepExportOptions } from './step-exporter.js';
+/**
+ * The exporter state this phase cannot read off the pass.
+ *
+ * `propertySetContext` and `georefContext` are thunks, not values, matching
+ * every other call site of theirs in `export()`: this phase calls
+ * `propertySetContext()` twice (once for `buildRelDefinesByPropertiesIndex`,
+ * once for `collectPropertyAndQuantitySetMutations`) and moving that call
+ * out from under the two sites — deriving one value up front instead —
+ * would be a behaviour change nothing here asked for.
+ */
+export interface CollectionContext {
+    readonly dataStore: IfcDataStore;
+    readonly mutationView: MutablePropertyView | null;
+    readonly propertySetContext: () => PropertySetContext;
+    readonly georefContext: (deltaOnly: boolean) => GeorefContext;
+}
+/**
+ * Populate `pass` with everything the overlay's edits and `options` imply,
+ * in place. The caller owns three gates and this phase does not re-derive
+ * any of them: `applyMutations` (`options.applyMutations !== false`, read
+ * once in `export()` — see the "read ONCE" comment there for why a second
+ * read would be a bug, not a style choice), `options.visibleOnly`, and
+ * `options.georefMutations`.
+ */
+export declare function collectModifications(pass: ExportPass, options: StepExportOptions, applyMutations: boolean, ctx: CollectionContext): void;
+//# sourceMappingURL=step-collection.d.ts.map

package/dist/step-collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-collection.d.ts","sourceRoot":"","sources":["../src/step-collection.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAI/D,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAgC,KAAK,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC5F,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAExE;;;;;;;;;GASG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAClD,QAAQ,CAAC,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;IACtD,QAAQ,CAAC,aAAa,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,aAAa,CAAC;CAC/D;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,iBAAiB,EAC1B,cAAc,EAAE,OAAO,EACvB,GAAG,EAAE,iBAAiB,GACrB,IAAI,CAsIN"}

package/dist/step-collection.js

@@ -0,0 +1,126 @@
+/* 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 { collectReferencedEntityIds, getVisibleEntityIds, collectStyleEntities } from './reference-collector.js';
+import { buildRelDefinesByPropertiesIndex } from './step-property-set-index.js';
+import { collectPropertyAndQuantitySetMutations } from './step-property-set-collection.js';
+import { applyGeoreferencingMutations } from './step-georeferencing.js';
+/**
+ * Populate `pass` with everything the overlay's edits and `options` imply,
+ * in place. The caller owns three gates and this phase does not re-derive
+ * any of them: `applyMutations` (`options.applyMutations !== false`, read
+ * once in `export()` — see the "read ONCE" comment there for why a second
+ * read would be a bug, not a style choice), `options.visibleOnly`, and
+ * `options.georefMutations`.
+ */
+export function collectModifications(pass, options, applyMutations, ctx) {
+    if (options.visibleOnly && ctx.dataStore.source) {
+        const visible = getVisibleEntityIds(ctx.dataStore, options.hiddenEntityIds ?? new Set(), options.isolatedEntityIds ?? null, pass.effective);
+        pass.hiddenProductIds = visible.hiddenProductIds;
+        pass.allowedEntityIds = collectReferencedEntityIds(visible.roots, ctx.dataStore.source, pass.effective, visible.hiddenProductIds, pass.isRefExcludedDuringClosureWalk);
+        // Second pass: collect IFCSTYLEDITEM entities that reference included
+        // geometry. Styled items reference geometry items but nothing references
+        // them back, so the forward closure misses them.
+        collectStyleEntities(pass.allowedEntityIds, ctx.dataStore.source, { byId: pass.effective, byType: pass.effective.byType });
+    }
+    // Process mutations if we have a mutation view
+    if (ctx.mutationView && applyMutations) {
+        const mutationView = ctx.mutationView;
+        const mutations = mutationView.getMutations();
+        // Attribute values come from the *overlay*, never from the mutation
+        // history. The history is append-only and undo writes its reverse edit
+        // with `skipHistory: true`, so a superseded UPDATE_ATTRIBUTE record keeps
+        // its stale `newValue` forever — replaying it resurrects edits the user
+        // undid (#1957). The overlay is what the editor shows, and it is already
+        // the source for psets, quantities, positional attributes and retypes
+        // below, so attributes were the sole outlier.
+        for (const [entityId, attrs] of mutationView.getAttributeMutationsByEntity()) {
+            pass.modifiedEntities.add(entityId);
+            let target = pass.modifiedAttributes.get(entityId);
+            if (!target) {
+                target = new Map();
+                pass.modifiedAttributes.set(entityId, target);
+            }
+            for (const [name, value] of attrs)
+                target.set(name, value);
+        }
+        // Group mutations by entity, separating property vs quantity mutations
+        const entityPropMutations = new Map();
+        const entityQuantMutations = new Map();
+        for (const mutation of mutations) {
+            // Handled above, off the overlay. Skipped explicitly because an
+            // UPDATE_ATTRIBUTE record can also carry a `psetName` (georef fields
+            // encode their target entity there) and must not be mistaken for a
+            // property-set edit.
+            if (mutation.type === 'UPDATE_ATTRIBUTE')
+                continue;
+            if (!mutation.psetName)
+                continue;
+            const isQuantity = mutation.type === 'CREATE_QUANTITY' || mutation.type === 'UPDATE_QUANTITY'
+                || mutation.type === 'DELETE_QUANTITY' || mutation.type === 'DELETE_QUANTITY_SET';
+            const targetMap = isQuantity ? entityQuantMutations : entityPropMutations;
+            if (!targetMap.has(mutation.entityId)) {
+                targetMap.set(mutation.entityId, new Set());
+            }
+            targetMap.get(mutation.entityId).add(mutation.psetName);
+        }
+        // Build a reverse index of IfcRelDefinesByProperties → (relId, psetId)
+        // pairs keyed on each related entity. The two property/quantity loops
+        // below previously walked every entity in `entityIndex.byId` per
+        // modified entity (O(E·N)); the index keeps the per-entity step
+        // O(K) where K is the number of rels referencing that entity.
+        const { byEntity: relDefinesByEntity, relatedByRel } = buildRelDefinesByPropertiesIndex(ctx.propertySetContext());
+        // A source IfcRelDefinesByProperties whose EVERY related object the
+        // session deleted has nothing left to relate, and emitting it leaves a
+        // `#id` pointing at a record the export skipped. Dropped only when all of
+        // them are gone: a rel that still names a live entity is that entity's
+        // only link to its psets, and nothing here rewrites a RelatedObjects list.
+        for (const [relId, related] of relatedByRel) {
+            if (related.length > 0 && related.every((id) => pass.effective.isDeleted(id))) {
+                pass.skipRelationshipIds.add(relId);
+            }
+        }
+        collectPropertyAndQuantitySetMutations(pass, options, { entityPropMutations, entityQuantMutations, relDefinesByEntity }, ctx.propertySetContext());
+        for (const [entityId] of pass.modifiedAttributes) {
+            // An overlay-CREATED entity carrying attribute edits is emitted once,
+            // by the new-entities pass, and already counted in `newEntityCount`.
+            // Counting it here too made the header claim two affected entities for
+            // one created-then-renamed wall.
+            if (pass.isOverlayCreated(entityId))
+                continue;
+            // A source entity with no bytes never gets its line rewritten (the
+            // source-iteration pass skips it), so an attribute edit against it
+            // must not inflate the count either.
+            if (!pass.hasEmittableHostBytes(entityId))
+                continue;
+            // Under `deltaOnly` this only NOMINATES the host's ATTRIBUTE edits:
+            // nothing writes an in-place attribute edit into a delta except the
+            // type-object line rewrite, so the ledger drops it at settle time
+            // unless that pass reports having carried it (#2462). That nomination
+            // is deliberately made at INTENT: the per-kind warning exists to NAME
+            // an edit the delta could not carry, and an undeliverable edit is
+            // exactly the one that must still be named.
+            //
+            // A FULL export has no such warning, so an edit that resolved to
+            // nothing has nothing to say and nothing to claim — it waits for the
+            // rewrite instead. `setAttribute` to the value already in the slot, and
+            // `setAttribute` naming a slot the class does not declare, both leave
+            // the line byte-identical and used to count anyway (#2483).
+            //
+            // Recorded unconditionally. It used to be skipped for a host that also
+            // had a pset or qset edit, because the count was per entity and the
+            // other loop had already nominated it — which is exactly what let a
+            // pset emission mark the rename delivered and suppress its warning. The
+            // ledger de-duplicates the COUNT per entity now, so the two edits can
+            // and must be nominated separately.
+            pass.inPlaceNominees.attribute.add(entityId);
+            if (options.deltaOnly === true)
+                pass.modifications.nominate(entityId, 'attribute');
+        }
+    }
+    // Process georeferencing mutations (only when applyMutations is enabled)
+    if (applyMutations && options.georefMutations) {
+        applyGeoreferencingMutations(pass, options.georefMutations, ctx.georefContext(options.deltaOnly === true));
+    }
+}
+//# sourceMappingURL=step-collection.js.map

package/dist/step-collection.js.map

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

package/dist/step-export-contexts.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The per-phase contexts that do NOT allocate express ids.
+ *
+ * Split out of `StepExporter` for #2475. These two are pure forwarders: they
+ * assemble what a phase cannot read off the pass, out of values handed to
+ * them, and touch no exporter state of their own.
+ *
+ * WHY ONLY THESE TWO. `georefContext` and `propertySetContext` stay methods on
+ * `StepExporter`, and `collectionContext` stays with them because it forwards
+ * to both. Those two are the only places that mint express ids, via
+ * `allocateExpressId: () => this.nextExpressId++` — two closures over ONE
+ * instance counter. Moving them would mean re-establishing that shared
+ * identity through a parameter, and capturing the counter's value instead of
+ * its closure gives each builder its own sequence, silently emitting two
+ * entities with the same `#N` — well-formed STEP in which every reference
+ * still resolves, and two different entities.
+ *
+ * That failure used to be invisible: `findDanglingRefs` collects defined ids
+ * into a `Set`, which absorbs a duplicate rather than reporting it. It is now
+ * caught — `step-georeferencing.test.ts`'s "mints distinct ids for generated
+ * psets and for created georeferencing" drives both allocating paths in one
+ * export and asserts no id is defined twice. Freezing both closures fails that
+ * test and only that test.
+ *
+ * So the reason this module holds two functions rather than five is written
+ * down here AND checkable, which is the only reason it is safe to leave the
+ * other three where they are.
+ */
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { MutablePropertyView } from '@ifc-lite/mutations';
+import type { SourceIterationContext } from './step-source-iteration.js';
+import type { OverlayEntitiesContext } from './step-overlay-entities.js';
+import type { PropertySetContext } from './step-property-set-readers.js';
+/**
+ * The state `step-source-iteration.ts` cannot read off the pass (#2475 2d).
+ *
+ * No `allocateExpressId`: that phase never allocates an id, it only rewrites
+ * lines that already have one. `applySourceLineMutations` (a free function in
+ * `step-attribute-mutations.ts`, closed over `mutationView` here) and
+ * `isGeometryEntity` are injected rather than read off the pass because each
+ * has readers outside this phase — the mutation pipeline is shared with the
+ * type-object `HasPropertySets` rewrite (see `StepExporter`'s
+ * `propertySetContext`, which stays a method because it mints express ids) and
+ * with the overlay-created-entities block in `export()`; `isGeometryEntity`
+ * with the visible-only setup closure and that same block.
+ *
+ * `propertySetContext` arrives as a THUNK, not a value: the phase calls it
+ * per use and the original method rebuilt it per call, which is the behaviour
+ * being preserved.
+ */
+export declare function buildSourceIterationContext(dataStore: IfcDataStore, mutationView: MutablePropertyView | null, propertySetContext: () => PropertySetContext): SourceIterationContext;
+/**
+ * The state `step-overlay-entities.ts` cannot read off the pass (#2475
+ * step 2e). `applyOverlayEntityOverrides` is the free function
+ * `step-overlay-attribute-overrides.ts` exports; `isGeometryEntity` and
+ * `relationshipWithheldWarning` are the same shared readers
+ * {@link buildSourceIterationContext} already injects into the other output
+ * pass.
+ */
+export declare function buildOverlayEntitiesContext(mutationView: MutablePropertyView | null): OverlayEntitiesContext;
+//# sourceMappingURL=step-export-contexts.d.ts.map

package/dist/step-export-contexts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-export-contexts.d.ts","sourceRoot":"","sources":["../src/step-export-contexts.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAK/D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAEzE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,YAAY,EACvB,YAAY,EAAE,mBAAmB,GAAG,IAAI,EACxC,kBAAkB,EAAE,MAAM,kBAAkB,GAC3C,sBAAsB,CASxB;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,mBAAmB,GAAG,IAAI,GACvC,sBAAsB,CAOxB"}