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

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

@@ -0,0 +1,10 @@
+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): void;
+/** Adds a 1 pixel outline in `ink` around every opaque pixel. */
+export declare function outline(src: Pixels, ink: number): Pixels;

package/dist/types/games/kit/clips.d.ts

@@ -0,0 +1,36 @@
+import type { AudioEvent } from '../../web/src/walkthrough/runtime.js';
+export interface ClipCut {
+    kind: 'end' | 'start';
+    /** The scene the clip started in. */
+    scene: number;
+    clip: string;
+    /** The clip's length and how much of it played, in ms. */
+    ms: number;
+    played: number;
+    /** What cut it: 'picture' (ShowGraphic or the end of the run) or the clip that played over it. */
+    by: string;
+    /** When it started, in ms of the walkthrough's clock. */
+    at: number;
+    /** A start clip: ms from the level's first frame. */
+    since?: number;
+}
+export interface ClipLog {
+    events: AudioEvent[];
+    /** When play entered each scene (before its intro picture). */
+    scenes: {
+        t: number;
+        n: number;
+    }[];
+    /** Each scene's first frame of play (after the intro and the fade in). */
+    starts: {
+        t: number;
+        n: number;
+    }[];
+    /** File names of the disk's clips, by their bytes. */
+    names: Map<Uint8Array, string>;
+}
+/** A .VOC clip's length in ms. */
+export declare function vocMs(bytes: Uint8Array): number;
+/** Every clip the run cut off at a scene's end or at a level's start. */
+export declare function clipCuts(log: ClipLog): ClipCut[];
+export declare function describeCut(c: ClipCut): string;

package/dist/types/games/kit/gameSim.d.ts

@@ -0,0 +1,108 @@
+import { type CharInfo, type World } from '../../web/src/engine/world.js';
+import { type Game } from '../../web/src/formats/game.js';
+import type { RecordedKey } from '../../web/src/formats/recording.js';
+/** PLAYGAME's game clock. */
+export declare const TICKS_PER_SECOND = 18.2;
+/** A built disk's files (in games/<id>/disk), by lower-case name. */
+export declare function readDisk(diskDir: string): Map<string, Uint8Array>;
+/** Keys pressed in one scene, timed from the tick play entered it. */
+interface SceneKeys {
+    scene: number;
+    keys: RecordedKey[];
+}
+interface State {
+    w: World;
+    rand: number;
+    scene: number;
+    prev: number;
+    link: number;
+    ticks: number;
+    clock: number;
+    lastKeyTick: number;
+    held: number[];
+    pending: number[];
+    doScroll: boolean;
+    ended: GameSim['ended'];
+    deaths: number;
+    trail: number[];
+    segments: SceneKeys[];
+    segmentTicks: number[];
+    clip: GameSim['clip'];
+}
+export declare class GameSim {
+    readonly files: Map<string, Uint8Array>;
+    readonly seed: number;
+    readonly game: Game;
+    ci: CharInfo;
+    w: World;
+    scene: number;
+    prev: number;
+    link: number;
+    /** Scenes entered, in order (a death enters the same scene again). */
+    trail: number[];
+    /** Game ticks since play entered the current scene (a segment's clock). */
+    ticks: number;
+    /** Keys per scene entered (a scene entered again after a death keeps counting on). */
+    segments: SceneKeys[];
+    /** Ticks each finished segment ran. */
+    segmentTicks: number[];
+    private lastKeyTick;
+    private held;
+    private pending;
+    private doScroll;
+    /** TimerCounter: it runs on across scenes. */
+    private clock;
+    private rand;
+    ended: 'won' | 'lost' | undefined;
+    deaths: number;
+    /**
+     * The .VOC clip the Sound Blaster is playing (PlaySbVocFile: a new one cuts it off), with
+     * the game clock tick it ends on; a scene's exit or intro picture cuts it too (ShowGraphic).
+     */
+    clip: {
+        name: string;
+        until: number;
+    } | undefined;
+    constructor(files: Map<string, Uint8Array>, seed?: number);
+    private file;
+    /** loadscene + StartSceneInits, as playScene does them. */
+    private enter;
+    press(scan: number): void;
+    release(scan: number): void;
+    releaseAll(): void;
+    isHeld(scan: number): boolean;
+    private event;
+    /** One game tick; returns 'link' (into another scene), 'dead' or 'end'. */
+    tick(): Promise<'link' | 'dead' | 'end' | undefined>;
+    /** Game ticks until the clip playing now ends (0 when none is). */
+    get clipTicksLeft(): number;
+    /**
+     * Stands still until the clip playing now has played to the end, so the bot's next sound
+     * (a jump, a pickup) doesn't cut it off: a level's start clip, say. Returns what a tick
+     * returned if play left the scene meanwhile.
+     */
+    waitForClip(): Promise<'link' | 'dead' | 'end' | undefined>;
+    /** The character's block and the pixels past it. */
+    get pos(): {
+        x: number;
+        y: number;
+        sx: number;
+        sy: number;
+    };
+    meter(i: number): number;
+    /** Money: Game-Maker's counter 3, which shows meter - 1. */
+    get money(): number;
+    /** The block number at (x, y) as it is now (a block taken or pushed is a new block number). */
+    blockAt(x: number, y: number): number;
+    /** The block's attributes as shown now (timed blocks change by themselves). */
+    shown(x: number, y: number): import("../../web/src/formats/blocks.js").Block;
+    solidAt(x: number, y: number): boolean;
+    snapshot(): State;
+    restore(s: State): void;
+}
+/**
+ * A GameSim for one game's built disk: `diskSim(new URL('../disk', import.meta.url))` in the
+ * game's tools/sim.ts. It reads the disk when made without files; the seed defaults to 1.
+ */
+export declare function diskSim(disk: URL): new (files?: Map<string, Uint8Array>, seed?: number) => GameSim;
+export {};

package/dist/types/games/kit/music.d.ts

@@ -0,0 +1 @@
+export * from '../../web/src/audio/compose.js';

package/dist/types/games/kit/palette.d.ts

@@ -0,0 +1,16 @@
+export declare class PaletteBuilder {
+    readonly pal: Uint8Array<ArrayBuffer>;
+    private next;
+    readonly ramps: Map<string, number[]>;
+    /** One color from 8-bit RGB; returns its index. */
+    color(r: number, g: number, b: number): number;
+    /** A ramp of n shades from dark to light (8-bit RGB stops); returns the indexes. */
+    ramp(name: string, n: number, from: readonly [number, number, number], to: readonly [number, number, number], mid?: readonly [number, number, number]): number[];
+    get(name: string): number[];
+    /**
+     * Game-Maker's designers look for these grays, reds, black and LCD green; keep them. Black
+     * comes first: PLAYGAME clears the screen to color 0 before the high score prompt.
+     */
+    designerColors(): void;
+    get used(): number;
+}

package/dist/types/games/kit/pcText.d.ts

@@ -0,0 +1,8 @@
+import { Pixels } from './pixels.js';
+/** Text in the PC font; returns the width drawn. */
+export declare function text(p: Pixels, x: number, y: number, s: string, col: number, scale?: number): number;
+export declare const textWidth: (s: string, scale?: number) => number;
+/** Text with an outline (and an optional drop shadow). */
+export declare function outlined(p: Pixels, x: number, y: number, s: string, col: number, edge: number, scale?: number, shadow?: number): void;
+/** Centered text (outlined when `edge` is given). */
+export declare function centered(p: Pixels, y: number, s: string, col: number, scale?: number, edge?: number, cx?: number, shadow?: number): void;

package/dist/types/games/kit/pixels.d.ts

@@ -0,0 +1,26 @@
+export declare class Pixels {
+    readonly w: number;
+    readonly h: number;
+    readonly px: Uint8Array;
+    constructor(w: number, h: number, fill?: number);
+    get(x: number, y: number): number;
+    set(x: number, y: number, c: number): this;
+    rect(x: number, y: number, w: number, h: number, c: number): this;
+    frame(x: number, y: number, w: number, h: number, c: number): this;
+    line(x0: number, y0: number, x1: number, y1: number, c: number): this;
+    disc(cx: number, cy: number, r: number, c: number): this;
+    ring(cx: number, cy: number, r: number, c: number): this;
+    /** Every pixel through fn(x, y, current) → new color (or the same). */
+    map(fn: (x: number, y: number, c: number) => number): this;
+    /** Copies another picture in, skipping `transparent` pixels. */
+    blit(src: Pixels, dx: number, dy: number, transparent?: number): this;
+    /** A sub-rectangle as a new picture (cutting a 20x20 block out of a big drawing). */
+    crop(x: number, y: number, w: number, h: number): Pixels;
+    flipX(): Pixels;
+    /** ASCII art: each character maps to a color through `key`; others are skipped. */
+    draw(x: number, y: number, rows: string[], key: Record<string, number>): this;
+}
+/** A seeded random number generator (mulberry32), so builds are reproducible. */
+export declare function rng(seed: number): () => number;
+/** 4x4 Bayer matrix ordered dither: true where a pixel at (x, y) should take the lighter color for level 0..1. */
+export declare function dither(x: number, y: number, level: number): boolean;

package/dist/types/games/kit/reel.d.ts

@@ -0,0 +1,34 @@
+import { Pixels } from './pixels.js';
+/** The palette (6-bit VGA) faded toward black: light 0 is black, 1 is unchanged. */
+export declare function dimmed(pal: Uint8Array, light: number): Uint8Array;
+export declare class Reel {
+    /** The reel's palette (6-bit VGA, 768 bytes). */
+    readonly pal: Uint8Array;
+    readonly w: number;
+    readonly h: number;
+    readonly frames: Uint8Array[];
+    readonly palettes: Uint8Array[];
+    private last?;
+    constructor(
+    /** The reel's palette (6-bit VGA, 768 bytes). */
+    pal: Uint8Array, w?: number, h?: number);
+    /** Adds a picture for `hold` frames, its palette faded to `light`. */
+    add(p: Pixels, hold?: number, light?: number, pal?: Uint8Array<ArrayBufferLike>): this;
+    /** A picture drawn over a copy of `bg` (the actors over the scenery), for `hold` frames. */
+    frame(bg: Pixels, draw: (p: Pixels) => void, hold?: number, light?: number, pal?: Uint8Array<ArrayBufferLike>): this;
+    /** The picture fading in from black over `n` frames (the last at full light). */
+    fadeIn(p: Pixels, n: number, pal?: Uint8Array<ArrayBufferLike>): this;
+    /** The last picture fading out to black over `n` frames. */
+    fadeOut(n: number): this;
+    /**
+     * A cartoon's closing iris: black closes in on (cx, cy) over `n` frames from the last picture
+     * down to a circle `end` pixels across (round on a 4:3 screen: VGA's pixels are taller than
+     * wide), and holds there `hold` frames. Follow it with fadeOut. Gives an intro whose pictures
+     * are the title's art a last view that isn't the title.
+     */
+    irisOut(cx: number, cy: number, n: number, end?: number, hold?: number): this;
+    /** The .FLI: `speed` is the wait after each frame in 1/70 s (5 = 14 frames a second). */
+    fli(speed: number): Uint8Array;
+    /** How long it plays, in seconds. */
+    seconds(speed: number): number;
+}

package/dist/types/games/kit/sceneSim.d.ts

@@ -0,0 +1,84 @@
+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';
+export interface SimScene {
+    map: GameMap;
+    bbl: Block[];
+    mbl?: Block[];
+    mon?: Monster[];
+    chr: Character;
+    cbl: Block[];
+    links?: {
+        from: {
+            x: number;
+            y: number;
+        };
+        to: {
+            x: number;
+            y: number;
+        };
+    }[];
+    /** Monster names by number (for bots that look for one). */
+    names?: string[];
+}
+/** What Sim.snapshot() keeps. */
+interface SimState {
+    w: Omit<World, 'sound' | 'rand' | 'joystick' | 'bg' | 'mblk' | 'cblk' | 'mon' | 'palette' | 'chr'>;
+    chr: Character;
+    randA: number;
+    held: number[];
+    pending: number[];
+    doScroll: boolean;
+    sounds: number;
+    ticks: number;
+    link: number;
+    dead: boolean;
+}
+export declare class Sim {
+    readonly scene: SimScene;
+    readonly w: World;
+    private held;
+    private doScroll;
+    sounds: number[];
+    /** Ticks played so far. */
+    ticks: number;
+    /** Called with every key event (scan, bit 7 = released), e.g. to record a demo. */
+    onKey?: (key: number) => void;
+    /** Link index reached (-1 = none yet). */
+    link: number;
+    dead: boolean;
+    constructor(scene: SimScene, start: {
+        x: number;
+        y: number;
+    }, ci?: CharInfo, seed?: number, 
+    /** False for games whose scenes never scroll (one screen each): the scroll window is shut. */
+    scroll?: boolean);
+    /** kit/pixels.ts rng() (mulberry32), with its state out where a snapshot can keep it. */
+    private randA;
+    private rand;
+    /** Everything that changes as the scene plays, to try a move and take it back with restore(). */
+    snapshot(): SimState;
+    restore(s: SimState): void;
+    press(scan: number): void;
+    release(scan: number): void;
+    private pending;
+    private event;
+    /** One 18.2 Hz game tick (8 scroll steps + tick()). */
+    tick(): Promise<void>;
+    run(ticks: number, each?: (t: number) => void | boolean): Promise<void>;
+    /** Live monsters called `name`, with their block positions. */
+    monsters(name: string): {
+        x: number;
+        y: number;
+    }[];
+    /** Character position in pixels (x of its column, y of its bottom block). */
+    get pos(): {
+        x: number;
+        y: number;
+        bx: number;
+        by: number;
+    };
+}
+export {};

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

@@ -0,0 +1,11 @@
+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. */
+export declare function gradient(p: Pixels, x0: number, y0: number, w: number, h: number, ramp: number[], lo: number, hi: number): 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): 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;

package/dist/types/games/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/games/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/games/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/web/packages/tools/src/audio.d.ts

@@ -0,0 +1,3 @@
+export * from '../../../src/audio/compose.js';
+export * from '../../../../games/kit/tune.js';
+export * from '../../../../games/kit/sound.js';

package/dist/types/web/packages/tools/src/colors.d.ts

@@ -0,0 +1,20 @@
+export type RGB = readonly [number, number, number];
+export type TimeOfDay = 'morning' | 'noon' | 'afternoon' | 'sunset' | 'night' | 'show';
+export interface Lighting {
+    readonly mul: RGB;
+    readonly add: RGB;
+}
+/** Eight-bit RGB lighting presets; show is warm stage lighting. */
+export declare const TIME_OF_DAY_LIGHT: Readonly<Record<TimeOfDay, Lighting>>;
+/** Eight-bit sky ramp endpoints and optional middle stop, dark to light. */
+export declare const TIME_OF_DAY_SKY: Readonly<Record<TimeOfDay, readonly [RGB, RGB, RGB?]>>;
+/** Light one eight-bit RGB color, rounding and clamping each component. */
+export declare function lightColor(color: RGB, lighting: TimeOfDay | Lighting): [number, number, number];
+/** A pure eight-bit RGB ramp, including both endpoints; a middle stop falls at t=0.5. */
+export declare function colorRamp(count: number, from: RGB, to: RGB, mid?: RGB): [number, number, number][];
+/**
+ * Light a native 768-byte, six-bit VGA palette, without changing pixel indexes or the input.
+ * Indexes 0 (engine clear color) and 255 (transparent) are preserved by default. Supply
+ * your own list to protect glowing ramps, designer colors, or to adjust every entry ([]).
+ */
+export declare function adjustPalette(palette: Uint8Array, lighting: TimeOfDay | Lighting, preserve?: readonly number[]): Uint8Array;

package/dist/types/web/packages/tools/src/drawing.d.ts

@@ -0,0 +1,10 @@
+export * from '../../../../games/kit/pixels.js';
+export * from '../../../../games/kit/palette.js';
+export * from '../../../../games/kit/pcText.js';
+export * from '../../../../games/kit/blit.js';
+export * from '../../../../games/kit/shading.js';
+export * from '../../../../games/kit/textBounds.js';
+export * from '../../../../games/kit/reel.js';
+export { FONT8X8 } from '../../../src/gfx/font8x8.js';
+export * from './text.js';
+export * from './colors.js';

package/dist/types/web/packages/tools/src/images.d.ts

@@ -0,0 +1,2 @@
+export { encodePng, type IndexedPicture } from '../../../src/assistant/png.js';
+export { crc32 } from '../../../src/project/zip.js';

package/dist/types/web/packages/tools/src/microFont.d.ts

@@ -0,0 +1 @@
+export declare const MICRO_GLYPHS: Readonly<Record<string, string>>;

package/dist/types/web/packages/tools/src/simulation.d.ts

@@ -0,0 +1,3 @@
+export { Sim, type SimScene } from '../../../../games/kit/sceneSim.js';
+export { GameSim, readDisk, diskSim, TICKS_PER_SECOND } from '../../../../games/kit/gameSim.js';
+export { newCharInfo, type CharInfo } from '../../../src/engine/world.js';

package/dist/types/web/packages/tools/src/text.d.ts

@@ -0,0 +1,41 @@
+import { FONT_CP437 } from '../../../src/gfx/cp437Glyphs.js';
+import { toCp437, fromCp437 } from '../../../src/retro/text/cp437.js';
+import { Pixels } from '../../../../games/kit/pixels.js';
+import { MICRO_GLYPHS } from './microFont.js';
+export { FONT_CP437, toCp437, fromCp437, MICRO_GLYPHS };
+export type TextFont = 'cp437' | 'micro';
+/** Encode Unicode DOS symbols, including box drawing. Unsupported characters throw. */
+export declare function encodeText(s: string): Uint8Array;
+/** A fresh copy of a glyph's rows; bit 0 is the leftmost pixel. */
+export declare function glyphRows(code: number, font?: TextFont): Uint8Array;
+export interface TextOptions {
+    font?: TextFont;
+    /** Palette index, 0..254; 255 is reserved for transparent pixels. */
+    color?: number;
+    scale?: number;
+    /** A one-output-pixel outline, including diagonal neighbors. */
+    outline?: number;
+    /** Shadow offset in output pixels, independent of glyph scale. */
+    shadow?: {
+        color: number;
+        dx?: number;
+        dy?: number;
+    };
+}
+export interface TextImage {
+    width: number;
+    height: number;
+    /** Row-major palette indexes; transparent pixels are 255. */
+    pixels: Uint8Array;
+    /** Where the unadorned first text cell begins within the image. */
+    originX: number;
+    originY: number;
+}
+/** Same-size shadowed sprite; pixels beyond the source canvas are clipped. */
+export declare function dropShadow(src: Pixels, ink: number, dx?: number, dy?: number): Pixels;
+/**
+ * Render Unicode text (LF/CRLF separated lines) or raw CP437 bytes (one row, including
+ * control-code glyphs). Returns native indexed pixels, with enough padding for effects.
+ * CP437 cells are 8×8; micro cells are 3×5 plus a 1px gap, with no trailing gap.
+ */
+export declare function renderText(text: string | Uint8Array, options?: TextOptions): TextImage;

package/dist/types/web/scripts/cdGames.d.ts

@@ -0,0 +1,103 @@
+import type { Plugin } from 'vite';
+import type { PrintablesFile } from '../src/manual/printables/types.js';
+import { type Issue } from '../src/project/health.js';
+import { type BoxGame } from '../src/desk/boxes/boxFacts.js';
+export interface CdCatalogEntry {
+    id: string;
+    title: string;
+    kind: 'gameware' | 'shareware';
+    /** Folder of the game's files, relative to the site root. */
+    path: string;
+    gam: string | null;
+    files: string[];
+    /** Size of each file in `files`, in bytes. */
+    sizes: number[];
+    /** Shareware: the author's notice (readme / order form), as text. */
+    notice?: string;
+    /** Shareware: CRC-32 of the .gam file, to recognize the game when imported. */
+    gamCrc?: number;
+    /** Total size of the game's files in bytes. */
+    bytes: number;
+    /** Shareware: the name of its DOS program (listed on the retro PC; never served). */
+    exe?: string;
+    /** A few lines from the game's own story or instruction screen. */
+    blurb?: string;
+    author?: string;
+    company?: string;
+    year?: number;
+    price?: string;
+    /** Original games (../games): the disk label, box art and manual, from about.json. */
+    original?: OriginalExtras;
+    /** Original games: about.json "series" ("bizarre": The Bard of Bizarre's games, src/project/bizarre.ts). */
+    series?: string;
+    /** games/catalog.json: the entry has a games/details/<id>.json (see slimCatalog). */
+    details?: boolean;
+    /** Original games: the site path of the game's walkthrough (../games/<id>/walkthrough.json, src/walkthrough). */
+    walkthrough?: string;
+    /** Original games: its DOS player look, ../games/<id>/player.json ({ base, patches }: src/dosPlayer/catalogPatches.ts). */
+    player?: unknown;
+    /** The build drew its pictures (games/shots/<id>-<cols>x<rows>.png, scripts/gameShots.ts). */
+    shots?: boolean;
+    /** …and its hero (games/shots/<id>-hero.png). */
+    heroShot?: boolean;
+    /** All its files in one gzipped file in its folder, named by a hash of them (packName, src/project/gamePack.ts). */
+    pack?: string;
+    /** Built sites: what the home page's quick check finds in it (src/editor/shell/gameHealth.ts), so the page need not fetch files to know. */
+    health?: Issue[];
+    /** Built sites: the size of its pack in bytes (what downloading it for offline use costs, src/offline). */
+    packBytes?: number;
+    /** Built sites, games with a box: what the box reads from the .gam (src/desk/boxes/boxFacts.ts). */
+    boxGame?: BoxGame;
+}
+/** What ../games/<id>/about.json and manual.json add for an original game. */
+export interface OriginalExtras {
+    /** Printed disk label: background, band and text colors, and a small logo line. */
+    label?: {
+        background: string;
+        band: string;
+        ink: string;
+        logo?: string;
+    };
+    /** Box art: colors, tagline, back-cover copy, feature bullets and screenshot spots. */
+    box?: {
+        background: string;
+        accent: string;
+        ink: string;
+        tagline: string;
+        back: string;
+        features: string[];
+        /** Map views for screenshots: [map file, x, y] in blocks. */
+        shots?: [string, number, number][];
+        rating?: string;
+    };
+    /** The manual: pages of simple HTML, with <shot map="x.map" x="1" y="2"> screenshots. */
+    manual?: {
+        title: string;
+        pages: {
+            head: string;
+            html: string;
+        }[];
+    };
+    /** The paper extras in the box (games/<id>/printables.json, see src/manual/printables). */
+    printables?: PrintablesFile;
+    /** 'sb' games use the Sound Blaster; 'speaker' ones only the PC speaker. */
+    sound?: 'sb' | 'speaker';
+}
+export interface GmInstallEntry {
+    name: string;
+    size: number;
+    dir: boolean;
+}
+/**
+ * The catalog without what only some pages read (games/catalog.json): a shareware notice,
+ * an original game's manual and printables. Those are in games/details/<id>.json. The play
+ * page needs only this (and, for shareware, its game's details); games/index.json has it all.
+ */
+export declare function slimCatalog(catalog: CdCatalogEntry[]): CdCatalogEntry[];
+/** Every playable game on the CD and in ../games but the secret ones (what games/index.json lists, and every page, sitemap and picture the build makes). */
+export declare function cdCatalog(cdRoot: string): CdCatalogEntry[];
+/** The secret games (games/extra-<gate>.json): listed only once what reveals each is found. */
+export declare function cdSecretCatalog(cdRoot: string): CdCatalogEntry[];
+/** Where each game file the site serves (e.g. games/gameware/nebula/nebula.gam) is on disk. */
+export declare function cdFiles(cdRoot: string): ReadonlyMap<string, string>;
+export declare function cdGames(cdRoot: string): Plugin;

package/dist/types/web/scripts/gameShots.d.ts

@@ -0,0 +1,12 @@
+import { type HeroSpec, type LevelPicture } from '../src/gfx/levelPicture.js';
+/**
+ * A palette PNG of only the colors the picture uses; rows unfiltered (flat pixel art packs best
+ * that way). With `transparent`, that palette index is see-through.
+ */
+export declare function encodeIndexedPng(pic: LevelPicture, transparent?: number): Uint8Array;
+/**
+ * A game's pictures, by site path: each size in BUILT_SHOTS, its title screen (titlePixels),
+ * an original game's box views (builtMapViews of its box's `shots`) and its hero (heroOf);
+ * none when it has no level to show. `disk` maps a game file's name (as listed) to where it is on disk.
+ */
+export declare function gameShots(id: string, gam: string | null, disk: ReadonlyMap<string, string>, boxShots?: [string, number, number][], hero?: HeroSpec): Map<string, Uint8Array>;