@heroku/sdk 0.11.1 → 0.12.0

package/dist/core/create-client.d.ts

@@ -7,7 +7,7 @@ type RoutesModule = Record<string, Record<string, RouteDefinition>>;
  * and `stream` are deliberately excluded — those belong on the
  * individual route call, not on the client wrapper.
  */
-export type StickyRouteOptions = Pick<RequestOptions, 'headers' | 'signal' | 'timeout'> & {
+export type StickyRouteOptions = Pick<RequestOptions, 'headers' | 'reauthorize' | 'signal' | 'timeout'> & {
     /**
      * Request body applied to write calls on the derived client. Primarily
      * for methods whose route metadata lacks `hasRequestBody` (e.g. DELETE
@@ -30,7 +30,12 @@ export type RoutesClientExtras<T> = {
      * Returns a same-shaped client where each route call applies the
      * provided options. Caller-supplied headers override the api-client's
      * defaults; subsequent `withOptions` calls layer headers and replace
-     * signal / timeout.
+     * signal / timeout / reauthorize.
+     *
+     * Pass `reauthorize: false` to opt the derived client's calls out of the
+     * client-level 401 refresh (see {@link RequestOptions.reauthorize}) — for
+     * call sites where a 401 means something other than an expired Heroku
+     * credential and must not drive a login.
      *
      * The original client is not mutated.
      */

package/dist/core/create-client.js

@@ -11,12 +11,15 @@ function mergeStickyOptions(base, next) {
     if (next.headers || base?.headers) {
         merged.headers = { ...base?.headers, ...next.headers };
     }
-    // signal, timeout, and body are not additive — last wins, but only if
-    // the caller actually set them. Otherwise the previous value persists.
+    // signal, timeout, reauthorize, and body are not additive — last wins,
+    // but only if the caller actually set them. Otherwise the previous value
+    // persists.
     if (next.signal !== undefined)
         merged.signal = next.signal;
     if (next.timeout !== undefined)
         merged.timeout = next.timeout;
+    if (next.reauthorize !== undefined)
+        merged.reauthorize = next.reauthorize;
     if (next.body !== undefined)
         merged.body = next.body;
     return merged;

package/dist/core/extend-resource.d.ts

@@ -1,3 +1,5 @@
+import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
+import { HerokuApiClient } from '@heroku/heroku-fetch';
 import type { DashboardBackendClient } from '../services/dashboard-backend.js';
 import type { DataClient } from '../services/data.js';
 import type { MetricsClient } from '../services/metrics.js';
@@ -14,10 +16,58 @@ type BaseResourceCtx = {
     platform: PlatformClient;
     repositories: RepositoriesClient;
 };
-export type ResourceCtx = BaseResourceCtx & {
+export type ResourceCtx = {
+    /**
+     * Build a raw {@link HerokuApiClient} that inherits the SDK's resolved
+     * client options for the `inheritFrom` service bundle (token,
+     * `userAgent`/headers, `signal`, `timeout`, `warn`, …), with `overrides`
+     * applied last.
+     *
+     * `inheritFrom` selects *which resolved option bundle to start from* — not
+     * the wire service; pass `service` in `overrides` to redirect the client to
+     * a different host and auth behavior. The returned client is raw, NOT the
+     * managed service client: it does not carry that client's `defaultAccept`
+     * (e.g. the platform's `version=3.sdk`) or routes proxy, so callers issue
+     * `get`/`post`/`stream` directly and set `Accept` per call.
+     *
+     * When `overrides.service === 'custom'` the inherited bundle is narrowed to
+     * identity and cancellation only (never auth/routing), so a custom stream
+     * host can't receive the Heroku token, a `reauthorize` login callback, or
+     * consumer headers. Prefer {@link makeCustomHostClient} for that case rather
+     * than assembling the overrides by hand.
+     *
+     * Optional for compatibility with existing extension contexts; prefer
+     * {@link makeCtxClient} at call sites so a context predating this stays
+     * on the pre-threading behavior.
+     *
+     * TODO(next major): make this required on ResourceCtx and drop the
+     * {@link makeCtxClient} fallback once external hand-built contexts are no
+     * longer supported.
+     */
+    makeClient?: (inheritFrom: ServiceName, overrides?: HerokuApiClientOptions) => HerokuApiClient;
     /** Available to SDK-provided extensions; optional for compatibility with existing extension contexts. */
     repositoriesApi?: RepositoriesApiClient;
-};
+} & BaseResourceCtx;
+/**
+ * Build a raw {@link HerokuApiClient} from a resource context, inheriting the
+ * SDK's resolved client options for the `inheritFrom` service bundle
+ * (identity, `signal`, `warn`, token, …) with `overrides` applied last. Falls
+ * back to a bare client carrying only `overrides` when the context predates
+ * {@link ResourceCtx.makeClient} (e.g. a hand-built test ctx, or a standalone
+ * call with no SDK behind it), preserving the pre-threading behavior exactly.
+ */
+export declare function makeCtxClient(ctx: Pick<ResourceCtx, 'makeClient'>, inheritFrom: ServiceName, overrides?: HerokuApiClientOptions): HerokuApiClient;
+/**
+ * Build a raw {@link HerokuApiClient} for a non-Heroku-credential host — a
+ * custom stream/API host the routes-generated clients don't cover (logplex,
+ * busl, exec-manager). Inherits only the SDK's identity and cancellation from
+ * the platform option bundle; forces `service: 'custom'`, the given `baseUrl`,
+ * and an empty `token`, and drops every auth/routing option (`reauthorize`,
+ * `headers`, `hooks`, `twoFactor`, `region`, …) so none crosses to the
+ * third-party origin. `overrides` the call site explicitly sets still apply —
+ * use them for a per-host header or timeout, not to smuggle inherited auth.
+ */
+export declare function makeCustomHostClient(ctx: Pick<ResourceCtx, 'makeClient'>, baseUrl: string, overrides?: Omit<HerokuApiClientOptions, 'baseUrl' | 'service' | 'token'>): HerokuApiClient;
 export type ResourceMethods = Record<string, (...args: any[]) => any>;
 export type ResourceExtension<S extends ServiceName = ServiceName, R extends string = string, M extends ResourceMethods = ResourceMethods> = {
     factory: (ctx: ResourceCtx) => M;

package/dist/core/extend-resource.js

@@ -1,3 +1,30 @@
+import { HerokuApiClient } from '@heroku/heroku-fetch';
+/**
+ * Build a raw {@link HerokuApiClient} from a resource context, inheriting the
+ * SDK's resolved client options for the `inheritFrom` service bundle
+ * (identity, `signal`, `warn`, token, …) with `overrides` applied last. Falls
+ * back to a bare client carrying only `overrides` when the context predates
+ * {@link ResourceCtx.makeClient} (e.g. a hand-built test ctx, or a standalone
+ * call with no SDK behind it), preserving the pre-threading behavior exactly.
+ */
+export function makeCtxClient(ctx, inheritFrom, overrides = {}) {
+    return ctx.makeClient ? ctx.makeClient(inheritFrom, overrides) : new HerokuApiClient(overrides);
+}
+/**
+ * Build a raw {@link HerokuApiClient} for a non-Heroku-credential host — a
+ * custom stream/API host the routes-generated clients don't cover (logplex,
+ * busl, exec-manager). Inherits only the SDK's identity and cancellation from
+ * the platform option bundle; forces `service: 'custom'`, the given `baseUrl`,
+ * and an empty `token`, and drops every auth/routing option (`reauthorize`,
+ * `headers`, `hooks`, `twoFactor`, `region`, …) so none crosses to the
+ * third-party origin. `overrides` the call site explicitly sets still apply —
+ * use them for a per-host header or timeout, not to smuggle inherited auth.
+ */
+export function makeCustomHostClient(ctx, baseUrl, overrides = {}) {
+    return makeCtxClient(ctx, 'platform', {
+        ...overrides, baseUrl, service: 'custom', token: '',
+    });
+}
 export function extendResource(service, resource, factory) {
     return { factory, resource, service };
 }

package/dist/core/extensions-proxy.js

@@ -1,5 +1,55 @@
 import createDebug from 'debug';
 const debug = createDebug('heroku:sdk:extensions');
+/**
+ * Re-derive the extension context so that an operation-wide cancellation set
+ * via `sdk.platform.withOptions({signal})` also reaches the clients its
+ * extensions issue requests through `ctx`.
+ *
+ * Extension factories close over `ctx.*` (e.g. `ctx.platform`) to issue their
+ * own — often nested, sometimes cross-service — requests. Without this, a signal
+ * set on a service client would reach generated route methods but never the
+ * requests an extension method makes through `ctx`, so cancellation could not
+ * stop the work an extension started. The derivation is applied to *every*
+ * service client in `ctx` because cancellation is operation-wide and extensions
+ * cross services (e.g. a `data` extension polls through `ctx.platform`).
+ *
+ * Only the operation-wide `signal` / `timeout` are propagated. A `withHeaders`
+ * call, and the `headers` / `body` fields of a `withOptions` call, are
+ * endpoint-specific and must not ride cross-service onto unrelated requests
+ * (e.g. an `Accept-Expansion` header a sibling endpoint rejects), so they stay
+ * on the routes client the caller scoped and are not re-derived here.
+ *
+ * `withOptions` returns a fresh client without mutating the original, and the
+ * derived clients are memoized per key, so sibling derived clients — and the
+ * base client — stay isolated from one another.
+ */
+function deriveCtx(ctx, method, args) {
+    if (method !== 'withOptions')
+        return ctx;
+    const options = args[0];
+    const scoped = {};
+    if (options?.signal !== undefined)
+        scoped.signal = options.signal;
+    if (options?.timeout !== undefined)
+        scoped.timeout = options.timeout;
+    if (Object.keys(scoped).length === 0)
+        return ctx;
+    const cache = new Map();
+    const derived = {};
+    for (const key of Object.keys(ctx)) {
+        Object.defineProperty(derived, key, {
+            enumerable: true,
+            get() {
+                if (!cache.has(key)) {
+                    const client = ctx[key];
+                    cache.set(key, typeof client?.withOptions === 'function' ? client.withOptions(scoped) : client);
+                }
+                return cache.get(key);
+            },
+        });
+    }
+    return derived;
+}
 export function mergeExtensions(client, extensions, ctx) {
     const methodsByResource = new Map();
     for (const ext of extensions) {
@@ -34,7 +84,7 @@ export function mergeExtensions(client, extensions, ctx) {
                 }
                 return (...args) => {
                     const rewrapped = inner.apply(target, args);
-                    return mergeExtensions(rewrapped, extensions, ctx);
+                    return mergeExtensions(rewrapped, extensions, deriveCtx(ctx, resourceKey, args));
                 };
             }
             const extMethods = methodsByResource.get(resourceKey);

package/dist/core/heroku-sdk.js

@@ -1,3 +1,4 @@
+import { HerokuApiClient } from '@heroku/heroku-fetch';
 import { createDashboardBackendClient } from '../services/dashboard-backend.js';
 import { createDataClient } from '../services/data.js';
 import { createMetricsClient } from '../services/metrics.js';
@@ -5,7 +6,17 @@ import { createNotificationsClient } from '../services/notifications.js';
 import { createPlatformClient } from '../services/platform.js';
 import { createRepositoriesApiClient } from '../services/repositories-api.js';
 import { createRepositoriesClient } from '../services/repositories.js';
+import { SDK_VERSION } from '../version.js';
 import { mergeExtensions } from './extensions-proxy.js';
+/**
+ * Default `User-Agent` identity for SDK-originated traffic. {@link HerokuSDK}
+ * applies it as a fill-if-absent default on every service client (in its
+ * `#getClientOptions` merge), so requests the SDK drives stay identifiable even
+ * when the consumer passes no `userAgent`. A consumer-supplied
+ * `clientOptions.userAgent` — or a per-service override — wins. The version is
+ * stamped from package.json at build time; see `src/version.ts`.
+ */
+const DEFAULT_USER_AGENT = { name: '@heroku/sdk', version: SDK_VERSION };
 function partitionByService(extensions) {
     const map = new Map();
     for (const ext of extensions) {
@@ -15,6 +26,26 @@ function partitionByService(extensions) {
     }
     return map;
 }
+/**
+ * The options a custom-host client (`service: 'custom'`) inherits from the
+ * SDK's resolved bundle: identity and cancellation only. Every
+ * Heroku-credential-domain option — auth (`token`, `reauthorize`, `twoFactor`),
+ * routing (`headers`, `region`, `defaultAccept`), and consumer
+ * `hooks`/`onResponseMetadata` — is intentionally dropped so it never reaches a
+ * third-party origin (logplex, busl, exec-manager): sending the bearer token or
+ * a consumer `Authorization` header cross-origin would leak credentials, and
+ * inheriting `reauthorize` would turn a non-Heroku 401 into a spurious
+ * `heroku login`.
+ */
+function pickCustomHostOptions(options) {
+    return {
+        ...(options.debug !== undefined && { debug: options.debug }),
+        ...(options.signal !== undefined && { signal: options.signal }),
+        ...(options.timeout !== undefined && { timeout: options.timeout }),
+        ...(options.userAgent !== undefined && { userAgent: options.userAgent }),
+        ...(options.warn !== undefined && { warn: options.warn }),
+    };
+}
 export class HerokuSDK {
     #clientOptions;
     #clientOptionsByService;
@@ -72,6 +103,7 @@ export class HerokuSDK {
         const serviceOptions = { ...serviceOverride };
         delete serviceOptions.service;
         return {
+            userAgent: DEFAULT_USER_AGENT,
             ...this.#clientOptions,
             ...serviceOptions,
         };
@@ -86,6 +118,17 @@ export class HerokuSDK {
                 enumerable: true,
                 get: () => this.#getRawData(),
             },
+            makeClient: {
+                enumerable: true,
+                value: (inheritFrom, overrides = {}) => {
+                    const resolved = this.#getClientOptions(inheritFrom);
+                    // A custom host is not the Heroku credential domain: start from
+                    // identity/cancellation only, never the auth/routing options that
+                    // would leak across origins or drive a re-login on a foreign 401.
+                    const base = overrides.service === 'custom' ? pickCustomHostOptions(resolved) : resolved;
+                    return new HerokuApiClient({ ...base, ...overrides });
+                },
+            },
             metrics: {
                 enumerable: true,
                 get: () => this.#getRawMetrics(),
@@ -122,7 +165,7 @@ export class HerokuSDK {
         return this.#rawMetrics;
     }
     #getRawNotifications() {
-        this.#rawNotifications ??= createNotificationsClient(this.#clientOptions);
+        this.#rawNotifications ??= createNotificationsClient(this.#getClientOptions('notifications'));
         return this.#rawNotifications;
     }
     #getRawPlatform() {

package/dist/core/with-signal.d.ts

@@ -0,0 +1,19 @@
+import type { RoutesClientExtras } from './create-client.js';
+/**
+ * Bind a cancellation signal to a routes client so the requests it issues
+ * abort in flight.
+ *
+ * Extension methods receive their signal as a per-call option (e.g.
+ * `addOn.createAndWait(app, body, {signal})`) rather than through the client,
+ * so the signal reaches `wait()`/`throwIfAborted()` checkpoints but not the
+ * in-flight request unless it's pushed onto the client. This returns a derived,
+ * signal-bearing client (the original is never mutated) — or the client
+ * unchanged when no signal is supplied, so a signal-less call stays a no-op.
+ *
+ * Signals do not combine: `withOptions` is last-wins, so binding a per-call
+ * signal here replaces any signal already set on the client (e.g. a
+ * session-level one) for the requests this derived client issues. A caller that
+ * needs both to abort the request must combine them itself (e.g.
+ * `AbortSignal.any([sessionSignal, callSignal])`) before passing one in.
+ */
+export declare function withSignal<T>(client: RoutesClientExtras<T> & T, signal?: AbortSignal): RoutesClientExtras<T> & T;

package/dist/core/with-signal.js

@@ -0,0 +1,20 @@
+/**
+ * Bind a cancellation signal to a routes client so the requests it issues
+ * abort in flight.
+ *
+ * Extension methods receive their signal as a per-call option (e.g.
+ * `addOn.createAndWait(app, body, {signal})`) rather than through the client,
+ * so the signal reaches `wait()`/`throwIfAborted()` checkpoints but not the
+ * in-flight request unless it's pushed onto the client. This returns a derived,
+ * signal-bearing client (the original is never mutated) — or the client
+ * unchanged when no signal is supplied, so a signal-less call stays a no-op.
+ *
+ * Signals do not combine: `withOptions` is last-wins, so binding a per-call
+ * signal here replaces any signal already set on the client (e.g. a
+ * session-level one) for the requests this derived client issues. A caller that
+ * needs both to abort the request must combine them itself (e.g.
+ * `AbortSignal.any([sessionSignal, callSignal])`) before passing one in.
+ */
+export function withSignal(client, signal) {
+    return signal ? client.withOptions({ signal }) : client;
+}

package/dist/resources/data/database.js

@@ -1,34 +1,47 @@
 import { extendResource } from '../../core/extend-resource.js';
+import { withSignal } from '../../core/with-signal.js';
 import { resolvePgDatabase } from './internal/resolve-pg-database.js';
 export async function describe(ctx, appIdentity, addonIdentity, options = {}) {
     options.signal?.throwIfAborted();
     const addon = await resolvePgDatabase(ctx, appIdentity, { input: addonIdentity, ...options });
-    return ctx.data.database.info(addon.id);
+    // Bind the signal so the request aborts in flight, not just during resolution.
+    const data = withSignal(ctx.data, options.signal);
+    return data.database.info(addon.id);
 }
 export async function upgradeWaitStatus(ctx, appIdentity, addonIdentity, options = {}) {
     options.signal?.throwIfAborted();
     const addon = await resolvePgDatabase(ctx, appIdentity, { input: addonIdentity, ...options });
-    return ctx.data.database.upgradeWaitStatus(addon.id);
+    // Bind the signal so the request aborts in flight, not just during resolution.
+    const data = withSignal(ctx.data, options.signal);
+    return data.database.upgradeWaitStatus(addon.id);
 }
 export async function dryRunUpgrade(ctx, appIdentity, addonIdentity, body = {}, options = {}) {
     options.signal?.throwIfAborted();
     const addon = await resolvePgDatabase(ctx, appIdentity, { input: addonIdentity, ...options });
-    return ctx.data.database.dryRunUpgrade(addon.id, body);
+    // Bind the signal so the request aborts in flight, not just during resolution.
+    const data = withSignal(ctx.data, options.signal);
+    return data.database.dryRunUpgrade(addon.id, body);
 }
 export async function runUpgrade(ctx, appIdentity, addonIdentity, body = {}, options = {}) {
     options.signal?.throwIfAborted();
     const addon = await resolvePgDatabase(ctx, appIdentity, { input: addonIdentity, ...options });
-    return ctx.data.database.runUpgrade(addon.id, body);
+    // Bind the signal so the request aborts in flight, not just during resolution.
+    const data = withSignal(ctx.data, options.signal);
+    return data.database.runUpgrade(addon.id, body);
 }
 export async function prepareUpgrade(ctx, appIdentity, addonIdentity, body = {}, options = {}) {
     options.signal?.throwIfAborted();
     const addon = await resolvePgDatabase(ctx, appIdentity, { input: addonIdentity, ...options });
-    return ctx.data.database.prepareUpgrade(addon.id, body);
+    // Bind the signal so the request aborts in flight, not just during resolution.
+    const data = withSignal(ctx.data, options.signal);
+    return data.database.prepareUpgrade(addon.id, body);
 }
 export async function cancelUpgrade(ctx, appIdentity, addonIdentity, options = {}) {
     options.signal?.throwIfAborted();
     const addon = await resolvePgDatabase(ctx, appIdentity, { input: addonIdentity, ...options });
-    return ctx.data.database.cancelUpgrade(addon.id);
+    // Bind the signal so the request aborts in flight, not just during resolution.
+    const data = withSignal(ctx.data, options.signal);
+    return data.database.cancelUpgrade(addon.id);
 }
 export const databaseExtensions = extendResource('data', 'database', ctx => ({
     cancelUpgrade: (appIdentity, addonIdentity, options) => cancelUpgrade(ctx, appIdentity, addonIdentity, options),

package/dist/resources/data/internal/resolve-pg-database.js

@@ -1,5 +1,6 @@
 import { NotFoundError } from '@heroku/heroku-fetch';
 import createDebug from 'debug';
+import { withSignal } from '../../../core/with-signal.js';
 import { AddonAttachmentAmbiguousError, AddonAttachmentNotFoundError, resolveAddonAttachment } from '../../platform/add-on-attachment/resolve.js';
 import { getPostgresServiceName, isPostgresAddonInternal } from './postgres-utils.js';
 const debug = createDebug('heroku:sdk:resources:database');
@@ -87,8 +88,7 @@ async function equivalentAttachment(ctx, matches, error, signal) {
  */
 async function listAppConfigVars(ctx, appIdentity, error, signal) {
     try {
-        return await ctx.platform
-            .withOptions({ signal })
+        return await withSignal(ctx.platform, signal)
             .configVar.infoForApp(appIdentity);
     }
     catch (configVarError) {
@@ -101,14 +101,11 @@ async function listAppConfigVars(ctx, appIdentity, error, signal) {
  * Used by `attachmentResolutionFallback` to list all attachments on an app that match the
  * add-on service filter. Throws `PgDatabaseNotFoundError` if the app does not exist
  * or the listing fails for any other reason.
-*/
+ */
 async function listPostgresAttachments(ctx, appIdentity, attachmentId, error, signal) {
     let attachments;
     try {
-        attachments = await ctx.platform
-            .withHeaders({ 'Accept-Inclusion': 'addon:plan,config_vars' })
-            .withOptions({ signal })
-            .addOnAttachment.listByApp(appIdentity);
+        attachments = await withSignal(ctx.platform.withHeaders({ 'Accept-Inclusion': 'addon:plan,config_vars' }), signal).addOnAttachment.listByApp(appIdentity);
     }
     catch (listError) {
         signal?.throwIfAborted();

package/dist/resources/data/maintenance.js

@@ -1,9 +1,12 @@
 import { extendResource } from '../../core/extend-resource.js';
+import { withSignal } from '../../core/with-signal.js';
 import { resolvePgDatabase } from './internal/resolve-pg-database.js';
 export async function info(ctx, appIdentity, addonIdentity, options = {}) {
     options.signal?.throwIfAborted();
     const addon = await resolvePgDatabase(ctx, appIdentity, { input: addonIdentity, ...options });
-    return ctx.data.maintenance.info(addon.id);
+    // Bind the signal so the request aborts in flight, not just during resolution.
+    const data = withSignal(ctx.data, options.signal);
+    return data.maintenance.info(addon.id);
 }
 export const maintenanceExtensions = extendResource('data', 'maintenance', ctx => ({
     info: (appIdentity, addonIdentity, options) => info(ctx, appIdentity, addonIdentity, options),

package/dist/resources/data/postgres-database.js

@@ -1,9 +1,12 @@
 import { extendResource } from '../../core/extend-resource.js';
+import { withSignal } from '../../core/with-signal.js';
 import { resolvePgDatabase } from './internal/resolve-pg-database.js';
 export async function listCredentials(ctx, appIdentity, addonIdentity, options = {}) {
     options.signal?.throwIfAborted();
     const addon = await resolvePgDatabase(ctx, appIdentity, { input: addonIdentity, ...options });
-    return ctx.data.postgresDatabase.listCredentials(addon.id);
+    // Bind the signal so the request aborts in flight, not just during resolution.
+    const data = withSignal(ctx.data, options.signal);
+    return data.postgresDatabase.listCredentials(addon.id);
 }
 export const postgresDatabaseExtensions = extendResource('data', 'postgresDatabase', ctx => ({
     listCredentials: (appIdentity, addonIdentity, options) => listCredentials(ctx, appIdentity, addonIdentity, options),

package/dist/resources/data/redis/resolve-by-app.js

@@ -1,4 +1,5 @@
 import createDebug from 'debug';
+import { withSignal } from '../../../core/with-signal.js';
 import { RedisAddonAmbiguousError, RedisAddonNotFoundError } from './errors.js';
 const debug = createDebug('heroku:sdk:resources:redis');
 const DEFAULT_REDIS_ADDON_SERVICE_PREFIX = 'heroku-redis';
@@ -19,7 +20,7 @@ const DEFAULT_REDIS_ADDON_SERVICE_PREFIX = 'heroku-redis';
 export async function resolveRedisByApp(ctx, appIdentity, options = {}) {
     options.signal?.throwIfAborted();
     const { addonServiceName = DEFAULT_REDIS_ADDON_SERVICE_PREFIX, database } = options;
-    const platform = options.signal ? ctx.platform.withOptions({ signal: options.signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, options.signal);
     debug('resolveByApp app=%s service-prefix=%s database=%s', appIdentity, addonServiceName, database ?? '<any>');
     const addons = await platform.addOn.listByApp(appIdentity);
     const filter = database?.toUpperCase();

package/dist/resources/data/redis/wait-for-ready.d.ts

@@ -26,7 +26,7 @@ export type WaitForRedisReadyOptions = {
  * provision call resolves.
  *
  * Cancellation: the caller's `signal` is threaded into both the
- * in-flight request (via `withOptions`) and the poll-delay `wait()`,
+ * in-flight request (via `withSignal`) and the poll-delay `wait()`,
  * so aborting takes effect during either phase.
  */
 export declare function waitForRedisReady(ctx: Pick<ResourceCtx, 'data'>, nameOrId: string, options?: WaitForRedisReadyOptions): Promise<RedisWaitResult>;

package/dist/resources/data/redis/wait-for-ready.js

@@ -1,5 +1,6 @@
 import { NotFoundError } from '@heroku/heroku-fetch';
 import createDebug from 'debug';
+import { withSignal } from '../../../core/with-signal.js';
 import { wait } from '../../../utils/wait.js';
 const debug = createDebug('heroku:sdk:resources:redis');
 const DEFAULT_INTERVAL_MS = 5000;
@@ -13,13 +14,13 @@ const DEFAULT_INTERVAL_MS = 5000;
  * provision call resolves.
  *
  * Cancellation: the caller's `signal` is threaded into both the
- * in-flight request (via `withOptions`) and the poll-delay `wait()`,
+ * in-flight request (via `withSignal`) and the poll-delay `wait()`,
  * so aborting takes effect during either phase.
  */
 export async function waitForRedisReady(ctx, nameOrId, options = {}) {
     const { intervalMs = DEFAULT_INTERVAL_MS, signal, timeoutMs } = options;
     signal?.throwIfAborted();
-    const data = signal ? ctx.data.withOptions({ signal }) : ctx.data;
+    const data = withSignal(ctx.data, signal);
     const deadline = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
     debug('waitForReady name=%s intervalMs=%d timeoutMs=%s', nameOrId, intervalMs, timeoutMs ?? '<none>');
     while (true) {

package/dist/resources/data/transfer/capture-and-wait.js

@@ -1,11 +1,14 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { resolvePgDatabase } from '../internal/resolve-pg-database.js';
 import { waitForTransfer } from './wait-for-transfer.js';
 export async function captureAndWait(ctx, appIdentity, addonIdentity, options = {}) {
     const { capturePoller, signal, waitPoller } = options;
     signal?.throwIfAborted();
     const addon = await resolvePgDatabase(ctx, appIdentity, { input: addonIdentity, ...options });
+    // Bind the signal so the create request aborts in flight, not just the wait.
+    const data = withSignal(ctx.data, signal);
     capturePoller?.onStart?.(addon);
-    const backup = await ctx.data.backup.create(addon.id);
+    const backup = await data.backup.create(addon.id);
     capturePoller?.onStop?.(addon);
     waitPoller?.onStart?.(backup);
     const transfer = await waitForTransfer(ctx, addon.app.name, backup.uuid, options);

package/dist/resources/data/transfer/restore-and-wait.js

@@ -1,12 +1,15 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { resolvePgDatabase } from '../internal/resolve-pg-database.js';
 import { waitForTransfer } from './wait-for-transfer.js';
 export async function restoreAndWait(ctx, appIdentity, addonIdentity, backupUrl, options = {}) {
     const { extensions, restorePoller, signal, waitPoller } = options;
     signal?.throwIfAborted();
     const addon = await resolvePgDatabase(ctx, appIdentity, { input: addonIdentity, ...options });
+    // Bind the signal so the create request aborts in flight, not just the wait.
+    const data = withSignal(ctx.data, signal);
     restorePoller?.onStart?.(addon);
     // eslint-disable-next-line camelcase
-    const restore = await ctx.data.restore.create(addon.id, { backup_url: backupUrl, extensions });
+    const restore = await data.restore.create(addon.id, { backup_url: backupUrl, extensions });
     restorePoller?.onStop?.(addon);
     waitPoller?.onStart?.(restore);
     const transfer = await waitForTransfer(ctx, addon.app.name, restore.uuid, options);

package/dist/resources/data/transfer/wait-for-transfer.js

@@ -1,4 +1,6 @@
 import { extendResource } from '../../../core/extend-resource.js';
+import { withSignal } from '../../../core/with-signal.js';
+import { isAbortError } from '../../../utils/is-abort-error.js';
 import { wait } from '../../../utils/wait.js';
 const DEFAULT_INTERVAL_MS = 3000;
 const MAX_FAILURES = 20;
@@ -46,7 +48,7 @@ export class TransferTimeoutError extends Error {
 export async function waitForTransfer(ctx, appIdentity, transferId, options = {}) {
     const { intervalMs = DEFAULT_INTERVAL_MS, onPoll, signal, timeoutMs, verbose, } = options;
     signal?.throwIfAborted();
-    const data = signal ? ctx.data.withOptions({ signal }) : ctx.data;
+    const data = withSignal(ctx.data, signal);
     const deadline = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
     let failures = 0;
     let transfer;
@@ -56,6 +58,11 @@ export async function waitForTransfer(ctx, appIdentity, transferId, options = {}
             transfer = await data.transfer.infoByApp(appIdentity, transferId, { verbose });
         }
         catch (error) {
+            // Never retry a cancellation: a client- or caller-level abort must stop
+            // the poll immediately rather than burn up to MAX_FAILURES attempts.
+            if (signal?.aborted || isAbortError(error)) {
+                throw error;
+            }
             failures++;
             if (failures > MAX_FAILURES) {
                 throw error;

package/dist/resources/data/transfer-schedule.js

@@ -1,11 +1,14 @@
 import { extendResource } from '../../core/extend-resource.js';
+import { withSignal } from '../../core/with-signal.js';
 import { findLegacyDatabase } from './internal/postgres-utils.js';
 import { resolvePgDatabase } from './internal/resolve-pg-database.js';
 export async function list(ctx, appIdentity, options = {}) {
     options.signal?.throwIfAborted();
     // Schedules are app-scoped, so any legacy DB ID unlocks the app's list.
     const addon = await findLegacyDatabase(ctx, appIdentity);
-    return ctx.data.transferSchedule.list(addon.id);
+    // Bind the signal so the request aborts in flight, not just during resolution.
+    const data = withSignal(ctx.data, options.signal);
+    return data.transferSchedule.list(addon.id);
 }
 export async function create(ctx, appIdentity, addonIdentity, body, options = {}) {
     options.signal?.throwIfAborted();
@@ -17,12 +20,16 @@ export async function create(ctx, appIdentity, addonIdentity, body, options = {}
         // eslint-disable-next-line camelcase
         requestBody = { ...body, schedule_name: `${attachment.name}_URL` };
     }
-    return ctx.data.transferSchedule.create(addon.id, requestBody);
+    // Bind the signal so the request aborts in flight, not just during resolution.
+    const data = withSignal(ctx.data, options.signal);
+    return data.transferSchedule.create(addon.id, requestBody);
 }
 export async function del(ctx, appIdentity, addonIdentity, scheduleId, options = {}) {
     options.signal?.throwIfAborted();
     const addon = await resolvePgDatabase(ctx, appIdentity, { input: addonIdentity, ...options });
-    return ctx.data.transferSchedule.delete(addon.id, scheduleId);
+    // Bind the signal so the request aborts in flight, not just during resolution.
+    const data = withSignal(ctx.data, options.signal);
+    return data.transferSchedule.delete(addon.id, scheduleId);
 }
 export const transferScheduleExtensions = extendResource('data', 'transferSchedule', ctx => ({
     create: (appIdentity, addonIdentity, body, options) => create(ctx, appIdentity, addonIdentity, body, options),

package/dist/resources/extensions/platform.d.ts

@@ -1,7 +1,9 @@
+export { accountExtensions, type AccountWithDelinquency, type GetAccountWithDelinquencyOptions } from '../platform/account.js';
 export { addOnAttachmentExtensions } from '../platform/add-on-attachment/index.js';
 export { addOnExtensions } from '../platform/add-on/index.js';
 export { appExtensions, type AppInfo, type DiffAppsOptions, type DiffRow, type PipelineCouplingDetail, } from '../platform/app/index.js';
 export { containerExtensions, type DockerReleasesBatchUpdateOpts, NotAContainerAppError, type ReleaseDockerImagesResult, type RemoveProcessTypesOpts, } from '../platform/container/index.js';
+export { type DelinquencyResource, type DelinquencySchedule, formatDelinquencyWarning, } from '../platform/delinquency.js';
 export { type CreateAndWaitOptions, domainExtensions, type DomainOptions, type WaitForReadyOptions, } from '../platform/domain/index.js';
 export { DynoCrashedError, type DynoExtended, type DynoExtendedFields, dynoExtensions, DynoNotReadyError, type DynoState, enableExec, exchangeExecCredentials, type ExchangeExecCredentialsOptions, type ExecCredentials, type ExecOptions, type ExecPrereqs, execPrereqs, type ExecReservation, execStatus, type ExecStatusOptions, listExtended, type ListExtendedOptions, restartForExec, type RestartForExecOptions, runDyno, type RunDynoOptions, waitForInfo, type WaitForInfoOptions, waitForRelease, type WaitForReleaseOptions, type WaitForReleaseProgress, type WaitForReleaseResult, } from '../platform/dyno/index.js';
 export { type AttachmentAttachedEvent, type AttachmentDetachedEvent, type AttachmentUpdatedEvent, type HerokuLogEvent, logSessionExtensions, parseHerokuLogLine, type ProvisioningCompletedEvent, type ScaledToEntry, type ScaledToEvent, type StartingProcessEvent, type StateChangedEvent, } from '../platform/log-session/index.js';
@@ -12,6 +14,7 @@ export { type ResolveRepoNameOptions, reviewAppConfigExtensions } from '../platf
 export { privateToShield, shieldToPrivate } from '../platform/shield.js';
 export { createAndAssociate, type CreateAndAssociateOptions, sniEndpointExtensions } from '../platform/sni-endpoint/index.js';
 export { spaceExtensions, SpaceNotAllocatedError, SpaceNotReadyError, type SpaceOptions, type SpaceWithNat, waitForAllocated, type WaitForAllocatedOptions, } from '../platform/space/index.js';
+export { type GetTeamWithDelinquencyOptions, teamExtensions, type TeamWithDelinquency } from '../platform/team.js';
 export { telemetryDrainExtensions, type TelemetryDrainOptions, type TelemetryDrainTarget } from '../platform/telemetry-drain/index.js';
 export { testRunExtensions, TestRunNotReadyError, type TestRunStatus, waitForState, type WaitForStateOptions, } from '../platform/test-run/index.js';
 export { vpnConnectionExtensions, VpnConnectionFailedError, VpnConnectionNotReadyError, type VpnConnectionOptions, waitForActive, type WaitForActiveOptions, } from '../platform/vpn-connection/index.js';

package/dist/resources/extensions/platform.js

@@ -1,7 +1,9 @@
+export { accountExtensions } from '../platform/account.js';
 export { addOnAttachmentExtensions } from '../platform/add-on-attachment/index.js';
 export { addOnExtensions } from '../platform/add-on/index.js';
 export { appExtensions, } from '../platform/app/index.js';
 export { containerExtensions, NotAContainerAppError, } from '../platform/container/index.js';
+export { formatDelinquencyWarning, } from '../platform/delinquency.js';
 export { domainExtensions, } from '../platform/domain/index.js';
 export { DynoCrashedError, dynoExtensions, DynoNotReadyError, enableExec, exchangeExecCredentials, execPrereqs, execStatus, listExtended, restartForExec, runDyno, waitForInfo, waitForRelease, } from '../platform/dyno/index.js';
 export { logSessionExtensions, parseHerokuLogLine, } from '../platform/log-session/index.js';
@@ -12,6 +14,7 @@ export { reviewAppConfigExtensions } from '../platform/review-app-config/index.j
 export { privateToShield, shieldToPrivate } from '../platform/shield.js';
 export { createAndAssociate, sniEndpointExtensions } from '../platform/sni-endpoint/index.js';
 export { spaceExtensions, SpaceNotAllocatedError, SpaceNotReadyError, waitForAllocated, } from '../platform/space/index.js';
+export { teamExtensions } from '../platform/team.js';
 export { telemetryDrainExtensions } from '../platform/telemetry-drain/index.js';
 export { testRunExtensions, TestRunNotReadyError, waitForState, } from '../platform/test-run/index.js';
 export { vpnConnectionExtensions, VpnConnectionFailedError, VpnConnectionNotReadyError, waitForActive, } from '../platform/vpn-connection/index.js';