@heroku/sdk 0.11.0 → 0.11.2

package/dist/resources/platform/container/remove-process-types.js

@@ -1,10 +1,11 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { ensureContainerStack } from './ensure-container-stack.js';
 /**
  * Remove one or more process types from a container app
  */
 export async function removeProcessTypes(ctx, appIdentity, processTypes, 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);
     // eslint-disable-next-line camelcase
     const requestBody = { docker_image: null };
     const updatedFormations = [];

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

@@ -0,0 +1,23 @@
+/**
+ * Shared shape of the platform's delinquency payloads. `AccountDelinquency`
+ * and `TeamDelinquency` are structurally identical — each carries the two
+ * scheduled timestamps (or `null` when nothing is scheduled) — so a single
+ * formatter serves both.
+ */
+export interface DelinquencySchedule {
+    scheduled_deletion_time: null | string;
+    scheduled_suspension_time: null | string;
+}
+/** The kind of resource a delinquency applies to; used in the message text. */
+export type DelinquencyResource = 'account' | 'team';
+/**
+ * Format the delinquency warning sentence for a resource, or `undefined` when
+ * there is nothing to say. Pure — formatting only; the caller emits it.
+ *
+ * Produces a message for an upcoming suspension, a past suspension with an
+ * upcoming deletion, or an upcoming deletion. Returns `undefined` when neither
+ * timestamp is set, or when a suspension is already past with no deletion
+ * scheduled. Dates render in UTC so the message reads the same for every
+ * consumer. `now` defaults to the wall clock and is injectable for testing.
+ */
+export declare function formatDelinquencyWarning(resource: DelinquencyResource, delinquency: DelinquencySchedule | null | undefined, now?: number): string | undefined;

package/dist/resources/platform/delinquency.js

@@ -0,0 +1,41 @@
+/**
+ * Format the delinquency warning sentence for a resource, or `undefined` when
+ * there is nothing to say. Pure — formatting only; the caller emits it.
+ *
+ * Produces a message for an upcoming suspension, a past suspension with an
+ * upcoming deletion, or an upcoming deletion. Returns `undefined` when neither
+ * timestamp is set, or when a suspension is already past with no deletion
+ * scheduled. Dates render in UTC so the message reads the same for every
+ * consumer. `now` defaults to the wall clock and is injectable for testing.
+ */
+export function formatDelinquencyWarning(resource, delinquency, now = Date.now()) {
+    const suspension = parseTime(delinquency?.scheduled_suspension_time);
+    const deletion = parseTime(delinquency?.scheduled_deletion_time);
+    if (!suspension && !deletion)
+        return undefined;
+    if (suspension) {
+        if (suspension > now) {
+            return `This ${resource} is delinquent with payment and we'll suspend it on ${new Date(suspension).toUTCString()}.`;
+        }
+        if (deletion) {
+            return `This ${resource} is delinquent with payment and we suspended it on ${new Date(suspension).toUTCString()}.`
+                + ` If the ${resource} is still delinquent, we'll delete it on ${new Date(deletion).toUTCString()}.`;
+        }
+        return undefined;
+    }
+    if (deletion) {
+        return `This ${resource} is delinquent with payment and we'll delete it on ${new Date(deletion).toUTCString()}.`;
+    }
+    return undefined;
+}
+/**
+ * Parse an ISO timestamp to epoch ms, or `undefined` when it is absent or
+ * unparseable. A `0`/`NaN` result is treated as absent so it never trips the
+ * truthiness checks above.
+ */
+function parseTime(time) {
+    if (!time)
+        return undefined;
+    const ms = Date.parse(time);
+    return Number.isNaN(ms) || ms === 0 ? undefined : ms;
+}

package/dist/resources/platform/domain/clear-custom-domains.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 /**
  * Delete all custom domains from an app.
  *
@@ -7,7 +8,7 @@
 export async function clearCustomDomains(ctx, appIdentity, options = {}) {
     const { signal } = options;
     signal?.throwIfAborted();
-    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, signal);
     // List and filter to custom domains
     const domains = await platform.domain.list(appIdentity);
     const customDomains = domains.filter(d => d.kind === 'custom');

package/dist/resources/platform/domain/create-and-wait.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { waitForReady } from './wait-for-ready.js';
 /**
  * Create a domain with SNI endpoint resolution and optional waiting.
@@ -11,7 +12,7 @@ import { waitForReady } from './wait-for-ready.js';
 export async function createAndWait(ctx, appIdentity, hostname, options = {}) {
     const { poller, resolveSniEndpoint, signal, sniEndpoint, timeoutMs, wait: shouldWait, waitIntervalMs, } = options;
     signal?.throwIfAborted();
-    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, signal);
     let resolvedSniEndpoint = null;
     if (sniEndpoint) {
         // Explicit SNI endpoint provided

package/dist/resources/platform/domain/wait-for-ready.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { wait } from '../../../utils/wait.js';
 const DEFAULT_WAIT_INTERVAL_MS = 5000;
 /**
@@ -11,7 +12,7 @@ const DEFAULT_WAIT_INTERVAL_MS = 5000;
 export async function waitForReady(ctx, appIdentity, options = {}) {
     const { domain, hostname, poller, signal, timeoutMs, waitIntervalMs = DEFAULT_WAIT_INTERVAL_MS, } = options;
     signal?.throwIfAborted();
-    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, signal);
     let domains;
     if (domain) {
         domains = [domain];

package/dist/resources/platform/dyno/exec.js

@@ -1,4 +1,5 @@
 import { HerokuApiClient, NotFoundError } from '@heroku/heroku-fetch';
+import { withSignal } from '../../../core/with-signal.js';
 import { wait } from '../../../utils/wait.js';
 import { waitForInfo } from './wait-for-info.js';
 /** The app feature that gates Heroku Exec. */
@@ -20,7 +21,7 @@ const DEFAULT_SETTLE_MS = 2000;
  */
 export async function execPrereqs(ctx, appIdentity, options = {}) {
     options.signal?.throwIfAborted();
-    const platform = options.signal ? ctx.platform.withOptions({ signal: options.signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, options.signal);
     const [app, buildpacks, configVars, feature] = await Promise.all([
         platform.app.info(appIdentity),
         platform.buildpackInstallation.list(appIdentity),
@@ -51,7 +52,7 @@ export async function execPrereqs(ctx, appIdentity, options = {}) {
  */
 export async function enableExec(ctx, appIdentity, options = {}) {
     options.signal?.throwIfAborted();
-    const platform = options.signal ? ctx.platform.withOptions({ signal: options.signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, options.signal);
     await platform.appFeature.update(appIdentity, EXEC_FEATURE, { enabled: true });
 }
 /**
@@ -82,7 +83,7 @@ export async function restartForExec(ctx, appIdentity, dynoIdentity, options = {
     const { settleMs = DEFAULT_SETTLE_MS, ...waitOptions } = options;
     const { signal } = waitOptions;
     signal?.throwIfAborted();
-    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, signal);
     await wait(settleMs, signal);
     await platform.dyno.restartAll(appIdentity);
     return waitForInfo(ctx, appIdentity, dynoIdentity, {

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

@@ -1,4 +1,5 @@
 import { extendResource } from '../../../core/extend-resource.js';
+import { withSignal } from '../../../core/with-signal.js';
 import { enableExec, exchangeExecCredentials, execPrereqs, execStatus, restartForExec, } from './exec.js';
 import { listExtended } from './list-extended.js';
 import { runDyno } from './run.js';
@@ -20,15 +21,17 @@ export async function scaleDynos(ctx, appIdentity, updates, options = {}) {
 }
 export async function restartDynos(ctx, appIdentity, target, options = {}) {
     options.signal?.throwIfAborted();
+    // Bind the signal so the request aborts in flight.
+    const platform = withSignal(ctx.platform, options.signal);
     if (!target) {
-        await ctx.platform.dyno.restartAll(appIdentity);
+        await platform.dyno.restartAll(appIdentity);
         return;
     }
     if ('dyno' in target) {
-        await ctx.platform.dyno.restart(appIdentity, target.dyno);
+        await platform.dyno.restart(appIdentity, target.dyno);
         return;
     }
-    await ctx.platform.dyno.restartFormation(appIdentity, target.type);
+    await platform.dyno.restartFormation(appIdentity, target.type);
 }
 export const dynoExtensions = extendResource('platform', 'dyno', ctx => ({
     enableExec: (appIdentity, options) => (enableExec(ctx, appIdentity, options)),

package/dist/resources/platform/dyno/run.js

@@ -1,4 +1,5 @@
 import { HerokuApiClient, HerokuApiError } from '@heroku/heroku-fetch';
+import { withSignal } from '../../../core/with-signal.js';
 const DEFAULT_RUN_RETRIES = 2;
 const ACCEPT_RUN_INSIDE = 'application/vnd.heroku+json; version=3.sdk';
 /**
@@ -69,6 +70,6 @@ async function postRun(ctx, appIdentity, body, options) {
         });
         return (await response.json());
     }
-    const platform = options.signal ? ctx.platform.withOptions({ signal: options.signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, options.signal);
     return platform.dyno.create(appIdentity, body);
 }

package/dist/resources/platform/dyno/wait-for-info.js

@@ -1,4 +1,5 @@
 import { HerokuApiError, NotFoundError, RateLimitError } from '@heroku/heroku-fetch';
+import { withSignal } from '../../../core/with-signal.js';
 import { wait } from '../../../utils/wait.js';
 const DEFAULT_ATTEMPTS = 20;
 const DEFAULT_DELAY_MS = 1000;
@@ -62,7 +63,7 @@ export async function waitForInfo(ctx, appIdentity, dynoIdentity, options = {})
     signal?.throwIfAborted();
     // Scope the in-flight info call to the caller's signal so an abort
     // takes effect during the API call, not just during the backoff.
-    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, signal);
     let lastError;
     let lastDyno;
     for (let attempt = 0; attempt < attempts; attempt++) {

package/dist/resources/platform/dyno/wait-for-release.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { wait } from '../../../utils/wait.js';
 const DEFAULT_DELAY_MS = 10_000;
 const LATEST_RELEASE_RANGE = 'version ..; max=1, order=desc';
@@ -45,7 +46,7 @@ export class ReleaseNotConvergedError extends Error {
 export async function waitForRelease(ctx, appIdentity, options = {}) {
     const { attempts, delayMs = DEFAULT_DELAY_MS, onPoll, signal, type, withRun, } = options;
     signal?.throwIfAborted();
-    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, signal);
     const releases = await platform
         .withHeaders({ Range: LATEST_RELEASE_RANGE })
         .release.list(appIdentity);

package/dist/resources/platform/log-session/index.js

@@ -1,6 +1,7 @@
 import { HerokuApiClient } from '@heroku/heroku-fetch';
 import createDebug from 'debug';
 import { extendResource } from '../../../core/extend-resource.js';
+import { withSignal } from '../../../core/with-signal.js';
 import { getGeneration } from '../app/index.js';
 import { parseHerokuLogLine } from './parser.js';
 export { parseHerokuLogLine, } from './parser.js';
@@ -37,6 +38,9 @@ const TRANSPORT_RETRY_MAX_DELAY_MS = 5000;
 export async function* streamLogs(ctx, appIdentity, options = {}) {
     const { dyno, lines, maxConsecutiveTransportErrors = MAX_CONSECUTIVE_TRANSPORT_ERRORS, maxRetryDelayMs = TRANSPORT_RETRY_MAX_DELAY_MS, retryBaseDelayMs = TRANSPORT_RETRY_BASE_DELAY_MS, sessionTimeoutMs = DEFAULT_FIR_SESSION_TIMEOUT_MS, signal, source, tail = false, type, } = options;
     signal?.throwIfAborted();
+    // Bind the caller's signal to the platform client so the session-create
+    // request below aborts in flight, not merely between reads of the stream.
+    const platform = withSignal(ctx.platform, signal);
     const generation = await getGeneration(ctx, appIdentity, { signal });
     const isFir = generation === 'fir';
     // Fir doesn't support a bounded session; the platform always streams.
@@ -52,7 +56,7 @@ export async function* streamLogs(ctx, appIdentity, options = {}) {
     let consecutiveTransportErrors = 0;
     while (true) {
         debug('streamLogs creating session app=%s generation=%s tail=%s', appIdentity, generation ?? '<unknown>', effectiveTail);
-        const session = await ctx.platform.logSession.create(appIdentity, createOpts);
+        const session = await platform.logSession.create(appIdentity, createOpts);
         if (!session.logplex_url) {
             throw new Error('Log session response did not include a logplex_url.');
         }
@@ -81,6 +85,7 @@ export async function* streamLogs(ctx, appIdentity, options = {}) {
             // header and keeps sending `text/plain`).
             const response = await logplexClient.stream(`${parsed.pathname}${parsed.search}`, {
                 headers: { Accept: 'text/event-stream' },
+                signal,
             });
             if (!response.body) {
                 throw new Error('Logplex stream returned no body.');

package/dist/resources/platform/pipeline/coupling.js

@@ -1,5 +1,6 @@
 import createDebug from 'debug';
 import { extendResource } from '../../../core/extend-resource.js';
+import { withSignal } from '../../../core/with-signal.js';
 const debug = createDebug('heroku:sdk:resources:pipeline-coupling');
 const APPS_FILTER_LIMIT = 1000;
 /**
@@ -13,7 +14,9 @@ const APPS_FILTER_LIMIT = 1000;
  */
 export async function listPipelineApps(ctx, pipelineId, options = {}) {
     options.signal?.throwIfAborted();
-    const allCouplings = await ctx.platform.pipelineCoupling.listByPipeline(pipelineId);
+    // Bind the signal so both requests abort in flight, not just at the checkpoints.
+    const platform = withSignal(ctx.platform, options.signal);
+    const allCouplings = await platform.pipelineCoupling.listByPipeline(pipelineId);
     // Drop malformed couplings (no app id) before issuing the bulk filter call.
     const couplings = allCouplings.filter(coupling => coupling.app?.id);
     const skipped = allCouplings.length - couplings.length;
@@ -35,7 +38,7 @@ export async function listPipelineApps(ctx, pipelineId, options = {}) {
     }
     options.signal?.throwIfAborted();
     const ids = couplingsToResolve.map(coupling => coupling.app.id);
-    const apps = await ctx.platform
+    const apps = await platform
         .withHeaders({ Range: `id ..; max=${APPS_FILTER_LIMIT};` })
         .filterApps.apps({ in: { id: ids } });
     if (apps.length !== ids.length) {

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

@@ -1,5 +1,6 @@
 import { HerokuApiClient } from '@heroku/heroku-fetch';
 import { extendResource } from '../../../core/extend-resource.js';
+import { withSignal } from '../../../core/with-signal.js';
 export class PipelineNotFoundError extends Error {
     identity;
     id = 'not_found';
@@ -52,7 +53,8 @@ const UUID_RE = /^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/i;
 export async function resolvePipeline(ctx, identity, options = {}) {
     options.signal?.throwIfAborted();
     if (UUID_RE.test(identity)) {
-        return ctx.platform.pipeline.info(identity);
+        // Bind the signal so the lookup aborts in flight.
+        return withSignal(ctx.platform, options.signal).pipeline.info(identity);
     }
     const apiClient = new HerokuApiClient({
         ...options.clientOptions,
@@ -60,6 +62,7 @@ export async function resolvePipeline(ctx, identity, options = {}) {
     });
     const response = await apiClient.get('/pipelines', {
         searchParams: { 'eq[name]': identity },
+        signal: options.signal,
     });
     const matches = (await response.json());
     if (matches.length === 0) {

package/dist/resources/platform/pipeline/promotion.js

@@ -1,28 +1,33 @@
 import { HerokuApiClient } from '@heroku/heroku-fetch';
 import createDebug from 'debug';
 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 debug = createDebug('heroku:sdk:resources:pipeline-promotion');
 const DEFAULT_INTERVAL_MS = 1000;
 const DEFAULT_RELEASE_STREAM_MAX_ATTEMPTS = 100;
 export async function promotePipeline(ctx, body, options = {}) {
     const { intervalMs = DEFAULT_INTERVAL_MS, onReleaseStream, releaseStreamMaxAttempts = DEFAULT_RELEASE_STREAM_MAX_ATTEMPTS, signal, timeoutMs, } = options;
+    // Bind the signal to the client so the create/poll/release-info requests
+    // abort in flight, not just the delay between polls.
+    const platform = withSignal(ctx.platform, signal);
     debug('promote source=%s targets=%d', body.source?.app?.id ?? '<unknown>', body.targets?.length ?? 0);
-    const promotion = await ctx.platform.pipelinePromotion.create(body);
+    const promotion = await platform.pipelinePromotion.create(body);
     if (!promotion.id) {
         throw new Error('Pipeline promotion response did not include an id');
     }
     debug('promote created promotion=%s intervalMs=%d timeoutMs=%s', promotion.id, intervalMs, timeoutMs ?? '<none>');
     const deadline = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
     const streamRunner = onReleaseStream
-        ? createReleaseStreamRunner(ctx, onReleaseStream, releaseStreamMaxAttempts, intervalMs, signal)
+        ? createReleaseStreamRunner(platform, onReleaseStream, releaseStreamMaxAttempts, intervalMs, signal)
         : undefined;
     let poll = 0;
     while (true) {
         signal?.throwIfAborted();
         poll++;
         // eslint-disable-next-line no-await-in-loop
-        const targets = await ctx.platform.pipelinePromotionTarget.list(promotion.id);
+        const targets = await platform.pipelinePromotionTarget.list(promotion.id);
         debug('promote poll=%d promotion=%s statuses=%o', poll, promotion.id, targets.map(target => target.status));
         if (targets.every(target => target.status !== 'pending')) {
             debug('promote terminal promotion=%s polls=%d', promotion.id, poll);
@@ -43,7 +48,7 @@ export async function promotePipeline(ctx, body, options = {}) {
  * output stream and hands it to `onReleaseStream`. Subsequent calls are
  * no-ops; the stream is one-shot per promotion.
  */
-function createReleaseStreamRunner(ctx, onReleaseStream, releaseStreamMaxAttempts, intervalMs, signal) {
+function createReleaseStreamRunner(platform, onReleaseStream, releaseStreamMaxAttempts, intervalMs, signal) {
     let handled = false;
     return async (targets) => {
         if (handled || targets.length !== 1)
@@ -53,7 +58,7 @@ function createReleaseStreamRunner(ctx, onReleaseStream, releaseStreamMaxAttempt
             return;
         handled = true;
         debug('promote release-stream lookup app=%s release=%s', target.app.id, target.release.id);
-        const release = await ctx.platform.release.info(target.app.id, target.release.id);
+        const release = await platform.release.info(target.app.id, target.release.id);
         if (!release.output_stream_url) {
             debug('promote release-stream skipped reason=no-output-stream-url');
             return;
@@ -84,9 +89,12 @@ async function fetchReleaseOutput(url, maxAttempts, intervalMs, signal) {
         let response;
         try {
             // eslint-disable-next-line no-await-in-loop
-            response = await buslClient.stream(path);
+            response = await buslClient.stream(path, { signal });
         }
-        catch {
+        catch (error) {
+            // An abort is terminal, not a retryable miss — let it propagate.
+            if (signal?.aborted || isAbortError(error))
+                throw error;
             // Treat HTTP errors thrown by the api-client as a retryable miss.
             response = undefined;
         }

package/dist/resources/platform/review-app-config/resolve-repo-name.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { debug } from './debug.js';
 /**
  * Resolves the GitHub repository name for a canonical pipeline ID.
@@ -9,7 +10,7 @@ import { debug } from './debug.js';
 export async function resolveRepoName(ctx, pipelineId, options = {}) {
     const { signal } = options;
     signal?.throwIfAborted();
-    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, signal);
     let useRepositoriesApi;
     try {
         const feature = await platform.accountFeature.info('dashboard-repositories-api');
@@ -22,7 +23,7 @@ export async function resolveRepoName(ctx, pipelineId, options = {}) {
     }
     if (useRepositoriesApi) {
         try {
-            const repositoriesApi = signal ? ctx.repositoriesApi.withOptions({ signal }) : ctx.repositoriesApi;
+            const repositoriesApi = withSignal(ctx.repositoriesApi, signal);
             const repository = await repositoriesApi.githubRepository.info(pipelineId);
             signal?.throwIfAborted();
             const repositoryName = repository.full_name?.trim();
@@ -40,7 +41,7 @@ export async function resolveRepoName(ctx, pipelineId, options = {}) {
         signal?.throwIfAborted();
         debug('repositories API disabled; falling back');
     }
-    const repositories = signal ? ctx.repositories.withOptions({ signal }) : ctx.repositories;
+    const repositories = withSignal(ctx.repositories, signal);
     const pipelineRepository = await repositories.pipelineRepository.info(pipelineId);
     signal?.throwIfAborted();
     const repositoryName = pipelineRepository.repository.name.trim();

package/dist/resources/platform/sni-endpoint/create-and-associate.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { waitForReady } from '../domain/wait-for-ready.js';
 const DEFAULT_WAIT_INTERVAL_MS = 1000;
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -35,7 +36,7 @@ const DEFAULT_TIMEOUT_MS = 30_000;
 export async function createAndAssociate(ctx, appIdentity, certificateChain, privateKey, options) {
     const { domainPoller, intervalMs = DEFAULT_WAIT_INTERVAL_MS, resolveDomains, signal, timeoutMs = DEFAULT_TIMEOUT_MS, } = options;
     signal?.throwIfAborted();
-    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, signal);
     const sniEndpoint = await platform.sniEndpoint.create(appIdentity, {
         certificate_chain: certificateChain,
         private_key: privateKey,

package/dist/resources/platform/space/wait-for-allocated.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { wait } from '../../../utils/wait.js';
 import { SpaceNotAllocatedError, SpaceNotReadyError } from './errors.js';
 const DEFAULT_INTERVAL_MS = 5000;
@@ -22,10 +23,7 @@ const DEFAULT_TIMEOUT_MS = 20 * 60 * 1000;
 export async function waitForAllocated(ctx, name, options = {}) {
     const { includeNat, intervalMs = DEFAULT_INTERVAL_MS, signal, timeoutMs = DEFAULT_TIMEOUT_MS, } = options;
     signal?.throwIfAborted();
-    let platform = ctx.platform.withHeaders({ 'Accept-Expansion': 'region' });
-    if (signal) {
-        platform = platform.withOptions({ signal });
-    }
+    const platform = withSignal(ctx.platform.withHeaders({ 'Accept-Expansion': 'region' }), signal);
     const deadline = Date.now() + timeoutMs;
     let space = await platform.space.info(name);
     while (space.state === 'allocating') {

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

@@ -0,0 +1,22 @@
+import type { Team, TeamDelinquency } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../core/extend-resource.js';
+export type GetTeamWithDelinquencyOptions = {
+    signal?: AbortSignal;
+};
+export type TeamWithDelinquency = {
+    delinquency: null | TeamDelinquency;
+    team: Team;
+};
+/**
+ * Fetch a team together with its delinquency status.
+ *
+ * Runs the two reads concurrently. The team 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 team fetch. Callers
+ * decide whether and how to surface a warning from `delinquency` —
+ * `formatDelinquencyWarning` renders the sentence.
+ */
+export declare function getTeamWithDelinquency(ctx: Pick<ResourceCtx, 'platform'>, teamIdentity: string, options?: GetTeamWithDelinquencyOptions): Promise<TeamWithDelinquency>;
+export declare const teamExtensions: import("../../core/extend-resource.js").ResourceExtension<"platform", "team", {
+    getWithDelinquency: (teamIdentity: string, options?: GetTeamWithDelinquencyOptions) => Promise<TeamWithDelinquency>;
+}>;

package/dist/resources/platform/team.js

@@ -0,0 +1,34 @@
+import createDebug from 'debug';
+import { extendResource } from '../../core/extend-resource.js';
+const debug = createDebug('heroku:sdk:resources:team');
+/**
+ * Fetch a team together with its delinquency status.
+ *
+ * Runs the two reads concurrently. The team 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 team fetch. Callers
+ * decide whether and how to surface a warning from `delinquency` —
+ * `formatDelinquencyWarning` renders the sentence.
+ */
+export async function getTeamWithDelinquency(ctx, teamIdentity, options = {}) {
+    options.signal?.throwIfAborted();
+    const platform = options.signal
+        ? ctx.platform.withOptions({ signal: options.signal })
+        : ctx.platform;
+    const [team, delinquency] = await Promise.all([
+        platform.team.info(teamIdentity),
+        platform.teamDelinquency.info(teamIdentity).catch((error) => {
+            // Soft-fail a secondary-call hiccup to null, but rethrow a cancellation:
+            // if the caller aborted, returning null would misreport a delinquent team
+            // as current. Anything else is logged and swallowed.
+            if (options.signal?.aborted)
+                throw error;
+            debug('team delinquency lookup failed; treating as not delinquent: %O', error);
+            return null;
+        }),
+    ]);
+    return { delinquency, team };
+}
+export const teamExtensions = extendResource('platform', 'team', ctx => ({
+    getWithDelinquency: (teamIdentity, options) => getTeamWithDelinquency(ctx, teamIdentity, options),
+}));

package/dist/resources/platform/telemetry-drain/remove-drains-for-target.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 /**
  * Remove all telemetry drains for a given app or space.
  *
@@ -11,7 +12,7 @@ export async function removeDrainsForTarget(ctx, target, options = {}) {
     const { signal } = options;
     const { app, space } = target;
     signal?.throwIfAborted();
-    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, signal);
     let drains = [];
     if (app) {
         drains = await platform.telemetryDrain.listByApp(app);

package/dist/resources/platform/test-run/wait-for-state.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { wait } from '../../../utils/wait.js';
 const DEFAULT_INTERVAL_MS = 1000;
 // Finite default so a stuck CI test run can't hang a caller forever.
@@ -48,7 +49,7 @@ export async function waitForState(ctx, pipelineId, testRunNumber, targetStates,
     signal?.throwIfAborted();
     // Scope the in-flight info call to the caller's signal so an abort takes
     // effect during the API call, not just during the backoff.
-    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, signal);
     const deadline = Date.now() + timeoutMs;
     while (true) {
         signal?.throwIfAborted();

package/dist/resources/platform/vpn-connection/wait-for-active.js

@@ -1,3 +1,4 @@
+import { withSignal } from '../../../core/with-signal.js';
 import { wait } from '../../../utils/wait.js';
 const DEFAULT_INTERVAL_MS = 10 * 1000;
 const DEFAULT_TIMEOUT_MS = 20 * 60 * 1000;
@@ -28,7 +29,7 @@ export class VpnConnectionNotReadyError extends Error {
 export async function waitForActive(ctx, spaceIdentity, vpnConnectionIdentity, options = {}) {
     const { intervalMs = DEFAULT_INTERVAL_MS, poller, signal, timeoutMs = DEFAULT_TIMEOUT_MS, } = options;
     signal?.throwIfAborted();
-    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const platform = withSignal(ctx.platform, signal);
     const deadline = Date.now() + timeoutMs;
     let vpnConnection = await platform.vpnConnection.info(spaceIdentity, vpnConnectionIdentity);
     poller?.onStart?.(vpnConnection);

package/dist/utils/is-abort-error.d.ts

@@ -0,0 +1,11 @@
+/**
+ * True when `error` is the standard `AbortError` raised for a cancelled
+ * request: `fetch`/`ky` reject an aborted request with a `DOMException` named
+ * `AbortError`, and `signal.throwIfAborted()` throws the same shape by default.
+ *
+ * Used so soft-failure handling (broad `.catch` defaults, retry loops) can let
+ * cancellation propagate instead of swallowing it or treating it as retryable.
+ * Pair it with `signal?.aborted` at the call site to also catch a custom-reason
+ * abort (`controller.abort(reason)`) or an `AbortSignal.timeout()` deadline.
+ */
+export declare function isAbortError(error: unknown): boolean;

package/dist/utils/is-abort-error.js

@@ -0,0 +1,14 @@
+/**
+ * True when `error` is the standard `AbortError` raised for a cancelled
+ * request: `fetch`/`ky` reject an aborted request with a `DOMException` named
+ * `AbortError`, and `signal.throwIfAborted()` throws the same shape by default.
+ *
+ * Used so soft-failure handling (broad `.catch` defaults, retry loops) can let
+ * cancellation propagate instead of swallowing it or treating it as retryable.
+ * Pair it with `signal?.aborted` at the call site to also catch a custom-reason
+ * abort (`controller.abort(reason)`) or an `AbortSignal.timeout()` deadline.
+ */
+export function isAbortError(error) {
+    return ((error instanceof Error || error instanceof DOMException)
+        && error.name === 'AbortError');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heroku/sdk",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "Heroku SDK",
   "author": "Heroku",
   "type": "module",