@sun-asterisk/sungen 3.2.24 → 3.2.25

package/dist/orchestrator/templates/ai-src/config/copilot.md

@@ -80,7 +80,7 @@ qa/deliverables/<name>-testcases.xlsx  # Styled workbook for client hand-off
 
 ## Test Data
 
-`{{variable}}` references in `.feature` map to keys in `test-data/<screen>.yaml`. Data is loaded **at runtime** — the same generated `.spec.ts` works across environments without recompiling.
+`{{variable}}` references in `.feature` map to keys in `test-data/<screen>.yaml`. They belong in slots that take a value (`with {{v}}`, `as {{v}}`, `contains {{v}}`) — never inside a `[Target]`, which is a selector key matched literally. Data is loaded **at runtime** — the same generated `.spec.ts` works across environments without recompiling.
 
 **Environment overrides**: `SUNGEN_ENV=staging npx playwright test` merges `<screen>.staging.yaml` on top of `<screen>.yaml`. Create `<screen>.<env>.yaml` for environment-specific values (different credentials, URLs, test users).
 

package/dist/orchestrator/templates/ai-src/skills/sungen-api-design/SKILL.md

@@ -84,6 +84,41 @@ A flow (`create → login → delete`) is a **Functional integration** test, **n
 
 Fixture path resolves cwd-relative/absolute first, else `qa/fixtures/<path>` (drop sample files there, reference by name from `test-data`). An empty resolved file param omits the part → use for missing-file `@cases` error rows. `files:`/`bodyFile:` are mutually exclusive. A **`GET`/`HEAD` entry may carry no body at all** (no `body:`/`files:`/`bodyFile:`) — HTTP forbids it and the catalog lint refuses it; put the inputs in the path or `query`, or use `POST`. **Automate the upload success case with `@api`** — don't defer it to `@manual`.
 
+## XML APIs (`encoding: xml`)
+
+For services that accept/return XML (OTA/SOAP-style backends). Works with ANY XML shape — attributes, namespaces, CDATA, nesting.
+
+**Send** — the body is a raw string template (YAML block scalar); declared `params:` bind as `:name` tokens:
+```yaml
+stock_check:
+  method: POST
+  path: /agent-api
+  encoding: xml
+  params: [agent_code, signature, item_code]
+  body: |
+    <?xml version="1.0" encoding="UTF-8" ?>
+    <request>
+      <method>StockCheck</method>
+      <agent_code>:agent_code</agent_code>
+      <signature>:signature</signature>
+      <item_code>:item_code</item_code>
+    </request>
+```
+Only DECLARED params bind (namespace prefixes like `soapenv:Envelope` are never touched). Bound values are XML-escaped (`& < > " '`) so data can't corrupt the document; wrap a token as `<![CDATA[:param]]>` to bind raw. Content-Type defaults to `application/xml` (override via `headers:`).
+
+**Read** — a response whose Content-Type contains `xml` (never `html`) parses to an object for `{{name.body.<path>}}`; a missing/octet-stream Content-Type is sniffed only when the body starts with `<?xml`. Charset comes from the Content-Type, else the XML declaration, else UTF-8 (Shift_JIS responses decode correctly). Mapping:
+
+| XML | Bound value |
+|---|---|
+| `<error_code>01000001</error_code>` | `{{r.body.response.error_code}}` = `"01000001"` (always strings — no numeric coercion, leading zeros survive) |
+| `<smok></smok>` / `<smok/>` | `""` |
+| `<shop id="7">` | `{{r.body.response.shop.@_id}}` = `"7"` (attributes keep an `@_` prefix) |
+| `<soapenv:Body>` | key stays `soapenv:Body` (`{{r.body.soapenv:Envelope.soapenv:Body...}}`) |
+| `<memo><![CDATA[x & y]]></memo>` | plain text `x & y`; `&amp;`-style entities decode (the 5 predefined only) |
+| repeated `<item>` | declare `arrayPaths: [r.items.item]` (dot path INCLUDING the root element) — then 1 item and N items are BOTH arrays and `[0]` access never breaks. Without it, one item is an object and two are an array. |
+
+Caveats: an element literally named `count`/`first`/`last`/`length` under an array parent is shadowed by the path helper's own accessors; parse failure keeps the raw string body (same as any non-JSON response); the 5 predefined entities decode even inside response CDATA sections (a deliberate deviation from strict XML — assert the decoded form). Field metadata / `matches schema` / OpenAPI import for XML are not supported yet. The project needs the `fast-xml-parser` dev dependency (new projects get it from `sungen init`; older ones: `npm install --save-dev fast-xml-parser` — generate warns when it's missing).
+
 ## Per-endpoint knobs & auth patterns
 - **Timeout** — a slow endpoint can override the datasource default (15s) with `timeout_ms: 30000` on its catalog entry (else the datasource `timeout_ms` applies).
 - **OAuth2 (pure API, no browser)** — no new grammar; it's `@api` chaining. Call the token endpoint, bind the token, thread it into later calls' `Bearer :token` header:
@@ -95,6 +130,20 @@ Fixture path resolves cwd-relative/absolute first, else `qa/fixtures/<path>` (dr
   ```
   The token endpoint is a normal catalog entry (`POST /oauth/token`, form/JSON body); `list_orders` carries `headers: { authorization: "Bearer :token" }`. For a browser-authorized session instead, use `@hybrid` + `@auth:<role>`.
 - **Pagination** — use query params (`?page=:page&limit=:limit`, imported into `params`) + assert the page shape with plain field access (`{{list.body.next_page_token}}`, `{{list.body.items.length}}`); no special primitive needed.
+- **Download an absolute URL from a response** (export/report endpoints returning a `body.url` on blob storage): declare a catalog entry whose `path:` is EXACTLY one token, and thread the URL as its param — this is the only supported syntax:
+  ```yaml
+  download_export:
+    method: GET
+    path: ":url"
+    params: [url]
+  ```
+  ```gherkin
+  @api:export_report @api:download_export(url={{export_report.body.url}})
+  Scenario: VP-API-FLOW exported file is downloadable
+    Then expect {{export_report.status}} is 200
+    And expect {{download_export.status}} is 200
+  ```
+  The bound value must be an ABSOLUTE http(s) URL — an empty string, a relative path, or any other scheme (`file:`, `data:`, `mailto:`) fails the run loudly, so a broken export returning `{"url": ""}` can never false-pass. Presigned query escapes survive verbatim; a non-JSON body (CSV/text) is kept as text for `expect {{download_export.body}}` assertions. A catalog entry may also declare a literal absolute `path: "https://…"` (its `:params` bind with normal encoding). **Security:** when the REQUEST URL's origin differs from the datasource `base_url`, none of the datasource headers are sent (auth/tenant defaults must not leak to another origin) — a cross-origin download that needs a header must declare it in the entry's own `headers:`. This boundary applies to the initial request only: a same-origin request that REDIRECTS to another origin still carries the datasource headers (fetch auto-strips only `authorization`/`cookie`/`proxy-authorization` cross-origin) — prefer binding the final URL over following an API-origin redirect. The 15s default timeout may be short for large files (`timeout_ms:` on the entry).
 
 ## Rules
 - **No HTTP, no selectors** — only `.feature` + the reviewed `apis.yaml` + `test-data`.

package/dist/orchestrator/templates/ai-src/skills/sungen-error-mapping/SKILL.md

@@ -77,6 +77,7 @@ needs any of these, it is a **finding for QA** — surface it in the run summary
 |---|---|---|
 | strict mode violation | Multiple elements match | Add `nth: 0`, `exact: true`, or more specific `name` |
 | strict mode violation on `see`/`hover [X] item\|option\|cell with {{v}}` (dynamic list) | Older builds didn't filter the locator by the value | Since 3.2.13 `see`/`hover ... with {{v}}` on list-member roles filters by `hasText` like `click` (existence/hover the matching item) — keep the step data-driven, don't add per-item selectors. Update sungen if still unfiltered |
+| strict mode violation on a filtered list step whose value is a PREFIX of sibling texts (e.g. `1:00` also inside `11:00`) | The `hasText` filter matches by SUBSTRING by default (case-insensitive, like Playwright), so several members match | Add `exact: true` to the selector YAML entry — it anchors the filter to the full text and is honored for `type: locator` entries too |
 | Timeout / not found | Element doesn't exist or name wrong | Re-snapshot → copy exact accessible name. Check iframe/dialog scope |
 | Element is not an input | Wrong element type targeted | Change `type` or `value` to match actual element |
 | not a select | Custom dropdown, not native `<select>` | Set the widget variant: `variant: radix-select`/`antd-select` (built-in recipes), a custom recipe name from `qa/app.yaml`, or project-wide `widgets.select` in `qa/app.yaml` |
@@ -86,7 +87,7 @@ needs any of these, it is a **finding for QA** — surface it in the run summary
 
 | Code | Meaning | Fix |
 |---|---|---|
-| `SG-W001` | Step matched no pattern — compiled to a no-op `// TODO` (the test runs weaker than it reads) | Rephrase to a documented pattern (`sungen-gherkin-syntax`) or tag `@manual` with a reason |
+| `SG-W001` | Step matched no pattern — sungen has no step form for the sentence. Compiles to `throw new Error("[sungen] …")` naming the step (it emitted a no-op `// TODO` before the unsupported-step gate, which let the scenario PASS asserting nothing) | Rephrase to a documented pattern (`sungen-gherkin-syntax`) or tag `@manual` with a reason. There is no silent fallback — the test goes red until one of those two is done |
 | `SG-W002` | A step's `{{value}}` was parsed but never used in the generated code | The step form isn't the one you think — check the pattern's exact syntax |
 | `SG-W003` | `{ name }` filter defaulted from the Gherkin reference on a name-from-content role (toast/alert/status) | Add explicit `name:` or opt out with `name: null` |
 | `SG-W005` | `qa/app.yaml` unknown key / unknown preset / unparseable | Fix the key, or `extends: native\|radix\|antd` |
@@ -95,14 +96,23 @@ needs any of these, it is a **finding for QA** — surface it in the run summary
 | `SG-W008` | `@manual` scenario incomplete in either direction: (a) HAS Gherkin steps but NO `Then` — a dangling `When` is invalid Gherkin, comments can NOT substitute; (b) documentation-style (NO steps) but its comments lack numbered action lines and/or a labeled oracle line — prose paragraphs / rationale-only comments export EMPTY Steps + Expected cells | Two valid shapes only: complete the Gherkin with a `Then`, or write the FULL procedure in the `# Tester verifies:` block as NUMBERED lines — action steps first (`1. <action>`), then labeled `Observable:`/`Oracle:`/`Expected:` lines (the number is what fills Steps, the label is what fills Expected results) |
 | `SG-W009` | test-data references `${QA_<NAME>}` (a SECRET env ref) but the name is declared in neither `.env.qa` nor `.env.qa.example` — the test throws "environment variable not set" the moment the key is used. (Only the `${QA_*}` shape is checked; any other `${...}` is literal data and never flagged.) | Add `QA_<NAME>=<value>` to `.env.qa` (gitignored) and list the NAME in `.env.qa.example` (the committed checklist). See `qa/TEST-DATA-GUIDE.md` |
 | `SG-W010` | A row step's `[Ref]` looks POSITIONAL (`First…`/`Last…`/`Top…`/`nth`) but has no selectors.yaml entry — the label is display-only, so the step checks existence ANYWHERE in the table; an ordering/sort-stability rule would pass even when the row moved | Declare the row in selectors.yaml (a `type: locator` value RELATIVE to the table, e.g. `first contact row:` → `value: 'tbody tr:first-child'`) — the step then asserts `toContainText` on that exact row. This is a selectors.yaml-only fix — allowed inside the run-test auto-fix loop |
-| `SG-W011` | A storage assertion written as `expect … in local/session storage` — `expect` steps only read `{{response}}` refs, so this compiles to a silent no-op | Rewrite using the supported grammar: `User see [KEY] in local storage exists/…` |
+| `SG-W011` | A storage assertion written as `expect … in local/session storage` — `expect` steps only read `{{response}}` refs, so this matches no pattern. Compiles to a `throw` (was a silent no-op) | Rewrite using the supported grammar: `User see [KEY] in local storage exists/…` |
 | `SG-W012` | A mock-install step written AFTER a navigation step in the same block — `page.route()` registered after `goto()` misses every request fired during page load | Move the mock-install step before the navigation, or into `Background` |
 | `SG-W013` | A page assertion (`see [X] page` / `is on [X] page`) whose `[Ref]` has no `type: page` selector entry (or collides with a non-page entry) — the step falls back to the feature's own path (or `/<ref>/`) instead of `X`'s real URL, so the anchored assertion can never pass | Declare a `type: page` entry for `[Ref]` with its real URL; if the key collides with another type, disambiguate with a `--type` suffix (`sungen-selector-keys` § Collision rule) |
 | `SG-W014` | `[X] page with {{v}}` where `{{v}}`'s base test-data value carries no query and no fragment — the step checks the PATH only, asserting less than it reads as | Informational — pass a value like `?q=…` if you meant to assert a query, or drop `with {{v}}` for a bare page |
+| `SG-W015` | `see [X] card/item with {{n}}` where `{{n}}`'s test-data value is a **bare number** — this compiles to a TEXT assertion (`toHaveText('3')`), NOT a count. An author reaching for "3 cards are shown" gets an assertion that can only pass if the card's TEXT is literally the digit: a wrong test with no error. Scoped to container-ish element types (`card`/`item`/`option` + plurals); a text element asserting a numeric readout (`[Row Quantity] text with 4`) stays silent | For a COUNT use a form that has count semantics: `see [Ref] row with {{n}}` / `see [T] table with {{n}}`, or a list `should have count`. If the number really is the element's text, assert it on a **text/label** element instead |
 | `SG-E020` | A step matched a pattern, but the **active adapter ships no template** for it (e.g. a web-only step compiled under `platform: mobile`). The feature file still generates — that one step compiles to `throw new Error("[sungen] …")` naming the step, feature, pattern, template and adapter, so the failure is loud and traceable rather than a crashed build | Rephrase to a step the target adapter actually ships (see `sungen-gherkin-syntax` Platform Support section / `sungen-mobile-gestures`), or tag the scenario `@manual` with the platform reason |
+| `SG-E021` | The step carries a trailing **state clause** (`… is hidden`) that the pattern which matched it does not assert — the clause would be SILENTLY DROPPED. Worst shape in this table: it does not weaken an assertion, it can INVERT one. `see [X] page is hidden` matched `page-assertion` (priority 13) ahead of `is-hidden` (11), so the step compiled to `toHaveURL(...)` — asserting the page IS displayed, and passing. Also fires on `wait for [X] is checked` (a wait honours only `hidden`/`visible`/`disabled`/`enabled`; everything else silently fell back to `visible`) and on `row`/`column in [T] table … is <state>` for any state but `hidden` | Move the state onto the element that has it: `Then User see [X] checkbox is checked`. For a page, assert the page you expect (`Then User see [Other] page`) or a marker element (`Then User see [Banner] is hidden`). If sungen cannot express the check, tag the scenario `@manual`. The diagnostic names the pattern that swallowed the clause — that name tells you which form you actually hit |
 | `SG-W020` | The matched pattern **declares `platforms`** (today: `@mock`) and the active platform isn't among them. Caught before template lookup, so the diagnostic can name the native alternative directly | Drop `@mock` from a mobile unit (there is no Mock Driver on Appium) — use `@api`/`@query` or a `@manual` note instead |
 | `SG-W021` | `use dialog` / `User is on [X] dialog` scope under the **mobile** adapter — the scope is recorded but no Appium template reads `inDialog`, so every following step resolves against the whole screen, not just the dialog | Don't rely on `scope: dialog`/`use dialog` for disambiguation on mobile — give the element inside the dialog its own unique accessibility-id/testid instead |
 | `SG-W022` | `Then User see [X] page` under the **mobile** adapter — a native app has no URL, so the step compiles to a bare COMMENT: it reads as an assertion, checks nothing, and the scenario passes whatever is on screen. Worse than a hard failure, because nothing ever goes red. (Its `is on [X] page` twin throws via `route-assertion`; `Given User is on [X] page` is the app-LAUNCH directive and correctly emits nothing) | Assert something actually on the screen — `Then User see [Some Header] text` / a screen-marker accessibility-id — instead of a page/URL check, or tag the scenario `@manual` |
+| `SG-W023` | A mobile **setup** step that emitted NO executable code, so a declared PRECONDITION is never established. `Given the user is logged out` matches `user-not-logged-in` → the `clear-auth` template, which on Appium is a bare COMMENT: mobile auth lives in the keychain/prefs, not in cookies, so no per-step action can clear it. The scenario then runs against whatever the PREVIOUS scenario left signed in and passes regardless — the same false-pass class as `SG-W022`, arriving through setup instead of assertion. Deliberately NOT a `throw` (an unestablished precondition weakens setup, it does not INVERT an assertion) | Declare a feature-level reset tier — `@reset:data` on the Feature — so each scenario starts from a wiped data layer; app state is reset in the `beforeEach` hook, not mid-scenario by a step. For BACKEND state (`database is empty`) the remedy is different: reset through a test API/script, or bind a `@query:` precondition, the same way the web adapter has to |
+| `SG-W024` | Two or more scenarios in one feature **share a name** and at least ONE carries a `@reset:` tag. The generated per-scenario tier lookup is keyed on the scenario NAME (a `@cases` title is built at runtime, so no compile-time key can match the rendered title), so every same-named scenario resolves to the SAME tier — including one that declared none, which then silently runs at its namesake's tier: a `@reset:none` chain broken, or a reinstall nobody asked for. Counted over EVERY scenario rather than the tagged subset, because the untagged twin is the one that gets the wrong tier and has no tag to be counted by | **Rename** the scenarios so each title is unique. Reported rather than resolved by precedence on purpose — two tests genuinely sharing one title cannot be told apart by a name-keyed lookup, so a rename is the only honest fix (silently picking a winner would be the same silent-discard shape as `SG-W021`) |
+| `SG-E022` | The **generated spec file itself** is not parseable JS/TS, so NOTHING in it runs — Playwright reports one `SyntaxError` and every scenario in the unit is lost. A compiler self-check (`@babel/parser`) on the emitted code, added after a field report where the runtime-data marker post-processor mis-paired quote delimiters across two literals and the user only found out at `npx playwright test`. Reported, never thrown — the file is still written so you keep the artifact to inspect. **Unlike every other code in this table this one blames the COMPILER, not your `.feature`** | Nothing to fix in the Gherkin — this should be impossible. **Report it** with the `.feature` (and the step) the file was generated from, attaching the unparseable `.spec.ts`. Check first that you are running the project-local compiler (`npx sungen`), not an older global one |
+| `SG-E023` | The step carries an **assertion clause** (`matches "…"`, `contains`, `has text`) but the generated code is a BARE VISIBILITY check — the clause was swallowed by a catch-all and the test would pass whatever the element says. The sibling of `SG-E021`, for the clauses that are not states: `SG-E021` closed the state case declaratively, but a dropped `matches`/`contains`/`has text` still slid through (reproduced live: a `matches "<format>"` step compiled by an older sungen lost the assertion entirely, emitted no warning, and left a `toBeVisible()` that passed whatever the label said). Four separate defects arrived this way, so the step now compiles to a runtime `throw`. Deliberately narrow — fires only on the bare-visibility shape, so a pattern that genuinely consumed the clause (`is-hidden`, `contains`, `matches-format`, the state family, or a `filter({ hasText })` on a list member) is untouched | Either the phrasing is not the supported one for that clause — check the exact form in `sungen-gherkin-syntax` — or this sungen predates the step: verify you are running the project-local compiler (`npx sungen`), not an older global one |
+| `SG-E024` | A mobile **app-lifecycle** step (`User restart the app` / `User reinstall the app`) in a feature that declares no `Path:` app id. The lifecycle templates resolve the target app through `__resolveAppId()`, a helper the appium test-file template emits ONLY when the id is present, so the spec used to compile clean and then die at runtime with `ReferenceError: __resolveAppId is not defined` — taking the WHOLE spec down, not the one step, because the failure lands in a before hook. (Field case: a mobile unit scaffolded with the nav recipe in `--path` instead of `--reach`, so `Path` never carried an app id.) Now refused at compile time as a `throw` naming the missing line | Add the app id under the `Feature` line: `Path: com.example.app/.MainActivity \| com.example.app`. For a mobile unit `--path` carries the **APP ID** and `--reach` carries the navigation recipe — if the nav recipe ended up in `--path`, that is the mistake |
+
+A diagnostic never changes generation's own exit code — `sungen generate --strict` turns any collected diagnostic into a non-zero exit for CI gates. They are not all inert, though: **`SG-W001`, `SG-W011`, `SG-E020`, `SG-E021`, `SG-W020`, `SG-E023` and `SG-E024` additionally compile the offending step to a runtime `throw`** — a step that reads as a check and silently checks nothing is worse than one that fails loudly. Generation always COMPLETES: the rest of the scenario and the rest of the file still compile. `SG-E022` is the odd one out — it blames the compiler, not your `.feature`, and throws nothing (the file is written so you can inspect it).
 
 ### Runtime error → `Test data "<key>" references ${QA_*} but the environment variable is not set`
 
@@ -123,7 +133,8 @@ The scenario uses a SECRET test-data key whose `QA_*` variable is missing in thi
 ### Assertion type rule
 
 Sungen picks assertion based on element type:
-- **Input** (`field`, `textarea`, `search`, `dropdown`, `slider`) → `toHaveValue()`
+- **Input** (`field`, `textarea`, `search`, `slider`) → `toHaveValue()`
+- **Dropdown** (`dropdown`, `select`, `combobox`) → runtime tag probe: `toHaveValue()` on a native `<select>`/input, `toHaveText()` on a `<button role="combobox">` trigger (Radix/shadcn, MUI). Pin one branch with `variant: native` or an `assertValue` recipe in `qa/app.yaml`.
 - **Text** (everything else: `message`, `heading`, `label`, `row`) → `toHaveText()`
 - **Partial** (`contains` keyword) → `toContainText()`
 

package/dist/orchestrator/templates/ai-src/skills/sungen-gherkin-syntax/SKILL.md

@@ -36,7 +36,7 @@ AND    →  inherits from preceding keyword
 
 ```
 User is on [T] page | page with {{v}} | dialog
-User fill [T] field | textarea | search | slider | date-picker with {{v}}
+User fill [T] field | textarea | search | slider | date-picker with {{v}}   # date-picker: web only unless qa/app.yaml declares widgets.datepicker — appium refuses it
 User fill [T] uploader with {{f}}                                    [web]
 User clear [T] field
 User check [T] checkbox | toggle | radio
@@ -104,13 +104,23 @@ two content-filtered queries can hit different rows if the table re-renders in b
 # 1. Visibility: User see [T] type (NEVER add "is visible") | is hidden
 # 2. Text (toHaveText): User see [T] message | header | label with {{v}}
 # 3. Partial (toContainText): User see [T] text contains {{v}}
-# 4. Input (toHaveValue): User see [T] field | dropdown | date-picker | search | slider with {{v}}
+# 3b. Format (shape, not value): User see [T] label matches "yyyy/mm/dd ~ yyyy/mm/dd"
+# 4. Input (toHaveValue): User see [T] field | date-picker | search | slider with {{v}}
+#    dropdown | select | combobox → tag probed at runtime (toHaveValue native, toHaveText custom trigger)
 # 5. State: User see [T] button is disabled | checkbox is checked | dialog with {{v}} is hidden
 # 6. Attribute (toHaveAttribute): User see [T] image | link with {{v}}
 # 7. Count: User see [T] row with {{count}}
 # 8. Page: User see [T] page | page with {{url}}   ← `with` also asserts the query string
+#    NEVER a state: `page is hidden` / `page is empty` … are NOT step forms (see Pattern 8 below)
 ```
 
+> **`page` takes NO state clause.** The only two forms are `see [T] page` and `see [T] page with
+> {{url}}`. `see [X] page is hidden` is not a supported step: `page` compiles to a URL assertion, so
+> the clause is dropped and the step asserts the page IS displayed — the opposite of what it reads
+> as. The compiler now rejects it (`SG-E021`) instead of generating that. To say "we left page X",
+> assert the page you expect (`Then User see [Other] page`); to say "this went away", assert a marker
+> element (`Then User see [Some Element] is hidden`).
+
 **Pattern 8 — the page assertion judges pathname AND query together.** Both `see [T] page` and
 `is on [T] page` (Then-side) compile to ONE web-first predicate — `toHaveURL(urlMatches({…}))`,
 which retries like any other assertion — comparing the **exact** pathname (anchored, trailing slash
@@ -197,7 +207,31 @@ Then User see key matching "PATTERN" in local storage      # regex over key name
 # same five forms with `session storage`
 ```
 
-`[KEY]` is a **storage key, not a selector** — never add it to selectors.yaml. It may embed `{{vars}}`: `[{{exclusive_code}}_ACCESS_TOKEN]`. The check runs inside the browser and returns only a boolean, so a failure message never contains the stored value (safe for tokens). There is deliberately no `equals {{expected}}` form. ⚠️ `expect [KEY] in local storage …` is NOT valid (`expect` reads `{{response}}` refs only) — the compiler warns SG-W011.
+`[KEY]` is a **storage key, not a selector** — never add it to selectors.yaml. It may embed `{{vars}}`: `[{{exclusive_code}}_ACCESS_TOKEN]`. **This is the ONLY bracket that accepts a `{{var}}`.** An element `[Reference]` is a selectors.yaml key matched **literally** — it is never interpolated, so `[{{var}}]` for an element is invalid and the compiler rejects it. To target text that varies (locale, `@cases` column), keep the reference static and put the variable in the selector entry's `name:`/`value:` field, or pick by text with `with {{var}}` (`User click [Answer List] item with {{confirm_value}}`). The check runs inside the browser and returns only a boolean, so a failure message never contains the stored value (safe for tokens). There is deliberately no `equals {{expected}}` form. ⚠️ `expect [KEY] in local storage …` is NOT valid (`expect` reads `{{response}}` refs only) — the compiler warns SG-W011.
+
+### Format assertion `see [T] type matches "<format>"`
+
+A spec often states a label's contract as a **shape**, not a value — "Format: yyyy/mm/dd ~ yyyy/mm/dd",
+"Format: 残りX個". Write it verbatim; no regex belongs in a `.feature`:
+
+```gherkin
+Then User see [Application Period] label matches "yyyy/mm/dd ~ yyyy/mm/dd"
+Then User see [Remaining Stock] label matches "残りX個"
+Then User see [Total Plans] label matches "*X件"
+```
+
+| Token | Matches | | Token | Matches |
+|---|---|---|---|---|
+| `yyyy` | a 4-digit year | | `X` | an integer, `1,280` allowed |
+| `mm` `dd` `hh` `ss` | a zero-padded 2-digit part | | `*` | any run of characters |
+
+Everything else is a **literal**. The match is **anchored** — `"X件"` is not satisfied by `12件です`;
+use `*` where the label legitimately carries more (a mobile node that fuses a prefix and its count,
+`開催中の企画\n2件` → `"*X件"`). A token glued to an ASCII letter stays literal, so `"Comment: X件"`
+keeps its `mm`.
+
+Use this instead of `with {{v}}` when the VALUE varies but the SHAPE is the requirement: an exact
+value pins data that changes daily (red while the app is right), and `contains` passes on anything.
 
 ### Tab order `[web]`
 
@@ -307,8 +341,13 @@ Full-shape contract check: `expect {{name.body}} matches schema [Ref]` validates
 ### Platform Support — web-only / mobile-only / divergences
 
 Every claim below is checked against a shipped `.hbs` under
-`adapters/{playwright,appium}/templates/steps/` or a shipped diagnostic — see
-`tests/codegen/adapter-template-parity.run.ts` `DIVERGENCES` for the authoritative one-sided list.
+`adapters/{playwright,appium}/templates/steps/` or a shipped diagnostic. The authoritative
+per-template answer is **generated from the adapters themselves** — `docs/spec/step-support-matrix.md`
+(regenerate: `npm run gen:step-matrix`; `DIVERGENCES` lives in `tools/step-support-matrix/sources.ts`). Read
+it when this prose and the compiler seem to disagree: the matrix is derived, this section is authored.
+
+The matrix maps **templates**, not phrasings — a phrasing no pattern requests is absent from it
+entirely (a *pattern* gap, not a template gap), which is what the catalogue below is for.
 
 **Web-only `[web]`** — the Appium template throws, naming the reason: `fill [T] uploader with
 {{f}}`, Positional table rows, the whole Table section, Browser storage, Tab order, `@mock`,
@@ -355,6 +394,10 @@ zero-match assertion failure, not a platform gap.
 | Group | Types |
 |---|---|
 | **Context** | `page` `dialog` `modal` `drawer` `tab` `alert` `overlay` `step` |
+
+> `page` is the one Context type with **no state**: `dialog`/`modal`/`drawer`/`tab` etc. all take
+> `is hidden` / `is visible`, `page` never does. It asserts a URL. See Pattern 8.
+
 | **Input** | `field` `textarea` `search` `dropdown` `option` `checkbox` `radio` `toggle` `uploader` `slider` `date-picker` |
 | **Trigger** | `button` `link` `icon` `menuitem` `tag` |
 | **Data** | `table` `row` `column` `cell` `list` `item` `card` `section` |
@@ -443,12 +486,68 @@ on mobile a dialog-scoped ref still resolves against the whole screen (`SG-W021`
 | `@afterEach` | Hook: runs after each test → `test.afterEach()` (custom cleanup) |
 | `@afterAll` | Hook: runs once after all tests → `test.afterAll()` |
 | `@flow` | Mark feature as E2E flow (cross-screen testing) |
+| `@reset:none\|soft\|data\|full` | **`[mobile]`** How much state each scenario starts from. Default `soft`. Feature-level, or on a Scenario to RAISE (never lower) that one scenario's tier. See "Reset tiers" below |
 | `@cases:dataset` | Data-driven: run the scenario once per row of the `dataset` LIST in test-data → one `test()` per row |
 | `@query:name` | Database: run the named query from `database/queries.yaml` (precondition) and bind its rows to `{{name}}`; assert with `expect {{name.count}} …` + path access. Override params `@query:name(p={{v}})`. Repeatable. (Optional Data Driver — see Database verification above) |
 | `@api:name` | API: run the named request from `api/apis.yaml` (precondition) and bind the response to `{{name}}`; assert with `expect {{name.status}} …` + path access (`{{name.body.<path>}}`). Override params `@api:name(p={{v}})`. Repeatable. (Optional API Driver) |
 | `@concurrent:N` | API idempotency: fire the bound `@api` request N times in parallel, then bind aggregates on the `@api` name — `{{name.ok_count}}` (2xx count) and `{{name.status_counts}}` (status→count map). Assert the exactly-once invariant (`expect {{name.ok_count}} is 1`); pair with `@query` as a DB oracle. Tag order = run order: `@api` (mutate) before `@query` (verify). (Optional API Driver) |
 | `@hybrid` | One unit, two capabilities: a signed-in browser session (UI) authorizes the `@api` call — the API request reuses the UI `storageState`. (Optional API + UI Drivers) |
 
+### Reset tiers (`@reset`) `[mobile]`
+
+Web gets a clean slate for free — a URL reload is effectively fresh state. Mobile does not: to save
+time the app stays alive across the whole session, so the end state of one scenario becomes the start
+state of the next. Left uncontrolled that breaks test independence (scenarios can't run in isolation
+or in parallel, a leftover "nearly right" state makes the FOLLOWING scenario fail, and a scenario that
+dies mid-flow poisons every one after it). Nobody just reinstalls between scenarios because a cold
+start is 5–30s — hence a ladder rather than one all-or-nothing switch.
+
+| Tier | Mechanism | Cost | Clears |
+|---|---|---|---|
+| `none` | nothing — only the NATIVE-context + portrait guards | 0s | — state carries over BY DESIGN |
+| `soft` | `terminateApp` + `activateApp` — **the default** | ~1–3s | in-memory state, navigation stack |
+| `data` | `soft` + wipe the app's data layer | ~2–5s | + local DB, cache, prefs, keychain |
+| `full` | `removeApp` + `installApp` | ~5–30s | + permissions, install-time state |
+
+```gherkin
+@platform:mobile @reset:data
+Feature: Onboarding
+  Path: com.example.app/.MainActivity | com.example.app
+
+  Scenario: VP-001 First-run tutorial shows for a brand-new user
+    Then User see [Tutorial Slide 1] section
+
+  @reset:full
+  Scenario: VP-002 Needs a clean install, unlike its neighbours
+    Then User see [Permission Prompt] dialog
+```
+
+Rules that matter when generating:
+
+- **`soft` is the default** — omit the tag unless the scenario actually needs more. An untagged
+  feature behaves exactly as it always did.
+- **Pick `data` for first-run / onboarding / empty-state oracles.** A plain relaunch leaves a
+  completed tutorial completed, so the scenario passes on run 1 and fails on run 2.
+- **Pick `full` only for permissions or install-time state.** It costs a cold start every scenario.
+- **Pick `none` only for a deliberate carryover chain** (a cart accumulating across scenarios). Order
+  becomes load-bearing, and the scenarios can no longer run independently — that is the trade.
+- **A scenario tier RAISES the feature tier, never lowers it.** A `@reset:full` feature is not weakened
+  by a `@reset:soft` scenario; use a separate feature if you need a weaker one.
+- **A failed scenario escalates the NEXT one by one rung** (`soft`→`data`→`full`), because a process
+  relaunch does not undo a half-written local DB. One rung, one scenario, and never from `none`.
+  A **retry** of the failed scenario is NOT escalated — it re-runs at its declared tier, so a
+  state-dependent failure fails both attempts and is reported honestly instead of passing on attempt 2.
+- **`SUNGEN_RESET_TIER=data` raises the floor for a whole run** without regenerating specs — CI can run
+  stricter than local dev. It never lowers a declared tier.
+- **`data`/`full` on iOS reinstall the app**, because `mobile: clearApp` is Android-only (UiAutomator2).
+  That needs `IOS_APP` (or `APP_APK` on Android) so the `appium:app` capability is present, or the
+  reset throws naming it.
+- **`data` and `full` wipe app data on the target device.** Emulator / dedicated test device only.
+
+Mobile app-state preconditions have no per-step equivalent: `Given the user is logged out` compiles to
+a COMMENT on Appium (auth lives in the keychain, not in cookies) and reports **SG-W023**. Declare
+`@reset:data` on the Feature instead of writing a step that establishes nothing.
+
 ### Data-driven scenarios (`@cases`)
 
 For one test case × many inputs (email/format/boundary validation, decision tables), tag the
@@ -575,7 +674,7 @@ dashboard:
 
 - Tool executes **only Given→When** of `@steps` scenario (skips Then)
 - The `Given` in `@extend` scenario is the **entry assertion** (confirms state after base steps)
-- **Entry assertion MUST use `Given User is on [X] type`** — NEVER `Given User see [X] type`
+- **Entry assertion MUST use `Given User is on [X] page`** (or `[X] dialog`) — NEVER `Given User see [X] type`. `is on` takes ONLY `page` (`screen` on mobile) and `dialog`: it names a navigation target. For a state inside the current page (a wizard step, a panel) assert it with `Then User see [X] section` and reach it via the flow's When steps or an `@steps`/`@extend` base — the compiler rejects `is on [X] <other type>`.
 - `Given` keyword ONLY allows `is on` action. `see` = `Then` only.
 - If `@steps` scenario fails, `@extend` scenario is **skipped**
 - Name format: `snake_case` or `kebab-case` with module prefix: `@steps:kudos__open_modal`
@@ -593,6 +692,11 @@ dashboard:
 | Hardcode data | `with {{admin@mail.com}}` | `with {{invalid_email}}` |
 | Missing `is` for state | `with {{text}} hidden` | `with {{text}} is hidden` |
 | State as value | `with {{disabled}}` | `is disabled` |
+| State on a `page` | `Then User see [Home] page is hidden` | `Then User see [Other] page` — or assert a marker element: `Then User see [Home Banner] is hidden`. `page` asserts a URL; the clause is dropped and the assertion INVERTS. Rejected by `SG-E021` |
+| State the step form cannot assert | `wait for [X] spinner is checked` · `see [R] row in [T] table with {{v}} is disabled` | Assert the state on the element itself: `Then User see [X] checkbox is checked`. A `wait` only honours `hidden`/`visible`/`disabled`/`enabled`; a row/column step only honours `is hidden`. Anything else is dropped → `SG-E021` |
+| Invented step form | any sentence with no matching pattern | Use a form from this reference. There is no silent fallback any more — an unmatched step compiles to a runtime `throw` (`SG-W001`). If the check cannot be automated, tag the scenario `@manual` |
+| Assertion clause the pattern drops | `Then User see [Code] text matches "<format>"` compiling to a bare `toBeVisible()` | Use the exact supported phrasing for the clause (see the `matches` / `contains` / `has text` forms above). A clause that gets swallowed leaves an assertion that passes whatever the element says, so the step is rejected with `SG-E023` instead. If the step still compiles bare, you are on an older global sungen — run `npx sungen` |
+| Mobile lifecycle step with no app id | `When User restart the app` in a feature whose `Path:` carries only a route | Declare the app id on the Feature: `Path: com.example.app/.MainActivity \| com.example.app`. The lifecycle steps resolve the app from `Path`; without it the whole spec would die at runtime, so the step is rejected with `SG-E024`. For a mobile unit `--path` carries the APP ID, `--reach` carries the navigation recipe |
 | Missing target type | `fill [email] with {{v}}` | `fill [email] field with {{v}}` |
 | Background with scope | `Background: ... And User is on [X] dialog` | Use `@steps` + `@extend` for scope-dependent flows |
 | `is on` after When | `When ... And User is on [X] dialog` | `And User see [X] dialog` or separate Given |

package/dist/orchestrator/templates/ai-src/skills/sungen-locale/SKILL.md

@@ -575,7 +575,7 @@ If the screen has multiple `.feature` files (e.g. `home.feature` + `home-modal.f
 
 ## What NOT to do
 
-- Do not edit `.feature` files. The i18n shape is already correct there (`{{var}}` was the convention from the start). Only selectors + test-data need surgery.
+- Do not edit `.feature` files. Their `[Target]` labels are locale-stable keys — they are matched literally and must NOT be turned into `[{{var}}]`. Localised text lives in the selector entry's `name:`/`value:`, so only selectors + test-data need surgery.
 {{#cap parallel-subagents}}
 - Do not write a separate selectors file per locale (`home.en.yaml`). One selectors file with `{{var}}` works across all locales — that's the whole point.
 - Do not delete keys from the base `test-data/<feature>.yaml`. Always append. Existing tests rely on base values being complete.

package/dist/orchestrator/templates/ai-src/skills/sungen-mobile-gestures/SKILL.md

@@ -43,6 +43,14 @@ patterns (`click`, `hover`, `fill`) don't cover.
 > - **`reinstall the app`** → remove → install from the session's build file → launch. **Requires
 >   the session to have installed via `APP_APK` / `IOS_APP`** (the `appium:app` cap) — attaching by
 >   package only makes the step fail loud with that exact fix in the message.
+>
+> **These two are IN-scenario steps. Reset BETWEEN scenarios is a tag, not a step** — `@reset:` on the
+> Feature (`none` · `soft` = default · `data` · `full`), which runs in the `beforeEach` hook. Reach for
+> the tag when the whole suite needs a cleaner starting state, and for these steps when one scenario's
+> ORACLE is "does this survive a restart / a reinstall". Writing a step to establish app state does not
+> work on mobile: `Given the user is logged out` compiles to a comment (auth lives in the keychain, not
+> in cookies) and reports **SG-W023** — declare `@reset:data` instead. Full tier table + trade-offs:
+> `sungen-gherkin-syntax` → "Reset tiers".
 > - **`turn airplane mode|wifi|mobile data on|off`** → `mobile: setConnectivity`. **Android-only** —
 >   XCUITest cannot toggle connectivity; on iOS the step throws loud. Keep such scenarios
 >   `@platform:android`. Do NOT author cleanup steps to restore connectivity "in case the test

package/dist/orchestrator/templates/ai-src/skills/sungen-selector-fix/SKILL.md

@@ -57,7 +57,7 @@ When running Phase 0 for a **flow** (`qa/flows/<name>/`), check existing screen
 2. **Collect references**: parse the `.feature` file for every `[Reference]` element + its type (e.g. `[Submit] button`, `[Email] field`). Deduplicate.
 
    ⛔ **Non-selector bracket refs — never hunt the DOM for these, never write a selectors.yaml entry:**
-   - `[KEY] in local storage …` / `[KEY] in session storage …` — a **storage key**, checked via `page.evaluate`, not an element (the key may embed `{{vars}}`, e.g. `[{{code}}_ACCESS_TOKEN]`).
+   - `[KEY] in local storage …` / `[KEY] in session storage …` — a **storage key**, checked via `page.evaluate`, not an element (the key may embed `{{vars}}`, e.g. `[{{code}}_ACCESS_TOKEN]` — this is the ONLY bracket that accepts one; an element `[Reference]` is matched literally and `[{{var}}]` is rejected by the compiler).
    - Bracket refs consumed by other non-DOM step families (`@mock` route refs) follow the same rule: if the step's grammar does not target a UI element, the bracket content is NOT a selector.
    Writing a fabricated entry for these breaks the real step (the pattern parses the bracket itself) and pollutes selectors.yaml.
    ✅ **Tab-order table cells ARE selector refs** — each `| [Ref] |` row under `Then User see tab order:` resolves through selectors.yaml like any element (verify them once; they are the same refs the scenario's other steps use — don't double-count them as new elements).

package/dist/orchestrator/templates/ai-src/skills/sungen-tc-generation/SKILL.md

@@ -449,6 +449,15 @@ Cross-pattern: `@high` by default.
 
 ---
 
+## Format over value
+
+When the spec states a label's contract as a **shape** ("Format: yyyy/mm/dd ~ yyyy/mm/dd", "Format: X件", "Format: 残りX個"), generate `matches "<format>"` — never `with {{v}}`. An exact value pins data that changes daily (red while the app is right); `contains` proves nothing. Tokens: `yyyy mm dd hh ss X *`. Anchored — use `*` when a node fuses a prefix with the value. See `sungen-gherkin-syntax` → Format assertion.
+
+```gherkin
+Then User see [Application Period] label matches "yyyy/mm/dd ~ yyyy/mm/dd"
+Then User see [Total Plans] label matches "*X件"
+```
+
 ## Priority Tags
 
 Every scenario **MUST** have exactly one priority tag. Assign by user impact per the **"Assign priority by user impact"** table in `sungen-gherkin-syntax`; override only when context differs.

package/dist/orchestrator/templates/ai-src/skills/sungen-tc-review/SKILL.md

@@ -46,7 +46,12 @@ Hard-fail gate. Any ✗ is a syntax error — must be fixed; do not score furthe
 - [ ] `Given` → only `is on` · `When` → action (click/fill/select/press/clear/check/uncheck/hover/wait) · `Then` → only `see` · `And` inherits the preceding keyword
 - [ ] NO `Given User see…` (→ `Then`, or entry assertion `Given User is on [X] page`)
 - [ ] NO `When … And User is on [X] dialog` (→ `And User see` or a separate `Given`)
+- [ ] `dismiss [X]` is SETUP, never proof — it is best-effort and never fails, so a scenario that
+      claims an overlay closed must assert it: `Then User see [X] is hidden` (mobile: tap the
+      close/scrim node explicitly, then assert)
+- [ ] `is on` takes ONLY `[X] page` (`[X] screen` on mobile) / `[X] dialog` — `is on [X] step|section|card` ✗ (it compiles to a real navigation, or to a URL assertion that cannot fail). A state inside the page → `Then User see [X] section`.
 - [ ] NO literal-URL navigation (`navigate to "/x"`) → `User is on [X] page` + declare in `selectors.yaml`
+- [ ] NO `{{var}}` inside a `[Target]` (`[{{confirm_value}}]` ✗) — a target is a selector key matched literally. For text that varies (locale, `@cases` column) keep the target static and move the variable into the selector entry's `name:`/`value:`, or pick by text with `with {{var}}`. Only a browser-storage key may embed one.
 
 ### A2. Action → Element type
 
@@ -67,6 +72,16 @@ Hard-fail gate. Any ✗ is a syntax error — must be fixed; do not score furthe
 ### A4. Assertion (8 patterns → determines the Playwright assertion)
 
 - [ ] Visibility `see [T] type` → NO redundant `is visible`; hidden uses `is hidden`
+- [ ] **No state clause on `[T] page`** — `page is hidden`/`is empty`/… are not step forms. `page`
+      asserts a URL, so the clause is dropped and the assertion inverts (`SG-E021`). Assert the
+      expected page, or a marker element
+- [ ] **The state is one the step form can actually assert** — a `wait for` honours only
+      `hidden`/`visible`/`disabled`/`enabled`; `row in [T] table` / `column in [T] table` honour
+      only `is hidden`. Anything else is dropped (`SG-E021`) — move the state onto the element
+- [ ] **No invented step forms** — every step matches a pattern in `sungen-gherkin-syntax`. An
+      unmatched step compiles to a runtime `throw` (`SG-W001`), never a silent pass; park a
+      genuinely unautomatable check as `@manual`
+- [ ] A spec `Format:` line → `matches "<format>"`, NOT `with {{v}}` (an exact value pins data that changes daily; `contains` proves nothing)
 - [ ] Correct pattern: text(`message/header/label with {{v}}`) · partial(`text contains {{v}}`) · input(`field/dropdown with {{v}}`) · state(`is …`) · attribute(`image/link with {{v}}`) · count(`row with {{count}}`) · page(`[T] page`)
 - [ ] Table: `[Col] column in [Table] table`, `[Ref] row in [Table] table with {{v}}`, `table with {{count}}`/`is empty`, `table match data:`; row scope used correctly
 

package/dist/orchestrator/templates/env.appium.example

@@ -24,6 +24,16 @@ JAVA_HOME=/opt/homebrew/opt/openjdk@21
 # IOS_BUNDLE_ID=<ios bundle id>      # REQUIRED — the iOS bundle (⚠ NOT the Android package)
 # IOS_TEAM_ID=<Apple Team ID>        # REQUIRED — 10-char id (Xcode → Settings → Accounts)
 
+# ════════════ State reset between scenarios ════════════
+# Raises the reset floor for a WHOLE run without regenerating any spec — CI can run stricter than
+# local dev. It never LOWERS a tier a feature declared with @reset:. Tiers, weakest → strongest:
+#   none  nothing reset (state carries over by design)      0s
+#   soft  terminate + relaunch — THE DEFAULT               ~1–3s
+#   data  + wipe local DB / cache / prefs / keychain        ~2–5s   (iOS: reinstalls, needs IOS_APP)
+#   full  + remove and reinstall (permissions too)          ~5–30s  (needs APP_APK / IOS_APP)
+# ⚠ data and full WIPE APP DATA on the target device — emulator / dedicated test device only.
+# SUNGEN_RESET_TIER=data
+
 # ════════════ Appium server security (opt-in) ════════════
 # Allow `mobile: shell` (raw adb passthrough) for device-level oracles (e.g. pulling an app's
 # SQLite DB via run-as). Starts the server with --allow-insecure=uiautomator2:adb_shell.

package/dist/orchestrator/templates/specs-api.d.ts

@@ -40,12 +40,13 @@ declare class ApiClient {
         method: string;
         path: string;
         body?: unknown;
-        encoding?: 'json' | 'form' | 'multipart';
+        encoding?: 'json' | 'form' | 'multipart' | 'xml';
         files?: Record<string, FileSpec | FileSpec[]>;
         bodyFile?: FileSpec;
         headers?: Record<string, string>;
         timeout?: number;
         datasource?: string;
+        arrayPaths?: string[];
     }, params?: Record<string, any>, opts?: {
         storageState?: string;
     }): Promise<{
@@ -65,12 +66,13 @@ declare class ApiClient {
         method: string;
         path: string;
         body?: unknown;
-        encoding?: 'json' | 'form' | 'multipart';
+        encoding?: 'json' | 'form' | 'multipart' | 'xml';
         files?: Record<string, FileSpec | FileSpec[]>;
         bodyFile?: FileSpec;
         headers?: Record<string, string>;
         timeout?: number;
         datasource?: string;
+        arrayPaths?: string[];
     }, params?: Record<string, any>, n?: number, opts?: {
         storageState?: string;
     }): Promise<{

package/dist/orchestrator/templates/specs-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"specs-api.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/templates/specs-api.ts"],"names":[],"mappings":"AA8GA,yFAAyF;AACzF,KAAK,QAAQ,GAAG,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAO/F,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AACD,oFAAoF;AACpF,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAM/D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAAC,EAC5C,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,KAAK,EAAE,MAAM,GACZ,QAAQ,CAsBV;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAGhE;AAED,cAAM,SAAS;IACb,OAAO,CAAC,OAAO,CAA8C;IAE7D,OAAO,CAAC,GAAG;IAWX;;;;;OAKG;IACG,IAAI,CACR,KAAK,EAAE,MAAM,EACb,GAAG,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAAC,CAAC;QAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,EAC5O,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,EAChC,IAAI,GAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAO,GACnC,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAC;IAiGvF;;;;;;OAMG;IACG,KAAK,CACT,KAAK,EAAE,MAAM,EACb,GAAG,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAAC,CAAC;QAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,EAC5O,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,EAChC,CAAC,SAAI,EACL,IAAI,GAAE;QAAE,YAAY,CAAC,EAAE,MAAM,CAAA;KAAO,GACnC,OAAO,CAAC;QACT,SAAS,EAAE,KAAK,CAAC;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,EAAE,EAAE,OAAO,CAAC;YAAC,IAAI,EAAE,GAAG,CAAC;YAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;SAAE,CAAC,CAAC;QAC9F,QAAQ,EAAE,MAAM,CAAC;QACjB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACtC,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;IAaF;;;;;OAKG;IACH,YAAY,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;CAGlF;AA2CD,eAAO,MAAM,GAAG,WAAkB,CAAC"}
+{"version":3,"file":"specs-api.d.ts","sourceRoot":"","sources":["../../../src/orchestrator/templates/specs-api.ts"],"names":[],"mappings":"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"}