create-planet 1.0.0

package/template/PROTOCOL_DIAGRAMS.md

@@ -0,0 +1,195 @@
+# Space Travel Protocol: Sequence Diagram
+
+The following diagram illustrates the lifecycle of a travel transaction using the **Elected Traffic Controllers (ETC)** consensus protocol.
+
+```mermaid
+sequenceDiagram
+    participant Traveler as 🚀 Ship Browser
+    participant DO as TrafficControl DO
+    participant Origin as 🌍 Origin Space Port
+    participant Dest as 🌍 Destination Space Port
+    participant KV as KV Store
+    participant D1 as D1 Database
+    participant TCs as 🌐 Elected Traffic Controllers (3f+1)
+
+    Note over Traveler, Dest: PHASE 1: INITIATION & SORTITION
+    Traveler->>Origin: POST /initiate (Destination, ShipID)
+    par Parallel discovery
+        Origin->>D1: Lookup cached manifests for origin neighbors
+        D1-->>Origin: Origin neighbor manifests
+        opt Cache miss
+            Origin->>Dest: Fetch space-manifest link + manifest JSON
+            Dest-->>Origin: PlanetManifest (name, landing_site, space_port)
+            Origin->>D1: Store manifest in traffic_controllers cache
+        end
+    and
+        Origin->>Dest: GET ?action=neighbors
+        Dest-->>Origin: Dest neighbor manifests
+    end
+    Origin->>Origin: Calculate 3D Coordinates & Travel Time
+    Note over Origin: Mandatory TCs: Origin + Destination
+    Note over Origin: Elected TCs: half from origin neighbors, half from dest neighbors
+    Origin->>Origin: Elect TCs (seed-based sortition, dedup)
+    Origin->>KV: Read Ed25519 identity keys (identity_public/private)
+    KV-->>Origin: Key pair
+    Origin->>Origin: Sign Plan (Ed25519)
+    Origin->>KV: Save consensus plan state (consensus_plan_{id})
+    par Fire-and-forget
+        Origin-->>DO: INITIATE_TRAVEL event
+    and Parallel POST ×N
+        Origin->>TCs: PRE-PREPARE (Signed Plan)
+    end
+
+    Note over TCs, KV: PHASE 2: CONSENSUS (PBFT)
+    loop Each Traffic Controller
+        TCs->>TCs: Verify Plan integrity (coordinates & travel time)
+        TCs->>KV: Read own identity keys
+        TCs->>TCs: Sign Plan
+        TCs->>KV: Merge signatures into consensus plan state
+        par Fire-and-forget
+            TCs-->>DO: PREPARE_PLAN event
+        and Parallel POST ×N
+            TCs->>TCs: COMMIT (Signed Plan)
+        end
+    end
+
+    Note over Origin, D1: PHASE 3: RECORDING & TRANSIT
+    Origin->>KV: Read accumulated signatures (consensus_plan_{id})
+    Origin->>Origin: Check quorum (2f+1 signatures reached)
+    Origin->>Dest: POST ?action=register (Approved Plan)
+    Dest->>Dest: Verify destination URL
+    Dest->>Dest: Verify travel time math
+    Dest->>Dest: Verify end_timestamp not expired (anti-cheat)
+    Dest->>Dest: Verify quorum (2f+1 signatures)
+    Dest->>D1: Store plan (incoming traffic)
+    Dest-->>Origin: 200 OK
+    Origin->>D1: Persist Approved Plan (travel_plans, status=PLAN_ACCEPTED)
+    Origin->>DO: Broadcast QUORUM_REACHED event
+    DO-->>Traveler: WebSocket push (status updates to live UI)
+    Origin-->>Traveler: 200 OK (Travel Authorized)
+
+    Note over Origin, Traveler: Ship Status: PREPARING
+
+    rect rgb(20, 25, 35)
+        Note right of Origin: Wait for Start_Timestamp
+    end
+
+    Note over Origin, Traveler: Ship Status: DEPARTING / IN TRANSIT (UI label)
+    Note over Traveler: Ship Status: INCOMING (ETA displayed)
+
+    rect rgb(20, 25, 35)
+        Note right of Origin: Wait for End_Timestamp
+    end
+
+    Note over Traveler: Ship Status: ARRIVED (client-side only)
+```
+
+## Protocol Summary
+
+1.  **Initiation:** The origin discovers its own neighbors and the destination's neighbors, then elects TCs: origin and destination are mandatory participants; remaining slots filled half from each neighbor pool.
+2.  **Consensus:** All elected TCs (including origin and destination) validate and sign the plan. Quorum requires $2f+1$ signatures; since origin and destination are both mandatory TCs, both must contribute.
+3.  **Recording:** Once quorum is reached, origin synchronously registers the plan with the destination (which verifies and stores it). Only after the destination confirms does origin persist the plan locally, broadcast the WebSocket event, and return 200 OK to the traveler.
+4.  **Transit:** Time is enforced by the federation; arrival status is tracked client-side via ETA timestamps.
+
+## Data Storage
+
+| Store              | Purpose                                                   | Durability                        |
+| ------------------ | --------------------------------------------------------- | --------------------------------- |
+| **D1**             | `travel_plans`, `traffic_controllers` cache               | Persistent                        |
+| **KV**             | Ed25519 identity key pair, in-flight consensus plan state | Persistent (keys), TTL 1h (plans) |
+| **Durable Object** | WebSocket sessions, last-50 event ring buffer             | In-memory only (volatile)         |
+
+## Plan Data State Diagram
+
+Server-side status stored in `travel_plans.status` (D1) and the in-flight KV plan:
+
+```mermaid
+stateDiagram-v2
+    [*] --> PREPARING : Origin creates plan (handleInitiate)
+    PREPARING --> PLAN_ACCEPTED : Quorum reached (2f+1 sigs) (handleCommit → D1 insert)
+    PLAN_ACCEPTED --> [*] : end_timestamp passes (no server transition — record kept forever)
+
+    note right of PREPARING
+        Stored in KV only
+        (consensus_plan_{id})
+    end note
+
+    note right of PLAN_ACCEPTED
+        Persisted to D1 travel_plans
+        Registered at destination (fire-and-forget)
+        KV entry expires after TTL
+    end note
+```
+
+## Plan UI Labels State Diagram
+
+Client-side display labels derived from server status + timestamps:
+
+```mermaid
+stateDiagram-v2
+    [*] --> SCHEDULED : status=PLAN_ACCEPTED start_timestamp in future (outgoing row at origin)
+    [*] --> INCOMING : status=PLAN_ACCEPTED (incoming row at destination)
+    SCHEDULED --> IN_TRANSIT : start_timestamp reached
+    INCOMING --> IN_TRANSIT : start_timestamp reached
+    IN_TRANSIT --> ARRIVED : end_timestamp reached
+    ARRIVED --> [*] : 5 s linger then row moves to archive section
+
+    note right of SCHEDULED
+        CSS: status-scheduled
+        Label: "SCHEDULED"
+    end note
+    note right of INCOMING
+        CSS: status-transit
+        Label: "IN TRANSIT"
+    end note
+    note right of IN_TRANSIT
+        CSS: status-transit
+        Label: "IN TRANSIT"
+    end note
+    note right of ARRIVED
+        CSS: status-arrived
+        Label: "ARRIVED"
+        (client-side only — no DB write)
+    end note
+```
+
+## Entity-Relationship Diagram
+
+```mermaid
+erDiagram
+    TRAVEL_PLANS {
+        TEXT id PK
+        TEXT ship_id
+        TEXT origin_url
+        TEXT destination_url
+        INTEGER start_timestamp
+        INTEGER end_timestamp
+        TEXT status "PREPARING | PLAN_ACCEPTED"
+        TEXT signatures "JSON: planet_url→Ed25519 sig"
+    }
+
+    TRAFFIC_CONTROLLERS {
+        TEXT planet_url PK
+        TEXT name
+        TEXT space_port_url
+        INTEGER last_manifest_fetch "Unix ms, TTL 1h"
+    }
+
+    KV_IDENTITY {
+        TEXT identity_public "Ed25519 public key (Base64)"
+        TEXT identity_private "Ed25519 private key (Base64)"
+    }
+
+    KV_CONSENSUS {
+        TEXT consensus_plan_id PK "consensus_plan_{uuid}"
+        TEXT plan_json "TravelPlan with accumulated sigs"
+    }
+
+    DO_TRAFFIC_CONTROL {
+        SET sessions "Active WebSocket connections"
+        ARRAY events "Ring buffer: last 50 API events"
+    }
+
+    TRAVEL_PLANS ||--o{ KV_CONSENSUS : "built during PBFT"
+    TRAVEL_PLANS }o--o{ TRAFFIC_CONTROLLERS : "controllers elected from"
+```

package/template/README.md

@@ -0,0 +1,51 @@
+# Planet Advanced Reference Implementation
+
+This repository serves as an **advanced reference implementation** for a planetary landing site in the [Federated Planets](https://github.com/Federated-Planets/federated-planets) universe, built with [Astro](https://astro.build) and optimized for running on [Cloudflare](https://workers.cloudflare.com/).
+
+In addition to the standard 3D Star Map, this implementation includes a functional **Space Port UI** template for tracking live traffic and mission archives, following the [Space Travel Protocol](https://github.com/Federated-Planets/federated-planets/blob/main/TRAVEL.md).
+
+For detailed information on how the Federated Planets world works, please refer to the [official specification](https://github.com/Federated-Planets/federated-planets).
+
+## Project Structure
+
+This project uses Astro to dynamically generate the landing site and calculate deterministic coordinates at build-time.
+
+- **`src/pages/index.astro`**: The main **Landing Site** template. Coordinate calculations are performed in the Astro frontmatter.
+- **`public/planet.css` & `public/map.js`**: Client-side styles and 3D ThreeJS interactivity.
+- **`public/manifest.json`**: The metadata file for your planet.
+- **`astro.config.mjs`**: Configuration for Astro and the `@astrojs/cloudflare` adapter.
+
+## Space Port UI
+
+The Space Port section in `index.astro` is designed to be updated via API or local state to show:
+
+- **Live Traffic:** Ships preparing, departing, or arriving.
+- **Mission Archive:** A historical log of recent arrivals and departures.
+- **3D Coordinates:** All locations in the UI use the standard federation `XXX.XX:YYY.YY:ZZZ.ZZ` format, calculated automatically from domain names.
+
+## Development and Build
+
+1.  **Install dependencies:**
+    ```bash
+    npm install
+    ```
+2.  **Local Development:**
+    ```bash
+    npm run dev
+    ```
+3.  **Build for Production:**
+    ```bash
+    npm run build
+    ```
+4.  **Local Preview (Wrangler):**
+    ```bash
+    npm run preview
+    ```
+
+## Deployment
+
+This project is configured for **Cloudflare Workers**.
+
+- **Build Command:** `npm run build`
+- **Output Directory:** `dist`
+- **Environment Variables:** Ensure you use **Node.js 20+** in your build environment.

package/template/astro.config.mjs

@@ -0,0 +1,20 @@
+import { defineConfig } from "astro/config";
+import cloudflare from "@astrojs/cloudflare";
+
+export default defineConfig({
+  output: "server",
+  adapter: cloudflare({
+    imageService: "cloudflare",
+    platformProxy: {
+      enabled: true,
+      configPath: "wrangler.build.jsonc",
+      persist: true,
+    },
+  }),
+  vite: {
+    ssr: {
+      external: ["cloudflare:workers"],
+      noExternal: true,
+    },
+  },
+});

package/template/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@federated-planets/planet",
+  "version": "1.0.0",
+  "description": "A decentralized space exploration game where every planet is a sovereign website.",
+  "scripts": {
+    "dev": "npm run build && wrangler dev -c wrangler.dev.jsonc",
+    "dev:db:init": "wrangler d1 execute planet_db --file=schema.sql --local -c wrangler.dev.jsonc",
+    "dev:clean": "rm -rf .wrangler/state",
+    "format": "prettier --write .",
+    "build": "astro build",
+    "postbuild": "node scripts/inject-do-exports.js",
+    "preview": "wrangler preview",
+    "simulate": "node scripts/simulate-universe.js",
+    "test": "npm run build && vitest run",
+    "test:protocol": "npm run build && vitest run src/tests/protocol.test.ts",
+    "test:warp-links": "npm run build && vitest run src/tests/warp-links.test.ts"
+  },
+  "dependencies": {
+    "@astrojs/cloudflare": "^13.1.4",
+    "astro": "^6.1.1",
+    "cheerio": "^1.2.0",
+    "md5": "^2.3.0",
+    "zod": "^3.25.76"
+  },
+  "type": "module",
+  "author": "Sergey Chernyshev",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@astrojs/check": "^0.9.8",
+    "@types/md5": "^2.3.6",
+    "miniflare": "^4.20260317.3",
+    "prettier": "^3.8.1",
+    "prettier-plugin-astro": "^0.14.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.2",
+    "wrangler": "^4.78.0"
+  }
+}

package/template/public/map.js

@@ -0,0 +1,329 @@
+// 3D Star Map using ThreeJS
+let scene, camera, renderer, planetsGroup;
+const planetPoints = [];
+const shipPoints = [];
+let selectedId = null;
+
+const initThree = () => {
+  const container = document.getElementById("three-container");
+  if (!container) return;
+
+  const rootStyle = getComputedStyle(document.documentElement);
+  const colorOutbound =
+    rootStyle.getPropertyValue("--color-outbound").trim() || "#e67e22";
+  const colorInbound =
+    rootStyle.getPropertyValue("--color-inbound").trim() || "#3498db";
+
+  scene = new THREE.Scene();
+  scene.background = new THREE.Color(
+    rootStyle.getPropertyValue("--map-bg").trim() || "#0b0e14",
+  );
+
+  const width = container.clientWidth;
+  const height = container.clientHeight;
+  camera = new THREE.PerspectiveCamera(45, width / height, 0.1, 5000);
+  camera.position.set(1500, 1500, 1500);
+  camera.lookAt(0, 0, 0);
+
+  renderer = new THREE.WebGLRenderer({ antialias: true });
+  renderer.setSize(width, height);
+  renderer.setPixelRatio(window.devicePixelRatio);
+  container.appendChild(renderer.domElement);
+
+  planetsGroup = new THREE.Group();
+  scene.add(planetsGroup);
+
+  const myX = parseFloat(document.body.dataset.myX) - 500;
+  const myY = parseFloat(document.body.dataset.myY) - 500;
+  const myZ = parseFloat(document.body.dataset.myZ) - 500;
+
+  const myPlanetGeo = new THREE.SphereGeometry(15, 32, 32);
+  const myPlanetMat = new THREE.MeshBasicMaterial({ color: 0x2ecc71 });
+  const myPlanet = new THREE.Mesh(myPlanetGeo, myPlanetMat);
+  myPlanet.position.set(myX, myY, myZ);
+  planetsGroup.add(myPlanet);
+
+  const pulseGeo = new THREE.SphereGeometry(20, 32, 32);
+  const pulseMat = new THREE.MeshBasicMaterial({
+    color: 0x2ecc71,
+    transparent: true,
+    opacity: 0.4,
+  });
+  const pulse = new THREE.Mesh(pulseGeo, pulseMat);
+  myPlanet.add(pulse);
+  myPlanet.userData.pulse = pulse;
+
+  document.querySelectorAll(".warp-links a").forEach((link) => {
+    const x = parseFloat(link.dataset.x) - 500;
+    const y = parseFloat(link.dataset.y) - 500;
+    const z = parseFloat(link.dataset.z) - 500;
+    const id = link.dataset.id;
+
+    const neighborGeo = new THREE.SphereGeometry(8, 16, 16);
+    const neighborMat = new THREE.MeshBasicMaterial({
+      color: 0x4a90e2,
+      transparent: true,
+      opacity: 0.6,
+    });
+    const neighbor = new THREE.Mesh(neighborGeo, neighborMat);
+    neighbor.position.set(x, y, z);
+    neighbor.userData = { id, originalColor: 0x4a90e2 };
+    planetsGroup.add(neighbor);
+    planetPoints.push(neighbor);
+
+    const points = [
+      new THREE.Vector3(myX, myY, myZ),
+      new THREE.Vector3(x, y, z),
+    ];
+    const lineGeo = new THREE.BufferGeometry().setFromPoints(points);
+    const lineMat = new THREE.LineDashedMaterial({
+      color: 0x4a90e2,
+      dashSize: 20,
+      gapSize: 10,
+      transparent: true,
+      opacity: 0,
+    });
+    const line = new THREE.Line(lineGeo, lineMat);
+    line.computeLineDistances();
+    line.userData = { id };
+    planetsGroup.add(line);
+    planetPoints.push(line);
+  });
+
+  // planId → { mesh, line } for removal on arrival
+  const shipObjects = new Map();
+
+  // Add Active Ships from Traffic
+  const shipsData = JSON.parse(container.dataset.ships || "[]");
+  shipsData.forEach((ship) => {
+    const ox = ship.originCoords.x - 500;
+    const oy = ship.originCoords.y - 500;
+    const oz = ship.originCoords.z - 500;
+    const dx = ship.destCoords.x - 500;
+    const dy = ship.destCoords.y - 500;
+    const dz = ship.destCoords.z - 500;
+
+    // Travel line
+    const linePoints = [
+      new THREE.Vector3(ox, oy, oz),
+      new THREE.Vector3(dx, dy, dz),
+    ];
+    const lineGeo = new THREE.BufferGeometry().setFromPoints(linePoints);
+    const shipLineColor =
+      ship.type === "incoming" ? colorInbound : colorOutbound;
+    const lineMat = new THREE.LineBasicMaterial({
+      color: new THREE.Color(shipLineColor),
+      transparent: true,
+      opacity: 0.7,
+    });
+    const travelLine = new THREE.Line(lineGeo, lineMat);
+    planetsGroup.add(travelLine);
+
+    // Ship mesh
+    const shipGeo = new THREE.TetrahedronGeometry(10);
+    const shipMat = new THREE.MeshBasicMaterial({ color: 0xf1c40f });
+    const shipMesh = new THREE.Mesh(shipGeo, shipMat);
+
+    shipMesh.userData = {
+      start: ship.rawPlan.start_timestamp,
+      end: ship.rawPlan.end_timestamp,
+      ox,
+      oy,
+      oz,
+      dx,
+      dy,
+      dz,
+    };
+
+    planetsGroup.add(shipMesh);
+    shipPoints.push(shipMesh);
+
+    if (ship.rawPlan.id)
+      shipObjects.set(ship.rawPlan.id, { mesh: shipMesh, line: travelLine });
+  });
+
+  const animate = () => {
+    requestAnimationFrame(animate);
+
+    planetsGroup.rotation.y += 0.002;
+    planetsGroup.rotation.x += 0.001;
+
+    if (myPlanet.userData.pulse) {
+      const s = 1 + Math.sin(Date.now() * 0.005) * 0.5;
+      myPlanet.userData.pulse.scale.set(s, s, s);
+      myPlanet.userData.pulse.material.opacity = 0.4 * (1 - (s - 0.5) / 1);
+    }
+
+    // Dynamic Ship Positioning (Lerp between origin and destination)
+    const now = Date.now();
+    shipPoints.forEach((s, i) => {
+      const { start, end, ox, oy, oz, dx, dy, dz } = s.userData;
+
+      let p = (now - start) / (end - start);
+      p = Math.max(0, Math.min(1, p));
+
+      s.position.set(
+        ox + (dx - ox) * p,
+        oy + (dy - oy) * p,
+        oz + (dz - oz) * p,
+      );
+      s.rotation.y += 0.05;
+    });
+
+    renderer.render(scene, camera);
+  };
+
+  animate();
+
+  window.addShipToScene = (ship) => {
+    const ox = ship.originCoords.x - 500;
+    const oy = ship.originCoords.y - 500;
+    const oz = ship.originCoords.z - 500;
+    const dx = ship.destCoords.x - 500;
+    const dy = ship.destCoords.y - 500;
+    const dz = ship.destCoords.z - 500;
+
+    const linePoints = [
+      new THREE.Vector3(ox, oy, oz),
+      new THREE.Vector3(dx, dy, dz),
+    ];
+    const lineGeo = new THREE.BufferGeometry().setFromPoints(linePoints);
+    const shipLineColor =
+      ship.type === "incoming" ? colorInbound : colorOutbound;
+    const lineMat = new THREE.LineBasicMaterial({
+      color: new THREE.Color(shipLineColor),
+      transparent: true,
+      opacity: 0.7,
+    });
+    const travelLine = new THREE.Line(lineGeo, lineMat);
+    planetsGroup.add(travelLine);
+
+    const shipGeo = new THREE.TetrahedronGeometry(10);
+    const shipMat = new THREE.MeshBasicMaterial({ color: 0xf1c40f });
+    const shipMesh = new THREE.Mesh(shipGeo, shipMat);
+    shipMesh.userData = {
+      start: ship.rawPlan.start_timestamp,
+      end: ship.rawPlan.end_timestamp,
+      ox,
+      oy,
+      oz,
+      dx,
+      dy,
+      dz,
+    };
+    planetsGroup.add(shipMesh);
+    shipPoints.push(shipMesh);
+
+    if (ship.rawPlan.id)
+      shipObjects.set(ship.rawPlan.id, { mesh: shipMesh, line: travelLine });
+  };
+
+  window.removeShipFromScene = (planId) => {
+    const objs = shipObjects.get(planId);
+    if (!objs) return;
+    planetsGroup.remove(objs.mesh);
+    planetsGroup.remove(objs.line);
+    const idx = shipPoints.indexOf(objs.mesh);
+    if (idx !== -1) shipPoints.splice(idx, 1);
+    shipObjects.delete(planId);
+  };
+
+  window.addEventListener("resize", () => {
+    const width = container.clientWidth;
+    const height = container.clientHeight;
+    renderer.setSize(width, height);
+    camera.aspect = width / height;
+    camera.updateProjectionMatrix();
+  });
+};
+
+const updateHighlight = (id, isActive) => {
+  const elements = document.querySelectorAll(`[data-id="${id}"]`);
+  elements.forEach((el) => {
+    if (isActive) el.classList.add("active");
+    else el.classList.remove("active");
+  });
+
+  const link = document.querySelector(`.warp-links a[data-id="${id}"]`);
+  if (link) {
+    const li = link.closest("li");
+    if (isActive) li.classList.add("active");
+    else li.classList.remove("active");
+  }
+
+  planetPoints.forEach((obj) => {
+    if (obj.userData.id === id) {
+      if (obj.isMesh) {
+        obj.material.opacity = isActive ? 1 : 0.6;
+        obj.scale.set(isActive ? 2 : 1, isActive ? 2 : 1, isActive ? 2 : 1);
+        obj.material.color.setHex(isActive ? 0xffffff : 0x4a90e2);
+      } else if (obj.isLine) {
+        obj.material.opacity = isActive ? 0.6 : 0;
+      }
+    }
+  });
+};
+
+const handleHover = (e) => {
+  const item = e.target.closest(".warp-links li");
+  if (!item) return;
+  const link = item.querySelector("a");
+  if (!link) return;
+  const id = link.dataset.id;
+  const isEnter = e.type === "mouseover" || e.type === "mouseenter";
+  if (isEnter) {
+    if (selectedId && selectedId !== id) updateHighlight(selectedId, false);
+    updateHighlight(id, true);
+  } else {
+    updateHighlight(id, false);
+    if (selectedId) updateHighlight(selectedId, true);
+  }
+};
+
+const handleClick = (e) => {
+  const item = e.target.closest(".warp-links li");
+  if (!item) return;
+  const link = item.querySelector("a");
+  if (!link) return;
+  const id = link.dataset.id;
+  if (e.target === link) return;
+  e.preventDefault();
+  if (selectedId && selectedId !== id) updateHighlight(selectedId, false);
+  selectedId = id;
+  updateHighlight(selectedId, true);
+  window.dispatchEvent(
+    new CustomEvent("planetSelected", {
+      detail: {
+        id: id,
+        name: link.dataset.name,
+        url: link.href,
+        x: parseFloat(link.dataset.x),
+        y: parseFloat(link.dataset.y),
+        z: parseFloat(link.dataset.z),
+        formatted: link.dataset.formatted,
+      },
+    }),
+  );
+};
+
+const initMap = () => {
+  initThree();
+  const warpRing = document.querySelector(".warp-links");
+  if (warpRing) {
+    warpRing.addEventListener("mouseover", handleHover);
+    warpRing.addEventListener("mouseout", handleHover);
+    warpRing.addEventListener("click", handleClick);
+  }
+  window.addEventListener("clearSelection", () => {
+    if (selectedId) {
+      updateHighlight(selectedId, false);
+      selectedId = null;
+    }
+  });
+};
+
+if (document.readyState === "loading") {
+  document.addEventListener("DOMContentLoaded", initMap);
+} else {
+  initMap();
+}