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

package/dist/types/diskDiff.d.ts

@@ -0,0 +1,47 @@
+export type DiskFiles = ReadonlyMap<string, Uint8Array>;
+export interface ChangedFile {
+    name: string;
+    kind: string;
+    before: number;
+    after: number;
+    summary: string[];
+}
+export interface DiskDiff {
+    added: {
+        name: string;
+        kind: string;
+        size: number;
+    }[];
+    removed: {
+        name: string;
+        kind: string;
+        size: number;
+    }[];
+    changed: ChangedFile[];
+    unchanged: number;
+}
+/** What a file is, by its first bytes when they say, else by its extension. */
+export declare function sniffKind(name: string, bytes: Uint8Array): string;
+/** Numbers as ranges: 3,4,5,9 -> "3-5, 9". Long lists are cut. */
+export declare function ranges(nums: number[], max?: number): string;
+/** Lines added and removed: shared head and tail dropped, then a longest-common-subsequence. */
+export declare function lineDiff(a: string[], b: string[]): {
+    added: number;
+    removed: number;
+};
+/** Changed map cells grouped into clusters (cells within 3 of each other), as bounding boxes. */
+export declare function cellClusters(cells: number[], width: number): {
+    count: number;
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}[];
+/** A short plain-text summary of how one file changed; a parse failure falls back to bytes. */
+export declare function summarizeChange(name: string, a: Uint8Array, b: Uint8Array): {
+    kind: string;
+    summary: string[];
+};
+export declare function diffDisks(a: DiskFiles, b: DiskFiles): DiskDiff;
+/** The plain-text report: counts, then added, removed, and changed files with their summaries. */
+export declare function formatDiff(d: DiskDiff): string;

package/dist/types/drawing.d.ts

@@ -0,0 +1,15 @@
+export * from './kit/pixels.js';
+export * from './kit/palette.js';
+export * from './kit/pcText.js';
+export * from './kit/blit.js';
+export * from './kit/shading.js';
+export * from './kit/textBounds.js';
+export * from './kit/reel.js';
+export { FONT8X8 } from '@lewismoten/gamemaker-sandbox-engine/gfx/font8x8';
+export * from './text.js';
+export * from './colors.js';
+export * from './kit/microText.js';
+export { microGlyphs, type MicroGlyphs } from './microFont.js';
+export * from './kit/transforms.js';
+export * from './kit/coverPaint.js';
+export * from './kit/palRamps.js';

package/dist/types/embroidery/compile.d.ts

@@ -0,0 +1,3 @@
+import { type Design, type Params, type Pattern } from './types.js';
+/** Compiles the design to stitches, ending with an 'end' command; the threads are the blocks' threads in order. */
+export declare function compile(design: Design, params?: Partial<Params>): Pattern;

package/dist/types/embroidery/dst.d.ts

@@ -0,0 +1,13 @@
+import type { Pattern, Stitch } from './types.js';
+/** The DST file for a pattern. */
+export declare function writeDst(pattern: Pattern): Uint8Array;
+/** Reads a DST back into absolute stitches in mm (jumps and color changes included; the header counts are checked by the caller). */
+export declare function readDst(bytes: Uint8Array): {
+    stitches: Stitch[];
+    colorChanges: number;
+    label: string;
+    declared: {
+        stitches: number;
+        colors: number;
+    };
+};

package/dist/types/embroidery/exp.d.ts

@@ -0,0 +1,8 @@
+import type { Pattern, Stitch } from './types.js';
+/** The EXP file for a pattern. */
+export declare function writeExp(pattern: Pattern): Uint8Array;
+/** Reads an EXP back into absolute stitches in mm; the end is where the data stops. */
+export declare function readExp(bytes: Uint8Array): {
+    stitches: Stitch[];
+    colorChanges: number;
+};

package/dist/types/embroidery/fill.d.ts

@@ -0,0 +1,6 @@
+import type { Poly, Pt } from './types.js';
+/**
+ * The chains of needle points that fill the outlines with rows at `angle` degrees. Each chain is sewn in order; moving
+ * between chains is the caller's job.
+ */
+export declare function tatami(polys: Poly[], angle: number, spacing: number, len: number): Pt[][];

package/dist/types/embroidery/geom.d.ts

@@ -0,0 +1,19 @@
+import type { Poly, Pt } from './types.js';
+export declare const dist: (a: Pt, b: Pt) => number;
+/** A circle as a polygon of `n` points, counter-clockwise from the right. */
+export declare function circle(cx: number, cy: number, r: number, n?: number): Poly;
+/** A star with `points` tips (first tip at `start` radians) between an inner and an outer radius. */
+export declare function star(cx: number, cy: number, inner: number, outer: number, points: number, start?: number): Poly;
+/** Points on an elliptical arc from angle a0 to a1 (radians), `n` segments. */
+export declare function arc(cx: number, cy: number, rx: number, ry: number, a0: number, a1: number, n?: number): Pt[];
+/** Signed area (positive when counter-clockwise). */
+export declare function area(p: Poly): number;
+/** The outline moved `d` mm inward (outward when negative), mitered at the corners with the miter length capped. */
+export declare function inset(p: Poly, d: number): Poly;
+/** Even-odd containment in any of the outlines. */
+export declare function inside(polys: Poly[], pt: Pt): boolean;
+/** The path cut into points about `step` mm apart along it (its corners are kept). Closed paths return to the start. */
+export declare function resample(path: Pt[], step: number, closed?: boolean): Pt[];
+/** The path cut at even spacing by arc length (corners are not kept), for satin. */
+export declare function evenly(path: Pt[], step: number, closed?: boolean): Pt[];
+export declare const rotate: (p: Pt, a: number) => Pt;

package/dist/types/embroidery/pes.d.ts

@@ -0,0 +1,10 @@
+import type { Pattern, Stitch } from './types.js';
+/** The PES file for a pattern. */
+export declare function writePes(pattern: Pattern): Uint8Array;
+/** Reads a PES back (the PEC section) into absolute stitches in mm. */
+export declare function readPes(bytes: Uint8Array): {
+    stitches: Stitch[];
+    colorChanges: number;
+    threads: number;
+    label: string;
+};

package/dist/types/embroidery/satin.d.ts

@@ -0,0 +1,11 @@
+import type { Pt } from './types.js';
+/**
+ * The needle points of a satin column along `path` (closed paths end where they began).
+ * Each lane is one list; a column up to `maxWidth` is a single lane.
+ */
+export declare function satin(path: Pt[], width: number, density: number, closed: boolean, maxWidth: number): Pt[][];
+/**
+ * Underlay for a satin column: a walk down its center, and a loose zigzag a little narrower than the column when it is
+ * wide enough to need one.
+ */
+export declare function satinUnderlay(path: Pt[], width: number, run: number, closed: boolean): Pt[][];

package/dist/types/embroidery/simulate.d.ts

@@ -0,0 +1,19 @@
+import type { Pattern, RGB } from './types.js';
+export interface Picture {
+    w: number;
+    h: number;
+    rgb: Uint8Array;
+}
+export interface SimOptions {
+    /** Picture size in mm (square), centered on 0,0. */
+    size: number;
+    pxPerMm: number;
+    /** Thread width, mm (about 0.4 for 40 weight thread, drawn a little heavier to read at small size). */
+    thread?: number;
+    /** Backing fabric color. */
+    backing?: RGB;
+    /** The mm point at the middle of the picture (default 0,0), to look closely at one part. */
+    center?: [number, number];
+}
+/** Draws the pattern. */
+export declare function simulate(pattern: Pattern, o: SimOptions): Picture;

package/dist/types/embroidery/strokeFont.d.ts

@@ -0,0 +1,20 @@
+import type { Pt } from './types.js';
+export interface ArcTextOptions {
+    /** Center of the circle. */
+    cx: number;
+    cy: number;
+    /** Radius of the letters' baselines (their feet), mm; the stroke centers run from here out (top) or in (bottom). */
+    baseline: number;
+    /** Height of the letters in mm (stroke center to stroke center). */
+    height: number;
+    /** Gap between letters, mm. */
+    gap: number;
+    /** 'top' reads left to right over the top with feet toward the center; 'bottom' reads left to right under the bottom with heads toward the center. */
+    side: 'top' | 'bottom';
+    /** Stretches the letters sideways (1 = as drawn). */
+    stretch?: number;
+    /** Where the middle of the word sits, radians (default: straight up for top, straight down for bottom). */
+    center?: number;
+}
+/** The strokes (as paths of points, mm) that spell `text` bent around the circle. */
+export declare function arcText(text: string, o: ArcTextOptions): Pt[][];

package/dist/types/embroidery/svg.d.ts

@@ -0,0 +1,3 @@
+import type { Design, RGB } from './types.js';
+/** The SVG text of the design, `margin` mm of backing around a square of `size` mm. */
+export declare function designSvg(design: Design, size: number, backing?: RGB): string;

package/dist/types/embroidery/types.d.ts

@@ -0,0 +1,70 @@
+export type Pt = [number, number];
+/** A closed outline (the last point joins the first). */
+export type Poly = Pt[];
+export type RGB = [number, number, number];
+export interface Thread {
+    /** A generic color name ("midnight navy"), not a brand. */
+    name: string;
+    rgb: RGB;
+    /** Brother PEC thread-chart index (1-64) for the PES file; the machine shows its own color for it. */
+    pec?: number;
+}
+/** What the needle does next: sew to the point, move without sewing, cut the thread then move, change thread, or finish. */
+export type Cmd = 'stitch' | 'jump' | 'trim' | 'color' | 'end';
+export interface Stitch {
+    x: number;
+    y: number;
+    cmd: Cmd;
+}
+export interface Pattern {
+    name: string;
+    threads: Thread[];
+    stitches: Stitch[];
+}
+/** A shape filled with tatami (rows of stitches), under an optional underlay. */
+export interface FillItem {
+    kind: 'fill';
+    polys: Poly[];
+    /** Direction of the rows, degrees. Regions should alternate it. */
+    angle: number;
+}
+/** A column of satin zigzag along a line, `width` mm wide (split into lanes beyond 7 mm). */
+export interface SatinItem {
+    kind: 'satin';
+    path: Pt[];
+    width: number;
+    closed?: boolean;
+}
+/** A plain line of running stitches. */
+export interface RunItem {
+    kind: 'run';
+    path: Pt[];
+    closed?: boolean;
+}
+export type Item = FillItem | SatinItem | RunItem;
+/** Everything sewn in one thread, in order; a color change comes between blocks. */
+export interface Block {
+    thread: Thread;
+    items: Item[];
+}
+export interface Design {
+    name: string;
+    /** The hoop's sewing field in mm. */
+    hoop: [number, number];
+    /** Blocks in sewing order. */
+    blocks: Block[];
+}
+/** The tuning numbers of the generator, in mm. */
+export interface Params {
+    fillSpacing: number;
+    fillLength: number;
+    satinDensity: number;
+    /** Extra satin width (total) so the thread draws in and still covers its shape. */
+    pullComp: number;
+    /** Outline growth of fills for the same reason. */
+    fillGrow: number;
+    maxStitch: number;
+    underlayRun: number;
+    maxSatin: number;
+}
+export declare const DEFAULTS: Params;

package/dist/types/embroidery/units.d.ts

@@ -0,0 +1,10 @@
+import type { Cmd, Pattern } from './types.js';
+export interface Move {
+    dx: number;
+    dy: number;
+    cmd: Cmd;
+}
+/** Cut-off for one record's move in either direction, in tenths of a millimeter (Tajima DST's limit; EXP and PES take more). */
+export declare const MAX_MOVE = 121;
+/** The pattern's records. Positions are rounded as absolute tenths, so rounding never builds up along a long run. */
+export declare function toRecords(pattern: Pattern, maxMove?: number): Move[];

package/dist/types/embroidery/validate.d.ts

@@ -0,0 +1,22 @@
+import type { Stitch } from './types.js';
+export interface Report {
+    stitches: number;
+    jumps: number;
+    colorChanges: number;
+    /** Longest sewn stitch and longest single jump record, mm. */
+    maxStitch: number;
+    maxJump: number;
+    /** Extents of every needle position, mm: [minX, minY, maxX, maxY]. */
+    extents: [number, number, number, number];
+    width: number;
+    height: number;
+    problems: string[];
+}
+export interface Expect {
+    hoop: [number, number];
+    /** Number of thread colors; the file must change color this many minus one times. */
+    colors: number;
+    /** The longest single record the format allows, mm (12.1 for DST). */
+    maxRecord: number;
+}
+export declare function validate(list: Stitch[], want: Expect): Report;

package/dist/types/formats/blocks.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';

package/dist/types/formats/character.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/character';

package/dist/types/formats/cmf.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/cmf';

package/dist/types/formats/fli.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/fli';

package/dist/types/formats/fliLimits.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/fliLimits';

package/dist/types/formats/game.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/game';

package/dist/types/formats/gif.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/gif';

package/dist/types/formats/graphicScripts.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/graphicScripts';

package/dist/types/formats/map.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/map';

package/dist/types/formats/monster.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/monster';

package/dist/types/formats/palette.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/palette';

package/dist/types/formats/recording.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/recording';

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

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/sound';

package/dist/types/formats/voc.d.ts

@@ -0,0 +1 @@
+export * from '@lewismoten/gamemaker-sandbox-engine/formats/voc';

package/dist/types/gifShrink.d.ts

@@ -0,0 +1,8 @@
+export interface GifShrink {
+    bytes: Uint8Array;
+    /** Table size before and after. */
+    from: number;
+    to: number;
+}
+/** The smaller file, or undefined when the table can't shrink without changing what PLAYGAME shows. */
+export declare function shrinkGif(bytes: Uint8Array): GifShrink | undefined;

package/dist/types/image/animatedGif.d.ts

@@ -0,0 +1,9 @@
+export interface AnimatedFrame {
+    /** width * height palette indexes. */
+    pixels: Uint8Array;
+    /** 768 bytes, 6 bits per channel. */
+    palette: Uint8Array;
+    /** Hundredths of a second this frame shows. */
+    delay: number;
+}
+export declare function encodeAnimatedGif(width: number, height: number, frames: AnimatedFrame[]): Uint8Array;

package/dist/types/image/png.d.ts

@@ -0,0 +1,10 @@
+export interface IndexedPicture {
+    width: number;
+    height: number;
+    pixels: Uint8Array;
+    /** 256 colors x 3 levels of 0-63. */
+    palette: Uint8Array;
+}
+export declare function encodePng(pic: IndexedPicture, scale?: number): Promise<Uint8Array>;
+/** Bytes as base64 (an MCP image block's data). */
+export declare function base64(bytes: Uint8Array): string;

package/dist/types/image/surface.d.ts

@@ -0,0 +1,26 @@
+import { Pixels } from '../kit/pixels.js';
+export type SurfaceMirror = 'none' | 'h' | 'v' | 'both';
+/** The pixel and its mirror images across the whole picture, without repeats. */
+export declare function mirrorAll(x: number, y: number, w: number, h: number, mirror: SurfaceMirror): [number, number][];
+type Plot = (x: number, y: number) => void;
+/** Every pixel of a straight line from a to b. */
+export declare function line(a: {
+    x: number;
+    y: number;
+}, b: {
+    x: number;
+    y: number;
+}, plot: Plot): void;
+/** The outline of the box with corners a and b. */
+export declare function box(a: {
+    x: number;
+    y: number;
+}, b: {
+    x: number;
+    y: number;
+}, plot: Plot): void;
+/** Fills one four-connected color region. A mask and writer can preserve missing or shared tiles. */
+export declare function floodFill(px: Uint8Array, w: number, h: number, x: number, y: number, v: number, allowed?: (x: number, y: number) => boolean, paint?: (x: number, y: number, value: number) => void): void;
+/** Move indexed pixels with wrapping at each edge; the input is unchanged. */
+export declare function shiftPixels(src: Pixels, dx: number, dy: number): Pixels;
+export {};

package/dist/types/images.d.ts

@@ -0,0 +1,13 @@
+export { encodePng, type IndexedPicture } from './image/png.js';
+export { crc32 } from '@lewismoten/gamemaker-sandbox-archives/zip';
+export { Pixels } from './kit/pixels.js';
+export { flipX, flipY, turn90, turn180 } from './kit/transforms.js';
+export { mirrorAll, line, box, floodFill, shiftPixels, type SurfaceMirror } from './image/surface.js';
+/** Portable RGBA pixels; accepts ImageData without requiring canvas or a DOM. RGB is treated as opaque. */
+export interface RgbaPixels {
+    width: number;
+    height: number;
+    data: ArrayLike<number>;
+}
+/** Median cut over the given RGBA images: up to `colors` 8-bit colors. */
+export declare function medianCutRgba(images: readonly RgbaPixels[], colors?: number): [number, number, number][];

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

@@ -0,0 +1,7 @@
+import { type Frame, type Sequence } from '@lewismoten/gamemaker-sandbox-engine/formats/character';
+import { type March, type Monster } from '@lewismoten/gamemaker-sandbox-engine/formats/monster';
+export declare function set(s: Sequence, frames: Frame[], o?: Partial<Omit<Sequence, 'frames'>>): void;
+export declare function mon(pics: [number, number][], o: Partial<Monster>, path?: March[]): Monster;
+export declare const corner: (x: number, y: number, speed: number, orient?: number) => March;
+/** Back and forth `run` blocks (to the right first) at `speed`, facing the way it goes. */
+export declare const pace: (run: number, speed: number, dy?: number) => March[];

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

@@ -0,0 +1,93 @@
+import { type Block } from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';
+/** What a map cell holds, by block name ('' or undefined for unnamed). */
+export type NameAt = (x: number, y: number) => string | undefined;
+/** A wanted part: its name, or a test (a RegExp, or { test, toString } for the report). */
+type Want = string | {
+    test(got: string): boolean;
+    toString(): string;
+};
+/** Where a part wants its neighbors: [dx, dy, wanted]. */
+export type Need = [number, number, Want][];
+/** A part and the parts that must sit beside it. `need` may be a function of the part's regex
+ * match; with several needs (a part that can stand in more than one place of its object) one
+ * of them must hold. */
+export interface PartRule {
+    part: string | {
+        test(name: string): boolean;
+    };
+    need: Need | Need[] | ((m: RegExpExecArray) => Need);
+    /** Name for the report (default: the part's name). */
+    what?: string;
+    /** false: the neighbors it checks are not parts of its object (no art join to measure). */
+    joins?: boolean;
+}
+/** Every part whose neighbors are wrong: "name at x,y: wanted W at dx,dy, found G". Parts must
+ * not run off the map's edge either (playgame's maps wrap, so the other side is wrong too).
+ * Right-hand and lower neighbors that are right go into `joined` (JSON [left or upper, right or
+ * lower, 'h' or 'v']), the pairs whose art must join up. */
+export declare function checkParts(at: NameAt, rules: PartRule[], w?: number, h?: number, joined?: Set<string>): string[];
+/** Rules for objects whose parts are named by column and row (house:0,1 or cat12): every part
+ * wants every other part of its object. `sizes` gives each object's columns and rows; `name`
+ * turns object, column and row back into a part name. `alias` lets an animation frame stand
+ * in for a part. */
+export declare function gridParts(re: RegExp, sizes: Map<string, [number, number]>, name: (obj: string, c: number, r: number) => string, alias?: (got: string) => string): PartRule;
+/** Rules for an object drawn as rows of parts (null: any block): each part wants every other
+ * part of the object at its place (a part found at several places: at one of them). */
+export declare function shape(what: string, rows: (Want | null)[][]): PartRule[];
+/** Pairs: every `a` has a `b` at dx, dy and every `b` an `a` the other way. */
+export declare const pair: (what: string, a: Want, b: Want, dx: number, dy: number) => PartRule[];
+/** Rules read off the maps themselves, for a game whose objects are numbered parts (sign0
+ * sign1 sign2, or sign00 sign01 down a column): where part n mostly stands (`share` of the
+ * time) with part n+1 just right of it (or just below it), that is how the object goes
+ * together, and every part n and n+1 must be so. Numbered animation frames and patterns don't
+ * stand that way, so they get no rule.
+ * `skip` leaves out stems that only look like objects. */
+export declare function autoParts(maps: NameAt[], names: Iterable<string>, skip?: RegExp, share?: number): PartRule[];
+/** A block book's names by block number. */
+export declare function namesOf(index: Map<string, number>): string[];
+/** Object sizes (columns, rows) from a block set's part names matched by `re` (object, col, row). */
+export declare function sizesOf(names: Iterable<string>, re: RegExp): Map<string, [number, number]>;
+/** A block's picture: palette index at x, y (0..19). */
+type Pic = (x: number, y: number) => number;
+interface Seam {
+    a: string;
+    b: string;
+    dir: 'h' | 'v';
+    /** Mean color distance across the shared edge. */
+    across: number;
+    /** Draws the pair joined (scaled up) into a PNG, for a look. */
+    draw?: (file: string, s?: number) => void;
+    /** Mean color distance one pixel in from the edge, on the busier side (the art's own texture,
+     * so a pattern with a line on its edge, like tile grout, is not a break). */
+    within: number;
+}
+/** How sharply each joined pair's art changes across its shared edge ('h': b right of a,
+ * 'v': b below a), next to how much it changes one pixel either side of the edge. A seam
+ * whose `across` is far above `within` is where the art breaks (an outline, a jump). */
+export declare function seams(pic: (name: string) => Pic, pal: Uint8Array, pairs: [string, string, 'h' | 'v'][]): Seam[];
+/** Seams that look broken: the colors jump across the edge much more than beside it. */
+export declare function brokenSeams(s: Seam[], factor?: number, floor?: number): Seam[];
+/** One adventure scene of a built disk: its name, palette, map and background blocks. */
+export interface DiskScene {
+    desc: string;
+    map: string;
+    pal: Uint8Array;
+    blocks: Uint8Array;
+    bbl: Block[];
+}
+/** Every adventure scene on a built disk (the .gam's scenes, by their files). */
+export declare function diskScenes(disk: string): DiskScene[];
+/** A PNG of map cells x..x+w, y..y+h of a disk scene (wrapping like playgame), scaled `s`
+ * times; `blocks` overrides the scene's block pictures (to show art before a fix). */
+export declare function writeArea(file: string, sc: DiskScene, x: number, y: number, w: number, h: number, s?: number, blocks?: Block[]): void;
+/** Checks a built disk: every map's multi-block objects (names: each map file's block names by
+ * number, undefined to skip the map) by the rules (or each map's own rules), and the art of every pair the maps join. */
+export declare function auditDisk(disk: string, names: (map: string) => string[] | undefined, rules: PartRule[] | ((map: string) => PartRule[]), opts?: {
+    factor?: number;
+    floor?: number;
+}): {
+    maps: [string, string[]][];
+    seams: Seam[];
+    broken: Seam[];
+};
+export {};

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

@@ -0,0 +1,26 @@
+export type AudioEvent = {
+    t: number;
+    kind: 'song';
+    bytes?: Uint8Array;
+} | {
+    t: number;
+    kind: 'stopSong';
+} | {
+    t: number;
+    kind: 'pause';
+    paused: boolean;
+} | {
+    t: number;
+    kind: 'speaker';
+    freqs: ArrayLike<number>;
+} | {
+    t: number;
+    kind: 'stopSpeaker';
+} | {
+    t: number;
+    kind: 'voc';
+    bytes?: Uint8Array;
+} | {
+    t: number;
+    kind: 'stopVoc';
+};

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

@@ -0,0 +1,20 @@
+import { Pixels } from './pixels.js';
+export declare const CLEAR = 255;
+/** Copies src over dst, skipping clear pixels. */
+export declare function over(dst: Pixels, src: Pixels, x?: number, y?: number): Pixels;
+/** Recolors every pixel through a lookup (palette swaps for variants and hurt flashes). */
+export declare function recolor(src: Pixels, fn: (c: number) => number): Pixels;
+/** Nearest-neighbor scaled copy (for big sprites on screens). */
+export declare function scaleBlit(dst: Pixels, src: Pixels, x: number, y: number, s: number, flip?: boolean, transparent?: number): void;
+/** Adds a 1 pixel outline in `ink` around every opaque pixel. */
+export declare function outline(src: Pixels, ink: number, options?: {
+    transparent?: number;
+    ignoreInk?: boolean;
+}): Pixels;
+export declare function asciiSprite(rows: string[], key: Record<string, number>, dx?: number, dy?: number, w?: number, h?: number): Pixels;
+/** Draw ASCII art through the indexed canvas. */
+export declare const asciiArt: (p: Pixels, x: number, y: number, rows: string[], key: Record<string, number>) => Pixels;
+/** Scale with an explicit transparent color and no mirroring. */
+export declare const scaleBlitTransparent: (dst: Pixels, src: Pixels, x: number, y: number, scale: number, transparent?: number) => void;
+/** In-place variant for existing sprite canvases. */
+export declare function outlineInPlace(p: Pixels, ink: number, transparent?: number): Pixels;