@yam8d/m8-sdk 0.4.0 → 0.5.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yam8d/m8-sdk",
-  "version": "0.4.0",
-  "description": "Client SDK for iframe applications that communicate with yam8d M8 host.",
+  "version": "0.5.1",
+  "description": "Client SDK for apps that read and drive a Dirtywave M8, inside a yam8d External Apps iframe or standalone over Web Serial, WebUSB or Web MIDI.",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",

package/types/client.d.ts

@@ -1,7 +1,12 @@
-import type { M8KeyName, M8Screen, M8SdkConfig, M8State } from './types';
+import type { M8ClientMode, M8DeviceBus, M8DeviceConnectOptions, M8DeviceSupport, M8DeviceTransport, M8KeyName, M8Screen, M8ScreenCells, M8SdkConfig, M8State, M8TransportEvent } from './types';
 import type { M8DescriptionPart, M8SemanticContext } from './viewContext';
-export type { CursorPos, CursorRect, M8KeyName, M8Screen, M8State, RGB, SystemInfos } from './types';
+export type { CursorPos, CursorRect, M8KeyName, M8Screen, M8ScreenCells, M8State, M8TransportEvent, RGB, SystemInfos } from './types';
 export type { M8DescriptionPart, M8SemanticContext } from './viewContext';
+/**
+ * The iframe name yam8d gives its External Apps frames. A client that sees it waits for the
+ * host handshake however long it takes, instead of falling back to standalone mode.
+ */
+export declare const YAM8D_FRAME_NAME = "yam8d-external-app";
 /**
  * Everything the SDK knows about the moment: raw state, semantic context, its
  * human-readable description and the whole screen. Plain JSON, safe to persist.
@@ -18,7 +23,15 @@ export interface M8Snapshot {
 }
 export interface M8Client {
     readonly state: M8State;
+    /**
+     * True when calls reach an M8: in host mode once the yam8d handshake is done, in
+     * standalone mode while a device is connected.
+     */
     readonly isConnected: boolean;
+    /** 'host' inside yam8d, 'standalone' otherwise; null until connect() has decided. */
+    readonly mode: M8ClientMode | null;
+    /** Standalone: the API the device is connected through, null while disconnected (always null in host mode). */
+    readonly deviceTransport: M8DeviceTransport | null;
     navigateToView(viewName: string): Promise<boolean>;
     navigateTo(x: number, y: number): Promise<void>;
     setValueToHex(targetHex: number): Promise<boolean>;
@@ -37,6 +50,11 @@ export interface M8Client {
      * No cursor movement involved, so it is instant and side-effect free.
      */
     getScreen(): Promise<M8Screen>;
+    /**
+     * The screen plus the foreground/background colour of every character cell ('#rrggbb').
+     * Rejects when the host predates this method (yam8d before SDK 0.5).
+     */
+    getScreenCells(): Promise<M8ScreenCells>;
     /** Fresh state + semantic context + description + whole screen in one call. */
     captureSnapshot(): Promise<M8Snapshot>;
     onStateChange(callback: (state: M8State) => void): () => void;
@@ -44,6 +62,37 @@ export interface M8Client {
     onCursorMove(callback: (pos: M8State['cursorPos'], rect: M8State['cursorRect'], selectionMode: boolean) => void): () => void;
     onTextUpdate(callback: (textUnderCursor: string | null, currentLine: string | null) => void): () => void;
     onKeyPress(callback: (keys: number) => void): () => void;
+    /**
+     * Starts forwarding the M8's MIDI clock and transport (needs SYNC OUT set in the M8's
+     * MIDI Settings, and Web MIDI permission in the page that owns the device). Hosts before
+     * SDK 0.5 reject the call.
+     */
+    enableMidiTransport(): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    /** MIDI start / stop / continue, the clock once per sixteenth, and song positions. */
+    onTransport(callback: (event: M8TransportEvent) => void): () => void;
+    /**
+     * Standalone: connects to the M8 from this page. Without a previously granted device the
+     * browser shows its device picker, which only opens from a user gesture (call this from a
+     * click handler). Replaces the current device. In host mode yam8d owns the device: no-op.
+     */
+    connectDevice(options?: M8DeviceConnectOptions): Promise<void>;
+    /** Standalone: releases the device so another page (yam8d, another app) can open it. */
+    disconnectDevice(): Promise<void>;
+    /** Fires when isConnected changes (handshake done, device connected, lost or released). */
+    onConnectionChange(callback: (connected: boolean) => void): () => void;
+    /** Standalone: raw protocol events and device commands; null in host mode or while disconnected. */
+    getDevice(): M8DeviceBus | null;
+    /** Standalone: whether the M8's USB audio is playing through this page. */
+    readonly isAudioConnected: boolean;
+    /**
+     * Standalone: plays the M8's USB audio input through this page (asks for audio permission;
+     * rejects when no input named M8 is found). In host mode yam8d plays it: no-op.
+     */
+    connectAudio(): Promise<void>;
+    disconnectAudio(): Promise<void>;
     disconnect(): void;
     /**
      * Derives semantic context from the current state: view, row, and the typed
@@ -69,6 +118,13 @@ export interface M8Client {
      */
     describeContextParts(): M8DescriptionPart[] | null;
 }
+/** Which device APIs the browser offers for standalone mode. */
+export declare const getDeviceSupport: () => M8DeviceSupport;
+/**
+ * Creates a client and connects it. Inside a yam8d External Apps iframe it talks to yam8d;
+ * anywhere else it runs standalone (see M8SdkConfig.mode) and reopens a device the page was
+ * granted before. A first standalone connection needs connectDevice() from a click.
+ */
 export declare function createM8Client(config?: M8SdkConfig): Promise<M8Client>;
 export declare function createM8ClientSync(config?: M8SdkConfig): {
     client: M8Client;

package/types/engine/astar.d.ts

@@ -0,0 +1,15 @@
+export type Direction = 'up' | 'down' | 'left' | 'right';
+export type Edge = {
+    to: string;
+    dir: Direction;
+    weight?: number;
+};
+export type Graph = Map<string, Edge[]>;
+export type Heuristic = (a: string, b: string) => number;
+export type EdgeCostFn = (from: string, to: string, dir: Direction) => number;
+export interface PathResult {
+    pages: string[];
+    directions: Direction[];
+    cost: number;
+}
+export declare function aStar(graph: Graph, start: string, goal: string, heuristic?: Heuristic, edgeCost?: EdgeCostFn): PathResult | null;

package/types/engine/audio.d.ts

@@ -0,0 +1,29 @@
+export declare const M8_AUDIO_CAPTURE_CONSTRAINTS: {
+    autoGainControl: false;
+    channelCount: {
+        ideal: number;
+    };
+    echoCancellation: false;
+    noiseSuppression: false;
+};
+/** The M8's audio input, or null (device labels are only visible once audio permission was given). */
+export declare const getM8AudioInputDevice: () => Promise<MediaDeviceInfo | null>;
+/**
+ * A stream from the M8's audio input. Without a labelled M8 input yet, it asks for audio
+ * permission first and looks again. Still none: `requireM8` rejects, otherwise the default
+ * input is returned (yam8d's recorder relies on that fallback).
+ */
+export declare const getM8InputStream: ({ requireM8 }?: {
+    requireM8?: boolean;
+}) => Promise<MediaStream>;
+export interface M8Audio {
+    /** Starts playing the M8's audio input through the page's speakers. Idempotent. */
+    connect(options?: {
+        requireM8?: boolean;
+    }): Promise<void>;
+    disconnect(): Promise<void>;
+    readonly connected: boolean;
+    /** A copy of what is being played, for recording; null while not connected. */
+    getOutputCaptureStream(): MediaStream | null;
+}
+export declare const createM8Audio: () => M8Audio;

package/types/engine/bus.d.ts

@@ -0,0 +1,13 @@
+import type { createEventBus } from './eventBus';
+import type { ProtocolEvents } from './protocol';
+export type ProtocolEventBus = ReturnType<typeof createEventBus<ProtocolEvents>>;
+export interface EngineBus {
+    protocol: {
+        eventBus: ProtocolEventBus;
+    };
+    commands: {
+        sendKeys(keys: number): void;
+        /** Asks the M8 to redraw the whole screen. */
+        resetScreen(): void;
+    };
+}

package/types/engine/connectWithRetry.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Runs `connect` until it succeeds. The M8 Headless is slower to enumerate and may not be
+ * immediately ready when the user clicks Connect, so failures are retried after a delay.
+ * Resolves to undefined once all attempts have failed.
+ */
+export declare const connectWithRetry: <T>(connect: () => Promise<T>, { maxAttempts, retryDelayMs }?: {
+    maxAttempts?: number;
+    retryDelayMs?: number;
+}) => Promise<T | undefined>;

package/types/engine/connection.d.ts

@@ -0,0 +1,56 @@
+export type M8DeviceTransport = 'serial' | 'usb' | 'midi';
+export interface M8ConnectOptions {
+    /** Which browser API to use. 'auto' (default) picks Web Serial, then WebUSB, then Web MIDI, by availability. */
+    transport?: M8DeviceTransport | 'auto';
+    /**
+     * false: only reuse a device the page was already granted, never open the browser's device
+     * picker (which needs a user gesture). Rejects when there is none. Default true.
+     */
+    prompt?: boolean;
+}
+export declare function decode7BitPacked(data: Uint8Array): Uint8Array;
+export declare const connection: () => {
+    readonly browserSupport: false;
+    readonly available?: undefined;
+    readonly connect?: undefined;
+} | {
+    readonly browserSupport: true;
+    readonly available: Record<M8DeviceTransport, boolean>;
+    readonly connect: ({ transport, prompt }?: M8ConnectOptions) => Promise<{
+        transport: M8DeviceTransport;
+        commands: {
+            stop: () => void;
+            resetScreen: () => void;
+            sendKeys: (keys: number) => void;
+            sendNoteOn: (note: number, velocity: number) => void;
+            sendNoteOff: () => void;
+            sendProgramChange: (program: number, channel?: number) => void;
+        };
+        reader: () => Promise<{
+            terminated: boolean;
+            data?: undefined;
+        } | {
+            terminated: boolean;
+            data: DataView<ArrayBufferLike> | undefined;
+        }>;
+        protocol: {
+            eventBus: {
+                emit: <K extends keyof import("./protocol").ProtocolEvents>(event: K, ...args: Parameters<import("./protocol").ProtocolEvents[K]>) => void;
+                on: <K extends keyof import("./protocol").ProtocolEvents>(event: K, callback: import("./protocol").ProtocolEvents[K]) => void;
+                off: <K extends keyof import("./protocol").ProtocolEvents>(event: K, callback: import("./protocol").ProtocolEvents[K]) => void;
+            };
+            dispatch: (data: DataView, dataLength: number) => void;
+            getSystemInfo: () => {
+                model: "Headless" | "Beta M8" | "M8 Model:01" | "M8 Model:02";
+                version: string;
+                fontMode: 0 | 1 | 2;
+            } | undefined;
+            getSystemInfos: () => import("./protocol").SystemInfos;
+        };
+        /** Resolves when the device stops sending (unplugged, or close() was called). */
+        closed: Promise<void>;
+        /** Releases the device so another page (or yam8d) can open it. */
+        close: () => Promise<void>;
+    }>;
+};
+export type ConnectedBus = Awaited<ReturnType<Exclude<ReturnType<typeof connection>['connect'], undefined>>>;

package/types/engine/cursorNavigator.d.ts

@@ -0,0 +1,15 @@
+import type { EngineBus } from './bus';
+import type { M8Store } from './store';
+export type Point = {
+    x: number;
+    y: number;
+};
+export interface CursorNavigator {
+    /** Moves the cursor towards `target` (M8 pixel coordinates). Resolves when it stops. */
+    navigateTo(target: Point): Promise<void>;
+    dispose(): void;
+}
+export declare const createCursorNavigator: ({ bus, store }: {
+    bus: EngineBus;
+    store: M8Store;
+}) => CursorNavigator;

package/types/engine/engine.d.ts

@@ -0,0 +1,30 @@
+import type { M8HostEvents, M8HostMethods, M8State } from '../types';
+import type { EngineBus } from './bus';
+import { type Point } from './cursorNavigator';
+import { type MacroRunner } from './macroRunner';
+import { type M8Store } from './store';
+import { type ScreenCellColors } from './viewExtractor';
+export interface M8EngineOptions {
+    debug?: boolean;
+    /** Cancel a running macro (view navigation) on any keydown in this window. Default false. */
+    cancelMacroOnKeydown?: boolean;
+    /** Use this store instead of a new one (for tests, or to keep state across reconnects). */
+    store?: M8Store;
+}
+export interface M8Engine {
+    readonly bus: EngineBus;
+    readonly store: M8Store;
+    /** The SDK methods, as an iframe client or the standalone client calls them. */
+    readonly methods: M8HostMethods;
+    readonly macro: MacroRunner;
+    /** Moves the cursor towards a point in M8 pixel coordinates. */
+    navigateTo(point: Point): Promise<void>;
+    navigateToView(viewName: string): Promise<void>;
+    getState(): M8State;
+    getScreenLines(): string[];
+    getScreenCellColors(): ScreenCellColors;
+    /** Listens to an SDK event. Returns the unsubscribe function. */
+    on<K extends keyof M8HostEvents>(event: K, callback: (payload: M8HostEvents[K]) => void): () => void;
+    dispose(): void;
+}
+export declare const createM8Engine: (bus: EngineBus, options?: M8EngineOptions) => M8Engine;

package/types/engine/eventBus.d.ts

@@ -0,0 +1,5 @@
+export declare const createEventBus: <T extends Record<string, (...args: any[]) => void>>() => {
+    emit: <K extends keyof T>(event: K, ...args: Parameters<T[K]>) => void;
+    on: <K extends keyof T>(event: K, callback: T[K]) => void;
+    off: <K extends keyof T>(event: K, callback: T[K]) => void;
+};

package/types/engine/host/fileBrowserHelpers.d.ts

@@ -0,0 +1,59 @@
+import type { M8State } from '../../types';
+export declare const normalizeForSearch: (text: string | null) => string;
+export declare const FILE_BROWSER_EXTENSION_SUFFIX_REGEX: RegExp;
+export type FileBrowserSnapshot = {
+    viewName: string | null;
+    viewTitle: string | null;
+    cursorPos: M8State['cursorPos'];
+    textUnderCursor: string | null;
+    currentLine: string | null;
+};
+export declare const getFileBrowserSnapshotFingerprint: (snapshot: FileBrowserSnapshot) => string;
+export declare const getSelectedFileBrowserEntry: (snapshot: FileBrowserSnapshot) => string | null;
+export declare const isFileBrowserView: (snapshot: Pick<FileBrowserSnapshot, "viewName" | "viewTitle">) => boolean;
+export declare const isParentDirectoryEntry: (entry: string | null) => boolean;
+export declare const isDirectoryEntry: (entry: string | null) => boolean;
+export declare const isM8FileEntry: (entry: string | null) => boolean;
+export declare const getFileEntrySearchTerms: (entry: string | null) => string[];
+export type FileBrowserEntryKind = 'parent' | 'dir' | 'file' | 'other';
+export type FileBrowserScreenEntry = {
+    /** Screen row, equal to the cursor grid row when the cursor stands on it. */
+    row: number;
+    text: string;
+    /** Normalized text, unique inside a directory. */
+    key: string;
+    kind: FileBrowserEntryKind;
+};
+export type FileBrowserScreen = {
+    entries: FileBrowserScreenEntry[];
+    cursorRow: number | null;
+    cursorKey: string | null;
+    /** The "/.." entry is visible, so the top of the directory is on screen. */
+    hasParent: boolean;
+    /** False when the cursor row disagrees with the cursor atoms: the screen is mid-redraw. */
+    consistent: boolean;
+};
+export declare const PARENT_ENTRY_KEY = "/..";
+export declare const classifyFileBrowserEntry: (text: string) => FileBrowserEntryKind;
+export declare const parseFileBrowserScreen: (lines: string[], snapshot: Pick<FileBrowserSnapshot, "cursorPos" | "viewTitle" | "textUnderCursor">) => FileBrowserScreen;
+/**
+ * Merge the entry keys of one screen into the display order accumulated for a directory.
+ * Screens overlap, so the first known entry anchors the new ones. When the screen
+ * contradicts the accumulated order (listing re-sorted or reloaded) the order restarts from
+ * the screen and `consistent` is false.
+ */
+export declare const mergeFileBrowserOrder: (order: string[], screen: string[]) => {
+    order: string[];
+    consistent: boolean;
+};
+/** Words of the search target (without its extension) and of the view title, to rank directories. */
+export declare const getDirectoryHintTokens: (targetText: string, viewTitle: string | null) => {
+    target: string[];
+    title: string[];
+};
+/**
+ * 2: the folder name shares a word with the target ("/Bass" for "bassline"),
+ * 1: it shares a word with the view title ("/Instruments" in "LOAD INSTRUMENT"), else 0.
+ * Only used to decide which folder to open first, never to skip one.
+ */
+export declare const scoreDirectoryRelevance: (directoryKey: string, hints: ReturnType<typeof getDirectoryHintTokens>) => number;

package/types/engine/host/fileBrowserSearch.d.ts

@@ -0,0 +1,13 @@
+import { type HostIO } from './hostIO';
+/**
+ * Navigate the M8 file browser (load/save views) to a file by name.
+ *
+ * The whole screen is readable, so every move is decided from what is visible:
+ *  - a match anywhere on screen is reached directly;
+ *  - a directory is read page by page (Opt+Up/Down) before any sub-directory is opened,
+ *    and a window that is not full is the whole directory (nothing to page);
+ *  - sub-directories are only opened once the files of the level have been checked, and
+ *    after coming back the cursor already sits on the folder just visited, so the next
+ *    folder is a few rows away instead of a trip to the top of the list.
+ */
+export declare const createFileBrowserSearch: (io: HostIO) => (targetText: string, exact?: boolean) => Promise<boolean>;

package/types/engine/host/floatEditor.d.ts

@@ -0,0 +1,2 @@
+import { type HostIO } from './hostIO';
+export declare const createFloatEditor: (io: HostIO) => (targetFloat: number) => Promise<boolean>;

package/types/engine/host/hostIO.d.ts

@@ -0,0 +1,30 @@
+import type { M8Store } from '../store';
+import { type FileBrowserSnapshot } from './fileBrowserHelpers';
+export declare const wait: (ms: number) => Promise<unknown>;
+/** Where key frames go: a connected bus's commands, or nothing while disconnected. */
+export type KeySink = {
+    sendKeys: (keys: number) => void;
+};
+/**
+ * What the value editors and the file browser search need from the engine: key output
+ * to the M8 and observation of the screen state.
+ */
+export type HostIO = {
+    store: M8Store;
+    debugLog: (...args: unknown[]) => void;
+    hasBus: () => boolean;
+    sendKeys: (keys: number) => void;
+    pressAndRelease: (keys: number, delayMs?: number) => Promise<void>;
+    waitForTextUnderCursorChange: (previousValue: string | null, timeoutMs?: number) => Promise<string | null>;
+    waitForCurrentLineChange: (previousValue: string | null, timeoutMs?: number) => Promise<string | null>;
+    getFileBrowserSnapshot: () => FileBrowserSnapshot;
+    waitForFileBrowserSnapshotChange: (previousSnapshot: FileBrowserSnapshot, timeoutMs?: number) => Promise<FileBrowserSnapshot>;
+    /** Whole M8 screen as text rows (row index === cursor grid row). */
+    getScreenLines: () => string[];
+};
+export declare const createHostIO: ({ getKeySink, store, debugLog, getScreenLines, }: {
+    getKeySink: () => KeySink | undefined;
+    store: M8Store;
+    debugLog: (...args: unknown[]) => void;
+    getScreenLines: () => string[];
+}) => HostIO;

package/types/engine/host/hostMethods.d.ts

@@ -0,0 +1,22 @@
+import type { M8HostMethods } from '../../types';
+import { type ScreenCellColors } from '../viewExtractor';
+import type { HostIO } from './hostIO';
+import type { createValueEditors } from './valueEditors';
+export type HostMethodsDeps = {
+    io: HostIO;
+    editors: ReturnType<typeof createValueEditors>;
+    setValueFloat: (targetFloat: number) => Promise<boolean>;
+    browseFile: (targetText: string, exact: boolean) => Promise<boolean>;
+    navigateToView: (viewName: string) => Promise<void>;
+    navigateTo: (point: {
+        x: number;
+        y: number;
+    }) => Promise<void>;
+    enableMidiTransport: () => Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    getScreenCellColors: () => ScreenCellColors;
+};
+/** The methods an SDK client can call on the engine (transport-agnostic). */
+export declare const createHostMethods: ({ io, editors, setValueFloat, browseFile, navigateToView, navigateTo, enableMidiTransport, getScreenCellColors, }: HostMethodsDeps) => M8HostMethods;

package/types/engine/host/hostState.d.ts

@@ -0,0 +1,7 @@
+import type { M8State } from '../../types';
+import type { M8Store } from '../store';
+export declare const getCurrentState: (store: M8Store) => M8State;
+export declare const textGridToPixel: (store: M8Store, gridX: number, gridY: number) => {
+    x: number;
+    y: number;
+};

package/types/engine/host/keySequences.d.ts

@@ -0,0 +1,2 @@
+export declare const calculateKeySequence: (currentValue: number, targetValue: number) => number[];
+export declare const calculateNoteKeySequence: (currentIndex: number, targetIndex: number) => number[];

package/types/engine/host/midiTransport.d.ts

@@ -0,0 +1,10 @@
+import type { M8TransportEvent } from '../../types';
+export type MidiTransport = {
+    /** Opens the M8 MIDI input (asks for Web MIDI permission the first time). */
+    enable: () => Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    disable: () => void;
+};
+export declare const createMidiTransport: (emit: (event: M8TransportEvent) => void) => MidiTransport;

package/types/engine/host/valueEditors.d.ts

@@ -0,0 +1,7 @@
+import { type HostIO } from './hostIO';
+export declare const createValueEditors: (io: HostIO) => {
+    setValueToHex: (targetHex: number) => Promise<boolean>;
+    setValueToInt: (targetInt: number) => Promise<boolean>;
+    setNote: (targetNoteString: string) => Promise<boolean>;
+    setValueToString: (targetString: string, exact?: boolean, searchInCurrentLine?: boolean) => Promise<boolean>;
+};

package/types/engine/host/valueParsers.d.ts

@@ -0,0 +1,24 @@
+export declare const parseHexValue: (text: string | null) => number | null;
+export declare const parseIntValue: (text: string | null) => number | null;
+export type ParsedFloatToken = {
+    raw: string;
+    negative: boolean;
+    intDigits: string;
+    decDigits: string;
+    decScale: number;
+    tickHundredths: number;
+    ticks: number;
+};
+export declare const parseFloatTokens: (line: string | null) => ParsedFloatToken[];
+export declare const pickFloatTokenIndex: (tokens: ParsedFloatToken[], hintText: string | null) => number;
+export type FloatCursorFocus = 'full' | 'int' | 'dec';
+export declare const detectFloatCursorFocus: (token: ParsedFloatToken | null, hintText: string | null) => FloatCursorFocus | null;
+export declare const isCursorOnForeignFloat: (tokens: ParsedFloatToken[], ownIndex: number, hintText: string | null) => boolean;
+export declare const formatFloatFromTicks: (ticks: number, tickHundredths: number) => string;
+export type ParsedNote = {
+    label: string;
+    noteName: string;
+    octave: number;
+    semitoneIndex: number;
+};
+export declare const parseNoteValue: (text: string | null) => ParsedNote | null;

package/types/engine/index.d.ts

@@ -0,0 +1,14 @@
+export type { EngineBus, ProtocolEventBus } from './bus';
+export { connectWithRetry } from './connectWithRetry';
+export { type ConnectedBus, connection, decode7BitPacked, type M8ConnectOptions, type M8DeviceTransport } from './connection';
+export { type CursorNavigator, createCursorNavigator, type Point } from './cursorNavigator';
+export { createM8Engine, type M8Engine, type M8EngineOptions } from './engine';
+export { createEventBus } from './eventBus';
+export { isDown, isEdit, isLeft, isOpt, isPlay, isRight, isShift, isUp, M8KeyMask, pressKeys } from './keys';
+export { createMacroRunner, type MacroRunner } from './macroRunner';
+export { type CharacterCommand, type KeyCommand, type ProtocolEvents, protocol, type RectCommand, type SystemCommand, type SystemInfos, type WaveCommand, } from './protocol';
+export { createSlipParser, queuedSerialReader, queuedUsbReader } from './queuedReaders';
+export { createM8Store, type M8CellMetrics, type M8MacroStatus, type M8Store, type M8StoreKey, type M8StoreState, type M8SystemInfo, } from './store';
+export { type DrawEventSource, registerViewExtractor, SCREEN_COLUMNS, SCREEN_ROWS, type ScreenCellColors, type ViewExtractor } from './viewExtractor';
+export { getViewGraph, getViewNames, type M8ViewGraph } from './viewGraph';
+export { createViewNavigation, toKeyMasks, type ViewNavigation } from './viewNavigation';

package/types/engine/keys.d.ts

@@ -0,0 +1,28 @@
+export declare const M8KeyMask: {
+    readonly Left: 128;
+    readonly Up: 64;
+    readonly Down: 32;
+    readonly Shift: 16;
+    readonly Play: 8;
+    readonly Right: 4;
+    readonly Opt: 2;
+    readonly Edit: 1;
+};
+export declare const isLeft: (frame: number) => boolean;
+export declare const isUp: (frame: number) => boolean;
+export declare const isDown: (frame: number) => boolean;
+export declare const isShift: (frame: number) => boolean;
+export declare const isPlay: (frame: number) => boolean;
+export declare const isRight: (frame: number) => boolean;
+export declare const isOpt: (frame: number) => boolean;
+export declare const isEdit: (frame: number) => boolean;
+export declare const pressKeys: ({ left, right, up, down, shift, play, opt, edit, }: {
+    left?: boolean;
+    right?: boolean;
+    up?: boolean;
+    down?: boolean;
+    shift?: boolean;
+    play?: boolean;
+    opt?: boolean;
+    edit?: boolean;
+}) => number;

package/types/engine/macroRunner.d.ts

@@ -0,0 +1,15 @@
+import type { EngineBus } from './bus';
+import type { M8Store } from './store';
+export interface MacroRunner {
+    /** Starts a sequence. While one is running, the new frames replace the remaining ones. */
+    start(sequence: number[]): void;
+    cancel(reason?: string): void;
+    readonly running: boolean;
+    dispose(): void;
+}
+export declare const createMacroRunner: ({ bus, store, cancelOnKeydown, }: {
+    bus: EngineBus;
+    store: M8Store;
+    /** Cancel the running macro on any keydown in this window (yam8d does, for its keyboard input). */
+    cancelOnKeydown?: boolean;
+}) => MacroRunner;