@agent-play/sdk 2.0.0 → 3.0.0

package/dist/index.js

@@ -1,6 +1,5 @@
 // src/world-events.ts
 var PLAYER_ADDED_EVENT = "world:player_added";
-var WORLD_STRUCTURES_EVENT = "world:structures";
 var WORLD_INTERACTION_EVENT = "world:interaction";
 var WORLD_AGENT_SIGNAL_EVENT = "world:agent_signal";
 var WORLD_JOURNEY_EVENT = "world:journey";
@@ -131,6 +130,207 @@ function langchainRegistration(agent) {
   };
 }
 
+// src/lib/parse-occupant-row.ts
+function parseAgentOccupantRow(raw) {
+  if (typeof raw.agentId !== "string" || typeof raw.name !== "string") {
+    throw new Error("occupant: agent needs agentId and name");
+  }
+  if (typeof raw.x !== "number" || typeof raw.y !== "number") {
+    throw new Error("occupant: agent needs numeric x and y");
+  }
+  const base = {
+    kind: "agent",
+    agentId: raw.agentId,
+    name: raw.name,
+    x: raw.x,
+    y: raw.y
+  };
+  let platform;
+  if (typeof raw.platform === "string") {
+    platform = raw.platform;
+  } else if (typeof raw.agentType === "string") {
+    platform = raw.agentType;
+  }
+  if (platform !== void 0) {
+    return { ...base, platform };
+  }
+  return base;
+}
+function parseMcpOccupantRow(raw) {
+  if (typeof raw.id !== "string" || typeof raw.name !== "string") {
+    throw new Error("occupant: mcp needs id and name");
+  }
+  if (typeof raw.x !== "number" || typeof raw.y !== "number") {
+    throw new Error("occupant: mcp needs numeric x and y");
+  }
+  const base = {
+    kind: "mcp",
+    id: raw.id,
+    name: raw.name,
+    x: raw.x,
+    y: raw.y
+  };
+  if (typeof raw.url === "string") {
+    return { ...base, url: raw.url };
+  }
+  return base;
+}
+
+// src/lib/world-chain-keys.ts
+var PLAYER_CHAIN_GENESIS_STABLE_KEY = "__genesis__";
+var PLAYER_CHAIN_HEADER_STABLE_KEY = "__header__";
+
+// src/lib/player-chain-merge.ts
+function isRecord(v) {
+  return typeof v === "object" && v !== null;
+}
+function stableOccupantSortKey(occ) {
+  if (occ.kind === "agent") {
+    return `agent:${occ.agentId}`;
+  }
+  return `mcp:${occ.id}`;
+}
+function sortNodeRefsForSerializedFetch(nodes) {
+  const removed = nodes.filter((n) => n.removed === true);
+  const rest = nodes.filter((n) => n.removed !== true);
+  removed.sort((a, b) => b.leafIndex - a.leafIndex);
+  rest.sort((a, b) => a.leafIndex - b.leafIndex);
+  return [...removed, ...rest];
+}
+function parsePlayerChainFanoutNotify(raw) {
+  if (!isRecord(raw)) {
+    return void 0;
+  }
+  if (typeof raw.updatedAt !== "string" || raw.updatedAt.length === 0) {
+    return void 0;
+  }
+  if (!Array.isArray(raw.nodes)) {
+    return void 0;
+  }
+  const nodes = [];
+  for (const row of raw.nodes) {
+    if (!isRecord(row)) {
+      return void 0;
+    }
+    if (typeof row.stableKey !== "string" || row.stableKey.length === 0) {
+      return void 0;
+    }
+    if (typeof row.leafIndex !== "number" || !Number.isFinite(row.leafIndex)) {
+      return void 0;
+    }
+    const ref = {
+      stableKey: row.stableKey,
+      leafIndex: row.leafIndex
+    };
+    if (row.removed === true) {
+      ref.removed = true;
+    }
+    if (typeof row.updatedAt === "string" && row.updatedAt.length > 0) {
+      ref.updatedAt = row.updatedAt;
+    }
+    nodes.push(ref);
+  }
+  return { updatedAt: raw.updatedAt, nodes };
+}
+function parsePlayerChainFanoutNotifyFromSsePayload(sseData) {
+  if (!isRecord(sseData)) {
+    return void 0;
+  }
+  return parsePlayerChainFanoutNotify(sseData.playerChainNotify);
+}
+function parsePlayerChainNodeRpcBody(json) {
+  if (!isRecord(json) || !isRecord(json.node)) {
+    throw new Error("getPlayerChainNode: invalid response shape");
+  }
+  const n = json.node;
+  if (n.kind === "genesis") {
+    if (n.stableKey !== PLAYER_CHAIN_GENESIS_STABLE_KEY || typeof n.text !== "string") {
+      throw new Error("getPlayerChainNode: invalid genesis node");
+    }
+    return {
+      kind: "genesis",
+      stableKey: PLAYER_CHAIN_GENESIS_STABLE_KEY,
+      text: n.text
+    };
+  }
+  if (n.kind === "header") {
+    if (n.stableKey !== PLAYER_CHAIN_HEADER_STABLE_KEY || typeof n.sid !== "string") {
+      throw new Error("getPlayerChainNode: invalid header node");
+    }
+    const b = n.bounds;
+    if (!isRecord(b)) {
+      throw new Error("getPlayerChainNode: invalid header bounds");
+    }
+    const { minX, minY, maxX, maxY } = b;
+    if (typeof minX !== "number" || typeof minY !== "number" || typeof maxX !== "number" || typeof maxY !== "number") {
+      throw new Error("getPlayerChainNode: invalid header bounds");
+    }
+    return {
+      kind: "header",
+      stableKey: PLAYER_CHAIN_HEADER_STABLE_KEY,
+      sid: n.sid,
+      bounds: { minX, minY, maxX, maxY }
+    };
+  }
+  if (n.kind !== "occupant") {
+    throw new Error("getPlayerChainNode: unknown node kind");
+  }
+  if (typeof n.stableKey !== "string" || n.stableKey.length === 0) {
+    throw new Error("getPlayerChainNode: invalid occupant stableKey");
+  }
+  if (n.removed === true) {
+    return { kind: "occupant", stableKey: n.stableKey, removed: true };
+  }
+  const occ = n.occupant;
+  if (!isRecord(occ) || occ.kind !== "agent" && occ.kind !== "mcp") {
+    throw new Error("getPlayerChainNode: invalid occupant payload");
+  }
+  const occupant = occ.kind === "agent" ? parseAgentOccupantRow(occ) : parseMcpOccupantRow(occ);
+  return {
+    kind: "occupant",
+    stableKey: n.stableKey,
+    removed: false,
+    occupant
+  };
+}
+function mergeSnapshotWithPlayerChainNode(snapshot, node) {
+  if (node.kind === "genesis") {
+    return snapshot;
+  }
+  if (node.kind === "header") {
+    return {
+      ...snapshot,
+      sid: node.sid,
+      worldMap: {
+        ...snapshot.worldMap,
+        bounds: node.bounds
+      }
+    };
+  }
+  if (node.removed) {
+    return {
+      ...snapshot,
+      worldMap: {
+        ...snapshot.worldMap,
+        occupants: snapshot.worldMap.occupants.filter(
+          (o) => stableOccupantSortKey(o) !== node.stableKey
+        )
+      }
+    };
+  }
+  const key = stableOccupantSortKey(node.occupant);
+  const occupants = snapshot.worldMap.occupants.filter(
+    (o) => stableOccupantSortKey(o) !== key
+  );
+  return {
+    ...snapshot,
+    worldMap: {
+      ...snapshot.worldMap,
+      occupants: [...occupants, node.occupant]
+    }
+  };
+}
+
 // src/lib/remote-play-world.ts
 function formatMissingApiKeyError() {
   return [
@@ -144,43 +344,104 @@ function formatMissingApiKeyError() {
 function normalizeBaseUrl(url) {
   return url.replace(/\/$/, "");
 }
-function isRecord(v) {
+function isRecord2(v) {
   return typeof v === "object" && v !== null;
 }
-var STRUCTURE_KINDS = [
-  "home",
-  "tool",
-  "api",
-  "database",
-  "model"
-];
-function isWorldStructureKind(s) {
-  return STRUCTURE_KINDS.includes(s);
+function parseBounds(raw) {
+  if (!isRecord2(raw)) {
+    throw new Error("getWorldSnapshot: worldMap.bounds must be an object");
+  }
+  const { minX, minY, maxX, maxY } = raw;
+  if (typeof minX !== "number" || typeof minY !== "number" || typeof maxX !== "number" || typeof maxY !== "number") {
+    throw new Error(
+      "getWorldSnapshot: bounds need numeric minX, minY, maxX, maxY"
+    );
+  }
+  return { minX, minY, maxX, maxY };
 }
-function parseWorldStructure(x) {
-  if (!isRecord(x)) return null;
-  if (typeof x.id !== "string" || typeof x.kind !== "string") return null;
-  if (!isWorldStructureKind(x.kind)) return null;
-  if (typeof x.x !== "number" || typeof x.y !== "number") return null;
-  const out = {
-    id: x.id,
-    kind: x.kind,
-    x: x.x,
-    y: x.y
-  };
-  if (typeof x.toolName === "string") out.toolName = x.toolName;
-  if (typeof x.label === "string") out.label = x.label;
-  return out;
+function parseWorldMap(raw) {
+  if (!isRecord2(raw)) {
+    throw new Error("getWorldSnapshot: worldMap must be an object");
+  }
+  const bounds = parseBounds(raw.bounds);
+  const occ = raw.occupants;
+  if (!Array.isArray(occ)) {
+    throw new Error("getWorldSnapshot: worldMap.occupants must be an array");
+  }
+  const occupants = [];
+  const coordKeys = /* @__PURE__ */ new Set();
+  for (const row of occ) {
+    if (!isRecord2(row) || row.kind !== "agent" && row.kind !== "mcp") {
+      throw new Error("getWorldSnapshot: each occupant must have kind agent or mcp");
+    }
+    const xy = typeof row.x === "number" && typeof row.y === "number" ? `${row.x},${row.y}` : "";
+    if (xy.length === 0) {
+      throw new Error("getWorldSnapshot: occupant missing coordinates");
+    }
+    if (coordKeys.has(xy)) {
+      throw new Error("getWorldSnapshot: duplicate world map coordinate");
+    }
+    coordKeys.add(xy);
+    if (row.kind === "agent") {
+      occupants.push(parseAgentOccupantRow(row));
+    } else {
+      occupants.push(parseMcpOccupantRow(row));
+    }
+  }
+  return { bounds, occupants };
 }
-function parseStructures(v) {
-  if (!Array.isArray(v)) return [];
-  const out = [];
-  for (const x of v) {
-    const row = parseWorldStructure(x);
-    if (row !== null) out.push(row);
+function parseAgentPlaySnapshot(snapshot) {
+  if (!isRecord2(snapshot) || typeof snapshot.sid !== "string") {
+    throw new Error("getWorldSnapshot: invalid snapshot");
+  }
+  const worldMap = parseWorldMap(snapshot.worldMap);
+  const out = { sid: snapshot.sid, worldMap };
+  if ("mcpServers" in snapshot && Array.isArray(snapshot.mcpServers)) {
+    const servers = [];
+    for (const m of snapshot.mcpServers) {
+      if (!isRecord2(m) || typeof m.id !== "string" || typeof m.name !== "string") {
+        continue;
+      }
+      const row = {
+        id: m.id,
+        name: m.name
+      };
+      if (typeof m.url === "string") row.url = m.url;
+      servers.push(row);
+    }
+    if (servers.length > 0) out.mcpServers = servers;
   }
   return out;
 }
+function parseRegisteredAgentSummary(raw) {
+  if (!isRecord2(raw)) {
+    throw new Error("addPlayer: registeredAgent missing");
+  }
+  if (typeof raw.agentId !== "string" || typeof raw.name !== "string") {
+    throw new Error("addPlayer: registeredAgent.agentId and name required");
+  }
+  if (!Array.isArray(raw.toolNames)) {
+    throw new Error("addPlayer: registeredAgent.toolNames must be an array");
+  }
+  const toolNames = [];
+  for (const t of raw.toolNames) {
+    if (typeof t !== "string") {
+      throw new Error("addPlayer: registeredAgent.toolNames must be strings");
+    }
+    toolNames.push(t);
+  }
+  if (typeof raw.zoneCount !== "number" || typeof raw.yieldCount !== "number" || typeof raw.flagged !== "boolean") {
+    throw new Error("addPlayer: registeredAgent counters invalid");
+  }
+  return {
+    agentId: raw.agentId,
+    name: raw.name,
+    toolNames,
+    zoneCount: raw.zoneCount,
+    yieldCount: raw.yieldCount,
+    flagged: raw.flagged
+  };
+}
 function formatInvalidHoldSecondsError() {
   return [
     "RemotePlayWorld.hold().for(seconds): seconds must be a finite number.",
@@ -189,24 +450,12 @@ function formatInvalidHoldSecondsError() {
   ].join("\n");
 }
 var RemotePlayWorld = class {
-  /** Normalized {@link RemotePlayWorldOptions.baseUrl} (no trailing slash). Used for `fetch` base. */
   apiBase;
-  /** Trimmed account API key; sent on `addPlayer` and implied for RPC auth expectations. */
   apiKey;
-  /** Optional bearer token merged into request headers when set. */
   authToken;
-  /** Session id from `GET /api/agent-play/session`; `null` until {@link RemotePlayWorld.start} succeeds. */
   sid = null;
-  /** When true, {@link RemotePlayWorld.close} is a no-op and listeners already ran. */
   closed = false;
-  /** Unsubscribe callbacks registered via {@link RemotePlayWorld.onClose}. */
   closeListeners = /* @__PURE__ */ new Set();
-  /**
-   * @param options - Base URL, API key, and optional auth token.
-   * @throws Error if `apiKey` is missing or whitespace-only (see {@link formatMissingApiKeyError}).
-   *
-   * @remarks **Callees:** {@link formatMissingApiKeyError}, {@link normalizeBaseUrl}.
-   */
   constructor(options) {
     if (typeof options.apiKey !== "string" || options.apiKey.trim().length === 0) {
       throw new Error(formatMissingApiKeyError());
@@ -215,25 +464,12 @@ var RemotePlayWorld = class {
     this.apiKey = options.apiKey.trim();
     this.authToken = options.authToken;
   }
-  /**
-   * Registers a one-shot listener invoked when {@link RemotePlayWorld.close} runs (e.g. process shutdown).
-   *
-   * @param handler - Synchronous callback; errors are swallowed.
-   * @returns Unsubscribe function that removes this `handler` from the set.
-   *
-   * @remarks **Callers:** user code. **Callees:** `Set.prototype.add` / `delete`.
-   */
   onClose(handler) {
     this.closeListeners.add(handler);
     return () => {
       this.closeListeners.delete(handler);
     };
   }
-  /**
-   * Returns a helper that sleeps for wall-clock seconds (useful for `await world.hold().for(3600)`).
-   *
-   * @remarks **Callers:** user code. **Callees:** {@link formatInvalidHoldSecondsError}.
-   */
   hold() {
     return {
       for: async (seconds) => {
@@ -247,38 +483,25 @@ var RemotePlayWorld = class {
       }
     };
   }
-  /**
-   * Authorization header map for requests that only need session cookie or bearer auth.
-   *
-   * @internal
-   * @remarks **Callers:** {@link RemotePlayWorld.start}, {@link RemotePlayWorld.addPlayer} (via headers),
-   * {@link RemotePlayWorld.registerMcp}, and any future GET-only calls.
-   */
   authHeaders() {
     if (this.authToken === void 0) return {};
     return { Authorization: `Bearer ${this.authToken}` };
   }
-  /**
-   * Headers for JSON `POST` bodies (RPC, players, MCP).
-   *
-   * @internal
-   * @remarks **Callers:** {@link RemotePlayWorld.addPlayer}, {@link RemotePlayWorld.rpc}, {@link RemotePlayWorld.registerMcp}.
-   * **Callees:** {@link authHeaders}.
-   */
   jsonHeaders() {
     return {
       "content-type": "application/json",
       ...this.authHeaders()
     };
   }
-  /**
-   * Creates a session and stores `sid` from `GET /api/agent-play/session`.
-   *
-   * @throws Error if the response is not OK or JSON lacks a non-empty `sid` string.
-   *
-   * @remarks **Callers:** user code. **Callees:** `fetch`, {@link isRecord}.
-   */
-  async start() {
+  mergeAuthFetch(input, init) {
+    const headers = new Headers(init?.headers);
+    const auth = this.authHeaders();
+    for (const [k, v] of Object.entries(auth)) {
+      headers.set(k, v);
+    }
+    return fetch(input, { ...init, headers });
+  }
+  async connect() {
     const res = await fetch(`${this.apiBase}/api/agent-play/session`, {
       headers: this.authHeaders()
     });
@@ -286,16 +509,11 @@ var RemotePlayWorld = class {
       throw new Error(`session failed: ${res.status}`);
     }
     const json = await res.json();
-    if (!isRecord(json) || typeof json.sid !== "string" || json.sid.length === 0) {
+    if (!isRecord2(json) || typeof json.sid !== "string" || json.sid.length === 0) {
       throw new Error("session: invalid response");
     }
     this.sid = json.sid;
   }
-  /**
-   * Marks the client closed and invokes all {@link onClose} listeners once.
-   *
-   * @remarks **Callers:** user code. **Callees:** `Array.from` over {@link closeListeners}.
-   */
   async close() {
     if (this.closed) {
       return;
@@ -308,38 +526,119 @@ var RemotePlayWorld = class {
       }
     }
   }
-  /**
-   * @returns Current session id.
-   * @throws Error if {@link RemotePlayWorld.start} has not been called successfully.
-   *
-   * @remarks **Callers:** user code. **Callees:** none.
-   */
   getSessionId() {
     if (this.sid === null) {
-      throw new Error("RemotePlayWorld.start() must be called first");
+      throw new Error("RemotePlayWorld.connect() must be called first");
     }
     return this.sid;
   }
-  /**
-   * @returns Absolute watch URL for the session (`/agent-play/watch` on `apiBase`). Query `sid` is not appended;
-   * consumers append `?sid=` from {@link getSessionId} when needed.
-   *
-   * @remarks **Callers:** user code. **Callees:** `URL` constructor.
-   */
   getPreviewUrl() {
     const u = new URL("/agent-play/watch", this.apiBase);
     u.search = "";
     return u.toString();
   }
+  async getWorldSnapshot() {
+    const res = await fetch(`${this.apiBase}/api/agent-play/sdk/rpc`, {
+      method: "POST",
+      headers: this.jsonHeaders(),
+      body: JSON.stringify({ op: "getWorldSnapshot", payload: {} })
+    });
+    const text = await res.text();
+    if (!res.ok) {
+      throw new Error(`getWorldSnapshot: ${res.status} ${text}`);
+    }
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch {
+      throw new Error("getWorldSnapshot: invalid JSON");
+    }
+    if (!isRecord2(json) || !("snapshot" in json)) {
+      throw new Error("getWorldSnapshot: invalid response shape");
+    }
+    return parseAgentPlaySnapshot(json.snapshot);
+  }
+  /**
+   * Fetches one player-chain node (genesis, header, occupant row, or removal) for `stableKey`, same snapshot scope as {@link RemotePlayWorld.getWorldSnapshot}.
+   */
+  async getPlayerChainNode(stableKey) {
+    const trimmed = stableKey.trim();
+    if (trimmed.length === 0) {
+      throw new Error("getPlayerChainNode: stableKey is required");
+    }
+    const res = await fetch(`${this.apiBase}/api/agent-play/sdk/rpc`, {
+      method: "POST",
+      headers: this.jsonHeaders(),
+      body: JSON.stringify({
+        op: "getPlayerChainNode",
+        payload: { stableKey: trimmed }
+      })
+    });
+    const text = await res.text();
+    if (!res.ok) {
+      throw new Error(`getPlayerChainNode: ${res.status} ${text}`);
+    }
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch {
+      throw new Error("getPlayerChainNode: invalid JSON");
+    }
+    return parsePlayerChainNodeRpcBody(json);
+  }
   /**
-   * Registers a player agent with the server for the current session.
-   *
-   * @param input - Name, type, `agent` registration from {@link langchainRegistration}, optional `agentId`.
-   * @returns Resolved player row with `previewUrl` and `structures`.
-   * @throws Error on HTTP errors or malformed JSON.
-   *
-   * @remarks **Callers:** user code. **Callees:** {@link getSessionId}, `fetch`, `JSON.parse`, {@link parseStructures}.
+   * Opens the session SSE stream, emits an initial snapshot from {@link RemotePlayWorld.getWorldSnapshot}, then on each **`playerChainNotify`** merges nodes in deterministic order via {@link RemotePlayWorld.getPlayerChainNode}.
    */
+  subscribeWorldState(callbacks) {
+    let closeSource = null;
+    const task = (async () => {
+      try {
+        const { createEventSource } = await import("eventsource-client");
+        let snapshot = await this.getWorldSnapshot();
+        callbacks.onSnapshot(snapshot);
+        const source = createEventSource({
+          url: `${this.apiBase}/api/agent-play/events?sid=${encodeURIComponent(
+            this.getSessionId()
+          )}`,
+          fetch: (input, init) => this.mergeAuthFetch(input, init)
+        });
+        closeSource = () => {
+          source.close();
+        };
+        for await (const msg of source) {
+          if (typeof msg.data !== "string") {
+            continue;
+          }
+          let data;
+          try {
+            data = JSON.parse(msg.data);
+          } catch {
+            continue;
+          }
+          const notify = parsePlayerChainFanoutNotifyFromSsePayload(data);
+          if (notify === void 0 || notify.nodes.length === 0) {
+            continue;
+          }
+          const ordered = sortNodeRefsForSerializedFetch(notify.nodes);
+          for (const ref of ordered) {
+            const node = await this.getPlayerChainNode(ref.stableKey);
+            snapshot = mergeSnapshotWithPlayerChainNode(snapshot, node);
+          }
+          callbacks.onSnapshot(snapshot);
+        }
+      } catch (e) {
+        callbacks.onError?.(
+          e instanceof Error ? e : new Error(String(e))
+        );
+      }
+    })();
+    return {
+      close: () => {
+        closeSource?.();
+        void task;
+      }
+    };
+  }
   async addPlayer(input) {
     const sid = this.getSessionId();
     const url = `${this.apiBase}/api/agent-play/players?sid=${encodeURIComponent(sid)}`;
@@ -358,21 +657,21 @@ var RemotePlayWorld = class {
     if (!res.ok) {
       throw new Error(`addPlayer: ${res.status} ${bodyText}`);
     }
-    let json;
+    let body;
     try {
-      json = JSON.parse(bodyText);
+      body = JSON.parse(bodyText);
     } catch {
       throw new Error("addPlayer: invalid JSON");
     }
-    if (!isRecord(json)) {
+    if (!isRecord2(body)) {
       throw new Error("addPlayer: invalid response shape");
     }
-    const playerId = json.playerId;
-    const previewUrl = json.previewUrl;
+    const playerId = body.playerId;
+    const previewUrl = body.previewUrl;
     if (typeof playerId !== "string" || typeof previewUrl !== "string") {
       throw new Error("addPlayer: missing playerId or previewUrl");
     }
-    const structures = parseStructures(json.structures);
+    const registeredAgent = parseRegisteredAgentSummary(body.registeredAgent);
     const now = /* @__PURE__ */ new Date();
     return {
       id: playerId,
@@ -381,14 +680,9 @@ var RemotePlayWorld = class {
       createdAt: now,
       updatedAt: now,
       previewUrl,
-      structures
+      registeredAgent
     };
   }
-  /**
-   * Appends a chat-style interaction line for a player (RPC `recordInteraction`).
-   *
-   * @remarks **Callers:** user code. **Callees:** {@link rpc}.
-   */
   async recordInteraction(input) {
     await this.rpc("recordInteraction", {
       playerId: input.playerId,
@@ -396,29 +690,9 @@ var RemotePlayWorld = class {
       text: input.text
     });
   }
-  /**
-   * Records a full journey for a player (RPC `recordJourney`).
-   *
-   * @remarks **Callers:** user code. **Callees:** {@link rpc}.
-   */
   async recordJourney(playerId, journey) {
     await this.rpc("recordJourney", { playerId, journey });
   }
-  /**
-   * Re-syncs layout structures from an ordered tool name list (RPC `syncPlayerStructuresFromTools`).
-   *
-   * @remarks **Callers:** user code. **Callees:** {@link rpc}.
-   */
-  async syncPlayerStructuresFromTools(playerId, toolNames) {
-    await this.rpc("syncPlayerStructuresFromTools", { playerId, toolNames });
-  }
-  /**
-   * Registers an MCP server metadata row for the session (HTTP POST, not the same as RPC `op`).
-   *
-   * @returns New registration id string from JSON `{ id }`.
-   *
-   * @remarks **Callers:** user code. **Callees:** `fetch`, {@link getSessionId}, {@link jsonHeaders}.
-   */
   async registerMcp(options) {
     const sid = this.getSessionId();
     const url = `${this.apiBase}/api/agent-play/mcp/register?sid=${encodeURIComponent(sid)}`;
@@ -441,18 +715,11 @@ var RemotePlayWorld = class {
     } catch {
       throw new Error("registerMcp: invalid JSON");
     }
-    if (!isRecord(json) || typeof json.id !== "string") {
+    if (!isRecord2(json) || typeof json.id !== "string") {
       throw new Error("registerMcp: invalid response");
     }
     return json.id;
   }
-  /**
-   * Posts `{ op, payload }` to `/api/agent-play/sdk/rpc?sid=...`.
-   *
-   * @internal
-   * @remarks **Callers:** {@link recordInteraction}, {@link recordJourney}, {@link syncPlayerStructuresFromTools}.
-   * **Callees:** {@link getSessionId}, `fetch`, {@link jsonHeaders}.
-   */
   async rpc(op, payload) {
     const sid = this.getSessionId();
     const url = `${this.apiBase}/api/agent-play/sdk/rpc?sid=${encodeURIComponent(sid)}`;
@@ -469,17 +736,23 @@ var RemotePlayWorld = class {
 };
 export {
   PLAYER_ADDED_EVENT,
+  PLAYER_CHAIN_GENESIS_STABLE_KEY,
+  PLAYER_CHAIN_HEADER_STABLE_KEY,
   RemotePlayWorld,
   WORLD_AGENT_SIGNAL_EVENT,
   WORLD_INTERACTION_EVENT,
   WORLD_JOURNEY_EVENT,
-  WORLD_STRUCTURES_EVENT,
   agentPlayDebug,
   boundsContain,
   clampWorldPosition,
   configureAgentPlayDebug,
   isAgentPlayDebugEnabled,
   langchainRegistration,
-  resetAgentPlayDebug
+  mergeSnapshotWithPlayerChainNode,
+  parsePlayerChainFanoutNotify,
+  parsePlayerChainFanoutNotifyFromSsePayload,
+  parsePlayerChainNodeRpcBody,
+  resetAgentPlayDebug,
+  sortNodeRefsForSerializedFetch
 };
 //# sourceMappingURL=index.js.map