@domino-sdk/relay 1.0.0-next.9 → 1.0.0

package/dist/server/index.js

@@ -0,0 +1,2520 @@
+import {
+  activityTypeSchema,
+  activityTypes,
+  automaticCatchUpConfirmSchema,
+  automaticCatchUpInputSchema,
+  automaticCatchUpPreviewSchema,
+  automaticCatchUpResultSchema,
+  automaticOutcomePageSchema,
+  automaticOutcomeQuerySchema,
+  automaticSchedulingPageSchema,
+  automaticSchedulingQuerySchema,
+  automaticSchedulingRetrySchema,
+  automaticSchedulingSchema,
+  deploymentPreviewSchema,
+  deploymentRecordSchema,
+  deploymentResultSchema,
+  projectDeploymentSchema,
+  promoteDeploymentSchema,
+  publishDeploymentSchema,
+  rejectDeploymentSchema,
+  rollbackDeploymentSchema,
+  submitDeploymentSchema
+} from "../chunk-VFHHLN6A.js";
+import "../chunk-MC6V6VMG.js";
+import {
+  identityIntegrationInputSchema,
+  identityIntegrationSchema,
+  identityIntegrationSecretSchema,
+  identityKindClaimSchema
+} from "../chunk-WJSSJ7AF.js";
+import {
+  imageAssetArtifactSchema
+} from "../chunk-BGGKNIRP.js";
+import "../chunk-GQKYAQM6.js";
+import "../chunk-GUP7YRR4.js";
+import {
+  allocateQuestSchema,
+  allocatedQuestSchema,
+  catalogDeploymentPreviewSchema,
+  catalogDeploymentSchema,
+  collectionBeginSchema,
+  collectionPreviewSchema,
+  collectionResolveSchema,
+  memberEnrollmentInputSchema,
+  publishQuestDraftSchema,
+  questCatalogSchema,
+  questDraftSchema,
+  questEnrollmentSchema,
+  questPublicationPreviewSchema,
+  rewardDeliveriesSchema,
+  rewardDeliverySchema,
+  saveQuestDraftSchema
+} from "../chunk-EYH5RDIE.js";
+import {
+  cosmosNetworkSchema,
+  createPointLedgerSchema,
+  engagementBoundaryPageSchema,
+  engagementChangePreviewInputSchema,
+  engagementChangePreviewSchema,
+  engagementChangeSchema,
+  engagementPageQuerySchema,
+  engagementPageSchema,
+  engagementPublishSchema,
+  engagementRuleSchema,
+  engagementVersionPageSchema,
+  engagementVersionQuerySchema,
+  evmChainIdSchema,
+  leaderboardExclusionSchema,
+  leaderboardGroupSchema,
+  leaderboardPageSchema,
+  leaderboardQuerySchema,
+  leaderboardSettlementApprovalSchema,
+  leaderboardSettlementSchema,
+  leaderboardSettlementSummarySchema,
+  linkedWalletSchema,
+  managedPointLedgerSchema,
+  managedProfileSchema,
+  offerControlSchema,
+  offerSchema,
+  pointLedgerSchema,
+  pointsAccountSchema,
+  pointsEntrySchema,
+  pointsMutationSchema,
+  pointsResultSchema,
+  profileModerationSchema,
+  profileSettingsInputSchema,
+  profileSettingsSchema,
+  publishedLeaderboardSchema,
+  publishedReferralSchema,
+  redemptionCancellationSchema,
+  redemptionSchema,
+  referralControlSchema,
+  referralHistorySchema,
+  referralManagementSchema,
+  solanaMainnet,
+  walletBalanceSchema,
+  walletSignInNetworksSchema,
+  walletUnlinkInputSchema
+} from "../chunk-36HTX2BM.js";
+import {
+  MANAGEMENT_TIMEOUT,
+  lifetime,
+  retryAfter,
+  retrying,
+  validTimeout
+} from "../chunk-6QJ3LADK.js";
+import {
+  RequestError,
+  isRequestError
+} from "../chunk-NPGENI7K.js";
+import "../chunk-XFMSUPNS.js";
+import {
+  appIdentityKindSchema,
+  attemptSchema,
+  authProviderSchema,
+  beginHandoverSchema,
+  campaignEnrollmentSchema,
+  configurePickupSchema,
+  confirmHandoverSchema,
+  contentPerformancePageSchema,
+  contentPerformanceQuerySchema,
+  contentQualificationPageSchema,
+  contentQualificationQuerySchema,
+  counterHistoryQuerySchema,
+  counterHistorySchema,
+  counterModerationResultSchema,
+  counterModerationSchema,
+  createStockItemSchema,
+  entitlementCorrectionSchema,
+  entitlementSchema,
+  identifier,
+  memberCampaignEnrollmentInputSchema,
+  memberCampaignWithdrawalInputSchema,
+  memberIdentitySchema,
+  memberProgressSchema,
+  pickupAvailabilitySchema,
+  pickupCatalogSchema,
+  projectCalendarInputSchema,
+  projectCalendarSchema,
+  projectGroupKey,
+  publishedReleaseSchema,
+  questSettingsInputSchema,
+  snapshotSchema,
+  staffDecisionSchema,
+  stockItemSchema,
+  submitSchema,
+  trackerContentReadSchema,
+  trackerContentSchema,
+  trackerControlSchema,
+  trackerIngestResultSchema,
+  trackerIngestSchema,
+  trackerOutcomePageSchema,
+  trackerOutcomeQuerySchema,
+  trackerOutcomeRetrySchema,
+  trackerOutcomeSchema,
+  trackerPageSchema,
+  trackerPreviewInputSchema,
+  trackerPreviewSchema,
+  trackerQuerySchema,
+  trackerStatusSchema,
+  trackerSummarySchema
+} from "../chunk-JON5SESL.js";
+
+// src/server/webhooks.ts
+import { z } from "zod";
+var webhookEventSchema = z.object({
+  id: z.string().uuid(),
+  version: z.literal(1),
+  type: activityTypeSchema,
+  createdAt: z.number().int().nonnegative(),
+  organization: z.string(),
+  project: z.string(),
+  environment: z.enum(["test", "live"]),
+  data: z.record(z.string(), z.json())
+});
+var webhookInputSchema = z.object({
+  url: z.url().max(2048).refine((value) => {
+    const url = new URL(value);
+    return url.protocol === "https:" && !url.username && !url.password && !url.hash;
+  }, "Use an HTTPS URL without credentials or a fragment"),
+  types: z.array(activityTypeSchema).min(1).max(100).refine((v) => new Set(v).size === v.length)
+}).strict();
+var webhookUpdateSchema = webhookInputSchema.partial().extend({ enabled: z.boolean().optional() }).strict();
+var webhookEndpointSchema = z.object({
+  ...webhookInputSchema.shape,
+  id: z.string().uuid(),
+  enabled: z.boolean(),
+  disabledReason: z.string().nullable(),
+  consecutiveFailures: z.number().int().nonnegative(),
+  createdAt: z.number(),
+  updatedAt: z.number()
+});
+var webhookSecretSchema = z.object({
+  endpoint: webhookEndpointSchema,
+  secret: z.string(),
+  previousValidUntil: z.number().nullable()
+});
+var webhookDeliverySchema = z.object({
+  id: z.string().uuid(),
+  endpoint: z.string().uuid(),
+  event: webhookEventSchema,
+  status: z.enum(["pending", "delivered", "failed", "skipped"]),
+  attempts: z.number().int().nonnegative(),
+  responseStatus: z.number().nullable(),
+  lastError: z.string().nullable(),
+  createdAt: z.number(),
+  deliveredAt: z.number().nullable(),
+  replayOf: z.string().uuid().nullable()
+});
+var webhookQuerySchema = z.object({
+  before: z.string().uuid().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(50)
+}).strict();
+var webhookDeliveryPageSchema = z.object({
+  items: z.array(webhookDeliverySchema),
+  next: z.string().uuid().nullable()
+});
+var WEBHOOK_MAX_BYTES = 64 * 1024;
+async function verifyWebhook(input) {
+  const bytes = new TextEncoder().encode(input.body);
+  const tolerance = input.toleranceSeconds ?? 300;
+  const now = input.now ?? Date.now();
+  if (bytes.length > WEBHOOK_MAX_BYTES || !Number.isFinite(now) || !Number.isFinite(tolerance) || tolerance < 0 || tolerance > 300) {
+    throw new Error("Invalid webhook verification input");
+  }
+  const parts = input.signature.split(",");
+  const timestamps = parts.filter((part) => part.startsWith("t="));
+  const timestamp = timestamps[0]?.slice(2) ?? "";
+  const signatures = parts.filter((part) => /^v1=[a-f0-9]{64}$/.test(part)).map((part) => part.slice(3));
+  if (timestamps.length !== 1 || !/^\d{1,12}$/.test(timestamp) || Math.abs(now / 1e3 - Number(timestamp)) > tolerance || signatures.length < 1 || signatures.length > 2) {
+    throw new Error("Invalid or expired webhook signature");
+  }
+  const secrets = typeof input.secret === "string" ? [input.secret] : input.secret;
+  const message = new TextEncoder().encode(`${timestamp}.${input.body}`);
+  for (const secret of secrets) {
+    if (!secret) {
+      continue;
+    }
+    const key = await crypto.subtle.importKey(
+      "raw",
+      new TextEncoder().encode(secret),
+      { name: "HMAC", hash: "SHA-256" },
+      false,
+      ["verify"]
+    );
+    for (const signature of signatures) {
+      const digest = Uint8Array.from(
+        signature.match(/../g) ?? [],
+        (byte) => Number.parseInt(byte, 16)
+      );
+      if (await crypto.subtle.verify("HMAC", key, digest, message)) {
+        return webhookEventSchema.parse(JSON.parse(input.body));
+      }
+    }
+  }
+  throw new Error("Invalid webhook signature");
+}
+
+// src/server/resource-lifecycle.ts
+import { z as z2 } from "zod";
+var resourceLifecycleKindSchema = z2.enum([
+  "tracker",
+  "referral",
+  "leaderboard",
+  "engagement",
+  "collection",
+  "quest-type",
+  "image",
+  "point-ledger"
+]);
+var managedResourceSchema = z2.object({
+  kind: resourceLifecycleKindSchema,
+  id: identifier,
+  key: identifier.nullable(),
+  title: z2.string(),
+  archivedAt: z2.number().int().nonnegative().nullable()
+});
+var resourceLifecycleInputSchema = z2.object({
+  actionId: z2.string().uuid(),
+  kind: resourceLifecycleKindSchema,
+  resource: identifier,
+  archived: z2.boolean(),
+  reason: z2.string().trim().min(1).max(500),
+  expectedArchivedAt: z2.number().int().nonnegative().nullable().optional()
+}).strict();
+var resourceLifecycleResultSchema = z2.object({
+  resource: managedResourceSchema,
+  changed: z2.boolean()
+});
+
+// src/server/index.ts
+import { z as z7 } from "zod";
+
+// src/server/errors.ts
+var ManagementErrorCode = {
+  /** The input or an option failed validation before anything was sent (kind `client`). */
+  InvalidInput: "invalid-input",
+  /** The client's `getToken` failed before anything was sent (kind `client` or `network`). */
+  Credential: "credential",
+  Network: "network",
+  Timeout: "timeout",
+  Aborted: "aborted",
+  InvalidResponse: "invalid-response"
+};
+var uncertainStatuses = /* @__PURE__ */ new Set([500, 502, 504]);
+function uncertainOutcome(init) {
+  if (init.method === void 0 || init.method === "GET") {
+    return false;
+  }
+  switch (init.kind) {
+    case "network":
+    case "timeout":
+    case "aborted":
+      return true;
+    case "http":
+      return uncertainStatuses.has(init.status ?? 0);
+    case "invalid-response":
+      return (init.status ?? 0) >= 200 && (init.status ?? 0) < 300;
+    default:
+      return false;
+  }
+}
+var managementErrorBrand = /* @__PURE__ */ Symbol.for("@domino-sdk/relay.ManagementError");
+function isManagementError(value) {
+  return isRequestError(value) && value[managementErrorBrand] === true;
+}
+var ManagementError = class extends RequestError {
+  name = "ManagementError";
+  [managementErrorBrand] = true;
+  /** The rest of the server's error body besides `error` and `code`, such as `moved`; absent when there is none. */
+  details;
+  /** The request's method; absent when the call failed before forming a request. */
+  method;
+  /** The management API path, below `/management/v1`, without its query; absent like `method`. */
+  path;
+  constructor(init) {
+    super(init.message, {
+      kind: init.kind,
+      uncertain: init.uncertain ?? uncertainOutcome(init),
+      status: init.status,
+      code: init.code,
+      operationId: init.actionId,
+      replaySafe: init.replaySafe,
+      retryAfter: init.retryAfter,
+      cause: init.cause
+    });
+    this.details = init.details && Object.keys(init.details).length ? init.details : void 0;
+    this.method = init.method;
+    this.path = init.path;
+  }
+};
+var DEFAULT_MANAGEMENT_TIMEOUT = MANAGEMENT_TIMEOUT;
+
+// src/server/hosting.ts
+import { z as z4 } from "zod";
+
+// src/server/starters.ts
+import { z as z3 } from "zod";
+var starterTemplates = [
+  {
+    id: "campaign",
+    title: "Campaign tour",
+    summary: "A neutral quest app with a guided tour of every quest kind. The blank canvas for anything."
+  },
+  {
+    id: "classic",
+    title: "Classic questboard",
+    summary: "The familiar Domino portal: quests in a grid grouped by section, a claim page, points, and a leaderboard."
+  },
+  {
+    id: "waitlist",
+    title: "Waitlist",
+    summary: "Collect sign-ups before launch. People move up the line by inviting friends."
+  },
+  {
+    id: "referral",
+    title: "Referral program",
+    summary: "Give every member an invite link and reward them when friends join and qualify."
+  },
+  {
+    id: "discord",
+    title: "Discord activation",
+    summary: "Turn new Discord members into regulars with quests for joining, introducing themselves, and taking part, rewarded with roles."
+  },
+  {
+    id: "api",
+    title: "API",
+    summary: "A headless Worker with typed routes and interactive API docs, for plugging Domino into your own product."
+  }
+];
+var starterIdSchema = z3.enum(
+  starterTemplates.map((template) => template.id)
+);
+
+// src/server/hosting.ts
+var outputPathSchema = z4.string().min(1).max(512).refine(
+  (path) => path.split("/").every(
+    (part) => /^[\w-][\w.-]*$/.test(part) && part !== "node_modules"
+  ),
+  "Expected a relative build output path without hidden segments"
+);
+var appRoutingSchema = z4.enum(["legacy", "transparent"]).default("legacy");
+var APP_SECRET_LIMIT = 50;
+var appSecretNameSchema = z4.string().regex(
+  /^[A-Z_][A-Z0-9_]{0,63}$/,
+  "Use 1-64 uppercase letters, digits, and underscores, not starting with a digit"
+).refine(
+  (name) => !name.startsWith("DOMINO_") && name !== "ASSETS",
+  "DOMINO_ names and ASSETS are reserved for Domino's own bindings"
+);
+var appSecretValueSchema = z4.string().min(1).refine(
+  (value) => new TextEncoder().encode(value).length <= 5120,
+  "Secret values can be at most 5 KiB"
+);
+var appSecretInputSchema = z4.object({ value: appSecretValueSchema }).strict();
+var appSecretSchema = z4.object({
+  name: appSecretNameSchema,
+  updatedAt: z4.number(),
+  updatedBy: z4.string()
+});
+var appSecretDeclarationSchema = z4.object({
+  description: z4.string().trim().min(1).max(500),
+  required: z4.boolean().default(true)
+}).strict();
+var appSecretDeclarationsSchema = z4.record(appSecretNameSchema, appSecretDeclarationSchema).refine(
+  (secrets) => Object.keys(secrets).length <= APP_SECRET_LIMIT,
+  `Declare at most ${APP_SECRET_LIMIT} app secrets`
+);
+var appSecretListSchema = z4.object({
+  secrets: z4.array(appSecretSchema),
+  declared: z4.array(appSecretDeclarationSchema.extend({ name: appSecretNameSchema })).default([])
+});
+var hostedAppSecretsSchema = z4.object({ secrets: z4.record(appSecretNameSchema, appSecretValueSchema) }).strict();
+var appScripts = {
+  routing: appRoutingSchema,
+  devScript: z4.string().regex(/^[\w:-]+$/),
+  checkScript: z4.string().regex(/^[\w:-]+$/),
+  buildScript: z4.string().regex(/^[\w:-]+$/)
+};
+var workerSettings = {
+  runWorkerFirst: z4.boolean().default(false),
+  main: outputPathSchema.refine(
+    (path) => /\.m?js$/.test(path),
+    "Expected a compiled JavaScript entry"
+  ),
+  compatibilityDate: z4.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  compatibilityFlags: z4.array(z4.string().min(1)).max(50).default([]),
+  vars: z4.record(
+    z4.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).refine((name) => name !== "ASSETS"),
+    z4.string()
+  ).default({}),
+  secrets: appSecretDeclarationsSchema.default({})
+};
+var distinctBindings = (worker) => !Object.keys(worker.secrets).some((name) => name in worker.vars);
+var distinctBindingsMessage = {
+  message: "A name can't be both an app var and a declared secret",
+  path: ["secrets"]
+};
+var hostedAppSchema = z4.discriminatedUnion("kind", [
+  z4.object({
+    kind: z4.literal("static"),
+    directory: outputPathSchema,
+    ...appScripts
+  }).strict(),
+  z4.object({
+    kind: z4.literal("worker"),
+    directory: outputPathSchema,
+    assetsDirectory: outputPathSchema.optional(),
+    ...appScripts,
+    ...workerSettings
+  }).strict().refine(distinctBindings, distinctBindingsMessage)
+]);
+var repositorySchema = z4.object({
+  id: z4.string().uuid(),
+  organization: identifier,
+  project: identifier,
+  remote: z4.string().url(),
+  defaultBranch: z4.string(),
+  status: z4.enum(["provisioning", "ready"])
+});
+var createRepositorySchema = z4.object({
+  /** Omitted: the starter chosen at project setup, else `campaign`. */
+  starter: starterIdSchema.optional()
+}).strict();
+var deviceStartSchema = z4.object({
+  challenge: z4.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var deviceRedeemSchema = z4.object({
+  id: z4.string().uuid(),
+  verifier: z4.string().min(43).max(128)
+}).strict();
+var deviceApproveSchema = z4.object({
+  id: z4.string().uuid(),
+  code: z4.string().regex(/^[A-F0-9]{4}-[A-F0-9]{4}$/)
+}).strict();
+var commitSchema = z4.string().regex(/^[a-f0-9]{40}$/);
+var stageRequestSchema = z4.object({
+  commit: commitSchema,
+  requestId: z4.string().uuid()
+}).strict();
+var buildIdentitySchema = z4.object({
+  routing: appRoutingSchema,
+  slug: z4.string().min(1).max(35).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional(),
+  runtime: z4.enum(["simulation", "hosted-test"]).default("simulation"),
+  id: z4.string().uuid(),
+  repository: z4.string().uuid(),
+  organization: identifier,
+  project: identifier,
+  commit: commitSchema,
+  createdAt: z4.number(),
+  actor: z4.string(),
+  commitMessage: z4.string().max(500).optional()
+});
+var buildPhaseSchema = z4.enum([
+  "queued",
+  "source",
+  "install",
+  "check",
+  "build",
+  "deploy",
+  "ready",
+  "failed"
+]);
+var buildStatusSchema = z4.object({
+  phase: buildPhaseSchema,
+  failedPhase: buildPhaseSchema.optional(),
+  updatedAt: z4.number(),
+  message: z4.string()
+});
+var hostedBuildSchema = buildIdentitySchema.extend({
+  ...buildStatusSchema.shape,
+  finished: z4.boolean(),
+  current: z4.boolean(),
+  stagingUrl: z4.string().url()
+});
+var stagingAccessModeSchema = z4.enum(["console", "password"]);
+var stagingAccessSchema = z4.object({ mode: stagingAccessModeSchema });
+var stagingAccessInputSchema = z4.discriminatedUnion("mode", [
+  z4.object({ mode: z4.literal("console") }).strict(),
+  z4.object({
+    mode: z4.literal("password"),
+    password: z4.string().min(8).max(128)
+  }).strict()
+]);
+var stagingPathSchema = z4.string().max(2048).refine(
+  (path) => path.startsWith("/") && !path.startsWith("//") && !path.includes("\\"),
+  "Expected a path on the staging host"
+);
+var stagingLinkSchema = z4.object({
+  url: z4.string().url(),
+  expiresAt: z4.number()
+});
+var buildSnapshotSchema = z4.object({
+  builds: z4.array(hostedBuildSchema),
+  current: hostedBuildSchema.nullable(),
+  selected: hostedBuildSchema.nullable(),
+  logs: z4.string()
+});
+var assetPathSchema = z4.string().max(512).refine(
+  (path) => path.startsWith("/") && // oxlint-disable-next-line no-control-regex -- Asset paths must reject control characters.
+  !/[\\\u0000-\u001f?#%]/.test(path) && path.slice(1).split("/").every((part) => part.length > 0 && !part.startsWith(".")),
+  "Expected a public asset path without hidden segments"
+);
+var base64Schema = z4.string().regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/);
+var stagedDeploymentLimits = {
+  /** Bytes of JSON, uncompressed. */
+  size: 64e6,
+  /** Bytes of the Brotli-compressed object. */
+  compressedSize: 1e7
+};
+var stagedDeploymentSchema = z4.object({
+  encoding: z4.literal("br"),
+  sha256: z4.string().regex(/^[0-9a-f]{64}$/),
+  compressedSize: z4.number().int().positive().max(stagedDeploymentLimits.compressedSize),
+  size: z4.number().int().positive().max(stagedDeploymentLimits.size)
+}).strict();
+var stagedDeploymentContentSchema = stagedDeploymentSchema.extend({
+  content: z4.string().max(Math.ceil(stagedDeploymentLimits.compressedSize / 3) * 4)
+}).strict();
+var stagedDeploymentKey = (build, sha256) => `builds/${build}/deployment/${sha256}.br`;
+var artifactFields = {
+  routing: appRoutingSchema,
+  worker: z4.object({
+    ...workerSettings,
+    modules: z4.array(
+      z4.object({
+        path: outputPathSchema.refine((path) => path !== "metadata"),
+        type: z4.enum([
+          "application/javascript+module",
+          "application/wasm",
+          "text/plain",
+          "application/octet-stream"
+        ]),
+        content: base64Schema.max(14e6)
+      }).strict()
+    ).min(1).max(500)
+  }).strict().refine(distinctBindings, distinctBindingsMessage).optional(),
+  assets: z4.array(
+    z4.object({
+      path: assetPathSchema,
+      content: base64Schema.max(14e6),
+      size: z4.number().int().min(0).max(1e7)
+    }).strict()
+  ).max(500)
+};
+var buildArtifactsSchema = z4.discriminatedUnion("format", [
+  z4.object({
+    format: z4.literal(1),
+    ...artifactFields,
+    quests: z4.unknown(),
+    catalog: z4.unknown()
+  }).strict(),
+  z4.object({
+    format: z4.literal(2),
+    ...artifactFields,
+    deployment: stagedDeploymentSchema,
+    images: z4.array(imageAssetArtifactSchema).max(10)
+  }).strict()
+]).superRefine((value, ctx) => {
+  if (value.worker) {
+    const modules = value.worker.modules;
+    if (new Set(modules.map((m) => m.path)).size !== modules.length) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Duplicate Worker module paths"
+      });
+    }
+    if (!modules.some(
+      (m) => m.path === value.worker?.main && m.type === "application/javascript+module"
+    )) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Worker entry module is missing"
+      });
+    }
+    if (modules.reduce(
+      (sum, m) => sum + m.content.length * 3 / 4 - (m.content.endsWith("==") ? 2 : m.content.endsWith("=") ? 1 : 0),
+      0
+    ) > 1e7) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Worker modules exceed 10 MB"
+      });
+    }
+  }
+  if (new Set(value.assets.map((a) => a.path)).size !== value.assets.length) {
+    ctx.addIssue({ code: "custom", message: "Duplicate asset paths" });
+  }
+  if (!value.worker && !value.assets.some((a) => a.path === "/index.html")) {
+    ctx.addIssue({
+      code: "custom",
+      message: "Build must include index.html"
+    });
+  }
+  if (value.assets.reduce((sum, a) => sum + a.size, 0) > 1e7) {
+    ctx.addIssue({ code: "custom", message: "Staging assets exceed 10 MB" });
+  }
+});
+
+// src/server/development.ts
+import { z as z5 } from "zod";
+var developmentPreflightSchema = z5.object({
+  organization: z5.string(),
+  project: z5.string(),
+  environment: z5.enum(["test", "live"]),
+  identity: z5.object({
+    exchange: z5.literal("supported"),
+    activeIntegrations: z5.number().int().nonnegative()
+  }).optional(),
+  staging: z5.enum(["configured", "blocked"]),
+  development: z5.object({
+    status: z5.enum(["configured", "blocked"]),
+    // How `domino dev` reaches the preview origin: a Cloudflare tunnel, or a direct route on a
+    // local development stack. APIs that predate the field use tunnels.
+    transport: z5.enum(["tunnel", "direct"]).default("tunnel"),
+    missing: z5.array(z5.string()),
+    authentication: z5.array(z5.string())
+  }),
+  checks: z5.array(
+    z5.object({
+      id: z5.string(),
+      status: z5.enum(["ok", "error"]),
+      message: z5.string(),
+      missing: z5.array(z5.string()).optional(),
+      issues: z5.array(z5.string()).optional()
+    })
+  )
+});
+
+// src/server/hosted.ts
+import { z as z6 } from "zod";
+var hostedKeyPermissions = ["read", "points", "ingest"];
+var hostedKeyPermissionList = z6.array(z6.string()).transform(
+  (values) => values.filter(
+    (value) => hostedKeyPermissions.includes(value)
+  )
+);
+var hostedManagementBindings = [
+  "DOMINO_MANAGEMENT_KEY",
+  "DOMINO_API_URL",
+  "DOMINO_ORGANIZATION",
+  "DOMINO_PROJECT",
+  "DOMINO_ENVIRONMENT"
+];
+var hostedKeySecretSchema = z6.string().regex(/^dhk_[A-Za-z0-9_-]{43}$/, "Expected a hosted app key");
+var hostedKeySchema = z6.object({
+  id: z6.string().uuid(),
+  token: hostedKeySecretSchema,
+  organization: identifier,
+  project: identifier,
+  environment: z6.enum(["test", "live"]),
+  permissions: hostedKeyPermissionList,
+  expiresAt: z6.number().nullable()
+}).strict();
+var hostedDeploymentKeySchema = hostedKeySchema.extend({ apiUrl: z6.string().url() }).strict();
+function hostedManagementClient(env) {
+  const missing = hostedManagementBindings.filter((name) => !env[name]);
+  if (missing.length) {
+    throw new Error(
+      `Missing ${missing.join(", ")}. Domino sets these for hosted apps and domino dev; update the project's vite.config.ts to forward them in development.`
+    );
+  }
+  const environment = z6.enum(["test", "live"]).parse(env.DOMINO_ENVIRONMENT);
+  const token = env.DOMINO_MANAGEMENT_KEY;
+  return createManagementClient({
+    baseUrl: env.DOMINO_API_URL.replace(/\/+$/, ""),
+    getToken: async () => token,
+    organization: env.DOMINO_ORGANIZATION,
+    project: env.DOMINO_PROJECT,
+    environment
+  });
+}
+
+// src/server/index.ts
+var environmentSchema = z7.enum(["test", "live"]);
+var roleSchema = z7.enum(["editor", "reviewer", "staff"]);
+var permissionSchema = z7.enum([
+  "read",
+  "publish",
+  "review",
+  "confirm",
+  "handover",
+  "inventory",
+  "access",
+  "points",
+  /**
+   * Custom tracker ingestion only (`trackers.ingest`), such as for an indexer's key. Editors and
+   * hosted-app keys hold it.
+   */
+  "ingest",
+  /**
+   * Enrolling members from a server (`quests.enroll`), which vouches for their consent. Editors
+   * hold it; hosted-app keys do not.
+   */
+  "enroll"
+]);
+var permissionListSchema = z7.array(z7.string()).transform(
+  (values) => values.filter(
+    (value) => permissionSchema.safeParse(value).success
+  )
+);
+var rolePermissions = {
+  editor: ["read", "publish", "inventory", "points", "ingest", "enroll"],
+  reviewer: ["read", "review"],
+  staff: ["read", "confirm", "handover"]
+};
+var projectSetupSchema = z7.object({
+  mode: z7.enum(["new", "existing"]),
+  brief: z7.string().trim().min(1).max(4e3)
+}).strict();
+var projectSchema = z7.object({
+  slug: z7.string().min(1).max(35).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+  /** A response, so fields a newer server adds to the setup are dropped, not rejected. */
+  setup: z7.object(projectSetupSchema.shape).optional(),
+  /** The starter chosen at setup. A plain string, so later starters still parse. */
+  starter: z7.string().optional(),
+  id: z7.string().min(1),
+  organization: identifier,
+  project: identifier,
+  name: z7.string(),
+  subtitle: z7.string(),
+  initials: z7.string(),
+  color: z7.string(),
+  permissions: permissionListSchema,
+  environments: z7.array(environmentSchema)
+});
+var projectInputSchema = z7.object({
+  actionId: identifier,
+  name: z7.string().trim().min(1).max(80),
+  setup: projectSetupSchema.optional(),
+  /** The starter a new hosted app begins from, with `setup.mode` "new". */
+  starter: starterIdSchema.optional()
+}).strict();
+var projectDeletionInputSchema = z7.object({ confirm: z7.string().min(1).max(80) }).strict();
+var projectDeletionSchema = z7.object({
+  project: identifier,
+  purgeAfter: z7.number().int()
+});
+var projectTransferInputSchema = z7.object({ organization: identifier, confirm: z7.string().min(1).max(80) }).strict();
+var projectTransferSchema = z7.object({
+  organization: identifier,
+  project: identifier
+});
+var grantSchema = z7.object({
+  subject: z7.string().min(1).max(200),
+  roles: z7.array(roleSchema),
+  environments: z7.array(environmentSchema)
+}).strict();
+var grantRecordSchema = z7.object(grantSchema.shape);
+var stockAdditionSchema = z7.object({
+  item: identifier,
+  quantity: z7.number().int(),
+  actionId: identifier
+});
+var completionRevokeSchema = z7.object({
+  actionId: identifier,
+  reason: z7.string().trim().min(1).max(500),
+  freeOccurrence: z7.boolean().default(false)
+}).strict();
+var RevokedEntitlementOutcome = {
+  /** No other completion grants the reward: it is void, after cancelling a handover in progress. */
+  Voided: "voided",
+  /** Lowered to the best tier another completion grants, after cancelling a handover in progress. */
+  Downgraded: "downgraded",
+  /** Another completion grants the same tier, or it was already void. */
+  Kept: "kept",
+  /** Already collected: its earned tier follows the other completions, and the item stays handed over. */
+  Flagged: "flagged"
+};
+var RevokedDeliveryOutcome = {
+  /** The role was delivered and stays: remove it in Discord if appropriate. */
+  Flagged: "flagged",
+  /** The grant was stopped before any call to Discord. */
+  Cancelled: "cancelled",
+  /** The grant was stopped, but a call to Discord may already have been sent and can still land. */
+  InFlight: "in-flight",
+  /** The grant had failed, so Discord never received the role. */
+  NotDelivered: "not-delivered"
+};
+var RevokedReferralOutcome = {
+  /** The inviter's rewards for this member are reversed. */
+  Unqualified: "unqualified",
+  /** Qualified on another accepted completion of the program's quest instead. */
+  Requalified: "requalified"
+};
+var entitlementOutcomeSchema = z7.string().min(1).max(64);
+var deliveryOutcomeSchema = z7.string().min(1).max(64);
+var referralOutcomeSchema = z7.string().min(1).max(64);
+var completionRevocationSchema = z7.object({
+  completion: identifier,
+  quest: identifier,
+  member: identifier,
+  revokedAt: z7.number(),
+  occurrenceFreed: z7.boolean(),
+  points: z7.array(
+    z7.object({
+      entry: identifier,
+      balance: identifier,
+      reversal: identifier.nullable(),
+      reversed: z7.number().int(),
+      unreversed: z7.number().int()
+    })
+  ),
+  entitlements: z7.array(
+    z7.object({
+      entitlement: identifier,
+      reward: identifier,
+      outcome: entitlementOutcomeSchema,
+      status: z7.string()
+    })
+  ),
+  deliveries: z7.array(
+    z7.object({
+      delivery: z7.string(),
+      roleId: z7.string(),
+      outcome: deliveryOutcomeSchema,
+      /**
+       * By Relay's records, another accepted, unrevoked completion of the member also granted this
+       * role to the same Discord account and server. Relay does not read Discord's membership.
+       */
+      stillGranted: z7.boolean()
+    })
+  ),
+  referrals: z7.array(
+    z7.object({
+      program: identifier,
+      outcome: referralOutcomeSchema
+    })
+  ),
+  streakMilestone: z7.boolean()
+});
+var accessSchema = z7.object({
+  actor: z7.string(),
+  organization: z7.string(),
+  admin: z7.boolean(),
+  local: z7.boolean(),
+  projects: z7.array(projectSchema)
+});
+var querySchema = z7.object({
+  q: z7.string().max(200).default(""),
+  filter: z7.string().max(50).default("all"),
+  offset: z7.coerce.number().int().min(0).max(1e6).default(0),
+  limit: z7.coerce.number().int().min(1).max(100).default(25)
+});
+var accountProfileSchema = z7.object({
+  name: z7.string().optional(),
+  /** The account's handle, where the provider has one (X and Discord). */
+  username: z7.string().optional(),
+  email: z7.string().optional(),
+  emailVerified: z7.boolean().default(false),
+  imageUrl: z7.string().url().optional()
+});
+var memberAccountSchema = z7.object({
+  /** `wallet` for wallet sign-in, `account` for every other connected account. */
+  kind: z7.enum(["account", "wallet"]),
+  provider: z7.string(),
+  subject: z7.string(),
+  signInEnabled: z7.boolean(),
+  profile: accountProfileSchema.optional()
+});
+var operationSchema = z7.object({
+  target: z7.string(),
+  paused: z7.boolean(),
+  revision: z7.number().int(),
+  reason: z7.string(),
+  actor: z7.string().nullable(),
+  changedAt: z7.number()
+});
+var operationInputSchema = z7.object({
+  target: z7.union([
+    z7.literal("redemptions"),
+    z7.string().regex(/^quest:[\w-]+$/)
+  ]),
+  paused: z7.boolean(),
+  revision: z7.number().int().nonnegative(),
+  reason: z7.string().trim().min(1).max(500),
+  actionId: identifier
+}).strict();
+var questLifecycleInputSchema = z7.object({
+  quest: identifier,
+  expectedRelease: identifier.optional(),
+  archived: z7.boolean(),
+  reason: z7.string().trim().min(1).max(500),
+  actionId: identifier
+}).strict();
+var questLifecycleSchema = z7.object({
+  quest: identifier,
+  key: identifier.nullable(),
+  title: z7.string(),
+  release: identifier,
+  lifecycle: z7.enum(["active", "paused", "archived"]),
+  changed: z7.boolean()
+});
+var memberSchema = z7.object({
+  id: z7.string(),
+  accounts: z7.array(memberAccountSchema).default([]),
+  attempts: z7.number(),
+  completions: z7.number(),
+  rewards: z7.number(),
+  lastActivity: z7.number().nullable()
+});
+var personSchema = z7.object({
+  id: z7.string(),
+  accounts: z7.array(memberAccountSchema).default([])
+});
+var metricsSchema = z7.object({
+  quests: z7.number(),
+  members: z7.number(),
+  attempts: z7.number(),
+  completions: z7.number(),
+  review: z7.number(),
+  failed: z7.number(),
+  entitlements: z7.number()
+});
+var readinessSchema = z7.object({
+  checks: z7.array(
+    z7.object({
+      id: z7.string(),
+      status: z7.enum(["ready", "blocked"]),
+      title: z7.string(),
+      detail: z7.string()
+    })
+  )
+});
+var inventorySchema = z7.object({
+  item: z7.string(),
+  name: z7.string().nullable().default(null),
+  available: z7.number(),
+  reserved: z7.number(),
+  allocated: z7.number().default(0)
+});
+var auditRecordSchema = z7.object({
+  id: z7.string(),
+  action: z7.string(),
+  actor: z7.string().nullable(),
+  detail: z7.string(),
+  at: z7.number(),
+  attempt: z7.string().nullable()
+});
+var pageSchema = z7.object({
+  snapshot: snapshotSchema,
+  members: z7.array(memberSchema),
+  people: z7.array(personSchema).default([]),
+  metrics: metricsSchema,
+  total: z7.number(),
+  offset: z7.number(),
+  limit: z7.number(),
+  inventory: z7.array(inventorySchema),
+  operations: z7.array(operationSchema).default([]),
+  audit: z7.array(auditRecordSchema).default([]),
+  questCounts: z7.record(z7.string(), z7.number())
+});
+var managedOAuthAccountBaseSchema = z7.object({
+  provider: z7.enum(["x", "discord"]),
+  revision: z7.number().int().nonnegative()
+});
+var managedOAuthAccountSchema = z7.discriminatedUnion("status", [
+  managedOAuthAccountBaseSchema.extend({
+    status: z7.literal("connected"),
+    subject: z7.string().min(1),
+    linkedAt: z7.number()
+  }),
+  managedOAuthAccountBaseSchema.extend({ status: z7.literal("disconnected") })
+]);
+var memberOAuthUnlinkInputSchema = z7.object({
+  provider: z7.enum(["x", "discord"]),
+  subject: z7.string().min(1).max(4096),
+  revision: z7.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER - 1),
+  reason: z7.string().trim().min(1).max(500)
+}).strict();
+var managedWalletSchema = linkedWalletSchema.extend({
+  status: z7.enum(["linked", "unlinked"]),
+  unlinkedAt: z7.number().int().nullable(),
+  /** "member", or the operator or key that unlinked it. */
+  unlinkedBy: z7.string().nullable()
+});
+var managedMemberIdentitySchema = memberIdentitySchema.extend({
+  status: z7.enum(["linked", "unlinked"]),
+  unlinkedAt: z7.number().int().nullable(),
+  /** The operator or key that unlinked it. */
+  unlinkedBy: z7.string().nullable()
+});
+var memberIdentityChangeInputSchema = z7.object({
+  kind: appIdentityKindSchema,
+  subject: z7.string().min(1).max(256),
+  reason: z7.string().trim().min(1).max(500)
+}).strict();
+var balanceCheckSchema = walletBalanceSchema.pick({
+  chain: true,
+  token: true,
+  decimals: true,
+  total: true,
+  wallets: true,
+  observedAt: true
+}).extend({ attempt: identifier });
+var walletBalanceChainsSchema = z7.object({
+  chains: z7.array(
+    z7.object({
+      chain: z7.union([
+        z7.literal(solanaMainnet),
+        cosmosNetworkSchema,
+        evmChainIdSchema
+      ]),
+      name: z7.string(),
+      testnet: z7.boolean()
+    })
+  )
+});
+var memberWalletUnlinkInputSchema = walletUnlinkInputSchema.extend({ reason: z7.string().trim().min(1).max(500) }).strict();
+var memberWalletSignInInputSchema = walletUnlinkInputSchema.extend({
+  enabled: z7.boolean(),
+  reason: z7.string().trim().min(1).max(500)
+}).strict();
+var participantSignInSchema = z7.object({
+  providers: z7.array(
+    z7.object({ provider: authProviderSchema, configured: z7.boolean() })
+  ),
+  email: z7.boolean(),
+  /** Wallet families: `"solana"`, `"eip155"`, `"cosmos"`. */
+  wallets: walletSignInNetworksSchema,
+  /** Why participants cannot sign in to this project, or null. */
+  issue: z7.string().nullable(),
+  updatedAt: z7.number().nullable(),
+  updatedBy: z7.string().nullable()
+});
+var participantSignInInputSchema = z7.object({
+  wallets: walletSignInNetworksSchema
+}).strict();
+var memberDetailSchema = z7.object({
+  snapshot: snapshotSchema,
+  member: memberSchema,
+  progress: memberProgressSchema,
+  /** Current and historical campaign enrollment state, including inactive enrollments. */
+  campaignEnrollments: z7.array(campaignEnrollmentSchema).default([]),
+  passes: z7.array(
+    z7.object({
+      provider: z7.string(),
+      event: z7.string(),
+      subject: z7.string(),
+      attempt: identifier.nullable()
+    })
+  ).default([]),
+  /** Linked and unlinked wallets. */
+  wallets: z7.array(managedWalletSchema),
+  /** The member's 10 most recent recorded balance reads, newest first. */
+  balanceChecks: z7.array(balanceCheckSchema),
+  /** The member's participant profile in this project. */
+  profile: managedProfileSchema.nullable(),
+  /**
+   * The identities trackers attribute records to this member through, besides wallets and the
+   * member ID: their selected X and Discord accounts and their `app:<name>` identities in this
+   * project, including app identities an operator unlinked, by kind.
+   */
+  identities: z7.array(managedMemberIdentitySchema)
+});
+var stockInputSchema = z7.object({
+  item: identifier,
+  quantity: z7.number().int().positive().max(1e6),
+  actionId: identifier
+}).strict();
+var ingestTrackerScopeSchema = z7.array(identifier).min(1).max(100).nullable();
+var tokenScopeInputSchema = z7.object({ ingestTrackers: ingestTrackerScopeSchema }).strict();
+var tokenInputSchema = z7.object({
+  name: z7.string().trim().min(1).max(80),
+  project: identifier,
+  environment: environmentSchema,
+  permissions: z7.array(permissionSchema).min(1),
+  ingestTrackers: ingestTrackerScopeSchema.optional(),
+  days: z7.number().int().min(1).max(90).default(30)
+}).strict();
+var tokenSchema = z7.object({
+  id: z7.string(),
+  name: z7.string(),
+  project: z7.string(),
+  environment: environmentSchema,
+  permissions: permissionListSchema,
+  ingestTrackers: ingestTrackerScopeSchema.optional(),
+  expiresAt: z7.number()
+});
+var issuedTokenSchema = tokenSchema.extend({ token: z7.string() });
+var teamSchema = z7.array(
+  z7.object({ id: z7.string(), label: z7.string() })
+);
+var memberLookupSchema = z7.object({
+  provider: z7.string().min(1).max(200),
+  subject: z7.string().min(1).max(2048)
+}).strict();
+var verifiedPassSchema = z7.object({
+  provider: identifier,
+  event: identifier,
+  subject: z7.string().min(1).max(2048),
+  member: identifier,
+  quest: identifier
+}).strict();
+function withActionId(input) {
+  return { ...input, actionId: input.actionId ?? crypto.randomUUID() };
+}
+function actionIdOf(input) {
+  return typeof input === "object" && input !== null && "actionId" in input && typeof input.actionId === "string" ? input.actionId : void 0;
+}
+function queryString(values) {
+  const query = new URLSearchParams(
+    Object.entries(values).flatMap(
+      ([key, value]) => value === void 0 ? [] : [[key, String(value)]]
+    )
+  ).toString();
+  return query ? "?" + query : "";
+}
+var serverErrorSchema = z7.looseObject({
+  error: z7.string(),
+  code: z7.string().optional()
+});
+function checkedTimeout(timeout) {
+  if (timeout !== void 0 && !validTimeout(timeout)) {
+    throw new ManagementError({
+      kind: "client",
+      code: ManagementErrorCode.InvalidInput,
+      message: "Management timeout must be a positive, finite number of milliseconds"
+    });
+  }
+  return timeout;
+}
+function clientFailure(error) {
+  if (error instanceof ManagementError) {
+    return error;
+  }
+  return new ManagementError({
+    kind: "client",
+    code: ManagementErrorCode.InvalidInput,
+    message: error instanceof z7.ZodError ? `Invalid management request: ${z7.prettifyError(error)}` : error instanceof Error ? error.message : "Invalid management request",
+    cause: error
+  });
+}
+function guarded(api) {
+  return Object.fromEntries(
+    Object.entries(api).map(([key, value]) => [
+      key,
+      typeof value === "function" ? (...args) => {
+        try {
+          return Promise.resolve(value(...args)).catch((error) => {
+            throw clientFailure(error);
+          });
+        } catch (error) {
+          return Promise.reject(clientFailure(error));
+        }
+      } : value && typeof value === "object" ? guarded(value) : value
+    ])
+  );
+}
+function createManagementClient(options) {
+  const clientTimeout = checkedTimeout(options.timeout) ?? DEFAULT_MANAGEMENT_TIMEOUT;
+  function callLifetime(call) {
+    return lifetime(
+      checkedTimeout(call?.timeout) ?? clientTimeout,
+      call?.signal ?? void 0
+    );
+  }
+  function transportFailure(error, context, life, sent, status, refused = false, headers) {
+    if (error instanceof ManagementError) {
+      return error;
+    }
+    const unsent = {
+      retryAfter: headers ? retryAfter(headers) : void 0,
+      ...!sent ? { uncertain: false } : refused ? {
+        uncertain: context.method !== "GET" && [500, 502, 504].includes(status ?? 0)
+      } : {},
+      ...status === void 0 ? {} : { status }
+    };
+    const ended = life.ended();
+    if (ended === "aborted") {
+      return new ManagementError({
+        ...context,
+        ...unsent,
+        kind: "aborted",
+        code: ManagementErrorCode.Aborted,
+        message: "The management request was cancelled",
+        cause: life.reason()
+      });
+    }
+    if (ended === "timeout") {
+      return new ManagementError({
+        ...context,
+        ...unsent,
+        kind: "timeout",
+        code: ManagementErrorCode.Timeout,
+        message: `The management request did not finish within ${life.timeout} ms`,
+        cause: error
+      });
+    }
+    return new ManagementError({
+      ...context,
+      ...unsent,
+      kind: "network",
+      code: ManagementErrorCode.Network,
+      message: "The management request failed before Domino answered",
+      cause: error
+    });
+  }
+  async function credential(context, life) {
+    if (!options.getToken) {
+      return null;
+    }
+    const getToken = options.getToken;
+    try {
+      return await new Promise((resolve, reject) => {
+        const stop = () => reject(life.signal.reason);
+        life.signal.addEventListener("abort", stop, { once: true });
+        getToken().then(resolve, reject).finally(() => life.signal.removeEventListener("abort", stop));
+      });
+    } catch (error) {
+      if (life.signal.aborted) {
+        throw transportFailure(error, context, life, false);
+      }
+      throw new ManagementError({
+        ...context,
+        // A token source that could not reach its own service failed like a network call.
+        kind: error instanceof TypeError ? "network" : "client",
+        code: ManagementErrorCode.Credential,
+        uncertain: false,
+        message: "Could not get a management credential",
+        cause: error
+      });
+    }
+  }
+  async function send(path, fetchInit, context, life) {
+    if (life.signal.aborted) {
+      throw transportFailure(life.reason(), context, life, false);
+    }
+    const headers = new Headers(fetchInit.headers);
+    const token = await credential(context, life);
+    if (token) {
+      headers.set("Authorization", `Bearer ${token}`);
+    }
+    if (options.organization) {
+      headers.set("X-Relay-Organization", options.organization);
+    }
+    if (options.project) {
+      headers.set("X-Relay-Project", options.project);
+    }
+    if (options.environment) {
+      headers.set("X-Relay-Environment", options.environment);
+    }
+    let response;
+    try {
+      response = await fetch(`${options.baseUrl}/management/v1${path}`, {
+        ...fetchInit,
+        headers,
+        signal: life.signal
+      });
+    } catch (error) {
+      throw transportFailure(error, context, life, true);
+    }
+    if (!response.ok) {
+      let text;
+      try {
+        text = await response.text();
+      } catch (error2) {
+        throw transportFailure(
+          error2,
+          context,
+          life,
+          true,
+          response.status,
+          true,
+          response.headers
+        );
+      }
+      let body = null;
+      try {
+        body = JSON.parse(text);
+      } catch {
+      }
+      const parsed = serverErrorSchema.safeParse(body);
+      const { error, code, ...details } = parsed.success ? parsed.data : { error: `Request failed (${response.status})`, code: void 0 };
+      throw new ManagementError({
+        ...context,
+        kind: "http",
+        status: response.status,
+        message: error,
+        ...code === void 0 ? {} : { code },
+        details,
+        retryAfter: retryAfter(response.headers)
+      });
+    }
+    return response;
+  }
+  async function raw(path, init) {
+    const { timeout, signal, ...fetchInit } = init ?? {};
+    const life = callLifetime({ timeout, signal: signal ?? void 0 });
+    try {
+      return await send(
+        path,
+        fetchInit,
+        {
+          method: (fetchInit.method ?? "GET").toUpperCase(),
+          path: path.split("?")[0],
+          replaySafe: false
+        },
+        life
+      );
+    } finally {
+      life.end();
+    }
+  }
+  async function exchange(path, schema, input, method, call, replaySafe) {
+    const actionId = actionIdOf(input);
+    const context = {
+      method,
+      replaySafe,
+      path: path.split("?")[0],
+      ...actionId ? { actionId } : {}
+    };
+    const fetchInit = {
+      method,
+      ...input === void 0 ? {} : {
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(input)
+      }
+    };
+    const life = callLifetime(call);
+    try {
+      return await retrying(
+        life,
+        { replaySafe: method === "GET" || replaySafe },
+        async () => {
+          const response = await send(path, fetchInit, context, life);
+          let body;
+          try {
+            body = await response.json();
+          } catch (error) {
+            if (error instanceof SyntaxError && !life.signal.aborted) {
+              throw new ManagementError({
+                ...context,
+                kind: "invalid-response",
+                code: ManagementErrorCode.InvalidResponse,
+                status: response.status,
+                message: "Domino answered with a body that is not JSON",
+                cause: error
+              });
+            }
+            throw transportFailure(
+              error,
+              context,
+              life,
+              true,
+              response.status,
+              false,
+              response.headers
+            );
+          }
+          const parsed = schema.safeParse(body);
+          if (!parsed.success) {
+            throw new ManagementError({
+              ...context,
+              kind: "invalid-response",
+              code: ManagementErrorCode.InvalidResponse,
+              status: response.status,
+              message: "Domino answered with a response this client does not recognize",
+              cause: parsed.error
+            });
+          }
+          return parsed.data;
+        }
+      );
+    } finally {
+      life.end();
+    }
+  }
+  async function request(path, schema, input, method = input === void 0 ? "GET" : "POST", call) {
+    return exchange(path, schema, input, method.toUpperCase(), call, false);
+  }
+  const get = (path, schema, call) => exchange(path, schema, void 0, "GET", call, true);
+  const post = (path, schema, input, call) => exchange(path, schema, input, "POST", call, actionIdOf(input) !== void 0);
+  async function create(path, responseSchema, inputSchema, input, call) {
+    return post(
+      path,
+      responseSchema,
+      inputSchema.parse(withActionId(input)),
+      call
+    );
+  }
+  const ok = z7.object({ ok: z7.literal(true) });
+  return guarded({
+    raw,
+    request,
+    trackers: {
+      list: (call) => get("/trackers", z7.array(trackerStatusSchema), call),
+      get: (reference, call) => get(
+        `/trackers/${identifier.parse(reference)}`,
+        trackerStatusSchema,
+        call
+      ),
+      records: (reference, query = {}, call) => get(
+        `/trackers/${identifier.parse(reference)}/records${queryString(trackerQuerySchema.parse(query))}`,
+        trackerPageSchema,
+        call
+      ),
+      summary: (reference, query = {}, call) => get(
+        `/trackers/${identifier.parse(reference)}/summary${queryString(trackerQuerySchema.parse(query))}`,
+        trackerSummarySchema,
+        call
+      ),
+      content: (reference, query, call) => get(
+        `/trackers/${identifier.parse(reference)}/content${queryString(trackerContentReadSchema.parse(query))}`,
+        trackerContentSchema,
+        call
+      ),
+      control: (reference, input, call) => post(
+        `/trackers/${identifier.parse(reference)}/control`,
+        trackerStatusSchema,
+        trackerControlSchema.parse(input),
+        call
+      ),
+      ingest: (reference, input, call) => post(
+        `/trackers/${identifier.parse(reference)}/records`,
+        trackerIngestResultSchema,
+        trackerIngestSchema.parse(input),
+        call
+      ),
+      /** Why each tracker-triggered quest admitted or skipped a record observation, newest first. */
+      outcomes: (reference, query = {}, call) => get(
+        `/trackers/${identifier.parse(reference)}/outcomes${queryString(trackerOutcomeQuerySchema.parse(query))}`,
+        trackerOutcomePageSchema,
+        call
+      ),
+      /**
+       * Re-runs admission for a skipped observation under the quest's current release, links,
+       * membership and enrollment, releasing historical activity whatever the quest's historical
+       * policy; requires `review` permission. Fails with 409, the current reason and its `skip`
+       * code when it still cannot admit.
+       */
+      retryOutcome: (reference, input, call) => post(
+        `/trackers/${identifier.parse(reference)}/outcomes/retry`,
+        trackerOutcomeSchema,
+        trackerOutcomeRetrySchema.parse(input),
+        call
+      ),
+      /** A bounded X search sample to explore a query before defining a tracker. Stores nothing. */
+      preview: (input, call) => post(
+        "/tracker-preview",
+        trackerPreviewSchema,
+        trackerPreviewInputSchema.parse(input),
+        call
+      )
+    },
+    engagement: {
+      previewChange: (input, call) => post(
+        "/engagement/preview-change",
+        engagementChangePreviewSchema,
+        engagementChangePreviewInputSchema.parse(input),
+        call
+      ),
+      change: (input, call) => post(
+        "/engagement/change",
+        engagementRuleSchema,
+        engagementChangeSchema.parse(input),
+        call
+      ),
+      versions: (input, call) => get(
+        "/engagement/versions" + queryString(engagementVersionQuerySchema.parse(input)),
+        engagementVersionPageSchema,
+        call
+      ),
+      boundaries: (input, call) => get(
+        "/engagement/boundaries" + queryString(engagementPageQuerySchema.parse(input)),
+        engagementBoundaryPageSchema,
+        call
+      ),
+      publish: (input, call) => post(
+        "/engagement/publish",
+        engagementRuleSchema,
+        engagementPublishSchema.parse(input),
+        call
+      ),
+      list: (call) => get("/engagement", z7.array(engagementRuleSchema), call),
+      page: (input, call) => get(
+        "/engagement/history" + queryString(engagementPageQuerySchema.parse(input)),
+        engagementPageSchema,
+        call
+      )
+    },
+    content: {
+      performance: (input, call) => get(
+        "/content/performance" + queryString(contentPerformanceQuerySchema.parse(input)),
+        contentPerformancePageSchema,
+        call
+      ),
+      qualifications: (input, call) => get(
+        "/content/qualifications" + queryString(contentQualificationQuerySchema.parse(input)),
+        contentQualificationPageSchema,
+        call
+      )
+    },
+    pointLedgers: {
+      list: (call) => get("/point-ledgers", z7.array(managedPointLedgerSchema), call),
+      save: (input, call) => post(
+        "/point-ledgers/update",
+        managedPointLedgerSchema,
+        pointLedgerSchema.parse(input),
+        call
+      ),
+      archive: (ledger, call) => post(
+        `/point-ledgers/${identifier.parse(ledger)}/archive`,
+        managedPointLedgerSchema,
+        {},
+        call
+      )
+    },
+    points: {
+      ledgers: (call) => get("/point-ledgers", z7.array(managedPointLedgerSchema), call),
+      createLedger: (input, call) => create(
+        "/point-ledgers",
+        pointLedgerSchema,
+        createPointLedgerSchema,
+        input,
+        call
+      ),
+      update: (input, call) => post(
+        "/points",
+        pointsResultSchema,
+        pointsMutationSchema.parse(input),
+        call
+      ),
+      balance: (member, balance, call) => get(
+        `/points/${identifier.parse(member)}/${identifier.parse(balance)}`,
+        pointsAccountSchema,
+        call
+      ),
+      history: (member, balance, before, call) => get(
+        `/points/${identifier.parse(member)}/${identifier.parse(balance)}/history${queryString({ before })}`,
+        z7.object({
+          items: z7.array(pointsEntrySchema),
+          next: z7.number().nullable()
+        }),
+        call
+      )
+    },
+    referrals: {
+      /** A member's referral point history, newest first. Pass `nextCursor` as `cursor`. */
+      history: (member, query = {}, call) => get(
+        `/referrals/history/${identifier.parse(member)}${queryString({ cursor: query.cursor })}`,
+        referralHistorySchema,
+        call
+      ),
+      list: (call) => get("/referrals", z7.array(publishedReferralSchema), call),
+      participants: (before, call) => get(
+        `/referrals/participants${queryString({ before })}`,
+        referralManagementSchema,
+        call
+      ),
+      control: (input, call) => post(
+        "/referrals/control",
+        ok,
+        referralControlSchema.parse(input),
+        call
+      )
+    },
+    leaderboards: {
+      list: (call) => get("/leaderboards", z7.array(publishedLeaderboardSchema), call),
+      standings: (board, input = {}, call) => {
+        const query = leaderboardQuerySchema.parse(input);
+        return get(
+          `/leaderboards/${identifier.parse(board)}${queryString({
+            limit: query.limit,
+            cursor: query.cursor || void 0
+          })}`,
+          leaderboardPageSchema,
+          call
+        );
+      },
+      history: (board, call) => get(
+        `/leaderboards/${identifier.parse(board)}/history`,
+        z7.array(publishedLeaderboardSchema),
+        call
+      ),
+      exclusions: (board, call) => get(
+        `/leaderboards/${identifier.parse(board)}/exclusions`,
+        z7.array(z7.object({ member: identifier })),
+        call
+      ),
+      exclude: (board, input, call) => post(
+        `/leaderboards/${identifier.parse(board)}/exclusions`,
+        ok,
+        leaderboardExclusionSchema.parse(input),
+        call
+      ),
+      group: (group, input, call) => post(
+        `/leaderboard-groups/${identifier.parse(typeof group === "string" ? group : projectGroupKey(group))}`,
+        ok,
+        leaderboardGroupSchema.parse(input),
+        call
+      ),
+      settlements: (board, call) => get(
+        `/leaderboards/${identifier.parse(board)}/settlements`,
+        z7.array(leaderboardSettlementSummarySchema),
+        call
+      ),
+      settlement: (settlement, call) => get(
+        `/leaderboard-settlements/${identifier.parse(settlement)}`,
+        leaderboardSettlementSchema,
+        call
+      ),
+      approveSettlement: (settlement, input, call) => post(
+        `/leaderboard-settlements/${identifier.parse(settlement)}/approve`,
+        leaderboardSettlementSchema,
+        leaderboardSettlementApprovalSchema.parse(withActionId(input)),
+        call
+      )
+    },
+    deployments: {
+      list: (call) => get("/deployments", z7.array(deploymentRecordSchema), call),
+      get: (deployment, call) => get(
+        `/deployments/${identifier.parse(deployment)}`,
+        deploymentRecordSchema,
+        call
+      ),
+      preview: (input, call) => {
+        const { engagement, ...deployment } = projectDeploymentSchema.parse(input);
+        return post(
+          "/deployments/preview",
+          deploymentPreviewSchema,
+          { ...deployment, ...engagement.length ? { engagement } : {} },
+          call
+        );
+      },
+      publish: (input, call) => post(
+        "/deployments/publish",
+        deploymentResultSchema,
+        publishDeploymentSchema.parse(input),
+        call
+      ),
+      submit: (input, call) => post(
+        "/deployments/submit",
+        deploymentRecordSchema,
+        submitDeploymentSchema.parse(input),
+        call
+      ),
+      reject: (input, call) => post(
+        "/deployments/reject",
+        deploymentRecordSchema,
+        rejectDeploymentSchema.parse(input),
+        call
+      ),
+      promote: (input, call) => {
+        const parsed = promoteDeploymentSchema.parse(withActionId(input));
+        return post(
+          "/deployments/promote",
+          deploymentRecordSchema,
+          parsed,
+          call
+        );
+      },
+      rollback: (input, call) => {
+        const parsed = rollbackDeploymentSchema.parse(withActionId(input));
+        return post(
+          "/deployments/rollback",
+          deploymentRecordSchema,
+          parsed,
+          call
+        );
+      }
+    },
+    catalog: {
+      allocateQuest: (input = {}, call) => create(
+        "/catalog/quests",
+        allocatedQuestSchema,
+        allocateQuestSchema,
+        input,
+        call
+      ),
+      read: (call) => get("/catalog", questCatalogSchema, call),
+      previewDeployment: (input, call) => post(
+        "/catalog/deploy/preview",
+        catalogDeploymentPreviewSchema,
+        catalogDeploymentSchema.parse(input),
+        call
+      ),
+      deploy: (input, call) => post(
+        "/catalog/deploy",
+        questCatalogSchema,
+        catalogDeploymentSchema.parse(input),
+        call
+      ),
+      saveDraft: (input, call) => post(
+        "/catalog/drafts",
+        questDraftSchema,
+        saveQuestDraftSchema.parse(input),
+        call
+      ),
+      preview: (input, call) => post(
+        "/catalog/preview",
+        questPublicationPreviewSchema,
+        publishQuestDraftSchema.parse(input),
+        call
+      ),
+      publish: (input, call) => post(
+        "/catalog/publish",
+        questPublicationPreviewSchema,
+        publishQuestDraftSchema.parse(input),
+        call
+      )
+    },
+    /** Staff-confirmed quests and reviews. */
+    attempts: {
+      /**
+       * Submits a staff-confirmed quest (`manual({ actor: "staff" })`) for a member; requires
+       * `confirm` permission. Resolves with the queued attempt, or with the original attempt when
+       * the action ID repeats. Any other quest fails with 403.
+       */
+      confirm: (input, call) => post(
+        "/attempts",
+        attemptSchema,
+        submitSchema.parse(withActionId(input)),
+        call
+      ),
+      /**
+       * Accepts or rejects an attempt waiting for review, at the `generation` the reviewer saw,
+       * with a reason; requires `review` permission.
+       */
+      review: (attempt, input, call) => post(
+        `/attempts/${identifier.parse(attempt)}/review`,
+        attemptSchema,
+        staffDecisionSchema.parse(withActionId(input)),
+        call
+      ),
+      /** Evaluates a failed attempt again under a new generation; requires `review` permission. */
+      retry: (attempt, call) => post(
+        `/attempts/${identifier.parse(attempt)}/retry`,
+        attemptSchema,
+        {},
+        call
+      )
+    },
+    passes: {
+      /**
+       * Records a member's external event pass, which the app verified, and submits the entry
+       * quest (`manual({ actor: "staff" })`); requires `confirm` permission. The same pass for
+       * the same member resolves with the original attempt.
+       */
+      verify: (input, call) => post(
+        "/passes/verify",
+        attemptSchema,
+        verifiedPassSchema.parse(input),
+        call
+      )
+    },
+    completions: {
+      /**
+       * Revokes an accepted completion with a reason; requires `review` permission. In one
+       * transaction it reverses the completion's points, voids its undelivered tiered rewards and
+       * flags collected ones, stops Discord role grants not yet delivered and flags delivered roles for
+       * an operator to remove in Discord (Relay never removes roles), re-evaluates referral
+       * qualification on it, and revokes a streak milestone. `freeOccurrence` lets the member
+       * complete the quest again for the same occurrence. Replaying the action ID returns the
+       * first result.
+       */
+      revoke: (input, call) => {
+        const { completion, ...body } = input;
+        return post(
+          `/completions/${identifier.parse(completion)}/revoke`,
+          completionRevocationSchema,
+          completionRevokeSchema.parse(withActionId(body)),
+          call
+        );
+      }
+    },
+    /** Staff handover of a member's reward entitlement; requires `handover` permission. */
+    handover: {
+      /** Starts handing over an entitlement at the `revision` staff saw, with an optional pickup selection. */
+      begin: (entitlement, input, call) => post(
+        `/entitlements/${identifier.parse(entitlement)}/begin`,
+        entitlementSchema,
+        beginHandoverSchema.parse(withActionId(input)),
+        call
+      ),
+      /** Completes the handover `begin` started; the entitlement becomes collected. */
+      confirm: (entitlement, input, call) => post(
+        `/entitlements/${identifier.parse(entitlement)}/confirm`,
+        entitlementSchema,
+        confirmHandoverSchema.parse(withActionId(input)),
+        call
+      ),
+      /**
+       * Cancels a handover that was started but not confirmed, at the `revision` staff saw, with a
+       * reason. The entitlement is available again and any pickup size it held returns to stock.
+       */
+      cancel: (entitlement, input, call) => post(
+        `/entitlements/${identifier.parse(entitlement)}/cancel`,
+        entitlementSchema,
+        entitlementCorrectionSchema.parse(withActionId(input)),
+        call
+      )
+    },
+    /** Operator corrections of a member's reward entitlement; require `review` permission. */
+    entitlements: {
+      /**
+       * Voids an available entitlement granted by mistake, at the `revision` the operator saw, with
+       * a reason. It can no longer be handed over. A quest that grants the member the same reward
+       * again makes it available as a fresh grant; a voided referral reward stays void.
+       */
+      void: (entitlement, input, call) => post(
+        `/entitlements/${identifier.parse(entitlement)}/void`,
+        entitlementSchema,
+        entitlementCorrectionSchema.parse(withActionId(input)),
+        call
+      ),
+      /**
+       * Corrects a collection recorded by mistake, at the `revision` the operator saw, with a
+       * reason. The entitlement is available again and any pickup size it held returns to stock.
+       */
+      correctCollection: (entitlement, input, call) => post(
+        `/entitlements/${identifier.parse(entitlement)}/correct`,
+        entitlementSchema,
+        entitlementCorrectionSchema.parse(withActionId(input)),
+        call
+      )
+    },
+    collection: {
+      resolve: (code, call) => post(
+        "/collection/resolve",
+        collectionPreviewSchema,
+        collectionResolveSchema.parse({ code }),
+        call
+      ),
+      begin: (input, call) => post(
+        "/collection/begin",
+        entitlementSchema,
+        collectionBeginSchema.parse(input),
+        call
+      )
+    },
+    operations: {
+      /**
+       * Pauses or resumes redemptions or one quest's participation, against the `revision` the
+       * operator saw, with a reason; requires `publish` permission.
+       */
+      configure: (input, call) => post(
+        "/operations",
+        operationSchema,
+        operationInputSchema.parse(withActionId(input)),
+        call
+      )
+    },
+    inventory: {
+      createItem: (input, call) => create(
+        "/stock-items",
+        stockItemSchema,
+        createStockItemSchema,
+        input,
+        call
+      ),
+      /** Adds `quantity` units to a stock item; requires `inventory` permission. */
+      addStock: (input, call) => post(
+        "/stock",
+        stockAdditionSchema,
+        stockInputSchema.parse(withActionId(input)),
+        call
+      ),
+      catalog: (call) => get("/pickup-inventory", z7.array(pickupCatalogSchema), call),
+      configure: (input, call) => post(
+        "/pickup-inventory",
+        pickupCatalogSchema,
+        configurePickupSchema.parse(input),
+        call
+      ),
+      availability: (entitlement, call) => get(
+        `/pickup-inventory/${encodeURIComponent(entitlement)}`,
+        pickupAvailabilitySchema,
+        call
+      )
+    },
+    offers: {
+      list: (call) => get("/offers", z7.array(offerSchema), call),
+      redemptions: (input = {}, call) => get(
+        `/redemptions${queryString({ member: input.member })}`,
+        z7.array(redemptionSchema),
+        call
+      ),
+      /** Pauses or resumes an offer at the revision the operator saw. */
+      control: (offer, input, call) => post(
+        `/offers/${identifier.parse(offer)}/control`,
+        offerSchema,
+        offerControlSchema.parse(withActionId(input)),
+        call
+      ),
+      /** Cancels fulfillment, refunds points and returns the unit to stock. */
+      cancelRedemption: (redemption, input, call) => post(
+        `/redemptions/${identifier.parse(redemption)}/cancel`,
+        redemptionSchema,
+        redemptionCancellationSchema.parse(withActionId(input)),
+        call
+      )
+    },
+    readiness: (call) => get("/readiness", readinessSchema, call),
+    access: (call) => get("/access", accessSchema, call),
+    createProject: (input, call) => create("/projects", projectSchema, projectInputSchema, input, call),
+    /** Delete the client's current project. Domino support can restore it for 30 days. */
+    deleteProject: (input, call) => request(
+      "/project",
+      projectDeletionSchema,
+      projectDeletionInputSchema.parse(input),
+      "DELETE",
+      call
+    ),
+    /** Move the client's current project to another organization the caller administers. */
+    transferProject: (input, call) => post(
+      "/project/transfer",
+      projectTransferSchema,
+      projectTransferInputSchema.parse(input),
+      call
+    ),
+    /**
+     * The signed-in person's personal API keys. Console and unscoped human CLI sessions manage
+     * them; API keys and project-scoped playground sessions cannot.
+     */
+    tokens: {
+      list: (call) => get("/tokens", z7.array(tokenSchema), call),
+      /**
+       * Issues a key for one project and environment, limited to permissions the caller holds
+       * there. The secret `token` is in this response only.
+       */
+      create: (input, call) => post("/tokens", issuedTokenSchema, tokenInputSchema.parse(input), call),
+      /** Replace a personal key's ingestion restriction without changing its secret. */
+      scope: (id, input, call) => request(
+        `/tokens/${encodeURIComponent(z7.string().min(1).parse(id))}/scope`,
+        tokenSchema,
+        tokenScopeInputSchema.parse(input),
+        "PUT",
+        call
+      ),
+      revoke: (id, call) => request(
+        `/tokens/${encodeURIComponent(z7.string().min(1).parse(id))}`,
+        ok,
+        void 0,
+        "DELETE",
+        call
+      )
+    },
+    /** Who holds which roles on the client's project; organization administrators only. */
+    grants: {
+      list: (call) => get("/grants", z7.array(grantRecordSchema), call),
+      /** Replaces one person's roles and environments on the project. The audit log records it. */
+      set: (input, call) => request(
+        "/grants",
+        grantRecordSchema,
+        grantSchema.parse(input),
+        "PUT",
+        call
+      )
+    },
+    /** The organization's people, to choose a grant's `subject`; organization administrators only. */
+    team: {
+      list: (call) => get("/team", teamSchema, call)
+    },
+    /** Signed activity notifications for one project/environment; writes require publish permission. */
+    webhooks: {
+      list: (call) => get("/webhooks", z7.array(webhookEndpointSchema), call),
+      create: (input, call) => post(
+        "/webhooks",
+        webhookSecretSchema,
+        webhookInputSchema.parse(input),
+        call
+      ),
+      update: (id, input, call) => request(
+        `/webhooks/${z7.string().uuid().parse(id)}`,
+        webhookEndpointSchema,
+        webhookUpdateSchema.parse(input),
+        "PUT",
+        call
+      ),
+      disable: (id, call) => post(
+        `/webhooks/${z7.string().uuid().parse(id)}/disable`,
+        webhookEndpointSchema,
+        {},
+        call
+      ),
+      rotateSecret: (id, call) => post(
+        `/webhooks/${z7.string().uuid().parse(id)}/rotate-secret`,
+        webhookSecretSchema,
+        {},
+        call
+      ),
+      deliveries: (id, query = {}, call) => get(
+        `/webhooks/${z7.string().uuid().parse(id)}/deliveries${queryString(webhookQuerySchema.parse(query))}`,
+        webhookDeliveryPageSchema,
+        call
+      ),
+      replay: (id, delivery, call) => post(
+        `/webhooks/${z7.string().uuid().parse(id)}/deliveries/${z7.string().uuid().parse(delivery)}/replay`,
+        webhookDeliverySchema,
+        {},
+        call
+      )
+    },
+    /**
+     * Keys that let an existing app exchange its own login for member sessions, per project and
+     * environment. Organization administrators, from a Console session only.
+     */
+    identityIntegrations: {
+      list: (call) => get("/identity-integrations", z7.array(identityIntegrationSchema), call),
+      /** The secret `token` is in this response only. */
+      create: (input, call) => post(
+        "/identity-integrations",
+        identityIntegrationSecretSchema,
+        identityIntegrationInputSchema.parse(input),
+        call
+      ),
+      /** Replaces the key's secret and extends it by 90 days; the old secret stops working. */
+      rotate: (id, call) => post(
+        `/identity-integrations/${z7.string().uuid().parse(id)}/rotate`,
+        identityIntegrationSecretSchema,
+        {},
+        call
+      ),
+      /**
+       * The `app:<name>` kinds claimed in the project and environment, each with the integration
+       * that owns its identities, connected or not, and how many it has. A new integration reusing
+       * a kind with identities adopts them from that integration (`adoptIdentitiesFrom`).
+       */
+      kinds: (call) => get(
+        "/identity-integrations/kinds",
+        z7.array(identityKindClaimSchema),
+        call
+      ),
+      /**
+       * Deletes the key and ends every member session it issued. Its kind's identities stay linked
+       * and keep attributing tracker records; unlink them on the member to stop that.
+       */
+      revoke: (id, call) => request(
+        `/identity-integrations/${z7.string().uuid().parse(id)}`,
+        z7.null(),
+        void 0,
+        "DELETE",
+        call
+      )
+    },
+    page: (page, query, call) => get(`/${page}${queryString(query)}`, pageSchema, call),
+    resources: {
+      list: (call) => get(
+        "/resources",
+        z7.object({ resources: z7.array(managedResourceSchema) }),
+        call
+      ),
+      lifecycle: (input, call) => post(
+        "/resources/lifecycle",
+        resourceLifecycleResultSchema,
+        resourceLifecycleInputSchema.parse(input),
+        call
+      )
+    },
+    rewardDeliveries: (member, call) => get(
+      `/reward-deliveries${queryString({ member })}`,
+      rewardDeliveriesSchema,
+      call
+    ),
+    /** Relinquish automatic removal for an external assignment; requires `review` and an audited reason. */
+    preserveRewardRole: (id, body, call) => post(
+      `/reward-deliveries/${encodeURIComponent(id)}/preserve`,
+      rewardDeliverySchema,
+      body,
+      call
+    ),
+    retryRewardDelivery: (id, call) => post(
+      `/reward-deliveries/${encodeURIComponent(id)}/retry`,
+      rewardDeliverySchema,
+      {},
+      call
+    ),
+    /** The project's members, as operators see them. */
+    members: {
+      counters: {
+        history: (member, quest, query = {}, call) => get(
+          `/members/${identifier.parse(member)}/counters/${identifier.parse(quest)}${queryString(counterHistoryQuerySchema.parse(query))}`,
+          counterHistorySchema,
+          call
+        ),
+        moderate: (member, quest, contribution, input, call) => post(
+          `/members/${identifier.parse(member)}/counters/${identifier.parse(quest)}/${identifier.parse(contribution)}/moderate`,
+          counterModerationResultSchema,
+          counterModerationSchema.parse(input),
+          call
+        )
+      },
+      /** A member's detail: accounts, progress, passes, wallets and profile. */
+      get: (member, call) => get(`/members/${encodeURIComponent(member)}`, memberDetailSchema, call),
+      /**
+       * The one member of the client's project holding exactly this account, with `provider` and `subject` as a member's
+       * `accounts` list them; requires `read` permission. Fails with 404 `member-not-found` when
+       * nobody holds it. Unlike the members page's `q` search, it never matches part of a value
+       * or another letter case.
+       */
+      lookup: (input, call) => get(
+        `/members/lookup${queryString(memberLookupSchema.parse(input))}`,
+        personSchema,
+        call
+      ),
+      /** Who each member is: up to 100 distinct IDs; unknown IDs come back without accounts. */
+      people: (members, call) => get(
+        `/people${queryString({ ids: members.join(",") })}`,
+        z7.array(personSchema),
+        call
+      ),
+      /** Current X and Discord quest account selections; requires read permission. */
+      oauthAccounts: (member, call) => get(
+        `/members/${encodeURIComponent(member)}/oauth-accounts`,
+        z7.array(managedOAuthAccountSchema),
+        call
+      ),
+      /** Unlinks the reviewed selection across this organization/environment, preserving ownership and sign-in. */
+      unlinkOAuthAccount: (member, input, call) => post(
+        `/members/${encodeURIComponent(member)}/oauth-accounts/unlink`,
+        z7.array(managedOAuthAccountSchema),
+        memberOAuthUnlinkInputSchema.parse(input),
+        call
+      ),
+      /** Unlinks a member's wallet from the project with a reason; requires `review` permission. The address stays bound to the member. */
+      unlinkWallet: (member, input, call) => post(
+        `/members/${encodeURIComponent(member)}/wallets/unlink`,
+        z7.array(managedWalletSchema),
+        memberWalletUnlinkInputSchema.parse(input),
+        call
+      ),
+      /**
+       * Unlinks one of a member's `app:<name>` identities with a reason; requires `review`
+       * permission. It stops attributing tracker records, the member's sessions that the kind's
+       * integration issued for it end, and signing in with it fails until it is relinked.
+       */
+      unlinkIdentity: (member, input, call) => post(
+        `/members/${encodeURIComponent(member)}/identities/unlink`,
+        z7.array(managedMemberIdentitySchema),
+        memberIdentityChangeInputSchema.parse(input),
+        call
+      ),
+      /** Relinks an `app:<name>` identity an operator unlinked from this member, with a reason; requires `review` permission. */
+      relinkIdentity: (member, input, call) => post(
+        `/members/${encodeURIComponent(member)}/identities/relink`,
+        z7.array(managedMemberIdentitySchema),
+        memberIdentityChangeInputSchema.parse(input),
+        call
+      ),
+      /**
+       * Enables or disables sign-in with a member's wallet, across the organization and environment,
+       * with a reason; requires `review` permission. Sessions it already issued run out within 8 hours.
+       */
+      setWalletSignIn: (member, input, call) => post(
+        `/members/${encodeURIComponent(member)}/wallets/sign-in`,
+        z7.array(managedWalletSchema),
+        memberWalletSignInInputSchema.parse(input),
+        call
+      )
+    },
+    /** The hosted app's secrets. Values are write-only; builds staged after a change receive it. */
+    secrets: {
+      list: (call) => get("/secrets", appSecretListSchema, call),
+      set: (name, value, call) => request(
+        `/secrets/${appSecretNameSchema.parse(name)}`,
+        appSecretSchema,
+        appSecretInputSchema.parse({ value }),
+        "PUT",
+        call
+      ),
+      delete: async (name, call) => {
+        await raw(`/secrets/${appSecretNameSchema.parse(name)}`, {
+          ...call,
+          method: "DELETE"
+        });
+      }
+    },
+    /**
+     * The chains quest code can read token balances on with `ctx.wallet.balance()`, with their
+     * names; requires `read` permission. Any other chain fails the evaluation.
+     */
+    walletBalanceChains: (call) => get("/wallet-balance-chains", walletBalanceChainsSchema, call),
+    /**
+     * The project calendar in this environment: the timezone that sets where days, weeks and months
+     * begin for budgets, streaks and leaderboards.
+     */
+    calendar: {
+      /**
+       * The timezone in effect, today's date, when today ends, any pending change, and a stored
+       * timezone the calendar no longer accepts (`unsupported`, read as UTC).
+       */
+      read: (call) => get("/calendar", projectCalendarSchema, call),
+      /**
+       * Changes the project timezone from the next day boundary, with a reason; requires `publish`
+       * permission. The current timezone cancels a pending change; a call that changes nothing
+       * records nothing. In live, only a person in Console can change it, not an API key.
+       */
+      configure: (input, call) => post(
+        "/calendar",
+        projectCalendarSchema,
+        projectCalendarInputSchema.parse(withActionId(input)),
+        call
+      )
+    },
+    /** Participant profiles in this project and environment. */
+    profiles: {
+      /** Who sees profiles, and which accounts supply default names and pictures, in order. */
+      settings: (call) => get("/profile-settings", profileSettingsSchema, call),
+      /**
+       * Changes the profile settings against `expectedRevision`, with a reason; requires `publish`
+       * permission. In live, only a person in Console can change them, not an API key.
+       */
+      configure: (input, call) => post(
+        "/profile-settings",
+        profileSettingsSchema,
+        profileSettingsInputSchema.parse(withActionId(input)),
+        call
+      ),
+      /**
+       * Resets a member's name, removes their picture, or locks or unlocks their profile, with a
+       * reason; requires `review` permission.
+       */
+      moderate: (member, input, call) => post(
+        `/members/${identifier.parse(member)}/profile`,
+        managedProfileSchema,
+        profileModerationSchema.parse(withActionId(input)),
+        call
+      )
+    },
+    /**
+     * Code-authored quests. Quests created in Console change participation through a catalog draft
+     * instead. Except `enroll`, these methods require `publish` permission; in live, only a person
+     * in Console can use them.
+     */
+    campaigns: {
+      /** Enrolls or restores a member in every quest of a campaign that requires enrollment. */
+      enroll: (input, call) => post(
+        "/campaigns/enrollments",
+        campaignEnrollmentSchema,
+        memberCampaignEnrollmentInputSchema.parse(input),
+        call
+      ),
+      /** Pauses a member's new campaign admissions while preserving history and completed work. */
+      withdraw: (input, call) => post(
+        "/campaigns/enrollments/withdraw",
+        campaignEnrollmentSchema,
+        memberCampaignWithdrawalInputSchema.parse(input),
+        call
+      )
+    },
+    quests: {
+      /** Pending and exhausted asynchronous balance checks. Requires read. */
+      automaticScheduling: (query = {}, call) => get(
+        `/quests/automatic-scheduling${queryString(automaticSchedulingQuerySchema.parse(query))}`,
+        automaticSchedulingPageSchema,
+        call
+      ),
+      /** Requeues a failed balance check with its original durable event identity. Requires review. */
+      retryAutomaticScheduling: (input, call) => post(
+        "/quests/automatic-scheduling/retry",
+        automaticSchedulingSchema,
+        automaticSchedulingRetrySchema.parse(input),
+        call
+      ),
+      /** Prerequisite-only automatic decisions, including stable skip reasons. Requires read. */
+      automaticOutcomes: (query = {}, call) => get(
+        `/quests/automatic-outcomes${queryString(automaticOutcomeQuerySchema.parse(query))}`,
+        automaticOutcomePageSchema,
+        call
+      ),
+      /** Preview selected paused outcomes under current rules and budget usage. Requires review. */
+      previewAutomaticCatchUp: (input, call) => post(
+        "/quests/automatic-outcomes/preview",
+        automaticCatchUpPreviewSchema,
+        automaticCatchUpInputSchema.parse(input),
+        call
+      ),
+      /** Confirm the exact preview; changed eligibility requires another preview. Requires review. */
+      catchUpAutomatic: (input, call) => post(
+        "/quests/automatic-outcomes/catch-up",
+        automaticCatchUpResultSchema,
+        automaticCatchUpConfirmSchema.parse(input),
+        call
+      ),
+      /**
+       * Enrolls a member in a quest whose tracker trigger requires enrollment, vouching for their
+       * consent; requires `enroll` permission. The member must have joined the project. Enrolling
+       * again returns the first enrollment. The member's skips recorded as `not-enrolled` on the
+       * quest are decided again.
+       */
+      enroll: (input, call) => post(
+        "/quests/enrollments",
+        questEnrollmentSchema,
+        memberEnrollmentInputSchema.parse(input),
+        call
+      ),
+      /**
+       * Stops new participation and hides the quest from collections, with a reason. Completions,
+       * attempts and rewards stay. Deploying the quest's code again keeps it archived.
+       */
+      archive: (quest, input, call) => post(
+        "/releases/lifecycle",
+        questLifecycleSchema,
+        questLifecycleInputSchema.parse(
+          withActionId({ ...input, quest, archived: true })
+        ),
+        call
+      ),
+      /**
+       * Opens an archived quest again, with a reason. It must pass the prerequisite graph and the
+       * app's supported interactions; it stays paused while a resource setting is empty.
+       */
+      unarchive: (quest, input, call) => post(
+        "/releases/lifecycle",
+        questLifecycleSchema,
+        questLifecycleInputSchema.parse(
+          withActionId({ ...input, quest, archived: false })
+        ),
+        call
+      ),
+      /**
+       * Changes a quest's settings values (`set`) or returns them to their defaults (`reset`),
+       * publishing a new release from `expectedRelease`, the release the operator saw.
+       */
+      updateSettings: (input, call) => post(
+        "/releases/settings",
+        publishedReleaseSchema,
+        questSettingsInputSchema.parse(input),
+        call
+      )
+    },
+    /** How participants sign in to this project and environment. */
+    participantSignIn: (call) => get("/participant-sign-in", participantSignInSchema, call),
+    /** Sets the wallet networks participants can sign in with; requires `publish` permission. */
+    configureParticipantSignIn: (input, call) => request(
+      "/participant-sign-in",
+      participantSignInSchema,
+      participantSignInInputSchema.parse(input),
+      "PUT",
+      call
+    )
+  });
+}
+export {
+  APP_SECRET_LIMIT,
+  DEFAULT_MANAGEMENT_TIMEOUT,
+  ManagementError,
+  ManagementErrorCode,
+  RevokedDeliveryOutcome,
+  RevokedEntitlementOutcome,
+  RevokedReferralOutcome,
+  WEBHOOK_MAX_BYTES,
+  accessSchema,
+  accountProfileSchema,
+  activityTypeSchema,
+  activityTypes,
+  appRoutingSchema,
+  appSecretDeclarationSchema,
+  appSecretDeclarationsSchema,
+  appSecretInputSchema,
+  appSecretListSchema,
+  appSecretNameSchema,
+  appSecretSchema,
+  appSecretValueSchema,
+  assetPathSchema,
+  auditRecordSchema,
+  balanceCheckSchema,
+  buildArtifactsSchema,
+  buildIdentitySchema,
+  buildPhaseSchema,
+  buildSnapshotSchema,
+  buildStatusSchema,
+  commitSchema,
+  completionRevocationSchema,
+  completionRevokeSchema,
+  createManagementClient,
+  createRepositorySchema,
+  developmentPreflightSchema,
+  deviceApproveSchema,
+  deviceRedeemSchema,
+  deviceStartSchema,
+  entitlementCorrectionSchema,
+  entitlementSchema,
+  environmentSchema,
+  grantRecordSchema,
+  grantSchema,
+  hostedAppSchema,
+  hostedAppSecretsSchema,
+  hostedBuildSchema,
+  hostedDeploymentKeySchema,
+  hostedKeyPermissions,
+  hostedKeySchema,
+  hostedKeySecretSchema,
+  hostedManagementBindings,
+  hostedManagementClient,
+  identityIntegrationSchema,
+  identityKindClaimSchema,
+  ingestTrackerScopeSchema,
+  inventorySchema,
+  isManagementError,
+  issuedTokenSchema,
+  managedMemberIdentitySchema,
+  managedOAuthAccountSchema,
+  managedResourceSchema,
+  managedWalletSchema,
+  memberAccountSchema,
+  memberDetailSchema,
+  memberIdentityChangeInputSchema,
+  memberIdentitySchema,
+  memberLookupSchema,
+  memberOAuthUnlinkInputSchema,
+  memberSchema,
+  memberWalletSignInInputSchema,
+  memberWalletUnlinkInputSchema,
+  metricsSchema,
+  operationInputSchema,
+  operationSchema,
+  pageSchema,
+  participantSignInInputSchema,
+  participantSignInSchema,
+  permissionSchema,
+  personSchema,
+  projectDeletionInputSchema,
+  projectDeletionSchema,
+  projectInputSchema,
+  projectSchema,
+  projectSetupSchema,
+  projectTransferInputSchema,
+  projectTransferSchema,
+  querySchema,
+  questLifecycleInputSchema,
+  questLifecycleSchema,
+  readinessSchema,
+  repositorySchema,
+  resourceLifecycleInputSchema,
+  resourceLifecycleKindSchema,
+  resourceLifecycleResultSchema,
+  rolePermissions,
+  roleSchema,
+  stageRequestSchema,
+  stagedDeploymentContentSchema,
+  stagedDeploymentKey,
+  stagedDeploymentLimits,
+  stagedDeploymentSchema,
+  stagingAccessInputSchema,
+  stagingAccessModeSchema,
+  stagingAccessSchema,
+  stagingLinkSchema,
+  stagingPathSchema,
+  starterIdSchema,
+  starterTemplates,
+  stockAdditionSchema,
+  stockInputSchema,
+  teamSchema,
+  tokenInputSchema,
+  tokenSchema,
+  tokenScopeInputSchema,
+  verifiedPassSchema,
+  verifyWebhook,
+  walletBalanceChainsSchema,
+  webhookDeliveryPageSchema,
+  webhookDeliverySchema,
+  webhookEndpointSchema,
+  webhookEventSchema,
+  webhookInputSchema,
+  webhookQuerySchema,
+  webhookSecretSchema,
+  webhookUpdateSchema
+};