@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/types/kit/textfit.d.ts

@@ -0,0 +1,74 @@
+export declare const W = 320;
+export declare const H = 200;
+type RGB = [number, number, number];
+/** A string PLAYGAME writes, in a palette index, at a pixel position. */
+interface TextItem {
+    x: number;
+    y: number;
+    col: number;
+    text: string;
+    /** The color PLAYGAME asked for (RGBRed and friends); flagged when the screen shows something else. */
+    want?: RGB;
+    /** Marker boxes (menu cursors) are solid fills, not glyphs. */
+    box?: {
+        w: number;
+        h: number;
+    };
+}
+/** One screen as shown: the picture under the text, the palette on the DAC and the text. */
+export interface TextScreen {
+    /** Where it comes from, e.g. "help.lst > help.txt p1". */
+    name: string;
+    kind: 'page' | 'menu' | 'scores' | 'load' | 'save';
+    pixels: Uint8Array;
+    palette: Uint8Array;
+    texts: TextItem[];
+}
+export interface TextFitIssue {
+    screen: string;
+    text: string;
+    x: number;
+    y: number;
+    /** Background pixels near the letters that are not the paper under them. */
+    artPixels: number;
+    /** WCAG contrast ratio of the text color against its paper. */
+    contrast: number;
+    problems: string[];
+}
+interface TextFitOptions {
+    /** Pixels around each line that must be plain paper (default 2). */
+    margin?: number;
+    /** RGB distance (8-bit) from the paper that counts as art (default 72). */
+    artDistance?: number;
+    /** Art pixels tolerated per line (default 0). */
+    allowArt?: number;
+    /** Lowest contrast ratio allowed (default 3). */
+    minContrast?: number;
+}
+export declare function readDisk(dir: string): Map<string, Uint8Array>;
+/**
+ * Every screen where PLAYGAME draws text over this game's pictures. `ink` is the text pages' RGB
+ * (6-bit), when a game's player patches color.rgb.purple.
+ */
+export declare function textScreens(files: Map<string, Uint8Array>, ink?: RGB): TextScreen[];
+/** Marks every art pixel (not paper) inside a text zone; returns the issues. */
+export declare function checkTextScreen(s: TextScreen, opts?: TextFitOptions, marks?: Uint8Array): TextFitIssue[];
+/** The screen as the player sees it, as 8-bit RGB, with art pixels near text tinted magenta when `marks` is given. */
+export declare function renderRgb(s: TextScreen, marks?: Uint8Array): Uint8Array;
+/** A picture shown between levels (a level scene's intro or ending list), with its palette. */
+export interface CardScreen {
+    name: string;
+    pixels: Uint8Array;
+    palette: Uint8Array;
+}
+/** The pictures every level scene shows around play (slots 9 and 10), as the player sees them. */
+export declare function levelCards(files: Map<string, Uint8Array>): CardScreen[];
+/**
+ * Words baked into a Starter card (games/kit/starter/screens.ts cardPicture) that run past its
+ * parchment box. The box is found from the pixel at (24, 16): the run of that color left, right,
+ * up and down. Text colors are the other colors inside the box; the frame's colors (read just
+ * outside the box above the text) are not counted. Returns a problem per side, or none. A picture
+ * with no such box (a card of another design) is skipped, since there is no box to measure.
+ */
+export declare function cardOverflow(c: CardScreen): string[];
+export {};

package/dist/types/kit/transforms.d.ts

@@ -0,0 +1,8 @@
+import { Pixels } from './pixels.js';
+export declare function resampleBlit(dst: Pixels, src: Pixels, x: number, y: number, s: number, flip?: boolean): Pixels;
+export declare function turn45(src: Pixels, scale?: number): Pixels;
+export declare function turn90(src: Pixels): Pixels;
+export declare function turn180(src: Pixels): Pixels;
+export declare function flipX(src: Pixels): Pixels;
+export declare function flipY(src: Pixels): Pixels;
+export declare function rotate(src: Pixels, deg: number): Pixels;

package/dist/types/lookAlike.d.ts

@@ -0,0 +1,31 @@
+import { type Block } from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';
+import type { GameMap } from '@lewismoten/gamemaker-sandbox-engine/formats/map';
+export interface LookInput {
+    blocks: Block[];
+    /** Every palette (768 bytes) a scene using this set shows. */
+    palettes: Uint8Array[];
+    /** Block numbers the set's maps draw, plus what they turn into (the closure). */
+    used: ReadonlySet<number>;
+    /** Numbers that must keep their number and picture game-wide (block 0, pickups, required and starting inventory). */
+    pinned: ReadonlySet<number>;
+}
+export interface LookGroup {
+    /** The block that stays: the pinned one if any, else the lowest number. */
+    keep: number;
+    /** The blocks that go; each is drawn exactly as `keep` is, and plays the same. */
+    fold: number[];
+}
+export interface LookResult {
+    groups: LookGroup[];
+    /** Groups left alone because two of their blocks are pinned. */
+    pinnedGroups: number[][];
+    /** Blocks of one shape in different colors (not folded). */
+    colorVariants: number[][];
+}
+export declare function findLookAlikes({ blocks, palettes, used, pinned }: LookInput): LookResult;
+/** The set with every folded block gone: `to[n]` is where block n went (itself if it stayed), maps renumbered. */
+export declare function applyFold(blocks: Block[], maps: GameMap[], groups: LookGroup[]): {
+    blocks: Block[];
+    maps: GameMap[];
+    to: number[];
+};

package/dist/types/menuVersionEntry.d.ts

@@ -0,0 +1 @@
+export { stampMenuVersion, type MenuVersionSpot } from './kit/menuVersion.js';

package/dist/types/mesh/colorBodies.d.ts

@@ -0,0 +1,18 @@
+import type { Mesh, Vec3 } from './mesh.js';
+export type Rgb = [number, number, number];
+/** Up to `max` colors that stand for the mesh's triangle colors (by area), those closer than `merge` joined. */
+export declare function pickPalette(mesh: Mesh, max?: number, merge?: number): Rgb[];
+export interface BodiesOptions {
+    min: Vec3;
+    max: Vec3;
+    cell: number;
+    /** Thin each body's mesh to within this distance of its surface (see decimate.ts). */
+    simplify?: number;
+    /** The volume the bodies together should have (the whole figure's): they are grown a hair if the mesher left them short. */
+    volume?: number;
+}
+/** One closed body per palette color (a color with no solid of its own is left out). */
+export declare function colorBodies(mesh: Mesh, palette: Rgb[], field: (x: number, y: number, z: number) => number, o: BodiesOptions): {
+    color: Rgb;
+    mesh: Mesh;
+}[];

package/dist/types/mesh/decimate.d.ts

@@ -0,0 +1,10 @@
+import type { Mesh } from './mesh.js';
+export interface DecimateOptions {
+    /** The largest distance, in the mesh's units, a collapse may move the surface (the cost limit is its square, times the planes meeting there). */
+    maxError: number;
+    /** Colors further apart than this (0-255 steps) make an edge a color border to hold in place (default 30). */
+    colorStep?: number;
+    /** Never go below this many triangles (default 4). */
+    minTriangles?: number;
+}
+export declare function decimate(mesh: Mesh, o: DecimateOptions): Mesh;

package/dist/types/mesh/fieldTrinket.d.ts

@@ -0,0 +1,40 @@
+import { type MeshReport } from './meshCheck.js';
+import type { Mesh } from './mesh.js';
+import { type Rgb } from './colorBodies.js';
+import { type Overhang } from './overhang.js';
+export type V3 = [number, number, number];
+export interface FieldTrinketInput {
+    /** Signed distance in mm (negative inside); must be positive below z = 0 so the floor is flat. */
+    mm: (x: number, y: number, z: number) => number;
+    /** The 0-255 color of the surface at a point, given its outward normal. */
+    colorAt: (x: number, y: number, z: number, normal: V3) => Rgb;
+    /** The box the mesh is sampled in, in mm. */
+    box: {
+        min: V3;
+        max: V3;
+    };
+    /** Filament colors (at most four), when the automatic pick would join two the eye must tell apart. */
+    palette?: Rgb[];
+    /** The grid of the color bodies in mm (default 1.5): finer when the trinket has gaps or details under 1.5 mm. */
+    bodyCell?: number;
+    /** How many separate solids the trinket is made of (default 1): a coin cut into pieces is 3. */
+    pieces?: number;
+}
+export interface FieldTrinket {
+    mesh: Mesh;
+    report: MeshReport;
+    /** The pieces left when the surface is eroded by half a millimeter (of at least a speck's size). */
+    erodedPieces: number;
+    /** Specks the eroded surface leaves: parts thinner than a millimeter that would not print. */
+    erodedSpecks: number;
+    overhang: Overhang;
+    bodies: {
+        color: Rgb;
+        mesh: Mesh;
+    }[];
+    wholeVolume: number;
+    field: (x: number, y: number, z: number) => number;
+    support?: Mesh;
+}
+/** Mesh and check a trinket's field. `cell` is the mesh's cell in mm (default 0.95). */
+export declare function meshFieldTrinket(input: FieldTrinketInput, cell?: number): FieldTrinket;

package/dist/types/mesh/figureShapes.d.ts

@@ -0,0 +1,24 @@
+import type { Rgb } from './colorBodies.js';
+import type { D3 } from './sdfShapes.js';
+/** An ellipsoid centered at (cx, cy, cz) with radii rx, ry, rz (a close estimate of the distance, good for meshing). */
+export declare const ellipsoid3: (cx: number, cy: number, cz: number, rx: number, ry: number, rz: number) => D3;
+/** A rounded cone (a capsule that is r0 wide at a and r1 wide at b). */
+export declare const roundCone3: (ax: number, ay: number, az: number, r0: number, bx: number, by: number, bz: number, r1: number) => D3;
+/** The smooth union of fields: parts melt together over about `k` mm. */
+export declare const smoothUnion3: (k: number, ...fs: D3[]) => D3;
+/** A field turned about the z axis by `a` radians and moved by (dx, dy, dz). */
+export declare const place3: (f: D3, a: number, dx?: number, dy?: number, dz?: number) => D3;
+/** A field made bigger (or smaller) by `k`, about the origin. */
+export declare const scale3: (f: D3, k: number) => D3;
+export interface FigurePart {
+    d: D3;
+    color: Rgb;
+}
+/**
+ * A figure of colored parts: the parts melt together over `blend` mm, the floor is flattened onto z = 0, and a surface point
+ * takes the color of the part whose own surface it is nearest to (so a comb or an eye keeps its color where it meets the head).
+ */
+export declare function figure(parts: FigurePart[], blend?: number): {
+    mm: D3;
+    colorAt: (x: number, y: number, z: number) => Rgb;
+};

package/dist/types/mesh/mesh.d.ts

@@ -0,0 +1,9 @@
+export interface Mesh {
+    /** x, y, z per vertex. */
+    positions: Float32Array;
+    /** Three vertex numbers per triangle. */
+    indices: Uint32Array;
+    /** Optional color per triangle: r, g, b (0-255) each. */
+    colors?: Uint8Array;
+}
+export type Vec3 = [number, number, number];

package/dist/types/mesh/meshCheck.d.ts

@@ -0,0 +1,22 @@
+import type { Mesh, Vec3 } from './mesh.js';
+export interface MeshReport {
+    triangles: number;
+    vertices: number;
+    /** Edges that belong to one triangle or three or more (a closed mesh has none). */
+    badEdges: number;
+    /** Edges two triangles walk the same way (a flipped triangle). */
+    flippedEdges: number;
+    /** Triangles with no area. */
+    degenerate: number;
+    /** Separate pieces; a print wants 1 (or pieces that rest on the bed). */
+    pieces: number;
+    /** Triangles in each piece, largest first. */
+    pieceTriangles: number[];
+    min: Vec3;
+    max: Vec3;
+    /** Enclosed volume (positive when the triangles face outward). */
+    volume: number;
+    /** Surface area. */
+    area: number;
+}
+export declare function inspectMesh(mesh: Mesh): MeshReport;

package/dist/types/mesh/overhang.d.ts

@@ -0,0 +1,24 @@
+import type { Mesh, Vec3 } from './mesh.js';
+export interface Overhang {
+    /** Area of the faces tipped more than the limit from upright and off the bed, in the mesh's units squared. */
+    area: number;
+    /** Their share of the whole surface. */
+    share: number;
+}
+/** Faces whose normal points down past `limit` degrees from upright (45 is the usual FDM limit) and that are above the bed (z = 0). */
+export declare function overhang(mesh: Mesh, limit?: number, bed?: number): Overhang;
+export interface SupportOptions {
+    min: Vec3;
+    max: Vec3;
+    /** Voxel size. */
+    cell: number;
+    /** Air kept between a support and the model so they part cleanly. */
+    gap: number;
+}
+/**
+ * Support pillars for `field` (negative inside, floor at z = 0): under every part that leans out more than
+ * 45 degrees (a voxel with nothing solid straight below it or to its four sides below), a column straight
+ * down to the model or the bed, a voxel wider all round, kept `gap` away from the model. Undefined when
+ * nothing needs support.
+ */
+export declare function supportBody(field: (x: number, y: number, z: number) => number, o: SupportOptions): Mesh | undefined;

package/dist/types/mesh/pixelFigure.d.ts

@@ -0,0 +1,41 @@
+import type { Mesh } from './mesh.js';
+export declare const TRANSPARENT = 255;
+export interface PixelPicture {
+    w: number;
+    h: number;
+    /** Palette index per pixel, row major from the top; 255 is empty. */
+    cells: Uint8Array;
+    /** 6-bit VGA palette (768 bytes). */
+    palette: Uint8Array;
+}
+export interface FigureOptions {
+    /** Most colors (the base counts as the outline color): 4, or 3. */
+    colors?: number;
+    /** Palette indices that must keep a color of their own, the first one being the outline and base; the rest of the colors are chosen farthest-first. */
+    keep?: number[];
+    /** Millimeters per pixel block. */
+    block?: number;
+    /** Blocks deep the figure is. */
+    layers?: number;
+    /** Rows of base plate under the feet. */
+    baseRows?: number;
+    /** Blocks the base sticks out each side, and front and back. */
+    baseMargin?: number;
+}
+export interface Figure {
+    /** One closed mesh per color, darkest (outline and base) first. */
+    bodies: {
+        color: [number, number, number];
+        mesh: Mesh;
+    }[];
+    /** The whole solid as one mesh. */
+    solid: Mesh;
+    /** Cleaned color map (width x height, with the base), for previews: index into `bodies`, -1 empty. */
+    map: Int8Array;
+    w: number;
+    h: number;
+    droppedSpecks: number;
+    bridged: number;
+}
+/** The figure of a picture. */
+export declare function pixelFigure(pic: PixelPicture, o?: FigureOptions): Figure;

package/dist/types/mesh/sampledField.d.ts

@@ -0,0 +1,3 @@
+import type { NetsOptions } from './surfaceNets.js';
+/** `field` sampled over the box; outside the grid the nearest sample is read, which is air. */
+export declare function sampledField(field: (x: number, y: number, z: number) => number, o: Pick<NetsOptions, 'min' | 'max' | 'cell'>): (x: number, y: number, z: number) => number;

package/dist/types/mesh/sdfShapes.d.ts

@@ -0,0 +1,20 @@
+export type D2 = (x: number, y: number) => number;
+export type D3 = (x: number, y: number, z: number) => number;
+export declare const circle2: (r: number, cx?: number, cy?: number) => D2;
+export declare const ring2: (r0: number, r1: number) => D2;
+export declare const roundRect2: (hx: number, hy: number, r: number, cx?: number, cy?: number) => D2;
+/** A capsule: the line from (ax, ay) to (bx, by), `r` wide each side. */
+export declare const capsule2: (ax: number, ay: number, bx: number, by: number, r: number) => D2;
+/** A convex or concave polygon (counter-clockwise or not), by points. */
+export declare function polygon2(pts: [number, number][]): D2;
+/** Lines of text in the 3x5 micro font, each pixel a rounded square `px` mm wide, the block centered on (cx, cy). Letters are `px` apart, lines 2 px. */
+export declare function pixelText2(lines: string[], px: number, cx?: number, cy?: number, round?: number): D2;
+/** A flat shape standing from z0 to z1. */
+export declare const extrude: (d2: D2, z0: number, z1: number) => D3;
+export declare const sphere3: (cx: number, cy: number, cz: number, r: number) => D3;
+/** A box with rounded edges, centered, half sizes hx, hy, hz and corner radius r. */
+export declare const roundBox3: (cx: number, cy: number, cz: number, hx: number, hy: number, hz: number, r: number) => D3;
+export declare const union3: (...fs: D3[]) => D3;
+export declare const subtract3: (a: D3, ...cuts: D3[]) => D3;
+export declare const intersect3: (a: D3, b: D3) => D3;
+export declare const union2: (...fs: D2[]) => D2;

package/dist/types/mesh/stl.d.ts

@@ -0,0 +1,9 @@
+import type { Mesh } from './mesh.js';
+export interface StlOptions {
+    /** Written into the header (80 bytes at most). */
+    name?: string;
+}
+/** The mesh as a binary STL file. */
+export declare function writeStl(mesh: Mesh, options?: StlOptions): Uint8Array;
+/** A binary STL read back, its corners that coincide joined into shared vertices. */
+export declare function readStl(data: Uint8Array): Mesh;

package/dist/types/mesh/strokeText.d.ts

@@ -0,0 +1,8 @@
+import { type D2 } from './sdfShapes.js';
+/** Lines of capitals, digits and marks, `cap` mm tall, drawn with a pen `pen` mm wide, the block centered on (cx, cy). */
+export declare function strokeText2(lines: string[], cap: number, pen: number, cx?: number, cy?: number): D2;
+/**
+ * Characters set round a circle of `radius` mm (their feet toward the middle), clockwise from `startDeg` (90 is the top),
+ * `stepDeg` apart: a decoder coin's ring of digits, or a coin's legend. Each is `cap` mm tall, drawn with a pen `pen` mm wide.
+ */
+export declare function ringText2(text: string, radius: number, cap: number, pen: number, stepDeg: number, startDeg?: number): D2;

package/dist/types/mesh/surfaceNets.d.ts

@@ -0,0 +1,14 @@
+import type { Mesh, Vec3 } from './mesh.js';
+export interface NetsOptions {
+    /** The box to sample: the surface must lie inside it. */
+    min: Vec3;
+    max: Vec3;
+    /** The grid spacing, in the field's units. */
+    cell: number;
+    /** Retry a grid that splits the surface into more separate pieces than this (default: any number is fine). */
+    maxPieces?: number;
+    /** How many grids to try before settling for the best (default 30). */
+    attempts?: number;
+}
+/** The closed surface of `field` = 0 over the box. */
+export declare function surfaceNets(field: (x: number, y: number, z: number) => number, o: NetsOptions): Mesh;

package/dist/types/mesh/tetraMesh.d.ts

@@ -0,0 +1,4 @@
+import type { Mesh } from './mesh.js';
+import type { NetsOptions } from './surfaceNets.js';
+/** The closed surface of `field` = 0 over the box (the grid starts a fixed cell outside it). */
+export declare function tetraMesh(field: (x: number, y: number, z: number) => number, o: Pick<NetsOptions, 'min' | 'max' | 'cell'>): Mesh;

package/dist/types/mesh/threeMf.d.ts

@@ -0,0 +1,12 @@
+import type { Mesh } from './mesh.js';
+import { type ZipCodec } from './zipFile.js';
+export interface Part {
+    name: string;
+    mesh: Mesh;
+    /** 0-255 each. */
+    color: [number, number, number];
+}
+/** The parts as a 3MF file. */
+export declare function write3mf(parts: Part[], title: string, codec?: ZipCodec): Uint8Array;
+/** A 3MF written by `write3mf` read back (its parts, meshes and colors). */
+export declare function read3mf(data: Uint8Array, codec?: ZipCodec): Part[];

package/dist/types/mesh/trinketKinds.d.ts

@@ -0,0 +1,72 @@
+import { type D2, type D3 } from './sdfShapes.js';
+export interface FlatKind {
+    /** A 2D outline of the flat part (a circle, a rounded rectangle). */
+    outline: D2;
+    /** Thickness of the plate in mm. */
+    thick: number;
+    /** Width of the raised rim in mm (0 for none), and how far it stands above the face. */
+    rim?: {
+        width: number;
+        height: number;
+    };
+    /** Raised artwork (lettering, a crown) and how far it stands above the face. */
+    relief?: {
+        shape: D2;
+        height: number;
+    };
+    /** Sunk artwork and how deep it goes. */
+    engrave?: {
+        shape: D2;
+        depth: number;
+    };
+    /** Holes through the plate (a key-chain hole). */
+    holes?: D2[];
+    /** A recess in the back (the floor) for gluing in a pin back or a magnet, as a solid to cut away (see pinBack). */
+    pocket?: D3;
+}
+/** A plate with its rim, relief, engraving and holes: the face is at z = thick. */
+export declare function plate(k: FlatKind): D3;
+/** The outline for a key-chain tag: a rounded rectangle of half sizes hx, hy. */
+export declare const tagOutline: (hx: number, hy: number, r: number) => D2;
+export declare const holeAt: (x: number, y: number, r: number) => D2;
+/**
+ * A die: a rounded cube of `size` mm with a dimple of radius `pipR` for each pip (the usual 1..6 on opposite faces summing to 7).
+ * The dimples are deep (about three quarters of a radius), so the pips read in plain light; `pips` is the union of them, to color
+ * the pips apart (a point on a dimple's surface has `pips` near zero).
+ */
+export declare function die(size: number, pipR: number, corner?: number): D3 & {
+    pips: D3;
+};
+/** A regular polygon outline (a hexagonal badge, a shield point up), `n` sides, radius `r`. */
+export declare const regular2: (n: number, r: number, turn?: number) => D2;
+/**
+ * The pocket for a pin back: a bar-shaped recess `len` mm long and `w` mm wide at the floor, centered on (cx, cy), to glue a
+ * bar pin into (give it as `pocket`). Its roof is a gable at 45 degrees, so it prints without supports.
+ */
+export declare const pinBack: (cx?: number, cy?: number, len?: number, w?: number) => D3;
+/** A key-chain ring tab: a round lug of outer radius `r + wall` with a hole of radius `r`, at (x, y). Join `shape` to the outline with union2 and give `hole` to `holes`. */
+export declare const ringTab: (x: number, y: number, r?: number, wall?: number) => {
+    shape: D2;
+    hole: D2;
+};
+export interface GemShape {
+    /** Sides of the table and girdle (6 or 8). */
+    sides: number;
+    /** Apothems in mm: the flat table the gem stands on, and the widest part (the girdle). */
+    table: number;
+    girdle: number;
+    /** Height of the crown (table to girdle) and of the pavilion (girdle to the point), in mm. */
+    crown: number;
+    pavilion: number;
+    /** Turn the pavilion's facets by half a side, as a brilliant cut does (default true). */
+    offset?: boolean;
+}
+/**
+ * A faceted gem standing on its table (flat down), the crown flaring out as it rises and the pavilion narrowing to the point:
+ * the crown leans out at under 45 degrees from vertical, so it prints without supports. Also the shape of a crystal shard.
+ * `facet(x, y, z)` is the number of the facet a surface point belongs to, for coloring.
+ */
+export declare function gem(g: GemShape): {
+    field: D3;
+    facet: (x: number, y: number, z: number) => number;
+};

package/dist/types/mesh/trinketTool.d.ts

@@ -0,0 +1,26 @@
+import type { FieldTrinket } from './fieldTrinket.js';
+export interface TrinketToolDef {
+    id: string;
+    title: string;
+    blurb: string;
+    /** Printed height and width in mm, only to start the biggest first. */
+    height: number;
+    maxWidth: number;
+    /** How many separate solids it is (default 1), such as a coin printed in three pieces. */
+    pieces?: number;
+}
+export interface TrinketTool<D extends TrinketToolDef> {
+    /** The folder id in web/public/trinkets and the manifest's `game`. */
+    game: string;
+    /** The game's title, in the STL and 3MF names. */
+    gameTitle: string;
+    out: string;
+    /** The files, and folders (each file in them, sorted), the trinkets are made from: the key of the manifest. */
+    keyFiles: string[];
+    defs: D[];
+    make: (def: D) => FieldTrinket;
+    args: string[];
+}
+/** A hash of the sources, so an up-to-date set of trinkets is not made again. */
+export declare function sourceKey(entries: string[]): string;
+export declare function runTrinketTool<D extends TrinketToolDef>(tool: TrinketTool<D>): Promise<void>;

package/dist/types/mesh/voxel.d.ts

@@ -0,0 +1,10 @@
+import type { Mesh } from './mesh.js';
+export interface VoxelGrid {
+    nx: number;
+    ny: number;
+    nz: number;
+    /** True where a voxel is filled. Outside the grid is empty. */
+    has: (x: number, y: number, z: number) => boolean;
+}
+/** The surface of the filled voxels as a mesh. A voxel touching another only along an edge makes a non-manifold edge: avoid that in the grid. */
+export declare function voxelMesh(g: VoxelGrid, size?: number): Mesh;

package/dist/types/mesh/zipFile.d.ts

@@ -0,0 +1,13 @@
+export interface ZipEntry {
+    name: string;
+    data: Uint8Array;
+}
+export interface ZipCodec {
+    /** Raw deflate (no zlib header). */
+    deflate?: (data: Uint8Array) => Uint8Array;
+    /** Raw inflate, needed to read deflated entries. */
+    inflate?: (data: Uint8Array) => Uint8Array;
+}
+export declare function crc32(data: Uint8Array): number;
+export declare function writeZip(entries: ZipEntry[], codec?: ZipCodec): Uint8Array;
+export declare function readZip(data: Uint8Array, codec?: ZipCodec): ZipEntry[];

package/dist/types/microFont.d.ts

@@ -0,0 +1,6 @@
+export type MicroGlyphs = Readonly<Record<string, string>>;
+export declare const MICRO_GLYPHS: MicroGlyphs;
+/** Square letterforms for technical labels, with the full punctuation repertoire. */
+export declare const MICRO_SQUARE_GLYPHS: MicroGlyphs;
+/** Select an exact repertoire when preserving an existing font's fallback behavior. */
+export declare function microGlyphs(characters: string, square?: boolean): MicroGlyphs;

package/dist/types/pack/meshPack.d.ts

@@ -0,0 +1,26 @@
+/** Bytes of `size`-byte values split into planes: every value's first byte, then every second byte... */
+export declare function toPlanes(data: Uint8Array, size: number): Uint8Array;
+/** `toPlanes` undone. */
+export declare function fromPlanes(data: Uint8Array, size: number): Uint8Array;
+/** Vertex numbers as varints: each one's distance back from one past the highest so far, zigzagged; `starts` restart the count (a block per part). */
+export declare function packIndices(ix: ArrayLike<number>, starts?: Set<number>): Uint8Array;
+/** `count` vertex numbers from `packIndices`'s bytes. */
+export declare function unpackIndices(data: Uint8Array, count: number, starts?: Set<number>): Uint32Array;
+/** A binary STL packed: its header, a table of its distinct corners, each triangle's corner numbers and attribute, and any normal that is not the one worked out again. */
+export declare function packStl(stl: Uint8Array): Uint8Array;
+/** The binary STL `packStl` packed, byte for byte. */
+export declare function unpackStl(pack: Uint8Array): Uint8Array;
+/** Several named files in one pack (a ZIP's worth, to zip in the browser): each binary STL packed by `packStl`, the rest as they are. */
+export declare function packFiles(files: {
+    name: string;
+    data: Uint8Array;
+}[]): Uint8Array;
+/** The files `packFiles` packed, each byte for byte. */
+export declare function unpackFiles(pack: Uint8Array): {
+    name: string;
+    data: Uint8Array;
+}[];
+/** A file of float32s then uint32 vertex numbers (little-endian, as the phone kit's parts.bin), packed: the floats in byte planes, the numbers as varints counted afresh at each of `starts` (a part's first number). */
+export declare function packFloatsAndIndices(bin: Uint8Array, floats: number, starts: number[]): Uint8Array;
+/** The file `packFloatsAndIndices` packed, byte for byte. */
+export declare function unpackFloatsAndIndices(pack: Uint8Array): Uint8Array;

package/dist/types/pack/threeMfPack.d.ts

@@ -0,0 +1,11 @@
+import { type Part } from '../mesh/threeMf.js';
+import { type ZipCodec, type ZipEntry } from '../mesh/zipFile.js';
+/** The files inside the 3MF write3mf writes for these parts, before any deflate (write3mf stores them when given no codec). */
+export declare function threeMfEntries(parts: Part[], title: string): ZipEntry[];
+/** A 3MF from write3mf, packed (deflate the result); throws when its inner files would not come back the same. */
+export declare function pack3mf(file: Uint8Array, codec: Pick<ZipCodec, 'inflate'>): Uint8Array;
+/** A packed 3MF's title and parts, ready for write3mf or threeMfEntries. */
+export declare function unpack3mf(pack: Uint8Array): {
+    title: string;
+    parts: Part[];
+};

package/dist/types/palettePresetData.d.ts

@@ -0,0 +1,4 @@
+export declare const ATARI_NTSC_RGB = "\n000000 404040 6c6c6c 909090 b0b0b0 c8c8c8 dcdcdc ececec\n444400 646410 848424 a0a034 b8b840 d0d050 e8e85c fcfc68\n702800 844414 985c28 ac783c bc8c4c cca05c dcb468 e8cc7c\n841800 983418 ac5030 c06848 d0805c e09470 eca880 fcbc94\n880000 9c2020 b03c3c c05858 d07070 e08888 eca0a0 fcb4b4\n78005c 8c2074 a03c88 b0589c c070b0 d084c0 dc9cd0 ecb0e0\n480078 602090 783ca4 8c58b8 a070cc b484dc c49cec d4b0fc\n140084 302098 4c3cac 6858c0 7c70d0 9488e0 a8a0ec bcb4fc\n000088 1c209c 3840b0 505cc0 6874d0 7c8ce0 90a4ec a4b8fc\n00187c 1c3890 3854a8 5070bc 6888cc 7c9cdc 90b4ec a4c8fc\n002c5c 1c4c78 386890 5084ac 689cc0 7cb4d4 90cce8 a4e0fc\n00402c 1c5c48 387c64 509c80 68b494 7cd0ac 90e4c0 a4fcd4\n003c00 205c20 407c40 5c9c5c 74b474 8cd08c a4e4a4 b8fcb8\n143800 345c1c 507c38 6c9850 84b468 9ccc7c b4e490 c8fca4\n2c3000 4c501c 687034 848c4c 9ca864 b4c078 ccd488 e0ec9c\n442800 644818 846830 a08444 b89c58 d0b46c e8cc7c fce08c\n";
+export declare const ATARI_PAL_RGB = "\n000000 404040 6c6c6c 909090 b0b0b0 c8c8c8 dcdcdc ececec\n805800 947020 a8843c bc9c58 ccac70 dcc084 ecd09c fce0b0\n445c00 5c7820 74903c 8cac58 a0c070 b0d484 c0e89c d4fcb0\n703400 885020 a0683c b48458 c89870 dcac84 ecc09c fcd4b0\n006414 208034 3c9850 58b06c 70c484 84d89c 9ce8b4 b0fcc8\n700014 882034 a03c50 b4586c c87084 dc849c ec9cb4 fcb0c8\n005c5c 207474 3c8c8c 58a4a4 70b8b8 84c8c8 9cdcdc b0ecec\n70005c 842074 943c88 a8589c b470b0 c484c0 d09cd0 e0b0e0\n003c70 1c5888 3874a0 508cb4 68a4c8 7cb8dc 90ccec a4e0fc\n580070 6c2088 803ca0 9458b4 a470c8 b484dc c49cec d4b0fc\n002070 1c3c88 3858a0 5074b4 6888c8 7ca0dc 90b4ec a4c8fc\n3c0080 542094 6c3ca8 8058bc 9470cc a884dc b89cec c8b0fc\n000088 20209c 3c3cb0 5858c0 7070d0 8484e0 9c9cec b0b0fc\n";
+export declare const NES_RGB = "\n575757 000c8e 0800a6 340096 550061 630015 5a0000 3c0e00\n112800 003b00 004200 003a05 002652 000000 a5a5a5 0041d9\n2f1eff 6704f2 9400b4 aa0057 a31800 803900 4b5b00 137600\n008100 007923 006288 ffffff 4a9fff 797eff af63ff dd55ff\nf757c2 f76a63 dc8810 aea900 78c400 4ad211 2fcf64 2fbdc4\n414141 b9ddff cad1ff dec6ff f0c0ff fcc0ee fdc6ca f5d0aa\ne4dd95 d0e892 bdeea2 b2eec0 b0e8e3 b3b3b3\n";
+export declare const C64_RGB = "\n000000 ffffff fa3200 1de0ff a84bcc 68ba51 004ad0 ffe94d\nff5b00 c13e00 ff723e 605e62 8c937f b2ff90 458aff c3b8d7\n";

package/dist/types/palettePresets.d.ts

@@ -0,0 +1,12 @@
+import type { Palette } from '@lewismoten/gamemaker-sandbox-engine/formats/palette';
+export interface PalettePreset {
+    readonly id: string;
+    readonly name: string;
+    readonly stem: string;
+    /** Occupied entries, including menu black; index 255 is always reserved. */
+    readonly entries: number;
+    readonly description: string;
+}
+export declare const PALETTE_PRESETS: readonly PalettePreset[];
+/** A fresh 768-byte VGA palette. Black is moved to index 0; unused entries and 255 are black. */
+export declare function createPalettePreset(id: string): Palette;