@ifc-lite/cli 0.28.0 → 0.29.1

package/dist/commands/step-args.js

@@ -0,0 +1,333 @@
+/* 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/. */
+/**
+ * Reading a STEP record's top-level argument list out of its text, for a
+ * caller that then edits one slot BY INDEX.
+ *
+ * The failure this exists to prevent is silent. A scanner that loses track of
+ * quote state or paren depth still produces parts; they are just not the
+ * record's arguments any more, because the commas it swallowed took every
+ * following slot with them. The write lands on whatever the mis-scan
+ * accumulated and the caller reports a success that did not happen
+ * (LTplus-AG/ifc-lite#2470, #4125 for the `mutate` instance). So this returns
+ * null rather than parts it does not believe in.
+ *
+ * The mis-scan nothing structural notices is an undoubled apostrophe, what an
+ * authoring tool emits when it forgets to double one. The scan closes the
+ * string at it and reopens on the next quote, so the text between the two is
+ * read inside-out and every comma in it is swallowed. TWO of them leave quote
+ * parity EVEN and paren depth at ZERO, so the scan ends clean on text that
+ * split wrong: `'guid',$,'John's wall',$,$,$,$,'A's',.NOTDEFINED.` is nine
+ * attributes read as four, and writing slot 2 deletes attributes 3 to 7.
+ *
+ * What always shows is a token ending where a token cannot end: the phantom
+ * terminator leaves the rest of the content where a separator belongs
+ * (`'John's wall'` closes after `John`, leaving a bare `s`). So this validates
+ * the list as a grammar rather than counting characters. An argument is ONE
+ * token, after a token only whitespace and then `,` or `)` may follow, and that
+ * (In the STEP examples below, `*\/` is a JavaScript escape so the example does not
+ * terminate this comment block. The backslash is not in the STEP text, and STEP
+ * gives `\` its own meaning, so strip it before copying an example into a test.)
+ *
+ * holds AT EVERY DEPTH. Applied to the top level alone it misses a phantom that
+ * swallows a `)`, a `(` and the comma between them, which leaves the depth
+ * balanced and each surviving part passing a token check on its own:
+ * `IFCLABEL('a's'),$,IFCLABEL('b's'),$` is four attributes read as two. Any
+ * two top-level slots that each hold a string inside parens can do it, and real
+ * entities have that shape (`IfcPerson`'s MiddleNames / PrefixTitles,
+ * `IfcPropertyTableValue`'s DefiningValues / DefinedValues).
+ *
+ * What the rule cannot see is a corruption whose bytes are themselves a valid
+ * argument list: a stray apostrophe at the END of a string's content emits a
+ * doubled quote by accident, so `''','''` is two arguments to its author and
+ * one to anyone reading the text. A generated sweep accepted 814 of 80,035 corruptions
+ * with a split other than the author's, down from 1,066 before the rule reached into
+ * lists, and every survivor it looked at had that shape; separating them needs the
+ * schema, not the text. That harness is NOT committed, so those figures record one run
+ * and cannot be reproduced from this tree.
+ *
+ * A STEP block comment is refused rather than understood, because `mutate` must
+ * not rewrite a record it cannot read: `/` breaks a bare run, so a part
+ * carrying a comment outside a string is never one token, whatever the comment
+ * CONTAINS. Whitespace in the comment is not what gives it away:
+ * `$,/*renamed*\/,$` has none and was read as three slots for two attributes,
+ * the same phantom-slot shift as the rest of #4125 (see {@link isTokenBreak}
+ * for why breaking on the OPENER is enough).
+ *
+ * Several readers in this repo DO skip comments; diverging from them is
+ * deliberate. The nearest is `validate.ts` in this very package, which skips
+ * `/* ... *\/` while counting top-level attribute indices; it returns indices
+ * rather than parts, so it never has to put the bytes back. `source-header.ts`'s
+ * `splitTopLevel` is closer still, since it returns PARTS, but it drops the
+ * comment bytes, so it cannot satisfy the round-trip contract below either.
+ * And `packages/parser`'s
+ * `entity-extractor.ts` reads comments at every depth through
+ * `StepTextScan.skipLexicalAt`, and says so as policy: one comment-skip rule for
+ * decoded STEP text rather than a fourth hand-rolled copy. The difference is what
+ * the two produce. That one extracts VALUES and collapses a comment to a space;
+ * this one must satisfy `parts.join(',') === input` byte for byte, because its
+ * caller rewrites the user's file. Skipping a comment under that contract would
+ * silently delete it from their file, and keeping it inside the part means the
+ * part is not one token. Doing both needs a richer return type than `string[]`,
+ * which is a different module. (`STEP_TRIVIA` itself is legal anywhere whitespace
+ * is. Its call sites are what place it, and they all put it immediately before a
+ * `\(`.)
+ *
+ * What this module does NOT cover, so its refusal is not read as more than it is:
+ * `mutate` finds records with a line regex that allows only whitespace before the
+ * `(`, so a comment after the class keyword is skipped BEFORE reaching this code,
+ * and the run reports success having changed nothing; and `lastIndexOf(')')` can
+ * slice into a legal trailing comment. Both are #4163, one on each SIDE of the
+ * argument list (before the `(`, after the `)`), and both are the same
+ * line-versus-record shape as the wrapped-record case #4163 also covers.
+ *
+ * `packages/export/src/step-argument-parser.ts` is the nearest copy, and this is
+ * deliberately its near-twin rather than an import: `@ifc-lite/export`'s
+ * `exports` map exposes only `.`, so reaching it would mean adding a published
+ * export (and an `api-surface` entry) to a v4.0.0 package to fix a CLI bug.
+ * #4125 declined consolidating them, with its own measurement of why: the
+ * splitters in this repo have different CONTRACTS, so a shared function needs a
+ * mode flag or a richer return type, which is a new abstraction rather than a
+ * de-duplication. What they could share is the REFUSE side, and for TWO of the
+ * three it is pinned rather than described: the export twin and the Rust
+ * `split_top_level_args` are both held to the vectors in
+ * `rust/export/tests/fixtures/step_refuse_vectors.json`, by
+ * `packages/export/src/step-refuse.parity.test.ts` and by
+ * `rust/export/src/step_slot_tests.rs`'s
+ * `refuses_every_shared_cross_language_vector`.
+ *
+ * THIS splitter is NOT held to those vectors, and would not pass them today. `"`
+ * is absent from `isTokenBreak` below, so a binary literal is consumed as a bare
+ * run and two of the shared vectors are ACCEPTED here: `'g',"0F` splits as two
+ * parts with the unterminated literal intact, and `'g',"01,23"` splits into
+ * THREE parts for two attributes, because the comma inside the literal is read
+ * as a separator. The consumer is a live by-index writer — `mutate-step-record.ts`
+ * does `args[attrIdx] = …` and then `args.join(',')` — so that is the #4125
+ * failure still open in this file, not a hypothetical one. Adding the character
+ * is a behaviour change that would also refuse legitimate binary literals such
+ * as `"0F"`, which needs corpus verification rather than a one-character edit;
+ * LTplus-AG/ifc-lite#4200 tracks both the fix and the parity test that would
+ * have caught it.
+ *
+ * They diverge on the ACCEPT side, deliberately: this one refuses any slot
+ * carrying a `/* ... *\/` comment, while the export twin keeps the comment's
+ * bytes inside the slot and accepts it. That divergence is each caller's
+ * choice, so no fixture pins it.
+ *
+ * The export twin's `splitTopLevelStepArguments` used to have the three
+ * structural checks and no per-part check at all; #4173 gave it one
+ * (`isWellFormedStepSlot`), so the two now agree that a part must be one
+ * well-formed value.
+ */
+/**
+ * Split a STEP argument list on top-level commas, or return null when the text
+ * cannot be scanned as one. `input` is the text BETWEEN a record's outermost
+ * parentheses; the module header says why null rather than parts.
+ *
+ * Nothing is trimmed and nothing is normalised, so for input this accepts
+ * `parts.join(',')` reproduces `input` byte for byte and a caller that replaces
+ * one part leaves every other byte of the record alone. Rejected: a quote still
+ * open at the end, a paren depth that does not return to zero, a depth that
+ * ever goes NEGATIVE (a stray closing paren balanced by a later opening one),
+ * and a part that is not one token at every depth (see {@link isLoneStepToken}).
+ *
+ * An EMPTY top-level slot (`a,,b`, or a trailing comma) is NOT rejected: it is
+ * invalid STEP that costs no alignment, since an empty argument is one part
+ * exactly as the entity parser counts it, so every index still names the
+ * attribute it is meant to. An empty INPUT is not an empty slot: `#1=IFCFOO();`
+ * has no arguments, so it splits to `[]` and any slot request then fails the
+ * caller's bounds check.
+ */
+export function splitTopLevelStepArgs(input) {
+    if (input === '')
+        return [];
+    const parts = [];
+    let current = '';
+    let depth = 0;
+    let inString = false;
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        if (char === "'") {
+            current += char;
+            // A doubled quote INSIDE a string is an escaped apostrophe. Outside one
+            // the first quote opens a string and the second is read on its own next
+            // pass, so `''` there is the empty string rather than an escape.
+            if (inString && input[i + 1] === "'") {
+                current += input[i + 1];
+                i++;
+                continue;
+            }
+            inString = !inString;
+            continue;
+        }
+        if (!inString) {
+            if (char === '(') {
+                depth++;
+            }
+            else if (char === ')') {
+                depth--;
+                if (depth < 0)
+                    return null;
+            }
+            else if (char === ',' && depth === 0) {
+                parts.push(current);
+                current = '';
+                continue;
+            }
+        }
+        current += char;
+    }
+    if (inString || depth !== 0)
+        return null;
+    parts.push(current);
+    // These three are the contract this shares with
+    // `packages/export/src/step-argument-parser.ts`, which has them too (plus its
+    // own per-part check since #4173). That parity, not speed, is why they are
+    // kept: they add no coverage at all, and deleting any one of them, or all
+    // three, fails no test (measured). Only the `depth < 0` check above is an
+    // early exit; these two run after the whole scan and save only a walk over
+    // the parts.
+    return parts.every(isLoneStepToken) ? parts : null;
+}
+/**
+ * Is `part` exactly ONE STEP argument, all the way down? Surrounding whitespace
+ * is ignored, because a record may carry it and this must not refuse a record
+ * it could rewrite. An empty part passes, as an empty slot is accepted above.
+ */
+function isLoneStepToken(part) {
+    const text = part.trim();
+    return text === '' || skipToken(text, 0) === text.length;
+}
+/**
+ * Index just past the one token starting at `from`, or -1 when the text there
+ * is not one token. The forms, per ISO 10303-21: a string (`'...'`, `''`
+ * escaping an apostrophe), a list (`(...)`), or a bare run (`$`, `*`, `#123`, a
+ * number, an enumeration `.T.`, a binary `"0F"`) optionally applied to a list
+ * (`IFCINTEGER(3)`).
+ *
+ * Deliberately loose about what a bare run CONTAINS and strict only about where
+ * it may end: this is not a STEP validator and must not become one. A list's
+ * elements are held to the same rule, so a fragment left by a phantom string
+ * terminator is caught wherever it lands. Nesting is carried in `depth` rather
+ * than by recursing, so a pathologically nested record (this text comes from a
+ * file) refuses instead of overflowing the stack.
+ */
+function skipToken(text, from) {
+    let i = from;
+    let depth = 0;
+    let expectToken = true;
+    for (;;) {
+        i += countWhitespace(text, i);
+        const char = text[i];
+        if (expectToken) {
+            // A list element may be empty (`(1,,2)`), as a top-level slot may be.
+            if (depth > 0 && (char === ',' || char === ')')) {
+                expectToken = false;
+                continue;
+            }
+            if (char === "'") {
+                i = skipString(text, i);
+                if (i < 0)
+                    return -1;
+            }
+            else if (char === '(') {
+                depth++;
+                i++;
+                continue; // the list's first element is still a token to read
+            }
+            else {
+                const start = i;
+                while (i < text.length && !isTokenBreak(text[i]))
+                    i++;
+                // Nothing consumed: the end of the text, or a separator where a token
+                // belongs.
+                if (i === start)
+                    return -1;
+                const afterKeyword = i + countWhitespace(text, i);
+                if (text[afterKeyword] === '(') {
+                    depth++;
+                    i = afterKeyword + 1;
+                    continue;
+                }
+            }
+            expectToken = false;
+            continue;
+        }
+        // A token just closed, so only `,` or `)` may follow. At depth zero the
+        // token was the whole argument.
+        if (depth === 0)
+            return i;
+        if (char === ')') {
+            depth--;
+            i++;
+            continue;
+        }
+        if (char !== ',')
+            return -1;
+        i++;
+        expectToken = true;
+    }
+}
+/** Index just past the string starting at `from`, or -1 if it never closes. */
+function skipString(text, from) {
+    for (let i = from + 1; i < text.length; i++) {
+        if (text[i] !== "'")
+            continue;
+        if (text[i + 1] === "'")
+            i++;
+        else
+            return i + 1;
+    }
+    return -1;
+}
+/**
+ * Can this character only begin or separate another token?
+ *
+ * `/` is in the set for the STEP block comment, which opens with `/*`. Breaking
+ * on the OPENER is enough, and is why there is no comment state machine here: a
+ * comment can only sit where a token or a separator belongs, and either way the
+ * `/` ends the bare run short of the part's end, so `isLoneStepToken` refuses
+ * the part however the comment is written. `*` is deliberately NOT in the set,
+ * because it is the derived-attribute marker and a token in its own right, so
+ * breaking on it would refuse `$,$,*`.
+ */
+function isTokenBreak(char) {
+    return (char === "'" ||
+        char === '(' ||
+        char === ')' ||
+        char === ',' ||
+        char === '/' ||
+        char === ' ' ||
+        char === '\t' ||
+        char === '\n' ||
+        char === '\r' ||
+        char === '\x0b' ||
+        char === '\x0c');
+}
+/**
+ * How many whitespace characters run from `from`.
+ *
+ * All six characters every NAMED STEP whitespace set in this repo agrees on
+ * (`is_step_space`, `isSpaceByte`, `isAsciiSpace`, `STEP_TRIVIA`): ` \t\n\r\x0b\x0c`.
+ * This used to be space and tab only, safe only because the caller split on
+ * newlines before this ever ran; #4163's multi-line work now feeds this a raw
+ * multi-line `argsText`, so `\n` and `\r` (and `\x0b`/`\x0c`, in the set for the
+ * same reason) had to join both this and {@link isTokenBreak} or a bare run
+ * spans a line break silently and two tokens separated by one come back as ONE
+ * part (measured, before this widening: `'$\n$'` split to `["$\n$"]`, where
+ * `'$ $'` and `'$\t$'` were already refused).
+ */
+function countWhitespace(text, from) {
+    let n = 0;
+    while (from + n < text.length &&
+        (text[from + n] === ' ' ||
+            text[from + n] === '\t' ||
+            text[from + n] === '\n' ||
+            text[from + n] === '\r' ||
+            text[from + n] === '\x0b' ||
+            text[from + n] === '\x0c'))
+        n++;
+    return n;
+}
+//# sourceMappingURL=step-args.js.map

package/dist/commands/step-args.js.map

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

package/dist/commands/storey-selection.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedStep } from './extract-entities.js';
+/** Every product whose ObjectPlacement chains up through `storeyPlacementId`. */
+export declare function productsUnderPlacement(storeyPlacementId: number, parsed: ParsedStep): Set<number>;
+/** Resolve a --storey selector (GUID / name / expressId) to its placement id. */
+export declare function resolveStoreyPlacement(token: string, parsed: ParsedStep): number;
+//# sourceMappingURL=storey-selection.d.ts.map

package/dist/commands/storey-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storey-selection.d.ts","sourceRoot":"","sources":["../../src/commands/storey-selection.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAaxD,iFAAiF;AACjF,wBAAgB,sBAAsB,CAAC,iBAAiB,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,CA2BjG;AAED,iFAAiF;AACjF,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG,MAAM,CAgChF"}

package/dist/commands/storey-selection.js

@@ -0,0 +1,90 @@
+// 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/.
+/**
+ * `extract-entities`' `--storey` selector: resolve a storey token (GUID /
+ * name / expressId) to the set of products whose ObjectPlacement chains up
+ * through that storey's placement. Split out of `extract-entities.ts` to
+ * keep that file under its module-size budget.
+ */
+import { refsOutsideStrings } from './subset-relations.js';
+/** Map each IfcLocalPlacement to its parent placement (or null when top-level). */
+function placementParents(parsed) {
+    const parents = new Map();
+    for (const inst of parsed.instances.values()) {
+        if (inst.type !== 'IFCLOCALPLACEMENT')
+            continue;
+        const pm = /^\s*(#\d+|\$)/.exec(inst.body);
+        parents.set(inst.id, pm && pm[1].startsWith('#') ? parseInt(pm[1].slice(1), 10) : null);
+    }
+    return parents;
+}
+/** Every product whose ObjectPlacement chains up through `storeyPlacementId`. */
+export function productsUnderPlacement(storeyPlacementId, parsed) {
+    const parents = placementParents(parsed);
+    const under = new Set();
+    for (const pid of parents.keys()) {
+        let cur = pid;
+        let guard = 0;
+        while (cur != null && guard++ < 128) {
+            if (cur === storeyPlacementId) {
+                under.add(pid);
+                break;
+            }
+            cur = parents.get(cur) ?? null;
+        }
+    }
+    // Products referencing a selected placement. `refsOutsideStrings`, not a
+    // raw REF_RE scan: free text (e.g. `'... see also #40'`) could otherwise
+    // seed a product into the wrong storey's extraction.
+    const seeds = new Set();
+    for (const inst of parsed.instances.values()) {
+        for (const ref of refsOutsideStrings(inst.body)) {
+            if (under.has(ref)) {
+                seeds.add(inst.id);
+                break;
+            }
+        }
+    }
+    return seeds;
+}
+/** Resolve a --storey selector (GUID / name / expressId) to its placement id. */
+export function resolveStoreyPlacement(token, parsed) {
+    let storeyId;
+    const t = token.trim();
+    if (/^#?\d+$/.test(t)) {
+        storeyId = parseInt(t.replace('#', ''), 10);
+    }
+    else if (parsed.guidToId.has(t)) {
+        storeyId = parsed.guidToId.get(t);
+    }
+    else {
+        // match by name (2nd-to-last-ish quoted arg); scan storeys for a Name match
+        for (const inst of parsed.instances.values()) {
+            if (inst.type !== 'IFCBUILDINGSTOREY')
+                continue;
+            if (inst.body.includes(`'${t}'`)) {
+                storeyId = inst.id;
+                break;
+            }
+        }
+    }
+    if (storeyId === undefined)
+        throw new Error(`Storey not found: ${token}`);
+    const storey = parsed.instances.get(storeyId);
+    if (!storey || storey.type !== 'IFCBUILDINGSTOREY') {
+        throw new Error(`#${storeyId} is ${storey?.type ?? 'missing'}, not an IfcBuildingStorey`);
+    }
+    // IfcBuildingStorey ObjectPlacement is attribute 6 (after Guid, Owner, Name,
+    // Description, ObjectType) — the last #ref before LongName/Elevation. Grab the
+    // placement ref: the storey references exactly one IfcLocalPlacement.
+    // `refsOutsideStrings`, not a raw REF_RE scan: the storey's own Name/
+    // Description can contain a `#id`-shaped substring (e.g. `'duplicate of
+    // #99'`) naming an unrelated IfcLocalPlacement.
+    const refs = refsOutsideStrings(storey.body);
+    const placementId = refs.find((r) => parsed.instances.get(r)?.type === 'IFCLOCALPLACEMENT');
+    if (placementId === undefined)
+        throw new Error(`Storey #${storeyId} has no IfcLocalPlacement`);
+    return placementId;
+}
+//# sourceMappingURL=storey-selection.js.map

package/dist/commands/storey-selection.js.map

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

package/dist/commands/subset-relations.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Spatial-structure relations for an extracted subset: which ones join it, and
+ * what text each one emits.
+ *
+ * `IfcRelContainedInSpatialStructure` is one-to-MANY, and a real exporter
+ * writes exactly ONE of them per storey, naming every product in that storey.
+ * An all-or-nothing rule (keep the relation only when every id it mentions is
+ * kept) therefore drops containment on ANY strict subset of a real model: the
+ * extracted products land outside the spatial tree and a viewer shows the
+ * storey with nothing under it. So the `RelatedElements` SET is rewritten down
+ * to the kept members instead of the relation being dropped.
+ *
+ * The no-dangling-reference invariant is unchanged: every `#id` in an emitted
+ * record is an id the subset keeps, and since #4128 the caller's forward
+ * closure keeps only ids the file DEFINES, so kept implies defined. That covers
+ * the ids this module CHOOSES; it does not cover the references inside a kept
+ * record, which are emitted verbatim, so a source file that already dangles
+ * still dangles. That is the rest of the rules:
+ *   - the RELATING object (`RelatingStructure` / `RelatingObject`, the spatial
+ *     parent) is a hard requirement. A containment with no parent is
+ *     meaningless, and it would dangle. A KNOWN residual gap follows from that,
+ *     and it is not this module's to close: `buildSubset` force-keeps only
+ *     `IfcProject` / `IfcSite` / `IfcBuilding` / `IfcBuildingStorey`, so a
+ *     product contained in an `IfcSpace` or `IfcSpatialZone` still has an
+ *     unkept parent and still loses containment. Widening that type list is the
+ *     wrong close, because it force-keeps every space AND its forward closure in
+ *     every extraction; the right one is a BACKWARD closure from each kept
+ *     product up its containment and aggregation edges, which keeps exactly the
+ *     seeds' ancestors and needs no type list at all. Either way it is a change
+ *     to how `buildSubset` seeds, not to the rule here. Filed as #4124.
+ *   - an empty intersection drops the relation.
+ *   - every other non-set reference must be kept too. That is attribute 1,
+ *     `OwnerHistory`; usually it already is, because each kept product's own
+ *     body names the same shared `IfcOwnerHistory` and the products' forward
+ *     closure keeps it. An exporter that writes a PER-RELATIONSHIP
+ *     `IfcOwnerHistory` referenced by nothing else hits this rule every time,
+ *     and dropping there was the orphaned-storey symptom again (#4126). This
+ *     function still takes no `parsed`, so it cannot close over such a
+ *     reference; it REPORTS it in {@link SpatialRelationPlan.blockedOn} and the
+ *     caller, which does have `parsed`, decides whether to keep it and replan.
+ *     Purity is intact: `blockedOn` is a finding, not a mutation.
+ *
+ * A KNOWN gap: {@link keepWhole}, the fallback for a record this module could
+ * not read as its six attributes, still drops on the same private
+ * `OwnerHistory` and reports nothing. That is deliberate. Its references are
+ * read off the raw body with no established string boundaries, so a `#6` it
+ * names may be text rather than a reference, and forward-closing over it would
+ * re-create the hash-in-a-Name bug the scanner exists to avoid.
+ *
+ * A relation that loses NO member re-emits its source line verbatim, so an
+ * extraction that happened to keep every member does not churn.
+ *
+ * ## What this module re-implements, and why
+ *
+ * Three things here already exist in `@ifc-lite/export`, and all three are
+ * copied for ONE reason: that package's `exports` map exposes only `.`, and its
+ * `index.ts` re-exports none of them, so reaching any of them would mean adding
+ * a published export (and an `api-surface` entry) to a v4.0.0 package in order
+ * to fix a CLI bug.
+ *
+ *   - `filterHiddenRefsFromRelationshipLine` (`reference-collector.ts`) is the
+ *     same job, done better: it filters EVERY parenthesised attribute of ANY
+ *     `IFCREL*` line against an `isExcluded` predicate, so it needs no slot
+ *     table at all, and it carries an edge case this module has no equivalent
+ *     of (`IfcRelConnectsStructuralMember`'s optional trailing placement).
+ *     Adopting it would delete most of this file. The export barrier above is
+ *     the whole reason it is not adopted here, and nothing else: fed only
+ *     today's three types it would change no behaviour, because the CALLER
+ *     picks which lines it sees. Widening the type set is the separate decision,
+ *     and that is the one that changes which relations survive an extraction.
+ *     Consolidation follow-up: #4125.
+ *   - `splitTopLevelStepArguments` (`step-argument-parser.ts`) and
+ *     `skipStepComment` (`step-comment-skip.ts`): see {@link splitTopLevelArgs}.
+ *   - `STRUCTURE_RELATIONS` (`merged-empty-containers.ts`): three lines, see
+ *     below.
+ */
+/**
+ * One parsed STEP record, as `extract-entities.ts`'s `parseStep` produces it.
+ * Declared HERE and imported there, rather than the other way round, so the
+ * dependency runs one way: `extract-entities.ts` imports this module, never
+ * the reverse.
+ */
+export interface StepRecord {
+    id: number;
+    type: string;
+    /** Argument text between the outermost parentheses. */
+    body: string;
+    /** The verbatim `#id= TYPE(...);` text. */
+    full: string;
+}
+/**
+ * The assembled subset: the ids to emit, plus the record text to emit for the
+ * relations whose related-objects SET was filtered. An id absent from
+ * `rewritten` emits its source line unchanged.
+ */
+export interface Subset {
+    keep: Set<number>;
+    rewritten: ReadonlyMap<number, string>;
+}
+/** What {@link planSpatialRelations} found: relations to add, and their text. */
+export interface SpatialRelationPlan {
+    /** Relation ids that join the subset. */
+    add: number[];
+    /** Relation id → rewritten record text, for the ones that lost a member. */
+    rewritten: Map<number, string>;
+    /**
+     * One entry per relation this plan dropped for ONE reason alone: unkept non-SET references,
+     * in practice a relation-private `OwnerHistory`. Its relating parent is kept and its member
+     * intersection is non-empty, so keeping EVERY id in the entry is all that stands between it
+     * and surviving. Grouped per relation, because keeping only SOME of one relation's blockers
+     * leaves it dropped and those ids orphaned (#4150). A caller with the parsed model closes
+     * over a group and replans (#4126). Every other drop is final and reports nothing here.
+     */
+    blockedOn: number[][];
+}
+/**
+ * Spatial-structure relations, as `[relatingAttributeIndex, relatedAttributeIndex]`.
+ * `IfcRelAggregates` names the whole (`RelatingObject`) first; the two containment
+ * relations name the parts (`RelatedElements`) first. Same table as `STRUCTURE_RELATIONS`
+ * in `@ifc-lite/export`'s `merged-empty-containers.ts`, which reads the same three
+ * records, copied rather than imported because that module is internal to
+ * `@ifc-lite/export` and exporting it would widen a published API surface for a
+ * three-line constant.
+ *
+ * `IfcRelReferencedInSpatialStructure` is here for the same reason the other two are:
+ * same shape (one relating parent, one related SET), same one-per-storey authoring,
+ * same claim in the command's own docs that the output "parses and renders on its
+ * own". It used to be missing entirely, so a referenced-but-not-contained product was
+ * always orphaned.
+ */
+export declare const STRUCTURE_RELATIONS: Record<string, [number, number]>;
+/**
+ * All three are `GlobalId, OwnerHistory, Name, Description` plus the relating/related
+ * pair: exactly 6 attributes in every schema that defines them. A record that does not
+ * split into 6 was mis-scanned (or is not the entity the type name claims), so it falls
+ * back to keep-whole-or-drop-whole rather than having a slot index written into
+ * whatever it did split into.
+ *
+ * A relation type with a different attribute COUNT (`IfcRelAssignsToGroup` has 7)
+ * therefore cannot simply be added as a row above: it would fail this check on every
+ * record and fall silently back to keep-whole-or-drop-whole, which is the bug this
+ * module exists to fix. Such a type needs the count moved into the table value first,
+ * or the whole table derived from the schema registry, which returns 7 for that entity
+ * and would make row four safe rather than forbidden. Filed as #4123.
+ */
+export declare const STRUCTURE_RELATION_ATTRS = 6;
+/** A single `#id` and nothing else: an object reference in one slot. */
+export declare const SINGLE_REF_RE: RegExp;
+/**
+ * Decide every spatial-structure relation against a kept-id set.
+ *
+ * Pure in both arguments: adding relation ids to `keep` afterwards cannot
+ * change any verdict, because a relation of these types references products,
+ * spatial containers and an OwnerHistory, never another relation.
+ */
+export declare function planSpatialRelations(instances: Iterable<StepRecord>, keep: ReadonlySet<number>): SpatialRelationPlan;
+/**
+ * The `#id` object references in one argument, ignoring any that sit inside a
+ * STEP string literal.
+ *
+ * A relation's `Name` and `Description` are free TEXT, and free text contains
+ * `#`; `parseStep` tokenizes rather than regexes precisely because Revit
+ * writes names like that. Read raw, the `#99` in `'Level #99 contents'` looks
+ * like a reference to entity 99, and one unkept lookalike drops the WHOLE
+ * relation: the orphaned-storey bug this module exists to fix, re-created for
+ * any model that names a relation that way.
+ *
+ * Correct only on an argument whose split VALIDATED, so the quote boundaries
+ * are the record's own. {@link keepWhole} deliberately does NOT use this. It
+ * runs when the split FAILED, and also when it succeeded but the record is not
+ * the six-attribute shape this module rewrites, so its boundaries are not
+ * established in general. There, over-counting references (drop the record) is
+ * the safe error, while under-counting (emit a dangling `#id`) is not.
+ *
+ * Exported for `extract-entities.ts`'s `forwardClosure`, which has the same
+ * hazard scanning a whole record body for its reference closure: nothing here
+ * assumes `arg` is one split ARGUMENT rather than a whole body, since a comma
+ * or `)` outside a string does not affect the in-string/out-of-string state
+ * this walks.
+ */
+export declare function refsOutsideStrings(arg: string): number[];
+/**
+ * Split a STEP argument list on top-level commas, respecting nested parens,
+ * quoted strings, doubled-quote escapes, and `/* ... *\/` comments (#4227).
+ * Returns null on an unterminated string, an unbalanced paren depth, or a
+ * depth that ever goes negative -- {@link relationLine} writes a slot by
+ * index (#2470), so a mis-scanned list must not hand back parts that look
+ * like success. A comma/paren/quote inside a comment is skipped with it (see
+ * {@link skipStepComment}): unskipped, its comma shifts every later slot
+ * boundary and `relationLine` either mis-splices a member or falls back to
+ * {@link keepWhole}, dropping a relation that should have survived -- the
+ * orphaned-storey symptom (#4126) this module exists to fix, by a different
+ * route. An EMPTY INTERIOR slot (`a,,b`) is one part, not rejected.
+ *
+ * Near-twin of `@ifc-lite/export`'s `splitTopLevelStepArguments` (see the
+ * module header). Two differences: each part is `trim`med (because
+ * {@link SINGLE_REF_RE} is anchored), and a TRAILING empty slot (`a,b,`)
+ * yields 2 parts, not 3.
+ */
+export declare function splitTopLevelArgs(text: string): string[] | null;
+//# sourceMappingURL=subset-relations.d.ts.map

package/dist/commands/subset-relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subset-relations.d.ts","sourceRoot":"","sources":["../../src/commands/subset-relations.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAClB,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AAED,iFAAiF;AACjF,MAAM,WAAW,mBAAmB;IAClC,yCAAyC;IACzC,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,4EAA4E;IAC5E,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B;;;;;;;OAOG;IACH,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;CACvB;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAIhE,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,wEAAwE;AACxE,eAAO,MAAM,aAAa,QAAa,CAAC;AAExC;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC/B,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,GACxB,mBAAmB,CAarB;AA8DD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAsBxD;AAgDD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CAuC/D"}