@hushscript/sdk 0.0.0-stage → 1.0.0

package/dist/index.js

@@ -0,0 +1,3811 @@
+import { inspect } from 'util';
+import createClient from 'openapi-fetch';
+import { setImmediate } from 'timers/promises';
+import { parseBlob } from 'music-metadata';
+import { randomUUID } from 'crypto';
+import { stat, open } from 'fs/promises';
+
+// src/client.ts
+
+// package.json
+var package_default = {
+  version: "1.0.0"};
+
+// src/clock.ts
+var systemClock = {
+  now: () => performance.now(),
+  sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal?.aborted === true) {
+        reject(signal.reason);
+        return;
+      }
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(signal?.reason);
+      };
+      const timer = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+};
+
+// src/camel.ts
+function camelKey(key) {
+  return key.replace(/_([a-z0-9])/g, (_whole, char) => char.toUpperCase());
+}
+function camelize(value) {
+  if (Array.isArray(value)) return value.map(camelize);
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [camelKey(key), camelize(item)])
+    );
+  }
+  return value;
+}
+function unknownFields(raw, known) {
+  const extra = Object.entries(raw).filter(([key]) => !known.has(key));
+  return camelize(Object.fromEntries(extra));
+}
+function camelizeKnown(raw, known) {
+  const own = Object.entries(raw).filter(([key]) => known.has(key));
+  return { ...unknownFields(raw, known), ...camelize(Object.fromEntries(own)) };
+}
+
+// src/generated/catalog.ts
+var ERROR_CATALOG = {
+  "bad_request": { code: 1e3, status: 400, meaning: "The request body could not be parsed, or a required field was missing. Check the request against this operation's schema and resend." },
+  "invalid_email": { code: 1001, status: 400, meaning: "The email address failed format or safety validation (address lists, spoofed display names, control characters and quoted local parts are all rejected). Send a single plain address." },
+  "invalid_password": { code: 1002, status: 400, meaning: "The password did not meet the length bounds this API enforces. Choose a password between the documented minimum and maximum byte length." },
+  "missing_token": { code: 1003, status: 400, meaning: "No longer emitted: GET /api/auth/verify without a token now redirects to the app with ?error=link_expired instead of returning this JSON error. It stays in the catalog, with its code, slug and status unchanged, for clients that may still key on it." },
+  "invalid_locale": { code: 1004, status: 400, meaning: "The requested locale is not one this account or API supports. Use one of the documented locale codes." },
+  "bad_part_number": { code: 1005, status: 400, meaning: "The part number is outside the plan for this upload (below 1 or past the last part for the declared size). Recompute the part count from the declared size and part size." },
+  "no_payment_method": { code: 1006, status: 400, meaning: "No payment method was available to complete this action. Add or select a saved payment method before retrying." },
+  "malformed_event": { code: 1007, status: 400, meaning: "An inbound webhook or event payload could not be parsed or verified. This is not actionable from a normal API client." },
+  "invalid_filename": { code: 1020, status: 422, meaning: "No longer emitted: no current route returns this code. It stays in the catalog, with its code, slug and status unchanged, for clients that may still key on it. It used to mean: The uploaded file's name failed validation. Rename the file to remove unsupported characters and retry." },
+  "duration_out_of_range": { code: 1021, status: 422, meaning: "The declared or verified duration is shorter than 15 seconds or longer than this API's maximum accepted length of 10 hours. Trim or split the recording before uploading." },
+  "size_out_of_range": { code: 1022, status: 422, meaning: "The declared byte size is zero or exceeds this API's maximum accepted upload size. Compress or split the file before uploading." },
+  "part_too_large": { code: 1023, status: 422, meaning: "One uploaded part exceeded the maximum part size this API accepts. Resend that part split into smaller chunks." },
+  "size_exceeded": { code: 1024, status: 422, meaning: "The bytes received for this upload would exceed the size declared at creation. Start a new upload with the correct declared size." },
+  "no_parts": { code: 1025, status: 422, meaning: "The upload was marked complete with no parts recorded. Upload at least one part before calling complete." },
+  "invalid_title": { code: 1026, status: 422, meaning: "The provided title exceeded the maximum length or contained disallowed content. Shorten or sanitize the title and retry." },
+  "invalid_speaker_names": { code: 1027, status: 422, meaning: "The speaker-name mapping was not valid JSON or exceeded the allowed shape. Send a flat object of speaker label to display name." },
+  "too_many_names": { code: 1028, status: 422, meaning: "The speaker-name mapping named more speakers than this API allows on one transcript. Remove entries before retrying." },
+  "invalid_clip": { code: 1029, status: 422, meaning: "The preview clip could not be read as audio. Send a supported audio format within the preview size and duration limits." },
+  "clip_too_long": { code: 1030, status: 422, meaning: "The preview clip exceeds the maximum preview duration. Trim the clip and retry." },
+  "unsupported_format": { code: 1031, status: 422, meaning: "No longer emitted: no current route returns this code. It stays in the catalog, with its code, slug and status unchanged, for clients that may still key on it. It used to mean: The audio container or codec could not be probed by this API. Re-encode to one of the documented supported formats." },
+  "unknown_pack": { code: 1032, status: 422, meaning: "The requested pack id does not exist in this account's catalogue. Read GET /v1/billing/packs for the current, valid pack ids." },
+  "invalid_transcription_options": { code: 1033, status: 422, meaning: "The transcription_options object failed validation (an unsupported language, an invalid combination of options, or an over-limit field). Re-check each option against its documented bounds." },
+  "invalid_edit": { code: 1034, status: 422, meaning: "The submitted transcript edit was not valid for the current body (bad utterance shape or an out-of-range index). Reload the current body before editing." },
+  "too_many_tags": { code: 1035, status: 422, meaning: "The request would leave more tags on the transcript than this API allows. Remove existing tags before adding new ones." },
+  "no_speech": { code: 1036, status: 422, meaning: "No speech was detected in the submitted audio. Confirm the source file actually contains an audio track with speech." },
+  "url_invalid": { code: 1037, status: 400, meaning: "The supplied source URL is not a well-formed https URL. Provide a direct https link to the audio or video file." },
+  "url_blocked": { code: 1038, status: 422, meaning: "The supplied URL resolves to a host or address this API refuses to fetch (internal ranges, this API's own storage, or a disallowed host). Use a public, third-party hosted URL instead." },
+  "url_needs_app": { code: 1039, status: 422, meaning: "This URL source needs interactive authentication this API cannot perform on the caller's behalf. Download the file yourself and upload the bytes directly instead." },
+  "invalid_idempotency_key": { code: 1040, status: 422, meaning: "The supplied idempotency_key was outside the accepted length bounds. Send a key between the documented minimum and maximum length, or omit it." },
+  "upload_incomplete": { code: 1041, status: 422, meaning: "The assembled object was shorter than the size declared at creation, so the hold was released and nothing was billed. Re-upload every part and call complete again." },
+  "url_target_busy": { code: 1042, status: 429, meaning: "This API is already fetching from that target host as fast as it will, so the fetch was refused before it was attempted. This bounds the target site, not the caller: a different source URL will go through immediately, and the same one will after a short wait." },
+  "policy_version_stale": { code: 1043, status: 422, meaning: "accept_terms_version did not match the server's current policy version. The server records its own value, never the caller's, so retry with the current version returned by this same error." },
+  "unauthorized": { code: 2e3, status: 401, meaning: "The bearer token is missing, malformed, expired, or revoked. This is also the answer for a revoked, malformed, or unknown Personal Access Token, so a caller holding a PAT should mint a fresh one rather than retry the same one. Obtain a fresh session token or Personal Access Token and retry with it in the Authorization header." },
+  "invalid_credentials": { code: 2001, status: 401, meaning: "The submitted email/password pair did not match an account. Check the credentials or use the password-reset flow." },
+  "turnstile_failed": { code: 2010, status: 403, meaning: "The Cloudflare Turnstile challenge could not be verified. Re-run the challenge on the client and resend with a fresh token." },
+  "country_restricted": { code: 2011, status: 403, meaning: "This action is not available from the caller's detected jurisdiction. This is a policy decision, not a transient failure; retrying will not help." },
+  "signup_not_allowed": { code: 2012, status: 403, meaning: "New account creation is currently closed for this signup path. Retry later or use an already-provisioned account." },
+  "account_suspended": { code: 2013, status: 403, meaning: "The account is suspended, most commonly due to an open payment dispute. Resolve the dispute or contact support before retrying." },
+  "bad_signature": { code: 2020, status: 400, meaning: "A cryptographic signature on this request could not be verified. Not reachable from this public API; indicates a caller configuration bug elsewhere in the stack." },
+  "org_required": { code: 2021, status: 403, meaning: "This action requires the caller to belong to an organization, and the bearer does not. Join or create an organization first. PATCH /api/org also answers it, writing nothing, when the patch names a field whose right the caller lacks: the billing contact, tax identity and auto_renew need the billing right, every other field the admin right. POST /api/org/invites and PATCH /api/org/members/:user_id answer it too when they hand out or take away the billing right (an invite carrying an explicit is_billing true; a patch naming is_billing) for a caller who does not hold it, except that while no member of the workspace holds the right any admin may grant it (a revoke always needs it). A workspace member removal answers it too when the target holds the billing right and the caller neither holds it nor is that member (a member may always leave; removing a holder needs the right, so the recovery rule above is reachable only after the last holder leaves, revokes their own right, or deletes their account). An invite that leaves is_billing out defaults it to the caller's own right for role admin, so an admin without the billing right inviting an admin sends a plain admin invite and is not refused." },
+  "pat_forbidden": { code: 2022, status: 403, meaning: "This route is not in the Personal Access Token scope map at all, so no token, regardless of scope, can reach it. Use a session bearer for this call instead." },
+  "pat_scope_missing": { code: 2023, status: 403, meaning: "The Personal Access Token does not carry the scope this route requires (see x-required-scope on the operation). Mint or use a token that includes it." },
+  "step_up_required": { code: 2024, status: 403, meaning: "Deleting an account needs proof it is the holder asking. DELETE /api/me carried neither current_password nor email_code, or sent current_password for a password set or changed in the last 7 days, or one the requesting session itself set. Send the current password (set more than 7 days ago, not by this session), or a code sent by POST /api/me/deletion-code." },
+  "card_required": { code: 3e3, status: 402, meaning: "No longer emitted: no current route returns this code. It stays in the catalog, with its code, slug and status unchanged, for clients that may still key on it. It used to mean: This purchase needs a card on file and the account has none. Add a card through the account's payment settings before retrying." },
+  "insufficient_balance": { code: 3001, status: 402, meaning: "The account's balance cannot cover the requested seconds. The error body's needed_seconds and balance_seconds report the shortfall; top up before retrying." },
+  "card_declined": { code: 3002, status: 402, meaning: "No longer emitted: no current route returns this code. It stays in the catalog, with its code, slug and status unchanged, for clients that may still key on it. It used to mean: The card on file was declined when charged. Use a different payment method or contact the card issuer." },
+  "org_insufficient_balance": { code: 3003, status: 402, meaning: "The organization's shared minute pool cannot cover the requested seconds. The error body's org_balance_seconds reports the pool's current balance; an org admin must top it up." },
+  "not_found": { code: 4e3, status: 404, meaning: "No resource exists at this id for the authenticated caller. Confirm the id and that it belongs to this account." },
+  "wrong_state": { code: 4001, status: 409, meaning: "The target resource is not in a state this action allows (for example, an upload that already finished). Read its current state before retrying." },
+  "email_exists": { code: 4002, status: 409, meaning: "An account already exists for this email address. Sign in instead of registering again." },
+  "account_has_active_jobs": { code: 4003, status: 409, meaning: "This action cannot proceed while the account has active transcription jobs. Wait for them to finish, or cancel them, then retry." },
+  "ai_already_generated": { code: 4004, status: 409, meaning: "No longer emitted: no current route returns this code. It stays in the catalog, with its code, slug and status unchanged, for clients that may still key on it. It used to mean: An Insights bundle already exists for this transcript and this call did not ask for a paid regeneration. Pass a mode to request one." },
+  "promo_already_redeemed": { code: 4005, status: 409, meaning: "This promo code has already been redeemed on this account. Each code may be redeemed once per account." },
+  "org_already_member": { code: 4006, status: 409, meaning: "Creating an organization: the caller founded another organization that is still unpaid and either is still a member of it or created it less than 7 days ago (one unpaid founded organization at a time; leaving it does not lift the bound inside the 7 days and does after them; belonging to other organizations does not block it). Accepting an invite: the account is already a member of that organization." },
+  "org_plan_inactive": { code: 4007, status: 409, meaning: "The organization has no active plan, so its pool cannot fund this action. An org admin must renew the plan." },
+  "org_seat_limit": { code: 4008, status: 409, meaning: "The organization is already at its seat limit. Remove a member or increase the plan's seat count before inviting another." },
+  "org_wrong_region": { code: 4009, status: 409, meaning: "The target account's data region does not match the organization's region. Cross-region membership is not supported; the user needs an account in the org's region." },
+  "link_expired": { code: 4010, status: 410, meaning: "The magic link or similar time-boxed link has expired. Request a new one." },
+  "expired": { code: 4011, status: 410, meaning: "The referenced token or session has expired. Request a fresh one and retry." },
+  "invalid_code": { code: 4012, status: 410, meaning: "The submitted one-time code does not match what was issued. Re-check the code or request a new one." },
+  "no_pending": { code: 4013, status: 404, meaning: "No longer emitted: no current route returns this code. It stays in the catalog, with its code, slug and status unchanged, for clients that may still key on it. It used to mean: There is no pending operation of this kind to act on (for example, no pending export). Start the operation before trying to read its result." },
+  "promo_unavailable": { code: 4014, status: 410, meaning: "This promo code is not currently redeemable (expired, not yet active, or exhausted). Check the promotion's terms." },
+  "promo_card_required": { code: 4015, status: 409, meaning: "This promo requires a verified card on file before it can be redeemed. Add a card first." },
+  "invoice_not_found": { code: 4016, status: 404, meaning: "No invoice exists at this id for the caller's organization. Confirm the invoice id from GET /api/org/invoices." },
+  "org_retention_too_loose": { code: 4017, status: 409, meaning: "The requested retention setting exceeds the organization's configured maximum. Request a value at or below the org's ceiling." },
+  "org_plan_invoice_open": { code: 4018, status: 409, meaning: "The organization already has an open, unpaid plan invoice. Settle or wait for it to be superseded before requesting another." },
+  "pat_exchange_invalid": { code: 4019, status: 410, meaning: "The OAuth handoff exchange code is invalid, already used, or expired. Restart the handoff flow to obtain a new code." },
+  "pat_invalid": { code: 4020, status: 422, meaning: "The POST /api/pats request body failed validation: an empty or oversized name, an unknown or empty scope list, created_via outside app or oauth, or an invalid client_label. Fix the request body and retry. A bearer token that is itself malformed, revoked, or unknown never reaches this code; that case answers unauthorized (2000) instead." },
+  "pat_purchase_requires_app": { code: 4021, status: 403, meaning: "This purchase needs full Checkout, which this API cannot open or let the caller complete. Either the request had no quick_payment_method_id, in which case resend with one set to a card already on file (see GET /v1/billing/cards), or the saved card will not go through as attempted (declined, needs a different payment method, or was canceled), in which case retrying the same card changes nothing: fix or replace it, then retry with a brand new idempotency_key, or complete the purchase from the Hushscript app. A card whose issuer wants an interactive challenge is not a decline and answers 4023 instead." },
+  "pat_limit": { code: 4022, status: 409, meaning: "The account already holds the maximum number of Personal Access Tokens. Revoke an unused token before minting another." },
+  "pat_purchase_requires_authentication": { code: 4023, status: 403, meaning: "The saved card is fine, but the issuer wants a challenge (3DS) before this charge can go through. This API cannot open or let the caller complete that challenge, so the purchase is refused rather than left pending. Complete the purchase from the Hushscript app instead, where the holder can go through authentication." },
+  "org_signups_closed": { code: 4024, status: 403, meaning: "Creating a new organization is closed in this environment. Signups are open in every environment today, so this answers only where they were deliberately closed again. Existing organizations keep working normally; every other org route, including renewals, pack purchases, invites, and admin reads, stays open." },
+  "org_plan_frozen": { code: 4025, status: 402, meaning: "The organization's plan lapsed and its 30 day grace window has also passed, so no new organization funded upload is admitted. A job already running still settles normally. Paying a plan renewal clears the freeze right away." },
+  "org_pool_expired": { code: 4026, status: 402, meaning: "The organization's shared minute pool is present but its 365-day rolling clock has lapsed with no purchase, grant, or completed job to renew it. A pack purchase, an included plan grant, or completing another org-funded job all restart the clock for another year." },
+  "org_member_cap_exceeded": { code: 4027, status: 402, meaning: "This pool member has used their whole monthly share of the workspace's pooled seconds. The workspace pool itself may still have a balance; this is the per-member cap, separate from a plain insufficient-balance refusal." },
+  "org_renewal_payment_failed": { code: 4028, status: 402, meaning: "The daily renewal lane charged the organization's stored renewal card and Stripe answered with a structured failure. The invoice stays issued, the failure count goes up by one, a renewal-failed email carrying a fresh Checkout link for that same invoice is sent (flagged as the final attempt once the count reaches the cap of 3), and the lapsed term falls into the ordinary grace window. Once the cap is reached the lane stops retrying this organization automatically -- no further charge attempts, no further emails -- until the open invoice is paid by hand, which resets the count. GET /api/org exposes this as a derived renewal_capped boolean." },
+  "org_no_default_payment_method": { code: 4029, status: 409, meaning: "The chosen payment method is not one of the caller's own saved, fast checkout eligible cards, the caller has no Stripe customer at all, or auto renew was switched on with no renewal card stored yet. All three answer identically so this route can never be used to learn whether a given payment method id exists." },
+  "org_refund_window_closed": { code: 4030, status: 409, meaning: "The operator's signed fee-refund command came more than 30 days after the workspace's plan was first paid for, so the plan fee refund window has closed. No customer route returns this code; the fee refund exists only as that operator command. Packs are never refundable and never reach this check." },
+  "org_refund_not_eligible": { code: 4031, status: 409, meaning: "The target invoice of the operator's signed fee-refund command is not a paid, unrefunded plan invoice of this workspace, or the workspace already took its one refund. No customer route returns this code; the fee refund exists only as that operator command. Packs are never refundable regardless of this check." },
+  "org_refund_currency_mismatch": { code: 4032, status: 409, meaning: "No longer emitted: no current route returns this code. It stays in the catalog, with its code, slug and status unchanged, for clients that may still key on it. The signed admin fee-refund command answers its own currency_mismatch refusal instead. It used to mean: The Stripe charge settled in a currency different from the invoice's currency, so a partial refund amount cannot be computed. Contact support for a manual refund." },
+  "org_tax_id_invalid": { code: 4033, status: 400, meaning: "The tax id or its label does not match a shape this system accepts. This is a shape check only, never a registry lookup against a tax authority." },
+  "agent_signup_pending": { code: 4035, status: 409, meaning: "A signup already exists for this contact_email and has not yet been claimed, refunded, or expired. Wait for it to resolve or use a different contact address." },
+  "agent_claim_invalid": { code: 4036, status: 401, meaning: "The claim secret did not match, or the signup does not exist, has already been claimed, was refunded, or has expired. These cases answer identically on purpose. A confirmed-but-unpaid Checkout Session answers wrong_state (4001) instead once the secret itself has checked out." },
+  "agent_pack_locked": { code: 4037, status: 403, meaning: "An agent account's pack tier does not allow the requested pack yet. A fresh agent account is limited to the small packs; a larger pack unlocks only once enough prior payments have settled past the dispute window. Reached on POST /v1/agent/accounts (signup, always tier 0) and POST /v1/billing/purchase for an agent caller. The response carries details.allowed_packs, the pack ids currently buyable; retry with one of those. Never reached by a human account." },
+  "agent_purchase_capped": { code: 4038, status: 429, meaning: "An agent account has reached its per-credential spend cap for the current rolling window: 3 purchases, paid or declined, in the trailing 24 hours. The cap is counted per account across every credential the account has ever held, not per token, so rotating a credential does not reset it. Reached on POST /v1/billing/purchase for an agent caller, and for a human account's personal access token caller, which has its own cap of the same size counted the same way. A human purchasing through the app is never capped. The response carries details.limit, details.window_seconds and details.retry_after_seconds, and a Retry-After header naming the same wait in seconds." },
+  "org_last_admin": { code: 4039, status: 409, meaning: "A rights change or a member removal would leave the workspace with no member carrying is_admin. This is refused by a count check evaluated inside the update itself, not by a pre-read, so two admins concurrently dropping each other's flag cannot both succeed." },
+  "org_rights_invalid": { code: 4040, status: 422, meaning: "The member rights update carried no changed field, or monthly_cap_seconds fell outside the allowed range for a pooled member cap." },
+  "org_custody_unsupported": { code: 4043, status: 409, meaning: "The requested custody change is refused: the workspace is already firm custody, a custody switch is already scheduled, or the request asks to move to private custody, which is not reversible once transcripts carry an org_id." },
+  "org_reviewer_required": { code: 4044, status: 403, meaning: "The route needs the reviewer right. Carrying the admin flag alone never satisfies it, since the reviewer right is kept deliberately separate." },
+  "org_custodian_required": { code: 4045, status: 409, meaning: "Offboarding a member from a firm-custody workspace named no custodian to receive that member's work product." },
+  "org_custodian_invalid": { code: 4046, status: 422, meaning: "The named custodian is not a reviewer member of this workspace, or is the member being removed. The admin right does not qualify on its own." },
+  "transcript_legal_hold": { code: 4047, status: 409, meaning: "Deletion, an edit (body, translation, cleaned text, revert, retranslate), an AI-output delete or paid regeneration, a retention change or a re-file to another matter was refused because the transcript is under a legal hold, placed by a workspace admin or derived from its matter." },
+  "org_not_member": { code: 4048, status: 403, meaning: "The request named a workspace that the caller does not belong to." },
+  "org_matter_code_required": { code: 4049, status: 422, meaning: "The workspace sets matter_code_policy to required and the upload carried no matter_code. Send one, or ask a workspace admin to relax the policy." },
+  "org_matter_code_invalid": { code: 4050, status: 422, meaning: "matter_code or client_code is longer than 64 characters after trimming. Both are free text fields checked on length alone, and a blank or whitespace-only value is accepted and stored as no code. For a workspace (org) upload, client_code is validated here but the stored value always comes from the resolved matter's client, never from this field; a personal (no org) upload's client_code is stored exactly as sent." },
+  "org_usage_range_invalid": { code: 4051, status: 422, meaning: "GET /api/org/usage: from or to is missing, not a positive unix timestamp, reversed, or spans more than 366 days." },
+  "org_usage_group_invalid": { code: 4052, status: 422, meaning: "GET /api/org/usage: group_by is present and is not member, matter or client." },
+  "org_rebill_rate_invalid": { code: 4053, status: 422, meaning: "PATCH /api/org: rebill_rate_cents_per_hour is negative or above 100000. The rate is report only and never charges anyone." },
+  "org_asset_forbidden": { code: 4054, status: 403, meaning: "A workspace dictionary or prompt preset was created, edited or deleted by a member who holds neither the admin nor the reviewer right." },
+  "org_asset_limit": { code: 4055, status: 409, meaning: "The workspace already owns the maximum number of dictionaries or prompt presets. Delete one first before creating another." },
+  "org_letterhead_invalid": { code: 4056, status: 422, meaning: "PATCH /api/org: letterhead failed shape or length validation. Send null to clear the letterhead instead." },
+  "org_matter_hold_forbidden": { code: 4057, status: 403, meaning: "POST or DELETE /api/org/holds/matter from a workspace that is not in firm custody, or from a member without the reviewer right." },
+  "org_matter_hold_empty": { code: 4058, status: 404, meaning: "POST /api/org/holds/matter: no workspace transcript carries that matter code, so there was nothing to hold." },
+  "org_refund_term_renewed": { code: 4061, status: 409, meaning: "The workspace holds another paid plan term besides the invoice being refunded, so the operator's signed fee-refund command refuses and the refund is handled manually through support. No customer route returns this code; the fee refund exists only as that operator command." },
+  "org_self_grant_refused": { code: 4062, status: 409, meaning: "The member rights update targeted the caller's own row and asked for a right the caller does not already hold. Self-revocation, a self-targeted monthly cap change and a self-grant of the reviewer right are still allowed; a self-grant of the billing right is allowed only while no member of the workspace holds it. Otherwise another admin has to grant the right." },
+  "org_matter_not_found": { code: 4063, status: 404, meaning: "The matter id named in the request does not exist in this workspace." },
+  "org_matter_code_taken": { code: 4064, status: 409, meaning: "Another matter in this workspace already uses that matter code." },
+  "org_matter_closed": { code: 4065, status: 409, meaning: "That matter is closed and cannot take new work." },
+  "org_matter_limit": { code: 4066, status: 409, meaning: "This workspace has reached its configured matter limit." },
+  "org_client_not_found": { code: 4067, status: 404, meaning: "The client id named in the request does not exist in this workspace." },
+  "org_client_code_taken": { code: 4068, status: 409, meaning: "Another client in this workspace already uses that client code." },
+  "org_client_closed": { code: 4069, status: 409, meaning: "That client is closed, so its matters cannot take new work either." },
+  "org_client_limit": { code: 4070, status: 409, meaning: "This workspace has reached its configured client limit." },
+  "deletion_code_invalid": { code: 4071, status: 422, meaning: "The email_code sent to DELETE /api/me is wrong, expired, already used, or has had five wrong guesses. Request a new code with POST /api/me/deletion-code." },
+  "rate_limited": { code: 5e3, status: 429, meaning: "The caller has been rate limited. PAT-authenticated traffic carries a Retry-After header naming the wait in seconds; other rate-limited routes may not." },
+  "too_many_active_jobs": { code: 5001, status: 429, meaning: "The account already has the maximum number of concurrent pipeline jobs in flight. Wait for one to finish before starting another." },
+  "ai_cap_reached": { code: 5002, status: 503, meaning: "The Insights provider's own capacity is temporarily exhausted. Retry the generation after a short delay." },
+  "preview_daily_limit": { code: 5003, status: 429, meaning: "The caller's IP has reached the daily limit for the anonymous preview endpoint. Retry after the daily window resets, or authenticate to use the ordinary upload flow instead." },
+  "provider_error": { code: 6001, status: 502, meaning: "The transcription provider returned an error or could not be reached. This is usually transient; retry after a delay." },
+  "stripe_error": { code: 6002, status: 502, meaning: "The payment provider returned an error or could not be reached. This is usually transient; retry after a delay." },
+  "email_error": { code: 6003, status: 502, meaning: "The transactional email provider could not be reached or refused the message. Not directly actionable by an API caller; the underlying action may still have succeeded." },
+  "internal_error": { code: 9e3, status: 500, meaning: "An unexpected server-side failure occurred. Retry later; if it persists, it is a bug on the backend, not the request." },
+  "transcript_data_missing": { code: 9001, status: 500, meaning: "No longer emitted: no current route returns this code. It stays in the catalog, with its code, slug and status unchanged, for clients that may still key on it. It used to mean: The transcript's stored body could not be found or read where this action expected it. Treat as a transient storage fault and retry, or contact support if it persists." }
+};
+
+// src/generated/hints.ts
+var HINTS = {
+  "unauthorized": "Your token is invalid, revoked or expired. Create a new one in the Hushscript app under Account \u2192 MCP. Changing your password revokes all tokens.",
+  "pat_scope_missing": 'This call needs the "{scope}" permission. Create a token that includes it. For billing, the token also needs "Let this token buy minutes" turned on when you create it, and "Let connected apps buy minutes" must be on in the app under Account \u2192 MCP.',
+  "insufficient_balance": "Not enough minutes: {needed} needed, {balance} available. Buy a pack with the SDK's buy method or in the app.",
+  "rate_limited": "Too many requests. The SDK already waited and retried; slow down or try again in {retryAfter} s.",
+  "too_many_active_jobs": "50 jobs are already in progress. Wait for some to finish.",
+  "agent_purchase_capped": "This account has used its 3 purchase attempts for the last 24 hours. Try again in {retryAfter} s.",
+  "agent_pack_locked": "New agent accounts can buy {allowedPacks} until earlier purchases settle.",
+  "pat_purchase_requires_app": "The saved card was declined or can't be charged automatically. Buy this pack in the Hushscript app.",
+  "pat_purchase_requires_authentication": "Your bank wants to confirm this payment. Buy this pack in the Hushscript app.",
+  "no_default_card": "No saved card. Open the add-card link from the SDK's billing methods in a browser, or add a card in the app.",
+  "unsupported_media": "Supported: MP3, M4A/MP4/MOV, WAV, FLAC, OGG/Opus. Convert it first, e.g. ffmpeg -i input -vn -c:a libopus output.opus",
+  "duration_unreadable": "Could not read the file's duration. Pass durationSeconds.",
+  "duration_out_of_range": "Files must be between 15 seconds and 10 hours long.",
+  "size_out_of_range": "Files must be at most 5 GB.",
+  "daily_limit": "This upload would pass your daily transcription limit ({used} of {max} min used in the last 24 h).",
+  "policy_version_stale": "Accept the current terms version: {currentVersion}.",
+  "wrong_state": "The job has already moved on. Fetch the job to see where it is.",
+  "resume_file_mismatch": "This is not the file the upload started with. Pass the original file, or start a new transcription.",
+  "resume_file_required": "The upload was not finished. Pass the original file to resume it.",
+  "resume_job_missing": "This job no longer exists. Start a new transcription.",
+  "stream_size_mismatch": "The stream did not match the size you passed. Pass the exact size in bytes.",
+  "default_card_required": "You have more than one saved card and none is the default. Set a default card with the SDK's billing methods or in the app."
+};
+
+// src/generated/scopes.ts
+var OPERATION_SCOPES = {
+  "DELETE /v1/org/transcripts/{id}/hold": "org:write",
+  "GET /v1/account": "account:read",
+  "GET /v1/billing/cards": "billing",
+  "GET /v1/billing/holds": "account:read",
+  "GET /v1/billing/ledger": "account:read",
+  "GET /v1/billing/packs": "billing",
+  "GET /v1/billing/transactions": "account:read",
+  "GET /v1/jobs": "transcribe",
+  "GET /v1/jobs/{id}": "transcribe",
+  "GET /v1/org": "org:read",
+  "GET /v1/org/audit": "org:read",
+  "GET /v1/org/audit.csv": "org:read",
+  "GET /v1/org/invoices": "org:read",
+  "GET /v1/org/ledger": "org:read",
+  "GET /v1/org/ledger.csv": "org:read",
+  "GET /v1/org/matters": "org:read",
+  "GET /v1/org/members": "org:read",
+  "GET /v1/org/transcripts": "org:read",
+  "GET /v1/org/usage": "org:read",
+  "GET /v1/org/usage.csv": "org:read",
+  "GET /v1/transcription-context": "context",
+  "GET /v1/transcripts": "transcripts:read",
+  "GET /v1/transcripts/deleted": "transcripts:read",
+  "GET /v1/transcripts/{id}": "transcripts:read",
+  "GET /v1/uploads/{job}/part-urls": "transcribe",
+  "PATCH /v1/org/members/{user_id}": "org:write",
+  "POST /v1/agent/credentials/rotate": "pat:rotate",
+  "POST /v1/billing/cards/default": "billing",
+  "POST /v1/billing/purchase": "billing",
+  "POST /v1/billing/setup-session": "billing",
+  "POST /v1/org/custody": "org:write",
+  "POST /v1/org/transcripts/{id}/hold": "org:write",
+  "POST /v1/uploads": "transcribe",
+  "POST /v1/uploads/{job}/complete": "transcribe",
+  "POST /v1/uploads/{job}/heartbeat": "transcribe",
+  "PUT /v1/uploads/{job}/parts/{n}": "transcribe"
+};
+
+// src/http/retry.ts
+var MAX_RETRY_AFTER_SECONDS = 60;
+var BACKOFF_CAP_MS = 8e3;
+var BACKOFF_BASE_MS = 500;
+var PURCHASE_MAX_RETRIES = 1;
+var CREATE_RATE_LIMIT_SCHEDULE_MS = [15e3, 3e4, 6e4];
+var CREATE_ACTIVE_JOBS_WAIT_MS = 3e4;
+var CREATE_ACTIVE_JOBS_RETRIES = 9;
+var EXPLICIT_CLASSES = {
+  "POST /v1/uploads": "upload-create",
+  "PUT /v1/uploads/{job}/parts/{n}": "idempotent",
+  "POST /v1/uploads/{job}/heartbeat": "safe",
+  "POST /v1/uploads/{job}/complete": "idempotent",
+  "POST /v1/billing/purchase": "purchase",
+  "POST /v1/billing/setup-session": "purchase",
+  "POST /v1/agent/accounts/{signup_id}/claim": "never",
+  "POST /v1/agent/credentials/rotate": "never",
+  "POST /v1/agent/accounts": "never"
+};
+function retryClassFor(method, template) {
+  const verb = method.toUpperCase();
+  if (verb === "GET" || verb === "HEAD") return "safe";
+  return EXPLICIT_CLASSES[`${verb} ${template}`] ?? "mutate";
+}
+function backoffMs(attempt2, random) {
+  return random() * Math.min(BACKOFF_CAP_MS, BACKOFF_BASE_MS * 2 ** attempt2);
+}
+var MAX_RETRY_AFTER_REPORTED = Number.MAX_SAFE_INTEGER;
+function parseRetryAfter(header) {
+  if (header === null) return null;
+  const text = header.trim();
+  if (!/^\d+$/.test(text)) return null;
+  return Math.min(Number(text), MAX_RETRY_AFTER_REPORTED);
+}
+var STOP = { retry: false };
+function retriableFailure(retryClass, status, sent) {
+  switch (retryClass) {
+    case "safe":
+      return status === null || status === 429 || status === 500 || status >= 502 && status <= 504;
+    case "idempotent":
+    case "upload-create":
+      return status === null || status === 429 || status >= 500;
+    case "purchase":
+      return status === null || status === 502 || status === 503;
+    case "mutate":
+      return status === null && !sent;
+    // Stryker disable next-line ConditionalExpression,StringLiteral: without this case the switch returns undefined, which reads as false too
+    case "never":
+      return false;
+  }
+}
+function planRetry(input) {
+  const { retryClass, status, retryAfter, retriesDone, maxRetries } = input;
+  if (!retriableFailure(retryClass, status, input.sent)) return STOP;
+  if ((retryAfter ?? 0) > MAX_RETRY_AFTER_SECONDS) return STOP;
+  let delayMs = backoffMs(retriesDone, input.random);
+  let limit = retryClass === "purchase" ? Math.min(maxRetries, PURCHASE_MAX_RETRIES) : maxRetries;
+  if (retryClass === "upload-create" && status === 429) {
+    if (input.slug === "too_many_active_jobs") {
+      if (maxRetries === 0 || input.activeJobsDone >= CREATE_ACTIVE_JOBS_RETRIES) return STOP;
+      limit = Infinity;
+      delayMs = CREATE_ACTIVE_JOBS_WAIT_MS;
+    } else if (retryAfter === null) {
+      if (input.rateLimitsDone >= CREATE_RATE_LIMIT_SCHEDULE_MS.length) return STOP;
+      delayMs = CREATE_RATE_LIMIT_SCHEDULE_MS[input.rateLimitsDone] ?? delayMs;
+    }
+  }
+  if (retriesDone >= limit) return STOP;
+  return { retry: true, delayMs: retryAfter === null ? delayMs : retryAfter * 1e3 };
+}
+
+// src/http/operations.ts
+function compile(key) {
+  const space = key.indexOf(" ");
+  const literals = key.slice(space + 1).split(/\{[^{}]+\}/);
+  const pattern = literals.map((literal) => literal.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`)).join("[^/]+");
+  return {
+    key,
+    method: key.slice(0, space),
+    pattern: new RegExp(`^${pattern}$`),
+    pieces: literals.length
+  };
+}
+function templateMatcher(keys) {
+  const templates = [...new Set(keys)].map(compile).sort((a, b) => a.pieces - b.pieces);
+  return (verb, pathname) => templates.find((t) => t.method === verb && t.pattern.test(pathname))?.key;
+}
+var match = templateMatcher([...Object.keys(OPERATION_SCOPES), ...Object.keys(EXPLICIT_CLASSES)]);
+function operationFor(method, pathname) {
+  const verb = method.toUpperCase();
+  return match(verb, pathname) ?? `${verb} ${pathname}`;
+}
+function resolveOperation(operation) {
+  const space = operation.indexOf(" ");
+  return operationFor(operation.slice(0, space), operation.slice(space + 1));
+}
+function hasIdempotencyKey(body) {
+  if (body === null) return false;
+  try {
+    const key = JSON.parse(body)?.idempotency_key;
+    return typeof key === "string" && key !== "";
+  } catch {
+    return false;
+  }
+}
+function retryClassForRequest(method, pathname, body = null) {
+  const operation = operationFor(method, pathname);
+  const retryClass = retryClassFor(method, operation.slice(operation.indexOf(" ") + 1));
+  return retryClass === "upload-create" && !hasIdempotencyKey(body) ? "mutate" : retryClass;
+}
+var REDACTED = "hsr\u2026[redacted]";
+var TOKEN_SHAPE = /hsr\d+:[a-z]+:pat\.[0-9a-f]+\.[0-9a-f]+/g;
+var MIN_SECRET_LENGTH = 8;
+var MIN_SECRET_TAIL = 16;
+var URL_QUERY = /\b([a-z][a-z\d+.-]*:\/\/[^\s?#"'<>]+)\?[^\s"'<>#]*[^\s"'<>#).,;:]/gi;
+var QUERY_REDACTED = "?[redacted]";
+var secrets = /* @__PURE__ */ new Set();
+function registerSecret(secret) {
+  if (secret.length < MIN_SECRET_LENGTH) return;
+  remember(secret);
+  const marker = secret.indexOf("pat.");
+  if (marker === -1) return;
+  const tail = secret.slice(marker + "pat.".length);
+  for (const part of [tail, tail.slice(tail.lastIndexOf(".") + 1)]) {
+    if (part.length >= MIN_SECRET_TAIL) remember(part);
+  }
+}
+function remember(secret) {
+  secrets.add(secret);
+  secrets.add(encodeURIComponent(secret));
+}
+function redact(text) {
+  let out = text;
+  for (const secret of secrets) out = out.replaceAll(secret, REDACTED);
+  return out.replace(TOKEN_SHAPE, REDACTED).replace(URL_QUERY, `$1${QUERY_REDACTED}`);
+}
+function redactValue(value) {
+  if (typeof value === "string") return redact(value);
+  if (Array.isArray(value)) return value.map(redactValue);
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [redact(key), redactValue(item)])
+    );
+  }
+  return value;
+}
+function redactCause(cause) {
+  if (!(cause instanceof Error)) return redactValue(cause);
+  const copy = new Error(redact(cause.message));
+  copy.name = cause.name;
+  if (cause.stack !== void 0) copy.stack = redact(cause.stack);
+  const code = cause.code;
+  if (typeof code === "string") Object.assign(copy, { code });
+  if (cause.cause !== void 0) copy.cause = redactCause(cause.cause);
+  return copy;
+}
+function withRedactedField(name, value, field) {
+  const printable = () => ({ ...value, [field]: REDACTED });
+  Object.defineProperty(value, inspect.custom, { value: printable });
+  Object.defineProperty(value, "toString", {
+    value: () => `${name} ${JSON.stringify(printable())}`
+  });
+  return value;
+}
+
+// src/errors.ts
+var PLACEHOLDER = /\{(\w+)\}/g;
+function fillHint(template, values) {
+  const known = (name) => values[name] !== void 0 && values[name] !== null;
+  const kept = template.split(/(?<=\.) /).filter((sentence) => [...sentence.matchAll(PLACEHOLDER)].every((m) => known(m[1] ?? "")));
+  if (kept.length === 0) return null;
+  return kept.join(" ").replace(PLACEHOLDER, (_whole, name) => String(values[name]));
+}
+function minutes(seconds2, round) {
+  return seconds2 === void 0 ? void 0 : round(seconds2 / 60);
+}
+function hintValuesFrom(inputs) {
+  return {
+    scope: inputs.scope,
+    needed: minutes(inputs.neededSeconds, Math.ceil),
+    balance: minutes(inputs.balanceSeconds, Math.trunc),
+    used: minutes(inputs.usedSeconds, Math.trunc),
+    max: minutes(inputs.maxSeconds, Math.trunc),
+    retryAfter: inputs.retryAfter,
+    allowedPacks: inputs.allowedPacks?.join(", "),
+    currentVersion: inputs.currentVersion
+  };
+}
+function renderHint(slug, values) {
+  const template = HINTS[slug];
+  return template === void 0 ? null : fillHint(template, values);
+}
+function resolveHint(init) {
+  if (init.hint !== void 0) return init.hint === null ? null : redact(init.hint);
+  const hint = renderHint(init.code, init.hintValues ?? {});
+  return hint === null ? null : redact(hint);
+}
+var HushscriptError = class extends Error {
+  code;
+  numericCode;
+  status;
+  hint;
+  details;
+  retryAfter;
+  /** Set on an error `transcribe()` raised after its create was sent, or `buy()` after its purchase may have been sent (a failure provably before any attempt went out carries none): passing it back replays the same job or purchase instead of making a second one. */
+  idempotencyKey = null;
+  /** Set once the job id is known; `resume()` takes it. */
+  resumeToken = null;
+  constructor(init) {
+    super(
+      redact(init.message),
+      init.cause === void 0 ? void 0 : { cause: redactCause(init.cause) }
+    );
+    this.name = new.target.name;
+    this.code = redact(init.code);
+    this.numericCode = init.numericCode ?? null;
+    this.status = init.status ?? null;
+    this.hint = resolveHint(init);
+    this.details = redactValue(init.details ?? {});
+    this.retryAfter = init.retryAfter ?? null;
+  }
+};
+var failedBeforeSending = /* @__PURE__ */ new WeakSet();
+function markNotSent(error) {
+  failedBeforeSending.add(error);
+  return error;
+}
+function wasNotSent(error) {
+  return failedBeforeSending.has(error);
+}
+function describeError(error) {
+  if (error instanceof Error) {
+    return error.message === "" ? error.name : `${error.name}: ${error.message}`;
+  }
+  return typeof error === "string" ? `thrown string: ${error}` : `thrown ${typeof error}`;
+}
+function asHushscriptError(error, sent) {
+  if (error instanceof HushscriptError) return error;
+  const when = sent === void 0 ? "" : sent ? " after the request was sent" : " before the request was sent";
+  return new HushscriptError({
+    code: "unexpected_error",
+    message: `The SDK failed unexpectedly${when} (${describeError(error)}).`,
+    cause: error
+  });
+}
+var MISSING_TOKEN_HINT = "Set HUSHSCRIPT_TOKEN or pass a token. Create one in the Hushscript app: Account \u2192 MCP (app.hushscript.com/account/mcp).";
+var ConfigurationError = class _ConfigurationError extends HushscriptError {
+  constructor(init) {
+    super({ ...init, code: init.code ?? "config_invalid" });
+  }
+  static missingToken() {
+    return new _ConfigurationError({
+      message: "No Hushscript token: set HUSHSCRIPT_TOKEN or pass a token.",
+      hint: MISSING_TOKEN_HINT
+    });
+  }
+};
+var PreflightError = class extends HushscriptError {
+};
+var UnsupportedMediaError = class extends PreflightError {
+};
+var FileLimitError = class extends PreflightError {
+};
+var DailyLimitError = class extends PreflightError {
+};
+var ResumeMismatchError = class extends PreflightError {
+};
+var ApiError = class extends HushscriptError {
+};
+var AuthenticationError = class extends ApiError {
+};
+var PermissionDeniedError = class extends ApiError {
+};
+var InsufficientBalanceError = class extends ApiError {
+};
+var NotFoundError = class extends ApiError {
+};
+var ConflictError = class extends ApiError {
+};
+var ValidationError = class extends ApiError {
+};
+var RateLimitError = class extends ApiError {
+};
+var PaymentMethodRequiredError = class extends HushscriptError {
+  constructor(init) {
+    super({ ...init, code: init.code ?? "no_default_card" });
+  }
+};
+var UploadError = class extends HushscriptError {
+};
+var JobFailedError = class extends HushscriptError {
+  error;
+  failureKind;
+  jobId;
+  constructor(init) {
+    super({ ...init, code: init.code ?? "job_failed" });
+    this.error = init.error === null ? null : redact(init.error);
+    this.failureKind = init.failureKind;
+    this.jobId = init.jobId;
+  }
+};
+var WaitTimeoutError = class extends HushscriptError {
+  /** `resumeToken` is null only for `jobs.wait`, which has no idempotency key to build a token from. */
+  constructor(init) {
+    super({ ...init, code: init.code ?? "wait_timeout" });
+    this.resumeToken = init.resumeToken;
+  }
+};
+var AbortError = class extends HushscriptError {
+  constructor(init) {
+    super({ ...init, code: init.code ?? "aborted" });
+    this.resumeToken = init.resumeToken ?? null;
+  }
+};
+var NetworkError = class extends HushscriptError {
+  constructor(init) {
+    super({ ...init, code: init.code ?? "network_error" });
+  }
+};
+var OUTCOME_HINTS = {
+  "POST /v1/agent/accounts/{signup_id}/claim": "The claim may have succeeded. Retrying will fail with agent_claim_invalid. If you have no token, contact support with the signup id.",
+  "POST /v1/agent/credentials/rotate": "The old token may already be revoked. Try a request with it; if it fails, the new token was lost and the account needs support."
+};
+var OutcomeUnknownError = class extends HushscriptError {
+  #receivedToken;
+  constructor(init) {
+    super({ ...init, code: init.code ?? "outcome_unknown" });
+    this.#receivedToken = init.receivedToken ?? null;
+  }
+  /**
+   * The string a rotate answer carried as the new token when it was not a usable one, so a caller
+   * can still look at (or rescue) it. A getter over a private field: it is left out of `inspect`,
+   * `JSON.stringify` and every message. Null for every other outcome.
+   */
+  get receivedToken() {
+    return this.#receivedToken;
+  }
+  static hintFor(operation) {
+    return OUTCOME_HINTS[operation] ?? null;
+  }
+};
+var RATE_LIMIT_SLUGS = /* @__PURE__ */ new Set([
+  "rate_limited",
+  "too_many_active_jobs",
+  "agent_purchase_capped",
+  "url_target_busy"
+]);
+var BALANCE_SLUGS = /* @__PURE__ */ new Set([
+  "insufficient_balance",
+  "org_insufficient_balance",
+  "org_pool_expired",
+  "org_plan_frozen"
+]);
+var UPLOAD_SLUGS = /* @__PURE__ */ new Set(["upload_incomplete", "size_exceeded"]);
+var JOB_OPERATION = /^\w+ \/v1\/(?:jobs|uploads)(?:\/|$)/;
+function classFor(status, slug) {
+  if (UPLOAD_SLUGS.has(slug)) return UploadError;
+  if (RATE_LIMIT_SLUGS.has(slug)) return RateLimitError;
+  if (BALANCE_SLUGS.has(slug)) return InsufficientBalanceError;
+  switch (status) {
+    case 400:
+    case 422:
+      return ValidationError;
+    case 401:
+      return AuthenticationError;
+    case 402:
+      return InsufficientBalanceError;
+    case 403:
+      return PermissionDeniedError;
+    case 404:
+      return NotFoundError;
+    case 409:
+      return ConflictError;
+    case 429:
+      return RateLimitError;
+    default:
+      return ApiError;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function numberOf(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function hintValuesFor(details, retryAfter, operation) {
+  const nested = isRecord(details["details"]) ? details["details"] : {};
+  const packs = nested["allowedPacks"];
+  const version = details["currentVersion"] ?? nested["currentVersion"];
+  return hintValuesFrom({
+    scope: OPERATION_SCOPES[resolveOperation(operation)],
+    neededSeconds: numberOf(details["neededSeconds"]),
+    balanceSeconds: numberOf(details["balanceSeconds"]),
+    retryAfter,
+    allowedPacks: Array.isArray(packs) ? packs : void 0,
+    currentVersion: typeof version === "string" ? version : numberOf(version)
+  });
+}
+function errorFromResponse(res, body, operation) {
+  const record = isRecord(body) ? body : {};
+  const slug = typeof record["error"] === "string" ? record["error"] : null;
+  const numericCode = Number.isSafeInteger(record["code"]) ? record["code"] : null;
+  const code = slug ?? `http_${String(res.status)}`;
+  const extras = Object.entries(record).filter(([key]) => key !== "error" && key !== "code");
+  const details = camelize(Object.fromEntries(extras));
+  const nested = isRecord(details["details"]) ? details["details"] : {};
+  const bodyRetry = nested["retryAfterSeconds"];
+  const retryAfter = parseRetryAfter(res.headers.get("retry-after")) ?? (typeof bodyRetry === "number" && Number.isFinite(bodyRetry) && bodyRetry >= 0 ? Math.min(bodyRetry, MAX_RETRY_AFTER_REPORTED) : null);
+  const meaning = slug === null ? void 0 : ERROR_CATALOG[slug]?.meaning;
+  const message = meaning ?? (slug === null ? `The API answered ${String(res.status)}.` : `${slug} (HTTP ${String(res.status)})`);
+  const ErrorType = classFor(res.status, code);
+  return new ErrorType({
+    code,
+    message,
+    numericCode,
+    status: res.status,
+    details,
+    retryAfter,
+    // `wrong_state` names a job call, so only job and upload operations carry that hint.
+    ...code === "wrong_state" && !JOB_OPERATION.test(resolveOperation(operation)) ? { hint: null } : {},
+    hintValues: hintValuesFor(details, retryAfter, operation)
+  });
+}
+
+// src/http/pacing.ts
+var TokenBucket = class {
+  #capacity;
+  #windowMs;
+  #clock;
+  #stamps = [];
+  constructor(capacity, windowMs, clock) {
+    this.#capacity = capacity;
+    this.#windowMs = windowMs;
+    this.#clock = clock;
+  }
+  /** Resolves with the milliseconds spent waiting (0 when a slot was free). */
+  async acquire(signal) {
+    let waited = 0;
+    for (; ; ) {
+      const now = this.#clock.now();
+      while (now - (this.#stamps[0] ?? Infinity) >= this.#windowMs) {
+        this.#stamps.shift();
+      }
+      const oldest = this.#stamps.length < this.#capacity ? void 0 : this.#stamps[0];
+      if (oldest === void 0) {
+        this.#stamps.push(now);
+        return waited;
+      }
+      const wait = oldest + this.#windowMs - now;
+      await this.#clock.sleep(wait, signal);
+      waited += wait;
+    }
+  }
+};
+
+// src/log.ts
+function formatAttempt(entry) {
+  const parts = [
+    "hushscript",
+    entry.method,
+    entry.target,
+    `status=${String(entry.status)}`,
+    `attempt=${String(entry.attempt)}`,
+    `duration_ms=${String(entry.durationMs)}`
+  ];
+  if (entry.retryDelayMs !== null) parts.push(`retry_in_ms=${String(entry.retryDelayMs)}`);
+  return parts.join(" ");
+}
+function stderrSink(line) {
+  console.error(line);
+}
+function createLogger(level, sink = stderrSink) {
+  return {
+    enabled: level === "debug",
+    attempt(entry) {
+      if (level === "debug") sink(redact(formatAttempt(entry)));
+    }
+  };
+}
+function describeTarget(url2, apiOrigin) {
+  if (url2.origin === apiOrigin && !url2.pathname.startsWith("/__r2/")) return url2.pathname;
+  const part = url2.searchParams.get("partNumber") ?? "";
+  return /^\d+$/.test(part) ? `r2:part/${part}` : "r2:part";
+}
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://api.hushscript.com";
+var DEFAULT_TIMEOUT_SECONDS = 60;
+var MAX_TIMEOUT_SECONDS = 3600;
+var DEFAULT_MAX_RETRIES = 3;
+var PART_TIMEOUT_MS = 3e5;
+var CREATES_PER_WINDOW = 4;
+var CREATE_WINDOW_MS = 6e4;
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+var ResolvedConfig = class {
+  baseUrl;
+  timeoutMs;
+  /** Per upload part PUT; not configurable. */
+  partTimeoutMs;
+  maxRetries;
+  logLevel;
+  clock;
+  logger;
+  random;
+  /** Paces `POST /v1/uploads` for this client instance. */
+  createPacer;
+  userAgent;
+  #token;
+  constructor(token, values) {
+    this.#token = token;
+    Object.defineProperty(this, inspect.custom, { value: () => this.toString() });
+    this.baseUrl = values.baseUrl;
+    this.timeoutMs = values.timeoutMs;
+    this.partTimeoutMs = values.partTimeoutMs;
+    this.maxRetries = values.maxRetries;
+    this.logLevel = values.logLevel;
+    this.clock = values.clock;
+    this.logger = values.logger;
+    this.random = values.random;
+    this.createPacer = values.createPacer;
+    this.userAgent = values.userAgent;
+  }
+  authorization() {
+    if (this.#token === null) throw ConfigurationError.missingToken();
+    return `Bearer ${this.#token}`;
+  }
+  /** Replaces the token for every later request (token rotation); the new one is redacted from then on. */
+  setToken(token) {
+    registerSecret(token);
+    this.#token = checkToken(token);
+  }
+  toJSON() {
+    return {
+      token: REDACTED,
+      baseUrl: this.baseUrl,
+      timeoutMs: this.timeoutMs,
+      maxRetries: this.maxRetries,
+      logLevel: this.logLevel
+    };
+  }
+  toString() {
+    return `ResolvedConfig ${JSON.stringify(this.toJSON())}`;
+  }
+};
+function runtime() {
+  const deno = globalThis.Deno;
+  if (deno?.version?.deno !== void 0) return `deno/${deno.version.deno}`;
+  const bun = process.versions["bun"];
+  if (bun !== void 0) return `bun/${bun}`;
+  return `node/${process.versions.node}`;
+}
+function setValue(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value !== "string") return value;
+  return value.trim() === "" ? void 0 : value;
+}
+function checkBaseUrl(raw) {
+  let url2;
+  try {
+    url2 = new URL(raw);
+  } catch {
+    throw new ConfigurationError({ message: "baseUrl is not a valid URL." });
+  }
+  const loopback = url2.protocol === "http:" && LOOPBACK_HOSTS.has(url2.hostname);
+  if (url2.protocol !== "https:" && !loopback) {
+    throw new ConfigurationError({
+      message: "baseUrl must be https://, or http:// to localhost, 127.0.0.1 or [::1]."
+    });
+  }
+  if (url2.pathname !== "/" || url2.search !== "" || url2.hash !== "" || /[?#]/.test(raw)) {
+    throw new ConfigurationError({ message: "baseUrl must not have a path, query or fragment." });
+  }
+  return raw.replace(/\/+$/, "");
+}
+function isBrowser() {
+  return globalThis.window !== void 0 && globalThis.document !== void 0;
+}
+function checkLogLevel(raw) {
+  if (raw === "off" || raw === "debug") return raw;
+  throw new ConfigurationError({ message: 'The log level must be "off" or "debug".' });
+}
+function refuseBrowser(allowed) {
+  if (isBrowser() && allowed !== true) {
+    throw new ConfigurationError({
+      message: "The Hushscript SDK refuses to run in a browser: a token in a browser bundle is a leaked token. Call it from a server."
+    });
+  }
+}
+function checkToken(raw) {
+  if (typeof raw !== "string") {
+    throw new ConfigurationError({ message: "token must be a string." });
+  }
+  const token = raw.trim();
+  if (token === "") throw ConfigurationError.missingToken();
+  if (!token.startsWith("hsr")) {
+    throw new ConfigurationError({ message: "This doesn't look like a Hushscript token." });
+  }
+  if (!/^[\u0021-\u007e]+$/u.test(token)) {
+    throw new ConfigurationError({
+      message: "The token has spaces, control characters or non-ASCII characters in it; check how it was copied."
+    });
+  }
+  return token;
+}
+function build(token, options, env, internals) {
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT_SECONDS;
+  if (!Number.isFinite(timeout) || timeout <= 0) {
+    throw new ConfigurationError({ message: "timeout must be a positive number of seconds." });
+  }
+  if (timeout > MAX_TIMEOUT_SECONDS) {
+    throw new ConfigurationError({
+      message: `timeout must be at most ${String(MAX_TIMEOUT_SECONDS)} seconds.`
+    });
+  }
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  if (!Number.isInteger(maxRetries) || maxRetries < 0) {
+    throw new ConfigurationError({ message: "maxRetries must be a whole number, 0 or more." });
+  }
+  const clock = options.clock ?? systemClock;
+  const logLevel = checkLogLevel(
+    setValue(options.logLevel) ?? setValue(env["HUSHSCRIPT_LOG"]) ?? "off"
+  );
+  if (token !== null) registerSecret(token);
+  return new ResolvedConfig(token, {
+    baseUrl: checkBaseUrl(
+      setValue(options.baseUrl) ?? setValue(env["HUSHSCRIPT_BASE_URL"]) ?? DEFAULT_BASE_URL
+    ),
+    timeoutMs: timeout * 1e3,
+    partTimeoutMs: PART_TIMEOUT_MS,
+    maxRetries,
+    logLevel,
+    clock,
+    logger: createLogger(logLevel, internals.logSink),
+    random: internals.random ?? Math.random,
+    createPacer: new TokenBucket(CREATES_PER_WINDOW, CREATE_WINDOW_MS, clock),
+    userAgent: `hushscript-typescript/${package_default.version} ${runtime()}`
+  });
+}
+function resolveConfig(options = {}, internals = {}) {
+  const env = internals.env ?? process.env;
+  refuseBrowser(options.dangerouslyAllowBrowser);
+  const token = checkToken(setValue(options.token) ?? setValue(env["HUSHSCRIPT_TOKEN"]) ?? "");
+  return build(token, options, env, internals);
+}
+function resolveTokenlessConfig(options = {}, internals = {}) {
+  refuseBrowser(void 0);
+  return build(null, options, internals.env ?? process.env, internals);
+}
+
+// src/depth.ts
+var MAX_BODY_DEPTH = 64;
+function nestsDeeperThan(root, limit) {
+  const pending = [{ value: root, depth: 0 }];
+  for (let next = pending.pop(); next !== void 0; next = pending.pop()) {
+    const { value, depth } = next;
+    if (typeof value !== "object" || value === null) continue;
+    if (depth >= limit) return true;
+    for (const child of Object.values(value)) pending.push({ value: child, depth: depth + 1 });
+  }
+  return false;
+}
+
+// src/shape.ts
+var MAX_UNIX_SECONDS = 864e10;
+function problem(expected) {
+  return { path: [], expected };
+}
+function describeProblem({ path, expected }) {
+  const where = path.reduce(
+    (out, part) => typeof part === "number" ? `${out}[${String(part)}]` : out === "" ? part : `${out}.${part}`,
+    ""
+  );
+  return where === "" ? `expected ${expected}` : `${where}: expected ${expected}`;
+}
+var str = (value) => typeof value === "string" ? null : problem("a string");
+var num = (value) => typeof value === "number" && Number.isFinite(value) ? null : problem("a number");
+var positiveInt = (value) => Number.isSafeInteger(value) && value > 0 ? null : problem("a positive whole number");
+function positiveIntAtMost(max) {
+  return (value) => Number.isSafeInteger(value) && value > 0 && value <= max ? null : problem(`a positive whole number up to ${String(max)}`);
+}
+function isPathSegment(value) {
+  return typeof value === "string" && value !== "" && value !== "." && value !== ".." && !/[\uD800-\uDFFF]/u.test(value);
+}
+var pathId = (value) => isPathSegment(value) ? null : problem("a usable id");
+var bool = (value) => typeof value === "boolean" ? null : problem("a boolean");
+var anything = () => null;
+var timestamp = (value) => typeof value === "number" && Number.isFinite(value) && Math.abs(value) <= MAX_UNIX_SECONDS ? null : problem("a unix timestamp in seconds");
+var url = (value) => typeof value === "string" && URL.canParse(value) ? null : problem("a URL");
+function nullable(shape) {
+  return (value) => value === null ? null : shape(value);
+}
+function optional(shape) {
+  return (value) => value === void 0 ? null : shape(value);
+}
+function arrayOf(shape) {
+  return (value) => {
+    if (!Array.isArray(value)) return problem("an array");
+    for (let index = 0; index < value.length; index += 1) {
+      const found = shape(value[index]);
+      if (found !== null) return { path: [index, ...found.path], expected: found.expected };
+    }
+    return null;
+  };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function recordOf(shape) {
+  return (value) => {
+    if (!isRecord2(value)) return problem("an object");
+    for (const [key, item] of Object.entries(value)) {
+      const found = shape(item);
+      if (found !== null) return { path: [key, ...found.path], expected: found.expected };
+    }
+    return null;
+  };
+}
+function objectOf(fields) {
+  const entries = Object.entries(fields);
+  return (value) => {
+    if (!isRecord2(value)) return problem("an object");
+    for (const [key, shape] of entries) {
+      const found = shape(Object.hasOwn(value, key) ? value[key] : void 0);
+      if (found !== null) return { path: [key, ...found.path], expected: found.expected };
+    }
+    return null;
+  };
+}
+
+// src/transcribe/common.ts
+function aborted(signal) {
+  return new AbortError({ message: "The request was aborted.", cause: signal.reason });
+}
+async function sleepOrAbort(clock, ms, signal) {
+  try {
+    await clock.sleep(ms, signal);
+  } catch (error) {
+    if (signal.aborted) throw aborted(signal);
+    throw error;
+  }
+}
+function badResponse(route, status, cause) {
+  return new ApiError({
+    code: "bad_response",
+    message: `${route} answered with a body the SDK cannot use${cause === void 0 ? "" : ` (${describeError(cause)})`}.`,
+    status,
+    cause
+  });
+}
+async function guarded(call, route) {
+  try {
+    return await call;
+  } catch (error) {
+    if (error instanceof HushscriptError) throw error;
+    throw badResponse(route, null, error);
+  }
+}
+function usable(json) {
+  return nestsDeeperThan(json, MAX_BODY_DEPTH) ? void 0 : json;
+}
+async function readJson(call, route) {
+  const { data, response } = await guarded(call, route);
+  try {
+    return { status: response.status, json: usable(JSON.parse(String(data))) };
+  } catch {
+    return { status: response.status, json: void 0 };
+  }
+}
+async function readBody(call, route, shape) {
+  const { status, json } = await readJson(call, route);
+  const found = json === void 0 ? { path: [], expected: "a JSON body" } : shape(json);
+  if (found !== null) throw badResponse(route, status, new Error(describeProblem(found)));
+  return json;
+}
+async function readObject(call, route) {
+  const { status, json } = await readJson(call, route);
+  const isObject = typeof json === "object" && !Array.isArray(json);
+  return { status, body: isObject ? json : null };
+}
+
+// src/http/guard.ts
+var VERBS = ["GET", "PUT", "POST", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"];
+function guardApi(raw) {
+  const guarded2 = {
+    use: raw.use.bind(raw),
+    eject: raw.eject.bind(raw)
+  };
+  const guard = (name, call) => {
+    const routeAt = name === "request" ? 1 : 0;
+    guarded2[name] = async (...args) => {
+      try {
+        return await call(...args);
+      } catch (error) {
+        if (error instanceof HushscriptError) throw error;
+        const verb = name === "request" ? String(args[0]).toUpperCase() : name;
+        throw badResponse(`${verb} ${String(args[routeAt])}`, null, error);
+      }
+    };
+  };
+  for (const verb of VERBS) guard(verb, raw[verb]);
+  guard("request", raw.request);
+  return guarded2;
+}
+
+// src/http/fetch.ts
+var BODY_CHUNK_BYTES = 256 * 1024;
+var NEVER_SENT = /^(?:ECONNREFUSED|ENOTFOUND|EAI_AGAIN|UND_ERR_CONNECT_TIMEOUT|ERR_TLS_CERT_ALTNAME_INVALID|CERT_|DEPTH_ZERO_|UNABLE_TO_|SELF_SIGNED_)/;
+function isTransportFailure(error) {
+  return error instanceof TypeError || error instanceof DOMException && error.name === "NetworkError";
+}
+function errorCode(error) {
+  let current = error;
+  for (let depth = 0; depth < 4 && current instanceof Error; depth += 1) {
+    const code = current.code;
+    if (typeof code === "string") return code;
+    current = current.cause;
+  }
+  return void 0;
+}
+function bodyStream(bytes, progress) {
+  let offset = 0;
+  return new ReadableStream(
+    {
+      pull(controller) {
+        const end = Math.min(offset + BODY_CHUNK_BYTES, bytes.byteLength);
+        controller.enqueue(bytes.subarray(offset, end));
+        offset = end;
+        if (offset >= bytes.byteLength) {
+          progress.done = true;
+          controller.close();
+        }
+      }
+    },
+    { highWaterMark: 0 }
+  );
+}
+var NULL_BODY_STATUSES = /* @__PURE__ */ new Set([204, 205, 304]);
+function whenAborted(signal) {
+  return new Promise((_resolve, reject) => {
+    if (signal.aborted) reject(signal.reason);
+    else
+      signal.addEventListener("abort", () => {
+        reject(signal.reason);
+      });
+  });
+}
+function keepHugeRetryAfter(key, value, context) {
+  if (key === "retry_after_seconds" && value === Infinity && // Stryker disable next-line ConditionalExpression,OptionalChaining: every Node under test passes the source; the branch is for runtimes that do not
+  context?.source !== void 0 && /^\d+$/.test(context.source))
+    return MAX_RETRY_AFTER_REPORTED;
+  return value;
+}
+function parseBody(text) {
+  try {
+    const parsed = JSON.parse(text, keepHugeRetryAfter);
+    return nestsDeeperThan(parsed, MAX_BODY_DEPTH) ? text : parsed;
+  } catch {
+    return text;
+  }
+}
+function slugOf(body) {
+  if (body === null) return null;
+  if (typeof body !== "object") return null;
+  const slug = body.error;
+  return typeof slug === "string" ? slug : null;
+}
+function isAborted(signal) {
+  return signal.aborted;
+}
+function aborted2(signal) {
+  return new AbortError({ message: "The request was aborted.", cause: signal.reason });
+}
+async function pause(cfg, ms, signal) {
+  try {
+    await cfg.clock.sleep(ms, signal);
+  } catch (error) {
+    if (signal.aborted) throw aborted2(signal);
+    throw error;
+  }
+}
+async function attempt(timeoutMs, cfg, request, callerSignal) {
+  const controller = new AbortController();
+  const stopTimer = new AbortController();
+  const onCallerAbort = () => {
+    controller.abort(callerSignal.reason);
+  };
+  callerSignal.addEventListener("abort", onCallerAbort);
+  let timedOut = false;
+  cfg.clock.sleep(timeoutMs, stopTimer.signal).then(
+    () => {
+      timedOut = true;
+      controller.abort(new Error("timeout"));
+    },
+    () => void 0
+  );
+  const progress = { done: request.bytes === null };
+  let headersArrived = false;
+  try {
+    const response = await globalThis.fetch(request.url, {
+      method: request.method,
+      headers: request.headers,
+      body: request.bytes === null ? null : bodyStream(request.bytes, progress),
+      duplex: "half",
+      // Never followed: a 3xx is an error, and credentials never leave the API origin.
+      redirect: "manual",
+      signal: controller.signal
+    });
+    headersArrived = true;
+    const bytes = NULL_BODY_STATUSES.has(response.status) ? null : await Promise.race([response.arrayBuffer(), whenAborted(controller.signal)]);
+    return {
+      response: new Response(bytes, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      })
+    };
+  } catch (error) {
+    const connectPhase = NEVER_SENT.test(errorCode(error) ?? "");
+    const sent = headersArrived || !connectPhase && progress.done;
+    const foreign = !controller.signal.aborted && !isTransportFailure(error);
+    return { failure: { error, sent, timedOut, foreign } };
+  } finally {
+    stopTimer.abort();
+    callerSignal.removeEventListener("abort", onCallerAbort);
+  }
+}
+function terminalFailure(timeoutMs, retryClass, operation, failure, callerSignal) {
+  const code = errorCode(failure.error);
+  const callerAborted = isAborted(callerSignal);
+  const reason = callerAborted ? "The request was aborted." : failure.timedOut ? `The request timed out after ${String(timeoutMs / 1e3)} s.` : `The request failed before a response arrived (${describeError(failure.error)}${code === void 0 ? "" : `; code ${code}`}).`;
+  if (retryClass === "never" && failure.sent) {
+    return new OutcomeUnknownError({
+      message: `${reason} The request was sent, so its outcome is unknown.`,
+      hint: OutcomeUnknownError.hintFor(operation),
+      cause: callerAborted ? aborted2(callerSignal) : failure.error
+    });
+  }
+  if (callerAborted) return aborted2(callerSignal);
+  return new NetworkError({ message: reason, cause: failure.error });
+}
+function hardenedFetch(cfg, retryClass, options = {}) {
+  const timeoutMs = options.timeoutMs ?? cfg.timeoutMs;
+  const guarded2 = async (input, init, wire) => {
+    const direct = init?.body instanceof Uint8Array ? init.body : null;
+    const request = new Request(input, direct === null ? init : { ...init, body: null });
+    const url2 = new URL(request.url);
+    const method = request.method.toUpperCase();
+    const operation = operationFor(method, url2.pathname);
+    const apiOrigin = new URL(cfg.baseUrl).origin;
+    const target = describeTarget(url2, apiOrigin);
+    const signal = request.signal;
+    const buffer = direct ?? new Uint8Array(await request.arrayBuffer());
+    const bytes = buffer.byteLength > 0 ? buffer : null;
+    const headers = new Headers(request.headers);
+    if (url2.origin !== apiOrigin) headers.delete("authorization");
+    const carriesToken = headers.has("authorization");
+    if (bytes !== null) headers.set("content-length", String(bytes.byteLength));
+    const prepared = { url: request.url, method, headers, bytes };
+    let rateLimitsDone = 0;
+    let activeJobsDone = 0;
+    for (let retriesDone = 0; ; retriesDone += 1) {
+      wire.sent = false;
+      if (signal.aborted) throw aborted2(signal);
+      if (operation === "POST /v1/uploads")
+        await cfg.createPacer.acquire(signal).catch(() => {
+          throw aborted2(signal);
+        });
+      if (carriesToken) prepared.headers.set("authorization", cfg.authorization());
+      const startedAt = cfg.clock.now();
+      const outcome = await attempt(timeoutMs, cfg, prepared, signal);
+      wire.sent = "response" in outcome || outcome.failure.sent;
+      wire.everSent ||= wire.sent;
+      const durationMs = cfg.clock.now() - startedAt;
+      const log = (status, retryDelayMs) => {
+        cfg.logger.attempt({
+          method,
+          target,
+          status,
+          attempt: retriesDone + 1,
+          durationMs,
+          retryDelayMs
+        });
+      };
+      if ("response" in outcome) {
+        const response = outcome.response;
+        if (response.ok) {
+          log(response.status, null);
+          return response;
+        }
+        const body = parseBody(await response.text());
+        const plan2 = planRetry({
+          retryClass,
+          status: response.status,
+          // Stryker disable next-line BooleanLiteral: planRetry reads `sent` only when there is no status
+          sent: true,
+          slug: slugOf(body),
+          retryAfter: parseRetryAfter(response.headers.get("retry-after")),
+          retriesDone,
+          rateLimitsDone,
+          activeJobsDone,
+          maxRetries: cfg.maxRetries,
+          random: cfg.random
+        });
+        if (response.status === 429) {
+          if (slugOf(body) === "too_many_active_jobs") activeJobsDone += 1;
+          else rateLimitsDone += 1;
+        }
+        log(response.status, plan2.retry ? plan2.delayMs : null);
+        if (!plan2.retry) throw errorFromResponse(response, body, operation);
+        await pause(cfg, plan2.delayMs, signal);
+        continue;
+      }
+      const failure = outcome.failure;
+      if (failure.foreign) {
+        log("unexpected_error", null);
+        throw failure.error;
+      }
+      if (isAborted(signal))
+        throw terminalFailure(timeoutMs, retryClass, operation, failure, signal);
+      const plan = planRetry({
+        retryClass,
+        status: null,
+        sent: failure.sent,
+        slug: null,
+        retryAfter: null,
+        retriesDone,
+        rateLimitsDone,
+        activeJobsDone,
+        maxRetries: cfg.maxRetries,
+        random: cfg.random
+      });
+      log(failure.timedOut ? "timeout" : "network_error", plan.retry ? plan.delayMs : null);
+      if (!plan.retry) throw terminalFailure(timeoutMs, retryClass, operation, failure, signal);
+      await pause(cfg, plan.delayMs, signal);
+    }
+  };
+  return async (input, init) => {
+    const wire = { sent: false, everSent: false };
+    try {
+      return await guarded2(input, init, wire);
+    } catch (error) {
+      if (error instanceof HushscriptError) throw wire.everSent ? error : markNotSent(error);
+      if (retryClass === "never" && wire.sent) {
+        throw new OutcomeUnknownError({
+          message: `The SDK failed unexpectedly after the request was sent (${describeError(error)}), so its outcome is unknown.`,
+          cause: error
+        });
+      }
+      const wrapped = asHushscriptError(error, wire.everSent);
+      throw wire.everSent ? wrapped : markNotSent(wrapped);
+    }
+  };
+}
+
+// src/http/transport.ts
+function createTransport(config) {
+  return async (input, init) => {
+    const request = new Request(input, init);
+    const pathname = new URL(request.url).pathname;
+    const body = request.method.toUpperCase() === "POST" && pathname === "/v1/uploads" ? await request.clone().text() : null;
+    return hardenedFetch(config, retryClassForRequest(request.method, pathname, body))(request);
+  };
+}
+
+// src/money.ts
+var NO_MINOR_UNITS = /* @__PURE__ */ new Set([
+  "BIF",
+  "CLP",
+  "DJF",
+  "GNF",
+  "JPY",
+  "KMF",
+  "KRW",
+  "MGA",
+  "PYG",
+  "RWF",
+  "UGX",
+  "VND",
+  "VUV",
+  "XAF",
+  "XOF",
+  "XPF"
+]);
+var THREE_MINOR_UNITS = /* @__PURE__ */ new Set(["BHD", "JOD", "KWD", "OMR", "TND"]);
+function minorUnitDigits(currency) {
+  const code = currency.toUpperCase();
+  if (NO_MINOR_UNITS.has(code)) return 0;
+  return THREE_MINOR_UNITS.has(code) ? 3 : 2;
+}
+var KNOWN_CURRENCIES = new Set(Intl.supportedValuesOf("currency"));
+function display(amount, currency, digits) {
+  const code = currency.toUpperCase();
+  if (!KNOWN_CURRENCIES.has(code)) return `${(amount / 10 ** digits).toFixed(digits)} ${code}`;
+  const format = new Intl.NumberFormat("en", {
+    style: "currency",
+    currency: code,
+    minimumFractionDigits: digits,
+    maximumFractionDigits: digits
+  });
+  return format.format(amount / 10 ** digits);
+}
+function toMoney(amount, currency) {
+  return { amount, currency, formatted: display(amount, currency, minorUnitDigits(currency)) };
+}
+
+// src/shapes.ts
+var UPLOAD_LIMITS = objectOf({
+  max_daily_seconds: num,
+  max_active_jobs: num,
+  active_jobs: num,
+  used_today_seconds: num
+});
+var ACCOUNT = objectOf({
+  balance_seconds: num,
+  held_seconds: num,
+  credits_expire_at: nullable(timestamp),
+  card_on_file: bool,
+  data_region: str,
+  limits: UPLOAD_LIMITS
+});
+var OPTIONS_SUMMARY = objectOf({
+  language_code: nullable(str),
+  speaker_detection: bool,
+  medical_mode: bool,
+  multichannel: bool,
+  translation_targets: arrayOf(str),
+  keyterms: bool,
+  prompt: bool,
+  auto_generate_insights: nullable(bool)
+});
+var JOB = objectOf({
+  id: str,
+  state: str,
+  mode: str,
+  declared_seconds: nullable(num),
+  verified_seconds: nullable(num),
+  actual_seconds: nullable(num),
+  billable_seconds: nullable(num),
+  error: nullable(str),
+  failure_kind: nullable(str),
+  retry_of: nullable(str),
+  created_at: timestamp,
+  transcript_id: nullable(pathId),
+  options: OPTIONS_SUMMARY
+});
+var JOB_LIST = objectOf({
+  jobs: arrayOf(JOB),
+  next_cursor: nullable(str)
+});
+var JOB_ONE = JOB;
+var MAX_PART_BYTES = 32 * 1024 * 1024;
+var PART_URL = objectOf({ n: positiveInt, url });
+var UPLOAD_CREATE = objectOf({
+  job_id: pathId,
+  state: str,
+  upload: nullable(
+    objectOf({
+      part_size_bytes: positiveIntAtMost(MAX_PART_BYTES),
+      total_parts: positiveInt,
+      part_urls: nullable(arrayOf(PART_URL)),
+      next_part_number: nullable(positiveInt)
+    })
+  )
+});
+var UPLOAD_COMPLETE = objectOf({ state: str });
+var PART_URLS = nullable(
+  objectOf({
+    part_urls: nullable(arrayOf(PART_URL)),
+    next_part_number: optional(nullable(positiveInt))
+  })
+);
+var UTTERANCE = objectOf({
+  speaker: str,
+  start_ms: num,
+  end_ms: num,
+  text: str
+});
+var TRANSCRIPT_LANGUAGE = objectOf({
+  utterances: arrayOf(UTTERANCE)
+});
+var TRANSCRIPT_DETAIL = objectOf({
+  id: str,
+  title: str,
+  language_detected: nullable(str),
+  duration_seconds: num,
+  speaker_names: recordOf(str),
+  tags: arrayOf(str),
+  created_at: timestamp,
+  updated_at: timestamp,
+  auto_delete_at: nullable(timestamp),
+  edited: bool,
+  body: objectOf({
+    original: TRANSCRIPT_LANGUAGE,
+    translations: recordOf(TRANSCRIPT_LANGUAGE)
+  })
+});
+var TRANSCRIPT_LIST = objectOf({
+  transcripts: arrayOf(
+    objectOf({
+      id: str,
+      title: str,
+      language_detected: nullable(str),
+      duration_seconds: num,
+      created_at: timestamp,
+      auto_delete_at: nullable(timestamp),
+      tags: arrayOf(str)
+    })
+  ),
+  next_cursor: nullable(str)
+});
+var DELETED_LIST = objectOf({
+  deleted: arrayOf(
+    objectOf({
+      id: str,
+      title: str,
+      duration_seconds: num,
+      created_at: timestamp,
+      deleted_at: timestamp,
+      cause: str,
+      receipt: nullable(recordOf(anything))
+    })
+  ),
+  next_cursor: nullable(str)
+});
+var PACKS = objectOf({
+  packs: arrayOf(
+    objectOf({
+      id: str,
+      amount: num,
+      currency: str,
+      seconds: num,
+      referral_bonus_seconds: num,
+      available: optional(bool)
+    })
+  )
+});
+var CARDS = objectOf({
+  default_id: nullable(str),
+  methods: arrayOf(
+    objectOf({
+      id: str,
+      type: str,
+      brand: str,
+      last4: str,
+      exp_month: num,
+      exp_year: num,
+      email: nullable(str),
+      is_default: bool,
+      fast_checkout_eligible: bool
+    })
+  )
+});
+var SET_DEFAULT_CARD = objectOf({ ok: bool });
+var SETUP_SESSION = objectOf({
+  checkout_url: url
+});
+var TRANSACTIONS = objectOf({
+  transactions: arrayOf(
+    objectOf({
+      id: num,
+      seconds: num,
+      amount_cents: num,
+      amount_refunded_cents: num,
+      currency: str,
+      status: str,
+      created_at: timestamp,
+      payment_method_type: nullable(str),
+      payment_method_brand: nullable(str),
+      payment_method_last4: nullable(str),
+      receipt_number: nullable(str),
+      initiated_via: nullable(str)
+    })
+  ),
+  next_cursor: nullable(str)
+});
+var LEDGER = objectOf({
+  entries: arrayOf(
+    objectOf({
+      id: num,
+      delta_seconds: num,
+      kind: str,
+      job_id: nullable(str),
+      note: nullable(str),
+      created_at: timestamp
+    })
+  ),
+  next_cursor: nullable(str)
+});
+var HOLDS = objectOf({
+  holds: arrayOf(
+    objectOf({
+      id: str,
+      kind: str,
+      seconds: num,
+      created_at: timestamp
+    })
+  ),
+  next_cursor: nullable(str)
+});
+var AGENT_SIGNUP = objectOf({
+  signup_id: str,
+  claim_secret: str,
+  checkout_url: str,
+  amount: num,
+  currency: str,
+  expires_at: timestamp
+});
+
+// src/resources/account.ts
+var ACCOUNT_FIELDS = /* @__PURE__ */ new Set([
+  ...[
+    "balance_seconds",
+    "held_seconds",
+    "credits_expire_at",
+    "card_on_file",
+    "data_region",
+    "limits"
+  ],
+  "purchases_remaining_in_window"
+]);
+function expiry(raw) {
+  return raw.credits_expire_at === null ? null : new Date(raw.credits_expire_at * 1e3);
+}
+function purchasesRemaining(raw) {
+  const remaining = raw["purchases_remaining_in_window"];
+  return typeof remaining === "number" && Number.isSafeInteger(remaining) && remaining >= 0 ? remaining : null;
+}
+function toAccount(raw) {
+  return {
+    ...unknownFields(raw, ACCOUNT_FIELDS),
+    balanceSeconds: raw.balance_seconds,
+    heldSeconds: raw.held_seconds,
+    creditsExpireAt: expiry(raw),
+    cardOnFile: raw.card_on_file,
+    dataRegion: raw.data_region,
+    limits: camelize(raw.limits),
+    purchasesRemainingInWindow: purchasesRemaining(raw)
+  };
+}
+function toBalance(raw) {
+  return {
+    ...unknownFields(raw, ACCOUNT_FIELDS),
+    seconds: raw.balance_seconds,
+    // `+ 0` turns the -0 that truncating -59 / 60 gives into 0.
+    minutes: Math.trunc(raw.balance_seconds / 60) + 0,
+    heldSeconds: raw.held_seconds,
+    expiresAt: expiry(raw),
+    purchasesRemaining: purchasesRemaining(raw)
+  };
+}
+function readAccount(api, signal) {
+  return readBody(
+    api.GET("/v1/account", { parseAs: "text", ...signal === void 0 ? {} : { signal } }),
+    "GET /v1/account",
+    ACCOUNT
+  );
+}
+var ID3_HEADER_BYTES = 10;
+var MAX_ID3_TAGS = 4;
+var FRAME_SCAN_BYTES = 4096;
+var OPUS_SAMPLE_RATE = 48e3;
+var OPUS_HEAD_BYTES = 512;
+var OPUS_PRE_SKIP_AT = 10;
+async function opusPreSkipSeconds(source, signal) {
+  const head = await source.head(OPUS_HEAD_BYTES, signal);
+  const at = ascii(head, 0, head.length).indexOf("OpusHead");
+  if (at === -1 || at + OPUS_PRE_SKIP_AT + 2 > head.length) return 0;
+  const preSkip = (head[at + OPUS_PRE_SKIP_AT] ?? 0) | (head[at + OPUS_PRE_SKIP_AT + 1] ?? 0) << 8;
+  return preSkip / OPUS_SAMPLE_RATE;
+}
+var ProbeBlob = class _ProbeBlob extends Blob {
+  size;
+  source;
+  signal;
+  offset;
+  length;
+  constructor(source, signal, offset = 0, length = source.size) {
+    super([]);
+    this.size = length;
+    this.source = source;
+    this.signal = signal;
+    this.offset = offset;
+    this.length = length;
+  }
+  slice(start = 0, end = this.size) {
+    const clamp = (at) => Math.min(this.size, Math.max(0, at < 0 ? this.size + at : at));
+    const from = clamp(start);
+    return new _ProbeBlob(
+      this.source,
+      this.signal,
+      this.offset + from,
+      Math.max(0, clamp(end) - from)
+    );
+  }
+  async arrayBuffer() {
+    if (this.signal?.aborted) throw aborted(this.signal);
+    const bytes = await this.source.read(this.offset, this.length, this.signal);
+    await setImmediate();
+    if (this.signal?.aborted) throw aborted(this.signal);
+    return bytes.slice().buffer;
+  }
+};
+async function parse(source, duration, signal) {
+  await setImmediate();
+  if (signal?.aborted) throw aborted(signal);
+  const metadata = await parseBlob(new ProbeBlob(source, signal), {
+    duration,
+    skipCovers: true
+  });
+  if (signal?.aborted) throw aborted(signal);
+  return metadata;
+}
+function syncsafe(bytes, at) {
+  return ((bytes[at] ?? 0) & 127) * 2 ** 21 + ((bytes[at + 1] ?? 0) & 127) * 2 ** 14 + ((bytes[at + 2] ?? 0) & 127) * 2 ** 7 + ((bytes[at + 3] ?? 0) & 127);
+}
+function ascii(bytes, at, length) {
+  return String.fromCharCode(...bytes.subarray(at, at + length));
+}
+async function firstFrame(source, signal) {
+  let at = 0;
+  for (let tags = 0; tags < MAX_ID3_TAGS; tags += 1) {
+    const header = await source.read(at, ID3_HEADER_BYTES, signal);
+    if (ascii(header, 0, 3) !== "ID3" || header.length < ID3_HEADER_BYTES) break;
+    const footer = ((header[5] ?? 0) & 16) === 0 ? 0 : 10;
+    at += ID3_HEADER_BYTES + syncsafe(header, 6) + footer;
+  }
+  const window = await source.read(at, FRAME_SCAN_BYTES, signal);
+  for (let i = 0; i + 4 <= window.length; i += 1) {
+    const b1 = window[i + 1] ?? 0;
+    if (window[i] === 255 && (b1 & 224) === 224 && (b1 & 6) !== 0 && (b1 & 24) !== 8) {
+      return window.subarray(i);
+    }
+  }
+  return null;
+}
+async function hasDurationHeader(source, signal) {
+  const frame = await firstFrame(source, signal);
+  if (frame === null) return false;
+  const b1 = frame[1] ?? 0;
+  const mpeg1 = (b1 & 24) === 24;
+  const mono = (frame[3] ?? 0) >> 6 === 3;
+  const crc = (b1 & 1) === 0 ? 2 : 0;
+  const sideInfo = mpeg1 ? mono ? 17 : 32 : mono ? 9 : 17;
+  const tag = ascii(frame, 4 + crc + sideInfo, 4);
+  return tag === "Xing" || tag === "Info" || ascii(frame, 4 + 32, 4) === "VBRI";
+}
+function unreadable(cause) {
+  return new UnsupportedMediaError({
+    code: "duration_unreadable",
+    message: `Could not read the duration${cause === void 0 ? "" : ` (${describeError(cause)})`}; pass durationSeconds.`,
+    cause
+  });
+}
+async function probeDuration(source, signal) {
+  if (signal?.aborted) throw aborted(signal);
+  if (source.probeInput === null) throw unreadable();
+  let duration;
+  try {
+    let meta = await parse(source, false, signal);
+    if (meta.format.container === "MPEG" && !await hasDurationHeader(source, signal) || meta.format.duration === void 0) {
+      meta = await parse(source, true, signal);
+    }
+    duration = meta.format.duration ?? NaN;
+    if (/opus/i.test(meta.format.codec ?? "")) duration += await opusPreSkipSeconds(source, signal);
+  } catch (error) {
+    if (signal?.aborted) throw aborted(signal);
+    if (error instanceof AbortError) throw error;
+    throw unreadable(error);
+  }
+  if (signal?.aborted) throw aborted(signal);
+  if (!Number.isFinite(duration) || duration <= 0) throw unreadable();
+  return duration;
+}
+
+// src/transcribe/sniff.ts
+function startsWith(head, text, offset = 0) {
+  for (let i = 0; i < text.length; i += 1) {
+    if (head[offset + i] !== text.charCodeAt(i)) return false;
+  }
+  return true;
+}
+function isLayer3Sync(head) {
+  const [a, b = 0] = head;
+  return a === 255 && (b & 224) === 224 && (b & 6) === 2;
+}
+function sniff(head) {
+  if (startsWith(head, "ID3")) return "mp3";
+  if (head.length >= 12 && startsWith(head, "ftyp", 4)) return "isobmff";
+  if ((startsWith(head, "RIFF") || startsWith(head, "RF64") || startsWith(head, "BW64")) && startsWith(head, "WAVE", 8)) {
+    return "wav";
+  }
+  if (startsWith(head, "fLaC")) return "flac";
+  if (startsWith(head, "OggS")) return "ogg";
+  return isLayer3Sync(head) ? "mp3" : null;
+}
+
+// src/transcribe/preflight.ts
+var MAX_FILE_BYTES = 5e9;
+var MIN_DURATION_SECONDS = 15;
+var MAX_DURATION_SECONDS = 36e3;
+var MAX_KEYTERMS = 1e3;
+var MAX_KEYTERM_WORDS = 6;
+var MAX_KEYTERM_CHARS = 128;
+var MAX_PROMPT_CHARS = 2e3;
+var COMPILED_PROMPT_OVERHEAD = 203;
+var MAX_MATTER_CODE = 64;
+var MEDICAL_LANGUAGES = ["en", "es", "fr", "de"];
+var SNIFF_BYTES = 64;
+var WHITE_SPACE_EDGES = new RegExp("^\\p{White_Space}+|\\p{White_Space}+$", "gu");
+var WHITE_SPACE_RUN = new RegExp("\\p{White_Space}+", "u");
+function codePoints(text) {
+  return Array.from(text).length;
+}
+function trimWhiteSpace(text) {
+  return text.replace(WHITE_SPACE_EDGES, "");
+}
+function normalizeContext(options) {
+  const keyterms = [];
+  const keytermIndexes = [];
+  (options.keyterms ?? []).forEach((term, index) => {
+    const trimmed = trimWhiteSpace(term);
+    if (trimmed !== "") {
+      keyterms.push(trimmed);
+      keytermIndexes.push(index);
+    }
+  });
+  const prompt = trimWhiteSpace(options.prompt ?? "");
+  return { keyterms, keytermIndexes, prompt: prompt === "" ? void 0 : prompt };
+}
+function checkContext(options) {
+  const { keyterms, keytermIndexes, prompt } = normalizeContext(options);
+  const unique = new Set(keyterms);
+  if (unique.size > MAX_KEYTERMS) {
+    throw invalidOption(
+      `keyterms takes at most ${String(MAX_KEYTERMS)} unique terms (${String(unique.size)} given).`
+    );
+  }
+  keyterms.forEach((term, position) => {
+    const name = `keyterms[${String(keytermIndexes[position])}]`;
+    if (codePoints(term) > MAX_KEYTERM_CHARS) {
+      throw invalidOption(`${name} is longer than ${String(MAX_KEYTERM_CHARS)} characters.`);
+    }
+    if (term.split(WHITE_SPACE_RUN).length > MAX_KEYTERM_WORDS) {
+      throw invalidOption(`${name} has more than ${String(MAX_KEYTERM_WORDS)} words.`);
+    }
+  });
+  if (prompt === void 0) return;
+  const promptChars = codePoints(prompt);
+  if (promptChars > MAX_PROMPT_CHARS) {
+    throw invalidOption(`prompt is longer than ${String(MAX_PROMPT_CHARS)} characters.`);
+  }
+  if (unique.size > 0) {
+    let termChars = unique.size - 1;
+    for (const term of unique) termChars += codePoints(term) + 2;
+    const compiled = COMPILED_PROMPT_OVERHEAD + promptChars + termChars;
+    if (compiled > MAX_PROMPT_CHARS) {
+      throw invalidOption(
+        `prompt and keyterms together exceed ${String(MAX_PROMPT_CHARS)} characters (${String(compiled)}).`
+      );
+    }
+  }
+}
+function invalidOption(message) {
+  return new PreflightError({ code: "invalid_option", message });
+}
+function checkPathId(id, name) {
+  if (!isPathSegment(id)) {
+    throw invalidOption(
+      `${name} must be a non-empty string that is not "." or "..", with no lone surrogate.`
+    );
+  }
+  return id;
+}
+function checkDurationOption(seconds2) {
+  if (seconds2 !== void 0 && !(Number.isFinite(seconds2) && seconds2 > 0)) {
+    throw invalidOption("durationSeconds must be a finite number of seconds, above 0.");
+  }
+}
+function checkIdempotencyKey(key) {
+  let printable = typeof key === "string" && key.length >= 16 && key.length <= 128;
+  for (let i = 0; printable && i < key.length; i += 1) {
+    const code = key.charCodeAt(i);
+    printable = code >= 33 && code <= 126;
+  }
+  if (!printable) {
+    throw invalidOption(
+      "idempotencyKey must be 16 to 128 printable ASCII characters, without spaces."
+    );
+  }
+}
+function checkOptions(options) {
+  if (options.medical === true && !MEDICAL_LANGUAGES.includes(options.language ?? "")) {
+    throw invalidOption("medical needs language to be one of en, es, fr or de.");
+  }
+  checkContext(options);
+  if ((options.matterCode ?? "").length > MAX_MATTER_CODE) {
+    throw invalidOption(`matterCode is at most ${String(MAX_MATTER_CODE)} characters.`);
+  }
+  if (options.idempotencyKey !== void 0) checkIdempotencyKey(options.idempotencyKey);
+}
+async function readHead(source, signal) {
+  try {
+    return await source.head(SNIFF_BYTES, signal);
+  } catch (error) {
+    if (error instanceof HushscriptError) throw error;
+    throw new PreflightError({
+      code: "file_unreadable",
+      message: `The input could not be read (${describeError(error)}).`,
+      cause: error
+    });
+  }
+}
+async function preflight(source, options, api, signal) {
+  if (sniff(await readHead(source, signal)) === null) {
+    throw new UnsupportedMediaError({
+      code: "unsupported_media",
+      message: "The file is not in a supported audio format."
+    });
+  }
+  if (source.size > MAX_FILE_BYTES) {
+    throw new FileLimitError({
+      code: "size_out_of_range",
+      message: `The file is ${String(source.size)} bytes; the limit is 1 byte to ${String(MAX_FILE_BYTES)} bytes.`
+    });
+  }
+  const seconds2 = options.durationSeconds ?? await probeDuration(source, signal);
+  if (seconds2 < MIN_DURATION_SECONDS || Math.ceil(seconds2) > MAX_DURATION_SECONDS) {
+    throw new FileLimitError({
+      code: "duration_out_of_range",
+      message: `The duration is ${String(seconds2)} s; it must be 15 s to 10 hours.`
+    });
+  }
+  checkOptions(options);
+  const declared = Math.ceil(seconds2);
+  const data = await readAccount(api, signal);
+  const { used_today_seconds: used, max_daily_seconds: max } = data.limits;
+  if (used + declared > max) {
+    throw new DailyLimitError({
+      code: "daily_limit",
+      message: `This upload would pass the daily limit (${String(used)} of ${String(max)} s used).`,
+      details: { usedSeconds: used, maxSeconds: max },
+      hintValues: hintValuesFrom({ usedSeconds: used, maxSeconds: max })
+    });
+  }
+  return declared;
+}
+
+// src/resources/agent.ts
+var CLAIM_ROUTE = "POST /v1/agent/accounts/{signup_id}/claim";
+var ROTATE_ROUTE = "POST /v1/agent/credentials/rotate";
+function lostCredential(route, status, received, cause) {
+  return new OutcomeUnknownError({
+    message: `${route} answered ${String(status)} without a usable token, so the token may be lost.`,
+    hint: OutcomeUnknownError.hintFor(route),
+    cause: badResponse(route, status, cause),
+    ...received === void 0 ? {} : { receivedToken: received }
+  });
+}
+function tokenOf(body, route, status, keepReceived) {
+  const pat = body?.["pat"];
+  if (typeof pat !== "string") throw lostCredential(route, status);
+  registerSecret(pat.trim());
+  try {
+    return checkToken(pat);
+  } catch (error) {
+    const received = keepReceived && pat.trim() !== "" ? pat : void 0;
+    throw lostCredential(route, status, received, error);
+  }
+}
+var SIGNUP_FIELDS = /* @__PURE__ */ new Set([
+  ...[
+    "signup_id",
+    "claim_secret",
+    "checkout_url",
+    "pack",
+    "amount",
+    "currency",
+    "expires_at"
+  ]
+]);
+var CLAIM_FIELDS = /* @__PURE__ */ new Set(["pat", "balance_seconds", "user_id", "scopes"]);
+var ROTATE_FIELDS = /* @__PURE__ */ new Set(["pat", "pat_id", "scopes", "expires_at"]);
+function strings(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function tokenlessApi(baseUrl) {
+  const config = resolveTokenlessConfig({ baseUrl });
+  const api = createClient({ baseUrl: config.baseUrl, fetch: createTransport(config) });
+  api.use({
+    onRequest: ({ request }) => {
+      request.headers.set("user-agent", config.userAgent);
+    }
+  });
+  return api;
+}
+var agentStatic = {
+  async signup(request) {
+    const terms = request.acceptTerms;
+    if (typeof terms !== "string" || terms === "") {
+      throw new ValidationError({
+        code: "accept_terms_required",
+        message: "acceptTerms is required: pass the policy version you accept. It is never filled in for you."
+      });
+    }
+    const api = tokenlessApi(request.baseUrl);
+    const body = await readBody(
+      api.POST("/v1/agent/accounts", {
+        body: {
+          contact_email: request.email,
+          pack_id: request.pack,
+          accept_terms_version: request.acceptTerms,
+          agent: {
+            name: request.agent.name,
+            platform: request.agent.platform,
+            ...request.agent.contactUrl === void 0 ? {} : { contact_url: request.agent.contactUrl }
+          },
+          ...request.dataRegion === void 0 ? {} : { data_region: request.dataRegion },
+          ...request.dryRun === void 0 ? {} : { dry_run: request.dryRun }
+        },
+        parseAs: "text"
+      }),
+      "POST /v1/agent/accounts",
+      AGENT_SIGNUP
+    );
+    return withRedactedField(
+      "AgentSignup",
+      {
+        ...unknownFields(body, SIGNUP_FIELDS),
+        signupId: body.signup_id,
+        claimSecret: body.claim_secret,
+        checkoutUrl: body.checkout_url,
+        price: toMoney(body.amount, body.currency),
+        expiresAt: new Date(body.expires_at * 1e3)
+      },
+      "claimSecret"
+    );
+  },
+  async claim(signupId, claimSecret, options = {}) {
+    checkPathId(signupId, "signupId");
+    if (typeof claimSecret === "string") registerSecret(claimSecret);
+    const api = tokenlessApi(options.baseUrl);
+    const { status, body } = await readObject(
+      api.POST("/v1/agent/accounts/{signup_id}/claim", {
+        // The OpenAPI document leaves the {signup_id} path parameter out of this operation, so its
+        // generated type has no `path`; openapi-fetch still fills the template from it.
+        params: { path: { signup_id: signupId } },
+        body: { claim_secret: claimSecret },
+        parseAs: "text"
+      }),
+      CLAIM_ROUTE
+    );
+    const pat = tokenOf(body, CLAIM_ROUTE, status, false);
+    const seconds2 = body?.["balance_seconds"];
+    const balanceSeconds = typeof seconds2 === "number" && Number.isInteger(seconds2) ? seconds2 : 0;
+    const userId = body?.["user_id"];
+    return withRedactedField(
+      "AgentClaim",
+      {
+        ...body === null ? {} : unknownFields(body, CLAIM_FIELDS),
+        token: pat,
+        userId: typeof userId === "string" ? userId : "",
+        scopes: strings(body?.["scopes"]),
+        // A fresh account has no holds; the claim answer carries no expiry, and a follow-up read
+        // could fail after the token was shown for the only time.
+        balance: {
+          seconds: balanceSeconds,
+          minutes: Math.trunc(balanceSeconds / 60),
+          heldSeconds: 0,
+          expiresAt: null,
+          purchasesRemaining: null
+        }
+      },
+      "token"
+    );
+  }
+};
+var AgentResource = class {
+  #api;
+  #config;
+  constructor(api, config) {
+    this.#api = api;
+    this.#config = config;
+  }
+  /**
+   * Mints a successor token and revokes the one in use. The client starts using the new token at
+   * once; store the returned one. A lost answer raises `OutcomeUnknownError` and is never retried.
+   */
+  async rotateToken() {
+    const { status, body } = await readObject(
+      this.#api.POST("/v1/agent/credentials/rotate", { parseAs: "text" }),
+      ROTATE_ROUTE
+    );
+    const pat = tokenOf(body, ROTATE_ROUTE, status, true);
+    const expiresAt = body?.["expires_at"];
+    if (expiresAt !== void 0 && expiresAt !== null) {
+      const found = timestamp(expiresAt);
+      if (found !== null) {
+        const problem2 = describeProblem({ path: ["expires_at"], expected: found.expected });
+        throw lostCredential(ROTATE_ROUTE, status, pat, new Error(problem2));
+      }
+    }
+    this.#config.setToken(pat);
+    const tokenId = body?.["pat_id"];
+    return withRedactedField(
+      "RotatedToken",
+      {
+        ...body === null ? {} : unknownFields(body, ROTATE_FIELDS),
+        token: pat,
+        tokenId: typeof tokenId === "string" ? tokenId : "",
+        scopes: strings(body?.["scopes"]),
+        expiresAt: typeof expiresAt === "number" ? new Date(expiresAt * 1e3) : null
+      },
+      "token"
+    );
+  }
+};
+
+// src/paginate.ts
+function nextCursorOf(cursor) {
+  return cursor === "" ? null : cursor;
+}
+function assertCursorAdvanced(sent, next) {
+  if (next !== null && next === sent) {
+    throw new HushscriptError({
+      code: "pagination_loop",
+      message: "The API returned the same page cursor it was sent; stopping instead of repeating the page."
+    });
+  }
+}
+function stopIfAborted(signal) {
+  if (signal?.aborted === true) throw aborted(signal);
+}
+async function* paginate(fetchPage, signal) {
+  let cursor = null;
+  do {
+    stopIfAborted(signal);
+    const sent = cursor;
+    const page = await fetchPage(sent);
+    for (const item of page.items) {
+      stopIfAborted(signal);
+      yield item;
+    }
+    cursor = nextCursorOf(page.nextCursor);
+    assertCursorAdvanced(sent, cursor);
+  } while (cursor !== null);
+}
+
+// src/resources/billing.ts
+var PURCHASE_KEY = /^[\w-]{1,128}$/;
+var PURCHASE_ROUTE = "POST /v1/billing/purchase";
+function date(unixSeconds) {
+  return new Date(unixSeconds * 1e3);
+}
+var PACK_FIELDS = /* @__PURE__ */ new Set([
+  ...[
+    "id",
+    "amount",
+    "currency",
+    "seconds",
+    "referral_bonus_seconds",
+    "available"
+  ]
+]);
+var CARD_FIELDS = /* @__PURE__ */ new Set([
+  ...[
+    "id",
+    "type",
+    "brand",
+    "last4",
+    "exp_month",
+    "exp_year",
+    "email",
+    "is_default",
+    "fast_checkout_eligible"
+  ]
+]);
+var TRANSACTION_FIELDS = /* @__PURE__ */ new Set([
+  ...[
+    "id",
+    "seconds",
+    "amount_cents",
+    "amount_refunded_cents",
+    "currency",
+    "status",
+    "created_at",
+    "payment_method_type",
+    "payment_method_brand",
+    "payment_method_last4",
+    "receipt_number",
+    "initiated_via"
+  ]
+]);
+var LEDGER_FIELDS = /* @__PURE__ */ new Set([
+  ...[
+    "id",
+    "delta_seconds",
+    "kind",
+    "job_id",
+    "note",
+    "created_at"
+  ]
+]);
+var HOLD_FIELDS = /* @__PURE__ */ new Set([
+  ...[
+    "id",
+    "kind",
+    "seconds",
+    "created_at"
+  ]
+]);
+var CARDS_FIELDS = /* @__PURE__ */ new Set(["default_id", "methods"]);
+var PURCHASE_FIELDS = /* @__PURE__ */ new Set(["status", "balance_seconds"]);
+function packOf(raw) {
+  return {
+    ...unknownFields(raw, PACK_FIELDS),
+    id: raw.id,
+    seconds: raw.seconds,
+    minutes: Math.trunc(raw.seconds / 60),
+    price: toMoney(raw.amount, raw.currency),
+    bonusMinutes: Math.trunc(raw.referral_bonus_seconds / 60),
+    available: raw.available ?? true
+  };
+}
+function chosenCard(saved) {
+  if (saved.defaultId !== null) return saved.defaultId;
+  const eligible = saved.cards.filter((card) => card.fastCheckoutEligible);
+  const [only] = eligible;
+  if (only === void 0) {
+    throw new PaymentMethodRequiredError({
+      message: "The account has no saved card that can be charged."
+    });
+  }
+  if (eligible.length > 1) {
+    throw new PaymentMethodRequiredError({
+      code: "default_card_required",
+      message: "The account has no default card and several that can be charged."
+    });
+  }
+  return only.id;
+}
+var BillingResource = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /** The minute packs this account can buy, priced in its own currency. Needs the `billing` scope. */
+  async packs() {
+    const body = await readBody(
+      this.#api.GET("/v1/billing/packs", { parseAs: "text" }),
+      "GET /v1/billing/packs",
+      PACKS
+    );
+    return body.packs.map(packOf);
+  }
+  async cards() {
+    const body = await readBody(
+      this.#api.GET("/v1/billing/cards", { parseAs: "text" }),
+      "GET /v1/billing/cards",
+      CARDS
+    );
+    return {
+      ...unknownFields(body, CARDS_FIELDS),
+      defaultId: body.default_id,
+      cards: body.methods.map((m) => camelizeKnown(m, CARD_FIELDS))
+    };
+  }
+  async setDefaultCard(cardId) {
+    checkPathId(cardId, "cardId");
+    await readBody(
+      this.#api.POST("/v1/billing/cards/default", {
+        body: { payment_method_id: cardId },
+        parseAs: "text"
+      }),
+      "POST /v1/billing/cards/default",
+      SET_DEFAULT_CARD
+    );
+  }
+  /**
+   * The hosted page where a card is saved; open it in a browser. The request carries a key, so
+   * the single retry after a 502 lands on the same page.
+   */
+  async addCardUrl() {
+    const body = await readBody(
+      this.#api.POST("/v1/billing/setup-session", {
+        body: { idempotency_key: randomUUID() },
+        parseAs: "text"
+      }),
+      "POST /v1/billing/setup-session",
+      SETUP_SESSION
+    );
+    return body.checkout_url;
+  }
+  /**
+   * Buys `packId` with the default card and returns the balance the purchase answer reports. It
+   * makes no follow-up request. A lost or unusable response can still raise an error after payment.
+   * Every error raised once the purchase request may have been sent carries `idempotencyKey`; pass it back as
+   * `idempotencyKey` to retry without any chance of a second charge. One raised before any attempt
+   * was sent carries none: nothing can have been charged.
+   */
+  async buy(packId, options = {}) {
+    const key = options.idempotencyKey === void 0 ? randomUUID() : options.idempotencyKey;
+    if (typeof key !== "string" || !PURCHASE_KEY.test(key)) {
+      throw invalidOption(
+        "idempotencyKey must be 1 to 128 characters from A-Z, a-z, 0-9, _ and -."
+      );
+    }
+    const card = chosenCard(await this.cards());
+    try {
+      const { status, body } = await readObject(
+        this.#api.POST("/v1/billing/purchase", {
+          body: {
+            pack: packId,
+            idempotency_key: key,
+            quick_payment_method_id: card,
+            policy_ack: options.acknowledgeNoRefund === true
+          },
+          parseAs: "text"
+        }),
+        PURCHASE_ROUTE
+      );
+      const seconds2 = body?.["balance_seconds"];
+      if (body?.["status"] !== "ok" || typeof seconds2 !== "number" || !Number.isSafeInteger(seconds2)) {
+        throw badResponse(PURCHASE_ROUTE, status);
+      }
+      return {
+        ...unknownFields(body, PURCHASE_FIELDS),
+        seconds: seconds2,
+        minutes: Math.trunc(seconds2 / 60) + 0
+      };
+    } catch (error) {
+      const failure = asHushscriptError(error);
+      if (!wasNotSent(failure)) failure.idempotencyKey = key;
+      throw failure;
+    }
+  }
+  /** Purchases, newest first. */
+  transactions(options = {}) {
+    return paginate(async (cursor) => {
+      const page = await readBody(
+        this.#api.GET("/v1/billing/transactions", {
+          params: { query: cursor === null ? {} : { cursor } },
+          parseAs: "text",
+          ...options.signal === void 0 ? {} : { signal: options.signal }
+        }),
+        "GET /v1/billing/transactions",
+        TRANSACTIONS
+      );
+      return {
+        items: page.transactions.map(
+          (row) => ({
+            ...camelizeKnown(row, TRANSACTION_FIELDS),
+            createdAt: date(row.created_at)
+          })
+        ),
+        nextCursor: nextCursorOf(page.next_cursor)
+      };
+    }, options.signal);
+  }
+  /** Every hold, settle, release, purchase and refund that moved the balance, newest first. */
+  ledger(options = {}) {
+    return paginate(async (cursor) => {
+      const page = await readBody(
+        this.#api.GET("/v1/billing/ledger", {
+          params: { query: cursor === null ? {} : { cursor } },
+          parseAs: "text",
+          ...options.signal === void 0 ? {} : { signal: options.signal }
+        }),
+        "GET /v1/billing/ledger",
+        LEDGER
+      );
+      return {
+        items: page.entries.map(
+          (row) => ({
+            ...camelizeKnown(row, LEDGER_FIELDS),
+            createdAt: date(row.created_at)
+          })
+        ),
+        nextCursor: nextCursorOf(page.next_cursor)
+      };
+    }, options.signal);
+  }
+  /** The seconds currently reserved by work in flight, newest first. */
+  holds(options = {}) {
+    return paginate(async (cursor) => {
+      const page = await readBody(
+        this.#api.GET("/v1/billing/holds", {
+          params: { query: cursor === null ? {} : { cursor } },
+          parseAs: "text",
+          ...options.signal === void 0 ? {} : { signal: options.signal }
+        }),
+        "GET /v1/billing/holds",
+        HOLDS
+      );
+      return {
+        items: page.holds.map(
+          (row) => ({
+            ...camelizeKnown(row, HOLD_FIELDS),
+            createdAt: date(row.created_at)
+          })
+        ),
+        nextCursor: nextCursorOf(page.next_cursor)
+      };
+    }, options.signal);
+  }
+};
+
+// src/transcribe/wait.ts
+var DEFAULT_WAIT_TIMEOUT_SECONDS = 3600;
+var POLL_START_MS = 5e3;
+var POLL_FACTOR = 1.5;
+var POLL_CEILING_MS = 15e3;
+function isFinished(job) {
+  return job.state === "done" || job.state === "failed";
+}
+function failureOf(job) {
+  const kind = job.failure_kind === "media_unreadable" || job.failure_kind === "media_undecodable";
+  return new JobFailedError({
+    message: job.error ?? "The job failed.",
+    error: job.error,
+    failureKind: kind ? job.failure_kind : null,
+    jobId: job.id
+  });
+}
+async function readJob(api, id, signal) {
+  return readBody(
+    api.GET("/v1/jobs/{id}", {
+      params: { path: { id } },
+      parseAs: "text",
+      signal: signal ?? null
+    }),
+    "GET /v1/jobs/{id}",
+    JOB_ONE
+  );
+}
+async function waitForJob(settings) {
+  const { api, clock, jobId, signal } = settings;
+  const startedAt = clock.now();
+  const deadline = startedAt + settings.waitTimeout * 1e3;
+  let interval = POLL_START_MS;
+  for (; ; ) {
+    const job = await readJob(api, jobId, signal);
+    if (isFinished(job)) return job;
+    if (job.state === "queued" || job.state === "processing") {
+      settings.onProgress?.({ stage: "processing", state: job.state });
+    }
+    const remaining = deadline - clock.now();
+    if (remaining <= 0) {
+      throw new WaitTimeoutError({
+        message: `The job is still ${job.state} after ${String(settings.waitTimeout)} s; it keeps running.`,
+        resumeToken: settings.resumeToken
+      });
+    }
+    await sleepOrAbort(clock, Math.min(interval, remaining), signal);
+    interval = Math.min(interval * POLL_FACTOR, POLL_CEILING_MS);
+  }
+}
+
+// src/resources/jobs.ts
+var JOB_FIELDS = /* @__PURE__ */ new Set([
+  ...[
+    "id",
+    "state",
+    "mode",
+    "declared_seconds",
+    "verified_seconds",
+    "actual_seconds",
+    "billable_seconds",
+    "error",
+    "failure_kind",
+    "retry_of",
+    "created_at",
+    "transcript_id",
+    "private_result_expires_at",
+    "private_result_available",
+    "options",
+    "fetched_bytes",
+    "fetch_total_bytes"
+  ]
+]);
+function toJob(raw) {
+  return {
+    ...unknownFields(raw, JOB_FIELDS),
+    id: raw.id,
+    state: raw.state,
+    transcriptId: raw.transcript_id,
+    error: raw.error,
+    failureKind: raw.failure_kind,
+    mode: raw.mode,
+    declaredSeconds: raw.declared_seconds,
+    verifiedSeconds: raw.verified_seconds,
+    actualSeconds: raw.actual_seconds,
+    billableSeconds: raw.billable_seconds,
+    retryOf: raw.retry_of,
+    createdAt: new Date(raw.created_at * 1e3),
+    options: camelize(raw.options)
+  };
+}
+var JobsResource = class {
+  #api;
+  #wait;
+  constructor(api, wait) {
+    this.#api = api;
+    this.#wait = wait;
+  }
+  /** Every job, newest first; `active` keeps only the ones that have not finished. `signal` stops the walk between and during pages. */
+  list(options = {}) {
+    const { signal } = options;
+    return paginate(async (cursor) => {
+      const query2 = {};
+      if (options.active === true) query2.active = "true";
+      if (cursor !== null) query2.cursor = cursor;
+      const page = await readBody(
+        this.#api.GET("/v1/jobs", {
+          params: { query: query2 },
+          parseAs: "text",
+          ...signal === void 0 ? {} : { signal }
+        }),
+        "GET /v1/jobs",
+        JOB_LIST
+      );
+      return { items: page.jobs.map(toJob), nextCursor: nextCursorOf(page.next_cursor) };
+    }, signal);
+  }
+  async get(id) {
+    return toJob(await readJob(this.#api, checkPathId(id, "id")));
+  }
+  /** Polls until the job is done or failed; times out with a `WaitTimeoutError` that has no resume token. */
+  async wait(id, options) {
+    return toJob(await this.#wait(checkPathId(id, "id"), options));
+  }
+};
+
+// src/format/captions.ts
+var MAX_CHARS_PER_LINE = 42;
+var MAX_LINES = 2;
+var MAX_CUE_MS = 7e3;
+function wrapIntoCues(text, maxChars, maxLines) {
+  const words = text.split(/\s+/).filter(Boolean);
+  if (words.length === 0) return [""];
+  const cues = [];
+  let lines = [];
+  let line = "";
+  const flushLine = () => {
+    if (line !== "") lines.push(line);
+    line = "";
+  };
+  const flushCue = () => {
+    flushLine();
+    if (lines.length > 0) cues.push(lines.join("\n"));
+    lines = [];
+  };
+  for (const word of words) {
+    const candidate = line === "" ? word : `${line} ${word}`;
+    if (candidate.length <= maxChars) {
+      line = candidate;
+    } else {
+      flushLine();
+      if (lines.length >= maxLines) flushCue();
+      line = word;
+    }
+  }
+  flushCue();
+  return cues.length > 0 ? cues : [""];
+}
+function utteranceCues(utterances) {
+  return utterances.map((u) => ({
+    startMs: u.startMs,
+    endMs: u.endMs,
+    speaker: u.speaker,
+    speakerName: u.speakerName,
+    text: u.text
+  }));
+}
+function segmentCaptions(utterances) {
+  const textChars = (cue) => cue.replaceAll("\n", " ").length;
+  const out = [];
+  for (const u of utterances) {
+    const chunks = wrapIntoCues(u.text, MAX_CHARS_PER_LINE, MAX_LINES);
+    const span = Math.max(0, u.endMs - u.startMs);
+    const totalChars = chunks.reduce((sum, chunk) => sum + textChars(chunk), 0) || 1;
+    let accChars = 0;
+    chunks.forEach((text, index) => {
+      const startMs = u.startMs + Math.round(span * accChars / totalChars);
+      accChars += Math.max(1, textChars(text));
+      let endMs = index === chunks.length - 1 ? u.endMs : u.startMs + Math.round(span * accChars / totalChars);
+      if (endMs - startMs > MAX_CUE_MS) endMs = startMs + MAX_CUE_MS;
+      if (endMs < startMs) endMs = startMs;
+      out.push({ startMs, endMs, speaker: u.speaker, speakerName: u.speakerName, text });
+    });
+  }
+  return out;
+}
+
+// src/format/time.ts
+function pad(n, width = 2) {
+  return String(n).padStart(width, "0");
+}
+function secondsToClock(totalSeconds) {
+  const s = Math.max(0, Math.floor(totalSeconds));
+  const h = Math.floor(s / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  const sec = s % 60;
+  return h > 0 ? `${String(h)}:${pad(m)}:${pad(sec)}` : `${String(m)}:${pad(sec)}`;
+}
+function msToClock(ms) {
+  return secondsToClock(Math.floor(ms / 1e3));
+}
+function srtTimestamp(ms, separator = ",") {
+  const total = Math.max(0, Math.floor(ms));
+  const h = Math.floor(total / 36e5);
+  const m = Math.floor(total % 36e5 / 6e4);
+  const s = Math.floor(total % 6e4 / 1e3);
+  return `${pad(h)}:${pad(m)}:${pad(s)}${separator}${pad(total % 1e3, 3)}`;
+}
+
+// src/format/srt.ts
+function cueText(text) {
+  return text.split(/\r\n?|\n/).filter((line) => line.trim() !== "").join("\n");
+}
+function cuesFor(utterances, options) {
+  return options.captions === false ? utteranceCues(utterances) : segmentCaptions(utterances);
+}
+function withSpeaker(cue) {
+  return cue.speakerName === "" ? cue.text : `${cue.speakerName}: ${cue.text}`;
+}
+function arrowSafeCueText(text) {
+  return cueText(text).replace(/-{2,}>/g, "->");
+}
+function renderSrt(utterances, options) {
+  return cuesFor(utterances, options).map(
+    (cue, index) => `${String(index + 1)}
+${srtTimestamp(cue.startMs)} --> ${srtTimestamp(cue.endMs)}
+${arrowSafeCueText(withSpeaker(cue))}`
+  ).join("\n\n");
+}
+
+// src/format/txt.ts
+function blocksOf(utterances, merge) {
+  const blocks = [];
+  for (const u of utterances) {
+    const last = blocks.at(-1);
+    if (merge && last?.speaker === u.speaker) {
+      last.text += ` ${u.text}`;
+    } else {
+      blocks.push({
+        speaker: u.speaker,
+        speakerName: u.speakerName,
+        startMs: u.startMs,
+        text: u.text
+      });
+    }
+  }
+  return blocks;
+}
+function renderText(utterances, options) {
+  return blocksOf(utterances, options.merge !== false).map((block) => {
+    const who = options.speakers === false ? "" : block.speakerName;
+    const prefix = options.timestamps === true ? `[${msToClock(block.startMs)}] ` : "";
+    return `${prefix}${who === "" ? block.text : `${who}: ${block.text}`}`;
+  }).join("\n\n");
+}
+
+// src/format/vtt.ts
+function vttCueText(text) {
+  return cueText(text).replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll("-->", "--&gt;");
+}
+function renderVtt(utterances, options) {
+  const body = cuesFor(utterances, options).map(
+    (cue, index) => `${String(index + 1)}
+${srtTimestamp(cue.startMs, ".")} --> ${srtTimestamp(cue.endMs, ".")}
+${vttCueText(withSpeaker(cue))}`
+  ).join("\n\n");
+  return `WEBVTT
+
+${body}
+`;
+}
+
+// src/transcript.ts
+var CLEANED_KEY = "cleaned";
+function seconds(value) {
+  return new Date(value * 1e3);
+}
+function displayName(label, names) {
+  const saved = Object.hasOwn(names, label) ? names[label] : void 0;
+  const named = typeof saved === "string" ? saved.trim() : "";
+  if (named !== "") return named;
+  return label.trim() === "" ? "" : `Speaker ${label}`;
+}
+function utterancesOf(language, names) {
+  return language.utterances.map((u) => ({
+    // Fields the API adds later stay on the utterance, camelCased; the known ones below win.
+    ...camelize(u),
+    speaker: u.speaker,
+    speakerName: displayName(u.speaker, names),
+    startMs: u.start_ms,
+    endMs: u.end_ms,
+    text: u.text
+  }));
+}
+var Transcript = class _Transcript {
+  id;
+  title;
+  language;
+  durationSeconds;
+  createdAt;
+  updatedAt;
+  autoDeleteAt;
+  tags;
+  edited;
+  /** Label to display name, for the speakers that were renamed. */
+  speakers;
+  /** The original language. */
+  utterances;
+  /** Translation locales, without the reserved "cleaned". */
+  languages;
+  /** The AI-cleaned body, when there is one. */
+  cleaned;
+  #raw;
+  #translations = /* @__PURE__ */ new Map();
+  constructor(raw) {
+    this.#raw = raw;
+    this.id = raw.id;
+    this.title = raw.title;
+    this.language = raw.language_detected;
+    this.durationSeconds = raw.duration_seconds;
+    this.createdAt = seconds(raw.created_at);
+    this.updatedAt = seconds(raw.updated_at);
+    this.autoDeleteAt = raw.auto_delete_at === null ? null : seconds(raw.auto_delete_at);
+    this.tags = raw.tags;
+    this.edited = raw.edited;
+    this.speakers = raw.speaker_names;
+    this.utterances = utterancesOf(raw.body.original, raw.speaker_names);
+    const translations = raw.body.translations;
+    this.languages = Object.keys(translations).filter((key) => key !== CLEANED_KEY);
+    this.cleaned = Object.hasOwn(translations, CLEANED_KEY) ? this.#translation(CLEANED_KEY) : null;
+  }
+  /** Builds a transcript from a `GET /v1/transcripts/{id}` body, which `toJSON()` returns again. */
+  static fromApi(body) {
+    const found = TRANSCRIPT_DETAIL(body);
+    if (found !== null) {
+      throw badResponse("GET /v1/transcripts/{id}", null, new Error(describeProblem(found)));
+    }
+    return new _Transcript(body);
+  }
+  #translation(language) {
+    const known = this.#translations.get(language);
+    if (known !== void 0) return known;
+    const body = this.#raw.body.translations[language];
+    const built = body === void 0 ? this.utterances : utterancesOf(body, this.speakers);
+    this.#translations.set(language, built);
+    return built;
+  }
+  /** The plain text, the same as `toText()`. */
+  get text() {
+    return this.toText();
+  }
+  /** The translation (or "cleaned" body) for `language`; the original when there is none. */
+  utterancesFor(language) {
+    if (language === void 0 || language === "original") return this.utterances;
+    return Object.hasOwn(this.#raw.body.translations, language) ? this.#translation(language) : this.utterances;
+  }
+  toSRT(options = {}) {
+    return renderSrt(this.utterancesFor(options.language), options);
+  }
+  toVTT(options = {}) {
+    return renderVtt(this.utterancesFor(options.language), options);
+  }
+  toText(options = {}) {
+    return renderText(this.utterancesFor(options.language), options);
+  }
+  /** The API body this transcript was built from, unknown fields included. */
+  toJSON() {
+    return this.#raw;
+  }
+};
+
+// src/resources/transcripts.ts
+function date2(unixSeconds) {
+  return new Date(unixSeconds * 1e3);
+}
+function signalOf(signal) {
+  return signal === void 0 ? {} : { signal };
+}
+function query(options) {
+  const out = {};
+  if (options.pageSize !== void 0) {
+    if (!Number.isInteger(options.pageSize) || options.pageSize < 1) {
+      throw invalidOption("pageSize must be a whole number of 1 or more.");
+    }
+    out.limit = options.pageSize;
+  }
+  if (options.cursor !== void 0) out.cursor = options.cursor;
+  return out;
+}
+var SUMMARY_FIELDS = /* @__PURE__ */ new Set([
+  ...[
+    "id",
+    "title",
+    "language_detected",
+    "duration_seconds",
+    "created_at",
+    "auto_delete_at",
+    "tags",
+    "options",
+    "insights_state"
+  ]
+]);
+var DELETED_FIELDS = /* @__PURE__ */ new Set([
+  ...[
+    "id",
+    "title",
+    "duration_seconds",
+    "created_at",
+    "deleted_at",
+    "cause",
+    "receipt"
+  ]
+]);
+function summaryOf(row) {
+  return {
+    ...unknownFields(row, SUMMARY_FIELDS),
+    id: row.id,
+    title: row.title,
+    language: row.language_detected,
+    durationSeconds: row.duration_seconds,
+    createdAt: date2(row.created_at),
+    autoDeleteAt: row.auto_delete_at === null ? null : date2(row.auto_delete_at),
+    tags: row.tags
+  };
+}
+function deletedOf(row) {
+  return {
+    ...unknownFields(row, DELETED_FIELDS),
+    id: row.id,
+    title: row.title,
+    durationSeconds: row.duration_seconds,
+    createdAt: date2(row.created_at),
+    deletedAt: date2(row.deleted_at),
+    cause: row.cause,
+    receipt: row.receipt
+  };
+}
+function readTranscript(api, id, signal) {
+  return readBody(
+    api.GET("/v1/transcripts/{id}", {
+      params: { path: { id } },
+      parseAs: "text",
+      ...signalOf(signal)
+    }),
+    "GET /v1/transcripts/{id}",
+    TRANSCRIPT_DETAIL
+  );
+}
+var TranscriptsResource = class {
+  #api;
+  constructor(api) {
+    this.#api = api;
+  }
+  /**
+   * Every finished transcript, newest first, fetching pages as it goes. Jobs still running are in `jobs.list({ active: true })`.
+   * A page whose `next_cursor` repeats the cursor sent is yielded whole, then the walk raises `pagination_loop`.
+   */
+  list(options = {}) {
+    query(options);
+    return paginate(
+      (cursor) => this.#fetchPage({ ...options, ...cursor === null ? {} : { cursor } }),
+      options.signal
+    );
+  }
+  /** One page of `list()`. Raises `pagination_loop` when the answer's `next_cursor` is the cursor sent. */
+  async page(options = {}) {
+    const page = await this.#fetchPage(options);
+    assertCursorAdvanced(options.cursor ?? null, page.nextCursor);
+    return page;
+  }
+  async #fetchPage(options) {
+    const body = await readBody(
+      this.#api.GET("/v1/transcripts", {
+        params: { query: query(options) },
+        parseAs: "text",
+        ...signalOf(options.signal)
+      }),
+      "GET /v1/transcripts",
+      TRANSCRIPT_LIST
+    );
+    return { items: body.transcripts.map(summaryOf), nextCursor: nextCursorOf(body.next_cursor) };
+  }
+  async get(id) {
+    return Transcript.fromApi(await readTranscript(this.#api, checkPathId(id, "id")));
+  }
+  /** Deletion records, by upload time, newest first. */
+  deleted(options = {}) {
+    return paginate(async (cursor) => {
+      const body = await readBody(
+        this.#api.GET("/v1/transcripts/deleted", {
+          params: { query: cursor === null ? {} : { cursor } },
+          parseAs: "text",
+          ...signalOf(options.signal)
+        }),
+        "GET /v1/transcripts/deleted",
+        DELETED_LIST
+      );
+      return { items: body.deleted.map(deletedOf), nextCursor: nextCursorOf(body.next_cursor) };
+    }, options.signal);
+  }
+};
+
+// src/transcribe/heartbeat.ts
+var HEARTBEAT_INTERVAL_MS = 12e4;
+async function runHeartbeat(options) {
+  const { clock, signal, send } = options;
+  const interval = options.intervalMs ?? HEARTBEAT_INTERVAL_MS;
+  let nextAt = clock.now() + interval;
+  for (; ; ) {
+    try {
+      await clock.sleep(Math.max(0, nextAt - clock.now()), signal);
+    } catch {
+      return;
+    }
+    nextAt = Math.max(nextAt, clock.now()) + interval;
+    try {
+      await send();
+    } catch (error) {
+      if (signal.aborted) return;
+      if (error instanceof AuthenticationError) throw error;
+      if (error instanceof HushscriptError && error.code === "wrong_state") return;
+    }
+  }
+}
+
+// src/transcribe/resume.ts
+function encodeResumeToken(state) {
+  const body = {
+    v: 1,
+    jobId: state.jobId,
+    idempotencyKey: state.idempotencyKey,
+    size: state.size,
+    durationSeconds: state.durationSeconds
+  };
+  return Buffer.from(JSON.stringify(body)).toString("base64url");
+}
+var isWhole = (value) => Number.isSafeInteger(value);
+var isFiniteNumber = (value) => Number.isFinite(value);
+function invalid() {
+  return new ConfigurationError({ message: "The resume token is not valid." });
+}
+function decodeResumeToken(token) {
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(token, "base64url").toString("utf8"));
+  } catch {
+    throw invalid();
+  }
+  if (parsed === null) throw invalid();
+  const body = parsed;
+  const { jobId, idempotencyKey, size, durationSeconds } = body;
+  if (body["v"] !== 1 || !isPathSegment(jobId) || typeof idempotencyKey !== "string" || idempotencyKey === "" || !isWhole(size) || size < 1 || !isFiniteNumber(durationSeconds) || durationSeconds <= 0) {
+    throw invalid();
+  }
+  return { jobId, idempotencyKey, size, durationSeconds };
+}
+function assertSameFile(state, size) {
+  if (size === state.size) return;
+  throw new ResumeMismatchError({
+    code: "resume_file_mismatch",
+    message: `The file is ${String(size)} bytes; the upload started with ${String(state.size)} bytes.`
+  });
+}
+function fileRequired() {
+  return new ResumeMismatchError({
+    code: "resume_file_required",
+    message: "The upload is not finished, so resuming needs the original file."
+  });
+}
+function jobMissing() {
+  return new ResumeMismatchError({
+    code: "resume_job_missing",
+    message: "The job behind this resume token no longer exists, so it cannot be resumed."
+  });
+}
+function clampLength(size, offset, length) {
+  return Math.max(0, Math.min(length, size - offset));
+}
+var MemorySource = class {
+  size;
+  sequential = false;
+  probeInput;
+  #bytes;
+  constructor(bytes) {
+    this.#bytes = bytes;
+    this.size = bytes.byteLength;
+    this.probeInput = { kind: "bytes", bytes };
+  }
+  head(length, signal) {
+    return this.read(0, length, signal);
+  }
+  read(offset, length, signal) {
+    if (signal?.aborted) return Promise.reject(aborted(signal));
+    return Promise.resolve(
+      this.#bytes.subarray(offset, offset + clampLength(this.size, offset, length))
+    );
+  }
+  // Stryker disable next-line BlockStatement: every caller awaits close(), and awaiting undefined is the same as a resolved promise
+  close() {
+    return Promise.resolve();
+  }
+};
+var BlobSource = class {
+  size;
+  sequential = false;
+  probeInput;
+  #blob;
+  constructor(blob) {
+    this.#blob = blob;
+    this.size = blob.size;
+    this.probeInput = { kind: "blob", blob: blob.slice(0, blob.size, "") };
+  }
+  head(length, signal) {
+    return this.read(0, length, signal);
+  }
+  async read(offset, length, signal) {
+    if (signal?.aborted) throw aborted(signal);
+    const end = offset + clampLength(this.size, offset, length);
+    const bytes = new Uint8Array(await this.#blob.slice(offset, end).arrayBuffer());
+    if (signal?.aborted) throw aborted(signal);
+    return bytes;
+  }
+  // Stryker disable next-line BlockStatement: every caller awaits close(), and awaiting undefined is the same as a resolved promise
+  close() {
+    return Promise.resolve();
+  }
+};
+var FileSource = class {
+  size;
+  sequential = false;
+  probeInput;
+  #handle;
+  constructor(handle, path, size) {
+    this.#handle = handle;
+    this.size = size;
+    this.probeInput = { kind: "path", path };
+  }
+  head(length, signal) {
+    return this.read(0, length, signal);
+  }
+  async read(offset, length, signal) {
+    if (signal?.aborted) throw aborted(signal);
+    const wanted = clampLength(this.size, offset, length);
+    const buffer = new Uint8Array(wanted);
+    let filled = 0;
+    while (filled < wanted) {
+      const { bytesRead } = await this.#handle.read(
+        buffer,
+        filled,
+        wanted - filled,
+        offset + filled
+      );
+      if (signal?.aborted) throw aborted(signal);
+      if (bytesRead === 0) break;
+      filled += bytesRead;
+    }
+    return buffer.subarray(0, filled);
+  }
+  async close() {
+    await this.#handle.close();
+  }
+};
+function streamSizeMismatch(message) {
+  return new UploadError({ code: "stream_size_mismatch", message });
+}
+var StreamSource = class {
+  size;
+  sequential = true;
+  probeInput = null;
+  #reader;
+  #chunks = [];
+  #buffered = 0;
+  #position = 0;
+  #ended = false;
+  constructor(stream, size) {
+    this.#reader = stream.getReader();
+    this.size = size;
+  }
+  /** One read, given up with the SDK's `AbortError` when `signal` fires; `close()` releases the reader and leaves the stream itself alone. */
+  #next(signal) {
+    const pending = this.#reader.read();
+    if (signal === void 0) return pending;
+    if (signal.aborted) {
+      pending.catch(() => void 0);
+      return Promise.reject(aborted(signal));
+    }
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        reject(aborted(signal));
+      };
+      signal.addEventListener("abort", onAbort);
+      pending.then(resolve, reject).finally(() => {
+        signal.removeEventListener("abort", onAbort);
+      });
+    });
+  }
+  async #fill(length, signal) {
+    while (this.#buffered < length && !this.#ended) {
+      const { done, value } = await this.#next(signal);
+      if (done) {
+        this.#ended = true;
+      } else {
+        this.#chunks.push(value);
+        this.#buffered += value.byteLength;
+      }
+    }
+  }
+  /**
+   * The first `length` buffered bytes in one fresh array. A chunk that is only partly taken keeps a
+   * copy of its rest, so the returned part and the leftover never share (or pin) each other's memory.
+   */
+  #take(length, consume) {
+    const out = new Uint8Array(Math.min(length, this.#buffered));
+    let at = 0;
+    let used = 0;
+    for (const chunk of this.#chunks) {
+      if (at === out.byteLength) break;
+      const n = Math.min(chunk.byteLength, out.byteLength - at);
+      out.set(chunk.subarray(0, n), at);
+      at += n;
+      if (n < chunk.byteLength) {
+        if (consume) this.#chunks[used] = chunk.slice(n);
+        break;
+      }
+      used += 1;
+    }
+    if (consume) {
+      this.#chunks.splice(0, used);
+      this.#buffered -= out.byteLength;
+    }
+    return out;
+  }
+  async head(length, signal) {
+    await this.#fill(length, signal);
+    return this.#take(length, false);
+  }
+  async read(offset, length, signal) {
+    if (offset !== this.#position) {
+      throw new UploadError({
+        code: "stream_not_seekable",
+        message: "A stream can only be uploaded in order, one part at a time."
+      });
+    }
+    const wanted = clampLength(this.size, offset, length);
+    await this.#fill(wanted, signal);
+    if (this.#buffered < wanted) {
+      throw streamSizeMismatch(
+        `The stream ended after ${String(offset + this.#buffered)} bytes; size says ${String(this.size)}.`
+      );
+    }
+    const part = this.#take(wanted, true);
+    this.#position += wanted;
+    if (this.#position === this.size) {
+      await this.#fill(1, signal);
+      if (this.#buffered > 0) {
+        throw streamSizeMismatch(
+          `The stream has more than the ${String(this.size)} bytes size says.`
+        );
+      }
+    }
+    return part;
+  }
+  /** The stream belongs to the caller: releasing the lock leaves it uncanceled, unclosed and readable. */
+  close() {
+    this.#reader.releaseLock();
+    return Promise.resolve();
+  }
+};
+function isStream(file) {
+  return typeof file === "object" && "getReader" in file;
+}
+function unreadable2(path, cause) {
+  return new PreflightError({
+    code: "file_unreadable",
+    message: `${path} cannot be read: it is missing, not a regular file or cannot be opened${cause === void 0 ? "" : ` (${describeError(cause)})`}.`,
+    cause
+  });
+}
+async function statFile(path) {
+  let info;
+  try {
+    info = await stat(path);
+  } catch (error) {
+    throw unreadable2(path, error);
+  }
+  if (!info.isFile()) throw unreadable2(path);
+  return info.size;
+}
+async function openFile(path) {
+  await statFile(path);
+  let handle;
+  try {
+    handle = await open(path, "r");
+  } catch (error) {
+    throw unreadable2(path, error);
+  }
+  try {
+    const info = await handle.stat();
+    if (!info.isFile()) throw unreadable2(path);
+    return new FileSource(handle, path, info.size);
+  } catch (error) {
+    await handle.close();
+    throw error instanceof PreflightError ? error : unreadable2(path, error);
+  }
+}
+async function openSource(file, size) {
+  if (typeof file === "string") return openFile(file);
+  if (file instanceof Uint8Array) return new MemorySource(file);
+  if (file instanceof Blob) return new BlobSource(file);
+  if (isStream(file)) {
+    if (size === void 0) {
+      throw new PreflightError({
+        code: "invalid_option",
+        message: "A stream input needs size (and durationSeconds); the SDK will not buffer an unbounded stream."
+      });
+    }
+    if (!Number.isSafeInteger(size) || size < 1) {
+      throw new PreflightError({
+        code: "invalid_option",
+        message: "size must be a whole number of bytes, 1 or more."
+      });
+    }
+    return new StreamSource(file, size);
+  }
+  throw new PreflightError({
+    code: "invalid_option",
+    message: "file must be a path, a Blob, a Uint8Array or a ReadableStream."
+  });
+}
+
+// src/transcribe/upload.ts
+var PROXIED_PART_BYTES = MAX_PART_BYTES;
+var URL_MAX_AGE_MS = 23 * 3600 * 1e3;
+var PartUrls = class {
+  #api;
+  #cfg;
+  #jobId;
+  #signal;
+  #pages = [];
+  #inflight = /* @__PURE__ */ new Map();
+  #next;
+  #direct = true;
+  /** `signal` is the caller's and the upload's own failure signal combined, so a page fetch stops with the rest. */
+  constructor(settings, plan, signal) {
+    this.#api = settings.api;
+    this.#cfg = settings.cfg;
+    this.#jobId = settings.jobId;
+    this.#signal = signal;
+    this.#next = plan.next_part_number;
+    if (plan.part_urls === null) this.#direct = false;
+    else if (plan.part_urls.length > 0) this.#store(plan.part_urls);
+  }
+  #store(urls) {
+    const start = Math.min(...urls.map((entry) => entry.n));
+    const page = {
+      start,
+      urls: new Map(urls.map((entry) => [entry.n, entry.url])),
+      fetchedAt: this.#cfg.clock.now()
+    };
+    const at = this.#pages.findIndex((existing) => existing.start === start);
+    if (at === -1) this.#pages.push(page);
+    else this.#pages[at] = page;
+    return start;
+  }
+  #pageOf(n) {
+    return this.#pages.find((page) => page.urls.has(n));
+  }
+  /** One request per page start however many parts wait for it; a page without URLs switches the job to proxied parts. */
+  #fetchPage(start) {
+    const running = this.#inflight.get(start);
+    if (running !== void 0) return running;
+    const request = (async () => {
+      const data = await readBody(
+        this.#api.GET("/v1/uploads/{job}/part-urls", {
+          params: { path: { job: this.#jobId }, query: { start } },
+          signal: this.#signal,
+          parseAs: "text"
+        }),
+        "GET /v1/uploads/{job}/part-urls",
+        PART_URLS
+      ).catch((error) => {
+        if (error instanceof NotFoundError) return null;
+        throw error;
+      });
+      const { part_urls: urls, next_part_number: next = null } = data ?? { part_urls: null };
+      if (urls === null || urls.length === 0) {
+        this.#direct = false;
+        return;
+      }
+      const stored = this.#store(urls);
+      if (this.#next === stored) this.#next = next;
+    })().finally(() => {
+      this.#inflight.delete(start);
+    });
+    this.#inflight.set(start, request);
+    return request;
+  }
+  /** The URL for part `n`, or null when the job turns out to take proxied parts only. */
+  async urlFor(n) {
+    for (; ; ) {
+      if (!this.#direct) return null;
+      const page = this.#pageOf(n);
+      if (page === void 0) {
+        if (this.#next === null) {
+          throw new UploadError({
+            code: "part_url_missing",
+            message: `No upload URL for part ${String(n)}.`
+          });
+        }
+        await this.#fetchPage(this.#next);
+        continue;
+      }
+      if (this.#cfg.clock.now() - page.fetchedAt > URL_MAX_AGE_MS) {
+        await this.#fetchPage(page.start);
+        continue;
+      }
+      return page.urls.get(n) ?? null;
+    }
+  }
+  /** Fetches the page `stale` came from again, unless another part already did. */
+  async refresh(n, stale) {
+    const page = this.#pageOf(n);
+    if (page?.urls.get(n) !== stale) return;
+    await this.#fetchPage(page.start);
+  }
+};
+function isTerminal(error) {
+  const status = error.status ?? 0;
+  return error instanceof ApiError && status >= 400 && status < 500 && status !== 429;
+}
+function endsUpload(error) {
+  return error instanceof UploadError && (error.code === "part_url_missing" || error.code === "size_exceeded");
+}
+function etagOf(response) {
+  const etag = response.headers.get("etag")?.replaceAll('"', "") ?? "";
+  if (etag === "") {
+    throw new UploadError({
+      code: "etag_missing",
+      message: "Storage answered a part without an ETag."
+    });
+  }
+  return etag;
+}
+async function readPart(source, offset, length, signal) {
+  try {
+    return await source.read(offset, length, signal);
+  } catch (error) {
+    if (error instanceof HushscriptError) throw error;
+    throw new UploadError({
+      code: "source_read_failed",
+      message: `Reading the input failed at byte ${String(offset)}, part way through the upload (${describeError(error)}).`,
+      cause: error
+    });
+  }
+}
+async function uploadParts(settings) {
+  const { cfg, jobId, source, plan } = settings;
+  const partSize = plan?.part_size_bytes ?? PROXIED_PART_BYTES;
+  if (!Number.isInteger(partSize) || partSize < 1) {
+    throw new UploadError({
+      code: "bad_part_plan",
+      message: "The API returned an unusable part size."
+    });
+  }
+  const totalParts = Math.ceil(source.size / partSize);
+  if (plan !== null && plan.total_parts !== totalParts) {
+    throw new UploadError({
+      code: "bad_part_plan",
+      message: `The API planned ${String(plan.total_parts)} parts; the file needs ${String(totalParts)}.`
+    });
+  }
+  const failure = new AbortController();
+  const signal = AbortSignal.any([settings.signal, failure.signal]);
+  const urls = plan === null ? null : new PartUrls(settings, plan, signal);
+  const putFetch = hardenedFetch(cfg, "idempotent", { timeoutMs: cfg.partTimeoutMs });
+  const proxiedUrl = (n) => `${cfg.baseUrl}/v1/uploads/${encodeURIComponent(jobId)}/parts/${String(n)}`;
+  const acks = /* @__PURE__ */ new Map();
+  let proxied = plan === null;
+  const isProxied = () => proxied;
+  const isAborted2 = () => signal.aborted;
+  let directSucceeded = false;
+  let sent = 0;
+  let nextPart = 1;
+  const failures = [];
+  const putDirect = async (url2, bytes) => {
+    const response = await putFetch(url2, {
+      method: "PUT",
+      body: bytes,
+      signal
+    });
+    return etagOf(response);
+  };
+  const putProxied = async (n, bytes) => {
+    await putFetch(proxiedUrl(n), {
+      method: "PUT",
+      headers: {
+        authorization: cfg.authorization(),
+        "user-agent": cfg.userAgent,
+        "content-type": "application/octet-stream"
+      },
+      body: bytes,
+      signal
+    });
+  };
+  const recover = async (pages, error, n, url2, state) => {
+    if (!(error instanceof HushscriptError)) throw error;
+    if (isAborted2() || endsUpload(error)) throw error;
+    if (url2 === null && directSucceeded && isTerminal(error)) throw error;
+    let cause = error;
+    const forbidden = error.status === 403;
+    if (url2 !== null && !state.refetched && (forbidden || directSucceeded)) {
+      state.refetched = true;
+      try {
+        await pages.refresh(n, url2);
+        return;
+      } catch (refreshError) {
+        if (!(refreshError instanceof HushscriptError)) throw refreshError;
+        if (isAborted2() || endsUpload(refreshError) || directSucceeded && isTerminal(refreshError))
+          throw refreshError;
+        cause = refreshError;
+      }
+    }
+    if (!directSucceeded) {
+      proxied = true;
+      return;
+    }
+    throw new UploadError({
+      code: "parts_exhausted",
+      message: `Part ${String(n)} failed after retries and a fresh URL.`,
+      cause
+    });
+  };
+  const sendDirect = async (pages, n, bytes) => {
+    const state = {};
+    while (!isProxied()) {
+      let url2;
+      try {
+        url2 = await pages.urlFor(n);
+      } catch (error) {
+        await recover(pages, error, n, null, state);
+        continue;
+      }
+      if (url2 === null) {
+        if (directSucceeded) {
+          throw new UploadError({
+            code: "part_url_missing",
+            message: `No upload URL for part ${String(n)}.`
+          });
+        }
+        proxied = true;
+        return;
+      }
+      try {
+        const etag = await putDirect(url2, bytes);
+        if (isProxied()) return;
+        directSucceeded = true;
+        acks.set(n, etag);
+        return;
+      } catch (error) {
+        await recover(pages, error, n, url2, state);
+      }
+    }
+  };
+  const sendPart = async (n, bytes) => {
+    if (urls !== null) await sendDirect(urls, n, bytes);
+    if (isProxied()) await putProxied(n, bytes);
+  };
+  const worker = async () => {
+    while (!signal.aborted) {
+      const n = nextPart;
+      nextPart += 1;
+      if (n > totalParts) return;
+      const offset = (n - 1) * partSize;
+      const bytes = await readPart(source, offset, partSize, signal);
+      await sendPart(n, bytes);
+      sent += bytes.byteLength;
+      settings.onAcked(sent);
+    }
+  };
+  const guarded2 = async () => {
+    try {
+      await worker();
+    } catch (error) {
+      failures.push(error);
+      failure.abort();
+    }
+  };
+  const workers = source.sequential ? 1 : Math.min(settings.concurrency, totalParts);
+  await Promise.all(Array.from({ length: workers }, guarded2));
+  if (failures.length > 0) throw failures[0];
+  if (settings.signal.aborted) throw aborted(settings.signal);
+  if (isProxied()) return null;
+  return [...acks.entries()].sort(([a], [b]) => a - b).map(([n, etag]) => ({ n, etag }));
+}
+
+// src/transcribe/index.ts
+var DEFAULT_CONCURRENCY = 4;
+var MAX_CONCURRENCY = 8;
+function transcriptionOptions(options) {
+  const out = {};
+  if (options.language !== void 0) out.language_code = options.language;
+  if (options.speakers !== void 0) out.speaker_detection = options.speakers;
+  if (options.translateTo !== void 0) out.translation_targets = options.translateTo;
+  const { keyterms, prompt } = normalizeContext(options);
+  if (keyterms.length > 0) out.keyterms_prompt = keyterms;
+  if (prompt !== void 0) out.prompt = prompt;
+  if (options.medical !== void 0) out.medical_mode = options.medical;
+  if (options.multichannel !== void 0) out.multichannel = options.multichannel;
+  if (options.autoInsights !== void 0) out.auto_generate_insights = options.autoInsights;
+  return Object.keys(out).length === 0 ? void 0 : out;
+}
+function checkRuntimeOptions(options) {
+  const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
+  if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > MAX_CONCURRENCY) {
+    throw invalidOption(`concurrency must be a whole number from 1 to ${String(MAX_CONCURRENCY)}.`);
+  }
+  const waitTimeout = options.waitTimeout ?? DEFAULT_WAIT_TIMEOUT_SECONDS;
+  if (!Number.isFinite(waitTimeout) || waitTimeout <= 0) {
+    throw invalidOption("waitTimeout must be a positive number of seconds.");
+  }
+  checkDurationOption(options.durationSeconds);
+  return { concurrency, waitTimeout };
+}
+var CallbackErrors = class {
+  // Several workers can have a callback throw at once, so every thrown value is kept, not the last.
+  // The set lives as long as one transcribe or resume call.
+  #thrown = /* @__PURE__ */ new Set();
+  wrap(callback) {
+    if (callback === void 0) return void 0;
+    return (value) => {
+      try {
+        callback(value);
+      } catch (error) {
+        this.#thrown.add(error);
+        throw error;
+      }
+    };
+  }
+  owns(error) {
+    return this.#thrown.has(error);
+  }
+};
+var Pipeline = class {
+  #cfg;
+  #api;
+  constructor(cfg, api) {
+    this.#cfg = cfg;
+    this.#api = api;
+  }
+  async transcribe(file, options = {}) {
+    const { concurrency, waitTimeout } = checkRuntimeOptions(options);
+    const signal = options.signal ?? new AbortController().signal;
+    const callbackErrors = new CallbackErrors();
+    const onProgress = callbackErrors.wrap(options.onProgress);
+    const onResumeToken = callbackErrors.wrap(options.onResumeToken);
+    let token = null;
+    let sentKey = null;
+    let source = null;
+    try {
+      source = await openSource(file, options.size);
+      if (source.sequential && options.durationSeconds === void 0) {
+        throw invalidOption("A stream input needs durationSeconds and size.");
+      }
+      const durationSeconds = await preflight(source, options, this.#api, signal);
+      const idempotencyKey = options.idempotencyKey ?? randomUUID();
+      onProgress?.({
+        stage: "uploading",
+        percent: 0,
+        bytesSent: 0,
+        bytesTotal: source.size
+      });
+      const body = {
+        size_bytes: source.size,
+        duration_seconds: durationSeconds,
+        idempotency_key: idempotencyKey
+      };
+      if (options.title !== void 0) body.title = options.title;
+      if (options.matterCode !== void 0) body.matter_code = options.matterCode;
+      const transcription = transcriptionOptions(options);
+      if (transcription !== void 0) body.transcription_options = transcription;
+      sentKey = idempotencyKey;
+      const created = await readBody(
+        this.#api.POST("/v1/uploads", { body, signal, parseAs: "text" }),
+        "POST /v1/uploads",
+        UPLOAD_CREATE
+      );
+      const state = {
+        jobId: created.job_id,
+        idempotencyKey,
+        size: source.size,
+        durationSeconds
+      };
+      token = encodeResumeToken(state);
+      onResumeToken?.(token);
+      return await this.#finish(created, {
+        state,
+        token,
+        source,
+        concurrency,
+        waitTimeout,
+        signal,
+        onProgress
+      });
+    } catch (error) {
+      throw this.#annotate(error, token, signal, sentKey, callbackErrors);
+    } finally {
+      await source?.close();
+    }
+  }
+  async resume(token, file, options = {}) {
+    const state = decodeResumeToken(token);
+    const { concurrency, waitTimeout } = checkRuntimeOptions(options);
+    const signal = options.signal ?? new AbortController().signal;
+    const callbackErrors = new CallbackErrors();
+    const onProgress = callbackErrors.wrap(options.onProgress);
+    let source = null;
+    try {
+      if (typeof file === "string") {
+        const size = await statFile(file).catch(() => null);
+        if (size !== null) assertSameFile(state, size);
+      } else if (file !== void 0) {
+        source = await openSource(file, state.size);
+        assertSameFile(state, source.size);
+      }
+      const run = {
+        state,
+        token,
+        source,
+        concurrency,
+        waitTimeout,
+        signal,
+        onProgress
+      };
+      const job = await readJob(this.#api, state.jobId, signal).catch((error) => {
+        throw error instanceof NotFoundError ? jobMissing() : error;
+      });
+      if (job.state !== "uploading")
+        return await this.#finish({ state: job.state, upload: null }, run, job);
+      if (file === void 0) throw fileRequired();
+      if (source === null) {
+        source = await openSource(file, state.size);
+        assertSameFile(state, source.size);
+        run.source = source;
+      }
+      onProgress?.({
+        stage: "uploading",
+        percent: 0,
+        bytesSent: 0,
+        bytesTotal: source.size
+      });
+      const created = await readBody(
+        this.#api.POST("/v1/uploads", {
+          body: {
+            size_bytes: state.size,
+            duration_seconds: Math.ceil(state.durationSeconds),
+            idempotency_key: state.idempotencyKey
+          },
+          signal,
+          parseAs: "text"
+        }),
+        "POST /v1/uploads",
+        UPLOAD_CREATE
+      );
+      if (created.job_id !== state.jobId) throw jobMissing();
+      return await this.#finish(created, run);
+    } catch (error) {
+      throw this.#annotate(error, token, signal, state.idempotencyKey, callbackErrors);
+    } finally {
+      await source?.close();
+    }
+  }
+  async waitForJob(id, options = {}) {
+    const { waitTimeout } = checkRuntimeOptions({ waitTimeout: options.waitTimeout });
+    return waitForJob({
+      api: this.#api,
+      clock: this.#cfg.clock,
+      jobId: id,
+      waitTimeout,
+      signal: options.signal ?? new AbortController().signal,
+      onProgress: options.onProgress,
+      resumeToken: null
+    });
+  }
+  /**
+   * After a create was sent, adds the key to every error and the resume token to a cancellation.
+   * An error from before the create (there is no token yet either), or one a caller's callback
+   * threw, goes back as it was.
+   */
+  #annotate(error, token, signal, key, callbackErrors) {
+    if (key === null || callbackErrors.owns(error)) return error;
+    const cancelled = error instanceof AbortError || signal.aborted;
+    const out = cancelled && token !== null ? new AbortError({
+      message: error instanceof Error ? error.message : "The request was aborted.",
+      cause: error,
+      resumeToken: token
+    }) : asHushscriptError(error);
+    out.idempotencyKey = key;
+    out.resumeToken ??= token;
+    return out;
+  }
+  /** `known` is the job as `resume()` just read it, for a job that is not uploading. */
+  async #finish(created, run, known = null) {
+    const { state, signal } = run;
+    let jobState = created.state;
+    let finished = known;
+    if (created.state === "uploading") {
+      if (run.source === null) throw fileRequired();
+      jobState = await this.#upload(created, run, run.source);
+      finished = null;
+    }
+    if (jobState === "done" || jobState === "failed") {
+      return await this.#fetch(finished ?? await readJob(this.#api, state.jobId, signal), run);
+    }
+    if (jobState === "queued" || jobState === "processing") {
+      run.onProgress?.({ stage: "processing", state: jobState });
+    }
+    const job = await waitForJob({
+      api: this.#api,
+      clock: this.#cfg.clock,
+      jobId: state.jobId,
+      waitTimeout: run.waitTimeout,
+      signal,
+      onProgress: run.onProgress,
+      resumeToken: run.token
+    });
+    return await this.#fetch(job, run);
+  }
+  async #upload(created, run, source) {
+    const { state } = run;
+    const stop = new AbortController();
+    const signal = AbortSignal.any([run.signal, stop.signal]);
+    const failure = {};
+    const heartbeat = runHeartbeat({
+      clock: this.#cfg.clock,
+      signal,
+      send: () => this.#api.POST("/v1/uploads/{job}/heartbeat", {
+        params: { path: { job: state.jobId } },
+        signal
+      })
+    }).catch((error) => {
+      failure.failed = true;
+      failure.error = error;
+      stop.abort();
+    });
+    try {
+      const acks = await uploadParts({
+        cfg: this.#cfg,
+        api: this.#api,
+        jobId: state.jobId,
+        source,
+        plan: created.upload,
+        concurrency: run.concurrency,
+        signal,
+        onAcked: (bytesSent) => {
+          run.onProgress?.({
+            stage: "uploading",
+            percent: Math.floor(bytesSent * 100 / source.size),
+            bytesSent,
+            bytesTotal: source.size
+          });
+        }
+      });
+      const completed = await readBody(
+        this.#api.POST("/v1/uploads/{job}/complete", {
+          params: { path: { job: state.jobId } },
+          ...acks === null ? {} : { body: { parts: acks } },
+          signal,
+          parseAs: "text"
+        }),
+        "POST /v1/uploads/{job}/complete",
+        UPLOAD_COMPLETE
+      );
+      return completed.state;
+    } catch (error) {
+      throw failure.failed ? failure.error : error;
+    } finally {
+      stop.abort();
+      await heartbeat;
+    }
+  }
+  async #fetch(job, run) {
+    if (job.state === "failed") throw failureOf(job);
+    if (job.transcript_id === null) {
+      throw new UploadError({
+        code: "transcript_missing",
+        message: "The job is done but has no transcript id."
+      });
+    }
+    return Transcript.fromApi(await readTranscript(this.#api, job.transcript_id, run.signal));
+  }
+};
+
+// src/client.ts
+var Hushscript = class {
+  /** Every `/v1` operation, typed from the OpenAPI document, with the SDK's retries, timeouts and redaction. */
+  api;
+  /** Jobs, including those still processing; `wait` polls until one is done or failed. */
+  jobs;
+  /** Finished transcripts: list, read and the deletion records. */
+  transcripts;
+  /** Packs, saved cards and purchase history. Buying also needs the token's own purchase switch and the account-wide one, both in the app under Account → MCP. */
+  billing;
+  /** Calls an agent account makes with its own token. */
+  agent;
+  /** Signup and claim for agent accounts: no token needed, so they are static. */
+  static agent = agentStatic;
+  #config;
+  #pipeline;
+  constructor(options = {}) {
+    const config = resolveConfig(options);
+    this.#config = config;
+    Object.defineProperty(this, inspect.custom, { value: () => this.toString() });
+    const api = createClient({ baseUrl: config.baseUrl, fetch: createTransport(config) });
+    api.use({
+      onRequest: ({ request }) => {
+        request.headers.set("authorization", config.authorization());
+        request.headers.set("user-agent", config.userAgent);
+      }
+    });
+    this.api = guardApi(api);
+    this.#pipeline = new Pipeline(config, this.api);
+    this.jobs = new JobsResource(this.api, (id, options2) => this.#pipeline.waitForJob(id, options2));
+    this.transcripts = new TranscriptsResource(this.api);
+    this.billing = new BillingResource(this.api);
+    this.agent = new AgentResource(this.api, config);
+  }
+  /** Uploads `file`, waits for the transcript and returns it. */
+  transcribe(file, options) {
+    return this.#pipeline.transcribe(file, options);
+  }
+  /** Finishes a transcription from the token an `AbortError`, `WaitTimeoutError` or `onResumeToken` gave. */
+  resume(token, file, options) {
+    return this.#pipeline.resume(token, file, options);
+  }
+  /** Buys a pack with the saved default card and returns what the purchase left you with (alias of `hs.billing.buy`). */
+  buy(packId, options) {
+    return this.billing.buy(packId, options);
+  }
+  /** What can be spent now. Held minutes are already deducted from it, so do not subtract them again. */
+  async balance() {
+    return toBalance(await readAccount(this.api));
+  }
+  /** The account in camelCase: balance, holds, expiry, limits, `cardOnFile` and `dataRegion`. */
+  async account() {
+    return toAccount(await readAccount(this.api));
+  }
+  toJSON() {
+    return { token: REDACTED, baseUrl: this.#config.baseUrl };
+  }
+  toString() {
+    return `Hushscript ${JSON.stringify(this.toJSON())}`;
+  }
+};
+
+export { AbortError, ApiError, AuthenticationError, ConfigurationError, ConflictError, DailyLimitError, ERROR_CATALOG, FileLimitError, HINTS, Hushscript, HushscriptError, InsufficientBalanceError, JobFailedError, NetworkError, NotFoundError, OPERATION_SCOPES, OutcomeUnknownError, PaymentMethodRequiredError, PermissionDeniedError, PreflightError, RateLimitError, ResumeMismatchError, Transcript, UnsupportedMediaError, UploadError, ValidationError, WaitTimeoutError, paginate };