@vincentt-xr/cli 0.2.0 → 0.3.0

package/dist/publish/copy.js

@@ -0,0 +1,606 @@
+// Every line `vincentt publish` prints (Flows L22-L31). Pure functions returning
+// string arrays, so the transcripts are assertable without a terminal.
+//
+// Five vocabulary rules govern all of it:
+//   - "Permanent" is the word for the address, never "locked", "frozen" or
+//     "reserved". Locked and frozen imply a keyholder; there isn't one.
+//   - A version is "v5", always, everywhere. Never "version 5", never a hash.
+//   - "Live" is the word and "latest" is not a word this product has.
+//   - The checklist "found" things; it never "failed", "flagged" or "blocked" them.
+//   - Unpublish "takes it offline"; it never "removes" or "deletes".
+//
+// NEVER PRINTED, at any point, in any state: the project id, the org id, the
+// uploadId, the PAT, any presigned URL or fragment of one, the bucket, any S3
+// key, or a per-file upload log.
+/** The only horizontal rules in any f4 output. They exist here and nowhere else. */
+const RULE = "  ─────────────────────────────────────────────────────────────────────";
+const LABELS = {
+    title: "Title",
+    description: "Description",
+    image: "Social image",
+};
+const VALUE_MAX = 60;
+/** `Social image` is the longest label; the column is sized to it plus a gap. */
+const LABEL_WIDTH = 13;
+export function truncate(value, max = VALUE_MAX) {
+    return value.length <= max ? value : `${value.slice(0, max - 1)}…`;
+}
+// ---- units ------------------------------------------------------------------
+/** Bytes as the creator reads them. Decimal MB, matching what a build tool prints. */
+export function formatBytes(bytes) {
+    if (bytes < 1000)
+        return `${bytes} B`;
+    const kb = bytes / 1000;
+    if (kb < 1000)
+        return `${round1(kb)} kB`;
+    const mb = kb / 1000;
+    if (mb < 1000)
+        return `${round1(mb)} MB`;
+    return `${round1(mb / 1000)} GB`;
+}
+function round1(n) {
+    const r = Math.round(n * 10) / 10;
+    return Number.isInteger(r) ? String(r) : r.toFixed(1);
+}
+/** The limit, printed as a plain number and never as policy. */
+export function formatLimit(bytes) {
+    return `${Math.round(bytes / 1_048_576)} MB`;
+}
+export function relativeTime(iso, now) {
+    const then = Date.parse(iso);
+    if (Number.isNaN(then))
+        return "";
+    const seconds = Math.max(0, Math.round((now - then) / 1000));
+    if (seconds < 60)
+        return "just now";
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60)
+        return `${minutes} minute${minutes === 1 ? "" : "s"} ago`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 24)
+        return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+    const days = Math.round(hours / 24);
+    if (days < 30)
+        return `${days} day${days === 1 ? "" : "s"} ago`;
+    const months = Math.round(days / 30);
+    return `${months} month${months === 1 ? "" : "s"} ago`;
+}
+// ---- the findings block -----------------------------------------------------
+/**
+ * Flow L25. Three registers of copy because the platform's confidence genuinely
+ * differs:
+ *   - TEMPLATE-DEFAULT is flat and assertive. The CLI matched a string in a
+ *     corpus it ships; it knows.
+ *   - LIKELY-DEFAULT is hedged. The heuristic will be wrong sometimes, and a
+ *     creator whose experience is genuinely called "AR" must not be told they
+ *     made a mistake.
+ *   - The dead og:image is the only ✗ the checklist ever emits, and it earns it:
+ *     the manifest either contains the path or it does not.
+ *
+ * BOTH default tiers print the offending value. "Still the template default"
+ * without the string is a claim the creator has to go and verify; with it they
+ * either recognise it instantly or spot that we are wrong.
+ *
+ * A FINDING IS NEVER A COUNT. No "2 issues found", no summary line, and no exit
+ * code that varies with findings.
+ */
+export function findingLines(byFile, withSubtitle) {
+    const out = [];
+    out.push(withSubtitle
+        ? "  Link preview  (what Slack, iMessage and WhatsApp will show)"
+        : "  Link preview");
+    out.push("");
+    const multi = byFile.length > 1;
+    for (const file of byFile) {
+        // A dist with index.html and gallery.html prints two blocks with the
+        // filename as a sub-heading, rather than repeating the path on every line.
+        if (multi) {
+            out.push(`    ${file.file}`);
+            out.push("");
+        }
+        for (const finding of file.findings) {
+            out.push(...findingLine(finding, file.file, multi));
+        }
+        if (multi)
+            out.push("");
+    }
+    if (!multi)
+        out.push("");
+    return out;
+}
+function findingLine(f, file, indented) {
+    const pad = indented ? "  " : "";
+    const label = LABELS[f.field].padEnd(LABEL_WIDTH);
+    // The file · tag sits on a continuation line indented to the VALUE column, so
+    // the eye reads three labels and three values and the fix detail stays out of
+    // the scan. 4 (gutter) + 3 (glyph) + the label width + 1.
+    const detail = `${pad}${" ".repeat(4 + 3 + LABEL_WIDTH + 1)}${file} · ${f.tag}`;
+    switch (f.tier) {
+        case "present":
+            return [`${pad}    ✓  ${label} ${truncate(f.value ?? "")}`];
+        case "missing":
+            return [`${pad}    !  ${label} not found`, detail];
+        case "template-default":
+            return [
+                `${pad}    !  ${label} still the template default: "${truncate(f.value ?? "")}"`,
+                detail,
+            ];
+        case "likely-default":
+            return [`${pad}    !  ${label} looks unset: "${truncate(f.value ?? "")}"`, detail];
+        case "dead-image":
+            return [`${pad}    ✗  ${label} ${f.value} is not in dist/`, detail];
+    }
+}
+/**
+ * Mandatory and always present. A screen with a red ✗ on it reads as a gate
+ * unless it explicitly says otherwise, and a creator who believes the platform
+ * is gating their publish on our opinion of their <meta> tags has learned
+ * something false about who owns the dist.
+ */
+export function nothingBlocksYou() {
+    return [
+        "    Scrapers don't run JavaScript, so these have to be in the HTML your",
+        "    build produces. Fix them in your source and publish again — or publish",
+        "    now and fix them later. Nothing here blocks you.",
+        "",
+    ];
+}
+export function readingLine(fileCount, totalBytes) {
+    return `→ Reading dist/ … ${fileCount} files · ${formatBytes(totalBytes)}`;
+}
+export function headerLine(projectName, orgName) {
+    return orgName ? `→ ${projectName} · ${orgName}` : `→ ${projectName}`;
+}
+/**
+ * Flow L22 — the single most consequential screen in the product, and its ORDER
+ * is the design.
+ *
+ * The address block is FIRST and it is fenced: a creator who reads nothing else
+ * reads the address and the sentence under it. The findings come AFTER, never
+ * before — the address is the irreversible thing and the metadata is fixable
+ * forever, so putting a red ✗ above the permanence block would make the eye land
+ * on the recoverable problem and skim the unrecoverable one.
+ */
+export function firstPublishChecklist(i) {
+    return [
+        "",
+        headerLine(i.projectName, i.orgName),
+        readingLine(i.fileCount, i.totalBytes),
+        "",
+        RULE,
+        "  FIRST PUBLISH",
+        "",
+        "    This address becomes permanent:",
+        "",
+        // Indented, alone, unadorned. No label, no backticks, no https:// — this is
+        // not a link to copy, it is a string to READ, and the creator is about to
+        // type `y` on it. Bare and surrounded by whitespace is what makes a typo
+        // visible.
+        `        ${i.address}`,
+        "",
+        "    After this it is yours forever, and can never be changed or reused —",
+        "    not by you, not by anyone else. Publishing again replaces what it",
+        "    serves; it never changes the address.",
+        "",
+        RULE,
+        "",
+        ...findingLines(i.findings, true),
+        ...nothingBlocksYou(),
+        `  Publishing v${i.nextVersion} · ${i.fileCount} files · ${formatBytes(i.totalBytes)}`,
+        "",
+    ];
+}
+/** The prompt line restates the address AND the version. `[y/N]` — an accidental Enter does nothing. */
+export function firstPublishPrompt(address, version) {
+    return `  Make ${address} permanent and publish v${version}? [y/N] `;
+}
+/**
+ * Declining. Glyphless, exit 0, zero network calls beyond the project read.
+ * Declining is not a failure and is not an error; it is the prompt working.
+ *
+ * The second line is the one that matters — a creator who backed out because the
+ * address was wrong needs to know the address is still theirs to change.
+ */
+export function declined() {
+    return [
+        "",
+        "  Nothing was published. The address is still yours to change:",
+        "  vincentt publish  when you're ready.",
+        "",
+    ];
+}
+/**
+ * Flow L24. No fence, no permanence block, no disclosure: the address is already
+ * permanent and the creator already knows, and presenting a frozen fact as a
+ * choice is worse than not presenting it at all.
+ *
+ * `(v5, published 3 days ago)` is rendered from the project read ALONE —
+ * liveVersion and livePublishedAt both ride GET /projects/{id}.
+ */
+export function republishChecklist(i) {
+    const when = i.livePublishedAt ? relativeTime(i.livePublishedAt, i.now) : "";
+    const context = when ? `(v${i.liveVersion}, published ${when})` : `(v${i.liveVersion})`;
+    return [
+        "",
+        headerLine(i.projectName, i.orgName),
+        readingLine(i.fileCount, i.totalBytes),
+        "",
+        `  Live at   ${i.address}   ${context}`,
+        `  Publishing v${i.nextVersion} · ${i.fileCount} files · ${formatBytes(i.totalBytes)}`,
+        "",
+        ...findingLines(i.findings, false),
+    ];
+}
+/** `[Y/n]` — on a republish an accidental Enter does the thing the creator typed the command to do. */
+export function republishPrompt(version) {
+    return `  Publish v${version} and make it live? [Y/n] `;
+}
+// ---- Flow L31, the offline address -------------------------------------------
+/**
+ * A publish onto an offline address brings it online, because publish always
+ * goes live. The creator must be told: they took it offline on purpose and might
+ * not intend to reverse that, so the default reverts to [y/N].
+ */
+export function offlineChecklist(i) {
+    return [
+        "",
+        headerLine(i.projectName, i.orgName),
+        readingLine(i.fileCount, i.totalBytes),
+        "",
+        `!  ${i.address} is currently offline.`,
+        "",
+        `   Publishing v${i.nextVersion} will put it back online and make v${i.nextVersion} live.`,
+        "",
+        ...findingLines(i.findings, false),
+    ];
+}
+export function offlinePrompt(version) {
+    return `  Publish v${version} and bring the address back online? [y/N] `;
+}
+// ---- Flow L31, not signed in -------------------------------------------------
+/**
+ * f1's line verbatim, with f4's reason. Note what is ABSENT, deliberately: f3's
+ * "your local dev loop doesn't need one" paragraph. It is the right copy for
+ * preview and the wrong copy here — a creator trying to publish is not looking
+ * for a smaller room, and offering one at this gate reads as a deflection.
+ */
+export function notSignedIn() {
+    return [
+        "",
+        "✗ You're not signed in.",
+        "",
+        "  Publishing puts your build at a permanent address, and that needs an account.",
+        "",
+        "  Sign in:  vincentt login",
+        "",
+    ];
+}
+// ---- Flow L28, the bounds ----------------------------------------------------
+/**
+ * Loud, local, instant, and it carries the real number. This fires before a
+ * single byte moves and before a single request is made.
+ *
+ * The two numbers are STACKED AND ALIGNED — the judgement the creator must make
+ * is a comparison, and prose defeats it. The three largest files are named
+ * because that is almost always the entire diagnosis: one uncompressed asset is
+ * nearly always the cause.
+ *
+ * The limit is printed as a number, never as policy. No "on your plan", no
+ * "upgrade" — it is a correctness limit and not a quota, and copy implying
+ * otherwise would be the first sentence of a billing model this feature does not
+ * have.
+ */
+export function tooLarge(v) {
+    if (v.kind === "file") {
+        return [
+            "",
+            "✗ One file is too large to publish.",
+            "",
+            ...alignedPair([v.path ?? "", formatBytes(v.observed)], ["the per-file limit", formatLimit(v.limit)]),
+            "",
+            "  Compress or externalise it, rebuild, then publish again.",
+            "",
+            "  Nothing was uploaded.",
+            "",
+        ];
+    }
+    if (v.kind === "count") {
+        return [
+            "",
+            "✗ This build has too many files to publish.",
+            "",
+            ...alignedPair(["your dist/", `${v.observed} files`], ["the limit", `${v.limit} files`]),
+            "",
+            "  Bundle or externalise the extras, rebuild, then publish again.",
+            "",
+            "  Nothing was uploaded.",
+            "",
+        ];
+    }
+    return [
+        "",
+        "✗ This build is too large to publish.",
+        "",
+        ...alignedPair(["your dist/", formatBytes(v.observed)], ["the limit", formatLimit(v.limit)]),
+        "",
+        "  The largest files are:",
+        "",
+        ...largestBlock(v),
+        "",
+        // The second verb matters: a 214 MB scan may belong on the creator's own CDN
+        // rather than inside the bundle, and a creator told only to compress will
+        // spend an hour on the wrong fix.
+        "  Compress or externalise the big ones, rebuild, then publish again.",
+        "",
+        "  Nothing was uploaded.",
+        "",
+    ];
+}
+function alignedPair(a, b) {
+    const labelWidth = Math.max(a[0].length, b[0].length);
+    const valueWidth = Math.max(a[1].length, b[1].length);
+    return [
+        `    ${a[0].padEnd(labelWidth)}  ${a[1].padStart(valueWidth)}`,
+        `    ${b[0].padEnd(labelWidth)}  ${b[1].padStart(valueWidth)}`,
+    ];
+}
+function largestBlock(v) {
+    const width = Math.max(0, ...v.largest.map((f) => f.path.length));
+    const sizeWidth = Math.max(0, ...v.largest.map((f) => formatBytes(f.size).length));
+    return v.largest.map((f) => `    ${f.path.padEnd(width)}  ${formatBytes(f.size).padStart(sizeWidth)}`);
+}
+/** No dist at all, or no index.html at its root. Zero network calls. */
+export function noDist(distDir) {
+    return [
+        "",
+        `✗ There's no build to publish at ${distDir}.`,
+        "",
+        "  Publishing uploads what your build produced — did the build run?",
+        "",
+        "  Build it, then publish:  npm run build",
+        "",
+        "  Nothing was uploaded.",
+        "",
+    ];
+}
+export function noIndexHtml(distDir) {
+    return [
+        "",
+        "✗ There's no index.html at the root of your build.",
+        "",
+        `  ${distDir} exists, but nothing there answers the address's own URL —`,
+        "  did the build run?",
+        "",
+        "  Build it, then publish:  npm run build",
+        "",
+        "  Nothing was uploaded.",
+        "",
+    ];
+}
+/** A local path rule the creator's own build broke. Local, before any request. */
+export function badPath(reason, offending) {
+    const why = {
+        path_traversal: "has a path that points outside your build",
+        absolute_path: "has an absolute path",
+        duplicate_path: "has the same path twice",
+        case_duplicate: "has two files whose names differ only by capitalisation, which your machine treats as one file and the web does not",
+        bad_encoding: "has a path we can't publish safely",
+        reserved_path: "has a top-level folder starting with `_`, which is reserved",
+    };
+    return [
+        "",
+        `✗ This build ${why[reason] ?? "has a path we can't publish"}.`,
+        "",
+        `    ${offending}`,
+        "",
+        "  Rename it in your source, rebuild, then publish again.",
+        "",
+        "  Nothing was uploaded.",
+        "",
+    ];
+}
+// ---- Flow L27, the upload ----------------------------------------------------
+const BAR_WIDTH = 28;
+/** The one redrawn line in f4. A bounded progress bar with a known total is not a stream. */
+export function progressBar(done, total, bytesDone, bytesTotal) {
+    const filled = total === 0 ? BAR_WIDTH : Math.round((done / total) * BAR_WIDTH);
+    const bar = "█".repeat(filled) + "░".repeat(Math.max(0, BAR_WIDTH - filled));
+    return `  ${bar}  ${done}/${total} · ${formatBytes(bytesDone)} / ${formatBytes(bytesTotal)}`;
+}
+/** The non-TTY degrade: periodic plain lines, at most one per 2s. */
+export function progressPlain(done, total, bytesDone) {
+    return `→ Uploaded ${done}/${total} · ${formatBytes(bytesDone)}`;
+}
+export function uploadStart(fileCount) {
+    return `→ Uploading ${fileCount} files…`;
+}
+export function uploadDone(fileCount, totalBytes, ms) {
+    const seconds = Math.max(1, Math.round(ms / 1000));
+    return `✓ Uploaded ${fileCount} files · ${formatBytes(totalBytes)} in ${seconds}s`;
+}
+/** Covers the commit. The pause between the last byte and the live URL is real. */
+export function finishing() {
+    return "→ Finishing…";
+}
+/**
+ * The payload of the entire command: the live URL, full and clickable, with the
+ * version in parentheses. The caching sentence is one line and ALWAYS present —
+ * a creator refreshing a phone that has the old page in memory will see the old
+ * page, decide publish is broken, and publish again.
+ */
+export function liveAt(liveUrl, version) {
+    return [
+        `✓ Live at ${liveUrl} (v${version})`,
+        "",
+        "  It may take a few seconds to appear on a device that has it cached.",
+        "",
+    ];
+}
+/** Prints only if a retry is needed. It says nothing about a failure, because nothing has failed yet. */
+export function takingLonger() {
+    return "!  Taking a moment longer than usual…";
+}
+// ---- Flow L29, the server-side failures ---------------------------------------
+/**
+ * The cause is NOT named. Every non-healing arm of the commit state machine
+ * returns this identically by design, and the CLI must not invent a distinction
+ * the wire does not carry. "Had to be restarted" is honest about what happened
+ * and is correct for all three arms.
+ */
+export function publishExpired(address, liveVersion) {
+    return [
+        "",
+        "✗ This publish took too long and had to be restarted.",
+        "",
+        ...unchangedLines(address, liveVersion),
+        "",
+        "  Publish again:  vincentt publish",
+        "",
+    ];
+}
+/** All three retries failed. "Nothing was lost" is the true and load-bearing sentence. */
+export function flipFailed(address, liveVersion) {
+    return [
+        "",
+        "✗ Your files uploaded, but the address didn't switch over.",
+        "",
+        liveVersion === undefined
+            ? `  ${address} is unchanged. Nothing was lost.`
+            : `  ${address} is still serving v${liveVersion}. Nothing was lost.`,
+        "",
+        "  Try again:  vincentt publish",
+        "",
+    ];
+}
+/**
+ * Two sentences, no explanation of version allocation. The real case is a
+ * teammate and an agent publishing in the same second, and "someone else
+ * published this project" tells the creator to check with a person before
+ * re-running — the correct next action, and not something a retry loop can do
+ * for them.
+ */
+export function publishContended() {
+    return [
+        "",
+        "✗ Someone else published this project at the same moment.",
+        "",
+        "  Your live address is unchanged. Publish again:  vincentt publish",
+        "",
+    ];
+}
+/**
+ * The commit found fewer objects than the manifest declared. The response
+ * carries COUNTS, never paths, so the CLI diffs against its OWN manifest and
+ * prints its own strings.
+ */
+export function publishIncomplete(address, counts, liveVersion) {
+    const missing = counts.missing ?? 0;
+    const mismatched = counts.mismatched ?? 0;
+    const what = mismatched > 0 && missing > 0
+        ? `${missing} file${missing === 1 ? "" : "s"} didn't arrive and ${mismatched} changed while uploading`
+        : mismatched > 0
+            ? `${mismatched} file${mismatched === 1 ? "" : "s"} changed while uploading`
+            : `${missing} file${missing === 1 ? "" : "s"} didn't arrive`;
+    return [
+        "",
+        `✗ The upload didn't complete — ${what}.`,
+        "",
+        ...unchangedLines(address, liveVersion),
+        "",
+        "  Rebuild if anything changed, then publish again:  vincentt publish",
+        "",
+    ];
+}
+/** A file's bytes changed under the CLI between hashing and PUT. Names the file. */
+export function badDigest(filePath, address, liveVersion) {
+    return [
+        "",
+        `✗ ${filePath} changed while uploading — rebuild and publish again.`,
+        "",
+        ...unchangedLines(address, liveVersion),
+        "",
+        "  Rebuild, then publish again:  npm run build",
+        "",
+    ];
+}
+/**
+ * Every failure states the live address is unchanged, because a creator whose
+ * publish just failed is asking exactly one question first.
+ */
+function unchangedLines(address, liveVersion) {
+    if (liveVersion === undefined) {
+        return [`  Your live address is unchanged — ${address}.`];
+    }
+    return [
+        `  Your live address is unchanged — ${address} is still`,
+        `  serving v${liveVersion}.`,
+    ];
+}
+export function tooLargeFromServer(observed, limit) {
+    return [
+        "",
+        "✗ This build is too large to publish.",
+        "",
+        ...alignedPair(["your dist/", formatBytes(observed)], ["the limit", formatLimit(limit)]),
+        "",
+        "  Compress or externalise the big ones, rebuild, then publish again.",
+        "",
+        "  Nothing was uploaded.",
+        "",
+    ];
+}
+export function rateLimited(retryAfterSec) {
+    return [
+        "",
+        `✗ Too many publishes recently. Try again in ${approxWait(retryAfterSec)}.`,
+        "",
+        "  Publish again then:  vincentt publish",
+        "",
+    ];
+}
+function approxWait(seconds) {
+    if (seconds < 90)
+        return "about a minute";
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60)
+        return `about ${minutes} minutes`;
+    const hours = Math.round(minutes / 60);
+    return `about ${hours} hour${hours === 1 ? "" : "s"}`;
+}
+// ---- Flow L30, the console-only verbs ----------------------------------------
+/**
+ * The same block serves rollback, unpublish, republish, versions, revert and
+ * take-offline. These are the words a creator will actually type, and every one
+ * of them lands on one screen that names the real home. A bare "unknown command"
+ * here would be the product failing to answer a question it knows the answer to.
+ *
+ * The reason is given in one clause and it is the honest one. Not "not
+ * supported", not "coming soon" — neither is true.
+ *
+ * IF THE FOLDER IS NOT LINKED THE LAST TWO LINES ARE DROPPED. The CLI does not
+ * know which project they meant, and guessing a console URL would be worse than
+ * none.
+ */
+export function consoleVerb(verb, versionsUrl) {
+    const out = [
+        `✗ There's no \`${verb}\` command.`,
+        "",
+        "  Rolling back, taking an address offline, and putting it back online are",
+        "  console actions — they change what a permanent address serves, and that",
+        "  belongs on a screen where you can see every version first.",
+        "",
+    ];
+    if (versionsUrl) {
+        out.push("  Open the project's Versions tab:", `  ${versionsUrl}`, "");
+    }
+    return out;
+}
+/** The six verbs that land on that block. */
+export const CONSOLE_ONLY_VERBS = [
+    "rollback",
+    "unpublish",
+    "republish",
+    "versions",
+    "revert",
+    "take-offline",
+];

package/dist/publish/defaults.d.ts

@@ -0,0 +1,16 @@
+/** One entry per known v2-template default, across template versions. */
+export declare const TEMPLATE_DEFAULT_TITLES: readonly string[];
+export declare const TEMPLATE_DEFAULT_DESCRIPTIONS: readonly string[];
+/**
+ * Only paths that are distinctively the TEMPLATE'S. `/og.png` is deliberately
+ * absent: it is the most common filename a creator picks for their own social
+ * image, so listing it would tell a creator who did the work that they did not.
+ * A placeholder still sitting at `/og.png` is indistinguishable from a real one
+ * without reading the bytes, which the CLI does not do — the dead-image check
+ * carries the real failure instead.
+ */
+export declare const TEMPLATE_DEFAULT_IMAGES: readonly string[];
+/** The framework names a `<title>` should never be. Feeds the generic-shape heuristic. */
+export declare const FRAMEWORK_NAMES: readonly string[];
+/** Corpus membership is exact after trimming and case-folding. */
+export declare function inCorpus(value: string, corpus: readonly string[]): boolean;

package/dist/publish/defaults.js

@@ -0,0 +1,52 @@
+// The CLI-bundled corpus of known v2-template default strings — the
+// high-confidence half of D-Template-default-detection-is-both.
+//
+// It ships WITH the CLI, versioned with it, and extending it is a two-line diff.
+// It rots as the template changes; the structural heuristics in classify.ts are
+// what carry the design when it does.
+/** One entry per known v2-template default, across template versions. */
+export const TEMPLATE_DEFAULT_TITLES = [
+    "Vite + React",
+    "Vite + React + TS",
+    "Vite App",
+    "React App",
+    "Vincentt XR App",
+    "Vincentt AR Experience",
+    "My AR Experience",
+];
+export const TEMPLATE_DEFAULT_DESCRIPTIONS = [
+    "An AR experience built with Vincentt",
+    "An AR experience built with Vincentt.",
+    "A Vincentt XR experience",
+    "Web site created using create-react-app",
+];
+/**
+ * Only paths that are distinctively the TEMPLATE'S. `/og.png` is deliberately
+ * absent: it is the most common filename a creator picks for their own social
+ * image, so listing it would tell a creator who did the work that they did not.
+ * A placeholder still sitting at `/og.png` is indistinguishable from a real one
+ * without reading the bytes, which the CLI does not do — the dead-image check
+ * carries the real failure instead.
+ */
+export const TEMPLATE_DEFAULT_IMAGES = [
+    "/og-placeholder.png",
+    "/vite.svg",
+    "/placeholder-social.png",
+];
+/** The framework names a `<title>` should never be. Feeds the generic-shape heuristic. */
+export const FRAMEWORK_NAMES = [
+    "vite",
+    "react",
+    "vite + react",
+    "next.js",
+    "nextjs",
+    "app",
+    "index",
+    "document",
+    "untitled",
+];
+/** Corpus membership is exact after trimming and case-folding. */
+export function inCorpus(value, corpus) {
+    const v = value.trim().toLowerCase();
+    return corpus.some((entry) => entry.trim().toLowerCase() === v);
+}