brepjs-bim 0.25.0 → 0.26.0

package/dist/elementFns/curtainWallFns.d.ts

@@ -9,8 +9,8 @@ import { BimError } from '../errors/bimError.js';
  * geometry (corner at 0,0,0).
  */
 export interface CurtainWallComponent {
-    readonly origin: [number, number, number];
-    readonly size: [number, number, number];
+    readonly origin: readonly [number, number, number];
+    readonly size: readonly [number, number, number];
     readonly solid: ValidSolid;
 }
 /** A curtain wall decomposed into glazing panels (plates) and mullions (members). */
@@ -18,15 +18,5 @@ export interface CurtainWallGrid {
     readonly panels: readonly CurtainWallComponent[];
     readonly mullions: readonly CurtainWallComponent[];
 }
-/**
- * Decomposes a curtain wall spec into its panel (plate) and mullion (member)
- * geometry. Mullions run along every vertical grid line (columns + 1 of them)
- * and every horizontal grid line (rows + 1); panels fill the cells between
- * adjacent mullions. The mullion section is centred on each grid line.
- *
- * Geometry is laid out in the wall's local frame: X across the wall, Z up, Y
- * through the depth. Each component's local-origin solid is returned alongside
- * its placement origin so the IFC writer can emit one IfcLocalPlacement per
- * component.
- */
+/** Generate owned components, releasing every partial output on failure or failed temporary cleanup. */
 export declare function curtainWallToGrid(spec: CurtainWallSpec): Result<CurtainWallGrid, BimError>;

package/dist/elementFns/cutOpeningSolid.d.ts

@@ -0,0 +1,8 @@
+import { Result, ValidSolid } from 'brepjs';
+import { BimError } from '../errors/bimError.js';
+/** Borrow the host; retain one independent solid only after all temporary cleanup succeeds. */
+export declare function cutOpeningSolid(input: {
+    readonly host: ValidSolid;
+    readonly makeTool: () => Result<ValidSolid, BimError>;
+    readonly hostKind: 'WALL' | 'SLAB';
+}): Result<ValidSolid, BimError>;

package/dist/elementFns/placedGeometry.d.ts

@@ -2,11 +2,6 @@ import { ValidSolid, Result } from 'brepjs';
 import { AnyBimElement } from '../types/bimTypes.js';
 import { BimError } from '../errors/bimError.js';
 import { FrameInput } from '../placementFrame.js';
-export interface PlacedGeometryTestHooks {
-    readonly afterPlaced?: ((solid: ValidSolid) => void) | undefined;
-}
-/** Package-internal deterministic failure seam for placement ownership tests. */
-export declare function setPlacedGeometryTestHooksForTesting(hooks: PlacedGeometryTestHooks | null): void;
 export interface PlacedSolidsOptions {
     /**
      * Cumulative frame of the element's containing spatial structure. Element

package/dist/elementFns/validateGeneratedSolid.d.ts

@@ -0,0 +1,7 @@
+import { Result, Solid, ValidSolid } from 'brepjs';
+import { BimError } from '../errors/bimError.js';
+/** Validate a candidate already owned by the surrounding generation scope. */
+export declare function validateGeneratedSolid(solid: Solid, context: {
+    readonly code: string;
+    readonly message: string;
+}): Result<ValidSolid, BimError>;

package/dist/familiesAdapter.d.ts

@@ -15,9 +15,9 @@ export interface FamiliesToBimOptions {
      * returns FAMILIES_PRODUCT_BODY_EVALUATOR_REQUIRED with the element path and
      * mapped category, and does not fall back to a parametric envelope.
      * Conventional archetype walls and railings stay specification-authoritative
-     * and do not require an evaluator. When present, civil walls and railings
-     * compare the evaluated Body with their post-opening parametric Body and
-     * retain the authored Body when they differ. Supplying this option does not
+     * and do not require an evaluator. Civil walls and railings always retain
+     * independent authored items as AUTHORITATIVE, including when coincident
+     * with the post-opening candidate. Supplying this option does not
      * opt unsupported products into the proxy fallback.
      */
     readonly bodyEvaluator?: csg.Evaluator | undefined;

package/dist/familiesProductBody.d.ts

@@ -1,40 +1,18 @@
-import { Result, Solid, ValidSolid, csg } from 'brepjs';
+import { Result, csg } from 'brepjs';
 import { ResolvedElement } from 'brepjs-families';
 import { BimError } from './errors/bimError.js';
 import { ProductBody } from './types/productBody.js';
 import { RigidFrame } from './placementFrame.js';
-type ExactProductBody = Extract<ProductBody, {
-    readonly kind: 'EXACT';
-}>;
-type ParametricProductBody = Extract<ProductBody, {
-    readonly kind: 'PARAMETRIC';
-}>;
-export type CivilProductBodySelection = {
-    readonly kind: 'PARAMETRIC';
-} | {
-    readonly kind: 'EXACT';
-    readonly body: ExactProductBody;
-};
 export interface CivilProductBodyInput {
     readonly element: ResolvedElement;
     readonly category: 'WALL' | 'RAILING';
     readonly evaluator: csg.Evaluator;
     readonly productWorldFrame: RigidFrame;
-    /** Borrowed model-owned comparison candidate after registered openings. */
-    readonly parametricBody: ParametricProductBody;
 }
-export interface FamiliesProductBodyTestHooks {
-    readonly afterCopy?: ((itemIndex: number, solid: Solid, source: Solid) => void) | undefined;
-    readonly beforeLocalize?: ((itemIndex: number, solid: ValidSolid) => void) | undefined;
-    readonly afterLocalized?: ((itemIndex: number, solid: ValidSolid) => void) | undefined;
-    readonly beforeCoincidence?: ((exact: ExactProductBody, parametric: ParametricProductBody) => void) | undefined;
-}
-/** Package-internal deterministic failure seams for exact ownership tests. */
-export declare function setFamiliesProductBodyTestHooksForTesting(hooks: FamiliesProductBodyTestHooks | null): void;
 /**
- * Evaluates a civil Product Body, clones and localizes every borrowed source,
- * then proves whether the registered-opening parametric Body is coincident.
- * An EXACT result is caller-owned until takeExactProductBody() succeeds.
+ * Borrow evaluator parents, then copy and inverse-localize in item order.
+ * Every successful result is AUTHORITATIVE and caller-owned until COMMITTED.
  */
-export declare function selectCivilProductBody(input: CivilProductBodyInput): Result<CivilProductBodySelection, BimError>;
-export {};
+export declare function prepareCivilProductBody(input: CivilProductBodyInput): Result<Extract<ProductBody, {
+    kind: 'AUTHORITATIVE';
+}>, BimError>;

package/dist/geometryGeneration.d.ts

@@ -0,0 +1,26 @@
+import { Result } from 'brepjs';
+import { BimError } from './errors/bimError.js';
+import { CleanupReport, OwnedBodyResource } from './productBodyCleanup.js';
+export type OwnGeneratedResource = <T extends Disposable>(resource: T) => T;
+export interface UncertainGeneratedResource {
+    readonly handle: Disposable;
+    readonly resource: object | undefined;
+    readonly itemIndex: number;
+}
+export interface GeneratedResource extends OwnedBodyResource {
+    nativeResource: object | undefined;
+}
+/** Already-attempted resources, with identities captured before any release. Never retry them. */
+export declare function uncertainGeneratedResources(error: BimError): readonly UncertainGeneratedResource[];
+/** Item positions must be unique within this generator-owned cleanup group. */
+export declare function failedResources(report: CleanupReport, owned: readonly GeneratedResource[]): readonly UncertainGeneratedResource[];
+export declare function generationFailure(error: BimError, uncertain: readonly UncertainGeneratedResource[]): Result<never, BimError>;
+/**
+ * A recipe owns every allocation until all temporary cleanup has succeeded.
+ * Register each fresh result before validation or another native call. Cleanup
+ * runs in reverse allocation order, once per resource, even if releases throw.
+ */
+export declare function generateGeometry<T extends Disposable>(context: {
+    readonly operation: string;
+    readonly codePrefix: string;
+}, build: (own: OwnGeneratedResource) => Result<T, BimError>): Result<T, BimError>;

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-export { BimModel, type ElementIdentityOptions, type OpeningIdentityOptions, } from './model/bimModel.js';
+export { BimModel, type BodyCommitReceipt, type ElementIdentityOptions, type OpeningIdentityOptions, } from './model/bimModel.js';
 export type { BimTreeNode, BimTreeSummary } from './model/treeSummary.js';
 export { placedSolids } from './elementFns/placedGeometry.js';
-export { bodySolids } from './types/productBody.js';
-export type { NonEmpty, ProductBody } from './types/productBody.js';
+export { bodySolids, validateProductBody, copyProductBody, transformProductBody, productBodyBounds, measureProductBodyMaterial, disposeProductBody, } from './types/productBody.js';
+export type { NonEmpty, ProductBody, ProductBodyError, ProductBodyOperation, ProductBodyBounds, ProductBodySpace, CleanupReport, GeometryCleanupDiagnostic, } from './types/productBody.js';
 export type { PlacedSolidsOptions } from './elementFns/placedGeometry.js';
-export type { FrameInput } from './placementFrame.js';
+export type { FrameInput, RigidFrame, Mat4x4 } from './placementFrame.js';
+export { frameFromPlacement, frameFromMatrix, frameMul, frameInverse, translationFrame, rotationFrame, IDENTITY_FRAME, } from './placementFrame.js';
 export { toIfc, toIfcValidated } from './serialize/toIfc.js';
 export type { ValidatedIfcResult } from './serialize/toIfc.js';
 export { setIfcWasmLocateFile } from './ifcRuntime.js';

package/dist/model/bimModel.d.ts

@@ -1,4 +1,5 @@
 import { Result } from 'brepjs';
+import { IfcGuid } from '../identity/ifcGuid.js';
 import { LocalId } from '../identity/localId.js';
 import { BimError } from '../errors/bimError.js';
 import { AnyBimElement, BimElement } from '../types/bimTypes.js';
@@ -25,6 +26,13 @@ import { SurfaceStyleSpec } from '../ifc-writer/styleWriter.js';
 import { ProjectSpec, SiteSpec, BuildingSpec, StoreySpec } from '../specs/spatialSpec.js';
 import { BridgePartSpec, BridgeSpec, EarthworksFillSpec } from '../specs/infrastructureSpec.js';
 import { ProductBody } from '../types/productBody.js';
+import { CleanupReport, GeometryCleanupDiagnostic } from '../productBodyCleanup.js';
+export interface BodyCommitReceipt {
+    readonly kind: 'COMMITTED';
+    readonly localId: LocalId;
+    readonly guid: IfcGuid;
+    readonly cleanup: CleanupReport;
+}
 /** Optional identity override for created elements: a stable key (e.g. a
  *  families key path) that replaces the positional GlobalId derivation. */
 export interface ElementIdentityOptions {
@@ -37,6 +45,7 @@ export interface OpeningIdentityOptions extends ElementIdentityOptions {
 }
 export declare class BimModel {
     #private;
+    getGeometryCleanupDiagnostics(): readonly GeometryCleanupDiagnostic[];
     init(spec: ProjectSpec, options?: ElementIdentityOptions): Result<LocalId, BimError>;
     [Symbol.dispose](): void;
     addSite(spec: SiteSpec, options?: ElementIdentityOptions): Result<LocalId, BimError>;
@@ -68,14 +77,11 @@ export declare class BimModel {
      */
     addRamp(spec: RampSpec, options?: ElementIdentityOptions): Result<LocalId, BimError>;
     addRailing(spec: RailingSpec, options?: ElementIdentityOptions): Result<LocalId, BimError>;
-    /**
-     * Atomically replaces a parametric wall or railing Body with authoritative,
-     * caller-owned exact solids. Success transfers every supplied handle to this
-     * model. Failure leaves both the model and all supplied handles unchanged.
-     */
-    takeExactProductBody(localId: LocalId, body: Extract<ProductBody, {
-        readonly kind: 'EXACT';
-    }>): Result<void, BimError>;
+    /** Ownership transfers only on COMMITTED, including when retirement reports failure. */
+    replaceProductBody(input: {
+        readonly localId: LocalId;
+        readonly body: ProductBody;
+    }): Result<BodyCommitReceipt, BimError>;
     /**
      * Adds an IfcCovering. When `hostLocalId` is supplied, an
      * IfcRelCoversBldgElements linking the covering to its host (e.g. a slab it
@@ -155,6 +161,8 @@ export declare class BimModel {
     placeIn(elementId: LocalId, containerId: LocalId): void;
     getProject(): BimElement<'PROJECT'> | null;
     getElement(id: LocalId): AnyBimElement | null;
+    /** Whether recipe commands still justify this element's recipe-derived quantities. */
+    isRecipeQuantityEligible(id: LocalId): boolean;
     /**
      * A serializable summary of the model's structure, rooted at the project and
      * walking the IFC spatial hierarchy (AGGREGATES: project → site → building →

package/dist/model/modelGeometry.d.ts

@@ -0,0 +1,10 @@
+import { Result, ValidSolid } from 'brepjs';
+import { BimError } from '../errors/bimError.js';
+import { AnyBimElement, BimCategory, BimElement } from '../types/bimTypes.js';
+export type ElementFields = {
+    [C in BimCategory]: Pick<BimElement<C>, 'category' | 'spec' | 'geometry'>;
+}[BimCategory];
+/** Transitional enumeration of current record storage. Step 2 converges these forms. */
+export declare function retainedSolids(element: ElementFields): readonly ValidSolid[];
+/** Snapshot ownership-bearing descriptors only; never freeze or clone native handles. */
+export declare function protectElement(element: AnyBimElement): Result<AnyBimElement, BimError>;

package/dist/ownedSolidChildren.d.ts

@@ -0,0 +1,7 @@
+import { getKernel, Solid } from 'brepjs';
+interface ExtractedSolidOwner extends Disposable {
+    readonly wrapped: Parameters<ReturnType<typeof getKernel>['dispose']>[0];
+}
+/** Register every eager iterator allocation before wrapping any child. */
+export declare function ownSolidChildren(parent: Solid['wrapped'], own: (resource: ExtractedSolidOwner, itemIndex: number) => void): readonly Solid[];
+export {};

package/dist/productBodyTestHooks.d.ts

@@ -1,6 +1,6 @@
 import { BimError } from './errors/bimError.js';
 import { Result, ValidSolid, measureVolume, getBounds } from 'brepjs';
-export type BodyNativeStep = 'validate' | 'union' | 'measure' | 'bounds';
+export type BodyNativeStep = 'validate' | 'copy' | 'transform' | 'union' | 'measure' | 'bounds';
 export interface BodyNativeEvent {
     readonly step: BodyNativeStep;
     readonly itemIndex: number;

package/dist/rigidPlacement.d.ts

@@ -1,4 +1,6 @@
-import { AnyShape, Dimension } from 'brepjs';
+import { AnyShape, Dimension, ComposedTransform } from 'brepjs';
 import { RigidFrame } from './placementFrame.js';
 /** Applies a rigid placement as a location so the source BRep is not rebuilt. */
 export declare function locateShapeInFrame<T extends AnyShape<Dimension>>(shape: T, frame: RigidFrame): T;
+/** The caller owns this temporary and must observe any failure from its cleanup. */
+export declare function composeFrameTransform(frame: RigidFrame): ComposedTransform;

package/dist/types/productBody.d.ts

@@ -1,29 +1,67 @@
+import { z } from 'zod';
 import { Bounds3D, Result, ValidSolid } from 'brepjs';
 import { BimError } from '../errors/bimError.js';
+import { RigidFrame } from '../placementFrame.js';
 import { CleanupReport } from '../productBodyCleanup.js';
+export type { CleanupReport, GeometryCleanupDiagnostic } from '../productBodyCleanup.js';
 export type NonEmpty<T> = readonly [T, ...T[]];
 export type ProductBody = {
     readonly kind: 'PARAMETRIC';
-    readonly solid: ValidSolid;
+    readonly solids: NonEmpty<ValidSolid>;
 } | {
-    readonly kind: 'EXACT';
+    readonly kind: 'AUTHORITATIVE';
     readonly solids: NonEmpty<ValidSolid>;
 };
-/** Returns borrowed Product-local solids. The model retains ownership. */
-export declare function bodySolids(body: ProductBody): NonEmpty<ValidSolid>;
-/** Model-owner cleanup. Borrowers must use {@link bodySolids} without disposing its items. */
-export declare function disposeProductBody(body: ProductBody): void;
-export type ProductBodyOperation = 'productBodyBounds' | 'measureProductBodyMaterial';
+export type ProductBodyOperation = 'validateProductBody' | 'copyProductBody' | 'transformProductBody' | 'productBodyBounds' | 'measureProductBodyMaterial';
 export interface ProductBodyError extends BimError {
     readonly operation: ProductBodyOperation;
     readonly itemIndex?: number;
     readonly cleanup: CleanupReport;
 }
+export type ProductBodySpace = {
+    readonly kind: 'LOCAL';
+} | {
+    readonly kind: 'RESOLVED';
+    readonly tag: string;
+    readonly frame: RigidFrame;
+};
+export interface ProductBodyBounds {
+    readonly space: {
+        readonly kind: 'LOCAL';
+    } | {
+        readonly kind: 'RESOLVED';
+        readonly tag: string;
+    };
+    readonly bounds: Readonly<Bounds3D>;
+}
+declare const descriptorSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        PARAMETRIC: "PARAMETRIC";
+        AUTHORITATIVE: "AUTHORITATIVE";
+    }>;
+    solids: z.ZodCustom<readonly unknown[], readonly unknown[]>;
+}, z.core.$strip>;
 /** @internal Exact resource object identity only, without native topology queries. */
 export declare function wrappedResourceObject(solid: unknown): object | undefined;
+/** @internal Capture opaque items before any native query, so owners can reject retired aliases. */
+export declare function snapshotProductBodyInput(input: unknown): Result<z.infer<typeof descriptorSchema>, ProductBodyError>;
+/** Borrow only. Reject duplicate handles and exact wrapped resource objects.
+ * Independent copies may share topology. Other external aliases remain a caller
+ * ownership precondition; rejection does not disable an alias's disposer/finalizer.
+ * Freezing a descriptor/collection neither clones nor transfers native handles.
+ */
+export declare function validateProductBody(input: unknown): Result<ProductBody, ProductBodyError>;
+/** Borrow protected Product-local items. Borrowers must not dispose the retained handles. */
+export declare function bodySolids(body: ProductBody): NonEmpty<ValidSolid>;
+/** Owner-only cleanup. COMPLETE means no failure was observable at the BIM boundary.
+ * A FAILED release must not be retried: its native-release outcome can be unknown.
+ */
+export declare function disposeProductBody(body: ProductBody): CleanupReport;
+/** Borrow a Body; return a fresh independently owned copy with unchanged authority/order. */
+export declare function copyProductBody(body: ProductBody): Result<ProductBody, ProductBodyError>;
+/** Borrow inputs; even identity placement returns fresh, independently disposable items. */
+export declare function transformProductBody(body: ProductBody, frame: RigidFrame): Result<ProductBody, ProductBodyError>;
 /** Occupied material in mm³. Borrowed imported items need no authored Body descriptor. */
 export declare function measureProductBodyMaterial(solids: NonEmpty<ValidSolid>): Result<number, ProductBodyError>;
-/** Borrow all items and query their tight bounds in their existing coordinates. */
-export declare function productBodyBounds(solids: NonEmpty<ValidSolid>): Result<{
-    readonly bounds: Readonly<Bounds3D>;
-}, ProductBodyError>;
+/** All-item tight bounds. A resolved tag belongs to the caller, not a document identity. */
+export declare function productBodyBounds(body: ProductBody | NonEmpty<ValidSolid>, space?: ProductBodySpace): Result<ProductBodyBounds, ProductBodyError>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brepjs-bim",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "BIM layer for brepjs — IFC4-aligned parametric building elements",
   "keywords": [
     "bim",
@@ -44,7 +44,8 @@
     "typecheck": "tsgo --noEmit",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "lint": "eslint src tests"
+    "lint": "eslint src tests",
+    "typecheck:consumers": "tsgo -p tsconfig.test.json --noEmit"
   },
   "peerDependencies": {
     "brepjs": ">=19.0.5",