@snaptrude/plugin-core 0.10.0 → 1.0.0

package/src/api/workspace/index.ts

@@ -10,13 +10,16 @@ import { PluginApiReturn } from "../../types"
  * Teams are **read-only** here (no create/invite/delete in v1, a deliberate
  * safety decision); there are no folders in v1. A `projectId` is the project's
  * floorkey. Plan limits are enforced by the backend — a limit rejection surfaces
- * as a normal host error. It also carries the workspace-level mode switch for
+ * as a normal host error. It also carries the workspace-level mode switches for
  * Present mode ({@linkcode PluginWorkspaceApi.openPresentMode} /
- * {@linkcode PluginWorkspaceApi.closePresentMode}).
+ * {@linkcode PluginWorkspaceApi.closePresentMode}) and Program mode
+ * ({@linkcode PluginWorkspaceApi.openProgramMode} /
+ * {@linkcode PluginWorkspaceApi.closeProgramMode}).
  *
  * - {@linkcode PluginWorkspaceApi.projects} — Create, copy, list, read & rename projects
  * - {@linkcode PluginWorkspaceApi.teams} — Read teams and their members
  * - {@linkcode PluginWorkspaceApi.openPresentMode} / {@linkcode PluginWorkspaceApi.closePresentMode} — Open/close the Present-mode documentation editor
+ * - {@linkcode PluginWorkspaceApi.openProgramMode} / {@linkcode PluginWorkspaceApi.closeProgramMode} — Open/close the Program tab (the spreadsheet the `program.spreadsheet.*` calls run in)
  */
 export abstract class PluginWorkspaceApi {
   /** Projects — create, copy, list, read & rename. See {@linkcode PluginWorkspaceProjectsApi}. */
@@ -68,6 +71,52 @@ export abstract class PluginWorkspaceApi {
    */
   public abstract closePresentMode(): PluginApiReturn<void>
 
+  /**
+   * Open Program mode — the Program tab the `program.spreadsheet.*` calls run in.
+   *
+   * Runs the top bar's own Program-button sequence (remember the preference,
+   * open or re-link the paired Program window) and resolves only once that tab
+   * has connected to the editor over its channel, so a `program.spreadsheet.*`
+   * call issued right after this resolves finds the tab open. The open happens
+   * outside a user gesture, so the browser may block the pop-up; the editor
+   * then shows its "Allow pop-up to continue" modal and this call keeps waiting
+   * (up to ~90s) for the user to confirm. Idempotent — resolves immediately
+   * when the Program tab is already connected, and is a no-op when the plugin is
+   * itself running in the Program tab. Write-gated.
+   *
+   * @throws `PRECONDITION_FAILED` if the user dismisses the pop-up modal or the
+   *   Program tab does not connect within the timeout.
+   *
+   * @examplePrompt Open program mode
+   * @examplePrompt Open the Program tab so I can build a custom sheet
+   * @examplePrompt Switch to the program spreadsheet
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.workspace.openProgramMode()
+   * const { sheets } = await snaptrude.program.spreadsheet.listSheets()
+   * ```
+   */
+  public abstract openProgramMode(): PluginApiReturn<void>
+
+  /**
+   * Close the Program tab.
+   *
+   * Idempotent — a no-op when no Program tab is connected. Write-gated, like
+   * {@linkcode PluginWorkspaceApi.openProgramMode}.
+   *
+   * @throws `PRECONDITION_FAILED` if the tab is still connected after ~15s.
+   *
+   * @examplePrompt Close program mode
+   * @examplePrompt Close the Program tab
+   *
+   * # Example
+   * ```ts
+   * await snaptrude.workspace.closeProgramMode()
+   * ```
+   */
+  public abstract closeProgramMode(): PluginApiReturn<void>
+
   constructor() {}
 }
 

package/src/errors/codes.ts

@@ -7,6 +7,8 @@
  * (`HANDLE_INVALID`) so error responses cannot be used as an existence /
  * ownership oracle (PLUGIN_HANDLE_MIGRATION_HLD §6). `HANDLE_KIND_MISMATCH`
  * stays distinct because the kind is information the caller already holds.
+ * `HANDLE_STALE` is the one deliberate exception: a handle the caller
+ * legitimately held whose entity was since retired (deleted or rebuilt).
  */
 export const PLUGIN_ERROR_CODES = [
   "VALIDATION",
@@ -34,6 +36,7 @@ export const PLUGIN_ERROR_CODES = [
   "PROPOSAL_SWITCH_BLOCKED",
   "INTERNAL",
   "UNKNOWN",
+  "HANDLE_STALE",
 ] as const
 
 export type PluginErrorCode = (typeof PLUGIN_ERROR_CODES)[number]
@@ -85,6 +88,10 @@ export const CODE_META: Record<PluginErrorCode, CodeMeta> = {
     hintTemplate: "Re-query the entity; do not cache handles across undo/reload.",
   },
   HANDLE_KIND_MISMATCH: { category: "handle" },
+  HANDLE_STALE: {
+    category: "handle",
+    hintTemplate: "The entity was deleted or rebuilt; re-query it for a fresh handle.",
+  },
   RESOURCE_QUOTA_EXCEEDED: {
     category: "quota",
     hintTemplate: "Release unused handles (core.handles.release) or use scopes.",

package/src/handles.ts

@@ -115,6 +115,19 @@ export type UnderlayHandle = EntityId<"underlay">
  */
 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
@@ -132,8 +145,17 @@ export type Vec3Handle = Handle<"vec3">
 export type QuatHandle = Handle<"quat">
 export type LineHandle = Handle<"line">
 export type ArcHandle = Handle<"arc">
-/** A curve is a line or an arc — its handle is one of those kinds. */
-export type CurveHandle = LineHandle | ArcHandle
+/**
+ * A NURBS curve value handle (open B-spline curve). Minted by
+ * `core.geom.create.splineFromPoints` / `splineFromControlPoints`, and returned by
+ * `edge.getCurve`, `profile.listCurves` and `update.curve.reverse` for a spline run;
+ * accepted everywhere a {@linkcode CurveHandle} is (profileFromCurves, query.curve.*).
+ * Closed spline loops never exist as a single handle — a closed run is built
+ * directly as a profile via `core.geom.create.profileFromSplinePoints`.
+ */
+export type SplineHandle = Handle<"spline">
+/** A curve is a line, an arc, or a spline — its handle is one of those kinds. */
+export type CurveHandle = LineHandle | ArcHandle | SplineHandle
 /**
  * A circle value handle. A circle is a CLOSED curve — it deliberately does NOT
  * join {@linkcode CurveHandle} (it has no stable start/end and would break the
@@ -233,12 +255,29 @@ export const ImportJobHandle = z
   .min(1)
   .transform((s) => s as ImportJobHandle)
 
+/**
+ * {@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 const DimensionHandle = z
+  .string()
+  .min(1)
+  .transform((s) => s as DimensionHandle)
+
 // Value-kind handle schemas (all-handle model, §11).
 export const Vec3Handle = handleSchema("vec3")
 export const QuatHandle = handleSchema("quat")
 export const LineHandle = handleSchema("line")
 export const ArcHandle = handleSchema("arc")
-export const CurveHandle = z.union([LineHandle, ArcHandle])
+export const SplineHandle = handleSchema("spline")
+// Explicitly typed (rather than inferred): the inferred union type prints its
+// three fully-expanded member schemas into handles.d.ts, which is served to
+// agents whole and has a size budget. ZodUnion (not ZodType) keeps `.options`.
+export const CurveHandle: z.ZodUnion<
+  readonly [typeof LineHandle, typeof ArcHandle, typeof SplineHandle]
+> = z.union([LineHandle, ArcHandle, SplineHandle])
 export const CircleHandle = handleSchema("circle")
 
 // BREP topology handle schemas (§2A.2.1). Prefix-shape validation only; existence,

package/src/index.ts

@@ -2,4 +2,6 @@ export * from "./api"
 export * from "./types"
 export * from "./host-utils"
 export * from "./handles"
+export * from "./massParameters"
+export * from "./massParameters.ops"
 export * from "./errors"

package/src/massParameters.ops.ts

@@ -0,0 +1,246 @@
+import * as z from "zod"
+import {
+  ContourRecord,
+  CurveRecord,
+  LoftOptions,
+  MAX_LOFT_SECTIONS,
+  MAX_PATH_CURVES,
+  MAX_SWEEP_PATH_POINTS,
+  SweepAlongCurveRecordOptions,
+  SweepOptions,
+  XYZ,
+} from "./massParameters"
+import type { CurveKind, SurfaceKind } from "./massParameters"
+
+/**
+ * The **operation half** of a mass creation-parameter record: which edge or
+ * face of the recipe's solid a kernel step used, the step itself, and the
+ * values a `design.update.parameters` patch may carry.
+ *
+ * Split out of `massParameters.ts` so that each file stays under the size limit
+ * at which the agent runtime still serves a type module in ONE whole read (the
+ * record module alone had grown past it). Do not merge the two back. It is
+ * re-exported from there and from the package root, so every import path keeps
+ * working.
+ *
+ * Everything here is **pure JSON** by construction, exactly as in
+ * {@linkcode MassParametersRecord}: plain objects, numbers and arrays only, one
+ * `{x, y, z}` point shape, no class instances.
+ */
+
+/** Maximum kernel operations chained onto one recipe. */
+export const MAX_OPERATIONS = 8
+/** Maximum edges one fillet/chamfer operation may select. */
+export const MAX_OPERATION_EDGES = 64
+/** Maximum faces one shell operation may open. */
+export const MAX_OPERATION_FACES = 32
+/** Maximum rows in a variable-fillet radius law. */
+export const MAX_FILLET_LAW_SAMPLES = 32
+
+// `XYZ` and the record schemas below are resolved through `z.lazy`: this module
+// and `massParameters.ts` re-export each other, and this one is evaluated first,
+// so their consts are not yet initialised while these schemas are built. The
+// closures run at parse time, when both modules are live.
+const At: z.ZodType<XYZ, XYZ> = z.lazy(() => XYZ)
+
+/**
+ * Which EDGE of the input solid an operation used: its index in
+ * `core.geom.query.brep.listEdges` order at authoring time, the indices of the
+ * two faces it lies between, and its curve kind. This is topology, not
+ * coordinates — it survives a scalar edit of the base recipe (which moves every
+ * edge) and trips on a reorder or a topology change. Read-only: to blend a
+ * different edge, re-select it on the new shape and re-apply the operation.
+ */
+export type EdgeSelector = {
+  index: number
+  faces: [number, number]
+  curve: CurveKind
+  /** Where the edge sits INSIDE its solid: its midpoint in the record's own
+   *  frame, divided by the solid's bounding-box extent — a ratio per axis,
+   *  never a length, so it survives a scalar edit that scales the whole shape.
+   *  Written only when the discriminators above cannot tell two edges apart. A
+   *  tiebreak, never a coordinate fingerprint: a replay checks it within 0.02 of
+   *  the solid's own box and refuses on a miss — it never searches for a better
+   *  candidate. */
+  at?: XYZ
+}
+
+/**
+ * Which FACE of the input solid an operation used: its index in
+ * `core.geom.query.brep.listFaces` order, its surface kind, and the number of
+ * edges in its outer loop. Read-only, like {@linkcode EdgeSelector}.
+ */
+export type FaceSelector = {
+  index: number
+  kind: SurfaceKind
+  edgeCount: number
+  /** The face's centroid under the same normalisation and the same tiebreak
+   *  rule as {@linkcode EdgeSelector}'s `at` — written only where the
+   *  discriminators above cannot separate two faces, which on a freeform solid
+   *  (every face answers `"spline"`) is the common case. */
+  at?: XYZ
+}
+
+/** The input solid's topology at authoring time — the counts a replay checks first. */
+export type TopologyCounts = { faceCount: number; edgeCount: number }
+
+/**
+ * One kernel operation applied to the base recipe's solid, in order. `input`
+ * pins the topology the operation was authored against, so a base edit that
+ * changes the topology is refused rather than mis-applied.
+ *
+ * Edit one by patching the whole list back:
+ * `design.update.parameters(mass, { operations })`.
+ */
+export type OperationRecord =
+  | {
+      op: "fillet"
+      edges: EdgeSelector[]
+      radius: number
+      /** Radius at the far end of the blend contour, internal length units — a
+       *  linear variable blend from `radius`. One edge, and never with `radii`. */
+      endRadius?: number
+      /** The blend's radius law instead: `position` is normalised arc length
+       *  along the blend contour (a ratio 0..1, never converted), `radius` is
+       *  internal length units. 2..32 rows, strictly increasing `position`.
+       *  One edge, and never with `endRadius`. */
+      radii?: { position: number; radius: number }[]
+      input: TopologyCounts
+    }
+  | { op: "chamfer"; edges: EdgeSelector[]; distance: number; input: TopologyCounts }
+  | { op: "shell"; openFaces: FaceSelector[]; thickness: number; input: TopologyCounts }
+  | { op: "offset"; distance: number; input: TopologyCounts }
+
+/**
+ * One value of a `MassParametersPatch` — whatever a record's `values` key (or
+ * `operations`) may hold. Each key you send replaces that value whole — a
+ * scalar, a point, a list or a record (`contour`, `profile`, `sections`,
+ * `path`, `options`, `operations`) alike — so send the complete value you read.
+ */
+export type ParameterPatchValue =
+  | number
+  | XYZ
+  | XYZ[]
+  | ContourRecord
+  | ContourRecord[]
+  | CurveRecord[]
+  | LoftOptions
+  | SweepOptions
+  | SweepAlongCurveRecordOptions
+  | OperationRecord[]
+
+const FaceIndex = z.number().int().nonnegative()
+
+/** See {@linkcode EdgeSelector}. */
+export const EdgeSelector: z.ZodType<EdgeSelector, EdgeSelector> = z.strictObject({
+  index: FaceIndex,
+  faces: z.tuple([FaceIndex, FaceIndex]),
+  curve: z.enum(["line", "arc", "circle", "spline"]),
+  at: At.optional(),
+})
+
+/** See {@linkcode FaceSelector}. */
+export const FaceSelector: z.ZodType<FaceSelector, FaceSelector> = z.strictObject({
+  index: FaceIndex,
+  kind: z.enum(["plane", "cylinder", "cone", "sphere", "torus", "spline"]),
+  edgeCount: z.number().int().positive(),
+  at: At.optional(),
+})
+
+/** See {@linkcode TopologyCounts}. */
+export const TopologyCounts: z.ZodType<TopologyCounts, TopologyCounts> = z.strictObject({
+  faceCount: z.number().int().positive(),
+  edgeCount: z.number().int().positive(),
+})
+
+/** One row of a variable fillet's radius law. See {@linkcode OperationRecord}. */
+const FilletLawRow = z.strictObject({
+  position: z.number().finite().min(0).max(1),
+  radius: z.number().finite().positive(),
+})
+
+/**
+ * See {@linkcode OperationRecord}.
+ *
+ * A variable fillet — `endRadius` or `radii` — names ONE edge: the law is a
+ * property of the blend contour that edge belongs to, and `position` is measured
+ * from that edge's start, so a second edge would have no origin. The two forms
+ * are mutually exclusive and `radii` rows run strictly forward.
+ */
+export const OperationRecord: z.ZodType<OperationRecord, OperationRecord> = z
+  .discriminatedUnion("op", [
+    z.strictObject({
+      op: z.literal("fillet"),
+      edges: z.array(EdgeSelector).min(1).max(MAX_OPERATION_EDGES),
+      radius: z.number().finite().positive(),
+      endRadius: z.number().finite().positive().optional(),
+      radii: z.array(FilletLawRow).min(2).max(MAX_FILLET_LAW_SAMPLES).optional(),
+      input: TopologyCounts,
+    }),
+    z.strictObject({
+      op: z.literal("chamfer"),
+      edges: z.array(EdgeSelector).min(1).max(MAX_OPERATION_EDGES),
+      distance: z.number().finite().positive(),
+      input: TopologyCounts,
+    }),
+    z.strictObject({
+      op: z.literal("shell"),
+      openFaces: z.array(FaceSelector).min(1).max(MAX_OPERATION_FACES),
+      thickness: z.number().finite().positive(),
+      input: TopologyCounts,
+    }),
+    z.strictObject({
+      op: z.literal("offset"),
+      distance: z
+        .number()
+        .finite()
+        .refine((value) => value !== 0, { message: "distance must be non-zero" }),
+      input: TopologyCounts,
+    }),
+  ])
+  .superRefine((operation, ctx) => {
+    if (operation.op !== "fillet") return
+    const { edges, endRadius, radii } = operation
+    if (endRadius === undefined && radii === undefined) return
+    if (endRadius !== undefined && radii !== undefined) {
+      ctx.addIssue({
+        code: "custom",
+        message: "endRadius is mutually exclusive with radii",
+      })
+    }
+    if (edges.length !== 1) {
+      ctx.addIssue({
+        code: "custom",
+        message: "a variable fillet names exactly one edge — the blend contour it runs along",
+      })
+    }
+    if (radii?.some((row, i) => i > 0 && row.position <= radii[i - 1].position)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "radii positions must strictly increase",
+      })
+    }
+  })
+
+/**
+ * One value of a parameter patch. See {@linkcode ParameterPatchValue}.
+ *
+ * Deliberately a CLOSED union of the shapes a record's `values` actually hold —
+ * no `z.unknown()`, nothing recursive: an unrecognised value is a VALIDATION at
+ * the wire, not a silent write of nonsense onto a mass. It only ever widens, so
+ * every value it accepted before it still accepts.
+ */
+export const ParameterPatchValue: z.ZodType<ParameterPatchValue, ParameterPatchValue> = z.lazy(() =>
+  z.union([
+    z.number().finite(),
+    XYZ,
+    z.array(XYZ).max(MAX_SWEEP_PATH_POINTS),
+    ContourRecord,
+    z.array(ContourRecord).max(MAX_LOFT_SECTIONS),
+    z.array(CurveRecord).max(MAX_PATH_CURVES),
+    LoftOptions,
+    SweepOptions,
+    SweepAlongCurveRecordOptions,
+    z.array(OperationRecord).max(MAX_OPERATIONS),
+  ]),
+)