@specbook/vite 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,9 +1,168 @@
 // src/index.ts
 import { existsSync as existsSync3, readdirSync } from "fs";
-import { mkdir as mkdir2, readFile as readFile5, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile6, writeFile as writeFile2 } from "fs/promises";
 import { createRequire } from "module";
-import { basename, dirname, join as join4, relative as relative4, resolve as resolve2, sep as sep4 } from "path";
-import fg4 from "fast-glob";
+import { basename, dirname, join as join5, relative as relative4, resolve as resolve2, sep as sep4 } from "path";
+
+// ../core/src/faker.ts
+var KEY = "__specbookFaker";
+var store = globalThis;
+var faker = new Proxy({}, {
+  get(_t, key) {
+    const current = store[KEY];
+    if (!current) {
+      throw new Error(
+        'faker is not initialised. Install "@faker-js/faker" in your project; specbook sets it up before each run.'
+      );
+    }
+    return current[key];
+  }
+});
+
+// ../core/src/template.ts
+var NAME = String.raw`[\w.$\[\]-]+`;
+var WHOLE = new RegExp(String.raw`^\s*\{\{\s*(${NAME})\s*\}\}\s*$`);
+var EMBED = new RegExp(String.raw`\{\{\s*(${NAME})\s*\}\}`, "g");
+var DEFERRED_NAMESPACES = ["secrets", "session"];
+var TemplateError = class extends Error {
+  constructor(variable) {
+    super(`Missing variable "{{${variable}}}"`);
+    this.variable = variable;
+    this.name = "TemplateError";
+  }
+  variable;
+};
+function isDeferred(name) {
+  const ns = name.split(".")[0];
+  return DEFERRED_NAMESPACES.includes(ns) && name.includes(".");
+}
+var isFakerName = (name) => name.startsWith("faker.");
+function fromFaker(path) {
+  let parent = faker;
+  let cur = faker;
+  for (const part of path.split(".").slice(1)) {
+    parent = cur;
+    cur = cur?.[part];
+    if (cur === void 0) return { found: false };
+  }
+  return { found: true, value: typeof cur === "function" ? cur.call(parent) : cur };
+}
+var steps = (path) => path.replace(/\[(\d+)\]/g, ".$1").split(".");
+function lookup(scope, path) {
+  if (isFakerName(path)) return fromFaker(path);
+  let cur = scope;
+  for (const part of steps(path)) {
+    if (cur !== null && typeof cur === "object" && Object.hasOwn(cur, part)) {
+      cur = cur[part];
+    } else {
+      return { found: false };
+    }
+  }
+  return { found: true, value: cur };
+}
+function renderString(s, scope) {
+  const whole = WHOLE.exec(s);
+  if (whole) {
+    const name = whole[1];
+    if (isDeferred(name)) return s;
+    const r = lookup(scope, name);
+    if (!r.found) throw new TemplateError(name);
+    return r.value;
+  }
+  return s.replace(EMBED, (m, name) => {
+    if (isDeferred(name)) return m;
+    const r = lookup(scope, name);
+    if (!r.found) throw new TemplateError(name);
+    const v = r.value;
+    return typeof v === "object" && v !== null ? JSON.stringify(v) : String(v);
+  });
+}
+function collectPlaceholders(value, into = /* @__PURE__ */ new Set()) {
+  if (typeof value === "string") {
+    for (const m of value.matchAll(EMBED)) into.add(m[1]);
+  } else if (Array.isArray(value)) {
+    for (const v of value) collectPlaceholders(v, into);
+  } else if (value !== null && typeof value === "object") {
+    for (const v of Object.values(value)) collectPlaceholders(v, into);
+  }
+  return into;
+}
+
+// ../core/src/environment.ts
+var AddressError = class extends Error {
+  constructor(message, variable) {
+    super(message);
+    this.variable = variable;
+    this.name = "AddressError";
+  }
+  variable;
+};
+var OAUTH_ADDRESS_FIELDS = [
+  "authorizationUrl",
+  "tokenUrl",
+  "openIdConnectUrl",
+  "clientId"
+];
+function environmentScope(cfg, env, fileVars = {}, extra = {}) {
+  return {
+    ...cfg.vars,
+    ...cfg.environments?.[env]?.vars,
+    ...fileVars,
+    ...extra
+  };
+}
+function renderAddress(template, scope, what) {
+  for (const name of collectPlaceholders(template)) {
+    if (isDeferred(name) || isFakerName(name))
+      throw new AddressError(
+        `${what} cannot use {{${name}}}: only environment variables are available`
+      );
+  }
+  let value;
+  try {
+    value = renderString(template, scope);
+  } catch (e) {
+    if (e instanceof TemplateError) throw new AddressError(`${what}: set ${e.variable}`, e.variable);
+    throw e;
+  }
+  if (value !== null && typeof value === "object")
+    throw new AddressError(`${what} is not a text value`);
+  const out = value === void 0 || value === null ? "" : String(value).trim();
+  if (/\{\{/.test(out)) throw new AddressError(`${what} still contains a placeholder: ${out}`);
+  return out;
+}
+function baseUrlFor(cfg, service, env, scope) {
+  const base = cfg.services[service]?.baseUrl;
+  const template = typeof base === "string" ? base : base?.[env];
+  if (!template) return void 0;
+  const what = `No base URL for ${service} in ${env}`;
+  const url = /\{\{/.test(template) ? renderAddress(template, scope, what) : template.trim();
+  return url ? url.replace(/\/+$/, "") : void 0;
+}
+function oauthFor(oauth, scope, profile = "sign-in") {
+  const out = { ...oauth };
+  for (const field of OAUTH_ADDRESS_FIELDS) {
+    const v = out[field];
+    if (typeof v !== "string" || !/\{\{/.test(v)) continue;
+    const rendered = renderAddress(v, scope, `${profile} ${field}`);
+    if (rendered) out[field] = rendered;
+    else delete out[field];
+  }
+  return out;
+}
+function environmentNames(cfg, fileEnvs = [], extra = []) {
+  const names = /* @__PURE__ */ new Set(["mock"]);
+  const services = Object.values(cfg.services ?? {});
+  if (services.some((s) => typeof s.baseUrl === "string")) names.add("live");
+  for (const s of services) {
+    if (s.baseUrl && typeof s.baseUrl === "object")
+      for (const k of Object.keys(s.baseUrl)) names.add(k);
+  }
+  for (const k of Object.keys(cfg.environments ?? {})) names.add(k);
+  for (const k of fileEnvs) names.add(k);
+  for (const k of extra) names.add(k);
+  return [...names];
+}
 
 // ../core/src/oauth.ts
 var OAuthError = class extends Error {
@@ -318,6 +477,65 @@ function parseDotenv(text) {
   return out;
 }
 
+// src/index.ts
+import fg4 from "fast-glob";
+
+// src/addresses.ts
+var NO_ADDRESSES = {
+  services: {},
+  tokenOrigins: {},
+  discoveryOrigins: {}
+};
+async function addressesFor(cfg, env, files, tokenOriginOf) {
+  const services = cfg.services ?? {};
+  const known = environmentNames({ services, environments: cfg.environments }, files.environments);
+  if (!known.includes(env)) return NO_ADDRESSES;
+  const scope = environmentScope(cfg, env, await files.vars());
+  const out = { services: {}, tokenOrigins: {}, discoveryOrigins: {} };
+  for (const [name, svc] of Object.entries(services)) {
+    if (env === "mock" && typeof svc.baseUrl === "string") continue;
+    try {
+      out.services[name] = baseUrlFor({ services }, name, env, scope);
+    } catch {
+    }
+  }
+  for (const [name, profile] of Object.entries(cfg.auth ?? {})) {
+    try {
+      if (!profile.oauth) continue;
+      const oauth = oauthFor(profile.oauth, scope, name);
+      if ("tokenUrl" in oauth && oauth.tokenUrl)
+        out.tokenOrigins[name] = new URL(oauth.tokenUrl).origin;
+      else if ("openIdConnectUrl" in oauth && oauth.openIdConnectUrl) {
+        out.discoveryOrigins[name] = new URL(oauth.openIdConnectUrl).origin;
+        const token = await tokenOriginOf(oauth.openIdConnectUrl);
+        if (token) out.tokenOrigins[name] = token;
+      }
+    } catch {
+    }
+  }
+  return out;
+}
+
+// src/definitions.ts
+function definitionRefs(text) {
+  const names = [];
+  for (const m of text.matchAll(/"\$ref":"(?:specbook:\/\/[^"#]*)?#\/\$defs\/([^"]+)"/g))
+    names.push(m[1].replace(/~1/g, "/").replace(/~0/g, "~"));
+  return names;
+}
+function pruneDefinitions(defs, roots) {
+  const all = defs.$defs ?? {};
+  const keep = /* @__PURE__ */ new Set();
+  const queue = [...roots ?? []];
+  while (queue.length) {
+    const name = queue.pop();
+    if (keep.has(name) || !(name in all)) continue;
+    keep.add(name);
+    queue.push(...definitionRefs(JSON.stringify(all[name])));
+  }
+  return { ...defs, $defs: Object.fromEntries(Object.entries(all).filter(([k]) => keep.has(k))) };
+}
+
 // src/discovery.ts
 var FETCH_TIMEOUT_MS = 5e3;
 function createDiscovery(opts = {}) {
@@ -511,7 +729,7 @@ async function writeEnvKey(file, key, value) {
 import { relative as relative2, sep as sep2 } from "path";
 import fg2 from "fast-glob";
 var IGNORE = ["**/node_modules/**", "**/.generated/**", "**/dist/**", "**/.git/**"];
-var NAME = /\.example\.json$/;
+var NAME2 = /\.example\.json$/;
 async function scanExamples(root, outDir, operations) {
   const examples = {};
   const assets = {};
@@ -527,8 +745,9 @@ async function scanExamples(root, outDir, operations) {
   const gen = `${root}/${outDir}`;
   for (const abs of await fg2("*/examples/*/*.example.json", { cwd: gen, absolute: true })) {
     const [svc, , id, file] = relative2(gen, abs).split(sep2);
+    if (!operations.has(`${svc}/${id}`)) continue;
     add(`${svc}/${id}`, {
-      name: file.replace(NAME, ""),
+      name: file.replace(NAME2, ""),
       abs,
       source: "generated",
       dir: `${svc}/${id}@generated`
@@ -542,7 +761,7 @@ async function scanExamples(root, outDir, operations) {
     const key = `${svc}/${id}`;
     if (!svc || !id || !operations.has(key)) continue;
     add(key, {
-      name: file.replace(NAME, ""),
+      name: file.replace(NAME2, ""),
       abs,
       source: "project",
       dir: `${svc}/${id}@project`
@@ -622,6 +841,15 @@ async function handleProxy2(req, res, deps) {
   const url = req.url ?? "/";
   if (!url.startsWith(`${MOUNT}/`)) return false;
   const config = await deps.getConfig();
+  const addressesByEnv = /* @__PURE__ */ new Map();
+  const addressesFor2 = (env) => {
+    let a = addressesByEnv.get(env);
+    if (!a) {
+      a = config.resolve(env);
+      addressesByEnv.set(env, a);
+    }
+    return a;
+  };
   const secretsByEnv = /* @__PURE__ */ new Map();
   const method = req.method ?? "GET";
   const headers = new Headers();
@@ -636,12 +864,13 @@ async function handleProxy2(req, res, deps) {
   const response = await handleProxy(request, {
     mount: MOUNT,
     policy: {
-      upstream: (env, service) => {
+      upstream: async (env, service) => {
+        const a = await addressesFor2(env);
         if (service.startsWith(AUTH_SERVICE_PREFIX))
-          return config.tokenOrigins?.[decode(service.slice(AUTH_SERVICE_PREFIX.length))];
+          return a.tokenOrigins[decode(service.slice(AUTH_SERVICE_PREFIX.length))];
         if (service.startsWith(DISCOVERY_SERVICE_PREFIX))
-          return config.discoveryOrigins?.[decode(service.slice(DISCOVERY_SERVICE_PREFIX.length))];
-        return config.services[service]?.baseUrl[env];
+          return a.discoveryOrigins[decode(service.slice(DISCOVERY_SERVICE_PREFIX.length))];
+        return a.services[service];
       },
       // a developer's own machine: their local services are the point
       allowPrivateHosts: true
@@ -671,9 +900,47 @@ async function handleProxy2(req, res, deps) {
   return true;
 }
 
-// src/sequences.ts
+// src/requests.ts
 import { readFile as readFile4 } from "fs/promises";
 import { join as join3 } from "path";
+function parseRequestTarget(src, services) {
+  const local = /* @__PURE__ */ new Map();
+  for (const m of src.matchAll(/import\s*(?:type\s*)?\{([^}]*)\}\s*from\s*['"]([^'"]+)['"]/g)) {
+    const service = m[2].split("/").pop();
+    if (!services.has(service) || /^import\s*type/.test(m[0])) continue;
+    for (const part of m[1].split(",")) {
+      const spec = part.trim();
+      if (!spec || spec.startsWith("type ")) continue;
+      const [imported, as] = spec.split(/\s+as\s+/);
+      local.set(as ?? imported, `${service}/${imported}`);
+    }
+  }
+  const used = /* @__PURE__ */ new Set();
+  for (const m of src.matchAll(/\b([A-Za-z_$][\w$]*)\s*\.\s*request\s*\(/g)) {
+    const key = local.get(m[1]);
+    if (key) used.add(key);
+  }
+  return used.size === 1 ? [...used][0] : void 0;
+}
+async function scanRequests(root, files, services) {
+  const meta = {};
+  const unresolved = [];
+  await Promise.all(
+    files.map(async (file) => {
+      const key = parseRequestTarget(
+        await readFile4(join3(root, file), "utf8").catch(() => ""),
+        services
+      );
+      if (key) meta[file] = key;
+      else unresolved.push(file);
+    })
+  );
+  return { meta, unresolved: unresolved.sort() };
+}
+
+// src/sequences.ts
+import { readFile as readFile5 } from "fs/promises";
+import { join as join4 } from "path";
 var KEYS = ["id", "title", "description", "group", "tags"];
 function readString(src, i) {
   const q = src[i];
@@ -771,7 +1038,7 @@ async function scanSequences(root, files) {
   const unresolved = [];
   await Promise.all(
     files.map(async (file) => {
-      const parsed = parseSequenceMeta(await readFile4(join3(root, file), "utf8").catch(() => ""));
+      const parsed = parseSequenceMeta(await readFile5(join4(root, file), "utf8").catch(() => ""));
       if (parsed) meta[parsed.id] = { ...parsed, file };
       else unresolved.push(file);
     })
@@ -788,14 +1055,14 @@ var VIRTUAL_FAKER = "virtual:specbook/faker";
 var RESOLVED_FAKER = `\0${VIRTUAL_FAKER}`;
 var VIRTUAL_FAKER_LOCALE = "virtual:specbook/faker-locale/";
 var RESOLVED_FAKER_LOCALE = `\0${VIRTUAL_FAKER_LOCALE}`;
-var VIRTUAL_MANIFESTS = "virtual:specbook/manifests";
-var RESOLVED_MANIFESTS = `\0${VIRTUAL_MANIFESTS}`;
+var VIRTUAL_MANIFEST = "virtual:specbook/manifest/";
+var RESOLVED_MANIFEST = `\0${VIRTUAL_MANIFEST}`;
 var VIRTUAL_OPERATIONS = "virtual:specbook/operations";
 var RESOLVED_OPERATIONS = `\0${VIRTUAL_OPERATIONS}`;
 var VIRTUAL_DOC = "virtual:specbook/doc/";
 var RESOLVED_DOC = `\0${VIRTUAL_DOC}`;
 function findConfig(root) {
-  return [join4(root, ".specbook/specbook.config.ts"), join4(root, "specbook.config.ts")].find(
+  return [join5(root, ".specbook/specbook.config.ts"), join5(root, "specbook.config.ts")].find(
     existsSync3
   );
 }
@@ -816,7 +1083,7 @@ async function readBody2(req) {
 }
 function fakerLocales(entry) {
   const names = /* @__PURE__ */ new Set(["en", "base"]);
-  const dir = join4(dirname(entry), "locale");
+  const dir = join5(dirname(entry), "locale");
   if (existsSync3(dir))
     for (const f of readdirSync(dir)) {
       const m = /^([A-Za-z0-9_]+)\.js$/.exec(f);
@@ -839,13 +1106,13 @@ function slim(manifests) {
 }
 async function collectTypes(root, outDir) {
   const libs = {};
-  const req = createRequire(join4(root, "package.json"));
+  const req = createRequire(join5(root, "package.json"));
   try {
     const entry = req.resolve("@specbook/core");
     const srcDir = dirname(entry);
     const files = await fg4("**/*.ts", { cwd: srcDir, ignore: ["**/*.test.ts"] });
     for (const f of files) {
-      libs[`file:///node_modules/@specbook/core/src/${f}`] = await readFile5(join4(srcDir, f), "utf8");
+      libs[`file:///node_modules/@specbook/core/src/${f}`] = await readFile6(join5(srcDir, f), "utf8");
     }
     libs["file:///node_modules/@specbook/core/package.json"] = JSON.stringify({
       name: "@specbook/core",
@@ -853,24 +1120,27 @@ async function collectTypes(root, outDir) {
     });
   } catch {
   }
-  const genDir = join4(root, outDir);
+  const genDir = join5(root, outDir);
   for (const f of await fg4("**/*.ts", { cwd: genDir })) {
-    libs[`file:///${outDir}/${f}`] = await readFile5(join4(genDir, f), "utf8");
+    libs[`file:///${outDir}/${f}`] = await readFile6(join5(genDir, f), "utf8");
   }
   const project = await scanProject(root);
   const sources = {};
   for (const f of project.sources.filter((s) => s.endsWith(".ts"))) {
-    sources[f] = await readFile5(join4(root, f), "utf8");
+    sources[f] = await readFile6(join5(root, f), "utf8");
   }
   return { libs, sources };
 }
 function specbook(options) {
   const root = resolve2(options.projectRoot);
   const outDir = options.outDir ?? ".generated";
+  const only = options.operations;
+  const keep = (service, op) => !only || only.has(`${service}/${op}`);
+  const neededDefs = /* @__PURE__ */ new Map();
   let server;
   let isBuild = false;
   let docHtml = [];
-  let manifestsCode = "export default {}";
+  let manifestCode = /* @__PURE__ */ new Map();
   let operationsCode = "export const operations = {}";
   let bundlePlan = /* @__PURE__ */ new Map();
   let definitionFiles = /* @__PURE__ */ new Map();
@@ -883,13 +1153,25 @@ function specbook(options) {
   async function registryCode() {
     const files = await scanProject(root);
     const manifests = {};
-    for (const m of await fg4("*/manifest.json", { cwd: join4(root, outDir), absolute: true })) {
-      const parsed = JSON.parse(await readFile5(m, "utf8"));
+    for (const m of await fg4("*/manifest.json", { cwd: join5(root, outDir), absolute: true })) {
+      const parsed = JSON.parse(await readFile6(m, "utf8"));
       manifests[parsed.service] = parsed;
     }
-    const examples = await fg4("*/examples/*/*.response.json", {
-      cwd: join4(root, outDir),
+    if (only) {
+      for (const [svc, m] of Object.entries(manifests)) {
+        const mm = m;
+        mm.operations = mm.operations.filter((o) => keep(svc, o.id));
+        if (mm.operations.length === 0) delete manifests[svc];
+        else mm.tags = [...new Set(mm.operations.flatMap((o) => o.tags ?? []))];
+      }
+    }
+    const inScope = (svc, op) => svc in manifests && keep(svc, op);
+    const examples = (await fg4("*/examples/*/*.response.json", {
+      cwd: join5(root, outDir),
       absolute: true
+    })).filter((abs) => {
+      const rel = relative4(join5(root, outDir), abs).split(sep4);
+      return inScope(rel[0], rel[2]);
     });
     const imp = (abs) => {
       if (isBuild) return `() => import(${JSON.stringify(abs)})`;
@@ -898,50 +1180,45 @@ function specbook(options) {
       return `(v) => import(/* @vite-ignore */ ${JSON.stringify(`/@fs${abs}`)} + '?t=' + v)`;
     };
     const raw = (abs) => `() => import(${JSON.stringify(`${abs}?raw`)}).then((m) => m.default)`;
-    const entry = (file) => `{ file: ${JSON.stringify(file)}, load: ${imp(join4(root, file))}${isBuild ? `, source: ${raw(join4(root, file))}` : ""} }`;
+    const entry = (file) => `{ file: ${JSON.stringify(file)}, load: ${imp(join5(root, file))}${isBuild ? `, source: ${raw(join5(root, file))}` : ""} }`;
     const cfg = findConfig(root);
     const requestsDir = requestsDirFor(root);
-    existsSync3(join4(root, "apis")) && !existsSync3(join4(root, "requests")) ? "apis" : "requests";
+    existsSync3(join5(root, "apis")) && !existsSync3(join5(root, "requests")) ? "apis" : "requests";
     let fakerEntry;
     try {
-      fakerEntry = createRequire(join4(root, "package.json")).resolve("@faker-js/faker");
+      fakerEntry = createRequire(join5(root, "package.json")).resolve("@faker-js/faker");
     } catch {
     }
     const operationEntries = Object.values(manifests).flatMap((m) => {
       const mm = m;
       return mm.operations.map(
-        (o) => `  ${JSON.stringify(`${mm.service}/${o.id}`)}: ${imp(join4(root, outDir, mm.service, "operations", `${o.id}.ts`))}`
+        (o) => `  ${JSON.stringify(`${mm.service}/${o.id}`)}: ${imp(join5(root, outDir, mm.service, "operations", `${o.id}.ts`))}`
       );
     });
-    const schemaFiles = await fg4("*/schemas/*.request.schema.json", {
-      cwd: join4(root, outDir),
-      absolute: true
-    });
-    const responseFiles = await fg4("*/schemas/*.responses.schema.json", {
-      cwd: join4(root, outDir),
-      absolute: true
-    });
+    const opOf = (abs, suffix) => {
+      const rel = relative4(join5(root, outDir), abs).split(sep4);
+      return [rel[0], rel[2].replace(suffix, "")];
+    };
+    const schemaFiles = (await fg4("*/schemas/*.request.schema.json", { cwd: join5(root, outDir), absolute: true })).filter((abs) => inScope(...opOf(abs, /\.request\.schema\.json$/)));
+    const responseFiles = (await fg4("*/schemas/*.responses.schema.json", { cwd: join5(root, outDir), absolute: true })).filter((abs) => inScope(...opOf(abs, /\.responses\.schema\.json$/)));
     const responseEntries = responseFiles.map((abs) => {
-      const rel = relative4(join4(root, outDir), abs).split(sep4);
+      const rel = relative4(join5(root, outDir), abs).split(sep4);
       const op = rel[2].replace(/\.responses\.schema\.json$/, "");
       return `  ${JSON.stringify(`${rel[0]}/${op}`)}: ${imp(abs)}`;
     });
-    const defFiles = await fg4("*/schemas/definitions.schema.json", {
-      cwd: join4(root, outDir),
-      absolute: true
-    });
+    const defFiles = (await fg4("*/schemas/definitions.schema.json", { cwd: join5(root, outDir), absolute: true })).filter((abs) => relative4(join5(root, outDir), abs).split(sep4)[0] in manifests);
     const schemaEntries = schemaFiles.map((abs) => {
-      const rel = relative4(join4(root, outDir), abs).split(sep4);
+      const rel = relative4(join5(root, outDir), abs).split(sep4);
       const op = rel[2].replace(/\.request\.schema\.json$/, "");
       return `  ${JSON.stringify(`${rel[0]}/${op}`)}: ${imp(abs)}`;
     });
-    const docFiles = await fg4("*/docs/*.json", { cwd: join4(root, outDir), absolute: true });
+    const docFiles = (await fg4("*/docs/*.json", { cwd: join5(root, outDir), absolute: true })).filter((abs) => inScope(...opOf(abs, /\.json$/)));
     const operationDocEntries = docFiles.map((abs) => {
-      const rel = relative4(join4(root, outDir), abs).split(sep4);
+      const rel = relative4(join5(root, outDir), abs).split(sep4);
       return `  ${JSON.stringify(`${rel[0]}/${rel[2].replace(/\.json$/, "")}`)}: ${imp(abs)}`;
     });
     const defEntries = defFiles.map((abs) => {
-      const service = relative4(join4(root, outDir), abs).split(sep4)[0];
+      const service = relative4(join5(root, outDir), abs).split(sep4)[0];
       return `  ${JSON.stringify(service)}: ${imp(abs)}`;
     });
     const known = new Set(
@@ -951,11 +1228,15 @@ function specbook(options) {
       })
     );
     const sequenceScan = await scanSequences(root, files.sequences);
+    const requestScan = await scanRequests(root, files.requests, new Set(Object.keys(manifests)));
     for (const f of files.sequences) {
-      const src = await readFile5(join4(root, f), "utf8").catch(() => "");
-      seqHeaders.set(join4(root, f), JSON.stringify(parseSequenceMeta(src)));
+      const src = await readFile6(join5(root, f), "utf8").catch(() => "");
+      seqHeaders.set(join5(root, f), JSON.stringify(parseSequenceMeta(src)));
     }
     const scanned = await scanExamples(root, outDir, known);
+    const keepExampleKey = (key) => !only || only.has(key);
+    for (const key of Object.keys(scanned.examples))
+      if (!keepExampleKey(key)) delete scanned.examples[key];
     const url = (abs) => isBuild ? `() => import(${JSON.stringify(`${abs}?url`)}).then((m) => m.default)` : `() => import(/* @vite-ignore */ ${JSON.stringify(`/@fs${abs}?url`)}).then((m) => m.default)`;
     const requestExampleEntries = Object.entries(scanned.examples).map(
       ([key, list]) => `  ${JSON.stringify(key)}: [${list.map(
@@ -977,23 +1258,28 @@ function specbook(options) {
     const assetEntries = Object.entries(scanned.assets).map(
       ([key, abs]) => `  ${JSON.stringify(key)}: ${url(abs)}`
     );
-    const pages = await scanDocs(root);
+    const pages = (await scanDocs(root)).filter(
+      (p) => !only || !p.operation || only.has(p.operation)
+    );
     docHtml = pages.map((p) => p.html);
     const docEntries = pages.map(
       (p, i) => `{ file: ${JSON.stringify(p.file)}, operation: ${JSON.stringify(p.operation)}, sequence: ${JSON.stringify(p.sequence)}, sequenceFile: ${JSON.stringify(p.sequenceFile)}, requestFile: ${JSON.stringify(p.requestFile)}, replace: ${JSON.stringify(p.replace)}, title: ${JSON.stringify(p.title)}, load: () => import(${JSON.stringify(`${VIRTUAL_DOC}${i}`)}).then((m) => m.default) }`
     );
     const exampleEntries = examples.map((abs) => {
-      const rel = relative4(join4(root, outDir), abs).split(sep4);
+      const rel = relative4(join5(root, outDir), abs).split(sep4);
       const status = rel[3].replace(/\.response\.json$/, "");
       const key = `${rel[0]}/${rel[2]}.${status}`;
       return `  ${JSON.stringify(key)}: ${imp(abs)}`;
     });
     if (isBuild) {
-      manifestsCode = `export default ${JSON.stringify(slim(manifests))}`;
+      const slimmed = slim(manifests);
+      manifestCode = new Map(
+        Object.entries(slimmed).map(([svc, m]) => [svc, `export default ${JSON.stringify(m)}`])
+      );
       operationsCode = `export const operations = {
 ${operationEntries.join(",\n")}
 }`;
-      const gen = join4(root, outDir);
+      const gen = join5(root, outDir);
       bundlePlan = /* @__PURE__ */ new Map();
       const slot = (key) => {
         const have = bundlePlan.get(key);
@@ -1033,7 +1319,7 @@ ${operationEntries.join(",\n")}
           const n = counts.get(tag) ?? 0;
           counts.set(tag, n + 1);
           operationChunks.set(
-            join4(gen, m.service, "operations", `${o.id}.ts`),
+            join5(gen, m.service, "operations", `${o.id}.ts`),
             `ops-${m.service}-${tag}-${Math.floor(n / 40)}`
           );
         }
@@ -1047,8 +1333,8 @@ ${operationEntries.join(",\n")}
             projectLoads.push(`  ${JSON.stringify(`${key}/${e.name}`)}: ${imp(e.abs)}`);
       }
       const services = Object.keys(manifests);
-      return `import manifests from ${JSON.stringify(VIRTUAL_MANIFESTS)}
-export const mode = "static"
+      return `export const mode = "static"
+export const minimal = ${JSON.stringify(!!only)}
 export const project = ${JSON.stringify({ root, outDir, requestsDir })}
 // where the data files are: dist/data, whether this chunk is in dist/ or dist/assets/
 const dataBase = import.meta.url.replace(/(assets\\/)?[^/]*$/, '') + 'data/'
@@ -1062,8 +1348,15 @@ const bundle = (key) => {
 }
 const part = (pick) =>
   new Proxy({}, { get: (_, key) => (typeof key === 'string' && key.includes('/') ? () => bundle(key).then((b) => ({ default: pick(b) })) : undefined) })
-export { manifests }
+export const manifests = {}
+const manifestLoaders = {${services.map((svc) => `
+  ${JSON.stringify(svc)}: () => import(${JSON.stringify(`${VIRTUAL_MANIFEST}${svc}`)})`).join(",")}
+}
+export const loadManifests = (names = Object.keys(manifestLoaders)) =>
+  Promise.all(names.map((svc) => manifests[svc] ? undefined : manifestLoaders[svc]?.().then((m) => { manifests[svc] = m.default }))).then(() => undefined)
 export const requests = [${files.requests.map(entry).join(",\n")}]
+export const requestMeta = ${JSON.stringify(requestScan.meta)}
+export const unresolvedRequests = ${JSON.stringify(requestScan.unresolved)}
 export const sequences = [${files.sequences.map(entry).join(",\n")}]
 export const sequenceMeta = ${JSON.stringify(sequenceScan.meta)}
 export const unresolvedSequences = ${JSON.stringify(sequenceScan.unresolved)}
@@ -1119,9 +1412,13 @@ export const loadConfig = ${cfg ? imp(cfg) : '() => Promise.resolve({ default: {
 `;
     }
     return `export const mode = ${JSON.stringify(isBuild ? "static" : "dev")}
+export const minimal = ${JSON.stringify(!!only)}
 export const project = ${JSON.stringify({ root, outDir, requestsDir })}
 export const manifests = ${JSON.stringify(slim(manifests))}
+export const loadManifests = () => Promise.resolve()
 export const requests = [${files.requests.map(entry).join(",\n")}]
+export const requestMeta = ${JSON.stringify(requestScan.meta)}
+export const unresolvedRequests = ${JSON.stringify(requestScan.unresolved)}
 export const sequences = [${files.sequences.map(entry).join(",\n")}]
 export const sequenceMeta = ${JSON.stringify(sequenceScan.meta)}
 export const unresolvedSequences = ${JSON.stringify(sequenceScan.unresolved)}
@@ -1158,33 +1455,24 @@ export const loadFaker = ${fakerEntry ? `() => import('virtual:specbook/faker')`
 export const loadConfig = ${cfg ? imp(cfg) : '() => Promise.resolve({ default: { project: "specbook", services: {} } })'}
 `;
   }
-  async function getProxyConfig() {
+  async function loadProjectConfig() {
     const cfgFile = findConfig(root);
-    if (!server || !cfgFile) return { services: {}, secretNames: {} };
-    const mod = await server.ssrLoadModule(cfgFile);
-    const cfg = mod.default ?? {};
-    const tokenOrigins = {};
-    const discoveryOrigins = {};
-    for (const [name, profile] of Object.entries(cfg.auth ?? {})) {
-      try {
-        const { tokenUrl, openIdConnectUrl } = profile.oauth ?? {};
-        if (tokenUrl) tokenOrigins[name] = new URL(tokenUrl).origin;
-        else if (openIdConnectUrl) {
-          discoveryOrigins[name] = new URL(openIdConnectUrl).origin;
-          const token = await tokenOriginOf(openIdConnectUrl);
-          if (token) tokenOrigins[name] = token;
-        }
-      } catch {
-      }
-    }
-    return {
-      services: Object.fromEntries(
-        Object.entries(cfg.services ?? {}).map(([k, v]) => [k, { baseUrl: v.baseUrl ?? {} }])
-      ),
-      secretNames: cfg.secrets ?? {},
-      tokenOrigins,
-      discoveryOrigins
-    };
+    if (!server || !cfgFile) return void 0;
+    return (await server.ssrLoadModule(cfgFile)).default ?? {};
+  }
+  async function getProxyConfig() {
+    const cfg = await loadProjectConfig();
+    if (!cfg) return { secretNames: {}, resolve: async () => NO_ADDRESSES };
+    const resolve3 = async (env) => isEnvName(env) ? addressesFor(
+      cfg,
+      env,
+      {
+        environments: await listEnvironmentFiles(root),
+        vars: async () => (await readEnvironment(root, env)).vars
+      },
+      tokenOriginOf
+    ) : NO_ADDRESSES;
+    return { secretNames: cfg.secrets ?? {}, resolve: resolve3 };
   }
   return {
     name: "specbook",
@@ -1192,7 +1480,7 @@ export const loadConfig = ${cfg ? imp(cfg) : '() => Promise.resolve({ default: {
       isBuild = c.command === "build";
     },
     async generateBundle() {
-      const read = async (abs) => JSON.parse(await readFile5(abs, "utf8"));
+      const read = async (abs) => JSON.parse(await readFile6(abs, "utf8"));
       for (const [key, p] of bundlePlan) {
         const out = {};
         if (p.schema) out.schema = await read(p.schema);
@@ -1213,6 +1501,13 @@ export const loadConfig = ${cfg ? imp(cfg) : '() => Promise.resolve({ default: {
             await Promise.all(statuses.map(async (n) => [n, await read(p.mock[n])]))
           );
         }
+        if (only) {
+          const svc = key.slice(0, key.indexOf("/"));
+          const set = neededDefs.get(svc) ?? /* @__PURE__ */ new Set();
+          for (const name of definitionRefs(JSON.stringify([out.schema, out.responses])))
+            set.add(name);
+          neededDefs.set(svc, set);
+        }
         this.emitFile({
           type: "asset",
           fileName: `data/${key}.json`,
@@ -1223,7 +1518,9 @@ export const loadConfig = ${cfg ? imp(cfg) : '() => Promise.resolve({ default: {
         this.emitFile({
           type: "asset",
           fileName: `data/${svc}/_definitions.json`,
-          source: await readFile5(abs)
+          source: only ? JSON.stringify(
+            pruneDefinitions(JSON.parse(await readFile6(abs, "utf8")), neededDefs.get(svc))
+          ) : await readFile6(abs)
         });
     },
     config(_, env) {
@@ -1235,7 +1532,8 @@ export const loadConfig = ${cfg ? imp(cfg) : '() => Promise.resolve({ default: {
               // manifests are their own chunk (preloaded with the app, so no extra round trip), and
               // operation modules are grouped by tag instead of one chunk per operation
               manualChunks(id) {
-                if (id === RESOLVED_MANIFESTS) return "manifests";
+                if (id.startsWith(RESOLVED_MANIFEST))
+                  return `manifest-${id.slice(RESOLVED_MANIFEST.length)}`;
                 return operationChunks.get(id);
               }
             }
@@ -1247,7 +1545,7 @@ export const loadConfig = ${cfg ? imp(cfg) : '() => Promise.resolve({ default: {
       if (id === VIRTUAL) return RESOLVED;
       if (id === VIRTUAL_TYPES) return RESOLVED_TYPES;
       if (id === VIRTUAL_FAKER) return RESOLVED_FAKER;
-      if (id === VIRTUAL_MANIFESTS) return RESOLVED_MANIFESTS;
+      if (id.startsWith(VIRTUAL_MANIFEST)) return `\0${id}`;
       if (id === VIRTUAL_OPERATIONS) return RESOLVED_OPERATIONS;
       if (id.startsWith(VIRTUAL_FAKER_LOCALE)) return `\0${id}`;
       if (id.startsWith(VIRTUAL_DOC)) return `\0${id}`;
@@ -1255,10 +1553,11 @@ export const loadConfig = ${cfg ? imp(cfg) : '() => Promise.resolve({ default: {
     },
     async load(id) {
       if (id === RESOLVED) return registryCode();
-      if (id === RESOLVED_MANIFESTS) return manifestsCode;
+      if (id.startsWith(RESOLVED_MANIFEST))
+        return manifestCode.get(id.slice(RESOLVED_MANIFEST.length)) ?? "export default {}";
       if (id === RESOLVED_OPERATIONS) return operationsCode;
       if (id === RESOLVED_FAKER || id.startsWith(RESOLVED_FAKER_LOCALE)) {
-        const r = await this.resolve("@faker-js/faker", join4(root, "package.json"), {
+        const r = await this.resolve("@faker-js/faker", join5(root, "package.json"), {
           skipSelf: true
         });
         if (!r) return "export {}";
@@ -1267,7 +1566,7 @@ export const loadConfig = ${cfg ? imp(cfg) : '() => Promise.resolve({ default: {
           return `export { ${id.slice(RESOLVED_FAKER_LOCALE.length)} as default } from ${pkg}`;
         let entry = r.id;
         try {
-          entry = createRequire(join4(root, "package.json")).resolve("@faker-js/faker");
+          entry = createRequire(join5(root, "package.json")).resolve("@faker-js/faker");
         } catch {
         }
         const names = fakerLocales(entry);
@@ -1294,7 +1593,7 @@ ${names.map((n) => `  ${JSON.stringify(n)}: () => import(${JSON.stringify(`${VIR
         basename(outDir)
       ]);
       for (const entry of readdirSync(root, { withFileTypes: true }))
-        if (entry.isDirectory() && !SKIP.has(entry.name)) s.watcher.add(join4(root, entry.name));
+        if (entry.isDirectory() && !SKIP.has(entry.name)) s.watcher.add(join5(root, entry.name));
       const relevant = (file) => {
         const rel = relative4(root, file);
         if (rel.startsWith("..") || /node_modules/.test(rel)) return false;
@@ -1318,7 +1617,7 @@ ${names.map((n) => `  ${JSON.stringify(n)}: () => import(${JSON.stringify(`${VIR
         if (file.endsWith(".md")) return refresh(file);
         if (!file.endsWith(".seq.ts")) return;
         const header = JSON.stringify(
-          parseSequenceMeta(await readFile5(file, "utf8").catch(() => ""))
+          parseSequenceMeta(await readFile6(file, "utf8").catch(() => ""))
         );
         if (seqHeaders.get(file) !== header) {
           seqHeaders.set(file, header);
@@ -1343,7 +1642,7 @@ ${names.map((n) => `  ${JSON.stringify(n)}: () => import(${JSON.stringify(`${VIR
             const abs = safeProjectPath(root, url.searchParams.get("path") ?? "");
             if (!abs || !existsSync3(abs)) return json2(res, 404, { error: "not found" });
             res.setHeader("content-type", "text/plain; charset=utf-8");
-            return void res.end(await readFile5(abs, "utf8"));
+            return void res.end(await readFile6(abs, "utf8"));
           }
           if (url.pathname === "/__specbook/types")
             return json2(res, 200, await collectTypes(root, outDir));
@@ -1362,6 +1661,35 @@ ${names.map((n) => `  ${JSON.stringify(n)}: () => import(${JSON.stringify(`${VIR
             );
             return json2(res, 200, { env, vars: values.vars, secrets, warnings });
           }
+          if (url.pathname === "/__specbook/environment" && req.method === "POST") {
+            const origin = req.headers.origin;
+            if (origin && new URL(origin).host !== req.headers.host)
+              return json2(res, 403, { error: "cross-origin request refused" });
+            const { name, from } = JSON.parse(await readBody2(req));
+            if (!isEnvName(name) || name === "mock" || !isEnvName(from))
+              return json2(res, 400, { error: "bad environment name" });
+            const conf = await loadProjectConfig();
+            const known = environmentNames(
+              { services: conf?.services ?? {}, environments: conf?.environments },
+              await listEnvironmentFiles(root)
+            );
+            if (known.includes(name)) return json2(res, 409, { error: `"${name}" already exists` });
+            if (!known.includes(from))
+              return json2(res, 400, { error: `unknown environment "${from}"` });
+            const own = {
+              ...conf?.environments?.[from]?.vars,
+              ...(await readEnvironment(root, from)).vars
+            };
+            await ensureEnvironmentsDir(root);
+            const file = varsFile(root, name);
+            await writeFile2(file, `# variables for ${name}, copied from ${from}
+`);
+            for (const [k, v] of Object.entries(own)) {
+              if (v === null || typeof v === "object" || !isVarName(k)) continue;
+              await writeEnvKey(file, k, String(v));
+            }
+            return json2(res, 200, { ok: true, name });
+          }
           if ((url.pathname === "/__specbook/secret" || url.pathname === "/__specbook/var") && req.method === "POST") {
             const origin = req.headers.origin;
             if (origin && new URL(origin).host !== req.headers.host)
@@ -1428,6 +1756,7 @@ export {
   listEnvironmentFiles,
   readAllVars,
   readEnvironment,
+  requestsDirFor,
   safeProjectPath,
   scanProject,
   secretsFileFor,