@vincentt-xr/cli 0.15.1 → 0.16.0

package/dist/publish/command.d.ts

@@ -1,4 +1,5 @@
 import type { ResolvedConfig } from "../shared/config.js";
+import { type BuiltWith } from "../platform/resolve.js";
 export interface PublishDeps {
     print: (line: string) => void;
     /** Raw write, for the redrawn progress line only. */
@@ -21,6 +22,15 @@ export interface PublishDeps {
     /** The active org's slug, for the usage deep link on a plan-limit refusal. */
     orgSlug?: () => Promise<string | undefined>;
     consoleUrl?: string;
+    /**
+     * What this project resolved on this machine, attached to the version row.
+     *
+     * Injected so the publish path can be tested without a `node_modules` tree,
+     * and defaulted to f17's SHARED resolver — the same one the report path calls,
+     * because two payloads carrying byte-identical values for one project is the
+     * mechanical proof there is one resolver and not two that drifted.
+     */
+    builtWith?: () => Promise<BuiltWith | undefined>;
 }
 export interface PublishOptions {
     distDir?: string;

package/dist/publish/command.js

@@ -17,6 +17,7 @@ import { classifyDist } from "./classify.js";
 import { createProgress } from "./progress.js";
 import { UploadFailed, uploadAll } from "./upload.js";
 import * as copy from "./copy.js";
+import { resolveBuiltWith } from "../platform/resolve.js";
 const COMMIT_RETRIES = 3;
 const COMMIT_RETRY_DELAY_MS = 2000;
 export async function publishCommand(deps, opts = {}) {
@@ -140,6 +141,10 @@ export async function publishCommand(deps, opts = {}) {
             return 0;
         }
     }
+    // Resolved AFTER the confirmation and never before it: a refused publish must
+    // read nothing about the creator's installed packages. A fault here yields
+    // undefined and the field is omitted — it can never fail a publish.
+    const builtWith = await (deps.builtWith ?? (() => resolveBuiltWith(deps.cwd)))().catch(() => undefined);
     return runUpload(deps, cfg, {
         projectId: binding.projectId,
         distDir,
@@ -148,6 +153,7 @@ export async function publishCommand(deps, opts = {}) {
         address,
         liveVersion: project.liveVersion ?? undefined,
         fetchImpl,
+        builtWith,
         org: {
             name: orgName || undefined,
             slug: (await deps.orgSlug?.()) || undefined,
@@ -158,7 +164,7 @@ export async function publishCommand(deps, opts = {}) {
 async function runUpload(deps, cfg, i) {
     let opened;
     try {
-        opened = await openUpload(cfg, i.projectId, i.manifest.files, i.note, i.fetchImpl);
+        opened = await openUpload(cfg, i.projectId, i.manifest.files, i.note, i.fetchImpl, i.builtWith);
     }
     catch (err) {
         for (const l of openErrorLines(err, i.address, i.liveVersion, i.org))

package/dist/publish/copy.d.ts

@@ -205,5 +205,18 @@ export declare function rateLimited(retryAfterSec: number): string[];
  * none.
  */
 export declare function consoleVerb(verb: string, versionsUrl?: string): string[];
-/** The six verbs that land on that block. */
+/**
+ * The verbs that land on that block — f4's and f10's six, plus f15's five.
+ *
+ * NONE OF THESE GAINS A HANDLER. They are routed to an answer precisely because
+ * they do not exist: f15 deliberately gives the CLI no checkout verb, since the
+ * authorized actor is a human reading consequence copy in a browser and a verb
+ * whose whole contribution is printing a URL is a browser flow with a shell in
+ * front of it.
+ *
+ * Routing them rather than ignoring them is about f15's actual actor. A human
+ * who types `vincentt upgrade` and gets "unrecognised command" shrugs and reads
+ * the help. AN AGENT RETRIES, or guesses a neighbouring verb, and neither
+ * terminates.
+ */
 export declare const CONSOLE_ONLY_VERBS: readonly string[];

package/dist/publish/copy.js

@@ -476,9 +476,19 @@ export function planLimitRefused(i) {
         "",
         ...alignedRows(rows),
         "",
+        // f15 FALSIFIED THE OLD SENTENCE. It said restoring was "a manual action by a
+        // Vincentt operator" — true until a customer could pay for it themselves, and
+        // false the moment checkout shipped.
+        //
+        // "cannot be done from the CLI" STAYS, and is the load-bearing half: an agent
+        // told only that publishing failed hunts for a flag, and naming the remedy as
+        // something outside this tool is what stops the loop.
+        //
+        // The restore is deliberately not promised as instant — it is about two
+        // minutes, and copy that promises instant is copy that lies on a slow tick.
         `  Published addresses were taken offline${takenOn} because the organization`,
-        "  went over its monthly traffic allowance. Restoring this is a manual action",
-        "  by a Vincentt operator and cannot be done from the CLI.",
+        "  went over its monthly traffic allowance. Taking a paid plan restores them",
+        "  automatically, in the console — it cannot be done from the CLI.",
         "",
         "  Every version is still stored and the address is still yours.",
         "",
@@ -681,7 +691,20 @@ export function consoleVerb(verb, versionsUrl) {
     }
     return out;
 }
-/** The six verbs that land on that block. */
+/**
+ * The verbs that land on that block — f4's and f10's six, plus f15's five.
+ *
+ * NONE OF THESE GAINS A HANDLER. They are routed to an answer precisely because
+ * they do not exist: f15 deliberately gives the CLI no checkout verb, since the
+ * authorized actor is a human reading consequence copy in a browser and a verb
+ * whose whole contribution is printing a URL is a browser flow with a shell in
+ * front of it.
+ *
+ * Routing them rather than ignoring them is about f15's actual actor. A human
+ * who types `vincentt upgrade` and gets "unrecognised command" shrugs and reads
+ * the help. AN AGENT RETRIES, or guesses a neighbouring verb, and neither
+ * terminates.
+ */
 export const CONSOLE_ONLY_VERBS = [
     "rollback",
     "unpublish",
@@ -689,4 +712,10 @@ export const CONSOLE_ONLY_VERBS = [
     "versions",
     "revert",
     "take-offline",
+    // f15 — checkout is console-only, by design.
+    "upgrade",
+    "billing",
+    "plan",
+    "subscribe",
+    "pay",
 ];

package/dist/scaffold/index.d.ts

@@ -11,8 +11,14 @@ export declare const TEMPLATE_REPO = "https://github.com/vincentt-xr/v2-template
  * immutable, which is what makes that an escape hatch rather than a coin flip.
  */
 export declare const DEFAULT_TEMPLATE_REF = "latest";
-/** Injectable git runner (real git by default; a fake in tests avoids the network). */
-export type GitRunner = (args: string[]) => Promise<void>;
+/**
+ * Injectable git runner (real git by default; a fake in tests avoids the network).
+ *
+ * Resolves to git's stdout. A fake that returns nothing still satisfies the type,
+ * so the tag resolution below treats a void result the same as empty output —
+ * unresolved rather than a crash.
+ */
+export type GitRunner = (args: string[]) => Promise<string | void>;
 /**
  * True when `dir` has no app yet (no package.json) → safe to scaffold into.
  * A directory that already holds an app is left untouched (project_create just binds).
@@ -46,12 +52,53 @@ export interface ScaffoldOptions {
     /** Test seam — defaults to spawning real git. */
     runGit?: GitRunner;
 }
+/**
+ * The concrete version tag the clone actually landed on, or `undefined` when the
+ * commit carries none.
+ *
+ * `git describe --tags` is the obvious call and it is WRONG here: against a clone
+ * of the moving tag it answers `latest`, which is the exact non-information this
+ * resolution exists to replace. `tag --points-at HEAD` lists every tag on the
+ * cloned commit instead — `latest` alongside the version tag it was force-moved
+ * onto — and the version tag is selected by shape.
+ *
+ * When several concrete versions share a commit (a re-tagged release), the
+ * HIGHEST is recorded: the tags name the same tree, so any is a correct baseline,
+ * and picking by precedence rather than by git's output order keeps the recorded
+ * value stable across clones.
+ */
+export declare function pickConcreteVersionTag(tagOutput: string | void): string | undefined;
+/** What a scaffold resolved. `templateVersion` absent = it could not be established. */
+export interface ScaffoldResult {
+    /**
+     * The concrete version tag the clone landed on. ABSENT rather than `latest`
+     * when unresolvable: a moving tag recorded as a baseline is worse than no
+     * baseline, because a later upgrade would trust it and widen what it replaces.
+     */
+    templateVersion?: string;
+    /** The ref that was ASKED for — `latest` on the default path. Diagnostic only. */
+    requestedRef?: string;
+}
+/**
+ * The shape an INJECTED scaffold may return. `void` is permitted, and reads as
+ * "this fake resolved no version" — which is the no-baseline state, already a
+ * first-class value here.
+ *
+ * Deliberately looser than what `scaffoldFromTemplate` itself returns: the real
+ * function always reports, while a caller's test double has nothing to report
+ * and must not be forced to invent a version to satisfy a type.
+ */
+export type ScaffoldOutcome = ScaffoldResult | void;
 /**
  * Scaffold the template into `targetDir`. Clones to a temp dir, strips `.git`,
  * copies the files in (never overwriting anything already there), then inits a
  * fresh repo. Throws a clear error if the clone fails (e.g. no git access).
+ *
+ * Returns what it resolved. The requested ref is not the answer: `latest` is
+ * force-updated by the template's release workflow, so recording it preserves
+ * nothing — every project from any date would report the same string.
  */
-export declare function scaffoldFromTemplate(targetDir: string, opts?: ScaffoldOptions): Promise<void>;
+export declare function scaffoldFromTemplate(targetDir: string, opts?: ScaffoldOptions): Promise<ScaffoldResult>;
 export type PackageManager = "pnpm" | "yarn" | "npm";
 /**
  * Pick the package manager the scaffolded template is set up for, by its lockfile.

package/dist/scaffold/index.js

@@ -23,7 +23,8 @@ export const TEMPLATE_REPO = "https://github.com/vincentt-xr/v2-template.git";
  */
 export const DEFAULT_TEMPLATE_REF = "latest";
 const realGit = async (args) => {
-    await execFileAsync("git", args);
+    const { stdout } = await execFileAsync("git", args);
+    return stdout;
 };
 /**
  * True when `dir` has no app yet (no package.json) → safe to scaffold into.
@@ -71,10 +72,57 @@ export class ScaffoldRefError extends Error {
         this.name = "ScaffoldRefError";
     }
 }
+/**
+ * A concrete `MAJOR.MINOR.PATCH` version tag, anchored at both ends.
+ *
+ * Anchored because a template repo carries tags a version compare cannot use:
+ * `latest` itself, and anything merely version-SHAPED (`1.4.3-extra`). Recording
+ * one of those is the defect this whole resolution exists to remove.
+ */
+const CONCRETE_VERSION_TAG = /^[0-9]+\.[0-9]+\.[0-9]+$/;
+/**
+ * The concrete version tag the clone actually landed on, or `undefined` when the
+ * commit carries none.
+ *
+ * `git describe --tags` is the obvious call and it is WRONG here: against a clone
+ * of the moving tag it answers `latest`, which is the exact non-information this
+ * resolution exists to replace. `tag --points-at HEAD` lists every tag on the
+ * cloned commit instead — `latest` alongside the version tag it was force-moved
+ * onto — and the version tag is selected by shape.
+ *
+ * When several concrete versions share a commit (a re-tagged release), the
+ * HIGHEST is recorded: the tags name the same tree, so any is a correct baseline,
+ * and picking by precedence rather than by git's output order keeps the recorded
+ * value stable across clones.
+ */
+export function pickConcreteVersionTag(tagOutput) {
+    if (!tagOutput)
+        return undefined;
+    const versions = tagOutput
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => CONCRETE_VERSION_TAG.test(line));
+    if (versions.length === 0)
+        return undefined;
+    return versions.sort(compareVersionDesc)[0];
+}
+function compareVersionDesc(a, b) {
+    const pa = a.split(".").map(Number);
+    const pb = b.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        if (pa[i] !== pb[i])
+            return pb[i] - pa[i];
+    }
+    return 0;
+}
 /**
  * Scaffold the template into `targetDir`. Clones to a temp dir, strips `.git`,
  * copies the files in (never overwriting anything already there), then inits a
  * fresh repo. Throws a clear error if the clone fails (e.g. no git access).
+ *
+ * Returns what it resolved. The requested ref is not the answer: `latest` is
+ * force-updated by the template's release workflow, so recording it preserves
+ * nothing — every project from any date would report the same string.
  */
 export async function scaffoldFromTemplate(targetDir, opts = {}) {
     const repo = opts.repo ?? TEMPLATE_REPO;
@@ -97,6 +145,17 @@ export async function scaffoldFromTemplate(targetDir, opts = {}) {
             }
             throw new Error(`Could not clone the ${repo} template (check your git access): ${msg}`);
         }
+        // BEFORE the strip below — `.git` is the only place the concrete tag is
+        // readable, and the copy into the target deliberately does not carry it.
+        // A failure here must not fail the scaffold: the files are correct either
+        // way, and the honest outcome is a missing baseline, not a missing app.
+        let templateVersion;
+        try {
+            templateVersion = pickConcreteVersionTag(await runGit(["-C", tmp, "tag", "--points-at", "HEAD"]));
+        }
+        catch {
+            templateVersion = undefined;
+        }
         await fs.rm(path.join(tmp, ".git"), { recursive: true, force: true });
         // Copy template contents in without clobbering anything already in the target.
         for (const entry of await fs.readdir(tmp)) {
@@ -110,6 +169,7 @@ export async function scaffoldFromTemplate(targetDir, opts = {}) {
         if (!(await isGitRepo(targetDir))) {
             await runGit(["-C", targetDir, "init"]);
         }
+        return { templateVersion, requestedRef: ref };
     }
     finally {
         await fs.rm(tmp, { recursive: true, force: true });

package/dist/shared/config.d.ts

@@ -18,6 +18,20 @@ export interface MachineConfig {
      */
     dxSendEnabledAt?: string;
 }
+/**
+ * What the project was scaffolded from — the drift baseline a later upgrade
+ * compares against.
+ *
+ * The whole object is ABSENT when the scaffold could not resolve a concrete
+ * version, and absent is a first-class state every reader must handle. The
+ * alternative — recording the moving `latest` tag — is strictly worse than
+ * absence: a reader cannot tell it apart from a real baseline, so it would be
+ * trusted, and an upgrade trusting a wrong baseline widens what it overwrites.
+ */
+export interface TemplateProvenance {
+    /** A concrete `MAJOR.MINOR.PATCH` tag. Never `latest`, never a branch. */
+    version: string;
+}
 export interface ProjectBinding {
     /** The backend Project id this working tree publishes to. */
     projectId: string;
@@ -25,6 +39,8 @@ export interface ProjectBinding {
     slug: string;
     /** Optional per-project API override; else the machine config's apiUrl. */
     apiUrl?: string;
+    /** Absent = no recorded baseline. See TemplateProvenance. */
+    template?: TemplateProvenance;
 }
 export declare const MACHINE_CONFIG_PATH: string;
 export declare function projectBindingPath(cwd: string): string;

package/dist/shared/config.js

@@ -176,7 +176,15 @@ async function isGitRoot(dir) {
 export async function writeProjectBinding(cwd, binding) {
     await fs.mkdir(path.join(cwd, BINDING_DIR), { recursive: true });
     const p = projectBindingPath(cwd);
-    await fs.writeFile(p, JSON.stringify(binding, null, 2) + "\n", "utf8");
+    // A caller that writes a whole binding without a `template` (`link`, a re-bind)
+    // must not DROP a baseline the scaffold recorded: the tree it describes is
+    // unchanged by a re-bind, and a lost baseline downgrades the next upgrade to
+    // the reporting path with nothing on screen to explain why.
+    const existing = binding.template
+        ? undefined
+        : (await readJsonIfExists(p))?.template;
+    const next = existing ? { ...binding, template: existing } : binding;
+    await fs.writeFile(p, JSON.stringify(next, null, 2) + "\n", "utf8");
     await ensureGitignored(cwd, `${BINDING_DIR}/`);
     // `create` and `link` WRITE a binding rather than resolve one, so they never
     // pass through the resolver's hook. Between the two, every way a folder comes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincentt-xr/cli",
-  "version": "0.15.1",
+  "version": "0.16.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: "" },
-    ];
-}