@hirely/sdk 1.0.1 → 1.0.3

package/dist/cache/memory-cache.js

@@ -0,0 +1,26 @@
+/** @internal */
+export class MemoryCache {
+    store = new Map();
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() > entry.expiresAt) {
+            this.store.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value, ttlSeconds) {
+        this.store.set(key, {
+            value,
+            expiresAt: Date.now() + ttlSeconds * 1000,
+        });
+    }
+    delete(key) {
+        this.store.delete(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+}

package/dist/client.js

@@ -0,0 +1,183 @@
+import { RequestClient } from "./http/request.js";
+import { API_KEY_PREFIX, DEFAULT_TIMEOUT_MS, DEFAULT_RETRIES } from "./constants.js";
+import { HirelyValidationError } from "./errors.js";
+import { createProjectsResource } from "./resources/projects.js";
+import { createWorkResource } from "./resources/work.js";
+import { createEducationResource } from "./resources/education.js";
+import { createSkillsResource } from "./resources/skills.js";
+import { createCertificatesResource } from "./resources/certificates.js";
+import { createServicesResource } from "./resources/services.js";
+import { createTestimonialsResource } from "./resources/testimonials.js";
+import { createFaqsResource } from "./resources/faqs.js";
+import { createContactsResource } from "./resources/contacts.js";
+import { createCvResource } from "./resources/cv.js";
+/**
+ * The Hirely SDK client.
+ *
+ * Instantiate once with your public API key and use any method or
+ * resource to fetch your portfolio data from the Hirely API.
+ *
+ * @example Basic usage
+ * ```ts
+ * import Hirely from "@hirely/sdk";
+ *
+ * const hirely = new Hirely({
+ *   apiKey: process.env.HIRELY_API_KEY!,
+ * });
+ *
+ * const portfolio = await hirely.get();
+ * const me        = await hirely.me();
+ * const project   = await hirely.projects.getBySlug("my-app");
+ * ```
+ *
+ * @example With caching and retries
+ * ```ts
+ * const hirely = new Hirely({
+ *   apiKey: process.env.HIRELY_API_KEY!,
+ *   timeout: 10_000,
+ *   retries: 2,
+ *   cache: { enabled: true, ttl: 300 },
+ * });
+ * ```
+ */
+export default class Hirely {
+    /** @internal */
+    http;
+    /**
+     * Projects resource.
+     * - `hirely.projects()` — all public projects
+     * - `hirely.projects.getById(id)` — fetch by MongoDB ID
+     * - `hirely.projects.getBySlug(slug)` — fetch by URL slug
+     */
+    projects;
+    /**
+     * Work experience resource.
+     * - `hirely.work()` — all work experience entries
+     * - `hirely.work.getById(id)` — fetch a single entry
+     */
+    work;
+    /**
+     * Education resource.
+     * - `hirely.education()` — all education entries
+     * - `hirely.education.getById(id)` — fetch a single entry
+     */
+    education;
+    /**
+     * Skills resource.
+     * - `hirely.skills()` — all skills
+     */
+    skills;
+    /**
+     * Certificates resource.
+     * - `hirely.certificates()` — all certificates
+     * - `hirely.certificates.getById(id)` — fetch a single certificate
+     */
+    certificates;
+    /**
+     * Services resource.
+     * - `hirely.services()` — all public services
+     * - `hirely.services.getById(id)` — fetch a single service
+     */
+    services;
+    /**
+     * Testimonials resource (approved and public only).
+     * - `hirely.testimonials()` — all testimonials
+     * - `hirely.testimonials.getById(id)` — fetch a single testimonial
+     */
+    testimonials;
+    /**
+     * FAQ resource.
+     * - `hirely.faqs()` — all FAQ entries
+     * - `hirely.faqs.getById(id)` — fetch a single FAQ
+     */
+    faqs;
+    /**
+     * Contacts resource.
+     * - `hirely.contacts()` — public social links
+     */
+    contacts;
+    /**
+     * CV resource.
+     * - `hirely.cv()` — most recent public CV
+     */
+    cv;
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new HirelyValidationError("Hirely API key is required. Pass it as `apiKey` in the constructor.", 400);
+        }
+        if (!config.apiKey.startsWith(API_KEY_PREFIX)) {
+            throw new HirelyValidationError(`Invalid Hirely API key. Keys must start with "${API_KEY_PREFIX}".`, 400);
+        }
+        this.http = new RequestClient({
+            apiKey: config.apiKey,
+            timeout: config.timeout ?? DEFAULT_TIMEOUT_MS,
+            retries: config.retries ?? DEFAULT_RETRIES,
+            fetchFn: config.fetch ?? globalThis.fetch.bind(globalThis),
+            cacheConfig: config.cache, // ← can be `undefined`
+        });
+        this.projects = createProjectsResource(this.http);
+        this.work = createWorkResource(this.http);
+        this.education = createEducationResource(this.http);
+        this.skills = createSkillsResource(this.http);
+        this.certificates = createCertificatesResource(this.http);
+        this.services = createServicesResource(this.http);
+        this.testimonials = createTestimonialsResource(this.http);
+        this.faqs = createFaqsResource(this.http);
+        this.contacts = createContactsResource(this.http);
+        this.cv = createCvResource(this.http);
+    }
+    /**
+     * Fetches the complete public portfolio in a single request.
+     *
+     * Returns profile, projects, work, education, skills, certificates,
+     * services, testimonials, FAQs, contacts, and CV.
+     *
+     * @param options - Optional per-request options.
+     *
+     * @example
+     * ```ts
+     * const portfolio = await hirely.get();
+     * console.log(portfolio.profile?.firstName);
+     * console.log(portfolio.projects.length);
+     * ```
+     *
+     * @example Next.js Server Component
+     * ```tsx
+     * export default async function Page() {
+     *   const portfolio = await hirely.get();
+     *   return (
+     *     <main>
+     *       <h1>{portfolio.profile?.firstName} {portfolio.profile?.lastName}</h1>
+     *       {portfolio.projects.map((p) => (
+     *         <article key={p._id}><h2>{p.title}</h2></article>
+     *       ))}
+     *     </main>
+     *   );
+     * }
+     * ```
+     */
+    get(options) {
+        return this.http.request("/all", options);
+    }
+    /**
+     * Fetches account information and the full public profile.
+     *
+     * Returns account-level data (username, email, role, plan) plus the
+     * complete profile (name, bio, avatar, location, birthday, etc.).
+     *
+     * @param options - Optional per-request options.
+     *
+     * @example
+     * ```ts
+     * const me = await hirely.me();
+     * console.log(me.userName);              // "mahmoud"
+     * console.log(me.plan);                  // "pro"
+     * console.log(me.profile?.firstName);    // "Mahmoud"
+     * console.log(me.profile?.positionName); // "Full-Stack Developer"
+     * console.log(me.profile?.avatar?.url);  // "https://..."
+     * ```
+     */
+    me(options) {
+        return this.http.request("/me", options);
+    }
+}

package/dist/constants.js

@@ -0,0 +1,12 @@
+/** @internal Base URL for the Hirely public API. Not configurable by consumers. */
+export const BASE_URL = "https://api.hirely.cc/api/v1/sdk";
+/** @internal Required prefix for all Hirely public API keys. */
+export const API_KEY_PREFIX = "hk_pub_";
+/** Default request timeout in milliseconds. */
+export const DEFAULT_TIMEOUT_MS = 30_000;
+/** Default number of retry attempts for transient errors. */
+export const DEFAULT_RETRIES = 2;
+/** HTTP status codes that trigger a retry. */
+export const RETRYABLE_STATUS_CODES = new Set([408, 425, 429, 500, 502, 503, 504]);
+/** Maximum backoff delay between retries in milliseconds. */
+export const MAX_BACKOFF_MS = 30_000;

package/dist/errors.d.ts

@@ -15,12 +15,9 @@
  * ```
  */
 export declare class HirelyError extends Error {
-    /** HTTP status code (0 for network/timeout errors). */
     readonly status: number;
-    /** Machine-readable error code. */
     readonly code: string;
-    /** The request ID from the server, if available. */
-    readonly requestId?: string;
+    readonly requestId: string | undefined;
     constructor(message: string, status: number, code?: string, requestId?: string);
 }
 /**
@@ -84,8 +81,7 @@ export declare class HirelyValidationError extends HirelyError {
  * ```
  */
 export declare class HirelyRateLimitError extends HirelyError {
-    /** Seconds until the rate limit resets (from `Retry-After` header). */
-    readonly retryAfter?: number;
+    readonly retryAfter: number | undefined;
     constructor(message?: string, retryAfter?: number, requestId?: string);
 }
 /**

package/dist/errors.js

@@ -0,0 +1,137 @@
+/**
+ * Base class for all Hirely SDK errors.
+ *
+ * @example
+ * ```ts
+ * import { HirelyError } from "@hirely/sdk";
+ *
+ * try {
+ *   await hirely.get();
+ * } catch (error) {
+ *   if (error instanceof HirelyError) {
+ *     console.error(error.status, error.message);
+ *   }
+ * }
+ * ```
+ */
+export class HirelyError extends Error {
+    status;
+    code;
+    requestId;
+    constructor(message, status, code = "HIRELY_ERROR", requestId) {
+        super(message);
+        this.name = "HirelyError";
+        this.status = status;
+        this.code = code;
+        this.requestId = requestId;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/**
+ * Thrown when the API key is missing, invalid, or revoked (HTTP 401/403).
+ *
+ * @example
+ * ```ts
+ * import { HirelyAuthenticationError } from "@hirely/sdk";
+ *
+ * try {
+ *   await hirely.get();
+ * } catch (error) {
+ *   if (error instanceof HirelyAuthenticationError) {
+ *     console.error("Check your HIRELY_API_KEY.");
+ *   }
+ * }
+ * ```
+ */
+export class HirelyAuthenticationError extends HirelyError {
+    constructor(message = "Invalid or missing API key", status = 401, requestId) {
+        super(message, status, "AUTHENTICATION_ERROR", requestId);
+        this.name = "HirelyAuthenticationError";
+    }
+}
+/**
+ * Thrown when a requested resource does not exist (HTTP 404).
+ *
+ * @example
+ * ```ts
+ * import { HirelyNotFoundError } from "@hirely/sdk";
+ *
+ * try {
+ *   const project = await hirely.projects.getBySlug("nonexistent");
+ * } catch (error) {
+ *   if (error instanceof HirelyNotFoundError) {
+ *     console.log("Project not found");
+ *   }
+ * }
+ * ```
+ */
+export class HirelyNotFoundError extends HirelyError {
+    constructor(message = "Resource not found", requestId) {
+        super(message, 404, "NOT_FOUND", requestId);
+        this.name = "HirelyNotFoundError";
+    }
+}
+/**
+ * Thrown when a request fails validation (HTTP 400/422).
+ */
+export class HirelyValidationError extends HirelyError {
+    constructor(message = "Validation error", status = 422, requestId) {
+        super(message, status, "VALIDATION_ERROR", requestId);
+        this.name = "HirelyValidationError";
+    }
+}
+/**
+ * Thrown when the API rate limit has been exceeded (HTTP 429).
+ *
+ * @example
+ * ```ts
+ * import { HirelyRateLimitError } from "@hirely/sdk";
+ *
+ * try {
+ *   await hirely.get();
+ * } catch (error) {
+ *   if (error instanceof HirelyRateLimitError) {
+ *     console.log(`Retry after ${error.retryAfter}s`);
+ *   }
+ * }
+ * ```
+ */
+export class HirelyRateLimitError extends HirelyError {
+    retryAfter; // ← was `?: number`
+    constructor(message = "Rate limit exceeded", retryAfter, requestId) {
+        super(message, 429, "RATE_LIMIT_EXCEEDED", requestId);
+        this.name = "HirelyRateLimitError";
+        this.retryAfter = retryAfter;
+    }
+}
+/**
+ * Thrown when a request exceeds the configured timeout.
+ *
+ * @example
+ * ```ts
+ * const hirely = new Hirely({ apiKey, timeout: 5000 });
+ *
+ * try {
+ *   await hirely.get();
+ * } catch (error) {
+ *   if (error instanceof HirelyTimeoutError) {
+ *     console.error("Request timed out after 5s");
+ *   }
+ * }
+ * ```
+ */
+export class HirelyTimeoutError extends HirelyError {
+    constructor(message = "Request timed out") {
+        super(message, 0, "TIMEOUT");
+        this.name = "HirelyTimeoutError";
+    }
+}
+/**
+ * Thrown when the Hirely API returns a server-side error (HTTP 5xx).
+ */
+export class HirelyServerError extends HirelyError {
+    constructor(message = "Internal server error", status = 500, requestId) {
+        super(message, status, "SERVER_ERROR", requestId);
+        this.name = "HirelyServerError";
+    }
+}

package/dist/http/request.js

@@ -0,0 +1,138 @@
+import { HirelyError, HirelyAuthenticationError, HirelyNotFoundError, HirelyValidationError, HirelyRateLimitError, HirelyTimeoutError, HirelyServerError, } from "../errors.js";
+import { MemoryCache } from "../cache/memory-cache.js";
+import { BASE_URL, DEFAULT_TIMEOUT_MS, DEFAULT_RETRIES, RETRYABLE_STATUS_CODES, MAX_BACKOFF_MS, } from "../constants.js";
+/** @internal */
+export class RequestClient {
+    apiKey;
+    timeout;
+    retries;
+    fetchFn;
+    cache = null;
+    cacheTtl;
+    constructor(config) {
+        this.apiKey = config.apiKey;
+        this.timeout = config.timeout;
+        this.retries = config.retries;
+        this.fetchFn = config.fetchFn;
+        this.cacheTtl = config.cacheConfig?.ttl ?? 300;
+        if (config.cacheConfig?.enabled) {
+            this.cache = config.cacheConfig.store ?? new MemoryCache();
+        }
+    }
+    buildCacheKey(endpoint) {
+        const keyScope = this.apiKey.slice(-8);
+        return `${keyScope}:${BASE_URL}${endpoint}`;
+    }
+    async fetchWithTimeout(url, init) {
+        if (this.timeout === 0) {
+            return this.fetchFn(url, init);
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            return await this.fetchFn(url, { ...init, signal: controller.signal });
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new HirelyTimeoutError(`Request timed out after ${this.timeout}ms`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    throwForStatus(status, message, requestId) {
+        switch (true) {
+            case status === 401 || status === 403:
+                throw new HirelyAuthenticationError(message, status, requestId);
+            case status === 404:
+                throw new HirelyNotFoundError(message, requestId);
+            case status === 400 || status === 422:
+                throw new HirelyValidationError(message, status, requestId);
+            case status === 429:
+                throw new HirelyRateLimitError(message, undefined, requestId);
+            case status >= 500:
+                throw new HirelyServerError(message, status, requestId);
+            default:
+                throw new HirelyError(message, status, "REQUEST_FAILED", requestId);
+        }
+    }
+    getRetryAfter(headers) {
+        const value = headers.get("retry-after");
+        if (!value)
+            return undefined;
+        const seconds = Number(value);
+        return Number.isFinite(seconds) ? seconds : undefined;
+    }
+    computeBackoff(attempt, retryAfterSeconds) {
+        if (retryAfterSeconds != null) {
+            return Math.min(retryAfterSeconds * 1000, MAX_BACKOFF_MS);
+        }
+        return Math.min(1000 * Math.pow(2, attempt), MAX_BACKOFF_MS);
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async request(endpoint, options) {
+        const bypassCache = options?.cache === false;
+        const cacheKey = this.buildCacheKey(endpoint);
+        if (this.cache && !bypassCache) {
+            const cached = await this.cache.get(cacheKey);
+            if (cached !== undefined)
+                return cached;
+        }
+        const url = `${BASE_URL}${endpoint}`;
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+        };
+        let lastError;
+        for (let attempt = 0; attempt <= this.retries; attempt++) {
+            let response;
+            try {
+                response = await this.fetchWithTimeout(url, { method: "GET", headers });
+            }
+            catch (error) {
+                if (error instanceof HirelyTimeoutError)
+                    throw error;
+                lastError = error;
+                if (attempt < this.retries) {
+                    await this.sleep(this.computeBackoff(attempt));
+                    continue;
+                }
+                throw new HirelyError(error instanceof Error ? error.message : "Network request failed", 0, "NETWORK_ERROR");
+            }
+            const requestId = response.headers.get("x-request-id") ?? undefined;
+            if (response.status === 429 && attempt < this.retries) {
+                const retryAfter = this.getRetryAfter(response.headers);
+                await this.sleep(this.computeBackoff(attempt, retryAfter));
+                continue;
+            }
+            if (RETRYABLE_STATUS_CODES.has(response.status) && response.status !== 429 && attempt < this.retries) {
+                await this.sleep(this.computeBackoff(attempt));
+                continue;
+            }
+            let body;
+            try {
+                body = (await response.json());
+            }
+            catch {
+                if (!response.ok) {
+                    this.throwForStatus(response.status, "Request failed", requestId);
+                }
+                throw new HirelyError("Invalid response from Hirely API", response.status, "PARSE_ERROR", requestId);
+            }
+            if (!response.ok || !body.success) {
+                this.throwForStatus(response.status, body?.message ?? "Request failed", requestId);
+            }
+            const data = body.data;
+            if (this.cache && !bypassCache) {
+                await this.cache.set(cacheKey, data, this.cacheTtl);
+            }
+            return data;
+        }
+        throw lastError ?? new HirelyError("Request failed after retries", 0, "REQUEST_FAILED");
+    }
+}

package/dist/index.d.ts

@@ -14,10 +14,9 @@
  *
  * @module
  */
-export { default } from "./client.js";
-export { default as Hirely } from "./client.js";
+export { default, default as Hirely } from "./client.js";
 export { HirelyError, HirelyAuthenticationError, HirelyNotFoundError, HirelyValidationError, HirelyRateLimitError, HirelyTimeoutError, HirelyServerError, } from "./errors.js";
-export type { HirelyConfig, HirelyCacheConfig, HirelyCache, HirelyRequestOptions, HirelyPortfolio, HirelyMe, HirelyProfile, HirelyProject, HirelyProjectMedia, HirelyWork, HirelyEducation, HirelySkill, HirelyCertificate, HirelyService, HirelyTestimonial, HirelyTestimonialClient, HirelyFaq, HirelyContact, HirелySocialLink, HirelyCV, } from "./types.js";
+export type { HirelyConfig, HirelyCacheConfig, HirelyCache, HirelyRequestOptions, HirelyPortfolio, HirelyMe, HirelyProfile, HirelyProject, HirelyProjectMedia, HirelyWork, HirelyEducation, HirelySkill, HirelyCertificate, HirelyService, HirelyTestimonial, HirelyTestimonialClient, HirelyFaq, HirelyContact, HirelySocialLink, HirelyCV, } from "./types.js";
 export type { ProjectsResource } from "./resources/projects.js";
 export type { WorkResource } from "./resources/work.js";
 export type { EducationResource } from "./resources/education.js";

package/dist/index.js

@@ -1 +1,18 @@
-export{s as Hirely,c as HirelyAuthenticationError,l as HirelyError,y as HirelyNotFoundError,p as HirelyRateLimitError,a as HirelyServerError,H as HirelyTimeoutError,u as HirelyValidationError,o as default};
+/**
+ * @hirely/sdk — Official JavaScript & TypeScript SDK for Hirely.
+ *
+ * @example
+ * ```ts
+ * import Hirely from "@hirely/sdk";
+ *
+ * const hirely = new Hirely({ apiKey: process.env.HIRELY_API_KEY! });
+ *
+ * const portfolio = await hirely.get();
+ * const me        = await hirely.me();
+ * const project   = await hirely.projects.getBySlug("my-app");
+ * ```
+ *
+ * @module
+ */
+export { default, default as Hirely } from "./client.js";
+export { HirelyError, HirelyAuthenticationError, HirelyNotFoundError, HirelyValidationError, HirelyRateLimitError, HirelyTimeoutError, HirelyServerError, } from "./errors.js";

package/dist/resources/certificates.js

@@ -0,0 +1,6 @@
+/** @internal */
+export function createCertificatesResource(http) {
+    const fn = (options) => http.request("/certificates", options);
+    fn.getById = (id, options) => http.request(`/certificates/${id}`, options);
+    return fn;
+}

package/dist/resources/contacts.js

@@ -0,0 +1,4 @@
+/** @internal */
+export function createContactsResource(http) {
+    return (options) => http.request("/contacts", options);
+}

package/dist/resources/cv.js

@@ -0,0 +1,4 @@
+/** @internal */
+export function createCvResource(http) {
+    return (options) => http.request("/cv", options);
+}

package/dist/resources/education.js

@@ -0,0 +1,6 @@
+/** @internal */
+export function createEducationResource(http) {
+    const fn = (options) => http.request("/educations", options);
+    fn.getById = (id, options) => http.request(`/educations/${id}`, options);
+    return fn;
+}

package/dist/resources/faqs.js

@@ -0,0 +1,6 @@
+/** @internal */
+export function createFaqsResource(http) {
+    const fn = (options) => http.request("/faq", options);
+    fn.getById = (id, options) => http.request(`/faq/${id}`, options);
+    return fn;
+}

package/dist/resources/projects.js

@@ -0,0 +1,7 @@
+/** @internal */
+export function createProjectsResource(http) {
+    const fn = (options) => http.request("/projects", options);
+    fn.getById = (id, options) => http.request(`/projects/${id}`, options);
+    fn.getBySlug = (slug, options) => http.request(`/projects/slug/${slug}`, options);
+    return fn;
+}

package/dist/resources/services.js

@@ -0,0 +1,6 @@
+/** @internal */
+export function createServicesResource(http) {
+    const fn = (options) => http.request("/services", options);
+    fn.getById = (id, options) => http.request(`/services/${id}`, options);
+    return fn;
+}

package/dist/resources/skills.js

@@ -0,0 +1,4 @@
+/** @internal */
+export function createSkillsResource(http) {
+    return (options) => http.request("/skills", options);
+}

package/dist/resources/testimonials.js

@@ -0,0 +1,6 @@
+/** @internal */
+export function createTestimonialsResource(http) {
+    const fn = (options) => http.request("/testimonials", options);
+    fn.getById = (id, options) => http.request(`/testimonials/${id}`, options);
+    return fn;
+}

package/dist/resources/work.js

@@ -0,0 +1,6 @@
+/** @internal */
+export function createWorkResource(http) {
+    const fn = (options) => http.request("/works", options);
+    fn.getById = (id, options) => http.request(`/works/${id}`, options);
+    return fn;
+}

package/dist/types.d.ts

@@ -434,10 +434,10 @@ export interface HirelyContact {
     /** MongoDB document ID. */
     _id: string;
     /** List of social/contact links. */
-    socialLinks?: HirелySocialLink[];
+    socialLinks?: HirelySocialLink[];
 }
 /** A single social or contact link. */
-export interface HirелySocialLink {
+export interface HirelySocialLink {
     /** Social platform name (e.g. "github", "linkedIn"). */
     platform: string;
     /** The profile URL. */

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hirely/sdk",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Official JavaScript and TypeScript SDK for connecting your Hirely portfolio to any website or application.",
   "type": "module",
   "exports": {
@@ -28,13 +28,12 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "build:js": "bun build src/index.ts --outdir dist --target node --format esm --minify",
-    "build:types": "tsc -p tsconfig.build.json",
     "build": "bun scripts/build.ts",
     "typecheck": "bunx tsgo --noEmit",
     "test": "bun test",
+    "smoke": "bun scripts/smoke.ts",
     "clean": "rm -rf dist",
-    "prepublishOnly": "bun run clean && bun run typecheck && bun run build && bun test",
+    "prepublishOnly": "bun run clean && bun run typecheck && bun run build && bun run smoke && bun test",
     "release:patch": "npm version patch && git push --follow-tags && npm publish",
     "release:minor": "npm version minor && git push --follow-tags && npm publish",
     "release:major": "npm version major && git push --follow-tags && npm publish"