counterfact 2.10.0 → 2.12.0

package/README.md

@@ -4,7 +4,7 @@
 
 <br>
 
-![MIT License](https://img.shields.io/badge/license-MIT-blue) [![Coverage Status](https://coveralls.io/repos/github/counterfact/api-simulator/badge.svg)](https://coveralls.io/github/pmcelhaney/counterfact) ![friction 0%](https://img.shields.io/badge/friction-0%25-brightgreen)
+![MIT License](https://img.shields.io/badge/license-MIT-blue) [![Coverage Status](https://coveralls.io/repos/github/counterfact/api-simulator/badge.svg)](https://coveralls.io/github/pmcelhaney/counterfact) ![friction 0%](https://img.shields.io/badge/friction-0%25-brightgreen) ![Swagger 2.0](https://img.shields.io/badge/Swagger-2.0-85EA2D) ![OpenAPI 3.0-3.2](https://img.shields.io/badge/OpenAPI-3.x-6BA539)
 
 </div>
 
@@ -17,6 +17,7 @@ Mock servers make it easy to get started, but hard to keep going.<br>
 Counterfact is an API simulator without those limits. 
 
 Point it at an [OpenAPI](https://www.openapis.org) document and get a live, stateful API in seconds. 
+Supports Swagger 2.0 and OpenAPI 3.0, 3.1, and 3.2.
 - Type-safe TypeScript handlers for every endpoint  
 - Hot reloading as you edit  
 - Shared state across routes  

package/dist/api-runner.js

@@ -64,6 +64,11 @@ export class ApiRunner {
      * Defaults to `""` (no subdirectory).
      */
     group;
+    /**
+     * Optional version label for this runner's spec (e.g. `"v1"`, `"v2"`).
+     * Defaults to `""` (unversioned).
+     */
+    version;
     /**
      * The subdirectory path segment derived from {@link group}.
      * Returns `""` when `group` is empty, otherwise `"/${group}"`.
@@ -72,8 +77,9 @@ export class ApiRunner {
         return this.group ? `/${this.group}` : "";
     }
     config;
-    constructor(config, nativeTs, openApiDocument, group) {
+    constructor(config, nativeTs, openApiDocument, group, version = "", versions = []) {
         this.group = group;
+        this.version = version;
         const modulesPath = this.group
             ? pathJoin(config.basePath, this.group)
             : config.basePath;
@@ -87,8 +93,8 @@ export class ApiRunner {
         this.contextRegistry = new ContextRegistry();
         this.scenarioRegistry = new ScenarioRegistry();
         this.scenarioFileGenerator = new ScenarioFileGenerator(modulesPath);
-        this.codeGenerator = new CodeGenerator(this.openApiPath, config.basePath + this.subdirectory, config.generate);
-        this.dispatcher = new Dispatcher(this.registry, this.contextRegistry, openApiDocument, config);
+        this.codeGenerator = new CodeGenerator(this.openApiPath, config.basePath + this.subdirectory, config.generate, version);
+        this.dispatcher = new Dispatcher(this.registry, this.contextRegistry, openApiDocument, config, version, versions);
         this.transpiler = new Transpiler(pathJoin(modulesPath, "routes"), compiledPathsDirectory, "commonjs");
         this.moduleLoader = new ModuleLoader(compiledPathsDirectory, this.registry, this.contextRegistry, pathJoin(modulesPath, "scenarios"), this.scenarioRegistry);
     }
@@ -101,8 +107,10 @@ export class ApiRunner {
      *
      * @param config - Runtime configuration for this runner instance.
      * @param group - Optional group name placing generated code in a subdirectory (default `""`).
+     * @param version - Optional version label for this spec (e.g. `"v1"`, `"v2"`).
+     * @param versions - Optional ordered list of all version labels in this group (oldest first).
      */
-    static async create(config, group = "") {
+    static async create(config, group = "", version = "", versions = []) {
         const nativeTs = await runtimeCanExecuteErasableTs();
         const modulesPath = group
             ? pathJoin(config.basePath, group)
@@ -114,7 +122,7 @@ export class ApiRunner {
         const openApiDocument = config.openApiPath === "_"
             ? undefined
             : await loadOpenApiDocument(config.openApiPath);
-        return new ApiRunner(config, nativeTs, openApiDocument, group);
+        return new ApiRunner(config, nativeTs, openApiDocument, group, version, versions);
     }
     /**
      * Generates TypeScript route stubs and type files from the OpenAPI spec.
@@ -123,11 +131,15 @@ export class ApiRunner {
      * - Routes and types are only generated when `config.openApiPath` is not `"_"`.
      * - The scenario context type file is always generated when
      *   `config.generate.types` is `true`, even without a spec.
+     *
+     * @param repository - Optional shared repository.  Pass a shared instance
+     *   when multiple versioned specs in the same group should merge their types
+     *   into the same output tree.
      */
-    async generate() {
+    async generate(repository) {
         if (this.config.openApiPath !== "_" &&
             (this.config.generate.routes || this.config.generate.types)) {
-            await this.codeGenerator.generate();
+            await this.codeGenerator.generate(repository);
         }
         if (this.config.generate.types) {
             await this.scenarioFileGenerator.generate();

package/dist/app.js

@@ -1,8 +1,13 @@
+import fs from "node:fs/promises";
+import nodePath from "node:path";
 import { createHttpTerminator } from "http-terminator";
 import { ApiRunner } from "./api-runner.js";
 import { startRepl as startReplServer } from "./repl/repl.js";
 import { createRouteFunction } from "./repl/route-builder.js";
 import { createKoaApp } from "./server/web-server/create-koa-app.js";
+import { Repository } from "./typescript-generator/repository.js";
+import { ensureDirectoryExists } from "./util/ensure-directory-exists.js";
+import { generateVersionsTsContent } from "./typescript-generator/versions-ts-generator.js";
 export { loadOpenApiDocument } from "./server/load-openapi-document.js";
 export { createMswHandlers, handleMswRequest, } from "./msw.js";
 export async function runStartupScenario(scenarioRegistry, contextRegistry, config, openApiDocument) {
@@ -18,19 +23,47 @@ export async function runStartupScenario(scenarioRegistry, contextRegistry, conf
     };
     await indexModule["startup"](scenario$);
 }
+/**
+ * Derives the URL prefix for a spec entry.
+ *
+ * Applies the following precedence rules:
+ *  1. Explicit `prefix` (even `""`) → returned as-is.
+ *  2. `group` + `version` both present → `/<group>/<version>`.
+ *  3. `group` present (no `version`) → `/<group>`.
+ *  4. Neither → `""` (root).
+ */
+function derivePrefix(spec) {
+    if (spec.prefix !== undefined) {
+        return spec.prefix;
+    }
+    if (spec.group && spec.version) {
+        return `/${spec.group}/${spec.version}`;
+    }
+    if (spec.group) {
+        return `/${spec.group}`;
+    }
+    return "";
+}
 /**
  * Normalises the spec configuration to an array.
  *
- * When `specs` is provided it is returned as-is. When it is omitted, a
- * single-entry array is constructed from `config.openApiPath`,
- * `config.prefix`, and `group = ""` so that the rest of the code never
- * needs to branch on single-vs-multiple specs.
+ * When `specs` is provided, each entry's `prefix` is resolved via
+ * {@link derivePrefix} so the rest of the code can assume `prefix` is always
+ * a string. When `specs` is omitted, a single-entry array is constructed from
+ * `config.openApiPath`, `config.prefix`, and `group = ""`.
  */
 function normalizeSpecs(config, specs) {
     if (specs !== undefined) {
-        return specs;
+        return specs.map((spec) => ({ ...spec, prefix: derivePrefix(spec) }));
     }
-    return [{ source: config.openApiPath, prefix: config.prefix, group: "" }];
+    return [
+        {
+            source: config.openApiPath,
+            prefix: config.prefix,
+            group: "",
+            version: "",
+        },
+    ];
 }
 function validateSpecGroups(specs) {
     if (specs.length <= 1) {
@@ -41,20 +74,26 @@ function validateSpecGroups(specs) {
         .filter(({ group }) => group === "")
         .map(({ index }) => String(index + 1));
     if (invalidSpecNumbers.length === 0) {
-        const seenGroups = new Set();
-        const duplicateGroupNames = new Set();
+        const seenKeys = new Set();
+        const duplicateKeys = new Set();
         for (const spec of specs) {
             const group = spec.group.trim();
-            if (seenGroups.has(group)) {
-                duplicateGroupNames.add(group);
+            const version = spec.version?.trim() ?? "";
+            // Use group@version as the uniqueness key so that the same group can
+            // appear with different versions (e.g. v1 and v2 of the same API).
+            // The empty-group case is already rejected above, so `group` is always
+            // non-empty here and the `@version` suffix remains unambiguous.
+            const key = version ? `${group}@${version}` : group;
+            if (seenKeys.has(key)) {
+                duplicateKeys.add(key);
                 continue;
             }
-            seenGroups.add(group);
+            seenKeys.add(key);
         }
-        if (duplicateGroupNames.size === 0) {
+        if (duplicateKeys.size === 0) {
             return;
         }
-        throw new Error(`Each spec must define a unique group when multiple APIs are configured (duplicate groups: ${[...duplicateGroupNames].join(", ")}).`);
+        throw new Error(`Each spec must define a unique group (and version) when multiple APIs are configured (duplicates: ${[...duplicateKeys].join(", ")}).`);
     }
     throw new Error(`Each spec must define a non-empty group when multiple APIs are configured (invalid spec entries: ${invalidSpecNumbers.join(", ")}).`);
 }
@@ -81,7 +120,18 @@ function validateSpecGroups(specs) {
 export async function counterfact(config, specs) {
     const normalizedSpecs = normalizeSpecs({ openApiPath: config.openApiPath, prefix: config.prefix }, specs);
     validateSpecGroups(normalizedSpecs);
-    const runners = await Promise.all(normalizedSpecs.map((spec) => ApiRunner.create({ ...config, openApiPath: spec.source, prefix: spec.prefix }, spec.group)));
+    // Compute the ordered versions per group (oldest first, as declared in specs).
+    // This list is passed to each runner so that $.minVersion() can compare
+    // version positions at runtime.
+    const versionsByGroup = new Map();
+    for (const spec of normalizedSpecs) {
+        const version = spec.version ?? "";
+        if (version) {
+            const existing = versionsByGroup.get(spec.group) ?? [];
+            versionsByGroup.set(spec.group, [...existing, version]);
+        }
+    }
+    const runners = await Promise.all(normalizedSpecs.map((spec) => ApiRunner.create({ ...config, openApiPath: spec.source, prefix: spec.prefix }, spec.group, spec.version ?? "", versionsByGroup.get(spec.group) ?? [])));
     const koaApp = createKoaApp({
         runners,
         config,
@@ -89,7 +139,61 @@ export async function counterfact(config, specs) {
     // The REPL is configured using the first runner.
     const primaryRunner = runners[0];
     async function start(options) {
-        await Promise.all(runners.map((runner) => runner.generate()));
+        // Serialize generate() calls within each group to avoid concurrent writes
+        // to the same output directory.  Runners that share a group share the same
+        // basePath subdirectory (and therefore the same counterfact-types
+        // destination), so running them in parallel would cause a race when both
+        // try to create that directory at startup.  Different groups are still
+        // generated in parallel.
+        //
+        // When multiple versioned specs share the same group, they also share a
+        // single Repository instance so that the shared `types/paths/…` files
+        // accumulate all versions into a merged Versioned<…> type instead of each
+        // overwriting the previous version's types.
+        const runnersByGroup = new Map();
+        for (const runner of runners) {
+            const bucket = runnersByGroup.get(runner.group) ?? [];
+            bucket.push(runner);
+            runnersByGroup.set(runner.group, bucket);
+        }
+        await Promise.all(Array.from(runnersByGroup.values()).map(async (bucket) => {
+            const sharedRepository = bucket.length > 1 ? new Repository() : undefined;
+            for (const runner of bucket) {
+                await runner.generate(sharedRepository);
+            }
+        }));
+        if (options.generate?.types) {
+            // Build a per-group map of unique non-empty version strings in
+            // declaration order. new Set() preserves insertion order so the first
+            // occurrence of each version is kept and duplicates are dropped without
+            // reordering.
+            const versionsByGroup = new Map();
+            for (const spec of normalizedSpecs) {
+                const group = spec.group;
+                const version = (spec.version ?? "").trim();
+                if (version === "") {
+                    continue;
+                }
+                const existing = versionsByGroup.get(group) ?? [];
+                if (!existing.includes(version)) {
+                    existing.push(version);
+                }
+                versionsByGroup.set(group, existing);
+            }
+            // Write <basePath>/<group>/types/versions.ts for every group that has
+            // at least one versioned spec.  When the group is empty the path
+            // collapses to <basePath>/types/versions.ts (the single-spec case).
+            await Promise.all(Array.from(versionsByGroup.entries()).map(async ([group, versions]) => {
+                const content = await generateVersionsTsContent(versions);
+                const versionsFilePath = group
+                    ? nodePath.join(config.basePath, group, "types", "versions.ts")
+                    : nodePath.join(config.basePath, "types", "versions.ts");
+                /* eslint-disable security/detect-non-literal-fs-filename -- path is derived from the caller-supplied basePath and fixed suffixes. */
+                await ensureDirectoryExists(versionsFilePath);
+                await fs.writeFile(versionsFilePath, content, "utf8");
+                /* eslint-enable security/detect-non-literal-fs-filename */
+            }));
+        }
         await Promise.all(runners.map((runner) => runner.watch()));
         await Promise.all(runners.map((runner) => runner.start(options)));
         let httpTerminator;

package/dist/cli/banner.js

@@ -67,7 +67,7 @@ export function createIntroduction(params) {
         `   API Base URL  ${url}`,
         source === "_" ? undefined : `   Swagger UI    ${swaggerUrl}`,
         "",
-        "   Instructions  https://counterfact.dev/docs/usage.html",
+        "   Instructions  https://github.com/counterfact/api-simulator/blob/main/docs/usage.md",
         "   Help/feedback https://github.com/pmcelhaney/counterfact/issues",
         "",
         ...telemetryWarning,

package/dist/cli/run.js

@@ -13,7 +13,7 @@ import { pathResolve } from "../util/forward-slash-path.js";
 import { loadConfigFile } from "../util/load-config-file.js";
 import { createIntroduction } from "./banner.js";
 import { checkForUpdates } from "./check-for-updates.js";
-import { isTelemetryEnabled, sendTelemetry } from "./telemetry.js";
+import { hashTelemetryLocation, isTelemetryEnabled, sendTelemetry, } from "./telemetry.js";
 const debug = createDebug("counterfact:cli:run");
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const DEFAULT_PORT = 3100;
@@ -22,18 +22,23 @@ const DEFAULT_PORT = 3100;
  * CLI flag) into an array of {@link SpecConfig} objects, or `undefined` when
  * the option is a plain string (single OpenAPI document path).
  *
- * - **Array**: each entry is mapped to `{source, prefix, group}` with defaults.
+ * - **Array**: each entry is mapped to `{source, prefix, group, version}` with defaults.
  * - **Object**: wrapped in a single-element array.
  * - **String / undefined**: returns `undefined` — caller handles the string
  *   case (it shifts the positional argument) and the `undefined` case
  *   (single spec derived from config).
+ *
+ * Note: `prefix` is intentionally left `undefined` when not supplied so that
+ * `normalizeSpecs` (in `app.ts`) can derive it automatically from
+ * `group`/`version`.
  */
 export function normalizeSpecOption(specOption) {
     if (Array.isArray(specOption)) {
         return specOption.map((entry) => ({
             source: entry.source,
-            prefix: entry.prefix ?? "",
+            prefix: entry.prefix,
             group: entry.group ?? "",
+            version: entry.version,
         }));
     }
     if (typeof specOption === "object" &&
@@ -42,13 +47,43 @@ export function normalizeSpecOption(specOption) {
         return [
             {
                 source: specOption.source,
-                prefix: specOption.prefix ?? "",
+                prefix: specOption.prefix,
                 group: specOption.group ?? "",
+                version: specOption.version,
             },
         ];
     }
     return undefined;
 }
+export function buildStartupTelemetryProperties(options, source, version, specs) {
+    const apiSources = specs?.map((spec) => spec.source) ?? [source];
+    const apiFileLocationHashes = apiSources
+        .filter((apiSource) => apiSource !== "_")
+        .map((apiSource) => hashTelemetryLocation(apiSource));
+    return {
+        alwaysFakeOptionals: Boolean(options.alwaysFakeOptionals),
+        apiFileLocationHashes,
+        buildCache: Boolean(options.buildCache),
+        generateRoutes: Boolean(options.generate) || Boolean(options.generateRoutes),
+        generateTypes: Boolean(options.generate) || Boolean(options.generateTypes),
+        mode: specs !== undefined
+            ? "multi-spec"
+            : source === "_"
+                ? "without-openapi"
+                : "single-spec",
+        openBrowser: Boolean(options.open),
+        port: options.port,
+        prune: Boolean(options.prune),
+        repl: Boolean(options.repl),
+        serve: Boolean(options.serve),
+        updateCheck: Boolean(options.updateCheck),
+        validateRequest: Boolean(options.validateRequest),
+        validateResponse: Boolean(options.validateResponse),
+        version,
+        watchRoutes: Boolean(options.watch) || Boolean(options.watchRoutes),
+        watchTypes: Boolean(options.watch) || Boolean(options.watchTypes),
+    };
+}
 /**
  * Builds the Commander program with all CLI options and the action handler.
  * Factored out of `runCli` so it is easy to test or extend.
@@ -110,6 +145,7 @@ function buildProgram(version, taglines) {
         debug("options: %o", options);
         debug("source: %s", source);
         debug("destination: %s", destination);
+        const startupTelemetryProperties = buildStartupTelemetryProperties(options, source, version, specs);
         const openBrowser = options.open;
         const url = `http://localhost:${options.port}${options.prefix}`;
         const guiUrl = `${url}/counterfact/`;
@@ -207,6 +243,7 @@ function buildProgram(version, taglines) {
             process.exit(1);
         }
         debug("started server");
+        sendTelemetry("counterfact_started", startupTelemetryProperties);
         await updateCheckPromise;
         if (config.startRepl) {
             startRepl();
@@ -253,7 +290,7 @@ function buildProgram(version, taglines) {
         .option("--watch-routes", "generate + watch routes for changes")
         .option("-s, --serve", "start the server")
         .option("-b, --build-cache", "builds the cache of compiled routes and types")
-        .option("--no-admin-api", "disable the admin API at /_counterfact/api/*")
+        .option("--admin-api", "enable the admin API at /_counterfact/api/*")
         .option("-r, --repl", "start the REPL")
         .option("--proxy-url <string>", "proxy URL")
         .option("--admin-api-token <string>", "bearer token required for /_counterfact/api/* endpoints (defaults to COUNTERFACT_ADMIN_API_TOKEN)")
@@ -294,10 +331,6 @@ export async function runCli(argv) {
     catch {
         taglines = ["counterfact — mock API server"];
     }
-    // Fire telemetry once on startup — fire-and-forget, never blocks.
-    if (isTelemetryEnabled()) {
-        sendTelemetry(version);
-    }
     debug("running counterfact CLI v%s", version);
     const program = buildProgram(version, taglines);
     await program.parseAsync(argv);

package/dist/cli/telemetry.js

@@ -1,13 +1,11 @@
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { PostHog } from "posthog-node";
 const POSTHOG_API_KEY = "phc_msXmBxiL8FVugNMLCx9bnPQGqfEMqmyBjnVkKhHkN3m7";
 const POSTHOG_HOST = "https://us.i.posthog.com";
 /**
  * Returns `true` when telemetry should be sent.
  *
- * Telemetry is disabled in CI, when `COUNTERFACT_TELEMETRY_DISABLED=true`,
- * or before the May 2026 rollout date unless the user has explicitly opted
- * in with `COUNTERFACT_TELEMETRY_DISABLED=false`.
+ * Telemetry is disabled in CI or when `COUNTERFACT_TELEMETRY_DISABLED=true`.
  */
 export function isTelemetryEnabled() {
     if (process.env["CI"])
@@ -15,29 +13,32 @@ export function isTelemetryEnabled() {
     const telemetryDisabledEnv = process.env["COUNTERFACT_TELEMETRY_DISABLED"];
     if (telemetryDisabledEnv === "true")
         return false;
-    const isBeforeRollout = new Date() < new Date("2026-05-01");
-    if (isBeforeRollout && telemetryDisabledEnv !== "false")
-        return false;
     return true;
 }
+export function hashTelemetryLocation(location) {
+    return createHash("sha256").update(location).digest("hex");
+}
 /**
  * Fires a telemetry event to PostHog.  Fire-and-forget — never blocks
  * startup and never surfaces errors to the user.
  */
-export function sendTelemetry(version) {
+export function sendTelemetry(event, properties = {}) {
+    if (!isTelemetryEnabled()) {
+        return;
+    }
     const telemetryKey = process.env["POSTHOG_API_KEY"] ?? POSTHOG_API_KEY;
     const telemetryHost = process.env["POSTHOG_HOST"] ?? POSTHOG_HOST;
     try {
         const posthog = new PostHog(telemetryKey, { host: telemetryHost });
         posthog.capture({
             distinctId: randomUUID(),
-            event: "counterfact_started",
+            event,
             properties: {
-                version,
                 nodeVersion: process.version,
                 platform: process.platform,
                 arch: process.arch,
                 source: "counterfact-cli",
+                ...properties,
             },
         });
         posthog.flush().catch(() => {

package/dist/migrate/update-route-types.js

@@ -14,6 +14,7 @@ const HTTP_METHODS = [
     "PATCH",
     "HEAD",
     "OPTIONS",
+    "QUERY",
 ];
 // Pre-compile regex patterns derived from HTTP_METHODS
 const HTTP_METHOD_ALTERNATION = HTTP_METHODS.join("|");

package/dist/msw.js

@@ -14,6 +14,7 @@ const allowedMethods = [
     "delete",
     "patch",
     "options",
+    "query",
 ];
 const mswHandlers = {};
 /**

package/dist/repl/repl.js

@@ -1,4 +1,5 @@
 import repl from "node:repl";
+import { sendTelemetry } from "../cli/telemetry.js";
 import { RawHttpClient } from "./raw-http-client.js";
 import { createRouteFunction } from "./route-builder.js";
 function printToStdout(line) {
@@ -194,9 +195,6 @@ export function startRepl(contextRegistry, registry, config, print = printToStdo
             }
             seenGroups.add(binding.key);
         }
-        if (duplicateGroups.size > 0) {
-            throw new Error(`Duplicate API groups are not allowed when multiple APIs are configured (duplicate groups: ${[...duplicateGroups].join(", ")}).`);
-        }
     }
     const rootBinding = groupedBindings[0];
     if (rootBinding === undefined) {
@@ -261,6 +259,7 @@ export function startRepl(contextRegistry, registry, config, print = printToStdo
         : undefined);
     replServer.defineCommand("counterfact", {
         action() {
+            sendTelemetry("repl_command_used", { command: "counterfact" });
             print("This is a read-eval-print loop (REPL), the same as the one you get when you run node with no arguments.");
             print("Except that it's connected to the running server, which you can access with the following globals:");
             print("");
@@ -268,7 +267,7 @@ export function startRepl(contextRegistry, registry, config, print = printToStdo
             print("- context: the root context ( same as loadContext('/') )");
             print("- route('/some/path'): create a request builder for the given path");
             print("");
-            print("For more information, see https://counterfact.dev/docs/usage.html");
+            print("For more information, see https://github.com/counterfact/api-simulator/blob/main/docs/usage.md");
             print("");
             this.clearBufferedCommand();
             this.displayPrompt();
@@ -277,6 +276,7 @@ export function startRepl(contextRegistry, registry, config, print = printToStdo
     });
     replServer.defineCommand("proxy", {
         action(text) {
+            sendTelemetry("repl_command_used", { command: "proxy" });
             if (text === "help" || text === "") {
                 print(".proxy [on|off] - turn the proxy on/off at the root level");
                 print(".proxy [on|off] <path-prefix> - turn the proxy on for a path");
@@ -316,6 +316,7 @@ export function startRepl(contextRegistry, registry, config, print = printToStdo
         : {};
     replServer.defineCommand("scenario", {
         async action(text) {
+            sendTelemetry("repl_command_used", { command: "scenario" });
             const trimmedText = text.trim();
             const parsedArgs = trimmedText.split(/\s+/u).filter(Boolean);
             const usage = isMultiApi

package/dist/server/counterfact-types/example.ts

@@ -2,9 +2,13 @@
  * Represents a named example defined in an OpenAPI document.
  * Examples can be referenced by route handlers via the `.example(name)` method
  * on the response builder.
+ *
+ * OpenAPI 3.2 adds `dataValue` as a structured alternative to `value`.
+ * When present, `dataValue` is preferred over `value`.
  */
 export interface Example {
+  dataValue?: unknown;
   description: string;
   summary: string;
-  value: unknown;
+  value?: unknown;
 }

package/dist/server/counterfact-types/generic-response-builder.ts

@@ -130,6 +130,10 @@ export type GenericResponseBuilderInner<
     : (name: ExampleNames<Response>) => COUNTERFACT_RESPONSE;
   text: MaybeShortcut<["text/plain"], Response>;
   xml: MaybeShortcut<["application/xml", "text/xml"], Response>;
+  stream: MaybeShortcut<
+    ["text/event-stream", "application/jsonl", "application/json-seq"],
+    Response
+  >;
 }>;
 
 /**

package/dist/server/counterfact-types/open-api-parameters.ts

@@ -6,7 +6,14 @@
  */
 export interface OpenApiParameters {
   explode?: boolean;
-  in: "body" | "cookie" | "formData" | "header" | "path" | "query";
+  in:
+    | "body"
+    | "cookie"
+    | "formData"
+    | "header"
+    | "path"
+    | "query"
+    | "querystring";
   name: string;
   required?: boolean;
   schema?: {

package/dist/server/counterfact-types/response-builder.ts

@@ -26,6 +26,11 @@ export interface ResponseBuilder {
   random: () => MaybePromise<ResponseBuilder>;
   randomLegacy: () => MaybePromise<ResponseBuilder>;
   status?: number;
+  stream: (iterable: AsyncIterable<unknown>) => {
+    body: AsyncIterable<unknown>;
+    contentType: string;
+    status?: number;
+  };
   text: (body: unknown) => ResponseBuilder;
   xml: (body: unknown) => ResponseBuilder;
 }

package/dist/server/counterfact-types/wide-response-builder.ts

@@ -23,4 +23,5 @@ export interface WideResponseBuilder {
   random: () => MaybePromise<WideResponseBuilder>;
   text: (body: unknown) => WideResponseBuilder;
   xml: (body: unknown) => WideResponseBuilder;
+  stream: (body: AsyncIterable<unknown>) => WideResponseBuilder;
 }