@lewismoten/gamemaker-sandbox-tools 0.0.0-stage → 3.4.0

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

@@ -0,0 +1,99 @@
+import type { Writer } from './song.js';
+/** Rhythm mode drum channels: bass drum (its own voice, FM channel 6), snare, tom-tom, cymbal, hi-hat. */
+export declare const DRUM: {
+    readonly kick: 11;
+    readonly snare: 12;
+    readonly tom: 13;
+    readonly cymbal: 14;
+    readonly hat: 15;
+};
+/** One note of a phrase: MIDI (null for a rest), its length in beats, and how it moves. */
+interface Tone {
+    n: number | null;
+    beats: number;
+    /** Slide up into the note from this many semitones below. */
+    scoop: number;
+    /** Fall away this many semitones as it ends. */
+    fall: number;
+    /** Velocity added (an accent) or taken away. */
+    accent: number;
+    /** Tied on from the note before (no new attack). */
+    tie: boolean;
+}
+/**
+ * Notes as text, as in kit/music but with triplets ("t", a third of a beat, "x" a sixth) and
+ * marks: "~C5 q" scoops up into the note, "C5 q\" falls off it, "C5 q!" accents it, "C5 q-"
+ * plays it softer, "_ q" holds the note before for longer.
+ */
+export declare function tones(s: string): Tone[];
+/** A patch with its levels changed (total level 0 loudest .. 63 silent; the key scaling bits are kept). */
+export declare function leveled(inst: Uint8Array, o: {
+    mod?: number;
+    car?: number;
+}): Uint8Array;
+/** The twin of a patch with vibrato on both operators (or off, if it had it): play both for a choir. */
+export declare function detuned(inst: Uint8Array): Uint8Array;
+/** A patch with its waveforms set (0 sine, 1 half sine, 2 absolute sine, 3 pulse sine). */
+export declare function waved(inst: Uint8Array, mod: number, car: number): Uint8Array;
+/** `steps` copies of a patch whose levels move from `from` to `to` (each { mod, car }), for swell(). */
+export declare function sweep(inst: Uint8Array, steps: number, from: {
+    mod?: number;
+    car?: number;
+}, to: {
+    mod?: number;
+    car?: number;
+}): Uint8Array[];
+export declare class Fx {
+    readonly w: Writer;
+    /** The patch each channel has now (after its program changes). */
+    private now;
+    /** Where each section starts (beat), for the preview tools. */
+    readonly sections: {
+        at: number;
+        name: string;
+    }[];
+    constructor(w: Writer);
+    private tick;
+    /** The channel's opening patch (instrument n for channel n, loaded before the first note). */
+    open(ch: number, inst: Uint8Array): this;
+    /** The instrument number of a patch: a channel's own opening patch, or one of the extra ones from 16 up (128 at most). */
+    patch(inst: Uint8Array): number;
+    /** A program change at beat `at` (nothing if the channel already has the patch). */
+    program(ch: number, at: number, inst: Uint8Array): this;
+    /** A section's start: a CMF marker (controller 0x66, value = its number) that PLAYGAME skips. */
+    marker(at: number, name: string): this;
+    /** One note, `len` beats from `at` (legato: the part of it held before letting go). */
+    note(ch: number, at: number, len: number, n: number, vel: number, legato?: number): this;
+    /**
+     * A phrase from beat `at` on one channel (see tones()): scoops slide up into their note in
+     * two-tick steps, falls slide away at the end, ties hold on. Returns its length in beats.
+     */
+    phrase(ch: number, at: number, s: string, vel: number, shift?: number, legato?: number): number;
+    /** Semitone steps from `from` to `to`, `ticks` timer ticks each, on one channel; returns the beat it ends on. */
+    slide(ch: number, at: number, from: number, to: number, ticks: number, vel: number): number;
+    /** The same notes on two channels at once, the second with the twin patch (a two-voice choir). */
+    choir(chA: number, chB: number, at: number, s: string, vel: number, shift?: number): number;
+    /** Program changes on `chs` stepping through `patches` evenly over `beats` from `at` (a swell or a filter sweep). */
+    swell(chs: number[], at: number, beats: number, patches: Uint8Array[]): this;
+    /** A chord on one channel: its notes in turn, one every `every` beats, for `beats` ('up', 'down', 'updown'). */
+    arp(ch: number, at: number, beats: number, notes: number[], every: number, vel: number, shape?: 'up' | 'down' | 'updown'): this;
+    /** A chord spread round several channels, a note every `every` beats; each rings on until its channel's next note (a harp). */
+    harp(chs: number[], at: number, beats: number, notes: number[], every: number, vel: number | ((k: number) => number)): this;
+    /** The phrase again on `ch`, `delay` beats later, `times` times, each softer (an echo). */
+    echo(ch: number, at: number, s: string, vel: number, delay: number, times?: number, decay?: number, shift?: number): this;
+    /** One note retriggered on its own channel `times` times, `gap` beats apart, each softer. */
+    stutter(ch: number, at: number, n: number, times: number, gap: number, vel: number, decay?: number): this;
+    /** The bass drum as a pitched voice (its patch from boomPatch). */
+    boom(at: number, len: number, n: number, vel: number): this;
+    /** A drum hit every `every` beats for `beats`, velocity ramping (a roll); tuned drums (tom, kick) walk through `notes`. */
+    drumRoll(drum: number, at: number, beats: number, every: number, velFrom: number, velTo: number, notes?: number[]): this;
+    /** Puts every drum channel back on its opening patch and the song's length in bars, then writes the CMF. */
+    cmf(bars: number): Uint8Array;
+}
+/** The bass drum as a sub bass: a sine that sustains while the note is held and rings out. */
+export declare function boomPatch(o?: {
+    decay?: number;
+    release?: number;
+    growl?: number;
+}): Uint8Array;
+export {};

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

@@ -0,0 +1,29 @@
+/** A PC speaker sound from a function of step (0..35) → Hz (0 = silence). */
+export declare function speaker(fn: (i: number, t: number) => number): Uint16Array;
+export declare const SPEAKER: {
+    rise: (from?: number, to?: number) => Uint16Array<ArrayBufferLike>;
+    fall: (from?: number, to?: number) => Uint16Array<ArrayBufferLike>;
+    coin: () => Uint16Array<ArrayBufferLike>;
+    hurt: () => Uint16Array<ArrayBufferLike>;
+    zap: () => Uint16Array<ArrayBufferLike>;
+    chirp: () => Uint16Array<ArrayBufferLike>;
+    arpeggio: (notes?: number[]) => Uint16Array<ArrayBufferLike>;
+    noise: (seed?: number, low?: number, high?: number) => Uint16Array<ArrayBufferLike>;
+    warble: (base?: number, depth?: number, speed?: number) => Uint16Array<ArrayBufferLike>;
+};
+/** A synthesizer voice for samples: time (s) → -1..1. */
+export type Synth = (t: number) => number;
+export declare const osc: {
+    sine: (hz: number | ((t: number) => number)) => Synth;
+    square: (hz: number | ((t: number) => number)) => Synth;
+    noise: (seed?: number) => Synth;
+};
+/** Renders `seconds` of a synth through an envelope (attack, decay to 0) as a .VOC. */
+export declare function sample(seconds: number, voice: Synth, opts?: {
+    rate?: number;
+    attack?: number;
+    gain?: number;
+    envelope?: (t: number) => number;
+}): Uint8Array;
+/** Mixes synths. */
+export declare const mix: (...voices: [Synth, number][]) => Synth;

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

@@ -0,0 +1,7 @@
+import { type Synth } from './sound.js';
+/** White noise through a one-pole low-pass (0..1: how much of the new sample passes). */
+export declare function lowNoise(seed: number, cutoff: number | ((t: number) => number)): Synth;
+export declare const gate: (v: Synth, from: number, to: number) => Synth;
+export declare const env: (attack: number, decay: number) => (u: number) => number;
+/** A one-pole low-pass over a synth (for growly, dull noises). */
+export declare function lowpass(v: Synth, k: number): Synth;

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

@@ -0,0 +1,13 @@
+export interface TarEntry {
+    /** A/B/c, with "/" between folders; a folder ends with "/". */
+    path: string;
+    data?: Uint8Array;
+    /** Unix permission bits (0o755 for a program, 0o644 for a file). */
+    mode?: number;
+}
+/** An uncompressed tar archive. */
+export declare function createTar(entries: TarEntry[], date?: Date): Uint8Array;
+/** A .tar.gz archive. */
+export declare function createTarGz(entries: TarEntry[], date?: Date): Promise<Uint8Array>;
+/** Reads a tar (or .tar.gz) archive's entries: path, mode and data. */
+export declare function readTar(bytes: Uint8Array): Promise<Required<TarEntry>[]>;

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

@@ -0,0 +1,51 @@
+/** A rectangle as [x0, y0, x1, y1], x1 and y1 exclusive. */
+type Box = [number, number, number, number];
+/** One string that ran past its picture or clip area. */
+export interface TextOverflow {
+    s: string;
+    /** The picture's size. */
+    w: number;
+    h: number;
+    /** Where the ink was, and the area it had to stay inside. */
+    ink: Box;
+    area: Box;
+    /** The drawing call's source: the game code that drew it, and the code that called that. */
+    at: string;
+    /** Every call from the game code down to the helper (an outline and its fill differ). */
+    via: string;
+    /** Characters the 8x8 font draws as an empty box (a curly quote, an accent), if any. */
+    missing?: string;
+}
+/** Collects one string's ink as a helper draws it; `end()` checks it against the area. */
+declare class TextInk {
+    private readonly w;
+    private readonly h;
+    private readonly s;
+    private readonly area;
+    private readonly has;
+    private x0;
+    private y0;
+    private x1;
+    private y1;
+    constructor(w: number, h: number, s: string, area: Box, has: (ch: string) => boolean);
+    /** A lit rectangle of the string (a font pixel, scaled). */
+    add(x: number, y: number, w?: number, h?: number): void;
+    end(): void;
+}
+/**
+ * A recorder for one string drawn on picture `p`, or undefined when the audit is off. `clip`
+ * is an area inside the picture the text must keep to (a frame, a sign's face); `has` says
+ * which characters the font draws (the PC font's printable ASCII unless a helper says).
+ */
+export declare function textInk(p: {
+    readonly w: number;
+    readonly h: number;
+}, s: string, clip?: Box, has?: (ch: string) => boolean): TextInk | undefined;
+/** One line about an overflow: the string, its ink box, the area and where it was drawn. */
+export declare function describe(o: TextOverflow): string;
+/** Reads a build's TEXT_BOUNDS file: the cut strings, and how many moved. */
+export declare function readBounds(file: string): {
+    cut: TextOverflow[];
+    moving: TextOverflow[];
+};
+export {};

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/kit/tune.d.ts

@@ -0,0 +1,6 @@
+import { type Voice } from './music.js';
+export declare const LEN: Record<string, number>;
+export declare function tune(bpm: number, voices: Voice[]): Uint8Array;
+export declare const v: (channel: number, instrument: Uint8Array, notes: string, velocity?: number, transpose?: number) => Voice;
+export declare const join: (...parts: string[]) => string;
+export declare const times: (n: number, s: string) => string;

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[];