@ksp-gonogo/kerbcast 1.4.0

package/dist/testing/index.js

@@ -0,0 +1,606 @@
+import { CameraLifecycle, ErrorSource, Layer, QualityPreset } from "../__generated__/types";
+function buildCamera(init) {
+    return {
+        flightId: init.flightId,
+        lifecycle: init.lifecycle ?? CameraLifecycle.Active,
+        partName: init.partName ?? `part-${init.flightId}`,
+        partTitle: init.partTitle ?? `Part ${init.flightId}`,
+        cameraName: init.cameraName ?? `camera-${init.flightId}`,
+        vesselName: init.vesselName ?? "Test Vessel",
+        layers: init.layers ?? [Layer.Near],
+        operatorLayers: init.operatorLayers ?? [Layer.Near],
+        renderWidth: init.renderWidth ?? 1280,
+        renderHeight: init.renderHeight ?? 720,
+        operatorWidth: init.operatorWidth ?? 1280,
+        operatorHeight: init.operatorHeight ?? 720,
+        supportsZoom: init.supportsZoom ?? true,
+        fov: init.fov ?? 60,
+        fovMin: init.fovMin ?? 10,
+        fovMax: init.fovMax ?? 120,
+        supportsPan: init.supportsPan ?? false,
+        panYaw: init.panYaw ?? 0,
+        panPitch: init.panPitch ?? 0,
+        panYawMin: init.panYawMin ?? -90,
+        panYawMax: init.panYawMax ?? 90,
+        panPitchMin: init.panPitchMin ?? -90,
+        panPitchMax: init.panPitchMax ?? 90,
+        encoderBitrateBps: init.encoderBitrateBps ?? 0,
+        targetBitrateBps: init.targetBitrateBps ?? 0,
+        degradeLevel: init.degradeLevel ?? 0,
+        viewerQuality: init.viewerQuality,
+        qualityLimitedBy: init.qualityLimitedBy,
+    };
+}
+/** Fraction of the operator render size each preset targets (mirrors the
+ *  sidecar's `QualityPreset::scale`). */
+const QUALITY_PRESET_SCALE = {
+    [QualityPreset.Full]: 1.0,
+    [QualityPreset.ThreeQuarter]: 0.75,
+    [QualityPreset.Half]: 0.5,
+    [QualityPreset.Quarter]: 0.25,
+};
+/** Scale + floor-to-even like the plugin's QualityClamp.ScaleDimension. */
+function scaleDim(operatorDim, scale) {
+    const v = Math.trunc(operatorDim * scale) & ~1;
+    return v < 2 ? 2 : v;
+}
+/**
+ * In-process protocol-level fake for the kerbcast sidecar.
+ *
+ * Owns a camera registry and speaks the full kerbcast wire protocol.
+ * Use it in tests to exercise `KerbcastClient` behaviour without a real
+ * sidecar or WebRTC stack.
+ *
+ * ```ts
+ * const sidecar = new MockSidecar();
+ * sidecar.addCamera({ flightId: 42 });
+ *
+ * vi.spyOn(globalThis, "fetch").mockImplementation(() =>
+ *   Promise.resolve(MockSidecar.makeOfferResponse([42]))
+ * );
+ *
+ * const client = new KerbcastClient({ host: "localhost", port: 8088 }, sidecar.createTransport());
+ * await client.connect([42]);
+ * sidecar.open();   // fires hello + camera-snapshot
+ *
+ * expect(client.cameras[0].flightId).toBe(42);
+ * ```
+ */
+export class MockSidecar {
+    constructor() {
+        this._cameras = new Map();
+        this._commands = [];
+        this._throttleMainScreen = false;
+        this._trackIdx = 0;
+        /** Slot mids available for the dynamic-subscription model. Override with
+         *  {@link withSlots} before connecting if a test needs a specific pool. */
+        this._slotMids = ["0", "1", "2", "3"];
+        /** mid -> camera currently bound to that slot. */
+        this._slotBindings = new Map();
+        /**
+         * Per-flight inbound stats to return from the fake getStats. Set via
+         * {@link setInboundStats}. Keyed by flightId.
+         */
+        this._inboundStats = new Map();
+        /**
+         * Tracks delivered by {@link deliverTrack}, keyed by mid/idx string so
+         * getStats can synthesize a trackIdentifier matching what the client saw.
+         */
+        this._deliveredTracks = new Map();
+    }
+    /** Register a camera that will appear in the `camera-snapshot` sent on `open()`. */
+    addCamera(init) {
+        this._cameras.set(init.flightId, buildCamera(init));
+    }
+    /**
+     * Returns a `KerbcastTransport` backed by this mock. Pass it as the
+     * second argument to `KerbcastClient`.
+     */
+    createTransport() {
+        const self = this;
+        return {
+            createPeer() {
+                const channel = {
+                    send(payload) {
+                        const msg = JSON.parse(payload);
+                        self._commands.push(msg);
+                        self._handleClientMessage(msg);
+                    },
+                    onOpen(h) {
+                        self._openHandler = h;
+                    },
+                    onMessage(h) {
+                        self._clientMsgHandler = h;
+                    },
+                    onClose() { },
+                };
+                return {
+                    addRecvOnlyTransceiver() { },
+                    createDataChannel: () => channel,
+                    onTrack(h) {
+                        self._onTrackHandler = h;
+                    },
+                    onStateChange(h) {
+                        self._stateHandler = h;
+                    },
+                    createOffer: async () => "v=0\r\n",
+                    setLocalDescription: async () => { },
+                    setRemoteAnswer: async () => { },
+                    waitForIceComplete: async () => { },
+                    localSdp: () => "v=0\r\n",
+                    close() { },
+                    getStats: async () => self._buildStatsReport(),
+                };
+            },
+        };
+    }
+    /**
+     * Simulate the sidecar completing the WebRTC handshake. Fires the
+     * channel `onOpen` handler (which triggers the client's `hello`), then
+     * responds with `hello` + `camera-snapshot`.
+     */
+    open() {
+        this._openHandler?.();
+        this._sendToClient({ type: "hello", content: { sidecarVersion: "0.0.1-mock", encoderBackend: "mock" } });
+        this._sendToClient({ type: "camera-snapshot", content: { cameras: Array.from(this._cameras.values()) } });
+        this._sendToClient({ type: "settings-state", content: { throttleMainScreen: this._throttleMainScreen } });
+    }
+    /** Drive the underlying peer's connection-state handler. */
+    setConnectionState(state) {
+        this._stateHandler?.(state);
+    }
+    /**
+     * Mark a camera as destroyed and push a `camera-state-changed` message
+     * to the client. The camera stays in the internal registry with
+     * `lifecycle: Destroyed`.
+     */
+    destroyCamera(flightId) {
+        const cam = this._cameras.get(flightId);
+        if (!cam)
+            return;
+        const destroyed = { ...cam, lifecycle: CameraLifecycle.Destroyed };
+        this._cameras.set(flightId, destroyed);
+        this._sendToClient({ type: "camera-state-changed", content: { state: destroyed } });
+    }
+    /**
+     * Apply a partial update to an existing camera and push a
+     * `camera-state-changed` message to the client.
+     */
+    updateCamera(flightId, partial) {
+        const cam = this._cameras.get(flightId);
+        if (!cam)
+            return;
+        const updated = { ...cam, ...partial };
+        this._cameras.set(flightId, updated);
+        this._sendToClient({ type: "camera-state-changed", content: { state: updated } });
+    }
+    /**
+     * Replace the entire camera registry and push a fresh `camera-snapshot` to
+     * the client. Models a vessel change / scene switch where the set of
+     * available cameras changes (cameras appear or disappear) — distinct from
+     * {@link destroyCamera}, which keeps the camera present but `Destroyed`.
+     */
+    setCameras(inits) {
+        this._cameras.clear();
+        for (const init of inits) {
+            this._cameras.set(init.flightId, buildCamera(init));
+        }
+        this._sendToClient({
+            type: "camera-snapshot",
+            content: { cameras: Array.from(this._cameras.values()) },
+        });
+    }
+    /** Send a `ping` from the sidecar; the client should respond with `pong`. */
+    firePing() {
+        this._sendToClient({ type: "ping" });
+    }
+    /** Push an `adaptive-shed` event to the client. */
+    fireAdaptiveShed(payload) {
+        this._sendToClient({ type: "adaptive-shed", content: payload });
+    }
+    /** Push an `error` event to the client (simulates a sidecar error reply). */
+    fireError(payload) {
+        this._sendToClient({ type: "error", content: payload });
+    }
+    /** Current mock-sidecar throttle state (reflects `set-throttle-main-screen` commands). */
+    get throttleMainScreen() {
+        return this._throttleMainScreen;
+    }
+    /** Push a `settings-state` event to the client (simulates a plugin-status-change broadcast). */
+    fireSettingsState(payload) {
+        this._throttleMainScreen = payload.throttleMainScreen;
+        this._sendToClient({ type: "settings-state", content: payload });
+    }
+    /** Configure the slot-pool mids before connecting (dynamic mode). */
+    withSlots(mids) {
+        this._slotMids = [...mids];
+        return this;
+    }
+    /**
+     * Deliver a track onto a slot (by mid), simulating the slot's media
+     * arriving over WebRTC. The client routes it to whichever camera is bound
+     * to that mid. (jsdom can't make real tracks; pass a stub in unit tests or
+     * a `canvas.captureStream()` track in a real-browser harness.)
+     *
+     * The track is remembered so the fake `getStats()` can synthesize a
+     * `trackIdentifier` matching what the client received.
+     */
+    deliverTrack(mid, track) {
+        this._deliveredTracks.set(mid, track);
+        this._onTrackHandler?.(track, this._trackIdx++, mid);
+    }
+    /** The slot mid currently carrying `flightId`, or undefined. */
+    slotMidFor(flightId) {
+        for (const [mid, fid] of this._slotBindings) {
+            if (fid === flightId)
+                return mid;
+        }
+        return undefined;
+    }
+    /** Every `ClientMessage` received from the client, in order. */
+    get commands() {
+        return this._commands;
+    }
+    /**
+     * Find the most recent client command of the given type. Pass `flightId`
+     * to further filter by camera (ignored for message types without a
+     * `content.flightId` field).
+     */
+    lastCommand(type, flightId) {
+        for (let i = this._commands.length - 1; i >= 0; i--) {
+            const cmd = this._commands[i];
+            if (cmd.type !== type)
+                continue;
+            if (flightId !== undefined) {
+                const c = cmd;
+                if (c.content?.flightId !== flightId)
+                    continue;
+            }
+            return cmd;
+        }
+        return undefined;
+    }
+    /**
+     * Build a `Response` that looks like the sidecar's `POST /offer` reply.
+     * Pass to `vi.spyOn(globalThis, "fetch").mockImplementation(...)` so the
+     * client's handshake can complete without a real HTTP server.
+     *
+     * ```ts
+     * vi.spyOn(globalThis, "fetch").mockImplementation(() =>
+     *   Promise.resolve(MockSidecar.makeOfferResponse([42]))
+     * );
+     * ```
+     */
+    static makeOfferResponse(cameras) {
+        return new Response(JSON.stringify({ sdp: "v=0\r\n", cameras }), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    /**
+     * Signaling-seam analogue of {@link makeOfferResponse}: resolve an offer's
+     * answer without HTTP. Pass as the client's `negotiate` config to exercise
+     * the brokered-signaling path a station uses.
+     */
+    negotiate(offer) {
+        return Promise.resolve({ sdp: "v=0\r\n", cameras: offer.cameras });
+    }
+    /**
+     * Configure the inbound video stats the fake `getStats()` will return for
+     * a given camera. Call before `client.inboundVideoStats()` in tests.
+     *
+     * The mock synthesizes a minimal `RTCStatsReport`-shaped object: one entry
+     * per flight that has stats set, with `type: "inbound-rtp"`, `kind: "video"`,
+     * and either a `trackIdentifier` matching the track delivered for that camera
+     * (legacy path) or a `mid` matching the slot binding (dynamic path), plus
+     * the stat fields from `partialStats`.
+     *
+     * ```ts
+     * sidecar.setInboundStats(42, { packetsReceived: 1000, framesDecoded: 300 });
+     * const stats = await client.inboundVideoStats();
+     * expect(stats.get(42)?.packetsReceived).toBe(1000);
+     * ```
+     */
+    setInboundStats(flightId, partialStats) {
+        this._inboundStats.set(flightId, partialStats);
+    }
+    /** Build a minimal RTCStatsReport-compatible object for the current state. */
+    _buildStatsReport() {
+        const entries = [];
+        for (const [flightId, stats] of this._inboundStats) {
+            const id = `inbound-rtp-${flightId}`;
+            // Resolve the identifier: prefer trackIdentifier from the delivered track
+            // (legacy path); fall back to mid from the slot binding (dynamic path).
+            let trackIdentifier;
+            let mid;
+            // Check slot bindings (dynamic mode).
+            for (const [slotMid, fid] of this._slotBindings) {
+                if (fid === flightId) {
+                    mid = slotMid;
+                    const track = this._deliveredTracks.get(slotMid);
+                    if (track?.id)
+                        trackIdentifier = track.id;
+                    break;
+                }
+            }
+            // Legacy mode: look for a delivered track whose mid matches the index
+            // position (mids in legacy mode are the slot index strings "0", "1", ...).
+            if (!trackIdentifier && !mid) {
+                for (const [deliveredMid, track] of this._deliveredTracks) {
+                    if (track.id) {
+                        trackIdentifier = track.id;
+                        mid = deliveredMid;
+                        break;
+                    }
+                }
+            }
+            const entry = {
+                id,
+                type: "inbound-rtp",
+                timestamp: Date.now(),
+                kind: "video",
+                trackIdentifier,
+                mid,
+                packetsReceived: stats.packetsReceived ?? 0,
+                bytesReceived: stats.bytesReceived ?? 0,
+                framesReceived: stats.framesReceived,
+                framesDecoded: stats.framesDecoded,
+                jitter: stats.jitter,
+                framesPerSecond: stats.framesPerSecond,
+            };
+            entries.push([id, entry]);
+        }
+        // Build a Map that satisfies the RTCStatsReport interface (iterable + forEach).
+        const map = new Map(entries);
+        return map;
+    }
+    _sendToClient(msg) {
+        this._clientMsgHandler?.(JSON.stringify(msg));
+    }
+    _handleClientMessage(msg) {
+        switch (msg.type) {
+            case "set-fov": {
+                const cam = this._cameras.get(msg.content.flightId);
+                if (cam)
+                    this._cameras.set(msg.content.flightId, { ...cam, fov: msg.content.fov });
+                break;
+            }
+            case "set-layers": {
+                const cam = this._cameras.get(msg.content.flightId);
+                if (cam) {
+                    this._cameras.set(msg.content.flightId, {
+                        ...cam,
+                        layers: msg.content.layers,
+                        operatorLayers: msg.content.layers,
+                    });
+                }
+                break;
+            }
+            case "set-render-size": {
+                const cam = this._cameras.get(msg.content.flightId);
+                if (cam) {
+                    this._cameras.set(msg.content.flightId, {
+                        ...cam,
+                        renderWidth: msg.content.width,
+                        renderHeight: msg.content.height,
+                        operatorWidth: msg.content.width,
+                        operatorHeight: msg.content.height,
+                    });
+                }
+                break;
+            }
+            case "set-pan": {
+                const cam = this._cameras.get(msg.content.flightId);
+                if (cam) {
+                    this._cameras.set(msg.content.flightId, {
+                        ...cam,
+                        panYaw: msg.content.yaw,
+                        panPitch: msg.content.pitch,
+                    });
+                }
+                break;
+            }
+            case "set-degrade": {
+                const cam = this._cameras.get(msg.content.flightId);
+                if (cam) {
+                    this._cameras.set(msg.content.flightId, { ...cam, degradeLevel: msg.content.level });
+                }
+                break;
+            }
+            case "set-quality": {
+                // Models the request being honored (no adaptive throttle in the
+                // mock): effective dims become the preset's fraction of the
+                // operator ceiling, and the authoritative state is echoed back as
+                // camera-state-changed, the same broadcast the sidecar fans out
+                // to every peer. Use `updateCamera` to simulate the throttled case
+                // (renderWidth below the target + qualityLimitedBy: "throttled").
+                const cam = this._cameras.get(msg.content.flightId);
+                if (!cam) {
+                    this._sendToClient({
+                        type: "error",
+                        content: {
+                            message: `no camera with flight_id=${msg.content.flightId}`,
+                            source: ErrorSource.Sidecar,
+                        },
+                    });
+                    break;
+                }
+                const preset = msg.content.preset ?? undefined;
+                const scale = preset ? QUALITY_PRESET_SCALE[preset] : 1.0;
+                const updated = {
+                    ...cam,
+                    viewerQuality: preset,
+                    qualityLimitedBy: undefined,
+                    renderWidth: scaleDim(cam.operatorWidth, scale),
+                    renderHeight: scaleDim(cam.operatorHeight, scale),
+                };
+                this._cameras.set(msg.content.flightId, updated);
+                this._sendToClient({ type: "camera-state-changed", content: { state: updated } });
+                break;
+            }
+            case "subscribe": {
+                const flightId = msg.content.flightId;
+                const freeMid = this._slotMids.find((m) => !this._slotBindings.has(m));
+                if (freeMid === undefined) {
+                    this._sendToClient({
+                        type: "error",
+                        content: { message: "no free slot", source: ErrorSource.Sidecar },
+                    });
+                }
+                else {
+                    this._slotBindings.set(freeMid, flightId);
+                    this._sendToClient({
+                        type: "slot-map",
+                        content: { mid: freeMid, flightId },
+                    });
+                }
+                break;
+            }
+            case "unsubscribe": {
+                const flightId = msg.content.flightId;
+                let bound;
+                for (const [mid, fid] of this._slotBindings) {
+                    if (fid === flightId) {
+                        bound = mid;
+                        break;
+                    }
+                }
+                if (bound !== undefined) {
+                    this._slotBindings.delete(bound);
+                    this._sendToClient({
+                        type: "slot-map",
+                        content: { mid: bound, flightId: undefined },
+                    });
+                }
+                break;
+            }
+            // Persistent velocities are integrated frame-by-frame by the plugin;
+            // the mock has no frame clock, so it doesn't model their *effect* on
+            // panYaw/fov. They're still recorded in `_commands`, so consumer tests
+            // can assert the command was sent via `lastCommand("set-pan-rate")`.
+            case "set-pan-rate":
+            case "set-zoom-rate":
+            case "hello":
+            case "pong":
+            case "request-keyframe":
+                break;
+            case "set-throttle-main-screen": {
+                /* Flip state and echo SettingsState back, mirroring the sidecar's broadcast. */
+                this._throttleMainScreen = msg.content.enabled;
+                this._sendToClient({
+                    type: "settings-state",
+                    content: { throttleMainScreen: this._throttleMainScreen },
+                });
+                break;
+            }
+            case "disconnect":
+                break;
+        }
+    }
+}
+/**
+ * Install jsdom shims needed by kerbcast component tests.
+ *
+ * jsdom omits several browser APIs that the SDK and React components call at
+ * construction or mount time. Stubbing here keeps individual tests clean.
+ * Each shim is idempotent so setup files can call `installDomStubs()`
+ * unconditionally.
+ *
+ * Stubs installed:
+ *   ResizeObserver   - jsdom does not implement it; CameraFeed uses it to
+ *                      drive auto render-size updates.
+ *   captureStream    - jsdom's HTMLCanvasElement lacks captureStream; the
+ *                      noise pipeline calls it to get its output MediaStream.
+ *                      Returns a stub MediaStream so callers receive a valid
+ *                      object rather than throwing.
+ *   MediaStream      - jsdom's MediaStream constructor is incomplete; tests
+ *                      need to construct instances for track delivery and
+ *                      stream assertions.
+ *   play             - jsdom prints "Not implemented" for HTMLMediaElement.play;
+ *                      the noise pipeline awaits it on the internal video element.
+ *   matchMedia       - jsdom does not implement window.matchMedia; theme
+ *                      detection reads prefers-color-scheme through it.
+ */
+export function installDomStubs() {
+    // ResizeObserver: jsdom omits entirely; CameraFeed's auto-size hook needs it.
+    if (typeof globalThis.ResizeObserver === "undefined") {
+        globalThis.ResizeObserver = class ResizeObserver {
+            observe() { }
+            unobserve() { }
+            disconnect() { }
+        };
+    }
+    // captureStream: jsdom's HTMLCanvasElement does not have it; the noise
+    // pipeline's tryCreateNoisePipeline checks for it and returns null when
+    // absent (safe degrade), but component tests that exercise the stream
+    // path directly need a stub that returns a constructible MediaStream.
+    if (typeof HTMLCanvasElement !== "undefined" &&
+        typeof HTMLCanvasElement.prototype.captureStream !== "function") {
+        HTMLCanvasElement.prototype.captureStream =
+            (_fps) => new StubMediaStream();
+    }
+    // MediaStream: jsdom's implementation is minimal and not always constructible
+    // with tracks. Provide a stub that satisfies the basic interface used by
+    // tests (getTracks, addTrack, id).
+    installStubMediaStream();
+    // play: jsdom's HTMLMediaElement.play is not implemented and prints a warning.
+    // The noise pipeline awaits video.play() on its internal video element.
+    if (typeof HTMLMediaElement !== "undefined") {
+        HTMLMediaElement.prototype.play = () => Promise.resolve();
+    }
+    // matchMedia: jsdom does not implement window.matchMedia; theme detection
+    // queries prefers-color-scheme through it. Stub returns a non-matching
+    // MediaQueryList so tests default to the light theme unless overridden.
+    if (typeof window !== "undefined" && typeof window.matchMedia !== "function") {
+        window.matchMedia = (query) => ({
+            matches: false,
+            media: query,
+            onchange: null,
+            addListener() { },
+            removeListener() { },
+            addEventListener() { },
+            removeEventListener() { },
+            dispatchEvent: () => false,
+        });
+    }
+}
+/** Minimal MediaStream stand-in for jsdom environments. */
+class StubMediaStream {
+    constructor() {
+        this.id = Math.random().toString(36).slice(2);
+        this._tracks = [];
+    }
+    getTracks() {
+        return [...this._tracks];
+    }
+    getVideoTracks() {
+        return this._tracks.filter((t) => t.kind === "video");
+    }
+    getAudioTracks() {
+        return this._tracks.filter((t) => t.kind === "audio");
+    }
+    addTrack(track) {
+        this._tracks.push(track);
+    }
+    removeTrack(track) {
+        const i = this._tracks.indexOf(track);
+        if (i !== -1)
+            this._tracks.splice(i, 1);
+    }
+    clone() {
+        return new StubMediaStream();
+    }
+}
+function installStubMediaStream() {
+    if (typeof globalThis === "undefined")
+        return;
+    // Only replace if the native MediaStream is not constructible (jsdom
+    // registers the class but its constructor requires active getUserMedia
+    // permissions that are never granted in a test environment).
+    try {
+        const ms = new globalThis.MediaStream();
+        if (typeof ms.getTracks === "function")
+            return; // native is adequate
+    }
+    catch {
+        // Fall through to install the stub.
+    }
+    globalThis.MediaStream = StubMediaStream;
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@ksp-gonogo/kerbcast",
+  "version": "1.4.0",
+  "description": "TypeScript client for the kerbcast KSP camera-streaming sidecar. KerbcastClient wraps the WebRTC peer + control channel; wire-format types are typeshare-generated from the sidecar's Rust protocol module.",
+  "license": "CC-BY-NC-SA-4.0",
+  "author": "Jon Pepler",
+  "homepage": "https://github.com/ksp-gonogo/kerbcast#readme",
+  "bugs": {
+    "url": "https://github.com/ksp-gonogo/kerbcast/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ksp-gonogo/kerbcast.git",
+    "directory": "client-sdk/typescript"
+  },
+  "keywords": [
+    "kerbcast",
+    "ksp",
+    "kerbal-space-program",
+    "webrtc",
+    "h264",
+    "protocol",
+    "typeshare"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "default": "./dist/testing/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "src/",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "jsdom": "^29.0.2",
+    "typescript": "^5.4.0",
+    "vitest": "^4.1.4"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "regen": "typeshare ../../sidecar/src --lang=typescript --output-file=src/__generated__/types.ts"
+  }
+}