@snaptrude/plugin-core 0.9.6 → 0.9.8

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

@@ -0,0 +1,427 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../types";
+import { ComponentHandle, DimensionHandle, Vec3Handle } from "../../handles";
+/**
+ * Dimension lines (Measuring Tape) — the measurement annotations the Measuring
+ * Tape tool leaves in the 3D scene, NOT an entity's width/height/depth
+ * properties (for those see `design.windows.getDimensions`,
+ * `design.create.staircase`'s `dimensions`, or `design.query.measure`).
+ *
+ * A dimension line is a scene object: two endpoints anchored to the geometry
+ * they were measured on, an offset that pushes the drawn line clear of the
+ * span, and a label showing the distance in the project's units. Because the
+ * endpoints are anchored, the line follows its host when the host is moved,
+ * edited, or resized, and it is removed with the host when the host is deleted.
+ * Dimension lines are storey-scoped, render in both plan and 3D, and are drawn
+ * into Present-mode sheets (style them with
+ * `presentation.placedViews.updateStyles(shapeId, "Dimension", …)`).
+ *
+ * **Units.** Every length here — `offset` and the record's `length` — is in
+ * **Babylon units** (BU), the engine's storage unit: 1 BU = 10 in = 0.254 m.
+ * Convert with `core.units.convert(value, from, await core.units.getBabylonType())`.
+ *
+ * **Offset convention.** `options.offset` is a **signed** distance in BU:
+ * positive pushes the drawn line to the **left** of the `from` → `to`
+ * direction in plan (`cross(up, direction)`), negative to the right. It
+ * defaults to `3.937` BU (1 m). The placement mode is always `"across"` (the
+ * tape tool's perpendicular mode), which re-perpendicularises when the host
+ * geometry is edited.
+ *
+ * Every mutator here (`create`, `delete`, `hide`, `show`) commits through the
+ * engine's command manager, so each call is a single undo entry, is autosaved,
+ * and replays to collaborators.
+ *
+ * Accessed via `snaptrude.design.dimensions`.
+ */
+export declare abstract class PluginDesignDimensionsApi {
+    constructor();
+    /**
+     * Draw one dimension line between two world points, anchored to a component.
+     *
+     * `anchor` is **required**: the endpoints are stored relative to the anchor's
+     * mesh, and only component-anchored dimension lines survive a reload. A
+     * free-point dimension anchors to a scene helper mesh whose id is not stable
+     * across reloads, so it is dropped or corrupted when the project is reopened
+     * — the host therefore rejects a non-component anchor rather than writing a
+     * record that silently disappears. Pass `options.anchorTo` to anchor the
+     * second endpoint to a different component (it defaults to `anchor`).
+     *
+     * The dimension is created flat (never plan-projected) so the same call
+     * produces the same record whatever the current camera; it still draws in
+     * plan.
+     *
+     * @param from - World-space first endpoint.
+     * @param to - World-space second endpoint.
+     * @param anchor - The component the first endpoint is anchored to (required).
+     * @param options - `anchorTo` (component for the second endpoint; defaults to
+     *   `anchor`), `offset` (signed perpendicular offset in Babylon units,
+     *   positive = left of the `from` → `to` direction in plan; default `3.937`
+     *   BU = 1 m).
+     * @returns The new dimension line's {@linkcode DimensionHandle}.
+     * @throws `VALIDATION` for malformed arguments or a degenerate span (`from`
+     *   and `to` closer than the engine's minimum); `HANDLE_INVALID` for an
+     *   unknown `anchor` / `anchorTo`; `PRECONDITION_FAILED` when the anchor is
+     *   outside the active proposal or the editor is not mounted;
+     *   `METHOD_NOT_PERMITTED` when plugin writes are disabled.
+     *
+     * @examplePrompt Dimension every wall on level 2
+     * @examplePrompt Add a dimension line along this wall
+     * @examplePrompt Measure the width of this room and label it on the plan
+     *
+     * # Example
+     * ```ts
+     * const { design, core } = snaptrude
+     * const v = core.math.vec3
+     * const curve = core.geom.query.curve
+     * for (const wall of await design.query.listWalls({ storeys: [2] })) {
+     *   const cl = await design.query.geometry.getCenterline(wall)
+     *   if (!cl) continue
+     *   const a = await curve.getStartPoint(cl)
+     *   const b = await curve.getEndPoint(cl)
+     *   await design.dimensions.create(
+     *     await v.new(a.x, a.y, a.z),
+     *     await v.new(b.x, b.y, b.z),
+     *     wall,
+     *   )
+     * }
+     * ```
+     */
+    abstract create(from: Vec3Handle, to: Vec3Handle, anchor: ComponentHandle, options?: {
+        anchorTo?: ComponentHandle;
+        offset?: number;
+    }): PluginApiReturn<DimensionHandle>;
+    /**
+     * List the dimension lines in the project as full records.
+     *
+     * Filters combine with AND. `storeys` keeps only the dimensions on those
+     * storey numbers, `anchors` only the ones anchored to those components
+     * (matching either endpoint, and matching an instanced anchor's source mesh
+     * too), `isHidden` only the ones whose user Hide flag equals the value given.
+     *
+     * Dimension lines drawn by the Measuring Tape onto a scene helper mesh rather
+     * than a component come back with `anchor: null` and are not proposal-scoped.
+     *
+     * @param options - `storeys`, `anchors`, `isHidden` filters (all optional,
+     *   ANDed).
+     * @returns The matching {@linkcode PluginDimensionLine} records (`[]` when
+     *   nothing matches).
+     * @throws `VALIDATION` for malformed filters; `HANDLE_INVALID` for an unknown
+     *   handle in `anchors`.
+     *
+     * @examplePrompt List all the dimension lines in this model
+     * @examplePrompt Which dimensions are on level 3?
+     * @examplePrompt Flag any dimension line shorter than 600 mm
+     *
+     * @performance Array read — one host round-trip returns every record. Filter
+     *   in one call rather than calling `get` per dimension.
+     *
+     * # Example
+     * ```ts
+     * const units = snaptrude.core.units
+     * const min = await units.convert(600, "millimeters", await units.getBabylonType())
+     * const short = (await snaptrude.design.dimensions.list()).filter(
+     *   (d) => d.length < min,
+     * )
+     * console.log(short.map((d) => `${d.label} on storey ${d.storey}`))
+     * ```
+     */
+    abstract list(options?: {
+        storeys?: number[];
+        anchors?: ComponentHandle[];
+        isHidden?: boolean;
+    }): PluginApiReturn<PluginDimensionLine[]>;
+    /**
+     * Read one dimension line by handle.
+     *
+     * Returns `null` — rather than throwing — when the dimension no longer
+     * exists, so a handle kept across a delete or an undo can be polled safely.
+     *
+     * @param dimension - The dimension line to read.
+     * @returns Its {@linkcode PluginDimensionLine} record, or `null` if it is
+     *   gone.
+     * @throws `VALIDATION` if `dimension` is not a non-empty id string.
+     *
+     * @examplePrompt Read the dimension line I just created
+     * @examplePrompt How long is this dimension and what does its label say?
+     * @examplePrompt Check whether that dimension line still exists
+     *
+     * # Example
+     * ```ts
+     * const dim = await snaptrude.design.dimensions.get(handle)
+     * if (dim) console.log(dim.label, dim.length, dim.storey)
+     * ```
+     */
+    abstract get(dimension: DimensionHandle): PluginApiReturn<PluginDimensionLine | null>;
+    /**
+     * Delete dimension lines — the same hard removal as selecting them and
+     * pressing Delete. Undoable as a **single** entry for the whole batch.
+     *
+     * Deleted handles are stale afterwards: {@linkcode
+     * PluginDesignDimensionsApi.get} returns `null` for them and the other
+     * mutators throw `HANDLE_INVALID`.
+     *
+     * @param dimensions - The dimension lines to delete (at least one — an empty
+     *   array is a caller error, not a no-op).
+     * @returns The dimensions that were deleted, as
+     *   {@linkcode PluginDimensionsChangeResult}.
+     * @throws `VALIDATION` for an empty or malformed array; `HANDLE_INVALID` if
+     *   any handle is unknown (the whole call rejects before anything is
+     *   deleted); `PRECONDITION_FAILED` if any dimension's anchor is outside the
+     *   active proposal; `METHOD_NOT_PERMITTED` when plugin writes are disabled.
+     *
+     * @examplePrompt Remove all dimension lines
+     * @examplePrompt Delete the dimensions on this wall
+     * @examplePrompt Clear the measurements I added to level 2
+     *
+     * @performance Array API — pass the whole set in one call (one host
+     *   round-trip, one undo entry). Never loop this per dimension.
+     *
+     * # Example
+     * ```ts
+     * const dims = snaptrude.design.dimensions
+     * const onWall = await dims.list({ anchors: [wall] })
+     * if (onWall.length > 0) await dims.delete(onWall.map((d) => d.id))
+     * ```
+     */
+    abstract delete(dimensions: DimensionHandle[]): PluginApiReturn<PluginDimensionsChangeResult>;
+    /**
+     * Hide dimension lines from the viewport — the same as the right-click "Hide"
+     * action (it sets the user Hide flag, `isHidden`). Undoable. Already-hidden
+     * dimensions are skipped and are not reported in `affected`.
+     *
+     * @param dimensions - The dimension lines to hide.
+     * @returns The dimensions actually hidden, as
+     *   {@linkcode PluginDimensionsChangeResult} — already-hidden inputs are
+     *   omitted, so `affected` can be shorter than the input.
+     * @throws `VALIDATION` for a malformed array; `HANDLE_INVALID` if any handle
+     *   is unknown; `PRECONDITION_FAILED` if any dimension's anchor is outside
+     *   the active proposal; `METHOD_NOT_PERMITTED` when plugin writes are
+     *   disabled.
+     *
+     * @examplePrompt Hide the dimensions on this storey
+     * @examplePrompt Hide every dimension line while I present
+     * @examplePrompt Temporarily hide the measurements on level 3
+     *
+     * @performance Array API — one host round-trip and one undo entry for the
+     *   whole set.
+     *
+     * # Example
+     * ```ts
+     * const dims = snaptrude.design.dimensions
+     * const onLevel3 = await dims.list({ storeys: [3] })
+     * const { affected } = await dims.hide(onLevel3.map((d) => d.id))
+     * ```
+     */
+    abstract hide(dimensions: DimensionHandle[]): PluginApiReturn<PluginDimensionsChangeResult>;
+    /**
+     * Reveal hidden dimension lines — clear the user Hide flag, the inverse of
+     * {@linkcode PluginDesignDimensionsApi.hide}. Undoable. Already-visible
+     * dimensions are skipped and are not reported in `affected`.
+     *
+     * Clearing the flag does not guarantee the dimension is on screen: a
+     * dimension whose anchor component is itself hidden stays off screen with
+     * `isHidden: false` and `isVisible: false`.
+     *
+     * @param dimensions - The dimension lines to reveal.
+     * @returns The dimensions actually revealed, as
+     *   {@linkcode PluginDimensionsChangeResult} — already-visible inputs are
+     *   omitted, so `affected` can be shorter than the input.
+     * @throws `VALIDATION` for a malformed array; `HANDLE_INVALID` if any handle
+     *   is unknown; `PRECONDITION_FAILED` if any dimension's anchor is outside
+     *   the active proposal; `METHOD_NOT_PERMITTED` when plugin writes are
+     *   disabled.
+     *
+     * @examplePrompt Show the dimension lines again
+     * @examplePrompt Unhide all the hidden dimensions
+     * @examplePrompt Bring back the measurements I hid on this storey
+     *
+     * @performance Array API — one host round-trip and one undo entry for the
+     *   whole set.
+     *
+     * # Example
+     * ```ts
+     * const dims = snaptrude.design.dimensions
+     * const hidden = await dims.list({ isHidden: true })
+     * await dims.show(hidden.map((d) => d.id))
+     * ```
+     */
+    abstract show(dimensions: DimensionHandle[]): PluginApiReturn<PluginDimensionsChangeResult>;
+}
+/**
+ * How a dimension line's drawn offset is constrained.
+ *
+ * - `"across"` — perpendicular to the span (the tape tool's default, and what
+ *   every plugin-created dimension uses); re-perpendicularises when the host
+ *   geometry is edited.
+ * - `"x"` / `"y"` / `"z"` — the offset is locked to that world axis.
+ * - `"none"` — no placement mode recorded (a plain world-space offset).
+ */
+export declare const PluginDimensionPlacement: z.ZodEnum<{
+    x: "x";
+    y: "y";
+    z: "z";
+    across: "across";
+    none: "none";
+}>;
+export type PluginDimensionPlacement = z.infer<typeof PluginDimensionPlacement>;
+/**
+ * One dimension line (Measuring Tape annotation). Lengths are in **Babylon
+ * units** (1 BU = 0.254 m — convert with `core.units.convert`).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `id` | {@linkcode DimensionHandle} | The dimension line's handle |
+ * | `from` | {@linkcode Vec3Components} | Live world position of the first endpoint |
+ * | `to` | {@linkcode Vec3Components} | Live world position of the second endpoint |
+ * | `length` | `number` | Straight-line distance between `from` and `to`, in Babylon units |
+ * | `label` | `string` | The text drawn on the canvas, in the project's units (a bare number for metric/inch projects, `27' 7"` style for feet-inches). For a span whose x, y and z all differ the drawn line is the plan projection, so `label` reads the horizontal distance while `length` is the true 3D one |
+ * | `offset` | {@linkcode Vec3Components} | World vector from the measured span to the drawn line |
+ * | `placement` | {@linkcode PluginDimensionPlacement} | How that offset is constrained |
+ * | `anchor` | {@linkcode ComponentHandle}` \| null` | Component the first endpoint is anchored to; `null` for a free point or a non-component host mesh |
+ * | `anchorTo` | {@linkcode ComponentHandle}` \| null` | Component the second endpoint is anchored to; equals `anchor` when both endpoints share a host |
+ * | `storey` | `number` | Storey the dimension belongs to |
+ * | `buildingId` | `string \| null` | Building it belongs to, when it has one |
+ * | `isHidden` | `boolean` | The user Hide flag (what `hide` / `show` toggle) |
+ * | `isVisible` | `boolean` | Whether it is actually drawn — `false` when hidden, and also when an anchor component is hidden |
+ * | `isPlanProjected` | `boolean` | Whether it is drawn flattened onto the storey base (Measuring Tape dimensions drawn in 2D are; plugin-created ones never are) |
+ */
+export declare const PluginDimensionLine: z.ZodObject<{
+    id: z.ZodPipe<z.ZodString, z.ZodTransform<DimensionHandle, string>>;
+    from: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    to: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    length: z.ZodNumber;
+    label: z.ZodString;
+    offset: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>;
+    placement: z.ZodEnum<{
+        x: "x";
+        y: "y";
+        z: "z";
+        across: "across";
+        none: "none";
+    }>;
+    anchor: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+    anchorTo: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+    storey: z.ZodNumber;
+    buildingId: z.ZodNullable<z.ZodString>;
+    isHidden: z.ZodBoolean;
+    isVisible: z.ZodBoolean;
+    isPlanProjected: z.ZodBoolean;
+}, z.core.$strip>;
+export type PluginDimensionLine = z.infer<typeof PluginDimensionLine>;
+/**
+ * Result of every `design.dimensions` mutation that takes a batch
+ * ({@linkcode PluginDesignDimensionsApi.delete} /
+ * {@linkcode PluginDesignDimensionsApi.hide} /
+ * {@linkcode PluginDesignDimensionsApi.show}) — the dimensions actually
+ * affected. `hide` / `show` skip dimensions already in the target state, so
+ * `affected` can be shorter than the input; `delete` echoes the whole batch.
+ * Failures throw (the RPC rejects); there is no `Result<>` monad in the SDK.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `affected` | {@linkcode DimensionHandle}`[]` | The dimension lines the call changed |
+ */
+export declare const PluginDimensionsChangeResult: z.ZodObject<{
+    affected: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<DimensionHandle, string>>>;
+}, z.core.$strip>;
+export type PluginDimensionsChangeResult = z.infer<typeof PluginDimensionsChangeResult>;
+/**
+ * Arguments for {@linkcode PluginDesignDimensionsApi.create} (options
+ * flattened).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `from` | {@linkcode Vec3Handle} | World-space first endpoint |
+ * | `to` | {@linkcode Vec3Handle} | World-space second endpoint |
+ * | `anchor` | {@linkcode ComponentHandle} | Component the first endpoint anchors to (required — free-point dimensions do not survive a reload) |
+ * | `anchorTo` | {@linkcode ComponentHandle}? | Component for the second endpoint (default: `anchor`) |
+ * | `offset` | `number`? | Signed perpendicular offset in Babylon units, positive = left of the `from` → `to` direction in plan (default `3.937` BU = 1 m) |
+ *
+ * TRANSPORT: positional args — validated host-side as this object.
+ */
+export declare const PluginDesignDimensionsCreateArgs: z.ZodObject<{
+    from: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../..").Handle<"vec3">, string>>;
+    to: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<import("../..").Handle<"vec3">, string>>;
+    anchor: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    anchorTo: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PluginDesignDimensionsCreateArgs = z.infer<typeof PluginDesignDimensionsCreateArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignDimensionsApi.list} (options flattened).
+ * Filters combine with AND; omitting all of them lists every dimension line.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `storeys` | `number[]`? | Only dimensions on these storey numbers |
+ * | `anchors` | {@linkcode ComponentHandle}`[]`? | Only dimensions anchored to these components (either endpoint) |
+ * | `isHidden` | `boolean`? | user-hidden flag === |
+ */
+export declare const PluginDesignDimensionsListArgs: z.ZodObject<{
+    storeys: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    anchors: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>>;
+    isHidden: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type PluginDesignDimensionsListArgs = z.infer<typeof PluginDesignDimensionsListArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignDimensionsApi.get}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `dimension` | {@linkcode DimensionHandle} | The dimension line to read |
+ */
+export declare const PluginDesignDimensionsGetArgs: z.ZodObject<{
+    dimension: z.ZodPipe<z.ZodString, z.ZodTransform<DimensionHandle, string>>;
+}, z.core.$strip>;
+export type PluginDesignDimensionsGetArgs = z.infer<typeof PluginDesignDimensionsGetArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignDimensionsApi.delete}.
+ *
+ * `.min(1)` mirrors {@linkcode PluginDesignDeleteEntitiesArgs}: an empty delete
+ * is a caller error, not a no-op.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `dimensions` | {@linkcode DimensionHandle}`[]` | Dimension lines to delete. Unknown handles reject the whole call (fail-fast). |
+ */
+export declare const PluginDesignDimensionsDeleteArgs: z.ZodObject<{
+    dimensions: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<DimensionHandle, string>>>;
+}, z.core.$strip>;
+export type PluginDesignDimensionsDeleteArgs = z.infer<typeof PluginDesignDimensionsDeleteArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignDimensionsApi.hide}. An empty array is
+ * allowed and is a no-op (mirroring {@linkcode PluginDesignVisibilityHideArgs}).
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `dimensions` | {@linkcode DimensionHandle}`[]` | Dimension lines to hide |
+ */
+export declare const PluginDesignDimensionsHideArgs: z.ZodObject<{
+    dimensions: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<DimensionHandle, string>>>;
+}, z.core.$strip>;
+export type PluginDesignDimensionsHideArgs = z.infer<typeof PluginDesignDimensionsHideArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignDimensionsApi.show}. An empty array is
+ * allowed and is a no-op.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `dimensions` | {@linkcode DimensionHandle}`[]` | Dimension lines to reveal |
+ */
+export declare const PluginDesignDimensionsShowArgs: z.ZodObject<{
+    dimensions: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<DimensionHandle, string>>>;
+}, z.core.$strip>;
+export type PluginDesignDimensionsShowArgs = z.infer<typeof PluginDesignDimensionsShowArgs>;
+//# sourceMappingURL=dimensions.d.ts.map

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

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

package/dist/api/design/doors/index.d.ts

@@ -7,9 +7,11 @@ import { PluginDesignChangeResult } from "../lock";
  * `design.create.door`; generic reads (`listDoors`/`getHost`/`getProperties`) live at
  * `design.query.*`. Door targets are {@linkcode ComponentHandle}s.
  *
- * `getSwingDirection` is a DERIVED read (no persisted field) — computed from the door
- * mesh reflection state. `mirror` reflects the door across an axis (undoable, one
- * command); `setType` is intentionally absent (the engine has no in-place re-type —
+ * `getSwingDirection` is a DERIVED read (no persisted field) — computed from the placed
+ * mesh's orientation: stand on the side the door swings open to, facing it; `'left'`
+ * when the hinged jamb is on your left. `mirror` reflects the door about one of its own
+ * axes (undoable, one command): `'x'` flips the swing side, `'z'` swaps the hinged jamb;
+ * `setType` is intentionally absent (the engine has no in-place re-type —
  * it would require delete+recreate).
  *
  * The **catalog** reads (`listCatalogGroups`/`listCatalog`/`getCatalogItem`/`exists`)
@@ -144,9 +146,11 @@ export declare abstract class PluginDesignDoorsApi {
      */
     abstract getSupportFloor(door: ComponentHandle): PluginApiReturn<ComponentHandle | null>;
     /**
-     * Get a door's swing (hinge) handedness — whether it opens as a left-hand or
-     * right-hand door. Derived from the door mesh's reflection state, not a
-     * persisted field.
+     * Get a door's swing (hinge) handedness. Stand on the side the door swings
+     * open to, facing the door: `'left'` when the hinged jamb is on your left,
+     * `'right'` when it is on your right. Derived from the placed mesh's
+     * orientation (the same reflection `mirror` and the `hinge` placement option
+     * apply), not a persisted field.
      *
      * @param door The door to query
      * @returns `'left'` / `'right'`, or `null` if indeterminate
@@ -165,11 +169,13 @@ export declare abstract class PluginDesignDoorsApi {
      */
     abstract getSwingDirection(door: ComponentHandle): PluginApiReturn<"left" | "right" | null>;
     /**
-     * Mirror a door across an axis, flipping its swing so it opens from the
-     * other side. Undoable as a single command.
+     * Mirror a door about its own axes. `'x'` (default) flips the swing side —
+     * the door opens to the other side of the wall; `'z'` swaps the hinged jamb
+     * (left-hand ↔ right-hand, same swing side); `'y'` turns it upside down.
+     * Undoable as a single command.
      *
      * @param door The door to mirror
-     * @param axis Reflection axis (optional; default `'x'` — the swing-flip axis)
+     * @param axis Reflection axis (optional; default `'x'` — the swing-flip axis; `'z'` — the hinge-jamb axis)
      * @returns The affected door(s)
      *
      * @examplePrompt Flip this door's swing
@@ -180,10 +186,11 @@ export declare abstract class PluginDesignDoorsApi {
      *
      * # Example
      * ```ts
-     * // Flip the selected door's swing — axis defaults to "x" (the swing-flip
-     * // axis); pass "y" or "z" to reflect across a different axis
+     * // Flip the selected door's swing side — axis defaults to "x"
      * const [door] = await snaptrude.design.query.listDoors({ isSelected: true })
      * const { affected } = await snaptrude.design.doors.mirror(door)
+     * // …or swap the hinged jamb instead (keeps the swing side)
+     * await snaptrude.design.doors.mirror(door, "z")
      * ```
      */
     abstract mirror(door: ComponentHandle, axis?: PluginMirrorAxis): PluginApiReturn<PluginDesignChangeResult>;
@@ -334,7 +341,7 @@ export declare const PluginDoorDimensions: z.ZodObject<{
     thickness: z.ZodNumber;
 }, z.core.$strip>;
 export type PluginDoorDimensions = z.infer<typeof PluginDoorDimensions>;
-/** Mirror axis — tokens mirror the engine `FlipDirection` verbatim (§6.1). */
+/** Mirror axis — tokens mirror the engine `FlipDirection` verbatim: `'x'` flips the swing side, `'z'` swaps the hinged jamb, `'y'` turns the door upside down. */
 export declare const PluginMirrorAxis: z.ZodEnum<{
     x: "x";
     y: "y";
@@ -347,7 +354,7 @@ export type PluginMirrorAxis = z.infer<typeof PluginMirrorAxis>;
  * | Property | Type | Description |
  * |---|---|---|
  * | `door` | {@linkcode ComponentHandle} | The door to mirror |
- * | `axis` | {@linkcode PluginMirrorAxis} | Reflection axis (optional; default `'x'` — the swing-flip axis) |
+ * | `axis` | {@linkcode PluginMirrorAxis} | Reflection axis (optional; default `'x'` — the swing-flip axis; `'z'` — the hinge-jamb axis) |
  */
 export declare const PluginDesignDoorMirrorArgs: z.ZodObject<{
     door: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;

package/dist/api/design/doors/index.d.ts.map

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

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

@@ -14,6 +14,7 @@ import { PluginDesignTransformApi } from "./transform";
 import { PluginDesignEditApi } from "./edit";
 import { PluginDesignUpdateApi } from "./update";
 import { PluginDesignVisibilityApi } from "./visibility";
+import { PluginDesignDimensionsApi } from "./dimensions";
 import { PluginDesignTypesApi } from "./types";
 import { PluginDesignChangeResult } from "./lock";
 /**
@@ -29,6 +30,7 @@ import { PluginDesignChangeResult } from "./lock";
  * - {@linkcode PluginDesignApi.erase} — plan-level adjacency-edge erase (NOT hard delete)
  * - {@linkcode PluginDesignApi.delete} — hard entity removal
  * - {@linkcode PluginDesignApi.visibility} — hide / isolate / reveal entities
+ * - {@linkcode PluginDesignApi.dimensions} — dimension lines (Measuring Tape): create / list / delete / hide
  * - {@linkcode PluginDesignApi.types} — read-only building type / assembly reference
  * - {@linkcode PluginDesignApi.lock} / {@linkcode PluginDesignApi.unlock} / {@linkcode PluginDesignApi.isLocked} / {@linkcode PluginDesignApi.listLocked} — lock state (top-level design verbs, §2A.1)
  * - {@linkcode PluginDesignApi.lockArea} / {@linkcode PluginDesignApi.unlockArea} / {@linkcode PluginDesignApi.isAreaLocked} / {@linkcode PluginDesignApi.listAreaLocked} — footprint-area lock for Room/Department spaces
@@ -64,6 +66,8 @@ export declare abstract class PluginDesignApi {
     abstract update: PluginDesignUpdateApi;
     /** Hide / isolate / reveal entities. See {@linkcode PluginDesignVisibilityApi}. */
     abstract visibility: PluginDesignVisibilityApi;
+    /** Dimension lines (Measuring Tape). See {@linkcode PluginDesignDimensionsApi}. */
+    abstract dimensions: PluginDesignDimensionsApi;
     /** Read-only building type / assembly reference. See {@linkcode PluginDesignTypesApi}. */
     abstract types: PluginDesignTypesApi;
     /**
@@ -242,5 +246,6 @@ export * from "./transform";
 export * from "./edit";
 export * from "./update";
 export * from "./visibility";
+export * from "./dimensions";
 export * from "./types";
 //# sourceMappingURL=index.d.ts.map

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

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

package/dist/api/presentation/annotate.d.ts

@@ -301,8 +301,8 @@ export type PluginAnnotateGeoKind = z.infer<typeof PluginAnnotateGeoKind>;
 /** Fill style for geo shapes (the same fills as the Present-mode style panel). */
 export declare const PluginAnnotateFill: z.ZodEnum<{
     pattern: "pattern";
-    solid: "solid";
     none: "none";
+    solid: "solid";
     semi: "semi";
 }>;
 export type PluginAnnotateFill = z.infer<typeof PluginAnnotateFill>;
@@ -445,8 +445,8 @@ export declare const PluginPresentationAnnotateShapeArgs: z.ZodObject<{
     }>>;
     fill: z.ZodOptional<z.ZodEnum<{
         pattern: "pattern";
-        solid: "solid";
         none: "none";
+        solid: "solid";
         semi: "semi";
     }>>;
 }, z.core.$strip>;

package/dist/api/presentation/shapes.d.ts

@@ -271,8 +271,8 @@ export declare const PluginPresentationShapeSpec: z.ZodDiscriminatedUnion<[z.Zod
     }>>;
     fill: z.ZodOptional<z.ZodEnum<{
         pattern: "pattern";
-        solid: "solid";
         none: "none";
+        solid: "solid";
         semi: "semi";
     }>>;
 }, z.core.$strip>], "type">;
@@ -426,8 +426,8 @@ export declare const PluginPresentationShapesUpsertArgs: z.ZodObject<{
         }>>;
         fill: z.ZodOptional<z.ZodEnum<{
             pattern: "pattern";
-            solid: "solid";
             none: "none";
+            solid: "solid";
             semi: "semi";
         }>>;
     }, z.core.$strip>], "type">;

package/dist/handles.d.ts

@@ -93,6 +93,18 @@ export type UnderlayHandle = EntityId<"underlay">;
  * Returned by `core.io.import.terrain`.
  */
 export type TerrainHandle = EntityId<"terrain">;
+/**
+ * A **dimension line** — one measurement annotation left behind by the Measuring
+ * Tape tool (NOT a width/height/depth property; see `design.dimensions`).
+ * Entity-style: the token IS the raw engine dimension id (`dim_…`), resolved live
+ * host-side from the dimension-line registry (`getDimensionLineMap()`) — not via
+ * `ComponentUtility.FindComponentById`, which does not index dimension lines (a
+ * dimension line is not a Component). No arena, no quota, stable across
+ * undo/redo and across reloads (the record persists with the project). Returned
+ * by `design.dimensions.create` and consumed by every other
+ * `design.dimensions.*` method.
+ */
+export type DimensionHandle = EntityId<"dimension">;
 /**
  * A handle to an **asynchronous import job** (today: a DWG → Forge conversion, which
  * can take minutes). Returned immediately by `core.io.import.dwg`; poll it via
@@ -173,6 +185,13 @@ export declare const MaterialHandle: z.ZodPipe<z.ZodString, z.ZodTransform<Mater
 export declare const UnderlayHandle: z.ZodPipe<z.ZodString, z.ZodTransform<UnderlayHandle, string>>;
 export declare const TerrainHandle: z.ZodPipe<z.ZodString, z.ZodTransform<TerrainHandle, string>>;
 export declare const ImportJobHandle: z.ZodPipe<z.ZodString, z.ZodTransform<ImportJobHandle, string>>;
+/**
+ * {@linkcode DimensionHandle} is an entity-style handle — the raw `dim_…` engine
+ * id, validated only as a non-empty string (no `"<kind>_"` prefix enforcement),
+ * resolved live host-side against the dimension-line registry (existence
+ * enforced there, as `HANDLE_INVALID`).
+ */
+export declare const DimensionHandle: z.ZodPipe<z.ZodString, z.ZodTransform<DimensionHandle, string>>;
 export declare const Vec3Handle: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<Handle<"vec3">, string>>;
 export declare const QuatHandle: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<Handle<"quat">, string>>;
 export declare const LineHandle: z.ZodPipe<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodString>, z.ZodTransform<Handle<"line">, string>>;