picopilot 0.0.0 → 0.1.1

package/dist/engine/pico8/drive.d.ts

@@ -0,0 +1,308 @@
+/**
+ * The `playtest` DRIVE-transform (ADR-0011): the PURE, CI-testable core that
+ * turns an ARBITRARY cart's Lua + a driven-run SPEC into a THROWAWAY driven cart
+ * whose input and frame loop the harness OWNS. This is the load-bearing seam of
+ * `picopilot playtest`, kept pure (cart text + spec in -> cart text + encoded
+ * command blocks out) so its correctness (the `btn`/`btnp` shim, the
+ * `_update`/`_draw` wrap, btnp-edge reconstruction, the opcode/block codec, the
+ * opt-in `srand`) is unit-tested WITHOUT the paid PICO-8 binary. Only the live
+ * drive-and-capture needs a real session (the manual/opt-in tier, ADR-0011).
+ *
+ * The recipe is DECIDED + spike-verified (PICO-8 v0.2.7). This module IMPLEMENTS
+ * it; it is not open design. The three load-bearing verified facts:
+ *  1. Redefine the global `btn`/`btnp` to read a per-frame held-buttons byte
+ *     from `serial(0x804)`, RECONSTRUCTING `btnp` EDGES from the held level (a
+ *     single scripted press = exactly one `btnp` true frame, not held-repeat).
+ *  2. The host<->cart transport is FIXED-SIZE command blocks (small unpadded
+ *     writes to a live `-x` stdin coalesce/drop in the OS pipe buffer), drained
+ *     ONE block per frame gated on the step-budget, with a `printh` ACK per
+ *     completed command (the resumable session waits on the ACK; the one-shot
+ *     ignores it).
+ *  3. The harness OWNS the frame loop: it wraps `_update`/`_update60`/`_draw` so
+ *     a STEP advances exactly N frames and a PAUSE (budget 0) FREEZES the game
+ *     (its callbacks skipped -> all state held, incl. logic in `_draw`).
+ *
+ * The one-shot command sends the whole script up front and exits; the cart-side
+ * machine here is identical to what the resumable session reuses (ADR-0011).
+ */
+/**
+ * A structured reason a drive harness could not be built (a target refusal, not
+ * a crash). Surfaced by the command as incur's `error({code,...})` envelope.
+ */
+export type DriveErrorCode = 
+/** The cart could not be parsed (not a valid .p8). */
+'playtest-cart-parse-error'
+/** The input script named an out-of-range button bit or frame. */
+ | 'playtest-input-invalid';
+/** A structured drive-harness-build failure. */
+export declare class DriveError extends Error {
+    readonly code: DriveErrorCode;
+    constructor(code: DriveErrorCode, message: string);
+}
+/**
+ * The PICO-8 button bit order (the `btn(i)`/`btnp(i)` index), used by the
+ * held-buttons byte the harness pipes over `serial(0x804)`: bit `i` set = button
+ * `i` held this frame. Matches PICO-8's own `btn` indices (verified).
+ */
+export declare const BUTTON_BITS: {
+    readonly left: 0;
+    readonly right: 1;
+    readonly up: 2;
+    readonly down: 3;
+    readonly o: 4;
+    readonly x: 5;
+};
+/** The valid button-bit range [0,5] a held-buttons byte can set. */
+export declare const BUTTON_BIT_MIN = 0;
+export declare const BUTTON_BIT_MAX = 5;
+/** The accepted button NAMES (and their bits) the live `input` verb parses. */
+export declare const BUTTON_NAMES: Readonly<Record<string, number>>;
+/**
+ * Parses a live-session `input` button spec into a single HELD-buttons byte: a
+ * comma/space-separated list of button NAMES (`left right up down o x`, plus the
+ * single-letter aliases `l r u d`), e.g. `"right o"` = hold Right + O this turn.
+ * Case-insensitive; an empty spec is the byte 0 (release all). An unknown name is
+ * a structured {@link DriveError} (`playtest-input-invalid`), never a silent skip.
+ * This is the SESSION-facing input surface (per-turn held level); the one-shot's
+ * {@link parseInputScript} is the frame-scripted surface. Both land on the same
+ * held byte -> {@link btnpEdges} machine.
+ */
+export declare function parseButtons(spec: string): number;
+/**
+ * The FIXED command-block size in bytes (ADR-0011). Load-bearing: small unpadded
+ * writes to a live `pico8 -x` stdin coalesce/drop in the OS pipe buffer, so every
+ * command is sent as a block of exactly this many bytes (opcode + arg + pad). The
+ * cart reads exactly this many bytes per frame and buffers a partial block across
+ * frames. 4 bytes comfortably clears the 1-2 byte coalesce window the spike hit.
+ */
+export declare const BLOCK_SIZE = 4;
+/**
+ * The tagged opcodes carried in a command block's first byte (ADR-0011). One
+ * command per block; the cart drains one block per frame against the step budget.
+ *  - STEP<n>:   advance exactly `n` frames (the arg byte), then pause.
+ *  - INPUT<b>:  set the held-buttons byte to `b` (the arg byte) for the next STEP.
+ *  - SHOT:      screenshot the current (frozen) frame.
+ *  - PAUSE:     set the step budget to 0 (freeze; callbacks skipped).
+ *  - QUIT:      print the done-sentinel so the launcher kills PICO-8.
+ */
+export declare const OPCODE: {
+    readonly step: 1;
+    readonly input: 2;
+    readonly shot: 3;
+    readonly pause: 4;
+    readonly quit: 5;
+};
+export type OpcodeName = keyof typeof OPCODE;
+/**
+ * The cart-side ACK lines the drive shim `printh`s when a command COMPLETES
+ * (ADR-0011: the resumable session WAITS for the ACK before sending the next
+ * command; the one-shot ignores them and waits only for the QUIT sentinel). One
+ * source of truth shared by the Lua shim (which prints them) and the host-side
+ * {@link import('./session.js').DriveSession} (which waits on them), so the
+ * handshake can never drift between the two ends.
+ *
+ * The load-bearing one is {@link ACK.stepDone}: a STEP's ACK fires when the frame
+ * budget REACHES ZERO (the N frames have actually advanced), NOT when the STEP
+ * block is merely read. That is what makes stepping deterministic, the host acts
+ * on a SETTLED, known frame, never mid-step. INPUT/SHOT/PAUSE complete the frame
+ * they are read (instantaneous), so they ACK at read time.
+ */
+export declare const ACK: {
+    /** A STEP's frame budget has fully drained (the N frames advanced). */
+    readonly stepDone: "__PP_ACK_STEP_DONE__";
+    /** The held-buttons byte was set (INPUT). */
+    readonly input: "__PP_ACK_INPUT__";
+    /** A screenshot was queued for the current frame (SHOT). */
+    readonly shot: "__PP_ACK_SHOT__";
+    /** The frame budget was forced to 0 (PAUSE). */
+    readonly pause: "__PP_ACK_PAUSE__";
+};
+/** One command in a driven-run script (the pre-codec, human-facing form). */
+export type DriveCommand = {
+    readonly op: 'step';
+    readonly frames: number;
+} | {
+    readonly op: 'input';
+    readonly held: number;
+} | {
+    readonly op: 'shot';
+} | {
+    readonly op: 'pause';
+} | {
+    readonly op: 'quit';
+};
+/**
+ * A single scripted button press/hold: press button `bit` on every frame in
+ * `[from, to]` inclusive (a single-frame press is `from === to`). The parsed
+ * form of the `--input "frame:bit,..."` spec, before it is expanded into the
+ * per-frame held-buttons bytes and then INPUT/STEP command blocks.
+ */
+export interface ScriptedPress {
+    readonly from: number;
+    readonly to: number;
+    readonly bit: number;
+}
+/**
+ * Encodes one {@link DriveCommand} into a FIXED-SIZE ({@link BLOCK_SIZE}) block:
+ * `[opcode, arg, 0, 0]`. `arg` carries the STEP frame count or the INPUT held
+ * byte; SHOT/PAUSE/QUIT ignore it (0). Fixed size is the point (ADR-0011): the
+ * cart always consumes exactly {@link BLOCK_SIZE} bytes per read.
+ */
+export declare function encodeCommand(cmd: DriveCommand): Uint8Array;
+/** Encodes a whole command script into a single concatenated block stream. */
+export declare function encodeScript(script: readonly DriveCommand[]): Uint8Array;
+/**
+ * A stateful block DECODER mirroring the cart-side shim: feed it raw byte chunks
+ * (a live `-x` stdin delivers arbitrary-sized reads), it buffers partial blocks
+ * across chunks and yields exactly one {@link DriveCommand} per completed
+ * {@link BLOCK_SIZE}-byte block. This is the TS twin of the Lua decoder, so the
+ * codec (including "a block split across two reads still decodes once") is
+ * asserted in CI without the binary.
+ */
+export declare class BlockDecoder {
+    private buffer;
+    /** Feeds a chunk of bytes; returns the commands newly completed by it. */
+    push(chunk: Uint8Array | readonly number[]): DriveCommand[];
+}
+/** Decodes one {@link BLOCK_SIZE}-byte block into a {@link DriveCommand}. */
+export declare function decodeBlock(block: readonly number[]): DriveCommand;
+/**
+ * Reconstructs `btnp` EDGES from a per-frame HELD-buttons sequence (ADR-0011,
+ * the load-bearing verified fact). Given the held byte for each frame, returns
+ * the `btnp` byte for each frame: bit `i` is set only on the frame the button
+ * TRANSITIONS 0 -> 1 (a rising edge), so a single scripted press triggers exactly
+ * one `btnp` (menus/start/single-actions behave), a hold triggers one edge then
+ * stays held (no repeat), and a release+press triggers two edges. This is a pure
+ * mirror of the cart-side shim (`btnp = held & ~prev`), tested independently.
+ */
+export declare function btnpEdges(held: readonly number[]): number[];
+/**
+ * Expands scripted presses into a per-frame HELD-buttons byte array of length
+ * `frames`: frame `f`'s byte has bit `p.bit` set for every press `p` whose
+ * `[from,to]` window covers `f`. This is the level signal the harness pipes; the
+ * cart reconstructs `btnp` edges from it (see {@link btnpEdges}).
+ */
+export declare function pressesToHeld(presses: readonly ScriptedPress[], frames: number): number[];
+/**
+ * Resolves a single BUTTON token to its bit. Accepts a NAME (`left right up down
+ * o x`, plus aliases `l r u d`, case-insensitive) OR a bare bit digit `0..5`, so
+ * BOTH `playtest` input surfaces share one button vocabulary (the `--input`
+ * timeline and the session `input` verb). An unknown token is a structured
+ * {@link DriveError}.
+ */
+export declare function parseButtonToken(token: string): number;
+/**
+ * Parses an `--input` spec into scripted presses. Each comma-separated token is
+ * either a TIMELINE entry `frame:button` / `from-to:button` (a press at that
+ * frame, or a hold across the inclusive window) OR a BARE button (a name/key with
+ * no `frame:`), which is a press at frame 0, so a name-only spec like `"z"` or
+ * `"o right"` (the natural "just press this" form, matching the session `input`
+ * verb) Just Works. `button` is a NAME (`o x left right up down`, aliases
+ * `l r u d`, PICO-8 keys `z`/`x`) or a bit digit `0..5`, so both `playtest` input
+ * surfaces share ONE vocabulary. E.g. `"3:o, 18-22:o, 20:right"` = press O at
+ * frame 3, hold O frames 18..22, press right at frame 20; `"z"` = press O at
+ * frame 0. Whitespace around tokens is ignored (a bare list may be space- or
+ * comma-separated). An unknown button is a structured {@link DriveError}.
+ */
+export declare function parseInputScript(spec: string): ScriptedPress[];
+/**
+ * The GENERIC input default (ADR-0011, US #9): applied when `--input` is omitted.
+ * Tuned to REACH play and stay there briefly for common one-button / runner /
+ * flappy shapes: press O once to START, a few well-spaced single-frame O presses
+ * (clean `btnp` edges) so a one-button game acts without dying instantly, a short
+ * O HOLD for hold-to-thrust games, and a right-nudge for directional runners. It
+ * is a best-effort default, NOT a universal driver; an unusual control scheme
+ * should pass an explicit per-cart `--input` (documented in the command help).
+ */
+export declare const GENERIC_INPUT: readonly ScriptedPress[];
+/**
+ * The default number of frames the generic/one-shot driver advances the cart, and
+ * the shot points within it. Chosen (per the spike) to catch LIVE play soon after
+ * the start press (before any death/retry churn) then a couple more spread out.
+ */
+export declare const DEFAULT_DRIVE_FRAMES = 40;
+export declare const DEFAULT_SHOT_FRAMES: readonly number[];
+/**
+ * The driven-run SPEC the transform expands: either an explicit per-frame press
+ * script (`presses`) or the {@link GENERIC_INPUT} default, plus the frames to
+ * advance, the frames to screenshot at, and the opt-in `srand` seed.
+ */
+export interface DriveSpec {
+    /** The scripted presses; defaults to {@link GENERIC_INPUT} when omitted. */
+    readonly presses?: readonly ScriptedPress[];
+    /** Total frames to advance the driven cart (defaults to {@link DEFAULT_DRIVE_FRAMES}). */
+    readonly frames?: number;
+    /** The frames to screenshot at (defaults to {@link DEFAULT_SHOT_FRAMES}). */
+    readonly shotFrames?: readonly number[];
+    /**
+     * The opt-in determinism seed (US #4, ADR-0011): iff given, the transform
+     * injects `srand(seed)` at cart start so an otherwise-random cart replays
+     * identically. NEVER injected silently (it changes game behaviour).
+     */
+    readonly seed?: number;
+    /** The done-sentinel the cart prints on QUIT (defaults to {@link DONE_SENTINEL}). */
+    readonly sentinel?: string;
+    /** The base filename the SHOT command names each screenshot (defaults to `play`). */
+    readonly shotBasename?: string;
+    /**
+     * Resolver for `#include <file>` directives in the cart's Lua (picopilot's
+     * standard scaffold is `__lua__` = a single `#include main.lua`). The driven
+     * cart runs from a THROWAWAY temp dir where the included files do not exist, so
+     * the transform must INLINE them to be self-contained. Given an include path
+     * (relative to the source cart), return the file's text, or `undefined` if it
+     * cannot be read (the directive is then left verbatim). Injected (not `fs`
+     * imported) so the transform stays pure + unit-testable. Omitted => includes
+     * are left as-is (fine for an already-inlined cart).
+     */
+    readonly readInclude?: (includePath: string) => string | undefined;
+}
+/**
+ * Inlines `#include <file>` directives in a cart's Lua so the driven cart is
+ * self-contained (it runs from a throwaway temp dir where the included files are
+ * absent, and `definedCallbacks` must SEE the real `_update`/`_draw` that live in
+ * the included file). Matches PICO-8's own `#include`: a line whose first
+ * non-space token is `#include`, the rest of the line is the path. Resolves
+ * recursively (an included file may itself `#include`), guarding against cycles.
+ * A path the resolver cannot read is left verbatim (best-effort, like the rest of
+ * the transform). With no resolver, the Lua is returned unchanged.
+ */
+export declare function resolveIncludes(lua: string, readInclude: ((includePath: string) => string | undefined) | undefined, seen?: ReadonlySet<string>): string;
+/** The default base filename SHOT names each screenshot (`play0.png`, ...). */
+export declare const SHOT_BASENAME: "play";
+/**
+ * Builds the ONE-SHOT command SCRIPT from a spec: the full sequence of INPUT /
+ * STEP / SHOT / QUIT blocks that drives the cart frame-by-frame. Each frame is an
+ * INPUT (the held byte for that frame) followed by a single-frame STEP; SHOT
+ * blocks are interleaved at the shot frames; a trailing QUIT ends the run. The
+ * cart drains one block per frame, so the whole script is sent up front and the
+ * cart replays it deterministically (ADR-0011: the one-shot sends everything and
+ * exits; the block+ACK transport lets it queue without loss).
+ */
+export declare function buildDriveScript(spec: DriveSpec): DriveCommand[];
+/** The result of building a drive harness: the throwaway cart + its command blocks. */
+export interface DriveHarness {
+    /** The throwaway `.p8` cart text (the entry's cart is UNTOUCHED). */
+    readonly cartText: string;
+    /** The command script (pre-codec) the harness drives the cart with. */
+    readonly script: readonly DriveCommand[];
+    /** The encoded FIXED-SIZE command blocks to pipe to the cart's stdin. */
+    readonly blocks: Uint8Array;
+    /** The base filename SHOT names each screenshot (for the result envelope). */
+    readonly shotBasename: string;
+    /** The number of SHOT commands in the script (= expected screenshots). */
+    readonly shotCount: number;
+}
+/**
+ * Builds the throwaway DRIVE harness (ADR-0011). Takes the user's cart text + a
+ * {@link DriveSpec} and produces a new cart with the SAME `__gfx__`/`__sfx__`/...
+ * and a `__lua__` that is: the drive shim, then the cart's own Lua (optionally
+ * prefixed with `srand(seed)` iff `--seed` given), then the wrapper tab. The
+ * entry's own cart bytes are NEVER mutated (we transform a parsed COPY).
+ *
+ * Returns the driven cart text plus the encoded command blocks the command pipes
+ * to stdin. Kept pure so every path is unit-tested without the paid binary.
+ *
+ * @throws {DriveError} an unparseable cart.
+ */
+export declare function buildDriveHarness(cartText: string, spec?: DriveSpec): DriveHarness;
+//# sourceMappingURL=drive.d.ts.map

package/dist/engine/pico8/drive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drive.d.ts","sourceRoot":"","sources":["../../../src/engine/pico8/drive.ts"],"names":[],"mappings":"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"}