@snaptrude/plugin-client 0.2.9 → 0.5.0

package/AGENTS.md

@@ -7,13 +7,16 @@ Plugins import `snaptrude` from this package to interact with the Snaptrude host
 
 > Source of truth: [`packages/plugin-core/AGENTS.md`](../plugin-core/AGENTS.md)
 
-This package **extends** every abstract class defined in `@snaptrude/plugin-core`.
-When plugin-core changes, this package must be updated to match.
+This package implements the API surface defined in `@snaptrude/plugin-core`. Only the
+root `PluginApi` class is extended; every namespace under it is satisfied structurally
+by a generic RPC proxy (see below). When plugin-core changes its top-level shape,
+this package must be updated to match.
 
 ## What this package contains
 
-- `src/api/` — Concrete implementations of all plugin-core abstract APIs
-- `src/host-api.ts` — Comlink RPC wrapper (`HostApi.call()`) for host API calls
+- `src/api/index.ts` — `ClientPluginApi`: wires one generic RPC proxy per top-level namespace
+- `src/rpc-proxy.ts` — `createRpcNamespace()`: Proxy mapping dotted property paths to host RPC calls
+- `src/host-api.ts` — Comlink RPC wrapper (`HostApi.call()`); unwraps success/error results
 - `src/plugin-worker.ts` — `PluginWorker` base class (lifecycle, UI messaging, Comlink exposure)
 - `src/index.ts` — Exports the `snaptrude` singleton (`ClientPluginApi` instance)
 
@@ -27,62 +30,51 @@ pnpm dev            # tsup watch mode
 
 ## Implementation patterns
 
-### Pure math/geometry (sync, local)
+### Everything is a generic RPC proxy (async, remote)
 
-Methods on `core.math.*` and `core.geom.*` are implemented directly — they inherit
-the base class implementation or override with equivalent logic. No RPC involved.
+Under the all-handle model there is no in-worker compute: `core.math.*` and
+`core.geom.*` values are opaque handles, so **every** namespace — `core.*`
+(including `core.units`), `design.*`, `entity.*`, `tools.*` — is a
+`createRpcNamespace<PluginXApi>("x")` Proxy. There are no hand-written
+per-method wrappers. Nested property access builds the dot-separated method
+path; the call marshals `{ method, args }` to the host via Comlink
+(`getHostApi().call()`):
 
 ```typescript
-// Example: ClientVec3Api inherits PluginVec3Api directly
-export class ClientVec3Api extends PluginVec3Api {}
-```
-
-### Host API calls (async, RPC)
-
-Methods on `entity.*`, `tools.*`, and `units.*` marshal calls to the host via Comlink:
+// src/api/index.ts — one proxy per top-level namespace
+this.core = createRpcNamespace<PluginCoreApi>("core")
 
-```typescript
-public async createRectangular(args: PluginSpaceCreateRectangularArgs) {
-  const hostApi = getHostApi()
-  return hostApi.call({
-    method: "entity.space.createRectangular",
-    args,
-  })
-}
+// Plugin code — positional args (whole tuple crosses the wire), values are handles:
+const v = await snaptrude.core.math.vec3.new(1, 2, 3)
+await snaptrude.entity.space.createRectangular(position, dimensions)
+//   → getHostApi().call({ method: "entity.space.createRectangular", args: [position, dimensions] })
 ```
 
-The `method` string must match the dot-separated path from `PluginApiMethod` (auto-inferred
-from the class hierarchy in `plugin-core/src/host-utils.ts`).
+The proxy is structurally cast to the abstract API type, so argument and return
+types are enforced by plugin-core while dispatch stays dynamic. The `method`
+string is exactly the property path and must match `PluginApiMethod`
+(auto-inferred from the class hierarchy in `plugin-core/src/host-utils.ts`).
 
 ## When to update this package
 
-- **plugin-core adds a new abstract method**: Add the concrete implementation here
-- **plugin-core removes a method**: Remove the implementation here
-- **plugin-core changes a signature**: Update the method signature + call args here
-- **plugin-core adds a new API module**: Create a matching file under `src/api/`, wire
-  into the parent barrel (`index.ts`), and add to `ClientPluginApi`
+- **plugin-core adds/removes/changes a method**: Usually nothing to do here — the
+  proxy dispatches dynamically and types flow from plugin-core. Rebuild plugin-core,
+  then run `pnpm check-types` here.
+- **plugin-core adds a new top-level namespace on `PluginApi`**: Add a matching
+  `createRpcNamespace<PluginNewApi>("new")` property in `ClientPluginApi`
+  (`src/api/index.ts`). Nested modules under an existing namespace need no wiring.
 
 After making changes, always run `pnpm check-types` to verify everything compiles.
 
 ## File mapping (plugin-core -> plugin-client)
 
-| plugin-core                           | plugin-client                          |
-| ------------------------------------- | -------------------------------------- |
-| `src/api/core/math/vec3.ts`           | `src/api/core/math/vec3.ts`            |
-| `src/api/core/math/quat.ts`           | `src/api/core/math/quat.ts`            |
-| `src/api/core/geom/line.ts`           | `src/api/core/geom/line.ts`            |
-| `src/api/core/geom/arc.ts`            | `src/api/core/geom/arc.ts`             |
-| `src/api/core/geom/curve.ts`          | `src/api/core/geom/curve.ts`           |
-| `src/api/core/geom/profile.ts`        | `src/api/core/geom/profile.ts`         |
-| `src/api/entity/space.ts`             | `src/api/entity/space.ts`              |
-| `src/api/entity/story.ts`             | `src/api/entity/story.ts`              |
-| `src/api/entity/referenceLine.ts`     | `src/api/entity/referenceLine.ts`      |
-| `src/api/entity/department.ts`        | `src/api/entity/department.ts`         |
-| `src/api/entity/buildableEnvelope.ts` | `src/api/entity/buildableEnvelope.ts`  |
-| `src/api/tools/selection.ts`          | `src/api/tools/selection.ts`           |
-| `src/api/tools/transform.ts`          | `src/api/tools/transform.ts`           |
-| `src/api/units/index.ts`              | `src/api/units/index.ts`               |
-| `src/api/index.ts` (`PluginApi`)      | `src/api/index.ts` (`ClientPluginApi`) |
+There are no per-namespace files here anymore — the whole plugin-core API tree is
+served by two files:
+
+| plugin-core                                   | plugin-client                                                        |
+| --------------------------------------------- | -------------------------------------------------------------------- |
+| `src/api/**` (all namespaces, e.g. `core.math.vec3`) | `src/api/index.ts` (`ClientPluginApi`, one `createRpcNamespace` each) |
+| `src/host-utils.ts` (`PluginApiMethod` types) | `src/rpc-proxy.ts` + `src/host-api.ts` (dispatch + Comlink transport) |
 
 ## Downstream consumers
 

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @snaptrude/plugin-client
 
+## 0.5.0
+
+### Minor Changes
+
+- 7750aa3: Exposed more snaptrude APIs
+
+### Patch Changes
+
+- Updated dependencies [7750aa3]
+  - @snaptrude/plugin-core@0.5.0
+
 ## 0.2.9
 
 ### Patch Changes

package/CLAUDE.md

@@ -5,7 +5,7 @@
 
 See [AGENTS.md](AGENTS.md) for:
 
-- Implementation patterns (sync math vs async RPC)
+- Implementation pattern (generic RPC proxy — every namespace is async host RPC)
 - File mapping from plugin-core to plugin-client
 - When and how to update this package in response to plugin-core changes
 - Downstream consumer notes

package/dist/api/index.d.ts

@@ -1,22 +1,18 @@
-import { ClientCoreApi } from "./core";
-import { ClientEntityApi } from "./entity";
-import { ClientToolsApi } from "./tools";
-import { ClientUnitsApi } from "./units";
-import { ClientDocumentationApi } from "./documentation";
-import { PluginApi } from "@snaptrude/plugin-core";
+import { PluginApi, PluginCoreApi, PluginDesignApi, PluginEntityApi, PluginProgramApi, PluginPresentationApi } from "@snaptrude/plugin-core";
 export declare class ClientPluginApi extends PluginApi {
     private static instance;
-    core: ClientCoreApi;
-    tools: ClientToolsApi;
-    entity: ClientEntityApi;
-    units: ClientUnitsApi;
-    documentation: ClientDocumentationApi;
+    /**
+     * Every namespace is fully remote under the all-handle model: math/geom now
+     * cross to the host (values are opaque handles), so there is no in-worker
+     * compute left. All dispatch through a single generic RPC Proxy. Units live
+     * under `core.units`, so they ride the `core` proxy.
+     */
+    core: PluginCoreApi;
+    design: PluginDesignApi;
+    entity: PluginEntityApi;
+    program: PluginProgramApi;
+    presentation: PluginPresentationApi;
     private constructor();
     static getInstance(): ClientPluginApi;
 }
-export * from "./core";
-export * from "./documentation";
-export * from "./entity";
-export * from "./tools";
-export * from "./units";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AACtC,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACxC,OAAO,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAElD,qBAAa,eAAgB,SAAQ,SAAS;IAC5C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAiB;IAEjC,IAAI,EAAE,aAAa,CAAA;IACnB,KAAK,EAAE,cAAc,CAAA;IACrB,MAAM,EAAE,eAAe,CAAA;IACvB,KAAK,EAAE,cAAc,CAAA;IACrB,aAAa,EAAE,sBAAsB,CAAA;IAE5C,OAAO;IASP,MAAM,CAAC,WAAW,IAAI,eAAe;CAMtC;AAED,cAAc,QAAQ,CAAA;AACtB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,aAAa,EACb,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACtB,MAAM,wBAAwB,CAAA;AAG/B,qBAAa,eAAgB,SAAQ,SAAS;IAC5C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAiB;IAExC;;;;;OAKG;IACI,IAAI,EAAE,aAAa,CAAA;IACnB,MAAM,EAAE,eAAe,CAAA;IACvB,MAAM,EAAE,eAAe,CAAA;IACvB,OAAO,EAAE,gBAAgB,CAAA;IACzB,YAAY,EAAE,qBAAqB,CAAA;IAE1C,OAAO;IAUP,MAAM,CAAC,WAAW,IAAI,eAAe;CAMtC"}