@ifc-lite/export 2.9.4 → 3.0.1

package/dist/step-omission-predicates.js

@@ -0,0 +1,268 @@
+/* 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/. */
+export function evaluateOmissionPredicates(pass, options, applyMutations, excludeGeometry, mutationView) {
+    /**
+     * "Does this model hold a record whose bytes this export cannot read?" —
+     * the one disjunct of {@link mayNameOmittedRefs} that is not already a
+     * value in hand, so it is a function and called last, behind `||`.
+     *
+     * Scans the EFFECTIVE index, and that is a requirement rather than an
+     * implementation detail: it has to cover the id space
+     * `isOmittedFromOutput` answers over, and an unreadable record can live in
+     * `deferredEntityIndex` — the secondary index `getCompleteEntityIndex`
+     * exists to merge — and nowhere in `entityIndex.byId`. Scanning `byId`,
+     * the obvious cheaper source, was measured to leave the gate false and
+     * ship the dangling ref; `relationship-filter-gate.test.ts` pins the
+     * merged scan behaviourally so that shortcut cannot come back as an
+     * optimisation.
+     *
+     * Reads the ref ITERATION yields — what the source-iteration pass's own
+     * skip reads — rather than re-asking `effective.get(id)` per id as
+     * `willBeEmitted` does, which on the largest files would cost a binary
+     * search and an allocation per entity and defeat the point of the gate.
+     * Every index here keeps the two in step by construction:
+     * `CompactEntityIndex` serves `get`, `has` and iteration from one pair of
+     * `Uint32Array`s, a `Map` trivially agrees, the merged deferred view is
+     * `byId.get ?? deferred.get` over `yield* byId; yield* deferred`, and
+     * `OverlayIndex` filters both by one tombstone set. An index whose `has`
+     * accepted an id its iteration never yields would defeat this — and would
+     * equally defeat the source-iteration pass's skip, so that file is broken
+     * either way; nothing in the repo builds one.
+     *
+     * Not short-circuited on `overlayActive`: an overlay-created record carries
+     * `(OVERLAY_BYTE_OFFSET, 0)` and so counts as unreadable here, which would
+     * make this always answer true once an overlay exists. Harmless —
+     * `overlayActive` is an earlier disjunct, so this never runs then — and
+     * correct if it ever did.
+     *
+     * ## Why a standalone pass rather than a value off the index
+     *
+     * Measured: 12.0 ms of a 470 ms export at 714,485 entities (2.55%), one
+     * call, whole index walked because a well-formed model gives it nothing to
+     * short-circuit on. The cheaper shape was prototyped and is 13x faster —
+     * `min(byteLength)` and `max(byteOffset + byteLength)` over
+     * `CompactEntityIndex`'s own `Uint32Array`s answer "is every ref readable
+     * within `extent`" exactly and allocation-free in 0.74 ms — and was not
+     * taken, because 11 ms does not buy what it costs.
+     *
+     * It could only stand in FRONT of this loop, never replace it:
+     * `EntityByIdIndex` is a structural type and plain `Map`s satisfy it
+     * (`synthetic-data-store.ts` builds one), so the walk stays for those. That
+     * makes it a second implementation of one predicate across a package
+     * boundary — the defect class #2637, #2668 and this gate are all instances
+     * of. And storing it at construction is the invariant
+     * `source-ref-bounds.ts` exists to delete: `CompactEntityIndex` is built by
+     * its builder, by `compactEntityIndexFromColumns` in the transport, and by
+     * embedders, so a value one producer writes is a value the next can skip,
+     * whereas testing the ref where it is READ cannot be bypassed. If 2.5% ever
+     * has to go, the safe shape is a memoized derivation the index computes
+     * from its own arrays on demand — not a field set at build time.
+     */
+    const hasAnyUnreadableSourceRef = () => {
+        for (const [, ref] of pass.effective) {
+            if (!pass.isReadableSourceRef(ref))
+                return true;
+        }
+        return false;
+    };
+    // If delta only, only export modified entities. Overlay-created entities
+    // also count — without this, `createEntity()`-only edits would silently
+    // drop out of delta exports.
+    const overlayNewEntityCount = (mutationView
+        && applyMutations
+        && typeof mutationView.getNewEntities === 'function') ? mutationView.getNewEntities().length : 0;
+    // Georef-only deltas (newGeorefLines populated but no entity changes) must
+    // still produce a non-empty DATA section.
+    if (
+    // `=== true`, matching `step-pass-builder.ts`'s two reads of the same
+    // option. A plain-JS caller passing `deltaOnly: 1` would otherwise have
+    // this module call the export a delta while the predicates there call it
+    // a full export -- the same divergence this file argues against for
+    // `visibleOnly` a few paragraphs down.
+    options.deltaOnly === true
+        && pass.modifiedEntities.size === 0
+        && overlayNewEntityCount === 0
+        && pass.newGeorefLines.length === 0) {
+        const emptyContent = new TextEncoder().encode(pass.buildHeader(0) + 'DATA;\nENDSEC;\nEND-ISO-10303-21;\n');
+        return {
+            kind: 'short-circuit',
+            result: {
+                content: emptyContent,
+                stats: {
+                    entityCount: 0,
+                    newEntityCount: 0,
+                    modifiedEntityCount: 0,
+                    fileSize: emptyContent.byteLength,
+                    warnings: pass.warnings,
+                },
+            },
+        };
+    }
+    /**
+     * "May a line this export writes name `#id`?" — the single predicate both
+     * relationship-line filter sites consume, derived from `willBeEmitted`
+     * rather than from a second list kept in step with it by hand.
+     *
+     * DERIVED, not identical, and the gaps are named below rather than glossed:
+     * a scope qualifier for ids the file never had, and `deltaOnly`, where
+     * `willBeEmitted` answers `true` for a source record whose line this export
+     * does not write at all (the source-iteration pass is skipped wholesale in
+     * that mode). Nor does this make the CLOSURE WALK agree with either: the
+     * walk keeps `isRefExcludedDuringClosureWalk` and diverges from this
+     * predicate for an unreadable source ref — see the note on that predicate,
+     * and the "walk and output predicates diverge" test.
+     *
+     * The hand-kept second list is the bug this replaces. `willBeEmitted` recognises
+     * seven reasons a line never lands — outside the closure, hidden product,
+     * tombstoned, never existed, unreadable source ref (#2491), geometry
+     * excluded by options, and the `deltaOnly` carve-out — while the filter
+     * used to consume `(hiddenProductIds !== null && hiddenProductIds.has(id))
+     * || effective.isDeleted(id)`, which answered for two: hidden product, and
+     * tombstoned. Notably NOT "never existed" — that one is deliberately out of
+     * scope for the filter even now, for the reason under the qualifier heading
+     * below. The gap was live: on a PLAIN full export, with no `visibleOnly`,
+     * no deletions and no overlay, an unreadable ref made the source-iteration
+     * pass skip an entity's line while an `IFCREL*` naming it shipped verbatim,
+     * dangling.
+     *
+     * Deriving the filter from `willBeEmitted` is also what fixed the
+     * `mayNameExcludedRefs` gate that stands in front of both call sites. That
+     * gate used to be a SECOND, shorter enumeration of the same reasons
+     * (hidden products exist, or an overlay is active) and answered `false` for
+     * exactly the unreadable-ref export above, so the filter never ran at all.
+     * It is now {@link mayNameOmittedRefs} — see there for why a gate is kept
+     * at all (running the filter on every `IFCREL*` line costs +13% of a
+     * 714k-entity export) and for the enumeration it has to cover.
+     *
+     * ## The one qualifier on top of `willBeEmitted`
+     *
+     * `willBeEmitted` answers NO for an id neither the file nor the session
+     * ever had, which is right for its own job — nothing GENERATED may name an
+     * id that does not exist. It is the wrong answer for rewriting a SOURCE
+     * line, and the difference is whose bug it is. A `#999` already sitting in
+     * a relationship's `OwnerHistory` slot in the input file is a dangling ref
+     * this export did not create and cannot repair; `filterHiddenRefsFromRelationshipLine`
+     * withholds a whole relationship when an excluded id is in a bare scalar,
+     * so treating it as an exclusion would DELETE a visible element's pset over
+     * somebody else's corrupt file. That is the harm #2637 was about, and
+     * `step-exporter.test.ts` states the position out loud: a pre-existing
+     * dangling ref is out of scope and ships as it arrived.
+     *
+     * So the filter asks the narrower question: is `#id` an entity this model
+     * HAS, that this export is nonetheless not writing? `effective.has` is
+     * false for a tombstone, hence the explicit `isDeleted` arm — deleting an
+     * entity IS this session's doing and must be filtered.
+     *
+     * This is a scope qualifier, not a second enumeration of omission reasons:
+     * an eighth reason added to `willBeEmitted` still reaches the filter with
+     * no edit here.
+     *
+     * ## What the filter can and cannot reach
+     *
+     * Only `IFCREL*` lines. A `#N` named from a product's `Representation` or
+     * `ObjectPlacement` slot is not touched, so `includeGeometry:false` — a
+     * reason `willBeEmitted` does answer for — produces the same dangling refs
+     * with this predicate as without it. Measured on `tests/models/AB22.ifc`:
+     * 80 dangling refs before and after, output byte-identical but for the
+     * header timestamp.
+     *
+     * ## Withholding is not free
+     *
+     * When the omitted id sits in a single-valued slot, or is a set's only
+     * member, `filterHiddenRefsFromRelationshipLine` withholds the WHOLE
+     * relationship — so an entity that relationship also named loses the
+     * association, on a plain full export with no options set. That is why the
+     * call sites push {@link relationshipWithheldWarning}.
+     *
+     * See `unreadable-ref-dangling.test.ts` for the reproduction. #2637 is the
+     * prior instance of this class, which took seven rounds because the same
+     * decision was recomputed per call site.
+     */
+    const isOmittedFromOutput = (id) => (pass.effective.has(id) || pass.effective.isDeleted(id)) && !pass.willBeEmitted(id);
+    /**
+     * "Can ANY id be omitted from this export at all?" — the precondition both
+     * `IFCREL*` filter sites are gated on, so the common export pays nothing.
+     *
+     * ## Why a gate exists
+     *
+     * Running `filterHiddenRefsFromRelationshipLine` on every `IFCREL*` line
+     * costs a re-parse of that line's attribute list, and a large model is
+     * mostly relationships. Measured on `tests/models/ara3d/schependomlaan.ifc`
+     * (714,485 entities, 21 interleaved reps in randomised order): 463 ms
+     * median with this gate false versus 523 ms filtering unconditionally,
+     * **+13%**. That is a real price paid on every export to protect a state
+     * most exports are not in. With the gate, the same export is 475 ms, +2.7%,
+     * all of it the fourth disjunct's one pass.
+     *
+     * ## Why THIS gate, and not the one that shipped before
+     *
+     * The gate this replaces was a second, hand-kept enumeration of "reasons an
+     * entity might be excluded", and it went stale exactly as such lists do: it
+     * named hidden products and the overlay and knew nothing about an unreadable
+     * source ref, so the bug this branch fixes reached the output with the
+     * filter switched off. A cheap gate is safe only as an OVER-APPROXIMATION of
+     * `isOmittedFromOutput` that can be checked against `willBeEmitted` branch
+     * by branch — so every branch is listed, with the disjunct that covers it:
+     *
+     * | `willBeEmitted` answers NO at                | covered by                    |
+     * |----------------------------------------------|-------------------------------|
+     * | `allowedEntityIds !== null && !has(id)`      | `allowedEntityIds !== null`   |
+     * | `!ref`, because the overlay tombstoned `id`  | `overlayActive`               |
+     * | overlay-created, geometry excluded           | `overlayActive`               |
+     * | `!isReadableSourceRef(ref)`                  | `hasAnyUnreadableSourceRef()` |
+     * | source-backed, geometry excluded             | `excludeGeometry`             |
+     * | `!ref`, because `id` never existed           | out of scope (below)          |
+     * | `!ref` while `has(id)` is TRUE               | nothing (below)               |
+     *
+     * "Never existed" needs no disjunct: `isOmittedFromOutput`'s own
+     * `(has || isDeleted)` qualifier already drops it, deliberately — a
+     * pre-existing dangling ref in somebody else's file is not this export's to
+     * repair (see that predicate's note).
+     *
+     * The last row is a real hole and is stated rather than hidden: an index
+     * that answers `has(id)` for an id its iteration never yields makes
+     * `isOmittedFromOutput` true with no disjunct true. It needs an index whose
+     * `has`, `get` and iteration disagree, which nothing in the repo builds and
+     * which would already break the source-iteration pass's own skip — see
+     * {@link hasAnyUnreadableSourceRef}, which rests on the same agreement.
+     *
+     * Three of the four disjuncts are reads of values this export already
+     * computed. Only the fourth costs anything, and it short-circuits: `||`
+     * evaluates it solely when the other three are false, i.e. only for an
+     * export that has nothing else to filter for.
+     *
+     * ## The two spellings that are deliberately NOT the obvious ones
+     *
+     * `allowedEntityIds !== null`, not `options.visibleOnly === true`. Not the
+     * same test: the closure is built under `if (options.visibleOnly &&
+     * ctx.dataStore.source)` in `step-collection.ts` — quoted rather than cited
+     * by line, because the line moved by three in the very commit that added
+     * this reference — which is TRUTHY rather than `=== true`, and which
+     * is a SECOND read of the caller's object. A plain-JS caller of this
+     * published package passing `visibleOnly: 1` — or a `get visibleOnly()` that
+     * answers `true` once — built the closure while the gate read false and
+     * shipped a relationship naming an entity outside it. Executed, not
+     * reasoned: 192 of an 800-case sweep over `visibleOnly`/`hidden`/`isolated`
+     * combinations shipped a dangling ref against the `=== true` spelling, 0
+     * against this one. Reading the state the walk PRODUCED cannot disagree with
+     * the walk, whatever `options` says afterwards.
+     *
+     * It is also wider than the `hiddenProductIds.size > 0` the old gate used: a
+     * closure exists whenever `visibleOnly` was requested, even with nothing
+     * hidden, and can exclude an entity the roots simply never reach. No fixture
+     * has produced that case, so the widening is defensive — but a gate that is
+     * true too often costs speed on a rare path, while one that is false too
+     * rarely ships a corrupt file, and this one costs nothing.
+     *
+     * `overlayActive` and `excludeGeometry` are the SAME consts the effective
+     * index and `isGeometryExcluded` are built from — one read of `options` per
+     * question, shared — so those two cannot disagree with the predicate either.
+     */
+    const mayNameOmittedRefs = pass.allowedEntityIds !== null
+        || pass.overlayActive
+        || excludeGeometry
+        || hasAnyUnreadableSourceRef();
+    return { kind: 'continue', isOmittedFromOutput, mayNameOmittedRefs };
+}
+//# sourceMappingURL=step-omission-predicates.js.map

package/dist/step-omission-predicates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-omission-predicates.js","sourceRoot":"","sources":["../src/step-omission-predicates.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAqD/D,MAAM,UAAU,0BAA0B,CACxC,IAAgB,EAChB,OAA0B,EAC1B,cAAuB,EACvB,eAAwB,EACxB,YAAwC;IAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwDG;IACH,MAAM,yBAAyB,GAAG,GAAY,EAAE;QAC9C,KAAK,MAAM,CAAC,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACrC,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC;gBAAE,OAAO,IAAI,CAAC;QAClD,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF,yEAAyE;IACzE,wEAAwE;IACxE,6BAA6B;IAC7B,MAAM,qBAAqB,GAAG,CAC5B,YAAY;WACT,cAAc;WACd,OAAO,YAAY,CAAC,cAAc,KAAK,UAAU,CACrD,CAAC,CAAC,CAAC,YAAY,CAAC,cAAc,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7C,2EAA2E;IAC3E,0CAA0C;IAC1C;IACE,sEAAsE;IACtE,wEAAwE;IACxE,yEAAyE;IACzE,oEAAoE;IACpE,uCAAuC;IACvC,OAAO,CAAC,SAAS,KAAK,IAAI;WACvB,IAAI,CAAC,gBAAgB,CAAC,IAAI,KAAK,CAAC;WAChC,qBAAqB,KAAK,CAAC;WAC3B,IAAI,CAAC,cAAc,CAAC,MAAM,KAAK,CAAC,EACnC,CAAC;QACD,MAAM,YAAY,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,qCAAqC,CAAC,CAAC;QAC3G,OAAO;YACL,IAAI,EAAE,eAAe;YACrB,MAAM,EAAE;gBACN,OAAO,EAAE,YAAY;gBACrB,KAAK,EAAE;oBACL,WAAW,EAAE,CAAC;oBACd,cAAc,EAAE,CAAC;oBACjB,mBAAmB,EAAE,CAAC;oBACtB,QAAQ,EAAE,YAAY,CAAC,UAAU;oBACjC,QAAQ,EAAE,IAAI,CAAC,QAAQ;iBACxB;aACF;SACF,CAAC;IACJ,CAAC;IAGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+EG;IACH,MAAM,mBAAmB,GAAG,CAAC,EAAU,EAAW,EAAE,CAClD,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC;IAEtF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8EG;IACH,MAAM,kBAAkB,GACtB,IAAI,CAAC,gBAAgB,KAAK,IAAI;WAC3B,IAAI,CAAC,aAAa;WAClB,eAAe;WACf,yBAAyB,EAAE,CAAC;IACjC,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,CAAC;AACvE,CAAC"}

package/dist/step-overlay-attribute-overrides.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Apply overlay attribute + positional overrides to an OVERLAY-CREATED
+ * entity's argument list (#2006) — the sibling of `step-attribute-
+ * mutations.ts`'s source-buffer pipeline that shares its two serialize
+ * helpers (`step-attribute-serializers.ts`). Split out of
+ * `step-attribute-mutations.ts` (#3184).
+ */
+import type { IfcAttributeValue } from '@ifc-lite/parser';
+import type { IfcSchemaVersion } from './schema-converter.js';
+/**
+ * Apply overlay attribute + positional overrides to an OVERLAY-CREATED
+ * entity's argument list (#2006).
+ *
+ * Distinct from {@link applyAttributeMutations} / {@link applyPositionalMutations},
+ * which rewrite a line read out of the source buffer. Here the whole line is
+ * ours: it was serialized moments ago from the creation payload, so the
+ * argument list is the authoring payload's, not the file's. That difference
+ * is why this PADS — `entity_create` takes whatever positional list the
+ * caller passes, so a wall authored with three arguments still has a real
+ * `Tag` slot at index 7, and dropping the edit because the payload was short
+ * would be the very data loss this fixes. The source-buffer path must not
+ * pad: there a short line means a different schema, and growing a record we
+ * did not author would corrupt it.
+ *
+ * Named and positional overrides resolve to a slot index up front and share
+ * ONE padding rule. Two padding rules on one record is how the next bug
+ * starts, and the argument for padding — the class is fixed at creation time,
+ * so a short payload is partial authoring — never depended on which of the
+ * two APIs queued the edit.
+ */
+export declare function applyOverlayEntityOverrides(argsText: string, entityType: string, attributeOverrides: Map<string, string> | null, positionalOverrides: Map<number, IfcAttributeValue> | null, schemaVersion: IfcSchemaVersion, onRejected?: (attrName: string, value: string) => void): string;
+//# sourceMappingURL=step-overlay-attribute-overrides.d.ts.map

package/dist/step-overlay-attribute-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-overlay-attribute-overrides.d.ts","sourceRoot":"","sources":["../src/step-overlay-attribute-overrides.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAK1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,EAC9C,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAAG,IAAI,EAC1D,aAAa,EAAE,gBAAgB,EAC/B,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GACrD,MAAM,CAoER"}

package/dist/step-overlay-attribute-overrides.js

@@ -0,0 +1,83 @@
+/* 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 { getAttributeNamesAcrossSchemas } from '@ifc-lite/parser';
+import { splitTopLevelArgs } from './step-argument-parser.js';
+import { getRealTypedSlots } from './attribute-real-slots.js';
+import { serializeNamedAttribute, serializePositionalOverride } from './step-attribute-serializers.js';
+/**
+ * Apply overlay attribute + positional overrides to an OVERLAY-CREATED
+ * entity's argument list (#2006).
+ *
+ * Distinct from {@link applyAttributeMutations} / {@link applyPositionalMutations},
+ * which rewrite a line read out of the source buffer. Here the whole line is
+ * ours: it was serialized moments ago from the creation payload, so the
+ * argument list is the authoring payload's, not the file's. That difference
+ * is why this PADS — `entity_create` takes whatever positional list the
+ * caller passes, so a wall authored with three arguments still has a real
+ * `Tag` slot at index 7, and dropping the edit because the payload was short
+ * would be the very data loss this fixes. The source-buffer path must not
+ * pad: there a short line means a different schema, and growing a record we
+ * did not author would corrupt it.
+ *
+ * Named and positional overrides resolve to a slot index up front and share
+ * ONE padding rule. Two padding rules on one record is how the next bug
+ * starts, and the argument for padding — the class is fixed at creation time,
+ * so a short payload is partial authoring — never depended on which of the
+ * two APIs queued the edit.
+ */
+export function applyOverlayEntityOverrides(argsText, entityType, attributeOverrides, positionalOverrides, schemaVersion, onRejected) {
+    const args = argsText.length > 0 ? splitTopLevelArgs(argsText) : [];
+    const attrNames = getAttributeNamesAcrossSchemas(entityType);
+    const named = [];
+    for (const [attrName, value] of attributeOverrides ?? []) {
+        const index = attrNames.indexOf(attrName);
+        if (index >= 0)
+            named.push([index, value]);
+    }
+    // Grow to the class's FULL declared arity as soon as any override names a
+    // declared slot the creation payload never reached. Growing only as far as
+    // the edited slot would emit eight arguments for an IfcWall that declares
+    // nine: this parser tolerates the truncated record, a schema-validating
+    // consumer rejects the file.
+    //
+    // An index PAST the declared layout is not a slot at all, so it cannot
+    // justify growing the record and stays dropped — as does any override on a
+    // class neither schema source knows, where there is no arity to grow to.
+    let needsPad = named.some(([index]) => index >= args.length);
+    if (!needsPad && positionalOverrides) {
+        for (const [index] of positionalOverrides) {
+            if (index >= args.length && index < attrNames.length) {
+                needsPad = true;
+                break;
+            }
+        }
+    }
+    if (needsPad) {
+        while (args.length < attrNames.length)
+            args.push('$');
+    }
+    // Every `named` index is < attrNames.length by construction, and padding
+    // has taken args.length to at least that, so each one lands.
+    const realSlots = getRealTypedSlots(entityType, schemaVersion);
+    for (const [index, value] of named) {
+        const serialized = serializeNamedAttribute(entityType, index, value, args[index], realSlots);
+        // Overlay-created entities take the same rejection: a non-numeric REAL is
+        // invalid STEP whoever authored the record. The slot keeps the `$` this
+        // path padded it with, rather than gaining a quoted string.
+        if (serialized === null) {
+            onRejected?.(attrNames[index] ?? `#${index}`, value);
+            continue;
+        }
+        args[index] = serialized;
+    }
+    if (positionalOverrides && positionalOverrides.size > 0) {
+        for (const [index, value] of positionalOverrides) {
+            if (index < 0 || index >= args.length)
+                continue;
+            args[index] = serializePositionalOverride(entityType, index, value, args[index], realSlots, schemaVersion);
+        }
+    }
+    return args.join(',');
+}
+//# sourceMappingURL=step-overlay-attribute-overrides.js.map

package/dist/step-overlay-attribute-overrides.js.map

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

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

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

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

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

package/dist/step-overlay-entities.js

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

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

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