@agent-play/sdk 3.4.1 → 3.4.2

package/dist/{chunk-Z2PYRHFU.js → chunk-WTI6DVRD.js}

@@ -17,6 +17,22 @@ var MINIMUM_STREET_LAYOUT_BOUNDS = {
   maxX: 19,
   maxY: 2
 };
+var COLUMN_STREET_ROW_HEIGHT = 3;
+var PARKING_STREET_ROW_HEIGHT = 4;
+var PARKING_COLUMN_GAP_ROWS = 2.5;
+var parkingZoneMinYFromColumnBase = (columnMinY) => {
+  const columnMaxY = columnMinY + COLUMN_STREET_ROW_HEIGHT - 1;
+  return Math.ceil(columnMaxY + 1 + PARKING_COLUMN_GAP_ROWS);
+};
+var parkingZoneMaxYFromColumnBase = (columnMinY) => {
+  return parkingZoneMinYFromColumnBase(columnMinY) + PARKING_STREET_ROW_HEIGHT - 1;
+};
+var DEFAULT_LAYOUT_BOUNDS_WITH_PARKING = {
+  minX: 0,
+  minY: 0,
+  maxX: 19,
+  maxY: parkingZoneMaxYFromColumnBase(0)
+};
 function expandBoundsToMinimumPlayArea(bounds) {
   return {
     minX: Math.min(bounds.minX, MINIMUM_PLAY_WORLD_BOUNDS.minX),
@@ -264,6 +280,64 @@ function getStreetPoolEntryById(id) {
 }
 
 // src/lib/world-layout-model.ts
+var LEGACY_MCP_PRIMARY_GROUP = "mcp";
+function normalizeLegacyOccupantGroup(value) {
+  if (value === LEGACY_MCP_PRIMARY_GROUP) {
+    return "arcade";
+  }
+  if (value === "agent" || value === "space" || value === "arcade" || value === "parking") {
+    return value;
+  }
+  throw new Error(
+    `normalizeLegacyWorldLayout: unknown primaryGroup ${value}`
+  );
+}
+function migrateLegacyWorldLayoutZone(zone) {
+  const rawPrimary = String(zone.primaryGroup);
+  const primaryGroup = normalizeLegacyOccupantGroup(rawPrimary);
+  const id = zone.id === "zone-mcp-strip" || rawPrimary === LEGACY_MCP_PRIMARY_GROUP ? primaryGroup === "arcade" ? "zone-arcade-strip" : zone.id : zone.id;
+  const allowedGroups = [
+    ...new Set(
+      zone.allowedGroups.map(
+        (group) => normalizeLegacyOccupantGroup(String(group))
+      )
+    )
+  ];
+  return { ...zone, id, primaryGroup, allowedGroups };
+}
+function threeStreetsFromLayoutOrPool(layout) {
+  if (layout.streets.length >= 3) {
+    const s0 = layout.streets[0];
+    const s1 = layout.streets[1];
+    const s2 = layout.streets[2];
+    if (s0 !== void 0 && s1 !== void 0 && s2 !== void 0) {
+      return [
+        { id: s0.id, label: s0.label },
+        { id: s1.id, label: s1.label },
+        { id: s2.id, label: s2.label }
+      ];
+    }
+  }
+  const a = STREET_NAME_POOL[0];
+  const b = STREET_NAME_POOL[1];
+  const c = STREET_NAME_POOL[2];
+  if (a === void 0 || b === void 0 || c === void 0) {
+    throw new Error("normalizeLegacyWorldLayout: STREET_NAME_POOL too small");
+  }
+  return [a, b, c];
+}
+function normalizeLegacyWorldLayout(layout) {
+  const migratedZones = layout.zones.map(migrateLegacyWorldLayoutZone);
+  if (migratedZones.some((zone) => zone.primaryGroup === "arcade")) {
+    return { ...layout, zones: migratedZones };
+  }
+  const streets = threeStreetsFromLayoutOrPool(layout);
+  const rebuilt = createVerticalStripSeedLayout({
+    bounds: layout.bounds,
+    streets
+  });
+  return { ...rebuilt, rev: layout.rev };
+}
 function streetFromPoolEntry(entry) {
   return { id: entry.id, label: entry.label };
 }
@@ -382,7 +456,88 @@ function assertValidLayoutBounds(bounds) {
     );
   }
 }
-var PRIMARY_GROUP_ORDER = ["agent", "space", "arcade"];
+var PRIMARY_GROUP_ORDER = [
+  "agent",
+  "space",
+  "arcade"
+];
+function partitionColumnWidths(spanX) {
+  if (spanX === 20) {
+    return [7, 7, 6];
+  }
+  const w0 = Math.floor(spanX / 3);
+  const w1 = Math.floor((spanX - w0) / 2);
+  const w2 = spanX - w0 - w1;
+  return [w0, w1, w2];
+}
+function buildColumnZones(input) {
+  const { minX, maxX } = input.bounds;
+  const spanX = maxX - minX + 1;
+  const widths = partitionColumnWidths(spanX);
+  const w0 = widths[0];
+  const w1 = widths[1];
+  const w2 = widths[2];
+  if (w0 === void 0 || w1 === void 0 || w2 === void 0) {
+    throw new Error("buildColumnZones: width partition failed");
+  }
+  const x0 = minX;
+  const x0Max = x0 + w0 - 1;
+  const x1 = x0Max + 1;
+  const x1Max = x1 + w1 - 1;
+  const x2 = x1Max + 1;
+  const x2Max = x2 + w2 - 1;
+  const s0 = input.streets[0];
+  const s1 = input.streets[1];
+  const s2 = input.streets[2];
+  if (s0 === void 0 || s1 === void 0 || s2 === void 0) {
+    throw new Error("buildColumnZones: expected three streets");
+  }
+  const { columnMinY, columnMaxY } = input;
+  return [
+    {
+      id: "zone-agent-strip",
+      streetId: s0.id,
+      streetLabel: s0.label,
+      rect: { minX: x0, maxX: x0Max, minY: columnMinY, maxY: columnMaxY },
+      primaryGroup: "agent",
+      allowedGroups: ["agent"]
+    },
+    {
+      id: "zone-space-strip",
+      streetId: s1.id,
+      streetLabel: s1.label,
+      rect: { minX: x1, maxX: x1Max, minY: columnMinY, maxY: columnMaxY },
+      primaryGroup: "space",
+      allowedGroups: ["space"]
+    },
+    {
+      id: "zone-arcade-strip",
+      streetId: s2.id,
+      streetLabel: s2.label,
+      rect: { minX: x2, maxX: x2Max, minY: columnMinY, maxY: columnMaxY },
+      primaryGroup: "arcade",
+      allowedGroups: ["arcade"]
+    }
+  ];
+}
+function layoutHasParkingZone(layout) {
+  return layout.zones.some((z) => z.primaryGroup === "parking");
+}
+function streetsFromLayoutWithParking(layout) {
+  const agent = primaryZoneForGroup(layout, "agent");
+  const space = primaryZoneForGroup(layout, "space");
+  const arcade = primaryZoneForGroup(layout, "arcade");
+  const parking = primaryZoneForGroup(layout, "parking");
+  if (agent === void 0 || space === void 0 || arcade === void 0 || parking === void 0) {
+    throw new Error("streetsFromLayoutWithParking: missing primary zone");
+  }
+  return [
+    { id: agent.streetId, label: agent.streetLabel },
+    { id: space.streetId, label: space.streetLabel },
+    { id: arcade.streetId, label: arcade.streetLabel },
+    { id: parking.streetId, label: parking.streetLabel }
+  ];
+}
 function streetsFromLayoutPrimaryGroups(layout) {
   const picks = PRIMARY_GROUP_ORDER.map((g) => {
     const zone = primaryZoneForGroup(layout, g);
@@ -403,6 +558,14 @@ function streetsFromLayoutPrimaryGroups(layout) {
 }
 function migrateWorldLayoutBounds(input) {
   assertValidLayoutBounds(input.bounds);
+  if (layoutHasParkingZone(input.layout)) {
+    const streets2 = streetsFromLayoutWithParking(input.layout);
+    const reseeded2 = createWorldLayoutWithParkingRow({
+      bounds: input.bounds,
+      streets: streets2
+    });
+    return { ...reseeded2, rev: input.layout.rev + 1 };
+  }
   const streets = streetsFromLayoutPrimaryGroups(input.layout);
   const reseeded = createVerticalStripSeedLayout({
     bounds: input.bounds,
@@ -410,6 +573,72 @@ function migrateWorldLayoutBounds(input) {
   });
   return { ...reseeded, rev: input.layout.rev + 1 };
 }
+function layoutNeedsParkingColumnGapMigration(layout) {
+  if (!layoutHasParkingZone(layout)) {
+    return false;
+  }
+  const agent = primaryZoneForGroup(layout, "agent");
+  const parking = primaryZoneForGroup(layout, "parking");
+  if (agent === void 0 || parking === void 0) {
+    return false;
+  }
+  const expectedParkingMinY = parkingZoneMinYFromColumnBase(agent.rect.minY);
+  return parking.rect.minY < expectedParkingMinY;
+}
+function migrateLayoutToParkingColumnGap(layout) {
+  const normalized = normalizeLegacyWorldLayout(layout);
+  if (!layoutNeedsParkingColumnGapMigration(normalized)) {
+    return normalized;
+  }
+  const streets = streetsFromLayoutWithParking(normalized);
+  const { minX, minY, maxX } = normalized.bounds;
+  const requiredMaxY = parkingZoneMaxYFromColumnBase(minY);
+  const nextBounds = {
+    minX,
+    minY,
+    maxX,
+    maxY: Math.max(normalized.bounds.maxY, requiredMaxY)
+  };
+  const reseeded = createWorldLayoutWithParkingRow({
+    bounds: nextBounds,
+    streets
+  });
+  return { ...reseeded, rev: normalized.rev + 1 };
+}
+function migrateLayoutToParkingRow(layout) {
+  const normalized = normalizeLegacyWorldLayout(layout);
+  if (layoutHasParkingZone(normalized)) {
+    return normalized;
+  }
+  const agent = primaryZoneForGroup(normalized, "agent");
+  const space = primaryZoneForGroup(normalized, "space");
+  const arcade = primaryZoneForGroup(normalized, "arcade");
+  if (agent === void 0 || space === void 0 || arcade === void 0) {
+    throw new Error("migrateLayoutToParkingRow: missing column zone");
+  }
+  const parkingStreet = nextStreetFromPool(
+    new Set(normalized.streets.map((s) => s.id))
+  );
+  if (parkingStreet === void 0) {
+    throw new Error("migrateLayoutToParkingRow: no street available in pool");
+  }
+  const nextBounds = {
+    ...normalized.bounds,
+    maxY: Math.max(
+      normalized.bounds.maxY,
+      parkingZoneMaxYFromColumnBase(normalized.bounds.minY)
+    )
+  };
+  return createWorldLayoutWithParkingRow({
+    bounds: nextBounds,
+    streets: [
+      { id: agent.streetId, label: agent.streetLabel },
+      { id: space.streetId, label: space.streetLabel },
+      { id: arcade.streetId, label: arcade.streetLabel },
+      parkingStreet
+    ]
+  });
+}
 function applyBoundsFieldUpdateToLayout(input) {
   assertIntegerBoundsValue(input.value, input.field);
   const nextBounds = {
@@ -419,61 +648,19 @@ function applyBoundsFieldUpdateToLayout(input) {
   return migrateWorldLayoutBounds({ layout: input.layout, bounds: nextBounds });
 }
 function createVerticalStripSeedLayout(input) {
-  const { minX, maxX, minY, maxY } = input.bounds;
-  const spanX = maxX - minX + 1;
-  if (spanX < 3) {
-    throw new Error("createVerticalStripSeedLayout: bounds spanX too small");
-  }
-  const widths = spanX === 20 ? [7, 7, 6] : (() => {
-    const w02 = Math.floor(spanX / 3);
-    const w12 = Math.floor((spanX - w02) / 2);
-    const w22 = spanX - w02 - w12;
-    return [w02, w12, w22];
-  })();
-  const w0 = widths[0];
-  const w1 = widths[1];
-  const w2 = widths[2];
-  if (w0 === void 0 || w1 === void 0 || w2 === void 0) {
-    throw new Error("createVerticalStripSeedLayout: width partition failed");
-  }
-  const x0 = minX;
-  const x0Max = x0 + w0 - 1;
-  const x1 = x0Max + 1;
-  const x1Max = x1 + w1 - 1;
-  const x2 = x1Max + 1;
-  const x2Max = x2 + w2 - 1;
+  const { minY, maxY } = input.bounds;
+  const zones = buildColumnZones({
+    bounds: input.bounds,
+    columnMinY: minY,
+    columnMaxY: maxY,
+    streets: input.streets
+  });
   const s0 = input.streets[0];
   const s1 = input.streets[1];
   const s2 = input.streets[2];
   if (s0 === void 0 || s1 === void 0 || s2 === void 0) {
     throw new Error("createVerticalStripSeedLayout: expected three streets");
   }
-  const zones = [
-    {
-      id: "zone-agent-strip",
-      streetId: s0.id,
-      streetLabel: s0.label,
-      rect: { minX: x0, maxX: x0Max, minY, maxY },
-      primaryGroup: "agent",
-      allowedGroups: ["agent"]
-    },
-    {
-      id: "zone-space-strip",
-      streetId: s1.id,
-      streetLabel: s1.label,
-      rect: { minX: x1, maxX: x1Max, minY, maxY },
-      primaryGroup: "space",
-      allowedGroups: ["space"]
-    },
-    {
-      id: "zone-arcade-strip",
-      streetId: s2.id,
-      streetLabel: s2.label,
-      rect: { minX: x2, maxX: x2Max, minY, maxY },
-      primaryGroup: "arcade",
-      allowedGroups: ["arcade"]
-    }
-  ];
   const streets = [
     streetFromPoolEntry(s0),
     streetFromPoolEntry(s1),
@@ -486,6 +673,62 @@ function createVerticalStripSeedLayout(input) {
     streets
   };
 }
+function createWorldLayoutWithParkingRow(input) {
+  const { minX, maxX, minY, maxY } = input.bounds;
+  const spanX = maxX - minX + 1;
+  if (spanX < 3) {
+    throw new Error("createWorldLayoutWithParkingRow: bounds spanX too small");
+  }
+  const requiredSpanY = Math.ceil(
+    COLUMN_STREET_ROW_HEIGHT + PARKING_COLUMN_GAP_ROWS + PARKING_STREET_ROW_HEIGHT
+  );
+  const actualSpanY = maxY - minY + 1;
+  if (actualSpanY < requiredSpanY) {
+    throw new Error(
+      `createWorldLayoutWithParkingRow: spanY must be >= ${String(requiredSpanY)}`
+    );
+  }
+  const columnMinY = minY;
+  const columnMaxY = minY + COLUMN_STREET_ROW_HEIGHT - 1;
+  const parkingMinY = parkingZoneMinYFromColumnBase(columnMinY);
+  const parkingMaxY = parkingMinY + PARKING_STREET_ROW_HEIGHT - 1;
+  if (parkingMaxY > maxY) {
+    throw new Error("createWorldLayoutWithParkingRow: parking band exceeds bounds");
+  }
+  const s0 = input.streets[0];
+  const s1 = input.streets[1];
+  const s2 = input.streets[2];
+  const s3 = input.streets[3];
+  if (s0 === void 0 || s1 === void 0 || s2 === void 0 || s3 === void 0) {
+    throw new Error("createWorldLayoutWithParkingRow: expected four streets");
+  }
+  const columnZones = buildColumnZones({
+    bounds: input.bounds,
+    columnMinY,
+    columnMaxY,
+    streets: [s0, s1, s2]
+  });
+  const parkingZone = {
+    id: "zone-parking-strip",
+    streetId: s3.id,
+    streetLabel: s3.label,
+    rect: { minX, maxX, minY: parkingMinY, maxY: parkingMaxY },
+    primaryGroup: "parking",
+    allowedGroups: ["parking"]
+  };
+  const streets = [
+    streetFromPoolEntry(s0),
+    streetFromPoolEntry(s1),
+    streetFromPoolEntry(s2),
+    streetFromPoolEntry(s3)
+  ];
+  return {
+    rev: 1,
+    bounds: input.bounds,
+    zones: [...columnZones, parkingZone],
+    streets
+  };
+}
 
 // ../../node_modules/zod/v3/external.js
 var external_exports = {};
@@ -4621,6 +4864,8 @@ var PurchaseRecordSchema = external_exports.object({
     "shop",
     "supermarket",
     "car_wash",
+    "parking",
+    "house",
     "talk_time",
     "wallet_bundle",
     "apu_credit",
@@ -4631,6 +4876,8 @@ var PurchaseRecordSchema = external_exports.object({
       "shop",
       "supermarket",
       "carwash",
+      "parking",
+      "house",
       "game",
       "apu",
       "talk",
@@ -4661,6 +4908,409 @@ function desaturateColor(hex) {
   return y << 16 | y << 8 | y;
 }
 
+// src/lib/parking-pricing.ts
+var PARKING_DURATION_TIERS = [
+  "1h",
+  "12h",
+  "1d",
+  "3d",
+  "7d",
+  "1mo",
+  "3mo",
+  "1y",
+  "forever"
+];
+var HOURS_PER_TIER = {
+  "1h": 1,
+  "12h": 12,
+  "1d": 24,
+  "3d": 72,
+  "7d": 168,
+  "1mo": 24 * 30,
+  "3mo": 24 * 90,
+  "1y": 24 * 365,
+  forever: null
+};
+var DEFAULT_PARKING_RATES_USD = {
+  "1h": 0.75,
+  "12h": 3.5,
+  "1d": 5,
+  "3d": 12,
+  "7d": 22,
+  "1mo": 65,
+  "3mo": 165,
+  "1y": 480,
+  forever: 750
+};
+var effectiveHourlyRateUsd = (tier) => {
+  const hours = HOURS_PER_TIER[tier];
+  if (hours === null) {
+    return DEFAULT_PARKING_RATES_USD.forever;
+  }
+  return DEFAULT_PARKING_RATES_USD[tier] / hours;
+};
+var computeParkingExpiresAt = (input) => {
+  if (input.tier === "forever") {
+    return null;
+  }
+  const hours = HOURS_PER_TIER[input.tier];
+  if (hours === null) {
+    return null;
+  }
+  const purchasedAt = new Date(input.purchasedAtIso);
+  if (Number.isNaN(purchasedAt.getTime())) {
+    throw new Error("computeParkingExpiresAt: invalid purchasedAtIso");
+  }
+  return new Date(purchasedAt.getTime() + hours * 60 * 60 * 1e3).toISOString();
+};
+var isParkingOccupantActive = (input) => {
+  if (input.expiresAt === null) {
+    return true;
+  }
+  const expires = new Date(input.expiresAt).getTime();
+  const now = new Date(input.nowIso).getTime();
+  if (Number.isNaN(expires) || Number.isNaN(now)) {
+    return false;
+  }
+  return expires > now;
+};
+
+// src/lib/parking-content-model.ts
+var NonEmpty2 = external_exports.string().trim().min(1);
+var IsoTimestamp2 = external_exports.string().trim().min(1);
+var PositivePrice2 = external_exports.number().finite().positive();
+var HexColor2 = external_exports.string().trim().regex(/^#[0-9a-fA-F]{6}$/, "expected #rrggbb hex color");
+var ParkingDurationTierSchema = external_exports.enum([
+  "1h",
+  "12h",
+  "1d",
+  "3d",
+  "7d",
+  "1mo",
+  "3mo",
+  "1y",
+  "forever"
+]);
+var ParkingBaySchema = external_exports.union([
+  external_exports.literal(1),
+  external_exports.literal(2),
+  external_exports.literal(3),
+  external_exports.literal(4)
+]);
+var ParkingLayerSchema = external_exports.union([external_exports.literal(1), external_exports.literal(2)]);
+var ParkingOccupantSchema = external_exports.object({
+  nodeId: NonEmpty2,
+  carPurchaseId: NonEmpty2,
+  displayNick: external_exports.string().trim().min(1).max(24),
+  colorHex: HexColor2,
+  model: NonEmpty2,
+  tier: ParkingDurationTierSchema,
+  purchasedAt: IsoTimestamp2,
+  expiresAt: IsoTimestamp2.nullable()
+});
+var ParkingSpotSchema = external_exports.object({
+  id: NonEmpty2,
+  bay: ParkingBaySchema,
+  layer: ParkingLayerSchema,
+  occupant: ParkingOccupantSchema.nullable()
+});
+var ParkingStreetContentSchema = external_exports.object({
+  spots: external_exports.array(ParkingSpotSchema).length(8),
+  rates: external_exports.record(ParkingDurationTierSchema, PositivePrice2)
+});
+var PARKING_BAY_COUNT = 4;
+var PARKING_LAYERS_PER_BAY = 2;
+var PARKING_SPOT_COUNT = PARKING_BAY_COUNT * PARKING_LAYERS_PER_BAY;
+var spotIdFor = (bay, layer) => `parking-bay-${String(bay)}-layer-${String(layer)}`;
+var createEmptyParkingStreetContent = () => {
+  const spots = [];
+  for (let bay = 1; bay <= PARKING_BAY_COUNT; bay += 1) {
+    for (let layer = 1; layer <= PARKING_LAYERS_PER_BAY; layer += 1) {
+      spots.push({
+        id: spotIdFor(bay, layer),
+        bay,
+        layer,
+        occupant: null
+      });
+    }
+  }
+  return ParkingStreetContentSchema.parse({
+    spots,
+    rates: { ...DEFAULT_PARKING_RATES_USD }
+  });
+};
+var listActiveParkingOccupancies = (content, nowIso) => {
+  const active = [];
+  for (const spot of content.spots) {
+    const occupant = spot.occupant;
+    if (occupant === null) {
+      continue;
+    }
+    if (occupant.expiresAt !== null && new Date(occupant.expiresAt).getTime() <= new Date(nowIso).getTime()) {
+      continue;
+    }
+    active.push({
+      nodeId: occupant.nodeId,
+      tier: occupant.tier,
+      expiresAt: occupant.expiresAt
+    });
+  }
+  return active;
+};
+var findParkingSpot = (content, bay, layer) => content.spots.find((s) => s.bay === bay && s.layer === layer);
+
+// src/lib/house-content-model.ts
+var NonEmpty3 = external_exports.string().trim().min(1);
+var IsoTimestamp3 = external_exports.string().trim().min(1);
+var PositivePrice3 = external_exports.number().finite().positive();
+var OwnerName = external_exports.string().trim().min(1).max(40);
+var OwnerSignature = external_exports.string().trim().min(1).max(8);
+var OwnerDisplayName = external_exports.string().trim().min(1).max(24);
+var HOUSE_WORLD_X = [3, 8, 13, 18];
+var HouseIdSchema = external_exports.union([
+  external_exports.literal(1),
+  external_exports.literal(2),
+  external_exports.literal(3),
+  external_exports.literal(4)
+]);
+var ParkingHouseBaySchema = external_exports.union([
+  external_exports.literal(1),
+  external_exports.literal(2),
+  external_exports.literal(3),
+  external_exports.literal(4)
+]);
+var HOUSE_CATALOG = [
+  { houseId: 1, bay: 1, priceUsd: 1299.99, layoutLabel: "Studio layout" },
+  { houseId: 2, bay: 2, priceUsd: 2199.99, layoutLabel: "Split room" },
+  { houseId: 3, bay: 3, priceUsd: 3499.99, layoutLabel: "L-shaped" },
+  { houseId: 4, bay: 4, priceUsd: 5999.99, layoutLabel: "Loft" }
+];
+var HouseSlotSchema = external_exports.object({
+  id: NonEmpty3,
+  houseId: HouseIdSchema,
+  bay: ParkingHouseBaySchema,
+  worldX: external_exports.number().finite(),
+  priceUsd: PositivePrice3,
+  layoutId: HouseIdSchema,
+  layoutLabel: NonEmpty3,
+  ownerNodeId: NonEmpty3.nullable(),
+  ownerDisplayName: OwnerDisplayName.nullable(),
+  ownerName: OwnerName.nullable(),
+  ownerSignature: OwnerSignature.nullable(),
+  purchasedAt: IsoTimestamp3.nullable()
+});
+var HouseStreetContentSchema = external_exports.object({
+  houses: external_exports.array(HouseSlotSchema).length(4)
+});
+var PARKING_HOUSE_COUNT = 4;
+var houseIdFor = (houseId) => `house-${String(houseId)}`;
+var createEmptyHouseStreetContent = () => {
+  const houses = HOUSE_CATALOG.map((entry, index) => {
+    const worldX = HOUSE_WORLD_X[index];
+    if (worldX === void 0) {
+      throw new Error("HOUSE_WORLD_X index mismatch");
+    }
+    return {
+      id: houseIdFor(entry.houseId),
+      houseId: entry.houseId,
+      bay: entry.bay,
+      worldX,
+      priceUsd: entry.priceUsd,
+      layoutId: entry.houseId,
+      layoutLabel: entry.layoutLabel,
+      ownerNodeId: null,
+      ownerDisplayName: null,
+      ownerName: null,
+      ownerSignature: null,
+      purchasedAt: null
+    };
+  });
+  return HouseStreetContentSchema.parse({ houses });
+};
+var findHouseSlot = (content, houseId) => content.houses.find((h) => h.houseId === houseId);
+var isHouseOwned = (house) => house.ownerNodeId !== null;
+var housePurchaseDetail = (house) => `House ${String(house.houseId)} \xB7 ${house.layoutLabel}`;
+var formatHouseOwnerDisplayName = (input) => {
+  const name = input.name.trim();
+  const signature = input.signature.trim().toUpperCase();
+  const divider = " \xB7 ";
+  const combined = `${name}${divider}${signature}`;
+  if (combined.length <= 24) {
+    return combined;
+  }
+  const suffix = `${divider}${signature}`;
+  const maxNameLen = 24 - suffix.length;
+  if (maxNameLen < 1) {
+    return signature.slice(0, 24);
+  }
+  return `${name.slice(0, maxNameLen)}${suffix}`;
+};
+var buildHouseOwnershipPanelLines = (house) => {
+  if (!isHouseOwned(house)) {
+    return [];
+  }
+  const ownerName = house.ownerName ?? house.ownerDisplayName ?? "Owner";
+  const ownerSignature = house.ownerSignature ?? "\u2014";
+  const purchasedAt = house.purchasedAt !== null ? new Date(house.purchasedAt).toLocaleDateString(void 0, {
+    dateStyle: "medium"
+  }) : "\u2014";
+  return [
+    "PROPERTY RECORD",
+    `Owner: ${ownerName}`,
+    `Signature: ${ownerSignature}`,
+    `Purchased: ${purchasedAt}`,
+    "Security: Node-verified title",
+    "Private residence \xB7 authorized entry only"
+  ];
+};
+
+// src/lib/house-layout-model.ts
+var BASE_BOUNDS = {
+  minX: 0,
+  minY: 0,
+  maxX: 10,
+  maxY: 7
+};
+var HOUSE_BLUEPRINTS = [
+  {
+    houseId: 1,
+    label: "Studio layout",
+    bounds: BASE_BOUNDS,
+    floor: { color: 12887412, pattern: "planks" },
+    exteriorPalette: {
+      wall: 16115400,
+      roof: 12986408,
+      door: 5125166,
+      window: 9489145,
+      trim: 16777215
+    },
+    fixtures: [
+      { kind: "bed", variant: "single-left", x: 2, y: 1.2 },
+      { kind: "wardrobe", variant: "single", x: 8.5, y: 1.5 },
+      { kind: "mirror", variant: "wall", x: 5, y: 0.4 },
+      { kind: "window", variant: "double", x: 1.5, y: 0.3 },
+      { kind: "window", variant: "single", x: 8, y: 0.3 }
+    ],
+    spawn: { x: 5, y: 5.5 }
+  },
+  {
+    houseId: 2,
+    label: "Split room",
+    bounds: BASE_BOUNDS,
+    floor: { color: 11583173, pattern: "tiles" },
+    exteriorPalette: {
+      wall: 15527921,
+      roof: 3622735,
+      door: 2503224,
+      window: 16774557,
+      trim: 7901340
+    },
+    fixtures: [
+      { kind: "bed", variant: "single-right", x: 8, y: 5 },
+      { kind: "wardrobe", variant: "double", x: 1.5, y: 1.5 },
+      { kind: "mirror", variant: "standing", x: 9, y: 2.5 },
+      { kind: "window", variant: "single", x: 3, y: 0.3 },
+      { kind: "window", variant: "single", x: 7, y: 0.3 }
+    ],
+    spawn: { x: 5, y: 3 }
+  },
+  {
+    houseId: 3,
+    label: "L-shaped",
+    bounds: BASE_BOUNDS,
+    floor: { color: 14142664, pattern: "carpet" },
+    exteriorPalette: {
+      wall: 15984117,
+      roof: 6953882,
+      door: 4854924,
+      window: 14794471,
+      trim: 13538264
+    },
+    fixtures: [
+      { kind: "bed", variant: "single-left", x: 1.5, y: 5.5 },
+      { kind: "wardrobe", variant: "single", x: 8.5, y: 5 },
+      { kind: "mirror", variant: "wall", x: 5, y: 0.4 },
+      { kind: "window", variant: "tall", x: 9, y: 0.3 },
+      { kind: "window", variant: "double", x: 2, y: 0.3 }
+    ],
+    spawn: { x: 5.5, y: 2.5 }
+  },
+  {
+    houseId: 4,
+    label: "Loft",
+    bounds: BASE_BOUNDS,
+    floor: { color: 6111287, pattern: "planks" },
+    exteriorPalette: {
+      wall: 9268835,
+      roof: 4073251,
+      door: 2171169,
+      window: 16772275,
+      trim: 6111287
+    },
+    fixtures: [
+      { kind: "bed", variant: "bunk", x: 7.5, y: 1 },
+      { kind: "wardrobe", variant: "double", x: 2, y: 4.5 },
+      { kind: "mirror", variant: "standing", x: 5, y: 4 },
+      { kind: "window", variant: "tall", x: 1, y: 0.3 },
+      { kind: "window", variant: "single", x: 6, y: 0.3 }
+    ],
+    spawn: { x: 4, y: 6 }
+  }
+];
+var getHouseBlueprint = (houseId) => {
+  const blueprint = HOUSE_BLUEPRINTS.find((b) => b.houseId === houseId);
+  if (blueprint === void 0) {
+    throw new Error(`getHouseBlueprint: unknown houseId ${String(houseId)}`);
+  }
+  return blueprint;
+};
+var layoutHouseFixtures = (blueprint) => blueprint.fixtures.map((fixture) => {
+  const slot = {
+    kind: fixture.kind,
+    variant: fixture.variant,
+    x: fixture.x,
+    y: fixture.y
+  };
+  if (fixture.rotation !== void 0) {
+    return { ...slot, rotation: fixture.rotation };
+  }
+  return slot;
+});
+var houseSpawnPosition = (blueprint) => ({
+  x: blueprint.spawn.x,
+  y: blueprint.spawn.y
+});
+var clampHousePosition = (blueprint, pos) => {
+  const { minX, minY, maxX, maxY } = blueprint.bounds;
+  return {
+    x: Math.min(maxX, Math.max(minX, pos.x)),
+    y: Math.min(maxY, Math.max(minY, pos.y))
+  };
+};
+
+// src/lib/parking-ownership.ts
+var MAX_TIMED_PARKING_SLOTS_PER_NODE = 2;
+var MAX_SLOTS_WITH_FOREVER = 1;
+var canNodeAcquireParkingSpot = (input) => {
+  const mine = input.active.filter((o) => o.nodeId === input.nodeId);
+  const hasForever = mine.some(
+    (o) => o.tier === "forever" || o.expiresAt === null
+  );
+  if (input.tier === "forever") {
+    if (mine.length > 0) {
+      return { ok: false, error: "PARKING_FOREVER_LIMIT" };
+    }
+    return { ok: true };
+  }
+  if (hasForever) {
+    return { ok: false, error: "PARKING_FOREVER_LIMIT" };
+  }
+  if (mine.length >= MAX_TIMED_PARKING_SLOTS_PER_NODE) {
+    return { ok: false, error: "PARKING_OWNERSHIP_LIMIT" };
+  }
+  return { ok: true };
+};
+
 // src/lib/wallet-apu-transaction.ts
 var APU_TOKEN = "APU";
 var buildApuWalletTransaction = (input) => {
@@ -4904,8 +5554,8 @@ var createEmptyGameStats = (date) => {
 };
 
 // src/lib/scanner-model.ts
-var NonEmpty2 = external_exports.string().trim().min(1);
-var IsoTimestamp2 = external_exports.string().trim().min(1);
+var NonEmpty4 = external_exports.string().trim().min(1);
+var IsoTimestamp4 = external_exports.string().trim().min(1);
 var ScannerTxOpSchema = external_exports.enum([
   "purchase",
   "redeemWalletBundle",
@@ -4916,8 +5566,8 @@ var ScannerTxOpSchema = external_exports.enum([
   "walletSeeded"
 ]);
 var ScannerTxRecordSchema = PurchaseRecordSchema.extend({
-  hostId: NonEmpty2,
-  indexedAt: IsoTimestamp2,
+  hostId: NonEmpty4,
+  indexedAt: IsoTimestamp4,
   op: ScannerTxOpSchema,
   blockRev: external_exports.number().int().nonnegative().optional(),
   merkleRootHex: external_exports.string().optional()
@@ -4926,7 +5576,7 @@ var ScannerBlockRecordSchema = external_exports.object({
   rev: external_exports.number().int().nonnegative(),
   merkleRootHex: external_exports.string(),
   merkleLeafCount: external_exports.number().int().nonnegative(),
-  at: IsoTimestamp2,
+  at: IsoTimestamp4,
   occupantCount: external_exports.number().int().nonnegative().optional(),
   leafDeltaCount: external_exports.number().int().nonnegative().optional(),
   label: external_exports.string().optional()
@@ -4941,19 +5591,19 @@ var ScannerMigrationStateSchema = external_exports.object({
   status: ScannerMigrationStatusSchema,
   cursor: external_exports.string(),
   totalIndexed: external_exports.number().int().nonnegative(),
-  startedAt: IsoTimestamp2,
-  completedAt: IsoTimestamp2.optional(),
+  startedAt: IsoTimestamp4,
+  completedAt: IsoTimestamp4.optional(),
   error: external_exports.string().optional()
 });
 var ScannerWalletSnapshotSchema = external_exports.object({
-  playerId: NonEmpty2,
+  playerId: NonEmpty4,
   balanceUsd: external_exports.number().finite().nonnegative(),
   powerUps: external_exports.number().int().nonnegative(),
-  updatedAt: IsoTimestamp2
+  updatedAt: IsoTimestamp4
 });
 var ScannerHeadSchema = external_exports.object({
-  generatedAt: IsoTimestamp2,
-  hostId: NonEmpty2,
+  generatedAt: IsoTimestamp4,
+  hostId: NonEmpty4,
   snapshotRev: external_exports.number().int().nonnegative(),
   merkleRootHex: external_exports.string().nullable(),
   merkleLeafCount: external_exports.number().int().nonnegative().nullable(),
@@ -4968,14 +5618,14 @@ var ScannerNodeWalletSchema = external_exports.object({
   balanceUsd: external_exports.number().finite().nonnegative(),
   powerUps: external_exports.number().int().nonnegative(),
   currency: external_exports.literal("USD"),
-  updatedAt: IsoTimestamp2
+  updatedAt: IsoTimestamp4
 });
 var ScannerNodeLedgerKpisSchema = external_exports.object({
   txCount: external_exports.number().int().nonnegative(),
   usdSpent: external_exports.number().finite().nonnegative(),
   apuMinted: external_exports.number().int().nonnegative(),
   apuBurned: external_exports.number().int().nonnegative(),
-  lastTxAt: IsoTimestamp2.nullable()
+  lastTxAt: IsoTimestamp4.nullable()
 });
 var ScannerNodeBreakdownSchema = external_exports.object({
   byAmenityKind: external_exports.record(external_exports.string(), external_exports.number().int().nonnegative()),
@@ -4989,15 +5639,15 @@ var ScannerNodeAnalyticsKpisSchema = external_exports.object({
   eventsLast24h: external_exports.number().int().nonnegative(),
   topEvents: external_exports.array(
     external_exports.object({
-      event: NonEmpty2,
+      event: NonEmpty4,
       count: external_exports.number().int().nonnegative()
     })
   )
 });
 var ScannerNodeProfileSchema = external_exports.object({
-  nodeId: NonEmpty2,
+  nodeId: NonEmpty4,
   kind: ScannerNodeKindSchema,
-  generatedAt: IsoTimestamp2,
+  generatedAt: IsoTimestamp4,
   wallet: ScannerNodeWalletSchema.nullable(),
   ledger: ScannerNodeLedgerKpisSchema,
   breakdown: ScannerNodeBreakdownSchema,
@@ -5021,10 +5671,10 @@ var ScannerNodeProfileSchema = external_exports.object({
   }).nullable(),
   analyticsEvents: external_exports.array(
     external_exports.object({
-      messageId: NonEmpty2,
-      event: NonEmpty2,
-      distinctId: NonEmpty2,
-      timestamp: IsoTimestamp2,
+      messageId: NonEmpty4,
+      event: NonEmpty4,
+      distinctId: NonEmpty4,
+      timestamp: IsoTimestamp4,
       properties: external_exports.record(
         external_exports.union([external_exports.string(), external_exports.number(), external_exports.boolean(), external_exports.null()])
       )
@@ -5038,8 +5688,8 @@ var ScannerNodeProfileSchema = external_exports.object({
 });
 
 // src/lib/analytics-event-model.ts
-var NonEmpty3 = external_exports.string().trim().min(1);
-var IsoTimestamp3 = external_exports.string().trim().min(1);
+var NonEmpty5 = external_exports.string().trim().min(1);
+var IsoTimestamp5 = external_exports.string().trim().min(1);
 var AnalyticsPropertyValueSchema = external_exports.union([
   external_exports.string(),
   external_exports.number(),
@@ -5047,23 +5697,23 @@ var AnalyticsPropertyValueSchema = external_exports.union([
   external_exports.null()
 ]);
 var AnalyticsContextSchema = external_exports.object({
-  hostId: NonEmpty3,
+  hostId: NonEmpty5,
   sid: external_exports.string().optional(),
   snapshotRev: external_exports.number().int().nonnegative().optional(),
   library: external_exports.enum(["agent-play-server", "agent-play-client"])
 });
 var AnalyticsEventSchema = external_exports.object({
-  messageId: NonEmpty3,
-  event: NonEmpty3,
-  distinctId: NonEmpty3,
-  timestamp: IsoTimestamp3,
+  messageId: NonEmpty5,
+  event: NonEmpty5,
+  distinctId: NonEmpty5,
+  timestamp: IsoTimestamp5,
   properties: external_exports.record(AnalyticsPropertyValueSchema),
   context: AnalyticsContextSchema.optional()
 });
 var AnalyticsTraitsSchema = external_exports.object({
-  distinctId: NonEmpty3,
+  distinctId: NonEmpty5,
   traits: external_exports.record(AnalyticsPropertyValueSchema),
-  timestamp: IsoTimestamp3
+  timestamp: IsoTimestamp5
 });
 var AnalyticsMigrationStatusSchema = external_exports.enum([
   "pending",
@@ -5075,8 +5725,8 @@ var AnalyticsMigrationStateSchema = external_exports.object({
   status: AnalyticsMigrationStatusSchema,
   cursor: external_exports.string(),
   totalIndexed: external_exports.number().int().nonnegative(),
-  startedAt: IsoTimestamp3,
-  completedAt: IsoTimestamp3.optional(),
+  startedAt: IsoTimestamp5,
+  completedAt: IsoTimestamp5.optional(),
   error: external_exports.string().optional()
 });
 var ANALYTICS_EVENT_NAMES = {
@@ -5522,6 +6172,12 @@ function mergeSnapshotWithPlayerChainNode(snapshot, node) {
 export {
   MINIMUM_PLAY_WORLD_BOUNDS,
   MINIMUM_STREET_LAYOUT_BOUNDS,
+  COLUMN_STREET_ROW_HEIGHT,
+  PARKING_STREET_ROW_HEIGHT,
+  PARKING_COLUMN_GAP_ROWS,
+  parkingZoneMinYFromColumnBase,
+  parkingZoneMaxYFromColumnBase,
+  DEFAULT_LAYOUT_BOUNDS_WITH_PARKING,
   expandBoundsToMinimumPlayArea,
   clampWorldPosition,
   boundsContain,
@@ -5565,9 +6221,14 @@ export {
   availableCellsForZone,
   isAgentSpawnOccupancyPointAvailableInZone,
   isSpaceAnchorOccupancyPointAvailableInZone,
+  layoutHasParkingZone,
   migrateWorldLayoutBounds,
+  layoutNeedsParkingColumnGapMigration,
+  migrateLayoutToParkingColumnGap,
+  migrateLayoutToParkingRow,
   applyBoundsFieldUpdateToLayout,
   createVerticalStripSeedLayout,
+  createWorldLayoutWithParkingRow,
   SaleStateSchema,
   ShopItemSchema,
   SupermarketItemSchema,
@@ -5579,6 +6240,40 @@ export {
   PurchaseRecordSchema,
   isItemAvailableForPurchase,
   desaturateColor,
+  PARKING_DURATION_TIERS,
+  DEFAULT_PARKING_RATES_USD,
+  effectiveHourlyRateUsd,
+  computeParkingExpiresAt,
+  isParkingOccupantActive,
+  ParkingDurationTierSchema,
+  ParkingSpotSchema,
+  ParkingStreetContentSchema,
+  PARKING_BAY_COUNT,
+  PARKING_LAYERS_PER_BAY,
+  PARKING_SPOT_COUNT,
+  createEmptyParkingStreetContent,
+  listActiveParkingOccupancies,
+  findParkingSpot,
+  HOUSE_WORLD_X,
+  HouseIdSchema,
+  HOUSE_CATALOG,
+  HouseSlotSchema,
+  HouseStreetContentSchema,
+  PARKING_HOUSE_COUNT,
+  createEmptyHouseStreetContent,
+  findHouseSlot,
+  isHouseOwned,
+  housePurchaseDetail,
+  formatHouseOwnerDisplayName,
+  buildHouseOwnershipPanelLines,
+  HOUSE_BLUEPRINTS,
+  getHouseBlueprint,
+  layoutHouseFixtures,
+  houseSpawnPosition,
+  clampHousePosition,
+  MAX_TIMED_PARKING_SLOTS_PER_NODE,
+  MAX_SLOTS_WITH_FOREVER,
+  canNodeAcquireParkingSpot,
   APU_TOKEN,
   buildApuWalletTransaction,
   buildAmenityPurchaseApuFields,
@@ -5636,4 +6331,4 @@ export {
   parsePlayerChainNodeRpcBody,
   mergeSnapshotWithPlayerChainNode
 };
-//# sourceMappingURL=chunk-Z2PYRHFU.js.map
+//# sourceMappingURL=chunk-WTI6DVRD.js.map