@buildinternet/uploads 0.5.0 → 0.7.0

package/dist/commands.js

@@ -6,12 +6,13 @@ import { resolvePutDefaults, workspaceMismatch, workspaceFromToken, } from "./co
 import { buildMarkdown } from "./embed.js";
 import { UploadsError } from "./errors.js";
 import { writeJson, writeStdout } from "./io.js";
-import { ghAttachmentKey, ghKeyPrefix, attachmentsCommentBody, } from "./github.js";
+import { ghAttachmentKey, ghKeyPrefix, attachmentsCommentBody, normalizeGithubCoordinate, } from "./github.js";
 import { resolveRepo, resolveCurrentPullRequest, execRunner, upsertAttachmentsComment, } from "./github-gh.js";
 import { resolvePutPrefix } from "./destinations.js";
 import { optimizeImageForUpload, rewriteKeyExtension, } from "./optimize.js";
 import { applyFrame, resolveFrameId } from "./frame.js";
 import { buildCliProvenance } from "./provenance.js";
+import { packageVersion } from "./package-version.js";
 // --- put ---
 const PUT_HELP = `uploads put <file> [options]
 
@@ -50,13 +51,15 @@ Options:
   --format human|url|markdown|json
   --pr <num>            Attach to a pull request: key gh/<owner>/<repo>/pull/<num>/<name> (stable URL, no hash)
   --issue <num>         Attach to an issue: key gh/<owner>/<repo>/issues/<num>/<name>
-  --comment             With --pr/--issue: create/update the attachments comment via your local gh auth
+  --comment             With --pr/--issue: update one managed comment with attachments and linked galleries via local gh auth
+  --gallery <id>         Add the uploaded object to this public gallery
 
 Examples:
   uploads put ./shot.png --repo myorg/myapp --ref 1722 --alt "New cards" --width 700
   uploads put ./mobile.png --frame phone
   uploads put ./ui.png --frame browser --frame-url "https://app.example/settings"
   uploads put ./shot.png --destination screenshots
+  uploads put ./after.png --gallery gal_example
 `;
 /**
  * Turns a pr/issue pair (+ optional repo) into a GhTarget; undefined when
@@ -158,11 +161,43 @@ function frameOptionsFromFlags(flags) {
  */
 export async function syncAttachmentsComment(client, target, run) {
     const items = (await client.listAll({ prefix: ghKeyPrefix(target) })).map(({ key, url }) => ({ key, url }));
-    if (items.length === 0)
+    const galleries = [];
+    let cursor;
+    do {
+        const page = await client.findGalleriesByReference({
+            provider: "github",
+            // GitHub references intentionally do not distinguish PRs from issues.
+            coordinate: `${target.repo.toLowerCase()}#${target.num}`,
+            cursor,
+        });
+        galleries.push(...page.galleries.map(({ id, title, url }) => ({ title, url, id })));
+        cursor = page.nextCursor ?? undefined;
+    } while (cursor);
+    const previewGalleries = await Promise.all(galleries.map(async ({ id, ...gallery }) => {
+        try {
+            const detail = await client.getGallery(id);
+            return {
+                ...gallery,
+                previews: detail.items
+                    .filter((item) => item.status === "available" && item.url && item.contentType?.startsWith("image/"))
+                    .slice(0, 3)
+                    .map((item) => ({
+                    url: item.url,
+                    alt: item.altText ?? item.objectKey,
+                    itemUrl: item.pageUrl,
+                })),
+            };
+        }
+        catch {
+            // A deleted or temporarily unavailable gallery still gets a safe title link.
+            return gallery;
+        }
+    }));
+    if (items.length === 0 && previewGalleries.length === 0)
         return { action: "skipped", count: 0 };
-    const body = attachmentsCommentBody(items);
+    const body = attachmentsCommentBody(items, previewGalleries);
     const { created } = upsertAttachmentsComment(target, body, run);
-    return { action: created ? "created" : "updated", count: items.length };
+    return { action: created ? "created" : "updated", count: items.length + previewGalleries.length };
 }
 // --- attach ---
 const ATTACH_HELP = `uploads attach <file...> [options]
@@ -302,6 +337,7 @@ export async function runPut(ctx, args, help = false, run = execRunner) {
     const prefixFlag = flagString(parsed.flags, "--prefix");
     const ghTarget = ghTargetFromFlags(parsed.flags, run);
     const wantComment = parsed.flags.has("--comment");
+    const galleryId = flagString(parsed.flags, "--gallery");
     if (wantComment && typeof parsed.flags.get("--comment") === "string") {
         throw new UsageError("--comment takes no value — place it after the file argument");
     }
@@ -386,6 +422,22 @@ export async function runPut(ctx, args, help = false, run = execRunner) {
         }),
     });
     const markdown = buildMarkdown(result.url, { alt, width });
+    let gallery;
+    if (galleryId) {
+        try {
+            // Gallery mutations use optimistic versions. Fetch immediately before this
+            // mutation so `put --gallery` composes safely with other CLI writers.
+            const current = await ctx.client.getGallery(galleryId);
+            const item = await ctx.client.addGalleryItem(galleryId, result.key, {
+                expectedVersion: current.version,
+                altText: alt,
+            });
+            gallery = { id: galleryId, url: current.url, item };
+        }
+        catch (err) {
+            gallery = { id: galleryId, error: galleryError(err) };
+        }
+    }
     const optimizeMeta = {
         optimized: prepared.optimized,
         skippedReason: prepared.skippedReason,
@@ -398,7 +450,13 @@ export async function runPut(ctx, args, help = false, run = execRunner) {
     }
     switch (format) {
         case "json":
-            await writeJson({ ...result, markdown, optimize: optimizeMeta, frame: prepared.frame });
+            await writeJson({
+                ...result,
+                markdown,
+                optimize: optimizeMeta,
+                frame: prepared.frame,
+                gallery,
+            });
             break;
         case "url":
             await writeStdout(`${result.url}\n`);
@@ -407,7 +465,13 @@ export async function runPut(ctx, args, help = false, run = execRunner) {
             await writeStdout(`${markdown}\n`);
             break;
         default:
-            await writeStdout(`URL: ${result.url}\nMARKDOWN: ${markdown}\n`);
+            await writeStdout(`URL: ${result.url}\nMARKDOWN: ${markdown}${gallery?.url ? `\nGALLERY: ${gallery.url}` : ""}\n`);
+    }
+    if (gallery?.url && format !== "human") {
+        process.stderr.write(`gallery: ${gallery.url}\n`);
+    }
+    if (gallery?.error) {
+        process.stderr.write(`warning: upload succeeded but adding it to gallery ${gallery.id} failed: ${gallery.error.message}\n`);
     }
     if (wantComment && ghTarget) {
         try {
@@ -421,7 +485,222 @@ export async function runPut(ctx, args, help = false, run = execRunner) {
             process.stderr.write(`warning: upload succeeded but the GitHub comment failed (is gh installed and authenticated?): ${err instanceof Error ? err.message : String(err)}\n`);
         }
     }
-    return 0;
+    return gallery?.error ? 1 : 0;
+}
+function galleryError(err) {
+    if (err instanceof UploadsError)
+        return { message: err.message, code: err.code, status: err.status };
+    return { message: err instanceof Error ? err.message : String(err) };
+}
+// --- galleries ---
+const GALLERY_HELP = `uploads gallery <command> [args]
+
+Public galleries can be viewed by anyone who knows the URL. Do not add sensitive media.
+Deleting a gallery only removes the gallery record; it never deletes its uploaded objects.
+
+Commands:
+  create --title <title> [--description <text>]
+  show <gallery-id>
+  list [--limit <n>] [--cursor <c>] [--all]
+  delete <gallery-id>
+  add <gallery-id> <object-key...> [--caption <text>] [--alt <text>]
+  link <gallery-id> --github <owner/repo#number|github-url>
+  unlink <gallery-id> --github <owner/repo#number|github-url>
+  list --github <owner/repo#number|github-url> [--limit <n>] [--cursor <c>] [--all]
+
+Examples:
+  uploads gallery create --title "Settings redesign"
+  uploads gallery add gal_example screenshots/app/after.webp --alt "Updated settings page"
+  uploads gallery show gal_example
+  uploads gallery link gal_example --github buildinternet/uploads#58
+  uploads gallery list --github https://github.com/buildinternet/uploads/pull/58
+`;
+function githubCoordinateFromFlags(flags) {
+    const value = flagString(flags, "--github");
+    if (!value)
+        throw new UsageError("--github requires an owner/repo#number coordinate or GitHub issue/PR URL");
+    const normalized = normalizeGithubCoordinate(value);
+    if (!normalized)
+        throw new UsageError("--github must be owner/repo#number or an https://github.com/.../issues|pull/number URL");
+    return normalized.coordinate;
+}
+export async function runGallery(ctx, args, help = false) {
+    const parsed = parseCommandArgs(args);
+    const action = parsed.positionals[0];
+    if (help || parsed.help || !action) {
+        process.stderr.write(GALLERY_HELP);
+        return help || parsed.help ? 0 : 2;
+    }
+    switch (action) {
+        case "create": {
+            const title = flagString(parsed.flags, "--title");
+            if (!title)
+                throw new UsageError("gallery create requires --title");
+            const gallery = await ctx.client.createGallery({
+                title,
+                description: flagString(parsed.flags, "--description"),
+            });
+            if (ctx.json)
+                await writeJson(gallery);
+            else
+                await writeStdout(`${gallery.url}\n`);
+            if (!ctx.quiet && !ctx.json)
+                process.stderr.write("warning: galleries are public to anyone with the URL\n");
+            return 0;
+        }
+        case "show": {
+            const id = parsed.positionals[1];
+            if (!id)
+                throw new UsageError("gallery show requires a gallery ID");
+            const gallery = await ctx.client.getGallery(id);
+            if (ctx.json)
+                await writeJson(gallery);
+            else
+                await writeStdout(`${gallery.url}\n`);
+            return 0;
+        }
+        case "list": {
+            const limit = flagInt(parsed.flags, "--limit", "--limit");
+            const cursor = flagString(parsed.flags, "--cursor");
+            const github = parsed.flags.has("--github")
+                ? githubCoordinateFromFlags(parsed.flags)
+                : undefined;
+            if (flagBool(parsed.flags, "--all")) {
+                const galleries = [];
+                let nextCursor = cursor;
+                do {
+                    const page = github
+                        ? await ctx.client.findGalleriesByReference({
+                            provider: "github",
+                            coordinate: github,
+                            limit,
+                            cursor: nextCursor,
+                        })
+                        : await ctx.client.listGalleries({ limit, cursor: nextCursor });
+                    galleries.push(...page.galleries);
+                    nextCursor = page.nextCursor ?? undefined;
+                } while (nextCursor);
+                if (ctx.json)
+                    await writeJson({ galleries, nextCursor: null });
+                else
+                    for (const gallery of galleries)
+                        await writeStdout(`${gallery.id}  ${gallery.url}  ${gallery.title}\n`);
+                return 0;
+            }
+            const page = github
+                ? await ctx.client.findGalleriesByReference({
+                    provider: "github",
+                    coordinate: github,
+                    limit,
+                    cursor,
+                })
+                : await ctx.client.listGalleries({ limit, cursor });
+            if (ctx.json)
+                await writeJson(page);
+            else {
+                for (const gallery of page.galleries)
+                    await writeStdout(`${gallery.id}  ${gallery.url}  ${gallery.title}\n`);
+                if (page.nextCursor)
+                    process.stderr.write(`cursor: ${page.nextCursor}\n`);
+            }
+            return 0;
+        }
+        case "link": {
+            const id = parsed.positionals[1];
+            if (!id)
+                throw new UsageError("gallery link requires a gallery ID");
+            const coordinate = githubCoordinateFromFlags(parsed.flags);
+            const current = await ctx.client.getGallery(id);
+            const reference = await ctx.client.linkGalleryExternalReference(id, {
+                expectedVersion: current.version,
+                provider: "github",
+                coordinate,
+            });
+            if (ctx.json)
+                await writeJson({ galleryId: id, reference });
+            else
+                await writeStdout((reference.canonicalUrl ?? reference.coordinate) + "\n");
+            return 0;
+        }
+        case "unlink": {
+            const id = parsed.positionals[1];
+            if (!id)
+                throw new UsageError("gallery unlink requires a gallery ID");
+            const coordinate = githubCoordinateFromFlags(parsed.flags);
+            const references = await ctx.client.listGalleryExternalReferences(id);
+            const reference = references.references.find((entry) => entry.provider === "github" && entry.coordinate === coordinate);
+            if (!reference) {
+                const output = { galleryId: id, coordinate, deleted: false };
+                if (ctx.json)
+                    await writeJson(output);
+                else if (!ctx.quiet)
+                    process.stderr.write("GitHub reference was already absent\n");
+                return 0;
+            }
+            const current = await ctx.client.getGallery(id);
+            const result = await ctx.client.unlinkGalleryExternalReference(id, reference.id, {
+                expectedVersion: current.version,
+            });
+            if (ctx.json)
+                await writeJson({ galleryId: id, coordinate, ...result });
+            else if (!ctx.quiet)
+                process.stderr.write("unlinked " + coordinate + "\n");
+            return 0;
+        }
+        case "delete": {
+            const id = parsed.positionals[1];
+            if (!id)
+                throw new UsageError("gallery delete requires a gallery ID");
+            const current = await ctx.client.getGallery(id);
+            const result = await ctx.client.deleteGallery(id, { expectedVersion: current.version });
+            if (ctx.json)
+                await writeJson(result);
+            else if (!ctx.quiet)
+                process.stderr.write(`deleted gallery ${result.id} (objects kept)\n`);
+            return 0;
+        }
+        case "add": {
+            const id = parsed.positionals[1];
+            const keys = parsed.positionals.slice(2);
+            if (!id || keys.length === 0)
+                throw new UsageError("gallery add requires a gallery ID and one or more object keys");
+            const caption = flagString(parsed.flags, "--caption");
+            const altText = flagString(parsed.flags, "--alt");
+            const added = [];
+            let galleryUrl;
+            const failures = [];
+            for (const objectKey of keys) {
+                try {
+                    // Always re-read before the next write: each add increments the version,
+                    // and this also avoids stale versions after an independent writer.
+                    const current = await ctx.client.getGallery(id);
+                    galleryUrl = current.url;
+                    added.push(await ctx.client.addGalleryItem(id, objectKey, {
+                        expectedVersion: current.version,
+                        caption,
+                        altText,
+                    }));
+                }
+                catch (err) {
+                    failures.push({ objectKey, error: galleryError(err) });
+                }
+            }
+            const output = { galleryId: id, galleryUrl: galleryUrl ?? null, added, failures };
+            if (ctx.json)
+                await writeJson(output);
+            else {
+                if (galleryUrl)
+                    await writeStdout(`GALLERY: ${galleryUrl}\n`);
+                for (const item of added)
+                    await writeStdout(`${item.objectKey}\n`);
+                for (const failure of failures)
+                    process.stderr.write(`warning: could not add ${failure.objectKey}: ${failure.error.message}\n`);
+            }
+            return failures.length === 0 ? 0 : 1;
+        }
+        default:
+            throw new UsageError(`unknown gallery command: ${action}`);
+    }
 }
 // --- list ---
 const LIST_HELP = `uploads list [--prefix <p>] [--pr <num> | --issue <num>] [--repo <owner/name>] [--limit <n>] [--cursor <c>] [--all] [--workspace <name>]
@@ -474,8 +753,13 @@ export async function runList(ctx, args, help = false, run = execRunner) {
 // --- delete ---
 const DELETE_HELP = `uploads delete <key> [--dry-run] [--workspace <name>]
 
+Options:
+  --dry-run             Preview without deleting
+  --workspace, -w <name>
+
 Examples:
   uploads delete screenshots/myapp/42/shot-a1b2c3.png
+  uploads delete screenshots/myapp/42/shot-a1b2c3.png --dry-run
 `;
 export async function runDelete(ctx, args, help = false) {
     const parsed = parseCommandArgs(args);
@@ -643,6 +927,7 @@ Checks API health, token auth, and workspace/token alignment.
 Examples:
   uploads --env-file .env doctor
   uploads --workspace acme --env-file .env doctor
+  uploads doctor --json
 `;
 /** Doctor's health + auth + workspace checks, shared by the CLI and the MCP tool. */
 export async function buildDoctorReport(config, client) {
@@ -689,6 +974,7 @@ export async function buildDoctorReport(config, client) {
     }
     return {
         ok: health.ok && authOk,
+        cliVersion: packageVersion(),
         apiUrl: config.apiUrl,
         workspace: config.workspace,
         workspaceSource: config.workspaceSource,
@@ -713,6 +999,7 @@ export async function runDoctor(ctx, args, help = false) {
         return report.ok ? 0 : 1;
     }
     const lines = [
+        `cli:       @buildinternet/uploads@${report.cliVersion}`,
         `config:    ${report.configPath}${report.configExists ? "" : " (missing)"}`,
         `api:       ${report.apiUrl} (${report.health.ok ? "ok" : "failed"})`,
         `workspace: ${report.workspace}`,

package/dist/github.d.ts

@@ -5,9 +5,16 @@ export interface GhTarget {
     kind: GhTargetKind;
     num: number;
 }
+/** A normalized GitHub issue/PR coordinate used for gallery references. */
+export interface GithubCoordinate {
+    coordinate: string;
+    canonicalUrl: string;
+}
 export declare function isValidRepo(repo: string): boolean;
 /** Parse "owner/name" from a git remote URL (SSH or HTTPS), else undefined. */
 export declare function parseRepoFromRemoteUrl(url: string): string | undefined;
+/** Normalize a GitHub issue or pull-request coordinate for gallery linking. */
+export declare function normalizeGithubCoordinate(value: string): GithubCoordinate | undefined;
 export declare function ghKeyPrefix(target: GhTarget): string;
 /**
  * Stable attachment key: same filename → same key → same public URL, so
@@ -21,6 +28,18 @@ export interface AttachmentItem {
     key: string;
     url: string | null;
 }
+/** A public gallery linked to the PR or issue whose managed comment is syncing. */
+export interface GalleryCommentItem {
+    title: string;
+    /** Canonical URL returned by the API; callers must not synthesize it. */
+    url: string;
+    /** A bounded set of available images; each links to its item page when known, else the gallery. */
+    previews?: {
+        url: string;
+        alt: string;
+        itemUrl?: string;
+    }[];
+}
 /** Default max width for images in the managed attachments comment (HTML img). */
 export declare const ATTACHMENT_IMAGE_WIDTH_DEFAULT = 400;
 /** Portrait / device mockups — keep phones readable, not full-column. */
@@ -32,4 +51,8 @@ export declare const ATTACHMENT_IMAGE_WIDTH_WIDE = 640;
  * practical signal (we don't re-fetch dimensions when rebuilding the comment).
  */
 export declare function attachmentImageWidth(filename: string): number;
-export declare function attachmentsCommentBody(items: AttachmentItem[]): string;
+/**
+ * Render the one marker-owned GitHub comment. When there are no galleries this
+ * intentionally preserves the legacy attachment-only body byte-for-byte.
+ */
+export declare function attachmentsCommentBody(items: AttachmentItem[], galleries?: GalleryCommentItem[]): string;

package/dist/github.js

@@ -10,6 +10,47 @@ export function parseRepoFromRemoteUrl(url) {
     const repo = match?.[1];
     return repo && isValidRepo(repo) ? repo : undefined;
 }
+/** Normalize a GitHub issue or pull-request coordinate for gallery linking. */
+export function normalizeGithubCoordinate(value) {
+    const input = value.trim();
+    let match = /^([^/\s#]+)\/([^/\s#]+)#([1-9][0-9]*)$/.exec(input);
+    if (!match) {
+        try {
+            const url = new URL(input);
+            if (url.protocol !== "https:" ||
+                url.hostname.toLowerCase() !== "github.com" ||
+                url.port ||
+                url.username ||
+                url.password ||
+                url.search ||
+                url.hash)
+                return undefined;
+            match = /^\/([^/]+)\/([^/]+)\/(?:issues|pull)\/([1-9][0-9]*)\/?$/.exec(url.pathname);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!match)
+        return undefined;
+    const [, ownerRaw, repositoryRaw, numberRaw] = match;
+    const repo = ownerRaw + "/" + repositoryRaw;
+    const number = Number(numberRaw);
+    if (!isValidRepo(repo) || !Number.isSafeInteger(number))
+        return undefined;
+    const owner = ownerRaw.toLowerCase();
+    const repository = repositoryRaw.toLowerCase();
+    const coordinate = owner + "/" + repository + "#" + number;
+    return {
+        coordinate,
+        canonicalUrl: "https://github.com/" +
+            encodeURIComponent(owner) +
+            "/" +
+            encodeURIComponent(repository) +
+            "/issues/" +
+            number,
+    };
+}
 export function ghKeyPrefix(target) {
     const [owner, name] = target.repo.split("/");
     return `gh/${sanitizeKeySegment(owner)}/${sanitizeKeySegment(name)}/${target.kind}/${target.num}/`;
@@ -48,9 +89,32 @@ export function attachmentImageWidth(filename) {
 function escapeHtmlAttr(s) {
     return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
 }
-export function attachmentsCommentBody(items) {
+function escapeHtmlText(s) {
+    return escapeHtmlAttr(s).replace(/'/g, "&#39;").replace(/>/g, "&gt;");
+}
+/**
+ * Render the one marker-owned GitHub comment. When there are no galleries this
+ * intentionally preserves the legacy attachment-only body byte-for-byte.
+ */
+export function attachmentsCommentBody(items, galleries = []) {
     const sorted = items.toSorted((a, b) => a.key.localeCompare(b.key));
-    const lines = [ATTACHMENTS_MARKER, "### 📎 Attachments", ""];
+    const sortedGalleries = galleries.toSorted((a, b) => a.title.localeCompare(b.title) || a.url.localeCompare(b.url));
+    const lines = [ATTACHMENTS_MARKER];
+    if (sortedGalleries.length > 0) {
+        lines.push("### 🖼️ Galleries", "");
+        for (const gallery of sortedGalleries) {
+            const href = escapeHtmlAttr(gallery.url);
+            lines.push(`#### <a href="${href}">${escapeHtmlText(gallery.title)}</a>`);
+            for (const preview of gallery.previews ?? []) {
+                const previewHref = preview.itemUrl ? escapeHtmlAttr(preview.itemUrl) : href;
+                lines.push(`<a href="${previewHref}"><img width="320" alt="${escapeHtmlAttr(preview.alt)}" src="${escapeHtmlAttr(preview.url)}"></a>`);
+            }
+            lines.push(`<sub><a href="${href}">Open gallery</a></sub>`, "");
+        }
+        lines.push("");
+    }
+    if (sorted.length > 0 || sortedGalleries.length === 0)
+        lines.push("### 📎 Attachments", "");
     for (const item of sorted) {
         const name = item.key.slice(item.key.lastIndexOf("/") + 1);
         if (item.url && inferContentType(name).startsWith("image/")) {

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { sanitizeKeySegment, sha256Short, deriveRepoFromGit, buildScreenshotKey
 export { BUILTIN_DESTINATIONS, isBuiltinDestination, keyMatchesDestination, resolveDestinationRoot, resolvePutPrefix, type BuiltinDestinationId, } from "./destinations.js";
 export { DEFAULT_API_URL, DEFAULT_WORKSPACE, UPLOADS_CONFIG_KEYS, defaultConfigPath, resolveConfigPath, loadConfigFile, loadEnvFile, resolveApiUrl, resolveConfig, describeConfigSources, redactToken, writeConfigKeys, configValuesFromClient, putDefaultsToConfigValues, resolvePutDefaults, mergePutDefaults, workspaceFromToken, workspaceMismatch, type UploadsClientConfig, type ResolvedConfig, type WorkspaceSource, type ConfigValueSource, type ConfigSources, type UploadsConfigKey, type UploadsConfigValues, type PutDefaults, } from "./config.js";
 export { UploadsError, type UploadsErrorCode } from "./errors.js";
-export { createUploadsClient, type UploadsClient, type PutOptions, type ProvenanceInput, type ListOptions, type PutResult, type ListItem, type ListResult, type HeadResult, type DeleteResult, type HealthResult, type UsageResult, type ReconcileResult, type PurgeExpiredResult, type PurgeExpiredResponse, } from "./client.js";
+export { createUploadsClient, type UploadsClient, type PutOptions, type ProvenanceInput, type ListOptions, type PutResult, type ListItem, type ListResult, type HeadResult, type DeleteResult, type GalleryItem, type Gallery, type GallerySummary, type GalleryListOptions, type GalleryListResult, type CreateGalleryOptions, type AddGalleryItemOptions, type DeleteGalleryOptions, type HealthResult, type UsageResult, type ReconcileResult, type PurgeExpiredResult, type PurgeExpiredResponse, } from "./client.js";
 export { buildCliProvenance } from "./provenance.js";
 export { ATTACHMENTS_MARKER, attachmentsCommentBody, ghAttachmentKey, ghKeyPrefix, isValidRepo, parseRepoFromRemoteUrl, type AttachmentItem, type GhTarget, type GhTargetKind, } from "./github.js";
 export { DEFAULT_OPTIMIZE_MAX_EDGE, DEFAULT_OPTIMIZE_QUALITY, optimizeImageForUpload, rewriteKeyExtension, withImageExtension, type OptimizeImageOptions, type OptimizeImageResult, type OptimizeOutputFormat, } from "./optimize.js";