UMS generator expansion: network topology, power systems, side-view, portfolio, campaigns

Add 13 new ReScript modules and rewrite GeneratorDemo to evolve the procedural
level generator from a basic MVP into a full design tool:

- Side-view renderer (Gunpoint-style 2-floor cross-section with dark exterior,
  lit windows, device shapes, guard figures, Manhattan wiring)
- Network topology generation (per-zone subnets, core router, firewalls,
  device IP assignment, PBX detection — all deterministic from seed)
- Power circuit generation (zone-based circuits from power sources to loads,
  backup UPS detection)
- Live network/power state layer with gameplay mutation verbs (shortCircuit,
  severCable, reroute, spoofMac, repair, setTrap, propagateFailure) — all
  functional/immutable with event logging for replay
- Canvas overlays for network topology (nodes, edges, IPs, firewalls) and
  power circuits (sources, loads, circuit labels)
- Level export (generatedLevel -> levelConfig shipping format) and import
  (reverse direction for diagnostics/forking)
- A2ML metadata envelope wrapper
- Editor bridge (generatedLevel <-> Model.level for TEA editor integration)
- Building metadata generation (name, type, role, street, district, difficulty
  — all deterministic from seed via PRNG-driven lookup tables)
- Portfolio system (building collections with CRUD, JSON encode/decode with
  deterministic rebuild from seeds)
- Campaign graph (directed mission progression with Unlocks/Branches/DeadEnd/
  SideMission edge types, BFS reachability, orphan validation)
- Portfolio and Campaign React components (building list cards, campaign canvas
  with node-edge diagram, edge creation UI, validation warnings)
- VerisimDB/ArangoDB sync persistence stubs
- Hash-based routing in main.js for generator/editor switching
- Elixir sync server routes for portfolio and campaign CRUD

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: hyperpolymath

idaptik-ums/idaptik-sync-server/lib/idaptik_sync_server/router.ex

@@ -230,6 +230,170 @@ defmodule IDApixiTIK.SyncServer.Router do
     end
   end
 
+  # ---------------------------------------------------------------------------
+  # Portfolio & Campaign API — /db/portfolios/*, /db/campaigns/*
+  #
+  # Portfolios are collections of generated buildings stored as VerisimDB hexads.
+  # Campaign graphs define mission progression edges stored in ArangoDB.
+  # ---------------------------------------------------------------------------
+
+  # Save portfolio to VerisimDB
+  post "/db/portfolios" do
+    portfolio_id = Map.get(conn.body_params, "id")
+
+    case DatabaseBridge.save_level(portfolio_id, Map.put(conn.body_params, "type", "portfolio")) do
+      {:ok, result} ->
+        conn
+        |> put_resp_content_type("application/json")
+        |> send_resp(200, Jason.encode!(result))
+
+      {:error, {:validation, msg}} ->
+        send_resp(conn, 422, Jason.encode!(%{error: msg}))
+
+      {:error, :verisim_unavailable} ->
+        send_resp(conn, 503, Jason.encode!(%{error: "verisim_unavailable"}))
+
+      {:error, reason} ->
+        send_resp(conn, 500, Jason.encode!(%{error: inspect(reason)}))
+    end
+  end
+
+  # Get portfolio from VerisimDB
+  get "/db/portfolios/:id" do
+    case DatabaseBridge.get_level(id) do
+      {:ok, portfolio} ->
+        conn
+        |> put_resp_content_type("application/json")
+        |> send_resp(200, Jason.encode!(portfolio))
+
+      {:error, :not_found} ->
+        send_resp(conn, 404, Jason.encode!(%{error: "not_found"}))
+
+      {:error, :verisim_unavailable} ->
+        send_resp(conn, 503, Jason.encode!(%{error: "verisim_unavailable"}))
+
+      {:error, reason} ->
+        send_resp(conn, 500, Jason.encode!(%{error: inspect(reason)}))
+    end
+  end
+
+  # Search portfolios by name
+  get "/db/portfolios/search" do
+    query = Map.get(conn.query_params, "q", "")
+
+    case DatabaseBridge.search_levels(query) do
+      {:ok, results} ->
+        conn
+        |> put_resp_content_type("application/json")
+        |> send_resp(200, Jason.encode!(results))
+
+      {:error, :verisim_unavailable} ->
+        send_resp(conn, 503, Jason.encode!(%{error: "verisim_unavailable"}))
+
+      {:error, reason} ->
+        send_resp(conn, 500, Jason.encode!(%{error: inspect(reason)}))
+    end
+  end
+
+  # Save campaign graph to ArangoDB
+  post "/db/campaigns" do
+    portfolio_id = Map.get(conn.body_params, "portfolioId", "")
+    edges = Map.get(conn.body_params, "edges", [])
+
+    aql = """
+    FOR edge IN @edges
+      UPSERT { _from: CONCAT("buildings/", edge.fromBuildingId), _to: CONCAT("buildings/", edge.toBuildingId) }
+      INSERT { _from: CONCAT("buildings/", edge.fromBuildingId), _to: CONCAT("buildings/", edge.toBuildingId), edgeType: edge.edgeType, label: edge.label, unlockCondition: edge.unlockCondition, portfolioId: @portfolioId }
+      UPDATE { edgeType: edge.edgeType, label: edge.label, unlockCondition: edge.unlockCondition }
+      IN campaign_edges
+      RETURN NEW
+    """
+
+    case DatabaseBridge.query_game(aql, %{"edges" => edges, "portfolioId" => portfolio_id}) do
+      {:ok, results} ->
+        conn
+        |> put_resp_content_type("application/json")
+        |> send_resp(200, Jason.encode!(%{ok: true, count: length(results)}))
+
+      {:error, :arango_unavailable} ->
+        send_resp(conn, 503, Jason.encode!(%{error: "arango_unavailable"}))
+
+      {:error, reason} ->
+        send_resp(conn, 500, Jason.encode!(%{error: inspect(reason)}))
+    end
+  end
+
+  # Get campaign graph for a portfolio from ArangoDB
+  get "/db/campaigns/:id" do
+    aql = """
+    FOR edge IN campaign_edges
+      FILTER edge.portfolioId == @portfolioId
+      RETURN {
+        fromBuildingId: SPLIT(edge._from, "/")[1],
+        toBuildingId: SPLIT(edge._to, "/")[1],
+        edgeType: edge.edgeType,
+        label: edge.label,
+        unlockCondition: edge.unlockCondition
+      }
+    """
+
+    case DatabaseBridge.query_game(aql, %{"portfolioId" => id}) do
+      {:ok, results} ->
+        conn
+        |> put_resp_content_type("application/json")
+        |> send_resp(200, Jason.encode!(%{portfolioId: id, edges: results}))
+
+      {:error, :arango_unavailable} ->
+        send_resp(conn, 503, Jason.encode!(%{error: "arango_unavailable"}))
+
+      {:error, reason} ->
+        send_resp(conn, 500, Jason.encode!(%{error: inspect(reason)}))
+    end
+  end
+
+  # Add a single edge to a campaign
+  post "/db/campaigns/:id/edges" do
+    from_id = Map.get(conn.body_params, "fromBuildingId", "")
+    to_id = Map.get(conn.body_params, "toBuildingId", "")
+    edge_type = Map.get(conn.body_params, "edgeType", "Unlocks")
+    label = Map.get(conn.body_params, "label", "")
+    condition = Map.get(conn.body_params, "unlockCondition")
+
+    aql = """
+    INSERT {
+      _from: CONCAT("buildings/", @fromId),
+      _to: CONCAT("buildings/", @toId),
+      edgeType: @edgeType,
+      label: @label,
+      unlockCondition: @condition,
+      portfolioId: @portfolioId
+    } INTO campaign_edges
+    RETURN NEW
+    """
+
+    bind_vars = %{
+      "fromId" => from_id,
+      "toId" => to_id,
+      "edgeType" => edge_type,
+      "label" => label,
+      "condition" => condition,
+      "portfolioId" => id
+    }
+
+    case DatabaseBridge.query_game(aql, bind_vars) do
+      {:ok, results} ->
+        conn
+        |> put_resp_content_type("application/json")
+        |> send_resp(200, Jason.encode!(%{ok: true, edge: List.first(results)}))
+
+      {:error, :arango_unavailable} ->
+        send_resp(conn, 503, Jason.encode!(%{error: "arango_unavailable"}))
+
+      {:error, reason} ->
+        send_resp(conn, 500, Jason.encode!(%{error: inspect(reason)}))
+    end
+  end
+
   match _ do
     send_resp(conn, 404, Jason.encode!(%{error: "not_found"}))
   end

idaptik-ums/main.js

@@ -1,12 +1,42 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// main.js — Entry point with hash-based routing for generator and editor
+//
+// Routes:
+//   #/generator (default) — GeneratorDemo procedural level generator
+//   #/editor — App (TEA-based level editor, when ready)
+//
+// The hash router enables the "Open in Editor" flow: GeneratorDemo converts
+// a level to Model.level format and navigates to #/editor.
+
 import React from 'react';
 import { createRoot } from 'react-dom/client';
-// Generator demo — click Generate to produce procedural buildings
 import { make as GeneratorDemo } from './src/generator/GeneratorDemo.res.mjs';
-// Original app (uncomment to switch back):
+// Original TEA editor (uncomment when ready):
 // import { make as App } from './src/App.res.mjs';
 
 const container = document.getElementById('app');
 if (container) {
   const root = createRoot(container);
-  root.render(React.createElement(GeneratorDemo, {}));
+
+  function renderRoute() {
+    const hash = window.location.hash || '#/generator';
+
+    switch (hash) {
+      case '#/editor':
+        // TODO: Mount App (TEA editor) when ready
+        // root.render(React.createElement(App, {}));
+        root.render(React.createElement(GeneratorDemo, {}));
+        break;
+      case '#/generator':
+      default:
+        root.render(React.createElement(GeneratorDemo, {}));
+        break;
+    }
+  }
+
+  // Listen for hash changes (navigation between generator and editor)
+  window.addEventListener('hashchange', renderRoute);
+
+  // Initial render
+  renderRoute();
 }

idaptik-ums/src/generator/A2mlWrapper.res

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// A2mlWrapper — A2ML metadata envelope for level JSON payloads
+//
+// Wraps a JSON payload (typically a levelConfig) in an A2ML metadata envelope.
+// The envelope includes version, generator info, seed, template name,
+// generation timestamp, and optional designer notes.
+//
+// A2ML (AI-to-Machine Language) is the hyperpolymath standard for
+// machine-readable metadata. The envelope enables downstream tools to
+// identify the origin and parameters of a generated level without parsing
+// the level data itself.
+//
+// @see 0-AI-MANIFEST.a2ml — repository-level A2ML manifest
+// @see LevelExport.res — produces the JSON payload to wrap
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/// Metadata fields for the A2ML envelope. These describe the generation
+/// parameters and context, not the level content itself.
+type a2mlMeta = {
+  version: string,
+  generator: string,
+  seed: int,
+  templateName: string,
+  generatedAt: string,
+  designerNotes: string,
+}
+
+// ---------------------------------------------------------------------------
+// Wrap / Unwrap
+// ---------------------------------------------------------------------------
+
+/// Wrap a JSON payload string in an A2ML metadata envelope.
+/// The result is a valid JSON object with "a2ml" metadata and "payload" data.
+let wrapInA2ml = (jsonPayload: string, meta: a2mlMeta): string => {
+  let metaJson = `{
+  "version": "${meta.version}",
+  "generator": "${meta.generator}",
+  "seed": ${Belt.Int.toString(meta.seed)},
+  "templateName": "${meta.templateName}",
+  "generatedAt": "${meta.generatedAt}",
+  "designerNotes": "${meta.designerNotes}"
+}`
+  `{
+  "a2ml": ${metaJson},
+  "payload": ${jsonPayload}
+}`
+}
+
+/// Unwrap an A2ML envelope, extracting the metadata and payload JSON string.
+/// Returns Error if the input is not a valid A2ML envelope.
+let unwrapA2ml = (wrapped: string): result<(string, a2mlMeta), string> => {
+  try {
+    let json = JSON.parseExn(wrapped)
+    let obj = json->Js.Json.decodeObject
+    switch obj {
+    | Some(dict) =>
+      let a2mlObj = Js.Dict.get(dict, "a2ml")
+      let payloadObj = Js.Dict.get(dict, "payload")
+      switch (a2mlObj, payloadObj) {
+      | (Some(metaJson), Some(payload)) =>
+        let metaDict = metaJson->Js.Json.decodeObject->Belt.Option.getWithDefault(Js.Dict.empty())
+        let getString = (d, k) => Js.Dict.get(d, k)->Belt.Option.flatMap(Js.Json.decodeString)->Belt.Option.getWithDefault("")
+        let getInt = (d, k) => Js.Dict.get(d, k)->Belt.Option.flatMap(Js.Json.decodeNumber)->Belt.Option.mapWithDefault(0, Belt.Float.toInt)
+        let meta: a2mlMeta = {
+          version: getString(metaDict, "version"),
+          generator: getString(metaDict, "generator"),
+          seed: getInt(metaDict, "seed"),
+          templateName: getString(metaDict, "templateName"),
+          generatedAt: getString(metaDict, "generatedAt"),
+          designerNotes: getString(metaDict, "designerNotes"),
+        }
+        let payloadStr = JSON.stringify(payload)
+        Ok((payloadStr, meta))
+      | _ => Error("Missing 'a2ml' or 'payload' fields")
+      }
+    | None => Error("Not a JSON object")
+    }
+  } catch {
+  | _ => Error("Invalid JSON")
+  }
+}