@heroku/sdk 0.11.1 → 0.11.2

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/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';

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

@@ -0,0 +1,22 @@
+import type { Account, AccountDelinquency } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../core/extend-resource.js';
+export type GetAccountWithDelinquencyOptions = {
+    signal?: AbortSignal;
+};
+export type AccountWithDelinquency = {
+    account: Account;
+    delinquency: AccountDelinquency | null;
+};
+/**
+ * Fetch the authenticated account together with its delinquency status.
+ *
+ * Runs the two reads concurrently. The account lookup hard-fails — there is no
+ * result without it. The delinquency lookup soft-fails to `null`: a hiccup on
+ * that secondary call must not sink an otherwise-successful account fetch (it
+ * backs commands like `whoami`). Callers decide whether and how to surface a
+ * warning from `delinquency` — `formatDelinquencyWarning` renders the sentence.
+ */
+export declare function getAccountWithDelinquency(ctx: Pick<ResourceCtx, 'platform'>, options?: GetAccountWithDelinquencyOptions): Promise<AccountWithDelinquency>;
+export declare const accountExtensions: import("../../core/extend-resource.js").ResourceExtension<"platform", "account", {
+    getWithDelinquency: (options?: GetAccountWithDelinquencyOptions) => Promise<AccountWithDelinquency>;
+}>;

package/dist/resources/platform/account.js

@@ -0,0 +1,34 @@
+import createDebug from 'debug';
+import { extendResource } from '../../core/extend-resource.js';
+const debug = createDebug('heroku:sdk:resources:account');
+/**
+ * Fetch the authenticated account together with its delinquency status.
+ *
+ * Runs the two reads concurrently. The account lookup hard-fails — there is no
+ * result without it. The delinquency lookup soft-fails to `null`: a hiccup on
+ * that secondary call must not sink an otherwise-successful account fetch (it
+ * backs commands like `whoami`). Callers decide whether and how to surface a
+ * warning from `delinquency` — `formatDelinquencyWarning` renders the sentence.
+ */
+export async function getAccountWithDelinquency(ctx, options = {}) {
+    options.signal?.throwIfAborted();
+    const platform = options.signal
+        ? ctx.platform.withOptions({ signal: options.signal })
+        : ctx.platform;
+    const [account, delinquency] = await Promise.all([
+        platform.account.info(),
+        platform.accountDelinquency.info().catch((error) => {
+            // Soft-fail a secondary-call hiccup to null, but rethrow a cancellation:
+            // if the caller aborted, returning null would misreport a delinquent
+            // account as current. Anything else is logged and swallowed.
+            if (options.signal?.aborted)
+                throw error;
+            debug('account delinquency lookup failed; treating as not delinquent: %O', error);
+            return null;
+        }),
+    ]);
+    return { account, delinquency };
+}
+export const accountExtensions = extendResource('platform', 'account', ctx => ({
+    getWithDelinquency: (options) => getAccountWithDelinquency(ctx, options),
+}));

package/dist/resources/platform/add-on/create-and-wait.js

@@ -1,4 +1,5 @@
 import { HerokuApiError } from '@heroku/heroku-fetch';
+import { withSignal } from '../../../core/with-signal.js';
 import { wait } from '../../../utils/wait.js';
 import { AddonConfirmationRequiredError, AddonProvisioningFailedError } from './errors.js';
 const DEFAULT_CREATE_WAIT_INTERVAL_MS = 5000;
@@ -28,7 +29,10 @@ const DEFAULT_CREATE_WAIT_INTERVAL_MS = 5000;
  */
 export async function createAndWait(ctx, appIdentity, body, options = {}) {
     options.signal?.throwIfAborted();
-    const platform = ctx.platform.withHeaders({ 'Accept-Expansion': 'addon_service,plan' });
+    // Bind the signal to the client so the create and poll requests abort in
+    // flight, not just the delay between polls.
+    const platform = withSignal(ctx.platform, options.signal)
+        .withHeaders({ 'Accept-Expansion': 'addon_service,plan' });
     let addon;
     try {
         addon = await platform

package/dist/resources/platform/add-on/describe.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { resolveAddonInternal } from './resolve.js';
 /**
  * Resolve, describe, and decorate an add-on for display.
@@ -13,11 +14,13 @@ import { resolveAddonInternal } from './resolve.js';
  */
 export async function describeAddon(ctx, addonIdentity, options = {}) {
     options.signal?.throwIfAborted();
+    // Bind the signal so both requests abort in flight, not just at the checkpoints.
+    const base = withSignal(ctx.platform, options.signal);
     // Accept-Expansion is scoped to the resolve call (addOn.resolution
     // serializer accepts addon_service + plan expansions). The
     // /addons/:id/addon-attachments endpoint uses Accept-Inclusion, not
     // Accept-Expansion, and rejects an unknown expansion header.
-    const resolvingPlatform = ctx.platform.withHeaders({
+    const resolvingPlatform = base.withHeaders({
         Accept: 'application/vnd.heroku+json; version=3.sdk',
         'Accept-Expansion': 'addon_service,plan',
     });
@@ -26,7 +29,7 @@ export async function describeAddon(ctx, addonIdentity, options = {}) {
         appIdentity: options.appIdentity,
     });
     options.signal?.throwIfAborted();
-    const attachments = await ctx.platform.addOnAttachment.listByAddOn(addon.id);
+    const attachments = await base.addOnAttachment.listByAddOn(addon.id);
     const plan = addon.plan;
     return {
         ...addon,

package/dist/resources/platform/add-on/destroy-and-wait.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { wait } from '../../../utils/wait.js';
 import { AddonProvisioningFailedError } from './errors.js';
 const DEFAULT_DESTROY_WAIT_INTERVAL_MS = 5000;
@@ -21,9 +22,7 @@ const DEFAULT_DESTROY_WAIT_INTERVAL_MS = 5000;
  */
 export async function destroyAndWait(ctx, appIdentity, addonIdentity, options = {}) {
     options.signal?.throwIfAborted();
-    const platform = ctx.platform
-        .withHeaders({ 'Accept-Expansion': 'plan' })
-        .withOptions({ signal: options.signal });
+    const platform = withSignal(ctx.platform.withHeaders({ 'Accept-Expansion': 'plan' }), options.signal);
     // The force body is scoped to the delete call only — a sticky body on the
     // shared client would leak onto the GET poll requests below.
     const deleteClient = options.force

package/dist/resources/platform/add-on/list-plans.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { AddonNotFoundError } from './errors.js';
 import { resolveAddonInternal } from './resolve.js';
 /**
@@ -7,7 +8,9 @@ import { resolveAddonInternal } from './resolve.js';
  */
 export async function listPlans(ctx, serviceIdentity, options = {}) {
     options.signal?.throwIfAborted();
-    const plans = await ctx.platform.plan.listByAddOn(serviceIdentity);
+    // Bind the signal so the request aborts in flight.
+    const platform = withSignal(ctx.platform, options.signal);
+    const plans = await platform.plan.listByAddOn(serviceIdentity);
     return [...plans].sort(byPriceCentsAsc);
 }
 /**
@@ -26,7 +29,10 @@ export async function listPlans(ctx, serviceIdentity, options = {}) {
  */
 export async function listPlansForAddon(ctx, addonIdentity, options = {}) {
     options.signal?.throwIfAborted();
-    const addon = await resolveAddonInternal(ctx.platform, addonIdentity, {
+    // Bind the signal so the resolve request aborts in flight (the helper itself
+    // doesn't thread options.signal into the client).
+    const platform = withSignal(ctx.platform, options.signal);
+    const addon = await resolveAddonInternal(platform, addonIdentity, {
         appIdentity: options.appIdentity,
     });
     // The route accepts either name or id; name is stable across

package/dist/resources/platform/add-on/resolve.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { debug } from './debug.js';
 import { AddonAmbiguousError, AddonNotFoundError } from './errors.js';
 /**
@@ -25,7 +26,10 @@ import { AddonAmbiguousError, AddonNotFoundError } from './errors.js';
  */
 export async function resolveAddon(ctx, addonIdentity, options = {}) {
     options.signal?.throwIfAborted();
-    return resolveAddonInternal(ctx.platform, addonIdentity, options);
+    // Bind the signal so the resolve request aborts in flight (the helper itself
+    // doesn't thread options.signal into the client).
+    const platform = withSignal(ctx.platform, options.signal);
+    return resolveAddonInternal(platform, addonIdentity, options);
 }
 export async function resolveAddonInternal(platform, addonIdentity, options = {}) {
     const { addonService, appIdentity } = options;

package/dist/resources/platform/add-on/upgrade.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { debug } from './debug.js';
 import { resolveAddonInternal } from './resolve.js';
 /**
@@ -18,7 +19,9 @@ import { resolveAddonInternal } from './resolve.js';
  */
 export async function upgrade(ctx, addonIdentity, plan, options = {}) {
     options.signal?.throwIfAborted();
-    const addon = await resolveAddonInternal(ctx.platform, addonIdentity, {
+    // Bind the signal so the resolve and update requests abort in flight.
+    const platform = withSignal(ctx.platform, options.signal);
+    const addon = await resolveAddonInternal(platform, addonIdentity, {
         addonService: options.addonService,
         appIdentity: options.appIdentity,
     });
@@ -31,5 +34,5 @@ export async function upgrade(ctx, addonIdentity, plan, options = {}) {
         debug('upgrade plan qualified plan=%s qualified=%s', plan, qualifiedPlan);
     }
     debug('upgrade addon=%s app=%s plan=%s', addon.id, addon.app.id, qualifiedPlan);
-    return ctx.platform.addOn.update(addon.app.id, addon.id, { plan: qualifiedPlan });
+    return platform.addOn.update(addon.app.id, addon.id, { plan: qualifiedPlan });
 }

package/dist/resources/platform/add-on/wait-for-provisioning.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { wait } from '../../../utils/wait.js';
 import { AddonProvisioningFailedError } from './errors.js';
 const DEFAULT_WAIT_INTERVAL_MS = 5000;
@@ -19,7 +20,9 @@ const DEFAULT_WAIT_INTERVAL_MS = 5000;
 export async function waitForProvisioning(ctx, addon, options = {}) {
     options.signal?.throwIfAborted();
     const intervalMs = options.waitIntervalMs ?? DEFAULT_WAIT_INTERVAL_MS;
-    const platform = ctx.platform.withHeaders({ 'Accept-Expansion': 'addon_service,plan' });
+    // Bind the signal so each poll request aborts in flight, not just the delay.
+    const platform = withSignal(ctx.platform, options.signal)
+        .withHeaders({ 'Accept-Expansion': 'addon_service,plan' });
     let current = addon;
     /* eslint-disable no-await-in-loop */
     while (current.state === 'provisioning' || current.state === 'deprovisioning') {