@snaptrude/plugin-core 0.3.0 → 0.6.0

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

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

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

@@ -0,0 +1,63 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../../types";
+import { ComponentHandle } from "../../../handles";
+import { PluginDesignChangeResult } from "../lock";
+/**
+ * Arguments for {@linkcode PluginDesignDeleteApi.entities}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `components` | {@linkcode ComponentHandle}`[]` | Entities to delete. Unknown/forged handles reject the whole call (fail-fast). |
+ *
+ * `.min(1)` is deliberately stricter than the shipped `PluginDesignLockArgs`
+ * (which allows an empty array) — an empty delete is a caller error, not a no-op.
+ *
+ * TRANSPORT: positional args — validated host-side as `{ components }`.
+ */
+export declare const PluginDesignDeleteEntitiesArgs: z.ZodObject<{
+    components: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+}, z.core.$strip>;
+export type PluginDesignDeleteEntitiesArgs = z.infer<typeof PluginDesignDeleteEntitiesArgs>;
+/**
+ * `snaptrude.design.delete.*` — **hard removal** of scene BIM entities.
+ *
+ * This is hard entity delete — distinct from `design.erase.edge` (a plan-level
+ * adjacency-edge topology op) and `design.boolean.subtract` (a CSG geometry
+ * delete). The constitution forbids `erase`/`clear`/`remove` as synonyms for
+ * `delete`; these are three separate operations.
+ *
+ * TRANSPORT: positional args per method.
+ */
+export declare abstract class PluginDesignDeleteApi {
+    constructor();
+    /**
+     * Delete one or more entities. Generic hard delete (backed by the same batched,
+     * undoable path as `entity.space.delete`). Cascade is opinionated by the engine:
+     * children are removed and linked-list neighbours are fixed up — not caller-tunable
+     * in v1. Undoable — commits as a **single** undo entry.
+     *
+     * @param components - Entities to delete. Unknown/forged handles reject the whole call (fail-fast).
+     * @returns The entities that were deleted, as {@linkcode ComponentHandle}`[]`
+     *   (echoed host-side from the resolved+deleted set — the engine returns no ids).
+     *   Deleted handles are **stale** afterwards: re-resolving one throws `HANDLE_INVALID`.
+     * @throws If any supplied handle is unknown/forged (`HANDLE_INVALID`) — the whole
+     *   call rejects before anything is deleted (all-or-nothing resolution).
+     *
+     * @examplePrompt Delete the selected objects
+     * @examplePrompt Remove these walls from the model
+     * @examplePrompt Get rid of this mass entirely
+     * @examplePrompt Delete all the furniture I picked
+     * @examplePrompt Remove the door and window I just created
+     *
+     * # Example
+     * ```ts
+     * // Hard-delete every furniture item on storey 2 (a single undo entry)
+     * const furniture = await snaptrude.design.query.listFurniture({ storeys: [2] })
+     * if (furniture.length > 0) {
+     *   const { affected } = await snaptrude.design.delete.entities(furniture)
+     * }
+     * ```
+     */
+    abstract entities(components: ComponentHandle[]): PluginApiReturn<PluginDesignChangeResult>;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/design/delete/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAElD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,8BAA8B;;iBAEzC,CAAA;AACF,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAA;AAE3F;;;;;;;;;GASG;AACH,8BAAsB,qBAAqB;;IAGzC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;aACa,QAAQ,CACtB,UAAU,EAAE,eAAe,EAAE,GAC5B,eAAe,CAAC,wBAAwB,CAAC;CAC7C"}

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

@@ -0,0 +1,268 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../../types";
+import { ComponentHandle } from "../../../handles";
+import { PluginDesignChangeResult } from "../lock";
+/**
+ * `snaptrude.design.doors` — door-specific reads + edits. Creation lives at
+ * `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 —
+ * it would require delete+recreate).
+ */
+export declare abstract class PluginDesignDoorsApi {
+    constructor();
+    /**
+     * Get the type name of a door — the label that identifies which kind of door
+     * the instance is, as shown in its properties.
+     *
+     * @param door The door to query
+     * @returns The type as a `string`, or `null`
+     *
+     * @examplePrompt What type of door is this?
+     * @examplePrompt Tell me the door type of the selected door
+     * @examplePrompt Is this a single or a double door?
+     * @examplePrompt Check what kind of door is on this wall
+     *
+     * # Example
+     * ```ts
+     * const [door] = await snaptrude.design.query.listDoors({ isSelected: true })
+     * const type = await snaptrude.design.doors.getType(door)
+     * if (type) console.log("door type:", type)
+     * ```
+     */
+    abstract getType(door: ComponentHandle): PluginApiReturn<string | null>;
+    /**
+     * Get the family name of a door — the Revit or native family the door
+     * instance comes from.
+     *
+     * @param door The door to query
+     * @returns The family as a `string`, or `null`
+     *
+     * @examplePrompt Which family does this door belong to?
+     * @examplePrompt What's the Revit family of the selected door?
+     * @examplePrompt Show the family name for this door
+     * @examplePrompt Find out which door family the imported door uses
+     *
+     * # Example
+     * ```ts
+     * const [door] = await snaptrude.design.query.listDoors()
+     * const family = await snaptrude.design.doors.getFamily(door)
+     * if (family) console.log("family:", family)
+     * ```
+     */
+    abstract getFamily(door: ComponentHandle): PluginApiReturn<string | null>;
+    /**
+     * Get the width of a door — how wide its opening is along the host wall.
+     *
+     * @param door The door to query
+     * @returns The width as a `number`, or `null`
+     *
+     * @examplePrompt How wide is this door?
+     * @examplePrompt What's the width of the selected door?
+     * @examplePrompt Measure the width of the entrance door
+     * @examplePrompt Check whether this door is 900mm wide
+     *
+     * # Example
+     * ```ts
+     * const [door] = await snaptrude.design.query.listDoors({ isSelected: true })
+     * const width = await snaptrude.design.doors.getWidth(door)
+     * if (width !== null) console.log("door width:", width)
+     * ```
+     */
+    abstract getWidth(door: ComponentHandle): PluginApiReturn<number | null>;
+    /**
+     * Get the height of a door — how tall its opening is from base to head.
+     *
+     * @param door The door to query
+     * @returns The height as a `number`, or `null`
+     *
+     * @examplePrompt How tall is this door?
+     * @examplePrompt What's the height of the selected door?
+     * @examplePrompt Check the door height for this opening
+     * @examplePrompt Is the front door 2100mm high?
+     *
+     * # Example
+     * ```ts
+     * const [door] = await snaptrude.design.query.listDoors()
+     * const height = await snaptrude.design.doors.getHeight(door)
+     * if (height !== null) console.log("door height:", height)
+     * ```
+     */
+    abstract getHeight(door: ComponentHandle): PluginApiReturn<number | null>;
+    /**
+     * Get the floor a door is hosted on — the storey/level component that
+     * supports the door.
+     *
+     * @param door The door to query
+     * @returns The support floor {@linkcode ComponentHandle}, or `null`
+     *
+     * @examplePrompt Which floor is this door on?
+     * @examplePrompt What storey does the selected door belong to?
+     * @examplePrompt Find the level that hosts this door
+     * @examplePrompt Tell me which floor the entrance door sits on
+     *
+     * # Example
+     * ```ts
+     * const [door] = await snaptrude.design.query.listDoors({ isSelected: true })
+     * const floor = await snaptrude.design.doors.getSupportFloor(door)
+     * if (floor) {
+     *   const props = await snaptrude.design.query.getProperties(floor)
+     *   console.log("hosted on storey:", props.storey)
+     * }
+     * ```
+     */
+    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.
+     *
+     * @param door The door to query
+     * @returns `'left'` / `'right'`, or `null` if indeterminate
+     *
+     * @examplePrompt Which way does this door swing?
+     * @examplePrompt Is the selected door left-handed or right-handed?
+     * @examplePrompt Check the hinge side of this door
+     * @examplePrompt Does the entrance door open to the left or the right?
+     *
+     * # Example
+     * ```ts
+     * const [door] = await snaptrude.design.query.listDoors({ isSelected: true })
+     * const swing = await snaptrude.design.doors.getSwingDirection(door)
+     * if (swing) console.log("opens as a", swing, "hand door")
+     * ```
+     */
+    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.
+     *
+     * @param door The door to mirror
+     * @param axis Reflection axis (optional; default `'x'` — the swing-flip axis)
+     * @returns The affected door(s)
+     *
+     * @examplePrompt Flip this door's swing
+     * @examplePrompt Mirror the selected door
+     * @examplePrompt Make this door open the other way
+     * @examplePrompt Reverse the hinge side of the entrance door
+     * @examplePrompt Change the door to swing from the other side
+     *
+     * # 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
+     * const [door] = await snaptrude.design.query.listDoors({ isSelected: true })
+     * const { affected } = await snaptrude.design.doors.mirror(door)
+     * ```
+     */
+    abstract mirror(door: ComponentHandle, axis?: PluginMirrorAxis): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * Set the width of one or more doors, resizing each opening and re-cutting
+     * the host wall. Width is in engine units; the change is undoable.
+     *
+     * @param doors The doors to resize
+     * @param width New width (engine units)
+     * @returns The affected doors
+     *
+     * @examplePrompt Make this door 900mm wide
+     * @examplePrompt Widen the selected doors to 1 metre
+     * @examplePrompt Change the door width to 3 feet
+     * @examplePrompt Resize all the bathroom doors to 750 wide
+     * @examplePrompt Narrow the entrance door a bit
+     *
+     * # Example
+     * ```ts
+     * // Resize every ground-floor door to a common width (engine units)
+     * const doors = await snaptrude.design.query.listDoors({ storeys: [1] })
+     * const { affected } = await snaptrude.design.doors.setWidth(doors, 900)
+     * console.log("resized", affected.length, "doors")
+     * ```
+     */
+    abstract setWidth(doors: ComponentHandle[], width: number): PluginApiReturn<PluginDesignChangeResult>;
+    /**
+     * Set the height of one or more doors, resizing each opening and re-cutting
+     * the host wall. Height is in engine units; the change is undoable.
+     *
+     * @param doors The doors to resize
+     * @param height New height (engine units)
+     * @returns The affected doors
+     *
+     * @examplePrompt Make this door 2100mm tall
+     * @examplePrompt Change the door height to 7 feet
+     * @examplePrompt Raise the selected doors to 2.4m high
+     * @examplePrompt Set all the doors on this storey to 2100 high
+     *
+     * # Example
+     * ```ts
+     * // setHeight takes an array — wrap a single door
+     * const [door] = await snaptrude.design.query.listDoors({ isSelected: true })
+     * await snaptrude.design.doors.setHeight([door], 2100)
+     * ```
+     */
+    abstract setHeight(doors: ComponentHandle[], height: number): PluginApiReturn<PluginDesignChangeResult>;
+}
+/**
+ * Arguments for the single-door read methods.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `door` | {@linkcode ComponentHandle} | The door to query |
+ */
+export declare const PluginDesignDoorArgs: z.ZodObject<{
+    door: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+}, z.core.$strip>;
+export type PluginDesignDoorArgs = z.infer<typeof PluginDesignDoorArgs>;
+/** Mirror axis — tokens mirror the engine `FlipDirection` verbatim (§6.1). */
+export declare const PluginMirrorAxis: z.ZodEnum<{
+    x: "x";
+    y: "y";
+    z: "z";
+}>;
+export type PluginMirrorAxis = z.infer<typeof PluginMirrorAxis>;
+/**
+ * Arguments for {@linkcode PluginDesignDoorsApi.mirror}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `door` | {@linkcode ComponentHandle} | The door to mirror |
+ * | `axis` | {@linkcode PluginMirrorAxis} | Reflection axis (optional; default `'x'` — the swing-flip axis) |
+ */
+export declare const PluginDesignDoorMirrorArgs: z.ZodObject<{
+    door: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    axis: z.ZodOptional<z.ZodEnum<{
+        x: "x";
+        y: "y";
+        z: "z";
+    }>>;
+}, z.core.$strip>;
+export type PluginDesignDoorMirrorArgs = z.infer<typeof PluginDesignDoorMirrorArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignDoorsApi.setWidth}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `doors` | {@linkcode ComponentHandle}`[]` | The doors to resize |
+ * | `width` | `number` | New width (engine units) |
+ */
+export declare const PluginDesignDoorSetWidthArgs: z.ZodObject<{
+    doors: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+    width: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginDesignDoorSetWidthArgs = z.infer<typeof PluginDesignDoorSetWidthArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignDoorsApi.setHeight}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `doors` | {@linkcode ComponentHandle}`[]` | The doors to resize |
+ * | `height` | `number` | New height (engine units) |
+ */
+export declare const PluginDesignDoorSetHeightArgs: z.ZodObject<{
+    doors: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+export type PluginDesignDoorSetHeightArgs = z.infer<typeof PluginDesignDoorSetHeightArgs>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/design/doors/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAClD,OAAO,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAA;AAElD;;;;;;;;;GASG;AACH,8BAAsB,oBAAoB;;IAGxC;;;;;;;;;;;;;;;;;;OAkBG;aACa,OAAO,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe,CAAC,MAAM,GAAG,IAAI,CAAC;IAE9E;;;;;;;;;;;;;;;;;;OAkBG;aACa,SAAS,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe,CAAC,MAAM,GAAG,IAAI,CAAC;IAEhF;;;;;;;;;;;;;;;;;OAiBG;aACa,QAAQ,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe,CAAC,MAAM,GAAG,IAAI,CAAC;IAE/E;;;;;;;;;;;;;;;;;OAiBG;aACa,SAAS,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe,CAAC,MAAM,GAAG,IAAI,CAAC;IAEhF;;;;;;;;;;;;;;;;;;;;;OAqBG;aACa,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe,CAAC,eAAe,GAAG,IAAI,CAAC;IAE/F;;;;;;;;;;;;;;;;;;;OAmBG;aACa,iBAAiB,CAC/B,IAAI,EAAE,eAAe,GACpB,eAAe,CAAC,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;;;OAqBG;aACa,MAAM,CACpB,IAAI,EAAE,eAAe,EACrB,IAAI,CAAC,EAAE,gBAAgB,GACtB,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;;;OAqBG;aACa,QAAQ,CACtB,KAAK,EAAE,eAAe,EAAE,EACxB,KAAK,EAAE,MAAM,GACZ,eAAe,CAAC,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;OAmBG;aACa,SAAS,CACvB,KAAK,EAAE,eAAe,EAAE,EACxB,MAAM,EAAE,MAAM,GACb,eAAe,CAAC,wBAAwB,CAAC;CAC7C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB;;iBAE/B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEvE,8EAA8E;AAC9E,eAAO,MAAM,gBAAgB;;;;EAA0B,CAAA;AACvD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B;;;;;;;iBAGrC,CAAA;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAEnF;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B;;;iBAGvC,CAAA;AACF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAEvF;;;;;;;GAOG;AACH,eAAO,MAAM,6BAA6B;;;iBAGxC,CAAA;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAA"}

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

@@ -0,0 +1,49 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../../types";
+import { ComponentHandle, Vec3Handle } from "../../../handles";
+import { OffsetSplitOutcome } from "../shared";
+/**
+ * STAGED (LLD Wave 2) — abstract shell only. NOT yet wired into `PluginDesignApi`
+ * and has no host implementation. `offsetSplit` migrates off `tools.offset` (adding
+ * the previously-dropped `offsetValue` to the result).
+ *
+ * `snaptrude.design.edit` — non-create geometry edits (offset-split, and later
+ * push-pull / topology edits). Undoable.
+ *
+ * TRANSPORT: positional args per method.
+ */
+export declare abstract class PluginDesignEditApi {
+    constructor();
+    /**
+     * Offset the top profile of a component by a distance and split the face along
+     * the offset curve. Positive distances offset outward, negative inward.
+     * Single-component only (the engine rejects batches).
+     * @param component - The component whose top profile is offset-split.
+     * @param offsetDistance - Offset distance; positive = outward, negative = inward.
+     * @param options - Optional settings: `profilePickPoint` picks the profile when ambiguous.
+     * @returns {@linkcode OffsetSplitOutcome} `{ createdIds, deletedIds, offsetValue }`
+     *
+     * @examplePrompt Offset the top face of this mass inward by 2 metres and split it
+     * @examplePrompt Create a 1m setback border on top of the selected mass
+     * @examplePrompt Split the roof profile with a 500mm inward offset
+     * @examplePrompt Offset-split the slab's top profile outward by 3 feet
+     *
+     * # Example
+     * ```ts
+     * // Offset the top profile inward by 2 units and split the face along it
+     * const [mass] = await snaptrude.design.query.listMasses()
+     * const { createdIds, offsetValue } = await snaptrude.design.edit.offsetSplit(mass, -2)
+     * // offsetValue is the post-clamp distance the engine actually applied
+     * ```
+     */
+    abstract offsetSplit(component: ComponentHandle, offsetDistance: number, options?: {
+        profilePickPoint?: Vec3Handle;
+    }): PluginApiReturn<OffsetSplitOutcome>;
+}
+export declare const PluginDesignOffsetSplitArgs: z.ZodObject<{
+    component: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    offsetDistance: z.ZodNumber;
+    profilePickPoint: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../../..").Handle<"vec3">, string>>>;
+}, z.core.$strip>;
+export type PluginDesignOffsetSplitArgs = z.infer<typeof PluginDesignOffsetSplitArgs>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/design/edit/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AAE9C;;;;;;;;;GASG;AACH,8BAAsB,mBAAmB;;IAGvC;;;;;;;;;;;;;;;;;;;;;OAqBG;aACa,WAAW,CACzB,SAAS,EAAE,eAAe,EAC1B,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE;QAAE,gBAAgB,CAAC,EAAE,UAAU,CAAA;KAAE,GAC1C,eAAe,CAAC,kBAAkB,CAAC;CACvC;AAGD,eAAO,MAAM,2BAA2B;;;;iBAItC,CAAA;AACF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA"}

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

@@ -0,0 +1,160 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../../types";
+import { ComponentHandle } from "../../../handles";
+/**
+ * The erase strategies exposed to plugins. `SplitAndUnion` is *enumerable* but
+ * NOT committable via {@linkcode PluginDesignEraseApi.edge} (it needs an
+ * interactive screen-space re-pick); `SplitAndDelete` is reserved in the engine
+ * and intentionally omitted. Derived host-side by the engine's `decideStrategy`.
+ */
+export declare const EraseStrategy: z.ZodEnum<{
+    DirectDelete: "DirectDelete";
+    DirectUnion: "DirectUnion";
+    SplitAndUnion: "SplitAndUnion";
+}>;
+export type EraseStrategy = z.infer<typeof EraseStrategy>;
+/** Default enumerated strategies — the two the scripted `edge()` can commit. */
+export declare const DEFAULT_ERASE_STRATEGIES: readonly EraseStrategy[];
+/**
+ * A **transient** reference to one erasable edge in the current plan's
+ * bottom-adjacency graph.
+ *
+ * ⚠️ **Lifetime**: valid ONLY until the next geometry-modifying operation. Any
+ * mutation (erase, boolean, transform, create, delete, …) rebuilds the adjacency
+ * graph and invalidates every previously-returned ref. Passing a stale ref to
+ * {@linkcode PluginDesignEraseApi.edge} throws `NO_STRATEGY_FOR_PICK_INFO`.
+ * Always re-list after a mutation.
+ *
+ * This is a by-value record (round-trip it back to `edge()` unmodified), NOT a
+ * registry handle. `components` and `snapPoint` are the marshalled public forms
+ * of the engine's raw `mesh.uniqueId` numbers / by-value point.
+ */
+export declare const ErasableEdgeRef: z.ZodObject<{
+    id: z.ZodString;
+    strategy: z.ZodEnum<{
+        DirectDelete: "DirectDelete";
+        DirectUnion: "DirectUnion";
+        SplitAndUnion: "SplitAndUnion";
+    }>;
+    edgeWeight: z.ZodNumber;
+    components: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+    snapPoint: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../..").Handle<"vec3">, string>>;
+}, z.core.$strip>;
+export type ErasableEdgeRef = z.infer<typeof ErasableEdgeRef>;
+/**
+ * Options for {@linkcode PluginDesignEraseApi.listErasableEdges}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `components` | {@linkcode ComponentHandle}`[]?` | Restrict to edges adjacent to at least one of these entities |
+ * | `strategies` | {@linkcode EraseStrategy}`[]?` | Restrict to these strategies. Default `["DirectDelete","DirectUnion"]` (hides interactive-only `SplitAndUnion`) |
+ *
+ * TRANSPORT: positional now — `listErasableEdges(options?)`; this schema is
+ * retained for host-side validation.
+ */
+export declare const PluginDesignListErasableEdgesArgs: z.ZodObject<{
+    components: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>>;
+    strategies: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        DirectDelete: "DirectDelete";
+        DirectUnion: "DirectUnion";
+        SplitAndUnion: "SplitAndUnion";
+    }>>>;
+}, z.core.$strip>;
+export type PluginDesignListErasableEdgesArgs = z.infer<typeof PluginDesignListErasableEdgesArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignEraseApi.edge}.
+ *
+ * TRANSPORT: positional now — `edge(edge: ErasableEdgeRef)`; this schema is
+ * retained for host-side validation.
+ */
+export declare const PluginDesignEraseEdgeArgs: z.ZodObject<{
+    edge: z.ZodObject<{
+        id: z.ZodString;
+        strategy: z.ZodEnum<{
+            DirectDelete: "DirectDelete";
+            DirectUnion: "DirectUnion";
+            SplitAndUnion: "SplitAndUnion";
+        }>;
+        edgeWeight: z.ZodNumber;
+        components: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>>;
+        snapPoint: z.ZodPipe<z.ZodString, z.ZodTransform<import("../../..").Handle<"vec3">, string>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PluginDesignEraseEdgeArgs = z.infer<typeof PluginDesignEraseEdgeArgs>;
+/** Result of {@linkcode PluginDesignEraseApi.edge} — success sentinel; the engine yields no survivor id. */
+export declare const PluginDesignEraseEdgeResult: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type PluginDesignEraseEdgeResult = z.infer<typeof PluginDesignEraseEdgeResult>;
+/**
+ * `snaptrude.design.erase` — **adjacency-edge erase** (plan-level topology op).
+ *
+ * Erase is NOT delete. The erase tool operates on an **edge**, and the effect is
+ * derived from that edge: erasing an internal edge between two masses **unions**
+ * them (`DirectUnion`); erasing an external boundary edge of a single mass
+ * **drops** it behind the edge (`DirectDelete`). For hard entity removal use
+ * `design.delete.entities`; for CSG geometry delete use `design.boolean.subtract`.
+ *
+ * Two-step: {@linkcode listErasableEdges} to enumerate, then {@linkcode edge} to
+ * commit one ref (single undo entry). Scoped to **2D plan adjacency edges** in v1.
+ *
+ * TRANSPORT: positional args per method.
+ */
+export declare abstract class PluginDesignEraseApi {
+    constructor();
+    /**
+     * Enumerate every erasable edge in the current plan's bottom-adjacency graph
+     * (one {@linkcode ErasableEdgeRef} per edge). Pure read — no scene mutation, no
+     * command, not undoable. Erase-ineligible components (locked, hidden, off-storey)
+     * are filtered out.
+     *
+     * ⚠️ Returned refs are **transient** — see {@linkcode ErasableEdgeRef}. Re-list
+     * after any geometry mutation.
+     *
+     * @param options - {@linkcode PluginDesignListErasableEdgesArgs} — optional filters (`components`, `strategies`)
+     * @returns The erasable edges (`[]` when none) — never `null`.
+     *
+     * @examplePrompt Which edges in my floor plan can be erased?
+     * @examplePrompt List the erasable edges on this storey
+     * @examplePrompt Show me the shared edges I could erase to merge rooms
+     * @examplePrompt What edges between these two spaces can be removed?
+     *
+     * # Example
+     * ```ts
+     * const edges = await snaptrude.design.erase.listErasableEdges()
+     * const union = edges.find((e) => e.strategy === "DirectUnion")
+     * if (union) await snaptrude.design.erase.edge(union)
+     * ```
+     */
+    abstract listErasableEdges(options?: PluginDesignListErasableEdgesArgs): PluginApiReturn<ErasableEdgeRef[]>;
+    /**
+     * Commit the erase for one edge. `DirectUnion` merges the two adjacent masses;
+     * `DirectDelete` drops the single mass behind the boundary edge. Single undo entry.
+     *
+     * Pass an {@linkcode ErasableEdgeRef} from {@linkcode listErasableEdges}
+     * unmodified. A stale ref (graph rebuilt by a prior mutation) or a `SplitAndUnion`
+     * edge throws.
+     *
+     * @param edge - The {@linkcode ErasableEdgeRef} to erase, from {@linkcode listErasableEdges} unmodified
+     * @returns `{ ok: true }` on success (the engine yields no survivor id today).
+     * @throws when the ref is stale, its components are all erase-ineligible, or the
+     *   strategy is not committable via the scripted path.
+     *
+     * @examplePrompt Erase the edge between these two rooms so they merge
+     * @examplePrompt Remove the shared boundary between the kitchen and the dining space
+     * @examplePrompt Merge the two adjacent rooms by erasing their common edge
+     * @examplePrompt Knock through the partition line between these spaces
+     * @examplePrompt Erase this boundary edge from the plan
+     *
+     * # Example
+     * ```ts
+     * // Merge two adjacent rooms by erasing an internal edge they share
+     * const edges = await snaptrude.design.erase.listErasableEdges({ strategies: ["DirectUnion"] })
+     * if (edges.length > 0) {
+     *   const { ok } = await snaptrude.design.erase.edge(edges[0])
+     * }
+     * ```
+     */
+    abstract edge(edge: ErasableEdgeRef): PluginApiReturn<PluginDesignEraseEdgeResult>;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/api/design/erase/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAc,MAAM,kBAAkB,CAAA;AAE9D;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;EAA2D,CAAA;AACrF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEzD,gFAAgF;AAChF,eAAO,MAAM,wBAAwB,EAAE,SAAS,aAAa,EAAoC,CAAA;AAEjG;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;iBAW1B,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iCAAiC;;;;;;;iBAG5C,CAAA;AACF,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAEjG;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;iBAEpC,CAAA;AACF,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAEjF,4GAA4G;AAC5G,eAAO,MAAM,2BAA2B;;iBAAoC,CAAA;AAC5E,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAErF;;;;;;;;;;;;;GAaG;AACH,8BAAsB,oBAAoB;;IAGxC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;aACa,iBAAiB,CAC/B,OAAO,CAAC,EAAE,iCAAiC,GAC1C,eAAe,CAAC,eAAe,EAAE,CAAC;IAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;aACa,IAAI,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe,CAAC,2BAA2B,CAAC;CAC1F"}