@ifc-lite/export 2.9.4 → 3.0.1

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

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ *
+ * `dataStore` and `mutationView` are the exporter's, injected rather than
+ * reached for. `isGeometryEntity` arrives as a parameter for a different
+ * reason: it is the free function in `step-geometry-types.ts`, so taking it
+ * here keeps this builder independent of the exporter AND of that module.
+ */
+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;;;;;;;GAOG;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":"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"}

package/dist/step-property-set-collection.d.ts

@@ -0,0 +1,24 @@
+import { type PropertySetContext } from './step-property-set-readers.js';
+import type { ExportPass, StepExportOptions } from './step-exporter.js';
+/** The mutation groupings `export()` builds before the collection phase runs. */
+export interface PropertyMutationGroups {
+    readonly entityPropMutations: Map<number, Set<string>>;
+    readonly entityQuantMutations: Map<number, Set<string>>;
+    readonly relDefinesByEntity: Map<number, Array<{
+        relId: number;
+        psetId: number;
+    }>>;
+}
+/**
+ * Collect what the overlay's property-set and quantity-set edits mean for this
+ * export: which sets to regenerate (`pass.newPropertySets` /
+ * `pass.newQuantitySets`), which source records to withhold
+ * (`pass.skipPropertySetIds` / `pass.skipRelationshipIds`), and which type
+ * objects need their `HasPropertySets` resolved later
+ * (`pass.typeOwnedPsetNamesByEntity`, `…IdsByEntity`, `pass.rewrittenEntityIds`).
+ *
+ * The caller owns the `mutationView && options.applyMutations !== false` gate;
+ * reaching here means overlay edits were both present and enabled.
+ */
+export declare function collectPropertyAndQuantitySetMutations(pass: ExportPass, options: StepExportOptions, groups: PropertyMutationGroups, ctx: PropertySetContext): void;
+//# sourceMappingURL=step-property-set-collection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"step-property-set-collection.d.ts","sourceRoot":"","sources":["../src/step-property-set-collection.ts"],"names":[],"mappings":"AAkBA,OAAO,EACL,KAAK,kBAAkB,EAKxB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAExE,iFAAiF;AACjF,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACvD,QAAQ,CAAC,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACxD,QAAQ,CAAC,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;CACpF;AAkBD;;;;;;;;;;GAUG;AACH,wBAAgB,sCAAsC,CACpD,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,iBAAiB,EAC1B,MAAM,EAAE,sBAAsB,EAC9B,GAAG,EAAE,kBAAkB,GACtB,IAAI,CAqQN"}

package/dist/step-property-set-collection.js

@@ -0,0 +1,286 @@
+/* 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 { extractQuantitiesOnDemand } from '@ifc-lite/parser';
+import { isTypeClass } from './type-owned-psets.js';
+import { getPropertySetName, getPropertyIdsInSet, getTypeOwnedHasPropertySetIds, getElementQuantityName, } from './step-property-set-readers.js';
+/**
+ * The store the extractor THIS class installed on a view currently reads
+ * (#2487). The extractor is installed once per view and closes over this box
+ * rather than over a store directly, so a later export of the same view against
+ * a different store re-points it instead of answering from the first file.
+ *
+ * A box, and not a `WeakSet` of views, because ownership has to reflect the
+ * CURRENT state and not the historical fact that an export once installed
+ * something. `setQuantityExtractor` is public: a caller may install its own
+ * afterwards, and a marker saying "the exporter owns this view" would then keep
+ * overwriting a caller-supplied base forever. With a box, the second export
+ * writes to a box nothing reads any more and never calls the setter again, so
+ * the caller's extractor stands. Weak, so it never keeps a session alive.
+ */
+const exporterQuantityBase = new WeakMap();
+/**
+ * Collect what the overlay's property-set and quantity-set edits mean for this
+ * export: which sets to regenerate (`pass.newPropertySets` /
+ * `pass.newQuantitySets`), which source records to withhold
+ * (`pass.skipPropertySetIds` / `pass.skipRelationshipIds`), and which type
+ * objects need their `HasPropertySets` resolved later
+ * (`pass.typeOwnedPsetNamesByEntity`, `…IdsByEntity`, `pass.rewrittenEntityIds`).
+ *
+ * The caller owns the `mutationView && options.applyMutations !== false` gate;
+ * reaching here means overlay edits were both present and enabled.
+ */
+export function collectPropertyAndQuantitySetMutations(pass, options, groups, ctx) {
+    const { entityPropMutations, entityQuantMutations, relDefinesByEntity } = groups;
+    // `export()` narrowed this through the enclosing `if`, and the caller still
+    // owns that gate: reaching here means the view exists and mutations are
+    // enabled. Named once here rather than asserted at each of the six reads.
+    const mutationView = ctx.mutationView;
+    // Collect modified property sets and find original psets to skip
+    for (const [entityId, psetNames] of entityPropMutations) {
+        // A deleted entity must not cause the exporter to REMOVE anything.
+        //
+        // This is the other half of the dangling-reference class, and the half
+        // `willBeEmitted` cannot reach: that predicate guards what gets ADDED,
+        // and this loop's real work is deciding what gets SKIPPED. An edited
+        // pset is replaced wholesale, so its original id goes into
+        // `skipPropertySetIds` — but IFC exporters share one IfcPropertySet
+        // between entities, and once the host is deleted there is no
+        // replacement to take its place. The surviving entity's relation then
+        // points at a container nobody wrote. Verified against main at
+        // e6516991 (#2030's own merge): edit `Pset_WallCommon` on one of two
+        // walls sharing it, delete that wall, and the export drops #11 while
+        // #12 still names it. `retainSharedAtoms` rescues a shared ATOM one
+        // level down; nothing rescues the shared container.
+        //
+        // Leaving the pset alone makes it an orphan when nothing else
+        // references it, which is valid IFC. Its relation is dropped by the
+        // sweep above, which handles a plain delete too — no pset edit needed.
+        if (pass.effective.isDeleted(entityId))
+            continue;
+        pass.modifiedEntities.add(entityId);
+        // Same rule as the attribute loop below: an overlay-CREATED entity is
+        // emitted once, by the new-entities pass, and already counted in
+        // `newEntityCount` — as are the pset entities this loop goes on to
+        // generate. Only the COUNT is guarded; the entity still records its
+        // pset edits and still emits them.
+        //
+        // A NOMINATION, in both modes, never a count on its own: this site sees
+        // a pset NAME the session touched, not whether that name resolves to
+        // anything. `deletePropertySet(id, 'AName')` on a host that owns no such
+        // set reaches here and changes nothing at all, and used to put "1
+        // modification" in the header of a byte-identical file (#2474). What
+        // settles it is the generator's `recordEmitted` and the skip branches'
+        // `recordWithheld` below.
+        if (!pass.isOverlayCreated(entityId) && pass.hasEmittableHostBytes(entityId)) {
+            pass.modifications.nominate(entityId, 'property-set');
+        }
+        // Get the FULL mutated property sets for this entity (merged base + mutations)
+        const allPsets = mutationView.getForEntity(entityId);
+        const relevantPsets = allPsets.filter((pset) => psetNames.has(pset.name));
+        const relDefinedPsetNames = new Set();
+        if (relevantPsets.length > 0) {
+            pass.newPropertySets.push({ entityId, psets: relevantPsets });
+        }
+        // Find original property set IDs and relationship IDs to skip — look
+        // up only the IfcRelDefinesByProperties rels that reference this entity.
+        const rels = relDefinesByEntity.get(entityId);
+        if (rels) {
+            for (const { relId, psetId: relatedPsetId } of rels) {
+                // Check if this pset is one we're modifying
+                const psetName = getPropertySetName(ctx, relatedPsetId);
+                if (psetName) {
+                    relDefinedPsetNames.add(psetName);
+                }
+                if (psetName && psetNames.has(psetName)) {
+                    pass.skipRelationshipIds.add(relId);
+                    pass.skipPropertySetIds.add(relatedPsetId);
+                    // Also skip the individual properties in this pset
+                    const propIds = getPropertyIdsInSet(ctx, relatedPsetId);
+                    for (const propId of propIds) {
+                        pass.skipPropertySetIds.add(propId);
+                    }
+                    // The other half of "did this edit change the file": a full export
+                    // applies a set DELETION by leaving these lines out, and produces
+                    // no replacement content to record an emission for. Without this
+                    // the count would settle from the generator alone and a real
+                    // deletion would stop counting along with the no-op one (#2474).
+                    pass.modifications.recordWithheld(entityId, 'property-set');
+                }
+            }
+        }
+        if (isTypeClass(pass.effective.typeOf(entityId))) {
+            const typeOwnedPsetIds = getTypeOwnedHasPropertySetIds(ctx, entityId, pass.effective);
+            const typeOwnedAffected = new Set();
+            for (const psetId of typeOwnedPsetIds) {
+                const psetName = getPropertySetName(ctx, psetId);
+                if (!psetName || !psetNames.has(psetName))
+                    continue;
+                typeOwnedAffected.add(psetName);
+                pass.skipPropertySetIds.add(psetId);
+                const propIds = getPropertyIdsInSet(ctx, psetId);
+                for (const propId of propIds) {
+                    pass.skipPropertySetIds.add(propId);
+                }
+                // No `recordWithheld` twin of the rel-defined branch above, and
+                // deliberately: a name that matches an OWNED pset is either dropped
+                // from the resolved list or swapped for the replacement this export
+                // generated, so slot 5 always comes back different and the repoint
+                // below records the emission for it. A second record here would be
+                // one no mutation can kill.
+            }
+            for (const psetName of psetNames) {
+                if (!relDefinedPsetNames.has(psetName)) {
+                    typeOwnedAffected.add(psetName);
+                }
+            }
+            if (typeOwnedAffected.size > 0) {
+                pass.typeOwnedPsetNamesByEntity.set(entityId, typeOwnedAffected);
+                pass.typeOwnedPsetIdsByEntity.set(entityId, typeOwnedPsetIds);
+                pass.rewrittenEntityIds.add(entityId);
+            }
+        }
+    }
+    // Collect modified quantity sets (only if quantities are included)
+    if (options.includeQuantities === false)
+        entityQuantMutations.clear();
+    // A quantity overlay with nothing under it regenerates a source quantity
+    // set from the edited quantity ALONE, and the skip loop below then
+    // withholds the source lines that held its siblings (#2487). Unlike
+    // properties — whose base falls back to the `baseTable` the view was
+    // constructed with — quantities have only the opt-in
+    // `setQuantityExtractor`, so the default really is an empty base, and
+    // four in-tree callers plus every external embedder never set it.
+    //
+    // The exporter is the one place that always holds the missing half: it
+    // was handed the very store the view is an overlay ON. Supplying it here
+    // makes the loss impossible for every caller rather than for the callers
+    // we happened to find, and a view that resolves its own quantities (the
+    // viewer, MCP, the CLI headless backend) is never overwritten.
+    //
+    // The extractor closes over ONE store, and the view outlives this export.
+    // So it closes over a BOX this class owns instead: a second export of the
+    // same view against a DIFFERENT store re-points that box rather than
+    // reading the first store's quantities, which is the one way "install only
+    // when absent" could have answered from the wrong file. The setter is
+    // called at most once per view, so a caller that installs its own
+    // extractor at any point — before the first export or after it — keeps it.
+    //
+    // `hasQuantityBase` and `setQuantityExtractor` are probed, like every other
+    // optional view capability this class reaches for (`peekNextExpressId`,
+    // `getNewEntities`, `getEntityTypeMutation`): `MutablePropertyView` is
+    // published API arriving from a separately versioned package, and callers
+    // pass partial and duck-typed views. `hasQuantityBase` is newer than
+    // `setQuantityExtractor`, and without it there is no way to tell an empty
+    // base from a caller-supplied one — so an older view falls back to the
+    // pre-#2487 behaviour (no base supplied) rather than risk overwriting one.
+    const quantityView = mutationView;
+    if (entityQuantMutations.size > 0 &&
+        typeof quantityView.setQuantityExtractor === 'function' &&
+        typeof quantityView.hasQuantityBase === 'function') {
+        const installed = exporterQuantityBase.get(quantityView);
+        if (installed) {
+            // Ours, or a caller's that replaced ours: re-pointing the box is a
+            // no-op in the second case, and calling the setter again is what
+            // would not be.
+            installed.store = ctx.dataStore;
+        }
+        else if (!quantityView.hasQuantityBase()) {
+            const box = { store: ctx.dataStore };
+            exporterQuantityBase.set(quantityView, box);
+            quantityView.setQuantityExtractor((id) => extractQuantitiesOnDemand(box.store, id));
+        }
+    }
+    for (const [entityId, qsetNames] of entityQuantMutations) {
+        // Same rule as the property loop above: a deleted entity removes nothing.
+        if (pass.effective.isDeleted(entityId))
+            continue;
+        pass.modifiedEntities.add(entityId);
+        // See the property loop above — an overlay-created entity is counted as
+        // new, not modified. The pset loop's own nomination no longer has to be
+        // excluded to avoid a double count: the ledger settles per ENTITY, so a
+        // host with both a pset and a qset edit counts once whatever is
+        // nominated. Nominating both buys the opposite — an accurate warning
+        // when the qset half is the half a delta cannot carry.
+        //
+        // Settled from effect like its property-set twin (#2474). The reachable
+        // no-op here is an UNDONE quantity-set creation whose name matches NO
+        // source set: `getMutations()` is append-only, so the `CREATE_QUANTITY`
+        // record still names the qset after `removeQuantityMutation` has taken
+        // it out of the overlay, and the generator below then finds nothing to
+        // write. The same undo against a COLLIDING name is not a no-op — it
+        // withholds the source set's lines — which is what the skip loop's
+        // `recordWithheld` below settles.
+        if (!pass.isOverlayCreated(entityId) && pass.hasEmittableHostBytes(entityId)) {
+            pass.modifications.nominate(entityId, 'quantity-set');
+        }
+        const allQsets = mutationView.getQuantitiesForEntity(entityId);
+        const relevantQsets = allQsets.filter((qset) => qsetNames.has(qset.name));
+        if (relevantQsets.length > 0) {
+            pass.newQuantitySets.push({ entityId, qsets: relevantQsets });
+        }
+        // The names this export is actually WRITING a replacement for. The
+        // affected-name set is not the same thing: it comes from the session's
+        // append-only mutation history, which keeps naming a quantity set after
+        // an undo has taken it back out of the overlay, so a Ctrl+Z used to
+        // withhold a source `IfcElementQuantity` that nothing regenerated.
+        //
+        // A quantity-set REMOVAL is the one case where withholding WITHOUT a
+        // replacement is the intent rather than the bug. It had no public
+        // populator when #2487 wrote that rule, so the rule read "always the
+        // bug"; `MutablePropertyView.deleteQuantitySet` (#2508) gives it one,
+        // and the deleted set is now asked for by name below. Without that, the
+        // panel hid a base quantity set the exported file still carried.
+        const regeneratedQsetNames = new Set(relevantQsets.map((qset) => qset.name));
+        // Skip original quantity set entities (IfcElementQuantity).
+        // Same per-entity index lookup as the property branch above.
+        const rels = relDefinesByEntity.get(entityId);
+        if (rels) {
+            for (const { relId, psetId: relatedPsetId } of rels) {
+                const qsetName = getElementQuantityName(ctx, relatedPsetId);
+                const deleted = qsetName !== null
+                    && mutationView.isQuantitySetDeleted?.(entityId, qsetName) === true;
+                if (qsetName && (regeneratedQsetNames.has(qsetName) || deleted)) {
+                    pass.skipRelationshipIds.add(relId);
+                    pass.skipPropertySetIds.add(relatedPsetId);
+                    const quantIds = getPropertyIdsInSet(ctx, relatedPsetId);
+                    for (const quantId of quantIds) {
+                        pass.skipPropertySetIds.add(quantId);
+                    }
+                    // The withheld half, exactly as the rel-defined property branch
+                    // above. This loop has just decided that #`relatedPsetId`, its
+                    // quantity atoms and the relationship that attached them do NOT
+                    // go into the file; whether anything is generated to take their
+                    // place is decided elsewhere, and is not this branch's to assume.
+                    //
+                    // It IS assumable for the pset side and not here, and the
+                    // difference is where the two read their base from.
+                    // `getForEntity` merges the overlay over the base pset walk, so a
+                    // name the session touched but did not change still resolves to
+                    // source content and is regenerated.
+                    // `getQuantitiesForEntity` merges the overlay over
+                    // `quantityExtractor`, which is OPT-IN: it defaults to null, and
+                    // several in-tree callers wire the property extractor beside it
+                    // and not it (`cli/commands/mutate.ts`, `gym.ts`,
+                    // `generate-spaces.ts`, `export/demesh-session.ts`), as does any
+                    // external embedder of these two published packages. With no
+                    // extractor the base is empty and the overlay is the only source,
+                    // so a qset the overlay no longer holds resolves to nothing.
+                    //
+                    // Which makes this reachable through an UNDONE quantity-set
+                    // creation whose name COLLIDES with a source set:
+                    // `setQuantity(id, 'Qto_WallBaseQuantities', ...)` followed by the
+                    // `removeQuantityMutation` that mutationSlice runs on Ctrl+Z. The
+                    // append-only history still names the qset, so this branch
+                    // withholds the source lines; the overlay is empty again, so
+                    // nothing is regenerated. The export drops the source quantity set
+                    // — a real change to the file, and a data-loss bug of its own
+                    // (#2487) — and this call is what stops the count from calling it
+                    // nothing.
+                    pass.modifications.recordWithheld(entityId, 'quantity-set');
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=step-property-set-collection.js.map