@snaptrude/plugin-core 0.9.12 → 0.9.14-networks-20260930.1

package/dist/api/design/networks.d.ts

@@ -0,0 +1,530 @@
+import * as z from "zod";
+import type { PluginApiReturn } from "../../types";
+/** Authored world-space connector. This is not a claim of certified family connector metadata. */
+export declare const NetworkPort: z.ZodObject<{
+    id: z.ZodString;
+    positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    system: z.ZodString;
+    sizeMm: z.ZodNumber;
+    heightMm: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/** The agent supplies every route and section. The host does not size or route a network. */
+export declare const NetworkGeometry: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"family">;
+    definitionId: z.ZodString;
+    version: z.ZodNumber;
+    values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+    positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+    ports: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        system: z.ZodString;
+        sizeMm: z.ZodNumber;
+        heightMm: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"route">;
+    pathMm: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    system: z.ZodString;
+    section: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"round">;
+        diameterMm: z.ZodNumber;
+        wallMm: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"rectangular">;
+        widthMm: z.ZodNumber;
+        heightMm: z.ZodNumber;
+        wallMm: z.ZodNumber;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>], "kind">;
+/** Electrical connectivity and circuit membership are distinct from physical route occupancy. */
+export declare const ElectricalGraphDocument: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    connections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        directed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            within: "within";
+            mountedOn: "mountedOn";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    domain: z.ZodLiteral<"electrical">;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        geometry: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"family">;
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            ports: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                system: z.ZodString;
+                sizeMm: z.ZodNumber;
+                heightMm: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"route">;
+            pathMm: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            system: z.ZodString;
+            section: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"round">;
+                diameterMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"rectangular">;
+                widthMm: z.ZodNumber;
+                heightMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>], "kind">;
+        kind: z.ZodEnum<{
+            transformer: "transformer";
+            mainBoard: "mainBoard";
+            distributionBoard: "distributionBoard";
+            mcbBox: "mcbBox";
+            junctionBox: "junctionBox";
+            switch: "switch";
+            outlet: "outlet";
+            light: "light";
+            load: "load";
+            equipment: "equipment";
+            fitting: "fitting";
+            wire: "wire";
+            cable: "cable";
+            conduit: "conduit";
+            cableDuct: "cableDuct";
+            cableTray: "cableTray";
+        }>;
+    }, z.core.$strict>>;
+    circuits: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        loads: z.ZodArray<z.ZodString>;
+        routes: z.ZodArray<z.ZodString>;
+        voltage: z.ZodNumber;
+        phases: z.ZodNumber;
+        ratedAmps: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Plumbing uses explicit directed port connections; touching geometry never creates a connection. */
+export declare const PlumbingGraphDocument: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    connections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        directed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            within: "within";
+            mountedOn: "mountedOn";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    domain: z.ZodLiteral<"plumbing">;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        geometry: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"family">;
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            ports: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                system: z.ZodString;
+                sizeMm: z.ZodNumber;
+                heightMm: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"route">;
+            pathMm: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            system: z.ZodString;
+            section: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"round">;
+                diameterMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"rectangular">;
+                widthMm: z.ZodNumber;
+                heightMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>], "kind">;
+        kind: z.ZodEnum<{
+            pipe: "pipe";
+            riser: "riser";
+            equipment: "equipment";
+            fitting: "fitting";
+            fixture: "fixture";
+            tank: "tank";
+            pump: "pump";
+            valve: "valve";
+            manifold: "manifold";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const NetworkGraphDocument: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    connections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        directed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            within: "within";
+            mountedOn: "mountedOn";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    domain: z.ZodLiteral<"electrical">;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        geometry: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"family">;
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            ports: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                system: z.ZodString;
+                sizeMm: z.ZodNumber;
+                heightMm: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"route">;
+            pathMm: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            system: z.ZodString;
+            section: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"round">;
+                diameterMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"rectangular">;
+                widthMm: z.ZodNumber;
+                heightMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>], "kind">;
+        kind: z.ZodEnum<{
+            transformer: "transformer";
+            mainBoard: "mainBoard";
+            distributionBoard: "distributionBoard";
+            mcbBox: "mcbBox";
+            junctionBox: "junctionBox";
+            switch: "switch";
+            outlet: "outlet";
+            light: "light";
+            load: "load";
+            equipment: "equipment";
+            fitting: "fitting";
+            wire: "wire";
+            cable: "cable";
+            conduit: "conduit";
+            cableDuct: "cableDuct";
+            cableTray: "cableTray";
+        }>;
+    }, z.core.$strict>>;
+    circuits: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        loads: z.ZodArray<z.ZodString>;
+        routes: z.ZodArray<z.ZodString>;
+        voltage: z.ZodNumber;
+        phases: z.ZodNumber;
+        ratedAmps: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    label: z.ZodString;
+    architectureRevision: z.ZodString;
+    connections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        to: z.ZodObject<{
+            node: z.ZodString;
+            port: z.ZodString;
+        }, z.core.$strict>;
+        directed: z.ZodBoolean;
+    }, z.core.$strict>>;
+    relationships: z.ZodArray<z.ZodObject<{
+        node: z.ZodString;
+        relation: z.ZodEnum<{
+            within: "within";
+            mountedOn: "mountedOn";
+            serves: "serves";
+            penetrates: "penetrates";
+        }>;
+        target: z.ZodObject<{
+            kind: z.ZodEnum<{
+                topology: "topology";
+                component: "component";
+            }>;
+            id: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    domain: z.ZodLiteral<"plumbing">;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        storey: z.ZodNumber;
+        geometry: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"family">;
+            definitionId: z.ZodString;
+            version: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString, z.ZodBoolean]>>;
+            positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            rotationDeg: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            ports: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                positionMm: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                direction: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                system: z.ZodString;
+                sizeMm: z.ZodNumber;
+                heightMm: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"route">;
+            pathMm: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            system: z.ZodString;
+            section: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"round">;
+                diameterMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"rectangular">;
+                widthMm: z.ZodNumber;
+                heightMm: z.ZodNumber;
+                wallMm: z.ZodNumber;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>], "kind">;
+        kind: z.ZodEnum<{
+            pipe: "pipe";
+            riser: "riser";
+            equipment: "equipment";
+            fitting: "fitting";
+            fixture: "fixture";
+            tank: "tank";
+            pump: "pump";
+            valve: "valve";
+            manifold: "manifold";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "domain">;
+export type NetworkGraphDocument = z.infer<typeof NetworkGraphDocument>;
+export type NetworkNode = NetworkGraphDocument["nodes"][number];
+export type NetworkPort = z.infer<typeof NetworkPort>;
+export type NetworkDomain = NetworkGraphDocument["domain"];
+/** JSON is an authored document, not a transport for live geometry handles. Maximum 2 MB characters. */
+export declare const NetworkValidateArgs: z.ZodObject<{
+    graphJson: z.ZodString;
+}, z.core.$strict>;
+export declare const NetworkCreateArgs: z.ZodObject<{
+    graphJson: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strict>;
+export declare const NetworkGetArgs: z.ZodObject<{
+    graphId: z.ZodString;
+}, z.core.$strict>;
+export declare const NetworkContextArgs: z.ZodObject<{
+    offset: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const NetworkQueryArgs: z.ZodObject<{
+    graphId: z.ZodString;
+    revision: z.ZodNumber;
+    queryJson: z.ZodString;
+}, z.core.$strict>;
+export declare const NetworkQuery: z.ZodObject<{
+    kind: z.ZodEnum<{
+        ports: "ports";
+        relationships: "relationships";
+        nodes: "nodes";
+        circuits: "circuits";
+        connected: "connected";
+        upstream: "upstream";
+        downstream: "downstream";
+        nearestPort: "nearestPort";
+    }>;
+    node: z.ZodOptional<z.ZodString>;
+    pointMm: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    radiusMm: z.ZodOptional<z.ZodNumber>;
+    system: z.ZodOptional<z.ZodString>;
+    sizeMm: z.ZodOptional<z.ZodNumber>;
+    heightMm: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export type NetworkQuery = z.infer<typeof NetworkQuery>;
+export interface NetworkDiagnostic {
+    path: string;
+    message: string;
+}
+export interface NetworkValidation {
+    ok: boolean;
+    diagnostics: NetworkDiagnostic[];
+    nodeCount: number;
+}
+/** Durable node-to-scene mapping. Each node owns one component and its pinned generated recipe. */
+export declare const NetworkComponentBinding: z.ZodObject<{
+    nodeId: z.ZodString;
+    componentId: z.ZodString;
+    definitionId: z.ZodString;
+    definitionVersion: z.ZodNumber;
+}, z.core.$strict>;
+export type NetworkComponentBinding = z.infer<typeof NetworkComponentBinding>;
+export interface SavedNetworkGraph {
+    id: string;
+    domain: NetworkDomain;
+    revision: 1;
+    requestId: string;
+    document: NetworkGraphDocument;
+    components: NetworkComponentBinding[];
+}
+export interface NetworkCreateResult {
+    graphId: string;
+    revision: number;
+    components: NetworkComponentBinding[];
+    alreadyCreated: boolean;
+    /** Queue acceptance is not a durable database acknowledgement. */
+    saveStatus: "queued" | "existing";
+}
+export interface NetworkContextResult {
+    proposalId: string;
+    buildingId: string | null;
+    revision: string;
+    /** PG2's native serialization uses Snaptrude units (1 SU = 254 mm). */
+    topologyUnits: "SU";
+    topologyJson: string;
+    nextOffset: number | null;
+    total: number;
+    storeys: {
+        number: number;
+        elevationMm: number;
+    }[];
+    components: {
+        id: string;
+        type: string;
+        storey: number;
+        minMm: number[];
+        maxMm: number[];
+    }[];
+    /** Saved graph inventory, paged with topology/components. Use these IDs after reopening a project. */
+    networks: {
+        graphId: string;
+        domain: NetworkDomain;
+        revision: number;
+        label: string;
+        componentCount: number;
+    }[];
+}
+export interface NetworkQueryResult {
+    revision: number;
+    resultJson: string;
+    nextOffset: number | null;
+    total: number;
+}
+/** Shared transport only. Electrical and plumbing documents retain separate schemas and semantics. */
+export declare abstract class PluginDomainNetworkApi {
+    /** Read the active proposal's architectural context before authoring. Keep one revision across pages. */
+    abstract context(args?: z.input<typeof NetworkContextArgs>): PluginApiReturn<NetworkContextResult>;
+    /** Validate authored JSON, pinned families and recipe evaluation without placing or saving anything.
+     * This does not build kernel meshes or certify engineering/code compliance.
+     */
+    abstract validate(args: z.input<typeof NetworkValidateArgs>): PluginApiReturn<NetworkValidation>;
+    /** Construct each node on its authored storey, with one undo command and queued project persistence.
+     * Networks can span storeys. Reuse requestId on retry; components returns the durable node mapping.
+     * Coordinates are world millimetres, Y-up; rotations are degrees. No engineering rules are inferred.
+     * Throws for stale architecture, invalid references/geometry or conflicting retries.
+     */
+    abstract create(args: z.input<typeof NetworkCreateArgs>): PluginApiReturn<NetworkCreateResult>;
+    /** Read one saved graph in the active proposal; null on miss. IDs are durable, not worker handles. */
+    abstract get(args: z.input<typeof NetworkGetArgs>): PluginApiReturn<SavedNetworkGraph | null>;
+    /** Read bounded authored topology in graph revision. Crossings do not connect. No clash/compliance claims. */
+    abstract query(args: z.input<typeof NetworkQueryArgs>): PluginApiReturn<NetworkQueryResult>;
+}
+/** Electrical equipment, physical routes and logical circuits, constructed from agent-authored intent. */
+export declare abstract class PluginElectricalApi extends PluginDomainNetworkApi {
+}
+/** Plumbing equipment and routed pipe networks, constructed from agent-authored intent. */
+export declare abstract class PluginPlumbingApi extends PluginDomainNetworkApi {
+}
+//# sourceMappingURL=networks.d.ts.map

package/dist/api/design/networks.d.ts.map

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

package/dist/api/design/query/geometry/index.d.ts

@@ -13,8 +13,8 @@ import { ComponentHandle, BrepHandle, ContourHandle, CurveHandle } from "../../.
  * {@linkcode PluginDesignQueryGeometryApi.getCenterline} mints a
  * {@linkcode CurveHandle} for a wall's core curve.
  * {@linkcode PluginDesignQueryGeometryApi.getTriangulatedMeshes} is the
- * handle-free exception: it returns the triangulated render meshes as plain
- * world-space arrays.
+ * handle-free exception: it returns `{ meshes }` — the triangulated render
+ * meshes as plain world-space arrays, wrapped in an object, never bare.
  *
  * Returned handles are session-ephemeral and go stale on undo/redo/re-topologize
  * — re-fetch a fresh one after edits.
@@ -27,10 +27,26 @@ export declare abstract class PluginDesignQueryGeometryApi {
      * scene entity, as a reusable {@linkcode BrepHandle} for the
      * `core.geom.query.brep.*` reads.
      *
+     * **Frame.** By default the brep comes back in the component's own LOCAL frame
+     * (its vertices are relative to the mesh origin, exactly as stored). This is
+     * the long-standing default, and existing callers rely on it. Pass
+     * `{ frame: "world" }` to get the same solid placed where it sits in the
+     * scene (world coordinates, like
+     * `getBottomContour` / `getTriangulatedMeshes` and every `design.query.measure`
+     * read). Use `"world"` whenever the handle will be COMBINED with other scene
+     * geometry or committed back beside its source: booleans between two scene
+     * masses, `brepFromFillet` / `brepFromShell` / `brepFromOffset` /
+     * `brepFromChamfer` on a scene mass followed by `massFromBrep`, or comparing
+     * its vertices with a bounding box. A world-frame handle from a parametrically
+     * live mass also carries that mass's recipe, so an operation result keeps an
+     * editable record.
+     *
      * @param component - The scene component to read
-     * @returns The brep as a {@linkcode BrepHandle}, or `null` if the component has no brep geometry
+     * @param options - `frame`: `"local"` (default, mesh-local coordinates) or `"world"` (scene coordinates)
+     * @returns The brep as a {@linkcode BrepHandle}, or `null` if the component has no brep geometry — also `null` for a parametric family: read `design.family.getParameters({ component }).parts[].brep`
      *
      * @examplePrompt Get the 3D solid geometry of the selected wall
+     * @examplePrompt Round the top rim of this column and put it back where it is
      * @examplePrompt How many faces does this mass have?
      * @examplePrompt Inspect the mesh of this slab so I can look at its faces and edges
      * @examplePrompt Read the vertices of the selected column's geometry
@@ -41,9 +57,14 @@ export declare abstract class PluginDesignQueryGeometryApi {
      * if (brep) {
      *   const faces = await snaptrude.core.geom.query.brep.listFaces(brep)
      * }
+     *
+     * // Operate on a scene mass and commit the result where the mass sits:
+     * const placed = await snaptrude.design.query.geometry.getBrep(mass, { frame: "world" })
+     * const rounded = await snaptrude.core.geom.create.brepFromFillet(placed, edges, 0.2)
+     * await snaptrude.design.create.massFromBrep(rounded, "Rounded")
      * ```
      */
-    abstract getBrep(component: ComponentHandle): PluginApiReturn<BrepHandle | null>;
+    abstract getBrep(component: ComponentHandle, options?: PluginDesignQueryGeometryGetBrepOptions): PluginApiReturn<BrepHandle | null>;
     /**
      * Get the **bottom-face contour** of a component — the footprint outline (outer
      * profile + holes) of its lowest horizontal face, as a reusable
@@ -110,7 +131,8 @@ export declare abstract class PluginDesignQueryGeometryApi {
      * Get the **triangulated render meshes** of scene components as plain,
      * serializable arrays — flat world-space vertex `positions` (`[x0, y0, z0,
      * x1, …]`) and triangle `indices` (three per triangle), one record per
-     * requested component.
+     * requested component. The result is `{ meshes }`, not a bare array —
+     * destructure it before iterating.
      *
      * Unlike the other `geometry.*` reads this does NOT mint kernel handles — the
      * raw arrays cross the boundary directly, ready for export, custom analysis,
@@ -169,8 +191,14 @@ export declare abstract class PluginDesignQueryGeometryApi {
  * |---|---|---|
  * | `component` | {@linkcode ComponentHandle} | The scene component to read |
  */
+/** Options for {@linkcode PluginDesignQueryGeometryApi.getBrep}: `frame` defaults to `"local"`. */
+export type PluginDesignQueryGeometryGetBrepOptions = {
+    frame?: "local" | "world";
+};
+export declare const PluginDesignQueryGeometryGetBrepOptions: z.ZodType<PluginDesignQueryGeometryGetBrepOptions, PluginDesignQueryGeometryGetBrepOptions>;
 export declare const PluginDesignQueryGeometryGetBrepArgs: z.ZodObject<{
     component: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    options: z.ZodOptional<z.ZodType<PluginDesignQueryGeometryGetBrepOptions, PluginDesignQueryGeometryGetBrepOptions, z.core.$ZodTypeInternals<PluginDesignQueryGeometryGetBrepOptions, PluginDesignQueryGeometryGetBrepOptions>>>;
 }, z.core.$strip>;
 export type PluginDesignQueryGeometryGetBrepArgs = z.infer<typeof PluginDesignQueryGeometryGetBrepArgs>;
 /**

package/dist/api/design/query/geometry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/api/design/query/geometry/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EACL,eAAe,EACf,UAAU,EACV,aAAa,EACb,WAAW,EACZ,MAAM,qBAAqB,CAAA;AAE5B;;;;;;;;;;;;;;;;;GAiBG;AACH,8BAAsB,4BAA4B;;IAGhD;;;;;;;;;;;;;;;;;;;;;OAqBG;aACa,OAAO,CACrB,SAAS,EAAE,eAAe,GACzB,eAAe,CAAC,UAAU,GAAG,IAAI,CAAC;IAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;aACa,gBAAgB,CAC9B,SAAS,EAAE,eAAe,GACzB,eAAe,CAAC,aAAa,GAAG,IAAI,CAAC;IAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;aACa,aAAa,CAC3B,SAAS,EAAE,eAAe,GACzB,eAAe,CAAC,WAAW,GAAG,IAAI,CAAC;IAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqDG;aACa,qBAAqB,CACnC,UAAU,EAAE,eAAe,EAAE,EAC7B,OAAO,CAAC,EAAE,kDAAkD,CAAC,SAAS,CAAC,GACtE,eAAe,CAAC,oDAAoD,CAAC;CACzE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oCAAoC;;iBAE/C,CAAA;AAEF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,oCAAoC,CAC5C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,6CAA6C;;iBAExD,CAAA;AAEF,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,6CAA6C,CACrD,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0CAA0C;;iBAErD,CAAA;AAEF,MAAM,MAAM,0CAA0C,GAAG,CAAC,CAAC,KAAK,CAC9D,OAAO,0CAA0C,CAClD,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB;;;;;;iBAMjC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,kDAAkD;;;;;;iBAQ7D,CAAA;AAEF,MAAM,MAAM,kDAAkD,GAAG,CAAC,CAAC,KAAK,CACtE,OAAO,kDAAkD,CAC1D,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oDAAoD;;;;;;;;iBAE/D,CAAA;AAEF,MAAM,MAAM,oDAAoD,GAAG,CAAC,CAAC,KAAK,CACxE,OAAO,oDAAoD,CAC5D,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/api/design/query/geometry/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EACL,eAAe,EACf,UAAU,EACV,aAAa,EACb,WAAW,EACZ,MAAM,qBAAqB,CAAA;AAE5B;;;;;;;;;;;;;;;;;GAiBG;AACH,8BAAsB,4BAA4B;;IAGhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;aACa,OAAO,CACrB,SAAS,EAAE,eAAe,EAC1B,OAAO,CAAC,EAAE,uCAAuC,GAChD,eAAe,CAAC,UAAU,GAAG,IAAI,CAAC;IAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;aACa,gBAAgB,CAC9B,SAAS,EAAE,eAAe,GACzB,eAAe,CAAC,aAAa,GAAG,IAAI,CAAC;IAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;aACa,aAAa,CAC3B,SAAS,EAAE,eAAe,GACzB,eAAe,CAAC,WAAW,GAAG,IAAI,CAAC;IAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsDG;aACa,qBAAqB,CACnC,UAAU,EAAE,eAAe,EAAE,EAC7B,OAAO,CAAC,EAAE,kDAAkD,CAAC,SAAS,CAAC,GACtE,eAAe,CAAC,oDAAoD,CAAC;CACzE;AAED;;;;;;GAMG;AACH,mGAAmG;AACnG,MAAM,MAAM,uCAAuC,GAAG;IAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;CAAE,CAAA;AACnF,eAAO,MAAM,uCAAuC,EAAE,CAAC,CAAC,OAAO,CAC7D,uCAAuC,EACvC,uCAAuC,CACqB,CAAA;AAE9D,eAAO,MAAM,oCAAoC;;;iBAG/C,CAAA;AAEF,MAAM,MAAM,oCAAoC,GAAG,CAAC,CAAC,KAAK,CACxD,OAAO,oCAAoC,CAC5C,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,6CAA6C;;iBAExD,CAAA;AAEF,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,6CAA6C,CACrD,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0CAA0C;;iBAErD,CAAA;AAEF,MAAM,MAAM,0CAA0C,GAAG,CAAC,CAAC,KAAK,CAC9D,OAAO,0CAA0C,CAClD,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB;;;;;;iBAMjC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAE3E;;;;;;;;GAQG;AACH,eAAO,MAAM,kDAAkD;;;;;;iBAQ7D,CAAA;AAEF,MAAM,MAAM,kDAAkD,GAAG,CAAC,CAAC,KAAK,CACtE,OAAO,kDAAkD,CAC1D,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oDAAoD;;;;;;;;iBAE/D,CAAA;AAEF,MAAM,MAAM,oDAAoD,GAAG,CAAC,CAAC,KAAK,CACxE,OAAO,oDAAoD,CAC5D,CAAA"}

package/dist/api/design/query/grids.d.ts

@@ -36,7 +36,7 @@ export type PluginGridLineProps = z.infer<typeof PluginGridLineProps>;
  * | `overrides` | `Partial<`{@linkcode PluginGridLineProps}`>`? | This line's raw overrides, when any exist |
  */
 export declare const PluginGridLineRecord: z.ZodObject<{
-    curve: z.ZodUnion<readonly [z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"arc">, string>>]>;
+    curve: z.ZodUnion<readonly [z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"arc">, string>>, z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"spline">, string>>]>;
     tag: z.ZodString;
     visible: z.ZodBoolean;
     props: z.ZodObject<{
@@ -84,7 +84,7 @@ export declare const PluginGridWingRecord: z.ZodObject<{
         max: z.ZodNumber;
     }, z.core.$strip>>;
     lines: z.ZodArray<z.ZodObject<{
-        curve: z.ZodUnion<readonly [z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"arc">, string>>]>;
+        curve: z.ZodUnion<readonly [z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"arc">, string>>, z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"spline">, string>>]>;
         tag: z.ZodString;
         visible: z.ZodBoolean;
         props: z.ZodObject<{
@@ -192,7 +192,7 @@ export declare const PluginGridGetResult: z.ZodObject<{
             max: z.ZodNumber;
         }, z.core.$strip>>;
         lines: z.ZodArray<z.ZodObject<{
-            curve: z.ZodUnion<readonly [z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"arc">, string>>]>;
+            curve: z.ZodUnion<readonly [z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"line">, string>>, z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"arc">, string>>, z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../../..").Handle<"spline">, string>>]>;
             tag: z.ZodString;
             visible: z.ZodBoolean;
             props: z.ZodObject<{