@scalar/mock-server 0.12.13 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # @scalar/mock-server
 
+## 0.13.0
+
+### Minor Changes
+
+- [#10051](https://github.com/scalar/scalar/pull/10051): feat: add a `logger` option to control startup logging
+
+  `createMockServer()` prints authentication instructions for the security schemes of the document when it starts. That is helpful in a terminal, but it is noise when the mock server runs inside a test harness or another program, which so far left callers replacing the global console.
+
+  Pass `logger: false` to silence those instructions, or a `(line: string) => void` sink to route them elsewhere:
+
+  ```ts
+  const app = await createMockServer({ document, logger: false })
+  ```
+
+  Diagnostics are not affected: warnings and errors about security schemes the mock server cannot handle, request validator compilation errors, and `x-seed` errors are printed either way.
+
+  `createAsyncApiMockServer()` already accepted a `logger` sink; it now takes the same `boolean | ((line: string) => void)` shape, so both factories are silenced and redirected the same way. It stays silent by default — pass `logger: true` to print its transport lifecycle lines.
+
+  The `MockServerLogger` type is now exported as well, so a custom sink can be typed outside of the package.
+
+- [#10037](https://github.com/scalar/scalar/pull/10037): Frame `text/event-stream` responses as Server-Sent Events instead of returning a single JSON body with an SSE content type. Each event is written as a `data:` line terminated by a blank line, then the stream closes.
+  - Named `examples` are read as the sequence of events the endpoint emits, in declaration order (`Prefer: example=<name>` still pins the stream to that one example).
+  - An array example is read as the event sequence too, one event per item.
+  - An example that already spells out SSE framing (`data:` and `event:` lines, or a `:` comment heartbeat) is written as its own framing, with only its terminating blank line normalized, instead of being wrapped in a second `data:` line. Such examples describe a whole stream, so a map of them is read as alternatives and the first one is served.
+  - With no example, the schema-generated payload is emitted three times so the stream has more than one event to iterate — unless the schema already generates a sequence (a multi-item array, or a string that spells the wire format out), which is sent once, not repeated.
+
+- [#10038](https://github.com/scalar/scalar/pull/10038): Answer unhandled errors with a structured JSON `500` naming the operation that failed, instead of the previous plain-text `Internal Server Error`. The body reports the error `message` along with the matched operation's `method`, OpenAPI `path`, and `operationId` (when the document declares one), and the error is still logged to the console. Errors that already carry their own response keep the status and body they chose.
+
+### Patch Changes
+
+- [#9967](https://github.com/scalar/scalar/pull/9967): Align the `ajv` and `ajv-formats` dependencies with the shared workspace catalog (`ajv@^8.20.0`).
+- [#10039](https://github.com/scalar/scalar/pull/10039): Fix request validation falling open for recursive schemas. Resolving a schema that references itself leaves a `'[circular]'` marker where the cycle was cut, which Ajv refused to compile, so the mock server logged an error and skipped validating the request body — or every parameter in that location. The recursion point now compiles as an always-valid schema, and a constraint that would flip that into a stricter one (`not`, `if`, `oneOf`, `contains`, and the keywords that only qualify them) is dropped, so the rest of the schema is enforced again without rejecting requests the document allows.
+- [#10035](https://github.com/scalar/scalar/pull/10035): Fix JSON responses for primitive string bodies. A response declaring `application/json` with a `type: string` schema (or a plain string example) was written to the wire verbatim, so clients received the bare characters `string` instead of `"string"` and could not parse the payload.
+
+  A string body is now JSON-encoded whenever the negotiated media type carries a single JSON document, which includes suffixed types such as `application/problem+json` and parameterized ones such as `application/json; charset=utf-8`. Two things keep their raw string: every other media type, where the characters are already the payload (`text/plain`, `text/event-stream`, XML, and the line-delimited JSON types), and a body that is already the value the schema describes — anything that parses when the schema declares a non-string type, or a JSON object or array when the schema says nothing, both of which are documents the author serialized by hand.
+
+  XML is now matched on the parsed media type subtype rather than by substring, so only a genuine XML type is serialized as an XML document. A media type that merely contains `xml` somewhere, such as one carrying it in a parameter, no longer is.
+
+- [#10044](https://github.com/scalar/scalar/pull/10044): fix: escape spec-derived path keys and route path keys that carry a query string
+
+  Path keys such as `/v1/messages?beta=true` used to be registered verbatim as routes, where the query string was read as routing syntax. On a parameterized path that made the router compile an invalid regular expression and every single request failed with an empty `500`. The query is now peeled off and matched against the incoming request, so `/v1/messages?beta=true` answers only requests that send `beta=true` and `/v1/messages` keeps answering the rest.
+
+  Characters that would otherwise be read as routing syntax (`:`, `*`, `|`, and braces outside a path parameter) are escaped, so a path key can no longer act as a pattern. Note that this also applies to `*`: a path key ending in `*` is now served as a literal path instead of matching everything below it.
+
+  One limitation is worth knowing: Hono allows a single parameter per path segment, so a segment that mixes a path parameter with escaped literal text (`/v1/jobs/{jobId}:cancel`) routes to the right operation but does not bind `jobId` by name. Request validation reads it as missing, so a document describing such a path needs the server-wide `validateRequest: false` for now.
+
 ## 0.12.13
 
 ### Patch Changes

package/dist/create-asyncapi-mock-server.d.ts

@@ -1,6 +1,7 @@
 import { createNodeWebSocket } from '@hono/node-ws';
 import { Hono } from 'hono';
 import type { MessageDirection, MockTransport } from './transports/types.js';
+import type { MockServerLogger } from './types.js';
 /** Options for {@link createAsyncApiMockServer}. */
 export type AsyncApiMockServerOptions = {
     /**
@@ -20,8 +21,13 @@ export type AsyncApiMockServerOptions = {
         direction: MessageDirection;
         payload: unknown;
     }) => void;
-    /** Optional sink for transport lifecycle log lines. Defaults to no-op. */
-    logger?: (line: string) => void;
+    /**
+     * Control the transport lifecycle log lines the server prints. Pass `true` to log them to the
+     * console, a `(line) => void` sink to route them elsewhere, or `false` (the default) to stay silent.
+     *
+     * Diagnostics such as a channel with no matching transport are printed either way.
+     */
+    logger?: boolean | MockServerLogger;
 };
 /** The result of {@link createAsyncApiMockServer}. */
 export type AsyncApiMockServer = {

package/dist/create-asyncapi-mock-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-asyncapi-mock-server.d.ts","sourceRoot":"","sources":["../src/create-asyncapi-mock-server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAI3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAoB,MAAM,oBAAoB,CAAA;AAK3F,oDAAoD;AACpD,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAEvC;;;;OAIG;IACH,UAAU,CAAC,EAAE,aAAa,EAAE,CAAA;IAE5B,yFAAyF;IACzF,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,gBAAgB,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAA;IAE/F,0EAA0E;IAC1E,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAChC,CAAA;AAED,sDAAsD;AACtD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,sEAAsE;IACtE,GAAG,EAAE,IAAI,CAAA;IACT;;;OAGG;IACH,eAAe,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,iBAAiB,CAAC,CAAA;CAC3E,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAsC9G"}
+{"version":3,"file":"create-asyncapi-mock-server.d.ts","sourceRoot":"","sources":["../src/create-asyncapi-mock-server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAI3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAoB,MAAM,oBAAoB,CAAA;AAC3F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAM/C,oDAAoD;AACpD,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAEvC;;;;OAIG;IACH,UAAU,CAAC,EAAE,aAAa,EAAE,CAAA;IAE5B,yFAAyF;IACzF,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,gBAAgB,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAA;IAE/F;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,gBAAgB,CAAA;CACpC,CAAA;AAED,sDAAsD;AACtD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,sEAAsE;IACtE,GAAG,EAAE,IAAI,CAAA;IACT;;;OAGG;IACH,eAAe,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,iBAAiB,CAAC,CAAA;CAC3E,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA0C9G"}

package/dist/create-asyncapi-mock-server.js

@@ -5,6 +5,7 @@ import { defaultTransports } from './transports/index.js';
 import { generateMessage } from './utils/generate-message.js';
 import { processAsyncApiDocument } from './utils/process-asyncapi-document.js';
 import { resolveChannels } from './utils/resolve-channels.js';
+import { resolveLogger } from './utils/resolve-logger.js';
 /**
  * Create a mock server for an AsyncAPI 3.1 document — the event-driven counterpart of
  * {@link createMockServer}. Each channel is registered on a transport (WebSocket or SSE by
@@ -28,7 +29,7 @@ export async function createAsyncApiMockServer(options) {
     const document = await processAsyncApiDocument(options.document);
     const channels = resolveChannels(document);
     const transports = [...defaultTransports, ...(options.transports ?? [])];
-    const log = options.logger ?? (() => undefined);
+    const log = resolveLogger(options.logger, false);
     // CORS for the SSE/HTTP routes (WebSocket upgrades are not subject to CORS).
     app.use(cors());
     const context = {
@@ -41,7 +42,9 @@ export async function createAsyncApiMockServer(options) {
     for (const channel of channels) {
         const transport = transports.find((candidate) => candidate.supports(channel));
         if (!transport) {
-            log(`[asyncapi] no transport for channel "${channel.id}" (protocols: ${channel.protocols.join(', ') || 'none'})`);
+            // A channel with no matching transport is a configuration problem, so surface it through the
+            // console unconditionally rather than the (silenceable) logger.
+            console.warn(`[asyncapi] no transport for channel "${channel.id}" (protocols: ${channel.protocols.join(', ') || 'none'})`);
             continue;
         }
         transport.register(channel, context);

package/dist/create-mock-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-mock-server.d.ts","sourceRoot":"","sources":["../src/create-mock-server.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAG3B,OAAO,KAAK,EAAc,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAiB5D;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,aAAa,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2GtF"}
+{"version":3,"file":"create-mock-server.d.ts","sourceRoot":"","sources":["../src/create-mock-server.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,IAAI,EAA0B,MAAM,MAAM,CAAA;AAIjE,OAAO,KAAK,EAAc,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAwD5D;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,aAAa,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8NtF"}

package/dist/create-mock-server.js

@@ -1,5 +1,6 @@
 import { getResolvedRef, mergeSiblingReferences } from '@scalar/workspace-store/helpers/get-resolved-ref';
 import { Hono } from 'hono';
+import { every } from 'hono/combine';
 import { cors } from 'hono/cors';
 import { buildSeedContext } from './utils/build-seed-context.js';
 import { executeSeed } from './utils/execute-seed.js';
@@ -9,17 +10,62 @@ import { honoRouteFromPath } from './utils/hono-route-from-path.js';
 import { isAuthenticationRequired } from './utils/is-authentication-required.js';
 import { logAuthenticationInstructions } from './utils/log-authentication-instructions.js';
 import { processOpenApiDocument } from './utils/process-openapi-document.js';
+import { requestMatchesPinnedQuery } from './utils/request-matches-pinned-query.js';
+import { resolveLogger } from './utils/resolve-logger.js';
 import { setUpAuthenticationRoutes } from './utils/set-up-authentication-routes.js';
+import { splitPathKey } from './utils/split-path-key.js';
 import { validateRequest } from './utils/validate-request.js';
 import { store } from './libs/store.js';
 import { mockAnyResponse } from './routes/mock-any-response.js';
 import { mockHandlerResponse } from './routes/mock-handler-response.js';
 import { respondWithOpenApiDocument } from './routes/respond-with-openapi-document.js';
+/** Record which operation a request matched, so an error escaping it can be named */
+const setMockedOperation = (c, operation) => {
+    ;
+    c.set('mockedOperation', operation);
+};
+/** Read back the operation a request matched, or `undefined` when it reached no mocked route */
+const getMockedOperation = (c) => c.get('mockedOperation');
+/**
+ * Whether an error carries its own response, the way Hono's `HTTPException` does.
+ *
+ * Checked structurally rather than with `instanceof`, exactly like Hono's own default handler, so an
+ * `HTTPException` thrown from a second copy of Hono is still recognized.
+ */
+const carriesResponse = (error) => 'getResponse' in error && typeof error.getResponse === 'function';
 /**
  * Create a mock server instance
  */
 export async function createMockServer(configuration) {
     const app = new Hono();
+    // Unhandled errors would otherwise reach Hono's default handler, which answers with a plain-text
+    // `Internal Server Error` that says nothing about what broke. A mock server fails for mundane,
+    // document-shaped reasons — a response header name the runtime rejects, an example that cannot be
+    // serialized — so answer with JSON that names the failing operation and repeats the message,
+    // which makes the failure readable in the response instead of something to go reproduce.
+    app.onError((error, c) => {
+        // The status and body such an error chose are deliberate, not an internal failure, so answer
+        // with them. Unlike Hono's default handler, which returns the response directly, it is rebuilt
+        // through the context so headers already staged on the response — those from the CORS
+        // middleware, most of all — still apply.
+        if (carriesResponse(error)) {
+            const response = error.getResponse();
+            return c.newResponse(response.body, response);
+        }
+        const operation = getMockedOperation(c);
+        // Keep logging the error, as Hono's default handler does, so the stack trace is not lost. Routes
+        // added to the returned app are not mocked operations, so name the concrete request instead —
+        // the log always points somewhere.
+        console.error(operation
+            ? `Error while mocking ${operation.method} ${operation.path}:`
+            : `Error handling ${c.req.method} ${c.req.path}:`, error);
+        return c.json({
+            error: 'Internal Server Error',
+            message: error.message,
+            // Left out entirely rather than sent as `null`, so a client can test for the key.
+            ...(operation ? { operation } : {}),
+        }, 500);
+    });
     /** Dereferenced OpenAPI document */
     const schema = await processOpenApiDocument(configuration?.document ?? configuration?.specification);
     // Seed data from schemas with x-seed extension
@@ -52,10 +98,34 @@ export async function createMockServer(configuration) {
     app.use(cors());
     /** Authentication methods defined in the OpenAPI document */
     setUpAuthenticationRoutes(app, schema);
-    logAuthenticationInstructions(schema?.components?.securitySchemes || {});
+    // Only the instructions honor `logger` (on by default); the util still prints warnings and errors
+    // about security schemes the mock server cannot handle, which a silenced startup should surface.
+    logAuthenticationInstructions(schema?.components?.securitySchemes || {}, resolveLogger(configuration.logger, true));
     /** Paths specified in the OpenAPI document */
     const paths = schema?.paths ?? {};
-    Object.keys(paths).forEach((path) => {
+    // A path key may pin query parameters to describe a variant of an operation, for example
+    // `/v1/messages?beta=true` next to `/v1/messages`. Hono runs every matching route in registration
+    // order, so a variant has to come before the sibling it shares a path with — otherwise the sibling
+    // answers its requests too, and the more pinned parameters a key has the more specific it is.
+    const pathKeys = Object.keys(paths).map((path) => {
+        const { path: pathname, query } = splitPathKey(path);
+        return { path, pathname, query };
+    });
+    /** Where each path first shows up in the document, so its variants stay with it */
+    const documentOrder = new Map();
+    pathKeys.forEach(({ pathname }, index) => {
+        if (!documentOrder.has(pathname)) {
+            documentOrder.set(pathname, index);
+        }
+    });
+    // Keys that share a path are grouped where the first of them appears and the most specific one
+    // leads the group; a key with a path of its own never moves. So the only keys that change places
+    // with anything unrelated are the variants of a path that is described more than once. When two
+    // distinct paths overlap — a literal and a parameterized one that pins a query — neither is moved,
+    // so whichever the document declares first is matched first, the same as any pair of overlapping
+    // Hono routes.
+    const orderedPathKeys = [...pathKeys].sort((a, b) => (documentOrder.get(a.pathname) ?? 0) - (documentOrder.get(b.pathname) ?? 0) || b.query.length - a.query.length);
+    orderedPathKeys.forEach(({ path, query }) => {
         // A path item may itself be a `$ref`, so resolve it before reading its operations.
         const pathItem = getResolvedRef(paths[path]);
         const methods = Object.keys(getOperations(pathItem));
@@ -63,17 +133,37 @@ export async function createMockServer(configuration) {
         methods.forEach((method) => {
             const route = honoRouteFromPath(path);
             const operation = pathItem?.[method];
+            // Remember which operation this route mocks, so the error handler can name it when something
+            // fails downstream. Recorded on the context rather than mapped back from the request path,
+            // which would not survive the app being mounted under a base path. Registered before the rest
+            // of the route so a failure in request validation is named too. The OpenAPI path key is kept
+            // (rather than the Hono route) because that is what the document author reads.
+            const mockedOperation = {
+                // `toUpperCase` widens to `string`, so restate the narrower type the method union guarantees.
+                method: method.toUpperCase(),
+                path,
+                ...(operation?.operationId ? { operationId: operation.operationId } : {}),
+            };
+            /** Middleware chain answering this operation, in the order it runs */
+            const handlers = [];
+            // Runs first, so the error handler can name the operation even when validation fails. For a
+            // path key that pins a query it is part of the guarded chain below, so it only fires once the
+            // request actually matches the variant rather than for one that is handed on to the sibling.
+            handlers.push(async (c, next) => {
+                setMockedOperation(c, mockedOperation);
+                await next();
+            });
             // Operation-level security overrides the global requirement, so fall back to the
             // document-wide `security` when the operation does not define its own.
             const effectiveSecurity = operation.security ?? schema?.security;
             // Check if authentication is required for this operation
             if (isAuthenticationRequired(effectiveSecurity)) {
-                app[method](route, handleAuthentication(schema, operation));
+                handlers.push(handleAuthentication(schema, operation));
             }
             // Notify the `onRequest` callback before validation runs, so it fires for every request —
             // including ones the validation middleware rejects with a `422`.
             if (configuration.onRequest) {
-                app[method](route, async (c, next) => {
+                handlers.push(async (c, next) => {
                     configuration.onRequest?.({ context: c, operation });
                     await next();
                 });
@@ -82,7 +172,7 @@ export async function createMockServer(configuration) {
             // opt out with `validateRequest: false`). Runs after authentication but before the
             // mock handler. Validators are compiled once here, so there is no per-request recompilation.
             if (configuration.validateRequest !== false) {
-                app[method](route, validateRequest(operation, pathItem?.parameters));
+                handlers.push(validateRequest(operation, pathItem?.parameters));
             }
             // Check if operation has x-handler extension
             // Validate that it's a non-empty string (consistent with x-seed validation)
@@ -90,11 +180,26 @@ export async function createMockServer(configuration) {
             const hasHandler = handlerCode && typeof handlerCode === 'string' && handlerCode.trim().length > 0;
             // Route to appropriate handler
             if (hasHandler) {
-                app[method](route, (c) => mockHandlerResponse(c, operation));
+                handlers.push(async (c) => await mockHandlerResponse(c, operation));
             }
             else {
-                app[method](route, (c) => mockAnyResponse(c, operation));
+                handlers.push(async (c) => await mockAnyResponse(c, operation));
+            }
+            if (query.length === 0) {
+                handlers.forEach((handler) => app[method](route, handler));
+                return;
             }
+            // The pinned query parameters are not part of the route, so they are checked here. A request
+            // that does not carry them is handed on to the next matching route — usually the sibling path
+            // key without the query string.
+            const operationChain = every(...handlers);
+            app[method](route, async (c, next) => {
+                if (!requestMatchesPinnedQuery(c, query)) {
+                    await next();
+                    return;
+                }
+                await operationChain(c, next);
+            });
         });
     });
     // OpenAPI JSON file

package/dist/index.d.ts

@@ -2,5 +2,6 @@ export { type AsyncApiMockServer, type AsyncApiMockServerOptions, createAsyncApi
 export { createMockServer } from './create-mock-server.js';
 export { defaultTransports, sseTransport, websocketTransport } from './transports/index.js';
 export type { MessageDirection, MockMessage, MockTransport, ResolvedChannel, ResolvedMessage, ResolvedOperation, TransportContext, } from './transports/types.js';
+export type { MockServerLogger, MockServerOptions } from './types.js';
 export { isAsyncApiDocument } from './utils/process-asyncapi-document.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,wBAAwB,GACzB,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAClF,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,aAAa,EACb,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,wBAAwB,GACzB,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAClF,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,aAAa,EACb,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,oBAAoB,CAAA;AAC3B,YAAY,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAClE,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA"}

package/dist/routes/mock-any-response.d.ts

@@ -1,10 +1,7 @@
 import type { OpenAPIV3_1 } from '@scalar/openapi-types';
 import type { Context } from 'hono';
-import type { StatusCode } from 'hono/utils/http-status';
 /**
  * Mock any response
  */
-export declare function mockAnyResponse(c: Context, operation: OpenAPIV3_1.OperationObject): (Response & import("hono").TypedResponse<{
-    error: string;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<null, StatusCode, "body">) | (Response & import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "body">);
+export declare function mockAnyResponse(c: Context, operation: OpenAPIV3_1.OperationObject): Response;
 //# sourceMappingURL=mock-any-response.d.ts.map

package/dist/routes/mock-any-response.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mock-any-response.d.ts","sourceRoot":"","sources":["../../src/routes/mock-any-response.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAIxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAOxD;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,CAAC,eAAe;;4PAwGjF"}
+{"version":3,"file":"mock-any-response.d.ts","sourceRoot":"","sources":["../../src/routes/mock-any-response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAIxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAanC;;GAEG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,CAAC,eAAe,YA6HjF"}

package/dist/routes/mock-any-response.js

@@ -1,12 +1,15 @@
-import { json2xml } from '@scalar/helpers/file/json2xml';
 import { getResolvedRef } from '@scalar/workspace-store/helpers/get-resolved-ref';
 import { getResolvedRefDeep } from '@scalar/workspace-store/helpers/get-resolved-ref-deep';
 import { getExampleFromSchema } from '@scalar/workspace-store/request-example';
 import { accepts } from 'hono/accepts';
+import { streamSSE } from 'hono/streaming';
+import { collectSseEvents, isEventStreamContentType } from '../utils/collect-sse-events.js';
 import { findPreferredResponseKey } from '../utils/find-preferred-response-key.js';
 import { normalizeResponseBody } from '../utils/normalize-response-body.js';
 import { parsePreferHeader } from '../utils/parse-prefer-header.js';
+import { pathParameters } from '../utils/path-parameters.js';
 import { selectResponseExample } from '../utils/select-response-example.js';
+import { serializeResponseBody } from '../utils/serialize-response-body.js';
 /**
  * Mock any response
  */
@@ -61,33 +64,51 @@ export function mockAnyResponse(c, operation) {
     });
     c.header('Content-Type', acceptedContentType);
     const acceptedResponse = selectedResponse?.content?.[acceptedContentType];
+    const responseSchema = acceptedResponse?.schema ? getResolvedRefDeep(acceptedResponse.schema) : undefined;
+    /** Generates the response body from the schema, or returns `undefined` when there is no schema. */
+    const generateFromSchema = () => responseSchema
+        ? getExampleFromSchema(responseSchema, {
+            emptyString: 'string',
+            variables: pathParameters(c),
+            mode: 'read',
+        })
+        : undefined;
+    // Server-Sent Events are a framed, multi-event wire format, so they cannot go out as one buffered
+    // body: a client reading the stream expects `data:` lines terminated by a blank line. Everything
+    // else (JSON, XML, text) keeps taking the single-body path below.
+    if (isEventStreamContentType(acceptedContentType)) {
+        const events = collectSseEvents(acceptedResponse, {
+            exampleName: prefer.example,
+            generate: generateFromSchema,
+        });
+        c.status(statusCode);
+        // `streamSSE` sets the transport headers itself (`Content-Type`, `Cache-Control`, `Connection`,
+        // `Transfer-Encoding`), so those win over a value the document declared for the same header —
+        // they are what makes the stream readable. Every other declared header set above survives.
+        return streamSSE(c, async (stream) => {
+            for (const event of events) {
+                if (event.framed) {
+                    await stream.write(event.text);
+                }
+                else {
+                    await stream.writeSSE({ data: event.text });
+                }
+            }
+        });
+    }
     // Body: a named/singular/first example if one is defined, otherwise generate
     // a value from the schema. `Prefer: example=<name>` picks a named example.
     const selectedExample = selectResponseExample(acceptedResponse, prefer.example);
-    const responseSchema = acceptedResponse?.schema ? getResolvedRefDeep(acceptedResponse.schema) : undefined;
     const body = selectedExample
         ? normalizeResponseBody(selectedExample.value, responseSchema)
         : responseSchema
-            ? normalizeResponseBody(getExampleFromSchema(responseSchema, {
-                emptyString: 'string',
-                variables: c.req.param(),
-                mode: 'read',
-            }), responseSchema)
+            ? normalizeResponseBody(generateFromSchema(), responseSchema)
             : null;
     c.status(statusCode);
-    return c.body(
-    // `null` is `typeof 'object'` too, but it is not a valid XML/JSON object
-    // root — serialize it (and any non-string primitive) with `JSON.stringify`
-    // so a `null` example does not get fed into `json2xml`.
-    body !== null && typeof body === 'object'
-        ? // XML
-            acceptedContentType?.includes('xml')
-                ? json2xml(body)
-                : // JSON
-                    JSON.stringify(body)
-        : typeof body === 'string'
-            ? // String
-                body
-            : // null / number / boolean
-                JSON.stringify(body));
+    const serializedBody = serializeResponseBody(body, acceptedContentType, responseSchema);
+    // `JSON.stringify` returns `undefined` for an `undefined` body, which is an empty response.
+    if (serializedBody === undefined) {
+        return c.body(null);
+    }
+    return c.body(serializedBody);
 }

package/dist/routes/mock-handler-response.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mock-handler-response.d.ts","sourceRoot":"","sources":["../../src/routes/mock-handler-response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAGxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAoIxD;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,CAAC,eAAe,gMA8D3F"}
+{"version":3,"file":"mock-handler-response.d.ts","sourceRoot":"","sources":["../../src/routes/mock-handler-response.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAGxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAqIxD;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,CAAC,eAAe,gMA8D3F"}

package/dist/routes/mock-handler-response.js

@@ -5,6 +5,7 @@ import { buildHandlerContext } from '../utils/build-handler-context.js';
 import { executeHandler } from '../utils/execute-handler.js';
 import { normalizeResponseBody } from '../utils/normalize-response-body.js';
 import { parsePreferHeader } from '../utils/parse-prefer-header.js';
+import { pathParameters } from '../utils/path-parameters.js';
 import { selectResponseExample } from '../utils/select-response-example.js';
 /**
  * Get example response from OpenAPI spec for a given status code.
@@ -48,7 +49,7 @@ function getExampleFromResponse(c, statusCode, responses, exampleName) {
         : responseSchema
             ? normalizeResponseBody(getExampleFromSchema(responseSchema, {
                 emptyString: 'string',
-                variables: c.req.param(),
+                variables: pathParameters(c),
                 mode: 'read',
             }), responseSchema)
             : null;

package/dist/types.d.ts

@@ -10,6 +10,8 @@ export type HttpMethod = (typeof httpMethods)[number];
 type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
     [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
 }[Keys];
+/** A sink for the informational log lines the mock servers print while starting up. */
+export type MockServerLogger = (line: string) => void;
 type BaseMockServerOptions = {
     /**
      * The OpenAPI document to use for mocking.
@@ -43,6 +45,19 @@ type BaseMockServerOptions = {
      * always return a mock response regardless of whether the request matches the contract.
      */
     validateRequest?: boolean;
+    /**
+     * Control the informational output the server prints while starting up, which is currently the
+     * authentication instructions for the security schemes of the document. Defaults to logging to
+     * the console.
+     *
+     * Pass `false` to silence it — handy when the mock server runs inside a test harness or another
+     * program, where the instructions are noise — or a `(line) => void` sink to route the lines
+     * somewhere other than the console.
+     *
+     * Diagnostics are not affected: warnings and errors about security schemes the mock server cannot
+     * handle, request validator compilation errors, and `x-seed` errors are printed either way.
+     */
+    logger?: boolean | MockServerLogger;
 };
 export type MockServerOptions = RequireAtLeastOne<BaseMockServerOptions, 'specification' | 'document'>;
 export {};

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,6CAA6C;AAC7C,eAAO,MAAM,WAAW,+DAAgE,CAAA;AAExF,wBAAwB;AACxB,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAA;AAErD;;GAEG;AACH,KAAK,iBAAiB,CAAC,CAAC,EAAE,IAAI,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,GACzF;KACG,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;CACzE,CAAC,IAAI,CAAC,CAAA;AAET,KAAK,qBAAqB,GAAG;IAC3B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAE5C;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAEvC;;OAEG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,WAAW,CAAC,eAAe,CAAA;KAAE,KAAK,IAAI,CAAA;IAExF;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,CAAC,qBAAqB,EAAE,eAAe,GAAG,UAAU,CAAC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAEnC,6CAA6C;AAC7C,eAAO,MAAM,WAAW,+DAAgE,CAAA;AAExF,wBAAwB;AACxB,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAA;AAErD;;GAEG;AACH,KAAK,iBAAiB,CAAC,CAAC,EAAE,IAAI,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,GACzF;KACG,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;CACzE,CAAC,IAAI,CAAC,CAAA;AAET,uFAAuF;AACvF,MAAM,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;AAErD,KAAK,qBAAqB,GAAG;IAC3B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAE5C;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAEvC;;OAEG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,WAAW,CAAC,eAAe,CAAA;KAAE,KAAK,IAAI,CAAA;IAExF;;;;;;;;;;;OAWG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IAEzB;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,gBAAgB,CAAA;CACpC,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,CAAC,qBAAqB,EAAE,eAAe,GAAG,UAAU,CAAC,CAAA"}

package/dist/utils/build-handler-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-handler-context.d.ts","sourceRoot":"","sources":["../../src/utils/build-handler-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAIxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAKnC,OAAO,EAAE,KAAK,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAEjF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,cAAc,CAAC,CAAA;IAC5D,KAAK,EAAE,OAAO,KAAK,CAAA;IACnB,GAAG,EAAE;QACH,IAAI,EAAE,GAAG,CAAA;QACT,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAC7B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAChC,CAAA;IACD,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CACzB,CAAA;AAED;;GAEG;AACH,KAAK,oBAAoB,GAAG;IAC1B,OAAO,EAAE,cAAc,CAAA;IACvB,QAAQ,EAAE,sBAAsB,CAAA;CACjC,CAAA;AA4DD;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,CAAC,EAAE,OAAO,EACV,SAAS,CAAC,EAAE,WAAW,CAAC,eAAe,GACtC,OAAO,CAAC,oBAAoB,CAAC,CAiD/B"}
+{"version":3,"file":"build-handler-context.d.ts","sourceRoot":"","sources":["../../src/utils/build-handler-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAA;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAIxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AAMnC,OAAO,EAAE,KAAK,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAEjF;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,cAAc,CAAC,CAAA;IAC5D,KAAK,EAAE,OAAO,KAAK,CAAA;IACnB,GAAG,EAAE;QACH,IAAI,EAAE,GAAG,CAAA;QACT,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;QAC7B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAChC,CAAA;IACD,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CACzB,CAAA;AAED;;GAEG;AACH,KAAK,oBAAoB,GAAG;IAC1B,OAAO,EAAE,cAAc,CAAA;IACvB,QAAQ,EAAE,sBAAsB,CAAA;CACjC,CAAA;AA4DD;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,CAAC,EAAE,OAAO,EACV,SAAS,CAAC,EAAE,WAAW,CAAC,eAAe,GACtC,OAAO,CAAC,oBAAoB,CAAC,CAiD/B"}

package/dist/utils/build-handler-context.js

@@ -5,6 +5,7 @@ import { getExampleFromSchema } from '@scalar/workspace-store/request-example';
 import { accepts } from 'hono/accepts';
 import { store } from '../libs/store.js';
 import { normalizeResponseBody } from './normalize-response-body.js';
+import { pathParameters } from './path-parameters.js';
 import { createStoreWrapper } from './store-wrapper.js';
 /**
  * Get example response from OpenAPI spec for a given status code.
@@ -42,7 +43,7 @@ function getExampleFromResponse(c, statusCode, responses) {
         : responseSchema
             ? normalizeResponseBody(getExampleFromSchema(responseSchema, {
                 emptyString: 'string',
-                variables: c.req.param(),
+                variables: pathParameters(c),
                 mode: 'read',
             }), responseSchema)
             : null;
@@ -86,7 +87,7 @@ export async function buildHandlerContext(c, operation) {
             faker,
             req: {
                 body,
-                params: c.req.param(),
+                params: pathParameters(c),
                 query: Object.fromEntries(new URL(c.req.url).searchParams.entries()),
                 headers: Object.fromEntries(Object.entries(c.req.header()).map(([key, value]) => [key, value ?? ''])),
             },

package/dist/utils/collect-sse-events.d.ts

@@ -0,0 +1,30 @@
+import type { OpenAPIV3_1 } from '@scalar/openapi-types';
+/** One event of a mocked Server-Sent Events response. */
+type SseEvent = {
+    /** Already-framed event text when `framed` is true, otherwise the `data` payload of one event. */
+    text: string;
+    /** Whether `text` is SSE framing of its own, to be written as is rather than wrapped in a `data:` line. */
+    framed: boolean;
+};
+/**
+ * The events a `text/event-stream` response emits, in order.
+ *
+ * Examples win over the schema, mirroring `selectResponseExample`, but a stream reads them as a
+ * sequence rather than a single body:
+ * 1. A named example requested via `Prefer: example=<name>`.
+ * 2. The singular `example` keyword.
+ * 3. Every entry of the `examples` map, in declaration order — an event stream that documents a
+ *    `summary` and a `row` example is documenting the two events it sends. A map of nothing but
+ *    complete framing is the exception: those are alternative streams, so only the first is served.
+ * 4. Nothing declared: a schema-generated payload, repeated so the stream has more than one event.
+ *
+ * `generate` is a callback so the schema is only turned into an example when no example is declared.
+ */
+export declare const collectSseEvents: (mediaType: OpenAPIV3_1.MediaTypeObject | undefined, { exampleName, generate }: {
+    exampleName?: string;
+    generate: () => unknown;
+}) => SseEvent[];
+/** Whether a media type is Server-Sent Events, ignoring parameters such as `; charset=utf-8`. */
+export declare const isEventStreamContentType: (contentType: string | undefined) => boolean;
+export {};
+//# sourceMappingURL=collect-sse-events.d.ts.map

package/dist/utils/collect-sse-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-sse-events.d.ts","sourceRoot":"","sources":["../../src/utils/collect-sse-events.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAcxD,yDAAyD;AACzD,KAAK,QAAQ,GAAG;IACd,kGAAkG;IAClG,IAAI,EAAE,MAAM,CAAA;IACZ,2GAA2G;IAC3G,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAgFD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAC3B,WAAW,WAAW,CAAC,eAAe,GAAG,SAAS,EAClD,2BAA2B;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,OAAO,CAAA;CAAE,KAC3E,QAAQ,EAoDV,CAAA;AAED,iGAAiG;AACjG,eAAO,MAAM,wBAAwB,GAAI,aAAa,MAAM,GAAG,SAAS,KAAG,OACf,CAAA"}