@buildinternet/uploads 0.1.0

package/dist/config.d.ts

@@ -0,0 +1,37 @@
+export { defaultConfigPath, resolveConfigPath, loadConfigFile, redactToken, writeConfigKeys, configValuesFromClient, putDefaultsToConfigValues, resolvePutDefaults, mergePutDefaults, UPLOADS_CONFIG_KEYS, type UploadsConfigKey, type UploadsConfigValues, type PutDefaults, } from "./config-file.js";
+export interface UploadsClientConfig {
+    apiUrl: string;
+    workspace: string;
+    token: string;
+}
+export declare const DEFAULT_API_URL = "https://api.uploads.sh";
+export declare const DEFAULT_WORKSPACE = "default";
+/** Workspace encoded in minted tokens: `up_<workspace>_…` */
+export declare function workspaceFromToken(token: string): string | undefined;
+export declare function loadEnvFile(path: string): Partial<UploadsClientConfig>;
+/** How the active workspace was chosen (for doctor hints). */
+export type WorkspaceSource = "override" | "env" | "file" | "user-config" | "token" | "default";
+export type ConfigValueSource = "flag" | "env" | "env-file" | "user-config" | "token" | "default";
+export interface ResolvedConfig extends UploadsClientConfig {
+    workspaceSource: WorkspaceSource;
+    configPath: string;
+    configExists: boolean;
+}
+export interface ConfigSources {
+    apiUrl: ConfigValueSource;
+    workspace: WorkspaceSource;
+    token: ConfigValueSource;
+}
+export declare function describeConfigSources(flags?: Partial<UploadsClientConfig> & {
+    envFile?: string;
+}): ConfigSources;
+export declare function resolveApiUrl(flags?: {
+    apiUrl?: string;
+    envFile?: string;
+}): string;
+export declare function resolveConfig(flags?: Partial<UploadsClientConfig> & {
+    envFile?: string;
+    requireToken?: boolean;
+}): ResolvedConfig;
+/** Warn when an explicit workspace override may not match the token's embedded workspace. */
+export declare function workspaceMismatch(config: ResolvedConfig): string | undefined;

package/dist/config.js

@@ -0,0 +1,157 @@
+import { existsSync, readFileSync } from "node:fs";
+import { loadConfigFile, resolveConfigPath } from "./config-file.js";
+import { UploadsError } from "./errors.js";
+export { defaultConfigPath, resolveConfigPath, loadConfigFile, redactToken, writeConfigKeys, configValuesFromClient, putDefaultsToConfigValues, resolvePutDefaults, mergePutDefaults, UPLOADS_CONFIG_KEYS, } from "./config-file.js";
+export const DEFAULT_API_URL = "https://api.uploads.sh";
+export const DEFAULT_WORKSPACE = "default";
+const TOKEN_WORKSPACE_RE = /^up_([a-z0-9][a-z0-9-]{1,62})_/;
+/** Workspace encoded in minted tokens: `up_<workspace>_…` */
+export function workspaceFromToken(token) {
+    return TOKEN_WORKSPACE_RE.exec(token)?.[1];
+}
+export function loadEnvFile(path) {
+    if (!existsSync(path)) {
+        throw new UploadsError(`--env-file not found: ${path}`, "USAGE");
+    }
+    const out = {};
+    for (const line of readFileSync(path, "utf8").split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eq = trimmed.indexOf("=");
+        if (eq === -1)
+            continue;
+        const key = trimmed.slice(0, eq).trim();
+        let value = trimmed.slice(eq + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        if (key === "UPLOADS_API_URL")
+            out.apiUrl = value;
+        else if (key === "UPLOADS_WORKSPACE")
+            out.workspace = value;
+        else if (key === "UPLOADS_TOKEN")
+            out.token = value;
+    }
+    return out;
+}
+function layerFromUserConfig(flags) {
+    if (flags?.envFile)
+        return {};
+    const path = resolveConfigPath(flags);
+    const raw = loadConfigFile(path);
+    return {
+        apiUrl: raw.UPLOADS_API_URL,
+        workspace: raw.UPLOADS_WORKSPACE,
+        token: raw.UPLOADS_TOKEN,
+    };
+}
+function pickApiUrl(flags) {
+    const fromEnvFile = flags?.envFile ? loadEnvFile(flags.envFile) : {};
+    const fromUser = layerFromUserConfig(flags);
+    return (flags?.apiUrl ??
+        process.env.UPLOADS_API_URL ??
+        fromEnvFile.apiUrl ??
+        fromUser.apiUrl ??
+        DEFAULT_API_URL);
+}
+export function describeConfigSources(flags) {
+    const fromEnvFile = flags?.envFile ? loadEnvFile(flags.envFile) : {};
+    const fromUser = layerFromUserConfig(flags);
+    const token = flags?.token ?? process.env.UPLOADS_TOKEN ?? fromEnvFile.token ?? fromUser.token;
+    let apiUrl = "default";
+    if (flags?.apiUrl)
+        apiUrl = "flag";
+    else if (process.env.UPLOADS_API_URL)
+        apiUrl = "env";
+    else if (fromEnvFile.apiUrl)
+        apiUrl = "env-file";
+    else if (fromUser.apiUrl)
+        apiUrl = "user-config";
+    let workspaceSource = "default";
+    if (flags?.workspace)
+        workspaceSource = "override";
+    else if (process.env.UPLOADS_WORKSPACE)
+        workspaceSource = "env";
+    else if (fromEnvFile.workspace)
+        workspaceSource = "file";
+    else if (fromUser.workspace)
+        workspaceSource = "user-config";
+    else if (token && workspaceFromToken(token))
+        workspaceSource = "token";
+    let tokenSource = "default";
+    if (flags?.token)
+        tokenSource = "flag";
+    else if (process.env.UPLOADS_TOKEN)
+        tokenSource = "env";
+    else if (fromEnvFile.token)
+        tokenSource = "env-file";
+    else if (fromUser.token)
+        tokenSource = "user-config";
+    return { apiUrl, workspace: workspaceSource, token: tokenSource };
+}
+export function resolveApiUrl(flags) {
+    return pickApiUrl(flags);
+}
+export function resolveConfig(flags) {
+    const fromEnvFile = flags?.envFile ? loadEnvFile(flags.envFile) : {};
+    const fromUser = layerFromUserConfig(flags);
+    const configPath = resolveConfigPath(flags);
+    const token = flags?.token ?? process.env.UPLOADS_TOKEN ?? fromEnvFile.token ?? fromUser.token;
+    const apiUrl = pickApiUrl(flags);
+    let workspace;
+    let workspaceSource;
+    if (flags?.workspace) {
+        workspace = flags.workspace;
+        workspaceSource = "override";
+    }
+    else if (process.env.UPLOADS_WORKSPACE) {
+        workspace = process.env.UPLOADS_WORKSPACE;
+        workspaceSource = "env";
+    }
+    else if (fromEnvFile.workspace) {
+        workspace = fromEnvFile.workspace;
+        workspaceSource = "file";
+    }
+    else if (fromUser.workspace) {
+        workspace = fromUser.workspace;
+        workspaceSource = "user-config";
+    }
+    else if (token && workspaceFromToken(token)) {
+        workspace = workspaceFromToken(token);
+        workspaceSource = "token";
+    }
+    else {
+        workspace = DEFAULT_WORKSPACE;
+        workspaceSource = "default";
+    }
+    if (flags?.requireToken !== false && !token) {
+        throw new UploadsError(missingTokenMessage(configPath), "MISSING_TOKEN");
+    }
+    return {
+        apiUrl,
+        workspace,
+        token: token ?? "",
+        workspaceSource,
+        configPath,
+        configExists: existsSync(configPath),
+    };
+}
+function missingTokenMessage(configPath) {
+    return [
+        "UPLOADS_TOKEN is required.",
+        `  uploads setup --token <token>         # guided setup → ${configPath}`,
+        `  uploads config init --token <token>   # writes ${configPath}`,
+        "  or set UPLOADS_TOKEN in env, pass --token, or use --env-file",
+    ].join("\n");
+}
+/** Warn when an explicit workspace override may not match the token's embedded workspace. */
+export function workspaceMismatch(config) {
+    const fromToken = workspaceFromToken(config.token);
+    if (!fromToken || fromToken === config.workspace)
+        return undefined;
+    if (config.workspaceSource === "token" || config.workspaceSource === "default")
+        return undefined;
+    return `workspace override "${config.workspace}" (token encodes "${fromToken}") — ensure the token is valid for the override workspace`;
+}

package/dist/embed.d.ts

@@ -0,0 +1,6 @@
+/** GitHub-embed helpers (content type + markdown). */
+export declare function inferContentType(filename: string): string;
+export declare function buildMarkdown(url: string, opts: {
+    alt: string;
+    width?: number;
+}): string;

package/dist/embed.js

@@ -0,0 +1,30 @@
+/** GitHub-embed helpers (content type + markdown). */
+export function inferContentType(filename) {
+    const ext = filename.includes(".")
+        ? filename.slice(filename.lastIndexOf(".") + 1).toLowerCase()
+        : "";
+    switch (ext) {
+        case "png":
+            return "image/png";
+        case "jpg":
+        case "jpeg":
+            return "image/jpeg";
+        case "gif":
+            return "image/gif";
+        case "webp":
+            return "image/webp";
+        case "svg":
+            return "image/svg+xml";
+        case "mp4":
+            return "video/mp4";
+        default:
+            return "application/octet-stream";
+    }
+}
+export function buildMarkdown(url, opts) {
+    if (opts.width) {
+        const alt = opts.alt.replace(/"/g, """);
+        return `<img width="${opts.width}" alt="${alt}" src="${url}">`;
+    }
+    return `![${opts.alt}](${url})`;
+}

package/dist/errors.d.ts

@@ -0,0 +1,6 @@
+export type UploadsErrorCode = "MISSING_TOKEN" | "NO_PUBLIC_URL" | "NOT_FOUND" | "UNAUTHORIZED" | "INVALID_KEY" | "API_ERROR" | "NETWORK" | "USAGE";
+export declare class UploadsError extends Error {
+    readonly code: UploadsErrorCode;
+    readonly status?: number;
+    constructor(message: string, code: UploadsErrorCode, status?: number);
+}

package/dist/errors.js

@@ -0,0 +1,10 @@
+export class UploadsError extends Error {
+    code;
+    status;
+    constructor(message, code, status) {
+        super(message);
+        this.name = "UploadsError";
+        this.code = code;
+        this.status = status;
+    }
+}

package/dist/github-gh.d.ts

@@ -0,0 +1,19 @@
+import { type GhTarget } from "./github.js";
+/** Runs a command and returns stdout; throws on non-zero exit. Injectable for tests. */
+export type CommandRunner = (cmd: string, args: string[], input?: string) => string;
+export declare const execRunner: CommandRunner;
+/**
+ * Resolve "owner/name". Order: explicit --repo (validated) → `gh repo view`
+ * (fork-aware) → parse the origin remote → UsageError.
+ */
+export declare function resolveRepo(explicit: string | undefined, run?: CommandRunner): string;
+/** Resolve the pull request associated with the current branch. */
+export declare function resolveCurrentPullRequest(repo: string, run?: CommandRunner): GhTarget;
+/**
+ * Create the managed attachments comment, or edit it in place if it already
+ * exists. Never touches any other comment. Body is passed via stdin
+ * (`-F body=@-`) so it is never shell-interpolated.
+ */
+export declare function upsertAttachmentsComment(target: GhTarget, body: string, run?: CommandRunner): {
+    created: boolean;
+};

package/dist/github-gh.js

@@ -0,0 +1,93 @@
+import { execFileSync } from "node:child_process";
+import { UsageError } from "./cli-args.js";
+import { ATTACHMENTS_MARKER, isValidRepo, parseRepoFromRemoteUrl, } from "./github.js";
+export const execRunner = (cmd, args, input) => execFileSync(cmd, args, { encoding: "utf8", input, stdio: ["pipe", "pipe", "pipe"] });
+/**
+ * Resolve "owner/name". Order: explicit --repo (validated) → `gh repo view`
+ * (fork-aware) → parse the origin remote → UsageError.
+ */
+export function resolveRepo(explicit, run = execRunner) {
+    if (explicit !== undefined) {
+        if (!isValidRepo(explicit)) {
+            throw new UsageError(`--repo must be owner/name (got: ${explicit})`);
+        }
+        return explicit;
+    }
+    try {
+        const out = run("gh", [
+            "repo",
+            "view",
+            "--json",
+            "nameWithOwner",
+            "--jq",
+            ".nameWithOwner",
+        ]).trim();
+        if (isValidRepo(out))
+            return out;
+    }
+    catch {
+        // gh missing, unauthenticated, or not in a repo — fall through
+    }
+    try {
+        const url = run("git", ["config", "--get", "remote.origin.url"]).trim();
+        const parsed = parseRepoFromRemoteUrl(url);
+        if (parsed)
+            return parsed;
+    }
+    catch {
+        // not a git repo — fall through
+    }
+    throw new UsageError("could not infer repository from git — pass --repo owner/name");
+}
+/** Resolve the pull request associated with the current branch. */
+export function resolveCurrentPullRequest(repo, run = execRunner) {
+    try {
+        const out = run("gh", [
+            "pr",
+            "view",
+            "--repo",
+            repo,
+            "--json",
+            "number",
+            "--jq",
+            ".number",
+        ]).trim();
+        if (/^\d+$/.test(out) && Number(out) > 0) {
+            return { repo, kind: "pull", num: Number.parseInt(out, 10) };
+        }
+    }
+    catch {
+        // Normalize gh's varying errors into a stable, actionable CLI message.
+    }
+    throw new UsageError("could not infer a pull request for the current branch — pass --pr <num> or --issue <num>");
+}
+/**
+ * PR comments live on the issues endpoint, so one path covers PRs and issues.
+ * Only the first 100 comments are searched (accepted v1 limitation).
+ */
+function findManagedComment(target, run) {
+    const raw = run("gh", ["api", `repos/${target.repo}/issues/${target.num}/comments?per_page=100`]);
+    const comments = JSON.parse(raw);
+    return comments.find((c) => typeof c.body === "string" && c.body.includes(ATTACHMENTS_MARKER));
+}
+/**
+ * Create the managed attachments comment, or edit it in place if it already
+ * exists. Never touches any other comment. Body is passed via stdin
+ * (`-F body=@-`) so it is never shell-interpolated.
+ */
+export function upsertAttachmentsComment(target, body, run = execRunner) {
+    const existing = findManagedComment(target, run);
+    if (existing) {
+        run("gh", [
+            "api",
+            `repos/${target.repo}/issues/comments/${existing.id}`,
+            "-X",
+            "PATCH",
+            "-F",
+            "body=@-",
+        ], body);
+        return { created: false };
+    }
+    run("gh", ["api", `repos/${target.repo}/issues/${target.num}/comments`, "-F", "body=@-"], body);
+    return { created: true };
+}

package/dist/github.d.ts

@@ -0,0 +1,24 @@
+export type GhTargetKind = "pull" | "issues";
+export interface GhTarget {
+    /** "owner/name" */
+    repo: string;
+    kind: GhTargetKind;
+    num: number;
+}
+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;
+export declare function ghKeyPrefix(target: GhTarget): string;
+/**
+ * Stable attachment key: same filename → same key → same public URL, so
+ * re-uploading updates every existing embed. Deliberately NO content hash
+ * (unlike buildScreenshotKey).
+ */
+export declare function ghAttachmentKey(target: GhTarget, filename: string): string;
+/** Hidden marker identifying the one comment this CLI manages. Never change it — existing comments are found by exact match. */
+export declare const ATTACHMENTS_MARKER = "<!-- uploads.sh:attachments -->";
+export interface AttachmentItem {
+    key: string;
+    url: string | null;
+}
+export declare function attachmentsCommentBody(items: AttachmentItem[]): string;

package/dist/github.js

@@ -0,0 +1,44 @@
+import { inferContentType } from "./embed.js";
+import { sanitizeKeySegment } from "./keys.js";
+const REPO_RE = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+export function isValidRepo(repo) {
+    return REPO_RE.test(repo);
+}
+/** Parse "owner/name" from a git remote URL (SSH or HTTPS), else undefined. */
+export function parseRepoFromRemoteUrl(url) {
+    const match = url.trim().match(/[/:]([^/:\s]+\/[^/:\s]+?)(?:\.git)?\/?$/);
+    const repo = match?.[1];
+    return repo && isValidRepo(repo) ? repo : undefined;
+}
+export function ghKeyPrefix(target) {
+    const [owner, name] = target.repo.split("/");
+    return `gh/${sanitizeKeySegment(owner)}/${sanitizeKeySegment(name)}/${target.kind}/${target.num}/`;
+}
+/**
+ * Stable attachment key: same filename → same key → same public URL, so
+ * re-uploading updates every existing embed. Deliberately NO content hash
+ * (unlike buildScreenshotKey).
+ */
+export function ghAttachmentKey(target, filename) {
+    return `${ghKeyPrefix(target)}${sanitizeKeySegment(filename)}`;
+}
+/** Hidden marker identifying the one comment this CLI manages. Never change it — existing comments are found by exact match. */
+export const ATTACHMENTS_MARKER = "<!-- uploads.sh:attachments -->";
+export function attachmentsCommentBody(items) {
+    const sorted = items.toSorted((a, b) => a.key.localeCompare(b.key));
+    const lines = [ATTACHMENTS_MARKER, "### 📎 Attachments", ""];
+    for (const item of sorted) {
+        const name = item.key.slice(item.key.lastIndexOf("/") + 1);
+        if (item.url && inferContentType(name).startsWith("image/")) {
+            lines.push(`![${name}](${item.url})`);
+        }
+        else if (item.url) {
+            lines.push(`- [${name}](${item.url})`);
+        }
+        else {
+            lines.push(`- ${name}`);
+        }
+    }
+    lines.push("", "<sub>Maintained by uploads.sh — re-uploading a file with the same name updates it everywhere it is embedded.</sub>");
+    return lines.join("\n");
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { inferContentType, buildMarkdown } from "./embed.js";
+export { sanitizeKeySegment, sha256Short, deriveRepoFromGit, buildScreenshotKey } from "./keys.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 ListOptions, type PutResult, type ListItem, type ListResult, type HeadResult, type DeleteResult, type HealthResult, } from "./client.js";
+export { ATTACHMENTS_MARKER, attachmentsCommentBody, ghAttachmentKey, ghKeyPrefix, isValidRepo, parseRepoFromRemoteUrl, type AttachmentItem, type GhTarget, type GhTargetKind, } from "./github.js";
+export { execRunner, resolveRepo, upsertAttachmentsComment, type CommandRunner, } from "./github-gh.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export { inferContentType, buildMarkdown } from "./embed.js";
+export { sanitizeKeySegment, sha256Short, deriveRepoFromGit, buildScreenshotKey } from "./keys.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, } from "./config.js";
+export { UploadsError } from "./errors.js";
+export { createUploadsClient, } from "./client.js";
+export { ATTACHMENTS_MARKER, attachmentsCommentBody, ghAttachmentKey, ghKeyPrefix, isValidRepo, parseRepoFromRemoteUrl, } from "./github.js";
+export { execRunner, resolveRepo, upsertAttachmentsComment, } from "./github-gh.js";

package/dist/keys.d.ts

@@ -0,0 +1,11 @@
+export declare function sanitizeKeySegment(s: string): string;
+export declare function sha256Short(bytes: Uint8Array): Promise<string>;
+export declare function deriveRepoFromGit(): string | undefined;
+export declare function buildScreenshotKey(opts: {
+    filename: string;
+    fileBytes: Uint8Array;
+    prefix?: string;
+    repo?: string;
+    ref?: string;
+    deriveRepoFromGit?: boolean;
+}): Promise<string>;

package/dist/keys.js

@@ -0,0 +1,34 @@
+import { execSync } from "node:child_process";
+export function sanitizeKeySegment(s) {
+    return s.replace(/[^A-Za-z0-9._-]/g, "-");
+}
+export async function sha256Short(bytes) {
+    const hash = await crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
+    return Array.from(new Uint8Array(hash))
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("")
+        .slice(0, 6);
+}
+export function deriveRepoFromGit() {
+    try {
+        const url = execSync("git config --get remote.origin.url", { encoding: "utf8" }).trim();
+        const match = url.match(/[/:]([^/]+?)(?:\.git)?$/);
+        return match?.[1];
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function buildScreenshotKey(opts) {
+    const dot = opts.filename.lastIndexOf(".");
+    const ext = dot >= 0 ? opts.filename.slice(dot + 1) : "";
+    const stem = dot >= 0 ? opts.filename.slice(0, dot) : opts.filename;
+    let repo = opts.repo;
+    if (!repo && opts.deriveRepoFromGit)
+        repo = deriveRepoFromGit();
+    repo = sanitizeKeySegment(repo ?? "misc");
+    const ref = sanitizeKeySegment(opts.ref ?? new Date().toISOString().slice(0, 10));
+    const short = await sha256Short(opts.fileBytes);
+    const prefix = sanitizeKeySegment(opts.prefix ?? "screenshots");
+    return `${prefix}/${repo}/${ref}/${sanitizeKeySegment(stem)}-${short}${ext ? `.${sanitizeKeySegment(ext)}` : ""}`;
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@buildinternet/uploads",
+  "version": "0.1.0",
+  "description": "CLI and client for uploads.sh — workspace-scoped image hosting for GitHub embeds",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/buildinternet/uploads.git",
+    "directory": "packages/uploads"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./agent": {
+      "types": "./dist/agent.d.ts",
+      "import": "./dist/agent.js"
+    }
+  },
+  "bin": {
+    "uploads": "./bin/uploads.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "build": "tsc",
+    "pack:check": "node ./scripts/check-pack.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "peerDependencies": {
+    "files-sdk": "^2.1.0"
+  },
+  "peerDependenciesMeta": {
+    "files-sdk": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "ai": "^6.0.0",
+    "files-sdk": "^2.1.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}