@heroku/sdk 0.11.1 → 0.12.0

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

@@ -1,4 +1,6 @@
-import { HerokuApiClient, NotFoundError } from '@heroku/heroku-fetch';
+import { NotFoundError } from '@heroku/heroku-fetch';
+import { makeCustomHostClient } from '../../../core/extend-resource.js';
+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 +22,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 +53,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 +84,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, {
@@ -106,11 +108,16 @@ export async function restartForExec(ctx, appIdentity, dynoIdentity, options = {
  * `Authorization` header survive). The caller feeds the returned info,
  * plus the private key it holds, to its own SSH transport; the SDK does
  * not open the connection.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the custom-host
+ * client. Standalone callers omit it, and the client falls back to the
+ * pre-threading bare construction.
  */
-export async function exchangeExecCredentials(appIdentity, options) {
+export async function exchangeExecCredentials(appIdentity, options, ctx = {}) {
     options.signal?.throwIfAborted();
     const endpoint = resolveExecEndpoint(appIdentity, options.apiKey, options.configVars);
-    const client = newExecClient(endpoint.baseUrl, options.clientOptions);
+    const client = newExecClient(endpoint.baseUrl, options.clientOptions, ctx);
     const path = `${endpoint.apiPath}/${encodeURIComponent(options.dyno)}`;
     const response = await client.put(path, { client_key: options.publicKey }, {
         headers: {
@@ -129,11 +136,16 @@ export async function exchangeExecCredentials(appIdentity, options) {
  * custom-host Basic-auth setup as {@link exchangeExecCredentials}. The
  * caller correlates each reservation's `dyno_name` with live dyno state
  * for display.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the custom-host
+ * client. Standalone callers omit it, and the client falls back to the
+ * pre-threading bare construction.
  */
-export async function execStatus(appIdentity, options) {
+export async function execStatus(appIdentity, options, ctx = {}) {
     options.signal?.throwIfAborted();
     const endpoint = resolveExecEndpoint(appIdentity, options.apiKey, options.configVars);
-    const client = newExecClient(endpoint.baseUrl, options.clientOptions);
+    const client = newExecClient(endpoint.baseUrl, options.clientOptions, ctx);
     const response = await client.get(endpoint.apiPath, {
         headers: { ...options.headers, Authorization: endpoint.authorization },
         signal: options.signal,
@@ -168,10 +180,13 @@ function resolveExecEndpoint(appIdentity, apiKey, configVars) {
         baseUrl: `${url.protocol}//${url.host}`,
     };
 }
-function newExecClient(baseUrl, clientOptions) {
-    return new HerokuApiClient({
-        ...clientOptions, baseUrl, service: 'custom', token: '',
-    });
+function newExecClient(baseUrl, clientOptions, ctx = {}) {
+    // exec-manager is a custom host with Basic auth embedded per request. The
+    // custom-host client forces `token: ''` and inherits only the SDK's identity
+    // (User-Agent) and signal — never `reauthorize`/headers, so a bad-Basic 401
+    // can't drive a spurious `heroku login`. The caller's `clientOptions` still
+    // apply on top.
+    return makeCustomHostClient(ctx, baseUrl, clientOptions);
 }
 function toBasicAuth(username, password) {
     return `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`;

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,22 +21,24 @@ 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)),
-    exchangeExecCredentials: (appIdentity, options) => (exchangeExecCredentials(appIdentity, options)),
+    exchangeExecCredentials: (appIdentity, options) => (exchangeExecCredentials(appIdentity, options, ctx)),
     execPrereqs: (appIdentity, options) => (execPrereqs(ctx, appIdentity, options)),
-    execStatus: (appIdentity, options) => (execStatus(appIdentity, options)),
-    listExtended: (appIdentity, options) => (listExtended(appIdentity, options)),
+    execStatus: (appIdentity, options) => (execStatus(appIdentity, options, ctx)),
+    listExtended: (appIdentity, options) => (listExtended(appIdentity, options, ctx)),
     restart: (appIdentity, target, options) => (restartDynos(ctx, appIdentity, target, options)),
     restartForExec: (appIdentity, dynoIdentity, options) => (restartForExec(ctx, appIdentity, dynoIdentity, options)),
     run: (appIdentity, command, options) => (runDyno(ctx, appIdentity, command, options)),

package/dist/resources/platform/dyno/list-extended.d.ts

@@ -1,5 +1,6 @@
 import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
 import type { Dyno } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../../core/extend-resource.js';
 /**
  * Operational detail the platform attaches to each dyno only when the
  * `?extended=true` query is used with the `version=3.sdk` Accept
@@ -46,5 +47,10 @@ export type ListExtendedOptions = {
  *
  * Unlike the routes client, this does not auto-paginate — it issues a
  * single GET, matching the historical CLI behavior.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the bare client.
+ * Standalone callers omit it, and the client falls back to the pre-threading
+ * bare construction.
  */
-export declare function listExtended(appIdentity: string, options?: ListExtendedOptions): Promise<DynoExtended[]>;
+export declare function listExtended(appIdentity: string, options?: ListExtendedOptions, ctx?: Pick<ResourceCtx, 'makeClient'>): Promise<DynoExtended[]>;

package/dist/resources/platform/dyno/list-extended.js

@@ -1,4 +1,4 @@
-import { HerokuApiClient } from '@heroku/heroku-fetch';
+import { makeCtxClient } from '../../../core/extend-resource.js';
 const ACCEPT_EXTENDED = 'application/vnd.heroku+json; version=3.sdk';
 /**
  * List an app's dynos with the extended operational detail block.
@@ -12,10 +12,15 @@ const ACCEPT_EXTENDED = 'application/vnd.heroku+json; version=3.sdk';
  *
  * Unlike the routes client, this does not auto-paginate — it issues a
  * single GET, matching the historical CLI behavior.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the bare client.
+ * Standalone callers omit it, and the client falls back to the pre-threading
+ * bare construction.
  */
-export async function listExtended(appIdentity, options = {}) {
+export async function listExtended(appIdentity, options = {}, ctx = {}) {
     options.signal?.throwIfAborted();
-    const apiClient = new HerokuApiClient({
+    const apiClient = makeCtxClient(ctx, 'platform', {
         ...options.clientOptions,
         service: 'platform',
     });

package/dist/resources/platform/dyno/run.d.ts

@@ -73,4 +73,4 @@ export type RunDynoOptions = {
  * open their own interactive session; the SDK does not establish the
  * session, spawn ssh, or manage TTY state.
  */
-export declare function runDyno(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string, command: string, options?: RunDynoOptions): Promise<Dyno>;
+export declare function runDyno(ctx: Pick<ResourceCtx, 'makeClient' | 'platform'>, appIdentity: string, command: string, options?: RunDynoOptions): Promise<Dyno>;

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

@@ -1,4 +1,6 @@
-import { HerokuApiClient, HerokuApiError } from '@heroku/heroku-fetch';
+import { HerokuApiError } from '@heroku/heroku-fetch';
+import { makeCtxClient } from '../../../core/extend-resource.js';
+import { withSignal } from '../../../core/with-signal.js';
 const DEFAULT_RUN_RETRIES = 2;
 const ACCEPT_RUN_INSIDE = 'application/vnd.heroku+json; version=3.sdk';
 /**
@@ -58,7 +60,7 @@ export async function runDyno(ctx, appIdentity, command, options = {}) {
 }
 async function postRun(ctx, appIdentity, body, options) {
     if (options.dyno) {
-        const apiClient = new HerokuApiClient({
+        const apiClient = makeCtxClient(ctx, 'platform', {
             ...options.clientOptions,
             service: 'platform',
         });
@@ -69,6 +71,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.d.ts

@@ -95,7 +95,7 @@ export type StreamLogsOptions = {
  *   - non-2xx response from the logplex URL
  *   - errors thrown by `logSession.create` (auth, app-not-found, etc.)
  */
-export declare function streamLogs(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string, options?: StreamLogsOptions): AsyncGenerator<string, void, unknown>;
+export declare function streamLogs(ctx: Pick<ResourceCtx, 'makeClient' | 'platform'>, appIdentity: string, options?: StreamLogsOptions): AsyncGenerator<string, void, unknown>;
 export declare const logSessionExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "logSession", {
     parseHerokuLogLine: typeof parseHerokuLogLine;
     streamLogs: (appIdentity: string, options?: StreamLogsOptions) => AsyncGenerator<string, void, unknown>;

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

@@ -1,6 +1,6 @@
-import { HerokuApiClient } from '@heroku/heroku-fetch';
 import createDebug from 'debug';
-import { extendResource } from '../../../core/extend-resource.js';
+import { extendResource, makeCustomHostClient } 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 +37,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 +55,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.');
         }
@@ -64,15 +67,12 @@ export async function* streamLogs(ctx, appIdentity, options = {}) {
         try {
             // Logplex URLs hit a region-specific stream host (e.g.
             // virginia.sessions.logs.heroku.com). The token is embedded in
-            // the URL, so we use a custom-service client with no auth and
-            // a per-call baseUrl; this also picks up heroku-fetch's
-            // env-var proxy support.
+            // the URL, so we use a custom-host client with no auth and a
+            // per-call baseUrl, inheriting only the SDK's identity and
+            // cancellation; this also picks up heroku-fetch's env-var proxy
+            // support.
             const parsed = new URL(session.logplex_url);
-            const logplexClient = new HerokuApiClient({
-                baseUrl: parsed.origin,
-                service: 'custom',
-                token: '',
-            });
+            const logplexClient = makeCustomHostClient(ctx, parsed.origin);
             // Fir's telemetry-proxy sends newline-delimited plain text by
             // default, but concatenates records with zero delimiter bytes —
             // splitting on '\n' yields nothing. Requesting SSE flips the
@@ -81,6 +81,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.d.ts

@@ -1,5 +1,5 @@
+import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
 import type { Pipeline } from '@heroku/types/3.sdk';
-import { type HerokuApiClientOptions } from '@heroku/heroku-fetch';
 import type { ResourceCtx } from '../../../core/extend-resource.js';
 export type ResolvePipelineOptions = {
     clientOptions?: HerokuApiClientOptions;
@@ -47,7 +47,7 @@ export declare class PipelineAmbiguousError extends Error {
  *     that want to prompt the user should catch this and inspect
  *     `error.matches`.
  */
-export declare function resolvePipeline(ctx: Pick<ResourceCtx, 'platform'>, identity: string, options?: ResolvePipelineOptions): Promise<Pipeline>;
+export declare function resolvePipeline(ctx: Pick<ResourceCtx, 'makeClient' | 'platform'>, identity: string, options?: ResolvePipelineOptions): Promise<Pipeline>;
 export declare const pipelineExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "pipeline", {
     resolve: (identity: string, options?: ResolvePipelineOptions) => Promise<Pipeline>;
 }>;

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

@@ -1,5 +1,5 @@
-import { HerokuApiClient } from '@heroku/heroku-fetch';
-import { extendResource } from '../../../core/extend-resource.js';
+import { extendResource, makeCtxClient } from '../../../core/extend-resource.js';
+import { withSignal } from '../../../core/with-signal.js';
 export class PipelineNotFoundError extends Error {
     identity;
     id = 'not_found';
@@ -52,14 +52,16 @@ 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({
+    const apiClient = makeCtxClient(ctx, 'platform', {
         ...options.clientOptions,
         service: 'platform',
     });
     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.d.ts

@@ -15,7 +15,7 @@ export type PromotePipelineResult = {
     promotion: PipelinePromotion;
     targets: PipelinePromotionTarget[];
 };
-export declare function promotePipeline(ctx: Pick<ResourceCtx, 'platform'>, body: PipelinePromotionCreateOpts, options?: PromotePipelineOptions): Promise<PromotePipelineResult>;
+export declare function promotePipeline(ctx: Pick<ResourceCtx, 'makeClient' | 'platform'>, body: PipelinePromotionCreateOpts, options?: PromotePipelineOptions): Promise<PromotePipelineResult>;
 export declare const pipelinePromotionExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "pipelinePromotion", {
     promote: (body: PipelinePromotionCreateOpts, options?: PromotePipelineOptions) => Promise<PromotePipelineResult>;
 }>;

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

@@ -1,28 +1,32 @@
-import { HerokuApiClient } from '@heroku/heroku-fetch';
 import createDebug from 'debug';
-import { extendResource } from '../../../core/extend-resource.js';
+import { extendResource, makeCustomHostClient } 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(ctx, 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 +47,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(ctx, platform, onReleaseStream, releaseStreamMaxAttempts, intervalMs, signal) {
     let handled = false;
     return async (targets) => {
         if (handled || targets.length !== 1)
@@ -53,30 +57,27 @@ 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;
         }
         debug('promote release-stream fetching url=%s maxAttempts=%d', release.output_stream_url, releaseStreamMaxAttempts);
-        const stream = await fetchReleaseOutput(release.output_stream_url, releaseStreamMaxAttempts, intervalMs, signal);
+        const stream = await fetchReleaseOutput(ctx, release.output_stream_url, releaseStreamMaxAttempts, intervalMs, signal);
         await onReleaseStream({ stream, target });
     };
 }
 export const pipelinePromotionExtensions = extendResource('platform', 'pipelinePromotion', ctx => ({
     promote: (body, options) => promotePipeline(ctx, body, options),
 }));
-async function fetchReleaseOutput(url, maxAttempts, intervalMs, signal) {
+async function fetchReleaseOutput(ctx, url, maxAttempts, intervalMs, signal) {
     const parsed = new URL(url);
     const path = `${parsed.pathname}${parsed.search}`;
     // The release output URL points at a third-party stream host (e.g. busl).
-    // Use a custom-service client so the platform prefixUrl and bearer token
-    // don't leak across origins.
-    const buslClient = new HerokuApiClient({
-        baseUrl: parsed.origin,
-        service: 'custom',
-        token: '',
-    });
+    // Use a custom-host client so the platform prefixUrl, bearer token, and
+    // other auth/routing options don't leak across origins, while still
+    // inheriting the SDK's identity (User-Agent) and cancellation signal.
+    const buslClient = makeCustomHostClient(ctx, parsed.origin);
     let attempt = 0;
     while (true) {
         signal?.throwIfAborted();
@@ -84,9 +85,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);