arm64js 0.4.0

package/dist/loader.js

@@ -0,0 +1,36 @@
+// Which runtime to load, and from where. `sdk-v<X.Y>/` on the CDN holds an
+// exact, never-rewritten runtime.
+//
+// A page runs the runtime this package was released with, its own `X.Y`. A
+// snapshot saved on another engine can bring that engine's runtime in too.
+import { CDN_BASE } from '@arm64js/protocol';
+import { VERSION } from './version.js';
+/** The engine this package runs: its own major.minor. */
+export function packageEngine() {
+    const [major, minor] = VERSION.split('.');
+    return `${major}.${minor}`;
+}
+/** `'0.11'` as `[0, 11]`, or `null` for anything that is not an exact engine tag. */
+export function engineParts(tag) {
+    const m = /^(\d+)\.(\d+)$/.exec(tag);
+    return m ? [Number(m[1]), Number(m[2])] : null;
+}
+/** Whether engine `a` is newer than engine `b`. False unless both are exact tags. */
+export function isNewerEngine(a, b) {
+    const x = engineParts(a);
+    const y = engineParts(b);
+    if (!x || !y) {
+        return false;
+    }
+    return x[0] !== y[0] ? x[0] > y[0] : x[1] > y[1];
+}
+/** The immutable runtime directory for an exact `X.Y`, with its trailing slash. */
+export function runtimeDir(version) {
+    return `${CDN_BASE}/sdk-v${version}/`;
+}
+export function runtimeModuleUrl(version) {
+    return `${runtimeDir(version)}arm64js-sdk-lib.js`;
+}
+export function frameUrl(version) {
+    return `${runtimeDir(version)}frame.html`;
+}

package/dist/mount.d.ts

@@ -0,0 +1,12 @@
+/**
+ * What `mount` takes: a record of file name → Blob, or a list of Files (an
+ * `<input type=file>`'s `files`, a drop's).
+ */
+export type MountSource = Record<string, Blob> | Iterable<File> | ArrayLike<File>;
+/**
+ * `path` with repeated and trailing slashes dropped, so one folder has one key.
+ * The runtime checks the rest.
+ */
+export declare function guestPath(path: string): string;
+/** The record of Blobs the runtime takes. */
+export declare function mountFiles(source: MountSource): Record<string, Blob>;

package/dist/mount.js

@@ -0,0 +1,62 @@
+// Checks and normalizes what a page passes to `vm.mount`, before anything is
+// sent to the runtime.
+import { Arm64JSError } from '@arm64js/protocol';
+/**
+ * `path` with repeated and trailing slashes dropped, so one folder has one key.
+ * The runtime checks the rest.
+ */
+export function guestPath(path) {
+    if (typeof path !== 'string' || !path.startsWith('/')) {
+        throw new Arm64JSError('invalid-input', `the path must be an absolute guest path, not ${JSON.stringify(path)}`);
+    }
+    return `/${path
+        .split('/')
+        .filter((p) => p !== '' && p !== '.')
+        .join('/')}`;
+}
+/** The record of Blobs the runtime takes. */
+export function mountFiles(source) {
+    const files = recordOf(source);
+    if (Object.keys(files).length === 0) {
+        throw new Arm64JSError('invalid-input', 'mount: no files to share');
+    }
+    return files;
+}
+function recordOf(source) {
+    if (!source || typeof source !== 'object') {
+        throw new Arm64JSError('invalid-input', 'mount takes a record of Blobs or a list of Files');
+    }
+    if (source instanceof Blob) {
+        throw new Arm64JSError('invalid-input', 'mount: name the Blob, e.g. { "data.bin": blob }');
+    }
+    const list = source;
+    if (typeof list[Symbol.iterator] === 'function' || typeof list.length === 'number') {
+        return filesRecord(source);
+    }
+    // Checked here: something else (a folder handle) may not even reach the VM's
+    // frame, and then no answer would ever come back.
+    const proto = Object.getPrototypeOf(source);
+    if (proto !== Object.prototype && proto !== null) {
+        throw new Arm64JSError('invalid-input', 'mount takes a record of Blobs or a list of Files');
+    }
+    for (const [name, blob] of Object.entries(source)) {
+        if (!(blob instanceof Blob)) {
+            throw new Arm64JSError('invalid-input', `mount: ${name} is not a Blob`);
+        }
+    }
+    return source;
+}
+/** A list of Files as the record the runtime takes, named by `File.name`. */
+function filesRecord(source) {
+    const record = Object.create(null);
+    for (const file of Array.from(source)) {
+        if (!(file instanceof Blob) || typeof file.name !== 'string') {
+            throw new Arm64JSError('invalid-input', 'mount: every item in a list must be a File');
+        }
+        if (file.name in record) {
+            throw new Arm64JSError('invalid-input', `mount: two files are named ${file.name}`);
+        }
+        record[file.name] = file;
+    }
+    return record;
+}

package/dist/runtime.d.ts

@@ -0,0 +1,33 @@
+import { type BootOptions, type SnapshotInfo, type StorageStatus } from '@arm64js/protocol';
+import { type HostDeps, type HostMode, type LoadedHost } from './hosts.js';
+import { Vm } from './vm.js';
+/** Seams for tests; a page never passes these. */
+export interface Arm64JSDeps extends HostDeps {
+    /** The page's own engine (default: this package's). */
+    engine?: string;
+}
+/**
+ * The runtimes for this page: its own engine, loaded on the first call, and
+ * any other a snapshot needs.
+ */
+export declare class Runtime {
+    private readonly deps;
+    private readonly defaultEngine;
+    private readonly engines;
+    private readonly vms;
+    constructor(deps?: Arm64JSDeps);
+    load(engine?: string): Promise<LoadedHost>;
+    /** Forget a frame that stopped answering, and end the VMs that ran in it. */
+    private lost;
+    boot(id: string, opts?: BootOptions): Promise<Vm>;
+    private bootOn;
+    mode(): Promise<HostMode>;
+    engine(): Promise<string>;
+    listSnapshots(): Promise<SnapshotInfo[]>;
+    getSnapshot(id: string): Promise<SnapshotInfo | null>;
+    removeSnapshot(id: string, opts?: {
+        force?: boolean;
+    }): Promise<void>;
+    storageStatus(): Promise<StorageStatus>;
+    shutdown(): Promise<void>;
+}

package/dist/runtime.js

@@ -0,0 +1,121 @@
+import { Arm64JSError } from '@arm64js/protocol';
+import { withSdkErrors } from './errors.js';
+import { loadHost } from './hosts.js';
+import { engineParts, isNewerEngine, packageEngine } from './loader.js';
+import { Vm } from './vm.js';
+/**
+ * The runtimes for this page: its own engine, loaded on the first call, and
+ * any other a snapshot needs.
+ */
+export class Runtime {
+    deps;
+    defaultEngine;
+    engines = new Map();
+    vms = new Set();
+    constructor(deps = {}) {
+        this.deps = deps;
+        this.defaultEngine = deps.engine ?? packageEngine();
+    }
+    async load(engine = this.defaultEngine) {
+        const loading = this.engines.get(engine);
+        if (loading) {
+            return loading;
+        }
+        const next = loadHost(engine, this.deps, () => this.lost(engine, next)).catch((e) => {
+            if (this.engines.get(engine) === next) {
+                this.engines.delete(engine);
+            }
+            throw e;
+        });
+        this.engines.set(engine, next);
+        return next;
+    }
+    /** Forget a frame that stopped answering, and end the VMs that ran in it. */
+    lost(engine, loading) {
+        if (this.engines.get(engine) !== loading) {
+            return;
+        }
+        this.engines.delete(engine);
+        for (const vm of this.vms) {
+            if (vm.engine === engine) {
+                this.vms.delete(vm);
+                vm.lost();
+            }
+        }
+    }
+    async boot(id, opts) {
+        if (typeof id !== 'string') {
+            throw new Arm64JSError('invalid-input', 'boot takes an image name or a snapshot id');
+        }
+        const defaultHost = await this.load();
+        if (!isSnapshotId(id)) {
+            return this.bootOn(defaultHost, id, opts);
+        }
+        // The engine the snapshot was saved on. An unreadable record is left to the
+        // boot below to report.
+        const saved = (await defaultHost.host.getSnapshot(id).catch(() => null))?.engine;
+        const other = saved && saved !== defaultHost.engine && engineParts(saved) ? saved : null;
+        // Saved on a newer engine: use it. Saved on an older one: try ours first.
+        if (other && isNewerEngine(other, defaultHost.engine)) {
+            return this.bootOn(await this.load(other), id, opts);
+        }
+        try {
+            return await this.bootOn(defaultHost, id, opts);
+        }
+        catch (e) {
+            // A changed snapshot format: only the engine it was saved on can resume it.
+            if (!other || e.code !== 'engine-mismatch') {
+                throw e;
+            }
+            return this.bootOn(await this.load(other), id, opts);
+        }
+    }
+    async bootOn(loaded, id, opts) {
+        const { vmId } = await withSdkErrors(loaded.host.boot(id, opts));
+        const vm = new Vm(vmId, loaded.host, loaded.engine, (v) => this.vms.delete(v));
+        this.vms.add(vm);
+        return vm;
+    }
+    async mode() {
+        return (await this.load()).mode;
+    }
+    async engine() {
+        return (await this.load()).engine;
+    }
+    async listSnapshots() {
+        return withSdkErrors((await this.load()).host.listSnapshots());
+    }
+    async getSnapshot(id) {
+        return withSdkErrors((await this.load()).host.getSnapshot(id));
+    }
+    async removeSnapshot(id, opts) {
+        return withSdkErrors((await this.load()).host.removeSnapshot(id, opts));
+    }
+    async storageStatus() {
+        return withSdkErrors((await this.load()).host.storageStatus());
+    }
+    async shutdown() {
+        const loads = [...this.engines];
+        if (loads.length === 0) {
+            return;
+        }
+        // Wait for loads in flight, so no frame appears after shutdown.
+        const loaded = await Promise.all(loads.map(async ([, p]) => p.catch(() => null)));
+        for (const vm of [...this.vms]) {
+            await vm.dispose().catch(() => { });
+        }
+        this.vms.clear();
+        for (const l of loaded) {
+            l?.dispose();
+        }
+        for (const [engine, p] of loads) {
+            if (this.engines.get(engine) === p) {
+                this.engines.delete(engine);
+            }
+        }
+    }
+}
+/** A local snapshot id, as the runtime spells it. */
+function isSnapshotId(s) {
+    return /^[0-9a-f]{64}$/.test(s);
+}

package/dist/terminal.d.ts

@@ -0,0 +1,19 @@
+import { Terminal, type ITerminalOptions } from '@xterm/xterm';
+import type { Vm } from './vm.js';
+export interface TerminalOptions {
+    /** Size the terminal to its element, now and whenever the element resizes
+     *  (default true). Off, the terminal keeps `xterm.cols`/`xterm.rows`. */
+    fit?: boolean;
+    /** Passed to xterm's `Terminal`. */
+    xterm?: ITerminalOptions;
+}
+export interface AttachedTerminal {
+    /** The xterm instance, for themes, focus and addons. */
+    readonly xterm: Terminal;
+    /** Refit to the element now. */
+    fit(): void;
+    /** Detach from the VM and remove the terminal. The VM keeps running. */
+    dispose(): void;
+}
+/** Show a VM's console in `element` and send what is typed there to the guest. */
+export declare function attachTerminal(vm: Vm, element: HTMLElement, opts?: TerminalOptions): AttachedTerminal;

package/dist/terminal.js

@@ -0,0 +1,88 @@
+// An optional terminal for a VM, on xterm.js:
+//
+//   import { attachTerminal } from 'arm64js/terminal';
+//   import '@xterm/xterm/css/xterm.css';
+//   const term = attachTerminal(vm, document.getElementById('term')!);
+//
+// A separate entry point, so a page that never imports it carries no xterm.
+// `@xterm/xterm` and `@xterm/addon-fit` are optional peer dependencies.
+import { FitAddon } from '@xterm/addon-fit';
+import { Terminal } from '@xterm/xterm';
+/**
+ * How long the element must stay one size before the guest hears it, so a
+ * drag repaints a full-screen program once rather than per frame.
+ */
+const RESIZE_SETTLE_MS = 100;
+/** Show a VM's console in `element` and send what is typed there to the guest. */
+export function attachTerminal(vm, element, opts = {}) {
+    const xterm = new Terminal({ convertEol: true, cursorBlink: true, ...opts.xterm });
+    const fitAddon = new FitAddon();
+    const fitting = opts.fit ?? true;
+    if (fitting) {
+        xterm.loadAddon(fitAddon);
+    }
+    xterm.open(element);
+    const report = (e) => globalThis.console?.warn?.('[arm64js] terminal', e);
+    // What an `exec` prints is its caller's, not the person's at the keyboard.
+    const unsubscribeOutput = vm.onOutput((bytes, info) => {
+        if (!info.exec) {
+            xterm.write(bytes);
+        }
+    });
+    const unsubscribeExit = vm.onExit(({ reason }) => {
+        xterm.options.disableStdin = true;
+        xterm.write(`\r\n[the VM stopped: ${reason}]\r\n`);
+    });
+    const inputSubscription = xterm.onData((data) => void vm.write(data).catch(report));
+    let resizeTimer = null;
+    let lastSentSize = '';
+    const sendSizeToGuest = () => {
+        const size = `${xterm.cols}x${xterm.rows}`;
+        if (size === lastSentSize) {
+            return;
+        }
+        lastSentSize = size;
+        void vm.resize(xterm.cols, xterm.rows).catch(report);
+    };
+    const resizeSubscription = xterm.onResize(() => {
+        if (resizeTimer !== null) {
+            clearTimeout(resizeTimer);
+        }
+        resizeTimer = setTimeout(() => {
+            resizeTimer = null;
+            sendSizeToGuest();
+        }, RESIZE_SETTLE_MS);
+    });
+    const fit = () => {
+        if (fitting) {
+            fitAddon.fit();
+        }
+    };
+    const observer = fitting && typeof ResizeObserver !== 'undefined' ? new ResizeObserver(() => fit()) : null;
+    observer?.observe(element);
+    fit();
+    sendSizeToGuest();
+    // The guest's prompt was printed before this terminal existed; an empty line
+    // brings up a fresh one.
+    void vm.write('\r').catch(report);
+    let disposed = false;
+    return {
+        xterm,
+        fit,
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            if (resizeTimer !== null) {
+                clearTimeout(resizeTimer);
+            }
+            observer?.disconnect();
+            unsubscribeOutput();
+            unsubscribeExit();
+            inputSubscription.dispose();
+            resizeSubscription.dispose();
+            xterm.dispose();
+        },
+    };
+}

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "0.4.0";

package/dist/version.js

@@ -0,0 +1,2 @@
+// Generated by scripts/stamp-version.mjs from package.json. Do not edit.
+export const VERSION = "0.4.0";

package/dist/vm.d.ts

@@ -0,0 +1,56 @@
+import { type ExecOptions, type ExecResult, type OutputInfo, type ReadFileOptions, type SnapshotInfo, type SnapshotOptions, type VmExit, type WriteFileOptions } from '@arm64js/protocol';
+import { type MountSource } from './mount.js';
+/** What `writeFile` takes. */
+export type FileData = Blob | BufferSource | string;
+/** A live `mount`. */
+export interface Mount {
+    /** Where the files are in the guest. */
+    readonly path: string;
+    /** Remove the mount. Idempotent. */
+    unmount(): Promise<void>;
+}
+/** A running VM. */
+export declare class Vm {
+    readonly id: string;
+    private readonly host;
+    /** The engine this VM runs on (`'0.11'`). */
+    readonly engine: string;
+    private readonly onDisposed;
+    private disposed;
+    private frameLost;
+    private readonly exitListeners;
+    /** The latest `mount` at each path, so an old handle cannot undo a newer one. */
+    private readonly mounts;
+    /** Run a shell command (one or more lines) in the guest and get its output and
+     *  exit code. One at a time per VM. */
+    exec(command: string, opts?: ExecOptions): Promise<ExecResult>;
+    /** The raw bytes the guest prints on its console. `info.exec` marks what an
+     *  `exec` printed (its command, output and prompts). Returns the unsubscribe. */
+    onOutput(cb: (bytes: Uint8Array, info: OutputInfo) => void): () => void;
+    /** Type into the guest's console, as a person at a terminal would. Input
+     *  sent while an `exec` or `snapshot` runs is held and delivered after it. */
+    write(data: string): Promise<void>;
+    /** Set the guest's terminal size, so full-screen programs lay out for it. */
+    resize(cols: number, rows: number): Promise<void>;
+    /** The guest's run ending (a halt, a fault). Returns the unsubscribe. */
+    onExit(cb: (exit: VmExit) => void): () => void;
+    /** Show files to the guest, read-only, in the folder `path` (an absolute
+     *  guest path, created if missing). A file is read only as the guest asks, so
+     *  its size does not matter. Mounts are not kept in snapshots: mount again
+     *  after booting one. */
+    mount(source: MountSource, path: string): Promise<Mount>;
+    /** Undo the `mount` at `path`. Idempotent. */
+    unmount(path: string): Promise<void>;
+    /** Copy `data` into the guest as the file `path`, replacing it if it exists and
+     *  creating its folder if missing. The file lives in guest memory: for a large
+     *  one, `mount` it instead. */
+    writeFile(path: string, data: FileData, opts?: WriteFileOptions): Promise<void>;
+    /** Copy the guest's file `path` out, as a `Blob`. The copy is held in page
+     *  memory. */
+    readFile(path: string, opts?: ReadFileOptions): Promise<Blob>;
+    /** Save the VM to this browser's storage. The VM keeps running. */
+    snapshot(opts?: SnapshotOptions): Promise<SnapshotInfo>;
+    /** Stop the VM and free its workers. Idempotent. */
+    dispose(): Promise<void>;
+    private check;
+}

package/dist/vm.js

@@ -0,0 +1,161 @@
+import { Arm64JSError, } from '@arm64js/protocol';
+import { withSdkErrors } from './errors.js';
+import { guestPath, mountFiles } from './mount.js';
+/** The `onExit` a VM gets when its frame stops answering. */
+const LOST_EXIT = { reason: 'lost' };
+/** A running VM. */
+export class Vm {
+    id;
+    host;
+    engine;
+    onDisposed;
+    disposed = false;
+    frameLost = false;
+    exitListeners = new Set();
+    /** The latest `mount` at each path, so an old handle cannot undo a newer one. */
+    mounts = new Map();
+    /** @internal */
+    constructor(id, host, 
+    /** The engine this VM runs on (`'0.11'`). */
+    engine, onDisposed) {
+        this.id = id;
+        this.host = host;
+        this.engine = engine;
+        this.onDisposed = onDisposed;
+    }
+    /** Run a shell command (one or more lines) in the guest and get its output and
+     *  exit code. One at a time per VM. */
+    async exec(command, opts) {
+        this.check();
+        return withSdkErrors(this.host.exec(this.id, command, opts));
+    }
+    /** The raw bytes the guest prints on its console. `info.exec` marks what an
+     *  `exec` printed (its command, output and prompts). Returns the unsubscribe. */
+    onOutput(cb) {
+        this.check();
+        return this.host.onOutput(this.id, cb);
+    }
+    /** Type into the guest's console, as a person at a terminal would. Input
+     *  sent while an `exec` or `snapshot` runs is held and delivered after it. */
+    async write(data) {
+        this.check();
+        return withSdkErrors(this.host.write(this.id, data));
+    }
+    /** Set the guest's terminal size, so full-screen programs lay out for it. */
+    async resize(cols, rows) {
+        this.check();
+        return withSdkErrors(this.host.resize(this.id, cols, rows));
+    }
+    /** The guest's run ending (a halt, a fault). Returns the unsubscribe. */
+    onExit(cb) {
+        this.check();
+        if (this.frameLost) {
+            queueMicrotask(() => cb(LOST_EXIT));
+            return () => { };
+        }
+        const unsubscribe = this.host.onExit(this.id, cb);
+        this.exitListeners.add(cb);
+        return () => {
+            unsubscribe();
+            this.exitListeners.delete(cb);
+        };
+    }
+    /** Show files to the guest, read-only, in the folder `path` (an absolute
+     *  guest path, created if missing). A file is read only as the guest asks, so
+     *  its size does not matter. Mounts are not kept in snapshots: mount again
+     *  after booting one. */
+    async mount(source, path) {
+        this.check();
+        const guestDir = guestPath(path);
+        const files = mountFiles(source);
+        if (this.mounts.has(guestDir)) {
+            throw new Arm64JSError('invalid-input', `mount: ${guestDir} is already mounted, unmount it first`);
+        }
+        // Taken before the call, so a second mount here is refused while this one runs.
+        const token = {};
+        this.mounts.set(guestDir, token);
+        const handle = {
+            path: guestDir,
+            unmount: async () => {
+                if (this.mounts.get(guestDir) === token) {
+                    await this.unmount(guestDir);
+                }
+            },
+        };
+        try {
+            await withSdkErrors(this.host.mount(this.id, files, guestDir));
+        }
+        catch (e) {
+            // An unmount meanwhile may have let a newer mount take the path.
+            if (this.mounts.get(guestDir) === token) {
+                this.mounts.delete(guestDir);
+            }
+            throw e;
+        }
+        return handle;
+    }
+    /** Undo the `mount` at `path`. Idempotent. */
+    async unmount(path) {
+        this.check();
+        const guestDir = guestPath(path);
+        const token = this.mounts.get(guestDir);
+        await withSdkErrors(this.host.unmount(this.id, guestDir));
+        // A mount started meanwhile keeps its token.
+        if (this.mounts.get(guestDir) === token) {
+            this.mounts.delete(guestDir);
+        }
+    }
+    /** Copy `data` into the guest as the file `path`, replacing it if it exists and
+     *  creating its folder if missing. The file lives in guest memory: for a large
+     *  one, `mount` it instead. */
+    async writeFile(path, data, opts) {
+        this.check();
+        let blob;
+        if (data instanceof Blob) {
+            blob = data;
+        }
+        else if (typeof data === 'string' || data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+            blob = new Blob([data]);
+        }
+        else {
+            throw new Arm64JSError('invalid-input', 'writeFile takes a Blob, bytes or a string');
+        }
+        return withSdkErrors(this.host.writeFile(this.id, path, blob, opts));
+    }
+    /** Copy the guest's file `path` out, as a `Blob`. The copy is held in page
+     *  memory. */
+    async readFile(path, opts) {
+        this.check();
+        return withSdkErrors(this.host.readFile(this.id, path, opts));
+    }
+    /** Save the VM to this browser's storage. The VM keeps running. */
+    async snapshot(opts) {
+        this.check();
+        return withSdkErrors(this.host.snapshot(this.id, opts));
+    }
+    /** Stop the VM and free its workers. Idempotent. */
+    async dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        this.onDisposed(this);
+        await withSdkErrors(this.host.dispose(this.id));
+    }
+    /** @internal The frame this VM ran in stopped answering. */
+    lost() {
+        if (this.frameLost) {
+            return;
+        }
+        this.frameLost = true;
+        for (const cb of [...this.exitListeners]) {
+            cb(LOST_EXIT);
+        }
+        this.exitListeners.clear();
+    }
+    check() {
+        if (this.disposed) {
+            throw new Arm64JSError('vm-lost', 'this VM was disposed');
+        }
+    }
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "arm64js",
+  "version": "0.4.0",
+  "description": "Run a Linux VM inside your web page. Boots Alpine from the arm64js CDN, runs commands, keeps snapshots in the browser.",
+  "type": "module",
+  "license": "MIT",
+  "repository": "github:kooler/arm64js-sdk",
+  "homepage": "https://arm64js.com",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./terminal": {
+      "types": "./dist/terminal.d.ts",
+      "default": "./dist/terminal.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "stamp": "node scripts/stamp-version.mjs",
+    "build:protocol": "npm run build -w @arm64js/protocol",
+    "build": "npm run stamp && npm run build:protocol && node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json",
+    "typecheck": "npm run stamp && npm run build:protocol && tsc --noEmit",
+    "test": "npm run stamp && npm run build:protocol && vitest run",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "prepack": "npm run build",
+    "lint": "npm run stamp && npm run build:protocol && eslint .",
+    "prepare": "npm run stamp && npm run build:protocol && husky"
+  },
+  "dependencies": {
+    "@arm64js/protocol": "^1.1.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^26.6.0",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
+    "eslint": "^10.10.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-perfectionist": "^5.11.1",
+    "globals": "^17.12.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.5.1",
+    "prettier": "3.9.6",
+    "typescript": "^5.6.0",
+    "typescript-eslint": "^8.70.0",
+    "vitest": "^2.1.0"
+  },
+  "peerDependencies": {
+    "@xterm/addon-fit": "^0.10.0 || ^0.11.0",
+    "@xterm/xterm": "^5.5.0 || ^6.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@xterm/addon-fit": {
+      "optional": true
+    },
+    "@xterm/xterm": {
+      "optional": true
+    }
+  },
+  "workspaces": [
+    "protocol"
+  ],
+  "lint-staged": {
+    "*.{ts,js,mjs}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "!(*.{ts,js,mjs})": [
+      "prettier --write --ignore-unknown"
+    ]
+  }
+}