@x12i/map-store-playground 0.1.0

package/README.md

@@ -0,0 +1,40 @@
+# `@x12i/map-store-playground`
+
+Catalog and domain response previews for map-store `/map-store/v1`, for use with [`@x12i/api-playground`](https://www.npmjs.com/package/@x12i/api-playground) and [`@x12i/api-playground-kit`](https://www.npmjs.com/package/@x12i/api-playground-kit).
+
+## Exports
+
+| Mount path | Contents |
+|------------|----------|
+| `/@map-store-playground/catalog.js` | Endpoint groups + `/map-store/v1` routes |
+| `/@map-store-playground/renderers.js` | Overview panels (`renderResponse`, `presenceFor`) |
+
+## Mount in your playground server
+
+```js
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { createPlaygroundServer } from "@x12i/api-playground-kit/create-playground-server.js";
+
+const require = createRequire(import.meta.url);
+const pkg = dirname(require.resolve("@x12i/map-store-playground/package.json"));
+
+createPlaygroundServer({
+  root: /* your app dir */,
+  mounts: [{ urlPrefix: "/@map-store-playground/", fsRoot: join(pkg, "src") }],
+  proxies: [
+    {
+      pathPrefix: "/map-store",
+      targetOrigin: process.env.MAP_STORE_ORIGIN ?? "http://127.0.0.1:9230",
+      errorCode: "map-store-proxy-failed",
+    },
+    {
+      pathPrefix: "/health",
+      targetOrigin: process.env.MAP_STORE_ORIGIN ?? "http://127.0.0.1:9230",
+      errorCode: "map-store-proxy-failed",
+    },
+  ],
+});
+```
+
+Product-specific catalogs (e.g. Synapix UI flows / how-to guides) stay in the consumer app.

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@x12i/map-store-playground",
+  "version": "0.1.0",
+  "description": "Map-store /map-store/v1 catalog and response previews for @x12i/api-playground",
+  "type": "module",
+  "license": "UNLICENSED",
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "exports": {
+    "./catalog.js": "./src/catalog.js",
+    "./renderers.js": "./src/renderers.js",
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "@x12i/api-playground": ">=0.4.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/catalog.js

@@ -0,0 +1,781 @@
+/**
+ * Map-store /map-store/v1 catalog for @x12i/api-playground.
+ * @typedef {import("/@api-playground/types.js").PlaygroundEndpoint} PlaygroundEndpoint
+ * @typedef {import("/@api-playground/types.js").EndpointGroup} EndpointGroup
+ */
+
+/** @type {EndpointGroup[]} */
+export const groups = [
+  { id: "session", label: "Session" },
+  { id: "working", label: "Working products" },
+  { id: "objects", label: "Objects" },
+  { id: "investigation", label: "Investigation packets" },
+  { id: "counts", label: "Counts (Countex)" },
+  { id: "advanced", label: "Advanced / lab" },
+];
+
+const HONESTY = {
+  opaqueTokens:
+    "Generation tokens in responses (snapshotSetId, analysisSnapshotId, liveGenerationId) are opaque — never send them back on product URLs.",
+  noMutablePins: "Never use current, latest, or scs:… as request ids or pins.",
+  paging: "HTTP 200 on an index page alone is not enough — walk pageVariants / pageCount and reconcile to expectedItemCount / census.",
+  mixedGen: "Mixed generation → 409 → re-bootstrap.",
+  observed: "Observed communication ≠ REACHABLE / authoritative reachability.",
+  incomplete: "Partial / not-evaluated / unavailable / incomplete-publication ≠ green “safe”.",
+};
+
+/**
+ * @param {object} opts
+ * @returns {PlaygroundEndpoint}
+ */
+function ep(opts) {
+  return {
+    persistsData: false,
+    mayUseBrowser: false,
+    responseViews: ["json"],
+    submitLabel: "Send request",
+    avoidWhen: [],
+    requirements: ["Reachable map-store station"],
+    limitations: [],
+    sideEffects: [],
+    examples: [],
+    ...opts,
+  };
+}
+
+/**
+ * @param {object} p
+ * @returns {PlaygroundEndpoint}
+ */
+function workingProduct(p) {
+  const path = `/map-store/v1/working/${p.id}`;
+  return ep({
+    id: `working-${p.id}`,
+    group: "working",
+    name: p.name,
+    method: "GET",
+    path,
+    family: "working",
+    summary: p.summary,
+    purpose: p.purpose,
+    useWhen: p.useWhen,
+    avoidWhen: p.avoidWhen || [
+      "Do not invent joins client-side — only use published rows.",
+      HONESTY.opaqueTokens,
+    ],
+    internalFlow: [
+      { title: "Station org", description: "Map-store reads the configured Memorix org; the client never sends org/map/pin ids." },
+      { title: "Load product", description: `Fetches working/${p.id} for the current covering (and live generation when applicable).` },
+      {
+        title: "Optional page",
+        description: "Pass ?variant= to fetch a pageVariant. Walk all variants when reconciling counts.",
+      },
+    ],
+    requirements: ["memorixReachable", "estateReady", ...(p.requirements || [])],
+    limitations: [
+      HONESTY.paging,
+      HONESTY.mixedGen,
+      HONESTY.opaqueTokens,
+      ...(p.limitations || []),
+    ],
+    requestUi: {
+      variant: {
+        label: "variant",
+        description: "Optional pageVariant id from a prior page’s pageVariants list. Leave empty for the product index/default page.",
+        placeholder: "",
+        section: "common",
+        order: 1,
+        required: false,
+        type: "query",
+      },
+    },
+    inputs: [
+      {
+        name: "variant",
+        required: false,
+        meaning: "Page variant for paged working products",
+        type: "query",
+      },
+    ],
+    responseDescription: p.responseDescription,
+    responseViews: p.responseViews || ["preview", "json"],
+    submitLabel: "Fetch product",
+    examples: p.examples || [
+      {
+        name: "Default page",
+        description: `GET ${path}`,
+        request: {},
+      },
+    ],
+  });
+}
+
+/** @type {PlaygroundEndpoint[]} */
+export const endpoints = [
+  ep({
+    id: "process-health",
+    group: "session",
+    name: "Process health",
+    method: "GET",
+    path: "/health",
+    family: "session",
+    summary: "Process liveness (always 200 when the process is up).",
+    purpose:
+      "Probe that the map-store process is alive. Body includes memorixReachable / estateReady for banners even when Memorix is down — unlike /map-store/v1/health, this stays HTTP 200.",
+    useWhen: [
+      "Supervisors / load balancers need a cheap liveness probe",
+      "You want Memorix reachability hints without treating the estate as ready",
+    ],
+    avoidWhen: [
+      "Do not gate the Synapix session on this alone — prefer GET /map-store/v1/health for estate readiness",
+    ],
+    internalFlow: [
+      { title: "Probe", description: "Returns process ok plus Memorix probe fields (may be cached briefly)." },
+    ],
+    requestUi: {},
+    inputs: [],
+    responseDescription:
+      "JSON with ok: true plus station/Memorix fields (memorixReachable, estateReady, userMessage, …).",
+    responseViews: ["preview", "json"],
+    submitLabel: "Check process",
+    examples: [{ name: "Liveness", request: {} }],
+  }),
+
+  ep({
+    id: "estate-health",
+    group: "session",
+    name: "Estate health",
+    method: "GET",
+    path: "/map-store/v1/health",
+    family: "session",
+    summary: "Station + Memorix readiness for the published estate client.",
+    purpose:
+      "Session gate for Synapix. Requires memorixReachable and estateReady. Returns 503 when not configured, station mismatch, or Memorix unreachable — with userMessage and retryAfterMs.",
+    useWhen: [
+      "Before bootstrap / product walks",
+      "Polling while showing a Memorix-down banner",
+    ],
+    avoidWhen: [
+      "Do not treat stationOk alone as ready",
+      "Do not call Memorix :5100 from the browser",
+    ],
+    internalFlow: [
+      { title: "Station", description: "Validates Memorix URL/org configuration." },
+      { title: "Probe Memorix", description: "Fast reachability probe; cache TTL avoids hammering Memorix." },
+      { title: "Status", description: "200 when ready; 503 otherwise with the same field shape." },
+    ],
+    requirements: ["Map-store process listening"],
+    requestUi: {},
+    inputs: [],
+    responseDescription:
+      "Health body: memorixReachable, estateReady, userMessage, memorixUrl, memorixOrgId, …",
+    responseViews: ["preview", "json"],
+    submitLabel: "Check estate",
+    examples: [{ name: "Session gate", request: {} }],
+  }),
+
+  ep({
+    id: "bootstrap",
+    group: "session",
+    name: "Bootstrap",
+    method: "GET",
+    path: "/map-store/v1/bootstrap",
+    family: "session",
+    summary: "Covering + live pins, census, and nested bootstrap / liveBootstrap bodies.",
+    purpose:
+      "Start every session here. No ids in the request. Returns the station envelope (not a flat Security Map bootstrap): snapshotSetId, analysisSnapshotId, liveGenerationId, liveAvailability, bootstrap, liveBootstrap.",
+    useWhen: [
+      "Opening a new UI session or refresh cycle",
+      "Reading typed census / producerIdentity / assessmentCoverage",
+      "Confirming liveAvailability before treating live overlays as present",
+    ],
+    avoidWhen: [
+      HONESTY.opaqueTokens,
+      HONESTY.noMutablePins,
+      "Never treat missing/null liveAvailability as healthy live overlay",
+    ],
+    internalFlow: [
+      { title: "Pointers", description: "Map-store loads current working pointers for the station org." },
+      {
+        title: "Envelope",
+        description: "Returns pins + nested bootstrap and liveBootstrap (or null).",
+      },
+    ],
+    limitations: [
+      HONESTY.opaqueTokens,
+      "liveBootstrap may also be fetched as working/live-bootstrap",
+      "Incomplete publication → 503 incomplete-publication",
+    ],
+    requestUi: {},
+    inputs: [],
+    responseDescription:
+      "Envelope with snapshotSetId, analysisSnapshotId, liveGenerationId, liveAvailability, bootstrap {…}, liveBootstrap {…|null}. Unwrap nested bootstrap for census / producer identity.",
+    responseViews: ["preview", "json"],
+    submitLabel: "Bootstrap",
+    examples: [{ name: "Session bootstrap", request: {} }],
+  }),
+
+  workingProduct({
+    id: "live-bootstrap",
+    name: "Live bootstrap",
+    summary: "Live clock / OM status overlay (working product).",
+    purpose:
+      "Fetch the live-generation working product. Also embedded on GET /bootstrap as liveBootstrap. Two clocks: covering-stable vs live overlay — never treat live as covering-stable reachability.",
+    useWhen: [
+      "Need liveGenerationId / omStatus after bootstrap",
+      "Refreshing live overlay without re-walking stable products",
+    ],
+    avoidWhen: [
+      HONESTY.observed,
+      "Do not treat live overlay as authoritative REACHABLE",
+    ],
+    limitations: [HONESTY.observed],
+    responseDescription: "Wrapped { snapshotSetId, liveGenerationId, product, data } — unwrap data.",
+  }),
+
+  workingProduct({
+    id: "publication-manifest",
+    name: "Publication manifest",
+    summary: "Expected product set for this covering pin.",
+    purpose: "Lists which working products the publisher intends for this bag — useful before on-demand walks.",
+    useWhen: ["Discovering which products should exist", "Debugging incomplete-publication"],
+    responseDescription: "Manifest rows inside data (unwrap).",
+  }),
+
+  workingProduct({
+    id: "estate-object-inventory",
+    name: "Estate object inventory",
+    summary: "Typed inventory rows (assets, unresolved subjects, findings, alerts, …).",
+    purpose:
+      "Primary estate inventory. Page all variants; filter by objectType. Findings/alerts are not hosts.",
+    useWhen: ["Entities / Findings lists", "Reconciling typed census counts"],
+    limitations: [HONESTY.paging, "Display server-provided counts — do not hardcode tiles"],
+    responseDescription: "Inventory pages in data; walk pageVariants.",
+  }),
+
+  workingProduct({
+    id: "object-pre-ai-context",
+    name: "Object pre-AI context",
+    summary: "Placement, stories, objectType per object (pre-AI).",
+    purpose: "Published pre-AI context used for honesty copy (placement candidates, consequence stories).",
+    useWhen: ["Object detail placement / stories", "Deep-load for report planes"],
+    responseDescription: "Pre-AI context rows; often object-scoped pages.",
+  }),
+
+  workingProduct({
+    id: "object-security-context",
+    name: "Object security-context (working)",
+    summary: "Estate page-walk of OSC rows.",
+    purpose:
+      "Paged working product of object security-context. Prefer GET /objects/{id}/security-context for one object.",
+    useWhen: ["Bulk OSC walks", "Comparing to object join route"],
+    avoidWhen: ["Prefer the object join route for single-object detail"],
+    responseDescription: "OSC page payload in data.",
+  }),
+
+  workingProduct({
+    id: "object-classification",
+    name: "Object classification",
+    summary: "Classification candidates (may be missing on some bags).",
+    purpose:
+      "Classification product. May return incomplete-publication / missing — degrade honestly; never invent sole strongest label as truth.",
+    useWhen: ["Showing classification candidates on object detail"],
+    limitations: ["May 503 incomplete-publication on current bags", HONESTY.incomplete],
+    responseDescription: "Classification rows or incomplete-publication error.",
+  }),
+
+  workingProduct({
+    id: "object-exploitability-assessments",
+    name: "Object exploitability assessments",
+    summary: "EPA rows (attachment ≠ local asset exploitability).",
+    purpose: "Published EPA. Finding/alert EPA must not be promoted to “asset locally exploitable”.",
+    useWhen: ["EPA sections on findings/alerts/assets"],
+    avoidWhen: ["Do not promote finding EPA to asset exploitability"],
+    responseDescription: "EPA rows in data.",
+  }),
+
+  workingProduct({
+    id: "object-live-context",
+    name: "Object live-context",
+    summary: "Live overlay per object.",
+    purpose: "Live context rows. Observed ≠ REACHABLE.",
+    useWhen: ["Live overlay on object detail"],
+    limitations: [HONESTY.observed],
+    responseDescription: "Live context pages in data.",
+  }),
+
+  workingProduct({
+    id: "object-evidence-lineage",
+    name: "Object evidence lineage",
+    summary: "Object-scoped evidence lineage pages.",
+    purpose: "Lineage scoped to objects (≠ estate rollup evidence-lineage).",
+    useWhen: ["Object detail evidence lineage"],
+    responseDescription: "Object-scoped lineage pages.",
+  }),
+
+  workingProduct({
+    id: "evidence-lineage",
+    name: "Estate evidence-lineage",
+    summary: "Estate rollup lineage product.",
+    purpose: "Estate-level evidence lineage (not object-scoped).",
+    useWhen: ["Estate evidence rollups"],
+    avoidWhen: ["Do not confuse with object-evidence-lineage"],
+    responseDescription: "Estate lineage payload.",
+  }),
+
+  workingProduct({
+    id: "object-agent-context",
+    name: "Object agent-context",
+    summary: "Published agent context rows when present.",
+    purpose: "Agent context product for objects when the bag includes it.",
+    useWhen: ["Inspecting published agent context"],
+    responseDescription: "Agent context rows.",
+  }),
+
+  workingProduct({
+    id: "object-field-completeness",
+    name: "Object field-completeness",
+    summary: "Field completeness / gap accounting per object.",
+    purpose: "Gap accounting — incomplete ≠ safe.",
+    useWhen: ["Honesty about missing fields"],
+    limitations: [HONESTY.incomplete],
+    responseDescription: "Completeness / gap rows.",
+  }),
+
+  workingProduct({
+    id: "object-reachability-claims",
+    name: "Object reachability-claims",
+    summary: "Published reachability claim rows.",
+    purpose: "Claims only — not the same as candidate-reachability paths or observed edges.",
+    useWhen: ["Showing published claims"],
+    responseDescription: "Claim rows in data.",
+  }),
+
+  workingProduct({
+    id: "object-reachability-paths",
+    name: "Object reachability-paths",
+    summary: "Published reachability path rows.",
+    purpose: "Path product distinct from candidate-reachability.",
+    useWhen: ["Published path inspection"],
+    avoidWhen: ["Do not equate with candidate-reachability or live observation edges"],
+    responseDescription: "Path rows in data.",
+  }),
+
+  workingProduct({
+    id: "candidate-reachability",
+    name: "Candidate reachability",
+    summary: "Hypothesized / candidate path product.",
+    purpose: "Candidate reachability for predicted/conditional surfaces — not observed traffic.",
+    useWhen: ["Predicted / conditional path candidates"],
+    limitations: [HONESTY.observed],
+    responseDescription: "Candidate path pages.",
+  }),
+
+  workingProduct({
+    id: "live-observation-edges",
+    name: "Live observation edges",
+    summary: "Observed communication edges (large).",
+    purpose: "Full edge page walk. Observed ≠ REACHABLE.",
+    useWhen: ["Evidence / observed communication views"],
+    limitations: [HONESTY.observed, "Can be large — page carefully"],
+    responseDescription: "Edge pages in data.",
+  }),
+
+  workingProduct({
+    id: "investigation-context",
+    name: "Investigation context",
+    summary: "Published investigation context product.",
+    purpose: "Investigation context working product (packets also have dedicated HTTP routes).",
+    useWhen: ["Browsing investigation context rows"],
+    responseDescription: "Context payload in data.",
+  }),
+
+  workingProduct({
+    id: "investigation-unknown",
+    name: "Investigation unknown",
+    summary: "Published unknowns product.",
+    purpose: "Investigation unknown rows from the bag.",
+    useWhen: ["Surfacing published unknowns"],
+    responseDescription: "Unknowns payload.",
+  }),
+
+  workingProduct({
+    id: "known-unknowns",
+    name: "Known unknowns",
+    summary: "Published known-unknowns product.",
+    purpose: "Known-unknowns working product.",
+    useWhen: ["Honesty about what remains unresolved"],
+    responseDescription: "Known-unknowns payload.",
+  }),
+
+  ep({
+    id: "object-security-context-join",
+    group: "objects",
+    name: "Object security-context (join)",
+    method: "GET",
+    path: "/map-store/v1/objects/{objectId}/security-context",
+    family: "objects",
+    summary: "Preferred single-object join: context + classification + preAi + live overlay.",
+    purpose:
+      "Primary object-detail route. Returns context, classification, preAiContext, liveOverlay, retrieval metadata for one objectId.",
+    useWhen: [
+      "Object detail pages",
+      "Prefer over walking working/object-security-context for one id",
+    ],
+    avoidWhen: [
+      HONESTY.opaqueTokens,
+      "Station may not expose /objects/{id}/evidence-lineage or /live-context — use working products",
+    ],
+    internalFlow: [
+      { title: "Lookup", description: "Joins stable OSC with classification, pre-AI, and live overlay when present." },
+      { title: "Mixed generation", description: "409 mixed-generation → re-bootstrap." },
+    ],
+    limitations: [HONESTY.mixedGen, HONESTY.observed],
+    requestUi: {
+      objectId: {
+        label: "objectId",
+        description: "Published object id (opaque). Example lab shape: object:10.70.40.35,10.70.40.8,10.70.40.9",
+        placeholder: "object:…",
+        example: "object:10.70.40.35,10.70.40.8,10.70.40.9",
+        section: "primary",
+        order: 1,
+        required: true,
+        type: "path",
+      },
+    },
+    inputs: [
+      {
+        name: "objectId",
+        required: true,
+        meaning: "Object identifier from inventory / OSC",
+        type: "path",
+        example: "object:10.70.40.35,10.70.40.8,10.70.40.9",
+      },
+    ],
+    responseDescription:
+      "JSON with snapshotSetId, liveGenerationId, context, liveOverlay, classification, preAiContext, retrieval[], liveAuthority.",
+    responseViews: ["preview", "json"],
+    submitLabel: "Fetch object context",
+    examples: [
+      {
+        name: "Sample lab object",
+        request: { objectId: "object:10.70.40.35,10.70.40.8,10.70.40.9" },
+      },
+    ],
+  }),
+
+  ep({
+    id: "investigation-packets-index",
+    group: "investigation",
+    name: "Investigation packets (index)",
+    method: "GET",
+    path: "/map-store/v1/investigation-packets",
+    family: "investigation",
+    summary: "Index of security investigation packets.",
+    purpose:
+      "Lists investigation packets from the security-investigation-packet product. Packets are not Tier-1 AI conclusions.",
+    useWhen: ["Evidence & packets surfaces", "Picking a packetId for detail"],
+    avoidWhen: ["Do not treat packets as authoritative AI verdicts"],
+    internalFlow: [
+      {
+        title: "Product",
+        description: "Reads working security-investigation-packet index for the current covering.",
+      },
+    ],
+    requestUi: {},
+    inputs: [],
+    responseDescription: "snapshotSetId, analysisSnapshotId, liveGenerationId, index.",
+    responseViews: ["preview", "json"],
+    submitLabel: "List packets",
+    examples: [{ name: "Packet index", request: {} }],
+  }),
+
+  ep({
+    id: "investigation-packet",
+    group: "investigation",
+    name: "Investigation packet (by id)",
+    method: "GET",
+    path: "/map-store/v1/investigation-packets/{packetId}",
+    family: "investigation",
+    summary: "One investigation packet by id (variant).",
+    purpose: "Fetches a single packet. Not a Tier-1 AI conclusion.",
+    useWhen: ["Packet detail after listing the index"],
+    avoidWhen: ["Do not treat as AI triage narrative"],
+    internalFlow: [
+      {
+        title: "Variant",
+        description: "Loads security-investigation-packet with variant=packetId.",
+      },
+    ],
+    requestUi: {
+      packetId: {
+        label: "packetId",
+        description: "Packet id from the index response.",
+        placeholder: "packet id",
+        section: "primary",
+        order: 1,
+        required: true,
+        type: "path",
+      },
+    },
+    inputs: [
+      {
+        name: "packetId",
+        required: true,
+        meaning: "Investigation packet identifier",
+        type: "path",
+      },
+    ],
+    responseDescription: "snapshotSetId, analysisSnapshotId, liveGenerationId, packet.",
+    responseViews: ["json"],
+    submitLabel: "Fetch packet",
+  }),
+
+  ep({
+    id: "counts-index",
+    group: "counts",
+    name: "Counts API index",
+    method: "GET",
+    path: "/map-store/v1/counts",
+    family: "counts",
+    summary: "Describe Countex counters on the map-store API tier.",
+    purpose:
+      "Map-store hosts @x12i/countex. The browser never imports Countex — only these HTTP routes. Lists counter ids and related paths.",
+    useWhen: ["Discovering count routes", "Confirming Countex is wired on the station"],
+    avoidWhen: ["Do not add Countex to the browser bundle"],
+    internalFlow: [
+      {
+        title: "API tier",
+        description: "neo-services-map-store keeps an in-process Countex engine (memory adapters) rebuilt from Memorix inventory.",
+      },
+    ],
+    requirements: ["map-store with Memorix", "@x12i/countex on the station"],
+    requestUi: {},
+    inputs: [],
+    responseDescription: "engine, counters[], cachedSnapshotSetId, routes.",
+    responseViews: ["preview", "json"],
+    submitLabel: "Describe counts API",
+    examples: [
+      {
+        name: "Index",
+        request: {},
+        response: {
+          engine: "@x12i/countex",
+          counters: ["estate_by_object_type"],
+          routes: {
+            byObjectType: "GET /map-store/v1/counts/by-object-type",
+            query: "POST /map-store/v1/counts/query",
+          },
+        },
+      },
+    ],
+  }),
+
+  ep({
+    id: "counts-by-object-type",
+    group: "counts",
+    name: "Count estate by objectType",
+    method: "GET",
+    path: "/map-store/v1/counts/by-object-type",
+    family: "counts",
+    summary: "Walk inventory → Countex → walked vs bootstrap typed census.",
+    purpose:
+      "API-tier recount: map-store walks estate-object-inventory pages, ingests into @x12i/countex (estate_by_object_type), and returns reconcile deltas vs bootstrap typedRecordCensus. Use this instead of hardcoding census tiles or counting only in the browser.",
+    useWhen: [
+      "Reconciling Entities/Findings totals to published census",
+      "Home KPI honesty checks",
+    ],
+    avoidWhen: [
+      "Do not re-implement Countex in the UI",
+      "Do not treat process-local memory counts as durable analytics across stations",
+    ],
+    internalFlow: [
+      { title: "Pointers", description: "Load current Memorix covering pin." },
+      { title: "Walk", description: "Page estate-object-inventory (optional maxPages)." },
+      { title: "Countex", description: "ingestBatch + flush + query groupBy metric." },
+      { title: "Reconcile", description: "Compare walked counts to bootstrap typed census." },
+    ],
+    limitations: [
+      HONESTY.paging,
+      "Cached per snapshotSetId until force=1",
+      "In-process memory adapters — rebuild after station restart",
+    ],
+    requestUi: {
+      force: {
+        label: "force",
+        description: "Set 1/true to rebuild even if this pin was already counted.",
+        section: "common",
+        order: 1,
+        required: false,
+        type: "query",
+        placeholder: "1",
+      },
+      maxPages: {
+        label: "maxPages",
+        description: "Cap inventory page walk (default 500).",
+        section: "common",
+        order: 2,
+        required: false,
+        type: "query",
+        placeholder: "50",
+      },
+    },
+    inputs: [
+      { name: "force", required: false, meaning: "Force rebuild", type: "query" },
+      { name: "maxPages", required: false, meaning: "Max inventory pages", type: "query" },
+    ],
+    responseDescription:
+      "ingested, counts (Countex table), typedCensus, reconcile.byType / walkedTotal / censusTotal.",
+    responseViews: ["preview", "json"],
+    submitLabel: "Recount by objectType",
+    examples: [
+      {
+        name: "Force rebuild",
+        request: { force: "1" },
+        response: {
+          engine: "@x12i/countex",
+          counterId: "estate_by_object_type",
+          ingested: 1481,
+          reconcile: {
+            walkedTotal: 1481,
+            censusTotal: 1481,
+            byType: {
+              "endpoint-asset": { walked: 506, census: 506, delta: 0 },
+              finding: { walked: 392, census: 392, delta: 0 },
+            },
+          },
+        },
+      },
+    ],
+  }),
+
+  ep({
+    id: "counts-query",
+    group: "counts",
+    name: "Countex query",
+    method: "POST",
+    path: "/map-store/v1/counts/query",
+    family: "counts",
+    summary: "Run a Countex QuerySpec against the last estate rebuild.",
+    purpose:
+      "POST a Countex QuerySpec (scope, counterId, timeframe, groupBy, …). If no cache exists, map-store rebuilds from inventory first. Browser sends JSON only — no Countex import.",
+    useWhen: ["Custom groupings / filters after a by-object-type rebuild"],
+    avoidWhen: ["Do not point this at Memorix or embed Countex in the browser"],
+    internalFlow: [
+      { title: "Ensure engine", description: "Rebuild estate counters if needed." },
+      { title: "Query", description: "countex.query(body)." },
+    ],
+    requestUi: {
+      body: {
+        label: "JSON body (QuerySpec)",
+        description: "Full Countex QuerySpec JSON.",
+        section: "primary",
+        order: 1,
+        required: true,
+        type: "json",
+        example: JSON.stringify(
+          {
+            scope: "scs:…",
+            counterId: "estate_by_object_type",
+            timeframe: { type: "day", from: "2026-09-13", to: "2026-09-13" },
+            groupBy: ["metric"],
+            format: "table",
+            orderBy: "-count",
+            resolveLabels: true,
+          },
+          null,
+          2,
+        ),
+      },
+    },
+    inputs: [{ name: "body", required: true, meaning: "Countex QuerySpec", type: "json" }],
+    responseDescription: "{ engine, result } where result is Countex QueryResult.",
+    responseViews: ["json"],
+    submitLabel: "Run Countex query",
+    examples: [
+      {
+        name: "By metric (day)",
+        request: {
+          body: JSON.stringify({
+            scope: "scs:47282bd63cadb10939ceff72",
+            counterId: "estate_by_object_type",
+            timeframe: { type: "day", from: "2026-09-13", to: "2026-09-13" },
+            groupBy: ["metric"],
+            format: "table",
+            orderBy: "-count",
+            resolveLabels: true,
+          }),
+        },
+      },
+    ],
+  }),
+
+  ep({
+    id: "legacy-consume",
+    group: "advanced",
+    name: "Legacy local consume (lab)",
+    method: "GET",
+    path: "/map-store/v1/tenants/{tenant}/consume/{snapshotSetId}/{product}",
+    family: "advanced",
+    summary: "NOT Memorix — lab-only local cache. Synapix must not use this.",
+    purpose:
+      "Lab-only local consume store on the map-store process — not a Memorix read. Synapix estate data always comes from Memorix via /map-store/v1/working/*, /bootstrap, object join, and investigation-packets — never this route.",
+    useWhen: ["Debugging an old local consume cache in lab"],
+    avoidWhen: [
+      "Never use this for the published Memorix estate / Synapix UI",
+      HONESTY.noMutablePins,
+      "Prefer /map-store/v1/working/{product}",
+    ],
+    internalFlow: [
+      {
+        title: "Local store",
+        description: "Looks up a row in the local consume cache; 404 with guidance to use working/* when missing.",
+      },
+    ],
+    limitations: ["Not a Memorix writer", "Returns 404 consume-not-found when empty"],
+    requestUi: {
+      tenant: {
+        label: "tenant",
+        description: "Legacy tenant segment (lab).",
+        section: "primary",
+        order: 1,
+        required: true,
+        type: "path",
+        default: "default",
+      },
+      snapshotSetId: {
+        label: "snapshotSetId",
+        description: "Must not be current/latest — opaque pin if you truly need this lab route.",
+        section: "primary",
+        order: 2,
+        required: true,
+        type: "path",
+      },
+      product: {
+        label: "product",
+        description: "Consume product id.",
+        section: "primary",
+        order: 3,
+        required: true,
+        type: "path",
+      },
+      variant: {
+        label: "variant",
+        description: "Optional page variant.",
+        section: "common",
+        order: 4,
+        required: false,
+        type: "query",
+      },
+    },
+    inputs: [
+      { name: "tenant", required: true, meaning: "Legacy tenant", type: "path", default: "default" },
+      { name: "snapshotSetId", required: true, meaning: "Opaque snapshot set id", type: "path" },
+      { name: "product", required: true, meaning: "Product id", type: "path" },
+      { name: "variant", required: false, meaning: "Page variant", type: "query" },
+    ],
+    responseDescription: "Local consume row JSON, or 404 with gaps pointing at working/*.",
+    responseViews: ["json"],
+    submitLabel: "Fetch (lab only)",
+  }),
+];

package/src/renderers.js

@@ -0,0 +1,238 @@
+/**
+ * Domain response panels for map-store.
+ */
+
+/**
+ * @param {unknown} v
+ * @returns {Record<string, unknown> | null}
+ */
+function asRecord(v) {
+  return v && typeof v === "object" && !Array.isArray(v) ? /** @type {Record<string, unknown>} */ (v) : null;
+}
+
+/**
+ * @param {unknown} body
+ * @param {HTMLElement} overviewEl
+ * @param {HTMLElement} jsonEl
+ * @param {HTMLElement} genericEl
+ * @param {string} endpointId
+ */
+export function renderResponse(body, overviewEl, jsonEl, genericEl, endpointId) {
+  const text = safeJson(body);
+  jsonEl.textContent = text;
+  genericEl.textContent = text;
+  overviewEl.innerHTML = buildPreviewHtml(body, endpointId);
+}
+
+/**
+ * @param {unknown} body
+ * @param {string} endpointId
+ */
+function buildPreviewHtml(body, endpointId) {
+  if (body == null) return `<p class="tryit-guidance">Empty body.</p>`;
+  if (typeof body !== "object") return `<pre class="code-block"><code>${escape(String(body))}</code></pre>`;
+
+  /** @type {Record<string, unknown>} */
+  const o = /** @type {Record<string, unknown>} */ (body);
+
+  if (endpointId === "counts-by-object-type" || endpointId === "uc-count-object-types") {
+    const reconcile = asRecord(o.reconcile);
+    const byType = reconcile && asRecord(reconcile.byType);
+    const rows = [
+      ["engine", fmt(o.engine)],
+      ["counterId", fmt(o.counterId)],
+      ["snapshotSetId", fmt(o.snapshotSetId)],
+      ["ingested", fmt(o.ingested)],
+      ["pagesWalked", fmt(o.pagesWalked)],
+      ["walkedTotal", fmt(reconcile?.walkedTotal)],
+      ["censusTotal", fmt(reconcile?.censusTotal)],
+    ];
+    if (byType) {
+      for (const [k, v] of Object.entries(byType).slice(0, 12)) {
+        const rec = asRecord(v);
+        rows.push([`byType.${k}`, rec ? `walked=${rec.walked} census=${rec.census} Δ=${rec.delta}` : fmt(v)]);
+      }
+    }
+    return kvGrid(rows);
+  }
+
+  if (endpointId === "counts-index") {
+    return kvGrid([
+      ["engine", fmt(o.engine)],
+      ["counters", Array.isArray(o.counters) ? o.counters.join(", ") : fmt(o.counters)],
+      ["cachedSnapshotSetId", fmt(o.cachedSnapshotSetId)],
+      ["rebuiltAt", fmt(o.rebuiltAt)],
+    ]);
+  }
+
+  if (
+    endpointId === "process-health" ||
+    endpointId === "estate-health" ||
+    endpointId === "ui-session-gate"
+  ) {
+    return kvGrid([
+      ["memorixReachable", fmt(o.memorixReachable)],
+      ["estateReady", fmt(o.estateReady)],
+      ["stationOk", fmt(o.stationOk ?? o.ok)],
+      ["userMessage", fmt(o.userMessage)],
+      ["memorixUrl", fmt(o.memorixUrl)],
+      ["memorixOrgId", fmt(o.memorixOrgId)],
+      ["retryAfterMs", fmt(o.retryAfterMs)],
+    ]);
+  }
+
+  if (endpointId === "bootstrap" || endpointId === "ui-bootstrap" || endpointId === "ui-home") {
+    const boot = /** @type {Record<string, unknown>|null} */ (o.bootstrap && typeof o.bootstrap === "object" ? o.bootstrap : null);
+    const census = boot && typeof boot.typedCensus === "object" ? /** @type {Record<string, unknown>} */ (boot.typedCensus) : null;
+    const coverage = boot && typeof boot.assessmentCoverage === "object" ? /** @type {Record<string, unknown>} */ (boot.assessmentCoverage) : null;
+    const typed =
+      census ||
+      (coverage && typeof coverage.typedRecordCensus === "object"
+        ? /** @type {Record<string, unknown>} */ (coverage.typedRecordCensus)
+        : null);
+    const rows = [
+      ["snapshotSetId", fmt(o.snapshotSetId)],
+      ["analysisSnapshotId", fmt(o.analysisSnapshotId)],
+      ["liveGenerationId", fmt(o.liveGenerationId)],
+      ["liveAvailability", fmt(o.liveAvailability)],
+      ["liveUnavailableReason", fmt(o.liveUnavailableReason)],
+      ["liveBootstrap", o.liveBootstrap == null ? "null" : "present"],
+    ];
+    if (typed) {
+      rows.push(
+        ["census.endpoint-asset", fmt(typed["endpoint-asset"] ?? typed.endpointAsset)],
+        ["census.unresolved-subject", fmt(typed["unresolved-subject"] ?? typed.unresolvedSubject)],
+        ["census.finding", fmt(typed.finding)],
+        ["census.alert", fmt(typed.alert)],
+      );
+    }
+    if (coverage != null) rows.push(["assessmentCoverage", safeJson(coverage).slice(0, 400)]);
+    return kvGrid(rows) + `<p class="field-hint" style="margin-top:12px">Generation tokens are opaque — do not send them back on product URLs.</p>`;
+  }
+
+  if (endpointId === "object-security-context-join" || endpointId === "ui-object-join") {
+    return kvGrid([
+      ["snapshotSetId", fmt(o.snapshotSetId)],
+      ["liveGenerationId", fmt(o.liveGenerationId)],
+      ["context", o.context == null ? "null" : "present"],
+      ["classification", o.classification == null ? "null" : "present"],
+      ["preAiContext", o.preAiContext == null ? "null" : "present"],
+      ["liveOverlay", o.liveOverlay == null ? "null" : "present"],
+    ]);
+  }
+
+  if (endpointId === "investigation-packets-index" || endpointId === "ui-packets-index" || endpointId === "ui-evidence") {
+    const index = o.index;
+    let count = "—";
+    if (Array.isArray(index)) count = String(index.length);
+    else if (index && typeof index === "object") {
+      const items = /** @type {Record<string, unknown>} */ (index).items ?? /** @type {Record<string, unknown>} */ (index).packets;
+      if (Array.isArray(items)) count = String(items.length);
+      else count = "object";
+    }
+    return kvGrid([
+      ["snapshotSetId", fmt(o.snapshotSetId)],
+      ["analysisSnapshotId", fmt(o.analysisSnapshotId)],
+      ["liveGenerationId", fmt(o.liveGenerationId)],
+      ["index size", count],
+    ]);
+  }
+
+  if (String(endpointId).startsWith("working-") || String(endpointId).startsWith("ui-")) {
+    if (o.product != null || o.data != null) {
+      return kvGrid([
+        ["product", fmt(o.product)],
+        ["variant", fmt(o.variant)],
+        ["snapshotSetId", fmt(o.snapshotSetId)],
+        ["liveGenerationId", fmt(o.liveGenerationId)],
+        ["data", o.data == null ? "null" : summarizeData(o.data)],
+      ]);
+    }
+  }
+
+  return kvGrid(
+    Object.keys(o)
+      .slice(0, 12)
+      .map((k) => [k, summarizeValue(o[k])]),
+  );
+}
+
+/**
+ * Presence flags for createResponseView.setAvailableViews.
+ * @param {unknown} body
+ * @param {string[]} views
+ */
+export function presenceFor(body, views) {
+  const has = body != null;
+  return {
+    fetch: has && views.includes("preview"),
+    overview: has && views.includes("preview"),
+    generic: has,
+    parsed: has,
+  };
+}
+
+/**
+ * @param {unknown} data
+ */
+function summarizeData(data) {
+  if (Array.isArray(data)) return `array(${data.length})`;
+  if (data && typeof data === "object") {
+    const keys = Object.keys(/** @type {object} */ (data));
+    const pageVariants = /** @type {Record<string, unknown>} */ (data).pageVariants;
+    const extra = Array.isArray(pageVariants) ? `, pageVariants=${pageVariants.length}` : "";
+    return `object{${keys.slice(0, 8).join(", ")}${keys.length > 8 ? ",…" : ""}}${extra}`;
+  }
+  return fmt(data);
+}
+
+/**
+ * @param {unknown} v
+ */
+function summarizeValue(v) {
+  if (v == null) return "null";
+  if (typeof v === "object") return Array.isArray(v) ? `array(${v.length})` : "object";
+  return fmt(v);
+}
+
+/**
+ * @param {[string, string][]} rows
+ */
+function kvGrid(rows) {
+  const filtered = rows.filter(([, v]) => v !== "" && v !== "undefined");
+  return `<table class="doc-table"><thead><tr><th>Field</th><th>Value</th></tr></thead><tbody>${filtered
+    .map(
+      ([k, v]) =>
+        `<tr><td><code>${escape(k)}</code></td><td class="mono">${escape(v)}</td></tr>`,
+    )
+    .join("")}</tbody></table>`;
+}
+
+/**
+ * @param {unknown} v
+ */
+function fmt(v) {
+  if (v === undefined) return "";
+  if (v === null) return "null";
+  if (typeof v === "object") return safeJson(v);
+  return String(v);
+}
+
+/**
+ * @param {unknown} body
+ */
+function safeJson(body) {
+  try {
+    return JSON.stringify(body, null, 2);
+  } catch {
+    return String(body);
+  }
+}
+
+function escape(value) {
+  return String(value)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}