@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/types/web/src/project/companion.d.ts

@@ -1,35 +0,0 @@
-import { type GameFiles } from './files.js';
-declare const COMPANION_FORMAT = "gamemaker-companion";
-/** One game file's extras: section name -> whatever its editor keeps there. */
-type FileExtras = Record<string, unknown>;
-export interface Companion {
-    format: typeof COMPANION_FORMAT;
-    version: number;
-    files: Record<string, FileExtras>;
-    /** Anything else a newer version wrote. */
-    [key: string]: unknown;
-}
-export declare function emptyCompanion(): Companion;
-/** A companion from JSON text, bytes or an object; an empty one when it is not one. Unknown keys stay. */
-export declare function parseCompanion(src: unknown): Companion;
-/** Pretty JSON bytes, for the backup zip. */
-export declare function serializeCompanion(c: Companion): Uint8Array;
-/** True when it holds nothing worth keeping. */
-export declare function isEmptyCompanion(c: Companion | undefined): boolean;
-/** One section of a file's extras (e.g. the terrains of forest.bbl), or `fallback`. */
-export declare function getSection<T>(c: Companion, file: string, section: string, fallback: T): T;
-/** Sets (or, with undefined, removes) one section of a file's extras, in place. */
-export declare function setSection(c: Companion, file: string, section: string, value: unknown): void;
-/** A game file was renamed: its extras follow it. */
-export declare function renameInCompanion(c: Companion, from: string, to: string): void;
-/**
- * Takes companion files (.gmx) out of imported files and returns what they held, merged
- * (undefined when there were none). The game's own files are left as they were.
- */
-export declare function takeCompanion(files: GameFiles): Companion | undefined;
-/** The entries of a "Game files (.zip)" backup: every file, plus the companion when it holds anything. */
-export declare function backupEntries(files: GameFiles, gam: string, companion?: Companion): {
-    name: string;
-    data: Uint8Array;
-}[];
-export {};

package/dist/types/web/src/project/diskFacts.d.ts

@@ -1,30 +0,0 @@
-import type { CatalogEntry } from './files.js';
-/** The DOS player, renamed for each game (retro/computer/drives.ts gives it this size too). */
-export declare const PLAYER_EXE_BYTES = 160598;
-/** Bytes the DOS release adds to the game's files: the player .EXE, sound driver, CONFIG.BAT, README. */
-export declare const DOS_EXTRA_BYTES: number;
-type Sized = Pick<CatalogEntry, 'bytes' | 'original' | 'exe'>;
-/** Bytes the game takes on the hard disk once installed (or unzipped). */
-export declare function installedBytes(g: Sized): number;
-/** How many 3½" 1.44 MB disks the game ships on. Every disk count shown anywhere comes from here. */
-export declare function gameDisks(g: Sized): number;
-export declare function disksLine(n: number): string;
-/** A size as a 1995 catalog printed it: "812K" up to a megabyte, then "1.8 MB" (rounded up: it's what you need free). */
-export declare function sizeText(bytes: number, space?: boolean): string;
-export declare function hardDiskLine(g: Sized): string;
-/** "One 3½" 1.44 MB disk · 1.8 MB on hard disk": what a catalog says about a game's size. */
-export declare function storageLine(g: Sized): string;
-export declare const zipName: (g: Pick<CatalogEntry, "exe" | "id">) => string;
-/** The ZIP's size on a BBS: the game's files (their real pack size when the build measured it), the release's extras, FILE_ID.DIZ and the ZIP's own headers. */
-export declare function zipBytes(g: Pick<CatalogEntry, 'bytes' | 'original' | 'exe' | 'files' | 'sizes' | 'packBytes' | 'id'>): number;
-/** Characters a second Zmodem moves: 2400 bps (no compression), 14,400 with V.42bis (ZIPs don't shrink further, but the start and stop bits go). */
-declare const MODEM_CPS: {
-    readonly 2400: 230;
-    readonly 14400: 1650;
-};
-export declare function transferMinutes(bytes: number, bps: keyof typeof MODEM_CPS): number;
-/** "57 min", "2 hr 5 min". */
-export declare function minutesText(min: number): string;
-/** "57 min at 2400 · 8 min at 14.4k" */
-export declare function downloadLine(bytes: number, sep?: string): string;
-export {};

package/dist/types/web/src/project/files.d.ts

@@ -1,124 +0,0 @@
-import { GameFiles } from './gameFiles.js';
-export { GameFiles, cdName, normalize, IGNORED_FILE, type FileStream } from './gameFiles.js';
-import type { OriginalExtras } from '../../scripts/cdGames.js';
-import type { Issue } from './health.js';
-import type { BoxGame } from '../desk/boxes/boxFacts.js';
-export interface CatalogEntry {
-    id: string;
-    title: string;
-    /** gameware: free samples that came with Game-Maker; shareware: play only. */
-    kind: 'gameware' | 'shareware';
-    /** Folder of the game's files, relative to the site root. */
-    path: string;
-    /** Shareware: the author's notice and registration details. */
-    notice?: string;
-    /** Shareware: CRC-32 of the .gam file. */
-    gamCrc?: number;
-    /** Total size of the game's files. */
-    bytes?: number;
-    /** Shareware: its DOS program name, e.g. ORB.EXE (shown, never served). */
-    exe?: string;
-    /** A few lines from the game's story or instructions. */
-    blurb?: string;
-    /** Credits, from the game's own screens or Wikipedia. */
-    author?: string;
-    company?: string;
-    year?: number;
-    /** Registration price as its author stated it ("Freeware" for free games). */
-    price?: string;
-    gam: string | null;
-    files: string[];
-    /** Size of each file in `files`, in bytes (missing from older catalogs). */
-    sizes?: number[];
-    /** Original games made for this project: label, box art, manual, sound card. */
-    original?: OriginalExtras;
-    /** Original games: a series of their own ("bizarre": The Bard of Bizarre's, see bizarre.ts). */
-    series?: string;
-    /** Built sites: every file but the .gif pictures has a gzip copy beside it (<file>.gz, see packedUrl). */
-    gz?: boolean;
-    /** Built sites: all its files in one gzipped file in its folder (project/gamePack.ts, openPack), named with a hash of its content. */
-    pack?: string;
-    /** Built sites: the size of its pack in bytes. */
-    packBytes?: number;
-    /** Built sites: what the quick check (project/health.ts) finds in it, so no file need be fetched to know. */
-    health?: Issue[];
-    /** Built sites, games with a box: its level count and screenshot captions from the .gam (desk/boxes/boxFacts.ts boxGame). */
-    boxGame?: BoxGame;
-    /** From games/catalog.json: its notice, manual and printables are in games/details/<id>.json (withDetails). */
-    details?: boolean; /** Original games: the site path of its walkthrough (src/walkthrough), when it has one. */
-    walkthrough?: string;
-    /** Original games: its DOS player look (games/<id>/player.json, dosPlayer/catalogPatches.ts). */
-    player?: unknown;
-    /** Built sites: its pictures are drawn already (games/shots/, gfx/levelPicture.ts builtShotPath). */
-    shots?: boolean;
-    /** …and its hero (games/shots/<id>-hero.png, gfx/levelPicture.ts builtHeroPath). */
-    heroShot?: boolean;
-}
-/**
- * A Sandbox Software game: one of ours, with its box, disk and manual. Other games built in
- * ../games under another publisher's name (a BBS download such as The Bard of Bizarre's)
- * are listed with the shareware instead.
- */
-export declare function isSandboxGame(g: Pick<CatalogEntry, 'original' | 'company'>): boolean;
-/** Forgets the fetched catalogs, so the next load lists what is current (a secret game revealed). */
-export declare function forgetCatalog(): void;
-/**
- * The games catalog (games/index.json, about 300 kB). Many parts of the page ask for it;
- * it is fetched once and shared. A failed fetch is forgotten so a later call retries.
- */
-export declare function loadCatalog(base?: string): Promise<CatalogEntry[]>;
-/**
- * The games without their shareware notices, manuals and printables (games/catalog.json,
- * an eighth of index.json): for a page that only needs the list, such as the play page.
- * The full catalog when it is loaded already, or there is no short one.
- */
-export declare function loadCatalogList(base?: string): Promise<CatalogEntry[]>;
-/**
- * The list the home page, the shelf and the disk box draw from: games/catalog.json (a quarter
- * of index.json; manuals hold only their title until withDetails). The development server
- * hands out the full catalog instead: it serves catalog.json from whatever scripts/cdGames.ts
- * it was started with, which may be older than this page.
- */
-export declare function loadGameList(base?: string): Promise<CatalogEntry[]>;
-/** An entry with its shareware notice, manual and printables (games/details/<id>.json), for one from loadCatalogList. */
-export declare function withDetails(entry: CatalogEntry, base?: string): Promise<CatalogEntry>;
-/**
- * Bytes of one file at a site-relative URL (e.g. games/gameware/sample/sample.gam), fetched once. Shared: do not modify them.
- * `gz`: the file has a gzip copy beside it (a catalog entry's `gz`).
- */
-export declare function fetchSiteFile(url: string, gz?: boolean): Promise<Uint8Array | undefined>;
-/** A game's pack being read: its files so far, and each one as it comes (see openPack). */
-export interface PackHandle {
-    files: ReadonlyMap<string, Uint8Array>;
-    /** true once every file is in; false when the pack failed (or was stopped): fetch what is missing on its own. */
-    done: Promise<boolean>;
-    /** No longer needed: stops the download when nobody else is reading it. */
-    stop(): void;
-}
-/**
- * Starts reading a hosted game's pack (or joins the reading of it already going on), or
- * undefined when it has none. `onFile` hears of each file in it: those in already at once,
- * then the rest as they arrive, in pack order (play order, streamGame.ts packOrder). Shared:
- * do not modify the files.
- */
-export declare function openPack(entry: Pick<CatalogEntry, 'path' | 'pack'>, base?: string, onFile?: (name: string, bytes: Uint8Array) => void): PackHandle | undefined;
-/**
- * Starts reading a game's whole pack (when it has one), so the many files that are about to
- * be read one by one (a box's paper, a manual's pictures) come in one request instead.
- */
-export declare function warmPack(entry: Pick<CatalogEntry, 'path' | 'pack'>, base?: string): void;
-/**
- * One file of a hosted game, by the name a game uses for it (A-J.BKD finds the CD's
- * a_j.bkd); undefined when the game has no such file or it could not be fetched. From the
- * game's pack when that is here already (played, opened, or kept offline), else on its own.
- */
-export declare function fetchGameFile(entry: Pick<CatalogEntry, 'path' | 'files' | 'gz' | 'pack'>, name: string, base?: string): Promise<Uint8Array | undefined>;
-/**
- * Every file of a hosted game (copies, to change freely): its pack, in one request, when it
- * has one; files the pack did not bring (an older site, a failed download) one by one.
- */
-export declare function loadHostedGame(entry: CatalogEntry, base?: string, onProgress?: (done: number, total: number) => void): Promise<GameFiles>;
-/** Loads files picked with <input type=file multiple> or webkitdirectory, or dropped. */
-export declare function loadFileList(list: Iterable<File>): Promise<GameFiles>;
-/** "Eric-Jon Waugh · A-J Games · 1993" */
-export declare function creditLine(g: Pick<CatalogEntry, 'author' | 'company' | 'year'>): string;

package/dist/types/web/src/project/gameFiles.d.ts

@@ -1,49 +0,0 @@
-/** Files of a game still on their way from the site (project/streamGame.ts). */
-export interface FileStream {
-    /** Resolves once these files are in, or known not to come; undefined when none is still coming. */
-    need(names: string[]): Promise<void> | undefined;
-    /** Fetches these next, without waiting for them. */
-    want(names: string[]): void;
-}
-export declare class GameFiles {
-    private files;
-    /** Notified after any change. */
-    onChange?: (name: string) => void;
-    /** Set while files are still arriving: the game waits for one it needs (engine/machine.ts, need). */
-    stream?: FileStream;
-    /** Asked before set or delete changes a file; throws to refuse (a game opened to look inside, editor/core/readOnly.ts). */
-    guard?: (name: string) => void;
-    constructor(entries?: Iterable<[string, Uint8Array]>);
-    get(name: string | undefined): Uint8Array | undefined;
-    has(name: string | undefined): boolean;
-    /** The stored name a reference opens (see cdName), or undefined when there is none. */
-    resolve(name: string | undefined): string | undefined;
-    set(name: string, bytes: Uint8Array): void;
-    /**
-     * A copy of these files to change freely. While files are still arriving here, the copy
-     * gets them too as it needs them (its own changes stay).
-     */
-    copy(): GameFiles;
-    /** Adds a file that arrived (not one the game wrote): onChange is not told, and a file already here stays. */
-    put(name: string, bytes: Uint8Array): void;
-    delete(name: string): void;
-    names(): string[];
-    entries(): [string, Uint8Array][];
-    byExtension(ext: string): string[];
-    get size(): number;
-    /** The .gam file to play: the one named like the folder, else the first. */
-    mainGame(preferred?: string): string | undefined;
-}
-/**
- * File names as DOS saw them: lower case, without folders, and cut to 8.3. DOS dropped the
- * extra letters silently, so games could name "nejillian.gif" and open NEJILLIA.GIF.
- */
-export declare function normalize(name: string): string;
-/**
- * The name a file got on the Game-Maker CD. Its ISO 9660 copy allowed only A-Z, 0-9 and _,
- * so A-J.BKD, PARSEC-W.GIF and CAN'T.GIF are a_j.bkd, parsec_w.gif and can_t.gif there,
- * while the games still name them the DOS way. A name not found as is is looked up this way.
- */
-export declare function cdName(name: string): string;
-/** Files only meaningful to DOS. */
-export declare const IGNORED_FILE: RegExp;

package/dist/types/web/src/project/gamePack.d.ts

@@ -1,17 +0,0 @@
-/** The container of these files (not compressed). */
-export declare function encodePack(entries: Iterable<[string, Uint8Array]>): Uint8Array;
-/**
- * Reads a pack as its bytes come in: push() each chunk (already unzipped) and get the files
- * it completed. `done` once the end mark is read.
- */
-export declare class PackReader {
-    private chunks;
-    private total;
-    /** Bytes the next step needs (it waits until that many are in, so a big file is joined once). */
-    private want;
-    private started;
-    done: boolean;
-    push(chunk: Uint8Array): [string, Uint8Array][];
-}
-/** Every file of a whole pack (not compressed). */
-export declare function decodePack(bytes: Uint8Array): [string, Uint8Array][];

package/dist/types/web/src/project/health.d.ts

@@ -1,30 +0,0 @@
-type Severity = 'error' | 'warning';
-export interface Issue {
-    severity: Severity;
-    /** What kind of problem, for grouping in the report. */
-    kind: 'missing' | 'link' | 'name' | 'empty' | 'unreadable' | 'game' | 'dos';
-    /** The file the problem is in or about. */
-    file?: string;
-    message: string;
-}
-/** What the check needs to know about a game's files. Contents may be partial (see `get`). */
-export interface FileSource {
-    names(): string[];
-    /** Contents, when known. A quick check only loads the .gam, .lst and .bkd files. */
-    get(name: string): Uint8Array | undefined;
-    /** Size in bytes, when known without loading. */
-    byteSize?(name: string): number | undefined;
-}
-/** The files a game might need to be checked quickly: the .gam and graphic scripts. */
-export declare const QUICK_CHECK_FILE: RegExp;
-/** DOS 8.3 names (the CD's underscore spellings are fine too). */
-export declare function validDosName(name: string): boolean;
-/**
- * Checks a game. `deep` also reads every file with its format's reader (needs all
- * contents in `src`); without it only names, sizes and the .gam/.lst/.bkd files are used.
- */
-export declare function checkGame(src: FileSource, gam: string | undefined, opts?: {
-    deep?: boolean;
-}): Issue[];
-export declare function worstSeverity(issues: Issue[]): Severity | undefined;
-export {};

package/dist/types/web/src/project/secretGames.d.ts

@@ -1,19 +0,0 @@
-/** Which gates are open now (GATE_BIT), 0 when nothing is revealed. */
-export declare function secretsRevealed(): Promise<number>;
-/** FNV-1a of an id: how code that must know a secret game (its box cover) knows it without naming it. */
-export declare function idHash(id: string): number;
-/**
- * Whether a game is one of the secret ones, however a list came to name it (a dev server from
- * before games/extra-<gate>.json lists them in games/index.json): the magazine and the credits never
- * name one, even once it is revealed.
- */
-export declare const isOldSecret: (id: string) => boolean;
-/** Which gates the last list given out showed the secret games of (undefined: none given out yet). */
-export declare const secretsListed: () => number | undefined;
-/**
- * The list as it should show: with the secret games (fetched from `base`extra-<gate>.json) whose
- * gate is open added, and without any that an older dev server listed in it while still hidden.
- */
-export declare function withSecretGames<T extends {
-    id: string;
-}>(list: T[], base?: string): Promise<T[]>;

package/dist/types/web/src/project/storage.d.ts

@@ -1,46 +0,0 @@
-import { GameFiles } from './files.js';
-import type { Companion } from './companion.js';
-export interface ProjectRecord {
-    id: string;
-    name: string;
-    /** File name of the project's main .gam file within `files`. */
-    gam: string;
-    /** Date.now() of the last save; the project list is sorted newest first. */
-    updated: number;
-    /** The whole game directory: file name -> contents. */
-    files: Record<string, Uint8Array>;
-    /** Editor-only extras (companion.ts): never one of the game's files, so no export but the backup carries it. */
-    companion?: Companion;
-}
-/** Project summaries without their files. getAll() still loads the files, then drops them. */
-export declare function listProjects(): Promise<Omit<ProjectRecord, 'files'>[]>;
-export declare function loadProject(id: string): Promise<{
-    record: ProjectRecord;
-    files: GameFiles;
-} | undefined>;
-/**
- * Stores a project. `companion` undefined keeps the one stored already (many callers only
- * know the files), so the record is read and written in one transaction.
- */
-export declare function saveProject(id: string, name: string, gam: string, files: GameFiles, companion?: Companion): Promise<void>;
-/** The record to store: the given companion, else the stored one, else none. */
-export declare function withCompanion(next: ProjectRecord, stored: ProjectRecord | undefined, companion?: Companion): ProjectRecord;
-export declare function deleteProject(id: string): Promise<void>;
-/** Files a game wrote while being played (high scores, saves), keyed by game id. */
-export declare function loadSaveData(gameId: string): Promise<Record<string, Uint8Array>>;
-/** Fired on window after writeSaveFile stores a file (a saved game can hold a felt egg). */
-export declare const SAVES_CHANGED = "gm-saves-changed";
-/**
- * Adds or replaces one save file by rewriting the game's whole save record (read, change,
- * put in separate transactions). Failures are logged, not thrown, so play goes on.
- */
-export declare function writeSaveFile(gameId: string, name: string, bytes: Uint8Array, o?: {
-    quiet?: boolean;
-}): Promise<void>;
-/**
- * Replaces a game's whole save record (restoring a backup, deleting a slot): files left out
- * are gone afterwards. Fires SAVES_CHANGED. Unlike writeSaveFile, failures are thrown.
- */
-export declare function replaceSaveData(gameId: string, files: Record<string, Uint8Array>): Promise<void>;
-/** A random id; falls back to time + random when crypto.randomUUID is missing (insecure contexts). */
-export declare function newId(): string;

package/dist/types/web/src/project/streamGame.d.ts

@@ -1,38 +0,0 @@
-import { GameFiles, type CatalogEntry } from './files.js';
-/**
- * The game's files in the order play first needs them: the .gam, the title and menu, the
- * first level, the rest of the front end, the levels in the order their links reach them,
- * Game Won, and then everything else. Names are the catalog's (`names`), each once.
- */
-export declare function playOrder(gamName: string, gam: Uint8Array | undefined, names: string[]): string[];
-/**
- * The order of a game's files in its pack (project/gamePack.ts): play order, each file
- * followed by the ones it names (a slide list's pictures, a sound set's samples), so a
- * game read from the start of its pack has what it needs as early as it can.
- */
-export declare function packOrder(gamName: string | null, names: string[], get: (name: string) => Uint8Array | undefined): string[];
-/** Files a file names in turn, wanted right after it: a slide list's pictures, a backdrop's GIF, a sound set's samples. */
-export declare function filesNamedBy(name: string, bytes: Uint8Array): string[];
-/** What a demo preview reads before it starts: the title demo, and the first level's character (attract mode). */
-export declare function demoNeeds(gam: Uint8Array | undefined): string[];
-interface StreamedGame {
-    files: GameFiles;
-    /** The .gam is in: the game can be shown (its other files keep coming). */
-    started: Promise<void>;
-    /** Every file is in (or failed). */
-    done: Promise<void>;
-}
-/**
- * Starts fetching a hosted game's files: its pack (project/gamePack.ts), which brings them in
- * play order, or, without one, a few files at a time, most needed first. `files` fills
- * as they arrive; until the last is in, `files.stream` lets the engine wait for one.
- *
- * `aheadBytes` limits what is fetched before it is asked for (a demo on the home page needs a
- * few of a game's files, not its every picture): files the engine asks for (need, want) always
- * come; others, in play order, only until that many bytes have been fetched ahead. Unlimited
- * by default, so a game being played has everything by the time it gets there; `done` then
- * waits for files that may never be asked for. A pack read past that budget, with nothing
- * asked for still on its way, is stopped; what is asked for later comes file by file.
- */
-export declare function streamHostedGame(entry: CatalogEntry, base?: string, concurrency?: number, aheadBytes?: number): StreamedGame;
-export {};

package/dist/types/web/src/project/zip.d.ts

@@ -1,33 +0,0 @@
-export interface ZipEntry {
-    name: string;
-    data: Uint8Array;
-    /** Unix file mode (e.g. 0o100755 for a program); stored so unzipping keeps it executable. */
-    mode?: number;
-    /** Kept uncompressed (stored), as an ePub's first file, `mimetype`, must be. */
-    store?: boolean;
-}
-export declare function crc32(data: Uint8Array): number;
-export declare function createZip(entries: ZipEntry[], date?: Date): Promise<Uint8Array>;
-/** Limits for a zip from somewhere untrusted (linkIn/): more entries or bytes than these throw. */
-interface ZipLimits {
-    maxEntries: number;
-    /** Unpacked bytes in all, as the directory says and as actually inflated. */
-    maxBytes: number;
-}
-/** An entry of a zip's directory, read only when asked (listZip). */
-export interface ZipListing {
-    name: string;
-    /** Unpacked bytes, as the directory says. */
-    size: number;
-    /** Inflates it (stored and deflated entries; others give undefined). */
-    read: () => Promise<Uint8Array | undefined>;
-}
-/**
- * A zip's files from its central directory, without inflating any (a self-extracting .EXE's
- * too, which is never run): an import looks for the
- * .gam files first and reads the rest only for the games picked (project/importScan.ts).
- */
-export declare function listZip(bytes: Uint8Array, limits?: ZipLimits): ZipListing[];
-export declare function readZip(bytes: Uint8Array, limits?: ZipLimits): Promise<ZipEntry[]>;
-export declare function isZip(bytes: Uint8Array): boolean;
-export {};

package/dist/types/web/src/retro/dos/disks.d.ts

@@ -1,33 +0,0 @@
-import { type CatalogEntry, GameFiles } from '../../project/files.js';
-export declare const FLOPPY_BYTES = 1457664;
-/** original: the games made for this project, on professionally printed labels. */
-type DiskKind = 'rsd' | 'gameware' | 'original' | 'project' | 'blank';
-export interface Disk {
-    id: string;
-    kind: DiskKind;
-    title: string;
-    /** Hand-written label text. */
-    label: string;
-    /** Plastic color of the disk: the same for every disk from one author or company. */
-    color: string;
-    /** The label's printed band across the top. */
-    stripe: string;
-    /** Something written on the label later in red marker, if anything. */
-    note?: string;
-    /** HD disks have a second hole, opposite the write-protect tab. */
-    density: 'HD' | 'DD';
-    /** .gam file on the disk (none for blank disks and asset libraries). */
-    gam?: string;
-    /** Bytes used, for the "1 of 2" disk count. */
-    bytes: number;
-    /** The write-protect tab: originals are protected, so editing makes a copy. */
-    writeProtected: boolean;
-    projectId?: string;
-    /** The user's disks: when the game was last saved (Date.now()). */
-    updated?: number;
-    catalog?: CatalogEntry;
-    load: () => Promise<GameFiles>;
-}
-export declare function diskCount(bytes: number): number;
-export declare function loadDisks(): Promise<Disk[]>;
-export {};

package/dist/types/web/src/retro/text/cp437.d.ts

@@ -1,4 +0,0 @@
-/** Converts a string written with Unicode symbols, accents and box characters to CP437 byte codes. */
-export declare function toCp437(s: string): string;
-/** Converts CP437 byte codes to the Unicode characters a PC showed for them. */
-export declare function fromCp437(s: string): string;

package/dist/types/web/src/seededRandom.d.ts

@@ -1,6 +0,0 @@
-/** Mulberry32, the generator games/kit/pixels.ts seeds the simulators with: numbers in [0, 1). */
-export declare function mulberry32(seed: number): () => number;
-/** Xorshift32: numbers in [0, 1); a seed of 0 counts as 1. */
-export declare function xorshift32(seed: number): () => number;
-/** FNV-1a over the string's UTF-16 code units, as an unsigned 32-bit number: a seed from text. */
-export declare function fnv1a(s: string): number;

package/dist/types/web/src/tinHearts/deskHearts.d.ts

@@ -1,33 +0,0 @@
-/** The clock heart's id among the hunt's hearts (no game has this id). */
-export declare const CLOCK_HEART = "desk-clock";
-/** The room's hearts, as the hunt lists them (EGG.EXE's ledger, after the games). */
-export declare const DESK_HEARTS: readonly {
-    id: string;
-    title: string;
-}[];
-/** When the clock heart was taken (an ISO date). */
-export declare const CLOCK_FOUND_KEY = "gm-clock-heart";
-/**
- * The chicken comes out this many times before the heart comes with it: enough that the visitor
- * has met the chicken and knows the clock does something, few enough (every third press, so a
- * dozen presses, over any number of visits) that someone poking at the clock finds it.
- */
-export declare const POPS_BEFORE_HEART = 3;
-/** Fired on window when a heart is found, or EGG.EXE changes one (tinHearts.ts listens). */
-export declare const TIN_HEARTS_CHANGED = "gm-tin-hearts-changed";
-/** How many times the chicken has come out so far. */
-export declare function clockPops(): number;
-/** When the clock heart was taken, if it was. */
-export declare function clockHeartTaken(): string | undefined;
-/**
- * The chicken has popped out once more. `found`: whether the clock heart counts as found now
- * (taken, or added in EGG.EXE). True when the heart comes out with it this time.
- */
-export declare function chickenPopped(found: boolean): boolean;
-/** The visitor took the clock heart: kept once (the first date stays). */
-export declare function takeClockHeart(when?: Date): void;
-/**
- * Whether every game's heart was found before the clock heart joined the hunt. Decided the first
- * time it is asked (`gamesDone`: whether every game's heart counts as found now), then kept.
- */
-export declare function grandfathered(gamesDone: boolean): boolean;

package/dist/types/web/src/tinHearts/manifest.d.ts

@@ -1,30 +0,0 @@
-export interface HeartPlace {
-    /** The map file the heart's block is on (lower case, as on the disk). */
-    map: string;
-    /** Its cell on that map: column, row. */
-    at: [number, number];
-}
-export interface HeartManifest {
-    hearts: Record<string, HeartPlace>;
-    pending: string[];
-}
-/** The about.json fields the manifest is made from. */
-export interface AboutForHearts {
-    company?: string;
-    series?: string;
-    secret?: boolean;
-    tinHeart?: {
-        map?: unknown;
-        at?: unknown;
-    };
-}
-/** Does a game count toward the tin hearts at all (a Sandbox or Bard of Bizarre game, not secret)? */
-export declare const heartsCount: (a: AboutForHearts) => boolean;
-/** The about.json "tinHeart" field checked, or an error saying what is wrong with it. */
-export declare function heartPlace(a: AboutForHearts): HeartPlace | string | undefined;
-/** The manifest for a set of games (id -> about.json), ids in order. Throws on a bad entry. */
-export declare function buildManifest(abouts: Record<string, AboutForHearts>): HeartManifest;
-/** hearts.json as the generator writes it: one game a line. */
-export declare function manifestText(m: HeartManifest): string;
-/** Is a touch at cell (x, y) of map file `map` the heart at `place`? */
-export declare const isHeartAt: (place: HeartPlace, map: string | undefined, x: number, y: number) => boolean;

package/dist/types/web/src/tinHearts/tinHearts.d.ts

@@ -1,84 +0,0 @@
-import { type HeartManifest, type HeartPlace } from './manifest.js';
-import type { Session } from '../engine/scene.js';
-export declare const MANIFEST: HeartManifest;
-export declare const FOUND_FILE = "tinheart.dat";
-export declare const OVERRIDES_KEY = "gm-tin-hearts";
-type HeartOverride = 'added' | 'broken';
-type HeartStatus = 'saved' | 'added' | 'broken' | 'none';
-/** The heart a game hides, if it declares one. */
-export declare const heartOf: (gameId: string) => HeartPlace | undefined;
-/** What FOUND_FILE holds. */
-interface FoundNote {
-    /** When it was found (ISO date). */
-    found: string;
-    scene: number;
-    at: [number, number];
-}
-/** FOUND_FILE read back; undefined when it is missing or not a find. */
-export declare function parseFound(bytes: Uint8Array | undefined): FoundNote | undefined;
-/**
- * What the player passes the engine for a game played under `saveId` ('game:<id>'): it listens
- * for the touch at the heart's place and keeps the find. Undefined for a game with no heart.
- */
-export declare function heartHook(saveId: string | undefined): {
-    onSession: (s: Session) => void;
-    onTouched: NonNullable<Session['onTouched']>;
-} | undefined;
-export declare function readOverrides(): Record<string, HeartOverride>;
-export declare function setOverride(game: string, value: HeartOverride | undefined): void;
-/** EGG.EXE's Set all / Clear all: every listed heart found (or not), whatever the saves say. */
-export declare function setAllOverrides(states: Pick<HeartState, 'id' | 'inSave'>[], found: boolean): void;
-/** EGG.EXE's X Reset all (and R): every heart back to what the saves say. */
-export declare const resetAllOverrides: () => void;
-/** Where a heart stands: found = (in the save OR added by hand) AND not taken away. */
-export declare function statusOf(inSave: boolean, override: HeartOverride | undefined): {
-    status: HeartStatus;
-    found: boolean;
-};
-export interface HeartState {
-    id: string;
-    title: string;
-    inSave: boolean;
-    /** When the save says it was found. */
-    when?: string;
-    status: HeartStatus;
-    found: boolean;
-}
-/** A catalog entry, as much as counting needs. */
-interface CountedGame {
-    id: string;
-    title: string;
-}
-/** The games that count, from a catalog list: Sandbox or Bard of Bizarre, with a heart declared. */
-export declare function countedOf<T extends {
-    id: string;
-    title: string;
-    company?: string;
-    series?: string;
-    original?: unknown;
-}>(catalog: T[]): CountedGame[];
-/** Development only: the catalog's games that count but hide no heart yet. */
-export declare function pendingOf<T extends {
-    id: string;
-    title: string;
-}>(catalog: T[]): CountedGame[];
-/** Where every counted heart stands. */
-export declare function heartStates(games?: CountedGame[]): Promise<HeartState[]>;
-/** Where the room's hearts stand (the clock's): taken in the room, or changed in EGG.EXE. */
-export declare function deskHeartStates(): HeartState[];
-/** Every heart in the hunt: the counted games' (`games`, or the live catalog's), then the room's. */
-export declare function huntStates(games?: CountedGame[]): Promise<HeartState[]>;
-/**
- * Whether the hunt is won, from `states` (huntStates): every heart found, or every game's heart
- * found by someone who had found them all before the room's hearts joined (deskHearts.ts).
- */
-export declare function huntComplete(states: Pick<HeartState, 'id' | 'found'>[]): boolean;
-/** How many of the hunt's hearts are found, and whether it is won (huntComplete). */
-export declare function heartCount(): Promise<{
-    found: number;
-    total: number;
-    complete: boolean;
-}>;
-/** Calls `f` whenever a find may have changed (here, a save written, EGG.EXE in another tab). */
-export declare function watchHearts(f: () => void): () => void;
-export {};