@domino-sdk/relay 1.67.0 → 1.69.0

package/dist/server/index.js

@@ -1,7 +1,47 @@
 import {
   attemptCaptureSchema,
   capturedFactSchema
-} from "../chunk-RDUSFUXX.js";
+} from "../chunk-GEVARKEV.js";
+import {
+  PayoutSourceKind,
+  RestoredDeliveryOutcome,
+  RestoredEntitlementOutcome,
+  RestoredReferralOutcome,
+  RevokedDeliveryOutcome,
+  RevokedEntitlementOutcome,
+  RevokedReferralOutcome,
+  WEBHOOK_MAX_BYTES,
+  completionReceiptInputSchema,
+  completionReceiptListSchema,
+  completionReceiptSchema,
+  completionRestorationSchema,
+  completionRestoreSchema,
+  completionRevocationSchema,
+  completionRevocationShortfallSchema,
+  completionRevokeSchema,
+  maxCompletionReceipts,
+  memberCompletionPageSchema,
+  memberCompletionQuerySchema,
+  memberCompletionSchema,
+  revokedCompletionSchema,
+  verifyWebhook,
+  walletLinkedEventDataSchema,
+  webhookControlInputSchema,
+  webhookCreateInputSchema,
+  webhookDeleteInputSchema,
+  webhookDeliveryPageSchema,
+  webhookDeliverySchema,
+  webhookEndpointSchema,
+  webhookEndpointStateSchema,
+  webhookEventSchema,
+  webhookInputSchema,
+  webhookQuerySchema,
+  webhookRotateInputSchema,
+  webhookSecretSchema,
+  webhookStatePageSchema,
+  webhookStateQuerySchema,
+  webhookUpdateSchema
+} from "../chunk-WNEQEDMU.js";
 import {
   DEFAULT_MANAGEMENT_TIMEOUT,
   ManagementError,
@@ -17,17 +57,18 @@ import {
   managementTransport,
   questConfiguration,
   sequenceCursorSchema,
+  solanaRpc,
   walletSignatureValid
-} from "../chunk-JK3XV2CR.js";
+} from "../chunk-BRROI4CH.js";
 import {
   parseImageExtraction,
   parseImageResult
-} from "../chunk-RWR2LOPA.js";
+} from "../chunk-RKTMSTT7.js";
 import {
   sourceDataSchema,
   sourceRoles,
   validateQuestShape
-} from "../chunk-MVQQDPQX.js";
+} from "../chunk-AZDZEQFK.js";
 import {
   APP_KV_LIMIT,
   APP_MIGRATION_FILE_BYTES,
@@ -79,6 +120,7 @@ import {
   appStorageTablesSchema,
   appStorageValueSchema,
   assetPathSchema,
+  boundedBodyText,
   buildArtifactsSchema,
   buildIdentitySchema,
   buildPhaseSchema,
@@ -155,13 +197,13 @@ import {
   starterTemplates,
   starters,
   verifyScheduledRequest
-} from "../chunk-Q5QVAF7R.js";
+} from "../chunk-UGM6DUB2.js";
 import {
   isIntegrationParticipantPath,
   isParticipantRoute,
   participantRoutePattern,
   participantRoutes
-} from "../chunk-U66GUVSG.js";
+} from "../chunk-LZXDYSUH.js";
 import {
   activityTypeSchema,
   activityTypes,
@@ -187,12 +229,12 @@ import {
   publishDeploymentSchema,
   rejectDeploymentSchema,
   submitDeploymentSchema
-} from "../chunk-KUNPCDN6.js";
+} from "../chunk-ODJGTFPY.js";
 import {
   xUserLookupInputSchema,
   xUserSchema,
   xUsernameSchema
-} from "../chunk-X3FMVRMM.js";
+} from "../chunk-DIXYVGXO.js";
 import {
   analyticsBreakdowns,
   analyticsCatalog,
@@ -207,18 +249,15 @@ import {
   analyticsRanges,
   analyticsReadSchema,
   dashboardDefinitionSchema
-} from "../chunk-QYC3CZVD.js";
+} from "../chunk-CZ23KRVK.js";
 import "../chunk-MWMCQLCG.js";
 import {
   withActionId
-} from "../chunk-BQXRCJ3N.js";
-import {
-  base58
-} from "../chunk-UWUS4OOV.js";
+} from "../chunk-5RLIPTL7.js";
 import {
   withQuery
-} from "../chunk-Q6KTTVOI.js";
-import "../chunk-5SBA6X5X.js";
+} from "../chunk-WVK3G2J2.js";
+import "../chunk-SWLW4VN3.js";
 import {
   collectionBeginSchema,
   collectionPreviewSchema,
@@ -233,7 +272,7 @@ import {
   rewardDeliveriesSchema,
   rewardDeliveryQuerySchema,
   rewardDeliverySchema
-} from "../chunk-NRMQVK2W.js";
+} from "../chunk-ME2KUAVJ.js";
 import {
   allocateQuestSchema,
   allocatedQuestSchema,
@@ -244,7 +283,7 @@ import {
   questDraftSchema,
   questPublicationPreviewSchema,
   saveQuestDraftSchema
-} from "../chunk-DSJ46QLB.js";
+} from "../chunk-PO2ZDY27.js";
 import {
   engagementBoundaryPageSchema,
   engagementChangePreviewInputSchema,
@@ -270,7 +309,7 @@ import {
   referralQualificationSchema,
   referralRewardResolutionSchema,
   referralSuspensionSchema
-} from "../chunk-5DZNMLDM.js";
+} from "../chunk-2A3BJ262.js";
 import {
   CompletionSourceKind,
   acceptAnywaySchema,
@@ -281,12 +320,13 @@ import {
   badgeMutationResultSchema,
   badgeMutationSchema,
   badgePropertiesSchema,
+  base58,
+  base58Bytes,
   baseUnitsSchema,
   beginHandoverSchema,
   caip10,
   campaignEnrollmentSchema,
   completionKeySchema,
-  completionSourceSchema,
   configurePickupSchema,
   confirmHandoverSchema,
   contentPerformancePageSchema,
@@ -340,15 +380,18 @@ import {
   managedProfileSchema,
   managedTrackerCreateSchema,
   managementStateQuerySchema,
+  maxSolanaActionReference,
   memberBadgesSchema,
   memberCampaignEnrollmentInputSchema,
   memberCampaignWithdrawalInputSchema,
   memberIdentitySchema,
   memberProgressSchema,
+  nftTrackerCreateSchema,
   organizationDiscordServersSchema,
   pageCursorSchema,
   pageLimit,
   pageQuerySchema,
+  parseSolanaActionMemo,
   pickupAvailabilitySchema,
   pickupCatalogSchema,
   pointLedgerPropertiesSchema,
@@ -359,6 +402,8 @@ import {
   profileModerationSchema,
   profileSettingsInputSchema,
   profileSettingsSchema,
+  programAccountTrackerCreateSchema,
+  programActivityTrackerCreateSchema,
   projectCalendarInputSchema,
   projectCalendarSchema,
   projectGroupKey,
@@ -369,17 +414,26 @@ import {
   questSubmissionSchema,
   removeGroupMemberSchema,
   responseTables,
+  settlementPaymentSchema,
   signInProviderInputSchema,
   signInProviderOptionSchema,
   signInProviderSchema,
   snapshotSchema,
+  solanaActionMemo,
   solanaAddressSchema,
   solanaDevnet,
   solanaMainnet,
+  solanaMemoProgram,
+  solanaSignatureSchema2 as solanaSignatureSchema,
+  solanaTransactionFixtureInputSchema,
+  solanaTransactionSubmissionSchema,
   staffDecisionSchema,
+  stakeTrackerCreateSchema,
+  stationRefusal,
   stockItemSchema,
   streakProgressSchema,
   submitSchema,
+  takesSolanaTransaction,
   telegramChatConnectionSchema,
   telegramChatIdSchema,
   telegramChatsSchema,
@@ -407,12 +461,13 @@ import {
   walletBalanceSchema,
   walletChainSchema,
   walletSignInNetworksSchema,
+  walletTransactionsSchema,
   walletUnlinkInputSchema,
   whereSchemaIssue
-} from "../chunk-P33ZAJMS.js";
+} from "../chunk-CQVKOD3B.js";
 import {
   issueText
-} from "../chunk-FGXLXENM.js";
+} from "../chunk-VNEJH4NT.js";
 
 // src/server/identity-links.ts
 import * as z from "zod";
@@ -701,7 +756,9 @@ var leaderboardSettlementExportSchema = /* @__PURE__ */ (() => z6.object({
           /** EVM smart-contract wallets only: the CAIP-2 network that proved it, the one chain to pay it on. */
           provedOn: evmChainIdSchema.optional()
         })
-      )
+      ),
+      /** How a non-zero share in a non-points pool was paid on chain; absent otherwise. */
+      payment: settlementPaymentSchema.optional()
     })
   )
 }))();
@@ -935,8 +992,8 @@ var accountReference = /* @__PURE__ */ (() => z9.object({
   actionId: identifier,
   kind: z9.enum(["x", "discord"]),
   subject: z9.string().regex(/^[1-9][0-9]{0,19}$/, "Use the numeric user ID")
-}).strict().transform(({ actionId: actionId2, kind, subject }) => ({
-  actionId: actionId2,
+}).strict().transform(({ actionId: actionId3, kind, subject }) => ({
+  actionId: actionId3,
   provider: kind,
   id: subject
 })))();
@@ -1065,135 +1122,9 @@ var testMemberHistorySchema = /* @__PURE__ */ (() => z9.object({
   complete: z9.boolean()
 }))();
 
-// src/server/webhooks.ts
-import * as z10 from "zod";
-var PayoutSourceKind = {
-  Quest: "quest",
-  Leaderboard: "leaderboard",
-  Engagement: "engagement",
-  Manual: "manual"
-};
-var webhookEventSchema = /* @__PURE__ */ (() => z10.object({
-  id: z10.string().uuid(),
-  version: z10.literal(1),
-  type: activityTypeSchema,
-  createdAt: z10.number().int().nonnegative(),
-  organization: z10.string(),
-  project: z10.string(),
-  environment: z10.enum(["test", "live"]),
-  data: z10.record(z10.string(), z10.json())
-}))();
-var webhookControlInputSchema = /* @__PURE__ */ (() => z10.object({ actionId: z10.string().uuid().optional() }).strict())();
-var webhookInputSchema = /* @__PURE__ */ (() => z10.object({
-  url: z10.url().max(2048).refine((value) => {
-    const url2 = new URL(value);
-    return url2.protocol === "https:" && !url2.username && !url2.password && !url2.hash;
-  }, "Use an HTTPS URL without credentials or a fragment"),
-  types: z10.array(activityTypeSchema).min(1).max(100).refine((v) => new Set(v).size === v.length)
-}).strict())();
-var webhookCreateInputSchema = /* @__PURE__ */ (() => webhookInputSchema.extend({ actionId: z10.string().uuid().optional() }).strict())();
-var webhookRotateInputSchema = /* @__PURE__ */ (() => z10.object({ actionId: z10.string().uuid().optional() }).strict())();
-var webhookUpdateSchema = /* @__PURE__ */ (() => webhookInputSchema.partial().extend({ enabled: z10.boolean().optional() }).strict())();
-var webhookEndpointSchema = /* @__PURE__ */ (() => z10.object({
-  ...webhookInputSchema.shape,
-  id: z10.string().uuid(),
-  enabled: z10.boolean(),
-  disabledReason: z10.string().nullable(),
-  consecutiveFailures: z10.number().int().nonnegative(),
-  createdAt: z10.number(),
-  updatedAt: z10.number()
-}))();
-var webhookEndpointStateSchema = /* @__PURE__ */ (() => webhookEndpointSchema.extend({
-  revision: z10.number().int().nonnegative(),
-  deletedAt: z10.number().int().safe().nonnegative().nullable()
-}))();
-var webhookDeleteInputSchema = /* @__PURE__ */ (() => z10.strictObject({
-  actionId: z10.string().uuid().default(() => crypto.randomUUID()),
-  expectedRevision: z10.number().int().nonnegative(),
-  reason: z10.string().trim().min(1).max(500)
-}))();
-var webhookStateQuerySchema = /* @__PURE__ */ (() => z10.strictObject({
-  cursor: pageCursorSchema.optional(),
-  limit: z10.coerce.number().int().min(1).max(100).default(50)
-}))();
-var webhookStatePageSchema = /* @__PURE__ */ (() => z10.object({
-  items: z10.array(webhookEndpointStateSchema),
-  nextCursor: pageCursorSchema.nullable()
-}))();
-var webhookSecretSchema = /* @__PURE__ */ (() => z10.object({
-  endpoint: webhookEndpointSchema,
-  secret: z10.string(),
-  previousValidUntil: z10.number().nullable()
-}))();
-var webhookDeliverySchema = /* @__PURE__ */ (() => z10.object({
-  id: z10.string().uuid(),
-  endpoint: z10.string().uuid(),
-  event: webhookEventSchema,
-  status: z10.enum(["pending", "delivered", "failed", "skipped"]),
-  attempts: z10.number().int().nonnegative(),
-  responseStatus: z10.number().nullable(),
-  lastError: z10.string().nullable(),
-  createdAt: z10.number(),
-  deliveredAt: z10.number().nullable(),
-  replayOf: z10.string().uuid().nullable()
-}))();
-var webhookQuerySchema = /* @__PURE__ */ (() => z10.object({
-  /** A page's `nextCursor`: the deliveries after it, newest first. */
-  cursor: pageCursorSchema.optional(),
-  /** @deprecated Use `cursor`. Removed in 2.0.0. */
-  before: z10.string().uuid().optional(),
-  limit: z10.coerce.number().int().min(1).max(100).default(50)
-}).strict())();
-var webhookDeliveryPageSchema = /* @__PURE__ */ (() => z10.object({
-  items: z10.array(webhookDeliverySchema),
-  nextCursor: pageCursorSchema.nullable().default(null),
-  /** @deprecated Use `nextCursor`, passed back as `cursor`. Removed in 2.0.0. */
-  next: z10.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 timestamp2 = 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(timestamp2) || Math.abs(now / 1e3 - Number(timestamp2)) > tolerance || signatures.length < 1 || signatures.length > 2) {
-    throw new Error("Invalid or expired webhook signature");
-  }
-  const secrets3 = typeof input.secret === "string" ? [input.secret] : input.secret;
-  const message = new TextEncoder().encode(`${timestamp2}.${input.body}`);
-  for (const secret of secrets3) {
-    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 * as z11 from "zod";
-var resourceLifecycleKindSchema = /* @__PURE__ */ (() => z11.enum([
+import * as z10 from "zod";
+var resourceLifecycleKindSchema = /* @__PURE__ */ (() => z10.enum([
   "tracker",
   "referral",
   "leaderboard",
@@ -1203,51 +1134,51 @@ var resourceLifecycleKindSchema = /* @__PURE__ */ (() => z11.enum([
   "image",
   "point-ledger"
 ]))();
-var managedResourceSchema = /* @__PURE__ */ (() => z11.object({
+var managedResourceSchema = /* @__PURE__ */ (() => z10.object({
   kind: resourceLifecycleKindSchema,
   id: identifier,
   key: identifier.nullable(),
-  title: z11.string(),
-  archivedAt: z11.number().int().nonnegative().nullable()
+  title: z10.string(),
+  archivedAt: z10.number().int().nonnegative().nullable()
 }))();
-var resourceLifecycleInputSchema = /* @__PURE__ */ (() => z11.object({
-  actionId: z11.string().uuid(),
+var resourceLifecycleInputSchema = /* @__PURE__ */ (() => z10.object({
+  actionId: z10.string().uuid(),
   kind: resourceLifecycleKindSchema,
   resource: identifier,
-  archived: z11.boolean(),
+  archived: z10.boolean(),
   reason: lifecycleReasonSchema,
-  expectedArchivedAt: z11.number().int().nonnegative().nullable().optional()
+  expectedArchivedAt: z10.number().int().nonnegative().nullable().optional()
 }).strict())();
-var resourceLifecycleResultSchema = /* @__PURE__ */ (() => z11.object({
+var resourceLifecycleResultSchema = /* @__PURE__ */ (() => z10.object({
   resource: managedResourceSchema,
-  changed: z11.boolean()
+  changed: z10.boolean()
 }))();
 var managedOfferSchema = /* @__PURE__ */ (() => managedResourceSchema.extend({
-  kind: z11.literal("offer")
+  kind: z10.literal("offer")
 }))();
 var managedTieredRewardSchema = /* @__PURE__ */ (() => managedResourceSchema.extend({
-  kind: z11.literal("tiered-reward")
+  kind: z10.literal("tiered-reward")
 }))();
-var managedResourceListSchema = /* @__PURE__ */ (() => z11.object({
-  resources: z11.array(managedResourceSchema),
-  offers: z11.array(managedOfferSchema).default([]),
+var managedResourceListSchema = /* @__PURE__ */ (() => z10.object({
+  resources: z10.array(managedResourceSchema),
+  offers: z10.array(managedOfferSchema).default([]),
   /** Absent from a Relay older than tiered reward archiving; treat it as none. */
-  tieredRewards: z11.array(managedTieredRewardSchema).optional()
+  tieredRewards: z10.array(managedTieredRewardSchema).optional()
 }))();
-var offerLifecycleResultSchema = /* @__PURE__ */ (() => z11.object({
+var offerLifecycleResultSchema = /* @__PURE__ */ (() => z10.object({
   resource: managedOfferSchema,
-  changed: z11.boolean()
+  changed: z10.boolean()
 }))();
-var offerLifecycleInputSchema = /* @__PURE__ */ (() => z11.strictObject({
-  actionId: z11.string().uuid(),
+var offerLifecycleInputSchema = /* @__PURE__ */ (() => z10.strictObject({
+  actionId: z10.string().uuid(),
   offer: identifier,
-  archived: z11.boolean(),
-  reason: z11.string().trim().min(1).max(500),
-  expectedArchivedAt: z11.number().int().nonnegative().nullable().optional()
+  archived: z10.boolean(),
+  reason: z10.string().trim().min(1).max(500),
+  expectedArchivedAt: z10.number().int().nonnegative().nullable().optional()
 }))();
-var tieredRewardLifecycleResultSchema = /* @__PURE__ */ (() => z11.object({
+var tieredRewardLifecycleResultSchema = /* @__PURE__ */ (() => z10.object({
   resource: managedTieredRewardSchema,
-  changed: z11.boolean()
+  changed: z10.boolean()
 }))();
 var tieredRewardLifecycleInputSchema = /* @__PURE__ */ (() => offerLifecycleInputSchema.omit({ offer: true }).extend({ reward: identifier }))();
 var resourceLifecyclePaths = {
@@ -1267,46 +1198,46 @@ var resourceArchiveInputSchema = /* @__PURE__ */ (() => resourceLifecycleInputSc
 }))();
 
 // src/server/dashboards.ts
-import * as z12 from "zod";
-var dashboardListQuerySchema = /* @__PURE__ */ (() => z12.strictObject({
-  includeArchived: z12.union([z12.boolean(), z12.enum(["true", "false"])]).transform((value) => value === true || value === "true").optional()
+import * as z11 from "zod";
+var dashboardListQuerySchema = /* @__PURE__ */ (() => z11.strictObject({
+  includeArchived: z11.union([z11.boolean(), z11.enum(["true", "false"])]).transform((value) => value === true || value === "true").optional()
 }))();
 var summaryFields = /* @__PURE__ */ (() => ({
   key: identifier,
-  title: z12.string(),
-  description: z12.string().nullable(),
+  title: z11.string(),
+  description: z11.string().nullable(),
   /** Lists order by it, dashboards without one last, then by title. */
-  position: z12.number().int().nullable(),
-  archivedAt: z12.number().int().nonnegative().nullable(),
+  position: z11.number().int().nullable(),
+  archivedAt: z11.number().int().nonnegative().nullable(),
   /** When the current version was published. */
-  updatedAt: z12.number().int().nonnegative()
+  updatedAt: z11.number().int().nonnegative()
 }))();
-var dashboardSummarySchema = /* @__PURE__ */ (() => z12.object(summaryFields))();
-var dashboardListSchema = /* @__PURE__ */ (() => z12.array(dashboardSummarySchema))();
-var dashboardLifecycleInputSchema = /* @__PURE__ */ (() => z12.strictObject({
-  actionId: z12.string().uuid(),
+var dashboardSummarySchema = /* @__PURE__ */ (() => z11.object(summaryFields))();
+var dashboardListSchema = /* @__PURE__ */ (() => z11.array(dashboardSummarySchema))();
+var dashboardLifecycleInputSchema = /* @__PURE__ */ (() => z11.strictObject({
+  actionId: z11.string().uuid(),
   dashboard: identifier,
-  archived: z12.boolean(),
-  reason: z12.string().trim().min(1).max(500),
-  expectedArchivedAt: z12.number().int().nonnegative().nullable().optional()
+  archived: z11.boolean(),
+  reason: z11.string().trim().min(1).max(500),
+  expectedArchivedAt: z11.number().int().nonnegative().nullable().optional()
 }))();
-var dashboardLifecycleResultSchema = /* @__PURE__ */ (() => z12.object({
+var dashboardLifecycleResultSchema = /* @__PURE__ */ (() => z11.object({
   dashboard: dashboardSummarySchema,
-  changed: z12.boolean()
+  changed: z11.boolean()
 }))();
-var dashboardReadQuerySchema = /* @__PURE__ */ (() => z12.strictObject({
+var dashboardReadQuerySchema = /* @__PURE__ */ (() => z11.strictObject({
   key: identifier,
-  range: z12.enum(analyticsRanges).optional()
+  range: z11.enum(analyticsRanges).optional()
 }))();
-var dashboardReadSchema = /* @__PURE__ */ (() => z12.object({
+var dashboardReadSchema = /* @__PURE__ */ (() => z11.object({
   ...summaryFields,
   definition: dashboardDefinitionSchema,
-  range: z12.enum(analyticsRanges),
-  panels: z12.array(
-    z12.object({
+  range: z11.enum(analyticsRanges),
+  panels: z11.array(
+    z11.object({
       key: identifier,
       result: analyticsMetricResultSchema.optional(),
-      error: z12.object({ code: z12.string(), message: z12.string() }).optional()
+      error: z11.object({ code: z11.string(), message: z11.string() }).optional()
     })
   )
 }))();
@@ -1315,33 +1246,33 @@ var dashboardReadSchema = /* @__PURE__ */ (() => z12.object({
 import * as z62 from "zod";
 
 // src/server/client/http.ts
-import * as z15 from "zod";
+import * as z14 from "zod";
 
 // src/server/operations.ts
-import * as z13 from "zod";
-var operationSchema = /* @__PURE__ */ (() => z13.object({
-  target: z13.string(),
-  paused: z13.boolean(),
-  revision: z13.number().int(),
-  reason: z13.string(),
-  actor: z13.string().nullable(),
-  changedAt: z13.number()
-}))();
-var operationInputSchema = /* @__PURE__ */ (() => z13.object({
-  target: z13.union([
-    z13.literal("redemptions"),
-    z13.string().regex(/^quest:[\w-]+$/)
+import * as z12 from "zod";
+var operationSchema = /* @__PURE__ */ (() => z12.object({
+  target: z12.string(),
+  paused: z12.boolean(),
+  revision: z12.number().int(),
+  reason: z12.string(),
+  actor: z12.string().nullable(),
+  changedAt: z12.number()
+}))();
+var operationInputSchema = /* @__PURE__ */ (() => 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())();
 
 // src/server/revision-fence.ts
-import * as z14 from "zod";
+import * as z13 from "zod";
 function expectedRevision(schema) {
-  return z14.preprocess((body, context) => {
+  return z13.preprocess((body, context) => {
     if (body === null || typeof body !== "object" || Array.isArray(body) || !("expectedRevision" in body)) {
       return body;
     }
@@ -1352,7 +1283,7 @@ function expectedRevision(schema) {
         message: "expectedRevision and revision name different revisions",
         path: ["expectedRevision"]
       });
-      return z14.NEVER;
+      return z13.NEVER;
     }
     return { ...rest, revision: expectedRevision2 };
   }, schema);
@@ -1384,7 +1315,7 @@ function managementHttp(options) {
   }
   return { request, get, post, create, raw, exchange };
 }
-var ok = /* @__PURE__ */ (() => z15.object({ ok: z15.literal(true) }))();
+var ok = /* @__PURE__ */ (() => z14.object({ ok: z14.literal(true) }))();
 function createPointLedger({ create }) {
   function run(input, call) {
     return create(
@@ -1397,12 +1328,12 @@ function createPointLedger({ create }) {
   }
   return run;
 }
-function pathFirst(key, send) {
+function pathFirst(key2, send) {
   function run(first, second, call) {
     if (typeof first === "string") {
       return send(first, second, call);
     }
-    const { [key]: id, ...input } = first;
+    const { [key2]: id, ...input } = first;
     return send(
       id,
       input,
@@ -1459,10 +1390,10 @@ var operationVerb = ({ post }, target, paused, input, call) => {
 };
 
 // src/server/client/badges.ts
-import * as z16 from "zod";
+import * as z15 from "zod";
 function badges({ create, get, post }) {
   return {
-    list: (call) => get("/badges", z16.array(managedBadgeSchema), call),
+    list: (call) => get("/badges", z15.array(managedBadgeSchema), call),
     create: (input, call) => create("/badges", managedBadgeSchema, createBadgeSchema, input, call),
     update: (badge, input, call) => {
       const body = badgePropertiesSchema.extend(badgeMutationSchema.shape).parse(withActionId(input));
@@ -1524,7 +1455,7 @@ function content({ get }) {
 var contentApi = (http) => content(http);
 
 // src/server/client/deployments.ts
-import * as z17 from "zod";
+import * as z16 from "zod";
 function deployments({ get, post }) {
   function publishDeployment(target, call) {
     const id = typeof target === "string" ? identifier.parse(target) : publishDeploymentSchema.parse(target).id;
@@ -1570,7 +1501,7 @@ function deployments({ get, post }) {
      *
      * @deprecated Use `history`, which pages by `cursor` and `nextCursor`. Removed in 2.0.0.
      */
-    list: (call) => get("/deployments", z17.array(deploymentRecordSchema), call),
+    list: (call) => get("/deployments", z16.array(deploymentRecordSchema), call),
     /**
      * The project environment's deployments, newest first, one page at a time, with the two
      * newest published deployments beside every page. Pass a page's `nextCursor` back as
@@ -1609,7 +1540,7 @@ function deployments({ get, post }) {
 var deploymentsApi = (http) => deployments(http);
 
 // src/server/client/engagement.ts
-import * as z18 from "zod";
+import * as z17 from "zod";
 function engagement(http) {
   const { get, post } = http;
   return {
@@ -1655,7 +1586,7 @@ function engagement(http) {
       engagementPublishSchema.parse(withActionId(input)),
       call
     ),
-    list: (call) => get("/engagement", z18.array(engagementRuleSchema), call),
+    list: (call) => get("/engagement", z17.array(engagementRuleSchema), call),
     page: (input, call) => get(
       "/engagement/history" + queryString(engagementPageQuerySchema.parse(input)),
       engagementPageSchema,
@@ -1735,6 +1666,152 @@ var groupsApi = (http) => groups(http);
 
 // src/server/client/leaderboards.ts
 import * as z19 from "zod";
+
+// src/server/settlement-payouts.ts
+import * as z18 from "zod";
+var timestamp2 = /* @__PURE__ */ (() => z18.number().int().safe().nonnegative())();
+var index = /* @__PURE__ */ (() => z18.number().int().safe().nonnegative())();
+var actionId = /* @__PURE__ */ (() => z18.string().uuid().default(() => crypto.randomUUID()))();
+var signatureSchema = /* @__PURE__ */ (() => z18.string().min(64).max(88).regex(/^[1-9A-HJ-NP-Za-km-z]+$/))();
+var solanaPayoutMintSchema = /* @__PURE__ */ (() => z18.union([
+  z18.literal("SOL"),
+  solanaAddressSchema
+]))();
+var solanaPayoutSquadsSchema = /* @__PURE__ */ (() => z18.strictObject({
+  /** The multisig account (not its vault). */
+  multisig: solanaAddressSchema,
+  /** The vault the payout pays from; Squads' default vault is 0. */
+  vaultIndex: z18.number().int().min(0).max(255).default(0),
+  /** The member that signs each batch's proposal transaction and pays its fees and rent. */
+  proposer: solanaAddressSchema
+}))();
+var solanaPayoutInputSchema = /* @__PURE__ */ (() => z18.strictObject({
+  actionId,
+  /** The cluster, by CAIP-2 ID. */
+  network: z18.enum([solanaMainnet, solanaDevnet]),
+  mint: solanaPayoutMintSchema,
+  /** The wallet that signs every batch, pays its fees and rent, and holds the tokens. */
+  payer: solanaAddressSchema.optional(),
+  /** The Squads multisig whose vault pays, instead of a wallet. */
+  squads: solanaPayoutSquadsSchema.optional()
+}).refine((input) => input.payer === void 0 !== !input.squads, {
+  message: "Pass payer to pay from a wallet, or squads to pay from a multisig",
+  path: ["payer"]
+}))();
+var solanaPayoutConfirmationSchema = /* @__PURE__ */ (() => z18.strictObject({
+  actionId,
+  /** Signatures of transactions the team sent, which Relay reads first. */
+  signatures: z18.array(signatureSchema).max(100).default([])
+}))();
+var batchSchema = /* @__PURE__ */ (() => z18.object({
+  index,
+  /** The SPL Memo text the batch carries, which Relay finds it by. */
+  memo: z18.string(),
+  /**
+   * The unsigned v0 transaction, base64. Its fee payer and only signer signs it: the payer, or for
+   * a Squads payout the proposer.
+   */
+  transaction: z18.string(),
+  status: z18.string(),
+  /** The transaction Relay found for the batch; null while pending or expired. */
+  signature: z18.string().nullable(),
+  /** Base units the batch pays. */
+  amount: baseUnitsSchema,
+  /** Lamports for the token accounts the batch creates. */
+  rent: baseUnitsSchema,
+  /** The Squads vault transaction's index in its multisig; null for a wallet payout. */
+  transactionIndex: z18.string().nullable().default(null),
+  /** The address of the batch's Squads proposal account; null for a wallet payout. */
+  proposal: z18.string().nullable().default(null),
+  payments: z18.array(
+    z18.object({
+      member: identifier,
+      /** The member's proven Solana wallet the share goes to. */
+      wallet: z18.string(),
+      amount: baseUnitsSchema
+    })
+  )
+}))();
+var solanaPayoutSchema = /* @__PURE__ */ (() => z18.object({
+  id: identifier,
+  settlement: identifier,
+  network: z18.string(),
+  /** `"SOL"` or the mint address. */
+  mint: z18.string(),
+  /** The mint's token program; null for SOL. */
+  tokenProgram: z18.string().nullable(),
+  /** What pays: `wallet`, or `squads`, whose vault is `payer`. */
+  source: z18.string().default("wallet"),
+  /** The account that holds the tokens and pays: the wallet, or the multisig's vault. */
+  payer: z18.string(),
+  /** The Squads multisig, for a payout from its vault; null for a wallet payout. */
+  squads: z18.object({
+    multisig: z18.string(),
+    vaultIndex: z18.number().int().min(0).max(255),
+    proposer: z18.string(),
+    /**
+     * Lamports the proposer puts into each batch's vault transaction and proposal accounts,
+     * together. Squads returns them to the multisig's rent collector when the accounts close.
+     */
+    accountRent: baseUnitsSchema
+  }).nullable().default(null),
+  decimals: index,
+  /** Base units the batches pay together. */
+  total: baseUnitsSchema,
+  /** Lamports the payer spends on token accounts the batches create, at the build's rent. */
+  rent: baseUnitsSchema,
+  /**
+   * Lamports spent on signature fees, one signature per batch: by the payer, or by the proposer of
+   * a Squads payout.
+   */
+  fees: baseUnitsSchema,
+  /**
+   * The last block height at which the batches can land; after it, they expire. For a Squads
+   * payout, the height by which the proposals must be created.
+   */
+  lastValidBlockHeight: z18.string(),
+  createdAt: timestamp2,
+  createdBy: z18.string(),
+  batches: z18.array(batchSchema),
+  /** Winners with a non-zero, unpaid share this payout leaves out. */
+  skipped: z18.array(
+    z18.object({
+      member: identifier,
+      share: baseUnitsSchema,
+      reason: z18.string()
+    })
+  )
+}))();
+var solanaPayoutQuerySchema = /* @__PURE__ */ (() => z18.strictObject({
+  cursor: pageCursorSchema.optional(),
+  limit: z18.coerce.number().int().min(1).max(25).default(10)
+}))();
+var solanaPayoutPageSchema = /* @__PURE__ */ (() => z18.object({
+  items: z18.array(solanaPayoutSchema),
+  nextCursor: pageCursorSchema.nullable()
+}))();
+var solanaPayoutConfirmationResultSchema = /* @__PURE__ */ (() => z18.object({
+  settlement: identifier,
+  batches: z18.array(
+    z18.object({
+      payout: identifier,
+      index,
+      status: z18.string(),
+      signature: z18.string().nullable()
+    })
+  ),
+  paid: index,
+  pending: index,
+  unpaid: index
+}))();
+function squadsProposalUrl(payout, batch) {
+  if (payout.source !== "squads" || !batch.proposal) {
+    return null;
+  }
+  return payout.network === solanaDevnet ? `https://explorer.solana.com/address/${batch.proposal}?cluster=devnet` : `https://app.squads.so/squads/${payout.payer}/transactions`;
+}
+
+// src/server/client/leaderboards.ts
 function leaderboards(http) {
   const { get, post } = http;
   return {
@@ -1825,6 +1902,41 @@ function leaderboards(http) {
       leaderboardSettlementExportSchema,
       call
     ),
+    /**
+     * Builds unsigned Solana transfer batches that pay an approved settlement's unpaid token pool
+     * shares from `payer`, to each winner's most recently linked proven Solana wallet. The team
+     * signs and sends them; then call `confirmSolanaPayout`. Requires review permission.
+     *
+     * @experimental A minor release can change this method and its result.
+     */
+    buildSolanaPayout: (settlement, input, call) => post(
+      `/leaderboard-settlements/${identifier.parse(settlement)}/solana-payouts`,
+      solanaPayoutSchema,
+      solanaPayoutInputSchema.parse(withActionId(input)),
+      call
+    ),
+    /**
+     * Reads the outcome of a settlement's unsettled payout batches on chain and marks the shares
+     * they paid. Safe to repeat. Requires review permission.
+     *
+     * @experimental A minor release can change this method and its result.
+     */
+    confirmSolanaPayout: (settlement, input = {}, call) => post(
+      `/leaderboard-settlements/${identifier.parse(settlement)}/solana-payouts/confirm`,
+      solanaPayoutConfirmationResultSchema,
+      solanaPayoutConfirmationSchema.parse(withActionId(input)),
+      call
+    ),
+    /**
+     * A settlement's Solana payouts with their batches, newest first. Requires read permission.
+     *
+     * @experimental A minor release can change this method and its result.
+     */
+    solanaPayouts: (settlement, query = {}, call) => get(
+      `/leaderboard-settlements/${identifier.parse(settlement)}/solana-payouts${queryString(solanaPayoutQuerySchema.parse(query))}`,
+      solanaPayoutPageSchema,
+      call
+    ),
     rejectSettlement: (settlement, input, call) => post(
       `/leaderboard-settlements/${identifier.parse(settlement)}/reject`,
       leaderboardSettlementReviewSchema,
@@ -2018,12 +2130,12 @@ function referrals(http) {
     /** @deprecated Use `pause` or `resume`, `qualify` or `resolveReward`. Removed in 2.0.0. */
     control: (input, call) => {
       const parsed = referralControlSchema.parse(withActionId(input));
-      const { actionId: actionId2, reason } = parsed;
+      const { actionId: actionId3, reason } = parsed;
       if (parsed.kind === "suspend") {
         return post(
           `/referral-relationships/${parsed.member}/suspend`,
           ok,
-          { actionId: actionId2, suspended: parsed.suspended, reason },
+          { actionId: actionId3, suspended: parsed.suspended, reason },
           call
         );
       }
@@ -2031,14 +2143,14 @@ function referrals(http) {
         return post(
           `/referral-programs/${parsed.program}/members/${parsed.member}/qualify`,
           ok,
-          { actionId: actionId2, qualified: parsed.qualified, reason },
+          { actionId: actionId3, qualified: parsed.qualified, reason },
           call
         );
       }
       return post(
         `/referral-rewards/${parsed.entitlement}/resolve`,
         ok,
-        { actionId: actionId2, reason },
+        { actionId: actionId3, reason },
         call
       );
     }
@@ -2048,23 +2160,38 @@ var referralsApi = (http) => referrals(http);
 
 // src/server/client/trackers.ts
 import * as z23 from "zod";
+var sampledCreateSchemas = {
+  "wallet-program-activity": programActivityTrackerCreateSchema,
+  "wallet-nfts": nftTrackerCreateSchema,
+  "wallet-stake": stakeTrackerCreateSchema,
+  "wallet-program-accounts": programAccountTrackerCreateSchema
+};
 function trackers(http) {
   const { create, get, post } = http;
   return {
     /**
      * Creates a tracker as data in test, with the same validation as `defineTracker`; requires
      * `publish`. Name its source with `source`, such as `{ kind: "discord-messages", text: true }`,
-     * or an X search with `query` alone. An X tracker's first collection searches from
-     * `window.start`. Live refuses it with `promotion-required`: the tracker reaches live through
-     * a promotion. A key a deployment already publishes is refused with `tracker-owned-by-code`.
-     */
-    create: (input, call) => create(
-      "/trackers",
-      trackerStatusSchema,
-      managedTrackerCreateSchema,
-      input,
-      call
-    ),
+     * or an X search with `query` alone, a `wallet.programActivity()` source with
+     * `{ kind: "wallet-program-activity", chain, program, instruction, mint, minAmount, anySigner }`,
+     * a `wallet.nfts()` source with `{ kind: "wallet-nfts", collection }`, a `wallet.stake()`
+     * source with `{ kind: "wallet-stake", chain, voteAccount }`, or a `wallet.programAccounts()`
+     * source with `{ kind: "wallet-program-accounts", chain, program, account, seeds, field, idl }`.
+     * An X tracker's first collection searches from `window.start`. Live refuses it with
+     * `promotion-required`: the tracker reaches live through a promotion. A key a deployment
+     * already publishes is refused with `tracker-owned-by-code`.
+     */
+    create: (input, call) => {
+      const kind = input.source?.kind;
+      const schema = kind !== void 0 && Object.hasOwn(sampledCreateSchemas, kind) ? sampledCreateSchemas[kind] : managedTrackerCreateSchema;
+      return create(
+        "/trackers",
+        trackerStatusSchema,
+        schema,
+        input,
+        call
+      );
+    },
     /**
      * Changes a tracker created with `create`, in test; fields left out keep their value. `source`
      * replaces the source's settings but never its kind (`validation-failed`). A new query or
@@ -2426,7 +2553,13 @@ var billingSubscriptionSchema = /* @__PURE__ */ (() => subscriptionSchema(billin
 var projectBillingSchema = /* @__PURE__ */ (() => z25.object({
   available: z25.boolean(),
   reason: z25.enum(["admin-required", "staff-only", "not-configured"]).nullable(),
-  subscription: billingSubscriptionSchema.nullable()
+  subscription: billingSubscriptionSchema.nullable(),
+  offer: z25.object({
+    id: z25.string(),
+    plan: billingPlanSchema,
+    interval: z25.enum(billingIntervals),
+    freeMonths: z25.number().int()
+  }).nullable().optional()
 }))();
 var projectPlanSchema = /* @__PURE__ */ (() => z25.object({
   plan: z25.string(),
@@ -2681,9 +2814,9 @@ function dashboards({ get, post }) {
      * other panels still have results. Requires `read` permission.
      */
     read: (query, call) => {
-      const { key, ...rest } = dashboardReadQuerySchema.parse(query);
+      const { key: key2, ...rest } = dashboardReadQuerySchema.parse(query);
       return get(
-        `/dashboards/${key}${queryString(rest)}`,
+        `/dashboards/${key2}${queryString(rest)}`,
         dashboardReadSchema,
         call
       );
@@ -2693,15 +2826,15 @@ function dashboards({ get, post }) {
      * `includeArchived`, stays readable, and stays archived when its code deploys again. Live
      * gets the change through a promotion. Requires `publish` permission.
      */
-    archive: (key, input, call) => post(
-      `/dashboards/${identifier.parse(key)}/archive`,
+    archive: (key2, input, call) => post(
+      `/dashboards/${identifier.parse(key2)}/archive`,
       dashboardLifecycleResultSchema,
       resourceArchiveInputSchema.parse(withActionId(input)),
       call
     ),
     /** Restore an archived dashboard in test. Requires `publish` permission. */
-    unarchive: (key, input, call) => post(
-      `/dashboards/${identifier.parse(key)}/unarchive`,
+    unarchive: (key2, input, call) => post(
+      `/dashboards/${identifier.parse(key2)}/unarchive`,
       dashboardLifecycleResultSchema,
       resourceArchiveInputSchema.parse(withActionId(input)),
       call
@@ -2898,6 +3031,35 @@ function attempts({ get, post }) {
       submitSchema.parse(withActionId(input)),
       call
     ),
+    /**
+     * Completes a quest from a Solana transaction a member signed: Relay reads the transaction at
+     * `finalized` on `chain` (mainnet by default) and runs a normal attempt for the member whose
+     * linked wallet signed it, which the quest's evaluator decides, with the transaction in
+     * `ctx.action`. Requires `ingest` permission. The transaction must have succeeded and carry the
+     * quest's memo (`solanaActionMemo({ quest, reference? })` in an SPL Memo instruction); only a
+     * member-submitted `manual()` quest without input accepts one. Resolves with the queued attempt,
+     * or with the first attempt when the signature was already submitted.
+     *
+     * Refusals: 409 `transaction-not-final` (with `Retry-After`) until the transaction is
+     * finalized, about 13 seconds after it lands, so retry it; 422 `transaction-failed`; 422
+     * `transaction-not-for-quest` when it carries no memo for this quest; 404 `wallet-not-linked`
+     * when no signer is a member's linked wallet; 409 `account-ambiguous` when signers belong to
+     * different members; 422 `quest-not-transaction-completable` for any other kind of quest; on a
+     * quest with check-in stations, 422 `station-unknown` when the memo names none of them and 409
+     * `station-closed` when the station was closed at the transaction's block time, or 409
+     * `station-revoked` when an operator revoked it (`quests.stations.revoke`), whenever it was
+     * signed; 502
+     * `unavailable` when the Solana read failed, so retry it; 429 `rate-limited` past the project
+     * environment's budget of 1,500 reads per 10 minutes.
+     *
+     * @experimental A minor release can change this method and its result.
+     */
+    submitSolanaTransaction: (input, call) => post(
+      "/attempts/solana-transaction",
+      attemptSchema,
+      solanaTransactionSubmissionSchema.parse(input),
+      call
+    ),
     /**
      * Accepts or rejects an attempt waiting for review, at the `generation` the reviewer saw,
      * with a reason; requires `review` permission.
@@ -3025,181 +3187,22 @@ function passes({ post }) {
 }
 var passesApi = (http) => passes(http);
 
-// src/server/completions.ts
-import * as z31 from "zod";
-var completionRevokeSchema = /* @__PURE__ */ (() => z31.object({
-  actionId: identifier,
-  reason: z31.string().trim().min(1).max(500),
-  freeOccurrence: z31.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 = /* @__PURE__ */ (() => z31.string().min(1).max(64))();
-var deliveryOutcomeSchema = /* @__PURE__ */ (() => z31.string().min(1).max(64))();
-var referralOutcomeSchema = /* @__PURE__ */ (() => z31.string().min(1).max(64))();
-var completionRevocationSchema = /* @__PURE__ */ (() => z31.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: z31.number(),
-  occurrenceFreed: z31.boolean(),
-  badges: z31.array(z31.object({ badge: identifier, stillAwarded: z31.boolean() })).optional(),
-  groups: z31.array(z31.object({ group: identifier, stillMember: z31.boolean() })).optional(),
-  points: z31.array(
-    z31.object({
-      entry: identifier,
-      balance: identifier,
-      reversal: identifier.nullable(),
-      reversed: z31.number().int(),
-      unreversed: z31.number().int()
-    })
-  ),
-  entitlements: z31.array(
-    z31.object({
-      entitlement: identifier,
-      reward: identifier,
-      outcome: entitlementOutcomeSchema,
-      status: z31.string()
-    })
-  ),
-  deliveries: z31.array(
-    z31.object({
-      delivery: z31.string(),
-      roleId: z31.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: z31.boolean()
-    })
-  ),
-  referrals: z31.array(
-    z31.object({
-      program: identifier,
-      outcome: referralOutcomeSchema
-    })
-  ),
-  streakMilestone: z31.boolean(),
-  budgets: z31.array(
-    z31.object({ budget: identifier, released: z31.number().int().nonnegative() })
-  ).optional()
-}))();
-var completionRestoreSchema = /* @__PURE__ */ (() => z31.object({
-  actionId: identifier,
-  reason: z31.string().trim().min(1).max(500)
-}).strict())();
-var RestoredEntitlementOutcome = {
-  /** The revocation voided it, and it is available again. */
-  Restored: "restored",
-  /** The revocation lowered or flagged it: its earned tier is the completion's again. */
-  Raised: "raised",
-  /** It changed since the revocation (an operator restored, voided or corrected it), so it stays. */
-  Kept: "kept"
-};
-var RestoredDeliveryOutcome = {
-  /** The grant had not reached Discord, and it is queued again. */
-  Requeued: "requeued",
-  /** The grant counts again for reconciliation, and its delivery status stays. */
-  Kept: "kept"
-};
-var RestoredReferralOutcome = {
-  /** The member qualifies on this completion again. */
-  Qualified: "qualified",
-  /** The program is disabled or gone, or the referral is suspended, so nothing changed. */
-  Kept: "kept"
-};
-var openOutcome = /* @__PURE__ */ (() => z31.string().min(1).max(64))();
-var completionRestorationSchema = /* @__PURE__ */ (() => z31.object({
-  completion: identifier,
-  /** The quest ID, or the board ID when `source.kind` is `leaderboard`. */
-  quest: identifier,
-  member: identifier,
-  source: completionSourceSchema.optional(),
-  restoredAt: z31.number(),
-  points: z31.array(
-    z31.object({
-      entry: identifier,
-      balance: identifier,
-      reversal: identifier,
-      amount: z31.number().int()
-    })
-  ),
-  badges: z31.array(z31.object({ badge: identifier })),
-  groups: z31.array(z31.object({ group: identifier, added: z31.boolean() })),
-  entitlements: z31.array(
-    z31.object({
-      entitlement: identifier,
-      reward: identifier,
-      outcome: openOutcome,
-      status: z31.string()
-    })
-  ),
-  deliveries: z31.array(
-    z31.object({
-      delivery: z31.string(),
-      roleId: z31.string(),
-      outcome: openOutcome
-    })
-  ),
-  referrals: z31.array(
-    z31.object({
-      program: identifier,
-      outcome: openOutcome
-    })
-  ),
-  streakMilestone: z31.boolean(),
-  budgets: z31.array(
-    z31.object({ budget: identifier, charged: z31.number().int().nonnegative() })
-  ).optional()
-}))();
-var completionRevocationShortfallSchema = /* @__PURE__ */ (() => z31.object({
-  completion: identifier,
-  quest: identifier,
-  revokedAt: z31.number().int().nonnegative().safe(),
-  unreversedPoints: z31.record(identifier, z31.number().int().positive().safe())
-}))();
-var revokedCompletionSchema = /* @__PURE__ */ (() => z31.object({
-  completion: identifier,
-  quest: identifier,
-  /** The completion key: its occurrence, such as `once` or a day. */
-  key: z31.string(),
-  revokedAt: z31.number().int().nonnegative().safe(),
-  /** Why it was revoked, and what the revoke did, which a restore re-applies. */
-  reason: z31.string().optional(),
-  revocation: completionRevocationSchema.optional()
-}))();
-
 // src/server/client/completions.ts
-function completions({ post }) {
+function completions({ get, post }) {
   return {
+    /**
+     * One page of a member's completions that count (not revoked), of every quest and leaderboard
+     * prize or of one `quest`, ordered by quest ID, then completion ID; requires `read`
+     * permission. Pass a page's `nextCursor` back as `cursor` for the next page. Fails with 404
+     * `not-found` for a member who has not joined the project.
+     *
+     * @experimental A minor release can change the completions list.
+     */
+    list: (query, call) => get(
+      `/completions${queryString(memberCompletionQuerySchema.parse(query))}`,
+      memberCompletionPageSchema,
+      call
+    ),
     /**
      * 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
@@ -3239,6 +3242,35 @@ function completions({ post }) {
         completionRestoreSchema.parse(withActionId(body)),
         call
       )
+    ),
+    /**
+     * Records what your server did off-platform for a completion, such as minting a badge or
+     * sending a payout, by the transaction that did it; requires `points` permission. A completion
+     * holds one receipt per `key`: the same key with the same values answers the stored receipt, so
+     * a retry is safe, and other values fail with 409 `receipt-conflict`. A completion holds at most
+     * 20 receipts (409 `receipt-limit`). Relay does not read the chain. Console shows the receipt
+     * on the completion, with an explorer link on Solana mainnet and devnet, and the audit history
+     * records it. A revoked completion keeps its receipts, and takes new ones. Erasing the member
+     * deletes them.
+     *
+     * @experimental A minor release can change completion receipts.
+     */
+    recordReceipt: (completion, body, call) => post(
+      `/completions/${identifier.parse(completion)}/receipts`,
+      completionReceiptSchema,
+      completionReceiptInputSchema.parse(withActionId(body)),
+      call
+    ),
+    /**
+     * The completion's receipts, oldest first; requires `read` permission. Fails with 404
+     * `not-found` for a completion this project and environment don't have.
+     *
+     * @experimental A minor release can change completion receipts.
+     */
+    receipts: (completion, call) => get(
+      `/completions/${identifier.parse(completion)}/receipts`,
+      completionReceiptListSchema,
+      call
     )
   };
 }
@@ -3278,20 +3310,20 @@ function handover({ post }) {
 var handoverApi = (http) => handover(http);
 
 // src/server/entitlements.ts
-import * as z32 from "zod";
-var managedEntitlementQuerySchema = /* @__PURE__ */ (() => z32.strictObject({
-  q: z32.string().max(200).optional(),
-  status: z32.string().min(1).max(50).optional(),
+import * as z31 from "zod";
+var managedEntitlementQuerySchema = /* @__PURE__ */ (() => z31.strictObject({
+  q: z31.string().max(200).optional(),
+  status: z31.string().min(1).max(50).optional(),
   limit: pageLimit,
   cursor: pageCursorSchema.optional()
 }))();
-var managedEntitlementPageSchema = /* @__PURE__ */ (() => z32.object({
-  items: z32.array(entitlementSchema),
-  people: z32.array(personSchema),
-  total: z32.number().int().nonnegative(),
-  nextCursor: z32.string().nullable()
+var managedEntitlementPageSchema = /* @__PURE__ */ (() => z31.object({
+  items: z31.array(entitlementSchema),
+  people: z31.array(personSchema),
+  total: z31.number().int().nonnegative(),
+  nextCursor: z31.string().nullable()
 }))();
-var managedEntitlementSchema = /* @__PURE__ */ (() => z32.object({
+var managedEntitlementSchema = /* @__PURE__ */ (() => z31.object({
   entitlement: entitlementSchema,
   person: personSchema
 }))();
@@ -3383,11 +3415,11 @@ function collection({ post }) {
 var collectionApi = (http) => collection(http);
 
 // src/server/client/operations.ts
-import * as z33 from "zod";
+import * as z32 from "zod";
 function operations({ get, post }) {
   return {
     /** Every paused or resumed operation: redemptions and each quest's participation; requires `read`. */
-    list: (call) => get("/operations", z33.array(operationSchema), call),
+    list: (call) => get("/operations", z32.array(operationSchema), call),
     /**
      * Pauses or resumes redemptions or one quest's participation, against the `revision` the
      * operator saw, with a reason; requires `publish` permission.
@@ -3423,7 +3455,7 @@ function redemptions(http) {
 var redemptionsApi = (http) => redemptions(http);
 
 // src/server/client/inventory.ts
-import * as z34 from "zod";
+import * as z33 from "zod";
 function inventory({ create, get, post }) {
   return {
     /** Includes archived items and revision fences; requires read permission. */
@@ -3457,7 +3489,7 @@ function inventory({ create, get, post }) {
       call
     ),
     /** Every stock item with its counts and the offers that sell it; requires `read` permission. */
-    list: (call) => get("/stock-items", z34.array(managedStockItemSchema), call),
+    list: (call) => get("/stock-items", z33.array(managedStockItemSchema), call),
     createItem: (input, call) => create(
       "/stock-items",
       stockItemSchema,
@@ -3472,7 +3504,7 @@ function inventory({ create, get, post }) {
       stockInputSchema.parse(withActionId(input)),
       call
     ),
-    catalog: (call) => get("/pickup-inventory", z34.array(pickupCatalogSchema), call),
+    catalog: (call) => get("/pickup-inventory", z33.array(pickupCatalogSchema), call),
     configure: (input, call) => post(
       "/pickup-inventory",
       pickupCatalogSchema,
@@ -3489,7 +3521,7 @@ function inventory({ create, get, post }) {
 var inventoryApi = (http) => inventory(http);
 
 // src/server/client/offers.ts
-import * as z35 from "zod";
+import * as z34 from "zod";
 function offers({ get, post }) {
   return {
     /**
@@ -3527,7 +3559,7 @@ function offers({ get, post }) {
       ),
       call
     ),
-    list: (call) => get("/offers", z35.array(offerSchema), call),
+    list: (call) => get("/offers", z34.array(offerSchema), call),
     /**
      * Every redemption, or one member's, newest first, in one unbounded response.
      *
@@ -3535,7 +3567,7 @@ function offers({ get, post }) {
      */
     redemptions: (input = {}, call) => get(
       `/redemptions${queryString({ member: input.member })}`,
-      z35.array(redemptionSchema),
+      z34.array(redemptionSchema),
       call
     ),
     /** Pauses or resumes an offer at the revision the operator saw. */
@@ -3560,16 +3592,16 @@ function offers({ get, post }) {
 var offersApi = (http) => offers(http);
 
 // src/server/client/tokens.ts
-import * as z38 from "zod";
+import * as z37 from "zod";
 
 // src/server/api-keys.ts
-import * as z37 from "zod";
+import * as z36 from "zod";
 
 // src/server/permissions.ts
-import * as z36 from "zod";
-var environmentSchema = /* @__PURE__ */ (() => z36.enum(["test", "live"]))();
-var roleSchema = /* @__PURE__ */ (() => z36.enum(["editor", "reviewer", "staff"]))();
-var permissionSchema = /* @__PURE__ */ (() => z36.enum([
+import * as z35 from "zod";
+var environmentSchema = /* @__PURE__ */ (() => z35.enum(["test", "live"]))();
+var roleSchema = /* @__PURE__ */ (() => z35.enum(["editor", "reviewer", "staff"]))();
+var permissionSchema = /* @__PURE__ */ (() => z35.enum([
   "read",
   "publish",
   "review",
@@ -3589,7 +3621,7 @@ var permissionSchema = /* @__PURE__ */ (() => z36.enum([
    */
   "enroll"
 ]))();
-var permissionListSchema = /* @__PURE__ */ (() => z36.array(z36.string()).transform(
+var permissionListSchema = /* @__PURE__ */ (() => z35.array(z35.string()).transform(
   (values) => values.filter(
     (value) => permissionSchema.safeParse(value).success
   )
@@ -3599,8 +3631,8 @@ var rolePermissions = {
   reviewer: ["read", "review"],
   staff: ["read", "confirm", "handover"]
 };
-var projectRoleSchema = /* @__PURE__ */ (() => z36.enum([...roleSchema.options, "viewer"]))();
-var projectPermissionSchema = /* @__PURE__ */ (() => z36.enum([
+var projectRoleSchema = /* @__PURE__ */ (() => z35.enum([...roleSchema.options, "viewer"]))();
+var projectPermissionSchema = /* @__PURE__ */ (() => z35.enum([
   ...permissionSchema.options,
   "dashboards"
 ]))();
@@ -3612,55 +3644,55 @@ var projectRolePermissions = {
 };
 
 // src/server/api-keys.ts
-var ingestTrackerScopeSchema = /* @__PURE__ */ (() => z37.array(identifier).min(1).max(100).nullable())();
-var tokenScopeInputSchema = /* @__PURE__ */ (() => z37.object({ ingestTrackers: ingestTrackerScopeSchema }).strict())();
-var tokenInputSchema = /* @__PURE__ */ (() => z37.object({
-  name: z37.string().trim().min(1).max(80),
+var ingestTrackerScopeSchema = /* @__PURE__ */ (() => z36.array(identifier).min(1).max(100).nullable())();
+var tokenScopeInputSchema = /* @__PURE__ */ (() => z36.object({ ingestTrackers: ingestTrackerScopeSchema }).strict())();
+var tokenInputSchema = /* @__PURE__ */ (() => z36.object({
+  name: z36.string().trim().min(1).max(80),
   project: identifier,
   environment: environmentSchema,
-  permissions: z37.array(permissionSchema).min(1),
+  permissions: z36.array(permissionSchema).min(1),
   ingestTrackers: ingestTrackerScopeSchema.optional(),
-  days: z37.number().int().min(1).max(90).default(30)
+  days: z36.number().int().min(1).max(90).default(30)
 }).strict())();
-var tokenSchema = /* @__PURE__ */ (() => z37.object({
-  id: z37.string(),
-  name: z37.string(),
-  project: z37.string(),
+var tokenSchema = /* @__PURE__ */ (() => z36.object({
+  id: z36.string(),
+  name: z36.string(),
+  project: z36.string(),
   environment: environmentSchema,
   permissions: permissionListSchema,
   ingestTrackers: ingestTrackerScopeSchema.optional(),
-  expiresAt: z37.number()
+  expiresAt: z36.number()
 }))();
-var issuedTokenSchema = /* @__PURE__ */ (() => tokenSchema.extend({ token: z37.string() }))();
-var serviceKeyInputSchema = /* @__PURE__ */ (() => z37.object({
-  name: z37.string().trim().min(1).max(80),
-  permissions: z37.array(permissionSchema).min(1).refine(
+var issuedTokenSchema = /* @__PURE__ */ (() => tokenSchema.extend({ token: z36.string() }))();
+var serviceKeyInputSchema = /* @__PURE__ */ (() => z36.object({
+  name: z36.string().trim().min(1).max(80),
+  permissions: z36.array(permissionSchema).min(1).refine(
     (permissions) => !permissions.includes("access"),
     "Service keys cannot hold the access permission"
   ),
   /** Days until the first secret expires. Omit it for a key that never expires. */
-  expiresInDays: z37.number().int().min(1).max(3650).optional()
+  expiresInDays: z36.number().int().min(1).max(3650).optional()
 }).strict())();
-var serviceKeySchema = /* @__PURE__ */ (() => z37.object({
-  id: z37.string().uuid(),
-  organization: z37.string(),
-  project: z37.string(),
+var serviceKeySchema = /* @__PURE__ */ (() => z36.object({
+  id: z36.string().uuid(),
+  organization: z36.string(),
+  project: z36.string(),
   environment: environmentSchema,
-  name: z37.string(),
+  name: z36.string(),
   permissions: permissionListSchema,
   /** The Clerk user ID of the administrator who created it. */
-  createdBy: z37.string(),
-  createdAt: z37.number(),
+  createdBy: z36.string(),
+  createdAt: z36.number(),
   /** The latest use of any of its secrets, revoked ones included; null when none was used. */
-  lastUsedAt: z37.number().nullable(),
+  lastUsedAt: z36.number().nullable(),
   /** Its working secrets, oldest first. Any of them authenticates the key. */
-  secrets: z37.array(credentialSecretSchema)
+  secrets: z36.array(credentialSecretSchema)
 }))();
 var issuedServiceKeySchema = /* @__PURE__ */ (() => serviceKeySchema.extend({
-  secret: z37.string().uuid(),
-  token: z37.string()
+  secret: z36.string().uuid(),
+  token: z36.string()
 }))();
-var automationKeyPermissionSchema = /* @__PURE__ */ (() => z37.enum([
+var automationKeyPermissionSchema = /* @__PURE__ */ (() => z36.enum([
   "read",
   "publish",
   "inventory",
@@ -3668,47 +3700,47 @@ var automationKeyPermissionSchema = /* @__PURE__ */ (() => z37.enum([
   "ingest",
   "enroll"
 ]))();
-var automationKeyInputSchema = /* @__PURE__ */ (() => z37.object({
-  name: z37.string().trim().min(1).max(80),
-  permissions: z37.array(automationKeyPermissionSchema).min(1),
+var automationKeyInputSchema = /* @__PURE__ */ (() => z36.object({
+  name: z36.string().trim().min(1).max(80),
+  permissions: z36.array(automationKeyPermissionSchema).min(1),
   /**
    * The projects it reaches. Omit it for every project of the organization, current and future.
    * An empty list, allowed only with `createProjects`, reaches only the projects it creates.
    */
-  projects: z37.array(identifier).max(100).optional(),
+  projects: z36.array(identifier).max(100).optional(),
   /** Whether it may create projects. A project it creates joins its `projects` list. */
-  createProjects: z37.boolean().default(false),
+  createProjects: z36.boolean().default(false),
   /** Days until the first secret expires. Omit it for a key that never expires. */
-  expiresInDays: z37.number().int().min(1).max(3650).optional()
-}).strict().refine((key) => key.projects?.length !== 0 || key.createProjects, {
+  expiresInDays: z36.number().int().min(1).max(3650).optional()
+}).strict().refine((key2) => key2.projects?.length !== 0 || key2.createProjects, {
   message: "Choose a project, or let the key create projects",
   path: ["projects"]
 }))();
-var automationKeySchema = /* @__PURE__ */ (() => z37.object({
-  id: z37.string().uuid(),
-  organization: z37.string(),
-  name: z37.string(),
+var automationKeySchema = /* @__PURE__ */ (() => z36.object({
+  id: z36.string().uuid(),
+  organization: z36.string(),
+  name: z36.string(),
   permissions: permissionListSchema,
   /** The projects it reaches; null for every project of the organization. */
-  projects: z37.array(z37.string()).nullable(),
-  createProjects: z37.boolean(),
+  projects: z36.array(z36.string()).nullable(),
+  createProjects: z36.boolean(),
   /** The Clerk user ID of the administrator who created it. */
-  createdBy: z37.string(),
-  createdAt: z37.number(),
+  createdBy: z36.string(),
+  createdAt: z36.number(),
   /** The latest use of any of its secrets, revoked ones included; null when none was used. */
-  lastUsedAt: z37.number().nullable(),
+  lastUsedAt: z36.number().nullable(),
   /** Its working secrets, oldest first. Any of them authenticates the key. */
-  secrets: z37.array(credentialSecretSchema)
+  secrets: z36.array(credentialSecretSchema)
 }))();
 var issuedAutomationKeySchema = /* @__PURE__ */ (() => automationKeySchema.extend({
-  secret: z37.string().uuid(),
-  token: z37.string()
+  secret: z36.string().uuid(),
+  token: z36.string()
 }))();
 
 // src/server/client/tokens.ts
 function tokens({ get, post, request }) {
   return {
-    list: (call) => get("/tokens", z38.array(tokenSchema), call),
+    list: (call) => get("/tokens", z37.array(tokenSchema), call),
     /**
      * Issues a key for one project and environment, limited to permissions the caller holds
      * there. It expires after `days`, 1 to 90 (default 30). The secret `token` is in this
@@ -3717,14 +3749,14 @@ function tokens({ get, post, request }) {
     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(z38.string().min(1).parse(id))}/scope`,
+      `/tokens/${encodeURIComponent(z37.string().min(1).parse(id))}/scope`,
       tokenSchema,
       tokenScopeInputSchema.parse(input),
       "PUT",
       call
     ),
     revoke: (id, call) => request(
-      `/tokens/${encodeURIComponent(z38.string().min(1).parse(id))}`,
+      `/tokens/${encodeURIComponent(z37.string().min(1).parse(id))}`,
       ok,
       void 0,
       "DELETE",
@@ -3735,10 +3767,10 @@ function tokens({ get, post, request }) {
 var tokensApi = (http) => tokens(http);
 
 // src/server/client/service-keys.ts
-import * as z39 from "zod";
+import * as z38 from "zod";
 function serviceKeys({ get, post, request }) {
   return {
-    list: (call) => get("/service-keys", z39.array(serviceKeySchema), call),
+    list: (call) => get("/service-keys", z38.array(serviceKeySchema), call),
     /** The secret `token` is in this response only. */
     create: (input, call) => post(
       "/service-keys",
@@ -3751,14 +3783,14 @@ function serviceKeys({ get, post, request }) {
      * them with `revokeSecret`. The new `token` is in this response only.
      */
     addSecret: (id, input = {}, call) => post(
-      `/service-keys/${z39.string().uuid().parse(id)}/secrets`,
+      `/service-keys/${z38.string().uuid().parse(id)}/secrets`,
       issuedServiceKeySchema,
       credentialSecretInputSchema.parse(input),
       call
     ),
     /** Stops one secret working. A key's last secret cannot be revoked; revoke the key instead. */
     revokeSecret: (id, secret, call) => request(
-      `/service-keys/${z39.string().uuid().parse(id)}/secrets/${z39.string().uuid().parse(secret)}`,
+      `/service-keys/${z38.string().uuid().parse(id)}/secrets/${z38.string().uuid().parse(secret)}`,
       serviceKeySchema,
       void 0,
       "DELETE",
@@ -3766,8 +3798,8 @@ function serviceKeys({ get, post, request }) {
     ),
     /** Deletes the key; every secret stops working. */
     revoke: (id, call) => request(
-      `/service-keys/${z39.string().uuid().parse(id)}`,
-      z39.null(),
+      `/service-keys/${z38.string().uuid().parse(id)}`,
+      z38.null(),
       void 0,
       "DELETE",
       call
@@ -3777,10 +3809,10 @@ function serviceKeys({ get, post, request }) {
 var serviceKeysApi = (http) => serviceKeys(http);
 
 // src/server/client/automation-keys.ts
-import * as z40 from "zod";
+import * as z39 from "zod";
 function automationKeys({ get, post, request }) {
   return {
-    list: (call) => get("/automation-keys", z40.array(automationKeySchema), call),
+    list: (call) => get("/automation-keys", z39.array(automationKeySchema), call),
     /** The secret `token` is in this response only. */
     create: (input, call) => post(
       "/automation-keys",
@@ -3793,14 +3825,14 @@ function automationKeys({ get, post, request }) {
      * them with `revokeSecret`. The new `token` is in this response only.
      */
     addSecret: (id, input = {}, call) => post(
-      `/automation-keys/${z40.string().uuid().parse(id)}/secrets`,
+      `/automation-keys/${z39.string().uuid().parse(id)}/secrets`,
       issuedAutomationKeySchema,
       credentialSecretInputSchema.parse(input),
       call
     ),
     /** Stops one secret working. A key's last secret cannot be revoked; revoke the key instead. */
     revokeSecret: (id, secret, call) => request(
-      `/automation-keys/${z40.string().uuid().parse(id)}/secrets/${z40.string().uuid().parse(secret)}`,
+      `/automation-keys/${z39.string().uuid().parse(id)}/secrets/${z39.string().uuid().parse(secret)}`,
       automationKeySchema,
       void 0,
       "DELETE",
@@ -3808,8 +3840,8 @@ function automationKeys({ get, post, request }) {
     ),
     /** Deletes the key; every secret stops working. */
     revoke: (id, call) => request(
-      `/automation-keys/${z40.string().uuid().parse(id)}`,
-      z40.null(),
+      `/automation-keys/${z39.string().uuid().parse(id)}`,
+      z39.null(),
       void 0,
       "DELETE",
       call
@@ -3819,26 +3851,26 @@ function automationKeys({ get, post, request }) {
 var automationKeysApi = (http) => automationKeys(http);
 
 // src/server/client/grants.ts
-import * as z42 from "zod";
+import * as z41 from "zod";
 
 // src/server/grants.ts
-import * as z41 from "zod";
-var grantSchema = /* @__PURE__ */ (() => z41.object({
-  subject: z41.string().min(1).max(200),
-  roles: z41.array(roleSchema),
-  environments: z41.array(environmentSchema)
+import * as z40 from "zod";
+var grantSchema = /* @__PURE__ */ (() => z40.object({
+  subject: z40.string().min(1).max(200),
+  roles: z40.array(roleSchema),
+  environments: z40.array(environmentSchema)
 }).strict())();
-var projectGrantSchema = /* @__PURE__ */ (() => z41.object({
+var projectGrantSchema = /* @__PURE__ */ (() => z40.object({
   subject: grantSchema.shape.subject,
-  roles: z41.array(projectRoleSchema),
+  roles: z40.array(projectRoleSchema),
   environments: grantSchema.shape.environments,
   /**
    * When the grant stops giving access (epoch ms). Omit it, or send null, for a grant without
    * an end. An ended grant stays listed, so the project's access shows who had it and until when.
    */
-  expiresAt: z41.number().int().positive().nullable().optional()
+  expiresAt: z40.number().int().positive().nullable().optional()
 }).strict())();
-var grantRecordSchema = /* @__PURE__ */ (() => z41.object({
+var grantRecordSchema = /* @__PURE__ */ (() => z40.object({
   ...grantSchema.shape,
   /**
    * Every role the grant gives, `viewer` included, which `roles` leaves out. Absent from Relay
@@ -3846,23 +3878,23 @@ var grantRecordSchema = /* @__PURE__ */ (() => z41.object({
    *
    * @experimental
    */
-  projectRoles: z41.array(z41.string()).optional(),
+  projectRoles: z40.array(z40.string()).optional(),
   /**
    * When the grant stops giving access (epoch ms), or null for no end. A grant past it is still
    * listed and gives no permission.
    *
    * @experimental
    */
-  expiresAt: z41.number().nullable().optional()
+  expiresAt: z40.number().nullable().optional()
 }))();
-var teamSchema = /* @__PURE__ */ (() => z41.array(
-  z41.object({ id: z41.string(), label: z41.string() })
+var teamSchema = /* @__PURE__ */ (() => z40.array(
+  z40.object({ id: z40.string(), label: z40.string() })
 ))();
 
 // src/server/client/grants.ts
 function grants({ get, request }) {
   return {
-    list: (call) => get("/grants", z42.array(grantRecordSchema), call),
+    list: (call) => get("/grants", z41.array(grantRecordSchema), call),
     /**
      * Replaces one person's roles, environments and end date on the project. The audit log
      * records it. `viewer` and `expiresAt` are experimental.
@@ -3887,14 +3919,14 @@ function team({ get }) {
 var teamApi = (http) => team(http);
 
 // src/server/client/webhooks.ts
-import * as z43 from "zod";
+import * as z42 from "zod";
 function webhooks({ get, post, request }) {
   function rotateWebhookSecret(id, inputOrCall, call) {
     const isInput = call !== void 0 || inputOrCall !== void 0 && "actionId" in inputOrCall;
     const input = isInput ? inputOrCall ?? {} : {};
     const options = isInput ? call : inputOrCall;
     return post(
-      `/webhooks/${z43.string().uuid().parse(id)}/rotate-secret`,
+      `/webhooks/${z42.string().uuid().parse(id)}/rotate-secret`,
       webhookSecretSchema,
       webhookRotateInputSchema.parse(withActionId(input)),
       options
@@ -3902,7 +3934,7 @@ function webhooks({ get, post, request }) {
   }
   return {
     state: (id, call) => get(
-      `/webhooks/${z43.string().uuid().parse(id)}/state`,
+      `/webhooks/${z42.string().uuid().parse(id)}/state`,
       webhookEndpointStateSchema,
       call
     ),
@@ -3913,24 +3945,24 @@ function webhooks({ get, post, request }) {
       call
     ),
     delete: (id, input, call) => post(
-      `/webhooks/${z43.string().uuid().parse(id)}/delete`,
+      `/webhooks/${z42.string().uuid().parse(id)}/delete`,
       webhookEndpointStateSchema,
       webhookDeleteInputSchema.parse(withActionId(input)),
       call
     ),
     pause: (id, input = {}, call) => post(
-      `/webhooks/${z43.string().uuid().parse(id)}/pause`,
+      `/webhooks/${z42.string().uuid().parse(id)}/pause`,
       webhookEndpointSchema,
       webhookControlInputSchema.parse(withActionId(input)),
       call
     ),
     resume: (id, input = {}, call) => post(
-      `/webhooks/${z43.string().uuid().parse(id)}/resume`,
+      `/webhooks/${z42.string().uuid().parse(id)}/resume`,
       webhookEndpointSchema,
       webhookControlInputSchema.parse(withActionId(input)),
       call
     ),
-    list: (call) => get("/webhooks", z43.array(webhookEndpointSchema), call),
+    list: (call) => get("/webhooks", z42.array(webhookEndpointSchema), call),
     /** Pass an `actionId` to recover the endpoint and its secret after a lost answer. */
     create: (input, call) => post(
       "/webhooks",
@@ -3939,7 +3971,7 @@ function webhooks({ get, post, request }) {
       call
     ),
     update: (id, input, call) => request(
-      `/webhooks/${z43.string().uuid().parse(id)}`,
+      `/webhooks/${z42.string().uuid().parse(id)}`,
       webhookEndpointSchema,
       webhookUpdateSchema.parse(input),
       "PUT",
@@ -3947,14 +3979,14 @@ function webhooks({ get, post, request }) {
     ),
     /** @deprecated Use pause. Removed in 2.0.0. */
     disable: (id, call) => post(
-      `/webhooks/${z43.string().uuid().parse(id)}/disable`,
+      `/webhooks/${z42.string().uuid().parse(id)}/disable`,
       webhookEndpointSchema,
       {},
       call
     ),
     rotateSecret: rotateWebhookSecret,
     deliveries: (id, query = {}, call) => get(
-      `/webhooks/${z43.string().uuid().parse(id)}/deliveries${queryString(webhookQuerySchema.parse(query))}`,
+      `/webhooks/${z42.string().uuid().parse(id)}/deliveries${queryString(webhookQuerySchema.parse(query))}`,
       webhookDeliveryPageSchema,
       call
     ),
@@ -3964,7 +3996,7 @@ function webhooks({ get, post, request }) {
      */
     replay: (id, delivery, ...rest) => actionCommand(
       (webhook, input, call) => post(
-        `/webhooks/${z43.string().uuid().parse(webhook)}/deliveries/${z43.string().uuid().parse(delivery)}/replay`,
+        `/webhooks/${z42.string().uuid().parse(webhook)}/deliveries/${z42.string().uuid().parse(delivery)}/replay`,
         webhookDeliverySchema,
         webhookControlInputSchema.parse(input),
         call
@@ -3975,7 +4007,7 @@ function webhooks({ get, post, request }) {
 var webhooksApi = (http) => webhooks(http);
 
 // src/server/client/identity-integrations.ts
-import * as z44 from "zod";
+import * as z43 from "zod";
 function identityIntegrations({
   exchange,
   get,
@@ -3983,7 +4015,7 @@ function identityIntegrations({
   request
 }) {
   return {
-    list: (call) => get("/identity-integrations", z44.array(identityIntegrationSchema), call),
+    list: (call) => get("/identity-integrations", z43.array(identityIntegrationSchema), call),
     /** The secret `token` is in this response only. */
     create: (input, call) => post(
       "/identity-integrations",
@@ -4013,7 +4045,7 @@ function identityIntegrations({
      * @deprecated Use `addSecret`, then `revokeSecret` the old secret once your app uses the new one.
      */
     rotate: (id, call) => post(
-      `/identity-integrations/${z44.string().uuid().parse(id)}/rotate`,
+      `/identity-integrations/${z43.string().uuid().parse(id)}/rotate`,
       identityIntegrationSecretSchema,
       {},
       call
@@ -4023,7 +4055,7 @@ function identityIntegrations({
      * revoke them with `revokeSecret`. The new `token` is in this response only.
      */
     addSecret: (id, input = {}, call) => post(
-      `/identity-integrations/${z44.string().uuid().parse(id)}/secrets`,
+      `/identity-integrations/${z43.string().uuid().parse(id)}/secrets`,
       identityIntegrationSecretSchema,
       credentialSecretInputSchema.parse(input),
       call
@@ -4033,7 +4065,7 @@ function identityIntegrations({
      * environment instead of answering it, as `createIntoAppSecret` does.
      */
     addSecretIntoAppSecret: (id, appSecret, input = {}, call) => post(
-      `/identity-integrations/${z44.string().uuid().parse(id)}/secrets`,
+      `/identity-integrations/${z43.string().uuid().parse(id)}/secrets`,
       identityIntegrationAppSecretSchema,
       {
         ...credentialSecretInputSchema.parse(input),
@@ -4046,7 +4078,7 @@ function identityIntegrations({
      * revoked; disconnect the integration with `revoke` instead.
      */
     revokeSecret: (id, secret, call) => request(
-      `/identity-integrations/${z44.string().uuid().parse(id)}/secrets/${z44.string().uuid().parse(secret)}`,
+      `/identity-integrations/${z43.string().uuid().parse(id)}/secrets/${z43.string().uuid().parse(secret)}`,
       identityIntegrationSchema,
       void 0,
       "DELETE",
@@ -4054,7 +4086,7 @@ function identityIntegrations({
     ),
     /** Makes one secret never expire. */
     removeSecretExpiry: (id, secret, call) => request(
-      `/identity-integrations/${z44.string().uuid().parse(id)}/secrets/${z44.string().uuid().parse(secret)}/expiry`,
+      `/identity-integrations/${z43.string().uuid().parse(id)}/secrets/${z43.string().uuid().parse(secret)}/expiry`,
       identityIntegrationSchema,
       void 0,
       "DELETE",
@@ -4067,7 +4099,7 @@ function identityIntegrations({
      */
     kinds: (call) => get(
       "/identity-integrations/kinds",
-      z44.array(identityKindClaimSchema),
+      z43.array(identityKindClaimSchema),
       call
     ),
     /**
@@ -4079,7 +4111,7 @@ function identityIntegrations({
     setAccountVouching: (id, input, call) => (
       // The action ID's receipt makes a repeat apply once, so the client may resend it.
       exchange(
-        `/identity-integrations/${z44.string().uuid().parse(id)}/account-vouching`,
+        `/identity-integrations/${z43.string().uuid().parse(id)}/account-vouching`,
         identityIntegrationSchema,
         identityIntegrationAccountVouchingInputSchema.parse(
           withActionId(input)
@@ -4094,8 +4126,8 @@ function identityIntegrations({
      * and keep attributing tracker records; unlink them on the member to stop that.
      */
     revoke: (id, call) => request(
-      `/identity-integrations/${z44.string().uuid().parse(id)}`,
-      z44.null(),
+      `/identity-integrations/${z43.string().uuid().parse(id)}`,
+      z43.null(),
       void 0,
       "DELETE",
       call
@@ -4105,35 +4137,35 @@ function identityIntegrations({
 var identityIntegrationsApi = (http) => identityIntegrations(http);
 
 // src/server/audit.ts
-import * as z45 from "zod";
-var auditRecordSchema = /* @__PURE__ */ (() => z45.object({
-  id: z45.string(),
-  action: z45.string(),
-  actor: z45.string().nullable(),
+import * as z44 from "zod";
+var auditRecordSchema = /* @__PURE__ */ (() => z44.object({
+  id: z44.string(),
+  action: z44.string(),
+  actor: z44.string().nullable(),
   user: operatorUserSchema.nullable().optional(),
-  detail: z45.string(),
-  at: z45.number(),
-  attempt: z45.string().nullable()
-}).refine((record5) => !record5.user || record5.user.id === record5.actor, {
+  detail: z44.string(),
+  at: z44.number(),
+  attempt: z44.string().nullable()
+}).refine((record3) => !record3.user || record3.user.id === record3.actor, {
   message: "User profile must match the recorded actor",
   path: ["user"]
 }))();
-var auditQuerySchema = /* @__PURE__ */ (() => z45.strictObject({
-  category: z45.enum(["reviews", "rewards", "configuration"]).optional(),
-  q: z45.string().max(200).optional(),
+var auditQuerySchema = /* @__PURE__ */ (() => z44.strictObject({
+  category: z44.enum(["reviews", "rewards", "configuration"]).optional(),
+  q: z44.string().max(200).optional(),
   limit: pageLimit,
   cursor: pageCursorSchema.optional()
 }))();
 var auditListQuerySchema = /* @__PURE__ */ (() => auditQuerySchema.extend({
-  category: z45.enum(["reviews", "rewards", "configuration", "test-members"]).optional()
+  category: z44.enum(["reviews", "rewards", "configuration", "test-members"]).optional()
 }))();
 var accessHistoryQuerySchema = /* @__PURE__ */ (() => auditQuerySchema.omit({
   category: true
 }))();
-var auditPageSchema = /* @__PURE__ */ (() => z45.object({
-  items: z45.array(auditRecordSchema),
-  total: z45.number().int().nonnegative(),
-  nextCursor: z45.string().nullable()
+var auditPageSchema = /* @__PURE__ */ (() => z44.object({
+  items: z44.array(auditRecordSchema),
+  total: z44.number().int().nonnegative(),
+  nextCursor: z44.string().nullable()
 }))();
 
 // src/server/client/audit.ts
@@ -4230,7 +4262,7 @@ function discordRoles({ get, post }) {
 var discordRolesApi = (http) => discordRoles(http);
 
 // src/server/client/test-members.ts
-import * as z46 from "zod";
+import * as z45 from "zod";
 function testMembers({ get, post }) {
   return {
     create: (input, call) => post(
@@ -4239,7 +4271,7 @@ function testMembers({ get, post }) {
       testMemberCreateSchema.parse(withActionId(input)),
       call
     ),
-    list: (call) => get("/test-members", z46.array(testMemberSchema), call),
+    list: (call) => get("/test-members", z45.array(testMemberSchema), call),
     history: (member, query = {}, call) => get(
       `/test-members/${identifier.parse(member)}/history${queryString(testMemberHistoryQuerySchema.parse(query))}`,
       testMemberHistorySchema,
@@ -4257,16 +4289,16 @@ function testMembers({ get, post }) {
      * and file store one image, so pass `act`'s action ID to replay both. Reset deletes it.
      */
     uploadEvidence: (member, file, input = {}, call) => {
-      const { actionId: actionId2 } = withActionId(
-        z46.object({ actionId: identifier.optional() }).strict().parse(input)
+      const { actionId: actionId3 } = withActionId(
+        z45.object({ actionId: identifier.optional() }).strict().parse(input)
       );
       return post(
         `/test-members/${identifier.parse(member)}/evidence`,
         evidenceSchema,
         new ManagementUploadBody(
           file,
-          { "X-Relay-Upload-ID": actionId2 },
-          actionId2
+          { "X-Relay-Upload-ID": actionId3 },
+          actionId3
         ),
         call
       );
@@ -4517,79 +4549,79 @@ function memberImports({ get, post }) {
 var memberImportsApi = (http) => memberImports(http);
 
 // src/server/client/members.ts
-import * as z51 from "zod";
+import * as z50 from "zod";
 
 // src/server/members.ts
-import * as z49 from "zod";
+import * as z48 from "zod";
 
 // src/server/member-bans.ts
-import * as z47 from "zod";
-var memberBanRollbackSchema = /* @__PURE__ */ (() => z47.object({
-  completions: z47.boolean().default(false),
-  referralPayouts: z47.boolean().default(false),
-  pointAwards: z47.boolean().default(false)
+import * as z46 from "zod";
+var memberBanRollbackSchema = /* @__PURE__ */ (() => z46.object({
+  completions: z46.boolean().default(false),
+  referralPayouts: z46.boolean().default(false),
+  pointAwards: z46.boolean().default(false)
 }).strict())();
-var banReason = /* @__PURE__ */ (() => z47.string().trim().min(1).max(500))();
-var memberBanInputSchema = /* @__PURE__ */ (() => z47.object({
+var banReason = /* @__PURE__ */ (() => z46.string().trim().min(1).max(500))();
+var memberBanInputSchema = /* @__PURE__ */ (() => z46.object({
   actionId: identifier,
   reason: banReason,
   rollback: memberBanRollbackSchema.optional()
 }).strict())();
-var memberBanPreviewInputSchema = /* @__PURE__ */ (() => z47.object({ rollback: memberBanRollbackSchema.optional() }).strict())();
-var memberUnbanInputSchema = /* @__PURE__ */ (() => z47.object({
+var memberBanPreviewInputSchema = /* @__PURE__ */ (() => z46.object({ rollback: memberBanRollbackSchema.optional() }).strict())();
+var memberUnbanInputSchema = /* @__PURE__ */ (() => z46.object({
   actionId: identifier,
   reason: banReason,
-  restoreCompletions: z47.boolean().default(false)
+  restoreCompletions: z46.boolean().default(false)
 }).strict())();
-var points2 = /* @__PURE__ */ (() => z47.number().int().nonnegative())();
-var memberBanOutcomeSchema = /* @__PURE__ */ (() => z47.object({
+var points2 = /* @__PURE__ */ (() => z46.number().int().nonnegative())();
+var memberBanOutcomeSchema = /* @__PURE__ */ (() => z46.object({
   attemptsRejected: points2,
   completionsRevoked: points2,
   completionsRestored: points2,
-  completionsKept: z47.array(
-    z47.object({ completion: identifier, code: z47.string() })
+  completionsKept: z46.array(
+    z46.object({ completion: identifier, code: z46.string() })
   ),
   entriesReversed: points2,
   referralAccounts: points2,
-  points: z47.array(
-    z47.object({ ledger: identifier, reversed: points2, unreversed: points2 })
+  points: z46.array(
+    z46.object({ ledger: identifier, reversed: points2, unreversed: points2 })
   ),
-  referralDebt: z47.array(z47.object({ ledger: identifier, amount: points2 }))
+  referralDebt: z46.array(z46.object({ ledger: identifier, amount: points2 }))
 }))();
-var runStatusSchema = /* @__PURE__ */ (() => z47.string())();
-var runSchema = /* @__PURE__ */ (() => z47.object({
+var runStatusSchema = /* @__PURE__ */ (() => z46.string())();
+var runSchema = /* @__PURE__ */ (() => z46.object({
   status: runStatusSchema,
-  finishedAt: z47.number().int().nullable(),
+  finishedAt: z46.number().int().nullable(),
   outcome: memberBanOutcomeSchema.nullable()
 }))();
-var memberBanSchema = /* @__PURE__ */ (() => z47.object({
+var memberBanSchema = /* @__PURE__ */ (() => z46.object({
   id: identifier,
   member: identifier,
-  reason: z47.string(),
-  bannedAt: z47.number().int(),
-  bannedBy: z47.string().nullable(),
+  reason: z46.string(),
+  bannedAt: z46.number().int(),
+  bannedBy: z46.string().nullable(),
   rollback: runSchema.extend({
-    completions: z47.boolean(),
-    referralPayouts: z47.boolean(),
-    pointAwards: z47.boolean()
+    completions: z46.boolean(),
+    referralPayouts: z46.boolean(),
+    pointAwards: z46.boolean()
   }),
-  unban: z47.object({
-    reason: z47.string(),
-    unbannedAt: z47.number().int(),
-    by: z47.string().nullable(),
-    restoreCompletions: z47.boolean(),
+  unban: z46.object({
+    reason: z46.string(),
+    unbannedAt: z46.number().int(),
+    by: z46.string().nullable(),
+    restoreCompletions: z46.boolean(),
     restore: runSchema.nullable()
   }).nullable()
 }))();
-var memberBanPreviewSchema = /* @__PURE__ */ (() => z47.object({
+var memberBanPreviewSchema = /* @__PURE__ */ (() => z46.object({
   member: identifier,
-  banned: z47.boolean(),
+  banned: z46.boolean(),
   attempts: points2,
   completions: points2,
   entries: points2,
   referralAccounts: points2,
-  points: z47.array(
-    z47.object({
+  points: z46.array(
+    z46.object({
       ledger: identifier,
       completions: points2,
       pointAwards: points2,
@@ -4600,11 +4632,11 @@ var memberBanPreviewSchema = /* @__PURE__ */ (() => z47.object({
       referralDebt: points2
     })
   ),
-  inviters: z47.array(
-    z47.object({
+  inviters: z46.array(
+    z46.object({
       member: identifier,
-      ledgers: z47.array(
-        z47.object({
+      ledgers: z46.array(
+        z46.object({
           ledger: identifier,
           bonus: points2,
           reversed: points2,
@@ -4616,23 +4648,31 @@ var memberBanPreviewSchema = /* @__PURE__ */ (() => z47.object({
 }))();
 
 // src/server/wallets.ts
-import * as z48 from "zod";
+import * as z47 from "zod";
 var managedWalletSchema = /* @__PURE__ */ (() => linkedWalletSchema.extend({
   /**
    * True when the organization vouched for the wallet (a member import, or an app login's server at
    * sign-in), and the member has not proved it since. Absent from Relay versions without imports.
    */
-  imported: z48.boolean().optional(),
+  imported: z47.boolean().optional(),
   /**
    * The app login that vouched for the wallet at sign-in, while `imported` is true and no member
    * import attached it. Absent from Relay versions without it.
    */
   vouchedBy: accountVouchedBySchema.optional(),
   ...identitySourceFields,
-  status: z48.enum(["linked", "unlinked"]),
-  unlinkedAt: z48.number().int().nullable(),
+  /**
+   * A linked Solana wallet's primary `.sol` name (SNS), such as `"toly.sol"`, while the wallet owns the
+   * domain, as Relay last read it from mainnet. For display only: `address` stays the wallet's
+   * identity. Absent when it has none or Relay has not read it yet.
+   *
+   * @experimental A minor release can change `.sol` names.
+   */
+  name: z47.string().optional(),
+  status: z47.enum(["linked", "unlinked"]),
+  unlinkedAt: z47.number().int().nullable(),
   /** "member", or the operator or key that unlinked it. */
-  unlinkedBy: z48.string().nullable()
+  unlinkedBy: z47.string().nullable()
 }))();
 var balanceCheckSchema = /* @__PURE__ */ (() => walletBalanceSchema.pick({
   chain: true,
@@ -4642,66 +4682,66 @@ var balanceCheckSchema = /* @__PURE__ */ (() => walletBalanceSchema.pick({
   wallets: true,
   observedAt: true
 }).extend({ attempt: identifier }))();
-var walletBalanceChainsSchema = /* @__PURE__ */ (() => z48.object({
-  chains: z48.array(
-    z48.object({
-      chain: z48.union([
-        z48.literal(solanaMainnet),
-        z48.literal(solanaDevnet),
+var walletBalanceChainsSchema = /* @__PURE__ */ (() => z47.object({
+  chains: z47.array(
+    z47.object({
+      chain: z47.union([
+        z47.literal(solanaMainnet),
+        z47.literal(solanaDevnet),
         cosmosNetworkSchema,
         evmChainIdSchema
       ]),
-      name: z48.string(),
-      testnet: z48.boolean()
+      name: z47.string(),
+      testnet: z47.boolean()
     })
   )
 }))();
-var memberWalletUnlinkInputSchema = /* @__PURE__ */ (() => walletUnlinkInputSchema.extend({ reason: z48.string().trim().min(1).max(500) }).strict())();
+var memberWalletUnlinkInputSchema = /* @__PURE__ */ (() => walletUnlinkInputSchema.extend({ reason: z47.string().trim().min(1).max(500) }).strict())();
 var memberWalletSignInInputSchema = /* @__PURE__ */ (() => walletUnlinkInputSchema.extend({
-  enabled: z48.boolean(),
-  reason: z48.string().trim().min(1).max(500)
+  enabled: z47.boolean(),
+  reason: z47.string().trim().min(1).max(500)
 }).strict())();
 
 // src/server/members.ts
-var memberSchema = /* @__PURE__ */ (() => z49.object({
-  id: z49.string(),
-  test: z49.boolean().optional(),
-  name: z49.string().nullable().optional(),
-  accounts: z49.array(memberAccountSchema).default([]),
+var memberSchema = /* @__PURE__ */ (() => z48.object({
+  id: z48.string(),
+  test: z48.boolean().optional(),
+  name: z48.string().nullable().optional(),
+  accounts: z48.array(memberAccountSchema).default([]),
   /** The member's linked app identities, by kind. Absent from Relay versions without it. */
-  appIdentities: z49.array(memberAppIdentitySchema).optional(),
-  attempts: z49.number(),
-  completions: z49.number(),
-  rewards: z49.number(),
-  lastActivity: z49.number().nullable(),
+  appIdentities: z48.array(memberAppIdentitySchema).optional(),
+  attempts: z48.number(),
+  completions: z48.number(),
+  rewards: z48.number(),
+  lastActivity: z48.number().nullable(),
   /**
    * When the customer erased the member (`members.erase`), in Unix milliseconds: it keeps its ID
    * and accounting, with no profile, accounts or identities. Absent on a member that was not erased.
    */
-  erasedAt: z49.number().optional(),
+  erasedAt: z48.number().optional(),
   /**
    * When an operator banned the member (`members.ban`), in Unix milliseconds. Absent on a member
    * who is not banned now.
    *
    * @experimental A minor release can change member bans.
    */
-  bannedAt: z49.number().optional()
+  bannedAt: z48.number().optional()
 }))();
-var managedOAuthAccountBaseSchema = /* @__PURE__ */ (() => z49.object({
-  provider: z49.enum(["x", "discord"]),
-  revision: z49.number().int().nonnegative()
+var managedOAuthAccountBaseSchema = /* @__PURE__ */ (() => z48.object({
+  provider: z48.enum(["x", "discord"]),
+  revision: z48.number().int().nonnegative()
 }))();
-var managedOAuthAccountSchema = /* @__PURE__ */ (() => z49.discriminatedUnion("status", [
+var managedOAuthAccountSchema = /* @__PURE__ */ (() => z48.discriminatedUnion("status", [
   managedOAuthAccountBaseSchema.extend({
-    status: z49.literal("connected"),
-    subject: z49.string().min(1),
-    linkedAt: z49.number(),
+    status: z48.literal("connected"),
+    subject: z48.string().min(1),
+    linkedAt: z48.number(),
     /**
      * True when the organization vouched for the account, not the member's proof: a member import
      * attached it, or an app login's server did at sign-in (`vouchedBy`). Absent from Relay
      * versions without imports.
      */
-    imported: z49.boolean().optional(),
+    imported: z48.boolean().optional(),
     /**
      * The app login that vouched for the account at sign-in, for an account with `imported` set
      * that no member import attached. Absent from Relay versions without it.
@@ -4711,26 +4751,26 @@ var managedOAuthAccountSchema = /* @__PURE__ */ (() => z49.discriminatedUnion("s
      * True for a real account an operator linked to a test member without OAuth
      * (`testMembers.linkAccount`). Absent from Relay versions without it.
      */
-    testLinked: z49.boolean().optional(),
+    testLinked: z48.boolean().optional(),
     ...identitySourceFields
   }),
-  managedOAuthAccountBaseSchema.extend({ status: z49.literal("disconnected") })
+  managedOAuthAccountBaseSchema.extend({ status: z48.literal("disconnected") })
 ]))();
 var managedTelegramAccountBaseSchema = /* @__PURE__ */ (() => managedOAuthAccountBaseSchema.extend({
-  provider: z49.literal("telegram")
+  provider: z48.literal("telegram")
 }))();
-var managedTelegramAccountSchema = /* @__PURE__ */ (() => z49.discriminatedUnion("status", [
+var managedTelegramAccountSchema = /* @__PURE__ */ (() => z48.discriminatedUnion("status", [
   managedTelegramAccountBaseSchema.extend({
-    status: z49.literal("connected"),
+    status: z48.literal("connected"),
     /** The numeric Telegram user ID. */
-    subject: z49.string().min(1),
-    linkedAt: z49.number(),
+    subject: z48.string().min(1),
+    linkedAt: z48.number(),
     /**
      * True when the organization vouched for the account, not the member's proof: a member import
      * attached it, or an app login's server did at sign-in (`vouchedBy`). Absent from Relay
      * versions without it.
      */
-    imported: z49.boolean().optional(),
+    imported: z48.boolean().optional(),
     /**
      * The app login that vouched for the account at sign-in, for an account with `imported` set
      * that no member import attached. Absent from Relay versions without it.
@@ -4739,14 +4779,14 @@ var managedTelegramAccountSchema = /* @__PURE__ */ (() => z49.discriminatedUnion
     ...identitySourceFields
   }),
   managedTelegramAccountBaseSchema.extend({
-    status: z49.literal("disconnected")
+    status: z48.literal("disconnected")
   })
 ]))();
-var memberOAuthUnlinkInputSchema = /* @__PURE__ */ (() => z49.object({
-  provider: z49.enum(["x", "discord"]),
-  subject: z49.string().min(1).max(4096),
-  revision: z49.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER - 1),
-  reason: z49.string().trim().min(1).max(500)
+var memberOAuthUnlinkInputSchema = /* @__PURE__ */ (() => z48.object({
+  provider: z48.enum(["x", "discord"]),
+  subject: z48.string().min(1).max(4096),
+  revision: z48.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER - 1),
+  reason: z48.string().trim().min(1).max(500)
 }).strict())();
 var memberTelegramUnlinkInputSchema = /* @__PURE__ */ (() => memberOAuthUnlinkInputSchema.omit({ provider: true }).strict())();
 var managedMemberIdentitySchema = /* @__PURE__ */ (() => memberIdentitySchema.extend({
@@ -4755,7 +4795,7 @@ var managedMemberIdentitySchema = /* @__PURE__ */ (() => memberIdentitySchema.ex
    * login's server at sign-in), until the member links that provider's account, or signs in with
    * the X account, through Domino. Absent from Relay versions without imports.
    */
-  imported: z49.boolean().optional(),
+  imported: z48.boolean().optional(),
   /**
    * The app login that vouched for the account at sign-in, for an `imported` account no member
    * import attached. Absent from Relay versions without it.
@@ -4765,40 +4805,40 @@ var managedMemberIdentitySchema = /* @__PURE__ */ (() => memberIdentitySchema.ex
    * True for a real X or Discord account an operator linked to a test member without OAuth
    * (`testMembers.linkAccount`). Absent from Relay versions without it.
    */
-  testLinked: z49.boolean().optional(),
+  testLinked: z48.boolean().optional(),
   ...identitySourceFields,
-  status: z49.enum(["linked", "unlinked"]),
-  unlinkedAt: z49.number().int().nullable(),
+  status: z48.enum(["linked", "unlinked"]),
+  unlinkedAt: z48.number().int().nullable(),
   /** The operator or key that unlinked it. */
-  unlinkedBy: z49.string().nullable()
+  unlinkedBy: z48.string().nullable()
 }))();
-var memberIdentityChangeInputSchema = /* @__PURE__ */ (() => z49.object({
+var memberIdentityChangeInputSchema = /* @__PURE__ */ (() => z48.object({
   kind: appIdentityKindSchema,
-  subject: z49.string().min(1).max(256),
-  reason: z49.string().trim().min(1).max(500)
+  subject: z48.string().min(1).max(256),
+  reason: z48.string().trim().min(1).max(500)
 }).strict())();
-var memberDetailSchema = /* @__PURE__ */ (() => z49.object({
+var memberDetailSchema = /* @__PURE__ */ (() => z48.object({
   snapshot: snapshotSchema,
   member: memberSchema,
   progress: memberProgressSchema,
   /** Up to 25 revoked completions with an unreversed point remainder, newest first. */
-  revocationShortfalls: z49.array(completionRevocationShortfallSchema).default([]),
+  revocationShortfalls: z48.array(completionRevocationShortfallSchema).default([]),
   /** Up to 25 revoked completions, newest first. Relay older than restore leaves it out. */
-  revokedCompletions: z49.array(revokedCompletionSchema).optional(),
+  revokedCompletions: z48.array(revokedCompletionSchema).optional(),
   /** Current and historical campaign enrollment state, including inactive enrollments. */
-  campaignEnrollments: z49.array(campaignEnrollmentSchema).default([]),
-  passes: z49.array(
-    z49.object({
-      provider: z49.string(),
-      event: z49.string(),
-      subject: z49.string(),
+  campaignEnrollments: z48.array(campaignEnrollmentSchema).default([]),
+  passes: z48.array(
+    z48.object({
+      provider: z48.string(),
+      event: z48.string(),
+      subject: z48.string(),
       attempt: identifier.nullable()
     })
   ).default([]),
   /** Linked and unlinked wallets. */
-  wallets: z49.array(managedWalletSchema),
+  wallets: z48.array(managedWalletSchema),
   /** The member's 10 most recent recorded balance reads, newest first. */
-  balanceChecks: z49.array(balanceCheckSchema),
+  balanceChecks: z48.array(balanceCheckSchema),
   /** The member's participant profile in this project. */
   profile: managedProfileSchema.nullable(),
   /**
@@ -4806,20 +4846,20 @@ var memberDetailSchema = /* @__PURE__ */ (() => z49.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: z49.array(managedMemberIdentitySchema),
+  identities: z48.array(managedMemberIdentitySchema),
   /**
    * The creator accounts the member linked (a YouTube channel), whose content managed tracker
    * sources attribute to them. Absent from Relay versions without creator accounts.
    */
-  creatorAccounts: z49.array(managedCreatorAccountSchema).optional(),
+  creatorAccounts: z48.array(managedCreatorAccountSchema).optional(),
   /**
    * Who invited the member, when they accepted, and the member import that recorded it, or null
    * when nobody invited them. Absent from Relay versions before imported referrals.
    */
-  referral: z49.object({
+  referral: z48.object({
     inviter: identifier,
-    acceptedAt: z49.number().int().nonnegative(),
-    suspended: z49.boolean(),
+    acceptedAt: z48.number().int().nonnegative(),
+    suspended: z48.boolean(),
     import: identifier.nullable()
   }).nullable().optional(),
   /**
@@ -4830,9 +4870,9 @@ var memberDetailSchema = /* @__PURE__ */ (() => z49.object({
    */
   ban: memberBanSchema.nullable().optional()
 }))();
-var managedMemberProgressSchema = /* @__PURE__ */ (() => z49.object({
+var managedMemberProgressSchema = /* @__PURE__ */ (() => z48.object({
   member: identifier,
-  quests: z49.array(
+  quests: z48.array(
     memberProgressSchema.shape.quests.element.extend({
       /** The streak as `members.get` reports it, without the list of qualifying days. */
       streak: streakProgressSchema.omit({ days: true }).nullable().optional()
@@ -4843,10 +4883,10 @@ var managedMemberProgressSchema = /* @__PURE__ */ (() => z49.object({
   /** Each point balance the member has, by balance ID. */
   balances: snapshotSchema.shape.balances
 }))();
-var memberLookupSchema = /* @__PURE__ */ (() => z49.union([
-  z49.object({
-    provider: z49.string().min(1).max(200),
-    subject: z49.string().min(1).max(2048)
+var memberLookupSchema = /* @__PURE__ */ (() => z48.union([
+  z48.object({
+    provider: z48.string().min(1).max(200),
+    subject: z48.string().min(1).max(2048)
   }).strict(),
   identityReferenceSchema.transform(
     (reference) => reference.kind === "wallet" ? { provider: reference.chain, subject: reference.address } : { provider: reference.kind, subject: reference.subject }
@@ -4857,50 +4897,50 @@ var memberLookupSchema = /* @__PURE__ */ (() => z49.union([
     subject: address
   }))
 ]))();
-var booleanQuery = /* @__PURE__ */ (() => z49.union([
-  z49.boolean(),
-  z49.enum(["true", "false"]).transform((v) => v === "true")
+var booleanQuery = /* @__PURE__ */ (() => z48.union([
+  z48.boolean(),
+  z48.enum(["true", "false"]).transform((v) => v === "true")
 ]))();
-var managedMemberQuerySchema = /* @__PURE__ */ (() => z49.strictObject({
-  q: z49.string().max(200).optional(),
+var managedMemberQuerySchema = /* @__PURE__ */ (() => z48.strictObject({
+  q: z48.string().max(200).optional(),
   needsReview: booleanQuery.optional(),
-  limit: z49.coerce.number().int().min(1).max(100).optional(),
+  limit: z48.coerce.number().int().min(1).max(100).optional(),
   cursor: pageCursorSchema.optional()
 }))();
-var managedMemberPageSchema = /* @__PURE__ */ (() => z49.object({
-  items: z49.array(memberSchema),
-  total: z49.number().int().nonnegative(),
-  nextCursor: z49.string().nullable()
+var managedMemberPageSchema = /* @__PURE__ */ (() => z48.object({
+  items: z48.array(memberSchema),
+  total: z48.number().int().nonnegative(),
+  nextCursor: z48.string().nullable()
 }))();
 
 // src/server/member-erasure.ts
-import * as z50 from "zod";
+import * as z49 from "zod";
 var memberErasureInputSchema = evidenceRedactionInputSchema;
-var memberErasureDeletedSchema = /* @__PURE__ */ (() => z50.object({
+var memberErasureDeletedSchema = /* @__PURE__ */ (() => z49.object({
   /** The profile: display name and avatar. 0 or 1. */
-  profiles: z50.number().int().nonnegative(),
+  profiles: z49.number().int().nonnegative(),
   /** Sign-in identities. */
-  identities: z50.number().int().nonnegative(),
+  identities: z49.number().int().nonnegative(),
   /** Linked X, Discord, Telegram, Google, Apple and email accounts. */
-  accounts: z50.number().int().nonnegative(),
+  accounts: z49.number().int().nonnegative(),
   /** `app:<name>` identities your app's integration or an import gave. */
-  appIdentities: z50.number().int().nonnegative(),
+  appIdentities: z49.number().int().nonnegative(),
   /** Linked wallet addresses. */
-  wallets: z50.number().int().nonnegative(),
+  wallets: z49.number().int().nonnegative(),
   /** Signed-in sessions, ended at once. */
-  sessions: z50.number().int().nonnegative(),
+  sessions: z49.number().int().nonnegative(),
   /** Marketing consent records. */
-  consents: z50.number().int().nonnegative(),
+  consents: z49.number().int().nonnegative(),
   /** Leaderboard aliases. */
-  aliases: z50.number().int().nonnegative(),
+  aliases: z49.number().int().nonnegative(),
   /** Attempts whose submitted evidence (photo, text, URL or answers) was deleted. */
-  evidence: z50.number().int().nonnegative(),
+  evidence: z49.number().int().nonnegative(),
   /** Tracker records the member's accounts authored, whose stored content was forgotten. */
-  records: z50.number().int().nonnegative()
+  records: z49.number().int().nonnegative()
 }))();
-var memberErasureResultSchema = /* @__PURE__ */ (() => z50.object({
+var memberErasureResultSchema = /* @__PURE__ */ (() => z49.object({
   member: identifier,
-  erasedAt: z50.number().int(),
+  erasedAt: z49.number().int(),
   deleted: memberErasureDeletedSchema
 }))();
 
@@ -5123,7 +5163,7 @@ function members({ get, post }) {
     /** Who each member is: up to 100 distinct IDs; unknown IDs come back without accounts. */
     people: (members2, call) => get(
       `/people${queryString({ ids: members2.join(",") })}`,
-      z51.array(personSchema),
+      z50.array(personSchema),
       call
     ),
     /**
@@ -5133,7 +5173,7 @@ function members({ get, post }) {
      */
     oauthAccounts: (member, call) => get(
       `/members/${encodeURIComponent(member)}/oauth-accounts`,
-      z51.array(managedOAuthAccountSchema),
+      z50.array(managedOAuthAccountSchema),
       call
     ),
     /**
@@ -5145,7 +5185,7 @@ function members({ get, post }) {
      */
     unlinkOAuthAccount: (member, input, call) => post(
       `/members/${encodeURIComponent(member)}/oauth-accounts/unlink`,
-      z51.array(managedOAuthAccountSchema),
+      z50.array(managedOAuthAccountSchema),
       expectedRevision(memberOAuthUnlinkInputSchema).parse(input),
       call
     ),
@@ -5228,7 +5268,7 @@ function members({ get, post }) {
      */
     unlinkWallet: (member, input, call) => post(
       `/members/${encodeURIComponent(member)}/wallets/unlink`,
-      z51.array(managedWalletSchema),
+      z50.array(managedWalletSchema),
       memberWalletUnlinkInputSchema.parse(input),
       call
     ),
@@ -5241,7 +5281,7 @@ function members({ get, post }) {
      */
     unlinkIdentity: (member, input, call) => post(
       `/members/${encodeURIComponent(member)}/identities/unlink`,
-      z51.array(managedMemberIdentitySchema),
+      z50.array(managedMemberIdentitySchema),
       memberIdentityChangeInputSchema.parse(input),
       call
     ),
@@ -5252,7 +5292,7 @@ function members({ get, post }) {
      */
     relinkIdentity: (member, input, call) => post(
       `/members/${encodeURIComponent(member)}/identities/relink`,
-      z51.array(managedMemberIdentitySchema),
+      z50.array(managedMemberIdentitySchema),
       memberIdentityChangeInputSchema.parse(input),
       call
     ),
@@ -5264,7 +5304,7 @@ function members({ get, post }) {
      */
     setWalletSignIn: (member, input, call) => post(
       `/members/${encodeURIComponent(member)}/wallets/sign-in`,
-      z51.array(managedWalletSchema),
+      z50.array(managedWalletSchema),
       memberWalletSignInInputSchema.parse(input),
       call
     )
@@ -5314,77 +5354,77 @@ function domains({ get, post, raw }) {
 var domainsApi = (http) => domains(http);
 
 // src/server/connections.ts
-import { z as z52 } from "zod";
-var connectionPluginSchema = /* @__PURE__ */ (() => z52.string().max(40).regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "Use a kebab-case plugin ID"))();
+import { z as z51 } from "zod";
+var connectionPluginSchema = /* @__PURE__ */ (() => z51.string().max(40).regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "Use a kebab-case plugin ID"))();
 var knownConnectionStatuses = [
   "disconnected",
   "ready",
   "attention"
 ];
-var connectionStatusSchema = /* @__PURE__ */ (() => z52.string().min(1))();
+var connectionStatusSchema = /* @__PURE__ */ (() => z51.string().min(1))();
 var knownConnectionReconnectReasons = ["revoked", "expired"];
-var reconnectReasonSchema = /* @__PURE__ */ (() => z52.string().min(1))();
-var connectionSecretFieldSchema = /* @__PURE__ */ (() => z52.object({
-  name: z52.string(),
-  label: z52.string(),
-  help: z52.string().nullable(),
-  set: z52.boolean()
-}))();
-var connectionSchema = /* @__PURE__ */ (() => z52.object({
-  plugin: z52.string(),
-  name: z52.string(),
-  environment: z52.enum(["test", "live"]),
+var reconnectReasonSchema = /* @__PURE__ */ (() => z51.string().min(1))();
+var connectionSecretFieldSchema = /* @__PURE__ */ (() => z51.object({
+  name: z51.string(),
+  label: z51.string(),
+  help: z51.string().nullable(),
+  set: z51.boolean()
+}))();
+var connectionSchema = /* @__PURE__ */ (() => z51.object({
+  plugin: z51.string(),
+  name: z51.string(),
+  environment: z51.enum(["test", "live"]),
   status: connectionStatusSchema,
-  issue: z52.string().nullable(),
-  config: z52.record(z52.string(), z52.unknown()).nullable(),
-  configSchema: z52.record(z52.string(), z52.unknown()),
-  secrets: z52.array(connectionSecretFieldSchema),
-  revision: z52.number().int().nonnegative(),
-  connectedAt: z52.number().nullable(),
-  connectedBy: z52.string().nullable(),
-  updatedAt: z52.number().nullable(),
+  issue: z51.string().nullable(),
+  config: z51.record(z51.string(), z51.unknown()).nullable(),
+  configSchema: z51.record(z51.string(), z51.unknown()),
+  secrets: z51.array(connectionSecretFieldSchema),
+  revision: z51.number().int().nonnegative(),
+  connectedAt: z51.number().nullable(),
+  connectedBy: z51.string().nullable(),
+  updatedAt: z51.number().nullable(),
   // A Relay from before OAuth connections answers none.
   reconnectReason: reconnectReasonSchema.nullable().default(null),
   // A Relay from before dry runs answers none.
-  dryRun: z52.boolean().default(false)
+  dryRun: z51.boolean().default(false)
 }))();
-var connectionPageSchema = /* @__PURE__ */ (() => z52.object({
-  items: z52.array(connectionSchema),
-  nextCursor: z52.string().nullable()
+var connectionPageSchema = /* @__PURE__ */ (() => z51.object({
+  items: z51.array(connectionSchema),
+  nextCursor: z51.string().nullable()
 }))();
-var actionId = /* @__PURE__ */ (() => z52.string().uuid().default(() => crypto.randomUUID()))();
-var config = /* @__PURE__ */ (() => z52.record(z52.string(), z52.unknown()))();
-var secrets = /* @__PURE__ */ (() => z52.record(z52.string().max(64), z52.string().min(1).max(8192)))();
-var connectionConnectInputSchema = /* @__PURE__ */ (() => z52.strictObject({
+var actionId2 = /* @__PURE__ */ (() => z51.string().uuid().default(() => crypto.randomUUID()))();
+var config = /* @__PURE__ */ (() => z51.record(z51.string(), z51.unknown()))();
+var secrets = /* @__PURE__ */ (() => z51.record(z51.string().max(64), z51.string().min(1).max(8192)))();
+var connectionConnectInputSchema = /* @__PURE__ */ (() => z51.strictObject({
   config,
   secrets: secrets.default({}),
-  dryRun: z52.boolean().optional(),
-  actionId
+  dryRun: z51.boolean().optional(),
+  actionId: actionId2
 }))();
-var connectionAuthorizeInputSchema = /* @__PURE__ */ (() => z52.strictObject({
+var connectionAuthorizeInputSchema = /* @__PURE__ */ (() => z51.strictObject({
   config: config.default({}),
-  returnTo: z52.string().url().max(2048).optional(),
-  actionId
+  returnTo: z51.string().url().max(2048).optional(),
+  actionId: actionId2
 }))();
-var connectionAuthorizationSchema = /* @__PURE__ */ (() => z52.object({
-  authorizationUrl: z52.string().url(),
-  expiresAt: z52.number()
+var connectionAuthorizationSchema = /* @__PURE__ */ (() => z51.object({
+  authorizationUrl: z51.string().url(),
+  expiresAt: z51.number()
 }))();
-var connectionAuthorizationCompleteInputSchema = /* @__PURE__ */ (() => z52.strictObject({
-  code: z52.string().min(1).max(200)
+var connectionAuthorizationCompleteInputSchema = /* @__PURE__ */ (() => z51.strictObject({
+  code: z51.string().min(1).max(200)
 }))();
-var connectionUpdateInputSchema = /* @__PURE__ */ (() => z52.strictObject({
+var connectionUpdateInputSchema = /* @__PURE__ */ (() => z51.strictObject({
   config: config.optional(),
   secrets: secrets.optional(),
-  expectedRevision: z52.number().int().nonnegative().optional(),
-  actionId
+  expectedRevision: z51.number().int().nonnegative().optional(),
+  actionId: actionId2
 }).refine(
   (input) => input.config !== void 0 || Object.keys(input.secrets ?? {}).length,
   { message: "Change the config, a secret, or both" }
 ))();
-var connectionDisconnectInputSchema = /* @__PURE__ */ (() => z52.strictObject({
-  expectedRevision: z52.number().int().nonnegative().optional(),
-  actionId
+var connectionDisconnectInputSchema = /* @__PURE__ */ (() => z51.strictObject({
+  expectedRevision: z51.number().int().nonnegative().optional(),
+  actionId: actionId2
 }))();
 var knownPluginSlots = [
   "connection",
@@ -5394,29 +5434,29 @@ var knownPluginSlots = [
   "evaluator-capability",
   "identity"
 ];
-var pluginSlotSchema = /* @__PURE__ */ (() => z52.string().min(1))();
-var pluginSchema = /* @__PURE__ */ (() => z52.object({
-  id: z52.string(),
-  name: z52.string(),
-  slots: z52.array(pluginSlotSchema),
-  configSchema: z52.record(z52.string(), z52.unknown()),
-  secrets: z52.array(
-    z52.object({
-      name: z52.string(),
-      label: z52.string(),
-      help: z52.string().nullable()
+var pluginSlotSchema = /* @__PURE__ */ (() => z51.string().min(1))();
+var pluginSchema = /* @__PURE__ */ (() => z51.object({
+  id: z51.string(),
+  name: z51.string(),
+  slots: z51.array(pluginSlotSchema),
+  configSchema: z51.record(z51.string(), z51.unknown()),
+  secrets: z51.array(
+    z51.object({
+      name: z51.string(),
+      label: z51.string(),
+      help: z51.string().nullable()
     })
   ),
-  events: z52.array(z52.string()),
+  events: z51.array(z51.string()),
   // A Relay from before OAuth connections answers none.
-  oauth: z52.object({ configured: z52.boolean(), scopes: z52.array(z52.string()) }).nullable().default(null),
-  console: z52.object({ component: z52.string() }).nullable().default(null),
+  oauth: z51.object({ configured: z51.boolean(), scopes: z51.array(z51.string()) }).nullable().default(null),
+  console: z51.object({ component: z51.string() }).nullable().default(null),
   // A Relay from before dry runs answers none.
-  dryRun: z52.boolean().default(false)
+  dryRun: z51.boolean().default(false)
 }))();
-var pluginPageSchema = /* @__PURE__ */ (() => z52.object({
-  items: z52.array(pluginSchema),
-  nextCursor: z52.string().nullable()
+var pluginPageSchema = /* @__PURE__ */ (() => z51.object({
+  items: z51.array(pluginSchema),
+  nextCursor: z51.string().nullable()
 }))();
 var knownConnectionSyncKinds = ["connect", "resync"];
 var knownConnectionSyncStatuses = [
@@ -5424,53 +5464,53 @@ var knownConnectionSyncStatuses = [
   "finished",
   "failed"
 ];
-var connectionSyncSchema = /* @__PURE__ */ (() => z52.object({
-  kind: z52.string().min(1),
-  status: z52.string().min(1),
-  done: z52.number().int().nonnegative(),
-  total: z52.number().int().nonnegative().nullable(),
-  startedAt: z52.number(),
-  finishedAt: z52.number().nullable()
-}))();
-var connectionActivitySchema = /* @__PURE__ */ (() => z52.object({
-  plugin: z52.string(),
-  environment: z52.enum(["test", "live"]),
+var connectionSyncSchema = /* @__PURE__ */ (() => z51.object({
+  kind: z51.string().min(1),
+  status: z51.string().min(1),
+  done: z51.number().int().nonnegative(),
+  total: z51.number().int().nonnegative().nullable(),
+  startedAt: z51.number(),
+  finishedAt: z51.number().nullable()
+}))();
+var connectionActivitySchema = /* @__PURE__ */ (() => z51.object({
+  plugin: z51.string(),
+  environment: z51.enum(["test", "live"]),
   status: connectionStatusSchema,
-  dryRun: z52.boolean(),
-  lastSyncAt: z52.number().nullable(),
-  failingSince: z52.number().nullable(),
-  consecutiveFailures: z52.number().int().nonnegative(),
-  members: z52.object({
-    synced: z52.number().int().nonnegative(),
-    skipped: z52.array(
-      z52.object({
-        reason: z52.string(),
-        members: z52.number().int().nonnegative()
+  dryRun: z51.boolean(),
+  lastSyncAt: z51.number().nullable(),
+  failingSince: z51.number().nullable(),
+  consecutiveFailures: z51.number().int().nonnegative(),
+  members: z51.object({
+    synced: z51.number().int().nonnegative(),
+    skipped: z51.array(
+      z51.object({
+        reason: z51.string(),
+        members: z51.number().int().nonnegative()
       })
     )
   }),
   sync: connectionSyncSchema.nullable(),
-  errors: z52.array(
-    z52.object({ at: z52.number(), kind: z52.string(), message: z52.string() })
+  errors: z51.array(
+    z51.object({ at: z51.number(), kind: z51.string(), message: z51.string() })
   )
 }))();
-var connectionDryRunRequestSchema = /* @__PURE__ */ (() => z52.object({
-  id: z52.string(),
-  at: z52.number(),
-  member: z52.string().nullable(),
-  method: z52.string(),
-  path: z52.string(),
-  body: z52.unknown()
+var connectionDryRunRequestSchema = /* @__PURE__ */ (() => z51.object({
+  id: z51.string(),
+  at: z51.number(),
+  member: z51.string().nullable(),
+  method: z51.string(),
+  path: z51.string(),
+  body: z51.unknown()
 }))();
-var connectionDryRunPageSchema = /* @__PURE__ */ (() => z52.object({
-  items: z52.array(connectionDryRunRequestSchema),
-  nextCursor: z52.string().nullable()
+var connectionDryRunPageSchema = /* @__PURE__ */ (() => z51.object({
+  items: z51.array(connectionDryRunRequestSchema),
+  nextCursor: z51.string().nullable()
 }))();
-var connectionDryRunQuerySchema = /* @__PURE__ */ (() => z52.strictObject({
-  cursor: z52.string().min(1).max(40).optional(),
-  limit: z52.number().int().min(1).max(100).optional()
+var connectionDryRunQuerySchema = /* @__PURE__ */ (() => z51.strictObject({
+  cursor: z51.string().min(1).max(40).optional(),
+  limit: z51.number().int().min(1).max(100).optional()
 }))();
-var connectionResyncInputSchema = /* @__PURE__ */ (() => z52.strictObject({ actionId }))();
+var connectionResyncInputSchema = /* @__PURE__ */ (() => z51.strictObject({ actionId: actionId2 }))();
 
 // src/server/client/connections.ts
 function connectionPath(plugin) {
@@ -5652,7 +5692,7 @@ function schedules({ request, get, post }) {
 var schedulesApi = (http) => schedules(http);
 
 // src/server/client/storage.ts
-import * as z53 from "zod";
+import * as z52 from "zod";
 function storage({ get, post, raw }) {
   function clear(kind, name, input, call) {
     const path = `/storage/${kind}/${appSecretNameSchema.parse(name)}/clear`;
@@ -5696,7 +5736,7 @@ function storage({ get, post, raw }) {
       `/storage/sql/${appSecretNameSchema.parse(name)}/cell?${new URLSearchParams(
         {
           table,
-          row: String(z53.number().int().min(0).parse(options.row)),
+          row: String(z52.number().int().min(0).parse(options.row)),
           column: options.column,
           ...options.cursor === void 0 ? {} : { cursor: pageCursorSchema.parse(options.cursor) }
         }
@@ -5715,8 +5755,8 @@ function storage({ get, post, raw }) {
       call
     ),
     /** A KV value's size and, when it is UTF-8 text, a preview. */
-    value: (name, key, call) => get(
-      `/storage/kv/${appSecretNameSchema.parse(name)}/value?${new URLSearchParams({ key })}`,
+    value: (name, key2, call) => get(
+      `/storage/kv/${appSecretNameSchema.parse(name)}/value?${new URLSearchParams({ key: key2 })}`,
       appStorageValueSchema,
       call
     ),
@@ -5811,26 +5851,64 @@ var campaignsApi = (http) => campaigns(http);
 import * as z55 from "zod";
 
 // src/server/quests.ts
-import * as z54 from "zod";
-var questLifecycleInputSchema = /* @__PURE__ */ (() => z54.object({
+import * as z53 from "zod";
+var questLifecycleInputSchema = /* @__PURE__ */ (() => z53.object({
   quest: identifier,
   expectedRelease: identifier.optional(),
-  archived: z54.boolean(),
-  reason: z54.string().trim().min(1).max(500),
+  archived: z53.boolean(),
+  reason: z53.string().trim().min(1).max(500),
   actionId: identifier
 }).strict())();
-var questLifecycleSchema = /* @__PURE__ */ (() => z54.object({
+var questLifecycleSchema = /* @__PURE__ */ (() => z53.object({
   quest: identifier,
   key: identifier.nullable(),
-  title: z54.string(),
+  title: z53.string(),
   release: identifier,
-  lifecycle: z54.enum(["active", "paused", "archived"]),
+  lifecycle: z53.enum(["active", "paused", "archived"]),
+  changed: z53.boolean()
+}))();
+
+// src/server/quest-stations.ts
+import * as z54 from "zod";
+var stationOperationTarget = (quest, station) => `station:${quest}:${station}`;
+var stationRevocationInputSchema = /* @__PURE__ */ (() => z54.object({
+  reason: z54.string().trim().min(1).max(500),
+  actionId: identifier
+}).strict())();
+var stationRevocationSchema = /* @__PURE__ */ (() => z54.object({
+  quest: identifier,
+  station: z54.string(),
+  revoked: z54.boolean(),
+  reason: z54.string().nullable(),
+  actor: z54.string().nullable(),
+  /** When it was last revoked or restored, epoch milliseconds. */
+  changedAt: z54.number().nullable(),
   changed: z54.boolean()
 }))();
+var questStationStateSchema = /* @__PURE__ */ (() => z54.object({
+  key: z54.string(),
+  label: z54.string(),
+  opensAt: z54.number().optional(),
+  closesAt: z54.number().optional(),
+  status: z54.string(),
+  revocation: z54.object({
+    revoked: z54.boolean(),
+    reason: z54.string(),
+    actor: z54.string().nullable(),
+    changedAt: z54.number()
+  }).nullable(),
+  completions: z54.number().int().nonnegative()
+}))();
 
 // src/server/client/quests.ts
 function quests(http) {
   const { get, post } = http;
+  const station = (verb) => (quest, key2, input, call) => post(
+    `/quests/${identifier.parse(quest)}/stations/${encodeURIComponent(key2)}/${verb}`,
+    stationRevocationSchema,
+    stationRevocationInputSchema.parse(withActionId(input)),
+    call
+  );
   return {
     pause: (quest, input, call) => operationVerb(
       http,
@@ -5846,6 +5924,41 @@ function quests(http) {
       input,
       call
     ),
+    /**
+     * A quest's check-in stations.
+     *
+     * @experimental A minor release can change check-in stations.
+     */
+    stations: {
+      /**
+       * Each check-in station of the quest's current release, in its order, with its status now,
+       * its last revoke or restore, and its completions; requires `read`.
+       *
+       * @experimental A minor release can change check-in stations.
+       */
+      list: (quest, call) => get(
+        `/quests/${identifier.parse(quest)}/stations`,
+        z55.array(questStationStateSchema),
+        call
+      ),
+      /**
+       * Revokes a check-in station, such as one whose code leaked, with a reason; requires
+       * `publish`, as pausing a quest does. From then on a transaction naming the station is
+       * refused with `station-revoked`, whenever it was signed. It is an operation: it applies in
+       * this environment at once, and a promotion never changes it. Revoking a revoked station
+       * changes nothing.
+       *
+       * @experimental A minor release can change check-in stations.
+       */
+      revoke: station("revoke"),
+      /**
+       * Restores a revoked check-in station, with a reason; requires `publish`. Restoring a
+       * station that is not revoked changes nothing.
+       *
+       * @experimental A minor release can change check-in stations.
+       */
+      restore: station("restore")
+    },
     /**
      * Each quest's current release, the most recently published first, archived quests
      * included; requires `read` permission.
@@ -5988,6 +6101,31 @@ function x({ get }) {
 }
 var xApi = (http) => x(http);
 
+// src/server/client/solana.ts
+function solana({ post }) {
+  return {
+    /**
+     * Finalized, successful transactions as `ctx.wallet.transactions()` returns them, for a
+     * testing kit's `facts.wallet.transactions`: Relay reads them through its Solana RPC and
+     * decodes the program's instructions with the IDL a `settings.solanaProgram()` setting would
+     * store (or `idl`); requires `read` permission and stores nothing. Each transaction is seen
+     * by `wallet` (the fee payer by default) and must call `program`. Fails with 404
+     * `transaction-not-found` for a signature the cluster has no transaction for, 409
+     * `transaction-not-final` for one not finalized yet, and 422 `transaction-failed` for a
+     * failed one.
+     *
+     * @experimental A minor release can change this method and its result.
+     */
+    transactionFixture: (input, call) => post(
+      "/solana/transaction-fixtures",
+      walletTransactionsSchema,
+      solanaTransactionFixtureInputSchema.parse(input),
+      call
+    )
+  };
+}
+var solanaApi = (http) => solana(http);
+
 // src/server/client/discord.ts
 import * as z56 from "zod";
 function discord({ get, post }) {
@@ -6285,29 +6423,29 @@ function parse(message) {
   }
   const [, scheme, domain, family] = header;
   const address = lines[1] ?? "";
-  let index = 2;
+  let index2 = 2;
   let statement = null;
-  if (index < lines.length) {
-    if (lines[index] !== "") {
+  if (index2 < lines.length) {
+    if (lines[index2] !== "") {
       throw invalid("The address is not followed by an empty line");
     }
-    index++;
-    if (lines[index] === "") {
-      index++;
-    } else if (index < lines.length && !fieldLine.test(lines[index])) {
-      statement = lines[index];
-      index++;
-      if (lines[index] !== "") {
+    index2++;
+    if (lines[index2] === "") {
+      index2++;
+    } else if (index2 < lines.length && !fieldLine.test(lines[index2])) {
+      statement = lines[index2];
+      index2++;
+      if (lines[index2] !== "") {
         throw invalid("The statement is not followed by an empty line");
       }
-      index++;
+      index2++;
     }
   }
   const fields = {};
   const resources2 = [];
   let position = -1;
-  for (; index < lines.length; index++) {
-    const line = lines[index];
+  for (; index2 < lines.length; index2++) {
+    const line = lines[index2];
     const field = fieldLine.exec(line);
     const name = field?.[1];
     const at = name ? fieldOrder.indexOf(name) : -1;
@@ -6319,8 +6457,8 @@ function parse(message) {
       if (field[2] !== void 0) {
         throw invalid("Resources are listed one per line");
       }
-      while (lines[index + 1]?.startsWith("- ")) {
-        resources2.push(lines[++index].slice(2));
+      while (lines[index2 + 1]?.startsWith("- ")) {
+        resources2.push(lines[++index2].slice(2));
       }
     } else if (field[2] === void 0 || field[2] === "") {
       throw invalid(`${name} has no value`);
@@ -6447,40 +6585,336 @@ async function verifyWalletSignIn(input) {
   };
 }
 
-// src/server/development.ts
-import * as z60 from "zod";
-var developmentPreflightSchema = /* @__PURE__ */ (() => z60.object({
-  organization: z60.string(),
-  project: z60.string(),
-  environment: z60.enum(["test", "live"]),
-  identity: z60.object({
-    exchange: z60.literal("supported"),
-    activeIntegrations: z60.number().int().nonnegative()
-  }).optional(),
-  staging: z60.enum(["configured", "blocked"]),
-  development: z60.object({
-    status: z60.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: z60.enum(["tunnel", "direct"]).default("tunnel"),
-    missing: z60.array(z60.string()),
-    authentication: z60.array(z60.string())
-  }),
-  checks: z60.array(
-    z60.object({
-      id: z60.string(),
-      status: z60.enum(["ok", "error"]),
-      message: z60.string(),
-      missing: z60.array(z60.string()).optional(),
-      issues: z60.array(z60.string()).optional()
-    })
-  )
-}))();
+// src/solana-transaction-messages.ts
+var maxSolanaTransactionBytes = 1232;
+var SolanaTransactionShapeError = class extends Error {
+  name = "SolanaTransactionShapeError";
+};
+var refuse2 = (message) => {
+  throw new SolanaTransactionShapeError(message);
+};
+function key(address, what) {
+  return base58Bytes(address, 32) ?? refuse2(`${what} is not a Solana address`);
+}
+function shortVec(value) {
+  const bytes = [];
+  for (let rest = value; ; ) {
+    const byte = rest & 127;
+    rest >>= 7;
+    if (rest === 0) {
+      bytes.push(byte);
+      return bytes;
+    }
+    bytes.push(byte | 128);
+  }
+}
+function reader(bytes) {
+  let offset = 0;
+  const take = (length2) => {
+    if (offset + length2 > bytes.length) {
+      refuse2("The transaction ends early");
+    }
+    const slice = bytes.slice(offset, offset + length2);
+    offset += length2;
+    return slice;
+  };
+  const byte = () => take(1)[0];
+  const length = () => {
+    let value = 0;
+    for (let shift = 0; shift < 21; shift += 7) {
+      const next = byte();
+      value |= (next & 127) << shift;
+      if (!(next & 128)) {
+        return value;
+      }
+    }
+    return refuse2("The transaction has a malformed length");
+  };
+  const list = (item) => Array.from({ length: length() }, () => item());
+  return {
+    take,
+    byte,
+    length,
+    list,
+    rest: () => take(bytes.length - offset),
+    done: () => offset === bytes.length
+  };
+}
+function decodeMessage(bytes) {
+  const read = reader(bytes);
+  const first = bytes[0];
+  let version = "legacy";
+  if (first !== void 0 && first & 128) {
+    if ((first & 127) !== 0) {
+      refuse2(
+        `Version ${first & 127} transactions are not supported: use a legacy or version 0 message`
+      );
+    }
+    read.byte();
+    version = 0;
+  }
+  const header = [
+    read.byte(),
+    read.byte(),
+    read.byte()
+  ];
+  const accounts = read.list(() => read.take(32));
+  const blockhash = read.take(32);
+  const instructions = read.list(() => ({
+    program: read.byte(),
+    accounts: read.list(read.byte),
+    data: read.take(read.length())
+  }));
+  const lookups = version === 0 ? read.list(() => ({
+    table: read.take(32),
+    writable: read.list(read.byte),
+    readonly: read.list(read.byte)
+  })) : [];
+  if (!read.done()) {
+    refuse2("The transaction has bytes after its message");
+  }
+  return { version, header, accounts, blockhash, instructions, lookups };
+}
+function encodeMessage(message) {
+  const indexes = (values) => [...shortVec(values.length), ...values];
+  const bytes = [
+    ...message.version === 0 ? [128] : [],
+    ...message.header,
+    ...shortVec(message.accounts.length),
+    ...message.accounts.flatMap((account2) => [...account2]),
+    ...message.blockhash,
+    ...shortVec(message.instructions.length),
+    ...message.instructions.flatMap((instruction) => [
+      instruction.program,
+      ...indexes(instruction.accounts),
+      ...shortVec(instruction.data.length),
+      ...instruction.data
+    ])
+  ];
+  if (message.version === 0) {
+    bytes.push(...shortVec(message.lookups.length));
+    for (const lookup of message.lookups) {
+      bytes.push(
+        ...lookup.table,
+        ...indexes(lookup.writable),
+        ...indexes(lookup.readonly)
+      );
+    }
+  }
+  return Uint8Array.from(bytes);
+}
+function compileKitMessage(message) {
+  const version = message.version === "legacy" ? "legacy" : message.version === 0 ? 0 : refuse2(
+    `Version ${String(message.version)} transactions are not supported: use a legacy or version 0 message`
+  );
+  const payer = message.feePayer?.address ?? refuse2("Set the transaction message's fee payer");
+  const lifetime = message.lifetimeConstraint;
+  const blockhash = lifetime && "blockhash" in lifetime ? lifetime.blockhash : lifetime && "nonce" in lifetime ? lifetime.nonce : refuse2("Set the transaction message's blockhash or nonce lifetime");
+  const statics = /* @__PURE__ */ new Map([[payer, 3]]);
+  const looked = /* @__PURE__ */ new Map();
+  const add = (address, role) => statics.set(address, (statics.get(address) ?? 0) | role);
+  for (const instruction of message.instructions) {
+    add(instruction.programAddress, 0);
+    for (const account2 of instruction.accounts ?? []) {
+      if (account2.lookupTableAddress === void 0 || account2.role & 2) {
+        add(account2.address, account2.role);
+        continue;
+      }
+      if (version === "legacy") {
+        refuse2("A legacy message can't load accounts from a lookup table");
+      }
+      const known = looked.get(account2.address);
+      looked.set(account2.address, {
+        table: account2.lookupTableAddress,
+        index: account2.addressIndex ?? refuse2("A lookup table account needs its addressIndex"),
+        writable: !!(account2.role & 1) || !!known?.writable
+      });
+    }
+  }
+  for (const [address, entry] of looked) {
+    if (statics.has(address)) {
+      add(address, entry.writable ? 1 : 0);
+      looked.delete(address);
+    }
+  }
+  const rank = (role) => 3 - role;
+  const [first, ...rest] = [...statics];
+  const ordered = [first, ...rest.sort(([, a], [, b]) => rank(a) - rank(b))];
+  const count = (match) => ordered.filter(([, role]) => match(role)).length;
+  const tables = /* @__PURE__ */ new Map();
+  for (const [address, entry] of looked) {
+    const table = tables.get(entry.table) ?? { writable: [], readonly: [] };
+    table[entry.writable ? "writable" : "readonly"].push([address, entry.index]);
+    tables.set(entry.table, table);
+  }
+  const position = new Map(ordered.map(([address], index2) => [address, index2]));
+  let next = ordered.length;
+  for (const kind of ["writable", "readonly"]) {
+    for (const table of tables.values()) {
+      for (const [address] of table[kind]) {
+        position.set(address, next++);
+      }
+    }
+  }
+  if (next > 256) {
+    refuse2("The transaction names more than 256 accounts");
+  }
+  const at = (address) => position.get(address);
+  return {
+    version,
+    header: [
+      count((role) => (role & 2) !== 0),
+      count((role) => role === 2),
+      count((role) => (role & 2) === 0 && (role & 1) === 0)
+    ],
+    accounts: ordered.map(([address]) => key(address, address)),
+    blockhash: key(blockhash, "The transaction's blockhash"),
+    instructions: message.instructions.map((instruction) => ({
+      program: at(instruction.programAddress),
+      accounts: (instruction.accounts ?? []).map(({ address }) => at(address)),
+      data: Uint8Array.from(instruction.data ?? [])
+    })),
+    lookups: [...tables].map(([table, entries]) => ({
+      table: key(table, "A lookup table address"),
+      writable: entries.writable.map(([, index2]) => index2),
+      readonly: entries.readonly.map(([, index2]) => index2)
+    }))
+  };
+}
+function withInstruction(message, program, data) {
+  const programKey = key(program, "The program");
+  const existing = message.accounts.findIndex(
+    (account2) => account2.every((byte, index2) => byte === programKey[index2])
+  );
+  if (existing >= 0) {
+    return {
+      ...message,
+      instructions: [
+        ...message.instructions,
+        { program: existing, accounts: [], data }
+      ]
+    };
+  }
+  const statics = message.accounts.length;
+  const shift = (index2) => index2 >= statics ? index2 + 1 : index2;
+  return {
+    ...message,
+    header: [message.header[0], message.header[1], message.header[2] + 1],
+    accounts: [...message.accounts, programKey],
+    instructions: [
+      ...message.instructions.map((instruction) => ({
+        program: shift(instruction.program),
+        accounts: instruction.accounts.map(shift),
+        data: instruction.data
+      })),
+      { program: statics, accounts: [], data }
+    ]
+  };
+}
+function base64(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
+function fromBase64(value) {
+  let binary;
+  try {
+    binary = atob(value);
+  } catch {
+    return refuse2("The transaction is not base64");
+  }
+  return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+function splitWire(bytes) {
+  const read = reader(bytes);
+  const signatures = read.list(() => read.take(64));
+  return { signatures, message: read.rest() };
+}
+var isBytes = (value) => value instanceof Uint8Array;
+function messageOf(transaction2) {
+  if (typeof transaction2 === "string" || isBytes(transaction2)) {
+    const wire = typeof transaction2 === "string" ? fromBase64(transaction2) : Uint8Array.from(transaction2);
+    const { signatures, message } = splitWire(wire);
+    const decoded = decodeMessage(message);
+    if (signatures.length !== decoded.header[0]) {
+      refuse2(
+        `The transaction has ${signatures.length} signatures where its message needs ${decoded.header[0]}`
+      );
+    }
+    return {
+      message: decoded,
+      signed: signatures.some((signature) => signature.some(Boolean))
+    };
+  }
+  if ("messageBytes" in transaction2) {
+    return {
+      message: decodeMessage(Uint8Array.from(transaction2.messageBytes)),
+      signed: Object.values(transaction2.signatures).some(
+        (signature) => signature !== null && signature.some(Boolean)
+      )
+    };
+  }
+  if (Array.isArray(transaction2.instructions)) {
+    return { message: compileKitMessage(transaction2), signed: false };
+  }
+  return refuse2(
+    "Return a @solana/kit transaction message, a compiled transaction, or the transaction's bytes"
+  );
+}
+function appendSolanaInstruction(transaction2, program, data) {
+  const { message, signed } = messageOf(transaction2);
+  if (signed) {
+    refuse2(
+      "The transaction is already signed, and Domino's memo would void the signature: return it unsigned"
+    );
+  }
+  if (!message.instructions.length) {
+    refuse2("The transaction has no instructions");
+  }
+  const bytes = encodeMessage(withInstruction(message, program, data));
+  const signatures = message.header[0];
+  const wire = Uint8Array.from([
+    ...shortVec(signatures),
+    ...new Uint8Array(signatures * 64),
+    ...bytes
+  ]);
+  if (wire.length > maxSolanaTransactionBytes) {
+    refuse2(
+      `The transaction takes ${wire.length} bytes with Domino's memo, more than Solana's ${maxSolanaTransactionBytes}`
+    );
+  }
+  return base64(wire);
+}
+function decodeSolanaTransaction(transaction2) {
+  const { signatures, message } = splitWire(fromBase64(transaction2));
+  const decoded = decodeMessage(message);
+  const loaded = ["writable", "readonly"].flatMap(
+    (kind) => decoded.lookups.flatMap(
+      ({ table, ...indexes }) => indexes[kind].map((index2) => `${base58(table)}#${index2}`)
+    )
+  );
+  const names = [...decoded.accounts.map(base58), ...loaded];
+  return {
+    version: decoded.version,
+    signatures: signatures.length,
+    feePayer: names[0],
+    blockhash: base58(decoded.blockhash),
+    instructions: decoded.instructions.map(
+      (instruction) => ({
+        program: names[instruction.program],
+        accounts: instruction.accounts.map((index2) => names[index2]),
+        data: instruction.data
+      })
+    )
+  };
+}
 
 // src/server/hosted.ts
-import * as z61 from "zod";
+import * as z60 from "zod";
 var hostedKeyPermissions = ["read", "points", "ingest"];
-var hostedKeyPermissionList = /* @__PURE__ */ (() => z61.array(z61.string()).transform(
+var hostedKeyPermissionList = /* @__PURE__ */ (() => z60.array(z60.string()).transform(
   (values) => values.filter(
     (value) => hostedKeyPermissions.includes(value)
   )
@@ -6492,17 +6926,17 @@ var hostedManagementBindings = [
   "DOMINO_PROJECT",
   "DOMINO_ENVIRONMENT"
 ];
-var hostedKeySecretSchema = /* @__PURE__ */ (() => z61.string().regex(/^dhk_[A-Za-z0-9_-]{43}$/, "Expected a hosted app key"))();
-var hostedKeySchema = /* @__PURE__ */ (() => z61.object({
-  id: z61.string().uuid(),
+var hostedKeySecretSchema = /* @__PURE__ */ (() => z60.string().regex(/^dhk_[A-Za-z0-9_-]{43}$/, "Expected a hosted app key"))();
+var hostedKeySchema = /* @__PURE__ */ (() => z60.object({
+  id: z60.string().uuid(),
   token: hostedKeySecretSchema,
   organization: identifier,
   project: identifier,
-  environment: z61.enum(["test", "live"]),
+  environment: z60.enum(["test", "live"]),
   permissions: hostedKeyPermissionList,
-  expiresAt: z61.number().nullable()
+  expiresAt: z60.number().nullable()
 }).strict())();
-var hostedDeploymentKeySchema = /* @__PURE__ */ (() => hostedKeySchema.extend({ apiUrl: z61.string().url() }).strict())();
+var hostedDeploymentKeySchema = /* @__PURE__ */ (() => hostedKeySchema.extend({ apiUrl: z60.string().url() }).strict())();
 function hostedManagementClient(env) {
   const missing = hostedManagementBindings.filter((name) => !env[name]);
   if (missing.length) {
@@ -6510,7 +6944,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 = z61.enum(["test", "live"]).parse(env.DOMINO_ENVIRONMENT);
+  const environment = z60.enum(["test", "live"]).parse(env.DOMINO_ENVIRONMENT);
   const token = env.DOMINO_MANAGEMENT_KEY;
   return createManagementClient({
     baseUrl: env.DOMINO_API_URL.replace(/\/+$/, ""),
@@ -6521,6 +6955,690 @@ function hostedManagementClient(env) {
   });
 }
 
+// src/server/quest-actions.ts
+var solanaActionVersion = "2.4";
+var step = "domino-step";
+var maxBody = 16 * 1024;
+var metadataTtl = 6e4;
+var defaultConfirmTimeout = 45e3;
+var pollInterval = 1500;
+var refusalBrand = /* @__PURE__ */ (() => /* @__PURE__ */ Symbol.for("@domino-sdk/relay.QuestActionRefusal"))();
+var QuestActionRefusal = class extends Error {
+  constructor(message, status = 422) {
+    super(message);
+    this.status = status;
+  }
+  status;
+  name = "QuestActionRefusal";
+  [refusalBrand] = true;
+};
+function isRefusal(value) {
+  return value instanceof Error && value[refusalBrand] === true;
+}
+function solanaActionHeaders(chain) {
+  return new Headers({
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET,POST,PUT,OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, Authorization, Content-Encoding, Accept-Encoding, X-Accept-Action-Version, X-Accept-Blockchain-Ids",
+    "Access-Control-Expose-Headers": "X-Action-Version, X-Blockchain-Ids",
+    "X-Action-Version": solanaActionVersion,
+    "X-Blockchain-Ids": chain
+  });
+}
+function json2(chain, body, status = 200) {
+  const headers = solanaActionHeaders(chain);
+  headers.set("Content-Type", "application/json");
+  return new Response(JSON.stringify(body), { status, headers });
+}
+var failure = (chain, message, status) => json2(chain, { message }, status);
+async function readBody(request) {
+  const text = request.body ? await boundedBodyText(request.body, maxBody) : "";
+  if (text === null) {
+    return null;
+  }
+  if (!text.trim()) {
+    return {};
+  }
+  try {
+    const value = JSON.parse(text);
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function stepHref(request, value, extra = {}) {
+  const url = new URL(request.url);
+  url.searchParams.set(step, value);
+  for (const [name, item] of Object.entries(extra)) {
+    url.searchParams.set(name, item);
+  }
+  return url.pathname + url.search;
+}
+var wait = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+function defineQuestAction(options) {
+  const chain = solanaTransactionSubmissionSchema.shape.chain.parse(options.chain);
+  const confirmTimeout = options.confirmTimeout ?? defaultConfirmTimeout;
+  const { clientFor, cardFor } = questActionContext(options);
+  return async function questAction(request, env) {
+    if (request.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: solanaActionHeaders(chain)
+      });
+    }
+    if (request.method !== "GET" && request.method !== "POST") {
+      return failure(chain, `${request.method} is not an action method`, 405);
+    }
+    try {
+      const client = clientFor(env);
+      const card = await cardFor(client, request);
+      if (request.method === "GET") {
+        return json2(chain, actionCard(card, options.metadata, request));
+      }
+      const body = await readBody(request);
+      if (!body) {
+        return failure(chain, "Send a JSON body of at most 16 KB", 400);
+      }
+      const url = new URL(request.url);
+      switch (url.searchParams.get(step)) {
+        case null:
+          return await transaction(chain, card, options, request, url, body);
+        case "complete":
+          return await complete(
+            chain,
+            client,
+            card,
+            options,
+            request,
+            confirmTimeout,
+            body
+          );
+        case "link":
+          return json2(chain, {
+            type: "external-link",
+            externalLink: new URL(options.linkUrl, request.url).href
+          });
+        case "recheck":
+          return json2(chain, {
+            type: "post",
+            links: {
+              next: {
+                type: "post",
+                href: stepHref(request, "complete")
+              }
+            }
+          });
+        default:
+          return failure(chain, "Unknown action step", 400);
+      }
+    } catch (error) {
+      return questActionError(chain, error);
+    }
+  };
+}
+function questActionContext(options) {
+  let cached;
+  let hosted;
+  const clientFor = (env) => {
+    if (options.management) {
+      return options.management;
+    }
+    const source = options.env ?? (env && typeof env === "object" && hostedManagementBindings.some((name) => name in env) ? env : globalThis.process?.env ?? {});
+    const bindings = JSON.stringify(
+      hostedManagementBindings.map((name) => source[name] ?? null)
+    );
+    if (hosted?.bindings !== bindings) {
+      hosted = { bindings, client: hostedManagementClient(source) };
+    }
+    return hosted.client;
+  };
+  const cardFor = (client, request) => {
+    const now = Date.now();
+    if (!cached || cached.client !== client || now - cached.at > metadataTtl) {
+      const card = questCard(client, options.quest, request);
+      cached = { at: now, client, card };
+      card.catch(() => {
+        if (cached?.card === card) {
+          cached = void 0;
+        }
+      });
+    }
+    return cached.card;
+  };
+  return { clientFor, cardFor };
+}
+function questActionError(chain, error) {
+  if (isRefusal(error)) {
+    return failure(chain, error.message, error.status);
+  }
+  if (isManagementError(error)) {
+    return failure(
+      chain,
+      error.status === void 0 || error.status >= 500 ? "Domino could not be reached. Try again in a minute." : `Domino refused the app's request: ${error.message}`,
+      502
+    );
+  }
+  console.error(error);
+  return failure(chain, "The action failed. Try again in a minute.", 500);
+}
+async function questCard(client, quest, request) {
+  const [releases2, operations2] = await Promise.all([
+    client.quests.listWithoutCode(),
+    client.operations.list()
+  ]);
+  const release = releases2.find(
+    (item) => item.quest === quest || item.key === quest
+  );
+  if (!release) {
+    throw new QuestActionRefusal(
+      `Quest ${quest} does not exist in this project`,
+      404
+    );
+  }
+  return {
+    id: release.quest,
+    key: release.key ?? null,
+    title: release.title,
+    description: release.presentation.instructions ?? "",
+    image: release.presentation.image ? new URL(release.presentation.image, request.url).href : null,
+    closed: release.lifecycle === "archived" ? "This quest has ended." : release.lifecycle === "paused" || operations2.some(
+      (item) => item.target === `quest:${release.quest}` && item.paused
+    ) ? "This quest is paused." : takesSolanaTransaction(release.trigger) ? null : "This quest can't be completed from a wallet transaction.",
+    stations: release.stations ?? null,
+    revoked: new Set(
+      (release.stations ?? []).flatMap(
+        (station) => operations2.some(
+          (item) => item.target === stationOperationTarget(release.quest, station.key) && item.paused
+        ) ? [station.key] : []
+      )
+    )
+  };
+}
+function questIcon(card, icon, request, option) {
+  const url = icon ? new URL(icon, request.url).href : card.image;
+  if (!url) {
+    throw new QuestActionRefusal(
+      `The quest has no image: give it one, or set ${option}`,
+      500
+    );
+  }
+  return url;
+}
+function memberAccount(body) {
+  const account2 = body.account;
+  if (typeof account2 !== "string" || !base58Bytes(account2, 32)) {
+    throw new QuestActionRefusal("Send the wallet's address as account", 400);
+  }
+  return account2;
+}
+function actionCard(card, metadata = {}, request) {
+  return {
+    type: "action",
+    icon: questIcon(card, metadata.icon, request, "metadata.icon"),
+    title: metadata.title ?? card.title,
+    description: metadata.description ?? card.description,
+    label: metadata.label ?? "Complete quest",
+    ...card.closed ? { disabled: true, error: { message: card.closed } } : {},
+    ...metadata.actions?.length ? {
+      links: {
+        actions: metadata.actions.map((action) => ({
+          type: "transaction",
+          ...action
+        }))
+      }
+    } : {}
+  };
+}
+function paramsOf(url, body) {
+  const params = {};
+  for (const [name, value] of url.searchParams) {
+    if (name !== step) {
+      params[name] = value;
+    }
+  }
+  const data = body.data;
+  if (data && typeof data === "object" && !Array.isArray(data)) {
+    for (const [name, value] of Object.entries(data)) {
+      if (typeof value === "string" || Array.isArray(value) && value.every((item) => typeof item === "string")) {
+        params[name] = value;
+      }
+    }
+  }
+  return params;
+}
+function questMemo(card, reference) {
+  try {
+    return solanaActionMemo({ quest: card.key ?? card.id, reference });
+  } catch {
+    throw new QuestActionRefusal(
+      `The reference must be 1 to ${maxSolanaActionReference} letters, digits, _ or -`,
+      400
+    );
+  }
+}
+function withQuestMemo(built, memo) {
+  let serialized;
+  try {
+    serialized = appendSolanaInstruction(
+      built,
+      solanaMemoProgram,
+      new TextEncoder().encode(memo)
+    );
+  } catch (error) {
+    if (error instanceof SolanaTransactionShapeError) {
+      throw new QuestActionRefusal(error.message, 500);
+    }
+    throw error;
+  }
+  const instructions = decodeSolanaTransaction(serialized).instructions;
+  if (instructions.slice(0, -1).some(
+    ({ program, data }) => program === solanaMemoProgram && parseSolanaActionMemo(new TextDecoder().decode(data)) !== null
+  )) {
+    throw new QuestActionRefusal(
+      "The transaction already carries a Domino quest memo: return it without one, and the helper adds it",
+      500
+    );
+  }
+  return serialized;
+}
+async function transaction(chain, card, options, request, url, body) {
+  const account2 = memberAccount(body);
+  if (card.closed) {
+    return failure(chain, card.closed, 422);
+  }
+  const reference = await options.reference?.(request) ?? void 0;
+  const memo = questMemo(card, reference);
+  const built = await options.build({
+    account: account2,
+    params: paramsOf(url, body),
+    quest: { id: card.id, key: card.key, title: card.title },
+    request
+  });
+  const serialized = withQuestMemo(built, memo);
+  return json2(chain, {
+    type: "transaction",
+    transaction: serialized,
+    message: options.metadata?.message ?? `Completes "${card.title}"`,
+    links: {
+      next: { type: "post", href: stepHref(request, "complete") }
+    }
+  });
+}
+var passingRefusals = [
+  "transaction-not-final",
+  "attempt-pending",
+  "conflict",
+  "unavailable"
+];
+async function submitQuestTransaction(client, input, deadline, retried = passingRefusals) {
+  for (; ; ) {
+    try {
+      return {
+        attempt: await client.attempts.submitSolanaTransaction(input, {
+          timeout: Math.max(deadline - Date.now(), 5e3)
+        })
+      };
+    } catch (error) {
+      if (!isManagementError(error) || error.status === void 0 || !error.code || !retried.includes(error.code)) {
+        throw error;
+      }
+      const pause = Math.min(Math.max(error.retryAfter ?? 2e3, 500), 5e3);
+      if (deadline - Date.now() <= pause) {
+        return { waiting: error };
+      }
+      await wait(pause);
+    }
+  }
+}
+async function complete(chain, client, card, options, request, confirmTimeout, body) {
+  const signature = solanaSignatureSchema.safeParse(
+    body.signature ?? new URL(request.url).searchParams.get("signature")
+  );
+  if (!signature.success) {
+    return failure(chain, "Send the transaction's signature", 400);
+  }
+  const shown = actionCard(card, options.metadata, request);
+  const done = (label, description) => ({
+    type: "completed",
+    icon: shown.icon,
+    title: shown.title,
+    label,
+    description
+  });
+  const deadline = Date.now() + confirmTimeout;
+  const left = () => deadline - Date.now();
+  const later = done(
+    "Confirming on Solana",
+    "Confirming on Solana: check the quest in the app in a minute."
+  );
+  let attempt;
+  try {
+    const submitted = await submitQuestTransaction(
+      client,
+      { quest: card.id, signature: signature.data, chain },
+      deadline
+    );
+    if ("waiting" in submitted) {
+      return json2(
+        chain,
+        submitted.waiting.code === "transaction-not-final" ? later : submitted.waiting.code === "attempt-pending" ? done(
+          "Still checking",
+          "Your previous try on this quest is still being checked: check the quest in the app in a minute."
+        ) : done("Try again", "Domino is busy. Try again in a minute.")
+      );
+    }
+    attempt = submitted.attempt;
+  } catch (error) {
+    if (!isManagementError(error) || error.status === void 0) {
+      throw error;
+    }
+    if (error.code === "wallet-not-linked") {
+      return json2(chain, {
+        ...shown,
+        label: "Link your wallet",
+        description: "This wallet is not linked to a member yet. Link it in the app, then check again.",
+        disabled: false,
+        error: { message: "Wallet not linked" },
+        links: {
+          actions: [
+            {
+              type: "external-link",
+              href: stepHref(request, "link"),
+              label: "Link your wallet"
+            },
+            {
+              type: "post",
+              href: stepHref(request, "recheck", {
+                signature: signature.data
+              }),
+              label: "Check again"
+            }
+          ]
+        }
+      });
+    }
+    if (error.status >= 400 && error.status < 500) {
+      return json2(chain, done("Not completed", error.message));
+    }
+    throw error;
+  }
+  for (; ; ) {
+    switch (attempt.status) {
+      case "accepted": {
+        const managed = await client.attempts.get(attempt.id);
+        const rewards = managed.attempt.reviewRewards ?? managed.release?.rewards ?? [];
+        const points3 = rewards.reduce(
+          (sum, reward) => sum + (reward.kind === "points" ? reward.amount : 0),
+          0
+        );
+        return json2(
+          chain,
+          done(
+            points3 ? `+${points3} points` : "Quest complete",
+            `You completed "${card.title}".`
+          )
+        );
+      }
+      case "rejected":
+        return json2(
+          chain,
+          done(
+            "Not completed",
+            attempt.reason ?? "The quest's check did not pass."
+          )
+        );
+      case "progressed":
+        return json2(
+          chain,
+          done("Progress saved", attempt.reason ?? "Your progress is saved.")
+        );
+      case "needs-review":
+        return json2(
+          chain,
+          done(
+            "Submitted for review",
+            "A reviewer checks it: see the quest in the app."
+          )
+        );
+      case "failed":
+        return json2(
+          chain,
+          done(
+            "Couldn't check",
+            attempt.reason ?? "Domino could not check the quest. Try it in the app."
+          )
+        );
+    }
+    if (left() <= pollInterval) {
+      return json2(
+        chain,
+        done("Submitted", "Submitted: check the quest in the app in a minute.")
+      );
+    }
+    await wait(pollInterval);
+    attempt = (await client.attempts.get(attempt.id)).attempt;
+  }
+}
+function actionsJson(rules = [
+  { pathPattern: "/api/actions/**", apiPath: "/api/actions/**" }
+], chain = "solana") {
+  const network = solanaTransactionSubmissionSchema.shape.chain.parse(chain);
+  return async (request) => request.method === "OPTIONS" ? new Response(null, {
+    status: 204,
+    headers: solanaActionHeaders(network)
+  }) : request.method === "GET" || request.method === "HEAD" ? json2(network, { rules }) : failure(network, `${request.method} is not allowed`, 405);
+}
+
+// src/server/station-actions.ts
+var systemProgram = "11111111111111111111111111111111";
+var zeroTransfer = /* @__PURE__ */ (() => Uint8Array.of(2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))();
+var defaultFindTimeout = 9e4;
+var findInterval = 2e3;
+var submitTimeout = 6e4;
+var workerBudget = 28e3;
+function defineStationAction(options) {
+  const chain = solanaTransactionSubmissionSchema.shape.chain.parse(options.chain);
+  const findTimeout = options.findTimeout ?? defaultFindTimeout;
+  const { clientFor, cardFor } = questActionContext(options);
+  return async function stationAction(request, env, context) {
+    if (request.method === "OPTIONS") {
+      return new Response(null, {
+        status: 204,
+        headers: solanaActionHeaders(chain)
+      });
+    }
+    if (request.method !== "GET" && request.method !== "POST") {
+      return failure(
+        chain,
+        `${request.method} is not a transaction request method`,
+        405
+      );
+    }
+    try {
+      const client = clientFor(env);
+      const card = await cardFor(client, request);
+      const station = openStation(card, request);
+      if (request.method === "GET") {
+        return json2(chain, {
+          label: options.label ?? card.title,
+          icon: questIcon(card, options.icon, request, "the icon option")
+        });
+      }
+      const body = await readBody(request);
+      if (!body) {
+        return failure(chain, "Send a JSON body of at most 16 KB", 400);
+      }
+      const account2 = memberAccount(body);
+      if (card.closed) {
+        return failure(chain, card.closed, 422);
+      }
+      const memo = questMemo(card, station.key);
+      const own = await options.instructions?.({
+        account: account2,
+        station,
+        quest: { id: card.id, key: card.key, title: card.title },
+        request
+      }) ?? [];
+      const { value } = await solanaRpc(
+        options.rpcUrl,
+        "getLatestBlockhash",
+        [{ commitment: "confirmed" }]
+      );
+      const reference = base58(crypto.getRandomValues(new Uint8Array(32)));
+      const message = {
+        // Legacy, which every wallet that takes transaction requests reads.
+        version: "legacy",
+        feePayer: { address: account2 },
+        lifetimeConstraint: { blockhash: value.blockhash },
+        instructions: [...own, referenceTransfer(account2, reference)]
+      };
+      const transaction2 = withQuestMemo(message, memo);
+      const worker = !options.waitUntil && context?.waitUntil !== void 0;
+      const now = Date.now();
+      const task = findAndSubmit(client, card, chain, {
+        rpcUrl: options.rpcUrl,
+        reference,
+        deadline: now + findTimeout,
+        stopAt: worker ? now + workerBudget : Infinity
+      });
+      const keep = options.waitUntil ?? context?.waitUntil?.bind(context);
+      keep?.(task);
+      return json2(chain, {
+        transaction: transaction2,
+        message: `Checks you in at ${station.label} for "${card.title}". Wallet not linked yet? Sign in at ${new URL(options.linkUrl, request.url).href} first.`
+      });
+    } catch (error) {
+      return questActionError(chain, error);
+    }
+  };
+}
+function openStation(card, request) {
+  const key2 = new URL(request.url).searchParams.get("station");
+  if (!card.stations) {
+    throw new QuestActionRefusal(
+      `"${card.title}" has no check-in stations`,
+      422
+    );
+  }
+  if (!key2) {
+    throw new QuestActionRefusal(
+      "Name the station in the URL, as ?station=<key>",
+      400
+    );
+  }
+  const refusal = stationRefusal(card.stations, key2, Date.now());
+  if (refusal?.code === "station-unknown") {
+    throw new QuestActionRefusal(`"${card.title}" has no station "${key2}"`, 404);
+  }
+  const station = card.stations.find((item) => item.key === key2);
+  if (refusal) {
+    throw new QuestActionRefusal(`${station.label} is closed`, 409);
+  }
+  if (card.revoked.has(station.key)) {
+    throw new QuestActionRefusal(
+      `${station.label} no longer takes check-ins`,
+      409
+    );
+  }
+  return station;
+}
+function referenceTransfer(account2, reference) {
+  return {
+    programAddress: systemProgram,
+    accounts: [
+      { address: account2, role: 3 },
+      { address: account2, role: 1 },
+      { address: reference, role: 0 }
+    ],
+    data: zeroTransfer
+  };
+}
+async function findAndSubmit(client, card, chain, find) {
+  const deadline = Math.min(find.deadline, find.stopAt);
+  let found;
+  let lastError;
+  try {
+    while (!found && Date.now() < deadline) {
+      try {
+        ;
+        [found] = await solanaRpc(
+          find.rpcUrl,
+          "getSignaturesForAddress",
+          [find.reference, { commitment: "confirmed", limit: 1 }]
+        );
+      } catch (error) {
+        lastError = error;
+      }
+      if (!found) {
+        await wait(Math.min(findInterval, deadline - Date.now()));
+      }
+    }
+    if (!found) {
+      if (lastError) {
+        console.error(
+          "Station check-in: the reference lookup failed",
+          lastError
+        );
+      }
+      return;
+    }
+    if (found.err) {
+      console.error(
+        `Station check-in: transaction ${found.signature} failed on chain`,
+        found.err
+      );
+      return;
+    }
+    const submitted = await submitQuestTransaction(
+      client,
+      { quest: card.id, signature: found.signature, chain },
+      Math.min(Date.now() + submitTimeout, find.stopAt),
+      passingRefusals
+    );
+    if ("waiting" in submitted) {
+      console.error(
+        `Station check-in: Domino did not take transaction ${found.signature} in time`,
+        submitted.waiting
+      );
+    }
+  } catch (error) {
+    console.error(
+      `Station check-in: submitting ${found?.signature ?? "the transaction"} failed`,
+      error
+    );
+  }
+}
+
+// src/server/development.ts
+import * as z61 from "zod";
+var developmentPreflightSchema = /* @__PURE__ */ (() => z61.object({
+  organization: z61.string(),
+  project: z61.string(),
+  environment: z61.enum(["test", "live"]),
+  identity: z61.object({
+    exchange: z61.literal("supported"),
+    activeIntegrations: z61.number().int().nonnegative()
+  }).optional(),
+  staging: z61.enum(["configured", "blocked"]),
+  development: z61.object({
+    status: z61.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: z61.enum(["tunnel", "direct"]).default("tunnel"),
+    missing: z61.array(z61.string()),
+    authentication: z61.array(z61.string())
+  }),
+  checks: z61.array(
+    z61.object({
+      id: z61.string(),
+      status: z61.enum(["ok", "error"]),
+      message: z61.string(),
+      missing: z61.array(z61.string()).optional(),
+      issues: z61.array(z61.string()).optional()
+    })
+  )
+}))();
+
 // src/server/index.ts
 function clientFailure(error) {
   if (error instanceof ManagementError) {
@@ -6535,8 +7653,8 @@ function clientFailure(error) {
 }
 function guarded(api) {
   return Object.fromEntries(
-    Object.entries(api).map(([key, value]) => [
-      key,
+    Object.entries(api).map(([key2, value]) => [
+      key2,
       typeof value === "function" ? (...args) => {
         try {
           return Promise.resolve(value(...args)).catch((error) => {
@@ -6832,6 +7950,8 @@ function managementClient(options) {
     quests: questsApi(http),
     /** Public X data the project's configuration refers to by ID. */
     x: xApi(http),
+    /** Solana reads for quest development. */
+    solana: solanaApi(http),
     /**
      * This project and environment's Discord connection. An organization administrator installs
      * Domino's bot into a new server in Console; once one project of the organization connects a
@@ -6917,6 +8037,8 @@ var managementResponseTables = /* @__PURE__ */ (() => responseTables({
   collectionPreviewSchema: () => collectionPreviewSchema,
   completionRevocationSchema: () => completionRevocationSchema,
   completionRestorationSchema: () => completionRestorationSchema,
+  completionReceiptSchema: () => completionReceiptSchema,
+  completionReceiptListSchema: () => completionReceiptListSchema,
   connectionPageSchema: () => connectionPageSchema,
   connectionSchema: () => connectionSchema,
   connectionAuthorizationSchema: () => connectionAuthorizationSchema,
@@ -6967,6 +8089,7 @@ var managementResponseTables = /* @__PURE__ */ (() => responseTables({
   managedMemberIdentitySchema: () => managedMemberIdentitySchema,
   managedMemberPageSchema: () => managedMemberPageSchema,
   managedMemberProgressSchema: () => managedMemberProgressSchema,
+  memberCompletionPageSchema: () => memberCompletionPageSchema,
   memberConsentHistorySchema: () => memberConsentHistorySchema,
   memberConsentListSchema: () => memberConsentListSchema,
   memberImportPageSchema: () => memberImportPageSchema,
@@ -7047,6 +8170,7 @@ var managementResponseTables = /* @__PURE__ */ (() => responseTables({
   trackerSummarySchema: () => trackerSummarySchema,
   trackerTriggerOutcomePageSchema: () => trackerTriggerOutcomePageSchema,
   walletBalanceChainsSchema: () => walletBalanceChainsSchema,
+  walletTransactionsSchema: () => walletTransactionsSchema,
   webhookDeliveryPageSchema: () => webhookDeliveryPageSchema,
   webhookDeliverySchema: () => webhookDeliverySchema,
   webhookEndpointSchema: () => webhookEndpointSchema,
@@ -7077,6 +8201,7 @@ export {
   MemberImportRefusalCode,
   MemberImportState,
   PayoutSourceKind,
+  QuestActionRefusal,
   REFERRAL_INTEGRATION_REWARD_ERROR2 as REFERRAL_INTEGRATION_REWARD_ERROR,
   RestoredDeliveryOutcome,
   RestoredEntitlementOutcome,
@@ -7091,6 +8216,7 @@ export {
   accessSchema,
   accountProfileSchema,
   accountVouchedBySchema,
+  actionsJson,
   activeMemberMonthSchema,
   activeMemberUsageSchema,
   activityTypeSchema,
@@ -7169,6 +8295,9 @@ export {
   capturedFactSchema,
   commitSchema,
   compareAppMigrations,
+  completionReceiptInputSchema,
+  completionReceiptListSchema,
+  completionReceiptSchema,
   completionRestorationSchema,
   completionRestoreSchema,
   completionRevocationSchema,
@@ -7208,6 +8337,9 @@ export {
   dashboardReadQuerySchema,
   dashboardReadSchema,
   dashboardSummarySchema,
+  decodeSolanaTransaction,
+  defineQuestAction,
+  defineStationAction,
   deploymentActionSchema,
   deploymentRejectionSchema,
   developmentPreflightSchema,
@@ -7308,6 +8440,9 @@ export {
   managementResponseSchemas,
   managementResponses,
   managementStateQuerySchema,
+  maxCompletionReceipts,
+  maxSolanaActionReference,
+  maxSolanaTransactionBytes,
   memberAccountSchema,
   memberAccountUnlinkInputSchema,
   memberAppIdentitySchema,
@@ -7317,6 +8452,9 @@ export {
   memberBanPreviewSchema,
   memberBanRollbackSchema,
   memberBanSchema,
+  memberCompletionPageSchema,
+  memberCompletionQuerySchema,
+  memberCompletionSchema,
   memberCreatorAccountUnlinkInputSchema,
   memberDetailSchema,
   memberErasureDeletedSchema,
@@ -7376,6 +8514,7 @@ export {
   pageSchema,
   parseImageExtraction,
   parseImageResult,
+  parseSolanaActionMemo,
   participantExchangeAccountResultSchema,
   participantExchangeResultSchema,
   participantExchangeSchema,
@@ -7421,6 +8560,7 @@ export {
   questEnrollmentWithdrawalInputSchema,
   questLifecycleInputSchema,
   questLifecycleSchema,
+  questStationStateSchema,
   readinessSchema,
   realPeopleInTestUsageSchema,
   referralManagementSchema,
@@ -7445,8 +8585,23 @@ export {
   serviceKeySchema,
   settlementPayoutCsv,
   shortensEvidenceRetention,
+  solanaActionHeaders,
+  solanaActionMemo,
+  solanaActionVersion,
+  solanaMemoProgram,
+  solanaPayoutConfirmationResultSchema,
+  solanaPayoutConfirmationSchema,
+  solanaPayoutInputSchema,
+  solanaPayoutMintSchema,
+  solanaPayoutPageSchema,
+  solanaPayoutQuerySchema,
+  solanaPayoutSchema,
+  solanaPayoutSquadsSchema,
+  solanaSignatureSchema,
+  solanaTransactionSubmissionSchema,
   sourceDataSchema2 as sourceDataSchema,
   sourceRoles,
+  squadsProposalUrl,
   stageRequestSchema,
   stagedDeploymentContentSchema,
   stagedDeploymentKey,
@@ -7460,8 +8615,12 @@ export {
   starterIdSchema,
   starterTemplates,
   starters,
+  stationOperationTarget,
+  stationRevocationInputSchema,
+  stationRevocationSchema,
   stockAdditionSchema,
   stockInputSchema,
+  takesSolanaTransaction,
   teamSchema,
   telegramBotIdSchema,
   telegramIdentitySelectorSchema,
@@ -7508,6 +8667,7 @@ export {
   verifyWebhook,
   walletBalanceChainsSchema,
   walletIdentitySelectorSchema,
+  walletLinkedEventDataSchema,
   webhookControlInputSchema,
   webhookCreateInputSchema,
   webhookDeleteInputSchema,