@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

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

@@ -0,0 +1,169 @@
+import type { ExtrudedText } from './sdftext.js';
+export type V = [number, number, number];
+export declare const add: (a: V, b: V) => V;
+export declare const sub: (a: V, b: V) => V;
+export declare const scale: (a: V, k: number) => V;
+export declare const dot: (a: V, b: V) => number;
+export declare const cross: (a: V, b: V) => V;
+export declare const mix: (a: V, b: V, t: number) => V;
+export declare const clamp01: (v: number) => number;
+export declare function norm(v: V): V;
+/** A 3x3 rotation as rows (object to world). */
+type M3 = number[];
+export declare function rotX(a: number): M3;
+export declare function rotY(a: number): M3;
+/** a then b: the rotation that applies `b` first, then `a`. */
+export declare function mulM(a: M3, b: M3): M3;
+/** The rotation whose columns are these axes (object x, y, z in world space). */
+export declare const fromAxes: (x: V, y: V, z: V) => M3;
+export declare const apply: (m: M3, v: V) => V;
+/** Where a shape sits: object point p is at rot * (p * size) + pos in the world. */
+interface Place {
+    rot: M3;
+    pos: V;
+    size: number;
+}
+export declare const placed: (pos?: V, rot?: M3, size?: number) => Place;
+/** What a ray found, in object space (`p`, `n`) and the world (`n` is world). */
+interface LocalHit {
+    t: number;
+    /** Object-space normal. */
+    n: V;
+}
+export interface Hit {
+    t: number;
+    p: V;
+    /** The point in the shape's own coordinates (for textures). */
+    local: V;
+    /** World-space unit normal, facing the ray. */
+    n: V;
+    shape: Shape;
+}
+/** Surface look: the shader gets the hit and returns a base color and how shiny it is. */
+export interface Surface {
+    color: V;
+    /** Diffuse share of the light. */
+    kd: number;
+    /** Specular highlight strength and sharpness (Phong). */
+    ks: number;
+    shine: number;
+    /** How much of the sky the surface mirrors (0 = none). */
+    mirror: number;
+    /** Extra light the surface gives off (a highlight sweep). */
+    glow?: V;
+}
+export type Material = (h: Hit) => Surface;
+export declare abstract class Shape {
+    at: Place;
+    material: Material;
+    /** World-space bounding box, [min, max]. */
+    box: [V, V];
+    /** Whether the shape throws a shadow. */
+    shadows: boolean;
+    constructor(at: Place, material: Material);
+    /** The nearest hit of an object-space ray after EPS, or undefined. */
+    protected abstract local(o: V, d: V, tmax: number): LocalHit | undefined;
+    /** The shape's own bounding box in object space. */
+    protected abstract bounds(): [V, V];
+    /** Recomputes the world box after `at` changes. */
+    update(): this;
+    toWorld(p: V): V;
+    /** The world box's eight corners. */
+    corners(): V[];
+    hit(o: V, d: V, tmax: number): Hit | undefined;
+}
+export declare class Box extends Shape {
+    readonly mn: V;
+    readonly mx: V;
+    constructor(mn: V, mx: V, at: Place, material: Material);
+    protected bounds(): [V, V];
+    protected local(o: V, d: V, tmax: number): LocalHit | undefined;
+}
+/** A cone frustum (or cylinder when r0 = r1) around the object y axis, y0 to y1, its ends capped or open. */
+export declare class Cone extends Shape {
+    readonly r0: number;
+    readonly r1: number;
+    readonly y0: number;
+    readonly y1: number;
+    readonly caps: {
+        bottom?: boolean;
+        top?: boolean;
+    };
+    constructor(r0: number, r1: number, y0: number, y1: number, at: Place, material: Material, caps?: {
+        bottom?: boolean;
+        top?: boolean;
+    });
+    protected bounds(): [V, V];
+    protected local(o: V, d: V, tmax: number): LocalHit | undefined;
+}
+/** A flat ring (or disc when inner = 0) in the object's y = 0 plane. */
+export declare class Ring extends Shape {
+    readonly inner: number;
+    readonly outer: number;
+    constructor(inner: number, outer: number, at: Place, material: Material);
+    protected bounds(): [V, V];
+    protected local(o: V, d: V, tmax: number): LocalHit | undefined;
+}
+export declare class Sphere extends Shape {
+    readonly r: number;
+    constructor(r: number, at: Place, material: Material);
+    protected bounds(): [V, V];
+    protected local(o: V, d: V, tmax: number): LocalHit | undefined;
+}
+/** A rod with round ends from a to b. */
+export declare class Capsule extends Shape {
+    readonly a: V;
+    readonly b: V;
+    readonly r: number;
+    constructor(a: V, b: V, r: number, at: Place, material: Material);
+    protected bounds(): [V, V];
+    protected local(o: V, d: V, tmax: number): LocalHit | undefined;
+}
+/** A flat triangle, seen from both sides. */
+export declare class Tri extends Shape {
+    readonly a: V;
+    readonly b: V;
+    readonly c: V;
+    constructor(a: V, b: V, c: V, at: Place, material: Material);
+    protected bounds(): [V, V];
+    protected local(o: V, d: V, tmax: number): LocalHit | undefined;
+}
+/** Beveled 3D lettering (sdftext.ts), found by sphere tracing. */
+export declare class Lettering extends Shape {
+    readonly text: ExtrudedText;
+    constructor(text: ExtrudedText, at: Place, material: Material);
+    protected bounds(): [V, V];
+    protected local(o: V, d: V, tmax: number): LocalHit | undefined;
+}
+/** Shapes kept together behind one bounding box, so a ray that misses the box skips them all. */
+export declare class Group extends Shape {
+    readonly parts: Shape[];
+    constructor(parts: Shape[]);
+    protected bounds(): [V, V];
+    protected local(): LocalHit | undefined;
+    update(): this;
+    hit(o: V, d: V, tmax: number): Hit | undefined;
+}
+/** The nearest hit among shapes, or undefined. */
+export declare function nearest(shapes: Shape[], o: V, d: V, tmax?: number): Hit | undefined;
+/** Is anything between a point and the light along direction l? */
+export declare function blocked(shapes: Shape[], o: V, l: V, tmax?: number): boolean;
+/** A pinhole camera for a 320x200 screen shown 4:3 (tall pixels). */
+export declare class Camera {
+    readonly eye: V;
+    readonly focal: number;
+    readonly w: number;
+    readonly h: number;
+    readonly aspect: number;
+    readonly fw: V;
+    readonly right: V;
+    readonly up: V;
+    constructor(eye: V, target: V, focal: number, w?: number, h?: number, aspect?: number);
+    ray(sx: number, sy: number): V;
+    project(p: V): [number, number] | undefined;
+}
+export declare function noise(x: number, y: number, z: number): number;
+export declare function fbm(x: number, y: number, z: number, octaves?: number): number;
+/** A grainy hash in 0..1 for a point (sand). */
+export declare const grain: (x: number, y: number, z: number, k: number) => number;
+export {};

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

@@ -0,0 +1 @@
+export declare function recordedDemo(pairs: readonly number[], waitTicks?: number, releaseTicks?: number): Uint8Array;

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

@@ -0,0 +1,71 @@
+import { Pixels } from './pixels.js';
+/** The road in perspective: half its width on each screen row, and where its lanes and lines run. */
+export interface RoadView {
+    /** The lane's half width at screen row y (its rails sit at vx +- this). */
+    halfWidth: (y: number) => number;
+    /** Where lane k (-1 left, 0 middle, 1 right) runs at screen row y: two thirds of the way out for the side lanes. */
+    laneX: (k: number, y: number) => number;
+    /** Where the lines between the lanes run (side -1 or 1). */
+    dividerX: (side: number, y: number) => number;
+}
+/** A three-lane road from the vanishing point (vx, horizon), its half width growing `spread` pixels a row. */
+export declare function roadView(horizon: number, vx: number, spread: number): RoadView;
+/** One entry of a timetable: [tick after the scene starts, lane, what comes]. */
+export type RoadEntry<K> = readonly [tick: number, lane: number, kind: K];
+/** A spawner block of a lane's chain: on the map from the last entry's tick until just after its own. */
+export interface SpawnBlock<K> {
+    name: string;
+    kind: K;
+    /** Its birth time: the entry's tick (its first birth is its only one on the map). */
+    birthTime: number;
+    /** The next block of the chain, and when it takes over. */
+    next: string;
+    ntime: number;
+}
+/** A lane's chain of spawner blocks, its first block (the one on the map) and the blank it ends on. */
+export interface SpawnChain<K> {
+    lane: number;
+    first: string;
+    blocks: SpawnBlock<K>[];
+    end: string;
+}
+/**
+ * The spawner chains for a timetable, one per lane: a block per entry, each giving birth once.
+ * Every block's clock starts with the scene, so a block whose birth time is its entry's tick, on
+ * the map only around that tick, gives birth exactly then. Blocks are named `${prefix}${lane}_${i}`
+ * and `${prefix}${lane}_end`.
+ */
+export declare function spawnChains<K>(waves: readonly RoadEntry<K>[], lanes: readonly number[], prefix?: string): SpawnChain<K>[];
+/** A path step: [blocks across, blocks down, pixels a tick]. */
+export type RoadStep = [dx: number, dy: number, speed: number];
+/** A Game-Maker path corner: [x, y] from the start, the speed, the orientation. */
+export type RoadCorner = [x: number, y: number, speed: number, orient: number];
+/** A path as steps from where the last one ended (Game-Maker stores corners from the start). */
+export declare function roadCorners(steps: RoadStep[], orient: number): RoadCorner[];
+/**
+ * Lane k's slide from the vanishing point: -1 left, 0 middle, 1 right, outward along its line
+ * and faster as it comes (a block in 20 ticks, the next in 10, then 4 and 5 pixels a tick).
+ */
+export declare const laneSlide: (k: number) => RoadStep[];
+/** Leap speed: more than any spawner is from the vanishing point, in pixels a tick. */
+export declare const ROAD_LEAP = 240;
+/** The first step, from a spawner's cell onto the vanishing point's in one tick. */
+export declare const leapTo: (from: [number, number], vp: [number, number]) => RoadStep;
+/** A monster's sizes in step with its slide: a dot while it crawls the first block, then nearer and nearer. */
+export declare const growPics: (name: string) => [string, number][];
+/** How big each size is, and the row of the sprite its bottom sits on (lower as it nears). */
+export declare const ROAD_SIZES: readonly [{
+    readonly scale: 0.25;
+    readonly bottom: 6;
+}, {
+    readonly scale: 0.45;
+    readonly bottom: 11;
+}, {
+    readonly scale: 0.72;
+    readonly bottom: 16;
+}, {
+    readonly scale: 1;
+    readonly bottom: 19;
+}];
+/** A full-size 20x20 picture shrunk (nearest pixel), centered, its bottom row on `bottom`; `clear` is transparent. */
+export declare function shrinkSprite(src: Pixels, scale: number, bottom: number, clear: number): Pixels;

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

@@ -0,0 +1,6 @@
+export declare function expectScene(bot: {
+    sim: {
+        scene: number;
+    };
+    log: readonly string[];
+}, scene: number, what: string): void;

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

@@ -0,0 +1,17 @@
+import type { Pixels } from './pixels.js';
+/** The dark strip under name i (0..9): the marker and the 20 letters with their margin. */
+export declare const SLOT: {
+    readonly x: 54;
+    readonly w: 196;
+    readonly h: 14;
+    readonly y: (i: number) => number;
+};
+/** The light strip under the message line. */
+export declare const STATUS: {
+    readonly x: 34;
+    readonly y: 181;
+    readonly w: 246;
+    readonly h: 15;
+};
+/** Paints the ten name strips in `fill` (an optional 1 pixel `edge` round each), and the message strip. */
+export declare function saveSlots(p: Pixels, fill: number, status: number, edge?: number): Pixels;

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

@@ -0,0 +1,11 @@
+import { type World } from '@lewismoten/gamemaker-sandbox-engine/engine/world';
+export { changeBlocks } from '@lewismoten/gamemaker-sandbox-engine/engine/scene';
+export declare function initializeScene(w: World, start: {
+    x: number;
+    y: number;
+}, spawnWhenMonstersDisabled?: boolean): void;
+/** Compatibility for simulators that kept block birth schedules even with monsters disabled. */
+export declare const legacySceneInits: (w: World, start: {
+    x: number;
+    y: number;
+}) => void;

package/dist/types/{games/kit → kit}/sceneSim.d.ts

@@ -1,8 +1,8 @@
-import { type CharInfo, type World } from '../../web/src/engine/world.js';
-import { type Block } from '../../web/src/formats/blocks.js';
-import type { Character } from '../../web/src/formats/character.js';
-import type { GameMap } from '../../web/src/formats/map.js';
-import type { Monster } from '../../web/src/formats/monster.js';
+import { type CharInfo, type World } from '@lewismoten/gamemaker-sandbox-engine/engine/world';
+import { type Block } from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';
+import type { Character } from '@lewismoten/gamemaker-sandbox-engine/formats/character';
+import type { GameMap } from '@lewismoten/gamemaker-sandbox-engine/formats/map';
+import type { Monster } from '@lewismoten/gamemaker-sandbox-engine/formats/monster';
 export interface SimScene {
     map: GameMap;
     bbl: Block[];

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

@@ -0,0 +1,3 @@
+import { Pixels } from './pixels.js';
+export declare const page: (lines: string[], pages?: number) => string;
+export declare const sprite: (set: Map<string, Pixels>, name: string) => Pixels;

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

@@ -0,0 +1,34 @@
+/** A stroke piece: x0, y0, x1, y1 (center line) and its radius. */
+export type Seg = [number, number, number, number, number];
+/**
+ * One line of text as stroke pieces, centered on x = 0 with its baseline at `y`.
+ * `height` is the cap height; `gap` the space between letters (in cap heights).
+ */
+export declare function textStrokes(text: string, height: number, y: number, gap?: number): Seg[];
+/** Distances to the strokes' outsides on a grid (negative inside), capped at `cap`. */
+export declare class DistanceGrid {
+    readonly cell: number;
+    readonly cap: number;
+    readonly x0: number;
+    readonly y0: number;
+    readonly x1: number;
+    readonly y1: number;
+    readonly nx: number;
+    readonly ny: number;
+    readonly d: Float32Array;
+    constructor(segs: Seg[], cell?: number, cap?: number);
+    /** The distance at (x, y), bilinear between cells; outside the grid, a safe lower bound. */
+    at(x: number, y: number): number;
+}
+/** The letters as a solid: the 2D outline pushed `depth` deep (z from -depth/2 to depth/2), its edges rounded by `bevel`. */
+export declare class ExtrudedText {
+    readonly grid: DistanceGrid;
+    readonly bevel: number;
+    readonly half: number;
+    constructor(grid: DistanceGrid, depth: number, bevel: number);
+    sdf(x: number, y: number, z: number): number;
+    /** Where a ray (object space, unit direction) first meets the letters, or -1. */
+    trace(ox: number, oy: number, oz: number, dx: number, dy: number, dz: number): number;
+    /** The surface normal at a point (object space), from the field's gradient. */
+    normal(x: number, y: number, z: number): [number, number, number];
+}

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

@@ -0,0 +1,23 @@
+import { Pixels } from './pixels.js';
+/** A shade between ramp[lo] and ramp[hi] for level 0..1, ordered-dithered at (x, y). */
+export declare function shadeAt(ramp: number[], lo: number, hi: number, level: number, x: number, y: number): number;
+/**
+ * A vertical gradient across a rectangle. With `rows`, the blend between two ramp steps is
+ * dithered by whole rows (each row one color) instead of the 4x4 pattern: it reads as fine
+ * horizontal lines, and a GIF of it is far smaller, because a row of one color packs into a
+ * few LZW codes while a dither pattern costs codes all along the row.
+ */
+export declare function gradient(p: Pixels, x0: number, y0: number, w: number, h: number, ramp: number[], lo: number, hi: number, rows?: boolean): Pixels;
+/** A lit ellipsoid lump, light from the upper left. */
+export declare function blob(p: Pixels, cx: number, cy: number, rx: number, ry: number, ramp: number[], lo?: number, hi?: number, light?: number): Pixels;
+/** A raised box: light top/left edge, dark bottom/right edge. */
+export declare function bevel(p: Pixels, x: number, y: number, w: number, h: number, ramp: number[], face: number, depth?: number, edges?: readonly [number, number, number, number]): Pixels;
+/** Fills a rectangle with a speckled texture from ramp[lo..hi]. */
+export declare function speckle(p: Pixels, x0: number, y0: number, w: number, h: number, ramp: number[], base: number, spread: number, seed: number, density?: number): Pixels;
+/**
+ * Steps every pixel that belongs to one of `ramps` by `steps` along its own ramp (negative darkens, positive
+ * lightens), where `level(x, y)` (0..1) is ordered-dithered in: a cast shadow, or a painted pool of light, that
+ * keeps the colors of whatever it falls on. Pixels in no ramp are left alone.
+ */
+export declare function rampShift(p: Pixels, ramps: number[][], steps: number, level: (x: number, y: number) => number): Pixels;
+export declare function pool(p: Pixels, cx: number, cy: number, rx: number, ry: number, r: number[], lo: number, hi: number): Pixels;

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

@@ -0,0 +1,20 @@
+import { type Block } from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';
+import type { GameMap } from '@lewismoten/gamemaker-sandbox-engine/formats/map';
+export interface SceneBlocks {
+    blocks: Block[];
+    map: GameMap;
+}
+export interface SharedBlocks {
+    /** The shared set, BACKBL blocks (empty ones after the used). */
+    blocks: Block[];
+    /** Per scene, local block number to the shared one (-1: unused). */
+    numbers: number[][];
+    /** Per scene, its map with the shared numbers. */
+    maps: GameMap[];
+}
+/**
+ * One set for `scenes`. Scene 0's block 0 stays block 0; a block at a number listed in `pin`
+ * (such as a felt egg the desk knows by number) keeps that number. Throws when the used blocks
+ * don't fit BACKBL or two different blocks want one pinned number.
+ */
+export declare function shareBlocks(scenes: SceneBlocks[], pin?: number[]): SharedBlocks;

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

@@ -0,0 +1,89 @@
+import { type CmfEvent } from '@lewismoten/gamemaker-sandbox-engine/formats/cmf';
+/** A reedy, slightly bleating lead with vibrato (the singer). */
+export declare const VOICE: Uint8Array<ArrayBufferLike>;
+/** Oboe-ish double reed. */
+export declare const REED: Uint8Array<ArrayBufferLike>;
+/** Gospel drawbar organ for the comping. */
+export declare const ORGAN: Uint8Array<ArrayBufferLike>;
+/** A soft flute. */
+export declare const FLUTE: Uint8Array<ArrayBufferLike>;
+/** A plucked "oud". */
+export declare const OUD: Uint8Array<ArrayBufferLike>;
+/** Celesta / music box. */
+export declare const CELESTA: Uint8Array<ArrayBufferLike>;
+/** Electric piano for comping. */
+export declare const EPIANO: Uint8Array<ArrayBufferLike>;
+/** A rounder fingered bass. */
+export declare const BASS: Uint8Array<ArrayBufferLike>;
+export interface Section {
+    /** One chord per bar, or two ("D A": half a bar each). */
+    chords: string[];
+    /** One string of notes per bar (4 beats each), "G4 q, r e, ..." as in kit/music. */
+    tune: string[];
+}
+/** Bars of one section, sliced (e.g. the chorus without its pickup). */
+export declare const slice: (s: Section, from: number, to?: number) => Section;
+/** A section with its last bar's tune replaced (to change the pickup into the next part). */
+export declare const ending: (s: Section, last: string) => Section;
+/** Bars of band alone, one per chord. */
+export declare const vamp: (chords: string[], tune?: string) => Section;
+/** How the band voices chords: three comping tones (MIDI, low to high) and the bass root. */
+interface ChordBook {
+    voicing: (chord: string) => number[];
+    root: (chord: string) => number;
+}
+/** A chord book from tables of note names and bass roots (a song's own hand-picked voicings). */
+export declare function chordTable(voicing: Record<string, string[]>, root: Record<string, number>): ChordBook;
+type Drum = 'k' | 's' | 't' | 'c' | 'h';
+/** One bar of drums: per drum an 8th-note (8 chars) or 16th-note (16 chars) grid; 'x' hits, 'X' accents, '.' rests. */
+export type Groove = Partial<Record<Drum, string>>;
+export interface Part {
+    section: Section;
+    /** Melody patch on channel 0 (and the optional double on channel 1). */
+    lead: Uint8Array;
+    leadVel?: number;
+    /** Transpose the whole part (semitones). */
+    shift?: number;
+    /** Play the tune this much higher than written (12 for the flute and celesta). */
+    up?: number;
+    /** Channel 1: 'double' the tune an octave under the lead, 'octave' an octave over it, or none. */
+    second?: 'double' | 'octave' | 'none';
+    secondPatch?: Uint8Array;
+    secondVel?: number;
+    bass: 'whole' | 'half' | 'pump' | 'walk' | 'eighths';
+    bassPatch?: Uint8Array;
+    bassVel?: number;
+    /** Comping rhythm for one bar: 'x' chord, 'r' rest, each with a length, e.g. 'r e, x e, r e, x e, ...'. */
+    comp: string;
+    compPatch: Uint8Array;
+    compVel?: number;
+    /** A groove name per bar (the last one repeats). */
+    drums: string[];
+    drumVel?: number;
+    /** Leave the tune out (bars of band only). */
+    noTune?: boolean;
+}
+export declare class Writer {
+    private chords;
+    readonly tpb: number;
+    readonly events: CmfEvent[];
+    readonly instruments: Uint8Array[];
+    bar: number;
+    private current;
+    constructor(bpm: number, chords?: ChordBook);
+    private tick;
+    /** A note from beat `at` lasting `len` beats; it lets go a little early so the next one retriggers. */
+    note(ch: number, at: number, len: number, n: number, vel: number, legato?: number): void;
+    /** Plays a note string from beat `at`; returns its length in beats. */
+    line(ch: number, at: number, s: string, vel: number, shift?: number, legato?: number): number;
+    drums(at: number, g: Groove, vel: number): void;
+    /** The bass for `beats` beats from `at` under one chord. */
+    private bassLine;
+    /** Writes a section's bars: tune, second voice, bass, three comping voices and drums. */
+    part(p: Part): this;
+    /** Puts each melodic channel's patch in place for a part: the first part's are the file's instruments 0-5; later changes add an instrument and a program change. */
+    private patches;
+    /** The .CMF: ends exactly on the bar line, so PLAYGAME's restart keeps time. */
+    cmf(): Uint8Array;
+}
+export {};

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