@platformos/platformos-mcp-supervisor 0.0.2 → 0.2.0

package/dist/result/types.d.ts

@@ -1,58 +1,104 @@
 /**
- * The `validate_code` result contract — the agent-facing surface of the
- * supervisor.
+ * The `validate_code` result contract — the agent-facing surface of the supervisor.
  *
- * This is intentionally separate from check-common's `Offense`: `Offense` is a
- * stable, minimal detection type consumed by editors/CLI/browser, whereas
- * `ValidateCodeResult` is an LLM-ergonomics surface that may churn as agent
- * behaviour is tuned. The `result/` layer assembles this shape from enriched
- * diagnostics + advisories via order-independent pure transforms.
+ * Deliberately separate from check-common's `Offense`, which is the stable, minimal
+ * detection type consumed by editors/CLI/browser. The `result/` layer assembles this
+ * shape from enriched diagnostics via order-independent pure transforms.
+ */
+/**
+ * The outcome of a `validate_code` call.
+ *
+ * `ok` / `warning` / `error` all mean "this file was checked" and differ only in what was
+ * found. `not_applicable` means the file was NOT checked (see `fileApplicability`), so it
+ * is neither an approval nor a reason to block: `must_fix_before_write` is always `false`
+ * for it and `next_step` carries the reason.
+ */
+export type ValidateCodeStatus = 'ok' | 'warning' | 'error' | 'not_applicable';
+/**
+ * WHY a file was not checked, as a machine-readable code an agent can branch on.
+ * Present exactly when `status` is `not_applicable`.
  *
- * Field names mirror the v1 supervisor so the parity safety net (TASK-8.5) can
- * compare unchanged-contract fields against the captured baselines. Fields
- * marked "TASK-8" are part of the contract but are only populated once the
- * supervisor's per-domain layer and rule library are restored; the minimal
- * TASK-7 build leaves them empty / null.
+ * - `outside_project`  — resolved outside the project root this server serves.
+ * - `unsupported_type` — inside the project, but nothing here parses it: an asset, or a
+ *                        file in no deployed subtree that is not a source anyway. ROUTINE —
+ *                        never advise moving it under `app/`.
+ * - `misplaced_source` — a platformOS SOURCE sitting outside every subtree the platform
+ *                        deploys, so it will never be loaded. Almost always a mistake, and
+ *                        the opposite advice from `unsupported_type`.
+ * - `too_large`        — buffer above the size bound; refused before parsing.
+ * - `timed_out`        — validation exceeded its deadline; nothing conclusive.
+ * - `ignored`          — excluded by the project's `.platformos-check.yml` `ignore` list,
+ *                        so no check ran.
+ * - `internal_error`   — the validator failed to produce a result. A bug here, not a
+ *                        property of the file, and not something a retry can fix.
  */
-export type ValidateCodeMode = 'full' | 'quick';
-export type ValidateCodeStatus = 'ok' | 'warning' | 'error';
+export type NotApplicableReason = 'outside_project' | 'unsupported_type' | 'misplaced_source' | 'too_large' | 'timed_out' | 'ignored' | 'internal_error';
+/**
+ * A refusal to validate: agent-facing prose plus its machine-readable cause.
+ *
+ * `reason` becomes the result's `next_step`; `code` becomes `not_applicable_reason`.
+ */
+export interface Declined {
+    reason: string;
+    code: NotApplicableReason;
+}
 export type ValidateCodeSeverity = 'error' | 'warning' | 'info';
-/** Tool input. */
+/**
+ * Tool input. Exactly ONE of the two forms:
+ *
+ *   - `file_path` + `content` — a single file.
+ *   - `files` — several files validated TOGETHER, so they can reference each other.
+ *
+ * Both are optional here because the "exactly one" rule is enforced by the handler; a zod
+ * union would emit `anyOf`, which several MCP clients do not surface.
+ */
 export interface ValidateCodeParams {
-    /** Path of the file under edit (absolute, or relative to the project root). */
-    file_path: string;
-    /** The file contents to validate (the in-memory buffer). */
-    content: string;
-    /** Depth of analysis. Defaults to `full`. */
-    mode?: ValidateCodeMode;
+    /** Path of the single file under edit (absolute, or relative to the project root). */
+    file_path?: string;
+    /** The single file's contents (the in-memory buffer). */
+    content?: string;
+    /** Several files under edit, validated together. */
+    files?: Array<{
+        file_path: string;
+        content: string;
+    }>;
 }
 /**
- * An agent-facing fix. Translated from a check-common `FixDescription` (the
- * structured edits the engine already computed); the supervisor never
- * regenerates edit text from scratch.
+ * One replacement in the buffer, translated verbatim from a check-common
+ * `FixDescription`. The supervisor never authors edit text.
  *
- * - `text_edit` — replace `[start_index, end_index)` with `new_text`.
- * - `insert`    — insert `new_text` at `start_index` (`end_index === start_index`).
- * - `guidance`  — prose only; no machine-applicable edit.
+ * Offsets are 0-based indices into the buffer AS SENT — not the 1-based line/column the
+ * diagnostic carries.
  */
-export type AgentFix = {
-    type: 'text_edit' | 'insert';
-    description?: string;
-    /** 0-based offset into the file. */
+export interface AgentEdit {
+    /** 0-based offset into the buffer, INCLUSIVE. */
     start_index: number;
-    /** 0-based offset into the file. */
+    /** 0-based offset into the buffer, EXCLUSIVE. Equal to `start_index` for an insertion. */
     end_index: number;
+    /** Replacement text for the range. Empty string to delete. */
     new_text: string;
-} | {
-    type: 'guidance';
-    description: string;
-};
+}
 /**
- * A diagnostic as surfaced to the agent. Carries the structured check-common
- * fields (`check`, `severity`, range, `message`) plus the supervisor's
- * ergonomic enrichment (`hint`, `suggestion`, `confidence`, `fix`, `see_also`).
- * Line/column are 1-based (converted from check-common's 0-based offsets in the
- * `result/` layer).
+ * An agent-facing fix: prose plus the edits that apply it.
+ *
+ * Every edit is relative to the buffer as sent, so applying more than one requires
+ * accounting for index drift — or simply applying them from the end backwards.
+ */
+export interface AgentFix {
+    /**
+     * What the fix does. Present for a suggestion (the engine's own `Suggestion.message`);
+     * absent for a plain autofix, which the engine describes only through the message.
+     */
+    description?: string;
+    /** The edits, in the order the engine recorded them. Never empty. */
+    edits: AgentEdit[];
+}
+/**
+ * A diagnostic as surfaced to the agent: the structured check-common fields (`check`,
+ * `severity`, range, `message`) plus the supervisor's ergonomic enrichment (`hint`,
+ * `suggestions`, `fix`, `see_also`).
+ *
+ * Line/column are 1-based (converted from check-common's 0-based offsets in `result/`).
  */
 export interface ValidateCodeDiagnostic {
     /** The check code, e.g. `MissingPartial`, or a `pos-supervisor:` advisory code. */
@@ -69,87 +115,149 @@ export interface ValidateCodeDiagnostic {
     end_column?: number;
     /** Markdown explanation for the agent. */
     hint?: string;
-    /** A short, one-line "did you mean / use this" pointer. */
-    suggestion?: string;
-    /** Static confidence in [0, 1] that this diagnostic + its fix are correct. */
-    confidence?: number;
-    /** A single concrete fix for this diagnostic, when one is available. */
+    /**
+     * Fixes the engine offers as OPTIONS rather than as the answer — `Offense.suggest`.
+     *
+     * Kept separate from {@link fix} because an agent must act on them differently: `fix` is
+     * safe to apply unread, a suggestion is a choice. Absent when the engine offered none.
+     */
+    suggestions?: AgentFix[];
+    /**
+     * The engine's safe auto-fix for this diagnostic, when it has one — `Offense.fix`.
+     * Distinct from {@link suggestions}: this one is the answer, not a menu.
+     */
     fix?: AgentFix;
-    /** A pointer to another supervisor tool / doc that helps resolve this. */
-    see_also?: SeeAlso;
-}
-export interface SeeAlso {
-    tool?: string;
-    args?: Record<string, unknown>;
-    reason?: string;
+    /**
+     * URL of this check's documentation page, from check-common `meta.docs.url`. Absent for
+     * checks whose meta publishes none, rather than a guessed URL that 404s.
+     */
+    see_also?: string;
 }
 /**
- * A proposed fix shown to the agent at the top level of the result. Carries the
- * originating `check` so the agent can correlate it with a diagnostic.
+ * Whether the cross-file comparison ran. `computed` means this file's dependants were linted
+ * with the change applied and without it; `unavailable` means that could not be done (a
+ * failure, or the deadline); `not_applicable` means the file has no dependants this stage
+ * can find — the graph holds no edges pointing at it, or it has no logical name.
+ *
+ * `disabled` means this SERVER was started with cross-file impact turned off (`--no-impact`),
+ * so nothing was attempted and retrying will not change that — which is the whole reason it
+ * is not folded into `unavailable`.
+ *
+ * NONE OF THE FOUR IS A CLEARANCE, including `computed`. See {@link ValidateCodeImpact}.
  */
-export type ProposedFix = AgentFix & {
-    check?: string | null;
-};
-/** A group of related diagnostics sharing a root cause, with a unified remedy. */
-export interface DiagnosticCluster {
-    check: string;
-    count: number;
-    unified_fix?: string;
-}
-/** An advisory note about the file's architecture (doc-block coverage, layout correctness, …). */
-export interface ScorecardNote {
-    category: string;
-    status: 'ok' | 'warning' | 'info';
-    reason: string;
-}
-export interface TipEntry {
-    id: string;
-    severity: string;
-    message: string;
+export type ValidateCodeImpactStatus = 'computed' | 'unavailable' | 'not_applicable' | 'disabled';
+/**
+ * What this change BREAKS in files the request is not editing — the question lint cannot
+ * answer, being per-file and forward-looking. Derived per request by linting the edited
+ * file's dependants twice, with the changeset applied and without it, and reporting only the
+ * difference. The findings are the check engine's own, so they carry its message, severity
+ * and documentation link rather than a second opinion invented here.
+ *
+ * IT DOES NOT ANSWER "WHO DEPENDS ON THIS FILE", and never will: `{% render var %}` names its
+ * target at runtime, so no static analysis can enumerate a file's dependants, and a count
+ * that omits the ones it cannot see reads as a licence to delete. Only findings are
+ * published; their absence claims nothing.
+ */
+export interface ValidateCodeImpact {
+    status: ValidateCodeImpactStatus;
+    /**
+     * Files the change broke, each with the findings it GAINED. A finding already present
+     * before the change is not reported, however severe: it is not this edit's doing.
+     *
+     * PRESENT ONLY WHEN NON-EMPTY, and absence is not a clearance — it means no break was
+     * found among the dependants that are visible, which is not the same as none existing.
+     */
+    breaks?: ValidateCodeImpactBreak[];
+    /**
+     * Present only when more dependants were found than the bound allows: `returned` were
+     * linted, `total` were found.
+     *
+     * NOT the same kind of truncation as the result-level `truncated`, which withholds
+     * findings that WERE computed. The difference here was never checked at all, so an
+     * otherwise-clean answer carrying this field is a PARTIAL one.
+     */
+    unchecked_dependants?: ValidateCodeBucketTruncation;
 }
-export interface DomainGuideGotcha {
-    id: string;
-    message: string;
-    severity: string;
-    applies_to_errors?: string[];
+/** One file the change broke, and what it broke in it. */
+export interface ValidateCodeImpactBreak {
+    /** The broken file, project-relative. NOT a file the request asked about. */
+    file: string;
+    /** The findings this change introduced there, in reading order. */
+    diagnostics: ValidateCodeDiagnostic[];
 }
-export interface DomainGuide {
-    domain: string;
-    rule?: string;
-    triggered_gotchas: DomainGuideGotcha[];
+/** How many entries of one bucket were returned, against how many were found. */
+export interface ValidateCodeBucketTruncation {
+    /** Entries present in this result's list. */
+    returned: number;
+    /** Entries the checks actually produced. Always greater than `returned`. */
+    total: number;
 }
-export interface ValidateCodeStructuralSnapshot {
-    renders_used: string[];
-    filters_used: string[];
-    tags_used: string[];
-    translation_keys: string[];
-    doc_params: string[];
-    slug: string | null;
-    layout: string | null;
-    method: string | null;
+/**
+ * Present exactly when findings were withheld to keep the response bounded; ABSENT means
+ * the lists are complete. Only the affected buckets appear.
+ */
+export interface ValidateCodeTruncation {
+    errors?: ValidateCodeBucketTruncation;
+    warnings?: ValidateCodeBucketTruncation;
+    infos?: ValidateCodeBucketTruncation;
+    /** Plain-language statement of what was withheld and what is still true. */
+    note: string;
 }
 /**
- * The full `validate_code` result. Serialized as a single JSON text block over
- * the MCP stdio transport.
+ * The full `validate_code` result. Serialized as a single JSON text block over the MCP
+ * stdio transport.
  */
 export interface ValidateCodeResult {
     status: ValidateCodeStatus;
     /**
-     * When true the agent MUST NOT write the file. Set by any error or any
-     * "blocking" warning (the blocking set is defined explicitly in `result/`).
+     * When true the agent MUST NOT write the file. Set by any error or any "blocking"
+     * warning (the blocking set is defined explicitly in `result/`).
      */
     must_fix_before_write: boolean;
     errors: ValidateCodeDiagnostic[];
     warnings: ValidateCodeDiagnostic[];
     infos: ValidateCodeDiagnostic[];
-    proposed_fixes: ProposedFix[];
-    clusters: DiagnosticCluster[];
-    scorecard: ScorecardNote[];
+    /**
+     * Cross-file consequence of the edit: what it breaks in files you are not editing.
+     * Always present, and never a clearance. See {@link ValidateCodeImpact}.
+     */
+    impact: ValidateCodeImpact;
     /** Deterministic prose telling the agent what to do next. */
     next_step?: string;
-    /** Parse-failure message when the file could not be parsed at all; null/absent otherwise. */
-    parse_error?: string | null;
-    tips?: TipEntry[];
-    domain_guide?: DomainGuide | null;
-    structural?: ValidateCodeStructuralSnapshot | null;
+    /**
+     * Machine-readable cause when `status` is `not_applicable`; absent otherwise.
+     * See {@link NotApplicableReason}.
+     */
+    not_applicable_reason?: NotApplicableReason;
+    /**
+     * Present only when the response bound withheld findings. `status` and
+     * `must_fix_before_write` are computed from the COMPLETE set of findings, before
+     * anything is withheld. See {@link ValidateCodeTruncation}.
+     */
+    truncated?: ValidateCodeTruncation;
+}
+/** One file's outcome inside a multi-file {@link ValidateFilesResult}. */
+export interface ValidateFilesEntry {
+    /** The `file_path` exactly as the caller supplied it, so results are easy to match up. */
+    file_path: string;
+    result: ValidateCodeResult;
+}
+/**
+ * The multi-file result: one entry per requested file plus a request-level gate. Returned
+ * only for the `files` input form; the single form returns a bare
+ * {@link ValidateCodeResult}.
+ *
+ * A batch is NOT atomic. One declined or failing file never sinks the others, so `files`
+ * always has an entry for every requested path.
+ */
+export interface ValidateFilesResult {
+    /**
+     * True when ANY file blocks — an OR over the files' own gates, so a file that is merely
+     * `not_applicable` never blocks the set.
+     */
+    must_fix_before_write: boolean;
+    /** Per-file results, in the order requested. */
+    files: ValidateFilesEntry[];
+    /** Deterministic prose telling the agent what to do next across the whole batch. */
+    next_step?: string;
 }

package/dist/result/types.js

@@ -1,18 +1,9 @@
 /**
- * The `validate_code` result contract — the agent-facing surface of the
- * supervisor.
+ * The `validate_code` result contract — the agent-facing surface of the supervisor.
  *
- * This is intentionally separate from check-common's `Offense`: `Offense` is a
- * stable, minimal detection type consumed by editors/CLI/browser, whereas
- * `ValidateCodeResult` is an LLM-ergonomics surface that may churn as agent
- * behaviour is tuned. The `result/` layer assembles this shape from enriched
- * diagnostics + advisories via order-independent pure transforms.
- *
- * Field names mirror the v1 supervisor so the parity safety net (TASK-8.5) can
- * compare unchanged-contract fields against the captured baselines. Fields
- * marked "TASK-8" are part of the contract but are only populated once the
- * supervisor's per-domain layer and rule library are restored; the minimal
- * TASK-7 build leaves them empty / null.
+ * Deliberately separate from check-common's `Offense`, which is the stable, minimal
+ * detection type consumed by editors/CLI/browser. The `result/` layer assembles this
+ * shape from enriched diagnostics via order-independent pure transforms.
  */
 export {};
 //# sourceMappingURL=types.js.map

package/dist/transport/instructions-coverage.spec.d.ts

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

package/dist/transport/instructions-coverage.spec.js

@@ -0,0 +1,176 @@
+/**
+ * The safety net for what was DELETED from the server instructions.
+ *
+ * `SERVER_INSTRUCTIONS` used to enumerate platformOS semantics in English — that a JSON
+ * literal in `{% assign %}` needs double quotes, which subscript targets a write tag
+ * accepts, that a filter inside an `{% if %}` is rejected by the deploy converter. That
+ * prose was there for a reason: agents write those exact mistakes.
+ *
+ * Removing it is only safe if the mistakes are still CAUGHT, so each row below is a fixture
+ * built from a deleted claim, asserting the check that owns it fires. Otherwise the
+ * instructions get shorter and agents get worse.
+ *
+ * The two `[]` rows are DOCUMENTED SILENCES, which is the one claim no diagnostic can
+ * deliver — an agent cannot learn "we deliberately do not check this" from a finding that
+ * never appears. Those stayed in the prose; everything that fires did not.
+ *
+ * Run against the DEFAULT check set, which is what a project gets before it configures
+ * anything and therefore what these claims were promising.
+ */
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { runBatchLint } from '../lint/lint-batch.js';
+import { SERVER_INSTRUCTIONS } from './instructions.js';
+let projectDir;
+beforeAll(() => {
+    projectDir = mkdtempSync(join(tmpdir(), 'mcp-sup-claims-'));
+    mkdirSync(join(projectDir, '.git'));
+});
+afterAll(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+});
+/**
+ * One deleted claim: the pattern it warned about, and the checks that must still report
+ * it. Measured, not predicted — several of these are owned by a different check than the
+ * prose implied (a filter inside a condition is a PARSE error, not a filter check).
+ */
+const DELETED_CLAIMS = [
+    {
+        claim: 'a JSON literal in {% assign %} must use double quotes',
+        file: 'app/views/pages/json_quotes.liquid',
+        source: "{% assign o = {'k': 1} %}{{ o }}",
+        checks: ['JsonLiteralQuoteStyle'],
+    },
+    {
+        claim: 'a subscript write needs a Hash or an Array, not a number',
+        file: 'app/views/pages/write_target.liquid',
+        source: '{% assign n = 5 %}{% assign n["k"] = 1 %}{{ n }}',
+        checks: ['InvalidWriteTarget'],
+    },
+    {
+        claim: '{% assign x << v %} needs an Array; a Hash is refused',
+        file: 'app/views/pages/append_hash.liquid',
+        source: '{% assign h = {"a": 1} %}{% assign h << 2 %}{{ h }}',
+        checks: ['InvalidWriteTarget'],
+    },
+    {
+        claim: "hash_assign's target must end in a bracket",
+        file: 'app/views/pages/hash_assign_target.liquid',
+        source: '{% assign h = {"a": 1} %}{% hash_assign h.k = 2 %}{{ h }}',
+        // A PARSE error, not a write-target one: the grammar rejects the form outright.
+        checks: ['DeprecatedTag', 'LiquidHTMLSyntaxError'],
+    },
+    {
+        claim: 'a filter inside a condition is rejected by the converter',
+        file: 'app/views/pages/filter_in_if.liquid',
+        source: "{% assign a = 'x' %}{% if a | upcase == 'A' %}y{% endif %}",
+        checks: ['LiquidHTMLSyntaxError'],
+    },
+    {
+        claim: 'a filter on a {% for %} operand must be assigned first',
+        file: 'app/views/pages/filter_in_for.liquid',
+        source: '{% assign l = "a,b" | split: "," %}{% for x in l | reverse %}{{ x }}{% endfor %}',
+        checks: ['LiquidHTMLSyntaxError', 'UndefinedObject'],
+    },
+    {
+        claim: 'a filter elsewhere in a platformOS tag is silently ignored by the platform',
+        file: 'app/views/pages/filter_on_cache.liquid',
+        source: "{% cache 'k' | upcase %}x{% endcache %}",
+        checks: ['FilterWithoutEffect'],
+    },
+    {
+        claim: "{% for x in y limit: 'ten' %} warns on the argument type",
+        file: 'app/views/pages/tag_arg_type.liquid',
+        source: "{% for x in (1..3) limit: 'ten' %}{{ x }}{% endfor %}",
+        checks: ['ValidTagArgumentTypes'],
+    },
+    {
+        claim: 'a Hash filter given a number warns (a hard 500 at render time)',
+        file: 'app/views/pages/filter_arg_type.liquid',
+        source: "{{ 123 | hash_add_key: 'k', 1 }}",
+        checks: ['ValidFilterArgumentTypes'],
+    },
+    {
+        claim: 'a key defined twice in one YAML mapping is reported and does not block',
+        file: 'app/translations/dup.yml',
+        source: 'en:\n  a: 1\n  a: 2\n',
+        checks: ['DuplicateYAMLKey'],
+    },
+    {
+        claim: 'YAML 1.1 look-alikes (yes:/true:) are ONE key',
+        file: 'app/translations/lookalike.yml',
+        source: 'fr:\n  yes: 1\n  true: 2\n',
+        checks: ['DuplicateYAMLKey'],
+    },
+    {
+        claim: 'YAML that does not parse is reported and blocks',
+        file: 'app/schema/broken.yml',
+        source: 'a: [1, 2\n',
+        checks: ['YAMLSyntaxError'],
+    },
+];
+/** The claims that were KEPT, because nothing fires and so nothing else could say it. */
+const KEPT_SILENCES = [
+    {
+        claim: 'a core Liquid filter given an odd type coerces, and is never reported',
+        file: 'app/views/pages/core_filter.liquid',
+        source: '{{ 5 | upcase }}',
+    },
+    {
+        claim: 'the SHAPE of a model schema is not checked',
+        file: 'app/schema/shape.yml',
+        source: 'name: thing\nproperties:\n  - name: a\n    type: string\n    bogus: 1\n',
+    },
+    /**
+     * The half of duplicate-key detection that does NOT fire, and why the prose says the
+     * comparison is not exhaustive.
+     *
+     * `1:30` is a YAML 1.1 sexagesimal: Ruby's Psych resolves it to 5400, so these two keys
+     * are ONE key on the platform and the second value is discarded, while npm's `yaml` reads
+     * it as 90. The pair is one of the four named in check-common's
+     * `yaml/duplicate-keys.spec.ts`, which sweeps 5,476 token pairs against a live-Ruby oracle.
+     *
+     * Its control is the `yes:`/`true:` row above, which MUST fire.
+     */
+    {
+        claim: 'a YAML 1.1 sexagesimal colliding with its own value is NOT reported',
+        file: 'app/translations/sexagesimal.yml',
+        source: 'en:\n  1:30: a\n  5400: b\n',
+    },
+];
+const checksFor = async (file, source) => {
+    const { diagnostics } = await runBatchLint({
+        projectDir,
+        buffers: [{ filePath: file, content: source }],
+    });
+    return [...new Set((diagnostics.get(file) ?? []).map((d) => d.check))].sort();
+};
+describe('Every claim removed from the instructions is still caught by a check', () => {
+    it.each(DELETED_CLAIMS)('$claim', async ({ file, source, checks }) => {
+        expect(await checksFor(file, source)).toEqual([...checks].sort());
+    });
+});
+describe('The claims that were KEPT are the ones no diagnostic can deliver', () => {
+    it.each(KEPT_SILENCES)('$claim', async ({ file, source }) => {
+        // Nothing fires — which is exactly why the prose has to say it. This is the control
+        // for the group above: if these started reporting, the instructions would be claiming
+        // a silence that no longer exists.
+        expect(await checksFor(file, source)).toEqual([]);
+    });
+    it('and the instructions still state each of them', () => {
+        expect({
+            untypedArguments: SERVER_INSTRUCTIONS.includes('An argument the documentation leaves untyped'),
+            schemaShape: SERVER_INSTRUCTIONS.includes('The SHAPE of a model schema is not checked'),
+            duplicateKeyGap: SERVER_INSTRUCTIONS.includes('silence there does not prove two keys are distinct'),
+            perProjectConfig: SERVER_INSTRUCTIONS.includes('Coverage is per project'),
+        }).toEqual({
+            untypedArguments: true,
+            schemaShape: true,
+            duplicateKeyGap: true,
+            perProjectConfig: true,
+        });
+    });
+});
+//# sourceMappingURL=instructions-coverage.spec.js.map

package/dist/transport/instructions.d.ts

@@ -0,0 +1 @@
+export declare const SERVER_INSTRUCTIONS: string;