@vincentt-xr/cli 0.15.2 → 0.17.0

package/dist/shared/countLimit.js

@@ -0,0 +1,169 @@
+// The three count-limit refusals — seats, published projects, concurrent live
+// previews — as they reach a creator standing at a ceiling.
+//
+// THE REFUSAL IS THE NOTICE. A count limit is evaluated in the same request as
+// the act it refuses, so no earlier moment exists at which a warning could have
+// been delivered (B-F10-2, as amended). The obligation is discharged by the
+// refusal naming the axis, the current count and the ceiling — which means a
+// refusal rendered without its figures does not discharge it at all. That is the
+// whole reason these arms exist rather than the generic `✗ {message}` default.
+//
+// Two prohibitions govern every string below:
+//   - NO PRICE, and no plan other than the one in force. f16's inherited rule: a
+//     surface tells a creator where they stand, never what to buy.
+//   - NO COMMAND that resolves the refusal. An agent's default response to a
+//     failure is to run the next thing it is handed, and there is no CLI verb
+//     that frees a seat, unpublishes a project or ends someone else's preview.
+//     The copy names the act as a human one, in the console.
+const SUPPORT_EMAIL = "hello@vincentt.studio";
+const DEFAULT_CONSOLE_URL = "https://console.vincentt.studio";
+/**
+ * THE WIRE WINS over the machine's configured active org.
+ *
+ * The API names the org that owns the project being acted on; local config names
+ * whichever org the CLI was last pointed at, and on a machine with more than one
+ * workspace they are routinely different. Naming the local one would print the
+ * wrong workspace on the exact screen that is refusing the creator — and the
+ * refusal's figures are about the org the wire named, so a mismatched heading
+ * makes the numbers read as wrong rather than the name.
+ *
+ * The local values remain as a fallback for a body that carried neither, which
+ * is a refusal from an older api rather than a shape this client accepts.
+ */
+export function resolveCountLimit(detail, local) {
+    return {
+        orgName: detail.orgName ?? local?.name,
+        orgSlug: detail.orgSlug ?? local?.slug,
+        planName: detail.planName,
+        count: detail.count ?? 0,
+        ceiling: detail.ceiling ?? 0,
+        consoleUrl: local?.consoleUrl,
+    };
+}
+/**
+ * `Acme (acme)` — name and slug when they differ, one of them when they do not,
+ * and an empty string when the wire named neither. Matches f10's shipped
+ * plan-limit heading so the four plan refusals read as one family.
+ */
+export function orgLabel(name, slug) {
+    if (name && slug && name !== slug)
+        return `${name} (${slug})`;
+    return name || slug || "";
+}
+/**
+ * The figures, STACKED AND ALIGNED rather than inline. They are a comparison —
+ * the count against the ceiling — and f2's convention puts two values a creator
+ * must judge on their own aligned lines. Inline they are a sentence to parse;
+ * stacked, an agent and a human read them the same way.
+ */
+export function countRows(i, axisLabel, planSuffix) {
+    const rows = [];
+    if (i.orgName || i.orgSlug)
+        rows.push(["Organization", orgLabel(i.orgName, i.orgSlug)]);
+    if (i.planName)
+        rows.push(["Plan", `${i.planName} — ${planSuffix}`]);
+    rows.push([axisLabel, `${i.count} of ${i.ceiling} used`]);
+    return alignedRows(rows);
+}
+function alignedRows(rows) {
+    const width = Math.max(...rows.map((r) => r[0].length));
+    return rows.map(([label, value]) => `  ${label.padEnd(width)}   ${value}`);
+}
+/**
+ * f4's rule: where a verb does not exist because the act belongs to another
+ * surface, say where it lives and link to it — and if the link cannot be built,
+ * drop the link and keep the explanation.
+ *
+ * `path` is the org-scoped page that shows the axis being refused.
+ */
+export function consoleLines(i, path) {
+    if (!i.orgSlug)
+        return [`  Email ${SUPPORT_EMAIL}.`, ""];
+    const base = (i.consoleUrl ?? DEFAULT_CONSOLE_URL).replace(/\/$/, "");
+    return [`  See ${base}/orgs/${i.orgSlug}/${path}, or email`, `  ${SUPPORT_EMAIL}.`, ""];
+}
+// THERE IS NO SEAT ARM HERE, AND THE ABSENCE IS THE DESIGN.
+//
+// `seat_limit` is refused on `POST /orgs/{slug}/invites`, which the CLI does not
+// call and has no verb for: inviting a person is an act whose authorized actor
+// is a human, so it lives in the console (f15's convention). The seat refusal's
+// copy — including the two ways to free a seat — is the console's to render.
+//
+// A renderer for it added here would be an export with no caller, which is worse
+// than nothing: it reads as coverage and cannot fail.
+/**
+ * The published-project ceiling, refused at open-publish.
+ *
+ * "One published project" means ONE LIVE ADDRESS AT A TIME, and the copy says
+ * so, because the other reading — one project ever published — is what makes a
+ * creator believe they have permanently spent their slot on a mistake. Taking a
+ * project offline frees it, and that is the sentence that distinguishes the two.
+ *
+ * It does NOT say the project being published is excluded from the count, even
+ * though it is: a creator refused here is publishing a SECOND project, so the
+ * exclusion never applies on the screen that would explain it.
+ */
+export function publishedLimitRefused(i) {
+    return [
+        "",
+        "✗ This organization is already publishing as many projects as its plan allows.",
+        "",
+        ...countRows(i, "Published", "published projects are counted per organization"),
+        "",
+        "  The count is projects with a live address right now, not projects that have",
+        "  ever been published. Taking one offline in the console frees the slot, and",
+        "  everything already published stays exactly as it is.",
+        "",
+        ...consoleLines(i, "projects"),
+        "  Nothing was uploaded.",
+        "",
+    ];
+}
+/**
+ * The concurrent-preview ceiling, refused at mint.
+ *
+ * "Still running" is the load-bearing claim and it is stated first among the
+ * facts. A creator whose `vincentt preview` just refused has every reason to
+ * believe it took something down — the command that failed is the command that
+ * starts previews — and B-F10-3's guarantee (a count limit refuses growth and
+ * removes nothing) is invisible unless the refusal says it.
+ */
+export function previewLimitRefused(i) {
+    return [
+        "",
+        "✗ This organization has as many previews running as its plan allows.",
+        "",
+        ...countRows(i, "Previews", "previews are counted per organization"),
+        "",
+        "  Every preview that was running is still running — this one did not start.",
+        "  A preview stops when whoever started it stops it, or when it reaches its",
+        "  12-hour limit.",
+        "",
+        ...consoleLines(i, "projects"),
+        "  Nothing was started.",
+        "",
+    ];
+}
+/**
+ * The storage ceiling. It NAMES NO FIGURE, and the asymmetry with the three
+ * count refusals above is deliberate rather than an omission: the ceiling is an
+ * abuse ceiling, not a tier limit. It is flat on every plan, never sold, never
+ * displayed, and its only audience is an operator. A number here would be the
+ * product printing a magnitude a creator cannot act on and was never offered.
+ *
+ * Support is therefore the whole remedy — there is no console page showing this
+ * and no plan that raises it.
+ */
+export function storageCeilingRefused() {
+    return [
+        "",
+        "✗ This organization cannot upload more files right now.",
+        "",
+        "  This is not a plan limit and taking a different plan will not change it.",
+        "",
+        `  Email ${SUPPORT_EMAIL} and it can be looked at.`,
+        "",
+        "  Nothing was uploaded.",
+        "",
+    ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincentt-xr/cli",
-  "version": "0.15.2",
+  "version": "0.17.0",
   "description": "Vincentt CLI — the vincentt command-line dev loop (login, create, publish, preview, diagnostics, feedback, relay)",
   "license": "UNLICENSED",
   "type": "module",

package/dist/dx/qa.f7.fixtures.d.ts

@@ -1,73 +0,0 @@
-/**
- * QA fixtures for the dx-agent-consent delta (f7).
- *
- * Declared in the change's qa.md `## Fixtures` section. All three are
- * machine-config state, which f7 has never had a fixture for — its existing
- * fixtures (F7_JOURNAL_FRICTION, F7_REPORT_EXPIRED, …) are journal-side or
- * server-side.
- *
- * F7_CONFIG_SIGNED_IN is written by driving the REAL writeMachineConfig(), never
- * by hand-writing JSON. A hand-written config asserts against a shape the CLI
- * never produces — the f1 orgs/memberships failure at file scope, where a mock
- * of state the API could actually produce drifted from the API and stayed green.
- *
- * These are QA-owned (qa.* prefix) and deliberately separate from dev's test
- * files in the same package.
- */
-import type { JournalEntry } from "./journal.js";
-/** The honest baseline config, as the CLI itself writes it. */
-export declare const F7_CONFIG_SIGNED_IN: {
-    readonly apiUrl: "https://api.test";
-    readonly consoleUrl: "https://console.test";
-    readonly pat: "vct_alice";
-    readonly activeOrg: "alice";
-};
-/**
- * The instant every fixture is dated against. 145 days after the grant in
- * F7_CONFIG_ENABLED, and before DX_UNATTENDED_SUNSET.
- */
-export declare const F7_NOW: number;
-/** 145 days before F7_NOW. The AGE is the point — see qa.md on F7_CONFIG_ENABLED. */
-export declare const F7_ENABLED_AT = "2026-04-01T00:00:00.000Z";
-/**
- * The single pinned human-facing shape. Every human surface must render this
- * byte-for-byte; the age is the load-bearing half, so it is pinned as a literal
- * rather than computed (a computed expectation would follow a broken
- * implementation wherever it went).
- */
-export declare const F7_PINNED_ENABLEMENT_LINE = "Unattended send: ENABLED since 2026-04-01 (145 days)";
-/** F7_CONFIG_SIGNED_IN + durable enablement, aged. */
-export declare const F7_CONFIG_ENABLED: {
-    readonly dxSendEnabled: true;
-    readonly dxSendEnabledAt: "2026-04-01T00:00:00.000Z";
-    readonly apiUrl: "https://api.test";
-    readonly consoleUrl: "https://console.test";
-    readonly pat: "vct_alice";
-    readonly activeOrg: "alice";
-};
-/**
- * Every shape the enablement read must treat as DISABLED.
- *
- * Rows B, C, E, F, G are TRUTHY IN JAVASCRIPT — `if (cfg.dxSendEnabled)` passes
- * every one of them. That is the entire reason this fixture exists, and why the
- * read is specified as `=== true`. The worst is B ("false"): what a person
- * hand-editing this file writes when trying to turn the feature OFF.
- *
- * `raw` rows (K, L) are written as bytes rather than as an object, because the
- * property under test is that an UNPARSEABLE config fails closed instead of
- * throwing through into an unrelated verb.
- */
-export interface MalformedRow {
-    id: string;
-    why: string;
-    /** A config object to serialize, or undefined when `raw` carries the bytes. */
-    patch?: Record<string, unknown>;
-    /** Literal file bytes, for the rows that are not valid JSON at all. */
-    raw?: string;
-}
-export declare const F7_CONFIG_MALFORMED_ENABLEMENT: MalformedRow[];
-/**
- * F7_JOURNAL_FRICTION, as the record declares it: three runs of the same verb in
- * a few minutes, which is a repetition cluster.
- */
-export declare function f7JournalFriction(now?: number): JournalEntry[];

package/dist/dx/qa.f7.fixtures.js

@@ -1,58 +0,0 @@
-/** The honest baseline config, as the CLI itself writes it. */
-export const F7_CONFIG_SIGNED_IN = {
-    apiUrl: "https://api.test",
-    consoleUrl: "https://console.test",
-    pat: "vct_alice",
-    activeOrg: "alice",
-};
-/**
- * The instant every fixture is dated against. 145 days after the grant in
- * F7_CONFIG_ENABLED, and before DX_UNATTENDED_SUNSET.
- */
-export const F7_NOW = Date.parse("2026-08-24T12:00:00.000Z");
-/** 145 days before F7_NOW. The AGE is the point — see qa.md on F7_CONFIG_ENABLED. */
-export const F7_ENABLED_AT = "2026-04-01T00:00:00.000Z";
-/**
- * The single pinned human-facing shape. Every human surface must render this
- * byte-for-byte; the age is the load-bearing half, so it is pinned as a literal
- * rather than computed (a computed expectation would follow a broken
- * implementation wherever it went).
- */
-export const F7_PINNED_ENABLEMENT_LINE = "Unattended send: ENABLED since 2026-04-01 (145 days)";
-/** F7_CONFIG_SIGNED_IN + durable enablement, aged. */
-export const F7_CONFIG_ENABLED = {
-    ...F7_CONFIG_SIGNED_IN,
-    dxSendEnabled: true,
-    dxSendEnabledAt: F7_ENABLED_AT,
-};
-export const F7_CONFIG_MALFORMED_ENABLEMENT = [
-    { id: "A", why: 'truthy STRING "true"', patch: { dxSendEnabled: "true", dxSendEnabledAt: F7_ENABLED_AT } },
-    { id: "B", why: 'truthy in JS, means false to a human', patch: { dxSendEnabled: "false", dxSendEnabledAt: F7_ENABLED_AT } },
-    { id: "C", why: 'truthy in JS ("0")', patch: { dxSendEnabled: "0", dxSendEnabledAt: F7_ENABLED_AT } },
-    { id: "D", why: "truthy, not the boolean (1)", patch: { dxSendEnabled: 1, dxSendEnabledAt: F7_ENABLED_AT } },
-    { id: "E", why: "truthy ({} — what a refactor grouping the fields produces)", patch: { dxSendEnabled: {}, dxSendEnabledAt: F7_ENABLED_AT } },
-    { id: "F", why: "truthy ([])", patch: { dxSendEnabled: [], dxSendEnabledAt: F7_ENABLED_AT } },
-    { id: "G", why: 'truthy ("garbage")', patch: { dxSendEnabled: "garbage", dxSendEnabledAt: F7_ENABLED_AT } },
-    { id: "H", why: "key absent entirely", patch: {} },
-    { id: "I", why: "enabled true, dxSendEnabledAt absent", patch: { dxSendEnabled: true } },
-    { id: "J", why: 'enabled true, dxSendEnabledAt "not-a-date"', patch: { dxSendEnabled: true, dxSendEnabledAt: "not-a-date" } },
-    { id: "K", why: "file truncated mid-JSON", raw: '{"pat":"vct_alice","dxSendEn' },
-    { id: "L", why: "file empty (0 bytes)", raw: "" },
-];
-/**
- * F7_JOURNAL_FRICTION, as the record declares it: three runs of the same verb in
- * a few minutes, which is a repetition cluster.
- */
-export function f7JournalFriction(now = F7_NOW) {
-    const entry = (minutesAgo) => ({
-        ts: new Date(now - minutesAgo * 60_000).toISOString(),
-        v: "0.7.0",
-        verb: "preview",
-        skel: "preview",
-        exit: 0,
-        ms: 800,
-        err: null,
-        wt: "abc123",
-    });
-    return [entry(3), entry(2), entry(1)];
-}

package/dist/publish/qa.f4.fixtures.d.ts

@@ -1,25 +0,0 @@
-export type DistFixtureName = "CLEAN" | "TEMPLATE" | "MISSING_META" | "DEAD_IMAGE" | "MULTI_HTML" | "ADVERSARIAL" | "NO_DIST" | "OVERSIZE";
-/** The template defaults corpus the CLI ships, used verbatim by TEMPLATE. */
-export declare const TEMPLATE_TITLE = "Vite + React";
-export declare const TEMPLATE_DESCRIPTION = "Vite + React + TypeScript starter";
-/**
- * distFixture materializes one named tree under a fresh temp dir and returns
- * its cwd. The caller removes it.
- */
-export declare function distFixture(name: DistFixtureName): Promise<string>;
-export declare function removeFixture(cwd: string): Promise<void>;
-/**
- * The SHARED ADVERSARIAL ROWS. This list is the fixture the API's Go table test
- * and this suite both read; row-count parity is asserted in both runners.
- *
- * `reason` is the closed-enum value the API answers with. A row whose reason
- * differs between the two runners is a validator that disagrees with itself
- * across a repo boundary, which shows up only as a publish that cannot succeed.
- */
-export interface AdversarialRow {
-    name: string;
-    path: string;
-    /** "" means the row must be ACCEPTED. */
-    reason: string;
-}
-export declare function adversarialRows(): AdversarialRow[];

package/dist/publish/qa.f4.fixtures.js

@@ -1,140 +0,0 @@
-// QA f4 · the eight on-disk `dist/` trees the catalog names (4C / 4E).
-//
-// A distFixture is a REAL DIRECTORY, not a mock: the checklist parses HTML off
-// disk and the manifest hashes bytes off disk, so a fixture that stubbed either
-// would be asserting against a shape the product never reads.
-//
-// `ADVERSARIAL` is shared BYTE-FOR-BYTE with the API's validateManifest table —
-// one set of rows, read by both the Go table test and this vitest suite. A row
-// present in one runner and absent in the other fails the parity assertion, or
-// the shared fixture degrades into two fixtures with one name (f3's QA-F3-G11
-// lesson).
-import { promises as fs } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-/** The template defaults corpus the CLI ships, used verbatim by TEMPLATE. */
-export const TEMPLATE_TITLE = "Vite + React";
-export const TEMPLATE_DESCRIPTION = "Vite + React + TypeScript starter";
-function html(opts) {
-    const parts = ["<!doctype html><html><head>"];
-    if (opts.title !== undefined)
-        parts.push(`<title>${opts.title}</title>`);
-    if (opts.ogTitle !== undefined) {
-        parts.push(`<meta property="og:title" content="${opts.ogTitle}">`);
-    }
-    if (opts.description !== undefined) {
-        parts.push(`<meta name="description" content="${opts.description}">`);
-    }
-    if (opts.ogImage !== undefined) {
-        parts.push(`<meta property="og:image" content="${opts.ogImage}">`);
-    }
-    parts.push("</head><body><div id=\"root\"></div></body></html>");
-    return parts.join("");
-}
-/**
- * distFixture materializes one named tree under a fresh temp dir and returns
- * its cwd. The caller removes it.
- */
-export async function distFixture(name) {
-    const cwd = await fs.mkdtemp(path.join(os.tmpdir(), `vct-f4-${name.toLowerCase()}-`));
-    const dist = path.join(cwd, "dist");
-    if (name === "NO_DIST") {
-        // The ABSENCE of a dist/ directory IS the fixture.
-        return cwd;
-    }
-    await fs.mkdir(dist, { recursive: true });
-    switch (name) {
-        case "CLEAN": {
-            // A real title, description and og:image; og.png PRESENT; 6 files.
-            await fs.writeFile(path.join(dist, "index.html"), html({
-                title: "Harbour Wing — an AR walk",
-                description: "A guided AR tour of the Harbour Wing collection.",
-                ogImage: "/og.png",
-            }));
-            await fs.writeFile(path.join(dist, "og.png"), "png-bytes-clean");
-            await fs.mkdir(path.join(dist, "assets"), { recursive: true });
-            await fs.writeFile(path.join(dist, "assets", "app-a1b2c3.js"), "export const a=1;");
-            await fs.writeFile(path.join(dist, "assets", "app-d4e5f6.css"), "body{margin:0}");
-            await fs.writeFile(path.join(dist, "favicon.ico"), "ico-bytes");
-            await fs.writeFile(path.join(dist, "model.glb"), "glb-bytes");
-            return cwd;
-        }
-        case "TEMPLATE": {
-            // The template's own strings, untouched.
-            await fs.writeFile(path.join(dist, "index.html"), html({
-                title: TEMPLATE_TITLE,
-                description: TEMPLATE_DESCRIPTION,
-                ogImage: "/og.png",
-            }));
-            await fs.writeFile(path.join(dist, "og.png"), "png-bytes-template");
-            return cwd;
-        }
-        case "MISSING_META": {
-            // A title ONLY — no description, no og:image.
-            await fs.writeFile(path.join(dist, "index.html"), html({ title: "Harbour Wing — an AR walk" }));
-            return cwd;
-        }
-        case "DEAD_IMAGE": {
-            // og:image references /og.png, which is ABSENT from the tree. This is the
-            // ONLY fixture that produces a ✗.
-            await fs.writeFile(path.join(dist, "index.html"), html({
-                title: "Harbour Wing — an AR walk",
-                description: "A guided AR tour of the Harbour Wing collection.",
-                ogImage: "/og.png",
-            }));
-            return cwd;
-        }
-        case "MULTI_HTML": {
-            await fs.writeFile(path.join(dist, "index.html"), html({
-                title: "Harbour Wing — an AR walk",
-                description: "A guided AR tour of the Harbour Wing collection.",
-                ogImage: "/og.png",
-            }));
-            await fs.writeFile(path.join(dist, "og.png"), "png-bytes-multi");
-            // gallery.html has its OWN, DIFFERING findings.
-            await fs.writeFile(path.join(dist, "gallery.html"), html({ title: TEMPLATE_TITLE }));
-            return cwd;
-        }
-        case "ADVERSARIAL": {
-            // Paths only, and NO index.html at the root. The tree cannot literally
-            // contain "../escape.js" — the ROWS are the fixture, and they are shared
-            // with the Go table test through adversarialRows() below.
-            await fs.mkdir(path.join(dist, "sub"), { recursive: true });
-            await fs.writeFile(path.join(dist, "sub", "index.html"), html({ title: "nested" }));
-            return cwd;
-        }
-        case "OVERSIZE": {
-            // The bound variants are driven by SYNTHETIC MANIFEST ROWS rather than
-            // real bytes: writing 612 MB to a temp dir on every run would make the
-            // suite unusable, and the bound is checked against declared sizes before
-            // a byte moves — which is exactly the property under test.
-            await fs.writeFile(path.join(dist, "index.html"), html({ title: "big" }));
-            return cwd;
-        }
-    }
-    return cwd;
-}
-export async function removeFixture(cwd) {
-    await fs.rm(cwd, { recursive: true, force: true });
-}
-export function adversarialRows() {
-    return [
-        { name: "absolute", path: "/a.js", reason: "absolute_path" },
-        { name: "traversal", path: "../a.js", reason: "path_traversal" },
-        { name: "traversal_after_normalize", path: "a/../../b.js", reason: "path_traversal" },
-        { name: "backslash", path: "a\\b.js", reason: "backslash" },
-        { name: "empty_segment", path: "a//b.js", reason: "empty_segment" },
-        { name: "over_1024_bytes", path: `${"a".repeat(1025)}.js`, reason: "path_too_long" },
-        { name: "control_char", path: `a${String.fromCharCode(7)}b.js`, reason: "control_char" },
-        { name: "percent", path: "a%20b.js", reason: "bad_encoding" },
-        { name: "percent_2e2e", path: "a%2e%2e/b.js", reason: "bad_encoding" },
-        { name: "reserved_platform", path: "_platform/x.js", reason: "reserved_path" },
-        { name: "reserved_platform2", path: "_platform2/x.js", reason: "reserved_path" },
-        { name: "reserved_leading_underscore", path: "_anything/x.js", reason: "reserved_path" },
-        { name: "dot_segment", path: ".", reason: "path_traversal" },
-        { name: "dotdot_segment", path: "..", reason: "path_traversal" },
-        // THE ACCEPTED ROW. Without one the table passes on a validator that
-        // rejects everything.
-        { name: "nested_leading_underscore_is_ALLOWED", path: "a/_b.js", reason: "" },
-    ];
-}

package/dist/relay/qa.f12.fixtures.d.ts

@@ -1,154 +0,0 @@
-import { type ChildProcessByStdio } from "node:child_process";
-import type { Readable } from "node:stream";
-import { AnnotationStore } from "./annotations.js";
-import { type RelayHandle } from "./server.js";
-/** src/relay → packages/cli. The built entry is the one a creator runs. */
-export declare const CLI_ENTRY: string;
-export interface F12Tree {
-    dir: string;
-    cleanup: () => Promise<void>;
-}
-/**
- * A mkdtemp project root with `.vincentt/`, a written relay.json, and a project
- * BINDING.
- *
- * The binding is what makes the tree a tree: `relayInfoDir` resolves through
- * `locateProjectBinding`, which walks up from the cwd looking for
- * `.vincentt/project.json`. Without it a subdirectory of the project is a
- * DIFFERENT tree with its own cursor at 0 — which is precisely the
- * re-deliver-everything bug feedback.ts's header comment describes, so a fixture
- * that omitted the binding could not express the tree-anchoring case at all.
- */
-export declare function F12_TREE(opts?: {
-    relayPort: number;
-    pid?: number;
-    harnessPath?: string;
-}): Promise<F12Tree>;
-/** A fresh store over the tree, nothing on disk. readCursor ⇒ 0. */
-export declare function F12_STORE_EMPTY(projectDir: string): AnnotationStore;
-/** A valid 1×1 PNG data URL — the real screenshot shape `add()` decodes. */
-export declare const PNG_1X1: string;
-/**
- * F12_STORE_EMPTY plus three real `add()` calls ⇒ seq 1,2,3. `add()` is the same
- * function the real POST path calls, so driving it exercises the real delivery
- * path from one function inward.
- */
-export declare function F12_STORE_BATCH_3(projectDir: string, messages?: readonly string[]): Promise<AnnotationStore>;
-export interface F12Relay {
-    handle: RelayHandle;
-    port: number;
-    /** Everything the relay wrote to its `onLog` seam. */
-    logs: string[];
-    /**
-     * The `onAnnotation` notifications, one per accepted POST, carrying only the
-     * resolved tester. This is the seam `preview/runner.ts` wires to the preview
-     * terminal's `annotation received` line (Flow C8) — it is NOT `onLog`, so a
-     * case that watched `logs` for arrivals would see none and wrongly conclude
-     * the line was never wired.
-     */
-    arrivals: Array<{
-        tester?: string;
-        viewer?: string;
-    }>;
-    /** The rendered Flow C8 stream lines, as the preview terminal would print them. */
-    streamLines: string[];
-    close: () => Promise<void>;
-}
-/**
- * A real relay on a free port with an injectable store. Cases drive it through
- * REAL HTTP rather than by calling handlers directly: the exit contract is
- * defined in terms of status codes on a wire, and a handler-level call would not
- * observe a 410 the socket never sent.
- */
-export declare function F12_RELAY_LIVE(projectDir: string, store?: AnnotationStore): Promise<F12Relay>;
-/**
- * A tree whose relay.json names a port nothing listens on and a pid that is NOT
- * alive. The input to the liveness probe's dead arm.
- */
-export declare function F12_RELAY_DEAD(): Promise<F12Tree>;
-/** Write `.vincentt/annotations/offset` = n. n===null writes nothing (absent). */
-export declare function F12_CURSOR_AT(tree: string, n: number | null): Promise<void>;
-/** Raw cursor bytes, or null when the file is absent. */
-export declare function readCursorRaw(tree: string): Promise<string | null>;
-export interface HostileRow {
-    row: string;
-    payload: string;
-    attacks: string;
-}
-export declare const F12_HOSTILE_MESSAGES: readonly HostileRow[];
-export interface F12TwoTrees {
-    a: {
-        tree: F12Tree;
-        relay: F12Relay;
-        store: AnnotationStore;
-    };
-    b: {
-        tree: F12Tree;
-        relay: F12Relay;
-        store: AnnotationStore;
-    };
-    cleanup: () => Promise<void>;
-}
-/**
- * Two trees, two relays on two ports, two stores, two cursors. The
- * PROJECT-isolation fixture (QA-F12-G7). Deliberately NOT a tenant fixture —
- * these are one creator's two checkouts, the only multiplicity f12 has.
- */
-export declare function F12_TWO_TREES(): Promise<F12TwoTrees>;
-/** stdin ignored, stdout + stderr on their own pipes. */
-type PipedChild = ChildProcessByStdio<null, Readable, Readable>;
-export interface CliRun {
-    child: PipedChild;
-    /** Raw stdout BYTES — never merged with stderr. */
-    stdout: () => Buffer;
-    /** Raw stderr BYTES — never merged with stdout. */
-    stderr: () => Buffer;
-    out: () => string;
-    err: () => string;
-    /** Resolves with the OS-reported exit status. */
-    exit: Promise<{
-        code: number | null;
-        signal: NodeJS.Signals | null;
-    }>;
-    exited: () => boolean;
-    kill: (sig?: NodeJS.Signals) => void;
-}
-/**
- * Spawn the BUILT CLI with stdout/stderr on SEPARATE pipes and expose the real
- * exit status. `stdio: pipe` is load-bearing twice over: it keeps the two streams
- * distinguishable (QA-F12-C1) and it makes stdout a PIPE, which is the
- * asynchronous-write case the cursor invariant exists for (§3.1).
- */
-export declare function runCli(args: readonly string[], opts?: {
-    cwd: string;
-    env?: Record<string, string | undefined>;
-}): CliRun;
-/** Spawn, wait for exit, return everything. */
-export declare function runCliToEnd(args: readonly string[], opts: {
-    cwd: string;
-    env?: Record<string, string | undefined>;
-}): Promise<{
-    code: number | null;
-    signal: NodeJS.Signals | null;
-    stdout: Buffer;
-    stderr: Buffer;
-    out: string;
-    err: string;
-}>;
-/**
- * A throwaway HOME, so the dx journal (and therefore the dx nudge) starts empty.
- *
- * The nudge is journal-state-dependent and fires on the Nth recent run, so two
- * otherwise-identical invocations differ in stderr purely because one came later.
- * Any case comparing two runs byte-for-byte must isolate this or it is asserting
- * on run order rather than on the property it names.
- */
-export declare function freshHome(): Promise<string>;
-export declare function sleep(ms: number): Promise<void>;
-/** Wait until `cond()` or the deadline. Returns whether it became true. */
-export declare function until(cond: () => boolean, timeoutMs?: number, stepMs?: number): Promise<boolean>;
-/** Non-empty `\n`-split fragments of a raw stdout capture. */
-export declare function ndjsonLines(stdout: Buffer): string[];
-/** The Annotation key set §4.2 pins on stdout. */
-export declare const ANNOTATION_KEYS: readonly ["id", "seq", "createdAt", "projectDir", "message", "screenshotPath", "spec", "sessionId"];
-export {};