@memizy/host-sdk 0.0.0-stage → 1.0.0-rc.5

package/dist/src/relay/host.d.ts

@@ -0,0 +1,94 @@
+import { CreateRoomResponse, RelayErrorCode, RelayPlayer } from '@memizy/protocol';
+import { LocalSession, PluginEndpoint } from '../session';
+import { RelayStatus } from './socket';
+import { RemoteLobbyState } from './messages';
+export type RelayHostEvent = {
+    type: 'status';
+    status: RelayStatus;
+} | {
+    type: 'players';
+    players: RelayPlayer[];
+} | {
+    type: 'error';
+    code: RelayErrorCode;
+    message: string;
+} | {
+    type: 'closed';
+    reason: string;
+};
+export interface RelayHostOptions {
+    /** Server base URL, e.g. `https://mp.memizy.com`. */
+    serverUrl: string;
+    fetch?: typeof fetch;
+    WebSocket?: typeof WebSocket;
+    /** How long a player device may take to load the game (default 20 s). */
+    mountTimeoutMs?: number;
+    /** Timeout of one call to a remote plugin (default 15 s). */
+    callTimeoutMs?: number;
+}
+export declare class RelayHost {
+    readonly pin: string;
+    readonly hostToken: string;
+    players: RelayPlayer[];
+    /** The lobby/game state shown by the player apps. */
+    state: RemoteLobbyState;
+    private readonly options;
+    private readonly socket;
+    private readonly listeners;
+    private readonly channels;
+    private bundleVersion;
+    private genCounter;
+    private callCounter;
+    private session;
+    private hosting;
+    private readonly hostingWaiters;
+    private stopSession;
+    private constructor();
+    /** Creates a new room on the server. */
+    static create(options: RelayHostOptions): Promise<RelayHost>;
+    /** Re-attaches to an existing room (e.g. after a page reload). */
+    static resume(options: RelayHostOptions, room: CreateRoomResponse): RelayHost;
+    /** Resolves once the server confirmed the room and sent the current players. */
+    whenHosting(): Promise<void>;
+    get status(): RelayStatus;
+    on(listener: (event: RelayHostEvent) => void): () => void;
+    private emit;
+    /** Uploads the plugin and the set prepared for it (`LocalSession.prepared.set`). */
+    uploadBundle(pluginHtml: string, set: unknown): Promise<number>;
+    /** Allows or stops new players joining. */
+    setOpen(open: boolean): void;
+    kick(playerId: string): void;
+    /** Closes the room for everyone. */
+    close(): void;
+    /**
+     * Leaves the room without closing it (the page is going away). The room and its
+     * players stay on the server, so the host can come back (reload) or take it over.
+     */
+    disconnect(): void;
+    /** Updates the lobby/game state shown by the player apps. */
+    setState(update: Partial<RemoteLobbyState>): void;
+    /**
+     * Connects the session's remote players (all roster players that are relay
+     * players) and keeps the session in sync with the room: presence, late joins,
+     * reconnects, renames and kicks.
+     */
+    attach(session: LocalSession): void;
+    /** Disconnects from the session; player devices return to the lobby. */
+    detach(): void;
+    private onSessionEvent;
+    private connectRemote;
+    /** A session endpoint whose plugin instance runs on the player's device. */
+    endpointFor(playerId: string): PluginEndpoint;
+    private sendMount;
+    private remotePlugin;
+    private callRemote;
+    private channel;
+    private resetChannel;
+    /** Calls to a device that went away are dropped (resolved), like messages. */
+    private settleCalls;
+    private onServer;
+    private onPresence;
+    private onPlayer;
+    private sendTo;
+    private broadcast;
+}

package/dist/src/relay/messages.d.ts

@@ -0,0 +1,97 @@
+import { Player, SessionResult } from '@memizy/protocol';
+export type RemotePhase = 'lobby' | 'loading' | 'countdown' | 'running' | 'ended';
+export interface RemoteLobbyState {
+    phase: RemotePhase;
+    appName: string | null;
+    players: Player[];
+    /** Seconds left while counting down. */
+    countdown?: number;
+    /** Whether the authority is reachable (false = "waiting for the host"). */
+    authorityConnected: boolean;
+    result?: SessionResult;
+}
+export type SerializedError = {
+    message: string;
+};
+export type HostToPlayer = 
+/** Lobby / game state for the player app's own screens. */
+{
+    k: 'state';
+    state: RemoteLobbyState;
+}
+/** Create (or recreate) the plugin instance; download the bundle if its version changed. */
+ | {
+    k: 'mount';
+    gen: number;
+    bundle: number;
+    locale: string;
+}
+/** Remove the plugin instance. */
+ | {
+    k: 'unmount';
+}
+/** A PluginApi call. */
+ | {
+    k: 'call';
+    id: number;
+    gen: number;
+    method: string;
+    args: unknown[];
+}
+/** Result of a HostApi call. `hostNow` comes with `hello` (clock sync). */
+ | {
+    k: 'result';
+    id: number;
+    ok: true;
+    value: unknown;
+    hostNow?: number;
+} | {
+    k: 'result';
+    id: number;
+    ok: false;
+    error: SerializedError;
+};
+export type PlayerToHost = 
+/** After (re)joining: the generation of the plugin instance still alive (0 = none). */
+{
+    k: 'hello';
+    gen: number;
+}
+/** The plugin instance `gen` connected (Penpal handshake done). */
+ | {
+    k: 'mounted';
+    gen: number;
+} | {
+    k: 'mount-failed';
+    gen: number;
+    error: SerializedError;
+}
+/** A HostApi call of instance `gen`. */
+ | {
+    k: 'call';
+    id: number;
+    gen: number;
+    method: string;
+    args: unknown[];
+}
+/** Result of a PluginApi call. */
+ | {
+    k: 'result';
+    id: number;
+    ok: true;
+    value: unknown;
+} | {
+    k: 'result';
+    id: number;
+    ok: false;
+    error: SerializedError;
+};
+export declare function serializeError(error: unknown): SerializedError;
+/** Blobs (getAsset) are not JSON: they travel as base64. */
+export interface SerializedBlob {
+    $blob: string;
+    type: string;
+}
+export declare function blobToJson(blob: Blob): Promise<SerializedBlob>;
+export declare function jsonToBlob(value: SerializedBlob): Blob;
+export declare function isSerializedBlob(value: unknown): value is SerializedBlob;

package/dist/src/relay/player.d.ts

@@ -0,0 +1,98 @@
+import { HostApi, Theme, PluginApi, RelayErrorCode } from '@memizy/protocol';
+import { RelayStatus } from './socket';
+import { RemoteLobbyState } from './messages';
+export type RelayPlayerEvent = {
+    type: 'status';
+    status: RelayStatus;
+} | {
+    type: 'joined';
+    playerId: string;
+    token: string;
+    name: string;
+} | {
+    type: 'state';
+    state: RemoteLobbyState;
+} | {
+    type: 'host';
+    connected: boolean;
+}
+/** The plugin instance was created (`true`) or removed (`false`). */
+ | {
+    type: 'frame';
+    active: boolean;
+} | {
+    type: 'error';
+    code: RelayErrorCode | 'MOUNT_FAILED';
+    message: string;
+    fatal: boolean;
+} | {
+    type: 'closed';
+    reason: 'host' | 'expired' | 'kicked';
+};
+export interface RelayPlayerOptions {
+    serverUrl: string;
+    pin: string;
+    name: string;
+    /** Token from an earlier `joined` event: rejoin as the same player. */
+    token?: string;
+    /** Where the plugin iframe goes (called when the game starts). */
+    container: () => HTMLElement | null;
+    fetch?: typeof fetch;
+    WebSocket?: typeof WebSocket;
+    callTimeoutMs?: number;
+    /** Adjusts the downloaded plugin HTML before it runs (e.g. points the SDK import to a local build). */
+    transformHtml?: (html: string) => string;
+    /**
+     * Language and theme of this device. They replace the host's values, so every
+     * player sees the game in the language and theme of their own app.
+     */
+    config?: () => Partial<Theme>;
+    /** Creates the plugin instance (default: a sandboxed iframe; tests connect the SDK directly). */
+    createFrame?: FrameFactory;
+}
+export type FrameFactory = (html: string, title: string, hostApi: HostApi, doc: Document) => RemoteFrame;
+export interface RemoteFrame {
+    readonly iframe: HTMLElement;
+    readonly plugin: Promise<PluginApi>;
+    destroy(): void;
+}
+export declare class RelayPlayer {
+    playerId: string | null;
+    token: string | null;
+    name: string;
+    state: RemoteLobbyState | null;
+    hostConnected: boolean;
+    private readonly options;
+    private readonly socket;
+    private readonly listeners;
+    private bundle;
+    private frame;
+    private plugin;
+    private gen;
+    private callCounter;
+    private readonly pending;
+    /** Host clock minus local clock (ms). */
+    private skewMs;
+    /** The config the host sent last (before this device's overrides). */
+    private hostConfig;
+    private mountQueue;
+    constructor(options: RelayPlayerOptions);
+    get status(): RelayStatus;
+    on(listener: (event: RelayPlayerEvent) => void): () => void;
+    private emit;
+    /** Call when this device's language or theme changed (see `config`). */
+    updateConfig(): void;
+    private localConfig;
+    rename(name: string): void;
+    /** Reconnect right away (e.g. the page became visible again). */
+    reconnectNow(): void;
+    /** Leaves (the token stays valid for a rejoin until the room closes). */
+    leave(): void;
+    private onServer;
+    private up;
+    private onHost;
+    private ensureBundle;
+    private mount;
+    private hostApiFor;
+    private destroyFrame;
+}

package/dist/src/relay/socket.d.ts

@@ -0,0 +1,34 @@
+import { RelayClientMessage, RelayServerMessage } from '@memizy/protocol';
+/** `replaced`: the same host or player connected from another tab or device; this one stops. */
+export type RelayStatus = 'connecting' | 'online' | 'offline' | 'closed' | 'replaced';
+export interface RelaySocketOptions {
+    /** `ws(s)://…/ws` */
+    url: string;
+    /** The attach message sent after every (re)connect. */
+    attach: () => RelayClientMessage;
+    WebSocket?: typeof WebSocket;
+}
+export declare class RelaySocket {
+    status: RelayStatus;
+    private readonly options;
+    private ws;
+    private retry;
+    private retryTimer;
+    private pingTimer;
+    private stopped;
+    private readonly messageListeners;
+    private readonly statusListeners;
+    constructor(options: RelaySocketOptions);
+    onMessage(listener: (msg: RelayServerMessage) => void): () => void;
+    onStatus(listener: (status: RelayStatus) => void): () => void;
+    /** Sends when online; returns `false` when the message was dropped. */
+    send(msg: RelayClientMessage): boolean;
+    /** Stops for good (no reconnect). */
+    close(): void;
+    /** Reconnects right away (e.g. when the page becomes visible again). */
+    reconnectNow(): void;
+    private setStatus;
+    private open;
+}
+/** `http(s)://server` → `ws(s)://server/ws` */
+export declare function relayWebSocketUrl(serverUrl: string): string;

package/dist/src/session.d.ts

@@ -0,0 +1,233 @@
+import { AnswerRecord, HostApi, HostAs, Player, PluginApi, PluginRuntime, PluginView, SessionEndReason, SessionResult, Theme, SessionClock } from '@memizy/protocol';
+import { OQSEFile, ProgressRecord } from '@memizy/oqse';
+import { LearningAlgorithm } from './learning';
+import { HostStorage } from './storage';
+import { LoadedPlugin, PreparedSet } from './plugin';
+export interface SessionPlayer {
+    id: string;
+    name: string;
+    isHost?: boolean;
+}
+export interface SessionConfig {
+    plugin: LoadedPlugin;
+    /** The study set, loaded with `loadOQSEFile`. */
+    set: OQSEFile;
+    mode: 'solo' | 'multiplayer';
+    /** Multiplayer only: how the host takes part. */
+    hostAs?: HostAs;
+    /** Solo: exactly one player (default: a player called "Player"). Multiplayer: the roster. */
+    players?: SessionPlayer[];
+    /** Setting values (defaults are applied; invalid values throw). */
+    settings?: Record<string, unknown>;
+    storage?: HostStorage;
+    algorithm?: LearningAlgorithm;
+    /** Loader for assets that are not absolute URLs (e.g. files of an `.oqse` package). */
+    loadAsset?: (key: string, itemId: string | undefined) => Promise<Blob>;
+    /** Maps a player to the key of their stored progress and data (default: the player ID). */
+    userKeyFor?: (playerId: string) => string;
+    config?: Partial<Theme>;
+    sessionId?: string;
+    /**
+     * Seed of the display order of options, pairs… (SPEC 4.4; default: the session id).
+     * Pass the seed used for the relay bundle so all devices agree; `null` keeps the set's order.
+     */
+    shuffleSeed?: string | null;
+    host?: {
+        name: string;
+        version: string;
+    };
+    /** Max wait for all instances to be ready before the countdown (default 15 s). */
+    readyTimeoutMs?: number;
+    /** Countdown before the game starts in multiplayer (default 3 s; 0 = none). */
+    countdownMs?: number;
+    /**
+     * The session was already running (e.g. the host page was reloaded; pass the
+     * same `sessionId` and a persistent `storage`). The authority resumes from its
+     * last snapshot; without a snapshot the game starts again right away.
+     */
+    resume?: boolean;
+    /** When resuming: the pauses so far (from the `paused` events), so timers stay right. */
+    clock?: {
+        pausedMs?: number;
+        pausedAt?: number | null;
+    };
+    /**
+     * Memizy services this host offers (SPEC 5.3), by name. A plugin may call those it
+     * declares in `services`; payloads and results are JSON. Throw a `ProtocolError` to
+     * reject a call with a specific code.
+     */
+    services?: Record<string, ServiceHandler>;
+}
+/** Handles one service call. `playerId` is null on the board. */
+export type ServiceHandler = (payload: unknown, context: {
+    playerId: string | null;
+    address: string;
+    pluginId: string;
+    setId: string;
+}) => Promise<unknown>;
+export type SessionEvent = {
+    type: 'ready';
+    address: string;
+} | {
+    type: 'countdown';
+    secondsLeft: number;
+} | {
+    type: 'started';
+} | {
+    type: 'settings';
+    values: Record<string, unknown>;
+    valid: boolean;
+    message?: string;
+}
+/**
+ * A recorded answer. `record` is the updated learning progress (null for a generated item,
+ * which is not repeated); `skills` / `tags` come from the item (for statistics).
+ */
+ | {
+    type: 'answer';
+    playerId: string;
+    record: ProgressRecord | null;
+    answer: AnswerRecord;
+    generated: boolean;
+    skills: string[];
+    tags: string[];
+} | {
+    type: 'ended';
+    result: SessionResult;
+} | {
+    type: 'players';
+    players: Player[];
+} | {
+    type: 'authority';
+    connected: boolean;
+} | {
+    type: 'traffic';
+    from: string;
+    to: string;
+    bytes: number;
+    data: unknown;
+} | {
+    type: 'rejected';
+    address: string;
+    method: string;
+    code: string;
+    message: string;
+} | {
+    type: 'pluginError';
+    address: string;
+    code: string;
+    message: string;
+    context?: Record<string, unknown>;
+} | {
+    type: 'resize';
+    address: string;
+    height: number | 'auto';
+}
+/** The host paused or resumed the game (store `clock` to resume a reloaded host). */
+ | {
+    type: 'paused';
+    paused: boolean;
+    clock: {
+        pausedMs: number;
+        pausedAt: number | null;
+    };
+} | {
+    type: 'exit';
+    address: string;
+};
+/** Creates the plugin side of an instance for a given host API (iframe + Penpal, or a direct connection in tests). */
+export type PluginEndpoint = (hostApi: HostApi) => PluginApi | Promise<PluginApi>;
+export interface SessionInstance {
+    readonly address: string;
+    readonly view: PluginView;
+    readonly hostApi: HostApi;
+}
+export declare const SETTINGS_ADDRESS = "settings";
+export declare class LocalSession {
+    readonly id: string;
+    readonly plugin: LoadedPlugin;
+    readonly runtime: PluginRuntime;
+    readonly mode: 'solo' | 'multiplayer';
+    readonly hostAs: HostAs | null;
+    readonly authority: string;
+    readonly prepared: PreparedSet;
+    players: Player[];
+    settings: Record<string, unknown>;
+    settingsValid: boolean;
+    config: Theme;
+    started: boolean;
+    ended: boolean;
+    /** Pauses of the game (game time = session time without them). */
+    private pauseState;
+    private readonly options;
+    private readonly storage;
+    private readonly algorithm;
+    private readonly instances;
+    private readonly listeners;
+    private authorityConnected;
+    private startPromise;
+    private resumeStartPending;
+    private pendingSnapshot;
+    private snapshotTimer;
+    private readonly pendingData;
+    constructor(config: SessionConfig);
+    on(listener: (event: SessionEvent) => void): () => void;
+    private emit;
+    /** The default view of an address in this session. */
+    viewOf(address: string): PluginView;
+    /** Addresses that have a game instance in this session (board and players). */
+    addresses(): string[];
+    /**
+     * Connects a plugin instance at `address` (a player ID, `"board"`, or `"settings"`
+     * for the lobby settings screen). An existing instance at the address is replaced.
+     */
+    connect(address: string, endpoint: PluginEndpoint, options?: {
+        onDispose?: () => void;
+    }): Promise<SessionInstance>;
+    /** Recreates the instance at `address` (like a browser reload or a reconnect). */
+    reload(address: string): Promise<SessionInstance>;
+    /** Removes the instance at `address` (the player stays in the roster). */
+    disconnect(address: string): void;
+    private disposeInstance;
+    getInstance(address: string): SessionInstance | undefined;
+    /**
+     * Multiplayer: waits until all connected game instances are ready (or the
+     * ready timeout passes), runs the countdown and starts the game on the
+     * authority (SPEC 3.3). Solo games start automatically when ready.
+     */
+    start(): Promise<void>;
+    private runStart;
+    addPlayer(player: SessionPlayer): void;
+    removePlayer(id: string): void;
+    renamePlayer(id: string, name: string): void;
+    /**
+     * Simulates a connection loss / recovery of an instance. Messages to and from a
+     * disconnected instance are dropped; for the authority, the others are told
+     * that the authority is unavailable (SPEC 6.1).
+     */
+    setConnected(address: string, connected: boolean): void;
+    /** Services the plugin declares and this host offers (SPEC 5.3). */
+    get services(): string[];
+    /** Whether the game is paused (the clock stands still on every device). */
+    get paused(): boolean;
+    /** The session clock as sent to the instances (host time; the relay adds each device's skew). */
+    get clock(): SessionClock;
+    /** Pauses the game: timers and countdowns stop, players cannot act (the SDK shows "Paused"). */
+    pause(): void;
+    /** Continues a paused game. */
+    resume(): void;
+    private broadcastClock;
+    setConfig(config: Partial<Theme>): void;
+    /** Ends the session for all instances (they stay mounted until the app removes them). */
+    end(reason?: SessionEndReason): Promise<void>;
+    private createHostApi;
+    private buildInit;
+    private userKey;
+    private deliver;
+    private broadcastPlayers;
+    private setAuthorityConnected;
+    private callPlugin;
+    private flushSnapshot;
+    private pendingDataValue;
+    private flushData;
+}

package/dist/src/storage.d.ts

@@ -0,0 +1,24 @@
+import { ProgressRecord } from '@memizy/oqse';
+import { DataScope } from '@memizy/protocol';
+export interface HostStorage {
+    loadProgress(userKey: string, setId: string): Promise<Record<string, ProgressRecord>>;
+    /** Upserts the given records (other records stay). */
+    saveProgress(userKey: string, setId: string, records: Record<string, ProgressRecord>): Promise<void>;
+    /** `setId` is ignored for scope `plugin`. Returns `null` when nothing is saved. */
+    loadData(userKey: string, pluginId: string, scope: DataScope, setId: string): Promise<unknown>;
+    saveData(userKey: string, pluginId: string, scope: DataScope, setId: string, value: unknown): Promise<void>;
+    loadSnapshot(sessionId: string): Promise<unknown | null>;
+    saveSnapshot(sessionId: string, snapshot: unknown): Promise<void>;
+}
+/** In-memory storage (values are copied, like a real store would). */
+export declare class MemoryStorage implements HostStorage {
+    readonly progress: Map<string, Record<string, ProgressRecord>>;
+    readonly data: Map<string, unknown>;
+    readonly snapshots: Map<string, unknown>;
+    loadProgress(userKey: string, setId: string): Promise<Record<string, ProgressRecord>>;
+    saveProgress(userKey: string, setId: string, records: Record<string, ProgressRecord>): Promise<void>;
+    loadData(userKey: string, pluginId: string, scope: DataScope, setId: string): Promise<{} | null>;
+    saveData(userKey: string, pluginId: string, scope: DataScope, setId: string, value: unknown): Promise<void>;
+    loadSnapshot(sessionId: string): Promise<{} | null>;
+    saveSnapshot(sessionId: string, snapshot: unknown): Promise<void>;
+}

package/dist/storage.cjs

@@ -0,0 +1 @@
+var e=(e,t,n,r)=>JSON.stringify([e,t,n,n===`set`?r:null]),t=class{progress=new Map;data=new Map;snapshots=new Map;async loadProgress(e,t){return structuredClone(this.progress.get(`${e}|${t}`)??{})}async saveProgress(e,t,n){let r=`${e}|${t}`;this.progress.set(r,{...this.progress.get(r)??{},...structuredClone(n)})}async loadData(t,n,r,i){let a=this.data.get(e(t,n,r,i));return a===void 0?null:structuredClone(a)}async saveData(t,n,r,i,a){this.data.set(e(t,n,r,i),structuredClone(a))}async loadSnapshot(e){let t=this.snapshots.get(e);return t===void 0?null:structuredClone(t)}async saveSnapshot(e,t){this.snapshots.set(e,structuredClone(t))}};exports.MemoryStorage=t;

package/dist/storage.js

@@ -0,0 +1,37 @@
+//#region src/storage.ts
+var e = (e, t, n, r) => JSON.stringify([
+	e,
+	t,
+	n,
+	n === "set" ? r : null
+]), t = class {
+	progress = /* @__PURE__ */ new Map();
+	data = /* @__PURE__ */ new Map();
+	snapshots = /* @__PURE__ */ new Map();
+	async loadProgress(e, t) {
+		return structuredClone(this.progress.get(`${e}|${t}`) ?? {});
+	}
+	async saveProgress(e, t, n) {
+		let r = `${e}|${t}`;
+		this.progress.set(r, {
+			...this.progress.get(r) ?? {},
+			...structuredClone(n)
+		});
+	}
+	async loadData(t, n, r, i) {
+		let a = this.data.get(e(t, n, r, i));
+		return a === void 0 ? null : structuredClone(a);
+	}
+	async saveData(t, n, r, i, a) {
+		this.data.set(e(t, n, r, i), structuredClone(a));
+	}
+	async loadSnapshot(e) {
+		let t = this.snapshots.get(e);
+		return t === void 0 ? null : structuredClone(t);
+	}
+	async saveSnapshot(e, t) {
+		this.snapshots.set(e, structuredClone(t));
+	}
+};
+//#endregion
+export { t as MemoryStorage };

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "@memizy/host-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0-rc.5",
+  "description": "Run Memizy plugins: sandboxed iframes, protocol validation, sessions, storage hooks.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/src/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc --noEmit && vite build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@memizy/oqse": "^1.0.0-rc.5",
+    "@memizy/protocol": "^1.0.0-rc.5",
+    "penpal": "^8.0.1"
+  },
+  "devDependencies": {
+    "@memizy/plugin-sdk": "^1.0.0-rc.5",
+    "@types/node": "^25.6.0",
+    "@types/ws": "^8",
+    "jsdom": "^30.1.2",
+    "typescript": "~6.0.2",
+    "vite": "^8.0.9",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.1.4",
+    "ws": "^8"
+  },
+  "license": "MIT",
+  "author": "Memizy Team",
+  "keywords": [
+    "memizy",
+    "plugin",
+    "host",
+    "sdk",
+    "multiplayer"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/memizy/memizy.git",
+    "directory": "packages/host-sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/memizy/memizy/issues"
+  },
+  "homepage": "https://github.com/memizy/memizy/tree/main/packages/host-sdk#readme"
+}