@spacefast/common 0.0.24 → 0.2.1

package/dist/contracts/{platform.d.ts → partner.d.ts}

@@ -31,22 +31,19 @@ export declare const accessLogEntrySchema: z.ZodObject<{
 /**
  * One line a space's own code wrote, whichever tier wrote it.
  *
- * There is exactly one place these come from: the hosting provider's PHP error
- * log for the space's site. A Zero mutation, a PHP function, and a Functions
- * worker on Cloudflare all end up writing to that file on the origin — the
- * worker by tailing its output back to the origin that dispatched it — because
- * it is the only stream the provider ships off the box and serves back. The
- * runtime writes each record as one JSON line behind a marker; this is what the
- * reader gets after pulling that line back out of the provider's message.
+ * These come from one place: the hosting provider's PHP error log for the
+ * space's site, the only stream the provider ships off the box and serves back.
+ * A Zero mutation, a PHP function, and a Functions worker on Cloudflare all end
+ * up writing there, the worker by tailing its output back to the origin that
+ * dispatched it. The runtime writes each record as one JSON line behind a
+ * marker, and the reader gets that line back out of the provider's message.
  *
- * `id` is minted by the runtime at write time rather than derived on read: the
- * provider's log has no identity of its own, and a caller paging a window needs
- * a stable key for a line it may see again at a page boundary.
+ * `id` is minted by the runtime at write time: the provider's log has no
+ * identity of its own, and a caller paging a window needs a stable key for a
+ * line it may see again at a page boundary.
  *
- * Unlike its access-log sibling there is no `ts` alongside `timestamp`. That
- * duplication is a compatibility alias the access log carries for callers that
- * predate the rename; runtime logs have never been served to anyone, so there
- * is no caller to keep and no reason to inherit the wart.
+ * No `ts` alias beside `timestamp`. That is an access-log compatibility wart,
+ * and runtime logs have never been served to anyone.
  */
 export declare const runtimeLogEntrySchema: z.ZodObject<{
     id: z.ZodString;
@@ -54,8 +51,8 @@ export declare const runtimeLogEntrySchema: z.ZodObject<{
     level: z.ZodEnum<{
         info: "info";
         error: "error";
-        debug: "debug";
         warn: "warn";
+        debug: "debug";
     }>;
     requestId: z.ZodNullable<z.ZodString>;
     versionId: z.ZodNullable<z.ZodString>;
@@ -65,12 +62,11 @@ export declare const runtimeLogEntrySchema: z.ZodObject<{
 }, z.core.$strict>;
 export type RuntimeLogEntry = z.infer<typeof runtimeLogEntrySchema>;
 /**
- * Windowed like its access-log sibling, because it reads the same provider
- * index — `atomic_site_id` plus a `@timestamp` range — and that index has no
- * other way in. The two log kinds sit side by side under one command, so they
- * take one query shape; `requestId` and `handlerName` are the extra narrowings
- * only handler output can answer, and they are applied over the pages the
- * server fetched rather than by the provider, which indexes neither.
+ * Windowed like its access-log sibling, because it reads the same provider index
+ * (`atomic_site_id` plus a `@timestamp` range) and that index has no other way
+ * in. `requestId` and `handlerName` are the extra narrowings only handler output
+ * can answer, applied over the pages the server fetched because the provider
+ * indexes neither.
  */
 export declare const runtimeLogListQuerySchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
@@ -107,7 +103,7 @@ export declare const accessLogListResponseSchema: z.ZodObject<{
         path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
             registrar: "registrar";
-            wpcloud: "wpcloud";
+            infra: "infra";
             dns: "dns";
             runtime: "runtime";
         }>>>;
@@ -119,26 +115,17 @@ export declare const accessLogListResponseSchema: z.ZodObject<{
 /**
  * Paged handler logs.
  *
- * One thing about that cursor is worth stating rather than discovering: **an
- * empty page does not mean the end.** The cursor walks the provider's scroll
+ * An empty page does not mean the end. The cursor walks the provider's scroll
  * over every PHP-error-log line in the window, and only some of those lines are
- * handler output — a page can come back empty because the stretch it scanned
- * held none, or held none matching `requestId`/`handlerName`. The rule is
- * **`hasMore: false` means you have seen everything; `hasMore: true` means keep
- * paging, whatever `data` held.** A client that stops on the first empty page
- * will silently truncate its own search.
- *
- * `warnings` carries the same `log_retention_clamped` diagnostic the access log
- * does, for the same reason: one window, one retention, one way of saying it
- * was cut back.
+ * handler output, so a page can come back empty. `hasMore: false` means you have
+ * seen everything; `hasMore: true` means keep paging, whatever `data` held. A
+ * client that stops on the first empty page truncates its own search.
  *
- * **These lines lag.** A record is written to a file on the origin, shipped off
- * the box, and indexed before it can be read back, so a line a request just
- * wrote will not be in the next page. Nothing here is live, and the delay is
- * the provider's ingest lag rather than anything this surface schedules — it
- * has not been measured against a real client yet, so no surface should quote
- * a figure for it until the gate probe in
- * `e2e-tests/direct/wpcloud-behavior.test.ts` has actually run.
+ * These lines lag. A record is written to a file on the origin, shipped off the
+ * box, and indexed before it can be read back, so a line a request just wrote
+ * will not be in the next page. The delay is the provider's ingest lag and has
+ * not been measured, so no surface should quote a figure for it until the gate
+ * probe in `e2e-tests/direct/wpcloud-behavior.test.ts` has run.
  */
 export declare const runtimeLogListResponseSchema: z.ZodObject<{
     data: z.ZodArray<z.ZodObject<{
@@ -147,8 +134,8 @@ export declare const runtimeLogListResponseSchema: z.ZodObject<{
         level: z.ZodEnum<{
             info: "info";
             error: "error";
-            debug: "debug";
             warn: "warn";
+            debug: "debug";
         }>;
         requestId: z.ZodNullable<z.ZodString>;
         versionId: z.ZodNullable<z.ZodString>;
@@ -171,7 +158,7 @@ export declare const runtimeLogListResponseSchema: z.ZodObject<{
         path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         provider: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
             registrar: "registrar";
-            wpcloud: "wpcloud";
+            infra: "infra";
             dns: "dns";
             runtime: "runtime";
         }>>>;

package/dist/contracts/{platform.js → partner.js}

@@ -30,22 +30,19 @@ export const accessLogEntrySchema = z.object({
 /**
  * One line a space's own code wrote, whichever tier wrote it.
  *
- * There is exactly one place these come from: the hosting provider's PHP error
- * log for the space's site. A Zero mutation, a PHP function, and a Functions
- * worker on Cloudflare all end up writing to that file on the origin — the
- * worker by tailing its output back to the origin that dispatched it — because
- * it is the only stream the provider ships off the box and serves back. The
- * runtime writes each record as one JSON line behind a marker; this is what the
- * reader gets after pulling that line back out of the provider's message.
+ * These come from one place: the hosting provider's PHP error log for the
+ * space's site, the only stream the provider ships off the box and serves back.
+ * A Zero mutation, a PHP function, and a Functions worker on Cloudflare all end
+ * up writing there, the worker by tailing its output back to the origin that
+ * dispatched it. The runtime writes each record as one JSON line behind a
+ * marker, and the reader gets that line back out of the provider's message.
  *
- * `id` is minted by the runtime at write time rather than derived on read: the
- * provider's log has no identity of its own, and a caller paging a window needs
- * a stable key for a line it may see again at a page boundary.
+ * `id` is minted by the runtime at write time: the provider's log has no
+ * identity of its own, and a caller paging a window needs a stable key for a
+ * line it may see again at a page boundary.
  *
- * Unlike its access-log sibling there is no `ts` alongside `timestamp`. That
- * duplication is a compatibility alias the access log carries for callers that
- * predate the rename; runtime logs have never been served to anyone, so there
- * is no caller to keep and no reason to inherit the wart.
+ * No `ts` alias beside `timestamp`. That is an access-log compatibility wart,
+ * and runtime logs have never been served to anyone.
  */
 export const runtimeLogEntrySchema = z
     .object({
@@ -61,12 +58,11 @@ export const runtimeLogEntrySchema = z
 })
     .strict();
 /**
- * Windowed like its access-log sibling, because it reads the same provider
- * index — `atomic_site_id` plus a `@timestamp` range — and that index has no
- * other way in. The two log kinds sit side by side under one command, so they
- * take one query shape; `requestId` and `handlerName` are the extra narrowings
- * only handler output can answer, and they are applied over the pages the
- * server fetched rather than by the provider, which indexes neither.
+ * Windowed like its access-log sibling, because it reads the same provider index
+ * (`atomic_site_id` plus a `@timestamp` range) and that index has no other way
+ * in. `requestId` and `handlerName` are the extra narrowings only handler output
+ * can answer, applied over the pages the server fetched because the provider
+ * indexes neither.
  */
 export const runtimeLogListQuerySchema = logWindowQuerySchema.extend({
     requestId: z
@@ -78,7 +74,7 @@ export const runtimeLogListQuerySchema = logWindowQuerySchema.extend({
         .string()
         .min(1)
         .optional()
-        .describe("Return only lines from this handler — a Zero mutation or a Functions handler."),
+        .describe("Return only lines from this handler, either a Zero mutation or a Functions handler."),
 });
 export const accessLogListResponseSchema = z.object({
     data: z.array(accessLogEntrySchema),
@@ -91,26 +87,17 @@ export const accessLogListResponseSchema = z.object({
 /**
  * Paged handler logs.
  *
- * One thing about that cursor is worth stating rather than discovering: **an
- * empty page does not mean the end.** The cursor walks the provider's scroll
+ * An empty page does not mean the end. The cursor walks the provider's scroll
  * over every PHP-error-log line in the window, and only some of those lines are
- * handler output — a page can come back empty because the stretch it scanned
- * held none, or held none matching `requestId`/`handlerName`. The rule is
- * **`hasMore: false` means you have seen everything; `hasMore: true` means keep
- * paging, whatever `data` held.** A client that stops on the first empty page
- * will silently truncate its own search.
+ * handler output, so a page can come back empty. `hasMore: false` means you have
+ * seen everything; `hasMore: true` means keep paging, whatever `data` held. A
+ * client that stops on the first empty page truncates its own search.
  *
- * `warnings` carries the same `log_retention_clamped` diagnostic the access log
- * does, for the same reason: one window, one retention, one way of saying it
- * was cut back.
- *
- * **These lines lag.** A record is written to a file on the origin, shipped off
- * the box, and indexed before it can be read back, so a line a request just
- * wrote will not be in the next page. Nothing here is live, and the delay is
- * the provider's ingest lag rather than anything this surface schedules — it
- * has not been measured against a real client yet, so no surface should quote
- * a figure for it until the gate probe in
- * `e2e-tests/direct/wpcloud-behavior.test.ts` has actually run.
+ * These lines lag. A record is written to a file on the origin, shipped off the
+ * box, and indexed before it can be read back, so a line a request just wrote
+ * will not be in the next page. The delay is the provider's ingest lag and has
+ * not been measured, so no surface should quote a figure for it until the gate
+ * probe in `e2e-tests/direct/wpcloud-behavior.test.ts` has run.
  */
 export const runtimeLogListResponseSchema = z.object({
     data: z.array(runtimeLogEntrySchema),
@@ -127,7 +114,7 @@ export const analyticsQuerySchema = z.object({
         .describe('Analytics summary window. Defaults to "7d".'),
 });
 // Served by `GET /v1/spaces/{spaceId}/analytics`: traffic summary over the
-// requested window, read live from the hosting provider's edge metrics — no
+// requested window, read live from the hosting provider's edge metrics. No
 // local store exists. Counts cover every hostname mapped to the space's site;
 // a provider outage means this endpoint errors rather than answers stale.
 export const analyticsResponseSchema = z.object({

package/dist/contracts/plan-policy.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { diagnosticSeverity } from "./enums.js";
 import { planCodeSchema, planLimitValueSchema } from "./features.js";
 // Behaviors the platform disables (rather than failing publishes) when the
-// plan does not include them (internal-docs/platform.md "Plans And Limits").
+// plan does not include them (the platform spec "Plans And Limits").
 export const PLAN_DISABLED_BEHAVIOR_CODES = [
     "free_external_proxy_disabled",
     "routing_rules_over_plan",

package/dist/contracts/principal-assertion.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+export declare const exactOriginSchema: z.core.$ZodBranded<z.ZodString, "ExactOrigin", "out">;
+export type ExactOrigin = z.infer<typeof exactOriginSchema>;
+export declare const principalAssertionV1Schema: z.ZodUnion<readonly [z.ZodObject<{
+    actor: z.ZodObject<{
+        kind: z.ZodLiteral<"user">;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    subject: z.ZodOptional<z.ZodObject<{
+        issuer: z.ZodString;
+        subject: z.ZodString;
+    }, z.core.$strict>>;
+    format: z.ZodLiteral<"spacefast.principal">;
+    version: z.ZodLiteral<1>;
+    audience: z.ZodObject<{
+        spaceId: z.ZodTemplateLiteral<`spc_${string}`>;
+        runtimeInstanceId: z.ZodString;
+        host: z.core.$ZodBranded<z.ZodString, "ExactOrigin", "out">;
+    }, z.core.$strict>;
+    sessionVersion: z.ZodNumber;
+    accessGeneration: z.ZodNumber;
+    nonce: z.ZodString;
+    issuedAt: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    actor: z.ZodObject<{
+        kind: z.ZodLiteral<"service">;
+        id: z.ZodString;
+    }, z.core.$strict>;
+    format: z.ZodLiteral<"spacefast.principal">;
+    version: z.ZodLiteral<1>;
+    audience: z.ZodObject<{
+        spaceId: z.ZodTemplateLiteral<`spc_${string}`>;
+        runtimeInstanceId: z.ZodString;
+        host: z.core.$ZodBranded<z.ZodString, "ExactOrigin", "out">;
+    }, z.core.$strict>;
+    sessionVersion: z.ZodNumber;
+    accessGeneration: z.ZodNumber;
+    nonce: z.ZodString;
+    issuedAt: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+}, z.core.$strict>]>;
+export type PrincipalAssertionV1 = z.infer<typeof principalAssertionV1Schema>;

package/dist/contracts/principal-assertion.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { registeredIdSchema } from "./ids.js";
+function isExactHttpOrigin(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return false;
+    }
+    return ((url.protocol === "https:" || url.protocol === "http:") &&
+        url.origin === value &&
+        url.pathname === "/" &&
+        url.search === "" &&
+        url.hash === "" &&
+        url.username === "" &&
+        url.password === "");
+}
+export const exactOriginSchema = z
+    .string()
+    .url()
+    .max(2_000)
+    .refine(isExactHttpOrigin, "must be an exact HTTP origin without path, credentials, query, or fragment")
+    .brand();
+const principalAudienceSchema = z
+    .object({
+    spaceId: registeredIdSchema("spc"),
+    runtimeInstanceId: z.string().min(1).max(255),
+    host: exactOriginSchema,
+})
+    .strict();
+const principalSubjectSchema = z
+    .object({
+    issuer: z.string().min(1).max(255),
+    subject: z.string().min(1).max(512),
+})
+    .strict();
+const principalAssertionFields = {
+    format: z.literal("spacefast.principal"),
+    version: z.literal(1),
+    audience: principalAudienceSchema,
+    sessionVersion: z.number().int().nonnegative(),
+    accessGeneration: z.number().int().nonnegative(),
+    nonce: z.string().min(16).max(512),
+    issuedAt: z.number().int().nonnegative(),
+    expiresAt: z.number().int().positive(),
+};
+export const principalAssertionV1Schema = z
+    .union([
+    z
+        .object({
+        ...principalAssertionFields,
+        actor: z.object({ kind: z.literal("user"), id: z.string().min(1).max(255) }).strict(),
+        subject: principalSubjectSchema.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        ...principalAssertionFields,
+        actor: z.object({ kind: z.literal("service"), id: z.string().min(1).max(255) }).strict(),
+    })
+        .strict(),
+])
+    .refine((assertion) => assertion.expiresAt > assertion.issuedAt, {
+    path: ["expiresAt"],
+    message: "expiresAt must be after issuedAt",
+});

package/dist/contracts/principals.d.ts

@@ -0,0 +1,73 @@
+import { z } from "zod";
+/**
+ * An external principal: the partner's own customer, as this platform knows it.
+ *
+ * A principal is materialized the first time it owns something here, never by
+ * registration — there is no "create principal" call, and the id is whatever
+ * the partner already calls that customer in its own system. `principalId` is
+ * therefore the partner's id verbatim, casing included; matching within a
+ * tenant is case-insensitive, so `Cus_ABC` and `cus_abc` are one principal and
+ * the first spelling seen is the one kept.
+ *
+ * `principalType` is a literal rather than the team/external union the resource
+ * refs use: teams are principals too, but they are addressed as teams and have
+ * their own surface. This resource exists to answer "who are my customers", and
+ * only external principals are.
+ */
+export declare const PrincipalSchema: z.ZodObject<{
+    principalType: z.ZodLiteral<"external">;
+    principalId: z.ZodString;
+    mode: z.ZodEnum<{
+        live: "live";
+        test: "test";
+    }>;
+    spaceCount: z.ZodNumber;
+    status: z.ZodEnum<{
+        active: "active";
+        suspended: "suspended";
+        closed: "closed";
+    }>;
+    statusReason: z.ZodNullable<z.ZodString>;
+    statusChangedAt: z.ZodNullable<z.ZodString>;
+    statusActor: z.ZodNullable<z.ZodEnum<{
+        spacefast: "spacefast";
+        partner: "partner";
+    }>>;
+    assignedPlan: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export type Principal = z.infer<typeof PrincipalSchema>;
+export declare const principalListSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        principalType: z.ZodLiteral<"external">;
+        principalId: z.ZodString;
+        mode: z.ZodEnum<{
+            live: "live";
+            test: "test";
+        }>;
+        spaceCount: z.ZodNumber;
+        status: z.ZodEnum<{
+            active: "active";
+            suspended: "suspended";
+            closed: "closed";
+        }>;
+        statusReason: z.ZodNullable<z.ZodString>;
+        statusChangedAt: z.ZodNullable<z.ZodString>;
+        statusActor: z.ZodNullable<z.ZodEnum<{
+            spacefast: "spacefast";
+            partner: "partner";
+        }>>;
+        assignedPlan: z.ZodNullable<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    pagination: z.ZodObject<{
+        nextCursor: z.ZodNullable<z.ZodString>;
+        hasMore: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type PrincipalList = z.infer<typeof principalListSchema>;
+export declare const PrincipalParamsSchema: z.ZodObject<{
+    principalId: z.ZodString;
+}, z.core.$strip>;

package/dist/contracts/principals.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { principalLifecycleStatusSchema, principalStatusActorSchema } from "./commerce.js";
+import { CursorPaginationSchema, cursorListQuerySchema } from "./common.js";
+import { tenantMode } from "./enums.js";
+/**
+ * An external principal: the partner's own customer, as this platform knows it.
+ *
+ * A principal is materialized the first time it owns something here, never by
+ * registration — there is no "create principal" call, and the id is whatever
+ * the partner already calls that customer in its own system. `principalId` is
+ * therefore the partner's id verbatim, casing included; matching within a
+ * tenant is case-insensitive, so `Cus_ABC` and `cus_abc` are one principal and
+ * the first spelling seen is the one kept.
+ *
+ * `principalType` is a literal rather than the team/external union the resource
+ * refs use: teams are principals too, but they are addressed as teams and have
+ * their own surface. This resource exists to answer "who are my customers", and
+ * only external principals are.
+ */
+export const PrincipalSchema = z.object({
+    principalType: z
+        .literal("external")
+        .describe("Always `external`: teams are principals too, but they have their own surface."),
+    principalId: z
+        .string()
+        .describe("The partner's own id for this customer, in the casing it was first seen."),
+    mode: tenantMode.describe("`test` when this principal belongs to a linked test tenant, `live` otherwise."),
+    spaceCount: z
+        .number()
+        .int()
+        .nonnegative()
+        .describe("Spaces this principal currently owns in the tenant."),
+    status: principalLifecycleStatusSchema.describe("Lifecycle status. `active` by default; `suspended` reversibly halts the principal's spaces and mutations; `closed` is terminal."),
+    statusReason: z
+        .string()
+        .nullable()
+        .describe("Free-text reason recorded with the last status change, or null."),
+    statusChangedAt: z
+        .string()
+        .datetime()
+        .nullable()
+        .describe("When the status last changed, or null while never changed from the default."),
+    statusActor: principalStatusActorSchema
+        .nullable()
+        .describe("Who applied the current status: `partner` (the tenant) or `spacefast` (unliftable by the partner). Null while never changed."),
+    assignedPlan: z
+        .string()
+        .nullable()
+        .describe("Plan name assigned from the tenant's catalog, or null to fall back to defaultPlan."),
+    createdAt: z.string().datetime().describe("When this principal first owned something here."),
+    updatedAt: z.string().datetime().describe("When this principal was last seen owning something."),
+});
+export const principalListSchema = z.object({
+    data: z.array(PrincipalSchema),
+    pagination: CursorPaginationSchema,
+});
+export const PrincipalParamsSchema = z.object({
+    principalId: z.string().min(1).describe("The partner's own id for this customer."),
+});

package/dist/contracts/privacy.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const privacySettingsSchema: z.ZodObject<{
+    analyticsOptOut: z.ZodBoolean;
+    advertisingOptOut: z.ZodBoolean;
+}, z.core.$strip>;
+export type PrivacySettings = z.infer<typeof privacySettingsSchema>;
+export declare const privacySettingsPatchSchema: z.ZodObject<{
+    analyticsOptOut: z.ZodOptional<z.ZodBoolean>;
+    advertisingOptOut: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type PrivacySettingsPatch = z.infer<typeof privacySettingsPatchSchema>;

package/dist/contracts/privacy.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+// Account-level privacy choices, modeled on WordPress.com's `/me/settings`
+// pair (`tracks_opt_out`, `advertising_targeting_opt_out`). These are durable
+// server-side settings, distinct from the browser cookie-consent buckets: the
+// cookie answers "what may run in THIS browser", these answer "what may this
+// ACCOUNT's data be used for" on every device.
+export const privacySettingsSchema = z.object({
+    analyticsOptOut: z
+        .boolean()
+        .describe("Opt out of product analytics. When true, no analytics events are recorded for this account, in the browser or server-side."),
+    advertisingOptOut: z
+        .boolean()
+        .describe("Do-not-sell/share election (CCPA). When true, the account is excluded from any advertising or audience use."),
+});
+export const privacySettingsPatchSchema = privacySettingsSchema
+    .partial()
+    .describe("Fields to change; omitted fields are left alone.");

package/dist/contracts/problem-document.js

@@ -1,7 +1,6 @@
-// Reader for the RFC 9457 problem document every 4xx/5xx response carries, so the
-// client surfaces (CLI, MCP, SDK) share one definition of which members exist and
-// which values are trusted. Callers keep their own entry guards, message fallbacks
-// and public field names — this only extracts the wire members.
+// Reader for the RFC 9457 problem document every 4xx/5xx response carries, so
+// the CLI, MCP, and SDK share one definition of the wire members. Callers keep
+// their own entry guards, message fallbacks, and public field names.
 /** Returns undefined when the payload cannot be a problem document at all. */
 export function parseProblemDocument(payload) {
     if (!payload || typeof payload !== "object" || Array.isArray(payload)) {