@vincentt-xr/cli 0.15.2 → 0.17.0

package/dist/publish/api.d.ts

@@ -1,5 +1,6 @@
 import type { ResolvedConfig } from "../shared/config.js";
 import type { ManifestEntry } from "./manifest.js";
+import type { BuiltWith } from "../platform/resolve.js";
 export interface PublishProject {
     id: string;
     slug: string;
@@ -40,7 +41,15 @@ export interface CommitResult {
     releaseNote?: string;
 }
 export interface ApiErrorDetail {
-    limit?: number;
+    /**
+     * ⚠ `limit` CARRIES TWO DIFFERENT TYPES on two different codes, and the api
+     * owns both. On `publish_too_large` and f16's domain ceiling it is a
+     * MAGNITUDE (bytes, a count); on the three count refusals it is the AXIS NAME
+     * ("seats" | "published" | "previews" | "storage"). The two never appear on
+     * the same body, so the union is read at the arm that knows which code it is
+     * handling and never generically.
+     */
+    limit?: number | string;
     observed?: number;
     missing?: number;
     mismatched?: number;
@@ -66,6 +75,14 @@ export interface ApiErrorDetail {
      */
     orgName?: string;
     orgSlug?: string;
+    /**
+     * The count refusals' two figures — the org's current occupancy on the axis,
+     * and the plan's ceiling for it. Both are required for the refusal to
+     * discharge B-F10-2: a refusal naming neither is a refusal with no notice in
+     * it.
+     */
+    count?: number;
+    ceiling?: number;
 }
 export declare class PublishApiError extends Error {
     readonly status: number;
@@ -77,11 +94,21 @@ export declare class PublishApiError extends Error {
 /** The ONE call before the checklist. liveVersion + livePublishedAt ride it, by design. */
 export declare function readProject(cfg: ResolvedConfig, projectId: string, fetchImpl?: typeof fetch): Promise<PublishProject>;
 /**
- * Open an upload. The request body carries `files` (path/size/sha256) and an
- * optional `note`, AND NOTHING ELSE — there is no field for a MIME type and no
- * field a parsed title, description or image URL could land in.
+ * Open an upload. The request body carries `files` (path/size/sha256), an
+ * optional `note`, and an optional `builtWith`, AND NOTHING ELSE — there is no
+ * field for a MIME type and no field a parsed title, description or image URL
+ * could land in.
+ *
+ * `builtWith` CANNOT FAIL A PUBLISH. It is evidence and never authorization: it
+ * is computed on a machine the platform does not control, so nothing may branch
+ * on it, and the API validates it in its own pass after the manifest, dropping
+ * over-bound entries rather than refusing. An instrument that can break the
+ * product's most important write path is worse than an instrument with a gap —
+ * which is why it is omitted entirely when nothing resolved rather than sent as
+ * an empty object. `{}` means "resolution ran and found nothing", a different
+ * and specific fact.
  */
-export declare function openUpload(cfg: ResolvedConfig, projectId: string, files: ManifestEntry[], note: string | undefined, fetchImpl?: typeof fetch): Promise<OpenedUpload>;
+export declare function openUpload(cfg: ResolvedConfig, projectId: string, files: ManifestEntry[], note: string | undefined, fetchImpl?: typeof fetch, builtWith?: BuiltWith): Promise<OpenedUpload>;
 export declare function commitUpload(cfg: ResolvedConfig, projectId: string, uploadId: string, fetchImpl?: typeof fetch): Promise<CommitResult>;
 /** Abandon an open upload. Idempotent server-side; a failure here must never mask the real error. */
 export declare function abandonUpload(cfg: ResolvedConfig, projectId: string, uploadId: string, fetchImpl?: typeof fetch): Promise<void>;

package/dist/publish/api.js

@@ -58,15 +58,29 @@ export async function readProject(cfg, projectId, fetchImpl = fetch) {
     };
 }
 /**
- * Open an upload. The request body carries `files` (path/size/sha256) and an
- * optional `note`, AND NOTHING ELSE — there is no field for a MIME type and no
- * field a parsed title, description or image URL could land in.
+ * Open an upload. The request body carries `files` (path/size/sha256), an
+ * optional `note`, and an optional `builtWith`, AND NOTHING ELSE — there is no
+ * field for a MIME type and no field a parsed title, description or image URL
+ * could land in.
+ *
+ * `builtWith` CANNOT FAIL A PUBLISH. It is evidence and never authorization: it
+ * is computed on a machine the platform does not control, so nothing may branch
+ * on it, and the API validates it in its own pass after the manifest, dropping
+ * over-bound entries rather than refusing. An instrument that can break the
+ * product's most important write path is worse than an instrument with a gap —
+ * which is why it is omitted entirely when nothing resolved rather than sent as
+ * an empty object. `{}` means "resolution ran and found nothing", a different
+ * and specific fact.
  */
-export async function openUpload(cfg, projectId, files, note, fetchImpl = fetch) {
+export async function openUpload(cfg, projectId, files, note, fetchImpl = fetch, builtWith) {
     const res = await fetchImpl(`${cfg.apiUrl}/projects/${encodeURIComponent(projectId)}/publishes`, {
         method: "POST",
         headers: { ...authHeaders(cfg), "content-type": "application/json" },
-        body: JSON.stringify({ files, ...(note ? { note } : {}) }),
+        body: JSON.stringify({
+            files,
+            ...(note ? { note } : {}),
+            ...(builtWith ? { builtWith } : {}),
+        }),
     });
     if (!res.ok)
         throw await readError(res);

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,8 @@ import { classifyDist } from "./classify.js";
 import { createProgress } from "./progress.js";
 import { UploadFailed, uploadAll } from "./upload.js";
 import * as copy from "./copy.js";
+import { publishedLimitRefused, resolveCountLimit, storageCeilingRefused, } from "../shared/countLimit.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 +142,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 +154,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 +165,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))
@@ -312,8 +319,20 @@ function openErrorLines(err, address, liveVersion, org) {
     if (err.code === "unavailable_plan_limit") {
         return planLimitLines(err, org);
     }
+    // The two count/ceiling refusals of this change. Both land at OPEN — before a
+    // presigned URL is minted and before a byte moves — which is why they are here
+    // and not in commitErrorLines: neither is reachable from commit.
+    if (err.code === "published_limit") {
+        return publishedLimitRefused(resolveCountLimit(err.detail, org));
+    }
+    if (err.code === "storage_ceiling") {
+        // It takes no detail. The body is `{"limit":"storage"}` and names nothing
+        // else by design — the ceiling is an abuse ceiling, not a plan limit.
+        return storageCeilingRefused();
+    }
     if (err.code === "publish_too_large") {
-        return copy.tooLargeFromServer(err.detail.observed ?? 0, err.detail.limit ?? 0);
+        // `limit` is the MAGNITUDE on this code. See ApiErrorDetail.limit.
+        return copy.tooLargeFromServer(err.detail.observed ?? 0, numericLimit(err.detail.limit));
     }
     if (err.code === "rate_limited") {
         return copy.rateLimited(err.retryAfterSec ?? 60);
@@ -333,6 +352,15 @@ function openErrorLines(err, address, liveVersion, org) {
         "",
     ];
 }
+/**
+ * `detail.limit` on a code whose `limit` is a MAGNITUDE. A string there is the
+ * axis-name meaning arriving on a body that should not carry it, and it reads as
+ * 0 rather than as `NaN` — a bound printed as "NaN MB" is worse than one printed
+ * as a figure the copy already handles.
+ */
+function numericLimit(limit) {
+    return typeof limit === "number" ? limit : 0;
+}
 function manifestErrorLines(err, distDir) {
     if (err.reason === "no_dist")
         return copy.noDist(distDir);

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/dist/shared/countLimit.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The detail every count refusal carries. Pinned to the api's `Decision.Err`
+ * renderer: `{limit, count, ceiling, orgName, orgSlug, planName}`.
+ *
+ * On THESE codes `limit` is the AXIS NAME — "seats" | "published" | "previews" |
+ * "storage" — and not a magnitude. It is typed as the transport's union rather
+ * than narrowed to `string`, because the same detail bag carries the byte-valued
+ * `limit` of `publish_too_large`, and a type that disagreed with the transport
+ * would push the mismatch to a cast at the call site.
+ *
+ * NOTHING BELOW READS IT. The axis is already known from the code that selected
+ * the renderer, so reading it back would be the renderer asking the wire to
+ * confirm which function it is. It is declared so the shape is complete and so a
+ * reader can see the field was considered.
+ */
+export interface CountLimitDetail {
+    limit?: number | string;
+    count?: number;
+    ceiling?: number;
+    orgName?: string;
+    orgSlug?: string;
+    planName?: string;
+}
+/**
+ * The org as the CLI can otherwise name it — the machine's configured active
+ * org. It is the FALLBACK and never the authority: see `resolveOrg`.
+ */
+export interface LocalOrgIdentity {
+    name?: string;
+    slug?: string;
+    consoleUrl?: string;
+}
+export interface ResolvedCountLimit {
+    orgName?: string;
+    orgSlug?: string;
+    planName?: string;
+    count: number;
+    ceiling: number;
+    consoleUrl?: string;
+}
+/**
+ * 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 declare function resolveCountLimit(detail: CountLimitDetail, local?: LocalOrgIdentity): ResolvedCountLimit;
+/**
+ * `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 declare function orgLabel(name?: string, slug?: string): string;
+/**
+ * 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 declare function countRows(i: ResolvedCountLimit, axisLabel: string, planSuffix: string): string[];
+/**
+ * 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 declare function consoleLines(i: ResolvedCountLimit, path: string): string[];
+/**
+ * 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 declare function publishedLimitRefused(i: ResolvedCountLimit): string[];
+/**
+ * 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 declare function previewLimitRefused(i: ResolvedCountLimit): string[];
+/**
+ * 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 declare function storageCeilingRefused(): string[];