@memizy/protocol 0.0.0-stage → 1.0.0-rc.6

package/dist/src/schemas.d.ts

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+import { HostApi } from './types.js';
+export declare const AddressSchema: z.ZodString;
+export declare const HandshakeSchema: z.ZodObject<{
+    protocol: z.ZodString;
+    sdk: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$loose>;
+    plugin: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$loose>;
+    features: z.ZodArray<z.ZodString>;
+}, z.core.$loose>;
+export declare const OutgoingMessageSchema: z.ZodObject<{
+    to: z.ZodUnion<readonly [z.ZodLiteral<"authority">, z.ZodLiteral<"all">, z.ZodArray<z.ZodString>]>;
+    data: z.ZodUnknown;
+}, z.core.$loose>;
+export declare const AnswerRecordSchema: z.ZodObject<{
+    playerId: z.ZodOptional<z.ZodString>;
+    itemId: z.ZodString;
+    isCorrect: z.ZodBoolean;
+    confidence: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
+    timeSpentMs: z.ZodOptional<z.ZodNumber>;
+    hintsUsed: z.ZodOptional<z.ZodNumber>;
+    isSkipped: z.ZodOptional<z.ZodBoolean>;
+    answer: z.ZodOptional<z.ZodUnknown>;
+    item: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const DataScopeSchema: z.ZodEnum<{
+    set: "set";
+    plugin: "plugin";
+}>;
+export declare const SettingsUpdateSchema: z.ZodObject<{
+    values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    valid: z.ZodBoolean;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const SessionResultSchema: z.ZodObject<{
+    scores: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const ErrorReportSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>;
+/** Argument schemas of every Host API method. */
+export declare const HOST_API_ARGS: {
+    hello: z.ZodTuple<[z.ZodObject<{
+        protocol: z.ZodString;
+        sdk: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$loose>;
+        plugin: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$loose>;
+        features: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>], null>;
+    ready: z.ZodTuple<[], null>;
+    send: z.ZodTuple<[z.ZodObject<{
+        to: z.ZodUnion<readonly [z.ZodLiteral<"authority">, z.ZodLiteral<"all">, z.ZodArray<z.ZodString>]>;
+        data: z.ZodUnknown;
+    }, z.core.$loose>], null>;
+    saveSnapshot: z.ZodTuple<[z.ZodUnknown], null>;
+    recordAnswer: z.ZodTuple<[z.ZodObject<{
+        playerId: z.ZodOptional<z.ZodString>;
+        itemId: z.ZodString;
+        isCorrect: z.ZodBoolean;
+        confidence: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
+        timeSpentMs: z.ZodOptional<z.ZodNumber>;
+        hintsUsed: z.ZodOptional<z.ZodNumber>;
+        isSkipped: z.ZodOptional<z.ZodBoolean>;
+        answer: z.ZodOptional<z.ZodUnknown>;
+        item: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>], null>;
+    saveData: z.ZodTuple<[z.ZodEnum<{
+        set: "set";
+        plugin: "plugin";
+    }>, z.ZodUnknown], null>;
+    updateSettings: z.ZodTuple<[z.ZodObject<{
+        values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        valid: z.ZodBoolean;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], null>;
+    getAsset: z.ZodTuple<[z.ZodString, z.ZodOptional<z.ZodString>], null>;
+    end: z.ZodTuple<[z.ZodObject<{
+        scores: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], null>;
+    reportError: z.ZodTuple<[z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>], null>;
+    service: z.ZodTuple<[z.ZodString, z.ZodUnknown], null>;
+};
+/**
+ * Validates the arguments of a Host API call.
+ * @throws {ProtocolError} `INVALID_ARGUMENT` with readable details.
+ */
+export declare function parseHostCall<M extends keyof HostApi>(method: M, args: unknown[]): Parameters<HostApi[M]>;

package/dist/src/security.d.ts

@@ -0,0 +1,21 @@
+import { PluginRuntime } from './pluginRuntime.js';
+/** CDNs plugins load libraries from (scripts, styles, fonts, data files). */
+export declare const LIBRARY_ORIGINS: string[];
+/** Device permissions a plugin may declare, and their iframe `allow` names. */
+export declare const PLUGIN_DEVICES: readonly ["camera", "microphone", "geolocation", "serial", "bluetooth"];
+export type PluginDevice = (typeof PLUGIN_DEVICES)[number];
+/**
+ * The Content Security Policy of a plugin iframe.
+ *
+ * - Scripts only inline (the plugin itself), from the library CDNs and from the host
+ *   (`hostOrigin`, which serves the SDK in development and in Memizy Play).
+ * - Network requests (`fetch`, WebSocket…) only to the CDNs and the declared
+ *   `permissions.network` origins.
+ * - Images and media may come from any https URL (study sets link them), so an image
+ *   URL can still carry data out: the policy blocks data channels, not every leak.
+ */
+export declare function pluginContentPolicy(runtime: Pick<PluginRuntime, 'permissions'> | null, hostOrigin: string | null): string;
+/** The iframe `allow` attribute for the declared devices (empty when none). */
+export declare function pluginAllowAttribute(runtime: Pick<PluginRuntime, 'permissions'> | null): string;
+/** Puts the policy into the plugin HTML as the first element of `<head>` (before any script). */
+export declare function injectContentPolicy(html: string, policy: string): string;

package/dist/src/settings.d.ts

@@ -0,0 +1,22 @@
+import { LocalizedText, SettingDefinition } from './settingsSchema.js';
+export type SettingValue = string | number | boolean;
+/** Returns an error description if `value` is not valid for `def`, otherwise `null`. */
+export declare function validateSettingValue(def: SettingDefinition, value: unknown): string | null;
+/**
+ * Builds the full settings object: every declared setting gets the valid input
+ * value or its default. Invalid values and unknown keys are reported in `errors`
+ * (and replaced by defaults / dropped).
+ */
+export declare function resolveSettings(definitions: SettingDefinition[], input?: Record<string, unknown>): {
+    values: Record<string, SettingValue>;
+    errors: string[];
+};
+/** The settings a host shows for a mode (`modes` absent = both modes). */
+export declare function settingsForMode<T extends {
+    modes?: readonly string[];
+}>(definitions: readonly T[], mode: 'solo' | 'multiplayer'): T[];
+/**
+ * Picks the best text for a locale: exact match (`cs-CZ`), language (`cs`),
+ * English, then the first available.
+ */
+export declare function localize(text: LocalizedText, locale: string): string;

package/dist/src/settingsSchema.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+/** A string, or a map of BCP 47 language → string (e.g. `{ "cs": "Čas", "en": "Time" }`). */
+export declare const LocalizedTextSchema: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+export type LocalizedText = z.infer<typeof LocalizedTextSchema>;
+export declare const SettingDefinitionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"number">;
+    default: z.ZodNumber;
+    min: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodNumber>;
+    step: z.ZodOptional<z.ZodNumber>;
+    id: z.ZodString;
+    label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+    modes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        solo: "solo";
+        multiplayer: "multiplayer";
+    }>>>;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"boolean">;
+    default: z.ZodBoolean;
+    id: z.ZodString;
+    label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+    modes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        solo: "solo";
+        multiplayer: "multiplayer";
+    }>>>;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"select">;
+    options: z.ZodArray<z.ZodObject<{
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+        label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    }, z.core.$loose>>;
+    default: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    id: z.ZodString;
+    label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+    modes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        solo: "solo";
+        multiplayer: "multiplayer";
+    }>>>;
+}, z.core.$loose>, z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    default: z.ZodString;
+    maxLength: z.ZodOptional<z.ZodNumber>;
+    id: z.ZodString;
+    label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+    description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+    modes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        solo: "solo";
+        multiplayer: "multiplayer";
+    }>>>;
+}, z.core.$loose>], "type">;
+export type SettingDefinition = z.infer<typeof SettingDefinitionSchema>;

package/dist/src/types.d.ts

@@ -0,0 +1,182 @@
+import { OQSEAnyItem, OQSEMeta, ProgressRecord } from '@memizy/oqse';
+import { HostAs, PluginView } from './pluginRuntime.js';
+/** Address of an instance: a player ID, `"board"`, `"settings"` (`SETTINGS_ADDRESS`); `"server"` is reserved. */
+export type Address = string;
+/** Address of the presenter's board. */
+export declare const BOARD_ADDRESS = "board";
+/** Reserved for a future server-side authority (SPEC 3.1). */
+export declare const SERVER_ADDRESS = "server";
+/** Address of the plugin's own settings screen in the lobby (view `settings`). */
+export declare const SETTINGS_ADDRESS = "settings";
+export type SessionMode = 'solo' | 'multiplayer';
+export interface Player {
+    id: string;
+    name: string;
+    isHost: boolean;
+    connected: boolean;
+}
+export interface SessionInfo {
+    id: string;
+    mode: SessionMode;
+    /** `null` in solo. */
+    hostAs: HostAs | null;
+    view: PluginView;
+    /** This instance. */
+    self: Address;
+    /** Who owns the game state. */
+    authority: Address;
+    /** This instance joined a running game. */
+    lateJoin: boolean;
+}
+export interface Handshake {
+    /** Protocol version the SDK speaks, e.g. `"1.0"`. */
+    protocol: string;
+    sdk: {
+        name: string;
+        version: string;
+    };
+    plugin: {
+        id: string;
+        version: string;
+    };
+    features: string[];
+}
+/** Language and theme of the app (`InitPayload.config`, `configChanged`). */
+export interface HostConfig {
+    locale: string;
+    theme: 'light' | 'dark';
+}
+export type DataScope = 'plugin' | 'set';
+export interface PluginData {
+    /** Data across all sets (`null` = nothing saved yet). */
+    plugin: unknown;
+    /** Data for this plugin and the current set (`null` = nothing saved yet). */
+    set: unknown;
+}
+export interface InitPayload {
+    /** Negotiated version: same MAJOR, the lower MINOR. */
+    protocol: string;
+    host: {
+        name: string;
+        version: string;
+    };
+    oqseVersion: string;
+    features: string[];
+    session: SessionInfo;
+    /** Current roster (the presenter is not a player). */
+    players: Player[];
+    set: {
+        meta: OQSEMeta;
+        items: OQSEAnyItem[];
+    };
+    /** Values for every declared setting (defaults applied). */
+    settings: Record<string, unknown>;
+    config: HostConfig;
+    /** The session clock and its pauses (see {@link SessionClock}). */
+    clock: SessionClock;
+    /** Memizy services this host offers to the plugin (declared in its manifest and available here); call them with `service()`. */
+    services: string[];
+    /** Learning progress of `self` (empty for board/settings). */
+    progress: Record<string, ProgressRecord>;
+    /** Plugin data of `self` (`null` values for board/settings). */
+    data: PluginData;
+    /** Last saved snapshot, only for the authority (resume). */
+    snapshot: unknown | null;
+}
+/**
+ * The session clock. `Date.now() + offsetMs` is the session time. Pauses: the
+ * game time is `(pausedAt ?? sessionTime) - pausedMs` – it stands still while the host
+ * has paused the game (`pausedAt` = session time of the pause) and continues afterwards
+ * without the paused time (`pausedMs` = total of finished pauses).
+ */
+export interface SessionClock {
+    offsetMs: number;
+    /** Total length of finished pauses (ms). */
+    pausedMs: number;
+    /** Session time when the current pause started, or `null` while the game runs. */
+    pausedAt: number | null;
+}
+export interface AnswerRecord {
+    /** Default: self. The authority may record for any player. */
+    playerId?: string;
+    itemId: string;
+    isCorrect: boolean;
+    confidence?: 1 | 2 | 3 | 4;
+    timeSpentMs?: number;
+    hintsUsed?: number;
+    isSkipped?: boolean;
+    /**
+     * What the player answered, in the `checkAnswer` format of the item type
+     * (choice IDs, text, numbers…). Lets teachers see which wrong answers were chosen.
+     */
+    answer?: unknown;
+    /**
+     * The item itself, required when `itemId` is not in the set (a generated item, e.g.
+     * from a service). It needs at least `id` (= `itemId`) and `type`; the answer fields may
+     * be left out. Such answers count for statistics (`skills`, `tags`), not for repetition.
+     */
+    item?: {
+        id: string;
+        type: string;
+        [key: string]: unknown;
+    };
+}
+export interface SessionResult {
+    /** Final score per player ID (in solo: the single player). */
+    scores?: Record<string, number>;
+    /** Short plain-text summary shown by the host. */
+    summary?: string;
+}
+export interface SettingsUpdate {
+    values: Record<string, unknown>;
+    valid: boolean;
+    message?: string;
+}
+export interface ErrorReport {
+    code: string;
+    message: string;
+    context?: Record<string, unknown>;
+}
+export interface OutgoingMessage {
+    /** `'all'` = every other instance. */
+    to: 'authority' | 'all' | Address[];
+    /** JSON-serializable. */
+    data: unknown;
+}
+export interface IncomingMessage {
+    from: Address;
+    data: unknown;
+    /** Session clock (ms). */
+    sentAt: number;
+}
+export type SessionEndReason = 'finished' | 'host-left' | 'kicked' | 'closed' | 'error';
+/** Methods the host exposes to the plugin (plugin → host). SPEC section 5. */
+export interface HostApi {
+    hello(handshake: Handshake): Promise<InitPayload>;
+    ready(): Promise<void>;
+    send(message: OutgoingMessage): Promise<void>;
+    saveSnapshot(snapshot: unknown): Promise<void>;
+    recordAnswer(answer: AnswerRecord): Promise<void>;
+    saveData(scope: DataScope, value: unknown): Promise<void>;
+    updateSettings(update: SettingsUpdate): Promise<void>;
+    getAsset(key: string, itemId?: string): Promise<Blob>;
+    end(result: SessionResult): Promise<void>;
+    reportError(error: ErrorReport): Promise<void>;
+    /** Calls a Memizy service (one of `InitPayload.services`); returns its JSON result. */
+    service(name: string, payload: unknown): Promise<unknown>;
+}
+/** Methods the plugin exposes to the host (host → plugin). SPEC section 7. */
+export interface PluginApi {
+    start(): Promise<void>;
+    deliver(message: IncomingMessage): Promise<void>;
+    playersChanged(players: Player[]): Promise<void>;
+    authorityChanged(status: {
+        connected: boolean;
+    }): Promise<void>;
+    configChanged(config: HostConfig): Promise<void>;
+    /** The clock was corrected, or the game was paused / resumed. */
+    clockChanged(clock: SessionClock): Promise<void>;
+    sessionEnded(reason: SessionEndReason): Promise<void>;
+}
+export declare const HOST_API_METHODS: readonly ["hello", "ready", "send", "saveSnapshot", "recordAnswer", "saveData", "updateSettings", "getAsset", "end", "reportError", "service"];
+export declare const PLUGIN_API_METHODS: readonly ["start", "deliver", "playersChanged", "authorityChanged", "configChanged", "clockChanged", "sessionEnded"];

package/dist/src/version.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Protocol version handling (SPEC section 4.3).
+ */
+/** The protocol version implemented by this package. */
+export declare const PROTOCOL_VERSION = "1.0";
+export interface ProtocolVersion {
+    major: number;
+    minor: number;
+}
+/** Parses a `MAJOR.MINOR` version. Returns `null` for anything else. */
+export declare function parseProtocolVersion(version: string): ProtocolVersion | null;
+/** Compares two `MAJOR.MINOR` versions (negative: a < b, 0: equal, positive: a > b). */
+export declare function compareProtocolVersions(a: string, b: string): number;
+/**
+ * The protocol versions a host supports: one version, or one per MAJOR it supports
+ * (e.g. `['1.4', '2.1']`, SPEC 4.3).
+ */
+export type HostProtocolVersions = string | readonly string[];
+/**
+ * Negotiates the version both sides use: the plugin's MAJOR (which the host must
+ * support), the lower MINOR. Returns `null` when the host does not support that MAJOR
+ * or a version is invalid.
+ */
+export declare function negotiateProtocolVersion(plugin: string, host: HostProtocolVersions): string | null;
+/**
+ * Checks before loading the iframe whether a host can run a plugin whose
+ * manifest requires `required` (SPEC 4.3): the host supports its MAJOR with a MINOR ≥
+ * the required one.
+ */
+export declare function isProtocolSupported(required: string, host?: HostProtocolVersions): boolean;

package/dist/types.cjs

@@ -0,0 +1 @@
+var e=`board`,t=`server`,n=`settings`,r=[`hello`,`ready`,`send`,`saveSnapshot`,`recordAnswer`,`saveData`,`updateSettings`,`getAsset`,`end`,`reportError`,`service`],i=[`start`,`deliver`,`playersChanged`,`authorityChanged`,`configChanged`,`clockChanged`,`sessionEnded`];exports.BOARD_ADDRESS=e,exports.HOST_API_METHODS=r,exports.PLUGIN_API_METHODS=i,exports.SERVER_ADDRESS=t,exports.SETTINGS_ADDRESS=n;

package/dist/types.js

@@ -0,0 +1,24 @@
+//#region src/types.ts
+var e = "board", t = "server", n = "settings", r = [
+	"hello",
+	"ready",
+	"send",
+	"saveSnapshot",
+	"recordAnswer",
+	"saveData",
+	"updateSettings",
+	"getAsset",
+	"end",
+	"reportError",
+	"service"
+], i = [
+	"start",
+	"deliver",
+	"playersChanged",
+	"authorityChanged",
+	"configChanged",
+	"clockChanged",
+	"sessionEnded"
+];
+//#endregion
+export { e as BOARD_ADDRESS, r as HOST_API_METHODS, i as PLUGIN_API_METHODS, t as SERVER_ADDRESS, n as SETTINGS_ADDRESS };

package/dist/version.cjs

@@ -0,0 +1 @@
+var e=`1.0`,t=/^(\d+)\.(\d+)$/;function n(e){let n=t.exec(e);return n?{major:Number(n[1]),minor:Number(n[2])}:null}function r(e,t){let r=n(e),i=n(t);if(!r||!i)throw Error(`Invalid protocol version: ${r?t:e}`);return r.major===i.major?r.minor-i.minor:r.major-i.major}function i(e,t){for(let r of typeof t==`string`?[t]:t){let t=n(r);if(t?.major===e)return t}return null}function a(e,t){let r=n(e),a=r&&i(r.major,t);return!r||!a?null:`${r.major}.${Math.min(r.minor,a.minor)}`}function o(e,t=`1.0`){let r=n(e),a=r&&i(r.major,t);return!!r&&!!a&&a.minor>=r.minor}exports.PROTOCOL_VERSION=e,exports.compareProtocolVersions=r,exports.isProtocolSupported=o,exports.negotiateProtocolVersion=a,exports.parseProtocolVersion=n;

package/dist/version.js

@@ -0,0 +1,31 @@
+//#region src/version.ts
+var e = "1.0", t = /^(\d+)\.(\d+)$/;
+function n(e) {
+	let n = t.exec(e);
+	return n ? {
+		major: Number(n[1]),
+		minor: Number(n[2])
+	} : null;
+}
+function r(e, t) {
+	let r = n(e), i = n(t);
+	if (!r || !i) throw Error(`Invalid protocol version: ${r ? t : e}`);
+	return r.major === i.major ? r.minor - i.minor : r.major - i.major;
+}
+function i(e, t) {
+	for (let r of typeof t == "string" ? [t] : t) {
+		let t = n(r);
+		if (t?.major === e) return t;
+	}
+	return null;
+}
+function a(e, t) {
+	let r = n(e), a = r && i(r.major, t);
+	return !r || !a ? null : `${r.major}.${Math.min(r.minor, a.minor)}`;
+}
+function o(e, t = "1.0") {
+	let r = n(e), a = r && i(r.major, t);
+	return !!r && !!a && a.minor >= r.minor;
+}
+//#endregion
+export { e as PROTOCOL_VERSION, r as compareProtocolVersions, o as isProtocolSupported, a as negotiateProtocolVersion, n as parseProtocolVersion };

package/package.json

@@ -1,6 +1,65 @@
 {
   "name": "@memizy/protocol",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0-rc.6",
+  "description": "Memizy Plugin Protocol: types, Zod schemas and helpers shared by @memizy/plugin-sdk and @memizy/host-sdk.",
+  "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"
+    },
+    "./internal": {
+      "types": "./dist/src/internal.d.ts",
+      "import": "./dist/internal.js",
+      "require": "./dist/internal.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "SPEC.md",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc --noEmit && vite build && node ../../scripts/dts-extensions.mjs dist",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@memizy/oqse": "^1.0.0-rc.6",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "typescript": "~6.0.2",
+    "vite": "^8.0.4",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.1.4"
+  },
+  "license": "MIT",
+  "author": "Memizy Team",
+  "keywords": [
+    "memizy",
+    "plugin",
+    "protocol",
+    "oqse",
+    "education"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/memizy/memizy.git",
+    "directory": "packages/protocol"
+  },
+  "bugs": {
+    "url": "https://github.com/memizy/memizy/issues"
+  },
+  "homepage": "https://github.com/memizy/memizy/tree/main/packages/protocol#readme"
+}