@ifc-lite/export 2.8.3 → 2.8.4

package/dist/declared-property-type.d.ts

@@ -0,0 +1,107 @@
+/**
+ * The declared type a REGENERATED property is written back with
+ * (github.com/LTplus-AG/ifc-lite/issues/2482).
+ *
+ * Editing one property in a property set regenerates the WHOLE set, so every
+ * other property in it is re-serialized too. Those neighbours were written from
+ * `PropertyValueType` alone, which is a shape (string / real / integer / …) and
+ * not a type: the extractor collapses `IFCLABEL`, `IFCTEXT` and `IFCIDENTIFIER`
+ * to `String`, and every `…MEASURE` / `…RATIO` to `Real`, keeping the source
+ * token only in `Property.dataType`. Regenerating from the shape therefore
+ * rewrote `IFCTEXT` as `IFCLABEL` and `IFCLENGTHMEASURE` as `IFCREAL` — silently,
+ * permanently, and for properties the user never touched. On the numeric side
+ * the measure token IS the unit semantics, so the loss is not cosmetic.
+ *
+ * `dataType` is whatever token the source line carried, so it is NOT written
+ * back unconditionally. Four gates, in order:
+ *
+ * 1. **It must name a member of `IfcValue`.** `NominalValue` is declared as
+ *    `IfcValue`, so a token outside that SELECT is not writable there —
+ *    including the vendor and non-conformant tokens a source file can carry
+ *    (`IFCACMEWIDGETCODE('X')` parses fine and round-trips through `dataType`).
+ *    Membership is resolved from the schema registry rather than a hand-written
+ *    list, so all 106 of IFC4's `IfcValue` leaves are covered and nothing else
+ *    is. An unrecognized token falls back to the shape-derived primitive — the
+ *    old behaviour, which is lossy but valid, rather than a token no consumer
+ *    can resolve.
+ *
+ * 2. **Its EXPRESS base must agree with the effective `PropertyValueType`.**
+ *    This is what decides the OTHER question #2482 raised: what wins when the
+ *    session edited the value. `setProperty(…, valueType)` writes the effective
+ *    type; `dataType` stays the SOURCE token. When the caller names a type in a
+ *    different family (a `Boolean` written over an `IFCLENGTHMEASURE`), the
+ *    caller wins and the source token is dropped. When the two agree — which is
+ *    always the case for a property nobody edited, since the extractor derived
+ *    both from the same token — the source token is the more specific of the
+ *    two and wins.
+ *
+ * 3. **The VALUE must be representable in that base.** `serializeTypedMarker`
+ *    coerces, so without this an `IFCLENGTHMEASURE` carrying a non-numeric
+ *    value would be written as `IFCLENGTHMEASURE(NaN)`, where the shape-derived
+ *    path writes `$`. This gate also excludes the multi-valued property kinds
+ *    for free: an `IfcPropertyBoundedValue` is extracted as a measure `dataType`
+ *    over a DISPLAY STRING (`'12.5 [1 – 20]'`), and a string does not fit a REAL
+ *    base. Those kinds are regenerated as single values today — lossy, and a
+ *    separate question — but this pass must not make them worse by wrapping a
+ *    display string in a measure token.
+ *
+ * 4. **The VALUE must satisfy the member's own EXPRESS domain.** The base is not
+ *    the whole type: six `IfcValue` members are CONSTRAINED defined types whose
+ *    WHERE rule narrows the primitive they resolve to. `-1` is a fine REAL and
+ *    not a fine `IfcPositiveLengthMeasure`; `2` is a fine REAL and not a fine
+ *    `IfcNormalisedRatioMeasure`. Since `setProperty` performs no schema
+ *    validation, gate 3 alone let a session edit `IFCPOSITIVELENGTHMEASURE(5.)`
+ *    to `-1` and re-declare it `IFCPOSITIVELENGTHMEASURE(-1.)` — a line that
+ *    parses and fails validation, where the pre-#2482 shape-derived path wrote
+ *    a valid `IFCREAL(-1.)`. A gate whose purpose is to stop the exporter
+ *    writing a type it cannot justify must not itself write one.
+ *
+ *    A violating value does not fall all the way back to the shape-derived
+ *    primitive. It RELAXES to the nearest ancestor that is itself an `IfcValue`
+ *    member over the same base and carries no constraint —
+ *    `IfcPositiveLengthMeasure` → `IfcLengthMeasure` — resolved from the
+ *    registry's alias chain, not listed. `IFCLENGTHMEASURE(-1.)` is schema-valid
+ *    AND keeps the unit semantics, which is the whole thing #2482 is about;
+ *    dropping to `IFCREAL(-1.)` would re-inflict this PR's own defect on exactly
+ *    the properties whose value went out of range.
+ *
+ *    **Where the constraints come from.** `SCHEMA_REGISTRY.types` is a
+ *    `name -> underlying type` alias map (plus STRING widths); the generator
+ *    does not carry WHERE rules, so there is nothing to read. The six are
+ *    therefore written out below, which is tolerable only because the set is
+ *    CLOSED and small: they are every constrained member of `IfcValue`'s 106
+ *    defined-type leaves, and a test walks the live registry to fail if a schema
+ *    bump adds one this table has not heard of. String widths, which the
+ *    registry DOES carry (`IfcLabel: 'STRING(255)'`), are deliberately not
+ *    gated: every fallback for a string shape is itself `IFCLABEL` /
+ *    `IFCIDENTIFIER`, so rejecting an over-long label would emit the identical
+ *    over-long line, and rejecting an over-long `IfcText` (unbounded, therefore
+ *    valid) would narrow it to a bounded type and make the file worse.
+ *
+ * A `null` value is left entirely to {@link serializePropertyValue}: null is
+ * the extractor's reading of `IFCLOGICAL(.U.)` as well as of an absent value,
+ * and which of those a null means is #2472's question, not this one.
+ */
+import { PropertyValueType } from '@ifc-lite/data';
+/**
+ * Exported for the drift test only: the members {@link CONSTRAINED_MEMBERS}
+ * claims to cover, so the test holds the table against the LIVE registry rather
+ * than against a second copy of the same list.
+ */
+export declare const CONSTRAINED_IFC_VALUE_MEMBERS: readonly string[];
+/**
+ * The schema-cased `IfcValue` member a regenerated property is written back
+ * with, else `null` for the shape-derived fallback. See the module docstring for
+ * the four gates. Normally this is `dataType`'s own member; for a value outside
+ * a CONSTRAINED member's domain it is that member's nearest unconstrained
+ * ancestor (gate 4).
+ */
+export declare function declaredNominalValueType(value: unknown, type: PropertyValueType, dataType: string | undefined): string | null;
+/**
+ * Serialize a property's `NominalValue`, honouring the type the SOURCE line
+ * declared when the property carries one and it survives the gates above.
+ * Falls back to {@link serializePropertyValue}, which derives the primitive
+ * from the property's shape alone.
+ */
+export declare function serializeNominalValue(value: unknown, type: PropertyValueType, dataType: string | undefined): string;
+//# sourceMappingURL=declared-property-type.d.ts.map

package/dist/declared-property-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declared-property-type.d.ts","sourceRoot":"","sources":["../src/declared-property-type.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AA0FnD;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EAAoC,CAAC;AAqBhG;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,iBAAiB,EACvB,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,MAAM,GAAG,IAAI,CAcf;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,iBAAiB,EACvB,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,MAAM,CAIR"}

package/dist/declared-property-type.js

@@ -0,0 +1,236 @@
+/* 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/. */
+/**
+ * The declared type a REGENERATED property is written back with
+ * (github.com/LTplus-AG/ifc-lite/issues/2482).
+ *
+ * Editing one property in a property set regenerates the WHOLE set, so every
+ * other property in it is re-serialized too. Those neighbours were written from
+ * `PropertyValueType` alone, which is a shape (string / real / integer / …) and
+ * not a type: the extractor collapses `IFCLABEL`, `IFCTEXT` and `IFCIDENTIFIER`
+ * to `String`, and every `…MEASURE` / `…RATIO` to `Real`, keeping the source
+ * token only in `Property.dataType`. Regenerating from the shape therefore
+ * rewrote `IFCTEXT` as `IFCLABEL` and `IFCLENGTHMEASURE` as `IFCREAL` — silently,
+ * permanently, and for properties the user never touched. On the numeric side
+ * the measure token IS the unit semantics, so the loss is not cosmetic.
+ *
+ * `dataType` is whatever token the source line carried, so it is NOT written
+ * back unconditionally. Four gates, in order:
+ *
+ * 1. **It must name a member of `IfcValue`.** `NominalValue` is declared as
+ *    `IfcValue`, so a token outside that SELECT is not writable there —
+ *    including the vendor and non-conformant tokens a source file can carry
+ *    (`IFCACMEWIDGETCODE('X')` parses fine and round-trips through `dataType`).
+ *    Membership is resolved from the schema registry rather than a hand-written
+ *    list, so all 106 of IFC4's `IfcValue` leaves are covered and nothing else
+ *    is. An unrecognized token falls back to the shape-derived primitive — the
+ *    old behaviour, which is lossy but valid, rather than a token no consumer
+ *    can resolve.
+ *
+ * 2. **Its EXPRESS base must agree with the effective `PropertyValueType`.**
+ *    This is what decides the OTHER question #2482 raised: what wins when the
+ *    session edited the value. `setProperty(…, valueType)` writes the effective
+ *    type; `dataType` stays the SOURCE token. When the caller names a type in a
+ *    different family (a `Boolean` written over an `IFCLENGTHMEASURE`), the
+ *    caller wins and the source token is dropped. When the two agree — which is
+ *    always the case for a property nobody edited, since the extractor derived
+ *    both from the same token — the source token is the more specific of the
+ *    two and wins.
+ *
+ * 3. **The VALUE must be representable in that base.** `serializeTypedMarker`
+ *    coerces, so without this an `IFCLENGTHMEASURE` carrying a non-numeric
+ *    value would be written as `IFCLENGTHMEASURE(NaN)`, where the shape-derived
+ *    path writes `$`. This gate also excludes the multi-valued property kinds
+ *    for free: an `IfcPropertyBoundedValue` is extracted as a measure `dataType`
+ *    over a DISPLAY STRING (`'12.5 [1 – 20]'`), and a string does not fit a REAL
+ *    base. Those kinds are regenerated as single values today — lossy, and a
+ *    separate question — but this pass must not make them worse by wrapping a
+ *    display string in a measure token.
+ *
+ * 4. **The VALUE must satisfy the member's own EXPRESS domain.** The base is not
+ *    the whole type: six `IfcValue` members are CONSTRAINED defined types whose
+ *    WHERE rule narrows the primitive they resolve to. `-1` is a fine REAL and
+ *    not a fine `IfcPositiveLengthMeasure`; `2` is a fine REAL and not a fine
+ *    `IfcNormalisedRatioMeasure`. Since `setProperty` performs no schema
+ *    validation, gate 3 alone let a session edit `IFCPOSITIVELENGTHMEASURE(5.)`
+ *    to `-1` and re-declare it `IFCPOSITIVELENGTHMEASURE(-1.)` — a line that
+ *    parses and fails validation, where the pre-#2482 shape-derived path wrote
+ *    a valid `IFCREAL(-1.)`. A gate whose purpose is to stop the exporter
+ *    writing a type it cannot justify must not itself write one.
+ *
+ *    A violating value does not fall all the way back to the shape-derived
+ *    primitive. It RELAXES to the nearest ancestor that is itself an `IfcValue`
+ *    member over the same base and carries no constraint —
+ *    `IfcPositiveLengthMeasure` → `IfcLengthMeasure` — resolved from the
+ *    registry's alias chain, not listed. `IFCLENGTHMEASURE(-1.)` is schema-valid
+ *    AND keeps the unit semantics, which is the whole thing #2482 is about;
+ *    dropping to `IFCREAL(-1.)` would re-inflict this PR's own defect on exactly
+ *    the properties whose value went out of range.
+ *
+ *    **Where the constraints come from.** `SCHEMA_REGISTRY.types` is a
+ *    `name -> underlying type` alias map (plus STRING widths); the generator
+ *    does not carry WHERE rules, so there is nothing to read. The six are
+ *    therefore written out below, which is tolerable only because the set is
+ *    CLOSED and small: they are every constrained member of `IfcValue`'s 106
+ *    defined-type leaves, and a test walks the live registry to fail if a schema
+ *    bump adds one this table has not heard of. String widths, which the
+ *    registry DOES carry (`IfcLabel: 'STRING(255)'`), are deliberately not
+ *    gated: every fallback for a string shape is itself `IFCLABEL` /
+ *    `IFCIDENTIFIER`, so rejecting an over-long label would emit the identical
+ *    over-long line, and rejecting an over-long `IfcText` (unbounded, therefore
+ *    valid) would narrow it to a bounded type and make the file worse.
+ *
+ * A `null` value is left entirely to {@link serializePropertyValue}: null is
+ * the extractor's reading of `IFCLOGICAL(.U.)` as well as of an absent value,
+ * and which of those a null means is #2472's question, not this one.
+ */
+import { PropertyValueType } from '@ifc-lite/data';
+import { SCHEMA_REGISTRY } from '@ifc-lite/parser';
+import { getSelectDefinedLeaves } from './select-qualification.js';
+import { serializePropertyValue, serializeTypedMarker } from './step-serialization.js';
+/** The SELECT `IfcPropertySingleValue.NominalValue` is declared as. */
+const NOMINAL_VALUE_SELECT = 'IfcValue';
+/** UPPERCASE STEP token → `[schema-cased type name, EXPRESS base]`. */
+let nominalValueLeaves = null;
+function lookupNominalValueLeaf(token) {
+    if (!nominalValueLeaves) {
+        nominalValueLeaves = new Map();
+        for (const [type, base] of getSelectDefinedLeaves(NOMINAL_VALUE_SELECT)) {
+            nominalValueLeaves.set(type.toUpperCase(), [type, base]);
+        }
+    }
+    return nominalValueLeaves.get(token);
+}
+/**
+ * The EXPRESS bases a property of `type` may be re-declared as. `null` for the
+ * kinds that are not a single scalar `IfcValue` at all — an `Enum` is a bare
+ * enumeration token, a `Reference` is a different property CLASS, and a `List`
+ * is an aggregate.
+ */
+function acceptedBases(type) {
+    switch (type) {
+        case PropertyValueType.String:
+        case PropertyValueType.Label:
+        case PropertyValueType.Text:
+        case PropertyValueType.Identifier:
+            return ['STRING'];
+        case PropertyValueType.Real:
+            // NUMBER as well as REAL: several IfcValue members (IfcCountMeasure,
+            // IfcNumericMeasure) bottom out in NUMBER and are read back as numbers.
+            return ['REAL', 'NUMBER'];
+        case PropertyValueType.Integer:
+            return ['INTEGER', 'NUMBER'];
+        case PropertyValueType.Boolean:
+            return ['BOOLEAN'];
+        case PropertyValueType.Logical:
+            return ['LOGICAL'];
+        default:
+            return null;
+    }
+}
+/** Whether `value` can be written into `base` without being coerced into
+ *  something the shape-derived path would have refused to write at all. */
+function valueFitsBase(value, base) {
+    switch (base) {
+        case 'STRING':
+            return typeof value === 'string';
+        case 'REAL':
+        case 'NUMBER':
+            return typeof value === 'number' && Number.isFinite(value);
+        case 'INTEGER':
+            return typeof value === 'number' && Number.isInteger(value);
+        case 'BOOLEAN':
+        case 'LOGICAL':
+            // Not a truthiness test: `serializeTypedMarker` reads `'.F.'` and
+            // `'maybe'` alike, and the shape-derived path answers `IFCLOGICAL(.U.)`
+            // for anything that is not a real boolean. Leave those to it.
+            return typeof value === 'boolean';
+        default:
+            // BINARY and anything the registry resolves to something else: the
+            // extractor has no path that produces a faithful JS value for these.
+            return false;
+    }
+}
+/**
+ * The EXPRESS WHERE rule of every CONSTRAINED `IfcValue` member, keyed by the
+ * registry's casing. Hand-written because `SCHEMA_REGISTRY` carries alias chains
+ * and STRING widths but no WHERE rules — see gate 4 in the module docstring for
+ * why a closed table is acceptable here and what keeps it honest.
+ *
+ * IFC4 ADD2 TC1, IfcMeasureResource.
+ */
+const CONSTRAINED_MEMBERS = new Map([
+    ['IfcPositiveLengthMeasure', (v) => v > 0],
+    ['IfcNonNegativeLengthMeasure', (v) => v >= 0],
+    ['IfcPositiveRatioMeasure', (v) => v > 0],
+    ['IfcNormalisedRatioMeasure', (v) => v >= 0 && v <= 1],
+    ['IfcPositivePlaneAngleMeasure', (v) => v > 0],
+    ['IfcPositiveInteger', (v) => v > 0],
+]);
+/**
+ * Exported for the drift test only: the members {@link CONSTRAINED_MEMBERS}
+ * claims to cover, so the test holds the table against the LIVE registry rather
+ * than against a second copy of the same list.
+ */
+export const CONSTRAINED_IFC_VALUE_MEMBERS = [...CONSTRAINED_MEMBERS.keys()];
+/**
+ * The nearest ancestor of `name` along the registry's alias chain that is itself
+ * an `IfcValue` member over the SAME EXPRESS base and carries no constraint —
+ * `IfcPositiveLengthMeasure` → `IfcLengthMeasure`, `IfcNormalisedRatioMeasure` →
+ * `IfcRatioMeasure`. `null` when the chain leaves `IfcValue` before reaching one,
+ * in which case the caller falls back to the shape-derived primitive.
+ */
+function relaxedMember(name, base) {
+    const seen = new Set([name]);
+    let cursor = SCHEMA_REGISTRY.types[name];
+    while (cursor && !seen.has(cursor)) {
+        seen.add(cursor);
+        const leaf = lookupNominalValueLeaf(cursor.toUpperCase());
+        if (leaf && leaf[1] === base && !CONSTRAINED_MEMBERS.has(leaf[0]))
+            return leaf[0];
+        cursor = SCHEMA_REGISTRY.types[cursor];
+    }
+    return null;
+}
+/**
+ * The schema-cased `IfcValue` member a regenerated property is written back
+ * with, else `null` for the shape-derived fallback. See the module docstring for
+ * the four gates. Normally this is `dataType`'s own member; for a value outside
+ * a CONSTRAINED member's domain it is that member's nearest unconstrained
+ * ancestor (gate 4).
+ */
+export function declaredNominalValueType(value, type, dataType) {
+    if (value === null || value === undefined)
+        return null;
+    if (!dataType)
+        return null;
+    const leaf = lookupNominalValueLeaf(dataType.trim().toUpperCase());
+    if (!leaf)
+        return null;
+    const [name, base] = leaf;
+    const accepted = acceptedBases(type);
+    if (!accepted || !accepted.includes(base))
+        return null;
+    if (!valueFitsBase(value, base))
+        return null;
+    const constraint = CONSTRAINED_MEMBERS.get(name);
+    // `valueFitsBase` has already established a finite number for every base a
+    // constrained member resolves to (REAL / NUMBER / INTEGER) — not a coercion.
+    if (constraint && !constraint(value))
+        return relaxedMember(name, base);
+    return name;
+}
+/**
+ * Serialize a property's `NominalValue`, honouring the type the SOURCE line
+ * declared when the property carries one and it survives the gates above.
+ * Falls back to {@link serializePropertyValue}, which derives the primitive
+ * from the property's shape alone.
+ */
+export function serializeNominalValue(value, type, dataType) {
+    const declared = declaredNominalValueType(value, type, dataType);
+    if (declared === null)
+        return serializePropertyValue(value, type);
+    return serializeTypedMarker(declared, value);
+}
+//# sourceMappingURL=declared-property-type.js.map

package/dist/declared-property-type.js.map

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

package/dist/delta-modification-ledger.d.ts

@@ -0,0 +1,148 @@
+/**
+ * The bookkeeping behind the STEP header's `"Re-exported by ifc-lite, N
+ * modification(s)"` claim, behind `stats.modifiedEntityCount`, and behind the
+ * warning that says what a delta could not carry.
+ *
+ * A full export counts at the INTENT sites for the kinds an entity's own line
+ * carries, and that is sound there: the source-iteration pass writes every
+ * modified host's own (rewritten) line, so intending to modify an emittable host
+ * and emitting the modification are the same event. Property and quantity sets
+ * are the exception — see {@link EFFECT_SETTLED_KINDS}.
+ *
+ * `deltaOnly` breaks that identity. It skips the source-iteration pass
+ * wholesale, so the only lines a source-backed host can contribute to a delta
+ * are the ones the property-set generator, the quantity-set generator and the
+ * type-object `HasPropertySets` rewrite produce for it. A modification with no
+ * such line is simply not in the file:
+ *
+ *   - an in-place attribute edit (`setAttribute`) is applied by rewriting the
+ *     entity's own line inside the skipped pass — the report in #2462;
+ *   - a georeferencing edit to an EXISTING `IfcProjectedCRS` /
+ *     `IfcMapConversion` is queued as exactly such attribute edits;
+ *   - a property/quantity-set DELETION produces no replacement content, so
+ *     there is nothing for the delta to carry either. (A full export applies a
+ *     rel-defined removal by OMITTING the pset and its relationship, not by
+ *     rewriting the host's line; either way a delta has no line to carry.)
+ *
+ * All three used to count. The header then claimed a modification the DATA
+ * section did not contain — for an attribute-only session, `"1 modification"`
+ * over zero entity lines. So a delta's count is settled at the end, from what
+ * was actually emitted.
+ *
+ * ## Why the ledger is keyed on (entity, kind) and not on the entity
+ *
+ * One host can carry edits of several kinds, and the passes that survive
+ * `deltaOnly` deliver some kinds and not others. Rename a wall AND add a
+ * property set to it: the pset generator writes replacement lines, the rename
+ * has nowhere to go. Keyed per ENTITY, that pset emission marked the whole host
+ * delivered, so the ledger reported one delivered modification and said nothing
+ * about the rename — a caller could apply the delta believing the rename was in
+ * it. That is the same silent misreport this module exists to remove, one level
+ * down, so delivery is tracked per EDIT KIND:
+ *
+ *   - {@link ModificationLedger.nominate} takes the kind that was edited;
+ *   - {@link ModificationLedger.recordEmitted} takes the kind the emitted
+ *     content genuinely delivers — generated pset lines deliver `property-set`
+ *     and nothing else; a rewritten source line delivers the in-place kinds
+ *     ({@link recordSourceLineDelivery});
+ *   - {@link ModificationLedger.settle} counts an ENTITY as modified when ANY
+ *     of its kinds was delivered — `modifiedEntityCount` counts entities and
+ *     the header claim is unchanged by this keying — but warns for EVERY
+ *     nominated-and-undelivered (entity, kind) pair.
+ *
+ * The warning names the kind, deliberately. "entity #8's edits were not
+ * carried" is subtly false when only the rename was dropped and the pset landed,
+ * and a warning a reader learns to distrust is worse than no warning. One
+ * warning per kind also lets each one say WHY that kind cannot survive a delta,
+ * which is the actionable part.
+ *
+ * ## What is still not covered
+ *
+ * Retypes and positional edits are nominated only by the source-iteration pass,
+ * which `deltaOnly` skips — so a delta still drops them without naming them.
+ * They are not lost in every case: the type-object `HasPropertySets` rewrite
+ * runs the whole mutation pipeline, so a retype or positional edit to such a
+ * host does reach the delta and IS recorded as delivered here. It is the
+ * nomination that a delta cannot see, not the delivery.
+ *
+ * That leaves one narrow spot where the count under-claims rather than
+ * over-claims: a type object whose repoint FAILED, whose only other edit is a
+ * retype or a positional edit, emits its fallback line while nothing nominated
+ * the kind that line carries. Every other delta drops those two kinds without
+ * emitting anything at all, where claiming nothing is exactly right.
+ *
+ * NOTE this is all about what a DELTA contains, not about what may reference a
+ * source host. `willBeEmitted` / `hasEmittableHostBytes` deliberately answer
+ * "yes" for a source record under `deltaOnly` — a generated
+ * `IFCRELDEFINESBYPROPERTIES` may name a host whose line lives in the file
+ * being patched. That carve-out is right, and orthogonal to this count.
+ */
+/**
+ * What was edited about a host. Every value here is a distinction the exporter
+ * can actually make at its own nomination sites — no finer, because a kind the
+ * emit passes cannot tell apart could never be settled.
+ */
+export type ModificationKind = 'attribute' | 'georeferencing' | 'property-set' | 'quantity-set' | 'retype' | 'positional';
+export interface ModificationLedger {
+    /** This host has an edit of `kind` that would make it count as modified. */
+    nominate(entityId: number, kind: ModificationKind): void;
+    /** A pass wrote content that genuinely delivers this host's `kind` edit. */
+    recordEmitted(entityId: number, kind: ModificationKind): void;
+    /**
+     * A pass left content OUT of the file because of this host's `kind` edit —
+     * the way a full export applies a set deletion, and the other half of "did
+     * this edit change the file".
+     *
+     * Deliberately not `recordEmitted`: under `deltaOnly` there is no source
+     * content to leave out, so withholding delivers nothing there and the
+     * existing "a removal produces no replacement content for a delta to carry"
+     * warning stays exactly right.
+     */
+    recordWithheld(entityId: number, kind: ModificationKind): void;
+    /**
+     * This host's `kind` edit did NOT land, and a more specific warning has
+     * already said so. Keeps the pair out of the count (it really is undelivered)
+     * and out of the generic warning, which would otherwise blame the delta
+     * format for a drop that has nothing to do with it.
+     */
+    acknowledgeUndelivered(entityId: number, kind: ModificationKind): void;
+    /** Final count, plus a warning per kind the file left undelivered. */
+    settle(): {
+        modifiedEntityCount: number;
+        warnings: string[];
+    };
+}
+export declare function createModificationLedger(deltaOnly: boolean): ModificationLedger;
+/**
+ * Which kinds a rewritten source line actually DELIVERED.
+ *
+ * Every flag is an effect, measured by comparing the line across the operation
+ * that claims it — never "an edit of this kind was requested". A retype to the
+ * class the entity already is, a positional write of the token already in the
+ * slot, and a named attribute the class has no slot for all leave the text
+ * exactly as it was, and a line that did not change delivered nothing.
+ */
+export interface SourceLineDelivery {
+    attributed: boolean;
+    retyped: boolean;
+    positional: boolean;
+}
+/**
+ * Record what a rewritten SOURCE LINE delivered for `entityId`.
+ *
+ * A source line carries every IN-PLACE edit and nothing else: property and
+ * quantity sets live in separate records, and a type object's type-owned pset
+ * edit is delivered by the `HasPropertySets` REPOINT, not by the line rewrite
+ * that carries it — which is why the repoint site records `property-set`
+ * itself and the fallback site (where the repoint failed) does not.
+ *
+ * Only the kinds the mutation pipeline REPORTS having applied. A named
+ * attribute whose name resolves to no slot in the record's class is discarded
+ * by `applyAttributeMutations`, and calling that delivered would re-create the
+ * exact misreport this ledger exists to remove. `attributed` covers BOTH kinds
+ * a named-attribute rewrite can deliver: georeferencing edits to an existing
+ * `IfcProjectedCRS` / `IfcMapConversion` are queued into the very same
+ * `modifiedAttributes` map and applied by the very same call.
+ */
+export declare function recordSourceLineDelivery(ledger: ModificationLedger, entityId: number, mutated: SourceLineDelivery): void;
+//# sourceMappingURL=delta-modification-ledger.d.ts.map

package/dist/delta-modification-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delta-modification-ledger.d.ts","sourceRoot":"","sources":["../src/delta-modification-ledger.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8EG;AAEH;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GACxB,WAAW,GACX,gBAAgB,GAChB,cAAc,GACd,cAAc,GACd,QAAQ,GACR,YAAY,CAAC;AAqFjB,MAAM,WAAW,kBAAkB;IACjC,4EAA4E;IAC5E,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACzD,4EAA4E;IAC5E,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC9D;;;;;;;;;OASG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC/D;;;;;OAKG;IACH,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACvE,sEAAsE;IACtE,MAAM,IAAI;QAAE,mBAAmB,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAC/D;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,OAAO,GAAG,kBAAkB,CA0E/E;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,kBAAkB,GAC1B,IAAI,CAON"}