@agent-play/sdk 3.2.2 → 3.3.2

package/dist/chunk-WWIEHWZZ.js

@@ -0,0 +1,649 @@
+// src/lib/world-bounds.ts
+var MINIMUM_PLAY_WORLD_BOUNDS = {
+  minX: 0,
+  minY: 0,
+  maxX: 19,
+  maxY: 19
+};
+function expandBoundsToMinimumPlayArea(bounds) {
+  return {
+    minX: Math.min(bounds.minX, MINIMUM_PLAY_WORLD_BOUNDS.minX),
+    minY: Math.min(bounds.minY, MINIMUM_PLAY_WORLD_BOUNDS.minY),
+    maxX: Math.max(bounds.maxX, MINIMUM_PLAY_WORLD_BOUNDS.maxX),
+    maxY: Math.max(bounds.maxY, MINIMUM_PLAY_WORLD_BOUNDS.maxY)
+  };
+}
+function clampWorldPosition(p, bounds) {
+  return {
+    x: Math.min(Math.max(p.x, bounds.minX), bounds.maxX),
+    y: Math.min(Math.max(p.y, bounds.minY), bounds.maxY)
+  };
+}
+function boundsContain(bounds, p) {
+  return p.x >= bounds.minX && p.x <= bounds.maxX && p.y >= bounds.minY && p.y <= bounds.maxY;
+}
+
+// src/lib/occupancy-grid-model.ts
+var OCCUPANCY_POINT_MULTIPLIER = 5;
+var CONTINUOUS_RENDER_OFFSET = 0.2;
+var DEFAULT_AGENT_SPAWN_MIN_DISTANCE = 0.9;
+var SPATIAL_ZONE_INDEX_AGENTS = 0;
+var SPATIAL_ZONE_INDEX_SPACES = 2;
+function spatialZoneBounds(quartileIndex) {
+  const { minX, maxX, minY, maxY } = MINIMUM_PLAY_WORLD_BOUNDS;
+  const spanX = maxX - minX + 1;
+  const spanY = maxY - minY + 1;
+  const halfX = spanX / 2;
+  const halfY = spanY / 2;
+  const midLeftMax = minX + halfX - 1;
+  const midRightMin = minX + halfX;
+  const midBottomMax = minY + halfY - 1;
+  const midTopMin = minY + halfY;
+  switch (quartileIndex) {
+    case 0:
+      return { minX, maxX: midLeftMax, minY, maxY: midBottomMax };
+    case 1:
+      return { minX: midRightMin, maxX, minY, maxY: midBottomMax };
+    case 2:
+      return { minX, maxX: midLeftMax, minY: midTopMin, maxY };
+    case 3:
+      return { minX: midRightMin, maxX, minY: midTopMin, maxY };
+    default:
+      throw new Error(
+        `spatialZoneBounds: invalid zone index ${String(quartileIndex)}`
+      );
+  }
+}
+function spatialZoneCenter(quartileIndex) {
+  const b = spatialZoneBounds(quartileIndex);
+  return {
+    x: (b.minX + b.maxX + 1) / 2,
+    y: (b.minY + b.maxY + 1) / 2
+  };
+}
+function enumerateIntegerCellsInBounds(bounds) {
+  const cells = [];
+  for (let x = bounds.minX; x <= bounds.maxX; x += 1) {
+    for (let y = bounds.minY; y <= bounds.maxY; y += 1) {
+      cells.push({ x, y });
+    }
+  }
+  return cells;
+}
+function pointCellInSpatialZone(wx, wy, zoneIndex) {
+  const bounds = spatialZoneBounds(zoneIndex);
+  const cx = Math.floor(wx);
+  const cy = Math.floor(wy);
+  return cx >= bounds.minX && cx <= bounds.maxX && cy >= bounds.minY && cy <= bounds.maxY;
+}
+function listOccupancyPointsForSpatialZone(zoneIndex) {
+  const bounds = spatialZoneBounds(zoneIndex);
+  return enumerateIntegerCellsInBounds(bounds).flatMap((cell) => {
+    const points = [];
+    for (let dx = 0; dx < OCCUPANCY_POINT_MULTIPLIER; dx += 1) {
+      for (let dy = 0; dy < OCCUPANCY_POINT_MULTIPLIER; dy += 1) {
+        points.push({
+          x: cell.x + CONTINUOUS_RENDER_OFFSET + (dx + 0.5) / OCCUPANCY_POINT_MULTIPLIER,
+          y: cell.y + CONTINUOUS_RENDER_OFFSET + (dy + 0.5) / OCCUPANCY_POINT_MULTIPLIER
+        });
+      }
+    }
+    return points;
+  });
+}
+function occupancyPointsGroupedBySpatialZone() {
+  return [
+    listOccupancyPointsForSpatialZone(0),
+    listOccupancyPointsForSpatialZone(1),
+    listOccupancyPointsForSpatialZone(2),
+    listOccupancyPointsForSpatialZone(3)
+  ];
+}
+function listAllowedOccupancyPoints() {
+  return listOccupancyPointsForSpatialZone(SPATIAL_ZONE_INDEX_AGENTS);
+}
+function quantizePosition(v) {
+  return Math.round(v * OCCUPANCY_POINT_MULTIPLIER) / OCCUPANCY_POINT_MULTIPLIER;
+}
+function occupancyKeyForPosition(x, y) {
+  return `${quantizePosition(x).toFixed(3)},${quantizePosition(y).toFixed(3)}`;
+}
+function buildRankedOccupancyPointsForSpatialZone(zoneIndex) {
+  const center = spatialZoneCenter(zoneIndex);
+  return [...listOccupancyPointsForSpatialZone(zoneIndex)].sort((left, right) => {
+    const dl = Math.hypot(left.x - center.x, left.y - center.y);
+    const dr = Math.hypot(right.x - center.x, right.y - center.y);
+    if (dl !== dr) {
+      return dl - dr;
+    }
+    if (left.x !== right.x) {
+      return left.x - right.x;
+    }
+    return left.y - right.y;
+  });
+}
+function buildRankedOccupancyPoints() {
+  return buildRankedOccupancyPointsForSpatialZone(SPATIAL_ZONE_INDEX_AGENTS);
+}
+function boundingWorldRectForOccupancyPoints(points) {
+  const head = points[0];
+  if (head === void 0) {
+    return null;
+  }
+  let minX = head.x;
+  let maxX = head.x;
+  let minY = head.y;
+  let maxY = head.y;
+  for (const p of points) {
+    if (p.x < minX) minX = p.x;
+    if (p.x > maxX) maxX = p.x;
+    if (p.y < minY) minY = p.y;
+    if (p.y > maxY) maxY = p.y;
+  }
+  return { minX, maxX, minY, maxY };
+}
+function isAgentSpawnOccupancyPointAvailable(input) {
+  const minDistance = input.minDistance ?? DEFAULT_AGENT_SPAWN_MIN_DISTANCE;
+  const key = occupancyKeyForPosition(input.point.x, input.point.y);
+  if (input.occupiedKeys.has(key)) {
+    return false;
+  }
+  if (!pointCellInSpatialZone(
+    input.point.x,
+    input.point.y,
+    SPATIAL_ZONE_INDEX_AGENTS
+  )) {
+    return false;
+  }
+  for (const existing of input.existingOccupants) {
+    const dist = Math.hypot(
+      input.point.x - existing.x,
+      input.point.y - existing.y
+    );
+    if (dist < minDistance) {
+      return false;
+    }
+  }
+  return true;
+}
+function isSpaceAnchorOccupancyPointAvailable(input) {
+  const key = occupancyKeyForPosition(input.point.x, input.point.y);
+  if (input.occupiedKeys.has(key)) {
+    return false;
+  }
+  if (!pointCellInSpatialZone(
+    input.point.x,
+    input.point.y,
+    SPATIAL_ZONE_INDEX_SPACES
+  )) {
+    return false;
+  }
+  for (const existing of input.existingOccupants) {
+    const dist = Math.hypot(
+      input.point.x - existing.x,
+      input.point.y - existing.y
+    );
+    if (dist < input.minDistance) {
+      return false;
+    }
+  }
+  for (const anchor of input.structureAnchors) {
+    const dist = Math.hypot(
+      input.point.x - anchor.x,
+      input.point.y - anchor.y
+    );
+    if (dist < input.structureMinDistance) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/lib/world-chain-keys.ts
+var PLAYER_CHAIN_GENESIS_STABLE_KEY = "__genesis__";
+var PLAYER_CHAIN_HEADER_STABLE_KEY = "__header__";
+
+// src/lib/parse-occupant-row.ts
+var SPACE_AMENITY_KINDS = [
+  "supermarket",
+  "shop",
+  "car_wash"
+];
+function isSpaceAmenityKind(v) {
+  return SPACE_AMENITY_KINDS.includes(v);
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null;
+}
+function parseHumanOccupantRow(raw) {
+  if (typeof raw.id !== "string" || typeof raw.name !== "string") {
+    throw new Error("occupant: human needs id and name");
+  }
+  if (typeof raw.x !== "number" || typeof raw.y !== "number") {
+    throw new Error("occupant: human needs numeric x and y");
+  }
+  const base = {
+    kind: "human",
+    id: raw.id,
+    name: raw.name,
+    x: raw.x,
+    y: raw.y
+  };
+  if (typeof raw.interactive === "boolean") {
+    return { ...base, interactive: raw.interactive };
+  }
+  return base;
+}
+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
+  };
+  if (typeof raw.nodeId === "string" && raw.nodeId.length > 0) {
+    base.nodeId = raw.nodeId;
+  }
+  let platform;
+  if (typeof raw.platform === "string") {
+    platform = raw.platform;
+  } else if (typeof raw.agentType === "string") {
+    platform = raw.agentType;
+  }
+  const enableP2a = raw.enableP2a === "on" || raw.enableP2a === "off" ? raw.enableP2a : void 0;
+  const realtimeInstructions = typeof raw.realtimeInstructions === "string" && raw.realtimeInstructions.trim().length > 0 ? raw.realtimeInstructions : void 0;
+  const realtimeRaw = raw.realtimeWebrtc;
+  const realtimeWebrtc = typeof realtimeRaw === "object" && realtimeRaw !== null && typeof realtimeRaw.clientSecret === "string" && realtimeRaw.clientSecret.length > 0 && typeof realtimeRaw.model === "string" && realtimeRaw.model.length > 0 ? (() => {
+    const record = realtimeRaw;
+    const parsed = {
+      clientSecret: record.clientSecret,
+      model: record.model
+    };
+    if (typeof record.expiresAt === "string" && record.expiresAt.length > 0) {
+      parsed.expiresAt = record.expiresAt;
+    }
+    if (typeof record.voice === "string" && record.voice.length > 0) {
+      parsed.voice = record.voice;
+    }
+    return parsed;
+  })() : void 0;
+  const out = { ...base };
+  if (platform !== void 0) {
+    out.platform = platform;
+  }
+  if (enableP2a !== void 0) {
+    out.enableP2a = enableP2a;
+  }
+  if (realtimeInstructions !== void 0) {
+    out.realtimeInstructions = realtimeInstructions;
+  }
+  if (realtimeWebrtc !== void 0) {
+    out.realtimeWebrtc = realtimeWebrtc;
+  }
+  return out;
+}
+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;
+}
+function parseSpaceCatalogEntry(raw) {
+  if (typeof raw.id !== "string" || typeof raw.name !== "string") {
+    throw new Error("space catalog: id and name required");
+  }
+  if (typeof raw.description !== "string") {
+    throw new Error("space catalog: description required");
+  }
+  if (typeof raw.designKey !== "string") {
+    throw new Error("space catalog: designKey required");
+  }
+  const ownerRaw = raw.owner;
+  if (!isRecord(ownerRaw) || typeof ownerRaw.displayName !== "string") {
+    throw new Error("space catalog: owner.displayName required");
+  }
+  const amenitiesRaw = raw.amenities;
+  if (!Array.isArray(amenitiesRaw) || amenitiesRaw.length === 0) {
+    throw new Error("space catalog: amenities must be a non-empty array");
+  }
+  const amenities = [];
+  for (const a of amenitiesRaw) {
+    if (typeof a !== "string" || !isSpaceAmenityKind(a)) {
+      throw new Error("space catalog: invalid amenity");
+    }
+    amenities.push(a);
+  }
+  const owner = {
+    displayName: ownerRaw.displayName
+  };
+  if (typeof ownerRaw.playerId === "string" && ownerRaw.playerId.length > 0) {
+    owner.playerId = ownerRaw.playerId;
+  }
+  if (typeof ownerRaw.nodeId === "string" && ownerRaw.nodeId.length > 0) {
+    owner.nodeId = ownerRaw.nodeId;
+  }
+  const entry = {
+    id: raw.id,
+    name: raw.name,
+    description: raw.description,
+    designKey: raw.designKey,
+    owner,
+    amenities
+  };
+  if (Array.isArray(raw.activityObjectIds)) {
+    const ids = [];
+    for (const x of raw.activityObjectIds) {
+      if (typeof x === "string") {
+        ids.push(x);
+      }
+    }
+    if (ids.length > 0) {
+      entry.activityObjectIds = ids;
+    }
+  }
+  return entry;
+}
+function parseStructureOccupantRow(raw) {
+  if (typeof raw.id !== "string" || typeof raw.name !== "string") {
+    throw new Error("occupant: structure needs id and name");
+  }
+  if (typeof raw.x !== "number" || typeof raw.y !== "number") {
+    throw new Error("occupant: structure needs numeric x and y");
+  }
+  if (typeof raw.worldId !== "string") {
+    throw new Error("occupant: structure needs worldId");
+  }
+  const spaceIdsRaw = raw.spaceIds;
+  if (!Array.isArray(spaceIdsRaw) || spaceIdsRaw.length === 0) {
+    throw new Error("occupant: structure needs non-empty spaceIds");
+  }
+  const spaceIds = [];
+  for (const s of spaceIdsRaw) {
+    if (typeof s !== "string") {
+      throw new Error("occupant: structure spaceIds must be strings");
+    }
+    spaceIds.push(s);
+  }
+  const base = {
+    kind: "structure",
+    id: raw.id,
+    name: raw.name,
+    x: raw.x,
+    y: raw.y,
+    worldId: raw.worldId,
+    spaceIds
+  };
+  if (raw.stationary === true) {
+    base.stationary = true;
+  }
+  const pa = raw.primaryAmenity;
+  if (typeof pa === "string" && isSpaceAmenityKind(pa)) {
+    base.primaryAmenity = pa;
+  }
+  const am = raw.amenities;
+  if (Array.isArray(am) && am.length > 0) {
+    const list = [];
+    for (const x of am) {
+      if (typeof x === "string" && isSpaceAmenityKind(x)) {
+        list.push(x);
+      }
+    }
+    if (list.length > 0) {
+      base.amenities = list;
+    }
+  }
+  return base;
+}
+
+// src/lib/player-chain-merge.ts
+function isRecord2(v) {
+  return typeof v === "object" && v !== null;
+}
+function stableOccupantSortKey(occ) {
+  if (occ.kind === "human") {
+    return `human:${occ.id}`;
+  }
+  if (occ.kind === "agent") {
+    const nodeId = occ.nodeId;
+    if (typeof nodeId !== "string" || nodeId.length === 0) {
+      throw new Error("stableOccupantSortKey: invalid agent nodeId");
+    }
+    return `agent:${nodeId}:${occ.agentId}`;
+  }
+  if (occ.kind === "structure") {
+    return `structure:${occ.id}`;
+  }
+  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 (!isRecord2(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 (!isRecord2(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 (!isRecord2(sseData)) {
+    return void 0;
+  }
+  return parsePlayerChainFanoutNotify(sseData.playerChainNotify);
+}
+function parsePlayerChainNodeRpcBody(json) {
+  if (!isRecord2(json) || !isRecord2(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 (!isRecord2(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 === "space") {
+    if (typeof n.stableKey !== "string" || n.stableKey.length === 0) {
+      throw new Error("getPlayerChainNode: invalid space stableKey");
+    }
+    if (n.removed === true) {
+      return { kind: "space", stableKey: n.stableKey, removed: true };
+    }
+    const sp = n.space;
+    if (!isRecord2(sp)) {
+      throw new Error("getPlayerChainNode: invalid space payload");
+    }
+    return {
+      kind: "space",
+      stableKey: n.stableKey,
+      removed: false,
+      space: parseSpaceCatalogEntry(sp)
+    };
+  }
+  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 (!isRecord2(occ) || occ.kind !== "human" && occ.kind !== "agent" && occ.kind !== "mcp" && occ.kind !== "structure") {
+    throw new Error("getPlayerChainNode: invalid occupant payload");
+  }
+  const occupant = occ.kind === "human" ? parseHumanOccupantRow(occ) : occ.kind === "agent" ? parseAgentOccupantRow(occ) : occ.kind === "mcp" ? parseMcpOccupantRow(occ) : parseStructureOccupantRow(occ);
+  return {
+    kind: "occupant",
+    stableKey: n.stableKey,
+    removed: false,
+    occupant
+  };
+}
+function mergeSnapshotWithPlayerChainNode(snapshot, node) {
+  if (node.kind === "genesis") {
+    return snapshot;
+  }
+  if (node.kind === "space") {
+    const spaceIdFromKey = node.stableKey.startsWith("space:") ? node.stableKey.slice("space:".length) : "";
+    if (node.removed === true) {
+      return {
+        ...snapshot,
+        spaces: (snapshot.spaces ?? []).filter((s) => s.id !== spaceIdFromKey)
+      };
+    }
+    const merged = (snapshot.spaces ?? []).filter((s) => s.id !== node.space.id);
+    merged.push(node.space);
+    merged.sort((a, b) => a.id.localeCompare(b.id));
+    return { ...snapshot, spaces: merged };
+  }
+  if (node.kind === "header") {
+    return {
+      ...snapshot,
+      sid: node.sid,
+      worldMap: {
+        ...snapshot.worldMap,
+        bounds: node.bounds
+      }
+    };
+  }
+  if (node.removed === true) {
+    return {
+      ...snapshot,
+      worldMap: {
+        ...snapshot.worldMap,
+        occupants: snapshot.worldMap.occupants.filter(
+          (o) => stableOccupantSortKey(o) !== node.stableKey
+        )
+      }
+    };
+  }
+  if (node.removed !== false) {
+    throw new Error("mergeSnapshotWithPlayerChainNode: invalid occupant node");
+  }
+  const occ = node.occupant;
+  const key = stableOccupantSortKey(occ);
+  const occupants = snapshot.worldMap.occupants.filter(
+    (o) => stableOccupantSortKey(o) !== key
+  );
+  return {
+    ...snapshot,
+    worldMap: {
+      ...snapshot.worldMap,
+      occupants: [...occupants, occ]
+    }
+  };
+}
+
+export {
+  MINIMUM_PLAY_WORLD_BOUNDS,
+  expandBoundsToMinimumPlayArea,
+  clampWorldPosition,
+  boundsContain,
+  OCCUPANCY_POINT_MULTIPLIER,
+  CONTINUOUS_RENDER_OFFSET,
+  DEFAULT_AGENT_SPAWN_MIN_DISTANCE,
+  SPATIAL_ZONE_INDEX_AGENTS,
+  SPATIAL_ZONE_INDEX_SPACES,
+  spatialZoneBounds,
+  spatialZoneCenter,
+  pointCellInSpatialZone,
+  listOccupancyPointsForSpatialZone,
+  occupancyPointsGroupedBySpatialZone,
+  listAllowedOccupancyPoints,
+  occupancyKeyForPosition,
+  buildRankedOccupancyPointsForSpatialZone,
+  buildRankedOccupancyPoints,
+  boundingWorldRectForOccupancyPoints,
+  isAgentSpawnOccupancyPointAvailable,
+  isSpaceAnchorOccupancyPointAvailable,
+  parseHumanOccupantRow,
+  parseAgentOccupantRow,
+  parseMcpOccupantRow,
+  parseSpaceCatalogEntry,
+  parseStructureOccupantRow,
+  PLAYER_CHAIN_GENESIS_STABLE_KEY,
+  PLAYER_CHAIN_HEADER_STABLE_KEY,
+  sortNodeRefsForSerializedFetch,
+  parsePlayerChainFanoutNotify,
+  parsePlayerChainFanoutNotifyFromSsePayload,
+  parsePlayerChainNodeRpcBody,
+  mergeSnapshotWithPlayerChainNode
+};
+//# sourceMappingURL=chunk-WWIEHWZZ.js.map