@greatwait/contracts 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/effective-limits.js

@@ -0,0 +1,42 @@
+import { z } from "./zod.js";
+import { MAX_INLINE_PAYLOAD_BYTES, MAX_FORECAST_HORIZON_SECONDS, MAX_USAGE_WINDOW_DAYS, MAX_PARTITION_KEY_CEILING, } from "./configuration-bounds.js";
+const layer = z.enum(["default", "global", "deployment", "organization"]);
+export const effectiveCustomerLimitsSchema = z
+    .object({
+    limits: z
+        .object({
+        inlinePayloadBytes: z
+            .number()
+            .int()
+            .min(0)
+            .max(MAX_INLINE_PAYLOAD_BYTES),
+        partitionKeyCeiling: z
+            .number()
+            .int()
+            .min(1)
+            .max(MAX_PARTITION_KEY_CEILING)
+            .optional(),
+        forecastHorizonSeconds: z
+            .number()
+            .int()
+            .min(60)
+            .max(MAX_FORECAST_HORIZON_SECONDS),
+        usageWindowDays: z.number().int().min(1).max(MAX_USAGE_WINDOW_DAYS),
+    })
+        .strict(),
+    provenance: z
+        .object({
+        inlinePayloadBytes: layer,
+        partitionKeyCeiling: layer.optional(),
+        forecastHorizonSeconds: layer,
+        usageWindowDays: layer,
+    })
+        .strict(),
+    revision: z
+        .object({
+        global: z.number().int().nonnegative(),
+        organization: z.number().int().nonnegative(),
+    })
+        .strict(),
+})
+    .strict();

package/dist/endpoints.d.ts

@@ -38,9 +38,9 @@ export declare const callbackEgressFailureSchema: import("zod").ZodEnum<{
 }>;
 export type CallbackEgressFailure = z.infer<typeof callbackEgressFailureSchema>;
 /**
- * A safety ceiling on retained endpoint records, independent of later
- * commercial plan limits. Disabled records remain readable for audit and count
- * toward it; changing that lifetime semantic needs a product decision.
+ * @deprecated The former retained endpoint count ceiling. W0-15 removes count
+ * enforcement after the operator's decision; DNS/mutation admission and paged
+ * reads protect bounded work. Retained for source compatibility with old clients.
  */
 export declare const CALLBACK_ENDPOINT_LIMIT_PER_ENVIRONMENT = 50;
 /**
@@ -49,8 +49,8 @@ export declare const CALLBACK_ENDPOINT_LIMIT_PER_ENVIRONMENT = 50;
  * service resolve names without bound.
  */
 export declare const CALLBACK_ADMISSION_RATE_LIMITS: {
-    readonly destinationPerMinute: 5;
-    readonly projectPerMinute: 20;
+    readonly destinationPerMinute: 15;
+    readonly projectPerMinute: 60;
     readonly windowSeconds: 60;
 };
 /** Longest period during which a receiver may accept current and next keys. */
@@ -83,6 +83,19 @@ export declare const callbackEndpointNameSchema: import("zod").ZodString;
  * field, so list/get/update/disable/enable cannot accidentally recover it.
  */
 export declare const callbackEndpointSchema: import("zod").ZodObject<{
+    headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        secret: import("zod").ZodLiteral<false>;
+        value: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        secret: import("zod").ZodLiteral<true>;
+        configured: import("zod").ZodLiteral<true>;
+        value: import("zod").ZodOptional<import("zod").ZodNever>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        suppressed: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strict>]>>>;
     createdAt: import("zod").ZodString;
     disabledAt: import("zod").ZodOptional<import("zod").ZodString>;
     environmentKind: import("zod").ZodEnum<{
@@ -111,6 +124,19 @@ export declare const callbackEndpointSchema: import("zod").ZodObject<{
 export type CallbackEndpoint = z.infer<typeof callbackEndpointSchema>;
 export declare const callbackEndpointPageSchema: import("zod").ZodObject<{
     data: import("zod").ZodArray<import("zod").ZodObject<{
+        headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<false>;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<true>;
+            configured: import("zod").ZodLiteral<true>;
+            value: import("zod").ZodOptional<import("zod").ZodNever>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            suppressed: import("zod").ZodLiteral<true>;
+        }, import("zod/v4/core").$strict>]>>>;
         createdAt: import("zod").ZodString;
         disabledAt: import("zod").ZodOptional<import("zod").ZodString>;
         environmentKind: import("zod").ZodEnum<{
@@ -148,6 +174,19 @@ export declare const callbackEndpointPageSchema: import("zod").ZodObject<{
 export type CallbackEndpointPage = z.infer<typeof callbackEndpointPageSchema>;
 /** The one response that carries the per-endpoint secret. */
 export declare const callbackEndpointCreatedSchema: import("zod").ZodObject<{
+    headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        secret: import("zod").ZodLiteral<false>;
+        value: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        secret: import("zod").ZodLiteral<true>;
+        configured: import("zod").ZodLiteral<true>;
+        value: import("zod").ZodOptional<import("zod").ZodNever>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        suppressed: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strict>]>>>;
     createdAt: import("zod").ZodString;
     disabledAt: import("zod").ZodOptional<import("zod").ZodString>;
     environmentKind: import("zod").ZodEnum<{
@@ -183,6 +222,19 @@ export declare const callbackSigningKeyRotationRequestSchema: import("zod").ZodO
 export type CallbackSigningKeyRotationRequest = z.infer<typeof callbackSigningKeyRotationRequestSchema>;
 export declare const callbackEndpointRotatedSchema: import("zod").ZodObject<{
     endpoint: import("zod").ZodObject<{
+        headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<false>;
+            value: import("zod").ZodString;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            secret: import("zod").ZodLiteral<true>;
+            configured: import("zod").ZodLiteral<true>;
+            value: import("zod").ZodOptional<import("zod").ZodNever>;
+        }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            suppressed: import("zod").ZodLiteral<true>;
+        }, import("zod/v4/core").$strict>]>>>;
         createdAt: import("zod").ZodString;
         disabledAt: import("zod").ZodOptional<import("zod").ZodString>;
         environmentKind: import("zod").ZodEnum<{
@@ -239,7 +291,123 @@ export declare const callbackEndpointSigningSecretsSchema: import("zod").ZodObje
     }, import("zod/v4/core").$strip>>;
 }, import("zod/v4/core").$strip>;
 export type CallbackEndpointSigningSecrets = z.infer<typeof callbackEndpointSigningSecretsSchema>;
+/**
+ * Where an endpoint's signing secret is, for a result that does not carry it
+ * (W9-44, FXO-2907).
+ *
+ * `endpoints.ensure`, and a schedule write that names a `url` instead of an
+ * endpoint, may bring an endpoint into existence without handing its secret
+ * to the caller. An agent working over MCP is the reason: anything a tool
+ * returns lands in ordinary tool history, so the secret is never in the
+ * result. What is in it is where a person finds the secret — the endpoint's
+ * own page, where a signed-in member reveals it — so the agent can pass that
+ * on rather than leave the person to discover that deliveries are signed.
+ *
+ * `returned` is the literal `false` rather than an absent field because a
+ * reader deciding whether it holds a secret should be told so, not left to
+ * infer it from what is missing.
+ */
+export declare const signingSecretNoticeSchema: import("zod").ZodObject<{
+    guidance: import("zod").ZodString;
+    returned: import("zod").ZodLiteral<false>;
+    revealUrl: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>;
+export type SigningSecretNotice = z.infer<typeof signingSecretNoticeSchema>;
+/**
+ * The dashboard path of one endpoint's page, beneath the project and
+ * environment it belongs to. The dashboard's router serves it; a test there
+ * holds the two to the same shape.
+ */
+export declare function endpointDashboardPath(target: {
+    readonly endpoint: string;
+    readonly environmentKind: string;
+    /**
+     * The organization **as the dashboard addresses it**: the sign-in
+     * provider's organization, not GreatWait's `org_…` identifier.
+     */
+    readonly organization: string;
+    readonly project: string;
+}): string;
+/**
+ * The notice a secretless endpoint result carries. `dashboardOrigin` is the
+ * deployment's dashboard; without one the notice still says where to look.
+ */
+export declare function signingSecretNotice(target: Parameters<typeof endpointDashboardPath>[0], dashboardOrigin: string | undefined): SigningSecretNotice;
+/**
+ * What `endpoints.ensure` answers: the endpoint at the requested address,
+ * whether this call created it, and where its signing secret is.
+ *
+ * Metadata only, like every endpoint read. There is no `secret` field to fill
+ * by mistake; the shape is what keeps it out of an agent's history.
+ */
+export declare const callbackEndpointEnsuredSchema: import("zod").ZodObject<{
+    headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        secret: import("zod").ZodLiteral<false>;
+        value: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        secret: import("zod").ZodLiteral<true>;
+        configured: import("zod").ZodLiteral<true>;
+        value: import("zod").ZodOptional<import("zod").ZodNever>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        suppressed: import("zod").ZodLiteral<true>;
+    }, import("zod/v4/core").$strict>]>>>;
+    createdAt: import("zod").ZodString;
+    disabledAt: import("zod").ZodOptional<import("zod").ZodString>;
+    environmentKind: import("zod").ZodEnum<{
+        test: "test";
+        live: "live";
+    }>;
+    id: import("zod").ZodString;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    project: import("zod").ZodString;
+    signingKeys: import("zod").ZodObject<{
+        current: import("zod").ZodString;
+        next: import("zod").ZodOptional<import("zod").ZodObject<{
+            acknowledgedAt: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            overlapEndsAt: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    status: import("zod").ZodEnum<{
+        disabled: "disabled";
+        active: "active";
+    }>;
+    updatedAt: import("zod").ZodString;
+    url: import("zod").ZodString;
+    version: import("zod").ZodNumber;
+    created: import("zod").ZodBoolean;
+    signingSecret: import("zod").ZodObject<{
+        guidance: import("zod").ZodString;
+        returned: import("zod").ZodLiteral<false>;
+        revealUrl: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>;
+}, import("zod/v4/core").$strip>;
+export type CallbackEndpointEnsured = z.infer<typeof callbackEndpointEnsuredSchema>;
+/**
+ * A callback destination as a caller types it: HTTPS on port 443, no
+ * credentials or fragment, a public name or address. The DNS half of the
+ * policy runs when an endpoint is created at it.
+ */
+export declare function callbackUrlSchema(): import("zod").ZodString;
 export declare const callbackEndpointRequestSchema: import("zod").ZodObject<{
+    headers: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+        action: import("zod").ZodLiteral<"set">;
+        name: import("zod").ZodString;
+        value: import("zod").ZodString;
+        secret: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        action: import("zod").ZodLiteral<"keep">;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        action: import("zod").ZodLiteral<"remove">;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>, import("zod").ZodObject<{
+        action: import("zod").ZodLiteral<"suppress">;
+        name: import("zod").ZodString;
+    }, import("zod/v4/core").$strict>], "action">>>;
     name: import("zod").ZodOptional<import("zod").ZodString>;
     url: import("zod").ZodString;
 }, import("zod/v4/core").$strip>;

package/dist/endpoints.js

@@ -1,3 +1,4 @@
+import { endpointHeaderChangesSchema, publicHttpHeaderSchema, } from "./http-request.js";
 import { z } from "./zod.js";
 import { environmentKindSchema } from "./authority.js";
 import { evaluateCallbackUrl } from "./callback-safety.js";
@@ -38,9 +39,9 @@ export const CALLBACK_EGRESS_FAILURES = [
 ];
 export const callbackEgressFailureSchema = z.enum(CALLBACK_EGRESS_FAILURES);
 /**
- * A safety ceiling on retained endpoint records, independent of later
- * commercial plan limits. Disabled records remain readable for audit and count
- * toward it; changing that lifetime semantic needs a product decision.
+ * @deprecated The former retained endpoint count ceiling. W0-15 removes count
+ * enforcement after the operator's decision; DNS/mutation admission and paged
+ * reads protect bounded work. Retained for source compatibility with old clients.
  */
 export const CALLBACK_ENDPOINT_LIMIT_PER_ENVIRONMENT = 50;
 /**
@@ -49,8 +50,8 @@ export const CALLBACK_ENDPOINT_LIMIT_PER_ENVIRONMENT = 50;
  * service resolve names without bound.
  */
 export const CALLBACK_ADMISSION_RATE_LIMITS = {
-    destinationPerMinute: 5,
-    projectPerMinute: 20,
+    destinationPerMinute: 15,
+    projectPerMinute: 60,
     windowSeconds: 60,
 };
 /** Longest period during which a receiver may accept current and next keys. */
@@ -89,6 +90,7 @@ export const callbackEndpointNameSchema = z
  * field, so list/get/update/disable/enable cannot accidentally recover it.
  */
 export const callbackEndpointSchema = z.object({
+    headers: z.array(publicHttpHeaderSchema).optional(),
     createdAt: timestampSchema,
     disabledAt: timestampSchema.optional(),
     environmentKind: environmentKindSchema,
@@ -148,7 +150,75 @@ export const callbackEndpointSigningSecretsSchema = z.object({
         .extend({ overlapEndsAt: timestampSchema })
         .optional(),
 });
-function callbackUrlSchema() {
+/**
+ * Where an endpoint's signing secret is, for a result that does not carry it
+ * (W9-44, FXO-2907).
+ *
+ * `endpoints.ensure`, and a schedule write that names a `url` instead of an
+ * endpoint, may bring an endpoint into existence without handing its secret
+ * to the caller. An agent working over MCP is the reason: anything a tool
+ * returns lands in ordinary tool history, so the secret is never in the
+ * result. What is in it is where a person finds the secret — the endpoint's
+ * own page, where a signed-in member reveals it — so the agent can pass that
+ * on rather than leave the person to discover that deliveries are signed.
+ *
+ * `returned` is the literal `false` rather than an absent field because a
+ * reader deciding whether it holds a secret should be told so, not left to
+ * infer it from what is missing.
+ */
+export const signingSecretNoticeSchema = z.object({
+    /** One sentence an agent can relay to the person it is working for. */
+    guidance: z.string().min(1),
+    /** Never `true`: these results do not carry the secret. */
+    returned: z.literal(false),
+    /**
+     * The endpoint's page in the GreatWait dashboard, where a signed-in member
+     * reveals the secret. Absent only where this deployment has no dashboard.
+     */
+    revealUrl: z.string().url().optional(),
+});
+/**
+ * The dashboard path of one endpoint's page, beneath the project and
+ * environment it belongs to. The dashboard's router serves it; a test there
+ * holds the two to the same shape.
+ */
+export function endpointDashboardPath(target) {
+    return `/o/${encodeURIComponent(target.organization)}/p/${encodeURIComponent(target.project)}/${encodeURIComponent(target.environmentKind)}/settings/endpoints/${encodeURIComponent(target.endpoint)}`;
+}
+/**
+ * The notice a secretless endpoint result carries. `dashboardOrigin` is the
+ * deployment's dashboard; without one the notice still says where to look.
+ */
+export function signingSecretNotice(target, dashboardOrigin) {
+    return {
+        guidance: "GreatWait signs every callback to this endpoint. The signing secret is never returned here; a signed-in member of the project reveals it on the endpoint's page in the GreatWait dashboard, and your receiver uses it to verify that a callback came from GreatWait.",
+        returned: false,
+        ...(dashboardOrigin === undefined
+            ? {}
+            : {
+                revealUrl: new URL(endpointDashboardPath(target), dashboardOrigin)
+                    .href,
+            }),
+    };
+}
+/**
+ * What `endpoints.ensure` answers: the endpoint at the requested address,
+ * whether this call created it, and where its signing secret is.
+ *
+ * Metadata only, like every endpoint read. There is no `secret` field to fill
+ * by mistake; the shape is what keeps it out of an agent's history.
+ */
+export const callbackEndpointEnsuredSchema = callbackEndpointSchema.extend({
+    /** Whether this call created the endpoint, or found one already there. */
+    created: z.boolean(),
+    signingSecret: signingSecretNoticeSchema,
+});
+/**
+ * A callback destination as a caller types it: HTTPS on port 443, no
+ * credentials or fragment, a public name or address. The DNS half of the
+ * policy runs when an endpoint is created at it.
+ */
+export function callbackUrlSchema() {
     return z
         .string()
         .url()
@@ -164,6 +234,7 @@ function callbackUrlSchema() {
     });
 }
 export const callbackEndpointRequestSchema = z.object({
+    headers: endpointHeaderChangesSchema.optional(),
     /**
      * A name for people (W4-14, FXO-2255). Omitted on a create, the endpoint
      * takes its whole URL as its name; omitted on an update, the stored name

package/dist/first-value-journey.d.ts

@@ -6,7 +6,7 @@ import type { ProblemCode } from "./problems.js";
  *
  * **Declared once, here, because W9-03 is not the only story that has to tell
  * it.** The curl quickstart, the JavaScript quickstart, the website journey
- * W9-01 owns, the DocsAlot pages W9-04 publishes, and the command-line
+ * W9-01 owns, the documentation pages W9-04 publishes, and the command-line
  * ergonomics W10 owns are all the *same* sequence rendered for a different
  * reader. Written separately they diverge silently — the legacy scheduler's
  * hand-maintained client and documentation are the worked example, and the

package/dist/first-value-journey.js

@@ -109,20 +109,20 @@ export const CURL_JOURNEY_TOOLS = [
 ];
 export const FIRST_VALUE_PREREQUISITES = [
     {
-        action: "Accept your Greatwait invitation, sign in, and create a project in the dashboard.",
+        action: "Accept your GreatWait invitation, sign in, and create a project in the dashboard.",
         because: "projects.create accepts only a signed-in member, so a project is created by a person rather than by an API credential.",
         id: "project",
         title: "A project",
     },
     {
-        action: "In that project, create an API credential and copy the secret it shows once.",
+        action: "In that project, create an API credential with endpoints:write, occurrences:read, schedules:read and schedules:write, and copy the secret it shows once. The key picker starts with nothing selected and refuses an empty one, so those four are the boxes to tick.",
         because: "credentials.create accepts only a signed-in member: a credential that could mint another credential would make revoking one meaningless.",
         id: "credential",
         title: "An API credential",
     },
     {
         action: "Have an HTTPS URL of your own that answers POST with a 2xx status, and can be reached from the public internet.",
-        because: "Greatwait delivers your callback to an address you control. It does not offer a shared receiver to try, and it will not send your payload to a third-party inspection service on your behalf.",
+        because: "GreatWait delivers your callback to an address you control. It does not offer a shared receiver to try, and it will not send your payload to a third-party inspection service on your behalf.",
         id: "receiver",
         title: "An HTTPS receiver you control",
     },
@@ -190,7 +190,7 @@ export const FIRST_VALUE_STEPS = [
         key: "check-service",
         observe: "The service name and the environment you meant to work in. If the environment is not the one you expect, stop and fix GREATWAIT_API_URL before creating anything.",
         operationId: "meta.version",
-        purpose: "Confirms the origin you are pointed at is a Greatwait API and says which environment it serves. It needs no credential, so it separates 'wrong URL' from 'wrong key'.",
+        purpose: "Confirms the origin you are pointed at is a GreatWait API and says which environment it serves. It needs no credential, so it separates 'wrong URL' from 'wrong key'.",
         recovery: [
             {
                 nextMove: "Something answered, but not this service. Check GREATWAIT_API_URL — a 404 here comes from a proxy in front of the API rather than from the API, so it carries no problem document to read.",
@@ -235,7 +235,7 @@ export const FIRST_VALUE_STEPS = [
             { from: "id", variable: "GREATWAIT_ENDPOINTID" },
             { from: "secret", secret: true, variable: "GREATWAIT_ENDPOINT_SECRET" },
         ],
-        observe: "An endpoint identifier, and a signing secret returned by this call and by no other. Store the secret now: reading the endpoint back later will not show it again.",
+        observe: "An endpoint identifier, and a signing secret. Store it now: this is the only call that returns it, and reading the endpoint back shows a redacted prefix instead. It is not gone if you lose it — a signed-in member can read it again on the endpoint's own page in the dashboard, which is the one caller `endpoints.revealSigningSecret` accepts.",
         operationId: "endpoints.create",
         purpose: "Registers the address every occurrence of this schedule is delivered to, and mints the per-endpoint signing key your receiver verifies callbacks with.",
         recovery: [
@@ -247,6 +247,10 @@ export const FIRST_VALUE_STEPS = [
                 nextMove: "This project is at its destination ceiling. Disable a destination you no longer deliver to; disabled ones still count, because they stay readable for audit.",
                 when: "plan_limit_reached",
             },
+            {
+                nextMove: "An active destination already delivers to this address in this project — usually one a previous run of this journey created. Reuse that destination, disable it first, or give the new one a name of its own.",
+                when: "state_conflict",
+            },
         ],
         request: { url: "{{GREATWAIT_RECEIVER_URL}}" },
         title: "Create the destination",
@@ -278,7 +282,7 @@ export const FIRST_VALUE_STEPS = [
                 when: "invalid_request",
             },
             {
-                nextMove: "This organization is at a plan ceiling — live schedules, distinct partition keys, or payload size. Nothing was created; reduce the payload or archive a schedule and retry.",
+                nextMove: "This organization is at a plan ceiling — the payload is larger than its plan carries, or the schedule names a new partition key when the organization's keys are full. Nothing was created; send a smaller payload or reuse a partition key that is already live, and retry.",
                 when: "plan_limit_reached",
             },
             {
@@ -375,7 +379,7 @@ export const FIRST_VALUE_STEPS = [
                 when: "attempt-failed",
             },
             {
-                nextMove: "Nothing reached your receiver. Confirm the URL answers a POST from the public internet, and that it is not behind an allowlist Greatwait is not on.",
+                nextMove: "Nothing reached your receiver. Confirm the URL answers a POST from the public internet, and that it is not behind an allowlist GreatWait is not on.",
                 when: "receiver-unreachable",
             },
         ],