@snaptrude/plugin-core 0.0.0-dev-20260708130115 → 0.0.0-dev-20260827194031

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

@@ -0,0 +1,493 @@
+import * as z from "zod";
+import { PluginApiReturn } from "../../types";
+import { ComponentHandle } from "../../handles";
+/**
+ * `snaptrude.design.family.*` — author NATIVE parametric families from a JSON spec.
+ *
+ * A parametric family is a reusable, parameter-driven building component: a
+ * curtain-wall panel, a louvre screen, a balustrade, a shading fin. Unlike the
+ * rest of `design.*`, you do not build one out of geometry calls — you write a
+ * JSON **spec** describing its parameters and its geometry rules, and the host
+ * compiles that into a live parametric definition the user can place, flex and
+ * save to their library.
+ *
+ * ## Workflow
+ *
+ * ```
+ * getReference()        read the spec DSL once — grammar, ops, expressions, example
+ * prepare({ bundle })   validate + compile + show a live ghost; nothing committed
+ * flex({ values })      re-run at new values; returns the geometry delta
+ * place()               arm placement — the USER clicks to drop it
+ * create({ name })      commit it to the project's family library
+ * ```
+ *
+ * ## Read getReference() first
+ *
+ * The spec DSL is a closed expression language with its own op set, coordinate
+ * convention (**+Y up, integer millimetres** — not Snaptrude's babylon units)
+ * and part-naming law. It is deliberately NOT duplicated in these types:
+ * {@linkcode PluginDesignFamilyApi.getReference} returns the whole reference,
+ * generated from a family that is actually registered in the host, so the
+ * documentation cannot drift from what the compiler accepts.
+ *
+ * ## The repair contract
+ *
+ * {@linkcode PluginDesignFamilyApi.prepare} does **not** throw on an invalid
+ * spec — it returns `{ ok: false, errors }` where each error carries a JSON
+ * pointer into the bundle you sent (e.g. `"/root/geometry/2/body/0/w"`). Read
+ * `errors[0].path`, fix that node, and call `prepare` again. A failed `prepare`
+ * leaves the previous good draft standing, so it costs nothing but the node you
+ * broke. Re-authoring from scratch throws away everything already correct.
+ *
+ * Accessed via `snaptrude.design.family`.
+ */
+export declare abstract class PluginDesignFamilyApi {
+    constructor();
+    /**
+     * Read the family-spec DSL reference: grammar, the op table, the expression
+     * whitelist, the coordinate convention, the repair contract, and a worked
+     * example taken from a registered family.
+     *
+     * Read this before authoring a family for the first time in a session. The
+     * DSL is a closed language — a guessed op or function is a rejected spec.
+     *
+     * @returns The reference text
+     *
+     * @examplePrompt How do I write a parametric family spec?
+     * @examplePrompt Show me the family DSL
+     *
+     * # Example
+     * ```ts
+     * const { reference } = await snaptrude.design.family.getReference()
+     * ```
+     */
+    abstract getReference(): PluginApiReturn<PluginFamilyReference>;
+    /**
+     * Validate, compile and preview a family spec. Nothing is committed to the
+     * model or the library — call {@linkcode PluginDesignFamilyApi.place} or
+     * {@linkcode PluginDesignFamilyApi.create} for that.
+     *
+     * Safe to call repeatedly while iterating. On success, check `partCount` and
+     * `bbox` against what you intended before treating the family as correct — a
+     * facade that built 3 parts, or a 3 m screen reporting 40 m of height, is a
+     * visible bug the validator cannot catch.
+     *
+     * @param args The spec bundle, as `{ bundle }` or `{ spec }`
+     * @returns Build report, or `{ ok: false, errors }` with JSON-pointer paths
+     *
+     * @examplePrompt Make a louvre screen with adjustable blade count and tilt
+     * @examplePrompt Design a curtain wall panel family with 8 bays
+     * @examplePrompt Create a railing family I can adjust
+     *
+     * # Example
+     * ```ts
+     * const r = await snaptrude.design.family.prepare({ bundle })
+     * if (!r.ok) console.error(r.errors[0].path, r.errors[0].message)
+     * ```
+     */
+    abstract prepare(args: PluginDesignFamilyPrepareArgs): PluginApiReturn<PluginFamilyPrepareResult>;
+    /**
+     * Re-run the prepared family's recipe at new parameter values.
+     *
+     * Values are merged over the current ones and clamped to the parameter
+     * sheet's min/max, so a partial `{ bays: 6 }` is fine. The returned `changed`
+     * buckets are the host's own diff of what the geometry did — flexing a
+     * driving parameter and reporting them demonstrates the family is parametric.
+     *
+     * @param args The parameter values to change
+     * @returns The new build plus the geometry delta
+     *
+     * @examplePrompt Change it to 6 bays
+     * @examplePrompt Show me what happens with 20 blades
+     *
+     * # Example
+     * ```ts
+     * const { changed } = await snaptrude.design.family.flex({ values: { bays: 6 } })
+     * console.log(`removed ${changed.removed}, rebuilt ${changed.rebuilt}`)
+     * ```
+     */
+    abstract flex(args: PluginDesignFamilyFlexArgs): PluginApiReturn<PluginFamilyFlexResult>;
+    /**
+     * The prepared family's spec bundle, or `null` when nothing is prepared.
+     *
+     * @returns The draft bundle, or `null`
+     *
+     * # Example
+     * ```ts
+     * const bundle = await snaptrude.design.family.get()
+     * ```
+     */
+    abstract get(): PluginApiReturn<PluginFamilyBundle | null>;
+    /**
+     * Every parametric family registered in this session — native and imported.
+     *
+     * @returns One summary per family
+     *
+     * @examplePrompt What families are available?
+     *
+     * # Example
+     * ```ts
+     * const families = await snaptrude.design.family.list()
+     * ```
+     */
+    abstract list(): PluginApiReturn<PluginFamilySummary[]>;
+    /**
+     * Put a family into the model — either the prepared draft or any family from
+     * {@linkcode PluginDesignFamilyApi.list}.
+     *
+     * Two modes, chosen by whether you pass `position`:
+     *
+     * **With `position`** the component is created there and then, undoably. Use
+     * this when you know where it goes — you were given coordinates, or you are
+     * copying an existing instance. The returned `component` handle works with
+     * `design.transform.move` / `.rotate` and with
+     * {@linkcode PluginDesignFamilyApi.setParameters}.
+     *
+     * **Without `position`** it arms placement mode with a ghost on the cursor
+     * and returns immediately — no geometry yet. The USER clicks to drop it, so
+     * tell them to. Prefer this when the location is a judgement call.
+     *
+     * To COPY a placed component, place its family again at the new position with
+     * the same `values` — there is no separate copy call.
+     *
+     * @param args Which family, where, and at what parameter values
+     * @returns What was placed; `component` is present only in positioned mode
+     *
+     * @examplePrompt Place it in the model
+     * @examplePrompt Put a louvre screen at the origin
+     * @examplePrompt Copy that table two metres to the right
+     *
+     * # Example
+     * ```ts
+     * // positioned — geometry exists when this resolves
+     * const { component } = await snaptrude.design.family.place({
+     *   id: "revit:gypsum-stud-partition~90ad72",
+     *   position: { x: 0, y: 0, z: 0 },
+     *   rotation: 90,
+     * })
+     * await snaptrude.design.transform.move([component], { x: 2, y: 0, z: 0 })
+     *
+     * // interactive — the user clicks
+     * await snaptrude.design.family.place()
+     * ```
+     */
+    abstract place(args?: PluginDesignFamilyPlaceArgs): PluginApiReturn<PluginFamilyPlaceResult>;
+    /**
+     * Read a placed component's current parameter values and its sheet.
+     *
+     * Use before {@linkcode PluginDesignFamilyApi.setParameters} so you change
+     * what is actually there: parameter KEYS are the family's own, not the
+     * label the user says, and a Revit-imported family carries parameters that
+     * do not drive geometry at all.
+     *
+     * @param args The component to read
+     * @returns Its definition, current values, and the parameter sheet
+     *
+     * @examplePrompt What size is that table?
+     * @examplePrompt Show me the parameters on this partition
+     *
+     * # Example
+     * ```ts
+     * const { values, parameters } = await snaptrude.design.family.getParameters({ component })
+     * ```
+     */
+    abstract getParameters(args: PluginDesignFamilyGetParametersArgs): PluginApiReturn<PluginFamilyInstanceParameters | null>;
+    /**
+     * Change a placed component's parameters and rebuild its geometry in place.
+     *
+     * Partial: pass only what changes. The component keeps its position,
+     * rotation and identity — this is an edit, not a replace, and it is undoable.
+     *
+     * Only parameters with `drivesGeometry` actually move the mesh. Setting one
+     * that does not is accepted and stored (it round-trips to Revit) but nothing
+     * visible happens — say so rather than claiming a change the user cannot see.
+     *
+     * @param args The component and the values to change
+     * @returns The values now in effect
+     *
+     * @examplePrompt Make that table seat 8
+     * @examplePrompt Change the stud spacing to 400
+     *
+     * # Example
+     * ```ts
+     * await snaptrude.design.family.setParameters({ component, values: { seats: 8 } })
+     * ```
+     */
+    abstract setParameters(args: PluginDesignFamilySetParametersArgs): PluginApiReturn<PluginFamilyInstanceParameters>;
+    /**
+     * Commit the prepared bundle to the project's parametric-definition library,
+     * so it survives the session and appears in the Families panel.
+     *
+     * @param args Optional library name and team scope
+     * @returns The catalogued definition's id and version
+     *
+     * @examplePrompt Save this as a family called Vertical Louvre
+     * @examplePrompt Add it to my library
+     *
+     * # Example
+     * ```ts
+     * const { definitionId } = await snaptrude.design.family.create({ name: "Louvre Screen" })
+     * ```
+     */
+    abstract create(args?: PluginDesignFamilyCreateArgs): PluginApiReturn<PluginFamilyCreateResult>;
+}
+/** The family-spec DSL reference returned by `getReference`. */
+export interface PluginFamilyReference {
+    /** Grammar, op table, expression whitelist, repair contract, worked example. */
+    reference: string;
+}
+/**
+ * A family spec bundle. `root` is the family; `deps` carries every spec
+ * reachable through an `instance` op, keyed by spec id, so a saved family is
+ * self-contained and reloads anywhere.
+ *
+ * The internal shape of a spec is documented by
+ * {@linkcode PluginDesignFamilyApi.getReference}, not by these types — it is a
+ * data DSL whose grammar changes independently of this API surface.
+ */
+export interface PluginFamilyBundle {
+    root: Record<string, unknown>;
+    deps?: Record<string, Record<string, unknown>>;
+}
+/** Axis-aligned extents of a built family. Integer millimetres, +Y up. */
+export interface PluginFamilyBBox {
+    min: [number, number, number];
+    max: [number, number, number];
+    /** `[width, height, depth]` in millimetres. */
+    size: [number, number, number];
+}
+/** One row of a family's parameter sheet. */
+export interface PluginFamilyParameter {
+    key: string;
+    label: string;
+    type: "length" | "integer" | "enum" | "text" | "boolean";
+    /** Current value. `length`/`integer` are numbers; the rest are strings. */
+    value: string | number;
+    default: string | number;
+    /**
+     * Whether this parameter actually drives geometry — INFERRED by the host from
+     * which names the spec's expressions reference. `false` means the value is
+     * stored and round-tripped but moves nothing.
+     */
+    drivesGeometry: boolean;
+    min?: number;
+    max?: number;
+    options?: readonly string[];
+}
+/**
+ * A validation diagnostic. `path` is a JSON pointer into the submitted bundle —
+ * fix that node and re-`prepare`.
+ */
+export interface PluginFamilyDiagnostic {
+    /** JSON pointer, e.g. `"/root/geometry/2/body/0/w"`. */
+    path: string;
+    code: "schema" | "bad-expression" | "unknown-name" | "unknown-def" | "cycle" | "duplicate-name" | "unbounded-repeat" | "depth" | "bad-dimension";
+    message: string;
+    hint?: string;
+}
+/** What `prepare` reports. */
+export interface PluginFamilyPrepareResult {
+    /** `false` means the spec was rejected — read `errors`, fix, re-prepare. */
+    ok: boolean;
+    familyId?: string;
+    version?: number;
+    label?: string;
+    /** How many parts the family built. Sanity-check against intent. */
+    partCount?: number;
+    /** Extents in millimetres. Sanity-check against intent. */
+    bbox?: PluginFamilyBBox;
+    evalMs?: number;
+    parameters?: PluginFamilyParameter[];
+    /** Computed quantities, when the spec declares a `takeoff` block. */
+    takeoff?: Record<string, number | string>;
+    /** The first few part names — enough to check the naming came out right. */
+    sampleParts?: string[];
+    errors: PluginFamilyDiagnostic[];
+    warnings: PluginFamilyDiagnostic[];
+    /** Set when the bundle validated but threw while building. */
+    error?: string;
+}
+/**
+ * The host's diff of what a flex did to the geometry. This is the evidence that
+ * a family is parametric.
+ */
+export interface PluginFamilyChangeBuckets {
+    added: number;
+    removed: number;
+    moved: number;
+    rebuilt: number;
+    addedNames: string[];
+    removedNames: string[];
+}
+/** What `flex` reports. */
+export interface PluginFamilyFlexResult {
+    ok: boolean;
+    /** The RESOLVED values after merge + clamping — not necessarily what was sent. */
+    values?: Record<string, number | string>;
+    partCount?: number;
+    bbox?: PluginFamilyBBox;
+    evalMs?: number;
+    changed?: PluginFamilyChangeBuckets;
+    takeoff?: Record<string, number | string>;
+    error?: string;
+}
+/** One family available to place — from the session registry or the catalog. */
+export interface PluginFamilySummary {
+    id: string;
+    version: number;
+    label: string;
+    category?: string;
+    /** Number of rows on the family's parameter sheet. */
+    parameters: number;
+    /**
+     * Where the family came from, which decides how far you can edit it.
+     *
+     * `"native"` — authored from a JSON spec through this API. Its recipe is
+     * data, so every parameter genuinely re-runs the geometry.
+     *
+     * `"revit"` — imported from a Revit family. Parameters exist and are
+     * editable, but only those the importer could bind to geometry actually
+     * change the mesh; the rest are carried for round-tripping. Check
+     * `drivesGeometry` on the parameter before promising the user a change.
+     */
+    kind: "native" | "revit";
+}
+/** What `place` reports. */
+export interface PluginFamilyPlaceResult {
+    ok: boolean;
+    familyId?: string;
+    version?: number;
+    /**
+     * The created component — present ONLY when `position` was given. In
+     * interactive mode nothing exists yet, so there is nothing to hand back;
+     * the user has not clicked.
+     */
+    component?: ComponentHandle;
+    error?: string;
+}
+/** A placed component's parameter state, from `getParameters` / `setParameters`. */
+export interface PluginFamilyInstanceParameters {
+    /** The definition this instance is pinned to. */
+    familyId: string;
+    version: number;
+    label: string;
+    /** Current values, keyed by parameter key. */
+    values: Record<string, number | string>;
+    /** The sheet: what each key means, its bounds, and whether it moves geometry. */
+    parameters: PluginFamilyParameter[];
+}
+/** What `create` reports. */
+export interface PluginFamilyCreateResult {
+    ok: boolean;
+    definitionId?: string;
+    version?: number;
+    guid?: string;
+    error?: string;
+}
+/**
+ * A spec bundle as it crosses the boundary: `root` plus optional `deps`.
+ *
+ * Loose by design — the spec grammar is a data DSL validated by the host's own
+ * validator, which returns JSON-pointer diagnostics far more useful than a Zod
+ * shape error. This schema only guarantees the envelope is an object.
+ */
+export declare const PluginFamilyBundleSchema: z.ZodObject<{
+    root: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    deps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+/**
+ * Arguments for {@linkcode PluginDesignFamilyApi.prepare}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `bundle` | {@linkcode PluginFamilyBundle} | The family spec bundle |
+ * | `spec` | {@linkcode PluginFamilyBundle} | Alias for `bundle` |
+ *
+ * Exactly one of `bundle` / `spec` is required. A bare `FamilySpec` (no `root`
+ * wrapper) is also accepted by the host and wrapped for the caller.
+ */
+export declare const PluginDesignFamilyPrepareArgs: z.ZodObject<{
+    bundle: z.ZodOptional<z.ZodObject<{
+        root: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        deps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>>;
+    spec: z.ZodOptional<z.ZodObject<{
+        root: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        deps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PluginDesignFamilyPrepareArgs = z.infer<typeof PluginDesignFamilyPrepareArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignFamilyApi.flex}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `values` | `Record<string, number \| string>` | Parameter values to change (partial) |
+ */
+export declare const PluginDesignFamilyFlexArgs: z.ZodObject<{
+    values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+}, z.core.$strip>;
+export type PluginDesignFamilyFlexArgs = z.infer<typeof PluginDesignFamilyFlexArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignFamilyApi.create}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `name` | `string` | Library name; defaults to the spec's own label |
+ * | `teamId` | `string` | Team library to save into; omit for personal |
+ */
+export declare const PluginDesignFamilyCreateArgs: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PluginDesignFamilyCreateArgs = z.infer<typeof PluginDesignFamilyCreateArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignFamilyApi.place}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `id` | `string` | Family to place, from {@linkcode PluginDesignFamilyApi.list}. Omit to place the prepared draft |
+ * | `version` | `number` | Exact version; defaults to the newest known |
+ * | `position` | `{ x, y, z }` | Place HERE, without user interaction. Omit to arm the cursor instead |
+ * | `rotation` | `number` | Yaw in degrees about +Y. Only with `position` |
+ * | `values` | `Record<string, number \| string>` | Parameter values for THIS instance |
+ * | `storey` | `number` | Storey to place on; defaults to the active one |
+ */
+export declare const PluginDesignFamilyPlaceArgs: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodNumber>;
+    position: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodNumber;
+    }, z.core.$strip>>;
+    rotation: z.ZodOptional<z.ZodNumber>;
+    values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>>;
+    storey: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PluginDesignFamilyPlaceArgs = z.infer<typeof PluginDesignFamilyPlaceArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignFamilyApi.getParameters}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `component` | {@linkcode ComponentHandle} | A placed parametric component |
+ */
+export declare const PluginDesignFamilyGetParametersArgs: z.ZodObject<{
+    component: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+}, z.core.$strip>;
+export type PluginDesignFamilyGetParametersArgs = z.infer<typeof PluginDesignFamilyGetParametersArgs>;
+/**
+ * Arguments for {@linkcode PluginDesignFamilyApi.setParameters}.
+ *
+ * | Property | Type | Description |
+ * |---|---|---|
+ * | `component` | {@linkcode ComponentHandle} | A placed parametric component |
+ * | `values` | `Record<string, number \| string>` | Values to change (partial) |
+ */
+export declare const PluginDesignFamilySetParametersArgs: z.ZodObject<{
+    component: z.ZodPipe<z.ZodString, z.ZodTransform<ComponentHandle, string>>;
+    values: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+}, z.core.$strip>;
+export type PluginDesignFamilySetParametersArgs = z.infer<typeof PluginDesignFamilySetParametersArgs>;
+//# sourceMappingURL=family.d.ts.map

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

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