@ifc-lite/export 3.0.0 → 3.0.1

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

@@ -0,0 +1,158 @@
+/**
+ * Read-side state and helpers for the property-set and quantity-set phases
+ * of `StepExporter.export()` (#2475 steps 2b and 2c), split out of
+ * `step-property-sets.ts` (#3184): the {@link PropertySetContext} the
+ * generation/collection phases run against, the per-entity STEP-text
+ * readers those phases share (`entityLineText` and everything parsed from
+ * it), and the owner-history resolution the generators call for every
+ * record they emit.
+ *
+ * `isReadableSourceRef` on {@link PropertySetContext} is the exporter's OWN
+ * reader rather than the pass's: these readers are also reached from
+ * `buildRelDefinesByPropertiesIndex` (`step-property-set-index.ts`) and from
+ * `retainSharedAtoms`, neither of which has a pass in hand.
+ */
+import type { IfcDataStore, EntityExtractor } from '@ifc-lite/parser';
+import type { MutablePropertyView } from '@ifc-lite/mutations';
+import { type RandomSource } from '@ifc-lite/encoding';
+import { createSourceRefReader } from './source-ref-bounds.js';
+import { type EffectiveEntityIndex } from './effective-index.js';
+import type { IfcSchemaVersion } from './schema-converter.js';
+import type { SourceLineMutations } from './step-exporter.js';
+/**
+ * The exporter state these phases cannot read off the {@link ExportPass}.
+ *
+ * `isReadableSourceRef` is the exporter's OWN reader rather than the pass's:
+ * the byte readers below are also reached from
+ * {@link buildRelDefinesByPropertiesIndex} and from `retainSharedAtoms`,
+ * neither of which has a pass in hand. Both readers are built by
+ * `createSourceRefReader` over the same `dataStore.source`.
+ */
+export interface PropertySetContext {
+    readonly dataStore: IfcDataStore;
+    readonly entityExtractor: EntityExtractor | null;
+    readonly mutationView: MutablePropertyView | null;
+    readonly isReadableSourceRef: ReturnType<typeof createSourceRefReader>;
+    /** `() => this.nextExpressId++` on the exporter. */
+    readonly allocateExpressId: () => number;
+    readonly ownerHistory: OwnerHistoryCache;
+    /** `step-attribute-mutations.ts`'s `applySourceLineMutations`: the ONE
+     *  pipeline the source-iteration pass and the type-object rewrite share, so
+     *  it belongs to neither phase and is injected. */
+    readonly applySourceLineMutations: (expressId: number, entityText: string, recordType: string, attributeMutations: Map<string, string> | undefined, sourceSchema: IfcSchemaVersion, overlayActive: boolean, onRejected?: (attrName: string, value: string) => void) => SourceLineMutations;
+}
+/**
+ * The two owner-history memos the generators share, in one object so the
+ * exporter can hand them over by reference. Both are per-EXPORT rather than
+ * per-exporter; `StepExporter.export()` owns the reset and explains why.
+ */
+export interface OwnerHistoryCache {
+    /** Lazily-resolved fallback `#id` of an IfcOwnerHistory that survives the
+     *  current export closure (or `$` when the file has none). */
+    fallbackRef: string | undefined;
+    /** Per-host cache of an element's own OwnerHistory ref (`#id` or null). */
+    readonly byEntity: Map<number, string | null>;
+}
+/**
+ * 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 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.
+ */
+export declare function entityLineText(ctx: PropertySetContext, entityId: number): string | null;
+/**
+ * Get the name of a property set by parsing the entity
+ */
+export declare function getPropertySetName(ctx: PropertySetContext, psetId: number): string | null;
+/**
+ * Get the name of an element quantity set by parsing the entity
+ */
+export declare function getElementQuantityName(ctx: PropertySetContext, entityId: number): string | null;
+/**
+ * Get IDs of properties in a property set
+ */
+export declare function getPropertyIdsInSet(ctx: PropertySetContext, psetId: number): number[];
+/**
+ * The full HasPropertySets id list of a type object, from whichever authority
+ * owns the record.
+ *
+ * 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).
+ */
+export declare function getTypeOwnedHasPropertySetIds(ctx: PropertySetContext, entityId: number, effective: EffectiveEntityIndex): number[];
+/**
+ * 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.
+ */
+export declare function resolveOwnerHistoryRef(ctx: PropertySetContext, hostEntityId: number, willBeEmitted: (id: number) => boolean): string;
+/**
+ * Generate a new IFC GlobalId (22 character base64). `random` is the
+ * export's optional seeded source (`StepExportOptions.guidRandom`);
+ * undefined keeps the default random path.
+ */
+export declare function generateGlobalId(random?: RandomSource): string;
+/**
+ * Find a unit entity ID by name (simplified - returns null for now)
+ */
+export declare function findUnitId(ctx: PropertySetContext, unitName: string, effective: EffectiveEntityIndex): number | null;
+//# sourceMappingURL=step-property-set-readers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"step-property-set-readers.d.ts","sourceRoot":"","sources":["../src/step-property-set-readers.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAqB,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACzF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,EAAE,qBAAqB,EAAe,MAAM,wBAAwB,CAAC;AAE5E,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAErF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAE9D;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACjD,QAAQ,CAAC,YAAY,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAClD,QAAQ,CAAC,mBAAmB,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;IACvE,oDAAoD;IACpD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,MAAM,CAAC;IACzC,QAAQ,CAAC,YAAY,EAAE,iBAAiB,CAAC;IACzC;;uDAEmD;IACnD,QAAQ,CAAC,wBAAwB,EAAE,CACjC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACnD,YAAY,EAAE,gBAAgB,EAC9B,aAAa,EAAE,OAAO,EACtB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,KACnD,mBAAmB,CAAC;CAC1B;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC;kEAC8D;IAC9D,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;CAC/C;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAQH,wBAAgB,cAAc,CAAC,GAAG,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQvF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQzF;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQ/F;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAerF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,oBAAoB,GAAG,MAAM,EAAE,CAclI;AAsED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,GAAG,MAAM,CAepI;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,MAAM,CAE9D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,oBAAoB,GAAG,MAAM,GAAG,IAAI,CAEpH"}

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

@@ -0,0 +1,251 @@
+/* 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 { generateIfcGuid } from '@ifc-lite/encoding';
+import { decodeRange } from './source-ref-bounds.js';
+import { findLengthUnitReference, normalizeMapUnitName } from './step-map-unit.js';
+import { authoredEntityRefs } from './effective-index.js';
+import { HAS_PROPERTY_SETS_SLOT } from './type-owned-psets.js';
+/** `OwnerHistory` is slot 1 on every `IfcRoot` subtype, all schemas. */
+const OWNER_HISTORY_SLOT = 1;
+/**
+ * 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 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 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
+ */
+export 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.
+ *
+ * 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).
+ */
+export 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.
+ *
+ * **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.
+ */
+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.
+ */
+export 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.
+ */
+export function generateGlobalId(random) {
+    return generateIfcGuid(random);
+}
+/**
+ * Find a unit entity ID by name (simplified - returns null for now)
+ */
+export function findUnitId(ctx, unitName, effective) {
+    return findLengthUnitReference(normalizeMapUnitName(unitName), effective, { dataStore: ctx.dataStore, entityExtractor: ctx.entityExtractor });
+}
+//# sourceMappingURL=step-property-set-readers.js.map

package/dist/step-property-set-readers.js.map

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

package/dist/step-property-sets.d.ts

@@ -1,189 +1,5 @@
-/**
- * The property-set and quantity-set phases of `StepExporter.export()` (#2475
- * steps 2b and 2c), and the type-object `HasPropertySets` rewrite that sits
- * between them.
- *
- * ## Why one module, and why the rewrite is not its own function
- *
- *  - `generatedTypeOwnedPsetIds` is written by the property-set generation loop
- *    and read by the rewrite loop. `ExportPass` documents it as the binding
- *    that "is read in one phase only", and it stays that way here precisely
- *    because both loops live inside
- *    {@link generatePropertyAndQuantitySetEntities}: it is a plain local, not a
- *    field on the pass and not an argument threaded between two functions.
- *  - {@link getTypeOwnedHasPropertySetIds} is the rewrite's own helper, but its
- *    only call site is the property-set COLLECTION loop, which fills
- *    `pass.typeOwnedPsetIdsByEntity` from its result.
- *  - `getPropertySetName` is called from the collection loop twice and from the
- *    rewrite once.
- *  - The three generation loops run pset → rewrite → qset, and `export()`
- *    flushes `pass.rewrittenEntityLines` (the rewrite's output) only after the
- *    qset loop. That order is load-bearing and is kept exactly as it was.
- *
- * ## What stayed behind, and why these two exports exist
- *
- * `retainSharedAtoms` belongs to neither phase and runs between them, so it
- * stays on the exporter — which is why {@link getPropertyIdsInSet} is exported
- * rather than module-private, the same shape step 2a used for
- * `findLengthUnitReference`. {@link buildRelDefinesByPropertiesIndex} is
- * exported for the mirror-image reason: the collection loops consume its
- * `byEntity` half, but `export()` reads `relatedByRel` for the deleted-host
- * relationship sweep, which is neither phase's work.
- * `step-attribute-mutations.ts`'s `applySourceLineMutations` (moved off
- * `StepExporter` by #2475's "remaining private helpers" step) is shared with
- * the source-iteration pass, so it is injected on the context rather than
- * imported directly.
- *
- * ## The state these phases cannot read off the pass
- *
- * {@link PropertySetContext}, following `step-georeferencing.ts:GeorefContext`.
- * `allocateExpressId` is the exporter's own `nextExpressId++`: all six
- * allocation sites in an export live in the two generators below, and the
- * counter is shared with the georeferencing phase, so it is injected as a
- * callback rather than hoisted onto the pass. The owner-history memos are
- * injected BY REFERENCE and stay owned by the exporter, because their reset is
- * an `export()`-level statement whose comment explains why they are per-export;
- * storing them here would move that reset out of the method that documents it.
- *
- * Every helper below takes `ctx` FIRST; the two phase entry points take it
- * LAST, as `applyGeoreferencingMutations` does. The split is not aesthetic —
- * the two generators end in optional parameters, which a trailing `ctx` cannot
- * follow.
- */
-import type { IfcDataStore } from '@ifc-lite/parser';
-import { EntityExtractor } from '@ifc-lite/parser';
-import type { MutablePropertyView } from '@ifc-lite/mutations';
-import { createSourceRefReader } from './source-ref-bounds.js';
-import type { IfcSchemaVersion } from './schema-converter.js';
-import type { ExportPass, SourceLineMutations, StepExportOptions } from './step-exporter.js';
-/**
- * The two owner-history memos the generators share, in one object so the
- * exporter can hand them over by reference. Both are per-EXPORT rather than
- * per-exporter; `StepExporter.export()` owns the reset and explains why.
- */
-export interface OwnerHistoryCache {
-    /** Lazily-resolved fallback `#id` of an IfcOwnerHistory that survives the
-     *  current export closure (or `$` when the file has none). */
-    fallbackRef: string | undefined;
-    /** Per-host cache of an element's own OwnerHistory ref (`#id` or null). */
-    readonly byEntity: Map<number, string | null>;
-}
-/**
- * The exporter state these phases cannot read off the {@link ExportPass}.
- *
- * `isReadableSourceRef` is the exporter's OWN reader rather than the pass's:
- * the byte readers below are also reached from
- * {@link buildRelDefinesByPropertiesIndex} and from `retainSharedAtoms`,
- * neither of which has a pass in hand. Both readers are built by
- * `createSourceRefReader` over the same `dataStore.source`.
- */
-export interface PropertySetContext {
-    readonly dataStore: IfcDataStore;
-    readonly entityExtractor: EntityExtractor | null;
-    readonly mutationView: MutablePropertyView | null;
-    readonly isReadableSourceRef: ReturnType<typeof createSourceRefReader>;
-    /** `() => this.nextExpressId++` on the exporter. */
-    readonly allocateExpressId: () => number;
-    readonly ownerHistory: OwnerHistoryCache;
-    /** `step-attribute-mutations.ts`'s `applySourceLineMutations`: the ONE
-     *  pipeline the source-iteration pass and the type-object rewrite share, so
-     *  it belongs to neither phase and is injected. */
-    readonly applySourceLineMutations: (expressId: number, entityText: string, recordType: string, attributeMutations: Map<string, string> | undefined, sourceSchema: IfcSchemaVersion, overlayActive: boolean, onRejected?: (attrName: string, value: string) => void) => SourceLineMutations;
-}
-/** The mutation groupings `export()` builds before the collection phase runs. */
-export interface PropertyMutationGroups {
-    readonly entityPropMutations: Map<number, Set<string>>;
-    readonly entityQuantMutations: Map<number, Set<string>>;
-    readonly relDefinesByEntity: Map<number, Array<{
-        relId: number;
-        psetId: number;
-    }>>;
-}
-/**
- * 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 declare function buildRelDefinesByPropertiesIndex(ctx: PropertySetContext): {
-    byEntity: Map<number, Array<{
-        relId: number;
-        psetId: number;
-    }>>;
-    relatedByRel: Map<number, number[]>;
-};
-/**
- * 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 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.
- */
-export declare function entityLineText(ctx: PropertySetContext, entityId: number): string | null;
-/**
- * Get the name of a property set by parsing the entity
- */
-export declare function getPropertySetName(ctx: PropertySetContext, psetId: number): string | null;
-/**
- * Get IDs of properties in a property set
- */
-export declare function getPropertyIdsInSet(ctx: PropertySetContext, psetId: number): number[];
-/**
- * Collect what the overlay's property-set and quantity-set edits mean for this
- * export: which sets to regenerate (`pass.newPropertySets` /
- * `pass.newQuantitySets`), which source records to withhold
- * (`pass.skipPropertySetIds` / `pass.skipRelationshipIds`), and which type
- * objects need their `HasPropertySets` resolved later
- * (`pass.typeOwnedPsetNamesByEntity`, `…IdsByEntity`, `pass.rewrittenEntityIds`).
- *
- * The caller owns the `mutationView && options.applyMutations !== false` gate;
- * reaching here means overlay edits were both present and enabled.
- */
-export declare function collectPropertyAndQuantitySetMutations(pass: ExportPass, options: StepExportOptions, groups: PropertyMutationGroups, ctx: PropertySetContext): void;
+import { type PropertySetContext } from './step-property-set-readers.js';
+import type { ExportPass, StepExportOptions } from './step-exporter.js';
 /**
  * Write the generated property-set and quantity-set records into
  * `pass.entities`, and point every affected type object's `HasPropertySets` at

package/dist/step-property-sets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step-property-sets.d.ts","sourceRoot":"","sources":["../src/step-property-sets.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"step-property-sets.d.ts","sourceRoot":"","sources":["../src/step-property-sets.ts"],"names":[],"mappings":"AAkCA,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,gCAAgC,CAAC;AAE7F,OAAO,KAAK,EAAE,UAAU,EAAuB,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAG7F;;;;;;;;;GASG;AACH,wBAAgB,sCAAsC,CACpD,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,iBAAiB,EAC1B,GAAG,EAAE,kBAAkB,GACtB,IAAI,CAgLN"}