@rulecad/cad 0.2.1 → 0.3.1

package/AGENTS.md

@@ -50,8 +50,8 @@ variable says which rule it comes from. Follow these steps; they're what makes a
 - A part is named in fits as `<item>.<part>`; an object that returns one unnamed shape has one part, `body`.
 - A gap fit can't tell whether holes line up. Where a board screws into a part, add a holes fit
   (`{ "holes": "pcb.board", "into": "case.body", "depth": "m2.insert_length" }`).
-- A part built around another (a case around its board) reads it: `"uses": ["node/carrier"]`, then
-  `carrier.board_w` and `v.carrier.board_holes`. Never copy another object's numbers by hand.
+- A part built around another (a case around its board) reads it: `"uses": ["macropad/pcb"]`, then
+  `pcb.board_w` and `v.pcb.board_holes`. Never copy another object's numbers by hand.
 
 ## Circuit boards
 - `"engine": "pcb"` in the .json; `main(v)` returns a board built with `v.pcb` (see @rulecad/pcb's README).

package/README.md

@@ -96,11 +96,12 @@ which version it holds (`keyboard/keycap@0.1.0`, or `+changes` if it isn't a rel
 
 - `value`: a number, or arithmetic over numbers and names (`+ - * /`, brackets, `min`, `max`, `round`). Rule sets are
   `<namespace>.<rule>`; the object's own variables are bare names. Parsed, never evaluated as code.
-- **Other objects' numbers:** `"uses": ["node/carrier"]` reads another object as a rule set named after it:
-  `carrier.board_w` in an expression, `v.carrier.board_w` in code. It gets the object's variables and, from a board, its
-  outline (`board_x`, `board_y`, `board_w`, `board_d`) and, in code, its mounting holes (`v.carrier.board_holes`, each
-  `{ x, y, d }`). So a case follows its board: change the board and the case rebuilds around it. `"node/carrier@^0.2.0"`
-  also checks the version; `"node/carrier@0.2.0"` reads that release. `cad rules` shows each borrowed number with the
+- **Other objects' numbers:** `"uses": ["macropad/pcb"]` reads another object as a rule set named after it:
+  `pcb.board_w` in an expression, `v.pcb.board_w` in code. It gets the object's variables and, from a board, its
+  outline (`board_x`, `board_y`, `board_w`, `board_d`) and, in code, where each of its parts is (`v.pcb.board_parts`),
+  a shaped board's outline (`board_outline`) and its mounting holes (`v.pcb.board_holes`, each
+  `{ x, y, d }`). So a case follows its board: change the board and the case rebuilds around it. `"macropad/pcb@^0.2.0"`
+  also checks the version; `"macropad/pcb@0.2.0"` reads that release. `cad rules` shows each borrowed number with the
   object and version it came from; two objects can't read each other.
 - `show`: on the rules card `cad show` hands its target (six at most). `interface`: other parts depend on it (versioning will compare these).
 - `tweak: { min, max }`: may be changed with `--set`. Variables without one are fixed by their rule.
@@ -121,6 +122,10 @@ which version it holds (`keyboard/keycap@0.1.0`, or `+changes` if it isn't a rel
   text so punctuation stays small, each straight stroke thickened to whole print lines, dots drawn round, and ↑ ↓ ← →
   as arrows), `anchor(face, size, at)` (where something goes on a face, by anchor), and `cut(a, b)` (a subtract that
   only touches a's faces near b; JSCAD's own splits every face along b's planes, which can leave slivers far away).
+- A rule set can also carry `"footprints"` (pad data from @rulecad/pcb's `fromKicad`, with its source), which a
+  board's code reads as `v.parts.footprints.usb_c`.
+- An object or rule set named with a hyphen (`mx-switch`) is read with an underscore in expressions (`mx_switch.housing_top`),
+  since a hyphen there is a minus.
 - Rules carry `kind`: spec (manufacturer), default (slicer), community (rule of thumb) or measured (your own test
   print, which beats the rest), plus `source` and `checked`.
 
@@ -191,6 +196,8 @@ other items' variables, so a keycap can sit exactly where its slot meets the swi
   Objects with `"role": "reference"` (the MX switch) model things you don't print: drawn faint, never exported.
 - **plate** assemblies lay objects out on the bed: they're checked as one print and `export` writes one 3MF with an
   object per part. Supports are kept.
+- **Turning:** `"rotate": [0, 180, 0]` turns an item (degrees about x, y, z, in that order) about its own origin
+  before `at` moves it: a pod on a side mount, or a lid modelled face down as it prints.
 - **Components:** an item can be a whole assembly (`"assembly": "keycap-on-switch"`). Its parts, fits and `requires`
   come along, named per copy (`key-1-1.cap.cap`), and its overlaps are still checked inside each copy.
 - **Repeats:** `"repeat": { "x": { "count": "plate.cols", "step": "plate.pitch" }, "y": { … } }` places a grid of

package/lib/design.mjs

@@ -46,10 +46,10 @@ export function locate(ref) {
 }
 
 // ---------- objects that read each other ----------
-// "uses": ["node/carrier"] reads another object's numbers as a rule set named after it (carrier.board_w in an
-// expression, v.carrier.board_w in code): its variables, and what a board tells the parts around it (board_x, board_y,
-// board_w, board_d, and board_holes for code). The object is built (cached) first. "node/carrier@^0.2.0" also checks
-// its version; "node/carrier@0.2.0" reads that release instead of the working copy.
+// "uses": ["macropad/pcb"] reads another object's numbers as a rule set named after it (pcb.board_w in an
+// expression, v.pcb.board_w in code): its variables, and what a board tells the parts around it (board_x, board_y,
+// board_w, board_d, and for code board_holes, board_parts (where each part is) and board_outline, for a shaped board). The object is built (cached) first. "macropad/pcb@^0.2.0" also checks
+// its version; "macropad/pcb@0.2.0" reads that release instead of the working copy.
 export const isObjectRef = (u) => String(u).includes('/');
 const building = new Set();
 export async function objectSets(d, object) {
@@ -69,7 +69,7 @@ export async function objectSets(d, object) {
         rules[k] = { value: v, unit: units[k] ?? 'mm', rule: `${ref}'s ${k}`, kind: 'design', source: `${ref}@${version}` };
       }
       sets[u] = { name: base.name, rules };
-      if (b.circuit) extra[base.name] = { board_holes: (await pcbEngine()).holes(b.circuit) };
+      if (b.circuit) { const e = await pcbEngine(), board = b.circuit.find((x) => x.type === 'pcb_board'); extra[base.name] = { board_holes: e.holes(b.circuit), board_parts: e.parts ? e.parts(b.circuit) : {}, ...(board.outline ? { board_outline: board.outline } : {}) }; }
     }
   } finally { building.delete(self); }
   return { sets, extra };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulecad/cad",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "The cad command: JSCAD designs from traceable rules, checked for printing and fit, versioned by what fits, shared as links and exported as Bambu 3MF.",
   "type": "module",
   "bin": {
@@ -43,19 +43,19 @@
     "directory": "packages/cad"
   },
   "dependencies": {
-    "@rulecad/variables": "^0.1.0",
+    "@rulecad/variables": "^0.1.4",
     "@rulecad/keyboard-layout": "^0.1.2",
     "@rulecad/printcheck": "^0.1.0",
     "@rulecad/fit": "^0.2.0",
     "@rulecad/model-link": "^0.1.2",
     "@rulecad/versions": "^0.1.0",
-    "@rulecad/shapes": "^0.1.0",
+    "@rulecad/shapes": "^0.2.0",
     "@rulecad/rules": "^0.2.0",
     "@jscad/modeling": "^2.12.0",
     "three": "^0.186.1"
   },
   "peerDependencies": {
-    "@rulecad/pcb": "^0.1.0 || ^0.2.0"
+    "@rulecad/pcb": "^0.1.0 || ^0.2.0 || ^0.3.0"
   },
   "peerDependenciesMeta": {
     "@rulecad/pcb": {