@pipelex/sdk 0.59.0 → 0.61.0

package/dist/client.js

@@ -582,7 +582,8 @@ export class PipelexApiClient {
      * `url` is a fully resolved absolute URL. `mayStartRun` marks a request that may create a run,
      * whose errors then say whether it may have (see `RunCreation`).
      * `idempotencyKey`, already checked by `idempotencyKeyOf`, is sent as the
-     * `Idempotency-Key` header; only `start` and `copyMethod` pass one.
+     * `Idempotency-Key` header; only `start`, `copyMethod`, `rotateWebhookSecret` and
+     * `replayRunWebhookDelivery` pass one.
      */
     async requestRaw(method, url, options = {}) {
         const hasBody = options.body !== undefined;
@@ -1304,10 +1305,10 @@ export class PipelexApiClient {
      *
      * The mapping is what makes their no-verdict arms usable: a crate route answers `422`
      * for a request it cannot act on (a pipe selection `pipe-io` refuses; an unknown
-     * `kind`/`target`, or a `pipe_ref` on the concept-set-wide `types` kind, on `codegen`)
-     * and `501` for the reserved registry-form `method_ref` (the address form is resolved
-     * server-side as of pipelex-api 0.21.0). A caller branches on `ApiResponseError.status`,
-     * never on a message.
+     * `kind`/`target`, or a `pipe_ref` on the concept-set-wide `types` kind, on `codegen`;
+     * the reserved registry-form `method_ref`, coded `request.unsupported`, on all three, the
+     * address form being resolved server-side as of pipelex-api 0.21.0). A caller branches on
+     * the problem's `code`, never on a message.
      *
      * All of these are static and inference-free, so they default to the management-call
      * timeout. The internal raise is `crateRequestTimeoutMs`'s: the fetch-sized budget a
@@ -1429,9 +1430,8 @@ export class PipelexApiClient {
     // unexposed — see their section above for why that blocks nothing. `pipe-io` is
     // newer: a runner serves it from `pipelex-api` v0.33.0, and codes its selection
     // refusals `request.pipe_not_found`, `request.pipe_unspecified` and
-    // `request.pipe_ambiguous`, and a hosted origin
-    // serves it once the platform's proxy and the gateway list it (see
-    // `docs/crate-routes.md`).
+    // `request.pipe_ambiguous` from v0.90.0; the dev plane serves it too, measured on
+    // api-dev.pipelex.com on 2026-10-31 (see `docs/crate-routes.md`).
     //
     // All three are STATIC routes (no dry-run sweep), so like every static sibling they
     // take no `timeoutMs` — see the policy note on `requestExtension` before adding one
@@ -1460,7 +1460,7 @@ export class PipelexApiClient {
      * protocol's `files` map or as a `directory`, `tree` or `contents` the client sends
      * inline when small and by hash otherwise (see {@link CrateRequestBase}); an
      * address-form `method_ref` (server-resolved, pipelex-api >= 0.21.0; the registry form
-     * stays a `501`); or a hosted `method_id` (platform-resolved — see
+     * is a `422` `request.unsupported`); or a hosted `method_id` (platform-resolved — see
      * {@link PipelexHostedToolingExtensions}). An empty map or string is absent.
      *
      * `options.signal` stops the call between the steps a `directory`, `tree` or `contents`
@@ -1487,7 +1487,8 @@ export class PipelexApiClient {
      * Same 200-verdict discipline and same three-form closure selector as
      * {@link resolve}. Only a no-verdict condition throws `ApiResponseError`: an
      * unknown `kind`/`target`, a `pipe_ref` on the concept-set-wide `types` kind, or
-     * a malformed selector is a 422; a registry-form `method_ref` is a `501`.
+     * a malformed selector is a 422, and so is a registry-form `method_ref`, coded
+     * `request.unsupported`.
      */
     async codegen(request, options = {}) {
         return this.crateRequest("codegen", "codegen", request, options);
@@ -1520,9 +1521,9 @@ export class PipelexApiClient {
      * Only a no-verdict condition throws `ApiResponseError`: a malformed selector and an
      * over-limit file are `422` problems; a selection the route refuses is a `422` whose
      * `code` is `request.pipe_not_found` (an unknown `pipe_ref`), `request.pipe_unspecified`
-     * (no entry pipe) or `request.pipe_ambiguous` (an ambiguous code, several entry pipes), the
-     * candidates in its `params`; a registry-form `method_ref` is a `501`; a pipe whose
-     * artifacts cannot be derived is a `500`.
+     * (no entry pipe, or several bundles' `main_pipe` declarations) or `request.pipe_ambiguous`
+     * (an ambiguous bare code), the candidates in its `params`; a registry-form `method_ref` is a
+     * `422` `request.unsupported`; a pipe whose artifacts cannot be derived is a `500`.
      *
      * A `method_ref` gets the fetch-sized budget, as on the other crate routes. On the
      * hosted API the gateway caps a request at about 30 seconds whatever the client allows,
@@ -1934,7 +1935,84 @@ export class PipelexApiClient {
         yield* followCursor("listMethods", (cursor) => this.listMethods({ ...query, cursor }));
     }
     /**
-     * Read one method with its draft's files — `GET /v1/methods/{id}`: its identity, its draft
+     * One page of the template catalog — `GET /v1/method-templates`: the public methods of the
+     * organization the deployment names as its templates organization, the same for every caller.
+     *
+     * The templates the ordering lists lead, in its order, and every other template follows by name.
+     * `ordering` names the ordering to serve, such as `default` or an arm of a test; an absent,
+     * unknown or malformed name serves `default`, and the page's `ordering` names the one served,
+     * `null` when there is none. `category` keeps one category's templates, by slug, in the same
+     * order; an unknown slug keeps none. Whatever the filter, the page's `categories` names, with its
+     * label, every category at least one template shows, in the catalog's order, so no tab drawn
+     * from it is ever empty.
+     *
+     * Each `MethodTemplate` carries the method's id and name, its latest published version's number,
+     * description and categories, its organization's display name and each thumbnail with its size
+     * and a link to its bytes valid for about fifteen minutes. A template reads, runs and copies by
+     * its `method_id`, as another organization's public method does (`getMethod`, `copyMethod`).
+     *
+     * Pass the page's `nextCursor` back as `cursor` with the same `ordering` and `category`, which the
+     * cursor does not hold; `null` is the last page. `iterateMethodTemplates` follows it for you.
+     *
+     * Throws `ApiResponseError`: `422` `request.invalid` for a `limit` outside 1 to 200 or a cursor of
+     * another listing, `422` `request.malformed` for a cursor that does not decode, `500`
+     * `runtime.misconfigured` when the templates organization the deployment names has no record or
+     * a link cannot be signed, and `503` `runtime.unavailable`, safe to retry. A page whose `items`
+     * or `categories` is not an array, whose `next_cursor` or `ordering` is neither a string nor
+     * `null`, a template lacking a member a card is drawn from (a string `method_id`, `name` and
+     * `organization_name`, a `description` that is a string or `null`, a positive integer
+     * `latest_version`, an array of string `categories`, and `thumbnails` each with a string `path`,
+     * `media_type`, `sha256`, `url` and `expires_at` and a positive integer `width` and `height`), and a
+     * category without a string `slug` and `label` are an answer the SDK cannot read, thrown as an
+     * `ApiResponseError` too, its links redacted.
+     */
+    async listMethodTemplates(query = {}) {
+        const search = productQuery({
+            ordering: query.ordering,
+            category: query.category,
+            limit: query.limit,
+            cursor: query.cursor,
+        });
+        const endpoint = `method-templates${search}`;
+        const res = withLinks(await this.requestProductAnswer("GET", endpoint, undefined));
+        const page = this.readObjectAnswer("GET", endpoint, res);
+        const { items, next_cursor: nextCursor, ordering, categories } = page;
+        let fault = null;
+        if (!Array.isArray(items))
+            fault = "`items` is not an array";
+        else if (nextCursor !== null && typeof nextCursor !== "string") {
+            fault = "`next_cursor` is neither a string nor null";
+        }
+        else if (ordering !== null && typeof ordering !== "string") {
+            fault = "`ordering` is neither a string nor null";
+        }
+        else if (!Array.isArray(categories))
+            fault = "`categories` is not an array";
+        else
+            fault = methodTemplatesFault(items) ?? methodCategoriesFault(categories);
+        if (fault !== null) {
+            throw this.unreadableAnswer("GET", `/${API_PREFIX}/${endpoint}`, res, `a page of templates whose ${fault}`);
+        }
+        return {
+            items: items,
+            nextCursor: nextCursor,
+            ordering: ordering,
+            categories: categories,
+        };
+    }
+    /**
+     * Every template of the catalog, in the order served — follows `listMethodTemplates`'s cursor
+     * for you, with the same `ordering` and `category` on every page. It stops on a `null` cursor or
+     * on a cursor the server failed to advance, and throws `PagingNotTerminatingError` past a page
+     * ceiling no real catalog reaches. The ordering served and the categories are on each page, so
+     * read one page with `listMethodTemplates` when you need them.
+     */
+    async *iterateMethodTemplates(query = {}) {
+        yield* followCursor("listMethodTemplates", (cursor) => this.listMethodTemplates({ ...query, cursor }));
+    }
+    /**
+     * Read one method with its files — `GET /v1/methods/{id}`. One of the caller's organization's
+     * methods answers a `MethodDetail`: its identity, its draft
      * (`files`, `input_data`) with the draft's token (`updated_at`) and digest (`draft_digest`),
      * and its latest published version's summary (`latest_version`, `latest_published`), whatever
      * the publish state. A method never published reads with both `null`, never as an error.
@@ -1942,6 +2020,11 @@ export class PipelexApiClient {
      * link to its bytes valid for about fifteen minutes, and is empty for an empty draft;
      * `writeMethodTree` brings the tree to disk.
      *
+     * **Another organization's public method reads too, in a narrower shape**, a
+     * `PublicMethodDetail`: its latest published version, that version's description, categories
+     * and files, and nothing of its draft or of the owner's people, so no `updated_at` to write or
+     * publish with. Narrow the answer with `"updated_at" in method` before reading the draft.
+     *
      * Takes a bare catalog id: the method routes address the method itself, never a version of
      * it. A caller holding `mt_…@3` strips the suffix with `parseMethodSelector` and reads that
      * version with `getMethodVersion`. Every method route throws `RequestArgumentError` for a
@@ -1949,16 +2032,26 @@ export class PipelexApiClient {
      * and for an id that is empty, `.` or `..`, which the URL would resolve into another route's
      * path.
      *
-     * Throws `ApiResponseError`: `404` `pipelex.catalog.not_found` for an unknown or foreign-org
-     * method, `409` `pipelex.catalog.being_deleted` while its erasure runs, and a `500`
-     * `runtime.unexpected` for a method whose draft names a tree the platform holds no record of. An
-     * answer whose `files` is not a listing is an answer the SDK cannot read, thrown as an
-     * `ApiResponseError` too.
+     * Throws `ApiResponseError`: `404` `pipelex.catalog.not_found` for an unknown method, for
+     * another organization's internal one, and for a public one made internal again or being
+     * erased; `409` `pipelex.catalog.being_deleted` while the erasure of the caller's own method
+     * runs; and a `500` `runtime.unexpected` for a method whose tree the platform holds no record
+     * of. An answer whose `files` is not a listing is an answer the SDK cannot read, thrown as an
+     * `ApiResponseError` too, its links redacted, and so is one that lacks `updated_at` while it
+     * carries a member only the owner's read has (`draft_digest`, `created_by_user_id`,
+     * `input_data`, `pipe_output`, `copied_from`, `deletion_state`), which would otherwise pass for
+     * another organization's public method, and a public read without an integer `latest_version`
+     * and a `latest_published` object.
      */
     async getMethod(methodId) {
         const endpoint = methodPath(methodId, "getMethod");
-        const res = await this.requestProductAnswer("GET", endpoint, undefined);
-        return this.readSavedTree("GET", endpoint, withLinks(res), "a stored method");
+        const res = withLinks(await this.requestProductAnswer("GET", endpoint, undefined));
+        const method = this.readSavedTree("GET", endpoint, res, "a stored method");
+        const fault = methodReadFault(method);
+        if (fault !== null) {
+            throw this.unreadableAnswer("GET", `/${API_PREFIX}/${endpoint}`, res, `a stored method ${fault}`);
+        }
+        return method;
     }
     /**
      * Create a method — `POST /v1/methods`. The new method holds its tree as its draft and has no
@@ -2398,9 +2491,12 @@ export class PipelexApiClient {
      *
      * The answer is a `MethodPublishResult` discriminated on `outcome` — branch on it:
      * `published` with the new `version`; `unchanged` with the existing latest `version`;
-     * `refused` with a `reason` (`invalid`, or `not_runnable` for a draft that validates with
-     * pending signatures), a `message` and the runner's `validation` verdict, whose problem items
-     * are read member by member as `validate` reads them. Every arm carries the `method`. A publish
+     * `refused` with a `reason`, a `message` and the runner's `validation` verdict, whose problem
+     * items are read member by member as `validate` reads them. The reason is `invalid`, or
+     * `not_runnable` for a draft that validates with pending signatures, and for a public method
+     * also `thumbnail_missing`, `thumbnail_invalid` or `storage_reference` (see
+     * `MethodPublishRefusalReason`); a reason this SDK does not know is passed through as its raw
+     * string, still a verdict, so show its `message`. Every arm carries the `method`. A publish
      * moves no token.
      *
      * Takes a bare catalog id, as `getMethod` does. Throws `RequestArgumentError` when
@@ -2415,11 +2511,14 @@ export class PipelexApiClient {
      * cannot be reached, answers unusably or does not finish within the platform's deadline is a
      * `502` or a `503` with nothing written, so a retry is safe; a runner that refuses the request
      * itself is relayed under its own status. A retry of a publish that landed while its answer was
-     * lost, as on a client timeout, answers `unchanged` with the version it wrote.
+     * lost, as on a client timeout, answers `unchanged` with the version it wrote. A method made
+     * public while its publish ran is a `503` with nothing written, safe to retry, which a retry
+     * judges as a public method's publish.
      *
      * An answer whose `outcome` is not one of the outcomes above, that carries no `method` object,
-     * or a refusal whose `validation` is not a verdict object with a boolean `is_valid`, is an answer
-     * the SDK cannot read, thrown as an `ApiResponseError` too.
+     * or a refusal whose `reason` or `message` is not a string or whose `validation` is not a verdict
+     * object with a boolean `is_valid`, is an answer the SDK cannot read, thrown as an
+     * `ApiResponseError` too.
      */
     async publishMethod(methodId, input) {
         const token = input
@@ -2444,8 +2543,16 @@ export class PipelexApiClient {
         // The refused arm carries the runner's verdict, whose problem items are read member by
         // member as `validate` reads them, so one malformed item never costs the caller the others.
         const validation = answer.validation;
-        if (!isPlainObject(validation) || typeof validation.is_valid !== "boolean") {
-            throw this.unreadableAnswer("POST", `/${API_PREFIX}/${endpoint}`, res, "a publish result whose `validation` is not an object");
+        let fault = null;
+        if (typeof answer.reason !== "string")
+            fault = "`reason` is not a string";
+        else if (typeof answer.message !== "string")
+            fault = "`message` is not a string";
+        else if (!isPlainObject(validation) || typeof validation.is_valid !== "boolean") {
+            fault = "`validation` is not an object";
+        }
+        if (fault !== null) {
+            throw this.unreadableAnswer("POST", `/${API_PREFIX}/${endpoint}`, res, `a publish result whose ${fault}`);
         }
         return {
             ...answer,
@@ -2460,11 +2567,13 @@ export class PipelexApiClient {
      *
      * Pass the page's `nextCursor` back as `cursor` to continue; `null` is the last page. A page
      * may be short while `nextCursor` is set, because the platform reads versions whole. A method
-     * never published answers an empty page.
+     * never published answers an empty page. Another organization's public method lists its
+     * versions too, each without its `published_by`.
      *
      * Takes a bare catalog id, as `getMethod` does. Throws `ApiResponseError`: `404`
-     * `pipelex.catalog.not_found` for an unknown method, `409` `pipelex.catalog.being_deleted`, and
-     * `422` `request.invalid` for a cursor the listing did not issue for this method or a `limit`
+     * `pipelex.catalog.not_found` for an unknown method and for another organization's internal
+     * one, `409` `pipelex.catalog.being_deleted` while the erasure of the caller's own method runs,
+     * and `422` `request.invalid` for a cursor the listing did not issue for this method or a `limit`
      * outside 1 to 100. A page whose `items` is not an array or whose `next_cursor` is neither a
      * string nor `null` is an answer the SDK cannot read, thrown as an `ApiResponseError` too.
      */
@@ -2476,12 +2585,15 @@ export class PipelexApiClient {
     /**
      * One published version of a method, with its files — `GET /v1/methods/{id}/versions/{n}`.
      * `files` lists the version's tree as `getMethod` lists the draft's, each file with a link to
-     * its bytes valid for about fifteen minutes, which `writeMethodTree` writes to disk.
+     * its bytes valid for about fifteen minutes, which `writeMethodTree` writes to disk. Another
+     * organization's public method reads its versions too, without their `published_by`, the files
+     * linked in the organization that holds it.
      *
      * Takes a bare catalog id, as `getMethod` does, and the version number. Throws
      * `RequestArgumentError` for a `version` that is not a positive integer, before any request.
      * Throws `ApiResponseError`: `404` `pipelex.catalog.not_found` for a version the method never
-     * published and for an unknown method, `409` `pipelex.catalog.being_deleted`, and `500`
+     * published, for an unknown method and for another organization's internal one, `409`
+     * `pipelex.catalog.being_deleted` while the erasure of the caller's own method runs, and `500`
      * `runtime.unexpected` for a version stored before methods were trees and never rewritten as
      * one, which names no tree to serve.
      */
@@ -2505,10 +2617,16 @@ export class PipelexApiClient {
      * original stays as it was. The copy takes the draft, never the latest published version; with
      * `expected_draft_updated_at`, it takes exactly the draft the caller last saw.
      *
+     * **Another organization's public method copies too**, a template of the catalog among them,
+     * from its latest published version rather than its draft: that version's tree, description and
+     * categories, and the method's examples, never the owner's form inputs, with `copied_from`
+     * naming the `version`. Leave `expected_draft_updated_at` out then: sent with such a method, it
+     * is refused with a `422` `request.invalid` naming it.
+     *
      * The answer is a `MethodCopyResult` discriminated on `outcome` — branch on it: `copied` with
      * the copy as `method`, `examples_copied` and `stored_files_copied`; `refused` with the
      * `reason` `bundle_names_other_storage`, a `message` and every `references` entry (`{ path, uri
-     * }`) a `.mthds` file of the draft holds that the destination cannot read and, in a duplicate,
+     * }`) a `.mthds` file of the tree holds that the destination cannot read and, in a duplicate,
      * that names a file under the original's run files, which erasing the original would remove,
      * nothing written.
      *
@@ -2527,7 +2645,8 @@ export class PipelexApiClient {
      * that is not from a web session, or for a role that may not change methods, in the method's
      * organization or in the destination; `404` `pipelex.org.not_found` for a destination the
      * caller does not belong to, still being set up or unknown, alike; `404`
-     * `pipelex.catalog.not_found` for an unknown method; `409` `pipelex.catalog.being_deleted`;
+     * `pipelex.catalog.not_found` for an unknown method and for another organization's internal
+     * one; `409` `pipelex.catalog.being_deleted` while the erasure of the caller's own method runs;
      * `409` `pipelex.catalog.update_conflict` for a draft that moved since
      * `expected_draft_updated_at`; a `409` whose `domain` is `runtime` and `retry` `no`, for a
      * draft whose tree the method's organization holds no record of or no longer holds every file
@@ -2591,30 +2710,6 @@ export class PipelexApiClient {
         }
         return answer;
     }
-    /**
-     * One page of the copies made of a method, in the order of the copies' ids, which says nothing
-     * of when each was made — `GET /v1/methods/{id}/copies`.
-     *
-     * Each row is the `MethodCopyMarker` the original keeps of a copy: the copy's id, the
-     * destination's id, the member who made it and when. The destination is named by its id alone,
-     * never its name, so a surface shows a destination's name only from the reader's own
-     * memberships, and a copy in an organization the reader does not belong to stays a bare id. A
-     * marker stays when its copy is erased, and the copy then reads as not found. Pass the page's
-     * `nextCursor` back as `cursor` to continue; `null` is the last page. A method never copied,
-     * and a copy itself, answer an empty page. The listing is open to every member of the method's
-     * organization, a runner included, as every read of a method is.
-     *
-     * Takes a bare catalog id, as `getMethod` does. Throws `ApiResponseError`: `404`
-     * `pipelex.catalog.not_found` for an unknown method, `409` `pipelex.catalog.being_deleted`, and
-     * `422` `request.invalid` for a cursor the listing did not issue for this method or a `limit`
-     * outside 1 to 100. A page whose `items` is not an array or whose `next_cursor` is neither a
-     * string nor `null` is an answer the SDK cannot read, thrown as an `ApiResponseError` too.
-     */
-    async listMethodCopies(methodId, query = {}) {
-        const search = productQuery({ limit: query.limit, cursor: query.cursor });
-        const endpoint = `${methodPath(methodId, "listMethodCopies")}/copies`;
-        return this.requestPage(`${endpoint}${search}`);
-    }
     /**
      * Erase a method and everything it produced — `DELETE /v1/methods/{id}`.
      *
@@ -3729,9 +3824,13 @@ export class PipelexApiClient {
         return list;
     }
     /**
-     * One delivery of a run's webhooks, with its event as sent —
-     * `GET /v1/runs/{id}/webhook-deliveries/{delivery_id}`: the body of its latest attempt, which a
-     * receiver's log can be matched against byte for byte once written as compact JSON.
+     * One delivery of a run's webhooks, with its event —
+     * `GET /v1/runs/{id}/webhook-deliveries/{delivery_id}`: the body its latest attempt sent, or,
+     * before any attempt, the body its first attempt will send. Every attempt and replay of the
+     * delivery sends that body, only its `attempt` changing, so the event matches what a receiver
+     * logged only once an attempt was made: it then equals, as JSON, the body that attempt brought
+     * the receiver. Compare the two as parsed JSON values, never as text: the read promises the same
+     * value, not the same bytes.
      * `deliveryId` is the delivery's `delivery_id`, the receiver's `webhook-id`.
      *
      * Throws `RequestArgumentError` for an id that is empty, `.` or `..`, or holds a lone surrogate,
@@ -3754,20 +3853,34 @@ export class PipelexApiClient {
      * can read the run asks for one, an API key included, under the organization's replay rate.
      *
      * Answers the attempt number the replay is sent under; a replay asked again before it is sent is
-     * that same attempt. Throws `RequestArgumentError` for an id that is empty, `.` or `..`, or holds
-     * a lone surrogate, before any request. Throws `ApiResponseError`: `404` `run.not_found` for a
-     * run the caller cannot read; `422` `request.invalid` naming `delivery_id` for a delivery the run
-     * does not have; `409` `pipelex.org.not_manageable` with the reason `webhook_delivery_pending`
-     * for a delivery still on its retry schedule, or `webhook_delivery_attempts_exhausted` for one
-     * holding the most attempts a delivery holds; `429` `account.rate_limited`, with its
-     * `retry_after`, past the organization's replay rate; and a `500` or `503` when the replay could
-     * not be queued, which then counts nothing against the rate.
+     * that same attempt.
+     *
+     * `options.idempotencyKey` is sent as the `Idempotency-Key` header, and nothing is sent when it
+     * is absent or `null`. The platform stores the replay's answer under the key, so the same replay
+     * sent again under the same key, as after an answer lost to a time limit, gets the stored answer,
+     * naming the same attempt, and the delivery is not sent twice. A key reused for another request
+     * is refused `409` `request.idempotency_conflict`, and one whose earlier request is still being
+     * handled `409` `request.idempotency_key_in_use`, whose `retry` is `yes`: send it again under the
+     * same key after its `retry_after`. See `WebhookReplayOptions`.
+     *
+     * Throws `RequestArgumentError` for an id that is empty, `.` or `..`, or holds a lone surrogate,
+     * or for an idempotency key that is not 1 to 255 visible ASCII characters, before any request.
+     * Throws `ApiResponseError`: `404` `run.not_found` for a run the caller cannot read; `422`
+     * `request.invalid` naming `delivery_id` for a delivery the run does not have; `409`
+     * `pipelex.org.not_manageable` with the reason `webhook_delivery_pending` for a delivery still on
+     * its retry schedule, or `webhook_delivery_attempts_exhausted` for one holding the most attempts
+     * a delivery holds; `429` `account.rate_limited`, with its `retry_after`, past the
+     * organization's replay rate; and a `500` or `503` when the replay could not be queued, which
+     * then counts nothing against the rate.
      */
-    async replayRunWebhookDelivery(runId, deliveryId) {
+    async replayRunWebhookDelivery(runId, deliveryId, options = {}) {
         const call = "replayRunWebhookDelivery";
         const run = idPathSegment(runId, call, RUN_ID_ARGUMENT);
         const delivery = idPathSegment(deliveryId, call, DELIVERY_ID_ARGUMENT);
-        return this.requestProductObject("POST", `runs/${run}/webhook-deliveries/${delivery}/replay`);
+        const endpoint = `runs/${run}/webhook-deliveries/${delivery}/replay`;
+        const idempotencyKey = idempotencyKeyOf(options, "replay the delivery");
+        const res = await this.requestProductAnswer("POST", endpoint, undefined, { idempotencyKey });
+        return this.readObjectAnswer("POST", endpoint, res);
     }
     /** Patch a run's status (admin/manual) — `PUT /v1/runs/{id}`. */
     async updateRun(runId, input) {
@@ -4236,9 +4349,9 @@ function nonEmptyString(value) {
 /** The request header the hosted API reads a request's idempotency key from. */
 const IDEMPOTENCY_KEY_HEADER = "Idempotency-Key";
 /**
- * The longest idempotency key a start sends. It is room for any generated key, and keeps the
+ * The longest idempotency key a request sends. It is room for any generated key, and keeps the
  * hosted API's stored record of the key far inside its store's limit, which a longer key could
- * exceed, so that the start would run without the protection the key was sent for.
+ * exceed, so that the request would run without the protection the key was sent for.
  */
 const MAX_IDEMPOTENCY_KEY_LENGTH = 255;
 /**
@@ -4248,13 +4361,14 @@ const MAX_IDEMPOTENCY_KEY_LENGTH = 255;
  */
 const VISIBLE_ASCII = /^[\x21-\x7E]+$/;
 /**
- * The idempotency key a start or a method copy sends, or `undefined` when the options carry none
- * (absent or `null`). A key that is not a string of 1 to 255 visible ASCII characters is refused
- * with a `RequestArgumentError` rather than dropped, an empty one included, since a request sent
- * without the key its caller gave would lose the protection the caller asked for without a word.
- * `request` says what the request does, as the refusal's last sentence names it ("start the run",
- * "copy the method"). The message never quotes the key, which a caller may derive from something
- * private. The Python SDK holds a key to the same rule, in the same words.
+ * The idempotency key a start, a method copy, a secret rotation or a delivery replay sends, or
+ * `undefined` when the options carry none (absent or `null`). A key that is not a string of 1 to
+ * 255 visible ASCII characters is refused with a `RequestArgumentError` rather than dropped, an
+ * empty one included, since a request sent without the key its caller gave would lose the
+ * protection the caller asked for without a word. `request` says what the request does, as the
+ * refusal's last sentence names it ("start the run", "copy the method", "rotate the secret",
+ * "replay the delivery"). The message never quotes the key, which a caller may derive from
+ * something private. The Python SDK holds a key to the same rule, in the same words.
  */
 function idempotencyKeyOf(options, request = "start the run") {
     const key = options.idempotencyKey;
@@ -4391,6 +4505,106 @@ function savedFilesFault(files) {
     }
     return null;
 }
+/** The members only the owner's read of a method carries, never another organization's. */
+const OWNER_ONLY_METHOD_MEMBERS = [
+    "draft_digest",
+    "created_by_user_id",
+    "input_data",
+    "pipe_output",
+    "copied_from",
+    "deletion_state",
+];
+/**
+ * Why a method read is not one the SDK reads, or `null` when it is. The owner's read carries the
+ * draft's token, `updated_at`, which is what tells it from another organization's public method;
+ * so an answer without the token that still carries a member only the owner's read has is a
+ * damaged owner read rather than a public one, and a public read must carry the latest published
+ * version it is about.
+ */
+function methodReadFault(method) {
+    if ("updated_at" in method)
+        return null;
+    const ownerMember = OWNER_ONLY_METHOD_MEMBERS.find((member) => member in method);
+    if (ownerMember !== undefined) {
+        return `without \`updated_at\` that carries the owner's \`${ownerMember}\``;
+    }
+    if (!isPositiveInteger(method.latest_version)) {
+        return "read as another organization's public method whose `latest_version` is not a positive integer";
+    }
+    if (!isPlainObject(method.latest_published)) {
+        return "read as another organization's public method whose `latest_published` is not an object";
+    }
+    return null;
+}
+function isPositiveInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+/**
+ * Why the catalog's templates are not ones the SDK reads, or `null` when they are: each an object
+ * with what a card is drawn from, a string `method_id`, `name` and `organization_name`, a
+ * `description` that is a string or `null`, a positive integer `latest_version`, an array of string `categories`, and `thumbnails`, each with
+ * a string `path`, `media_type`, `sha256`, `url` and `expires_at` and a positive integer `width`
+ * and `height`.
+ */
+function methodTemplatesFault(items) {
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        if (!isPlainObject(item))
+            return `\`items\` holds an entry that is not an object, at [${index}]`;
+        for (const member of ["method_id", "name", "organization_name"]) {
+            if (typeof item[member] !== "string") {
+                return `\`items\` holds a template whose \`${member}\` is not a string, at [${index}]`;
+            }
+        }
+        if (item.description !== null &&
+            item.description !== undefined &&
+            typeof item.description !== "string") {
+            return `\`items\` holds a template whose \`description\` is neither a string nor null, at [${index}]`;
+        }
+        if (!isPositiveInteger(item.latest_version)) {
+            return `\`items\` holds a template whose \`latest_version\` is not a positive integer, at [${index}]`;
+        }
+        if (!isStringArray(item.categories)) {
+            return `\`items\` holds a template whose \`categories\` is not an array of strings, at [${index}]`;
+        }
+        const thumbnails = item.thumbnails;
+        if (!Array.isArray(thumbnails)) {
+            return `\`items\` holds a template whose \`thumbnails\` is not an array, at [${index}]`;
+        }
+        for (let position = 0; position < thumbnails.length; position += 1) {
+            const thumbnail = thumbnails[position];
+            const where = `at [${index}].thumbnails[${position}]`;
+            if (!isPlainObject(thumbnail))
+                return `\`items\` holds a thumbnail that is not an object, ${where}`;
+            for (const member of ["path", "media_type", "sha256", "url", "expires_at"]) {
+                if (typeof thumbnail[member] !== "string") {
+                    return `\`items\` holds a thumbnail whose \`${member}\` is not a string, ${where}`;
+                }
+            }
+            for (const member of ["width", "height"]) {
+                if (!isPositiveInteger(thumbnail[member])) {
+                    return `\`items\` holds a thumbnail whose \`${member}\` is not a positive integer, ${where}`;
+                }
+            }
+        }
+    }
+    return null;
+}
+/** Why the catalog's categories are not ones the SDK reads, or `null`: each a string `slug` and `label`. */
+function methodCategoriesFault(categories) {
+    for (let index = 0; index < categories.length; index += 1) {
+        const category = categories[index];
+        if (!isPlainObject(category) ||
+            typeof category.slug !== "string" ||
+            typeof category.label !== "string") {
+            return `\`categories\` holds an entry without a string \`slug\` and \`label\`, at [${index}]`;
+        }
+    }
+    return null;
+}
 function extractNetworkErrorCode(err) {
     if (err instanceof DOMException && err.name === "TimeoutError") {
         return "ABORT_TIMEOUT";