@unboxy/phaser-sdk 0.2.0 → 0.2.3

package/SDK-GUIDE.md

@@ -0,0 +1,141 @@
+# @unboxy/phaser-sdk — Agent Guide
+
+Reference for AI agents building games on the Unboxy platform. Tracks the **installed SDK version** — always matches the code in `node_modules/@unboxy/phaser-sdk`. Read this before calling any platform API.
+
+## What the SDK provides
+
+- `createUnboxyGame(options)` — Phaser.Game factory with platform defaults (screenshot + recording wired up)
+- `UnboxyScene` — optional base scene with `createButton`, `shakeCamera`, `flashCamera` helpers
+- `Unboxy.init()` — platform services: identity, save data
+- (future: leaderboards, multiplayer lobbies)
+
+## Platform services
+
+Initialize once at module load — resolves the host (home-ui, standalone, etc.) and returns a bound instance. Scenes read from the resulting promise.
+
+```ts
+// src/main.ts
+import { Unboxy } from '@unboxy/phaser-sdk';
+
+export const unboxyReady = Unboxy.init({ standaloneGameId: 'my-game' })
+  .catch(() => null);
+```
+
+`unboxyReady` resolves to an `Unboxy` instance, or `null` if init failed. Scenes should be resilient to `null` — they must still run for anonymous players.
+
+### Identity
+
+```ts
+const unboxy = await unboxyReady;
+if (unboxy) {
+  unboxy.user;            // { id, name, avatar? } | null — null = anonymous
+  unboxy.isAuthenticated; // boolean
+  unboxy.gameId;          // stable platform-issued game id
+  unboxy.host;            // 'unboxy-home-ui' | 'standalone' | 'discord' (future)
+}
+```
+
+### Save data — `unboxy.saves`
+
+Per-user key-value store scoped to `(gameId, userId)`. Backed by the Unboxy backend when authenticated, by localStorage when standalone/anonymous — **the API is identical either way**. Games should never branch on auth state for save logic.
+
+```ts
+// Read — returns null if the key doesn't exist
+const highScore = await unboxy.saves.get<number>('highScore');
+
+// Write — returns the new version number
+await unboxy.saves.set('highScore', 12340);
+
+// Optimistic concurrency — write only if stored version matches
+try {
+  await unboxy.saves.set('progress', { level: 3 }, { ifVersion: 7 });
+} catch (err) {
+  // RpcError with code 'VERSION_MISMATCH' — someone else wrote first
+}
+
+// List keys (no values — cheap)
+const keys = await unboxy.saves.list();
+
+// Delete
+await unboxy.saves.delete('progress');
+```
+
+**Type parameter on `.get<T>()`** is only for TypeScript convenience — the SDK does not validate. Treat returned data as untrusted and defend against missing/malformed values.
+
+### Quotas (enforced at backend)
+
+| Limit | Value |
+|---|---|
+| Per value | 100 KB |
+| Per `(game, user)` total | 1 MB |
+| Max keys per `(game, user)` | 64 |
+| Key format | `^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$` |
+
+Exceeding a quota throws `RpcError` with code `QUOTA_EXCEEDED`. Don't catch silently — surface a clear error.
+
+### When to use saves
+
+**Persist (by convention, no need to ask):**
+- High scores, personal bests
+- Level / stage / chapter progression
+- Unlockables (characters, skins, abilities)
+- In-game currency, inventories
+- Cosmetic selection (chosen character, color)
+- User-configurable settings (volume, difficulty preference, control scheme)
+- Tutorial-seen / onboarding-completed flags
+
+**Do not persist (transient state):**
+- Current-run position, velocity, HP
+- Active enemies, projectiles, particles
+- Scene camera position
+- Animation frames, timers, cooldowns
+- UI focus, current menu
+
+**Rule of thumb:** if the user would be annoyed to lose it on refresh, persist. If they'd be confused to see it come back (e.g. "why is there an enemy here from my last game?"), don't.
+
+### Suggested key names
+
+Use stable, descriptive key names so data carries across SDK versions:
+
+| Concept | Key |
+|---|---|
+| Highest score ever | `highScore` |
+| Current progression | `progress` |
+| Unlocked items | `unlocks` |
+| Player settings | `settings` |
+| Cosmetic selection | `cosmetics` |
+| Onboarding flag | `onboardedAt` |
+
+### Error handling patterns
+
+```ts
+// Graceful degradation — save failures must never block gameplay
+try {
+  await unboxy.saves.set('highScore', score);
+} catch (err) {
+  console.warn('[game] failed to save highScore', err);
+  // continue — game still works, just without persistence this turn
+}
+```
+
+```ts
+// Load at scene start — handle missing, malformed, and failure cases
+const saved = await unboxy.saves.get<number>('highScore').catch(() => null);
+this.highScore = typeof saved === 'number' ? saved : 0;
+```
+
+## Anti-patterns (don't do these)
+
+- Do **not** call `Unboxy.init()` inside a scene. Initialize at module load in `main.ts` and export the promise.
+- Do **not** block scene creation on `unboxyReady`. Games must cold-start immediately; hydrate when the promise resolves.
+- Do **not** save on every frame / every score tick. Debounce or only save on meaningful events (game over, level clear).
+- Do **not** store large binary blobs (images, audio) as save values — use a dedicated blob API when it ships.
+- Do **not** use `localStorage` directly for persistent data when `unboxy.saves` is available — you'll lose cross-device sync when we ship provisional accounts.
+
+## Changelog
+
+- **0.2.3** — anonymous users now use localStorage even inside a host (was throwing UNAUTHENTICATED when calling `saves` in home-ui without login)
+- **0.2.2** — added `SDK-GUIDE.md`
+- **0.2.1** — added `Unboxy.init`, `unboxy.user`, `unboxy.saves`, Transport abstraction (PostMessage + LocalStorage backends)
+- **0.2.0** — added `UnboxyScene`, recording support. Migrated to public npm.
+- **0.1.0** — initial release (CodeArtifact).

package/dist/core/Transport.d.ts

@@ -0,0 +1,22 @@
+import type { UnboxyUser } from '../protocol.js';
+/**
+ * Low-level transport for platform RPC calls. Swapped per host.
+ *
+ * Current implementations:
+ *   - PostMessageTransport: iframe hosted inside unboxy-home-ui
+ *   - LocalStorageTransport: game running standalone (no host, no user)
+ *
+ * Future implementations (not shipped):
+ *   - DiscordTransport: game running as a Discord Activity
+ */
+export interface Transport {
+    readonly kind: TransportKind;
+    readonly user: UnboxyUser | null;
+    readonly gameId: string;
+    call<T = unknown>(method: string, params?: unknown): Promise<T>;
+}
+export type TransportKind = 'unboxy-home-ui' | 'standalone' | 'discord';
+export declare class RpcError extends Error {
+    code: string;
+    constructor(code: string, message: string);
+}

package/dist/core/Transport.js

@@ -0,0 +1,7 @@
+export class RpcError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'RpcError';
+    }
+}

package/dist/core/Unboxy.d.ts

@@ -0,0 +1,41 @@
+import type { TransportKind } from './Transport.js';
+import { SavesModule } from '../saves/SavesModule.js';
+import type { UnboxyUser } from '../protocol.js';
+export interface UnboxyInitOptions {
+    /** Handshake timeout in ms when running inside a host. Default 2000. */
+    handshakeTimeoutMs?: number;
+    /**
+     * Game ID used for the localStorage fallback. Ignored when connected to a
+     * host (the host provides the authoritative gameId). Default 'standalone'.
+     */
+    standaloneGameId?: string;
+}
+/**
+ * Unboxy platform services bound to the current (game, user).
+ *
+ * The public API is host-agnostic. Under the hood, `Unboxy.init()` detects the
+ * host (home-ui iframe, Discord Activity, or standalone) and picks the right
+ * transport. Games should not care which one is active.
+ */
+export declare class Unboxy {
+    private transport;
+    readonly saves: SavesModule;
+    private constructor();
+    /** The current authenticated user, or `null` if anonymous / standalone. */
+    get user(): UnboxyUser | null;
+    get isAuthenticated(): boolean;
+    /** Stable game identifier issued by the host. May be a placeholder when standalone. */
+    get gameId(): string;
+    /** Which transport Unboxy.init() selected. Useful for debugging. */
+    get host(): TransportKind;
+    /**
+     * Initialize the SDK. Detects the host and negotiates identity.
+     *
+     * Resolution order:
+     *   1. If embedded in a window that responds to the Unboxy handshake → PostMessageTransport
+     *   2. Otherwise → LocalStorageTransport (anonymous, local-only saves)
+     *
+     * Discord Activity support is designed for but not shipped in this version.
+     */
+    static init(options?: UnboxyInitOptions): Promise<Unboxy>;
+}

package/dist/core/Unboxy.js

@@ -0,0 +1,49 @@
+import { PostMessageTransport } from './transports/PostMessageTransport.js';
+import { LocalStorageTransport } from './transports/LocalStorageTransport.js';
+import { SavesModule } from '../saves/SavesModule.js';
+// Kept in sync with package.json on each publish.
+const SDK_VERSION = '0.2.3';
+/**
+ * Unboxy platform services bound to the current (game, user).
+ *
+ * The public API is host-agnostic. Under the hood, `Unboxy.init()` detects the
+ * host (home-ui iframe, Discord Activity, or standalone) and picks the right
+ * transport. Games should not care which one is active.
+ */
+export class Unboxy {
+    constructor(transport) {
+        this.transport = transport;
+        // Saves are per-user. When the viewer is anonymous (no logged-in user),
+        // route save calls to localStorage even if a host is attached — the host
+        // backend requires auth, so forwarding would 401. Other module surfaces
+        // (future leaderboards, etc.) can still use the primary transport.
+        const savesTransport = transport.user === null
+            ? new LocalStorageTransport(transport.gameId || 'anonymous')
+            : transport;
+        this.saves = new SavesModule(savesTransport);
+    }
+    /** The current authenticated user, or `null` if anonymous / standalone. */
+    get user() { return this.transport.user; }
+    get isAuthenticated() { return this.transport.user !== null; }
+    /** Stable game identifier issued by the host. May be a placeholder when standalone. */
+    get gameId() { return this.transport.gameId; }
+    /** Which transport Unboxy.init() selected. Useful for debugging. */
+    get host() { return this.transport.kind; }
+    /**
+     * Initialize the SDK. Detects the host and negotiates identity.
+     *
+     * Resolution order:
+     *   1. If embedded in a window that responds to the Unboxy handshake → PostMessageTransport
+     *   2. Otherwise → LocalStorageTransport (anonymous, local-only saves)
+     *
+     * Discord Activity support is designed for but not shipped in this version.
+     */
+    static async init(options = {}) {
+        const handshakeTimeoutMs = options.handshakeTimeoutMs ?? 2000;
+        const standaloneGameId = options.standaloneGameId ?? 'standalone';
+        const pm = await PostMessageTransport.connect(handshakeTimeoutMs, SDK_VERSION);
+        if (pm)
+            return new Unboxy(pm);
+        return new Unboxy(new LocalStorageTransport(standaloneGameId));
+    }
+}

package/dist/core/transports/LocalStorageTransport.d.ts

@@ -0,0 +1,21 @@
+import type { Transport } from '../Transport.js';
+import type { UnboxyUser } from '../../protocol.js';
+/**
+ * Fallback transport when the game runs without a host (e.g., opened directly
+ * outside unboxy-home-ui) or when the viewer is anonymous. Data lives in
+ * localStorage, keyed by gameId. No network calls. Quotas mirror the backend.
+ */
+export declare class LocalStorageTransport implements Transport {
+    readonly gameId: string;
+    readonly kind: "standalone";
+    readonly user: UnboxyUser | null;
+    constructor(gameId: string);
+    call<T = unknown>(method: string, params?: unknown): Promise<T>;
+    private prefix;
+    private read;
+    private write;
+    private savesGet;
+    private savesSet;
+    private savesDelete;
+    private savesList;
+}

package/dist/core/transports/LocalStorageTransport.js

@@ -0,0 +1,74 @@
+import { RpcError } from '../Transport.js';
+/**
+ * Fallback transport when the game runs without a host (e.g., opened directly
+ * outside unboxy-home-ui) or when the viewer is anonymous. Data lives in
+ * localStorage, keyed by gameId. No network calls. Quotas mirror the backend.
+ */
+export class LocalStorageTransport {
+    constructor(gameId) {
+        this.gameId = gameId;
+        this.kind = 'standalone';
+        this.user = null;
+    }
+    async call(method, params) {
+        switch (method) {
+            case 'saves.get': return this.savesGet(params);
+            case 'saves.set': return this.savesSet(params);
+            case 'saves.delete': return this.savesDelete(params);
+            case 'saves.list': return this.savesList();
+            default: throw new RpcError('UNKNOWN_METHOD', `Unknown method: ${method}`);
+        }
+    }
+    prefix() { return `unboxy:saves:${this.gameId}:`; }
+    read(key) {
+        if (typeof localStorage === 'undefined')
+            return null;
+        const raw = localStorage.getItem(this.prefix() + key);
+        if (!raw)
+            return null;
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    write(key, rec) {
+        if (typeof localStorage === 'undefined')
+            throw new RpcError('UNAVAILABLE', 'localStorage unavailable');
+        localStorage.setItem(this.prefix() + key, JSON.stringify(rec));
+    }
+    savesGet({ key }) {
+        const rec = this.read(key);
+        return rec ? { value: rec.value, version: rec.version } : { value: null, version: null };
+    }
+    savesSet({ key, value, ifVersion }) {
+        const existing = this.read(key);
+        if (ifVersion !== undefined && existing && existing.version !== ifVersion) {
+            throw new RpcError('VERSION_MISMATCH', `Expected version ${ifVersion} but stored is ${existing.version}`);
+        }
+        const next = { value, version: (existing?.version ?? 0) + 1 };
+        this.write(key, next);
+        return { version: next.version };
+    }
+    savesDelete({ key }) {
+        if (typeof localStorage === 'undefined')
+            return { deleted: false };
+        const full = this.prefix() + key;
+        const existed = localStorage.getItem(full) !== null;
+        localStorage.removeItem(full);
+        return { deleted: existed };
+    }
+    savesList() {
+        if (typeof localStorage === 'undefined')
+            return { keys: [] };
+        const keys = [];
+        const p = this.prefix();
+        for (let i = 0; i < localStorage.length; i++) {
+            const k = localStorage.key(i);
+            if (k && k.startsWith(p))
+                keys.push(k.slice(p.length));
+        }
+        return { keys };
+    }
+}

package/dist/core/transports/PostMessageTransport.d.ts

@@ -0,0 +1,22 @@
+import type { Transport } from '../Transport.js';
+import { type UnboxyUser } from '../../protocol.js';
+/**
+ * Connects to a parent window that implements the Unboxy RPC host protocol.
+ * Used when the game is loaded inside unboxy-home-ui.
+ */
+export declare class PostMessageTransport implements Transport {
+    private parent;
+    readonly kind: "unboxy-home-ui";
+    user: UnboxyUser | null;
+    gameId: string;
+    private pending;
+    private seq;
+    private constructor();
+    /**
+     * Perform the handshake. Resolves once parent has replied with `unboxy:init`.
+     * Rejects if no response within `timeoutMs`.
+     */
+    static connect(timeoutMs?: number, sdkVersion?: string): Promise<PostMessageTransport | null>;
+    private installResultListener;
+    call<T = unknown>(method: string, params?: unknown): Promise<T>;
+}

package/dist/core/transports/PostMessageTransport.js

@@ -0,0 +1,88 @@
+import { RpcError } from '../Transport.js';
+import { PROTOCOL_VERSION, } from '../../protocol.js';
+/**
+ * Connects to a parent window that implements the Unboxy RPC host protocol.
+ * Used when the game is loaded inside unboxy-home-ui.
+ */
+export class PostMessageTransport {
+    constructor(parent) {
+        this.parent = parent;
+        this.kind = 'unboxy-home-ui';
+        this.user = null;
+        this.gameId = '';
+        this.pending = new Map();
+        this.seq = 0;
+    }
+    /**
+     * Perform the handshake. Resolves once parent has replied with `unboxy:init`.
+     * Rejects if no response within `timeoutMs`.
+     */
+    static async connect(timeoutMs = 2000, sdkVersion = '0.0.0') {
+        if (typeof window === 'undefined' || window.parent === window)
+            return null;
+        const transport = new PostMessageTransport(window.parent);
+        const initPromise = new Promise((resolve) => {
+            const onMessage = (event) => {
+                if (event.source !== window.parent)
+                    return;
+                const data = event.data;
+                if (!data || data.type !== 'unboxy:init')
+                    return;
+                window.removeEventListener('message', onMessage);
+                resolve(data);
+            };
+            window.addEventListener('message', onMessage);
+            setTimeout(() => {
+                window.removeEventListener('message', onMessage);
+                resolve(null);
+            }, timeoutMs);
+        });
+        const hello = {
+            type: 'unboxy:hello',
+            protocolVersion: PROTOCOL_VERSION,
+            sdkVersion,
+        };
+        transport.parent.postMessage(hello, '*');
+        const init = await initPromise;
+        if (!init)
+            return null;
+        if (init.protocolVersion !== PROTOCOL_VERSION) {
+            console.warn('[UnboxySDK] protocol version mismatch', init.protocolVersion, PROTOCOL_VERSION);
+        }
+        transport.user = init.user;
+        transport.gameId = init.gameId;
+        transport.installResultListener();
+        return transport;
+    }
+    installResultListener() {
+        window.addEventListener('message', (event) => {
+            if (event.source !== this.parent)
+                return;
+            const data = event.data;
+            if (!data || data.type !== 'unboxy:rpc.result')
+                return;
+            const pending = this.pending.get(data.id);
+            if (!pending)
+                return;
+            this.pending.delete(data.id);
+            if (data.ok)
+                pending.resolve(data.result);
+            else
+                pending.reject(new RpcError(data.error.code, data.error.message));
+        });
+    }
+    call(method, params) {
+        const id = `${++this.seq}-${Date.now()}`;
+        const message = { type: 'unboxy:rpc', id, method, params };
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve: resolve, reject });
+            this.parent.postMessage(message, '*');
+            setTimeout(() => {
+                if (this.pending.has(id)) {
+                    this.pending.delete(id);
+                    reject(new RpcError('TIMEOUT', `RPC ${method} timed out`));
+                }
+            }, 10000);
+        });
+    }
+}

package/dist/index.d.ts

@@ -3,3 +3,10 @@ export type { UnboxyGameOptions } from './core/UnboxyGame.js';
 export { UnboxyScene } from './core/UnboxyScene.js';
 export { setupScreenshotListener, takeScreenshot } from './screenshot/ScreenshotManager.js';
 export { setupRecordingListener } from './recording/RecordingManager.js';
+export { Unboxy } from './core/Unboxy.js';
+export type { UnboxyInitOptions } from './core/Unboxy.js';
+export { SavesModule } from './saves/SavesModule.js';
+export { RpcError } from './core/Transport.js';
+export type { Transport, TransportKind } from './core/Transport.js';
+export type { UnboxyUser } from './protocol.js';
+export { PROTOCOL_VERSION, type HelloMessage, type InitMessage, type RpcRequestMessage, type RpcResultOk, type RpcResultError, type HostToSdkMessage, type SdkToHostMessage, type RpcErrorPayload, type RpcMethod, type SavesGetParams, type SavesGetResult, type SavesSetParams, type SavesSetResult, type SavesDeleteParams, type SavesDeleteResult, type SavesListResult, } from './protocol.js';

package/dist/index.js

@@ -5,3 +5,8 @@ export { UnboxyScene } from './core/UnboxyScene.js';
 export { setupScreenshotListener, takeScreenshot } from './screenshot/ScreenshotManager.js';
 // Recording
 export { setupRecordingListener } from './recording/RecordingManager.js';
+// Platform services (v0.2.1+)
+export { Unboxy } from './core/Unboxy.js';
+export { SavesModule } from './saves/SavesModule.js';
+export { RpcError } from './core/Transport.js';
+export { PROTOCOL_VERSION, } from './protocol.js';

package/dist/protocol.d.ts

@@ -0,0 +1,67 @@
+export declare const PROTOCOL_VERSION = 1;
+export interface UnboxyUser {
+    id: string;
+    name: string;
+    avatar?: string;
+}
+export interface HelloMessage {
+    type: 'unboxy:hello';
+    protocolVersion: number;
+    sdkVersion: string;
+}
+export interface RpcRequestMessage {
+    type: 'unboxy:rpc';
+    id: string;
+    method: string;
+    params?: unknown;
+}
+export type SdkToHostMessage = HelloMessage | RpcRequestMessage;
+export interface InitMessage {
+    type: 'unboxy:init';
+    protocolVersion: number;
+    gameId: string;
+    user: UnboxyUser | null;
+    capabilities: string[];
+}
+export interface RpcResultOk {
+    type: 'unboxy:rpc.result';
+    id: string;
+    ok: true;
+    result: unknown;
+}
+export interface RpcErrorPayload {
+    code: string;
+    message: string;
+}
+export interface RpcResultError {
+    type: 'unboxy:rpc.result';
+    id: string;
+    ok: false;
+    error: RpcErrorPayload;
+}
+export type HostToSdkMessage = InitMessage | RpcResultOk | RpcResultError;
+export type RpcMethod = 'saves.get' | 'saves.set' | 'saves.delete' | 'saves.list';
+export interface SavesGetParams {
+    key: string;
+}
+export interface SavesGetResult {
+    value: unknown | null;
+    version: number | null;
+}
+export interface SavesSetParams {
+    key: string;
+    value: unknown;
+    ifVersion?: number;
+}
+export interface SavesSetResult {
+    version: number;
+}
+export interface SavesDeleteParams {
+    key: string;
+}
+export type SavesDeleteResult = {
+    deleted: boolean;
+};
+export interface SavesListResult {
+    keys: string[];
+}

package/dist/protocol.js

@@ -0,0 +1,3 @@
+// Shared postMessage protocol between the game SDK (iframe) and its host (unboxy-home-ui).
+// Kept as a single file so host and SDK can be type-checked against the same contract.
+export const PROTOCOL_VERSION = 1;

package/dist/saves/SavesModule.d.ts

@@ -0,0 +1,23 @@
+import type { Transport } from '../core/Transport.js';
+/**
+ * Per-user key-value save data scoped to the current (game, user).
+ *
+ * When the viewer is authenticated, reads/writes go through the host to the
+ * Unboxy backend. When anonymous or standalone, the same API is backed by
+ * localStorage — games do not branch on auth state.
+ *
+ * Size quotas (enforced at the backend):
+ *   - 100 KB per value
+ *   - 1 MB total per (game, user)
+ *   - 64 keys per (game, user)
+ */
+export declare class SavesModule {
+    private transport;
+    constructor(transport: Transport);
+    get<T = unknown>(key: string): Promise<T | null>;
+    set(key: string, value: unknown, options?: {
+        ifVersion?: number;
+    }): Promise<number>;
+    delete(key: string): Promise<boolean>;
+    list(): Promise<string[]>;
+}

package/dist/saves/SavesModule.js

@@ -0,0 +1,37 @@
+/**
+ * Per-user key-value save data scoped to the current (game, user).
+ *
+ * When the viewer is authenticated, reads/writes go through the host to the
+ * Unboxy backend. When anonymous or standalone, the same API is backed by
+ * localStorage — games do not branch on auth state.
+ *
+ * Size quotas (enforced at the backend):
+ *   - 100 KB per value
+ *   - 1 MB total per (game, user)
+ *   - 64 keys per (game, user)
+ */
+export class SavesModule {
+    constructor(transport) {
+        this.transport = transport;
+    }
+    async get(key) {
+        const res = await this.transport.call('saves.get', { key });
+        return (res?.value ?? null);
+    }
+    async set(key, value, options) {
+        const res = await this.transport.call('saves.set', {
+            key,
+            value,
+            ifVersion: options?.ifVersion,
+        });
+        return res.version;
+    }
+    async delete(key) {
+        const res = await this.transport.call('saves.delete', { key });
+        return res.deleted;
+    }
+    async list() {
+        const res = await this.transport.call('saves.list');
+        return res.keys;
+    }
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@unboxy/phaser-sdk",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "Unboxy Phaser 3 SDK — game infrastructure for the Unboxy platform",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["dist"],
+  "files": ["dist", "SDK-GUIDE.md"],
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build"