@hover-dev/core 0.15.0 → 0.17.0

package/dist/specs/sidecar.js

@@ -1,29 +1,62 @@
 /**
  * Structured-session sidecar for a generated spec.
  *
- * Every saved spec gets a companion `__vibe_tests__/.hover/<slug>.json` holding
+ * Every saved spec gets a companion `.hover/sidecars/<slug>.json` holding
  * the original structured `SpecStep[]` (plus assertions + metadata). The
  * `.spec.ts` is the human / CI artifact; this sidecar is the machine record
  * that downstream work reads instead of parsing generated code:
  *   - F4 cross-session extraction signature-matches `steps` across sidecars.
  *   - F7 optimization pass feeds the draft + this sidecar to the LLM.
  *
- * It lands in a dot-prefixed `.hover/` dir so Playwright's default `*.spec.ts`
- * glob never collects it, and it is pure data — no Hover runtime import.
+ * Home is the project-root `.hover/` directory (the same home as
+ * `.hover/conventions.md`) — Hover-derived data lives outside
+ * `__vibe_tests__/`, which stays 100% user-owned Playwright code. Sidecars
+ * historically lived nested at `__vibe_tests__/.hover/<slug>.json`; readers
+ * fall back to that legacy path and lazily copy-forward, so pre-existing
+ * projects keep working without a migration step.
  */
-import { mkdir, writeFile } from 'node:fs/promises';
+import { mkdir, writeFile, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 /** Current sidecar schema version. Bump when the shape changes so readers
  *  (Stage 2 detection, Stage 7 optimization) can migrate or skip cleanly. */
 export const SIDECAR_VERSION = 1;
-/** Sidecar directory under the spec output dir. Dot-prefixed on purpose:
- *  Playwright's default `*.spec.ts` glob never reaches into `.hover/`. */
+/** Project-root `.hover/` directory — the single home for Hover-derived data
+ *  (sidecars, runs, rules, conventions). */
+export function hoverDir(devRoot) {
+    return join(devRoot, '.hover');
+}
+/** Sanitize an id segment for use as a directory name (conversation / run id). */
+export function safeSeg(s) {
+    return (s || '').replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 80) || 'unknown';
+}
+/** Per-run home: `<devRoot>/.hover/conversations/<conversationId>/<runId>/`.
+ *  Everything a single agent run produces — meta.json (the ledger record),
+ *  report.md (QA), screenshots/ — lives here, grouped under its conversation so
+ *  deleting a conversation is one `rm -rf .hover/conversations/<conversationId>`.
+ *  (Distinct from `.hover/runs/`, which is the Playwright spec-run-results
+ *  ledger written by ▶ Run.) */
+export function conversationsDir(devRoot) {
+    return join(hoverDir(devRoot), 'conversations');
+}
+export function conversationDir(devRoot, conversationId) {
+    return join(conversationsDir(devRoot), safeSeg(conversationId));
+}
+export function runDir(devRoot, conversationId, runId) {
+    return join(conversationDir(devRoot, conversationId), safeSeg(runId));
+}
+/** Sidecar directory: `<devRoot>/.hover/sidecars`. Outside `__vibe_tests__/`,
+ *  so Playwright's default `*.spec.ts` glob trivially never reaches it. */
 export function sidecarDir(devRoot) {
+    return join(hoverDir(devRoot), 'sidecars');
+}
+/** Pre-relocation sidecar home (`__vibe_tests__/.hover/`). Read-only fallback;
+ *  nothing writes here anymore. */
+export function legacySidecarDir(devRoot) {
     return join(devRoot, '__vibe_tests__', '.hover');
 }
-/** Write the structured-session sidecar at `.hover/<slug>.json`. Caller passes
- *  the data minus the stamped fields (`version`, `createdAt`), which this
- *  function fills. Returns the absolute path written. */
+/** Write the structured-session sidecar at `.hover/sidecars/<slug>.json`.
+ *  Caller passes the data minus the stamped fields (`version`, `createdAt`),
+ *  which this function fills. Returns the absolute path written. */
 export async function writeSidecar(devRoot, data) {
     const dir = sidecarDir(devRoot);
     await mkdir(dir, { recursive: true });
@@ -36,3 +69,40 @@ export async function writeSidecar(devRoot, data) {
     await writeFile(path, JSON.stringify(sidecar, null, 2) + '\n', 'utf-8');
     return path;
 }
+/**
+ * Read one sidecar by slug, with legacy fallback + lazy copy-forward: when a
+ * sidecar only exists at the pre-relocation `__vibe_tests__/.hover/` path it
+ * is parsed from there and best-effort re-written into `.hover/sidecars/` so
+ * the next read hits the new home. Returns `null` when absent or malformed.
+ */
+export async function readSidecar(devRoot, slug) {
+    const current = await parseSidecarFile(join(sidecarDir(devRoot), `${slug}.json`));
+    if (current)
+        return current;
+    const legacy = await parseSidecarFile(join(legacySidecarDir(devRoot), `${slug}.json`));
+    if (legacy) {
+        // Copy-forward, best effort — a read must never fail because the
+        // migration write did.
+        try {
+            const dir = sidecarDir(devRoot);
+            await mkdir(dir, { recursive: true });
+            await writeFile(join(dir, `${slug}.json`), JSON.stringify(legacy, null, 2) + '\n', 'utf-8');
+        }
+        catch {
+            /* leave it in the legacy home */
+        }
+    }
+    return legacy;
+}
+/** Parse one sidecar file, or `null` when absent / not JSON. Deliberately
+ *  lenient on shape (an empty `{}` still counts as "a sidecar exists") —
+ *  consumers that need `steps`/`slug` filter for themselves. */
+export async function parseSidecarFile(path) {
+    try {
+        const sc = JSON.parse(await readFile(path, 'utf-8'));
+        return sc && typeof sc === 'object' ? sc : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/specs/softBatch.d.ts

@@ -0,0 +1,14 @@
+/** A trailing run with fewer than this many assertions is left alone —
+ *  `expect.soft` only earns its keep when ≥2 failures could be collected. */
+export declare const MIN_RUN = 2;
+export interface SoftBatchResult {
+    /** The (possibly) rewritten source. */
+    code: string;
+    /** Whether anything changed. */
+    changed: boolean;
+    /** How many assertions were softened across all tests. */
+    softened: number;
+}
+/** Run the soft-batch step over a spec's source text. Pure: text in, text out. */
+export declare function softBatch(source: string): SoftBatchResult;
+//# sourceMappingURL=softBatch.d.ts.map

package/dist/specs/softBatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"softBatch.d.ts","sourceRoot":"","sources":["../../src/specs/softBatch.ts"],"names":[],"mappings":"AAgCA;6EAC6E;AAC7E,eAAO,MAAM,OAAO,IAAI,CAAC;AAEzB,MAAM,WAAW,eAAe;IAC9B,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,kFAAkF;AAClF,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAuBzD"}

package/dist/specs/softBatch.js

@@ -0,0 +1,177 @@
+/**
+ * soft-batch — a deterministic finishing step of the optimization pass.
+ *
+ * After the LLM optimize pass decides WHAT to assert (it reads the observed
+ * feedback and adds the trailing "Then" assertions), this step applies the safe
+ * mechanical rewrite: the maximal *trailing run* of independent assertions in
+ * each `test()` body goes from `expect(...)` to `expect.soft(...)`, so a
+ * field-audit spec reports every failing field in one run instead of halting on
+ * the first. This is the "LLM decides, AST executes" split — the LLM never
+ * reprints the file to do it, so it can't drift; ts-morph applies the soften
+ * surgically and every untouched node stays byte-identical.
+ *
+ * Two assertion shapes are recognised, because that is what specs look like
+ * after optimize:
+ *   A. a bare `await expect(...)....` statement;
+ *   B. a Hover `await test.step('Then · …', async () => { await expect(...) })`
+ *      closure whose body is nothing but assertions — Hover emits one such step
+ *      per observed-feedback assertion, AFTER all the action steps.
+ *
+ * Safety guard (why this is deterministic and never changes test semantics):
+ * we only ever soften an assertion that sits in the trailing run — the suffix
+ * of the test body that is assertions all the way down, with no action after
+ * it. A *gating* assertion — one a later action depends on — is by construction
+ * followed by that action, so it never lands in the trailing run and is never
+ * softened. Softening only changes how failures are *reported* (all collected
+ * vs. stop-on-first), never whether the test passes. We require ≥2 assertions
+ * in the run: soft buys nothing for a single one. `expect.soft` collects across
+ * the whole test regardless of `test.step` nesting, so softening step-wrapped
+ * assertions is sound.
+ */
+import { Project, SyntaxKind, Node } from 'ts-morph';
+/** A trailing run with fewer than this many assertions is left alone —
+ *  `expect.soft` only earns its keep when ≥2 failures could be collected. */
+export const MIN_RUN = 2;
+/** Run the soft-batch step over a spec's source text. Pure: text in, text out. */
+export function softBatch(source) {
+    const project = new Project({
+        useInMemoryFileSystem: true,
+        compilerOptions: { allowJs: true },
+    });
+    const sf = project.createSourceFile('__spec.ts', source, { overwrite: true });
+    // Collect every assertion to soften first (across all test bodies), then
+    // apply — each edit is a localized identifier replace, so sibling targets
+    // stay valid.
+    const targets = [];
+    for (const body of testBodies(sf)) {
+        const run = trailingAssertionRun(body.getStatements());
+        const asserts = run.flatMap(bareAssertionsIn);
+        if (asserts.length >= MIN_RUN)
+            targets.push(...asserts);
+    }
+    let softened = 0;
+    for (const stmt of targets) {
+        if (soften(stmt))
+            softened++;
+    }
+    return { code: sf.getFullText(), changed: softened > 0, softened };
+}
+/**
+ * Yield the block body of every `test(...)` call (including `test.only` /
+ * `.skip` / `.fixme`), but NOT `test.describe` / hooks — those wrap tests, they
+ * aren't a test body.
+ */
+function testBodies(sf) {
+    const bodies = [];
+    for (const call of sf.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        if (!isTestCall(call.getExpression()))
+            continue;
+        const cb = call.getArguments().at(-1);
+        if (!cb)
+            continue;
+        if (Node.isArrowFunction(cb) || Node.isFunctionExpression(cb)) {
+            const block = cb.getBody();
+            if (Node.isBlock(block))
+                bodies.push(block);
+        }
+    }
+    return bodies;
+}
+/** `test` | `test.only` | `test.skip` | `test.fixme` — not `test.describe` or hooks. */
+function isTestCall(callee) {
+    if (Node.isIdentifier(callee))
+        return callee.getText() === 'test';
+    if (Node.isPropertyAccessExpression(callee)) {
+        const base = callee.getExpression();
+        if (!Node.isIdentifier(base) || base.getText() !== 'test')
+            return false;
+        return ['only', 'skip', 'fixme'].includes(callee.getName());
+    }
+    return false;
+}
+/** The longest suffix of `statements` that are all assertion units (a bare
+ *  assertion, or a `test.step` whose body is only assertions). */
+function trailingAssertionRun(statements) {
+    const run = [];
+    for (let i = statements.length - 1; i >= 0; i--) {
+        if (!isAssertionUnit(statements[i]))
+            break;
+        run.unshift(statements[i]);
+    }
+    return run;
+}
+/** A statement that contributes only assertions: a bare assertion (case A) or
+ *  an assertion-only `test.step` closure (case B). */
+function isAssertionUnit(stmt) {
+    return isBareAssertion(stmt) || bareAssertionsInStep(stmt) !== null;
+}
+/** The bare-assertion statements a unit contains: itself (case A) or the
+ *  assertions inside its `test.step` closure (case B). */
+function bareAssertionsIn(stmt) {
+    if (isBareAssertion(stmt))
+        return [stmt];
+    return bareAssertionsInStep(stmt) ?? [];
+}
+/** True if the statement is `(await) expect(...)....` — its call chain bottoms
+ *  out at an `expect` identifier. */
+function isBareAssertion(stmt) {
+    if (!Node.isExpressionStatement(stmt))
+        return false;
+    let expr = stmt.getExpression();
+    if (Node.isAwaitExpression(expr))
+        expr = expr.getExpression();
+    return leftmostBase(expr) === 'expect';
+}
+/**
+ * If `stmt` is `await test.step(label, async () => { …only assertions… })`,
+ * return those inner assertion statements; otherwise null. The closure body
+ * must be non-empty and contain ONLY bare assertions — a step that also acts
+ * (a "When" with a check) is not a pure assertion unit and is left alone.
+ */
+function bareAssertionsInStep(stmt) {
+    if (!Node.isExpressionStatement(stmt))
+        return null;
+    let expr = stmt.getExpression();
+    if (Node.isAwaitExpression(expr))
+        expr = expr.getExpression();
+    if (!Node.isCallExpression(expr))
+        return null;
+    const callee = expr.getExpression();
+    if (!Node.isPropertyAccessExpression(callee) ||
+        callee.getName() !== 'step' ||
+        callee.getExpression().getText() !== 'test') {
+        return null;
+    }
+    const cb = expr.getArguments().at(-1);
+    if (!cb || !(Node.isArrowFunction(cb) || Node.isFunctionExpression(cb)))
+        return null;
+    const block = cb.getBody();
+    if (!Node.isBlock(block))
+        return null;
+    const inner = block.getStatements();
+    if (inner.length === 0 || !inner.every(isBareAssertion))
+        return null;
+    return inner;
+}
+/** Descend a call/member chain to its leftmost identifier, e.g.
+ *  `expect(x).toHaveText(y)` → "expect", `page.goto('/')` → "page". */
+function leftmostBase(node) {
+    let cur = node;
+    while (cur && (Node.isCallExpression(cur) || Node.isPropertyAccessExpression(cur))) {
+        cur = cur.getExpression();
+    }
+    return cur && Node.isIdentifier(cur) ? cur.getText() : null;
+}
+/** Rewrite the `expect(` call inside a bare assertion statement to
+ *  `expect.soft(`. Skips ones already soft (their callee is `expect.soft`, not
+ *  the bare identifier `expect`). Returns whether a change was made. */
+function soften(stmt) {
+    for (const call of stmt.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        const callee = call.getExpression();
+        if (Node.isIdentifier(callee) && callee.getText() === 'expect') {
+            callee.replaceWithText('expect.soft');
+            return true;
+        }
+    }
+    return false;
+}

package/dist/specs/specStep.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The serialized captured-step shape the whole spec pipeline (writeSpec,
+ * sidecar, Page-Object extraction, the session record) consumes.
+ *
+ * One entry per recorded chat message: a user prompt, an agent narration, a
+ * `browser_*` / control-MCP tool call (`step`), or the terminal `done` summary.
+ * (Formerly `SkillStep` in specs/specStep.ts, back when a run could be saved
+ * as a `.claude/skills/<slug>/SKILL.md` — that feature was retired; only the
+ * type survived, now relocated here.)
+ */
+export interface SkillStep {
+    kind: 'user' | 'system' | 'step' | 'ai' | 'done';
+    text?: string;
+    tool?: string;
+    input?: unknown;
+    isError?: boolean;
+    turns?: number;
+    costUsd?: number;
+    summary?: string;
+}
+//# sourceMappingURL=specStep.d.ts.map

package/dist/specs/specStep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specStep.d.ts","sourceRoot":"","sources":["../../src/specs/specStep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,CAAC;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}

package/dist/specs/specStep.js

@@ -0,0 +1 @@
+export {};

package/dist/specs/text.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Small text helpers for the spec emitter.
+ *
+ * Hoisted here so writeSpec's JSDoc header derives a slug and a one-sentence
+ * "Expected" line through one shared implementation.
+ */
+/** Lowercase, hyphenate, and trim a display name into a filesystem-safe slug. */
+export declare function slugify(name: string): string;
+/**
+ * The first sentence of a done-summary, trimmed. Agents sometimes ramble; the
+ * Expected blocks only want the leading sentence. Splits on the gap that
+ * follows sentence-ending punctuation — Latin (`.`, `!`, `?`) AND CJK
+ * (`。`, `！`, `？`) so a Chinese summary doesn't dump its whole multi-line body
+ * (which then broke the JSDoc block). Also cuts at the first hard line break, so
+ * a summary that runs straight into a `\n\n- bullet` list keeps only the lead
+ * sentence. A summary with no such break comes back trimmed in full.
+ */
+export declare function firstSentence(summary: string): string;
+//# sourceMappingURL=text.d.ts.map

package/dist/specs/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/specs/text.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,iFAAiF;AACjF,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM5C;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAGrD"}

package/dist/specs/text.js

@@ -0,0 +1,27 @@
+/**
+ * Small text helpers for the spec emitter.
+ *
+ * Hoisted here so writeSpec's JSDoc header derives a slug and a one-sentence
+ * "Expected" line through one shared implementation.
+ */
+/** Lowercase, hyphenate, and trim a display name into a filesystem-safe slug. */
+export function slugify(name) {
+    return name
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/**
+ * The first sentence of a done-summary, trimmed. Agents sometimes ramble; the
+ * Expected blocks only want the leading sentence. Splits on the gap that
+ * follows sentence-ending punctuation — Latin (`.`, `!`, `?`) AND CJK
+ * (`。`, `！`, `？`) so a Chinese summary doesn't dump its whole multi-line body
+ * (which then broke the JSDoc block). Also cuts at the first hard line break, so
+ * a summary that runs straight into a `\n\n- bullet` list keeps only the lead
+ * sentence. A summary with no such break comes back trimmed in full.
+ */
+export function firstSentence(summary) {
+    const bySentence = summary.split(/(?<=[.!?。！？])\s+/)[0] ?? summary;
+    return bySentence.split(/\n/)[0]?.trim() ?? summary.trim();
+}

package/dist/specs/writeSpec.d.ts

@@ -1,4 +1,4 @@
-import type { SkillStep } from '../skills/writeSkill.js';
+import type { SkillStep } from '../specs/specStep.js';
 export type SpecStep = SkillStep;
 /**
  * Marker the deterministic translator leaves where a captured action is a real
@@ -24,6 +24,18 @@ export declare class SpecExistsError extends Error {
     readonly path: string;
     constructor(slug: string, path: string);
 }
+/**
+ * A credential to keep out of the generated spec. The deterministic translator
+ * replaces any fill value that exactly equals `value` with a
+ * `process.env.<envVar>` reference — so the literal password/username never
+ * lands in the spec source, the JSDoc header, OR the `.hover/` sidecar. The
+ * value comes from the caller (the editor resolves an `@account` mention from
+ * its vault); core only uses it to match-and-replace, never to write.
+ */
+export interface Redaction {
+    value: string;
+    envVar: string;
+}
 export interface WriteSpecOptions {
     devRoot: string;
     name: string;
@@ -31,10 +43,51 @@ export interface WriteSpecOptions {
     steps: SpecStep[];
     assertions?: SpecAssertion[];
     overwrite?: boolean;
+    /** Credentials to parameterize into `process.env.<envVar>` references. */
+    redactions?: Redaction[];
+    /** The run's target URL (the active environment / dev origin). Used to
+     *  guarantee the spec opens the app: if the captured session has NO
+     *  navigation (the agent connected to an already-open tab and never called
+     *  browser_navigate), a leading `page.goto()` is synthesized from this, and
+     *  it's the fallback origin for the scaffolded playwright config. */
+    startUrl?: string;
+    /** Recon-discovered reset recipe for the run's environment (debt-2 reproducible
+     *  state isolation). When tier 1, a shared `support/resetState.ts` helper is
+     *  generated and called in a `beforeEach` so the spec re-enters from a clean
+     *  client state every run. Tier 2/3 (backend-state) emit no reset here. (Engine
+     *  shape, decoupled from the extension's ResetRecipe — only tier/keys matter.) */
+    resetRecipe?: {
+        tier: number;
+        storageKeys?: string[];
+        hook?: string;
+    };
+    /** Auth-as-fixture (debt 3): engage the fixture EVEN WHEN a user playwright.config
+     *  already exists — i.e. the user approved Hover editing their config (Stage 4).
+     *  Without it, an existing config keeps login inline (Hover never edits a user's
+     *  config unprompted). When true, writeSpec also applies the setup-project edit
+     *  to the config. No effect when no login prefix is detected. */
+    authFixture?: boolean;
 }
 export interface WriteSpecResult {
+    /** Primary written file (the first flow when split, else the single spec). */
     path: string;
     slug: string;
+    /** Every file written — one per `mark_flow` feature when the run was split. */
+    files: {
+        path: string;
+        slug: string;
+        flow: string;
+    }[];
+    /** Auth-as-fixture (debt 3, Stage 4): a login was detected but a USER
+     *  playwright.config already exists, so Hover left login inline rather than
+     *  edit their config unprompted. This is the proposed edit to offer for
+     *  approval — on approval the caller re-saves with `authFixture: true`, which
+     *  applies it. Absent when there's no login, no user config, or the config
+     *  can't be safely edited (already has `projects`). */
+    authFixtureOffer?: {
+        configPath: string;
+        proposedConfig: string;
+    };
 }
 export declare function writeSpec(opts: WriteSpecOptions): Promise<WriteSpecResult>;
 /**
@@ -68,6 +121,14 @@ export declare function blockScope(lines: string[]): string[];
  * trailing role keyword is the convention Playwright MCP uses.
  */
 export declare function selectorFromDescription(desc: string, pageVar?: string): string;
+/**
+ * browser_select_option always targets a native `<select>` — whose ARIA role
+ * is `combobox`. The agent's description is usually the label ("marital
+ * status"), with no role keyword, so selectorFromDescription would fall back to
+ * getByText and match the *label text*, not the control — and `.selectOption()`
+ * on a text node throws. Force the combobox role by accessible name instead.
+ */
+export declare function selectorForSelect(desc: string, pageVar?: string): string;
 /**
  * Form fields from browser_fill_form have a `name` that's typically the
  * accessible name / label / aria-label. getByLabel is the right primitive.

package/dist/specs/writeSpec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeSpec.d.ts","sourceRoot":"","sources":["../../src/specs/writeSpec.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAUzD,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC;AAEjC;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,yBAAyB,CAAC;AAEzD;;0DAE0D;AAC1D,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,MAAM,WAAW,aAAa;IAC5B,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,qBAAa,eAAgB,SAAQ,KAAK;aACZ,IAAI,EAAE,MAAM;aAAkB,IAAI,EAAE,MAAM;gBAA1C,IAAI,EAAE,MAAM,EAAkB,IAAI,EAAE,MAAM;CAIvE;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;IAC7B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAAG,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;CAAE;AAEhE,wBAAsB,SAAS,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CAiChF;AAgVD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAM9E;AAED;;oCAEoC;AACpC,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,SAAS,GAAG,MAAM,CAqB9E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,SAAS,GAAG,MAAM,CAQ1F"}
+{"version":3,"file":"writeSpec.d.ts","sourceRoot":"","sources":["../../src/specs/writeSpec.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAatD,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC;AAEjC;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,yBAAyB,CAAC;AAEzD;;0DAE0D;AAC1D,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE9D;AA2CD,MAAM,WAAW,aAAa;IAC5B,oEAAoE;IACpE,IAAI,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,qBAAa,eAAgB,SAAQ,KAAK;aACZ,IAAI,EAAE,MAAM;aAAkB,IAAI,EAAE,MAAM;gBAA1C,IAAI,EAAE,MAAM,EAAkB,IAAI,EAAE,MAAM;CAIvE;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;IAC7B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,0EAA0E;IAC1E,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;IACzB;;;;yEAIqE;IACrE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;sFAIkF;IAClF,WAAW,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE;;;;qEAIiE;IACjE,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAiDD,MAAM,WAAW,eAAe;IAC9B,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,+EAA+E;IAC/E,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACtD;;;;;2DAKuD;IACvD,gBAAgB,CAAC,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC;CACnE;AAQD,wBAAsB,SAAS,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC,CAchF;AA+mBD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAM9E;AAED;;oCAEoC;AACpC,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAEpD;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,SAAS,GAAG,MAAM,CAqB9E;AA0DD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,SAAS,GAAG,MAAM,CAMxE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,SAAS,GAAG,MAAM,CAQ1F"}