@heroku/sdk 0.11.0 → 0.11.2

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 { getArbitraryLegacyDB } from './internal/postgres-utils.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 getArbitraryLegacyDB(ctx, appIdentity);
-    return ctx.data.transferSchedule.list(addon.id);
+    const addon = await findLegacyDatabase(ctx, appIdentity);
+    // 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') {

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

@@ -1,4 +1,5 @@
 import createDebug from 'debug';
+import { withSignal } from '../../../core/with-signal.js';
 const debug = createDebug('heroku:sdk:resources:add-on-attachment');
 export class AddonAttachmentNotFoundError extends Error {
     resource;
@@ -47,9 +48,7 @@ export async function resolveAddonAttachment(ctx, appIdentity, attachmentName, o
     const { addonService, signal } = options;
     signal?.throwIfAborted();
     debug('resolve app=%s attachment=%s service=%s', appIdentity ?? '<global>', attachmentName, addonService ?? '<any>');
-    const platform = ctx.platform
-        .withHeaders({ 'Accept-Inclusion': 'addon:plan,config_vars' })
-        .withOptions({ signal });
+    const platform = withSignal(ctx.platform.withHeaders({ 'Accept-Inclusion': 'addon:plan,config_vars' }), signal);
     const matches = await platform.addOnAttachment.resolution({
         // eslint-disable-next-line camelcase
         addon_attachment: attachmentName,

package/dist/resources/platform/app/create-and-setup.d.ts

@@ -39,10 +39,9 @@ export type CreateAndSetupInput = {
  * spinner. Per the poller contract, `onStart` fires BEFORE any request is
  * dispatched, and `onStop` fires ONLY on success — if a step rejects, the
  * error propagates and `onStop` is never called (there is no try/finally, so
- * the caller's error path stops the spinner). Signal threading uses the
- * standard `withOptions({signal})`
- * scoped-client idiom so an abort cancels in-flight requests, not just the
- * pre-flight `throwIfAborted()`.
+ * the caller's error path stops the spinner). Signal threading binds the
+ * signal to a scoped client (via `withSignal`) so an abort cancels in-flight
+ * requests, not just the pre-flight `throwIfAborted()`.
  *
  * The CLI parses flags / heroku.yml into `input` and owns git-remote setup
  * and rendering; this method owns the API orchestration only.

package/dist/resources/platform/app/create-and-setup.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 /**
  * Create an app and run its post-create setup in one call.
  *
@@ -13,17 +14,16 @@
  * spinner. Per the poller contract, `onStart` fires BEFORE any request is
  * dispatched, and `onStop` fires ONLY on success — if a step rejects, the
  * error propagates and `onStop` is never called (there is no try/finally, so
- * the caller's error path stops the spinner). Signal threading uses the
- * standard `withOptions({signal})`
- * scoped-client idiom so an abort cancels in-flight requests, not just the
- * pre-flight `throwIfAborted()`.
+ * the caller's error path stops the spinner). Signal threading binds the
+ * signal to a scoped client (via `withSignal`) so an abort cancels in-flight
+ * requests, not just the pre-flight `throwIfAborted()`.
  *
  * The CLI parses flags / heroku.yml into `input` and owns git-remote setup
  * and rendering; this method owns the API orchestration only.
  */
 export async function createAndSetup(ctx, input, options = {}) {
     options.signal?.throwIfAborted();
-    const platform = options.signal ? ctx.platform.withOptions({ signal: options.signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, options.signal);
     const { addons, buildpack, configVars, ...createParams } = input;
     const app = (createParams.space || createParams.team)
         ? (await platform.teamApp.create(createParams))

package/dist/resources/platform/app/diff.js

@@ -1,4 +1,5 @@
 import { NotFoundError } from '@heroku/heroku-fetch';
+import { withSignal } from '../../../core/with-signal.js';
 async function checksum(platform, app) {
     try {
         const releases = await platform.withHeaders({ Range: 'version ..; max=1, order=desc' }).release.list(app);
@@ -95,9 +96,7 @@ async function diffFeatures(platform, app1, app2) {
  */
 export async function diffApps(ctx, app1, app2, options = {}) {
     options.signal?.throwIfAborted();
-    const platform = options.signal
-        ? ctx.platform.withOptions({ signal: options.signal })
-        : ctx.platform;
+    const platform = withSignal(ctx.platform, options.signal);
     const files = await diffFiles(platform, app1, app2);
     const [env, stack, bp, addons, features] = await Promise.all([
         diffEnv(platform, app1, app2),

package/dist/resources/platform/app/index.js

@@ -1,4 +1,5 @@
 import { extendResource } from '../../../core/extend-resource.js';
+import { withSignal } from '../../../core/with-signal.js';
 import { createAndSetup } from './create-and-setup.js';
 import { diffApps } from './diff.js';
 import { describeApp } from './info.js';
@@ -11,11 +12,15 @@ export { transferApp } from './transfer.js';
 export { waitForACMCertificates } from './wait-for-acm-certificates.js';
 export async function enableMaintenance(ctx, appIdentity, options = {}) {
     options.signal?.throwIfAborted();
-    return ctx.platform.app.update(appIdentity, { maintenance: true });
+    // Bind the signal so the request aborts in flight.
+    const platform = withSignal(ctx.platform, options.signal);
+    return platform.app.update(appIdentity, { maintenance: true });
 }
 export async function disableMaintenance(ctx, appIdentity, options = {}) {
     options.signal?.throwIfAborted();
-    return ctx.platform.app.update(appIdentity, { maintenance: false });
+    // Bind the signal so the request aborts in flight.
+    const platform = withSignal(ctx.platform, options.signal);
+    return platform.app.update(appIdentity, { maintenance: false });
 }
 /**
  * Look up the platform generation (`cedar` or `fir`) of an app.
@@ -28,7 +33,8 @@ export async function disableMaintenance(ctx, appIdentity, options = {}) {
  */
 export async function getGeneration(ctx, appIdentity, options = {}) {
     options.signal?.throwIfAborted();
-    const platform = ctx.platform.withHeaders({
+    // Bind the signal so the request aborts in flight.
+    const platform = withSignal(ctx.platform, options.signal).withHeaders({
         Accept: 'application/vnd.heroku+json; version=3.sdk',
     });
     const app = await platform.app.info(appIdentity);

package/dist/resources/platform/app/info.d.ts

@@ -26,5 +26,9 @@ export type AppInfo = {
  * any error collapses to an empty default. The broad .catch is
  * intentional v1 fidelity with the Heroku CLI's apps:info; a future
  * tightening to specific status codes is non-breaking.
+ *
+ * Cancellation is exempt from the soft-fail: an aborted sub-request
+ * rethrows so the whole describe rejects instead of silently returning a
+ * partial view when the caller cancelled.
  */
 export declare function describeApp(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string, options?: DescribeAppOptions): Promise<AppInfo>;

package/dist/resources/platform/app/info.js

@@ -1,3 +1,5 @@
+import { withSignal } from '../../../core/with-signal.js';
+import { isAbortError } from '../../../utils/is-abort-error.js';
 /**
  * Composite "describe this app" view: parallel-fetches add-ons, the app
  * itself, dynos, collaborators, and the pipeline coupling.
@@ -7,19 +9,31 @@
  * any error collapses to an empty default. The broad .catch is
  * intentional v1 fidelity with the Heroku CLI's apps:info; a future
  * tightening to specific status codes is non-breaking.
+ *
+ * Cancellation is exempt from the soft-fail: an aborted sub-request
+ * rethrows so the whole describe rejects instead of silently returning a
+ * partial view when the caller cancelled.
  */
 export async function describeApp(ctx, appIdentity, options = {}) {
-    options.signal?.throwIfAborted();
-    const platform = options.signal
-        ? ctx.platform.withOptions({ signal: options.signal })
-        : ctx.platform;
+    const { signal } = options;
+    signal?.throwIfAborted();
+    const platform = withSignal(ctx.platform, signal);
+    // Collapse an expected soft error to a default, but never swallow an abort.
+    // Checks the signal's `aborted` flag as well as the error shape so a
+    // custom-reason abort (`controller.abort(reason)`), which `isAbortError`
+    // alone can't detect, still rejects instead of returning a partial view.
+    const softFail = (fallback) => (error) => {
+        if (signal?.aborted || isAbortError(error))
+            throw error;
+        return fallback;
+    };
     const [addons, app, dynos, collaborators, pipelineCoupling] = await Promise.all([
         platform.addOn.listByApp(appIdentity),
         platform.app.info(appIdentity),
-        platform.dyno.list(appIdentity).catch(() => []),
-        platform.collaborator.list(appIdentity).catch(() => []),
+        platform.dyno.list(appIdentity).catch(softFail([])),
+        platform.collaborator.list(appIdentity).catch(softFail([])),
         platform.pipelineCoupling.infoByApp(appIdentity)
-            .catch(() => null),
+            .catch(softFail(null)),
     ]);
     return {
         addons, app, collaborators, dynos, pipelineCoupling,

package/dist/resources/platform/app/transfer.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 /**
  * Transfer an app to another user or team.
  *
@@ -15,7 +16,7 @@
  */
 export async function transferApp(ctx, appIdentity, recipient, options = {}) {
     options.signal?.throwIfAborted();
-    const platform = options.signal ? ctx.platform.withOptions({ signal: options.signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, options.signal);
     if (options.personalToPersonal) {
         const body = { app: appIdentity, recipient };
         if (options.silent !== undefined)

package/dist/resources/platform/app/wait-for-acm-certificates.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { wait } from '../../../utils/wait.js';
 const DEFAULT_WAIT_INTERVAL_MS = 15_000;
 /**
@@ -16,7 +17,7 @@ const DEFAULT_WAIT_INTERVAL_MS = 15_000;
 export async function waitForACMCertificates(ctx, appIdentity, options = {}) {
     const { intervalMs = DEFAULT_WAIT_INTERVAL_MS, signal, timeoutMs } = options;
     signal?.throwIfAborted();
-    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, signal);
     function terminal(domains) {
         return domains
             .filter(domain => domain.kind === 'custom')

package/dist/resources/platform/container/ensure-container-stack.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 export class NotAContainerAppError extends Error {
     app;
     id = 'not_a_container_app';
@@ -14,7 +15,7 @@ export class NotAContainerAppError extends Error {
 export async function ensureContainerStack(ctx, appIdentity, options = {}) {
     const { signal } = options;
     signal?.throwIfAborted();
-    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, signal);
     const app = await platform.app.info(appIdentity);
     const allowedStack = 'container';
     if (app.build_stack.name !== allowedStack && app.stack.name !== allowedStack) {

package/dist/resources/platform/container/release-images.js

@@ -1,10 +1,11 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { ensureContainerStack } from './ensure-container-stack.js';
 /**
  * Release Docker images to a container app.
  */
 export async function releaseDockerImages(ctx, appIdentity, imagesByProcessType, options = {}) {
     await ensureContainerStack(ctx, appIdentity, options);
-    const platform = options.signal ? ctx.platform.withOptions({ signal: options.signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, options.signal);
     const oldReleases = await platform
         .withHeaders({ Range: 'version ..; max=1, order=desc' })
         .release.list(appIdentity);