naive-framework 0.1.0 → 0.2.0

package/schema/need-now.json

@@ -390,6 +390,16 @@
       },
       "why": "Written by the interfaces on every write, so it costs nothing; run mentura baseline once to adopt records written before it (EE-031)"
     },
+    "naive-config": {
+      "base": {
+        "discovery": 0.1,
+        "validation": 0.2,
+        "beachhead": 0.3,
+        "scale": 0.4,
+        "platform": 0.4
+      },
+      "why": "Every default holds without it; write one only to change a default: a route that fails closed, a check that only warns, a pinned package"
+    },
     "knowledge-sources": {
       "base": {
         "discovery": 0.05,
@@ -410,6 +420,16 @@
       },
       "why": "Once one fact (a price, a product name, a plan's limits) is repeated in several places, such as a site, newsletters and a payment provider; before launch there is rarely more than one copy"
     },
+    "freshness-log": {
+      "base": {
+        "discovery": 0.2,
+        "validation": 0.4,
+        "beachhead": 0.6,
+        "scale": 0.7,
+        "platform": 0.8
+      },
+      "why": "Written by mentura revalidate, verify and phase; costs nothing until a fact changes outside the venture, a record is checked without changing it, or the venture changes phase or pivots"
+    },
     "department": {
       "base": {
         "discovery": 0.3,
@@ -537,6 +557,16 @@
       },
       "why": "What the founder walks away with; written at the end of each pipeline run, cheap to refresh"
     },
+    "release": {
+      "base": {
+        "discovery": 0.3,
+        "validation": 0.4,
+        "beachhead": 0.6,
+        "scale": 0.7,
+        "platform": 0.7
+      },
+      "why": "A release to hand someone (an investor, a partner, a hire): the confirmed records frozen in, with named live holes (C-11, I-17). Built with node schema/build-release.mjs when someone outside needs it"
+    },
     "customer": {
       "base": {
         "discovery": 0.2,
@@ -596,6 +626,147 @@
         "platform": 0.3
       },
       "why": "The text of a raw source, beside source.json (EE-070)."
+    },
+    "judgment": {
+      "base": {
+        "discovery": 0.05,
+        "validation": 0.05,
+        "beachhead": 0.05,
+        "scale": 0.05,
+        "platform": 0.05
+      },
+      "why": "Never written by hand: a judgment is what a package's model step answers when mentura steps run asks it, so there is nothing to suggest"
+    },
+    "people": {
+      "base": {
+        "discovery": 0.6,
+        "validation": 0.7,
+        "beachhead": 0.8,
+        "scale": 0.9,
+        "platform": 0.9
+      },
+      "why": "Who is in the venture and which functions each owns; create-venture writes it"
+    },
+    "founder": {
+      "base": {
+        "discovery": 0.5,
+        "validation": 0.6,
+        "beachhead": 0.7,
+        "scale": 0.7,
+        "platform": 0.7
+      },
+      "when": [
+        {
+          "if": "team:cofounders",
+          "at_least": 0.8
+        }
+      ],
+      "why": "One file per founder, written by create-venture; links to the founder agreement"
+    },
+    "fund-thesis": {
+      "base": {
+        "discovery": 0.0,
+        "validation": 0.0,
+        "beachhead": 0.0,
+        "scale": 0.0,
+        "platform": 0.0
+      },
+      "when": [
+        {
+          "if": "type:vc-fund",
+          "at_least": 0.9
+        }
+      ],
+      "why": "A fund's foundation: what it invests in and why it wins"
+    },
+    "fund-terms": {
+      "base": {
+        "discovery": 0.0,
+        "validation": 0.0,
+        "beachhead": 0.0,
+        "scale": 0.0,
+        "platform": 0.0
+      },
+      "when": [
+        {
+          "if": "type:vc-fund",
+          "at_least": 0.9
+        }
+      ],
+      "why": "What the fund raises under; LPs ask for it first"
+    },
+    "deal": {
+      "base": {
+        "discovery": 0.0,
+        "validation": 0.0,
+        "beachhead": 0.0,
+        "scale": 0.0,
+        "platform": 0.0
+      },
+      "when": [
+        {
+          "if": "type:vc-fund",
+          "phase": "validation",
+          "at_least": 0.7
+        },
+        {
+          "if": "type:vc-fund",
+          "phase": "beachhead",
+          "at_least": 0.9
+        },
+        {
+          "if": "type:vc-fund",
+          "phase": "scale",
+          "at_least": 0.9
+        }
+      ],
+      "why": "A fund's pipeline, once it is investing"
+    },
+    "money-summary": {
+      "base": {
+        "discovery": 0.1,
+        "validation": 0.3,
+        "beachhead": 0.6,
+        "scale": 0.8,
+        "platform": 0.8
+      },
+      "when": [
+        {
+          "if": "funding:venture-capital",
+          "at_least": 0.6
+        }
+      ],
+      "why": "Written by the money source's sync; cash and runway once money moves"
+    },
+    "marketing-brand": {
+      "base": {
+        "discovery": 0.2,
+        "validation": 0.4,
+        "beachhead": 0.7,
+        "scale": 0.8,
+        "platform": 0.8
+      },
+      "why": "One brand every agent and interface reads (colors, licensed typefaces, voice rules, marks), once the venture shows itself in public"
+    },
+    "public-assets": {
+      "base": {
+        "discovery": 0.2,
+        "validation": 0.4,
+        "beachhead": 0.7,
+        "scale": 0.8,
+        "platform": 0.8
+      },
+      "why": "The source, license and credit of every file the venture ships as it is, before anything with rights attached is published"
+    },
+    "glossary": {
+      "base": {
+        "discovery": 0.1,
+        "validation": 0.3,
+        "beachhead": 0.5,
+        "scale": 0.6,
+        "platform": 0.7
+      },
+      "why": "A package's own terms, once two packages start using one word in different senses"
     }
   }
 }

package/schema/need-now.mjs

@@ -3,7 +3,8 @@
 // type and phase are in schema/need-now.json; facts about the venture raise or lower them:
 //   phase, ambition, funding, legal_form, offering (of any product), software (any product),
 //   path (go-to-market record), people, founders, agents, products (counts), publishes (a handoff
-//   under public-commitment), team (the answer to Naive's team question: solo, cofounders, looking).
+//   under public-commitment), team (the answer to Naive's team question: solo, cofounders, looking),
+//   type (the venture type, EE-082).
 // Departments (EE-047) are scored the same way, from their priors in operations/departments.json, and
 // held once venture.json lists them. Records that already exist are listed as held; a record in a layer the venture has turned off is
 // listed as layer off, not suggested. Jev re-scores the priors per venture once the
@@ -37,7 +38,7 @@ export function factsOf(dir) {
   const td = existsSync(teamFile) ? load(teamFile) : null;
   const team = td?.status === "decided" ? ["solo", "cofounders", "looking"].find((t) => (td.answer ?? "").toLowerCase().startsWith(t)) ?? null : null;
   return {
-    team, phase: v.phase, ambition: v.ambition, funding: v.form?.funding, legal_form: v.form?.legal_form,
+    team, type: v.type ?? null, phase: v.phase, ambition: v.ambition, funding: v.form?.funding, legal_form: v.form?.legal_form,
     offering: products.map((p) => p.offering), software: products.some((p) => p.software),
     path: json("purpose/validation/go-to-market.json")?.path,
     people: members.filter((m) => m.kind !== "agent").length + (v.owner === "self" && !members.some((m) => m.kind !== "agent") ? 1 : 0),

package/schema/packages.mjs

@@ -29,6 +29,8 @@ import { confirmedIn, filesOf } from "./foundation.mjs";
 import { route } from "../purpose/frameworks/idea-map/route.mjs";
 
 import { loadPackages } from "./load-packages.mjs";
+// Upgrades hook (U-5): packages a venture adopted early in naive.config.json open now.
+import { adopted } from "./naive-config.mjs";
 
 const repo = new URL("..", import.meta.url).pathname;
 const load = (p) => JSON.parse(readFileSync(p, "utf8"));
@@ -107,6 +109,9 @@ export function packages(dir, { flags = {}, answers = null } = {}) {
   const v = load(join(dir, "venture.json"));
   const { phase, facts, questions } = situation(dir, { flags, answers });
   const next = PHASES[PHASES.indexOf(phase) + 1];
+  // Upgrades hook (U-5): a package adopted early opens now, even an experimental one Naive does not model.
+  const early = adopted(dir);
+  const adopt = (id, f) => (early.has(id) && f.in !== "now" ? { ...f, in: "now", early: true, why: `${f.why}; adopted early in naive.config.json` } : f);
   let routes = null;
   try { routes = route(dir); } catch { routes = null; }
   const dest = new Map((routes?.destinations ?? []).map((d) => [d.id, d]));
@@ -126,20 +131,20 @@ export function packages(dir, { flags = {}, answers = null } = {}) {
       moves: s.status === "confirmed" ? "done" : waits.length ? "waits" : "now", ...(waits.length && s.status !== "confirmed" ? { waits_on: waits, waits_on_titles: waits.map(titleOf) } : {}),
       ...(d ? { route: { stage: d.stage, ideas: d.ideas.length, next: d.next ? { by: d.next.by, do: d.next.do, command: d.next.command } : null } } : {}) };
   };
-  const core = Object.entries(PACKAGES.core).filter(([, p]) => !p.not_modeled).map(([id, p]) => {
+  const core = Object.entries(PACKAGES.core).filter(([id, p]) => !p.not_modeled || early.has(id)).map(([id, p]) => {
     const records = [...p.required.map((t) => row(t, "required")), ...p.optional.map((t) => row(t, "optional")), ...p.refs.map((t) => row(t, "reads"))];
     const gate = records.filter((r) => r.role !== "optional");
     const weight = (r) => (r.role === "optional" ? 0.5 : 1);
     const progress = r2(records.reduce((s, r) => s + STATUS[r.status] * weight(r), 0) / records.reduce((s, r) => s + weight(r), 0));
     const state = gate.every((r) => r.status === "confirmed") ? "complete" : gate.every((r) => r.status !== "missing") ? "review" : "building";
-    return { kind: "core", id, title: p.title, department: p.department, purpose: p.purpose, ...fitOf(p), state, progress, records, planned: p.planned, unlocks: p.unlocks,
+    return { kind: "core", id, title: p.title, department: p.department, purpose: p.purpose, ...adopt(id, fitOf(p)), state, progress, records, planned: p.planned, unlocks: p.unlocks,
       missing: gate.filter((r) => r.status === "missing").map((r) => r.record), to_review: gate.filter((r) => r.status === "agent" || r.status === "draft").map((r) => r.record),
       moving: records.filter((r) => r.moves === "now" && r.role !== "reads").map((r) => r.record) };
   });
   const byId = Object.fromEntries(core.map((p) => [p.id, p]));
-  const handoff = Object.entries(PACKAGES.handoff).filter(([, p]) => !p.not_modeled).map(([id, p]) => {
+  const handoff = Object.entries(PACKAGES.handoff).filter(([id, p]) => !p.not_modeled || early.has(id)).map(([id, p]) => {
     const from = p.from.map((c) => byId[c]).filter(Boolean);
-    return { kind: "handoff", id, title: p.title, for: p.for, from: p.from, ...fitOf(p), state: from.every((c) => c.state === "complete") ? "complete" : "building",
+    return { kind: "handoff", id, title: p.title, for: p.for, from: p.from, ...adopt(id, fitOf(p)), state: from.every((c) => c.state === "complete") ? "complete" : "building",
       progress: r2(from.reduce((s, c) => s + c.progress, 0) / from.length), waits_on: from.filter((c) => c.state !== "complete").map((c) => c.id), unlocks: p.unlocks };
   });
   const order = (a, b) => ({ now: 0, next: 1, held: 2 }[a.in] - { now: 0, next: 1, held: 2 }[b.in]) || b.fit - a.fit;
@@ -149,7 +154,7 @@ export function packages(dir, { flags = {}, answers = null } = {}) {
     situation: { facts: Object.fromEntries(questions.map((q) => [q.id, q.value])), questions: questions.map((q) => ({ id: q.id, ask: q.ask, value: q.value, by: q.by, ...(q.p != null ? { p: q.p } : {}), moves: q.moves })) },
     progress: open.length ? r2(open.reduce((s, p) => s + p.progress, 0) / open.length) : 0,
     complete: [...core, ...handoff].filter((p) => p.in === "now" && p.state === "complete").map((p) => p.id),
-    core, handoff, assumes: PACKAGES.assumes, not_modeled: [...Object.entries(PACKAGES.core), ...Object.entries(PACKAGES.handoff)].filter(([, p]) => p.not_modeled).map(([id, p]) => ({ id, title: p.title, why: p.not_modeled })),
+    core, handoff, assumes: PACKAGES.assumes, not_modeled: [...Object.entries(PACKAGES.core), ...Object.entries(PACKAGES.handoff)].filter(([id, p]) => p.not_modeled && !early.has(id)).map(([id, p]) => ({ id, title: p.title, why: p.not_modeled })),
     enhancements: PACKAGES.enhancements,
     routing: routes ? { included: true, note: "Hackathon demo: each record shows where the founder's ideas for it stand and the one step that moves it (EE-061).", loose: routes.loose?.length ?? 0 } : { included: false } };
 }

package/schema/people.schema.json

@@ -0,0 +1,86 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "people.schema.json",
+  "title": "People",
+  "description": "The venture's people (people/people.json): who is in it, in which role, and which functions (hats) each owns. It is to human capital what venture.json is to the venture. A founder also has a file in people/founders/. Names only: no personal details.",
+  "type": "object",
+  "required": [
+    "venture",
+    "mode",
+    "people"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "venture": {
+      "type": "string"
+    },
+    "mode": {
+      "enum": [
+        "solo",
+        "team"
+      ],
+      "description": "solo: one person owns every function the venture imports"
+    },
+    "people": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": [
+          "id",
+          "name",
+          "role",
+          "hats"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^[a-z0-9-]+$"
+          },
+          "name": {
+            "type": "string"
+          },
+          "role": {
+            "type": "string",
+            "description": "A role id from governance/venture-template/roles/venture-roles.json"
+          },
+          "hats": {
+            "type": "array",
+            "items": {
+              "enum": [
+                "strategy",
+                "products",
+                "marketing-and-sales",
+                "supply-chain",
+                "service-delivery",
+                "customer-service",
+                "human-capital",
+                "it",
+                "finance",
+                "assets",
+                "risk-and-compliance",
+                "external-relationships",
+                "capabilities"
+              ]
+            },
+            "uniqueItems": true,
+            "description": "The functions this person owns (operations/departments.json)"
+          },
+          "founder_file": {
+            "type": "string",
+            "pattern": "^people/founders/[a-z0-9-]+\\.json$"
+          }
+        }
+      }
+    },
+    "founder_agreement": {
+      "type": "string",
+      "description": "The founder agreement, once there is one (governance/founder-agreement.json)"
+    },
+    "updated": {
+      "type": "string",
+      "format": "date"
+    }
+  }
+}

package/schema/public-assets.schema.json

@@ -0,0 +1,76 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "public-assets.schema.json",
+  "title": "Public assets",
+  "description": "The register of what the venture ships as it is, at public/assets.json (I-23, J-2, J-3, J-4): each file in public/ with its source, license and credit, facts read by code from its bytes, and alt text with who wrote it; remote images as links with a note in raw/sources/<id>/; and remote_hosts, the hosts an agent may fetch from. Checked by schema/check-assets.mjs. Version 0.x, unevaluated.",
+  "type": "object",
+  "required": ["version", "assets"],
+  "additionalProperties": false,
+  "$defs": {
+    "alt": {
+      "type": "object",
+      "required": ["text", "by"],
+      "additionalProperties": false,
+      "properties": {
+        "text": { "type": "string", "minLength": 1 },
+        "by": { "enum": ["agent", "person"], "description": "Who wrote it. An agent's alt text stays pending until a person confirms it in provenance" }
+      }
+    },
+    "facts": {
+      "type": "object",
+      "required": ["type", "bytes", "sha256"],
+      "additionalProperties": false,
+      "description": "Read from the bytes by code (schema/assets.mjs), never written by hand",
+      "properties": {
+        "type": { "type": "string" },
+        "width": { "type": "integer" },
+        "height": { "type": "integer" },
+        "sizes": { "type": "array", "items": { "type": "string" } },
+        "bytes": { "type": "integer" },
+        "sha256": { "type": "string", "pattern": "^[0-9a-f]{64}$" },
+        "filled_at": { "type": "string" }
+      }
+    }
+  },
+  "properties": {
+    "version": { "type": "string" },
+    "remote_hosts": { "type": "array", "items": { "type": "string" }, "description": "Hosts an agent may fetch images from (exact, or *.example.com); the platform fetcher refuses any other" },
+    "assets": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["path", "source", "license"],
+        "additionalProperties": false,
+        "properties": {
+          "path": { "type": "string", "pattern": "^public/(?!.*\\.\\./).+" },
+          "source": { "type": "string", "description": "Where it came from: who made it, or a URL" },
+          "license": { "type": "string", "description": "An SPDX id (CC-BY-4.0, OFL-1.1), owned (made by or for the venture), licensed (bought), or the restriction (all-rights-reserved)" },
+          "credit": { "type": "string", "description": "Who to credit; a missing credit fails the check" },
+          "alt": { "$ref": "#/$defs/alt" },
+          "decorative": { "type": "boolean", "description": "An image that says nothing, so it needs no alt text" },
+          "origin_url": { "type": "string", "description": "The remote work this is a copy of" },
+          "design_system": { "type": "string", "description": "The design system (brand design_systems id) this came from" },
+          "facts": { "$ref": "#/$defs/facts" }
+        }
+      }
+    },
+    "remote": {
+      "type": "array",
+      "description": "Remote images the venture links to rather than ships",
+      "items": {
+        "type": "object",
+        "required": ["id", "url", "license"],
+        "additionalProperties": false,
+        "properties": {
+          "id": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]*$", "description": "The raw source holding the note: raw/sources/<id>/" },
+          "url": { "type": "string" },
+          "license": { "type": "string" },
+          "credit": { "type": "string" },
+          "alt": { "$ref": "#/$defs/alt" },
+          "fetched": { "$ref": "#/$defs/facts", "description": "Facts from a fetch by the platform; the original stays private in raw/sources/<id>/original.*" },
+          "copy": { "type": "string", "pattern": "^public/", "description": "Where a full copy was kept, only when the license allows it" }
+        }
+      }
+    }
+  }
+}

package/schema/release-read.mjs

@@ -0,0 +1,111 @@
+// Reading a release without the router (C-12, I-17). A release is the venture's static shell
+// (C-11): the confirmed records frozen in, and named holes for what stays live. Everything here
+// reads <venture>/.release/ and nothing else, so a release can be read after the venture's records
+// change, on a machine with no router, or handed to an investor as files. It never imports
+// interface/router.mjs; schema/releases-test.mjs checks that.
+//
+// The answer to a path is { status, type, body }:
+//   /                    the release index: venture, phase, release id, routes in the release, holes
+//   /release.json        the manifest;  /card.json  the release card's data (P-25, O-7)
+//   /records/<file>      one frozen record, as it was when it was confirmed
+//   /<route>             a route as the release holds it: a frozen record, a collection's frozen items,
+//                        a frozen command answer (H-4), or a hole that names where to read it live.
+//                        An item the release does not hold answers 404 with the items it does and the
+//                        command that adds it without rebuilding the rest (C-18, N-10).
+// Any method other than GET or HEAD answers 405: a release is read-only.
+
+import { existsSync, readFileSync } from "node:fs";
+import { join, normalize } from "node:path";
+
+export const RELEASE_DIR = ".release";
+export const MANIFEST = ".release/release.json";
+export const CARD = ".release/card.json";
+export const RECORDS = ".release/records";
+
+/** The release manifest of a venture, or null when it has none. */
+export function readRelease(dir) {
+  const f = join(dir, MANIFEST);
+  return existsSync(f) ? JSON.parse(readFileSync(f, "utf8")) : null;
+}
+
+/** The frozen copy of one record in a release, as text, or null. */
+export function frozenText(dir, file) {
+  const rel = normalize(file);
+  if (rel.startsWith("..") || rel.startsWith("/")) return null;
+  const f = join(dir, RECORDS, rel);
+  return existsSync(f) ? readFileSync(f, "utf8") : null;
+}
+
+const parse = (file, text) => file.endsWith(".json") ? JSON.parse(text) : text;
+const json = (status, body) => ({ status, type: "application/json; charset=utf-8", body: JSON.stringify(body, null, 2) + "\n" });
+
+/** The index a reader starts from. */
+export function index(m) {
+  return { release: m.release, venture: m.venture, name: m.name, phase: m.phase, built_at: m.built_at, now: m.now,
+    routes: m.routes.filter((r) => r.in === "release").map((r) => r.route),
+    holes: m.holes.map((h) => ({ kind: h.kind, route: h.route, name: h.name, why: h.why })),
+    card: "/card.json", manifest: "/release.json",
+    note: "A release is read-only. Holes stay live: read them in the venture through the router." };
+}
+
+/** What a route holds in a release: { status, body }. Matches a concrete route (product/kettle) to its entry. */
+export function resolveRoute(dir, m, route) {
+  route = route.replace(/^\/+|\/+$/g, "");
+  const exact = m.routes.find((r) => r.route === route);
+  const entry = exact ?? m.routes.find((r) => r.route.endsWith("/[id]") && route.startsWith(r.route.slice(0, -4)) && !route.slice(r.route.length - 4).includes("/"));
+  if (!entry) return { status: 404, body: { error: `no route ${route} in release ${m.release}` } };
+  const id = exact ? null : route.slice(entry.route.length - 4);
+  const holes = m.holes.filter((h) => h.route === route || h.route_template === entry.route);
+  // A decision is also found by its id (decisions/founding-team), whatever its file is called.
+  const own = holes.find((h) => (h.route === route || (h.kind === "decision" && `decisions/${h.name}` === route)) && h.kind !== "attribute");
+  if (entry.in === "hole") return { status: 200, body: { route, hole: true, kind: own?.kind ?? entry.kind, why: own?.why ?? entry.why, live: own?.live ?? entry.live ?? null, ...(own ? {} : { holes }) } };
+  if (entry.in === "left out") return { status: 404, body: { route, left_out: true, why: entry.why } };
+  if (entry.kind === "command") {
+    const out = m.commands?.[entry.route];
+    return out === undefined ? { status: 404, body: { route, empty: true, why: entry.why ?? "not in this release" } } : { status: 200, body: { route, frozen: true, built_from: out.built_from, result: out.result } };
+  }
+  const recs = m.records.filter((r) => r.route_template === entry.route);
+  const fieldHoles = (r) => m.holes.filter((h) => h.kind === "attribute" && h.file === r.file).map((h) => h.field);
+  const one = (r) => ({ file: r.file, as_of: r.as_of, confirmed_by: r.confirmed_by, ...(fieldHoles(r).length ? { live_fields: fieldHoles(r) } : {}), record: parse(r.file, frozenText(dir, r.file)) });
+  if (entry.collection === "list") {
+    const items = m.records.filter((r) => r.route_template === `${entry.route}/[id]`);
+    return { status: 200, body: { route, items: Object.fromEntries(items.map((r) => [r.id, one(r)])), holes } };
+  }
+  if (entry.collection === "item") {
+    const hit = recs.find((r) => r.id === id);
+    if (own) return { status: 200, body: { route, hole: true, kind: own.kind, why: own.why, live: own.live ?? null } };
+    if (!hit) return { status: 404, body: { route, not_in_release: true, release: m.release, items: recs.map((r) => r.id), ...(holes.length ? { live_items: holes.filter((h) => h.kind !== "attribute").map((h) => h.name) } : {}),
+      note: `${route} was not known when release ${m.release} was built`, add: `node schema/build-release.mjs <venture dir> --add ${route}` } };
+    return { status: 200, body: { route, ...one(hit) } };
+  }
+  if (!recs.length) return { status: 404, body: { route, empty: true, why: entry.why ?? "no confirmed record when the release was built" } };
+  return { status: 200, body: { route, ...(recs.length === 1 ? one(recs[0]) : { records: recs.map(one) }) } };
+}
+
+/**
+ * Answers one request against a venture's release. draw, when given, turns the card's data into an
+ * image (the interface's job, O-7): draw(card) -> SVG text.
+ */
+export function answer(dir, method, path, { draw } = {}) {
+  if (method !== "GET" && method !== "HEAD") return { ...json(405, { error: "a release is read-only: only GET and HEAD" }), allow: "GET, HEAD" };
+  const m = readRelease(dir);
+  if (!m) return json(503, { error: `no release in ${dir}: run node schema/build-release.mjs ${dir} first` });
+  const p = decodeURIComponent(path.split("?")[0]);
+  if (p.split("/").includes("..")) return json(400, { error: "no .. in a release path" });
+  if (p === "/" || p === "") return json(200, index(m));
+  if (p === "/release.json") return json(200, m);
+  if (p === "/card.json") return existsSync(join(dir, CARD)) ? json(200, JSON.parse(readFileSync(join(dir, CARD), "utf8"))) : json(404, { error: "this release has no card" });
+  if (p === "/card.svg") {
+    if (!draw) return json(404, { error: "no card drawing here" });
+    return { status: 200, type: "image/svg+xml; charset=utf-8", body: draw(JSON.parse(readFileSync(join(dir, CARD), "utf8"))) };
+  }
+  if (p.startsWith("/records/")) {
+    const file = p.slice("/records/".length);
+    const r = m.records.find((x) => x.file === file);
+    const text = r ? frozenText(dir, file) : null;
+    if (text === null) return json(404, { error: `${file} is not in release ${m.release}` });
+    return { status: 200, type: file.endsWith(".json") ? "application/json; charset=utf-8" : "text/markdown; charset=utf-8", body: text };
+  }
+  const r = resolveRoute(dir, m, p);
+  return json(r.status, r.body);
+}