@heroku/sdk 0.5.5 → 0.6.0

package/README.md

@@ -1,6 +1,6 @@
 # Heroku SDK
 
-A TypeScript SDK for the [Heroku Platform API](https://devcenter.heroku.com/articles/platform-api-reference) and [Heroku Data API](https://devcenter.heroku.com/articles/heroku-postgres-api-reference). It generates fully-typed clients at runtime from route definitions — no hand-written method per endpoint.
+A TypeScript SDK for the [Heroku Platform API](https://devcenter.heroku.com/articles/platform-api-reference), [Heroku Data API](https://devcenter.heroku.com/articles/heroku-postgres-api-reference), the Heroku Dashboard Backend, the Heroku Metrics API, and the Heroku Repositories API. It generates fully-typed clients at runtime from route definitions — no hand-written method per endpoint.
 
 ## Installation
 
@@ -22,6 +22,7 @@ const sdk = new HerokuSDK({ extensions: [appExtensions] })
 // Upstream route (auto-generated from the API spec)
 const apps = await sdk.platform.app.list()
 const app  = await sdk.platform.app.info('my-app')
+const favorites = await sdk.dashboardBackend.favorite.list({ type: 'app' })
 
 // Hand-written extension method (provided by appExtensions)
 await sdk.platform.app.enableMaintenance('my-app')
@@ -38,13 +39,20 @@ const sdk = new HerokuSDK({ clientOptions: { token: 'your-api-token' } })
 If you only need one service (and want the smallest possible bundle), import the factory directly. These return the same typed client the SDK class wraps internally.
 
 ```ts
-import { createPlatformClient } from '@heroku/sdk/platform'
-import { createDataClient }     from '@heroku/sdk/data'
-
-const platform = createPlatformClient()
-const data     = createDataClient()
+import { createPlatformClient }     from '@heroku/sdk/platform'
+import { createDataClient }         from '@heroku/sdk/data'
+import { createDashboardBackendClient } from '@heroku/sdk/dashboard-backend'
+import { createMetricsClient }      from '@heroku/sdk/metrics'
+import { createRepositoriesClient } from '@heroku/sdk/repositories'
+
+const platform     = createPlatformClient()
+const data         = createDataClient()
+const dashboardBackend = createDashboardBackendClient()
+const metrics      = createMetricsClient()
+const repositories = createRepositoriesClient()
 
 const apps = await platform.app.list()
+const favorites = await dashboardBackend.favorite.list({ type: 'app' })
 ```
 
 ### Imports
@@ -54,6 +62,9 @@ const apps = await platform.app.list()
 | `HerokuSDK`, `extendResource`, types     | `@heroku/sdk`                     |
 | `createPlatformClient`, `PlatformClient` | `@heroku/sdk/platform`            |
 | `createDataClient`, `DataClient`         | `@heroku/sdk/data`                |
+| `createDashboardBackendClient`, `DashboardBackendClient` | `@heroku/sdk/dashboard-backend` |
+| `createMetricsClient`, `MetricsClient`   | `@heroku/sdk/metrics`             |
+| `createRepositoriesClient`, `RepositoriesClient` | `@heroku/sdk/repositories` |
 | `appExtensions`, `dynoExtensions`, …     | `@heroku/sdk/extensions/platform` |
 | `databaseExtensions`, …                  | `@heroku/sdk/extensions/data`     |
 

package/dist/core/dispatcher.js

@@ -16,8 +16,22 @@ export async function dispatch(client, route, args, invocation, requestOptions)
     if (route.hasRequestBody && remaining.length > 0) {
         body = remaining[0];
     }
+    let effectiveOptions = requestOptions;
+    if (route.query && route.query.length > 0 && remaining.length > 0) {
+        const raw = remaining[0];
+        if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
+            const searchParams = {};
+            for (const key of route.query) {
+                const value = raw[key];
+                if (value !== undefined && value !== null) {
+                    searchParams[key] = value;
+                }
+            }
+            effectiveOptions = { ...requestOptions, searchParams };
+        }
+    }
     debug('%s %s %s -> %s hasBody=%s', invocation ?? 'dispatch', route.method, route.path, path, body !== undefined);
-    const response = await callMethod(client, route.method, path, body, requestOptions);
+    const response = await callMethod(client, route.method, path, body, effectiveOptions);
     const contentLength = response.headers.get('content-length');
     if (response.status === 204 || contentLength === '0') {
         debug('%s empty response status=%d content-length=%s', invocation ?? 'dispatch', response.status, contentLength ?? '');
@@ -30,7 +44,7 @@ export async function dispatch(client, route, args, invocation, requestOptions)
     const nextRange = response.headers.get('next-range');
     if (!nextRange)
         return result;
-    return followPages(client, path, result, nextRange, invocation, requestOptions);
+    return followPages(client, path, result, nextRange, invocation, effectiveOptions);
 }
 /* eslint-disable no-await-in-loop -- pagination is inherently sequential; each page depends on the previous next-range header */
 async function followPages(client, path, firstPage, initialRange, invocation, requestOptions) {

package/dist/core/extend-resource.d.ts

@@ -1,9 +1,15 @@
+import type { DashboardBackendClient } from '../services/dashboard-backend.js';
 import type { DataClient } from '../services/data.js';
+import type { MetricsClient } from '../services/metrics.js';
 import type { PlatformClient } from '../services/platform.js';
-export type ServiceName = 'data' | 'platform';
+import type { RepositoriesClient } from '../services/repositories.js';
+export type ServiceName = 'dashboardBackend' | 'data' | 'metrics' | 'platform' | 'repositories';
 export type ResourceCtx = {
+    dashboardBackend: DashboardBackendClient;
     data: DataClient;
+    metrics: MetricsClient;
     platform: PlatformClient;
+    repositories: RepositoriesClient;
 };
 export type ResourceMethods = Record<string, (...args: any[]) => any>;
 export type ResourceExtension<S extends ServiceName = ServiceName, R extends string = string, M extends ResourceMethods = ResourceMethods> = {

package/dist/core/heroku-sdk.d.ts

@@ -1,6 +1,9 @@
 import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
+import type { DashboardBackendClient } from '../services/dashboard-backend.js';
 import type { DataClient } from '../services/data.js';
+import type { MetricsClient } from '../services/metrics.js';
 import type { PlatformClient } from '../services/platform.js';
+import type { RepositoriesClient } from '../services/repositories.js';
 import type { ApplyExtensions, ExtensionsFor, ResourceExtension } from './extend-resource.js';
 export type HerokuSDKOptions<Exts extends readonly ResourceExtension[]> = {
     clientOptions?: HerokuApiClientOptions;
@@ -9,6 +12,9 @@ export type HerokuSDKOptions<Exts extends readonly ResourceExtension[]> = {
 export declare class HerokuSDK<const Exts extends readonly ResourceExtension[] = readonly ResourceExtension[]> {
     #private;
     constructor(options?: HerokuSDKOptions<Exts>);
+    get dashboardBackend(): ApplyExtensions<DashboardBackendClient, ExtensionsFor<Exts, 'dashboardBackend'>>;
     get data(): ApplyExtensions<DataClient, ExtensionsFor<Exts, 'data'>>;
+    get metrics(): ApplyExtensions<MetricsClient, ExtensionsFor<Exts, 'metrics'>>;
     get platform(): ApplyExtensions<PlatformClient, ExtensionsFor<Exts, 'platform'>>;
+    get repositories(): ApplyExtensions<RepositoriesClient, ExtensionsFor<Exts, 'repositories'>>;
 }

package/dist/core/heroku-sdk.js

@@ -1,5 +1,8 @@
+import { createDashboardBackendClient } from '../services/dashboard-backend.js';
 import { createDataClient } from '../services/data.js';
+import { createMetricsClient } from '../services/metrics.js';
 import { createPlatformClient } from '../services/platform.js';
+import { createRepositoriesClient } from '../services/repositories.js';
 import { mergeExtensions } from './extensions-proxy.js';
 function partitionByService(extensions) {
     const map = new Map();
@@ -13,42 +16,84 @@ function partitionByService(extensions) {
 export class HerokuSDK {
     #clientOptions;
     #ctx;
+    #dashboardBackend;
     #data;
     #extensionsByService;
+    #metrics;
     #platform;
+    #rawDashboardBackend;
     #rawData;
+    #rawMetrics;
     #rawPlatform;
+    #rawRepositories;
+    #repositories;
     constructor(options = {}) {
         this.#clientOptions = options.clientOptions ?? {};
         this.#extensionsByService = partitionByService(options.extensions ?? []);
     }
+    get dashboardBackend() {
+        this.#dashboardBackend ??= mergeExtensions(this.#getRawDashboardBackend(), this.#extensionsByService.get('dashboardBackend') ?? [], this.#getCtx());
+        return this.#dashboardBackend;
+    }
     get data() {
         this.#data ??= mergeExtensions(this.#getRawData(), this.#extensionsByService.get('data') ?? [], this.#getCtx());
         return this.#data;
     }
+    get metrics() {
+        this.#metrics ??= mergeExtensions(this.#getRawMetrics(), this.#extensionsByService.get('metrics') ?? [], this.#getCtx());
+        return this.#metrics;
+    }
     get platform() {
         this.#platform ??= mergeExtensions(this.#getRawPlatform(), this.#extensionsByService.get('platform') ?? [], this.#getCtx());
         return this.#platform;
     }
+    get repositories() {
+        this.#repositories ??= mergeExtensions(this.#getRawRepositories(), this.#extensionsByService.get('repositories') ?? [], this.#getCtx());
+        return this.#repositories;
+    }
     #getCtx() {
         this.#ctx ??= Object.defineProperties({}, {
+            dashboardBackend: {
+                enumerable: true,
+                get: () => this.#getRawDashboardBackend(),
+            },
             data: {
                 enumerable: true,
                 get: () => this.#getRawData(),
             },
+            metrics: {
+                enumerable: true,
+                get: () => this.#getRawMetrics(),
+            },
             platform: {
                 enumerable: true,
                 get: () => this.#getRawPlatform(),
             },
+            repositories: {
+                enumerable: true,
+                get: () => this.#getRawRepositories(),
+            },
         });
         return this.#ctx;
     }
+    #getRawDashboardBackend() {
+        this.#rawDashboardBackend ??= createDashboardBackendClient(this.#clientOptions);
+        return this.#rawDashboardBackend;
+    }
     #getRawData() {
         this.#rawData ??= createDataClient(this.#clientOptions);
         return this.#rawData;
     }
+    #getRawMetrics() {
+        this.#rawMetrics ??= createMetricsClient(this.#clientOptions);
+        return this.#rawMetrics;
+    }
     #getRawPlatform() {
         this.#rawPlatform ??= createPlatformClient(this.#clientOptions);
         return this.#rawPlatform;
     }
+    #getRawRepositories() {
+        this.#rawRepositories ??= createRepositoriesClient(this.#clientOptions);
+        return this.#rawRepositories;
+    }
 }

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

@@ -1,5 +1,5 @@
 export { addOnExtensions } from '../platform/add-on/index.js';
-export { appExtensions, type AppInfo, type PipelineCouplingDetail } from '../platform/app/index.js';
+export { appExtensions, type AppInfo, type DiffAppsOptions, type DiffRow, type PipelineCouplingDetail, } from '../platform/app/index.js';
 export { containerExtensions, type DockerReleasesBatchUpdateOpts, NotAContainerAppError, type ReleaseDockerImagesResult, type RemoveProcessTypesOpts, } from '../platform/container/index.js';
 export { type CreateAndWaitOptions, domainExtensions, type DomainOptions, type WaitForReadyOptions, } from '../platform/domain/index.js';
 export { dynoExtensions, DynoNotReadyError, type DynoState, runDyno, type RunDynoOptions, waitForInfo, type WaitForInfoOptions, } from '../platform/dyno/index.js';
@@ -9,5 +9,7 @@ export { pipelineExtensions } from '../platform/pipeline/index.js';
 export { pipelinePromotionExtensions } from '../platform/pipeline/promotion.js';
 export { privateToShield, shieldToPrivate } from '../platform/shield.js';
 export { createAndAssociate, type CreateAndAssociateOptions, sniEndpointExtensions } from '../platform/sni-endpoint/index.js';
+export { spaceExtensions, SpaceNotAllocatedError, SpaceNotReadyError, type SpaceOptions, type SpaceWithNat, waitForAllocated, type WaitForAllocatedOptions, } from '../platform/space/index.js';
 export { telemetryDrainExtensions, type TelemetryDrainOptions, type TelemetryDrainTarget } from '../platform/telemetry-drain/index.js';
 export { testRunExtensions, TestRunNotReadyError, type TestRunStatus, waitForState, type WaitForStateOptions, } from '../platform/test-run/index.js';
+export { vpnConnectionExtensions, VpnConnectionFailedError, VpnConnectionNotReadyError, type VpnConnectionOptions, waitForActive, type WaitForActiveOptions, } from '../platform/vpn-connection/index.js';

package/dist/resources/extensions/platform.js

@@ -1,5 +1,5 @@
 export { addOnExtensions } from '../platform/add-on/index.js';
-export { appExtensions } from '../platform/app/index.js';
+export { appExtensions, } from '../platform/app/index.js';
 export { containerExtensions, NotAContainerAppError, } from '../platform/container/index.js';
 export { domainExtensions, } from '../platform/domain/index.js';
 export { dynoExtensions, DynoNotReadyError, runDyno, waitForInfo, } from '../platform/dyno/index.js';
@@ -9,5 +9,7 @@ export { pipelineExtensions } from '../platform/pipeline/index.js';
 export { pipelinePromotionExtensions } from '../platform/pipeline/promotion.js';
 export { privateToShield, shieldToPrivate } from '../platform/shield.js';
 export { createAndAssociate, sniEndpointExtensions } from '../platform/sni-endpoint/index.js';
+export { spaceExtensions, SpaceNotAllocatedError, SpaceNotReadyError, waitForAllocated, } from '../platform/space/index.js';
 export { telemetryDrainExtensions } from '../platform/telemetry-drain/index.js';
 export { testRunExtensions, TestRunNotReadyError, waitForState, } from '../platform/test-run/index.js';
+export { vpnConnectionExtensions, VpnConnectionFailedError, VpnConnectionNotReadyError, waitForActive, } from '../platform/vpn-connection/index.js';

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

@@ -0,0 +1,50 @@
+import type { App, ConfigVarUpdateOpts } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../../core/extend-resource.js';
+export type SetupStep = {
+    kind: 'addon' | 'buildpack' | 'config-vars' | 'setup';
+    label?: string;
+};
+export type CreateAndSetupOptions = {
+    poller?: {
+        onStart?: (step: SetupStep) => void;
+        onStop?: (step?: SetupStep) => void;
+    };
+    signal?: AbortSignal;
+};
+export type CreateAndSetupInput = {
+    addons?: Array<{
+        as?: string;
+        plan: string;
+    }>;
+    buildpack?: string;
+    configVars?: ConfigVarUpdateOpts;
+    name?: string;
+    region?: string;
+    space?: string;
+    stack?: string;
+    team?: string;
+};
+/**
+ * Create an app and run its post-create setup in one call.
+ *
+ * Creates the app (team/space → `teamApp.create`, otherwise `app.create`),
+ * then fans out the optional setup steps in parallel: add-ons
+ * (`addOn.create` per plan), config vars (`configVar.update`), and buildpack
+ * (`buildpackInstallation.update`). Returns the created `App`.
+ *
+ * Progress is reported via the `poller` convention. Because the steps run in
+ * parallel and a caller's progress indicator is typically a single global
+ * spinner, this method fires a single `onStart`/`onStop` pair around the whole
+ * setup batch rather than one per step, so parallel steps don't clobber the
+ * 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 CLI parses flags / heroku.yml into `input` and owns git-remote setup
+ * and rendering; this method owns the API orchestration only.
+ */
+export declare function createAndSetup(ctx: Pick<ResourceCtx, 'platform'>, input: CreateAndSetupInput, options?: CreateAndSetupOptions): Promise<App>;

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

@@ -0,0 +1,60 @@
+/**
+ * Create an app and run its post-create setup in one call.
+ *
+ * Creates the app (team/space → `teamApp.create`, otherwise `app.create`),
+ * then fans out the optional setup steps in parallel: add-ons
+ * (`addOn.create` per plan), config vars (`configVar.update`), and buildpack
+ * (`buildpackInstallation.update`). Returns the created `App`.
+ *
+ * Progress is reported via the `poller` convention. Because the steps run in
+ * parallel and a caller's progress indicator is typically a single global
+ * spinner, this method fires a single `onStart`/`onStop` pair around the whole
+ * setup batch rather than one per step, so parallel steps don't clobber the
+ * 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 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 { addons, buildpack, configVars, ...createParams } = input;
+    const app = (createParams.space || createParams.team)
+        ? (await platform.teamApp.create(createParams))
+        : await platform.app.create(createParams);
+    if (!app.name)
+        throw new Error('createAndSetup: created app has no name');
+    const appName = app.name;
+    // Deferred thunks: nothing is dispatched until the batch is launched below,
+    // so `onStart` reliably fires before the first request.
+    const steps = [];
+    if (addons?.length) {
+        for (const addon of addons) {
+            steps.push(() => platform.addOn.create(appName, {
+                attachment: addon.as ? { name: addon.as } : undefined,
+                plan: addon.plan,
+            }));
+        }
+    }
+    if (configVars && Object.keys(configVars).length > 0) {
+        steps.push(() => platform.configVar.update(appName, configVars));
+    }
+    if (buildpack) {
+        steps.push(() => platform.buildpackInstallation.update(appName, { updates: [{ buildpack }] }));
+    }
+    if (steps.length > 0) {
+        // Single combined progress window — one spinner for the whole parallel
+        // setup batch, not one per step. onStart before dispatch; onStop only on
+        // success (no try/finally — a rejection skips onStop per contract).
+        options.poller?.onStart?.({ kind: 'setup', label: 'setup' });
+        await Promise.all(steps.map(step => step()));
+        options.poller?.onStop?.();
+    }
+    return app;
+}

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

@@ -0,0 +1,20 @@
+import type { ResourceCtx } from '../../../core/extend-resource.js';
+export type DiffAppsOptions = {
+    signal?: AbortSignal;
+};
+export interface DiffRow {
+    app1: string | undefined;
+    app2: string | undefined;
+    prop: string;
+}
+/**
+ * Composite diff of two apps: compares slug checksum, config vars, stack,
+ * buildpacks, add-ons, and features, returning one `DiffRow` per differing
+ * property.
+ *
+ * Faithful port of the Heroku CLI's `apps:diff`: `diffFiles` runs first (so a
+ * missing app surfaces the `App not found: <app>` error before the rest), then
+ * the remaining five diffs run in parallel and their rows are concatenated in
+ * the CLI's order. Rendering (truncation, table output) stays with the caller.
+ */
+export declare function diffApps(ctx: Pick<ResourceCtx, 'platform'>, app1: string, app2: string, options?: DiffAppsOptions): Promise<DiffRow[]>;

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

@@ -0,0 +1,110 @@
+import { NotFoundError } from '@heroku/heroku-fetch';
+async function checksum(platform, app) {
+    try {
+        const releases = await platform.withHeaders({ Range: 'version ..; max=1, order=desc' }).release.list(app);
+        if (releases?.[0]?.slug) {
+            const slugId = releases[0].slug.id;
+            const slug = await platform.slug.info(app, slugId);
+            return slug?.checksum ?? null;
+        }
+        return null;
+    }
+    catch (error) {
+        if (isNotFound(error)) {
+            throw new Error(`App not found: ${app}`, { cause: error });
+        }
+        throw error;
+    }
+}
+function isNotFound(error) {
+    return error instanceof NotFoundError;
+}
+async function diffFiles(platform, app1, app2) {
+    const sums = await Promise.all([checksum(platform, app1), checksum(platform, app2)]);
+    return sums[0] === sums[1] ? [] : [{ app1: sums[0] ?? undefined, app2: sums[1] ?? undefined, prop: 'slug (checksum)' }];
+}
+async function diffEnv(platform, app1, app2) {
+    const [vars1, vars2] = await Promise.all([
+        platform.configVar.infoForApp(app1),
+        platform.configVar.infoForApp(app2),
+    ]);
+    const cfg1 = vars1 ?? {};
+    const cfg2 = vars2 ?? {};
+    const keys = new Set([...Object.keys(cfg1), ...Object.keys(cfg2)]);
+    return [...keys]
+        .filter(k => cfg1[k] !== cfg2[k])
+        .map(k => ({ app1: cfg1[k], app2: cfg2[k], prop: `config (${k})` }));
+}
+async function diffStack(platform, app1, app2) {
+    const [res1, res2] = await Promise.all([
+        platform.app.info(app1),
+        platform.app.info(app2),
+    ]);
+    const a = res1?.stack?.name;
+    const b = res2?.stack?.name;
+    return a === b ? [] : [{ app1: a, app2: b, prop: 'stack' }];
+}
+async function diffBuildpacks(platform, app1, app2) {
+    const [res1, res2] = await Promise.all([
+        platform.buildpackInstallation.list(app1),
+        platform.buildpackInstallation.list(app2),
+    ]);
+    const bps1 = res1 ?? [];
+    const bps2 = res2 ?? [];
+    const urls1 = bps1.map(obj => obj.buildpack?.url ?? '');
+    const urls2 = bps2.map(obj => obj.buildpack?.url ?? '');
+    const longest = urls1.length >= urls2.length ? urls1 : urls2;
+    const pairs = longest.map((_, k) => ({
+        app1: urls1[k],
+        app2: urls2[k],
+        prop: `buildpack (${k})`,
+    }));
+    return pairs.filter(pair => pair.app1 !== pair.app2);
+}
+async function diffAddons(platform, app1, app2) {
+    const [addons1, addons2] = await Promise.all([
+        platform.addOn.listByApp(app1),
+        platform.addOn.listByApp(app2),
+    ]);
+    const names1 = new Set((addons1 ?? []).map(addon => addon.addon_service?.name ?? '').filter(Boolean));
+    const names2 = new Set((addons2 ?? []).map(addon => addon.addon_service?.name ?? '').filter(Boolean));
+    const only1 = [...names1].filter(name => !names2.has(name)).map(name => ({ app1: 'true', app2: 'false', prop: `add-on (${name})` }));
+    const only2 = [...names2].filter(name => !names1.has(name)).map(name => ({ app1: 'false', app2: 'true', prop: `add-on (${name})` }));
+    return [...only1, ...only2];
+}
+async function diffFeatures(platform, app1, app2) {
+    const [features1, features2] = await Promise.all([
+        platform.appFeature.list(app1),
+        platform.appFeature.list(app2),
+    ]);
+    const names1 = new Set((features1 ?? []).map(f => (f.enabled ? f.name : null)).filter(Boolean));
+    const names2 = new Set((features2 ?? []).map(f => (f.enabled ? f.name : null)).filter(Boolean));
+    const only1 = [...names1].filter(name => !names2.has(name)).map(name => ({ app1: 'enabled', app2: 'disabled', prop: `feature (${name})` }));
+    const only2 = [...names2].filter(name => !names1.has(name)).map(name => ({ app1: 'disabled', app2: 'enabled', prop: `feature (${name})` }));
+    return [...only1, ...only2];
+}
+/**
+ * Composite diff of two apps: compares slug checksum, config vars, stack,
+ * buildpacks, add-ons, and features, returning one `DiffRow` per differing
+ * property.
+ *
+ * Faithful port of the Heroku CLI's `apps:diff`: `diffFiles` runs first (so a
+ * missing app surfaces the `App not found: <app>` error before the rest), then
+ * the remaining five diffs run in parallel and their rows are concatenated in
+ * the CLI's order. Rendering (truncation, table output) stays with the caller.
+ */
+export async function diffApps(ctx, app1, app2, options = {}) {
+    options.signal?.throwIfAborted();
+    const platform = options.signal
+        ? ctx.platform.withOptions({ signal: options.signal })
+        : ctx.platform;
+    const files = await diffFiles(platform, app1, app2);
+    const [env, stack, bp, addons, features] = await Promise.all([
+        diffEnv(platform, app1, app2),
+        diffStack(platform, app1, app2),
+        diffBuildpacks(platform, app1, app2),
+        diffAddons(platform, app1, app2),
+        diffFeatures(platform, app1, app2),
+    ]);
+    return [...files, ...env, ...stack, ...bp, ...addons, ...features];
+}

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

@@ -1,8 +1,14 @@
 import type { App } from '@heroku/types/3.sdk';
 import type { ResourceCtx } from '../../../core/extend-resource.js';
+import type { CreateAndSetupInput, CreateAndSetupOptions } from './create-and-setup.js';
+import type { DiffAppsOptions } from './diff.js';
 import type { DescribeAppOptions } from './info.js';
+import type { TransferOptions } from './transfer.js';
 import type { WaitForACMCertificatesOptions } from './wait-for-acm-certificates.js';
+export { createAndSetup, type CreateAndSetupInput, type CreateAndSetupOptions, type SetupStep, } from './create-and-setup.js';
+export { diffApps, type DiffAppsOptions, type DiffRow } from './diff.js';
 export { type AppInfo, describeApp, type DescribeAppOptions, type PipelineCouplingDetail, } from './info.js';
+export { transferApp, type TransferOptions } from './transfer.js';
 export { waitForACMCertificates, type WaitForACMCertificatesOptions } from './wait-for-acm-certificates.js';
 export type AppMaintenanceOptions = {
     signal?: AbortSignal;
@@ -51,11 +57,14 @@ export declare function getProcessTier(ctx: {
     platform: AppInfoPlatform;
 }, appIdentity: string, options?: GetProcessTierOptions): Promise<ProcessTier | undefined>;
 export declare const appExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "app", {
+    createAndSetup: (input: CreateAndSetupInput, options?: CreateAndSetupOptions) => Promise<App>;
     describe: (appIdentity: string, options?: DescribeAppOptions) => Promise<import("./info.js").AppInfo>;
+    diff: (app1: string, app2: string, options?: DiffAppsOptions) => Promise<import("./diff.js").DiffRow[]>;
     disableMaintenance: (appIdentity: string, options?: AppMaintenanceOptions) => Promise<App>;
     enableMaintenance: (appIdentity: string, options?: AppMaintenanceOptions) => Promise<App>;
     getGeneration: (appIdentity: string, options?: GetGenerationOptions) => Promise<GenerationKind | undefined>;
     getProcessTier: (appIdentity: string, options?: GetProcessTierOptions) => Promise<ProcessTier | undefined>;
     isShielded: (appIdentity: string, options?: IsShieldedOptions) => Promise<boolean>;
+    transfer: (appIdentity: string, recipient: string, options?: TransferOptions) => Promise<import("@heroku/types/3.sdk").TeamApp | import("@heroku/types/3.sdk").AppTransfer>;
     waitForACMCertificates: (appIdentity: string, options?: WaitForACMCertificatesOptions) => Promise<import("@heroku/types/3.sdk").Domain[]>;
 }>;

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

@@ -1,7 +1,13 @@
 import { extendResource } from '../../../core/extend-resource.js';
+import { createAndSetup } from './create-and-setup.js';
+import { diffApps } from './diff.js';
 import { describeApp } from './info.js';
+import { transferApp } from './transfer.js';
 import { waitForACMCertificates } from './wait-for-acm-certificates.js';
+export { createAndSetup, } from './create-and-setup.js';
+export { diffApps } from './diff.js';
 export { describeApp, } from './info.js';
+export { transferApp } from './transfer.js';
 export { waitForACMCertificates } from './wait-for-acm-certificates.js';
 export async function enableMaintenance(ctx, appIdentity, options = {}) {
     options.signal?.throwIfAborted();
@@ -46,11 +52,14 @@ export async function getProcessTier(ctx, appIdentity, options = {}) {
     return app.process_tier;
 }
 export const appExtensions = extendResource('platform', 'app', ctx => ({
+    createAndSetup: (input, options) => createAndSetup(ctx, input, options),
     describe: (appIdentity, options) => describeApp(ctx, appIdentity, options),
+    diff: (app1, app2, options) => diffApps(ctx, app1, app2, options),
     disableMaintenance: (appIdentity, options) => disableMaintenance(ctx, appIdentity, options),
     enableMaintenance: (appIdentity, options) => enableMaintenance(ctx, appIdentity, options),
     getGeneration: (appIdentity, options) => getGeneration(ctx, appIdentity, options),
     getProcessTier: (appIdentity, options) => getProcessTier(ctx, appIdentity, options),
     isShielded: (appIdentity, options) => isShielded(ctx, appIdentity, options),
+    transfer: (appIdentity, recipient, options) => transferApp(ctx, appIdentity, recipient, options),
     waitForACMCertificates: (appIdentity, options) => waitForACMCertificates(ctx, appIdentity, options),
 }));

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

@@ -0,0 +1,23 @@
+import type { AppTransfer, TeamApp } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../../core/extend-resource.js';
+export type TransferOptions = {
+    personalToPersonal?: boolean;
+    signal?: AbortSignal;
+    silent?: boolean;
+};
+/**
+ * Transfer an app to another user or team.
+ *
+ * Route selection mirrors the platform's two transfer surfaces:
+ *   - personal-to-personal transfers go through `POST /account/app-transfers`
+ *     (`appTransfer.create`), which emails the recipient for acceptance
+ *     (response `state: 'pending'`).
+ *   - team-involved transfers go through `PATCH /teams/apps/{name}`
+ *     (`teamApp.transferToTeam` / `transferToAccount`), differing only by body.
+ *
+ * The caller (CLI) decides `personalToPersonal` and interprets the returned
+ * `state` for presentation. `personalToPersonal` defaults falsy → the team
+ * route, so a caller who forgets the flag on a genuine personal transfer
+ * silently hits the team path (a caller-owned footgun the SDK can't detect).
+ */
+export declare function transferApp(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string, recipient: string, options?: TransferOptions): Promise<AppTransfer | TeamApp>;

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

@@ -0,0 +1,35 @@
+/**
+ * Transfer an app to another user or team.
+ *
+ * Route selection mirrors the platform's two transfer surfaces:
+ *   - personal-to-personal transfers go through `POST /account/app-transfers`
+ *     (`appTransfer.create`), which emails the recipient for acceptance
+ *     (response `state: 'pending'`).
+ *   - team-involved transfers go through `PATCH /teams/apps/{name}`
+ *     (`teamApp.transferToTeam` / `transferToAccount`), differing only by body.
+ *
+ * The caller (CLI) decides `personalToPersonal` and interprets the returned
+ * `state` for presentation. `personalToPersonal` defaults falsy → the team
+ * route, so a caller who forgets the flag on a genuine personal transfer
+ * silently hits the team path (a caller-owned footgun the SDK can't detect).
+ */
+export async function transferApp(ctx, appIdentity, recipient, options = {}) {
+    options.signal?.throwIfAborted();
+    const platform = options.signal ? ctx.platform.withOptions({ signal: options.signal }) : ctx.platform;
+    if (options.personalToPersonal) {
+        const body = { app: appIdentity, recipient };
+        if (options.silent !== undefined)
+            body.silent = options.silent;
+        return platform.appTransfer.create(body);
+    }
+    // Team-involved (personalToPersonal=false): both routes are PATCH /teams/apps/{name}
+    // with body {owner}, differing only by semantics. Split by recipient shape: an
+    // email recipient transfers ownership to a personal ACCOUNT; anything else is a
+    // TEAM name. Both produce a byte-identical wire request to the legacy
+    // app-transfer.ts (a single PATCH with {owner: recipient}), so this is a
+    // spec-faithful split with no functional regression.
+    const looksLikeEmail = recipient.includes('@');
+    return looksLikeEmail
+        ? platform.teamApp.transferToAccount(appIdentity, { owner: recipient })
+        : platform.teamApp.transferToTeam(appIdentity, { owner: recipient });
+}

package/dist/resources/platform/container/ensure-container-stack.d.ts

@@ -2,14 +2,9 @@ import type { App } from '@heroku/types/3.sdk';
 import type { ResourceCtx } from '../../../core/extend-resource.js';
 import type { ContainerOptions } from './index.js';
 export declare class NotAContainerAppError extends Error {
-    readonly app: Pick<App, 'build_stack' | 'id' | 'name' | 'stack'>;
+    readonly app: App;
     readonly id = "not_a_container_app";
-    constructor(app: Pick<App, 'build_stack' | 'id' | 'name' | 'stack'>);
-    get body(): {
-        app: Pick<App, "stack" | "id" | "name" | "build_stack">;
-        id: string;
-        message: string;
-    };
+    constructor(app: App);
 }
 /**
  * Ensure that the given app is a container app.

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

@@ -6,9 +6,6 @@ export class NotAContainerAppError extends Error {
         this.app = app;
         this.name = 'NotAContainerAppError';
     }
-    get body() {
-        return { app: this.app, id: this.id, message: this.message };
-    }
 }
 /**
  * Ensure that the given app is a container app.
@@ -21,12 +18,6 @@ export async function ensureContainerStack(ctx, appIdentity, options = {}) {
     const app = await platform.app.info(appIdentity);
     const allowedStack = 'container';
     if (app.build_stack.name !== allowedStack && app.stack.name !== allowedStack) {
-        throw new NotAContainerAppError({
-            // eslint-disable-next-line camelcase
-            build_stack: app.build_stack,
-            id: app.id,
-            name: app.name,
-            stack: app.stack,
-        });
+        throw new NotAContainerAppError(app);
     }
 }

package/dist/resources/platform/domain/test-utils.js

@@ -16,8 +16,11 @@ export function buildCtx(stubs = {}) {
     };
     platform.withOptions.mockReturnValue(platform);
     return {
+        dashboardBackend: {},
         data: {},
+        metrics: {},
         platform: platform,
+        repositories: {},
     };
 }
 export function buildDomain(overrides = {}) {

package/dist/resources/platform/space/errors.d.ts

@@ -0,0 +1,28 @@
+import type { Space } from '@heroku/types/3.sdk';
+/**
+ * Thrown by `waitForAllocated` when the space settles into a terminal
+ * state other than `allocated` (e.g. `deleting`).
+ */
+export declare class SpaceNotAllocatedError extends Error {
+    readonly space: Space;
+    readonly id = "space_not_allocated";
+    constructor(space: Space);
+    get body(): {
+        id: string;
+        message: string;
+    };
+}
+/**
+ * Thrown by `waitForAllocated` when `timeoutMs` elapses while the space
+ * is still `allocating`.
+ */
+export declare class SpaceNotReadyError extends Error {
+    readonly space: Space;
+    readonly timeoutMs: number;
+    readonly id = "space_not_ready";
+    constructor(space: Space, timeoutMs: number);
+    get body(): {
+        id: string;
+        message: string;
+    };
+}

package/dist/resources/platform/space/errors.js

@@ -0,0 +1,34 @@
+/**
+ * Thrown by `waitForAllocated` when the space settles into a terminal
+ * state other than `allocated` (e.g. `deleting`).
+ */
+export class SpaceNotAllocatedError extends Error {
+    space;
+    id = 'space_not_allocated';
+    constructor(space) {
+        super(`The space ${space.name} did not become allocated, with state ${space.state}.`);
+        this.space = space;
+        this.name = 'SpaceNotAllocatedError';
+    }
+    get body() {
+        return { id: this.id, message: this.message };
+    }
+}
+/**
+ * Thrown by `waitForAllocated` when `timeoutMs` elapses while the space
+ * is still `allocating`.
+ */
+export class SpaceNotReadyError extends Error {
+    space;
+    timeoutMs;
+    id = 'space_not_ready';
+    constructor(space, timeoutMs) {
+        super(`Timeout waiting for space ${space.name} to become allocated.`);
+        this.space = space;
+        this.timeoutMs = timeoutMs;
+        this.name = 'SpaceNotReadyError';
+    }
+    get body() {
+        return { id: this.id, message: this.message };
+    }
+}

package/dist/resources/platform/space/index.d.ts

@@ -0,0 +1,7 @@
+import type { WaitForAllocatedOptions } from './types.js';
+export { SpaceNotAllocatedError, SpaceNotReadyError } from './errors.js';
+export type { SpaceOptions, WaitForAllocatedOptions } from './types.js';
+export { type SpaceWithNat, waitForAllocated } from './wait-for-allocated.js';
+export declare const spaceExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "space", {
+    waitForAllocated: (name: string, options?: WaitForAllocatedOptions) => Promise<import("./wait-for-allocated.js").SpaceWithNat>;
+}>;

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

@@ -0,0 +1,7 @@
+import { extendResource } from '../../../core/extend-resource.js';
+import { waitForAllocated } from './wait-for-allocated.js';
+export { SpaceNotAllocatedError, SpaceNotReadyError } from './errors.js';
+export { waitForAllocated } from './wait-for-allocated.js';
+export const spaceExtensions = extendResource('platform', 'space', ctx => ({
+    waitForAllocated: (name, options) => waitForAllocated(ctx, name, options),
+}));

package/dist/resources/platform/space/types.d.ts

@@ -0,0 +1,25 @@
+export type SpaceOptions = {
+    signal?: AbortSignal;
+};
+export type WaitForAllocatedOptions = SpaceOptions & {
+    /**
+     * When true, once the space reaches a terminal state, also fetches
+     * the space's NAT info (`spaceNat.info`) and attaches it as `nat` on
+     * the result.
+     *
+     * Fetching NAT info is soft-failure: if it rejects, `nat` is left
+     * `undefined` on the returned space rather than failing the whole
+     * wait.
+     */
+    includeNat?: boolean;
+    /**
+     * Delay between polls in milliseconds.
+     * Defaults to 5000 (5s)
+     */
+    intervalMs?: number;
+    /**
+     * Wall-clock budget in milliseconds before `SpaceNotReadyError`
+     * is thrown. Defaults to 1200000 (20 minutes)
+     */
+    timeoutMs?: number;
+};

package/dist/resources/platform/space/types.js

@@ -0,0 +1 @@
+export {};

package/dist/resources/platform/space/wait-for-allocated.d.ts

@@ -0,0 +1,29 @@
+import type { Space, SpaceNat } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../../core/extend-resource.js';
+import type { WaitForAllocatedOptions } from './types.js';
+export type SpaceWithNat = Space & {
+    /**
+     * The space's NAT info, attached when `options.includeNat` is set and
+     * the fetch succeeds. Left `undefined` if `includeNat` was not
+     * requested, or if the NAT fetch failed (soft-failure).
+     */
+    nat?: SpaceNat;
+};
+/**
+ * Poll `space.info` until the space's `state` is no longer `allocating`,
+ * then return it.
+ *
+ * If the terminal state is not `allocated` (e.g. `deleting`), throws
+ * `SpaceNotAllocatedError`. On exceeding `timeoutMs` without reaching a
+ * terminal state, throws `SpaceNotReadyError`.
+ *
+ * Each poll uses the SDK default `Accept: version=3.sdk` with
+ * `Accept-Expansion: region` to match the existing CLI behaviour.
+ *
+ * When `options.includeNat` is true and the space becomes allocated,
+ * also fetches `spaceNat.info` and attaches it as `nat` on the result.
+ * That fetch is soft-failure: if it rejects, `nat` is left `undefined`
+ * rather than failing the wait. A caller abort during the fetch is the
+ * exception — it is re-thrown rather than swallowed.
+ */
+export declare function waitForAllocated(ctx: Pick<ResourceCtx, 'platform'>, name: string, options?: WaitForAllocatedOptions): Promise<SpaceWithNat>;

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

@@ -0,0 +1,56 @@
+import { wait } from '../../../utils/wait.js';
+import { SpaceNotAllocatedError, SpaceNotReadyError } from './errors.js';
+const DEFAULT_INTERVAL_MS = 5000;
+const DEFAULT_TIMEOUT_MS = 20 * 60 * 1000;
+/**
+ * Poll `space.info` until the space's `state` is no longer `allocating`,
+ * then return it.
+ *
+ * If the terminal state is not `allocated` (e.g. `deleting`), throws
+ * `SpaceNotAllocatedError`. On exceeding `timeoutMs` without reaching a
+ * terminal state, throws `SpaceNotReadyError`.
+ *
+ * Each poll uses the SDK default `Accept: version=3.sdk` with
+ * `Accept-Expansion: region` to match the existing CLI behaviour.
+ *
+ * When `options.includeNat` is true and the space becomes allocated,
+ * also fetches `spaceNat.info` and attaches it as `nat` on the result.
+ * That fetch is soft-failure: if it rejects, `nat` is left `undefined`
+ * rather than failing the wait. A caller abort during the fetch is the
+ * exception — it is re-thrown rather than swallowed.
+ */
+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 deadline = Date.now() + timeoutMs;
+    let space = await platform.space.info(name);
+    while (space.state === 'allocating') {
+        signal?.throwIfAborted();
+        if (Date.now() >= deadline) {
+            throw new SpaceNotReadyError(space, timeoutMs);
+        }
+        await wait(intervalMs, signal);
+        space = await platform.space.info(name);
+    }
+    if (space.state !== 'allocated') {
+        throw new SpaceNotAllocatedError(space);
+    }
+    if (!includeNat) {
+        return space;
+    }
+    try {
+        const nat = await platform.spaceNat.info(name);
+        return { ...space, nat };
+    }
+    catch {
+        // Soft-failure: a rejected NAT fetch leaves `nat` undefined rather than
+        // failing the wait — but a caller abort must not be swallowed here, so
+        // re-throw it if the signal aborted during the fetch.
+        signal?.throwIfAborted();
+        return space;
+    }
+}

package/dist/resources/platform/vpn-connection/index.d.ts

@@ -0,0 +1,8 @@
+import { type WaitForActiveOptions } from './wait-for-active.js';
+export { VpnConnectionFailedError, VpnConnectionNotReadyError, waitForActive, type WaitForActiveOptions, } from './wait-for-active.js';
+export type VpnConnectionOptions = {
+    signal?: AbortSignal;
+};
+export declare const vpnConnectionExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "vpnConnection", {
+    waitForActive: (spaceIdentity: string, vpnConnectionIdentity: string, options?: WaitForActiveOptions) => Promise<import("@heroku/types/3.sdk").VpnConnection>;
+}>;

package/dist/resources/platform/vpn-connection/index.js

@@ -0,0 +1,6 @@
+import { extendResource } from '../../../core/extend-resource.js';
+import { waitForActive } from './wait-for-active.js';
+export { VpnConnectionFailedError, VpnConnectionNotReadyError, waitForActive, } from './wait-for-active.js';
+export const vpnConnectionExtensions = extendResource('platform', 'vpnConnection', ctx => ({
+    waitForActive: (spaceIdentity, vpnConnectionIdentity, options) => waitForActive(ctx, spaceIdentity, vpnConnectionIdentity, options),
+}));

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

@@ -0,0 +1,39 @@
+import type { VpnConnection } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../../core/extend-resource.js';
+import type { Poller } from '../../../utils/poller.js';
+import type { VpnConnectionOptions } from './index.js';
+export declare class VpnConnectionFailedError extends Error {
+    readonly id = "vpn_connection_failed";
+    constructor(vpnConnection: VpnConnection);
+}
+export declare class VpnConnectionNotReadyError extends Error {
+    readonly timeoutMs: number;
+    readonly id = "vpn_connection_not_ready";
+    constructor(vpnConnection: VpnConnection, timeoutMs: number);
+}
+export type WaitForActiveOptions = VpnConnectionOptions & {
+    /**
+     * Delay between polls in milliseconds.
+     * Defaults to 10000 (10s)
+     */
+    intervalMs?: number;
+    /**
+     * Fires `poller.onStart` immediately before polling begins
+     * and `poller.onStop` once the connection becomes active.
+     */
+    poller?: Poller<VpnConnection>;
+    /**
+     * Wall-clock budget in milliseconds before {@link VpnConnectionNotReadyError}
+     * is thrown. Defaults to 1200000 (20 minutes)
+     */
+    timeoutMs?: number;
+};
+/**
+ * Poll `vpnConnection.info` until the connection's `status` is `active`,
+ * then return it.
+ *
+ * If `status` becomes `failed`, throws {@link VpnConnectionFailedError}.
+ * On exceeding `timeoutMs` without reaching `active` or `failed`, throws
+ * {@link VpnConnectionNotReadyError}.
+ */
+export declare function waitForActive(ctx: Pick<ResourceCtx, 'platform'>, spaceIdentity: string, vpnConnectionIdentity: string, options?: WaitForActiveOptions): Promise<VpnConnection>;

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

@@ -0,0 +1,48 @@
+import { wait } from '../../../utils/wait.js';
+const DEFAULT_INTERVAL_MS = 10 * 1000;
+const DEFAULT_TIMEOUT_MS = 20 * 60 * 1000;
+export class VpnConnectionFailedError extends Error {
+    id = 'vpn_connection_failed';
+    constructor(vpnConnection) {
+        super(vpnConnection.status_message);
+        this.name = 'VpnConnectionFailedError';
+    }
+}
+export class VpnConnectionNotReadyError extends Error {
+    timeoutMs;
+    id = 'vpn_connection_not_ready';
+    constructor(vpnConnection, timeoutMs) {
+        super(`Timeout waiting for VPN connection ${vpnConnection.name} to become allocated.`);
+        this.timeoutMs = timeoutMs;
+        this.name = 'VpnConnectionNotReadyError';
+    }
+}
+/**
+ * Poll `vpnConnection.info` until the connection's `status` is `active`,
+ * then return it.
+ *
+ * If `status` becomes `failed`, throws {@link VpnConnectionFailedError}.
+ * On exceeding `timeoutMs` without reaching `active` or `failed`, throws
+ * {@link VpnConnectionNotReadyError}.
+ */
+export async function waitForActive(ctx, spaceIdentity, vpnConnectionIdentity, options = {}) {
+    const { intervalMs = DEFAULT_INTERVAL_MS, poller, signal, timeoutMs = DEFAULT_TIMEOUT_MS, } = options;
+    signal?.throwIfAborted();
+    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const deadline = Date.now() + timeoutMs;
+    let vpnConnection = await platform.vpnConnection.info(spaceIdentity, vpnConnectionIdentity);
+    poller?.onStart?.(vpnConnection);
+    while (vpnConnection.status !== 'active') {
+        signal?.throwIfAborted();
+        if (vpnConnection.status === 'failed') {
+            throw new VpnConnectionFailedError(vpnConnection);
+        }
+        if (Date.now() >= deadline) {
+            throw new VpnConnectionNotReadyError(vpnConnection, timeoutMs);
+        }
+        await wait(intervalMs, signal);
+        vpnConnection = await platform.vpnConnection.info(spaceIdentity, vpnConnectionIdentity);
+    }
+    poller?.onStop?.(vpnConnection);
+    return vpnConnection;
+}

package/dist/services/dashboard-backend.d.ts

@@ -0,0 +1,5 @@
+import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
+import type { HerokuClient } from '@heroku/types/dashboard-backend';
+import type { RoutesClientExtras } from '../core/create-client.js';
+export type DashboardBackendClient = HerokuClient & RoutesClientExtras<HerokuClient>;
+export declare function createDashboardBackendClient(options?: HerokuApiClientOptions): DashboardBackendClient;

package/dist/services/dashboard-backend.js

@@ -0,0 +1,10 @@
+import * as routes from '@heroku/types/dashboard-backend/routes';
+import { createClient } from '../core/create-client.js';
+export function createDashboardBackendClient(options = {}) {
+    const baseUrl = process.env.HEROKU_PARTICLEBOARD_URL;
+    return createClient(routes, {
+        service: 'particleboard',
+        ...(baseUrl && { baseUrl }),
+        ...options,
+    });
+}

package/dist/services/metrics.d.ts

@@ -0,0 +1,5 @@
+import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
+import type { HerokuClient } from '@heroku/types/metrics';
+import type { RoutesClientExtras } from '../core/create-client.js';
+export type MetricsClient = HerokuClient & RoutesClientExtras<HerokuClient>;
+export declare function createMetricsClient(options?: HerokuApiClientOptions): MetricsClient;

package/dist/services/metrics.js

@@ -0,0 +1,23 @@
+import * as routes from '@heroku/types/metrics/routes';
+import { createClient } from '../core/create-client.js';
+const DEFAULT_METRICS_BASE_URL = 'https://api.metrics.heroku.com';
+export function createMetricsClient(options = {}) {
+    const baseUrl = process.env.HEROKU_METRICS_HOST ?? DEFAULT_METRICS_BASE_URL;
+    // Metrics is a distinct host that heroku-fetch does not model as a first-class
+    // service, so we use `service: 'custom'` with an explicit base URL. Auth (bearer
+    // token) is resolved by heroku-fetch exactly as for platform/data — same
+    // HEROKU_API_KEY / netrc source, shared across services on one SDK instance.
+    //
+    // Unlike platform/data, `service: 'custom'` sends no default Accept header, so we
+    // set `application/vnd.heroku+json; version=3` explicitly to match what meetas
+    // expects — the same versioned vendor type platform/data get automatically via
+    // heroku-fetch's `defaultAccept`. A caller can still override it via `headers`:
+    // `...options` first, then an explicit `headers` key whose `...options.headers`
+    // spread lands AFTER the literal Accept, so caller headers win for any key they set.
+    return createClient(routes, {
+        baseUrl,
+        service: 'custom',
+        ...options,
+        headers: { Accept: 'application/vnd.heroku+json; version=3', ...options.headers },
+    });
+}

package/dist/services/platform.js

@@ -1,5 +1,19 @@
 import * as routes from '@heroku/types/3.sdk/routes';
 import { createClient } from '../core/create-client.js';
+/**
+ * The Platform API variant this client's routes and types are generated from
+ * (`@heroku/types/3.sdk`). Dispatch at the same variant so the wire matches the
+ * shipped types — otherwise `3.sdk`-only routes (e.g. `buildMetadata.info`) 404
+ * under heroku-fetch's shared `version=3` default, and fields the types describe
+ * in their `3.sdk` shape (e.g. `App.generation: string`) arrive in the older
+ * `version=3` shape. A caller can still override per request via `withHeaders`,
+ * or per client by passing their own `defaultAccept`.
+ */
+const PLATFORM_SDK_ACCEPT = 'application/vnd.heroku+json; version=3.sdk';
 export function createPlatformClient(options = {}) {
-    return createClient(routes, { service: 'platform', ...options });
+    return createClient(routes, {
+        defaultAccept: PLATFORM_SDK_ACCEPT,
+        service: 'platform',
+        ...options,
+    });
 }

package/dist/services/repositories.d.ts

@@ -0,0 +1,5 @@
+import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
+import type { HerokuClient } from '@heroku/types/repositories';
+import type { RoutesClientExtras } from '../core/create-client.js';
+export type RepositoriesClient = HerokuClient & RoutesClientExtras<HerokuClient>;
+export declare function createRepositoriesClient(options?: HerokuApiClientOptions): RepositoriesClient;

package/dist/services/repositories.js

@@ -0,0 +1,11 @@
+import * as routes from '@heroku/types/repositories/routes';
+import { createClient } from '../core/create-client.js';
+const DEFAULT_REPOSITORIES_BASE_URL = 'https://kolkrabbi.heroku.com';
+export function createRepositoriesClient(options = {}) {
+    const baseUrl = process.env.HEROKU_REPOSITORIES_HOST ?? DEFAULT_REPOSITORIES_BASE_URL;
+    return createClient(routes, {
+        baseUrl,
+        service: 'custom',
+        ...options,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heroku/sdk",
-  "version": "0.5.5",
+  "version": "0.6.0",
   "description": "Heroku SDK",
   "author": "Heroku",
   "type": "module",
@@ -18,6 +18,18 @@
       "types": "./dist/services/data.d.ts",
       "default": "./dist/services/data.js"
     },
+    "./dashboard-backend": {
+      "types": "./dist/services/dashboard-backend.d.ts",
+      "default": "./dist/services/dashboard-backend.js"
+    },
+    "./metrics": {
+      "types": "./dist/services/metrics.d.ts",
+      "default": "./dist/services/metrics.js"
+    },
+    "./repositories": {
+      "types": "./dist/services/repositories.d.ts",
+      "default": "./dist/services/repositories.js"
+    },
     "./extensions/platform": {
       "types": "./dist/resources/extensions/platform.d.ts",
       "default": "./dist/resources/extensions/platform.js"
@@ -34,6 +46,14 @@
       "types": "./dist/resources/platform/app/index.d.ts",
       "default": "./dist/resources/platform/app/index.js"
     },
+    "./resources/platform/container": {
+      "types": "./dist/resources/platform/container/index.d.ts",
+      "default": "./dist/resources/platform/container/index.js"
+    },
+    "./resources/platform/domain": {
+      "types": "./dist/resources/platform/domain/index.d.ts",
+      "default": "./dist/resources/platform/domain/index.js"
+    },
     "./resources/platform/dyno": {
       "types": "./dist/resources/platform/dyno/index.d.ts",
       "default": "./dist/resources/platform/dyno/index.js"
@@ -50,10 +70,22 @@
       "types": "./dist/resources/platform/pipeline/*.d.ts",
       "default": "./dist/resources/platform/pipeline/*.js"
     },
+    "./resources/platform/sni-endpoint": {
+      "types": "./dist/resources/platform/sni-endpoint/index.d.ts",
+      "default": "./dist/resources/platform/sni-endpoint/index.js"
+    },
+    "./resources/platform/telemetry-drain": {
+      "types": "./dist/resources/platform/telemetry-drain/index.d.ts",
+      "default": "./dist/resources/platform/telemetry-drain/index.js"
+    },
     "./resources/platform/test-run": {
       "types": "./dist/resources/platform/test-run/index.d.ts",
       "default": "./dist/resources/platform/test-run/index.js"
     },
+    "./resources/platform/vpn-connection": {
+      "types": "./dist/resources/platform/vpn-connection/index.d.ts",
+      "default": "./dist/resources/platform/vpn-connection/index.js"
+    },
     "./resources/data/redis": {
       "types": "./dist/resources/data/redis/index.d.ts",
       "default": "./dist/resources/data/redis/index.js"
@@ -99,8 +131,8 @@
     "vitest": "^4.1.4"
   },
   "dependencies": {
-    "@heroku/heroku-fetch": "^0.1.3",
-    "@heroku/types": "^4.0.1",
+    "@heroku/heroku-fetch": "^0.1.4",
+    "@heroku/types": "^4.3.0",
     "debug": "^4.4.0"
   }
 }