@heroku/sdk 0.11.1 → 0.12.0

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

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

package/dist/resources/platform/account.js

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.d.ts

@@ -109,8 +109,13 @@ export type ExchangeExecCredentialsOptions = {
  * `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 declare function exchangeExecCredentials(appIdentity: string, options: ExchangeExecCredentialsOptions): Promise<ExecCredentials>;
+export declare function exchangeExecCredentials(appIdentity: string, options: ExchangeExecCredentialsOptions, ctx?: Pick<ResourceCtx, 'makeClient'>): Promise<ExecCredentials>;
 /** A running exec reservation, as reported by the exec-manager status endpoint. */
 export type ExecReservation = {
     [key: string]: unknown;
@@ -130,5 +135,10 @@ export type ExecStatusOptions = {
  * 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 declare function execStatus(appIdentity: string, options: ExecStatusOptions): Promise<ExecReservation[]>;
+export declare function execStatus(appIdentity: string, options: ExecStatusOptions, ctx?: Pick<ResourceCtx, 'makeClient'>): Promise<ExecReservation[]>;