@ifc-lite/export 3.0.0 → 3.0.1

package/dist/step-property-sets.js

@@ -1,685 +1,33 @@
 /* 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, serializeValue, ref } from '@ifc-lite/parser';
-import { generateIfcGuid } from '@ifc-lite/encoding';
-import { recordSourceLineDelivery } from './delta-modification-ledger.js';
-import { nominateDeliveredInPlaceEdits } from './in-place-nomination.js';
-import { decodeRange } from './source-ref-bounds.js';
-import { findLengthUnitReference, normalizeMapUnitName } from './step-georeferencing.js';
-import { authoredEntityRefs } from './effective-index.js';
-import { HAS_PROPERTY_SETS_SLOT, isTypeClass, resolveTypeOwnedPsetIds, rewriteTypeOwnedPsetLine, typeOwnedPsetRewriteWarning, } from './type-owned-psets.js';
-import { escapeStepString, toStepReal, quantityTypeToIfcType } from './step-serialization.js';
-import { serializeNominalValue } from './declared-property-type.js';
-/** `OwnerHistory` is slot 1 on every `IfcRoot` subtype, all schemas. */
-const OWNER_HISTORY_SLOT = 1;
-/**
- * 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();
-/**
- * Build a one-shot reverse index of every IfcRelDefinesByProperties in
- * the source: for each related entity, list the rels and property/quantity
- * sets that reference it. Used by the export pre-pass so the per-entity
- * "find owning rels" step is O(K) rather than O(N) per modified entity.
- *
- * `relatedByRel` is the same walk read the other way round, so the deleted-host
- * sweep costs nothing extra.
- */
-export function buildRelDefinesByPropertiesIndex(ctx) {
-    const byEntity = new Map();
-    const relatedByRel = new Map();
-    for (const [relId, relRef] of ctx.dataStore.entityIndex.byId) {
-        if (relRef.type.toUpperCase() !== 'IFCRELDEFINESBYPROPERTIES')
-            continue;
-        const psetId = getRelatedPropertySet(ctx, relId);
-        if (!psetId)
-            continue;
-        const related = getRelatedEntities(ctx, relId);
-        relatedByRel.set(relId, related);
-        for (const entityId of related) {
-            let bucket = byEntity.get(entityId);
-            if (!bucket) {
-                bucket = [];
-                byEntity.set(entityId, bucket);
-            }
-            bucket.push({ relId, psetId });
-        }
-    }
-    return { byEntity, relatedByRel };
-}
 /**
- * The source STEP text of an entity's line, or `null` when there are no bytes
- * to read.
- *
- * The byte check is on the RANGE, not on `dataStore.source`. `source` is a
- * MANDATORY accessor — `EMPTY_SOURCE_BYTES` is how "this model kept no bytes"
- * is spelled (server-parsed, synthetic, GLB and point-cloud stores all have
- * one) — so the `!ctx.dataStore.source` guard the five readers below used to
- * carry never fired. It was also redundant: a zero-length range decodes to
- * `''`, which fails every regex those readers run, so they already answered
- * "nothing" for a sourceless store. Scoping the check to the range is what
- * makes the guard live without changing a single answer, the same shape and
- * for the same reason as `reference-collector.ts` (#2339).
- *
- * An OVERLAY-created entity never reaches here: every caller resolves its id
- * through `dataStore.entityIndex.byId`, which holds source records only
- * (`effective-index.ts` synthesises the overlay refs on its own side and
- * writes nothing back), so an overlay id is already `undefined` at the
- * lookup and is served by the callers' documented "not a source record"
- * path. That is why an early return is safe HERE and is NOT safe at the
- * visible-only closure in `export` — see the comment there.
- *
- * ## Why `isReadableSourceRef` and not `byteLength === 0`
- *
- * An out-of-range ref does NOT degrade to "no match" here. `decodeUtf8`
- * clamps the range it cannot address, and the clamped window is still a
- * window over real file bytes — so these readers answer from somebody
- * ELSE's record. `source-ref-bounds.ts` (#2491) carries the measured
- * account of both shapes and of why "a clamped, empty decode already yields
- * no match" is false; it is not restated here, because an argument kept in
- * two files is an argument that has to stay true in two files.
- *
- * The consequence specific to THIS site is that the wrong answer is acted
- * on. `retainSharedAtoms` un-skips every id `getPropertyIdsInSet` returns,
- * so a member list read out of the wrong record un-skips the wrong atoms;
- * and the source-iteration pass already refuses to emit a record whose ref
- * fails `isReadableSourceRef` (see the `continue` in `export`), so before
- * this gate these readers were making decisions on behalf of a container
- * that the same export had decided not to write. Gating them on the same
- * predicate is what makes the two passes agree.
+ * The write phase of the property-set and quantity-set generation
+ * (#2475 steps 2b/2c): writes the records the generation phase
+ * (`step-property-set-generators.ts`) produces into `pass.entities`, then
+ * points every affected type object's `HasPropertySets` at them.
  *
- * The degradation is the one the exporter already handles: a record with no
- * emittable bytes, generating nothing and named by nothing. It costs one
- * answer that used to be right by luck — an overrunning ref on the file's
- * LAST record clamps back to exactly that record's text — but that record
- * is one the emission pass drops anyway, so keeping the answer only kept
- * the disagreement.
- */
-/*
- * Exported for `entity-line-text-bounds.test.ts`, which is the only pin on
- * where this range STARTS: every pattern the readers below run is unanchored
- * or `$`-anchored, so no public export path can see the first byte move
- * (#2497). That test used to reach the method by casting a `StepExporter` to
- * an interface of its privates; an export is the same access, stated.
- */
-export function entityLineText(ctx, entityId) {
-    const entityRef = ctx.dataStore.entityIndex.byId.get(entityId);
-    if (!entityRef || !ctx.isReadableSourceRef(entityRef))
-        return null;
-    return decodeRange(ctx.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
-}
-/**
- * Get entity IDs related by IfcRelDefinesByProperties (the related objects)
- */
-function getRelatedEntities(ctx, relId) {
-    const entityText = entityLineText(ctx, relId);
-    if (entityText === null)
-        return [];
-    // Parse IfcRelDefinesByProperties: #ID=IFCRELDEFINESBYPROPERTIES('guid',$,$,$,(#objects),#pset);
-    // The 5th argument (index 4) is the list of related objects
-    const match = entityText.match(/\(([^)]+)\)\s*,\s*#(\d+)\s*\)\s*;/);
-    if (!match)
-        return [];
-    const objectsList = match[1];
-    const refs = [];
-    const refMatches = objectsList.matchAll(/#(\d+)/g);
-    for (const m of refMatches) {
-        refs.push(parseInt(m[1], 10));
-    }
-    return refs;
-}
-/**
- * Get the property set ID from IfcRelDefinesByProperties
- */
-function getRelatedPropertySet(ctx, relId) {
-    const entityText = entityLineText(ctx, relId);
-    if (entityText === null)
-        return null;
-    // Last #ID before the closing );
-    const match = entityText.match(/,\s*#(\d+)\s*\)\s*;$/);
-    if (!match)
-        return null;
-    return parseInt(match[1], 10);
-}
-/**
- * Get the name of a property set by parsing the entity
- */
-export function getPropertySetName(ctx, psetId) {
-    const entityText = entityLineText(ctx, psetId);
-    if (entityText === null)
-        return null;
-    // Parse: IFCPROPERTYSET('guid',$,'Name',$,...) - Name is 3rd argument
-    const match = entityText.match(/IFCPROPERTYSET\s*\([^,]*,[^,]*,'([^']*)'/i);
-    if (!match)
-        return null;
-    return match[1];
-}
-/**
- * Get the name of an element quantity set by parsing the entity
- */
-function getElementQuantityName(ctx, entityId) {
-    const entityText = entityLineText(ctx, entityId);
-    if (entityText === null)
-        return null;
-    // Parse: IFCELEMENTQUANTITY('guid',$,'Name',...) - Name is 3rd argument
-    const match = entityText.match(/IFCELEMENTQUANTITY\s*\([^,]*,[^,]*,'([^']*)'/i);
-    if (!match)
-        return null;
-    return match[1];
-}
-/**
- * Get IDs of properties in a property set
- */
-export function getPropertyIdsInSet(ctx, psetId) {
-    const entityText = entityLineText(ctx, psetId);
-    if (entityText === null)
-        return [];
-    // Parse: IFCPROPERTYSET(...,(#prop1,#prop2,...)); - Last argument is properties list
-    const match = entityText.match(/\(\s*(#[^)]+)\s*\)\s*\)\s*;$/);
-    if (!match)
-        return [];
-    const propsList = match[1];
-    const ids = [];
-    const refMatches = propsList.matchAll(/#(\d+)/g);
-    for (const m of refMatches) {
-        ids.push(parseInt(m[1], 10));
-    }
-    return ids;
-}
-/**
- * The full HasPropertySets id list of a type object, from whichever authority
- * owns the record.
+ * `step-property-sets.ts` was split into this file plus
+ * `step-property-set-readers.ts` (the shared {@link PropertySetContext} and
+ * per-entity STEP-text readers), `step-property-set-index.ts` (the
+ * IfcRelDefinesByProperties reverse index), `step-property-set-generators.ts`
+ * (the two record generators) and `step-property-set-collection.ts` (the
+ * overlay-edit collection phase) — #3184. This file kept the original name
+ * because it is the phase `export()` calls last and the one every doc
+ * comment elsewhere in the package already cites as `step-property-sets.ts`.
  *
- * Slot 5 is `HasPropertySets` on every `IfcTypeObject` subtype. For a source
- * record the list is parsed out of the file; for an overlay-created type it is
- * read off the authored payload, where a reference is the documented `'#42'`
- * string form. Reading only the source made every pset on a created
- * `IfcWallType` look unowned, which is how it ended up on an occurrence
- * relation instead (#2012).
- */
-function getTypeOwnedHasPropertySetIds(ctx, entityId, effective) {
-    if (effective.isOverlayCreated(entityId)) {
-        const authored = ctx.mutationView?.getNewEntity(entityId)?.attributes?.[HAS_PROPERTY_SETS_SLOT];
-        return authoredEntityRefs(overlaySlotValue(ctx, entityId, HAS_PROPERTY_SETS_SLOT, authored));
-    }
-    if (!ctx.entityExtractor)
-        return [];
-    const entityRef = ctx.dataStore.entityIndex.byId.get(entityId);
-    if (!entityRef)
-        return [];
-    const entity = ctx.entityExtractor.extractEntity(entityRef);
-    const hasPropertySets = entity?.attributes?.[HAS_PROPERTY_SETS_SLOT];
-    if (!Array.isArray(hasPropertySets))
-        return [];
-    return hasPropertySets.filter((value) => typeof value === 'number');
-}
-/**
- * The overlay's answer for one positional slot of an overlay-created entity,
- * falling back to the creation payload only when the overlay has NOTHING to
- * say about that slot.
+ * ## The state this function cannot read off the pass
  *
- * **Ask `Map.has`, never `??`.** `setPositionalAttribute(id, slot, null)` is
- * an explicit "clear this slot", and its value is `null`, so `??` reads the
- * overlay's answer as an absence and reinstates the authored one. That is the
- * same overlay-versus-buffer confusion this whole change is about, one
- * attribute wide: an explicit null IS the overlay's answer, and the overlay is
- * the authority. Cleared OwnerHistory came back as the authored reference, and
- * a cleared `HasPropertySets` resurrected the list the user had removed.
+ * `allocateExpressId` is the exporter's own `nextExpressId++`, shared with
+ * the georeferencing phase, so it is injected as a callback on
+ * {@link PropertySetContext} rather than hoisted onto the pass.
  */
-function overlaySlotValue(ctx, entityId, slot, authored) {
-    const overrides = ctx.mutationView?.getPositionalMutationsForEntity(entityId);
-    if (!overrides?.has(slot))
-        return authored;
-    const value = overrides.get(slot);
-    // `Map.get` widens to `| undefined`, which `has` has already ruled out. A
-    // slot explicitly set to nothing serializes as `$`, i.e. null.
-    return value === undefined ? null : value;
-}
-/**
- * Read an element's own OwnerHistory reference (`#id`), or null when the
- * element omits one (`$`) or cannot be parsed. OwnerHistory is the second
- * attribute of every IfcRoot subtype, immediately after the GlobalId string.
- */
-function getOwnerHistoryRefOfEntity(ctx, entityId) {
-    const cached = ctx.ownerHistory.byEntity.get(entityId);
-    if (cached !== undefined)
-        return cached;
-    let result = null;
-    // An overlay-created host has no source line to read, but it does have an
-    // authored OwnerHistory in slot 1 — reading only the buffer sent every
-    // generated pset on a created entity to the file's first owner history
-    // instead of the one the caller named (#2012).
-    const overlay = ctx.mutationView?.getNewEntity(entityId);
-    if (overlay) {
-        const refs = authoredEntityRefs(overlaySlotValue(ctx, entityId, OWNER_HISTORY_SLOT, overlay.attributes[OWNER_HISTORY_SLOT]));
-        result = refs.length > 0 ? `#${refs[0]}` : null;
-        ctx.ownerHistory.byEntity.set(entityId, result);
-        return result;
-    }
-    const entityRef = ctx.dataStore.entityIndex.byId.get(entityId);
-    // Readability rather than presence, as everywhere else (#2491). A clamped
-    // decode would match nothing here, so this is tidiness rather than a bug —
-    // but the gates in this file agree on one predicate now.
-    if (entityRef && ctx.isReadableSourceRef(entityRef)) {
-        const entityText = decodeRange(ctx.dataStore.source, entityRef.byteOffset, entityRef.byteOffset + entityRef.byteLength);
-        // #ID=IFCWALL('GlobalId',#owner,...): GlobalId is a quoted STEP string
-        // (doubled '' escapes); OwnerHistory is the ref/`$` right after it.
-        const match = entityText.match(/=\s*IFC\w+\s*\(\s*'(?:[^']|'')*'\s*,\s*#(\d+)/i);
-        if (match)
-            result = `#${match[1]}`;
-    }
-    ctx.ownerHistory.byEntity.set(entityId, result);
-    return result;
-}
-/**
- * Resolve a STEP reference to an existing IfcOwnerHistory for the
- * IfcPropertySet / IfcRelDefinesByProperties / IfcElementQuantity entities we
- * generate for `hostEntityId`'s mutations. OwnerHistory is optional in IFC4 but
- * MANDATORY in IFC2X3 (IfcRoot.OwnerHistory), so emitting `$` yields an invalid
- * IFC2X3 file that strict readers (e.g. BIM Vision) reject.
- *
- * Prefer the host element's OWN owner history, then any owner history that
- * survives this export, then `$` only when none does.
- *
- * "Survives" is `willBeEmitted`, the same predicate that decides whether the
- * host itself may have psets generated for it. A reference is a reference: it
- * is no more acceptable to point an emitted `IfcPropertySet` at an owner
- * history the session deleted than at a host it deleted. This used to consult
- * only the `visibleOnly` closure, so an overlay-created OwnerHistory that was
- * later deleted still got referenced — a dangling `#N`, reached through the
- * one attribute the generators fill in for themselves.
- */
-function resolveOwnerHistoryRef(ctx, hostEntityId, willBeEmitted) {
-    const own = getOwnerHistoryRefOfEntity(ctx, hostEntityId);
-    if (own !== null) {
-        const ownId = parseInt(own.slice(1), 10);
-        if (willBeEmitted(ownId))
-            return own;
-    }
-    if (ctx.ownerHistory.fallbackRef === undefined) {
-        // Source-only: the fallback is a best-effort "some owner history the file
-        // still has", and the host's OWN history above is the path that resolves
-        // an overlay-created one.
-        const ids = ctx.dataStore.entityIndex.byType.get('IFCOWNERHISTORY') ?? [];
-        const surviving = ids.find((id) => willBeEmitted(id));
-        ctx.ownerHistory.fallbackRef = surviving !== undefined ? `#${surviving}` : '$';
-    }
-    return ctx.ownerHistory.fallbackRef;
-}
-/**
- * Generate a new IFC GlobalId (22 character base64). `random` is the
- * export's optional seeded source (`StepExportOptions.guidRandom`);
- * undefined keeps the default random path.
- */
-function generateGlobalId(random) {
-    return generateIfcGuid(random);
-}
-/**
- * Find a unit entity ID by name (simplified - returns null for now)
- */
-function findUnitId(ctx, unitName, effective) {
-    return findLengthUnitReference(normalizeMapUnitName(unitName), effective, { dataStore: ctx.dataStore, entityExtractor: ctx.entityExtractor });
-}
-/**
- * Generate STEP entities for property sets
- */
-function generatePropertySetEntities(ctx, entityId, psets, willBeEmitted, effective, typeOwnedPsetNames, random) {
-    const lines = [];
-    let count = 0;
-    const generatedTypeOwnedPsetIds = new Map();
-    for (const pset of psets) {
-        const propertyIds = [];
-        // Create IfcPropertySingleValue for each property
-        for (const prop of pset.properties) {
-            const propId = ctx.allocateExpressId();
-            count++;
-            // `prop.dataType`, not `prop.type` alone: regenerating the set rewrites
-            // every property in it, and the shape-derived primitive would re-declare
-            // the ones nobody edited (`IFCTEXT` → `IFCLABEL`, `IFCLENGTHMEASURE` →
-            // `IFCREAL`). See `declared-property-type.ts` for when the source token
-            // is trusted (#2482).
-            const valueStr = serializeNominalValue(prop.value, prop.type, prop.dataType);
-            const unitId = prop.unit ? findUnitId(ctx, prop.unit, effective) : null;
-            const unitStr = unitId !== null ? ref(unitId) : null;
-            // #ID=IFCPROPERTYSINGLEVALUE('Name',$,Value,Unit);
-            const line = `#${propId}=IFCPROPERTYSINGLEVALUE('${escapeStepString(prop.name)}',$,${valueStr},${unitStr ? serializeValue(unitStr) : '$'});`;
-            lines.push(line);
-            propertyIds.push(propId);
-        }
-        // Create IfcPropertySet
-        const psetId = ctx.allocateExpressId();
-        count++;
-        const propRefs = propertyIds.map(id => `#${id}`).join(',');
-        const globalId = generateGlobalId(random);
-        // #ID=IFCPROPERTYSET('GlobalId',#ownerHistory,'Name',$,(#props));
-        const psetLine = `#${psetId}=IFCPROPERTYSET('${globalId}',${resolveOwnerHistoryRef(ctx, entityId, willBeEmitted)},'${escapeStepString(pset.name)}',$,(${propRefs}));`;
-        lines.push(psetLine);
-        if (typeOwnedPsetNames?.has(pset.name)) {
-            generatedTypeOwnedPsetIds.set(pset.name, psetId);
-        }
-        else {
-            // Create IfcRelDefinesByProperties to link pset to entity
-            const relId = ctx.allocateExpressId();
-            count++;
-            const relGlobalId = generateGlobalId(random);
-            // #ID=IFCRELDEFINESBYPROPERTIES('GlobalId',#ownerHistory,$,$,(#entity),#pset);
-            const relLine = `#${relId}=IFCRELDEFINESBYPROPERTIES('${relGlobalId}',${resolveOwnerHistoryRef(ctx, entityId, willBeEmitted)},$,$,(#${entityId}),#${psetId});`;
-            lines.push(relLine);
-        }
-    }
-    return { lines, count, generatedTypeOwnedPsetIds };
-}
-/**
- * Generate STEP entities for quantity sets (IfcElementQuantity)
- */
-function generateQuantitySetEntities(ctx, entityId, qsets, willBeEmitted, random) {
-    const lines = [];
-    let count = 0;
-    for (const qset of qsets) {
-        const quantityIds = [];
-        for (const q of qset.quantities) {
-            const qId = ctx.allocateExpressId();
-            count++;
-            const ifcType = quantityTypeToIfcType(q.type);
-            // #ID=IFCQUANTITYLENGTH('Name',$,$,Value,$);
-            const val = toStepReal(q.value);
-            const line = `#${qId}=${ifcType}('${escapeStepString(q.name)}',$,$,${val},$);`;
-            lines.push(line);
-            quantityIds.push(qId);
-        }
-        // Create IfcElementQuantity
-        const qsetId = ctx.allocateExpressId();
-        count++;
-        const quantRefs = quantityIds.map(id => `#${id}`).join(',');
-        const globalId = generateGlobalId(random);
-        // #ID=IFCELEMENTQUANTITY('GlobalId',#ownerHistory,'Name',$,$,(#quants));
-        const qsetLine = `#${qsetId}=IFCELEMENTQUANTITY('${globalId}',${resolveOwnerHistoryRef(ctx, entityId, willBeEmitted)},'${escapeStepString(qset.name)}',$,$,(${quantRefs}));`;
-        lines.push(qsetLine);
-        // Create IfcRelDefinesByProperties to link qset to entity
-        const relId = ctx.allocateExpressId();
-        count++;
-        const relGlobalId = generateGlobalId(random);
-        const relLine = `#${relId}=IFCRELDEFINESBYPROPERTIES('${relGlobalId}',${resolveOwnerHistoryRef(ctx, entityId, willBeEmitted)},$,$,(#${entityId}),#${qsetId});`;
-        lines.push(relLine);
-    }
-    return { lines, count };
-}
-/**
- * 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');
-                }
-            }
-        }
-    }
-}
+import { decodeRange } from './source-ref-bounds.js';
+import { resolveTypeOwnedPsetIds, rewriteTypeOwnedPsetLine, typeOwnedPsetRewriteWarning, } from './type-owned-psets.js';
+import { recordSourceLineDelivery } from './delta-modification-ledger.js';
+import { nominateDeliveredInPlaceEdits } from './in-place-nomination.js';
+import { getPropertySetName } from './step-property-set-readers.js';
+import { generatePropertySetEntities, generateQuantitySetEntities } from './step-property-set-generators.js';
 /**
  * Write the generated property-set and quantity-set records into
  * `pass.entities`, and point every affected type object's `HasPropertySets` at