@heroku/sdk 0.11.1 → 0.11.2

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);

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;
         }