@voicethere/agent 0.5.4 → 0.5.5

package/dist/templates/game-sync/agent.js

@@ -11362,12 +11362,20 @@ function agentLog(level, message, fieldsOrSessionId, sessionId) {
 var MAX_LIVE_OBJECTS = 25;
 var REGISTER_NACK_REASON_WORLD_FULL = "world_full";
 var UNREGISTER_NACK_REASON_NOT_FOUND = "not_found";
-var UNREGISTER_NACK_REASON_NOT_OWNER = "not_owner";
 function parseRegisterCommand(message) {
   if (!message || typeof message !== "object") return false;
   const record = message;
   return record.type === "register";
 }
+function resolveRemoveTarget(objectId, ownedObjectIds) {
+  if (objectId !== void 0) {
+    return { ok: true, objectId };
+  }
+  if (!ownedObjectIds || ownedObjectIds.size === 0) {
+    return { ok: false, reason: UNREGISTER_NACK_REASON_NOT_FOUND };
+  }
+  return { ok: true, objectId: Math.max(...ownedObjectIds) };
+}
 function parseUnregisterCommand(message) {
   if (!message || typeof message !== "object") return null;
   const record = message;
@@ -11449,6 +11457,16 @@ function writeObjectSlot(world, slot, objectId, posX, posY, posZ, posW, dirX, di
   world[start + 7] = dirZ;
   world[start + 8] = dirW;
 }
+function preserveEmptySlots(simulated, authoritative) {
+  for (let slot = 0; slot < MAX_LIVE_OBJECTS; slot += 1) {
+    if (readSlotObjectId(authoritative, slot) === 0) {
+      markSlotFree(simulated, slot);
+    }
+  }
+}
+function commitSimulatedWorld(simulated, latestRedis) {
+  preserveEmptySlots(simulated, latestRedis);
+}
 function collectActiveObjectIds(world) {
   const ids = [];
   for (let slot = 0; slot < MAX_LIVE_OBJECTS; slot += 1) {
@@ -11686,6 +11704,7 @@ function simulateWorldStep(worldState2, dtSec, activeObjectIds) {
 var BROADCAST_HZ = 60;
 var BROADCAST_INTERVAL_MS = Math.floor(1e3 / BROADCAST_HZ);
 var SIM_LOCK_TTL_MS = BROADCAST_INTERVAL_MS * 2;
+var SIM_LOCK_RETRY_MS = 5;
 var MIN_SPEED = 90;
 var MAX_SPEED = 180;
 var connectedSessions = /* @__PURE__ */ new Set();
@@ -11695,6 +11714,46 @@ var freeSlots = [];
 var worldState = createEmptyWorldBuffer();
 var redis = null;
 var broadcastTimer = null;
+var worldMutationChain = Promise.resolve();
+function withWorldMutation(fn) {
+  const run = worldMutationChain.then(fn);
+  worldMutationChain = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function withRedisSimLock(fn, options) {
+  if (!redis) {
+    return fn();
+  }
+  const retryUntilAcquired = options?.retryUntilAcquired ?? true;
+  while (true) {
+    const lockAcquired = await redis.set(
+      REDIS_SIM_LOCK_KEY,
+      "1",
+      "PX",
+      SIM_LOCK_TTL_MS,
+      "NX"
+    );
+    if (lockAcquired === "OK") {
+      try {
+        return await fn();
+      } finally {
+        await redis.del(REDIS_SIM_LOCK_KEY);
+      }
+    }
+    if (!retryUntilAcquired) {
+      return null;
+    }
+    await sleep(SIM_LOCK_RETRY_MS);
+  }
+}
 function rand(min, max) {
   return min + Math.random() * (max - min);
 }
@@ -11794,6 +11853,7 @@ async function registerObjectInRedis(sessionId) {
     return null;
   }
   attachObjectToSession(sessionId, objectId);
+  worldState = await loadWorldFromRedis();
   return objectId;
 }
 async function releaseObjectInRedis(objectId) {
@@ -11812,35 +11872,32 @@ async function releaseObjectInRedis(objectId) {
     String(objectId),
     REDIS_EVAL_KEYS.headers
   );
+  if (Number(released) === 1) {
+    worldState = await loadWorldFromRedis();
+  }
   return Number(released) === 1;
 }
-function highestOwnedObjectId(sessionId) {
-  const owned = sessionObjects.get(sessionId);
-  if (!owned || owned.size === 0) return null;
-  return Math.max(...owned);
-}
 async function unregisterObject(sessionId, objectId) {
   const owned = sessionObjects.get(sessionId);
-  if (!owned || owned.size === 0) {
-    return { ok: false, reason: UNREGISTER_NACK_REASON_NOT_FOUND };
+  const target = resolveRemoveTarget(objectId, owned);
+  if (!target.ok) {
+    return target;
   }
-  let targetId = objectId;
-  if (targetId === void 0) {
-    const highest = highestOwnedObjectId(sessionId);
-    if (highest === null) {
-      return { ok: false, reason: UNREGISTER_NACK_REASON_NOT_FOUND };
-    }
-    targetId = highest;
-  }
-  if (!owned.has(targetId)) {
-    if (objectId !== void 0) {
-      return { ok: false, reason: UNREGISTER_NACK_REASON_NOT_OWNER };
-    }
+  const previousOwner = objectOwners.get(target.objectId) ?? sessionId;
+  notifyObjectReleased(target.objectId, previousOwner);
+  const released = await withWorldMutation(async () => {
+    if (!redis) {
+      return releaseObjectInRedis(target.objectId);
+    }
+    const result = await withRedisSimLock(
+      () => releaseObjectInRedis(target.objectId)
+    );
+    return result === true;
+  });
+  if (!released) {
     return { ok: false, reason: UNREGISTER_NACK_REASON_NOT_FOUND };
   }
-  notifyObjectReleased(targetId, sessionId);
-  await releaseObjectInRedis(targetId);
-  return { ok: true, objectId: targetId };
+  return { ok: true, objectId: target.objectId };
 }
 function trackedObjectsSnapshot() {
   const objects = [];
@@ -11893,34 +11950,36 @@ async function saveWorldToRedis(world) {
 }
 async function runSimulationTick() {
   if (!redis) {
-    const activeObjectIds = [...objectOwners.keys()];
-    simulateWorldStep(worldState, 1 / BROADCAST_HZ, activeObjectIds);
+    await withWorldMutation(async () => {
+      const activeObjectIds = [...objectOwners.keys()];
+      simulateWorldStep(worldState, 1 / BROADCAST_HZ, activeObjectIds);
+    });
     broadcastWorldBuffer(worldState);
     return;
   }
-  const lockAcquired = await redis.set(
-    REDIS_SIM_LOCK_KEY,
-    "1",
-    "PX",
-    SIM_LOCK_TTL_MS,
-    "NX"
-  );
-  if (lockAcquired === "OK") {
-    const world2 = await loadWorldFromRedis();
-    const activeObjectIds = collectActiveObjectIds(world2);
-    simulateWorldStep(world2, 1 / BROADCAST_HZ, activeObjectIds);
-    await saveWorldToRedis(world2);
-    worldState = world2;
-  }
+  await withWorldMutation(async () => {
+    await withRedisSimLock(
+      async () => {
+        const world2 = await loadWorldFromRedis();
+        const activeObjectIds = collectActiveObjectIds(world2);
+        simulateWorldStep(world2, 1 / BROADCAST_HZ, activeObjectIds);
+        const latestRedis = await loadWorldFromRedis();
+        commitSimulatedWorld(world2, latestRedis);
+        await saveWorldToRedis(world2);
+        worldState = world2;
+      },
+      { retryUntilAcquired: false }
+    );
+  });
   const world = await loadWorldFromRedis();
   worldState = world;
   broadcastWorldBuffer(world);
 }
 function startBroadcastLoopIfNeeded() {
   if (broadcastTimer) return;
-  if (connectedSessions.size < 1) return;
+  if (!redis && connectedSessions.size < 1) return;
   broadcastTimer = setInterval(() => {
-    if (connectedSessions.size < 1) {
+    if (!redis && connectedSessions.size < 1) {
       if (broadcastTimer) {
         clearInterval(broadcastTimer);
         broadcastTimer = null;
@@ -11935,6 +11994,7 @@ function startBroadcastLoopIfNeeded() {
   agentLog("info", `world loop started (${BROADCAST_HZ}Hz)`);
 }
 function stopBroadcastLoopIfNeeded() {
+  if (redis) return;
   if (connectedSessions.size >= 1) return;
   if (!broadcastTimer) return;
   clearInterval(broadcastTimer);
@@ -11965,8 +12025,9 @@ defineAgent({
       lazyConnect: true
     });
     await redis.connect();
-    worldState = createEmptyWorldBuffer();
     await ensureRedisWorldInitialized();
+    worldState = await loadWorldFromRedis();
+    startBroadcastLoopIfNeeded();
     agentLog("info", "game-sync agent connected to project Redis world buffer");
   },
   onClientJoin({ sessionId }) {
@@ -11980,14 +12041,12 @@ defineAgent({
   },
   async onClientLeave({ sessionId }) {
     connectedSessions.delete(sessionId);
-    const owned = sessionObjects.get(sessionId);
-    if (owned) {
-      for (const objectId of [...owned]) {
-        notifyObjectReleased(objectId, sessionId);
-        await releaseObjectInRedis(objectId);
+    for (const [objectId, ownerSessionId] of objectOwners) {
+      if (ownerSessionId === sessionId) {
+        objectOwners.delete(objectId);
       }
-      sessionObjects.delete(sessionId);
     }
+    sessionObjects.delete(sessionId);
     stopBroadcastLoopIfNeeded();
     agentLog(
       "info",
@@ -11996,7 +12055,15 @@ defineAgent({
   },
   async onDataChannelMessage(ctx) {
     if (parseRegisterCommand(ctx.message)) {
-      const objectId = redis ? await registerObjectInRedis(ctx.sessionId) : registerObjectInMemory(ctx.sessionId);
+      const objectId = await withWorldMutation(async () => {
+        if (!redis) {
+          return registerObjectInMemory(ctx.sessionId);
+        }
+        const result = await withRedisSimLock(
+          () => registerObjectInRedis(ctx.sessionId)
+        );
+        return result;
+      });
       if (objectId === null) {
         sendToClient(ctx.sessionId, {
           type: "register_nack",

package/dist/templates/voice-showcase/agent.js

@@ -669,6 +669,136 @@ function pickFunFact() {
 var GEOCODE_URL = "https://geocoding-api.open-meteo.com/v1/search";
 var FORECAST_URL = "https://api.open-meteo.com/v1/forecast";
 var FETCH_TIMEOUT_MS = 8e3;
+var DIGIT_WORDS = {
+  zero: "0",
+  oh: "0",
+  o: "0",
+  one: "1",
+  two: "2",
+  three: "3",
+  four: "4",
+  five: "5",
+  six: "6",
+  seven: "7",
+  eight: "8",
+  nine: "9"
+};
+var COUNTRY_ALIASES = {
+  thailand: "Thailand",
+  us: "United States",
+  usa: "United States",
+  america: "United States",
+  "united states": "United States",
+  "united states of america": "United States",
+  uk: "United Kingdom",
+  britain: "United Kingdom",
+  england: "United Kingdom",
+  "united kingdom": "United Kingdom",
+  "great britain": "United Kingdom",
+  germany: "Germany",
+  france: "France",
+  spain: "Spain",
+  italy: "Italy",
+  japan: "Japan",
+  china: "China",
+  india: "India",
+  australia: "Australia",
+  canada: "Canada",
+  brazil: "Brazil",
+  mexico: "Mexico",
+  netherlands: "Netherlands",
+  holland: "Netherlands",
+  "the netherlands": "Netherlands",
+  belgium: "Belgium",
+  switzerland: "Switzerland",
+  sweden: "Sweden",
+  norway: "Norway",
+  denmark: "Denmark",
+  finland: "Finland",
+  poland: "Poland",
+  portugal: "Portugal",
+  greece: "Greece",
+  turkey: "Turkey",
+  egypt: "Egypt",
+  "south africa": "South Africa",
+  "new zealand": "New Zealand",
+  ireland: "Ireland",
+  singapore: "Singapore",
+  malaysia: "Malaysia",
+  indonesia: "Indonesia",
+  vietnam: "Vietnam",
+  philippines: "Philippines",
+  "south korea": "South Korea",
+  korea: "South Korea",
+  taiwan: "Taiwan",
+  "hong kong": "Hong Kong",
+  israel: "Israel",
+  uae: "United Arab Emirates",
+  "united arab emirates": "United Arab Emirates",
+  "saudi arabia": "Saudi Arabia",
+  pakistan: "Pakistan",
+  bangladesh: "Bangladesh",
+  nigeria: "Nigeria",
+  kenya: "Kenya",
+  argentina: "Argentina",
+  chile: "Chile",
+  colombia: "Colombia",
+  peru: "Peru",
+  austria: "Austria",
+  "czech republic": "Czechia",
+  czechia: "Czechia",
+  romania: "Romania",
+  hungary: "Hungary",
+  ukraine: "Ukraine"
+};
+function matchCountryName(text) {
+  const key = text.trim().toLowerCase().replace(/[.,!?]+$/g, "").replace(/\s+/g, " ");
+  if (!key) return null;
+  return COUNTRY_ALIASES[key] ?? null;
+}
+function spokenDigitsToPostal(text) {
+  const tokens = text.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+  const digits = [];
+  for (const token of tokens) {
+    if (/^\d$/.test(token)) {
+      digits.push(token);
+      continue;
+    }
+    const mapped = DIGIT_WORDS[token];
+    if (mapped) {
+      digits.push(mapped);
+    }
+  }
+  if (digits.length >= 4 && digits.length <= 6) {
+    return digits.join("");
+  }
+  return null;
+}
+function splitTrailingCountry(text) {
+  const words = text.trim().split(/\s+/).filter(Boolean);
+  if (words.length < 2) return null;
+  for (let n = Math.min(3, words.length - 1); n >= 1; n -= 1) {
+    const tail = words.slice(-n).join(" ");
+    const country = matchCountryName(tail);
+    if (country) {
+      return { rest: words.slice(0, -n).join(" "), country };
+    }
+  }
+  return null;
+}
+function cityFromRemainder(rest) {
+  const trimmed = rest.trim().replace(/[.,!?;:]+$/g, "").replace(/\s+(?:in the|in|of)$/i, "").trim();
+  if (!trimmed) return null;
+  if (/^\d{4,6}(-\d{4})?$/.test(trimmed)) {
+    return trimmed;
+  }
+  const spoken = spokenDigitsToPostal(trimmed);
+  if (spoken) return spoken;
+  if (trimmed.length >= 2 && trimmed.length <= 60) {
+    return trimmed;
+  }
+  return null;
+}
 function wmoCodeToPhrase(code) {
   if (code === 0) return "clear sky";
   if (code <= 3) return "partly cloudy";
@@ -689,29 +819,48 @@ function formatWeatherSpeech(result) {
 function parseLocationUtterance(utterance) {
   const text = utterance.trim();
   if (!text) return null;
+  const countryOnly = matchCountryName(text);
+  if (countryOnly) {
+    return { country: countryOnly };
+  }
+  const trailing = splitTrailingCountry(text);
+  if (trailing) {
+    const city = cityFromRemainder(trailing.rest);
+    if (city) {
+      return { city, country: trailing.country };
+    }
+    return { country: trailing.country };
+  }
   const inMatch = text.match(
     /^(?:in\s+)?(.+?)\s+in\s+([a-zA-Z][\w\s.-]{1,40})$/i
   );
   if (inMatch) {
-    return { city: inMatch[1].trim(), country: inMatch[2].trim() };
+    const country = matchCountryName(inMatch[2]) ?? inMatch[2].trim();
+    return { city: inMatch[1].trim(), country };
   }
   const commaMatch = text.match(/^(.+?),\s*([a-zA-Z][\w\s.-]{1,40})$/);
   if (commaMatch) {
-    return { city: commaMatch[1].trim(), country: commaMatch[2].trim() };
+    const country = matchCountryName(commaMatch[2]) ?? commaMatch[2].trim();
+    return { city: commaMatch[1].trim(), country };
   }
   const countryMatch = text.match(
     /^(.+?)\s+(?:country\s+)?([a-zA-Z][\w\s.-]{2,40})$/i
   );
   if (countryMatch && countryMatch[2].split(/\s+/).length <= 3) {
     const city = countryMatch[1].trim();
-    const country = countryMatch[2].trim();
+    const countryRaw = countryMatch[2].trim();
+    const country = matchCountryName(countryRaw) ?? countryRaw;
     if (city.length >= 2 && country.length >= 2) {
       return { city, country };
     }
   }
-  if (/^\d{5}(-\d{4})?$/.test(text)) {
+  if (/^\d{4,6}(-\d{4})?$/.test(text)) {
     return { city: text };
   }
+  const spokenPostal = spokenDigitsToPostal(text);
+  if (spokenPostal) {
+    return { city: spokenPostal };
+  }
   if (text.length >= 2 && text.length <= 60) {
     return { city: text };
   }
@@ -1059,8 +1208,15 @@ function handleUtterance(state, utterance) {
     }
     case "weatherAwaitingLocation": {
       const parsed = parseLocationUtterance(text);
-      const city = parsed?.city ?? state.weatherCity;
-      const country = parsed?.country ?? state.weatherCountry;
+      let city = parsed?.city || state.weatherCity;
+      let country = parsed?.country || state.weatherCountry;
+      if (state.weatherCity && !country) {
+        const followUp = matchCountryName(text) ?? (parsed?.city ? matchCountryName(parsed.city) : null);
+        if (followUp) {
+          city = state.weatherCity;
+          country = followUp;
+        }
+      }
       if (!city) {
         const ask = speakAndChat(
           "Please tell me a city or ZIP code and the country."
@@ -1071,7 +1227,7 @@ function handleUtterance(state, utterance) {
           messages: ask.messages
         };
       }
-      if (!country && !parsed?.country && !state.weatherCountry) {
+      if (!country) {
         return {
           state: {
             ...state,
@@ -1084,12 +1240,11 @@ function handleUtterance(state, utterance) {
           ]
         };
       }
-      const resolvedCountry = country ?? state.weatherCountry;
       return {
-        state: { ...state, weatherCity: city, weatherCountry: resolvedCountry },
+        state: { ...state, weatherCity: city, weatherCountry: country },
         speakLines: [],
         messages: [],
-        pendingWeather: { city, country: resolvedCountry }
+        pendingWeather: { city, country }
       };
     }
     case "countAwaitingNumber": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voicethere/agent",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "description": "VoiceThere customer agent SDK — IPC types and runtime helpers for sandboxed child bundles",
   "type": "module",
   "exports": {

package/templates/game-sync-protocol.ts

@@ -19,6 +19,19 @@ export interface UnregisterCommand {
   objectId?: number;
 }
 
+export function resolveRemoveTarget(
+  objectId: number | undefined,
+  ownedObjectIds: ReadonlySet<number> | undefined | null,
+): { ok: true; objectId: number } | { ok: false; reason: string } {
+  if (objectId !== undefined) {
+    return { ok: true, objectId };
+  }
+  if (!ownedObjectIds || ownedObjectIds.size === 0) {
+    return { ok: false, reason: UNREGISTER_NACK_REASON_NOT_FOUND };
+  }
+  return { ok: true, objectId: Math.max(...ownedObjectIds) };
+}
+
 export function parseUnregisterCommand(
   message: unknown,
 ): UnregisterCommand | null {

package/templates/game-sync-world-layout.ts

@@ -124,6 +124,33 @@ export function writeObjectSlot(
   world[start + 8] = dirW;
 }
 
+/**
+ * After simulating from a Redis load, keep slots empty that a concurrent release
+ * zeroed in Redis while the tick was in flight — prevents saveWorldToRedis from
+ * restoring an object Lua just cleared (sim GET → simulate → SET race).
+ *
+ * `authoritative` must be a fresh Redis GET after simulate (never stale in-memory
+ * worldState — an empty buffer would wipe every live slot).
+ */
+export function preserveEmptySlots(
+  simulated: Float32Array,
+  authoritative: Float32Array,
+): void {
+  for (let slot = 0; slot < MAX_LIVE_OBJECTS; slot += 1) {
+    if (readSlotObjectId(authoritative, slot) === 0) {
+      markSlotFree(simulated, slot);
+    }
+  }
+}
+
+/** Merge a simulated world with the latest Redis snapshot before SET. */
+export function commitSimulatedWorld(
+  simulated: Float32Array,
+  latestRedis: Float32Array,
+): void {
+  preserveEmptySlots(simulated, latestRedis);
+}
+
 export function collectActiveObjectIds(world: Float32Array): number[] {
   const ids: number[] = [];
   for (let slot = 0; slot < MAX_LIVE_OBJECTS; slot += 1) {

package/templates/game-sync.ts

@@ -7,24 +7,27 @@
  *   [objectId, posX, posY, posZ, posW, dirX, dirY, dirZ, dirW]
  *
  * With project Redis (`AGENT_REDIS_URL`), the world blob is shared across runner
- * workers (key `game-sync:world`). One worker holds a sim lock per tick, runs
- * physics, and writes the blob; every worker GET+broadcasts to local sessions.
+ * workers (key `game-sync:world`). World writes (allocate/release Lua, sim SET)
+ * serialize on `game-sync:sim-lock`; one holder runs physics per tick.
  *
  * Control messages:
  * - `{ type: "register" }` -> allocates (or reuses) one 9-float slot
  * - server replies `{ type: "register_ack", objectId }`
  * - `{ type: "register_nack", reason: "world_full", maxObjects: 25 }` when cap reached
- * - `{ type: "unregister" }` or `{ type: "remove", objectId?: number }` -> releases owned object(s)
+ * - `{ type: "remove", objectId }` or `{ type: "unregister", objectId?: number }` ->
+ *   zeros that live slot (objectId required for click-to-remove; omit objectId on
+ *   unregister to drop the highest object owned by this session)
  * - `{ type: "unregister_ack", objectId }` or `{ type: "unregister_nack", reason }`
  *
  * Simulation:
  * - server-authoritative movement at 60Hz
  * - wall bounce + object-object elastic collisions on server
  * - clients render server snapshots; client binary writes are ignored
+ * - with project Redis, the sim loop keeps running with zero connected clients so
+ *   objects persist and keep moving after everyone disconnects
  *
  * Broadcast:
- * - 60Hz world-state broadcast starts when at least 1 client is connected
- * - stops when connected client count drops below 1
+ * - 60Hz world-state broadcast while the sim loop runs (no-op send when 0 sessions)
  *
  * Build:
  *   npx @voicethere/agent build --entry templates/game-sync.ts
@@ -42,9 +45,9 @@ import {
   parseChatCommand,
   parseRegisterCommand,
   parseUnregisterCommand,
+  resolveRemoveTarget,
   REGISTER_NACK_REASON_WORLD_FULL,
   UNREGISTER_NACK_REASON_NOT_FOUND,
-  UNREGISTER_NACK_REASON_NOT_OWNER,
 } from "./game-sync-protocol.js";
 import {
   LUA_ALLOCATE_OBJECT,
@@ -59,6 +62,7 @@ import {
 } from "./game-sync-sim.js";
 import {
   collectActiveObjectIds,
+  commitSimulatedWorld,
   countLiveObjects,
   createEmptyWorldBuffer,
   findFirstEmptySlot,
@@ -75,6 +79,7 @@ import {
 const BROADCAST_HZ = 60;
 const BROADCAST_INTERVAL_MS = Math.floor(1000 / BROADCAST_HZ);
 const SIM_LOCK_TTL_MS = BROADCAST_INTERVAL_MS * 2;
+const SIM_LOCK_RETRY_MS = 5;
 const MIN_SPEED = 90;
 const MAX_SPEED = 180;
 
@@ -86,6 +91,54 @@ const freeSlots: number[] = [];
 let worldState = createEmptyWorldBuffer();
 let redis: Redis | null = null;
 let broadcastTimer: NodeJS.Timeout | null = null;
+let worldMutationChain: Promise<void> = Promise.resolve();
+
+function withWorldMutation<T>(fn: () => Promise<T>): Promise<T> {
+  const run = worldMutationChain.then(fn);
+  worldMutationChain = run.then(
+    () => undefined,
+    () => undefined,
+  );
+  return run;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+async function withRedisSimLock<T>(
+  fn: () => Promise<T>,
+  options?: { retryUntilAcquired?: boolean },
+): Promise<T | null> {
+  if (!redis) {
+    return fn();
+  }
+
+  const retryUntilAcquired = options?.retryUntilAcquired ?? true;
+
+  while (true) {
+    const lockAcquired = await redis.set(
+      REDIS_SIM_LOCK_KEY,
+      "1",
+      "PX",
+      SIM_LOCK_TTL_MS,
+      "NX",
+    );
+    if (lockAcquired === "OK") {
+      try {
+        return await fn();
+      } finally {
+        await redis.del(REDIS_SIM_LOCK_KEY);
+      }
+    }
+    if (!retryUntilAcquired) {
+      return null;
+    }
+    await sleep(SIM_LOCK_RETRY_MS);
+  }
+}
 
 interface TrackedObjectInfo {
   objectId: number;
@@ -208,6 +261,7 @@ async function registerObjectInRedis(
   }
 
   attachObjectToSession(sessionId, objectId);
+  worldState = await loadWorldFromRedis();
   return objectId;
 }
 
@@ -228,43 +282,37 @@ async function releaseObjectInRedis(objectId: number): Promise<boolean> {
     String(objectId),
     REDIS_EVAL_KEYS.headers,
   );
+  if (Number(released) === 1) {
+    worldState = await loadWorldFromRedis();
+  }
   return Number(released) === 1;
 }
 
-function highestOwnedObjectId(sessionId: string): number | null {
-  const owned = sessionObjects.get(sessionId);
-  if (!owned || owned.size === 0) return null;
-  return Math.max(...owned);
-}
-
 async function unregisterObject(
   sessionId: string,
   objectId?: number,
 ): Promise<{ ok: true; objectId: number } | { ok: false; reason: string }> {
   const owned = sessionObjects.get(sessionId);
-  if (!owned || owned.size === 0) {
-    return { ok: false, reason: UNREGISTER_NACK_REASON_NOT_FOUND };
+  const target = resolveRemoveTarget(objectId, owned);
+  if (!target.ok) {
+    return target;
   }
 
-  let targetId = objectId;
-  if (targetId === undefined) {
-    const highest = highestOwnedObjectId(sessionId);
-    if (highest === null) {
-      return { ok: false, reason: UNREGISTER_NACK_REASON_NOT_FOUND };
-    }
-    targetId = highest;
-  }
-
-  if (!owned.has(targetId)) {
-    if (objectId !== undefined) {
-      return { ok: false, reason: UNREGISTER_NACK_REASON_NOT_OWNER };
+  const previousOwner = objectOwners.get(target.objectId) ?? sessionId;
+  notifyObjectReleased(target.objectId, previousOwner);
+  const released = await withWorldMutation(async () => {
+    if (!redis) {
+      return releaseObjectInRedis(target.objectId);
     }
+    const result = await withRedisSimLock(() =>
+      releaseObjectInRedis(target.objectId),
+    );
+    return result === true;
+  });
+  if (!released) {
     return { ok: false, reason: UNREGISTER_NACK_REASON_NOT_FOUND };
   }
-
-  notifyObjectReleased(targetId, sessionId);
-  await releaseObjectInRedis(targetId);
-  return { ok: true, objectId: targetId };
+  return { ok: true, objectId: target.objectId };
 }
 
 function trackedObjectsSnapshot(): TrackedObjectInfo[] {
@@ -328,26 +376,28 @@ async function saveWorldToRedis(world: Float32Array): Promise<void> {
 
 async function runSimulationTick(): Promise<void> {
   if (!redis) {
-    const activeObjectIds = [...objectOwners.keys()];
-    simulateWorldStep(worldState, 1 / BROADCAST_HZ, activeObjectIds);
+    await withWorldMutation(async () => {
+      const activeObjectIds = [...objectOwners.keys()];
+      simulateWorldStep(worldState, 1 / BROADCAST_HZ, activeObjectIds);
+    });
     broadcastWorldBuffer(worldState);
     return;
   }
 
-  const lockAcquired = await redis.set(
-    REDIS_SIM_LOCK_KEY,
-    "1",
-    "PX",
-    SIM_LOCK_TTL_MS,
-    "NX",
-  );
-  if (lockAcquired === "OK") {
-    const world = await loadWorldFromRedis();
-    const activeObjectIds = collectActiveObjectIds(world);
-    simulateWorldStep(world, 1 / BROADCAST_HZ, activeObjectIds);
-    await saveWorldToRedis(world);
-    worldState = world;
-  }
+  await withWorldMutation(async () => {
+    await withRedisSimLock(
+      async () => {
+        const world = await loadWorldFromRedis();
+        const activeObjectIds = collectActiveObjectIds(world);
+        simulateWorldStep(world, 1 / BROADCAST_HZ, activeObjectIds);
+        const latestRedis = await loadWorldFromRedis();
+        commitSimulatedWorld(world, latestRedis);
+        await saveWorldToRedis(world);
+        worldState = world;
+      },
+      { retryUntilAcquired: false },
+    );
+  });
 
   const world = await loadWorldFromRedis();
   worldState = world;
@@ -356,10 +406,10 @@ async function runSimulationTick(): Promise<void> {
 
 function startBroadcastLoopIfNeeded(): void {
   if (broadcastTimer) return;
-  if (connectedSessions.size < 1) return;
+  if (!redis && connectedSessions.size < 1) return;
 
   broadcastTimer = setInterval(() => {
-    if (connectedSessions.size < 1) {
+    if (!redis && connectedSessions.size < 1) {
       if (broadcastTimer) {
         clearInterval(broadcastTimer);
         broadcastTimer = null;
@@ -376,6 +426,7 @@ function startBroadcastLoopIfNeeded(): void {
 }
 
 function stopBroadcastLoopIfNeeded(): void {
+  if (redis) return;
   if (connectedSessions.size >= 1) return;
   if (!broadcastTimer) return;
   clearInterval(broadcastTimer);
@@ -409,8 +460,9 @@ defineAgent({
       lazyConnect: true,
     });
     await redis.connect();
-    worldState = createEmptyWorldBuffer();
     await ensureRedisWorldInitialized();
+    worldState = await loadWorldFromRedis();
+    startBroadcastLoopIfNeeded();
     agentLog("info", "game-sync agent connected to project Redis world buffer");
   },
 
@@ -426,16 +478,12 @@ defineAgent({
 
   async onClientLeave({ sessionId }) {
     connectedSessions.delete(sessionId);
-
-    const owned = sessionObjects.get(sessionId);
-    if (owned) {
-      for (const objectId of [...owned]) {
-        notifyObjectReleased(objectId, sessionId);
-        await releaseObjectInRedis(objectId);
+    for (const [objectId, ownerSessionId] of objectOwners) {
+      if (ownerSessionId === sessionId) {
+        objectOwners.delete(objectId);
       }
-      sessionObjects.delete(sessionId);
     }
-
+    sessionObjects.delete(sessionId);
     stopBroadcastLoopIfNeeded();
     agentLog(
       "info",
@@ -445,9 +493,15 @@ defineAgent({
 
   async onDataChannelMessage(ctx) {
     if (parseRegisterCommand(ctx.message)) {
-      const objectId = redis
-        ? await registerObjectInRedis(ctx.sessionId)
-        : registerObjectInMemory(ctx.sessionId);
+      const objectId = await withWorldMutation(async () => {
+        if (!redis) {
+          return registerObjectInMemory(ctx.sessionId);
+        }
+        const result = await withRedisSimLock(() =>
+          registerObjectInRedis(ctx.sessionId),
+        );
+        return result;
+      });
       if (objectId === null) {
         sendToClient(ctx.sessionId, {
           type: "register_nack",

package/templates/voice-showcase/conversation.ts

@@ -8,6 +8,7 @@ import { pickFunFact } from "./fun-facts.js";
 import {
   formatWeatherSpeech,
   lookupWeather,
+  matchCountryName,
   parseLocationUtterance,
   type FetchFn,
   type WeatherResult,
@@ -400,8 +401,19 @@ export function handleUtterance(
 
     case "weatherAwaitingLocation": {
       const parsed = parseLocationUtterance(text);
-      const city = parsed?.city ?? state.weatherCity;
-      const country = parsed?.country ?? state.weatherCountry;
+      let city = parsed?.city || state.weatherCity;
+      let country = parsed?.country || state.weatherCountry;
+
+      // Country-only follow-up: "Thailand" must not overwrite a stored ZIP as city.
+      if (state.weatherCity && !country) {
+        const followUp =
+          matchCountryName(text) ??
+          (parsed?.city ? matchCountryName(parsed.city) : null);
+        if (followUp) {
+          city = state.weatherCity;
+          country = followUp;
+        }
+      }
 
       if (!city) {
         const ask = speakAndChat(
@@ -414,7 +426,7 @@ export function handleUtterance(
         };
       }
 
-      if (!country && !parsed?.country && !state.weatherCountry) {
+      if (!country) {
         return {
           state: {
             ...state,
@@ -428,12 +440,11 @@ export function handleUtterance(
         };
       }
 
-      const resolvedCountry = country ?? state.weatherCountry;
       return {
-        state: { ...state, weatherCity: city, weatherCountry: resolvedCountry },
+        state: { ...state, weatherCity: city, weatherCountry: country },
         speakLines: [],
         messages: [],
-        pendingWeather: { city, country: resolvedCountry },
+        pendingWeather: { city, country },
       };
     }
 

package/templates/voice-showcase/weather.ts

@@ -20,6 +20,163 @@ export interface WeatherResult {
 
 export type FetchFn = typeof fetch;
 
+export type ParsedLocation = {
+  city?: string;
+  country?: string;
+};
+
+const DIGIT_WORDS: Record<string, string> = {
+  zero: "0",
+  oh: "0",
+  o: "0",
+  one: "1",
+  two: "2",
+  three: "3",
+  four: "4",
+  five: "5",
+  six: "6",
+  seven: "7",
+  eight: "8",
+  nine: "9",
+};
+
+/** Lowercase aliases → Open-Meteo-friendly country names. */
+const COUNTRY_ALIASES: Record<string, string> = {
+  thailand: "Thailand",
+  us: "United States",
+  usa: "United States",
+  america: "United States",
+  "united states": "United States",
+  "united states of america": "United States",
+  uk: "United Kingdom",
+  britain: "United Kingdom",
+  england: "United Kingdom",
+  "united kingdom": "United Kingdom",
+  "great britain": "United Kingdom",
+  germany: "Germany",
+  france: "France",
+  spain: "Spain",
+  italy: "Italy",
+  japan: "Japan",
+  china: "China",
+  india: "India",
+  australia: "Australia",
+  canada: "Canada",
+  brazil: "Brazil",
+  mexico: "Mexico",
+  netherlands: "Netherlands",
+  holland: "Netherlands",
+  "the netherlands": "Netherlands",
+  belgium: "Belgium",
+  switzerland: "Switzerland",
+  sweden: "Sweden",
+  norway: "Norway",
+  denmark: "Denmark",
+  finland: "Finland",
+  poland: "Poland",
+  portugal: "Portugal",
+  greece: "Greece",
+  turkey: "Turkey",
+  egypt: "Egypt",
+  "south africa": "South Africa",
+  "new zealand": "New Zealand",
+  ireland: "Ireland",
+  singapore: "Singapore",
+  malaysia: "Malaysia",
+  indonesia: "Indonesia",
+  vietnam: "Vietnam",
+  philippines: "Philippines",
+  "south korea": "South Korea",
+  korea: "South Korea",
+  taiwan: "Taiwan",
+  "hong kong": "Hong Kong",
+  israel: "Israel",
+  uae: "United Arab Emirates",
+  "united arab emirates": "United Arab Emirates",
+  "saudi arabia": "Saudi Arabia",
+  pakistan: "Pakistan",
+  bangladesh: "Bangladesh",
+  nigeria: "Nigeria",
+  kenya: "Kenya",
+  argentina: "Argentina",
+  chile: "Chile",
+  colombia: "Colombia",
+  peru: "Peru",
+  austria: "Austria",
+  "czech republic": "Czechia",
+  czechia: "Czechia",
+  romania: "Romania",
+  hungary: "Hungary",
+  ukraine: "Ukraine",
+};
+
+export function matchCountryName(text: string): string | null {
+  const key = text
+    .trim()
+    .toLowerCase()
+    .replace(/[.,!?]+$/g, "")
+    .replace(/\s+/g, " ");
+  if (!key) return null;
+  return COUNTRY_ALIASES[key] ?? null;
+}
+
+/** "eight four three two zero" → "84320" (4–6 digits). */
+export function spokenDigitsToPostal(text: string): string | null {
+  const tokens = text
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+  const digits: string[] = [];
+  for (const token of tokens) {
+    if (/^\d$/.test(token)) {
+      digits.push(token);
+      continue;
+    }
+    const mapped = DIGIT_WORDS[token];
+    if (mapped) {
+      digits.push(mapped);
+    }
+    // Skip STT filler ("welcome", "down", "there", …).
+  }
+  if (digits.length >= 4 && digits.length <= 6) {
+    return digits.join("");
+  }
+  return null;
+}
+
+function splitTrailingCountry(
+  text: string,
+): { rest: string; country: string } | null {
+  const words = text.trim().split(/\s+/).filter(Boolean);
+  if (words.length < 2) return null;
+  for (let n = Math.min(3, words.length - 1); n >= 1; n -= 1) {
+    const tail = words.slice(-n).join(" ");
+    const country = matchCountryName(tail);
+    if (country) {
+      return { rest: words.slice(0, -n).join(" "), country };
+    }
+  }
+  return null;
+}
+
+function cityFromRemainder(rest: string): string | null {
+  const trimmed = rest
+    .trim()
+    .replace(/[.,!?;:]+$/g, "")
+    .replace(/\s+(?:in the|in|of)$/i, "")
+    .trim();
+  if (!trimmed) return null;
+  if (/^\d{4,6}(-\d{4})?$/.test(trimmed)) {
+    return trimmed;
+  }
+  const spoken = spokenDigitsToPostal(trimmed);
+  if (spoken) return spoken;
+  if (trimmed.length >= 2 && trimmed.length <= 60) {
+    return trimmed;
+  }
+  return null;
+}
+
 /** Map WMO weather_code to a short English phrase. */
 export function wmoCodeToPhrase(code: number): string {
   if (code === 0) return "clear sky";
@@ -43,20 +200,36 @@ export function formatWeatherSpeech(result: WeatherResult): string {
 /** Parse city/zip and country from a single utterance when possible. */
 export function parseLocationUtterance(
   utterance: string,
-): { city: string; country?: string } | null {
+): ParsedLocation | null {
   const text = utterance.trim();
   if (!text) return null;
 
+  const countryOnly = matchCountryName(text);
+  if (countryOnly) {
+    return { country: countryOnly };
+  }
+
+  const trailing = splitTrailingCountry(text);
+  if (trailing) {
+    const city = cityFromRemainder(trailing.rest);
+    if (city) {
+      return { city, country: trailing.country };
+    }
+    return { country: trailing.country };
+  }
+
   const inMatch = text.match(
     /^(?:in\s+)?(.+?)\s+in\s+([a-zA-Z][\w\s.-]{1,40})$/i,
   );
   if (inMatch) {
-    return { city: inMatch[1]!.trim(), country: inMatch[2]!.trim() };
+    const country = matchCountryName(inMatch[2]!) ?? inMatch[2]!.trim();
+    return { city: inMatch[1]!.trim(), country };
   }
 
   const commaMatch = text.match(/^(.+?),\s*([a-zA-Z][\w\s.-]{1,40})$/);
   if (commaMatch) {
-    return { city: commaMatch[1]!.trim(), country: commaMatch[2]!.trim() };
+    const country = matchCountryName(commaMatch[2]!) ?? commaMatch[2]!.trim();
+    return { city: commaMatch[1]!.trim(), country };
   }
 
   const countryMatch = text.match(
@@ -64,16 +237,22 @@ export function parseLocationUtterance(
   );
   if (countryMatch && countryMatch[2]!.split(/\s+/).length <= 3) {
     const city = countryMatch[1]!.trim();
-    const country = countryMatch[2]!.trim();
+    const countryRaw = countryMatch[2]!.trim();
+    const country = matchCountryName(countryRaw) ?? countryRaw;
     if (city.length >= 2 && country.length >= 2) {
       return { city, country };
     }
   }
 
-  if (/^\d{5}(-\d{4})?$/.test(text)) {
+  if (/^\d{4,6}(-\d{4})?$/.test(text)) {
     return { city: text };
   }
 
+  const spokenPostal = spokenDigitsToPostal(text);
+  if (spokenPostal) {
+    return { city: spokenPostal };
+  }
+
   if (text.length >= 2 && text.length <= 60) {
     return { city: text };
   }