@hunt-labs/bytekit-sdk 0.7.4 → 0.8.0

package/CHANGELOG.md

@@ -10,6 +10,94 @@ today, see [README.md](./README.md), which remains the authoritative usage guide
 
 ## [Unreleased]
 
+## [0.8.0] - 2026-08-19
+
+### Removed
+
+- **BREAKING: `billing_multiplier` and `billed_bytes` are gone from the scrape success
+  envelope** (#3143). Read `billing` instead — a `BillingNode` that names every factor
+  applied to the charge, the multiplier they compose to, and the resulting billed bytes:
+
+  ```ts
+  // before
+  const spend = res.billed_bytes; // flat, base-endpoint only
+  // after
+  const spend = res.billing?.billed_bytes;
+  const why = res.billing?.factors; // [{ name: 'endpoint', value: 1.5, reason: 'scrape_md' }, …]
+  ```
+
+  This is a correction, not a rename: the two surfaces reported **different numbers for the
+  same charge**. The flat pair carried the BASE-endpoint composition, so a markdown cache hit
+  read `0.5` / `400` while the real charge — and the `X-Billing-Multiplier` header — was
+  `0.75` / `600`; an html-only miss read the per-format credits estimate `1.5` / `150` against
+  an endpoint factor of `1.0` / `100`. The flat pair also never carried the `clean_markdown`
+  ×3 surcharge, so on a successful clean it under-reported the amount billed by two thirds.
+  `billing.multiplier` composes every applied factor behind exactly one rounding, so it is the
+  number that predicts your invoice.
+
+  `billing` is optional and is **absent** on resources that completed before the billing node
+  existed. A pre-node row omits the field rather than reporting a zero node, because a zero
+  node would assert that a real past charge was zero. Test the node for presence
+  (`res.billing !== undefined`, or equivalently a plain truthiness check — `billing` is an
+  object or `undefined`, and an object is always truthy, so the two are the same test here).
+  The hazard is a condition that reaches _into_ the node: `if (res.billing?.billed_bytes)`
+  silently skips a genuine zero-byte charge, because `0` is falsy. Check that the node is
+  present, then read `billed_bytes` from it.
+
+  ```ts
+  // wrong — a real 0-byte charge is falsy and disappears
+  if (res.billing?.billed_bytes) record(res.billing.billed_bytes);
+  // right — presence first, value second
+  if (res.billing) record(res.billing.billed_bytes); // 0 is a charge, not an absence
+  ```
+
+  Two endpoints deliberately carry no node: `/v1/search` is billed per credit and reports
+  `credits_used`, and a single `/v1/fetch` reports its charge through response headers only.
+  The `/v1/logs` row field named `billing_multiplier` is a **different field** and is not the
+  envelope field this release removed. It carries the BASE settled `credits_charged` factor,
+  not the composed real-endpoint value the `X-Billing-Multiplier` header reports — a markdown
+  cache hit reads `0.5` on the logs row and `0.75` on the header.
+
+### Changed
+
+- Generated `ScrapeErrorEnvelope` types now describe terminal asynchronous `scrape.failed`
+  webhook delivery (#1856). No runtime SDK behavior or API shape changed.
+
+### Fixed
+
+- **`GET /v1/logs` entries now carry `billing_multiplier`, as a JSON number** (#3022). The
+  gateway had been serializing that value under an undeclared key `credits`, and as the raw
+  Postgres `NUMERIC(10,2)` string (`"1.50"`), while the OpenAPI spec — and therefore the
+  generated types in `src/generated/api.d.ts` — declared `billing_multiplier?: number | null`.
+  Anything typed against this package read `undefined` for the field.
+
+  **Breaking at the wire level:** the undeclared `credits` key is gone from every `/v1/logs`
+  entry. Code that reached past the generated types to read `credits` must read
+  `billing_multiplier`. No SDK method exposes this endpoint, so the only change inside this
+  package is the regenerated type description.
+
+- **`change_threshold` (on `monitors.create`/`monitors.list`/`monitors.get`/
+  `monitors.update` responses) and `change_pct` (on `monitors.captures.list` entries)
+  now serialize as JSON numbers, not strings** (#3021). Both are Postgres `NUMERIC(5,2)`
+  columns; the gateway passed the raw driver string through unconverted (`"5.00"` /
+  `"7.25"`) while the OpenAPI spec's _request_ schemas already declared `number` — only
+  the _response_ schemas had been (incorrectly) edited to match the buggy string output.
+  This release fixes the gateway serializer and corrects the two response schemas to
+  `number` / `number | null`, so spec and runtime now agree.
+
+  **Breaking at the wire level:** `client.monitors.create()`, `client.monitors.list()`,
+  `client.monitors.get()`, and `client.monitors.update()` now return a JS number for
+  `change_threshold` instead of a string (screenshot-type monitors only); the create
+  response's `MonitorCreateResponse` and every other monitor route serialize through the
+  same `MonitorResponse` schema, so all four are affected identically.
+  `client.monitors.captures.list()` now returns a JS number for `change_pct` instead of a
+  string. Code doing `parseFloat(monitor.change_threshold)` or template-literal
+  interpolation keeps working; strict `typeof x === 'string'` checks or string methods
+  (`.trim()`, `.padStart()`) will now throw. `change_pct` is `null` (not `0`) when there is
+  no prior capture to diff against, unchanged from before. No SDK method-level shape
+  changed otherwise — the only change inside this package is the regenerated type
+  description.
+
 ## [0.7.4] - 2026-08-19
 
 ### Changed
@@ -157,6 +245,16 @@ behave exactly as before.
   Bumping moves the anchor past those comments. The published `0.7.0` artifact is **not** stale in
   any way a consumer can observe — the divergence is comment text only.
 
+- **Corrected a false legacy-name claim carried since the rename (#2950).** The `0.7.0`-era note
+  below said the prior `rapidcrawl`/`@rapidcrawl/sdk` name "remains installable at its last
+  version but is deprecated." Verified 2026-08-13: both `rapidcrawl` and `@rapidcrawl/sdk` return
+  npm `404` ("is not in this registry"), and `npm deprecate` against either fails with the same
+  `404` — there is no published version left for a deprecation notice to attach to, so the claim
+  never held. No registry stub or deprecation was possible to publish; root `CLAUDE.md` carried
+  the same false claim and is corrected alongside this entry. Users of the old names should
+  install `@hunt-labs/bytekit-sdk` directly. No exported function, type, or runtime behavior
+  changes.
+
 ## [0.7.0] - 2026-08-11
 
 ### Added
@@ -538,8 +636,10 @@ against 0.1.0 — read each one before upgrading.
 ### Changed
 
 - Package renamed to `@hunt-labs/bytekit-sdk` (the `@bytekit` npm scope was
-  unobtainable). The prior `rapidcrawl`/`@rapidcrawl/sdk` name remains installable at
-  its last version but is deprecated.
+  unobtainable). ~~The prior `rapidcrawl`/`@rapidcrawl/sdk` name remains installable at
+  its last version but is deprecated.~~ **Corrected in 0.7.1 (see above): that claim
+  does not hold — both names 404 on npm and there is no published version left to
+  deprecate.**
 - Generated API types (`dist/generated/api.d.ts`) are now shipped in the tarball so
   consumers get the typed request/response surface without regenerating from the spec.
 

package/dist/generated/api.d.ts

@@ -1436,6 +1436,93 @@ export interface components {
             next_cursor: string | null;
             has_more: boolean;
         };
+        /**
+         * @description One named multiplicative term in a charge. A factor that did not apply is
+         *     ABSENT from the list rather than present with `value: 1` — an entry reading
+         *     `cache_hit ×1` would claim a cache-hit discount had been applied. The
+         *     `endpoint` factor is the exception: every billed request has an endpoint, so
+         *     it is always listed even when its value is 1.0.
+         */
+        BillingFactor: {
+            /**
+             * @description Closed vocabulary. `endpoint` — the per-endpoint format factor.
+             *     `cache_hit` — the 0.5× replay discount. `clean_markdown` — the 3×
+             *     surcharge, present only when the LLM clean actually succeeded.
+             *     `phase1_render` — the screenshot/recording render-overhead factor,
+             *     which is never composed with `cache_hit` or `clean_markdown`.
+             *     Treat an unrecognised name as a term you do not model rather than as an
+             *     error: the product of all `value`s always equals `multiplier`.
+             * @example endpoint
+             * @enum {string}
+             */
+            name: "endpoint" | "cache_hit" | "clean_markdown" | "phase1_render";
+            /**
+             * @description The multiplicative value of this term.
+             * @example 1.5
+             */
+            value: number;
+            /**
+             * @description Human-readable explanation of why this factor applied — for example the
+             *     endpoint bucket name, or `hit, age 412s`. NOT CONTRACTUAL: this string is
+             *     free text for display and debugging only. Its wording, its format, and
+             *     whether it carries any particular detail may change at any time without a
+             *     version bump. Never parse it, branch on it, or assert on it — read
+             *     `name` and `value` instead.
+             * @example scrape_md
+             */
+            reason: string;
+        };
+        /**
+         * @description The authoritative, self-explaining account of what this call was billed and
+         *     why. `multiplier` is the product of every entry in `factors`, composed in
+         *     list order (`endpoint` → `cache_hit` → `clean_markdown`), and
+         *     `billed_bytes = round(raw_bytes × multiplier)` behind exactly one rounding.
+         *     The factor list is the DEFINITION of the charge; the `X-Raw-Bytes` /
+         *     `X-Billing-Multiplier` / `X-Billable-Bytes` response headers are a rendering
+         *     of this same node, so where a header and this node disagree, the header is
+         *     the bug.
+         *
+         *     Two billable surfaces carry no node, by design rather than by omission:
+         *
+         *     * `POST /v1/search` is billed per credit, not per byte. Its charge is
+         *       reported by `credits_used`; no byte multiplier applies to it and the
+         *       factor vocabulary has no `search` term.
+         *     * Single (non-bulk) `POST /v1/fetch` returns the fetched bytes as the
+         *       response body, so it has no JSON envelope in which to carry a node. Its
+         *       charge is reported by the `X-Raw-Bytes` / `X-Billing-Multiplier` /
+         *       `X-Billable-Bytes` header trio alone. Items under
+         *       `GET /v1/fetch/bulk/{id}` DO carry the node.
+         *
+         *     Historical rows: for a resource that completed before its billing node was
+         *     persisted, this field is OMITTED rather than emitted as a zero node — a zero
+         *     node would assert that a real past charge was zero. Treat absence as "not
+         *     available for this row" and read the charge from `GET /v1/usage`.
+         */
+        BillingNode: {
+            /**
+             * @description The unmultiplied basis of the charge. For byte-billed endpoints this is
+             *     the upstream wire bytes actually transferred. For screenshots and
+             *     recordings it is the Phase 1 HTML fetch's wire bytes — the only proxied
+             *     traffic in the happy path — never the size of the returned PNG/JPEG/MP4
+             *     artifact.
+             * @example 1024
+             */
+            raw_bytes: number;
+            /** @description The named terms whose product is `multiplier`, in composition order. */
+            factors: components["schemas"]["BillingFactor"][];
+            /**
+             * @description The product of every `factors[].value` — the REAL composed multiplier for
+             *     this call, including the per-endpoint format factor. A markdown cache hit
+             *     reads 0.75 here (1.5 × 0.5).
+             * @example 0.75
+             */
+            multiplier: number;
+            /**
+             * @description `round(raw_bytes × multiplier)` — the bandwidth actually settled for this call.
+             * @example 768
+             */
+            billed_bytes: number;
+        };
         ScrapeRequest: {
             /** Format: uri */
             url: string;
@@ -1730,10 +1817,13 @@ export interface components {
             stats?: components["schemas"]["ScrapeStats"];
             /** @description Token-budget accounting. Present only when `token_budget` was supplied in the request. Contains `kept` (tokens in returned markdown), `total` (tokens in full pre-truncation markdown), and `truncated` (whether output was cut). Absent on uncapped requests to avoid noise. */
             markdown_tokens?: components["schemas"]["ScrapeMarkdownTokens"];
-            /** @description The multiplier applied to wire bytes to compute `billed_bytes` for this call (1.0-2.0 for format combinations on a cache miss). The value is pre-clean-markdown: when `clean_markdown: true` and the clean succeeded, the settled usage is 3× this number, and that surcharge is carried by neither this field nor the `X-Billing-Multiplier` response header — so on a successful clean neither surface predicts the amount you are billed. This field reports the BASE-endpoint composition, so every cache hit reads a flat 0.5 here whatever formats were requested — the per-endpoint format factor is applied later, at report time, by `GET /v1/usage/by-endpoint`. It can therefore differ from the `X-Billing-Multiplier` response header, which carries the composed real-endpoint value: a markdown cache hit reads 0.5 in this field and 0.75 in that header. Present whenever this call's billing amount has been finalized; omitted if unavailable. */
-            billing_multiplier?: number;
-            /** @description The actual bandwidth billed for this call — `round(content_length * billing_multiplier)`. Present alongside `billing_multiplier`. */
-            billed_bytes?: number;
+            /**
+             * @description Itemised account of this call's charge — the basis, the named factors
+             *     that composed the multiplier, and the resulting billed bytes. This node
+             *     is the authoritative billing surface for the response body. Omitted for
+             *     rows persisted before the billing node existed.
+             */
+            billing?: components["schemas"]["BillingNode"];
             /** @description Custom metadata provided by the caller in the request `custom` field. Stored verbatim and round-tripped on the synchronous response and webhook delivery. Not included in `GET /v1/scrape/:id`, bulk results, or cached hits. Omitted when no custom metadata was provided. */
             custom?: {
                 [key: string]: unknown;
@@ -1753,6 +1843,7 @@ export interface components {
             cache_age_s?: number;
         };
         /**
+         * @description Terminal asynchronous scrape failures are delivered to subscribers of `failed` as this payload with `X-ByteKit-Event: scrape.failed`.
          * @example {
          *       "schema_version": 1,
          *       "status": "failed",
@@ -1947,6 +2038,13 @@ export interface components {
              */
             file_size_bytes: number | null;
             credits_charged: number | null;
+            /**
+             * @description Itemised account of this capture's charge — the Phase 1 wire bytes it
+             *     was billed on, the `phase1_render` factor, and the resulting billed
+             *     bytes. Omitted for rows that completed before the billing node was
+             *     persisted, and for rows that have not completed.
+             */
+            billing?: components["schemas"]["BillingNode"];
             error_code: string | null;
             error_message: string | null;
             /** Format: date-time */
@@ -2066,6 +2164,13 @@ export interface components {
              */
             file_size_bytes: number | null;
             credits_charged: number | null;
+            /**
+             * @description Itemised account of this capture's charge — the Phase 1 wire bytes it
+             *     was billed on, the `phase1_render` factor, and the resulting billed
+             *     bytes. Omitted for rows that completed before the billing node was
+             *     persisted, and for rows that have not completed.
+             */
+            billing?: components["schemas"]["BillingNode"];
             error_code: string | null;
             error_message: string | null;
             /** Format: date-time */
@@ -2161,7 +2266,7 @@ export interface components {
             webhook_url: string;
             webhook_headers: Record<string, never> | null;
             /** @description Present on screenshot monitors only. */
-            change_threshold?: string;
+            change_threshold?: number;
             /** @description Present on scrape monitors only. */
             scrape_options?: unknown;
             /** @description Present on scrape monitors only. */
@@ -2203,7 +2308,7 @@ export interface components {
             content_hash: string | null;
             previous_hash: string | null;
             hash_distance: number | null;
-            change_pct: string | null;
+            change_pct: number | null;
             has_change: boolean;
             title_changed: boolean | null;
             /**
@@ -2284,6 +2389,12 @@ export interface components {
             cache?: "miss" | "hit" | "bypass";
             /** @description Age in whole seconds of the cached source job (its `completed_at`) replayed on a `cache: hit`. Clamped to ≥ 0 to absorb clock skew. Present only on `cache: hit`; null on `miss`/`bypass`. */
             cache_age_s?: number | null;
+            /**
+             * @description Itemised account of this job's charge — the basis, the named factors
+             *     that composed the multiplier, and the resulting billed bytes. Omitted
+             *     for jobs that completed before the billing node was persisted.
+             */
+            billing?: components["schemas"]["BillingNode"];
             warnings: string[] | null;
             error_code: string | null;
             error_message: string | null;
@@ -3110,7 +3221,7 @@ export interface operations {
                     "X-Raw-Bytes"?: number;
                     /** @description Chargeable bytes — round(X-Raw-Bytes × X-Billing-Multiplier). */
                     "X-Billable-Bytes"?: number;
-                    /** @description Billing multiplier applied to raw bytes to compute billable bytes. */
+                    /** @description Billing multiplier applied to raw bytes to compute billable bytes. A rendering of the response body's `billing` node, which is the authoritative surface: it names each factor that composed this value. Where the two disagree, the node is correct. */
                     "X-Billing-Multiplier"?: number;
                     /** @description HTTP status code returned by the target site during the screenshot capture. */
                     "X-Screenshot-Status-Code"?: number;
@@ -3145,7 +3256,7 @@ export interface operations {
                     "X-Raw-Bytes"?: number;
                     /** @description Chargeable bytes — round(X-Raw-Bytes × X-Billing-Multiplier). */
                     "X-Billable-Bytes"?: number;
-                    /** @description Billing multiplier applied to raw bytes to compute billable bytes. */
+                    /** @description Billing multiplier applied to raw bytes to compute billable bytes. A rendering of the response body's `billing` node, which is the authoritative surface: it names each factor that composed this value. Where the two disagree, the node is correct. */
                     "X-Billing-Multiplier"?: number;
                     [name: string]: unknown;
                 };
@@ -3336,7 +3447,7 @@ export interface operations {
                     "X-Raw-Bytes"?: number;
                     /** @description Chargeable bytes after applying the billing multiplier. Equals round(X-Raw-Bytes × X-Billing-Multiplier). */
                     "X-Billable-Bytes"?: number;
-                    /** @description Bandwidth cost multiplier (e.g. 1.0 for raw_html-only, 1.5 for +markdown/html). Cache hits compose the endpoint format factor: raw 0.5, markdown 0.75. Excludes the `clean_markdown` surcharge, exactly like the `billing_multiplier` body field: when `clean_markdown: true` and the clean succeeded, the settled usage is 3× this header's value, so neither surface predicts the amount you are billed. */
+                    /** @description Bandwidth cost multiplier (e.g. 1.0 for raw_html-only, 1.5 for +markdown/html). Cache hits compose the endpoint format factor: raw 0.5, markdown 0.75. Excludes the `clean_markdown` surcharge: when `clean_markdown: true` and the clean succeeded, the settled usage is 3× this header's value, so this header does not predict the amount you are billed. The response body's `billing` node is the authoritative surface — it DOES carry the `clean_markdown` factor, so its `multiplier` and `billed_bytes` are what you are charged. Where the two disagree, the node is correct. */
                     "X-Billing-Multiplier"?: number;
                     /** @description Credits charged for this scrape (multiplier applied to base 1.0 per format). */
                     "X-Scrape-Credits-Charged"?: number;
@@ -3749,7 +3860,7 @@ export interface operations {
                     "X-Raw-Bytes"?: number;
                     /** @description Chargeable bytes after applying the billing multiplier. Equals round(X-Raw-Bytes × X-Billing-Multiplier). */
                     "X-Billable-Bytes"?: number;
-                    /** @description Bandwidth cost multiplier applied to X-Raw-Bytes. A markdown fetch bills as fetch_md (miss 1.5, hit 0.75); a raw fetch bills 1.0 on a miss, 0.5 on a cache hit. */
+                    /** @description Bandwidth cost multiplier applied to X-Raw-Bytes. A markdown fetch bills as fetch_md (miss 1.5, hit 0.75); a raw fetch bills 1.0 on a miss, 0.5 on a cache hit. Single `/v1/fetch` returns the fetched bytes as the body, so it carries no `billing` node — this header trio is the ONLY billing surface here. Items under `GET /v1/fetch/bulk/{id}` do carry the node. */
                     "X-Billing-Multiplier"?: number;
                     /** @description Back-compat duplicate of `X-Billing-Multiplier` — identical value on every path. Prefer `X-Billing-Multiplier`; this alias is retained for clients that read the `X-Fetch-*` header family. */
                     "X-Fetch-Billing-Multiplier"?: number;
@@ -3847,7 +3958,7 @@ export interface operations {
                     "X-Raw-Bytes"?: number;
                     /** @description Chargeable bytes after applying the billing multiplier. Equals round(X-Raw-Bytes × X-Billing-Multiplier). */
                     "X-Billable-Bytes"?: number;
-                    /** @description Bandwidth cost multiplier applied to X-Raw-Bytes. A markdown fetch bills as fetch_md (miss 1.5, hit 0.75); a raw fetch bills 1.0 on a miss, 0.5 on a cache hit. */
+                    /** @description Bandwidth cost multiplier applied to X-Raw-Bytes. A markdown fetch bills as fetch_md (miss 1.5, hit 0.75); a raw fetch bills 1.0 on a miss, 0.5 on a cache hit. Single `/v1/fetch` returns the fetched bytes as the body, so it carries no `billing` node — this header trio is the ONLY billing surface here. Items under `GET /v1/fetch/bulk/{id}` do carry the node. */
                     "X-Billing-Multiplier"?: number;
                     /** @description Back-compat duplicate of `X-Billing-Multiplier` — identical value on every path. Prefer `X-Billing-Multiplier`; this alias is retained for clients that read the `X-Fetch-*` header family. */
                     "X-Fetch-Billing-Multiplier"?: number;
@@ -4052,6 +4163,12 @@ export interface operations {
                             content_url: string | null;
                             waf_vendor: string | null;
                             cache_hit: boolean;
+                            /**
+                             * @description Itemised account of this item's charge — the basis, the named factors
+                             *     that composed the multiplier, and the resulting billed bytes. Omitted
+                             *     for rows that completed before the billing node was persisted.
+                             */
+                            billing?: components["schemas"]["BillingNode"];
                             error_code: string | null;
                             error_message: string | null;
                             /** Format: date-time */
@@ -4492,6 +4609,12 @@ export interface operations {
                             /** Format: uri */
                             url: string;
                             credits_charged: number | null;
+                            /**
+                             * @description Itemised account of this item's charge — the basis, the named factors
+                             *     that composed the multiplier, and the resulting billed bytes. Omitted
+                             *     for rows that completed before the billing node was persisted.
+                             */
+                            billing?: components["schemas"]["BillingNode"];
                             error_code: string | null;
                             error_message: string | null;
                             /** Format: date-time */
@@ -4855,7 +4978,7 @@ export interface operations {
                     "X-Sitemap-ID"?: string;
                     /** @description Gzipped results CSV wire bytes — the bandwidth-billing basis. Emitted only when `status: completed`. */
                     "X-Raw-Bytes"?: number;
-                    /** @description Billing multiplier applied to raw bytes (1 for sitemap). Emitted only when `status: completed`. */
+                    /** @description Billing multiplier applied to raw bytes (1 for sitemap). Emitted only when `status: completed`. A rendering of the response body's `billing` node, which is the authoritative surface; where the two disagree, the node is correct. */
                     "X-Billing-Multiplier"?: number;
                     /** @description Billable bytes = round(X-Raw-Bytes × X-Billing-Multiplier). Emitted only when `status: completed`. */
                     "X-Billable-Bytes"?: number;
@@ -5503,7 +5626,7 @@ export interface operations {
                             raw_bytes?: number | null;
                             /** @description Billable bytes — raw_bytes × billing_multiplier, rounded. Mirrors the X-Billable-Bytes response header. null while pending/failed. */
                             billable_bytes?: number | null;
-                            /** @description Billing multiplier applied to raw_bytes (e.g. 1.0 for raw scrape, 1.5 for markdown/screenshot). Unlike the scrape response body field of the same name, this row reports the real-endpoint composition — the one the X-Billing-Multiplier response header carries — so cache hits compose the endpoint format factor and a markdown cache hit reads 0.75 here while the response body field reads 0.5. Mirrors the X-Billing-Multiplier response header. null while pending/failed. */
+                            /** @description BASE billing multiplier persisted for this request — the settled `credits_charged` factor, and the same factor `billable_bytes` above is derived from. Its scale is not uniform and is not a rate you can carry from one row to another: each endpoint persists its own credit unit, and the single and bulk paths of the same endpoint may persist different factors for identical options. Read this as the factor this one row settled at, and see that endpoint's own pricing for what it charges. This is a LOGS ROW field and is NOT the scrape response envelope field — the envelope carries no flat `billing_multiplier` at all; its billing surface is the `billing` node (see BillingNode). This row reports only the base settled factor, so it can differ from `billing.multiplier` and from the X-Billing-Multiplier response header, both of which report the composed real-endpoint value. null while pending/failed. */
                             billing_multiplier?: number | null;
                             duration_ms?: number | null;
                             /** @description How the request originated (single/bulk/monitor). */

package/dist/version.d.ts

@@ -5,4 +5,4 @@
  * outbound request carries — see the emit site in `client.ts`. The header name is spelled
  * only there, so issue #2905's pre-merge gate 1 counts exactly one occurrence in `src/`.
  */
-export declare const SDK_VERSION = "0.7.4";
+export declare const SDK_VERSION = "0.8.0";

package/dist/version.js

@@ -9,4 +9,4 @@
  * outbound request carries — see the emit site in `client.ts`. The header name is spelled
  * only there, so issue #2905's pre-merge gate 1 counts exactly one occurrence in `src/`.
  */
-export const SDK_VERSION = '0.7.4';
+export const SDK_VERSION = '0.8.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hunt-labs/bytekit-sdk",
-  "version": "0.7.4",
+  "version": "0.8.0",
   "description": "Official TypeScript SDK for the ByteKit API",
   "license": "MIT",
   "type": "module",