callman-mcp 0.8.0 → 0.9.0

package/dist/resources/docs/mocks.js

@@ -1,9 +1,34 @@
+import { MOCK_DATA_OPERATIONS, MOCK_FAKER_HINTS, MOCK_FIELD_TYPES, MOCK_ID_STRATEGIES, MOCK_RESOURCE_ENDPOINTS, MOCK_RESOURCE_TEMPLATES, MOCK_TEMPLATE_CATALOG } from "callman-core/mock-engine";
+// The vocabularies below come from callman-core, so this page always lists
+// exactly the words the engine (and the tools' schemas) take.
+const list = (values) => values.map((value) => `\`${value}\``).join(", ");
+const templateCatalog = () => {
+    const groups = new Map();
+    for (const entry of MOCK_TEMPLATE_CATALOG)
+        groups.set(entry.group, [...(groups.get(entry.group) ?? []), `\`{{${entry.token}}}\` ${entry.description.toLowerCase()}`]);
+    return [...groups].map(([group, tokens]) => `  - **${group}**: ${tokens.join(" · ")}`).join("\n");
+};
 export const MOCKS_DOC = `# Mock APIs through MCP
 
-A mock API is a fake HTTP API that answers with the responses you describe. Use it when a user says
-*"I need an API that returns …"* — to build a front end before the backend exists, to test a client
-against errors and slow answers, or to give a test a stable dependency. You create it with a few tool
-calls and hand the user a URL.
+A mock API is a fake HTTP API that answers like the real one. Use it when a user says *"I need an API that
+returns …"* — to build a front end before the backend exists, to test a client against errors, slow answers
+and sign-in, or to give a test a stable dependency. You create it with a few tool calls and hand the user a URL.
+
+With **mock engine v2** a mock can replace a real API: it has its own small database (**resources** with
+auto CRUD endpoints, filtering, paging and relations), **routes that read and write that data**, **user
+sign-in** with JWTs, **faults** on purpose and **test sessions** that keep parallel test runs apart — and it
+can be **imported** from an OpenAPI document, a Postman or a Callman collection.
+
+## Which engine the server runs
+
+\`GET /api/mocks/policy\` says it: \`engine: { version: 2, features, limits }\` means mock engine v2; no
+\`engine\` means v1 (static, template and builder routes over state only). The tools check this for you. On a
+v1 server every v2 part — \`resources\`, \`userAuth\`, \`faults\`, routes with \`data\` / \`faults\` /
+\`protected\`, the resource / record / session tools and import_mock — is refused with
+**MOCK_ENGINE_UNSUPPORTED before anything is created** (an older server would silently drop what it does not
+know). The same answer carries the mock lifetime: \`defaultTtlHours\` / \`maxTtlHours\` are set by the
+deployment (on-prem the admin's mock lifetime, 2 days unless changed); \`engine.limits\` has this
+installation's limits.
 
 ## Two places a mock can live (\`target\`)
 
@@ -11,53 +36,126 @@ calls and hand the user a URL.
 |---|---|---|
 | Where | On the Callman server | Inside the user's Callman desktop app |
 | URL | \`<server>/mock/<slug>/…\` — public, reachable by anyone with the URL (or the token) | \`http://127.0.0.1:<port>/…\` — this computer only |
-| Responses | static, **template** ({{…}}), **builder** presets, **variants**, request validation, delay | **static only** + delay |
-| State | yes (builder routes read and write it) | no |
-| Lifetime | expires after 1 / 6 / 24 / 48 h (default 48) | until deleted; lives while the app is open |
+| Answers | static, **template**, **builder** presets, **variants**, request validation, delay; v2: resources, data routes, sign-in, faults, sessions | static on every desktop; everything else on a desktop app with mock engine v2 (else 409 **LOCAL_MOCK_DESKTOP_OUTDATED**) |
+| Lifetime | the deployment's mock lifetime by default, any shorter \`ttlHours\`; renew with \`update_mock { ttlHours }\` | until deleted; lives while the app is open |
 | Needs | token with \`mocks:*\` | token with \`mocks:*\` **and** the desktop app open, signed in, with Settings → AI tools → "Let AI tools manage local mock APIs on this computer" on |
 | Routes are edited with | add_mock_route / update_mock_route / delete_mock_route | \`update_mock { routes }\` — REPLACES all routes |
 | Always on? | yes (no start/stop) | start_mock / stop_mock |
 
-If the server's \`publicUrl\` does not answer from your machine (an installation that never set its public address announces a host nobody can reach), use \`alternativeUrl\` from the same result — it is the API address plus \`/mock/<slug>\`.
+If the server's \`publicUrl\` does not answer from your machine (an installation that never set its public
+address announces a host nobody can reach), use \`alternativeUrl\` from the same result — it is the API
+address plus \`/mock/<slug>\`.
 
-Pick **server** unless the user wants it on their own machine, needs no network exposure, or a tool on
-their computer must call it at localhost. Desktop calls go through a relay: the app picks the request up
-within a few seconds. If it answers \`LOCAL_MOCK_DESKTOP_OFFLINE\`, tell the user to open the app and
-switch the setting on (or fall back to a server mock).
+Pick **server** unless the user wants it on their own machine, needs no network exposure, or a tool on their
+computer must call it at localhost. Desktop calls go through a relay: the app picks the request up within a
+few seconds. If it answers \`LOCAL_MOCK_DESKTOP_OFFLINE\`, tell the user to open the app and switch the setting
+on (or fall back to a server mock).
 
-## From a user's request to routes
+## From a user's request to a mock
 
 1. List first (\`list_mocks\`) — reuse or extend a mock that already fits instead of creating a duplicate.
-2. For each endpoint the user needs, decide: **method + path**, the **status code** and the **body**.
-   Use real-looking data; ask only when the contract is truly unknown.
-3. A fixed answer → a static response. Values taken from the request (the id in the path, a field of the
-   body) or random data → a template. A small CRUD API that remembers what was created → builder
-   routes over state. Different answers for different inputs (a 401 for a bad header, a 404 for one id)
-   → variants.
-4. Call \`create_mock\` with all routes at once. The result has the URL and a \`curl\` line per route —
-   give them to the user, and try one if you can.
-5. Iterate with \`update_mock_route\` / \`add_mock_route\`; read what real clients sent with \`get_mock_logs\`.
+2. There is a spec or a collection already? → \`import_mock\` (dryRun first).
+3. Decide per endpoint:
+   - things clients **create, list, read, change, delete** (users, orders, products) → a **resource**: one
+     entry gives all CRUD endpoints, validation, paging, filters and relations;
+   - an operation over that data that is not plain CRUD (cancel an order, find a user by email, count) → a
+     route with \`data\`;
+   - a fixed answer → a static route; values from the request or random data → a template route;
+   - sign-in, "only logged-in users", "users see only their own orders" → \`userAuth\` + \`protected\` /
+     \`ownerField\`;
+   - "sometimes fails", "is slow", "fails the first two calls" → \`faults\`;
+   - different answers for different inputs → variants.
+4. Call \`create_mock\` with all of it at once — on a v2 server it is one atomic request (all or nothing). The
+   result has the URL and a \`curl\` line per route, resource endpoint and sign-in endpoint — give them to the
+   user, and try one if you can. \`dryRun: true\` first shows what would be sent and any \`issues\`.
+5. Iterate: add_mock_route / update_mock_route, add_mock_resource / update_mock_resource; read what real
+   clients sent with \`get_mock_logs\` and what they stored with \`query_mock_records\`.
+
+## Resources — a database inside the mock (engine v2)
 
-\`\`\`json
-create_mock {
-  "name": "Orders API", "slug": "orders-api", "ttlHours": 24,
-  "routes": [
-    { "method": "GET", "path": "/orders", "statusCode": 200, "body": [{ "id": 1, "status": "NEW" }, { "id": 2, "status": "PAID" }] },
-    { "method": "GET", "path": "/orders/:id", "response": { "type": "template", "statusCode": 200, "body": { "id": "{{request.params.id}}", "status": "NEW", "createdAt": "{{now}}" } } },
-    { "method": "POST", "path": "/orders", "statusCode": 201, "body": { "id": "{{faker.uuid}}" }, "delay": { "mode": "fixed", "ms": 300 } }
-  ]
-}
+\`\`\`
+{ name, template?, basePath?, idField?, idStrategy?, lookupField?, allowClientId?, fields?, additionalFields?,
+  timestamps?, ownerField?, protected?, endpoints?, list?, seed? }
 \`\`\`
 
-## A route
+- **name**: lowercase first letter, letters / digits / \`_\` / \`-\` (users, orders, line-items); unique per mock.
+- **template**: start from a ready resource — ${list(MOCK_RESOURCE_TEMPLATES.map((template) => template.id))} — with
+  fields, id strategy and generated seed; keys you pass override it (\`{ "template": "users" }\` alone works).
+- **basePath**: default \`/<name>\`. **idField**: default \`id\`. **idStrategy**: ${list(MOCK_ID_STRATEGIES)}
+  (default uuid; \`client\` = the caller sends it). **lookupField**: what \`/:id\` looks up by (e.g. \`slug\`).
+- **fields**: \`{ name, type, required?, nullable?, unique?, uniqueCaseInsensitive?, default?, enum?, min?, max?,
+  minLength?, maxLength?, pattern?, items?, readOnly?, writeOnly?, ref?, fakerHint? }\`. Types:
+  ${list(MOCK_FIELD_TYPES)}. A \`password\` field is stored salted-hashed and never returned; \`default\` may be a
+  template (\`"{{now}}"\`, \`"{{auth.sub}}"\`); \`fakerHint\` says how seed data is generated
+  (${list(MOCK_FAKER_HINTS.slice(0, 12))} … any \`$random*\` token, or a template). No fields = schemaless: anything goes.
+- **additionalFields**: \`allow\` (default) / \`strip\` / \`reject\` (400) for fields that are not declared.
+- **timestamps**: \`{ createdAt, updatedAt }\` field names (default those; \`null\` switches one off).
+- **seed**: \`{ records?: [...], generate?: N, salt? }\` — every new copy of the data starts with the records plus N
+  generated ones. \`reset_mock_data\` goes back to it.
+- **endpoints**: per auto endpoint (${list(MOCK_RESOURCE_ENDPOINTS)}): \`false\` switches it off; an object sets
+  \`protected\`, \`faults\`, \`delay\`, \`responses\` (per outcome) or \`requestValidation\`.
+- **list**: \`envelope\` (\`array\` default; \`data-meta\` → \`{ data, meta: { total, page, limit } }\`; \`items\`; \`custom\`
+  with \`customBody\`), \`defaultLimit\` (null = all up to \`maxLimit\`), \`maxLimit\`, \`totalCountHeader\`, \`linkHeader\`,
+  \`filterMode\` (\`declared\` fields only / \`any\` query parameter), \`searchable\` (\`?q=\`), \`defaultSort\`.
+
+### Auto CRUD endpoints
+
+| Request | Answer |
+|---|---|
+| \`GET /<basePath>\` | the list (query language below), \`X-Total-Count\` and \`Link\` headers |
+| \`POST /<basePath>\` | 201 + the record (id and timestamps generated), \`Location\` header |
+| \`GET /<basePath>/:id\` | the record, or 404 |
+| \`PUT /<basePath>/:id\` | replace (id kept) · \`PATCH\` change the given fields |
+| \`DELETE /<basePath>/:id\` | 204 (relations: cascade / nullify / restrict → 409) |
+| \`GET\\|POST /<parent>/:<fk>/<child>\` | nested, for every \`ref\` field (\`/users/7/orders\`) |
+
+Writes are validated: **400** \`{ error, invalidFields: [{ field, message }] }\`, **409** \`{ error, field }\` for a
+taken unique value or id, **413** for a record over the size limit, **409** at the record limit. These
+endpoints are computed, never stored as routes: they do not count against the route limit, and an explicit
+route with the same path wins. Records can also be read and written without HTTP: \`query_mock_records\`,
+\`insert_mock_records\`, \`update_mock_records\`, \`delete_mock_records\`.
+
+### The list query language (json-server style)
+
+| Query | Meaning |
+|---|---|
+| \`status=paid\` · \`status=paid&status=new\` | equals · repeated = any of them |
+| \`total_gte=10\` \`_gt\` \`_lte\` \`_lt\` \`_ne\` | comparisons |
+| \`id_in=1,2,3\` · \`id_nin=4\` | in / not in a list |
+| \`email_exists=true\` | field present (or \`false\`: missing) |
+| \`tags_contains=red\` | an array field holds the value |
+| \`name_like=ada\` | case-insensitive substring (never a regular expression) |
+| \`address.city=Baku\` | nested fields |
+| \`q=ada\` | full-text search (\`list.searchable\`, or a schemaless resource) |
+| \`_sort=-total,name\` (or \`_sort=total&_order=desc\`) | sort, \`-\` = descending |
+| \`_page=2&_limit=10\` (or \`_per_page\`) · \`_start=20&_end=30\` | paging · slicing |
+| \`_expand=user\` · \`_embed=orders\` | inline the record a ref points to · the records pointing here |
+| \`_fields=id,name\` | only these fields |
+
+\`query_mock_records\` takes the same as arguments: \`where\` (equality), \`filters: [{ field, op, value }]\`
+(\`op\`: eq ne gt gte lt lte in nin exists contains like), \`q\`, \`sort\`, \`page\` / \`limit\` (default 20),
+\`start\` / \`end\`, \`expand\`, \`embed\`, \`fields\` — or \`query: "status=paid&_sort=-total"\` verbatim — and \`id\` for
+one record. It returns the records, the total and the query string to reuse with curl.
+
+### Relations — \`ref\`, \`_expand\`, \`_embed\`
+
+A field \`{ "name": "userId", "type": "string", "ref": { "resource": "users", "onDelete": "cascade" } }\` makes
+orders point at users: \`GET /orders?_expand=user\` inlines each order's user (the name is the field without
+\`Id\`; \`ref.as\` changes it), \`GET /users/7?_embed=orders\` lists a user's orders, and \`/users/7/orders\` answers
+GET and POST. \`onDelete\`: \`restrict\` (deleting the user answers 409 while orders exist), \`cascade\`
+(deletes them), \`nullify\` (sets the field null), \`none\` (default). \`ref.check\` (default true) refuses an
+order whose user does not exist (400).
+
+## Routes
 
 \`\`\`
-{ method, path, name?, response | (statusCode?, headers?, body?), variants?, delay?, requestValidation? }
+{ method, path, name?, response | (statusCode?, headers?, body?), variants?, delay?, requestValidation?,
+  data?, faults?, protected? }
 \`\`\`
 
 - **method**: GET POST PUT DELETE PATCH or ANY (any method that no specific route takes).
-- **path**: starts with \`/\`; letters, digits and \`/ _ - : * .\`; no \`..\`; at most 256 characters.
-  \`:name\` is a path parameter (letters, digits, underscore: \`:userId\`, not \`:user-id\`). A trailing
+- **path**: starts with \`/\`; letters, digits and \`/ _ - : * .\`; no \`..\`; at most 256 characters; \`/__callman\`
+  is reserved. \`:name\` is a path parameter (letters, digits, underscore: \`:userId\`, not \`:user-id\`). A trailing
   \`/*\` (or a \`*\` segment) matches everything below. The most specific route wins (literal segment >
   parameter > wildcard); a trailing slash is ignored. One route per method + path.
 - **response**: the full shape below. **Shorthand** for the common case: \`statusCode\` (default 200),
@@ -65,8 +163,9 @@ create_mock {
 - **name**: a label (shown in lists; usable as a reference).
 - **delay**: \`{ mode: "none" }\`, \`{ mode: "fixed", ms }\` or \`{ mode: "random", minMs, maxMs }\` — the
   answer is held back that long (server ≤ 60 000 ms, desktop ≤ 30 000 ms). Use it to test timeouts and spinners.
+- **data**, **faults**, **protected** (engine v2): below.
 
-### Responses (server)
+### Responses
 
 \`\`\`
 { "type": "static",   "statusCode": 200, "headers": { "X-Foo": "1" }, "body": <any JSON> }
@@ -77,26 +176,22 @@ create_mock {
 - **body**: any JSON value. An object/array is sent as JSON (\`content-type: application/json\` unless you
   set one); a *string* is sent as is (\`text/plain\` unless you set a content type — for XML/HTML put
   the text in \`body\` and set \`headers\`). No body = empty response (use for 204).
-- **template** — every string in the body may contain \`{{expression}}\`. A string that is *only* one
-  expression keeps its type (number, boolean, object); inside longer text the value becomes text.
-  Unknown expressions become \`null\` (whole) or empty (inline).
-  - \`request.params.<name>\`, \`request.query.<name>\`, \`request.headers.<name>\` (case-insensitive),
-    \`request.body.<dotted.path>\`, \`request.method\`
-  - \`state.<key>\` — the mock's state (see below)
-  - \`faker.email|uuid|fullName|firstName|lastName|phone|address|company|lorem|boolean|int\`
-  - \`random.int(min,max)\`, \`random.float(min,max)\`, \`random.boolean\`
-  - \`now\`, \`now+5m\`, \`now-2d\` (units s m h d) → ISO timestamps
-  - Example: \`{ "id": "{{request.params.id}}", "email": "{{faker.email}}", "age": "{{random.int(18,65)}}" }\`
-    (\`age\` becomes a number).
-
-### Builder presets (server)
-
-A builder route does the work of a REST endpoint over **state** (arrays of objects, stored per mock).
-\`config.preset\` must equal \`preset\`. Required keys are marked; the rest have defaults.
+- **template** — every string in the body (and in header values) may contain \`{{expression}}\`. A string that is
+  *only* one expression keeps its type (number, boolean, object); inside longer text the value becomes text.
+  Unknown expressions become \`null\` (whole) or empty (inline). Example:
+  \`{ "id": "{{request.params.id}}", "email": "{{faker.email}}", "age": "{{random.int(18,65)}}" }\` (\`age\` becomes a number).
+  The expressions:
+${templateCatalog()}
+
+### Builder presets (state-backed, every engine)
+
+A builder route does the work of a REST endpoint over **state** (arrays of objects, stored per mock). On a v2
+server prefer a **resource** — it does all of this with validation, relations and sessions. \`config\` is typed
+per preset; \`config.preset\` must equal \`preset\`. Required keys are marked; the rest have defaults.
 
 | preset | config | what it does |
 |---|---|---|
-| \`list\` | **source**: \`{kind:"static",data:[…]}\` or \`{kind:"state",stateKey}\`; \`filtering:{enabled,rules:[{queryParam,field,operator:equals\\|contains\\|startsWith\\|in}]}\`; \`sorting:{enabled,sortByParam:"sortBy",orderParam:"order",allowedFields:[…]}\`; \`pagination:{enabled,strategy:page\\|offset\\|cursor,defaultPageSize:20,maxPageSize:100,envelope:standard\\|data-meta\\|raw}\`; \`statusCode\`, \`headers\` | filter by query params, sort, paginate (\`?page=&limit=\`, \`?offset=&limit=\`, \`?cursor=<last id>&limit=\`). Envelopes: standard \`{items,total,page,totalPages}\`, data-meta \`{data,meta:{total,page,limit}}\`, raw array |
+| \`list\` | **source**: \`{kind:"static",data:[…]}\` or \`{kind:"state",stateKey}\`; \`filtering:{enabled,rules:[{queryParam,field,operator:equals\\|contains\\|startsWith\\|in}]}\`; \`sorting:{enabled,sortByParam:"sortBy",orderParam:"order",allowedFields:[…]}\`; \`pagination:{enabled,strategy:page\\|offset\\|cursor,defaultPageSize:20,maxPageSize:100,envelope:standard\\|data-meta\\|raw}\`; \`statusCode\`, \`headers\` | filter by query params, sort, paginate. Envelopes: standard \`{items,total,page,totalPages}\`, data-meta \`{data,meta:{total,page,limit}}\`, raw array |
 | \`detail\` | **source**, **notFoundBehavior**:\`{statusCode:404,body?}\`, \`paramName:"id"\`, \`lookupField:"id"\` | the item whose \`lookupField\` equals the path parameter; otherwise the not-found answer |
 | \`create\` | **stateKey**, \`autoGenerate:{id:"uuid"\\|"incremental",createdAt,updatedAt}\`, \`requiredFields:[…]\` (missing → 400), \`responseBehavior:return-created\\|return-id\\|status-only\`, \`statusCode:201\` | appends the request body (plus generated fields) to \`state[stateKey]\` |
 | \`update\` | **stateKey**, **notFoundBehavior**, \`paramName\`, \`lookupField\`, \`mergeStrategy:partial\\|full\`, \`autoUpdateUpdatedAt:true\`, \`statusCode:200\` | replaces/merges the matching item with the request body |
@@ -104,83 +199,213 @@ A builder route does the work of a REST endpoint over **state** (arrays of objec
 | \`echo\` | \`statusCode\`, \`headers\` | answers with the request: \`{method,params,query,headers,body}\` — handy to see what a client sends |
 | \`custom\` | \`statusCode\`, \`headers\`, \`body\` | a fixed answer through the builder |
 
-A full CRUD mock over one \`users\` collection (the path parameter name must match \`paramName\`):
-
-\`\`\`json
-create_mock { "name": "Users", "slug": "users-api", "routes": [
-  { "method": "GET",    "path": "/users",     "response": { "type": "builder", "preset": "list",   "config": { "preset": "list", "source": { "kind": "state", "stateKey": "users" }, "pagination": { "enabled": true } } } },
-  { "method": "GET",    "path": "/users/:id", "response": { "type": "builder", "preset": "detail", "config": { "preset": "detail", "source": { "kind": "state", "stateKey": "users" }, "notFoundBehavior": { "statusCode": 404 } } } },
-  { "method": "POST",   "path": "/users",     "response": { "type": "builder", "preset": "create", "config": { "preset": "create", "stateKey": "users", "autoGenerate": { "id": "incremental", "createdAt": true }, "requiredFields": ["name"] } } },
-  { "method": "PATCH",  "path": "/users/:id", "response": { "type": "builder", "preset": "update", "config": { "preset": "update", "stateKey": "users", "notFoundBehavior": { "statusCode": 404 } } } },
-  { "method": "DELETE", "path": "/users/:id", "response": { "type": "builder", "preset": "delete", "config": { "preset": "delete", "stateKey": "users", "notFoundBehavior": { "statusCode": 404 } } } }
-] }
-set_mock_state { "mock": "users-api", "initialState": { "users": [{ "id": 1, "name": "Ada" }] }, "state": { "users": [{ "id": 1, "name": "Ada" }] } }
-\`\`\`
-
-### State
+State is a JSON object per mock (limit 1 MB). \`get_mock_state\` shows \`state\` (live) and \`initialState\`;
+\`set_mock_state\` replaces either wholesale; \`reset_mock_state\` copies \`initialState\` back into \`state\`.
+\`{{state.key}}\` templates read it. Resource data is separate (\`reset_mock_data\`).
 
-State is a JSON object per mock (limit 1 MB). Builder \`create\`/\`update\`/\`delete\` change it as requests
-arrive (a missing array is created by the first \`create\`); \`list\`/\`detail\` with \`source.kind: "state"\` and
-\`{{state.key}}\` templates read it. \`get_mock_state\` shows \`state\` (live) and \`initialState\`;
-\`set_mock_state\` replaces either wholesale; \`reset_mock_state\` copies \`initialState\` back into \`state\`
-(do that between test runs). Seed *both* when you want a reset to return to the seed data.
-
-### Variants — different answers for different requests (server)
+### Variants — different answers for different requests
 
 A route can carry up to 20 variants. Each has \`priority\` (lower is checked first), a \`condition\` and a
 \`response\` (same shapes as above). The first variant whose condition matches answers; otherwise the
-route's own \`response\` does.
+route's own \`response\` (or \`data\`) does.
 
 \`\`\`json
 { "method": "GET", "path": "/profile",
   "response": { "type": "static", "statusCode": 200, "body": { "name": "Ada" } },
   "variants": [
-    { "priority": 1, "condition": { "type": "all", "rules": [{ "field": "headers.authorization", "operator": "not-exists" }] },
-      "response": { "type": "static", "statusCode": 401, "body": { "error": "unauthorized" } } },
-    { "priority": 2, "condition": { "type": "any", "rules": [{ "field": "query.fail", "operator": "equals", "value": "1" }] },
+    { "priority": 1, "condition": { "type": "any", "rules": [{ "field": "query.fail", "operator": "equals", "value": "1" }] },
       "response": { "type": "static", "statusCode": 500, "body": { "error": "boom" } } } ] }
 \`\`\`
 
 - \`condition.type\`: \`all\` (every rule) or \`any\` (at least one); 1–20 rules.
-- \`field\`: \`headers.<name>\`, \`params.<name>\`, \`query.<name>\`, \`body.<dotted.path>\`.
+- \`field\`: \`headers.<name>\`, \`params.<name>\`, \`query.<name>\`, \`body.<dotted.path>\` (v2 also \`auth.sub\`,
+  \`auth.claims.<name>\`, \`session.id\`).
 - \`operator\`: exists, not-exists (null and empty count as missing), equals, not-equals, contains,
-  starts-with, matches (a regular expression in \`value\`; an invalid one never matches). Values are compared as text.
+  starts-with, matches (a regular expression in \`value\`; unsafe patterns are refused). Values are compared as text.
+
+### Request validation
+
+\`requestValidation: { "mode": "schema", "schema": { …JSON Schema draft-07… } }\` makes the route reject a body
+that does not match with **400** and the list of invalid fields. Checked on POST, PUT and PATCH. \`mode: "any"\`
+(default) accepts anything; \`update_mock_route\` with \`requestValidation: null\` removes the gate.
+
+### Data routes — \`data\` (engine v2)
+
+A route that reads or writes a resource instead of answering a fixed body:
+
+\`\`\`
+data: { operation, resource, match?: [{ field, op?, value, skipIfEmpty? }], write?: { source?, pick?, omit?, set? },
+        mode?: "merge"|"replace", many?, find?: { useRequestQuery?, sort?, limit? }, responses? }
+\`\`\`
+
+- **operation**: ${list(MOCK_DATA_OPERATIONS)}. insert creates from the body; find answers a list (with
+  \`find.useRequestQuery\` the caller's list query applies too); findOne / update / delete / upsert act on the
+  first match (\`many: true\` → every match); count answers \`{ count }\`.
+- **match**: every rule must hold; \`value\` is a template or a literal — \`"{{request.params.id}}"\`,
+  \`"{{request.query.status}}"\`, \`"{{auth.sub}}"\`; \`op\` eq (default) ne gt gte lt lte in contains like;
+  \`skipIfEmpty\` ignores a rule whose value is empty (optional filters).
+- **write**: \`source\` (default \`"{{request.body}}"\`), \`pick\` / \`omit\` fields, \`set\` fields last
+  (\`{ "status": "cancelled", "cancelledAt": "{{now}}" }\`).
+- The answer is the record(s); no match → 404. **responses** overrides per outcome (success, created, notFound,
+  conflict, validationError, unauthorized, forbidden, limitExceeded, payloadTooLarge); a **template** \`response\`
+  on the route shapes the success answer with \`{{record}}\`, \`{{records}}\`, \`{{total}}\`. A static response
+  or the shorthand is refused on a data route.
+
+\`\`\`json
+{ "method": "GET",  "path": "/users/by-email/:email", "data": { "operation": "findOne", "resource": "users", "match": [{ "field": "email", "value": "{{request.params.email}}" }] } }
+{ "method": "POST", "path": "/orders/:id/cancel",     "data": { "operation": "update", "resource": "orders", "match": [{ "field": "id", "value": "{{request.params.id}}" }], "write": { "source": "{}", "set": { "status": "cancelled" } } } }
+{ "method": "GET",  "path": "/stats/orders",          "data": { "operation": "count", "resource": "orders", "match": [{ "field": "status", "value": "{{request.query.status}}", "skipIfEmpty": true }] } }
+\`\`\`
+
+## User sign-in — \`userAuth\` (engine v2)
+
+\`\`\`
+userAuth: { usersResource?: "users", identityField?: "email", passwordField?: "password", tokenTtlSeconds?: 3600,
+            roleClaim?: "role", claims?, protect?: "none"|"resources"|"all", endpoints?, responses?, issuer?, audience? }
+\`\`\`
+
+- \`POST /auth/register\` (201) and \`POST /auth/login\` (200) take \`{ <identityField>, <passwordField> }\` (register:
+  the whole user) and answer \`{ accessToken, tokenType: "Bearer", expiresIn, user }\`; \`GET /auth/me\` answers the
+  signed-in user. Paths change with \`endpoints: { login: { path }, register: { enabled: false } }\`.
+- The users resource needs the identity field (make it \`unique\`) and a \`password\` field (type password).
+- Tokens are HS256 JWTs signed with a per-mock secret (never shown); callers send \`Authorization: Bearer <token>\`.
+  Missing / invalid → **401** with \`WWW-Authenticate: Bearer\`; a role that does not fit → **403**.
+- What needs a user: \`protect\` sets the default — \`resources\` (default: every resource endpoint), \`all\` (every
+  route too) or \`none\`. \`protected\` on a route, a resource or one endpoint overrides it: \`true\` (any signed-in
+  user), \`{ "roles": ["admin"] }\` (the \`roleClaim\` field of the user must be one of them), \`false\` (public).
+- \`ownerField\` on a resource (\`"ownerField": "userId"\`) scopes it to the signed-in user: they list, read and
+  change only their own records, and new records get their id.
+- Templates see the user: \`{{auth.sub}}\`, \`{{auth.user.<field>}}\`, \`{{auth.claims.<name>}}\`.
+- \`X-Mock-Token\` (the mock's own access gate, \`auth: "token"\`) is separate and checked first.
+- \`update_mock { userAuth }\` changes it (the secret is kept), \`update_mock { userAuth: null }\` switches it off.
+
+## Faults — fail on purpose (engine v2)
+
+\`\`\`
+faults: { errorRate?, errorStatus?: 500, errorBody?, delay?, timeoutRate?, dropRate?, failFirst? }
+\`\`\`
+
+| Key | Effect |
+|---|---|
+| \`errorRate\` | % of requests answered with \`errorStatus\` (and \`errorBody\`) |
+| \`delay\` | extra delay on every request (\`{ mode: "fixed", ms }\` / \`{ mode: "random", minMs, maxMs }\`) |
+| \`timeoutRate\` | % of requests held unanswered, then 504 — the client's timeout fires first |
+| \`dropRate\` | % of requests whose connection is closed without an answer (a proxy in front shows 502) |
+| \`failFirst\` | the first N calls (per test session) fail with \`errorStatus\`, then it recovers — retry logic |
+
+Set them for the whole mock (\`create_mock\` / \`update_mock { faults }\`, null removes), for one route (the
+route's \`faults\`) or for one resource endpoint (\`endpoints: { create: { faults: … } }\`). \`reset_mock_data\`
+restarts the \`failFirst\` counters. A mock whose faults were set as full rules (conditions, sequences) shows
+them as \`faultRules\` next to the flat form.
+
+## Test sessions — \`X-Mock-Session\` (engine v2)
+
+A caller that sends \`X-Mock-Session: <id>\` (1–64 letters, digits, \`. _ : -\`) gets **its own copy of the data**,
+seeded on first use and dropped after being idle — so parallel test runs never see each other's writes. Too many
+active sessions → 429 (\`x-mock-limit-reason: session-limit\`). A caller can read and reset its own session at
+\`GET /__callman/session\` and \`POST /__callman/session/reset\`. From here: \`list_mock_sessions\`, and \`session\`
+on query_mock_records, insert / update / delete_mock_records and reset_mock_data.
+
+## Import — \`import_mock\` (engine v2)
+
+Builds a mock from an **OpenAPI 3.x / Swagger 2.0** document (JSON or YAML), a **Postman** collection (its saved
+examples) or a **Callman** collection (\`collection\`: its requests with their newest recorded responses,
+secrets redacted). One source: \`content\` (the document text, e.g. a file you read), \`url\` or \`filePath\`.
+**This MCP server reads URLs and files itself — the Callman server never fetches anything.** Files, and URLs on
+localhost or a private network, are refused (MOCK_IMPORT_SOURCE_BLOCKED) unless the user set
+\`CALLMAN_ALLOW_LOCAL_SOURCES=1\` for this server — read the file yourself and pass \`content\` instead.
+
+- \`mode: "auto"\` (default): CRUD groups (\`GET/POST /pets\` + \`GET/PUT/DELETE /pets/{id}\`) become resources with
+  the examples as seed records; everything else becomes routes. \`mode: "routes"\`: one route per operation.
+- Extra responses become variants; a caller picks one with \`X-Mock-Response-Code: 404\` or
+  \`X-Mock-Response-Name: <example name>\`. OpenAPI request schemas become request validation
+  (\`validateRequests: false\` turns it off); \`keepServerBasePath\` keeps \`/api/v3\` in the paths.
+- \`dryRun: true\` shows the routes and resources it would create and the **report**: what was converted, what
+  needs attention (\`warning\`) and what was \`lost\` — read it to the user.
+- \`into: { mock, strategy }\` adds to an existing mock: \`merge\` (default) keeps its routes and resources and adds
+  the new ones (same method + path or resource name is skipped); \`replace\` swaps them.
+- \`target: "desktop"\` converts on the server and writes a local mock to the desktop app.
+
+## Worked example — users + orders CRUD with login
+
+\`\`\`json
+create_mock {
+  "name": "Shop API", "slug": "shop-api",
+  "resources": [
+    { "template": "users" },
+    { "name": "orders", "idStrategy": "incremental", "ownerField": "userId",
+      "fields": [
+        { "name": "userId", "type": "string", "ref": { "resource": "users", "onDelete": "cascade" } },
+        { "name": "total", "type": "number", "required": true, "min": 0, "fakerHint": "$randomPrice" },
+        { "name": "status", "type": "string", "enum": ["pending", "paid", "cancelled"], "default": "pending" }
+      ] }
+  ],
+  "userAuth": { "usersResource": "users", "protect": "resources" },
+  "routes": [
+    { "method": "POST", "path": "/orders/:id/cancel", "protected": true,
+      "data": { "operation": "update", "resource": "orders",
+                "match": [{ "field": "id", "value": "{{request.params.id}}" }, { "field": "userId", "value": "{{auth.sub}}" }],
+                "write": { "source": "{}", "set": { "status": "cancelled" } } } },
+    { "method": "GET", "path": "/health", "statusCode": 200, "body": { "ok": true }, "protected": false }
+  ]
+}
+\`\`\`
+
+What the client (or you, with the curl lines from the result) can now do against \`<server>/mock/shop-api\`:
+
+\`\`\`
+POST /auth/register   { "email": "ada@example.com", "password": "secret123", "name": "Ada" }   → 201 { accessToken, user }
+POST /auth/login      { "email": "ada@example.com", "password": "secret123" }                 → 200 { accessToken, tokenType, expiresIn, user }
+GET  /auth/me                                   Authorization: Bearer <accessToken>          → Ada (no password)
+POST /orders          { "total": 42 }           Authorization: Bearer …                      → 201 { id: 1, userId: <Ada's id>, total: 42, status: "pending", createdAt, updatedAt }
+GET  /orders?status=pending&_sort=-total&_expand=user   (Bearer)                            → Ada's orders only, each with its user; X-Total-Count
+PATCH /orders/1       { "status": "paid" }      (Bearer)                                     → the changed order
+POST /orders/1/cancel                           (Bearer)                                     → status "cancelled"
+POST /orders          { "total": -1 }           (Bearer)                                     → 400 { error, invalidFields: [{ field: "total", … }] }
+GET  /orders                                    (no token)                                   → 401
+\`\`\`
 
-### Request validation (server)
+Then, for the user's tests:
 
-\`requestValidation: { "mode": "schema", "schema": { …JSON Schema draft-07… } }\` makes the route reject a
-body that does not match with **400** and the list of invalid fields — to let a client team verify what
-they send. Checked on POST, PUT and PATCH requests. \`mode: "any"\` (default) accepts anything. An invalid
-schema is refused when you save the route. \`update_mock_route\` with \`requestValidation: null\` removes the gate.
+- \`update_mock { "mock": "shop-api", "faults": { "failFirst": 2, "errorStatus": 503 } }\` — the first two calls fail,
+  the third succeeds (retry logic); \`reset_mock_data\` restarts the count.
+- Each test run sends its own \`X-Mock-Session: run-<n>\` header → isolated data; \`list_mock_sessions\` shows them.
+- \`query_mock_records { "mock": "shop-api", "resource": "orders", "filters": [{ "field": "total", "op": "gte", "value": 10 }], "expand": ["user"] }\`
+  shows what the client stored; \`insert_mock_records\` prepares data; \`reset_mock_data\` puts the seed back.
 
-### Auth (server)
+## Auth of the mock itself (server)
 
-\`auth: "public"\` (default) — anyone with the URL. \`auth: "token"\` — callers must send
-\`X-Mock-Token: <token>\` (else 401). The token is generated by the server and returned **once**, in the
-create_mock / update_mock result; \`get_mock\` keeps it masked unless the token holds \`environments:reveal\`
-and you pass \`reveal: true\`. Never put it into places the user did not ask for.
+\`auth: "public"\` (default) — anyone with the URL. \`auth: "token"\` — callers must send \`X-Mock-Token: <token>\`
+(else 401). The token is generated by the server and returned **once**, in the create_mock / update_mock result;
+\`get_mock\` keeps it masked unless the token holds \`environments:reveal\` and you pass \`reveal: true\`. Never put
+it into places the user did not ask for. (User sign-in above is a different thing: it simulates the API's own login.)
 
-## Limits (server defaults; an installation may change them)
+## Limits (server defaults; an installation may change them — \`GET /api/mocks/policy\` → \`engine.limits\`)
 
-20 mocks per workspace · 50 routes per mock · response body ≤ 100 KB · request body ≤ 1 MB ·
-state ≤ 1 MB · 20 000 requests in total per mock, then 429 · 30 requests per second per mock, then 429 ·
-the 500 newest request logs are kept · slugs: 3–48 chars, lowercase letters/digits/single dashes, start
-with a letter, a few reserved words (api, mock, admin …) refused · lifetime 1/6/24/48 h, then **410 Gone**.
-Local (desktop): response body ≤ 256 KB, ports 1024–65535 (omit \`port\` and the app picks a free one),
-the mock listens on 127.0.0.1 only.
+20 mocks per workspace · 50 routes per mock · response body ≤ 100 KB · request body ≤ 1 MB · state ≤ 1 MB ·
+20 000 requests in total per mock, then 429 · 30 requests per second per mock, then 429 · the 500 newest request
+logs are kept · slugs: 3–48 chars, lowercase letters/digits/single dashes, start with a letter, a few reserved
+words (api, mock, admin …) refused · lifetime up to the deployment's mock lifetime (longer requests are capped),
+then **410 Gone** — renew before that with \`update_mock { ttlHours }\`. A flood from one address gets 429 with
+\`X-Mock-Limit-Reason: ip-rate-limit\`. Engine v2: 20 resources per mock, 100 fields per resource, 1 000 records
+per resource, 16 KB per record, 512 KB of seed records, 20 active test sessions (idle after 60 min), 2 MB per import.
+Local (desktop): ports 1024–65535 (omit \`port\` and the app picks a free one), the mock
+listens on 127.0.0.1 only; a relay command carries at most 1 MB (a route body sent to an older desktop app: 256 KB).
 
 ## Desktop (local) mocks
 
-\`create_mock { target: "desktop", name, port?, autoStart?, routes? }\` creates a local mock in the user's
-app and starts it (\`start: false\` to skip). Routes are static: \`{ method, path, name?, statusCode, headers, body, delay }\`
-(or \`response: { type: "static", … }\` — the same route object you would give a server mock works as
-long as it is static; \`variants\`, \`requestValidation\`, template and builder responses are refused
-with LOCAL_MOCK_FEATURE_UNSUPPORTED). \`body\` is text: a string is sent verbatim, anything else is
-sent as formatted JSON. \`:param\` segments and a trailing \`/*\` work; every request is logged
-(\`get_mock_logs { target: "desktop" }\`, the latest requests only, kept until the app quits).
-To change routes: \`get_mock { target: "desktop" }\`, edit, \`update_mock { routes: [...all of them] }\`.
-\`start_mock\` / \`stop_mock\` / \`delete_mock\` act on one by name or id. Mocks the AI created carry an "AI"
-badge in the app. The mock is only reachable from the user's computer — don't hand out the URL to others.
+\`create_mock { target: "desktop", name, port?, autoStart?, routes?, resources?, userAuth?, faults? }\` creates a
+local mock in the user's app and starts it (\`start: false\` to skip). Static routes —
+\`{ method, path, name?, statusCode, headers, body, delay }\` or \`response: { type: "static", … }\` — work with every
+desktop app: \`body\` is text (a string is sent verbatim, anything else as formatted JSON). Templates, variants,
+request validation, resources, data routes, sign-in and faults need a server and a desktop app with mock engine
+v2 (the same engine runs on the desktop); with a v1 server they are refused (LOCAL_MOCK_FEATURE_UNSUPPORTED /
+MOCK_ENGINE_UNSUPPORTED), with an older desktop app the server answers LOCAL_MOCK_DESKTOP_OUTDATED.
+\`:param\` segments and a trailing \`/*\` work; every request is logged (\`get_mock_logs { target: "desktop" }\`, the
+latest requests only, kept until the app quits). To change routes: \`get_mock { target: "desktop" }\`, edit,
+\`update_mock { routes: [...all of them] }\`. The resource, record and session tools take \`target: "desktop"\` too.
+\`start_mock\` / \`stop_mock\` / \`delete_mock\` act on one by name or id. Mocks the AI created carry an "AI" badge in
+the app. The mock is only reachable from the user's computer — don't hand out the URL to others.
 
 ## Tools
 
@@ -188,23 +413,33 @@ badge in the app. The mock is only reachable from the user's computer — don't
 |---|---|---|
 | list_mocks, get_mock, get_mock_logs | mocks:read | \`target\` server/desktop |
 | get_mock_stats, get_mock_state | mocks:read | server |
+| query_mock_records, list_mock_sessions | mocks:read | engine v2, \`target\` server/desktop |
 | create_mock, update_mock | mocks:write | \`target\` server/desktop |
 | add_mock_route, update_mock_route, reorder_mock_routes, set_mock_state, reset_mock_state | mocks:write | server |
+| add_mock_resource, update_mock_resource, insert_mock_records, update_mock_records, reset_mock_data, import_mock | mocks:write | engine v2, \`target\` server/desktop |
 | start_mock, stop_mock | mocks:write | desktop |
 | delete_mock | mocks:delete (+ \`confirm: true\`) | \`target\` server/desktop |
 | delete_mock_route | mocks:delete (+ \`confirm: true\`) | server |
+| delete_mock_resource, delete_mock_records | mocks:delete (+ \`confirm: true\`) | engine v2, \`target\` server/desktop |
 
 \`mock\` is the name, the slug or the id. A route is referenced by routeId, \`"GET /users/:id"\`, its path
-(when unique) or its name. If \`create_mock\` fails on a route, the new mock is deleted again (needs
-mocks:delete; otherwise the result says it is kept) and the error names the failing route and why.
+(when unique) or its name; a resource by its name (or id). On a v1 server, if \`create_mock\` fails on a route,
+the new mock is deleted again (needs mocks:delete; otherwise the result says it is kept) and the error names the
+failing route and why; on a v2 server the create is atomic.
 
 ## Errors you may meet
 
 \`PAT_SCOPE_MISSING\` (token lacks mocks:read/write/delete) · \`FEATURE_DISABLED\` (mocks switched off for the
-account) · \`MOCK_SLUG_TAKEN\` (pick another slug) · \`MOCK_LIMIT_REACHED\` (delete an old mock) ·
-\`ROUTE_PATH_CONFLICT\` (the method + path exists) · \`MOCK_ROUTE_LIMIT_REACHED\` · \`VALIDATION_ERROR\`
-(details name the field) · \`LOCAL_MOCK_DESKTOP_OFFLINE\` (open the desktop app and switch the setting on) ·
-\`LOCAL_MOCK_TIMEOUT\` (the app did not answer; check with list_mocks before repeating a create) ·
-\`LOCAL_MOCK_FEATURE_UNSUPPORTED\` (use a server mock).
+account) · \`MOCK_ENGINE_UNSUPPORTED\` (a v2 part on a v1 server — nothing was written) · \`MOCK_DEFINITION_INVALID\`
+(\`details.issues\` names each problem by path; nothing was written) · \`MOCK_SLUG_TAKEN\` (pick another slug) ·
+\`MOCK_LIMIT_REACHED\` (delete an old mock) · \`ROUTE_PATH_CONFLICT\` (the method + path exists) ·
+\`MOCK_ROUTE_LIMIT_REACHED\` · \`MOCK_RESOURCE_CONFLICT\` (a resource with that name exists) ·
+\`MOCK_RESOURCE_NOT_FOUND\` / \`MOCK_RECORD_NOT_FOUND\` · \`MOCK_RECORD_INVALID\` (the record does not fit the fields) ·
+\`MOCK_RECORD_DELETE_BLOCKED\` (a \`restrict\` reference) · \`REVISION_CONFLICT\` (changed elsewhere; read and repeat) ·
+\`MOCK_IMPORT_SOURCE_BLOCKED\` (a file or private URL without CALLMAN_ALLOW_LOCAL_SOURCES) ·
+\`MOCK_IMPORT_UNSUPPORTED\` / \`MOCK_IMPORT_UNREADABLE\` / \`MOCK_IMPORT_TOO_LARGE\` · \`VALIDATION_ERROR\` (details name
+the field) · \`LOCAL_MOCK_DESKTOP_OFFLINE\` (open the desktop app and switch the setting on) ·
+\`LOCAL_MOCK_DESKTOP_OUTDATED\` (update the desktop app, or use a server mock) · \`LOCAL_MOCK_TIMEOUT\` (the app did
+not answer; check with list_mocks before repeating a create) · \`LOCAL_MOCK_FEATURE_UNSUPPORTED\` (static only here).
 `;
 //# sourceMappingURL=mocks.js.map

package/dist/resources/docs/mocks.js.map

@@ -1 +1 @@
-{"version":3,"file":"mocks.js","sourceRoot":"","sources":["../../../src/resources/docs/mocks.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,SAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgNxB,CAAC"}
+{"version":3,"file":"mocks.js","sourceRoot":"","sources":["../../../src/resources/docs/mocks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAEjM,2EAA2E;AAC3E,8DAA8D;AAC9D,MAAM,IAAI,GAAG,CAAC,MAAyB,EAAU,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAErG,MAAM,eAAe,GAAG,GAAW,EAAE;IACnC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAoB,CAAC;IAC3C,KAAK,MAAM,KAAK,IAAI,qBAAqB;QAAE,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,EAAE,OAAO,KAAK,CAAC,KAAK,QAAQ,KAAK,CAAC,WAAW,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,CAAC;IACtK,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,SAAS,KAAK,OAAO,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACpG,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,SAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAuEuB,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;;oFAExB,IAAI,CAAC,kBAAkB,CAAC;;;;IAIxG,IAAI,CAAC,gBAAgB,CAAC;;KAErB,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;;;;;sCAKF,IAAI,CAAC,uBAAuB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyFjE,eAAe,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAyDA,IAAI,CAAC,oBAAoB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2M5C,CAAC"}