@mylasertools/kerfscript 0.2.0 → 0.3.0

package/docs/openscad.md

@@ -1,67 +1,71 @@
 # Coming from OpenSCAD
 
-KerfScript borrows OpenSCAD's syntax on purpose: if you have written
-OpenSCAD, you can read KerfScript and write it within minutes. It is not a
-drop-in replacement. It only makes flat parts, and a few rules are different.
-OpenSCAD files do not run unchanged.
+KerfScript uses syntax familiar to OpenSCAD users, with features for laser
+cutting. Existing OpenSCAD files may need changes to run in KerfScript.
+This guide covers the shared syntax and the differences that affect a port.
 
 ## The same
 
-- Statements, modules, functions, `for`, `if`, `let`, `each`, list
-  comprehensions, ranges like `[0:2:10]`, function literals.
+You can use familiar building blocks:
+
+- Modules, functions, `for`, `if`, `let`, `each`, list comprehensions,
+  ranges and function literals.
 - `children()`, `children(i)` and `$children`.
-- Special variables that start with `$` are dynamically scoped, and `$fn`,
-  `$fa` and `$fs` set curve resolution.
-- 2D shapes: `square()` (also called `rect()`), `circle(r)` or `circle(d =)`,
-  `polygon(points, paths)`, `text()`.
-- Transforms: `translate`, `rotate`, `scale`, `mirror`, `multmatrix`.
-- Combining: `union`, `difference`, `intersection`, `hull`, `offset(r)`,
-  `offset(delta, chamfer)`.
+- Dynamically scoped `$` variables, plus `$fn`, `$fa` and `$fs` for curve
+  resolution.
+- 2D shapes: `square()` or `rect()`, `circle()`, `polygon()` and `text()`.
+- Transforms: `translate`, `rotate`, `scale`, `mirror` and `multmatrix`.
+- Shape operations: `union`, `difference`, `intersection`, `hull` and `offset`.
 - `echo()`, `assert()`, `use <...>` and `include <...>`.
-- Customizer comments: `// [40:5:400]`, `/* [Group] */`, `/* [Hidden] */`,
-  and captions on the line above. Tools that read OpenSCAD settings read
-  these.
+- Customizer comments for ranges, choices, groups and captions.
+
+See the [language reference](../LANGUAGE.md) for supported arguments.
 
 ## Different
 
-|             | OpenSCAD                                      | KerfScript                                                      |
-| ----------- | --------------------------------------------- | --------------------------------------------------------------- |
-| Output      | a solid, as STL, 3MF and more                 | a cut file, as SVG or DXF                                       |
-| Dimensions  | 3D, and 2D for export                         | 2D only                                                         |
-| Assignments | the last one in a scope wins everywhere in it | run in order; a later one takes effect from that line           |
-| Errors      | many mistakes give `undef` and a warning      | type mistakes stop the program, naming the line                 |
-| `color()`   | colours a shape                               | not available; use `cut()`, `score()`, `engrave()` or `layer()` |
-| Fonts       | system fonts                                  | only fonts you pass in, so a file renders the same everywhere   |
-| Libraries   | any file on disk                              | the standard library and whatever the host allows               |
+| Feature     | OpenSCAD                                                     | KerfScript                                                 |
+| ----------- | ------------------------------------------------------------ | ---------------------------------------------------------- |
+| Geometry    | 3D and 2D                                                    | 2D parts for laser cutting                                 |
+| Output      | 3D formats and 2D exports                                    | SVG and DXF with operation layers                          |
+| Assignments | The last assignment in a scope applies throughout that scope | Assignments take effect in order                           |
+| Type errors | Many produce `undef` and a warning                           | Stop evaluation with an error                              |
+| `color()`   | Sets a shape's colour                                        | Use `cut()`, `score()`, `engrave()` or `layer()`           |
+| Fonts       | Looks up system fonts                                        | Uses fonts supplied by the application or CLI              |
+| Libraries   | Can load local files                                         | Loads the standard library and sources allowed by the host |
+
+Assignment order is especially important when adapting a design. A value
+assigned later in a KerfScript program does not change earlier geometry.
 
 ## Not in KerfScript
 
-3D modules (`cube`, `sphere`, `cylinder`, `polyhedron`,
-`linear_extrude`, `rotate_extrude`, `projection`), `minkowski`, `resize`,
-`color`, `import`, `surface` and `render`. Each stops with an error that
-names it, so you find out at once.
+KerfScript does not support `cube`, `sphere`, `cylinder`, `polyhedron`,
+`linear_extrude`, `rotate_extrude` or `projection`. It also does not support
+`minkowski`, `resize`, `color`, `import`, `surface` or `render`.
+
+Calls to these modules produce an error. For a design based on an extruded
+2D outline, start with that outline and remove the extrusion.
 
 ## Only in KerfScript
 
-- Layers: `cut()`, `score()`, `engrave()`, `guide()` and `layer()`.
-  See [Layers](layers.md).
-- Kerf compensation with `$kerf`. See [Kerf](kerf.md).
-- Parts, quantities, materials and sheet packing: `part()`, `material()`,
-  `$sheet`, `$gap`. See [Parts and sheets](parts-and-sheets.md).
-- Joinery that reads `$thickness`: `finger_rect`, `finger_holes`, `tslot`,
-  `living_hinge`.
-- Lines as well as areas: `line()`, `polyline()`, `arc()`, `path()`,
-  `stroke()` and `outline()`.
-- Shapes OpenSCAD lacks: `ellipse`, `regular_polygon`, `star`, rounded
-  `rect(r =)`.
-- `text_width()` and `text_metrics()`, to size a part to its text.
+- **Operations:** `cut()`, `score()`, `engrave()`, `guide()` and `layer()`.
+- **Material settings:** `$kerf` for cut compensation and `$thickness` for
+  material-dependent joints.
+- **Parts and layout:** `part()`, `material()`, quantities, `$sheet` and `$gap`.
+- **Joinery:** `finger_rect`, `finger_holes`, `tslot` and `living_hinge`.
+- **Paths:** `line`, `polyline`, `arc`, `path`, `stroke` and `outline`.
+- **Additional shapes:** `ellipse`, `regular_polygon`, `star` and rounded
+  rectangles with `rect(r = ...)`.
+- **Text measurement:** `text_width()` and `text_metrics()`.
 
 ## Porting a 2D design
 
-1. Drop `linear_extrude()` and any 3D parts.
-2. Replace `color()` with the layer the shape belongs on.
-3. Check assignments: code that relied on a later assignment overriding an
-   earlier one should assign once.
-4. Pass the fonts your `text()` calls use.
-5. Add `$kerf` and `$thickness`, and replace hand-made finger joints with
-   `finger_rect()` if you want them to follow the material.
+1. Keep the 2D geometry and remove extrusion or other 3D operations.
+2. Assign shapes to cut, score or engrave layers.
+3. Check repeated assignments and put each value before the code that uses it.
+4. Supply the fonts used by `text()`.
+5. Set the measured material thickness and kerf. Use the joinery modules
+   where they suit the design.
+
+Render the result and check the dimensions and layers before exporting.
+The [layers](layers.md), [kerf](kerf.md) and
+[parts and sheets](parts-and-sheets.md) guides cover those steps.

package/docs/parts-and-sheets.md

@@ -1,7 +1,8 @@
 # Parts and sheets
 
-A design often has more than one piece. KerfScript lets you name each piece,
-say how many you need and what it is cut from, and lays them out on sheets.
+Use parts to name the pieces in a design, set quantities and assign
+materials. KerfScript lays them out on sheets, grouping parts that use the
+same material and thickness.
 
 ## Parts
 
@@ -10,16 +11,27 @@ part("side", qty = 2) rect([100, 60]);
 part("base") rect([100, 100]);
 ```
 
-`part(name, qty = 1)` makes a named part. Everything inside it is one piece
-with its own layers. Shapes outside any part form one part called `part`.
+This creates two side panels and one base. Each `part()` has its own layers
+and appears in the parts list with dimensions and cut length. The default
+quantity is one.
 
-Parts show up in the part list with their size and cut length, which the
-playground and `kerf check` print.
+Shapes outside a `part()` are collected into a part named `part`.
+
+Transforms and operations such as `translate()`, `difference()` and
+`offset()` can wrap a part and change all of it. Layer wrappers such as
+`score()` and `engrave()` go inside the part instead, since a whole part on
+the score layer would have nothing to cut:
+
+```kerf
+part("tag") {
+  rect([60, 30], r = 3);
+  score() translate([5, 5]) rect([50, 20]);
+}
+```
 
 ## Materials
 
-Each part records `$thickness`, `$kerf` and `$material` where it is made.
-`material()` sets all three for the parts inside it:
+`material()` sets the thickness, kerf and material name for its parts:
 
 ```kerf
 material(thickness = 3, kerf = 0.15, name = "plywood") {
@@ -31,38 +43,40 @@ material(thickness = 2, kerf = 0.1, name = "acrylic") {
 }
 ```
 
-## Sheets
-
-With the default `$layout = "pack"`, KerfScript:
+The two plywood panels share a sheet. The acrylic window goes on a separate
+sheet. Each part records the `$thickness`, `$kerf` and `$material` values in
+effect where it is defined.
 
-1. groups parts by material and thickness,
-2. copies each part `qty` times,
-3. turns a part 90° when that makes it fit,
-4. packs them in rows onto sheets of `$sheet` (600 by 400 mm by default),
-   with `$gap` millimetres between parts and around the edge.
+## Sheets
 
-A part bigger than the sheet gives a warning. With `$layout = "none"` parts
-stay where your program put them.
+Set the available sheet size and spacing in millimetres:
 
 ```kerf
 $sheet = [300, 200];
 $gap = 4;
 ```
 
-## One file per sheet
+With the default `$layout = "pack"`, KerfScript arranges copies of each part
+in rows, leaving the specified gap. It rotates a part 90° if that lets it
+fit the sheet. The default sheet is 600 × 400 mm, with a 3 mm gap between
+parts and at the sheet edges.
 
-The design above makes two sheets: one of plywood and one of acrylic. The
-combined SVG shows every sheet stacked one above the other, which is useful
-for a preview but is **not** a cutting job: the sheets are different
-materials.
+A part larger than the sheet produces a warning. Set `$layout = "none"`
+to keep the positions from your code instead of packing the parts.
+
+The CLI `--margin` option and API `margin` option let you set the edge
+spacing separately from the gap between parts.
+
+## One file per sheet
 
-Cut each sheet as its own job:
+A combined SVG stacks all sheets in one preview. For the material example
+above, export the plywood and acrylic sheets separately and cut each with
+the matching material settings.
 
-- On the command line, `--split` writes one file per sheet
-  (`design-1.svg`, `design-2.svg`, ...). `kerf check` lists the sheets with
-  their material and thickness.
-- From JavaScript, `result.sheets` has an SVG and a DXF for each sheet, with
-  its `material` and `thickness`.
+- On the command line, add `--split` to write `design-1.svg`,
+  `design-2.svg` and so on. `kerf check` lists each sheet's material and
+  thickness.
+- In JavaScript, `result.sheets` provides the SVG, DXF, material and
+  thickness for each sheet.
 
-Before cutting, check that each file's material and thickness match the
-sheet in your machine.
+DXF exports contain one sheet per file.

package/docs/versions.md

@@ -1,43 +1,33 @@
 # Versions
 
-KerfScript has two version numbers.
+KerfScript 0.3.0 implements language version 0.1. The package version tracks
+the software release; the language version tracks the syntax and behavior
+of `.kerf` programs.
 
-- The **language version** (now 0.1) covers what `.kerf` files mean: the
-  syntax, the built-in modules and functions, and the rules for layers, kerf
-  and parts. The [language reference](../LANGUAGE.md) describes one language
-  version.
-- The **package version** (now 0.2.0) is the version of the interpreter, the
-  `kerf` command and the JavaScript API. It changes more often: bug fixes,
-  new output options and API additions do not change the language.
-
-The site footer, `kerf --version` and the `VERSION` and `LANGUAGE_VERSION`
-exports show both.
+Package updates can include bug fixes, export options and JavaScript API
+changes without changing the language version. Use `kerf --version` to see
+both numbers, or read the `VERSION` and `LANGUAGE_VERSION` exports in JavaScript.
 
 ## Before 1.0
 
-KerfScript is young, and the language may still change before 1.0. What we
-promise in the meantime:
+The language may change before 1.0. Release notes identify changes that
+affect existing programs or their output, including geometry and text layout
+fixes. Removing or renaming a language feature requires a new language version.
 
-- **Changes are written down.** Every change that can alter what a file
-  produces is listed in the changelog under the version that made it.
-- **Files keep running where we can manage it.** A program that worked keeps
-  working, or stops with an error that says what to change. It does not
-  silently start cutting something different.
-- **Geometry changes are called out.** If the same file starts producing
-  different geometry, for example after a packing or text layout fix, the
-  changelog says which designs are affected.
-- **Breaking changes raise the language version.** Package releases within
-  one language version do not remove or rename anything in the language.
+Check the changelog when upgrading a tool that renders saved designs.
 
 ## From 1.0
 
-From language version 1.0, `.kerf` files written for 1.x keep producing the
-same parts in every later 1.x interpreter, apart from bug fixes listed in the
-changelog. New features are additions. Anything that would change existing
-files waits for 2.0.
+The compatibility policy for language version 1.x is to keep existing
+programs working throughout that series. New features will be added without
+changing existing syntax. Bug fixes that affect output will be listed in
+the changelog; other breaking changes will require language version 2.0.
 
 ## Pinning a version
 
-Hosts that store designs, like MyLaserTools, record which interpreter
-version a design was published with, so a stored design can be checked
-against later versions before it is upgraded.
+For repeatable exports, record the interpreter version, settings and font
+files used with a design. Applications that store designs should retain
+that information and compare the output before upgrading the interpreter.
+
+Pin the npm package to an exact version when your application needs a fixed
+renderer, for example `@mylasertools/kerfscript@0.3.0`.

package/docs/webassembly.md

@@ -0,0 +1,131 @@
+# WebAssembly
+
+`kerfscript.wasm` runs KerfScript from any language that can host a
+WebAssembly module: Python, Rust, Go, C#, Java, Ruby and others. It is a
+WASI (preview 1) module built from the same source as the JavaScript package,
+so it makes the same SVG and DXF files, byte for byte.
+
+For JavaScript applications, use the [JavaScript API](javascript.md)
+instead: it is smaller and faster.
+
+## Getting the module
+
+Download `kerfscript-<version>.wasm` from the
+[releases](https://github.com/mylasertools/kerfscript/releases) page and save
+it as `kerfscript.wasm`, or get `kerfscript-wasm-<version>.zip`, which has the
+module with this guide and its licences. You can also build it from the
+repository with [Javy](https://github.com/bytecodealliance/javy):
+
+```sh
+npm run build
+npm run wasm        # writes dist/kerfscript.wasm
+```
+
+Set `JAVY` to the javy binary if it is not on the `PATH`.
+
+## How it works
+
+The module reads one JSON request from standard input, writes one JSON
+response to standard output and exits. Start a fresh instance for each
+request. From a shell, with [Wasmtime](https://wasmtime.dev):
+
+```sh
+echo '{"source": "rect([80, 50]);"}' | wasmtime run kerfscript.wasm
+```
+
+### Request
+
+| Field         | Value                                                                       |
+| ------------- | --------------------------------------------------------------------------- |
+| `command`     | `"render"` (default), `"params"`, `"version"` or `"licenses"`               |
+| `source`      | The program, as a string                                                    |
+| `params`      | Parameter values keyed by name                                              |
+| `files`       | Libraries for `include` and `use`, keyed by path: `{"lib/tab.kerf": "..."}` |
+| `fonts`       | Font files keyed by name, base64 encoded. `Atkinson` is built in            |
+| `defaultFont` | Name to use when `text()` does not specify a font                           |
+| `kerf`        | Kerf override for every part, in millimetres                                |
+| `layout`      | `"pack"` (default) or `"none"`                                              |
+| `sheet`       | Sheet size `[width, height]` in millimetres                                 |
+| `gap`         | Space between packed parts                                                  |
+| `margin`      | Space between the parts and the sheet edge                                  |
+| `guides`      | `true` to include guide layer geometry                                      |
+
+These match the [render() options](javascript.md#options). A path in `files`
+can leave out `.kerf`, as in the program.
+
+### Response
+
+Every response has `ok`. When it is `false`, `error` holds the message and
+`echoes` holds what the program echoed before it stopped. The module never
+exits with an error code for a bad program.
+
+- `render`: `svg` (all sheets, for preview), `width`, `height`, `parts`,
+  `warnings`, `echoes` and `sheets`. Each sheet has `width`, `height`,
+  `material`, `thickness`, `svg` and `dxf`; write one file per sheet to cut.
+- `params`: `parameters`, as from [`parameters()`](javascript.md).
+- `version`: `version` (package) and `language`.
+- `licenses`: `files`, the licence texts of the module and of everything
+  built into it, keyed by file name: `LICENSE`, `COMMERCIAL-LICENSE.md`,
+  `THIRD-PARTY-NOTICES.md`, `THIRD-PARTY-LICENSES.md` (the JavaScript engine
+  and its Rust crates) and `OFL.txt`. The release ZIP has the same files.
+
+## Python
+
+With the [`wasmtime`](https://pypi.org/project/wasmtime/) package:
+
+```python
+import json, os, tempfile
+from wasmtime import Engine, Linker, Module, Store, WasiConfig
+
+engine = Engine()
+module = Module.from_file(engine, "kerfscript.wasm")
+linker = Linker(engine)
+linker.define_wasi()
+
+def kerf(request):
+    with tempfile.TemporaryDirectory() as d:
+        inp, out = os.path.join(d, "in.json"), os.path.join(d, "out.json")
+        with open(inp, "w", encoding="utf-8") as f:
+            json.dump(request, f)
+        wasi = WasiConfig()
+        wasi.stdin_file = inp
+        wasi.stdout_file = out
+        store = Store(engine)
+        store.set_wasi(wasi)
+        linker.instantiate(store, module).exports(store)["_start"](store)
+        with open(out, encoding="utf-8") as f:
+            return json.load(f)
+
+result = kerf({"source": "w = 80; rect([w, 50]);", "params": {"w": 120}})
+for i, sheet in enumerate(result["sheets"]):
+    with open(f"sheet-{i + 1}.svg", "w", encoding="utf-8", newline="") as f:
+        f.write(sheet["svg"])
+```
+
+Compile the module once and reuse it; each request only needs a new `Store`.
+
+## Node.js
+
+The JavaScript package is the better fit in Node.js, but the module also runs
+under `node:wasi`, which is how the test suite checks it:
+
+```js
+import { closeSync, openSync, readFileSync, writeFileSync } from 'node:fs';
+import { WASI } from 'node:wasi';
+
+const module = await WebAssembly.compile(readFileSync('kerfscript.wasm'));
+writeFileSync('in.json', JSON.stringify({ source: 'rect([80, 50]);' }));
+const stdin = openSync('in.json', 'r');
+const stdout = openSync('out.json', 'w');
+const wasi = new WASI({ version: 'preview1', stdin, stdout, returnOnExit: true });
+wasi.start(await WebAssembly.instantiate(module, wasi.getImportObject()));
+closeSync(stdin);
+closeSync(stdout);
+console.log(JSON.parse(readFileSync('out.json', 'utf8')).svg);
+```
+
+## Performance
+
+The module carries its own JavaScript engine (QuickJS), so it is about 2 MB
+and renders roughly three to five times slower than Node.js. The example
+designs take well under a second.

package/fonts/OFL.txt

@@ -0,0 +1,92 @@
+Copyright 2020 Braille Institute of America, Inc.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@mylasertools/kerfscript",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "KerfScript: a programming language for laser cutting. Write parametric 2D parts with cut, score and engrave layers, kerf compensation and joinery, and export SVG or DXF.",
   "type": "module",
   "license": "AGPL-3.0-only",
   "author": "MyLaserTools",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/mylasertools-com/kerfscript.git"
+    "url": "git+https://github.com/mylasertools/kerfscript.git"
   },
-  "bugs": "https://github.com/mylasertools-com/kerfscript/issues",
+  "bugs": "https://github.com/mylasertools/kerfscript/issues",
   "keywords": [
     "kerfscript",
     "laser-cutting",
@@ -45,12 +45,14 @@
   },
   "files": [
     "dist",
+    "!dist/kerfscript.wasm",
     "README.md",
     "docs",
     "LANGUAGE.md",
     "LICENSE",
     "COMMERCIAL-LICENSE.md",
     "THIRD-PARTY-NOTICES.md",
+    "fonts/OFL.txt",
     "CHANGELOG.md",
     "TRADEMARKS.md",
     "CLA.md"
@@ -70,9 +72,11 @@
     "site": "npm run build && npm --prefix site run build",
     "site:serve": "npm --prefix site run preview",
     "prepack": "npm run check",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "compat": "node scripts/compat.mjs"
+    "format": "prettier --write . --ignore-path .gitignore --ignore-path .prettierignore --ignore-path .git/info/exclude",
+    "format:check": "prettier --check . --ignore-path .gitignore --ignore-path .prettierignore --ignore-path .git/info/exclude",
+    "compat": "node scripts/compat.mjs",
+    "wasm": "node scripts/wasm.mjs",
+    "readme-images": "npm run build && cd site && node ../scripts/readme-images.mjs"
   },
   "devDependencies": {
     "@types/node": "20.19.43",