@ifc-lite/export 2.9.4 → 3.0.0

package/dist/step-collection.d.ts

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

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

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

package/dist/step-collection.js

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

package/dist/step-collection.js.map

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

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

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

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

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

package/dist/step-export-contexts.js

@@ -0,0 +1,51 @@
+/* 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 { applySourceLineMutations, applyOverlayEntityOverrides } from './step-attribute-mutations.js';
+import { relationshipWithheldWarning } from './step-export-types.js';
+import { isGeometryEntity } from './step-geometry-types.js';
+/**
+ * The state `step-source-iteration.ts` cannot read off the pass (#2475 2d).
+ *
+ * No `allocateExpressId`: that phase never allocates an id, it only rewrites
+ * lines that already have one. `applySourceLineMutations` (a free function in
+ * `step-attribute-mutations.ts`, closed over `mutationView` here) and
+ * `isGeometryEntity` are injected rather than read off the pass because each
+ * has readers outside this phase — the mutation pipeline is shared with the
+ * type-object `HasPropertySets` rewrite (see `StepExporter`'s
+ * `propertySetContext`, which stays a method because it mints express ids) and
+ * with the overlay-created-entities block in `export()`; `isGeometryEntity`
+ * with the visible-only setup closure and that same block.
+ *
+ * `propertySetContext` arrives as a THUNK, not a value: the phase calls it
+ * per use and the original method rebuilt it per call, which is the behaviour
+ * being preserved.
+ */
+export function buildSourceIterationContext(dataStore, mutationView, propertySetContext) {
+    return {
+        dataStore,
+        applySourceLineMutations: (expressId, entityText, recordType, attributeMutations, sourceSchema, overlayActive, onRejected) => applySourceLineMutations(mutationView, expressId, entityText, recordType, attributeMutations, sourceSchema, overlayActive, onRejected),
+        isGeometryEntity,
+        propertySetContext,
+        relationshipWithheldWarning,
+    };
+}
+/**
+ * The state `step-overlay-entities.ts` cannot read off the pass (#2475
+ * step 2e). `applyOverlayEntityOverrides` is the free function
+ * `step-attribute-mutations.ts` exports — it and its two
+ * `serializeNamedAttribute` / `serializePositionalOverride` helpers moved
+ * together, since those two have no reader outside this cluster;
+ * `isGeometryEntity` and `relationshipWithheldWarning` are the same shared
+ * readers {@link buildSourceIterationContext} already injects into the other
+ * output pass.
+ */
+export function buildOverlayEntitiesContext(mutationView) {
+    return {
+        mutationView,
+        applyOverlayEntityOverrides,
+        isGeometryEntity,
+        relationshipWithheldWarning,
+    };
+}
+//# sourceMappingURL=step-export-contexts.js.map

package/dist/step-export-contexts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-export-contexts.js","sourceRoot":"","sources":["../src/step-export-contexts.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAiC/D,OAAO,EAAE,wBAAwB,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AACtG,OAAO,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAK5D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,2BAA2B,CACzC,SAAuB,EACvB,YAAwC,EACxC,kBAA4C;IAE5C,OAAO;QACL,SAAS;QACT,wBAAwB,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,kBAAkB,EAAE,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,EAAE,CAC3H,wBAAwB,CAAC,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,kBAAkB,EAAE,YAAY,EAAE,aAAa,EAAE,UAAU,CAAC;QACxI,gBAAgB;QAChB,kBAAkB;QAClB,2BAA2B;KAC5B,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,2BAA2B,CACzC,YAAwC;IAExC,OAAO;QACL,YAAY;QACZ,2BAA2B;QAC3B,gBAAgB;QAChB,2BAA2B;KAC5B,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,262 @@
+/**
+ * The vocabulary of a STEP export: what a caller asks for, what it gets back,
+ * and the state one `export()` call threads through its phases.
+ *
+ * Split out of `step-exporter.ts` for #2475. These are declarations only -- no
+ * behaviour lives here beyond one message builder -- which is why they could
+ * move without touching a single guard.
+ *
+ * Two ways in, deliberately. The seven sibling modules that already imported
+ * `ExportPass` / `SourceLineMutations` still import them from
+ * `step-exporter.js`, which re-exports this file, so no existing call site
+ * moved and the package's public entry point is untouched. Code written since
+ * the split imports straight from here instead -- `step-pass-builder.ts` does
+ * -- because the re-export exists to avoid churning callers, not as a channel
+ * anything new should be routed through.
+ */
+import type { IfcAttributeValue, IfcSourceHeader, MapConversion, ProjectedCRS } from '@ifc-lite/parser';
+import type { PropertySet, QuantitySet } from '@ifc-lite/data';
+import type { RandomSource } from '@ifc-lite/encoding';
+import type { IfcSchemaVersion } from './schema-converter.js';
+import type { ModificationLedger, SourceLineDelivery } from './delta-modification-ledger.js';
+import type { EffectiveEntityIndex } from './effective-index.js';
+import type { createSourceRefReader } from './source-ref-bounds.js';
+/**
+ * Options for STEP export
+ */
+export interface StepExportOptions {
+    /** IFC schema version for the output file (any version, will convert if needed) */
+    schema: 'IFC2X3' | 'IFC4' | 'IFC4X3' | 'IFC5';
+    /** File description */
+    description?: string;
+    /** Author name */
+    author?: string;
+    /** Organization name */
+    organization?: string;
+    /** Application name (defaults to 'ifc-lite') */
+    application?: string;
+    /** Output filename */
+    filename?: string;
+    /** Include original geometry entities (default: true) */
+    includeGeometry?: boolean;
+    /** Include property sets (default: true) */
+    includeProperties?: boolean;
+    /** Include quantity sets (default: true) */
+    includeQuantities?: boolean;
+    /** Include relationships (default: true) */
+    includeRelationships?: boolean;
+    /** Apply mutations from MutablePropertyView (default: true if provided) */
+    applyMutations?: boolean;
+    /** Only export entities with mutations (delta export) */
+    deltaOnly?: boolean;
+    /** Only export entities currently visible in the viewer */
+    visibleOnly?: boolean;
+    /** Hidden entity IDs (local expressIds) — required when visibleOnly is true */
+    hiddenEntityIds?: Set<number>;
+    /** Isolated entity IDs (local expressIds, null = no isolation active) */
+    isolatedEntityIds?: Set<number> | null;
+    /** Georeferencing mutations to apply (IfcProjectedCRS / IfcMapConversion edits) */
+    georefMutations?: {
+        projectedCRS?: Partial<ProjectedCRS>;
+        mapConversion?: Partial<MapConversion>;
+    };
+    /**
+     * Seeded randomness for the GlobalIds this exporter SYNTHESIZES:
+     * the `IfcPropertySet` / `IfcElementQuantity` roots regenerated for
+     * mutated (or overlay-created) property and quantity sets, their
+     * `IfcRelDefinesByProperties` links. Without it those come from the platform
+     * CSPRNG, so two exports of the same model differ in exactly those bytes -
+     * which breaks byte-reproducibility for in-store builds that call
+     * `addPropertySet` / `addQuantitySet` (the sets themselves live in the
+     * mutation overlay and only become IFC roots here). Pass the same seeded
+     * source used for `SpatialAnchor.guidRandom` to close that gap. Default
+     * (omitted) behaviour for THESE ids is unchanged: random.
+     *
+     * NOT the `IFCPROXY` placeholders any more (#2733). Those used to be minted
+     * from this source too, so an omitted `guidRandom` made every downgraded
+     * IFC4X3 entity differ on re-export. They are now derived from the source
+     * line when this is omitted, and only fall back to this source when it is
+     * supplied - so passing a seeded source still pins them, but NOT passing one
+     * no longer makes them random. See `convertStepLine`.
+     */
+    guidRandom?: RandomSource;
+    /**
+     * Pin the STEP header `FILE_NAME` timestamp (STEP format, e.g.
+     * `20240101T000000`). Omitted = the wall clock, as before. Required for
+     * genuinely byte-identical exports, since the header otherwise carries the
+     * export instant.
+     */
+    timeStamp?: string;
+    /** Progress callback for async export */
+    onProgress?: (progress: StepExportProgress) => void;
+}
+/**
+ * Progress information during STEP export
+ */
+export interface StepExportProgress {
+    /** Current phase of export */
+    phase: 'preparing' | 'entities' | 'assembling';
+    /** Progress 0-1 */
+    percent: number;
+    /** Number of entities processed so far */
+    entitiesProcessed: number;
+    /** Total entities to process */
+    entitiesTotal: number;
+}
+/**
+ * Result of STEP export
+ */
+export interface StepExportResult {
+    /** STEP file content as bytes (avoids V8 string length limit for large files) */
+    content: Uint8Array;
+    /** Statistics about the export */
+    stats: {
+        /** Total entities exported */
+        entityCount: number;
+        /** New entities created for mutations */
+        newEntityCount: number;
+        /** Entities modified by mutations */
+        modifiedEntityCount: number;
+        /** File size in bytes */
+        fileSize: number;
+        /**
+         * Non-fatal refusals: things the caller asked for that this export could
+         * not write. Empty when the export did everything it was asked to do.
+         *
+         * A requested `georefMutations.mapConversion` is one case: with no
+         * `IfcGeometricRepresentationContext` to reference as `SourceCRS`, the
+         * `IfcMapConversion` is skipped (writing it would produce a dangling
+         * reference) while the `IfcProjectedCRS` is still written — so the output
+         * is indistinguishable from "no map conversion was requested" unless the
+         * caller reads this (#2067).
+         *
+         * A WITHHELD RELATIONSHIP is the other: when a relationship names an
+         * entity this export is not writing, in a slot with no spelling for an
+         * omitted reference, the whole relationship line is dropped rather than
+         * shipped dangling — see {@link relationshipWithheldWarning}. This can
+         * happen on a plain full export with no options set at all, so it is
+         * reported rather than left to be discovered by a diff.
+         *
+         * Same `string[]` shape as `MergeExportResult.stats.warnings`.
+         */
+        warnings: string[];
+    };
+}
+/**
+ * Message for a relationship this export DROPPED rather than rewrote.
+ *
+ * `filterHiddenRefsFromRelationshipLine` removes an omitted `#N` from a
+ * SET/LIST attribute, but a single-valued attribute has no STEP spelling for
+ * "omitted" and an empty SET is not the same statement as the original — so in
+ * both of those cases it withholds the whole line and the relationship simply
+ * is not in the output. Withholding beats shipping a dangling `#N`, but it is
+ * not free: every OTHER entity that relationship named loses the association.
+ * A visible element can therefore come out of a plain full export with one
+ * fewer pset than it went in with, and before this warning existed nothing in
+ * the result said so (adversarial review of #2668).
+ *
+ * Deliberately reports the relationship rather than the omitted target: the
+ * target's own omission is already the caller's own doing in every reason but
+ * the unreadable-ref one, whereas the lost association is the surprise.
+ */
+export declare const relationshipWithheldWarning: (expressId: number, type: string) => string;
+/**
+ * What `step-attribute-mutations.ts`'s `applySourceLineMutations` produced: the rewritten
+ * line, plus which edit kinds that rewrite actually delivered. The delivery
+ * half is {@link SourceLineDelivery} rather than three loose booleans so that
+ * the pipeline and the ledger cannot disagree about what a source line carries
+ * — an added kind has one place to be added.
+ */
+export type SourceLineMutations = SourceLineDelivery & {
+    text: string;
+};
+/**
+ * The state one `export()` call shares across its seven phases.
+ *
+ * Introduced by step 1 of #2475: `export()` is ~1267 lines and the phases a
+ * split would separate are held together by ~30 local bindings, most of which
+ * are read in three or more phases. Naming that set once — as an interface
+ * with a single construction site at the top of `export()` — is what lets a
+ * later phase extraction take one parameter instead of fifteen.
+ *
+ * Two properties of this object are load-bearing and must survive every later
+ * move:
+ *
+ * 1. **The predicates are members, not duplicated expressions.** Six of them
+ *    (`isOverlayCreated`, `isReadableSourceRef`, `isGeometryExcluded`,
+ *    `hasEmittableHostBytes`, `willBeEmitted`,
+ *    `isRefExcludedDuringClosureWalk`) exist precisely so two phases cannot
+ *    disagree about a gate — see the comments at their construction sites for
+ *    the corrupt files the earlier, per-phase versions let through (#2491,
+ *    #2414, #2398, #2637). A phase that reimplements one of these instead of
+ *    reading it off the pass reintroduces exactly that class of defect.
+ * 2. **`allowedEntityIds` and `hiddenProductIds` are mutable, and the
+ *    predicates close over the pass rather than over a snapshot.** Both are
+ *    assigned AFTER construction, in `step-collection.ts`, and the order there
+ *    matters more than it looks: `hiddenProductIds` is set first, and
+ *    `allowedEntityIds` is the value the closure walk on the next line is
+ *    computing — so `isRefExcludedDuringClosureWalk` is handed to that walk
+ *    as one of that call's own arguments — while `allowedEntityIds`, and only
+ *    it, is still null. The
+ *    output-line filter reads both later, through `isOmittedFromOutput` ->
+ *    `willBeEmitted`, so neither can be a snapshot taken before the walk ran —
+ *    that is the invariant the #2637 regression broke.
+ *
+ * Deliberately NOT on the pass, and why: `isOmittedFromOutput`,
+ * `mayNameOmittedRefs` and
+ * `overlayNewEntityCount` are eagerly-computed values whose value is only
+ * defined after work that runs past this construction site, so hoisting them
+ * would change what they compute rather than where they are named;
+ * `generatedTypeOwnedPsetIds` is read in one phase only — a local inside
+ * `step-property-sets.ts:generatePropertyAndQuantitySetEntities`, which holds
+ * both the loop that writes it and the loop that reads it (#2475).
+ */
+export interface ExportPass {
+    /** Output accumulator: every DATA-section line this export will write. */
+    readonly entities: string[];
+    /** Lines contributed by entities that have no source record. */
+    newEntityCount: number;
+    readonly schema: IfcSchemaVersion;
+    readonly sourceSchema: IfcSchemaVersion;
+    readonly converting: boolean;
+    readonly sourceHeader: IfcSourceHeader | undefined;
+    readonly schemaToken: string;
+    readonly overlayActive: boolean;
+    readonly effective: EffectiveEntityIndex;
+    readonly modifications: ModificationLedger;
+    /** Widened from the imported `InPlaceNominees` (whose sets are readonly)
+     *  because the collection passes below add to them. */
+    readonly inPlaceNominees: {
+        attribute: Set<number>;
+        georeferencing: Set<number>;
+    };
+    allowedEntityIds: Set<number> | null;
+    hiddenProductIds: ReadonlySet<number> | null;
+    readonly modifiedEntities: Set<number>;
+    readonly modifiedAttributes: Map<number, Map<string, string>>;
+    readonly newPropertySets: Array<{
+        entityId: number;
+        psets: PropertySet[];
+    }>;
+    readonly newQuantitySets: Array<{
+        entityId: number;
+        qsets: QuantitySet[];
+    }>;
+    readonly typeOwnedPsetNamesByEntity: Map<number, Set<string>>;
+    readonly typeOwnedPsetIdsByEntity: Map<number, number[]>;
+    readonly rewrittenEntityIds: Set<number>;
+    readonly rewrittenEntityLines: Map<number, string>;
+    readonly overlayTypeOwnedPsets: Map<number, IfcAttributeValue>;
+    readonly skipPropertySetIds: Set<number>;
+    readonly skipRelationshipIds: Set<number>;
+    readonly newGeorefLines: string[];
+    readonly warnings: string[];
+    readonly buildHeader: (modifications: number) => string;
+    readonly isOverlayCreated: (entityId: number) => boolean;
+    readonly isReadableSourceRef: ReturnType<typeof createSourceRefReader>;
+    readonly isGeometryExcluded: (entityId: number, recordType: string) => boolean;
+    readonly hasEmittableHostBytes: (entityId: number) => boolean;
+    readonly willBeEmitted: (entityId: number) => boolean;
+    readonly isRefExcludedDuringClosureWalk: (id: number) => boolean;
+}
+//# sourceMappingURL=step-export-types.d.ts.map

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

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

package/dist/step-export-types.js

@@ -0,0 +1,22 @@
+/* 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/. */
+/**
+ * Message for a relationship this export DROPPED rather than rewrote.
+ *
+ * `filterHiddenRefsFromRelationshipLine` removes an omitted `#N` from a
+ * SET/LIST attribute, but a single-valued attribute has no STEP spelling for
+ * "omitted" and an empty SET is not the same statement as the original — so in
+ * both of those cases it withholds the whole line and the relationship simply
+ * is not in the output. Withholding beats shipping a dangling `#N`, but it is
+ * not free: every OTHER entity that relationship named loses the association.
+ * A visible element can therefore come out of a plain full export with one
+ * fewer pset than it went in with, and before this warning existed nothing in
+ * the result said so (adversarial review of #2668).
+ *
+ * Deliberately reports the relationship rather than the omitted target: the
+ * target's own omission is already the caller's own doing in every reason but
+ * the unreadable-ref one, whereas the lost association is the surprise.
+ */
+export const relationshipWithheldWarning = (expressId, type) => `Relationship #${expressId} (${type}) was withheld from the export: it names at least one entity that has no line in this export, in a slot with no spelling for an omitted reference (a single-valued attribute, or a set whose every member is omitted). Anything else that relationship associated is no longer associated in the output.`;
+//# sourceMappingURL=step-export-types.js.map

package/dist/step-export-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-export-types.js","sourceRoot":"","sources":["../src/step-export-types.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAkK/D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CAAC,SAAiB,EAAE,IAAY,EAAU,EAAE,CACrF,iBAAiB,SAAS,KAAK,IAAI,0SAA0S,CAAC"}