@domino-sdk/relay 1.11.1 → 1.15.0

package/dist/server/index.js

@@ -1,3 +1,7 @@
+import {
+  attemptCaptureSchema,
+  capturedFactSchema
+} from "../chunk-NIYCAW2I.js";
 import {
   activityTypeSchema,
   activityTypes,
@@ -21,21 +25,30 @@ import {
   publishDeploymentSchema,
   rejectDeploymentSchema,
   submitDeploymentSchema
-} from "../chunk-2K2QBPAD.js";
+} from "../chunk-ZLYBUM7K.js";
 import "../chunk-MC6V6VMG.js";
 import {
+  DEFAULT_MANAGEMENT_TIMEOUT,
+  ManagementError,
+  ManagementErrorCode,
   REFERRAL_INTEGRATION_REWARD_ERROR,
+  actionIdOf,
   containsReferralIntegrationReward,
   identityIntegrationInputSchema,
   identityIntegrationSchema,
   identityIntegrationSecretSchema,
   identityKindClaimSchema,
-  parseImageExtraction,
-  parseImageResult,
+  isManagementError,
+  managementErrorSchema,
+  managementTransport,
   participantExchangeSchema,
   questConfiguration,
   sequenceCursorSchema
-} from "../chunk-OCXGG75K.js";
+} from "../chunk-CHD6HHWG.js";
+import {
+  parseImageExtraction,
+  parseImageResult
+} from "../chunk-W335CWYJ.js";
 import {
   imageAssetArtifactSchema
 } from "../chunk-ZGH6NEG6.js";
@@ -52,7 +65,7 @@ import {
 } from "../chunk-AXRMT33W.js";
 import {
   withActionId
-} from "../chunk-X7ECZ3AK.js";
+} from "../chunk-XMBM2XD5.js";
 import {
   allocateQuestSchema,
   allocatedQuestSchema,
@@ -70,9 +83,8 @@ import {
   rewardDeliveriesSchema,
   rewardDeliverySchema,
   saveQuestDraftSchema
-} from "../chunk-T657WO56.js";
+} from "../chunk-LLMJ2SUT.js";
 import {
-  cosmosNetworkSchema,
   createPointLedgerSchema,
   engagementBoundaryPageSchema,
   engagementChangePreviewInputSchema,
@@ -85,7 +97,6 @@ import {
   engagementRuleVersionPageSchema,
   engagementVersionPageSchema,
   engagementVersionQuerySchema,
-  evmChainIdSchema,
   leaderboardExclusionSchema,
   leaderboardGroupSchema,
   leaderboardPageSchema,
@@ -93,7 +104,6 @@ import {
   leaderboardSettlementApprovalSchema,
   leaderboardSettlementSchema,
   leaderboardSettlementSummarySchema,
-  linkedWalletSchema,
   managedPointHistoryPageSchema,
   managedPointLedgerSchema,
   managedProfileSchema,
@@ -116,26 +126,20 @@ import {
   referralManagementSchema,
   referralQualificationSchema,
   referralRewardResolutionSchema,
-  referralSuspensionSchema,
+  referralSuspensionSchema
+} from "../chunk-UJACD6K2.js";
+import {
+  cosmosNetworkSchema,
+  evmChainIdSchema,
+  linkedWalletSchema,
   solanaMainnet,
   walletBalanceSchema,
   walletSignInNetworksSchema,
   walletUnlinkInputSchema
-} from "../chunk-ZFABFKIY.js";
-import {
-  MANAGEMENT_TIMEOUT,
-  lifetime,
-  retryAfter,
-  retrying,
-  validTimeout
-} from "../chunk-6QJ3LADK.js";
-import {
-  RequestError,
-  isRequestError
-} from "../chunk-NPGENI7K.js";
-import {
-  clientIdentity
-} from "../chunk-AGFUDCNM.js";
+} from "../chunk-2UAVZCMH.js";
+import "../chunk-6QJ3LADK.js";
+import "../chunk-NPGENI7K.js";
+import "../chunk-3PPEXDWR.js";
 import "../chunk-PT5STHFH.js";
 import {
   CompletionSourceKind,
@@ -553,78 +557,13 @@ var resourceArchiveInputSchema = resourceLifecycleInputSchema.omit({
 });
 
 // src/server/index.ts
-import { z as z13 } from "zod";
-
-// src/server/errors.ts
-import { z as z8 } from "zod";
-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 managementErrorSchema = z8.looseObject({
-  error: z8.string(),
-  code: z8.string().optional()
-});
-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;
+import { z as z12 } from "zod";
 
 // src/server/hosting.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 
 // src/server/starters.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 var starterTemplates = [
   {
     id: "campaign",
@@ -657,63 +596,63 @@ var starterTemplates = [
     summary: "A headless Worker with typed routes and interactive API docs, for plugging Domino into your own product."
   }
 ];
-var starterIdSchema = z9.enum(
+var starterIdSchema = z8.enum(
   starterTemplates.map((template) => template.id)
 );
 
 // src/server/hosting.ts
-var outputPathSchema = z10.string().min(1).max(512).refine(
+var outputPathSchema = z9.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 = z10.enum(["legacy", "transparent"]).default("legacy");
+var appRoutingSchema = z9.enum(["legacy", "transparent"]).default("legacy");
 var APP_SECRET_LIMIT = 50;
 var APP_KV_LIMIT = 5;
 var APP_SQL_LIMIT = 5;
 var APP_MIGRATION_LIMIT = 100;
 var APP_MIGRATION_FILE_BYTES = 9e4;
 var APP_MIGRATION_TOTAL_BYTES = 1e6;
-var appSecretNameSchema = z10.string().regex(
+var appSecretNameSchema = z9.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 = z10.string().min(1).refine(
+var appSecretValueSchema = z9.string().min(1).refine(
   (value) => new TextEncoder().encode(value).length <= 5120,
   "Secret values can be at most 5 KiB"
 );
-var appSecretInputSchema = z10.object({ value: appSecretValueSchema }).strict();
-var appSecretSchema = z10.object({
+var appSecretInputSchema = z9.object({ value: appSecretValueSchema }).strict();
+var appSecretSchema = z9.object({
   name: appSecretNameSchema,
-  updatedAt: z10.number(),
-  updatedBy: z10.string()
+  updatedAt: z9.number(),
+  updatedBy: z9.string()
 });
-var appSecretDeclarationSchema = z10.object({
-  description: z10.string().trim().min(1).max(500),
-  required: z10.boolean().default(true)
+var appSecretDeclarationSchema = z9.object({
+  description: z9.string().trim().min(1).max(500),
+  required: z9.boolean().default(true)
 }).strict();
-var appSecretDeclarationsSchema = z10.record(appSecretNameSchema, appSecretDeclarationSchema).refine(
+var appSecretDeclarationsSchema = z9.record(appSecretNameSchema, appSecretDeclarationSchema).refine(
   (secrets) => Object.keys(secrets).length <= APP_SECRET_LIMIT,
   `Declare at most ${APP_SECRET_LIMIT} app secrets`
 );
-var appSecretListSchema = z10.object({
-  secrets: z10.array(appSecretSchema),
-  declared: z10.array(appSecretDeclarationSchema.extend({ name: appSecretNameSchema })).default([])
+var appSecretListSchema = z9.object({
+  secrets: z9.array(appSecretSchema),
+  declared: z9.array(appSecretDeclarationSchema.extend({ name: appSecretNameSchema })).default([])
 });
-var hostedAppSecretsSchema = z10.object({ secrets: z10.record(appSecretNameSchema, appSecretValueSchema) }).strict();
-var storageDescription = z10.object({
-  description: z10.string().trim().min(1).max(500)
+var hostedAppSecretsSchema = z9.object({ secrets: z9.record(appSecretNameSchema, appSecretValueSchema) }).strict();
+var storageDescription = z9.object({
+  description: z9.string().trim().min(1).max(500)
 }).strict();
-var appStorageSchema = z10.object({
-  kv: z10.record(appSecretNameSchema, storageDescription).refine(
+var appStorageSchema = z9.object({
+  kv: z9.record(appSecretNameSchema, storageDescription).refine(
     (stores) => Object.keys(stores).length <= APP_KV_LIMIT,
     `Declare at most ${APP_KV_LIMIT} KV stores`
   ).default({}),
-  sql: z10.record(
+  sql: z9.record(
     appSecretNameSchema,
     storageDescription.extend({
       migrations: outputPathSchema.optional()
@@ -723,60 +662,60 @@ var appStorageSchema = z10.object({
     `Declare at most ${APP_SQL_LIMIT} SQL stores`
   ).default({})
 }).strict();
-var appStorageKindSchema = z10.enum(["kv", "sql"]);
-var appStorageListSchema = z10.object({
-  stores: z10.array(
-    z10.object({
-      kind: z10.string(),
+var appStorageKindSchema = z9.enum(["kv", "sql"]);
+var appStorageListSchema = z9.object({
+  stores: z9.array(
+    z9.object({
+      kind: z9.string(),
       name: appSecretNameSchema,
-      createdAt: z10.number().nullable(),
-      declared: z10.boolean(),
-      description: z10.string().optional()
+      createdAt: z9.number().nullable(),
+      declared: z9.boolean(),
+      description: z9.string().optional()
     })
   )
 });
 var APP_STORAGE_ROW_LIMIT = 50;
 var APP_STORAGE_PREVIEW_CHARACTERS = 2e3;
-var appStorageCellSchema = z10.union([
-  z10.string(),
-  z10.number(),
-  z10.null(),
-  z10.object({ text: z10.string(), truncated: z10.literal(true) }),
-  z10.object({ blob: z10.number().int().min(0) })
+var appStorageCellSchema = z9.union([
+  z9.string(),
+  z9.number(),
+  z9.null(),
+  z9.object({ text: z9.string(), truncated: z9.literal(true) }),
+  z9.object({ blob: z9.number().int().min(0) })
 ]);
-var appStorageTablesSchema = z10.object({
-  tables: z10.array(
+var appStorageTablesSchema = z9.object({
+  tables: z9.array(
     /** `kind` is SQLite's: `table` or `view`. */
-    z10.object({ name: z10.string(), kind: z10.string() })
+    z9.object({ name: z9.string(), kind: z9.string() })
   )
 });
-var appStorageRowsSchema = z10.object({
-  table: z10.string(),
-  columns: z10.array(z10.string()),
-  rows: z10.array(z10.array(appStorageCellSchema)),
+var appStorageRowsSchema = z9.object({
+  table: z9.string(),
+  columns: z9.array(z9.string()),
+  rows: z9.array(z9.array(appStorageCellSchema)),
   /** How many rows come before this page in storage order. */
-  offset: z10.number().int().min(0),
-  total: z10.number().int().min(0),
+  offset: z9.number().int().min(0),
+  total: z9.number().int().min(0),
   /** Pass back as `cursor` for the next page; null on the last one. */
   nextCursor: pageCursorSchema.nullable().default(null)
 });
-var appStorageKeysSchema = z10.object({
-  keys: z10.array(
-    z10.object({ name: z10.string(), expiration: z10.number().nullable() })
+var appStorageKeysSchema = z9.object({
+  keys: z9.array(
+    z9.object({ name: z9.string(), expiration: z9.number().nullable() })
   ),
   /** Pass back as `cursor` for the next page; null on the last one. */
   nextCursor: pageCursorSchema.nullable().default(null),
   /** @deprecated Use `nextCursor`. Removed in 2.0.0. */
-  cursor: z10.string().nullable()
+  cursor: z9.string().nullable()
 });
-var appStorageValueSchema = z10.object({
-  key: z10.string(),
-  size: z10.number().int().min(0),
+var appStorageValueSchema = z9.object({
+  key: z9.string(),
+  size: z9.number().int().min(0),
   /** Null when the value is not UTF-8 text. */
-  text: z10.string().nullable(),
-  truncated: z10.boolean()
+  text: z9.string().nullable(),
+  truncated: z9.boolean()
 });
-var appMigrationNameSchema = z10.string().max(255).regex(/^[\w-][\w.-]*\.sql$/);
+var appMigrationNameSchema = z9.string().max(255).regex(/^[\w-][\w.-]*\.sql$/);
 function compareAppMigrations(a, b) {
   const left = Number.parseInt(a.split("_")[0], 10);
   const right = Number.parseInt(b.split("_")[0], 10);
@@ -793,12 +732,12 @@ function compareAppMigrations(a, b) {
   }
   return a < b ? -1 : a > b ? 1 : 0;
 }
-var appMigrationsSchema = z10.record(
+var appMigrationsSchema = z9.record(
   appSecretNameSchema,
-  z10.array(
-    z10.object({
+  z9.array(
+    z9.object({
       name: appMigrationNameSchema,
-      sql: z10.string().min(1).refine(
+      sql: z9.string().min(1).refine(
         (sql) => new TextEncoder().encode(sql).length <= APP_MIGRATION_FILE_BYTES,
         `A migration file must not exceed ${APP_MIGRATION_FILE_BYTES} bytes`
       )
@@ -816,21 +755,21 @@ var appMigrationsSchema = z10.record(
 );
 var appScripts = {
   routing: appRoutingSchema,
-  devScript: z10.string().regex(/^[\w:-]+$/),
-  checkScript: z10.string().regex(/^[\w:-]+$/),
-  buildScript: z10.string().regex(/^[\w:-]+$/)
+  devScript: z9.string().regex(/^[\w:-]+$/),
+  checkScript: z9.string().regex(/^[\w:-]+$/),
+  buildScript: z9.string().regex(/^[\w:-]+$/)
 };
 var workerSettings = {
-  runWorkerFirst: z10.boolean().default(false),
+  runWorkerFirst: z9.boolean().default(false),
   main: outputPathSchema.refine(
     (path) => /\.m?js$/.test(path),
     "Expected a compiled JavaScript entry"
   ),
-  compatibilityDate: z10.string().regex(/^\d{4}-\d{2}-\d{2}$/),
-  compatibilityFlags: z10.array(z10.string().min(1)).max(50).default([]),
-  vars: z10.record(
-    z10.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).refine((name) => name !== "ASSETS"),
-    z10.string()
+  compatibilityDate: z9.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  compatibilityFlags: z9.array(z9.string().min(1)).max(50).default([]),
+  vars: z9.record(
+    z9.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).refine((name) => name !== "ASSETS"),
+    z9.string()
   ).default({}),
   secrets: appSecretDeclarationsSchema.default({}),
   storage: appStorageSchema.optional()
@@ -858,62 +797,62 @@ var distinctBindings = (worker, ctx) => {
     }
   }
 };
-var hostedAppSchema = z10.discriminatedUnion("kind", [
-  z10.object({
-    kind: z10.literal("static"),
+var hostedAppSchema = z9.discriminatedUnion("kind", [
+  z9.object({
+    kind: z9.literal("static"),
     directory: outputPathSchema,
     ...appScripts
   }).strict(),
-  z10.object({
-    kind: z10.literal("worker"),
+  z9.object({
+    kind: z9.literal("worker"),
     directory: outputPathSchema,
     assetsDirectory: outputPathSchema.optional(),
     ...appScripts,
     ...workerSettings
   }).strict().superRefine(distinctBindings)
 ]);
-var repositorySchema = z10.object({
-  id: z10.string().uuid(),
+var repositorySchema = z9.object({
+  id: z9.string().uuid(),
   organization: identifier,
   project: identifier,
-  remote: z10.string().url(),
-  defaultBranch: z10.string(),
-  status: z10.enum(["provisioning", "ready"])
+  remote: z9.string().url(),
+  defaultBranch: z9.string(),
+  status: z9.enum(["provisioning", "ready"])
 });
-var createRepositorySchema = z10.object({
+var createRepositorySchema = z9.object({
   /** Omitted: the starter chosen at project setup, else `campaign`. */
   starter: starterIdSchema.optional()
 }).strict();
-var deviceStartSchema = z10.object({
-  challenge: z10.string().regex(/^[a-f0-9]{64}$/)
+var deviceStartSchema = z9.object({
+  challenge: z9.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var deviceRedeemSchema = z10.object({
-  id: z10.string().uuid(),
-  verifier: z10.string().min(43).max(128)
+var deviceRedeemSchema = z9.object({
+  id: z9.string().uuid(),
+  verifier: z9.string().min(43).max(128)
 }).strict();
-var deviceApproveSchema = z10.object({
-  id: z10.string().uuid(),
-  code: z10.string().regex(/^[A-F0-9]{4}-[A-F0-9]{4}$/)
+var deviceApproveSchema = z9.object({
+  id: z9.string().uuid(),
+  code: z9.string().regex(/^[A-F0-9]{4}-[A-F0-9]{4}$/)
 }).strict();
-var commitSchema = z10.string().regex(/^[a-f0-9]{40}$/);
-var stageRequestSchema = z10.object({
+var commitSchema = z9.string().regex(/^[a-f0-9]{40}$/);
+var stageRequestSchema = z9.object({
   commit: commitSchema,
-  requestId: z10.string().uuid()
+  requestId: z9.string().uuid()
 }).strict();
-var buildIdentitySchema = z10.object({
+var buildIdentitySchema = z9.object({
   routing: appRoutingSchema,
-  slug: z10.string().min(1).max(35).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional(),
-  runtime: z10.enum(["simulation", "hosted-test"]).default("simulation"),
-  id: z10.string().uuid(),
-  repository: z10.string().uuid(),
+  slug: z9.string().min(1).max(35).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).optional(),
+  runtime: z9.enum(["simulation", "hosted-test"]).default("simulation"),
+  id: z9.string().uuid(),
+  repository: z9.string().uuid(),
   organization: identifier,
   project: identifier,
   commit: commitSchema,
-  createdAt: z10.number(),
-  actor: z10.string(),
-  commitMessage: z10.string().max(500).optional()
+  createdAt: z9.number(),
+  actor: z9.string(),
+  commitMessage: z9.string().max(500).optional()
 });
-var buildPhaseSchema = z10.enum([
+var buildPhaseSchema = z9.enum([
   "queued",
   "source",
   "install",
@@ -923,72 +862,72 @@ var buildPhaseSchema = z10.enum([
   "ready",
   "failed"
 ]);
-var buildStatusSchema = z10.object({
+var buildStatusSchema = z9.object({
   phase: buildPhaseSchema,
   failedPhase: buildPhaseSchema.optional(),
-  updatedAt: z10.number(),
-  message: z10.string()
+  updatedAt: z9.number(),
+  message: z9.string()
 });
 var hostedBuildSchema = buildIdentitySchema.extend({
   ...buildStatusSchema.shape,
-  finished: z10.boolean(),
-  current: z10.boolean(),
-  stagingUrl: z10.string().url()
-});
-var stagingAccessModeSchema = z10.enum(["console", "password"]);
-var stagingAccessSchema = z10.object({ mode: stagingAccessModeSchema });
-var stagingAccessInputSchema = z10.discriminatedUnion("mode", [
-  z10.object({ mode: z10.literal("console") }).strict(),
-  z10.object({
-    mode: z10.literal("password"),
-    password: z10.string().min(8).max(128)
+  finished: z9.boolean(),
+  current: z9.boolean(),
+  stagingUrl: z9.string().url()
+});
+var stagingAccessModeSchema = z9.enum(["console", "password"]);
+var stagingAccessSchema = z9.object({ mode: stagingAccessModeSchema });
+var stagingAccessInputSchema = z9.discriminatedUnion("mode", [
+  z9.object({ mode: z9.literal("console") }).strict(),
+  z9.object({
+    mode: z9.literal("password"),
+    password: z9.string().min(8).max(128)
   }).strict()
 ]);
-var stagingPathSchema = z10.string().max(2048).refine(
+var stagingPathSchema = z9.string().max(2048).refine(
   (path) => path.startsWith("/") && !path.startsWith("//") && !path.includes("\\"),
   "Expected a path on the staging host"
 );
-var stagingLinkSchema = z10.object({
-  url: z10.string().url(),
-  expiresAt: z10.number()
+var stagingLinkSchema = z9.object({
+  url: z9.string().url(),
+  expiresAt: z9.number()
 });
-var buildSnapshotSchema = z10.object({
-  builds: z10.array(hostedBuildSchema),
+var buildSnapshotSchema = z9.object({
+  builds: z9.array(hostedBuildSchema),
   current: hostedBuildSchema.nullable(),
   selected: hostedBuildSchema.nullable(),
-  logs: z10.string()
+  logs: z9.string()
 });
-var assetPathSchema = z10.string().max(512).refine(
+var assetPathSchema = z9.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 = z10.string().regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/);
+var base64Schema = z9.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 = z10.object({
-  encoding: z10.literal("br"),
-  sha256: z10.string().regex(/^[0-9a-f]{64}$/),
-  compressedSize: z10.number().int().positive().max(stagedDeploymentLimits.compressedSize),
-  size: z10.number().int().positive().max(stagedDeploymentLimits.size)
+var stagedDeploymentSchema = z9.object({
+  encoding: z9.literal("br"),
+  sha256: z9.string().regex(/^[0-9a-f]{64}$/),
+  compressedSize: z9.number().int().positive().max(stagedDeploymentLimits.compressedSize),
+  size: z9.number().int().positive().max(stagedDeploymentLimits.size)
 }).strict();
 var stagedDeploymentContentSchema = stagedDeploymentSchema.extend({
-  content: z10.string().max(Math.ceil(stagedDeploymentLimits.compressedSize / 3) * 4)
+  content: z9.string().max(Math.ceil(stagedDeploymentLimits.compressedSize / 3) * 4)
 }).strict();
 var stagedDeploymentKey = (build, sha256) => `builds/${build}/deployment/${sha256}.br`;
 var artifactFields = {
   routing: appRoutingSchema,
-  worker: z10.object({
+  worker: z9.object({
     ...workerSettings,
     migrations: appMigrationsSchema.optional(),
-    modules: z10.array(
-      z10.object({
+    modules: z9.array(
+      z9.object({
         path: outputPathSchema.refine((path) => path !== "metadata"),
-        type: z10.enum([
+        type: z9.enum([
           "application/javascript+module",
           "application/wasm",
           "text/plain",
@@ -998,26 +937,26 @@ var artifactFields = {
       }).strict()
     ).min(1).max(500)
   }).strict().superRefine(distinctBindings).optional(),
-  assets: z10.array(
-    z10.object({
+  assets: z9.array(
+    z9.object({
       path: assetPathSchema,
       content: base64Schema.max(14e6),
-      size: z10.number().int().min(0).max(1e7)
+      size: z9.number().int().min(0).max(1e7)
     }).strict()
   ).max(500)
 };
-var buildArtifactsSchema = z10.discriminatedUnion("format", [
-  z10.object({
-    format: z10.literal(1),
+var buildArtifactsSchema = z9.discriminatedUnion("format", [
+  z9.object({
+    format: z9.literal(1),
     ...artifactFields,
-    quests: z10.unknown(),
-    catalog: z10.unknown()
+    quests: z9.unknown(),
+    catalog: z9.unknown()
   }).strict(),
-  z10.object({
-    format: z10.literal(2),
+  z9.object({
+    format: z9.literal(2),
     ...artifactFields,
     deployment: stagedDeploymentSchema,
-    images: z10.array(imageAssetArtifactSchema).max(10)
+    images: z9.array(imageAssetArtifactSchema).max(10)
   }).strict()
 ]).superRefine((value, ctx) => {
   if (value.worker) {
@@ -1069,39 +1008,39 @@ var buildArtifactsSchema = z10.discriminatedUnion("format", [
 });
 
 // src/server/development.ts
-import { z as z11 } from "zod";
-var developmentPreflightSchema = z11.object({
-  organization: z11.string(),
-  project: z11.string(),
-  environment: z11.enum(["test", "live"]),
-  identity: z11.object({
-    exchange: z11.literal("supported"),
-    activeIntegrations: z11.number().int().nonnegative()
+import { z as z10 } from "zod";
+var developmentPreflightSchema = z10.object({
+  organization: z10.string(),
+  project: z10.string(),
+  environment: z10.enum(["test", "live"]),
+  identity: z10.object({
+    exchange: z10.literal("supported"),
+    activeIntegrations: z10.number().int().nonnegative()
   }).optional(),
-  staging: z11.enum(["configured", "blocked"]),
-  development: z11.object({
-    status: z11.enum(["configured", "blocked"]),
+  staging: z10.enum(["configured", "blocked"]),
+  development: z10.object({
+    status: z10.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: z11.enum(["tunnel", "direct"]).default("tunnel"),
-    missing: z11.array(z11.string()),
-    authentication: z11.array(z11.string())
+    transport: z10.enum(["tunnel", "direct"]).default("tunnel"),
+    missing: z10.array(z10.string()),
+    authentication: z10.array(z10.string())
   }),
-  checks: z11.array(
-    z11.object({
-      id: z11.string(),
-      status: z11.enum(["ok", "error"]),
-      message: z11.string(),
-      missing: z11.array(z11.string()).optional(),
-      issues: z11.array(z11.string()).optional()
+  checks: z10.array(
+    z10.object({
+      id: z10.string(),
+      status: z10.enum(["ok", "error"]),
+      message: z10.string(),
+      missing: z10.array(z10.string()).optional(),
+      issues: z10.array(z10.string()).optional()
     })
   )
 });
 
 // src/server/hosted.ts
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 var hostedKeyPermissions = ["read", "points", "ingest"];
-var hostedKeyPermissionList = z12.array(z12.string()).transform(
+var hostedKeyPermissionList = z11.array(z11.string()).transform(
   (values) => values.filter(
     (value) => hostedKeyPermissions.includes(value)
   )
@@ -1113,17 +1052,17 @@ var hostedManagementBindings = [
   "DOMINO_PROJECT",
   "DOMINO_ENVIRONMENT"
 ];
-var hostedKeySecretSchema = z12.string().regex(/^dhk_[A-Za-z0-9_-]{43}$/, "Expected a hosted app key");
-var hostedKeySchema = z12.object({
-  id: z12.string().uuid(),
+var hostedKeySecretSchema = z11.string().regex(/^dhk_[A-Za-z0-9_-]{43}$/, "Expected a hosted app key");
+var hostedKeySchema = z11.object({
+  id: z11.string().uuid(),
   token: hostedKeySecretSchema,
   organization: identifier,
   project: identifier,
-  environment: z12.enum(["test", "live"]),
+  environment: z11.enum(["test", "live"]),
   permissions: hostedKeyPermissionList,
-  expiresAt: z12.number().nullable()
+  expiresAt: z11.number().nullable()
 }).strict();
-var hostedDeploymentKeySchema = hostedKeySchema.extend({ apiUrl: z12.string().url() }).strict();
+var hostedDeploymentKeySchema = hostedKeySchema.extend({ apiUrl: z11.string().url() }).strict();
 function hostedManagementClient(env) {
   const missing = hostedManagementBindings.filter((name) => !env[name]);
   if (missing.length) {
@@ -1131,7 +1070,7 @@ function hostedManagementClient(env) {
       `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 = z12.enum(["test", "live"]).parse(env.DOMINO_ENVIRONMENT);
+  const environment = z11.enum(["test", "live"]).parse(env.DOMINO_ENVIRONMENT);
   const token = env.DOMINO_MANAGEMENT_KEY;
   return createManagementClient({
     baseUrl: env.DOMINO_API_URL.replace(/\/+$/, ""),
@@ -1143,9 +1082,9 @@ function hostedManagementClient(env) {
 }
 
 // src/server/index.ts
-var environmentSchema = z13.enum(["test", "live"]);
-var roleSchema = z13.enum(["editor", "reviewer", "staff"]);
-var permissionSchema = z13.enum([
+var environmentSchema = z12.enum(["test", "live"]);
+var roleSchema = z12.enum(["editor", "reviewer", "staff"]);
+var permissionSchema = z12.enum([
   "read",
   "publish",
   "review",
@@ -1165,7 +1104,7 @@ var permissionSchema = z13.enum([
    */
   "enroll"
 ]);
-var permissionListSchema = z13.array(z13.string()).transform(
+var permissionListSchema = z12.array(z12.string()).transform(
   (values) => values.filter(
     (value) => permissionSchema.safeParse(value).success
   )
@@ -1175,33 +1114,33 @@ var rolePermissions = {
   reviewer: ["read", "review"],
   staff: ["read", "confirm", "handover"]
 };
-var projectSetupSchema = z13.object({
-  mode: z13.enum(["new", "existing"]),
-  brief: z13.string().trim().min(1).max(4e3)
+var projectSetupSchema = z12.object({
+  mode: z12.enum(["new", "existing"]),
+  brief: z12.string().trim().min(1).max(4e3)
 }).strict();
-var operatorUserSchema = z13.object({
-  id: z13.string(),
-  name: z13.string().nullable(),
-  email: z13.string().nullable(),
-  avatar: z13.string().nullable()
-});
-var projectSchema = z13.object({
-  slug: z13.string().min(1).max(35).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
-  createdBy: z13.string().nullable().optional(),
+var operatorUserSchema = z12.object({
+  id: z12.string(),
+  name: z12.string().nullable(),
+  email: z12.string().nullable(),
+  avatar: z12.string().nullable()
+});
+var projectSchema = z12.object({
+  slug: z12.string().min(1).max(35).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+  createdBy: z12.string().nullable().optional(),
   creator: operatorUserSchema.nullable().optional(),
   /** A response, so fields a newer server adds to the setup are dropped, not rejected. */
-  setup: z13.object(projectSetupSchema.shape).optional(),
+  setup: z12.object(projectSetupSchema.shape).optional(),
   /** The starter chosen at setup. A plain string, so later starters still parse. */
-  starter: z13.string().optional(),
-  id: z13.string().min(1),
+  starter: z12.string().optional(),
+  id: z12.string().min(1),
   organization: identifier,
   project: identifier,
-  name: z13.string(),
-  subtitle: z13.string(),
-  initials: z13.string(),
-  color: z13.string(),
+  name: z12.string(),
+  subtitle: z12.string(),
+  initials: z12.string(),
+  color: z12.string(),
   permissions: permissionListSchema,
-  environments: z13.array(environmentSchema)
+  environments: z12.array(environmentSchema)
 }).refine(
   (project) => !project.creator || project.creator.id === project.createdBy,
   {
@@ -1209,45 +1148,45 @@ var projectSchema = z13.object({
     path: ["creator"]
   }
 );
-var projectInputSchema = z13.object({
+var projectInputSchema = z12.object({
   actionId: identifier,
-  name: z13.string().trim().min(1).max(80),
+  name: z12.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 projectUpdateInputSchema = z13.union([
-  z13.object({ name: projectInputSchema.shape.name }).strict(),
-  z13.object({
+var projectUpdateInputSchema = z12.union([
+  z12.object({ name: projectInputSchema.shape.name }).strict(),
+  z12.object({
     slug: projectSchema.shape.slug,
-    confirm: z13.string().min(1).max(80)
+    confirm: z12.string().min(1).max(80)
   }).strict()
 ]);
-var projectDeletionInputSchema = z13.object({ confirm: z13.string().min(1).max(80) }).strict();
-var projectDeletionSchema = z13.object({
+var projectDeletionInputSchema = z12.object({ confirm: z12.string().min(1).max(80) }).strict();
+var projectDeletionSchema = z12.object({
   project: identifier,
-  purgeAfter: z13.number().int()
+  purgeAfter: z12.number().int()
 });
-var projectTransferInputSchema = z13.object({ organization: identifier, confirm: z13.string().min(1).max(80) }).strict();
-var projectTransferSchema = z13.object({
+var projectTransferInputSchema = z12.object({ organization: identifier, confirm: z12.string().min(1).max(80) }).strict();
+var projectTransferSchema = z12.object({
   organization: identifier,
   project: identifier
 });
-var grantSchema = z13.object({
-  subject: z13.string().min(1).max(200),
-  roles: z13.array(roleSchema),
-  environments: z13.array(environmentSchema)
+var grantSchema = z12.object({
+  subject: z12.string().min(1).max(200),
+  roles: z12.array(roleSchema),
+  environments: z12.array(environmentSchema)
 }).strict();
-var grantRecordSchema = z13.object(grantSchema.shape);
-var stockAdditionSchema = z13.object({
+var grantRecordSchema = z12.object(grantSchema.shape);
+var stockAdditionSchema = z12.object({
   item: identifier,
-  quantity: z13.number().int(),
+  quantity: z12.number().int(),
   actionId: identifier
 });
-var completionRevokeSchema = z13.object({
+var completionRevokeSchema = z12.object({
   actionId: identifier,
-  reason: z13.string().trim().min(1).max(500),
-  freeOccurrence: z13.boolean().default(false)
+  reason: z12.string().trim().min(1).max(500),
+  freeOccurrence: z12.boolean().default(false)
 }).strict();
 var RevokedEntitlementOutcome = {
   /** No other completion grants the reward: it is void, after cancelling a handover in progress. */
@@ -1275,216 +1214,218 @@ var RevokedReferralOutcome = {
   /** Qualified on another accepted completion of the program's quest instead. */
   Requalified: "requalified"
 };
-var entitlementOutcomeSchema = z13.string().min(1).max(64);
-var deliveryOutcomeSchema = z13.string().min(1).max(64);
-var referralOutcomeSchema = z13.string().min(1).max(64);
-var completionRevocationSchema = z13.object({
+var entitlementOutcomeSchema = z12.string().min(1).max(64);
+var deliveryOutcomeSchema = z12.string().min(1).max(64);
+var referralOutcomeSchema = z12.string().min(1).max(64);
+var completionRevocationSchema = z12.object({
   completion: identifier,
   /** The quest ID, or the board ID when `source.kind` is `leaderboard`. */
   quest: identifier,
   member: identifier,
   /** What paid the revoked completion. `source.id` repeats `quest`. */
   source: completionSourceSchema.optional(),
-  revokedAt: z13.number(),
-  occurrenceFreed: z13.boolean(),
-  points: z13.array(
-    z13.object({
+  revokedAt: z12.number(),
+  occurrenceFreed: z12.boolean(),
+  points: z12.array(
+    z12.object({
       entry: identifier,
       balance: identifier,
       reversal: identifier.nullable(),
-      reversed: z13.number().int(),
-      unreversed: z13.number().int()
+      reversed: z12.number().int(),
+      unreversed: z12.number().int()
     })
   ),
-  entitlements: z13.array(
-    z13.object({
+  entitlements: z12.array(
+    z12.object({
       entitlement: identifier,
       reward: identifier,
       outcome: entitlementOutcomeSchema,
-      status: z13.string()
+      status: z12.string()
     })
   ),
-  deliveries: z13.array(
-    z13.object({
-      delivery: z13.string(),
-      roleId: z13.string(),
+  deliveries: z12.array(
+    z12.object({
+      delivery: z12.string(),
+      roleId: z12.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: z13.boolean()
+      stillGranted: z12.boolean()
     })
   ),
-  referrals: z13.array(
-    z13.object({
+  referrals: z12.array(
+    z12.object({
       program: identifier,
       outcome: referralOutcomeSchema
     })
   ),
-  streakMilestone: z13.boolean()
-});
-var accessSchema = z13.object({
-  actor: z13.string(),
-  organization: z13.string(),
-  admin: z13.boolean(),
-  local: z13.boolean(),
-  projects: z13.array(projectSchema)
-});
-var querySchema = z13.object({
-  q: z13.string().max(200).default(""),
-  filter: z13.string().max(50).default("all"),
-  offset: z13.coerce.number().int().min(0).max(1e6).default(0),
-  limit: z13.coerce.number().int().min(1).max(100).default(25)
-});
-var accountProfileSchema = z13.object({
-  name: z13.string().optional(),
+  streakMilestone: z12.boolean()
+});
+var accessSchema = z12.object({
+  actor: z12.string(),
+  organization: z12.string(),
+  admin: z12.boolean(),
+  local: z12.boolean(),
+  projects: z12.array(projectSchema)
+});
+var querySchema = z12.object({
+  q: z12.string().max(200).default(""),
+  filter: z12.string().max(50).default("all"),
+  offset: z12.coerce.number().int().min(0).max(1e6).default(0),
+  limit: z12.coerce.number().int().min(1).max(100).default(25)
+});
+var accountProfileSchema = z12.object({
+  name: z12.string().optional(),
   /** The account's handle, where the provider has one (X and Discord). */
-  username: z13.string().optional(),
-  email: z13.string().optional(),
-  emailVerified: z13.boolean().default(false),
-  imageUrl: z13.string().url().optional()
+  username: z12.string().optional(),
+  email: z12.string().optional(),
+  emailVerified: z12.boolean().default(false),
+  imageUrl: z12.string().url().optional()
 });
-var memberAccountSchema = z13.object({
+var memberAccountSchema = z12.object({
   /** `wallet` for wallet sign-in, `account` for every other connected account. */
-  kind: z13.enum(["account", "wallet"]),
-  provider: z13.string(),
-  subject: z13.string(),
-  signInEnabled: z13.boolean(),
+  kind: z12.enum(["account", "wallet"]),
+  provider: z12.string(),
+  subject: z12.string(),
+  signInEnabled: z12.boolean(),
   profile: accountProfileSchema.optional()
 });
-var operationSchema = z13.object({
-  target: z13.string(),
-  paused: z13.boolean(),
-  revision: z13.number().int(),
-  reason: z13.string(),
-  actor: z13.string().nullable(),
-  changedAt: z13.number()
-});
-var operationInputSchema = z13.object({
-  target: z13.union([
-    z13.literal("redemptions"),
-    z13.string().regex(/^quest:[\w-]+$/)
+var operationSchema = z12.object({
+  target: z12.string(),
+  paused: z12.boolean(),
+  revision: z12.number().int(),
+  reason: z12.string(),
+  actor: z12.string().nullable(),
+  changedAt: z12.number()
+});
+var operationInputSchema = z12.object({
+  target: z12.union([
+    z12.literal("redemptions"),
+    z12.string().regex(/^quest:[\w-]+$/)
   ]),
-  paused: z13.boolean(),
-  revision: z13.number().int().nonnegative(),
-  reason: z13.string().trim().min(1).max(500),
+  paused: z12.boolean(),
+  revision: z12.number().int().nonnegative(),
+  reason: z12.string().trim().min(1).max(500),
   actionId: identifier
 }).strict();
-var questLifecycleInputSchema = z13.object({
+var questLifecycleInputSchema = z12.object({
   quest: identifier,
   expectedRelease: identifier.optional(),
-  archived: z13.boolean(),
-  reason: z13.string().trim().min(1).max(500),
+  archived: z12.boolean(),
+  reason: z12.string().trim().min(1).max(500),
   actionId: identifier
 }).strict();
-var questLifecycleSchema = z13.object({
+var questLifecycleSchema = z12.object({
   quest: identifier,
   key: identifier.nullable(),
-  title: z13.string(),
+  title: z12.string(),
   release: identifier,
-  lifecycle: z13.enum(["active", "paused", "archived"]),
-  changed: z13.boolean()
-});
-var memberSchema = z13.object({
-  id: z13.string(),
-  test: z13.boolean().optional(),
-  name: z13.string().nullable().optional(),
-  accounts: z13.array(memberAccountSchema).default([]),
-  attempts: z13.number(),
-  completions: z13.number(),
-  rewards: z13.number(),
-  lastActivity: z13.number().nullable()
-});
-var personSchema = z13.object({
-  id: z13.string(),
-  accounts: z13.array(memberAccountSchema).default([])
-});
-var metricsSchema = z13.object({
-  quests: z13.number(),
-  members: z13.number(),
-  attempts: z13.number(),
-  completions: z13.number(),
-  review: z13.number(),
-  failed: z13.number(),
-  entitlements: z13.number()
-});
-var readinessSchema = z13.object({
-  checks: z13.array(
-    z13.object({
-      id: z13.string(),
-      status: z13.enum(["ready", "blocked"]),
-      title: z13.string(),
-      detail: z13.string()
+  lifecycle: z12.enum(["active", "paused", "archived"]),
+  changed: z12.boolean()
+});
+var memberSchema = z12.object({
+  id: z12.string(),
+  test: z12.boolean().optional(),
+  name: z12.string().nullable().optional(),
+  accounts: z12.array(memberAccountSchema).default([]),
+  attempts: z12.number(),
+  completions: z12.number(),
+  rewards: z12.number(),
+  lastActivity: z12.number().nullable()
+});
+var personSchema = z12.object({
+  id: z12.string(),
+  test: z12.boolean().optional(),
+  name: z12.string().nullable().optional(),
+  accounts: z12.array(memberAccountSchema).default([])
+});
+var metricsSchema = z12.object({
+  quests: z12.number(),
+  members: z12.number(),
+  attempts: z12.number(),
+  completions: z12.number(),
+  review: z12.number(),
+  failed: z12.number(),
+  entitlements: z12.number()
+});
+var readinessSchema = z12.object({
+  checks: z12.array(
+    z12.object({
+      id: z12.string(),
+      status: z12.enum(["ready", "blocked"]),
+      title: z12.string(),
+      detail: z12.string()
     })
   )
 });
-var inventorySchema = z13.object({
-  item: z13.string(),
-  name: z13.string().nullable().default(null),
-  available: z13.number(),
-  reserved: z13.number(),
-  allocated: z13.number().default(0)
-});
-var auditRecordSchema = z13.object({
-  id: z13.string(),
-  action: z13.string(),
-  actor: z13.string().nullable(),
+var inventorySchema = z12.object({
+  item: z12.string(),
+  name: z12.string().nullable().default(null),
+  available: z12.number(),
+  reserved: z12.number(),
+  allocated: z12.number().default(0)
+});
+var auditRecordSchema = z12.object({
+  id: z12.string(),
+  action: z12.string(),
+  actor: z12.string().nullable(),
   user: operatorUserSchema.nullable().optional(),
-  detail: z13.string(),
-  at: z13.number(),
-  attempt: z13.string().nullable()
+  detail: z12.string(),
+  at: z12.number(),
+  attempt: z12.string().nullable()
 }).refine((record) => !record.user || record.user.id === record.actor, {
   message: "User profile must match the recorded actor",
   path: ["user"]
 });
-var pageSchema = z13.object({
+var pageSchema = z12.object({
   snapshot: snapshotSchema,
-  members: z13.array(memberSchema),
-  people: z13.array(personSchema).default([]),
+  members: z12.array(memberSchema),
+  people: z12.array(personSchema).default([]),
   metrics: metricsSchema,
-  total: z13.number(),
-  offset: z13.number(),
-  limit: z13.number(),
-  inventory: z13.array(inventorySchema),
-  operations: z13.array(operationSchema).default([]),
-  audit: z13.array(auditRecordSchema).default([]),
-  questCounts: z13.record(z13.string(), z13.number())
-});
-var managedOAuthAccountBaseSchema = z13.object({
-  provider: z13.enum(["x", "discord"]),
-  revision: z13.number().int().nonnegative()
-});
-var managedOAuthAccountSchema = z13.discriminatedUnion("status", [
+  total: z12.number(),
+  offset: z12.number(),
+  limit: z12.number(),
+  inventory: z12.array(inventorySchema),
+  operations: z12.array(operationSchema).default([]),
+  audit: z12.array(auditRecordSchema).default([]),
+  questCounts: z12.record(z12.string(), z12.number())
+});
+var managedOAuthAccountBaseSchema = z12.object({
+  provider: z12.enum(["x", "discord"]),
+  revision: z12.number().int().nonnegative()
+});
+var managedOAuthAccountSchema = z12.discriminatedUnion("status", [
   managedOAuthAccountBaseSchema.extend({
-    status: z13.literal("connected"),
-    subject: z13.string().min(1),
-    linkedAt: z13.number()
+    status: z12.literal("connected"),
+    subject: z12.string().min(1),
+    linkedAt: z12.number()
   }),
-  managedOAuthAccountBaseSchema.extend({ status: z13.literal("disconnected") })
+  managedOAuthAccountBaseSchema.extend({ status: z12.literal("disconnected") })
 ]);
-var memberOAuthUnlinkInputSchema = z13.object({
-  provider: z13.enum(["x", "discord"]),
-  subject: z13.string().min(1).max(4096),
-  revision: z13.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER - 1),
-  reason: z13.string().trim().min(1).max(500)
+var memberOAuthUnlinkInputSchema = z12.object({
+  provider: z12.enum(["x", "discord"]),
+  subject: z12.string().min(1).max(4096),
+  revision: z12.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER - 1),
+  reason: z12.string().trim().min(1).max(500)
 }).strict();
 var managedWalletSchema = linkedWalletSchema.extend({
-  status: z13.enum(["linked", "unlinked"]),
-  unlinkedAt: z13.number().int().nullable(),
+  status: z12.enum(["linked", "unlinked"]),
+  unlinkedAt: z12.number().int().nullable(),
   /** "member", or the operator or key that unlinked it. */
-  unlinkedBy: z13.string().nullable()
+  unlinkedBy: z12.string().nullable()
 });
 var managedMemberIdentitySchema = memberIdentitySchema.extend({
-  status: z13.enum(["linked", "unlinked"]),
-  unlinkedAt: z13.number().int().nullable(),
+  status: z12.enum(["linked", "unlinked"]),
+  unlinkedAt: z12.number().int().nullable(),
   /** The operator or key that unlinked it. */
-  unlinkedBy: z13.string().nullable()
+  unlinkedBy: z12.string().nullable()
 });
-var memberIdentityChangeInputSchema = z13.object({
+var memberIdentityChangeInputSchema = z12.object({
   kind: appIdentityKindSchema,
-  subject: z13.string().min(1).max(256),
-  reason: z13.string().trim().min(1).max(500)
+  subject: z12.string().min(1).max(256),
+  reason: z12.string().trim().min(1).max(500)
 }).strict();
 var balanceCheckSchema = walletBalanceSchema.pick({
   chain: true,
@@ -1494,65 +1435,65 @@ var balanceCheckSchema = walletBalanceSchema.pick({
   wallets: true,
   observedAt: true
 }).extend({ attempt: identifier });
-var walletBalanceChainsSchema = z13.object({
-  chains: z13.array(
-    z13.object({
-      chain: z13.union([
-        z13.literal(solanaMainnet),
+var walletBalanceChainsSchema = z12.object({
+  chains: z12.array(
+    z12.object({
+      chain: z12.union([
+        z12.literal(solanaMainnet),
         cosmosNetworkSchema,
         evmChainIdSchema
       ]),
-      name: z13.string(),
-      testnet: z13.boolean()
+      name: z12.string(),
+      testnet: z12.boolean()
     })
   )
 });
-var memberWalletUnlinkInputSchema = walletUnlinkInputSchema.extend({ reason: z13.string().trim().min(1).max(500) }).strict();
+var memberWalletUnlinkInputSchema = walletUnlinkInputSchema.extend({ reason: z12.string().trim().min(1).max(500) }).strict();
 var memberWalletSignInInputSchema = walletUnlinkInputSchema.extend({
-  enabled: z13.boolean(),
-  reason: z13.string().trim().min(1).max(500)
+  enabled: z12.boolean(),
+  reason: z12.string().trim().min(1).max(500)
 }).strict();
-var participantSignInSchema = z13.object({
-  providers: z13.array(
-    z13.object({ provider: authProviderSchema, configured: z13.boolean() })
+var participantSignInSchema = z12.object({
+  providers: z12.array(
+    z12.object({ provider: authProviderSchema, configured: z12.boolean() })
   ),
-  email: z13.boolean(),
+  email: z12.boolean(),
   /** Wallet families: `"solana"`, `"eip155"`, `"cosmos"`. */
   wallets: walletSignInNetworksSchema,
   /** Why participants cannot sign in to this project, or null. */
-  issue: z13.string().nullable(),
-  updatedAt: z13.number().nullable(),
-  updatedBy: z13.string().nullable()
+  issue: z12.string().nullable(),
+  updatedAt: z12.number().nullable(),
+  updatedBy: z12.string().nullable()
 });
-var participantSignInInputSchema = z13.object({
+var participantSignInInputSchema = z12.object({
   wallets: walletSignInNetworksSchema
 }).strict();
-var completionRevocationShortfallSchema = z13.object({
+var completionRevocationShortfallSchema = z12.object({
   completion: identifier,
   quest: identifier,
-  revokedAt: z13.number().int().nonnegative().safe(),
-  unreversedPoints: z13.record(identifier, z13.number().int().positive().safe())
+  revokedAt: z12.number().int().nonnegative().safe(),
+  unreversedPoints: z12.record(identifier, z12.number().int().positive().safe())
 });
-var memberDetailSchema = z13.object({
+var memberDetailSchema = z12.object({
   snapshot: snapshotSchema,
   member: memberSchema,
   progress: memberProgressSchema,
   /** Up to 25 revoked completions with an unreversed point remainder, newest first. */
-  revocationShortfalls: z13.array(completionRevocationShortfallSchema).default([]),
+  revocationShortfalls: z12.array(completionRevocationShortfallSchema).default([]),
   /** Current and historical campaign enrollment state, including inactive enrollments. */
-  campaignEnrollments: z13.array(campaignEnrollmentSchema).default([]),
-  passes: z13.array(
-    z13.object({
-      provider: z13.string(),
-      event: z13.string(),
-      subject: z13.string(),
+  campaignEnrollments: z12.array(campaignEnrollmentSchema).default([]),
+  passes: z12.array(
+    z12.object({
+      provider: z12.string(),
+      event: z12.string(),
+      subject: z12.string(),
       attempt: identifier.nullable()
     })
   ).default([]),
   /** Linked and unlinked wallets. */
-  wallets: z13.array(managedWalletSchema),
+  wallets: z12.array(managedWalletSchema),
   /** The member's 10 most recent recorded balance reads, newest first. */
-  balanceChecks: z13.array(balanceCheckSchema),
+  balanceChecks: z12.array(balanceCheckSchema),
   /** The member's participant profile in this project. */
   profile: managedProfileSchema.nullable(),
   /**
@@ -1560,123 +1501,129 @@ var memberDetailSchema = z13.object({
    * 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: z13.array(managedMemberIdentitySchema)
+  identities: z12.array(managedMemberIdentitySchema)
 });
-var stockInputSchema = z13.object({
+var stockInputSchema = z12.object({
   item: identifier,
-  quantity: z13.number().int().positive().max(1e6),
+  quantity: z12.number().int().positive().max(1e6),
   actionId: identifier
 }).strict();
-var ingestTrackerScopeSchema = z13.array(identifier).min(1).max(100).nullable();
-var tokenScopeInputSchema = z13.object({ ingestTrackers: ingestTrackerScopeSchema }).strict();
-var tokenInputSchema = z13.object({
-  name: z13.string().trim().min(1).max(80),
+var ingestTrackerScopeSchema = z12.array(identifier).min(1).max(100).nullable();
+var tokenScopeInputSchema = z12.object({ ingestTrackers: ingestTrackerScopeSchema }).strict();
+var tokenInputSchema = z12.object({
+  name: z12.string().trim().min(1).max(80),
   project: identifier,
   environment: environmentSchema,
-  permissions: z13.array(permissionSchema).min(1),
+  permissions: z12.array(permissionSchema).min(1),
   ingestTrackers: ingestTrackerScopeSchema.optional(),
-  days: z13.number().int().min(1).max(90).default(30)
+  days: z12.number().int().min(1).max(90).default(30)
 }).strict();
-var tokenSchema = z13.object({
-  id: z13.string(),
-  name: z13.string(),
-  project: z13.string(),
+var tokenSchema = z12.object({
+  id: z12.string(),
+  name: z12.string(),
+  project: z12.string(),
   environment: environmentSchema,
   permissions: permissionListSchema,
   ingestTrackers: ingestTrackerScopeSchema.optional(),
-  expiresAt: z13.number()
+  expiresAt: z12.number()
 });
-var issuedTokenSchema = tokenSchema.extend({ token: z13.string() });
-var teamSchema = z13.array(
-  z13.object({ id: z13.string(), label: z13.string() })
+var issuedTokenSchema = tokenSchema.extend({ token: z12.string() });
+var teamSchema = z12.array(
+  z12.object({ id: z12.string(), label: z12.string() })
 );
-var memberLookupSchema = z13.object({
-  provider: z13.string().min(1).max(200),
-  subject: z13.string().min(1).max(2048)
+var memberLookupSchema = z12.object({
+  provider: z12.string().min(1).max(200),
+  subject: z12.string().min(1).max(2048)
 }).strict();
-var booleanQuery = z13.union([
-  z13.boolean(),
-  z13.enum(["true", "false"]).transform((v) => v === "true")
+var booleanQuery = z12.union([
+  z12.boolean(),
+  z12.enum(["true", "false"]).transform((v) => v === "true")
 ]);
-var managedMemberQuerySchema = z13.strictObject({
-  q: z13.string().max(200).optional(),
+var managedMemberQuerySchema = z12.strictObject({
+  q: z12.string().max(200).optional(),
   needsReview: booleanQuery.optional(),
-  limit: z13.coerce.number().int().min(1).max(100).optional(),
+  limit: z12.coerce.number().int().min(1).max(100).optional(),
   cursor: pageCursorSchema.optional()
 });
-var managedMemberPageSchema = z13.object({
-  items: z13.array(memberSchema),
-  total: z13.number().int().nonnegative(),
-  nextCursor: z13.string().nullable()
+var managedMemberPageSchema = z12.object({
+  items: z12.array(memberSchema),
+  total: z12.number().int().nonnegative(),
+  nextCursor: z12.string().nullable()
 });
 var projectMetricsSchema = metricsSchema.extend({
-  completionsByQuest: z13.array(
-    z13.object({ quest: identifier, completions: z13.number() })
+  completionsByQuest: z12.array(
+    z12.object({ quest: identifier, completions: z12.number() })
   )
 });
-var pageLimit = z13.coerce.number().int().min(1).max(100).optional();
-var managedAttemptQuerySchema = z13.strictObject({
-  q: z13.string().max(200).optional(),
-  status: z13.string().min(1).max(50).optional(),
+var pageLimit = z12.coerce.number().int().min(1).max(100).optional();
+var managedAttemptQuerySchema = z12.strictObject({
+  q: z12.string().max(200).optional(),
+  status: z12.string().min(1).max(50).optional(),
+  limit: pageLimit,
+  cursor: pageCursorSchema.optional()
+});
+var managedAttemptPageSchema = z12.object({
+  items: z12.array(attemptSchema),
+  releases: z12.array(publishedReleaseSchema),
+  people: z12.array(personSchema),
+  total: z12.number().int().nonnegative(),
+  nextCursor: z12.string().nullable()
+});
+var managedReleaseQuerySchema = z12.strictObject({
+  quest: identifier.optional(),
   limit: pageLimit,
   cursor: pageCursorSchema.optional()
 });
-var managedAttemptPageSchema = z13.object({
-  items: z13.array(attemptSchema),
-  releases: z13.array(publishedReleaseSchema),
-  people: z13.array(personSchema),
-  total: z13.number().int().nonnegative(),
-  nextCursor: z13.string().nullable()
+var managedReleasePageSchema = z12.object({
+  items: z12.array(publishedReleaseSchema),
+  nextCursor: z12.string().nullable()
 });
-var managedAttemptSchema = z13.object({
+var managedAttemptSchema = z12.object({
   attempt: attemptSchema,
   release: publishedReleaseSchema.nullable(),
-  events: z13.array(eventSchema),
+  events: z12.array(eventSchema),
   person: personSchema
 });
-var managedEntitlementQuerySchema = z13.strictObject({
-  q: z13.string().max(200).optional(),
-  status: z13.string().min(1).max(50).optional(),
+var managedEntitlementQuerySchema = z12.strictObject({
+  q: z12.string().max(200).optional(),
+  status: z12.string().min(1).max(50).optional(),
   limit: pageLimit,
   cursor: pageCursorSchema.optional()
 });
-var managedEntitlementPageSchema = z13.object({
-  items: z13.array(entitlementSchema),
-  people: z13.array(personSchema),
-  total: z13.number().int().nonnegative(),
-  nextCursor: z13.string().nullable()
+var managedEntitlementPageSchema = z12.object({
+  items: z12.array(entitlementSchema),
+  people: z12.array(personSchema),
+  total: z12.number().int().nonnegative(),
+  nextCursor: z12.string().nullable()
 });
-var managedEntitlementSchema = z13.object({
+var managedEntitlementSchema = z12.object({
   entitlement: entitlementSchema,
   person: personSchema
 });
 var managedStockItemSchema = inventorySchema.extend({
-  offers: z13.array(identifier)
+  offers: z12.array(identifier)
 });
-var auditQuerySchema = z13.strictObject({
-  category: z13.enum(["reviews", "rewards", "configuration"]).optional(),
-  q: z13.string().max(200).optional(),
+var auditQuerySchema = z12.strictObject({
+  category: z12.enum(["reviews", "rewards", "configuration"]).optional(),
+  q: z12.string().max(200).optional(),
   limit: pageLimit,
   cursor: pageCursorSchema.optional()
 });
 var accessHistoryQuerySchema = auditQuerySchema.omit({
   category: true
 });
-var auditPageSchema = z13.object({
-  items: z13.array(auditRecordSchema),
-  total: z13.number().int().nonnegative(),
-  nextCursor: z13.string().nullable()
+var auditPageSchema = z12.object({
+  items: z12.array(auditRecordSchema),
+  total: z12.number().int().nonnegative(),
+  nextCursor: z12.string().nullable()
 });
-var verifiedPassSchema = z13.object({
+var verifiedPassSchema = z12.object({
   provider: identifier,
   event: identifier,
-  subject: z13.string().min(1).max(2048),
+  subject: z12.string().min(1).max(2048),
   member: identifier,
   quest: identifier
 }).strict();
-function actionIdOf(input) {
-  return typeof input === "object" && input !== null && "actionId" in input && typeof input.actionId === "string" ? input.actionId : void 0;
-}
 function groupKey(group) {
   return identifier.parse(
     typeof group === "string" ? group : projectGroupKey(group)
@@ -1690,16 +1637,6 @@ function queryString(values) {
   ).toString();
   return query ? "?" + query : "";
 }
-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;
@@ -1707,7 +1644,7 @@ function clientFailure(error) {
   return new ManagementError({
     kind: "client",
     code: ManagementErrorCode.InvalidInput,
-    message: error instanceof z13.ZodError ? `Invalid management request: ${z13.prettifyError(error)}` : error instanceof Error ? error.message : "Invalid management request",
+    message: error instanceof z12.ZodError ? `Invalid management request: ${z12.prettifyError(error)}` : error instanceof Error ? error.message : "Invalid management request",
     cause: error
   });
 }
@@ -1731,231 +1668,7 @@ function createManagementClient(options) {
   return managementClient(options);
 }
 function managementClient(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);
-    headers.set("X-Domino-Client", clientIdentity());
-    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 = managementErrorSchema.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, tolerant = false) {
-    const actionId = actionIdOf(input);
-    const context = {
-      method,
-      replaySafe,
-      path: path.split("?")[0],
-      ...actionId ? { actionId } : {}
-    };
-    const fetchInit = {
-      method,
-      headers: tolerant ? { "X-Domino-Response": "tolerant-v1" } : void 0,
-      ...input === void 0 ? {} : {
-        headers: {
-          "Content-Type": "application/json",
-          ...tolerant ? { "X-Domino-Response": "tolerant-v1" } : {}
-        },
-        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 = knownResponse(schema).safeParse(
-            tolerant ? { status: response.status, operationId: actionId, result: body } : 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();
-    }
-  }
+  const { raw, exchange } = managementTransport(options);
   async function request(path, schema, input, method = input === void 0 ? "GET" : "POST", call) {
     return exchange(path, schema, input, method.toUpperCase(), call, false);
   }
@@ -1969,7 +1682,7 @@ function managementClient(options) {
       call
     );
   }
-  const ok = z13.object({ ok: z13.literal(true) });
+  const ok = z12.object({ ok: z12.literal(true) });
   function pointHistory(member, ledger, query = {}, call) {
     return get(
       `/points/${identifier.parse(member)}/${identifier.parse(ledger)}/history${queryString(typeof query === "number" ? { before: query } : pageQuerySchema.parse(query))}`,
@@ -2091,8 +1804,8 @@ function managementClient(options) {
       }
       return exchange(
         path,
-        z13.object({
-          status: z13.number(),
+        z12.object({
+          status: z12.number(),
           operationId: identifier.optional(),
           result: schema
         }),
@@ -2123,7 +1836,7 @@ function managementClient(options) {
         call
       ),
       ...resourceArchiveMethods("tracker"),
-      list: (call) => get("/trackers", z13.array(trackerStatusSchema), call),
+      list: (call) => get("/trackers", z12.array(trackerStatusSchema), call),
       get: (reference, call) => get(
         `/trackers/${identifier.parse(reference)}`,
         trackerStatusSchema,
@@ -2239,7 +1952,7 @@ function managementClient(options) {
         engagementPublishSchema.parse(withActionId(input)),
         call
       ),
-      list: (call) => get("/engagement", z13.array(engagementRuleSchema), call),
+      list: (call) => get("/engagement", z12.array(engagementRuleSchema), call),
       page: (input, call) => get(
         "/engagement/history" + queryString(engagementPageQuerySchema.parse(input)),
         engagementPageSchema,
@@ -2260,7 +1973,7 @@ function managementClient(options) {
     },
     pointLedgers: {
       unarchive: (ledger, input, call) => archiveResource("point-ledger", ledger, false, input, call),
-      list: (call) => get("/point-ledgers", z13.array(managedPointLedgerSchema), call),
+      list: (call) => get("/point-ledgers", z12.array(managedPointLedgerSchema), call),
       /**
        * Creates a point ledger, with a stable `key` when code refers to it; requires `publish`. In
        * live, only a person in Console can create one.
@@ -2290,7 +2003,7 @@ function managementClient(options) {
     },
     points: {
       /** @deprecated Use `pointLedgers.list()`, which reads the same ledgers. Removed in 2.0.0. */
-      ledgers: (call) => get("/point-ledgers", z13.array(managedPointLedgerSchema), call),
+      ledgers: (call) => get("/point-ledgers", z12.array(managedPointLedgerSchema), call),
       /** @deprecated Use `pointLedgers.create(input)`. Removed in 2.0.0. */
       createLedger: createPointLedger,
       /**
@@ -2328,7 +2041,7 @@ function managementClient(options) {
         referralHistorySchema,
         call
       ),
-      list: (call) => get("/referrals", z13.array(publishedReferralSchema), call),
+      list: (call) => get("/referrals", z12.array(publishedReferralSchema), call),
       participants: referralParticipants,
       /**
        * Suspends or restores a member's referral relationship, with a reason; requires `publish`.
@@ -2391,7 +2104,7 @@ function managementClient(options) {
     },
     leaderboards: {
       ...resourceArchiveMethods("leaderboard"),
-      list: (call) => get("/leaderboards", z13.array(publishedLeaderboardSchema), call),
+      list: (call) => get("/leaderboards", z12.array(publishedLeaderboardSchema), call),
       standings: (board, input = {}, call) => {
         const query = leaderboardQuerySchema.parse(input);
         return get(
@@ -2405,12 +2118,12 @@ function managementClient(options) {
       },
       history: (board, call) => get(
         `/leaderboards/${identifier.parse(board)}/history`,
-        z13.array(publishedLeaderboardSchema),
+        z12.array(publishedLeaderboardSchema),
         call
       ),
       exclusions: (board, call) => get(
         `/leaderboards/${identifier.parse(board)}/exclusions`,
-        z13.array(z13.object({ member: identifier })),
+        z12.array(z12.object({ member: identifier })),
         call
       ),
       exclude: (board, input, call) => post(
@@ -2451,7 +2164,7 @@ function managementClient(options) {
       ),
       settlements: (board, call) => get(
         `/leaderboards/${identifier.parse(board)}/settlements`,
-        z13.array(leaderboardSettlementSummarySchema),
+        z12.array(leaderboardSettlementSummarySchema),
         call
       ),
       settlement: (settlement, call) => get(
@@ -2531,7 +2244,7 @@ function managementClient(options) {
       )
     },
     deployments: {
-      list: (call) => get("/deployments", z13.array(deploymentRecordSchema), call),
+      list: (call) => get("/deployments", z12.array(deploymentRecordSchema), call),
       get: (deployment, call) => get(
         `/deployments/${identifier.parse(deployment)}`,
         deploymentRecordSchema,
@@ -2598,6 +2311,28 @@ function managementClient(options) {
     metrics: {
       read: (call) => get("/metrics", projectMetricsSchema, call)
     },
+    /** Release history: every version a quest has been published as. */
+    releases: {
+      /**
+       * One page of the project's releases, newest first, including each quest's earlier
+       * releases; `quest` keeps one quest's. Pass a page's `nextCursor` back as `cursor` for the
+       * next page. Requires `read` and `publish` permission.
+       */
+      list: (query = {}, call) => get(
+        `/releases/list${queryString(managedReleaseQuerySchema.parse(query))}`,
+        managedReleasePageSchema,
+        call
+      ),
+      /**
+       * One release by ID, current or historical. Requires `read` and `publish` permission.
+       * Fails with 404 when the project has no such release.
+       */
+      get: (release, call) => get(
+        `/releases/${identifier.parse(release)}`,
+        publishedReleaseSchema,
+        call
+      )
+    },
     /** Attempts, staff-confirmed quests and reviews. */
     attempts: {
       /**
@@ -2619,6 +2354,17 @@ function managementClient(options) {
         managedAttemptSchema,
         call
       ),
+      /**
+       * Everything one evaluation run of a test-environment attempt read, for `replayAttempt` from
+       * `@domino-sdk/relay/testing`; requires `publish` permission, because captures hold raw provider answers. Relay serves captures only in the
+       * test environment: in live it fails with 422 `test-environment-required`. An attempt with
+       * no evaluation run yet fails with 409 `attempt-not-evaluated`.
+       */
+      capture: (attempt, call) => get(
+        `/attempts/${identifier.parse(attempt)}/capture`,
+        attemptCaptureSchema,
+        call
+      ),
       /**
        * 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
@@ -2767,7 +2513,7 @@ function managementClient(options) {
     },
     operations: {
       /** Every paused or resumed operation: redemptions and each quest's participation; requires `read`. */
-      list: (call) => get("/operations", z13.array(operationSchema), call),
+      list: (call) => get("/operations", z12.array(operationSchema), call),
       /**
        * Pauses or resumes redemptions or one quest's participation, against the `revision` the
        * operator saw, with a reason; requires `publish` permission.
@@ -2816,7 +2562,7 @@ function managementClient(options) {
         call
       ),
       /** Every stock item with its counts and the offers that sell it; requires `read` permission. */
-      list: (call) => get("/stock-items", z13.array(managedStockItemSchema), call),
+      list: (call) => get("/stock-items", z12.array(managedStockItemSchema), call),
       createItem: (input, call) => create(
         "/stock-items",
         stockItemSchema,
@@ -2831,7 +2577,7 @@ function managementClient(options) {
         stockInputSchema.parse(withActionId(input)),
         call
       ),
-      catalog: (call) => get("/pickup-inventory", z13.array(pickupCatalogSchema), call),
+      catalog: (call) => get("/pickup-inventory", z12.array(pickupCatalogSchema), call),
       configure: (input, call) => post(
         "/pickup-inventory",
         pickupCatalogSchema,
@@ -2857,10 +2603,10 @@ function managementClient(options) {
         offerControlSchema.omit({ enabled: true }).parse(withActionId(input)),
         call
       ),
-      list: (call) => get("/offers", z13.array(offerSchema), call),
+      list: (call) => get("/offers", z12.array(offerSchema), call),
       redemptions: (input = {}, call) => get(
         `/redemptions${queryString({ member: input.member })}`,
-        z13.array(redemptionSchema),
+        z12.array(redemptionSchema),
         call
       ),
       /** Pauses or resumes an offer at the revision the operator saw. */
@@ -2909,7 +2655,7 @@ function managementClient(options) {
      * them; API keys and project-scoped playground sessions cannot.
      */
     tokens: {
-      list: (call) => get("/tokens", z13.array(tokenSchema), call),
+      list: (call) => get("/tokens", z12.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.
@@ -2917,14 +2663,14 @@ function managementClient(options) {
       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(z13.string().min(1).parse(id))}/scope`,
+        `/tokens/${encodeURIComponent(z12.string().min(1).parse(id))}/scope`,
         tokenSchema,
         tokenScopeInputSchema.parse(input),
         "PUT",
         call
       ),
       revoke: (id, call) => request(
-        `/tokens/${encodeURIComponent(z13.string().min(1).parse(id))}`,
+        `/tokens/${encodeURIComponent(z12.string().min(1).parse(id))}`,
         ok,
         void 0,
         "DELETE",
@@ -2933,7 +2679,7 @@ function managementClient(options) {
     },
     /** Who holds which roles on the client's project; organization administrators only. */
     grants: {
-      list: (call) => get("/grants", z13.array(grantRecordSchema), call),
+      list: (call) => get("/grants", z12.array(grantRecordSchema), call),
       /** Replaces one person's roles and environments on the project. The audit log records it. */
       set: (input, call) => request(
         "/grants",
@@ -2950,7 +2696,7 @@ function managementClient(options) {
     /** Signed activity notifications for one project/environment; writes require publish permission. */
     webhooks: {
       state: (id, call) => get(
-        `/webhooks/${z13.string().uuid().parse(id)}/state`,
+        `/webhooks/${z12.string().uuid().parse(id)}/state`,
         webhookEndpointStateSchema,
         call
       ),
@@ -2961,24 +2707,24 @@ function managementClient(options) {
         call
       ),
       delete: (id, input, call) => post(
-        `/webhooks/${z13.string().uuid().parse(id)}/delete`,
+        `/webhooks/${z12.string().uuid().parse(id)}/delete`,
         webhookEndpointStateSchema,
         webhookDeleteInputSchema.parse(withActionId(input)),
         call
       ),
       pause: (id, input = {}, call) => post(
-        `/webhooks/${z13.string().uuid().parse(id)}/pause`,
+        `/webhooks/${z12.string().uuid().parse(id)}/pause`,
         webhookEndpointSchema,
         webhookControlInputSchema.parse(withActionId(input)),
         call
       ),
       resume: (id, input = {}, call) => post(
-        `/webhooks/${z13.string().uuid().parse(id)}/resume`,
+        `/webhooks/${z12.string().uuid().parse(id)}/resume`,
         webhookEndpointSchema,
         webhookControlInputSchema.parse(withActionId(input)),
         call
       ),
-      list: (call) => get("/webhooks", z13.array(webhookEndpointSchema), call),
+      list: (call) => get("/webhooks", z12.array(webhookEndpointSchema), call),
       create: (input, call) => post(
         "/webhooks",
         webhookSecretSchema,
@@ -2986,7 +2732,7 @@ function managementClient(options) {
         call
       ),
       update: (id, input, call) => request(
-        `/webhooks/${z13.string().uuid().parse(id)}`,
+        `/webhooks/${z12.string().uuid().parse(id)}`,
         webhookEndpointSchema,
         webhookUpdateSchema.parse(input),
         "PUT",
@@ -2994,24 +2740,24 @@ function managementClient(options) {
       ),
       /** @deprecated Use pause. Removed in 2.0.0. */
       disable: (id, call) => post(
-        `/webhooks/${z13.string().uuid().parse(id)}/disable`,
+        `/webhooks/${z12.string().uuid().parse(id)}/disable`,
         webhookEndpointSchema,
         {},
         call
       ),
       rotateSecret: (id, call) => post(
-        `/webhooks/${z13.string().uuid().parse(id)}/rotate-secret`,
+        `/webhooks/${z12.string().uuid().parse(id)}/rotate-secret`,
         webhookSecretSchema,
         {},
         call
       ),
       deliveries: (id, query = {}, call) => get(
-        `/webhooks/${z13.string().uuid().parse(id)}/deliveries${queryString(webhookQuerySchema.parse(query))}`,
+        `/webhooks/${z12.string().uuid().parse(id)}/deliveries${queryString(webhookQuerySchema.parse(query))}`,
         webhookDeliveryPageSchema,
         call
       ),
       replay: (id, delivery, call) => post(
-        `/webhooks/${z13.string().uuid().parse(id)}/deliveries/${z13.string().uuid().parse(delivery)}/replay`,
+        `/webhooks/${z12.string().uuid().parse(id)}/deliveries/${z12.string().uuid().parse(delivery)}/replay`,
         webhookDeliverySchema,
         {},
         call
@@ -3022,7 +2768,7 @@ function managementClient(options) {
      * environment. Organization administrators, from a Console session only.
      */
     identityIntegrations: {
-      list: (call) => get("/identity-integrations", z13.array(identityIntegrationSchema), call),
+      list: (call) => get("/identity-integrations", z12.array(identityIntegrationSchema), call),
       /** The secret `token` is in this response only. */
       create: (input, call) => post(
         "/identity-integrations",
@@ -3032,7 +2778,7 @@ function managementClient(options) {
       ),
       /** Replaces the key's secret and extends it by 90 days; the old secret stops working. */
       rotate: (id, call) => post(
-        `/identity-integrations/${z13.string().uuid().parse(id)}/rotate`,
+        `/identity-integrations/${z12.string().uuid().parse(id)}/rotate`,
         identityIntegrationSecretSchema,
         {},
         call
@@ -3044,7 +2790,7 @@ function managementClient(options) {
        */
       kinds: (call) => get(
         "/identity-integrations/kinds",
-        z13.array(identityKindClaimSchema),
+        z12.array(identityKindClaimSchema),
         call
       ),
       /**
@@ -3052,8 +2798,8 @@ function managementClient(options) {
        * and keep attributing tracker records; unlink them on the member to stop that.
        */
       revoke: (id, call) => request(
-        `/identity-integrations/${z13.string().uuid().parse(id)}`,
-        z13.null(),
+        `/identity-integrations/${z12.string().uuid().parse(id)}`,
+        z12.null(),
         void 0,
         "DELETE",
         call
@@ -3068,9 +2814,8 @@ function managementClient(options) {
      * and finds a `detail` quest in that result. `activity` uses `attempts.list`, and its `detail`
      * uses `attempts.get`. `members` uses `members.list`; `page()` ignores its `detail`, while
      * `members.get` reads a member. `rewards` uses `entitlements.list` and `inventory.list`, and
-     * its `detail` uses `entitlements.get`. No resource read lists historical releases or reads
-     * one historical release, so `releases` and its `detail` have no exact replacement;
-     * `quests.list` returns current releases only. `settings` uses `metrics.read`, `quests.list`
+     * its `detail` uses `entitlements.get`. `releases` uses `releases.list`, and its `detail`
+     * uses `releases.get`. `settings` uses `metrics.read`, `quests.list`
      * and `operations.list`; its `detail` has no effect. `audit` uses `audit.list`, except
      * `filter: "access"` uses `audit.access`; its `detail` has no effect. On every page,
      * `detail: "new"` is client-side create mode and triggers no replacement read. Resource lists
@@ -3105,7 +2850,7 @@ function managementClient(options) {
     resources: {
       list: (call) => get(
         "/resources",
-        z13.object({ resources: z13.array(managedResourceSchema) }),
+        z12.object({ resources: z12.array(managedResourceSchema) }),
         call
       ),
       /** @deprecated Use the resource archive/unarchive methods. Removed in 2.0.0. */
@@ -3142,7 +2887,7 @@ function managementClient(options) {
         testMemberCreateSchema.parse(withActionId(input)),
         call
       ),
-      list: (call) => get("/test-members", z13.array(testMemberSchema), call),
+      list: (call) => get("/test-members", z12.array(testMemberSchema), call),
       history: (member, query = {}, call) => get(
         `/test-members/${identifier.parse(member)}/history${queryString(testMemberHistoryQuerySchema.parse(query))}`,
         testMemberHistorySchema,
@@ -3224,26 +2969,26 @@ function managementClient(options) {
       /** Who each member is: up to 100 distinct IDs; unknown IDs come back without accounts. */
       people: (members, call) => get(
         `/people${queryString({ ids: members.join(",") })}`,
-        z13.array(personSchema),
+        z12.array(personSchema),
         call
       ),
       /** Current X and Discord quest account selections; requires read permission. */
       oauthAccounts: (member, call) => get(
         `/members/${encodeURIComponent(member)}/oauth-accounts`,
-        z13.array(managedOAuthAccountSchema),
+        z12.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`,
-        z13.array(managedOAuthAccountSchema),
+        z12.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`,
-        z13.array(managedWalletSchema),
+        z12.array(managedWalletSchema),
         memberWalletUnlinkInputSchema.parse(input),
         call
       ),
@@ -3254,14 +2999,14 @@ function managementClient(options) {
        */
       unlinkIdentity: (member, input, call) => post(
         `/members/${encodeURIComponent(member)}/identities/unlink`,
-        z13.array(managedMemberIdentitySchema),
+        z12.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`,
-        z13.array(managedMemberIdentitySchema),
+        z12.array(managedMemberIdentitySchema),
         memberIdentityChangeInputSchema.parse(input),
         call
       ),
@@ -3271,7 +3016,7 @@ function managementClient(options) {
        */
       setWalletSignIn: (member, input, call) => post(
         `/members/${encodeURIComponent(member)}/wallets/sign-in`,
-        z13.array(managedWalletSchema),
+        z12.array(managedWalletSchema),
         memberWalletSignInInputSchema.parse(input),
         call
       )
@@ -3421,7 +3166,7 @@ function managementClient(options) {
        * Each quest's current release, the most recently published first, archived quests
        * included; requires `read` permission.
        */
-      list: (call) => get("/quests/list", z13.array(publishedReleaseSchema), call),
+      list: (call) => get("/quests/list", z12.array(publishedReleaseSchema), call),
       /** Pending and exhausted asynchronous balance checks. Requires read. */
       automaticScheduling: (query = {}, call) => get(
         `/quests/automatic-scheduling${queryString(automaticSchedulingQuerySchema.parse(query))}`,
@@ -3696,6 +3441,9 @@ var managementResponseSchemas = lazyResponseReaders({
   get managedAttemptPageSchema() {
     return knownResponse(managedAttemptPageSchema);
   },
+  get managedReleasePageSchema() {
+    return knownResponse(managedReleasePageSchema);
+  },
   get managedAttemptSchema() {
     return knownResponse(managedAttemptSchema);
   },
@@ -3972,6 +3720,7 @@ var managementResponses = {
     leaderboardSettlementSummarySchema
   ),
   managedAttemptPageSchema: responseSchema(managedAttemptPageSchema),
+  managedReleasePageSchema: responseSchema(managedReleasePageSchema),
   managedAttemptSchema: responseSchema(managedAttemptSchema),
   managedEntitlementPageSchema: responseSchema(managedEntitlementPageSchema),
   managedEntitlementSchema: responseSchema(managedEntitlementSchema),
@@ -4084,6 +3833,7 @@ export {
   appStorageTablesSchema,
   appStorageValueSchema,
   assetPathSchema,
+  attemptCaptureSchema,
   auditPageSchema,
   auditQuerySchema,
   auditRecordSchema,
@@ -4093,6 +3843,7 @@ export {
   buildPhaseSchema,
   buildSnapshotSchema,
   buildStatusSchema,
+  capturedFactSchema,
   commitSchema,
   compareAppMigrations,
   completionRevocationSchema,
@@ -4162,6 +3913,8 @@ export {
   managedPointHistoryPageSchema,
   managedQuestEnrollmentPageSchema,
   managedQuestEnrollmentSchema,
+  managedReleasePageSchema,
+  managedReleaseQuerySchema,
   managedResourceSchema,
   managedStockItemSchema,
   managedWalletSchema,