@domino-sdk/relay 1.0.0-next.2 → 1.0.0-next.34

package/dist/chunk-4KNTMNXA.js

@@ -1,1847 +0,0 @@
-import {
-  authoringIdentityShape,
-  engagementArtifactSchema,
-  engagementBoundaryPageSchema,
-  engagementDeploymentEntrySchema,
-  engagementPageQuerySchema,
-  engagementPageSchema,
-  leaderboardArtifactSchema,
-  leaderboardDefinitionSchema,
-  leaderboardPageSchema,
-  leaderboardPlacementSchema,
-  leaderboardPreviewSchema,
-  leaderboardQuerySchema,
-  normalizeAuthoringIdentity,
-  publishedReferralSchema,
-  referralAcceptSchema,
-  referralArtifactSchema,
-  referralDefinitionSchema,
-  referralHistorySchema,
-  referralSummarySchema,
-  validateAuthoringIdentity
-} from "./chunk-B76BAJ25.js";
-import {
-  authScopeSchema,
-  exchangeResultSchema,
-  memberSummarySchema,
-  sessionSchema
-} from "./chunk-VH4OQ5VX.js";
-import {
-  AVATAR_UPLOAD_LIMIT,
-  avatarUploadTypes,
-  linkedWalletSchema,
-  ownProfileSchema,
-  profileCompletionPageSchema,
-  profileCompletionQuerySchema,
-  profileReferralSchema,
-  profileSummarySchema,
-  profileUpdateSchema,
-  walletAddressInput,
-  walletAddressInputSchema,
-  walletChallengeInputSchema,
-  walletChallengeSchema,
-  walletConnectionSchema,
-  walletMessageChallengeSchema,
-  walletProofSchema,
-  walletSignInNetworksSchema,
-  walletSignatureSchema,
-  walletUnlinkInputSchema
-} from "./chunk-ONDBQSMU.js";
-import {
-  accountConnectionSchema,
-  attemptSchema,
-  authProviderSchema,
-  contentAdmissionPageSchema,
-  contentAdmissionQuerySchema,
-  contentAdmissionSchema,
-  contentEnrollmentInputSchema,
-  contentEnrollmentSchema,
-  contentPerformancePageSchema,
-  contentPerformanceQuerySchema,
-  contentQualificationPageSchema,
-  contentQualificationQuerySchema,
-  contentReleaseInputSchema,
-  entitlementSchema,
-  errorSchema,
-  evidenceSchema,
-  identifier,
-  memberProgressSchema,
-  photoResultSchema,
-  pickupAvailabilitySchema,
-  pickupSelectionSchema,
-  publishedReleaseSchema,
-  publishedTrackerSchema,
-  questDescriptionSchema,
-  quizEvidenceSchema,
-  releaseSchema,
-  reviewModeSchema,
-  settingsValuesSchema,
-  snapshotSchema,
-  storedReviewModeSchema,
-  submissionEvidenceSchema,
-  templateSchema,
-  tieredRewardReferenceSchema,
-  trackerArtifactSchema,
-  validateSubmissionValue,
-  valueEvidenceSchema,
-  xTweetSchema
-} from "./chunk-NKGJEYZM.js";
-
-// src/point-ledgers.ts
-import { z } from "zod";
-var pointLedgerPropertiesSchema = z.object({
-  name: z.string().trim().min(1).max(120),
-  description: z.string().trim().max(1e3).default("")
-}).strict();
-var createPointLedgerSchema = pointLedgerPropertiesSchema.extend({ actionId: identifier, key: identifier.optional() }).strict();
-var pointLedgerSchema = pointLedgerPropertiesSchema.extend({
-  id: identifier
-});
-var pointLedgerDeclarationSchema = pointLedgerPropertiesSchema.extend({ key: identifier }).strict();
-var pointLedgerReferenceSchema = z.object({
-  id: identifier,
-  key: identifier.nullable(),
-  name: z.string()
-});
-
-// src/reward-deliveries.ts
-import { z as z2 } from "zod";
-var rewardDeliverySchema = z2.object({
-  id: z2.string(),
-  quest: z2.string(),
-  completion: z2.string(),
-  member: z2.string(),
-  provider: z2.literal("discord"),
-  action: z2.literal("grant-role"),
-  roleId: z2.string(),
-  /**
-   * `failed` is terminal: Discord rejected the grant permanently (unknown role,
-   * member left the server, missing permissions) or retries ran out after
-   * about a day. An operator can retry it once the cause is fixed.
-   */
-  status: z2.enum(["pending", "delivered", "failed"]),
-  /** Provider attempts in the current round; an operator retry starts a new round at zero. */
-  attempts: z2.number().int(),
-  /** While pending with a `lastError`, when the next attempt is scheduled. */
-  nextAt: z2.number(),
-  lastError: z2.string().nullable(),
-  createdAt: z2.number(),
-  deliveredAt: z2.number().nullable()
-});
-var rewardDeliveriesSchema = z2.object({
-  deliveries: z2.array(rewardDeliverySchema)
-});
-
-// src/catalog.ts
-import { z as z3 } from "zod";
-var interactionSchema = z3.enum([
-  "photo",
-  "text",
-  "url",
-  "quiz",
-  "claim",
-  "staff",
-  "automatic"
-]);
-function questInteraction(trigger) {
-  return trigger.kind === "automatic" ? "automatic" : trigger.actor === "staff" ? "staff" : trigger.input === "none" ? "claim" : trigger.input;
-}
-var questTypeVersionSchema = z3.object({
-  key: identifier.optional(),
-  id: identifier,
-  version: identifier,
-  code: z3.string(),
-  definition: questDescriptionSchema,
-  provider: storedReviewModeSchema,
-  createdAt: z3.number()
-});
-var collectionSlotSchema = z3.object({
-  id: identifier,
-  key: identifier.optional(),
-  title: z3.string().trim().min(1).max(120)
-}).strict();
-var collectionSlotDeclarationSchema = collectionSlotSchema.omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
-var questCollectionSchema = collectionSlotSchema.extend({
-  quests: z3.array(identifier).max(100).refine(
-    (v) => new Set(v).size === v.length,
-    "A collection can contain a quest only once"
-  )
-});
-var questInstanceSchema = z3.object({
-  id: identifier,
-  title: z3.string().trim().min(1).max(120),
-  typeVersion: identifier,
-  settings: settingsValuesSchema,
-  requires: z3.array(identifier).max(30),
-  status: z3.enum(["active", "paused", "archived"])
-}).strict();
-var questDraftChangesSchema = z3.object({
-  quests: z3.array(
-    questInstanceSchema.extend({ expectedRelease: identifier.nullable() })
-  ).max(50),
-  collections: z3.array(questCollectionSchema).max(50)
-}).strict();
-var draftBase = z3.object({
-  id: identifier,
-  revision: z3.number().int().positive(),
-  baseRevision: z3.number().int().nonnegative(),
-  changes: questDraftChangesSchema
-});
-var questDraftSchema = z3.discriminatedUnion("status", [
-  draftBase.extend({ status: z3.literal("draft") }),
-  draftBase.extend({
-    status: z3.literal("published"),
-    releaseIds: z3.array(identifier)
-  })
-]);
-var questCatalogSchema = z3.object({
-  revision: z3.number().int().nonnegative(),
-  types: z3.array(questTypeVersionSchema),
-  collections: z3.array(questCollectionSchema),
-  quests: z3.array(questInstanceSchema),
-  drafts: z3.array(questDraftSchema),
-  releases: z3.array(publishedReleaseSchema).default([]),
-  supportedInteractions: z3.array(interactionSchema)
-});
-var catalogDeploymentSchema = z3.object({
-  expectedRevision: z3.number().int().nonnegative(),
-  types: z3.array(
-    z3.object({
-      code: z3.string().min(1).max(1e6),
-      provider: reviewModeSchema
-    })
-  ).max(50).default([]),
-  collections: z3.array(collectionSlotDeclarationSchema).max(50).default([]),
-  supportedInteractions: z3.array(interactionSchema).min(1).optional()
-}).strict();
-var catalogDeploymentPreviewSchema = z3.object({
-  revision: z3.number().int().nonnegative(),
-  types: z3.array(questTypeVersionSchema),
-  collections: z3.array(collectionSlotSchema),
-  supportedInteractions: z3.array(interactionSchema)
-});
-var saveQuestDraftSchema = z3.object({
-  id: identifier.optional(),
-  actionId: identifier,
-  expectedRevision: z3.number().int().nonnegative(),
-  baseRevision: z3.number().int().nonnegative(),
-  changes: questDraftChangesSchema
-}).strict();
-var publishQuestDraftSchema = z3.object({ id: identifier, expectedRevision: z3.number().int().positive() }).strict();
-var questRewardViewSchema = z3.discriminatedUnion("kind", [
-  z3.object({
-    kind: z3.literal("points"),
-    label: z3.string(),
-    amount: z3.number().int().nonnegative(),
-    ledger: pointLedgerReferenceSchema
-  }),
-  z3.object({
-    kind: z3.literal("tier"),
-    label: z3.string(),
-    reward: tieredRewardReferenceSchema.extend({ title: z3.string() }),
-    tier: identifier
-  }),
-  z3.object({ kind: z3.literal("integration"), label: z3.string() })
-]);
-var questViewSchema = memberProgressSchema.shape.quests.element.extend(
-  {
-    release: identifier,
-    interaction: interactionSchema,
-    lifecycle: z3.enum(["active", "paused", "archived"]),
-    rewards: z3.array(questRewardViewSchema)
-  }
-);
-var collectionViewSchema = z3.object({
-  key: identifier.optional(),
-  id: identifier,
-  title: z3.string(),
-  quests: z3.array(questViewSchema)
-});
-var questExperienceSchema = z3.object({
-  member: identifier,
-  quests: z3.array(questViewSchema),
-  collections: z3.array(collectionViewSchema)
-});
-var questPublicationPreviewSchema = z3.object({
-  draft: questDraftSchema,
-  releases: z3.array(publishedReleaseSchema),
-  affectedCollections: z3.array(questCollectionSchema)
-});
-var allocateQuestSchema = z3.object({ actionId: identifier }).strict();
-var allocatedQuestSchema = z3.object({ id: identifier });
-
-// src/errors.ts
-var RelayError = class extends Error {
-  constructor(message, status, missing = [], code) {
-    super(message);
-    this.status = status;
-    this.missing = missing;
-    this.code = code;
-  }
-  status;
-  missing;
-  code;
-};
-
-// src/submissions.ts
-import { z as z4 } from "zod";
-var common = {
-  id: identifier,
-  quest: identifier,
-  release: identifier.optional()
-};
-var claimInputSchema = z4.union([
-  submissionEvidenceSchema,
-  z4.object({ kind: z4.literal("none") }).strict()
-]);
-var draftSchema = z4.union([
-  claimInputSchema,
-  z4.object({ kind: z4.literal("photo"), file: z4.instanceof(Blob) })
-]);
-var recordSchema = z4.union([
-  z4.object({
-    ...common,
-    stage: z4.literal("review"),
-    draft: draftSchema.nullable()
-  }),
-  z4.object({ ...common, stage: z4.literal("upload"), file: z4.instanceof(Blob) }),
-  z4.object({
-    ...common,
-    stage: z4.literal("claim"),
-    evidence: identifier,
-    file: z4.instanceof(Blob).optional()
-  }),
-  z4.object({
-    ...common,
-    stage: z4.literal("submitted"),
-    evidence: identifier,
-    attempt: identifier
-  }),
-  z4.object({ ...common, stage: z4.literal("claim"), input: claimInputSchema }),
-  z4.object({
-    ...common,
-    stage: z4.literal("submitted"),
-    input: claimInputSchema,
-    attempt: identifier
-  })
-]);
-function submissions(transport, configuredStore, namespace) {
-  async function open(quest, options = {
-    input: "photo"
-  }) {
-    if (!configuredStore) {
-      throw new Error(
-        "Submissions require durable storage. Use createBrowserRelayClient or provide a SubmissionStore."
-      );
-    }
-    const store = configuredStore;
-    identifier.parse(quest);
-    const session = await transport.session();
-    if (session?.principal.kind !== "member") {
-      throw new Error("Sign in to submit an activity");
-    }
-    const sessionId = session.id;
-    const key = JSON.stringify([
-      "relay-submission-v1",
-      namespace,
-      session.organization,
-      session.environment,
-      session.project,
-      session.principal.member,
-      quest
-    ]);
-    async function currentSession() {
-      const current = await transport.session();
-      if (current?.id !== sessionId) {
-        throw new Error(
-          "Your session changed. Reopen the submission before continuing."
-        );
-      }
-    }
-    async function read() {
-      const saved = await store.read(key);
-      if (saved === void 0 || saved === null) {
-        return null;
-      }
-      const parsed = recordSchema.safeParse(saved);
-      if (!parsed.success || parsed.data.quest !== quest) {
-        throw new Error(
-          "Saved submission could not be read. Do not create another claim until it is recovered."
-        );
-      }
-      const record = parsed.data;
-      const input = record.stage === "review" ? record.draft?.kind : "input" in record ? record.input.kind : "photo";
-      if (!options.recoverPrevious && input !== options.input) {
-        throw new Error(
-          "Saved submission uses a different input type. Reopen it with its original type to recover it."
-        );
-      }
-      return record;
-    }
-    function claim(record) {
-      return transport.claim(
-        {
-          quest,
-          actionId: record.id,
-          ...record.release ? { release: record.release } : {},
-          ..."evidence" in record ? { evidence: record.evidence } : record.input.kind !== "none" ? { input: record.input } : {}
-        },
-        sessionId
-      );
-    }
-    async function resumeRecord(saved) {
-      if (saved.stage === "review") {
-        throw new QuestUpdatedError(
-          "This quest changed. Review it before submitting again.",
-          "quest-updated",
-          saved.draft
-        );
-      }
-      let record = saved;
-      if (record.stage === "upload") {
-        const evidence = await transport.upload(
-          record.file,
-          record.id,
-          sessionId
-        );
-        record = {
-          id: record.id,
-          quest,
-          ...record.release ? { release: record.release } : {},
-          file: record.file,
-          stage: "claim",
-          evidence: evidence.id
-        };
-        await store.write(key, record);
-      }
-      let attempt;
-      try {
-        attempt = await claim(record);
-      } catch (error) {
-        if (error instanceof RelayError && error.status === 422 && error.code === "invalid-submission" && record.stage === "claim") {
-          await store.write(key, null);
-          throw error;
-        }
-        if (error instanceof RelayError && error.status === 409 && (error.code === "quest-updated" || error.code === "stale-quiz") && record.stage === "claim") {
-          const draft = "input" in record ? record.input : "file" in record && record.file ? { kind: "photo", file: record.file } : null;
-          await store.write(
-            key,
-            error.code === "quest-updated" ? {
-              id: record.id,
-              quest,
-              release: record.release,
-              stage: "review",
-              draft
-            } : null
-          );
-          throw new QuestUpdatedError(error.message, error.code, draft);
-        }
-        throw error;
-      }
-      await store.write(key, {
-        ...record,
-        stage: "submitted",
-        attempt: attempt.id
-      });
-      if (attempt.status === "failed") {
-        attempt = await transport.retry(attempt.id, sessionId);
-      }
-      return attempt;
-    }
-    async function submit(record) {
-      return store.exclusive(key, async () => {
-        await currentSession();
-        const existing = await read();
-        if (existing?.stage === "review" && existing.release === record.release) {
-          throw new QuestUpdatedError(
-            "Review the latest quest before submitting again.",
-            "quest-updated",
-            existing.draft
-          );
-        }
-        if (existing && existing.stage !== "submitted" && existing.stage !== "review") {
-          throw new Error(
-            "A submission is unfinished. Resume it before choosing new input."
-          );
-        }
-        if (existing?.stage === "submitted") {
-          const previous = await claim(existing);
-          if (previous.status === "failed") {
-            return transport.retry(previous.id, sessionId);
-          }
-          if (previous.status !== "rejected" && !(options.repeatable && previous.status === "accepted")) {
-            return previous;
-          }
-        }
-        await store.write(key, record);
-        return resumeRecord(record);
-      });
-    }
-    const handle = {
-      async discard() {
-        return store.exclusive(key, async () => {
-          await currentSession();
-          const record = await read();
-          if (!record) {
-            return;
-          }
-          if (record.stage !== "submitted") {
-            throw new Error(
-              "Resume the unfinished submission before starting over."
-            );
-          }
-          const attempt = await claim(record);
-          if (attempt.status !== "failed" && attempt.status !== "rejected" && !(options.repeatable && attempt.status === "accepted")) {
-            throw new Error(
-              "Only a failed or rejected submission can be discarded."
-            );
-          }
-          await store.write(key, null);
-        });
-      },
-      async status() {
-        await currentSession();
-        const record = await read();
-        if (!record) {
-          return { kind: "empty" };
-        }
-        if (record.stage === "review") {
-          return { kind: "needs-review" };
-        }
-        return record.stage === "submitted" ? { kind: "submitted", attempt: record.attempt } : { kind: "pending", stage: record.stage };
-      },
-      async resume() {
-        return store.exclusive(key, async () => {
-          await currentSession();
-          const record = await read();
-          if (!record) {
-            throw new Error("There is no saved submission to resume");
-          }
-          return resumeRecord(record);
-        });
-      }
-    };
-    if (options.input === "text" || options.input === "url") {
-      const kind = options.input;
-      return {
-        ...handle,
-        submit(value) {
-          const input = valueEvidenceSchema.parse({ kind, value });
-          return submit({
-            id: crypto.randomUUID(),
-            quest,
-            release: options.release,
-            stage: "claim",
-            input
-          });
-        }
-      };
-    }
-    if (options.input === "quiz") {
-      return {
-        ...handle,
-        submit(answers, version) {
-          const input = quizEvidenceSchema.parse({
-            kind: "quiz",
-            answers,
-            ...version || options.release ? { release: version?.release ?? options.release } : {}
-          });
-          return submit({
-            id: crypto.randomUUID(),
-            ...options.release ? { release: options.release } : {},
-            quest,
-            stage: "claim",
-            input
-          });
-        }
-      };
-    }
-    if (options.input === "none") {
-      return {
-        ...handle,
-        submit() {
-          return submit({
-            id: crypto.randomUUID(),
-            ...options.release ? { release: options.release } : {},
-            quest,
-            stage: "claim",
-            input: { kind: "none" }
-          });
-        }
-      };
-    }
-    return {
-      ...handle,
-      async submit(file) {
-        if (!["image/jpeg", "image/png"].includes(file.type) || file.size === 0 || file.size > 5 * 1024 * 1024) {
-          throw new Error("Choose a JPG or PNG photo under 5 MB");
-        }
-        const bytes = new Uint8Array(await file.slice(0, 4).arrayBuffer());
-        const signature = file.type === "image/png" ? [137, 80, 78, 71] : [255, 216, 255];
-        if (!signature.every((byte, index) => bytes[index] === byte)) {
-          throw new Error("Image content does not match its file type");
-        }
-        return submit({
-          id: crypto.randomUUID(),
-          ...options.release ? { release: options.release } : {},
-          quest,
-          stage: "upload",
-          file
-        });
-      }
-    };
-  }
-  return open;
-}
-var QuestUpdatedError = class extends RelayError {
-  constructor(message, code, draft) {
-    super(message, 409, [], code);
-    this.draft = draft;
-  }
-  draft;
-};
-
-// src/quest-experience.ts
-function reconcileQuestDraft(view, draft) {
-  if (!draft) {
-    return null;
-  }
-  if (draft.kind === "text" || draft.kind === "url") {
-    return view.interaction === draft.kind ? draft : null;
-  }
-  if (draft.kind === "photo") {
-    return view.interaction === "photo" ? draft : null;
-  }
-  if (draft.kind === "none") {
-    return view.interaction === "claim" ? draft : null;
-  }
-  if (view.interaction !== "quiz") {
-    return null;
-  }
-  const answers = Object.fromEntries(
-    (view.presentation.quiz ?? []).flatMap((q) => {
-      const answer = draft.answers[q.id];
-      return q.choices.some((c) => c.id === answer) ? [[q.id, answer]] : [];
-    })
-  );
-  return { kind: "quiz", release: view.release, answers };
-}
-function questActions(submission, latest) {
-  return async (view) => {
-    async function run(task) {
-      try {
-        return { kind: "submitted", attempt: await task() };
-      } catch (error) {
-        if (!(error instanceof QuestUpdatedError)) {
-          throw error;
-        }
-        const current = await latest(view.quest).catch(() => {
-          throw error;
-        });
-        return {
-          kind: "quest-updated",
-          latest: current,
-          originalDraft: error.draft,
-          draft: reconcileQuestDraft(current, error.draft)
-        };
-      }
-    }
-    if (view.lifecycle !== "active" || view.interaction === "staff" || view.interaction === "automatic") {
-      const handle = await submission(view.quest, {
-        input: "none",
-        release: view.release,
-        recoverPrevious: true,
-        repeatable: view.completion.kind === "keyed"
-      });
-      return {
-        kind: "status",
-        view,
-        status: handle.status,
-        discard: handle.discard,
-        resume: () => run(handle.resume)
-      };
-    }
-    switch (view.interaction) {
-      case "text":
-      case "url": {
-        const kind = view.interaction;
-        const handle = await submission(view.quest, {
-          input: kind,
-          release: view.release,
-          recoverPrevious: true,
-          repeatable: view.completion.kind === "keyed"
-        });
-        return {
-          kind,
-          view,
-          status: handle.status,
-          discard: handle.discard,
-          resume: () => run(handle.resume),
-          submit: (value) => run(() => {
-            if (view.trigger.kind !== "manual" || view.trigger.input !== "text" && view.trigger.input !== "url") {
-              throw new Error("Quest input changed");
-            }
-            const problem = validateSubmissionValue(
-              { kind, value },
-              view.trigger
-            );
-            if (problem) {
-              throw new Error(problem);
-            }
-            return handle.submit(value);
-          })
-        };
-      }
-      case "photo": {
-        const handle = await submission(view.quest, {
-          input: "photo",
-          release: view.release,
-          recoverPrevious: true,
-          repeatable: view.completion.kind === "keyed"
-        });
-        return {
-          kind: "photo",
-          view,
-          status: handle.status,
-          discard: handle.discard,
-          resume: () => run(handle.resume),
-          submit: (file) => run(() => handle.submit(file))
-        };
-      }
-      case "quiz": {
-        const handle = await submission(view.quest, {
-          input: "quiz",
-          release: view.release,
-          recoverPrevious: true,
-          repeatable: view.completion.kind === "keyed"
-        });
-        return {
-          kind: "quiz",
-          view,
-          status: handle.status,
-          discard: handle.discard,
-          resume: () => run(handle.resume),
-          submit: (answers) => run(() => handle.submit(answers, { release: view.release }))
-        };
-      }
-      case "claim": {
-        const handle = await submission(view.quest, {
-          input: "none",
-          release: view.release,
-          recoverPrevious: true,
-          repeatable: view.completion.kind === "keyed"
-        });
-        return {
-          kind: "claim",
-          view,
-          status: handle.status,
-          discard: handle.discard,
-          resume: () => run(handle.resume),
-          submit: () => run(handle.submit)
-        };
-      }
-    }
-  };
-}
-
-// src/progress.ts
-function observeProgress(transport, listener, options = {}, onDispose = () => {
-}) {
-  const interval = options.intervalMs ?? 1500;
-  const maximum = options.maxBackoffMs ?? 3e4;
-  if (!Number.isFinite(interval) || interval <= 0 || !Number.isFinite(maximum) || maximum < interval) {
-    throw new Error(
-      "Progress polling requires a positive interval and a maximum at least as large"
-    );
-  }
-  let disposed = false;
-  let controller;
-  let timer;
-  let sessionId;
-  let failures = 0;
-  function clear() {
-    controller?.abort();
-    if (timer !== void 0) {
-      clearTimeout(timer);
-    }
-    sessionId = void 0;
-    if (!disposed) {
-      listener({ kind: "loading" });
-    }
-  }
-  async function refresh() {
-    if (disposed) {
-      return;
-    }
-    controller?.abort();
-    if (timer !== void 0) {
-      clearTimeout(timer);
-    }
-    const request = new AbortController();
-    controller = request;
-    const current = () => !disposed && !request.signal.aborted;
-    try {
-      const session = await transport.session(request.signal);
-      if (!current()) {
-        return;
-      }
-      if (sessionId !== (session?.id ?? null)) {
-        sessionId = session?.id ?? null;
-        listener({ kind: "session", session });
-      }
-      if (session?.principal.kind === "member") {
-        const progress = await transport.progress(session.id, request.signal);
-        if (!current()) {
-          return;
-        }
-        const confirmed = await transport.session(request.signal);
-        if (!current()) {
-          return;
-        }
-        if (confirmed?.id !== session.id || progress.member !== session.principal.member) {
-          sessionId = void 0;
-          listener({ kind: "loading" });
-          return;
-        }
-        listener({ kind: "ready", session: confirmed, progress });
-      }
-      failures = 0;
-    } catch (error) {
-      if (!current()) {
-        return;
-      }
-      failures = Math.min(failures + 1, 20);
-      sessionId = void 0;
-      listener({
-        kind: "error",
-        error: error instanceof Error ? error : new Error("Could not refresh progress")
-      });
-    } finally {
-      if (current()) {
-        timer = setTimeout(
-          () => void refresh(),
-          Math.min(maximum, interval * 2 ** failures)
-        );
-      }
-    }
-  }
-  const observer = {
-    refresh,
-    clear,
-    dispose() {
-      if (disposed) {
-        return;
-      }
-      disposed = true;
-      controller?.abort();
-      if (timer !== void 0) {
-        clearTimeout(timer);
-      }
-      onDispose();
-    }
-  };
-  return observer;
-}
-
-// src/index.ts
-import { z as z10 } from "zod";
-
-// src/avatar.ts
-import { createAvatar } from "@dicebear/core";
-import * as shapes from "@dicebear/shapes";
-function avatarSrc(avatar) {
-  return avatar.source === "generated" ? defaultAvatar(avatar.seed) : avatar.url;
-}
-function defaultAvatar(seed) {
-  return createAvatar(shapes, { seed }).toDataUri();
-}
-function defaultAvatarSvg(seed) {
-  return createAvatar(shapes, { seed }).toString();
-}
-function walletAvatarSeed(wallet) {
-  return `${wallet.chain}:${wallet.chain === "solana" ? wallet.address : wallet.address.toLowerCase()}`;
-}
-
-// src/collection.ts
-import { z as z5 } from "zod";
-var collectionCodeSchema = z5.string().regex(/^relay:collect:[a-f0-9]{64}$/);
-var collectionPassSchema = z5.object({
-  code: collectionCodeSchema,
-  expiresAt: z5.number(),
-  entitlement: identifier
-});
-var collectionResolveSchema = z5.object({ code: collectionCodeSchema }).strict();
-var collectionBeginSchema = collectionResolveSchema.extend({
-  actionId: identifier,
-  revision: z5.number().int().positive(),
-  selection: pickupSelectionSchema.optional()
-});
-var collectionPreviewSchema = z5.object({
-  entitlement: entitlementSchema,
-  inventory: pickupAvailabilitySchema,
-  expiresAt: z5.number()
-});
-
-// src/configuration.ts
-function questConfiguration(release) {
-  return release.configuration ?? {
-    defaults: Object.fromEntries(
-      Object.entries(release.fields).map(([key, field]) => [
-        key,
-        field.default
-      ])
-    ),
-    overrides: { ...release.values },
-    preserved: Object.keys(release.values)
-  };
-}
-
-// src/deployments.ts
-import { z as z8 } from "zod";
-
-// src/images.ts
-import { z as z7 } from "zod";
-
-// src/x.ts
-import { z as z6 } from "zod";
-var xIdSchema = z6.string().regex(/^[0-9]{1,20}$/);
-var xConnectionSchema = z6.object({ userId: xIdSchema });
-var xProfileSchema = z6.object({
-  id: xIdSchema,
-  username: z6.string(),
-  name: z6.string(),
-  bio: z6.string().nullable(),
-  profileImageUrl: z6.string().url().nullable(),
-  followersCount: z6.number().int().nonnegative().nullable(),
-  verified: z6.boolean().nullable()
-});
-var xPostSchema = xTweetSchema.extend({
-  quotedTweetId: xIdSchema.nullish().transform((v) => v ?? null),
-  inReplyToUserId: xIdSchema.nullish().transform((v) => v ?? null),
-  inReplyToStatusId: xIdSchema.nullish().transform((v) => v ?? null),
-  retweetedTweetId: xIdSchema.nullish().transform((v) => v ?? null),
-  /**
-   * Attached media in post order. Videos and GIFs carry their preview image URL. Like the tracker
-   * projection (migration 0056), a list with any malformed item is dropped whole, so positions
-   * never shift and a bad entry never fails the post read.
-   */
-  media: z6.unknown().transform(
-    (value) => z6.array(z6.object({ type: z6.string(), url: z6.string() })).safeParse(value).data ?? []
-  )
-});
-var xRequestSchema = z6.discriminatedUnion("operation", [
-  z6.object({ operation: z6.literal("connection") }).strict(),
-  z6.object({ operation: z6.literal("profile") }).strict(),
-  z6.object({ operation: z6.literal("post"), postId: xIdSchema }).strict(),
-  z6.object({ operation: z6.literal("follows"), userId: xIdSchema }).strict(),
-  z6.object({ operation: z6.literal("reposted"), postId: xIdSchema }).strict()
-]);
-
-// src/images.ts
-var imageReferenceSchema = z7.union([
-  z7.strictObject({ evidence: z7.string().min(1).max(256) }),
-  z7.strictObject({ x: z7.literal("profile") }),
-  z7.strictObject({
-    x: z7.literal("post"),
-    postId: xIdSchema,
-    index: z7.number().int().min(0).max(3).default(0)
-  }),
-  z7.strictObject({ asset: identifier })
-]);
-var criteria = z7.string().trim().min(1).max(2e3);
-var imageFieldSchema = z7.strictObject({
-  type: z7.enum(["string", "number", "boolean"]),
-  description: z7.string().trim().min(1).max(500)
-});
-var imageFieldsSchema = z7.record(z7.string().regex(/^[a-zA-Z][a-zA-Z0-9_]{0,39}$/), imageFieldSchema).refine((fields) => {
-  const count = Object.keys(fields).length;
-  return count >= 1 && count <= 12;
-}, "Declare between 1 and 12 fields");
-var imageRequestSchema = z7.discriminatedUnion("operation", [
-  z7.strictObject({
-    operation: z7.literal("inspect"),
-    image: imageReferenceSchema
-  }),
-  z7.strictObject({
-    operation: z7.literal("compare"),
-    images: z7.tuple([imageReferenceSchema, imageReferenceSchema])
-  }),
-  z7.strictObject({
-    operation: z7.literal("review"),
-    images: z7.array(imageReferenceSchema).min(1).max(4),
-    criteria
-  }),
-  z7.strictObject({
-    operation: z7.literal("extract"),
-    image: imageReferenceSchema,
-    fields: imageFieldsSchema
-  }),
-  z7.strictObject({
-    operation: z7.literal("seen"),
-    image: imageReferenceSchema,
-    maxDistance: z7.number().int().min(0).max(8).default(8)
-  })
-]);
-var hash = z7.string().regex(/^[0-9a-f]{16}$/);
-var imageInspectionSchema = z7.strictObject({
-  width: z7.number().int().positive(),
-  height: z7.number().int().positive(),
-  format: z7.enum(["jpeg", "png", "webp", "gif", "avif"]),
-  bytes: z7.number().int().positive(),
-  sha256: z7.string().regex(/^[0-9a-f]{64}$/),
-  phash: hash,
-  dhash: hash
-});
-var distance = z7.number().int().min(0).max(64);
-var imageComparisonSchema = z7.strictObject({
-  identical: z7.boolean(),
-  phashDistance: distance,
-  dhashDistance: distance
-});
-var imageExtractionSchema = z7.strictObject({
-  values: z7.record(
-    z7.string(),
-    z7.union([z7.string().max(2e3), z7.number(), z7.boolean(), z7.null()])
-  ),
-  reason: z7.string().min(1).max(2e3)
-});
-var imageSightingsSchema = z7.strictObject({
-  matches: z7.number().int().nonnegative(),
-  closestDistance: distance.nullable(),
-  firstSeenAt: z7.number().int().nonnegative().nullable()
-});
-var sha256 = z7.string().regex(/^[0-9a-f]{64}$/);
-var imageSize = z7.number().int().positive().max(5 * 1024 * 1024);
-var imageAssetArtifactSchema = z7.strictObject({
-  key: identifier,
-  sha256,
-  size: imageSize,
-  path: z7.string().min(1).max(500).optional()
-});
-var imageUploadRequestSchema = z7.strictObject({
-  images: z7.array(
-    z7.strictObject({
-      sha256,
-      size: imageSize,
-      type: z7.enum(["image/jpeg", "image/png", "image/webp"])
-    })
-  ).min(1).max(10)
-});
-var imageUploadsSchema = z7.strictObject({
-  images: z7.array(
-    z7.strictObject({
-      sha256,
-      upload: z7.strictObject({
-        url: z7.string().url(),
-        headers: z7.record(z7.string(), z7.string()),
-        expiresAt: z7.number().int().positive()
-      }).nullable()
-    })
-  )
-});
-var publishedImageSchema = z7.strictObject({
-  key: identifier,
-  sha256,
-  type: z7.enum(["image/jpeg", "image/png", "image/webp"]),
-  size: imageSize,
-  width: z7.number().int().positive(),
-  height: z7.number().int().positive()
-});
-function parseImageExtraction(raw, value) {
-  const result = imageExtractionSchema.parse(value);
-  const fields = imageFieldsSchema.parse(raw);
-  for (const [key, field] of Object.entries(fields)) {
-    const extracted = result.values[key];
-    if (extracted === void 0) {
-      throw new Error("Image extraction omitted " + key);
-    }
-    if (extracted !== null && typeof extracted !== field.type) {
-      throw new Error("Image extraction returned the wrong type for " + key);
-    }
-  }
-  if (Object.keys(result.values).some((key) => !Object.hasOwn(fields, key))) {
-    throw new Error("Image extraction returned an undeclared field");
-  }
-  return result;
-}
-function parseImageResult(request, value) {
-  switch (request.operation) {
-    case "inspect":
-      return imageInspectionSchema.parse(value);
-    case "compare":
-      return imageComparisonSchema.parse(value);
-    case "review":
-      return photoResultSchema.parse(value);
-    case "extract":
-      return parseImageExtraction(request.fields, value);
-    case "seen":
-      return imageSightingsSchema.parse(value);
-  }
-}
-
-// src/deployments.ts
-var projectCatalogArtifactSchema = catalogDeploymentSchema.omit({ expectedRevision: true }).extend({
-  engagement: z8.array(engagementArtifactSchema).max(50).default([]),
-  trackers: z8.array(trackerArtifactSchema).max(50).default([]),
-  pointLedgers: z8.array(pointLedgerDeclarationSchema).max(50).default([]),
-  referrals: z8.array(referralArtifactSchema).max(50).default([]),
-  leaderboards: z8.array(leaderboardArtifactSchema).max(50).default([]),
-  images: z8.array(imageAssetArtifactSchema).max(10).default([])
-});
-var projectDeploymentSchema = projectCatalogArtifactSchema.extend({ releases: z8.array(releaseSchema).max(50).default([]) }).refine(
-  (value) => value.engagement.length > 0 || value.trackers.length > 0 || value.pointLedgers.length > 0 || value.releases.length > 0 || value.leaderboards.length > 0 || value.referrals.length > 0 || value.images.length > 0 || value.types.length > 0 || value.collections.length > 0 || value.supportedInteractions !== void 0,
-  "No resources configured. Add engagement, trackers, quests, questTypes, pointLedgers, leaderboards, referrals, images, collections, or supportedInteractions to relay.json."
-);
-var deploymentPreviewSchema = z8.object({
-  id: identifier,
-  engagement: z8.array(engagementDeploymentEntrySchema).default([]),
-  trackers: z8.array(publishedTrackerSchema).default([]),
-  baseRevision: z8.number().int().nonnegative(),
-  pointLedgers: z8.array(pointLedgerSchema).default([]),
-  releases: z8.array(publishedReleaseSchema),
-  types: z8.array(questTypeVersionSchema),
-  collections: z8.array(questCollectionSchema),
-  supportedInteractions: z8.array(interactionSchema),
-  referrals: z8.array(publishedReferralSchema).default([]),
-  leaderboards: z8.array(leaderboardPreviewSchema).default([]),
-  images: z8.array(publishedImageSchema).default([])
-});
-var publishDeploymentSchema = z8.object({ id: identifier }).strict();
-var deploymentResultSchema = deploymentPreviewSchema.extend({
-  revision: z8.number().int().positive()
-});
-
-// src/identity-integration.ts
-import { z as z9 } from "zod";
-var identityIntegrationInputSchema = z9.object({
-  name: z9.string().trim().min(1).max(80),
-  origin: z9.string().url().refine((value) => {
-    const url = new URL(value);
-    return url.protocol === "https:" && url.origin === value;
-  }, "Use an exact HTTPS application origin")
-}).strict();
-var identityIntegrationSchema = authScopeSchema.extend({
-  id: z9.string().uuid(),
-  name: z9.string(),
-  origin: z9.string(),
-  expiresAt: z9.number()
-});
-var identityIntegrationSecretSchema = identityIntegrationSchema.extend(
-  {
-    token: z9.string()
-  }
-);
-var participantExchangeSchema = z9.object({
-  subject: z9.string().min(1).max(200),
-  previousToken: z9.string().max(200).optional()
-}).strict();
-
-// src/index.ts
-function createRelayClient(options) {
-  async function send(path, init = {}) {
-    const headers = new Headers(init.headers);
-    if (options.token) {
-      headers.set("Authorization", `Bearer ${options.token}`);
-    }
-    if (options.organization) {
-      headers.set("X-Relay-Organization", options.organization);
-    }
-    if (options.project) {
-      headers.set("X-Relay-Project", options.project);
-    }
-    if (options.environment) {
-      headers.set("X-Relay-Environment", options.environment);
-    }
-    if (init.method && init.method !== "GET") {
-      headers.set("X-Relay-CSRF", "1");
-    }
-    const response = await fetch(options.baseUrl + path, {
-      ...init,
-      signal: init.signal ? AbortSignal.any([init.signal, AbortSignal.timeout(15e3)]) : AbortSignal.timeout(15e3),
-      headers
-    });
-    if (!response.ok) {
-      const value = await response.json().catch(() => null);
-      const error = errorSchema.safeParse(value);
-      throw new RelayError(
-        error.success ? error.data.error : `Request failed (${response.status})`,
-        response.status,
-        error.success ? error.data.missing : [],
-        error.success ? error.data.code : void 0
-      );
-    }
-    return response;
-  }
-  async function request(path, schema, init = {}) {
-    const response = await send(path, init);
-    const value = await response.json();
-    return schema.parse(value);
-  }
-  async function walletRequest(path, schema, init = {}) {
-    for (let attempt = 0; ; attempt++) {
-      let response;
-      try {
-        response = await send(path, init);
-      } catch (error) {
-        const transient = error instanceof RelayError && [500, 502, 503, 504].includes(error.status) || error instanceof TypeError || error instanceof DOMException && error.name === "TimeoutError";
-        if (!transient || attempt === 2) {
-          throw error;
-        }
-        await new Promise(
-          (resolve) => setTimeout(resolve, attempt === 0 ? 250 : 750)
-        );
-        continue;
-      }
-      const value = await response.json();
-      return schema.parse(value);
-    }
-  }
-  function query(path, values) {
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(values)) {
-      if (value !== void 0) {
-        params.set(key, String(value));
-      }
-    }
-    return path + "?" + params;
-  }
-  function json(body) {
-    return {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
-    };
-  }
-  function sessionHeaders(session) {
-    return { "Content-Type": "application/json", "X-Relay-Session": session };
-  }
-  const submission = submissions(
-    {
-      session: () => request("/v1/auth/session", sessionSchema.nullable()),
-      upload: (file, action, session) => request("/v1/me/evidence", evidenceSchema, {
-        method: "POST",
-        headers: {
-          "Content-Type": file.type,
-          "X-Relay-Upload-ID": action,
-          "X-Relay-Session": session
-        },
-        body: file
-      }),
-      claim: (input, session) => request("/v1/me/attempts", attemptSchema, {
-        ...json(input),
-        headers: {
-          "Content-Type": "application/json",
-          "X-Relay-Session": session
-        }
-      }),
-      retry: (attempt, session) => request(`/v1/attempts/${attempt}/retry`, attemptSchema, {
-        ...json({}),
-        headers: {
-          "Content-Type": "application/json",
-          "X-Relay-Session": session
-        }
-      })
-    },
-    options.submissionStore,
-    options.baseUrl
-  );
-  const observers = /* @__PURE__ */ new Set();
-  async function changeSession(task) {
-    for (const observer of observers) {
-      observer.clear();
-    }
-    try {
-      return await task();
-    } finally {
-      for (const observer of observers) {
-        void observer.refresh();
-      }
-    }
-  }
-  const experience = () => request("/v1/me/experience", questExperienceSchema);
-  async function getQuest(id) {
-    const quest = (await experience()).quests.find(
-      (q) => q.quest === id || q.key === id
-    );
-    if (!quest) {
-      throw new RelayError("Quest not found", 404);
-    }
-    return quest;
-  }
-  return {
-    referrals: {
-      list: () => request("/v1/referrals", z10.array(referralDefinitionSchema)),
-      summary: () => request("/v1/referrals/me", referralSummarySchema),
-      history: (before) => request(
-        query("/v1/referrals/history", { before }),
-        referralHistorySchema
-      ),
-      accept: (input) => request("/v1/referrals/accept", z10.object({ ok: z10.literal(true) }), {
-        method: "POST",
-        body: JSON.stringify(referralAcceptSchema.parse(input))
-      })
-    },
-    tieredRewards: {
-      /**
-       * The project's tiered rewards with their keys. Entitlements and reward
-       * definitions name them by ID: use this to find the ID for a key.
-       */
-      list: () => request("/v1/tiered-rewards", z10.array(tieredRewardReferenceSchema))
-    },
-    pointLedgers: {
-      /**
-       * The project's point ledgers with their keys and names. Reads return
-       * ledger IDs: use this to find the ID for a key, or a ledger's name.
-       */
-      list: () => request("/v1/point-ledgers", z10.array(pointLedgerReferenceSchema))
-    },
-    leaderboards: {
-      list: () => request("/v1/leaderboards", z10.array(leaderboardDefinitionSchema)),
-      standings: (board, options2 = {}) => {
-        const parsed = leaderboardQuerySchema.parse(options2);
-        return request(
-          query(`/v1/leaderboards/${identifier.parse(board)}`, parsed),
-          leaderboardPageSchema
-        );
-      },
-      /**
-       * A profile's current rank and score on `board` (`profile.id` from a leaderboard row or
-       * `profiles.mine()`). Needs the board's access, like `standings`; a profile this viewer
-       * cannot see is a 404, as in `profiles.get`.
-       */
-      placement: (board, profile) => request(
-        `/v1/leaderboards/${identifier.parse(board)}/profiles/${identifier.parse(profile)}`,
-        leaderboardPlacementSchema
-      )
-    },
-    /**
-     * Participant profiles: the display name and avatar other participants see where the project
-     * enables profiles in Console. Render an avatar with `avatarSrc(profile.avatar)`.
-     */
-    profiles: {
-      /** The signed-in member's own profile, whatever the project shows to others. */
-      mine: () => request("/v1/me/profile", ownProfileSchema),
-      /**
-       * Changes the member's own name, avatar choice or visibility; omitted fields stay, and null
-       * returns to the default. `session` (the ID the app read) makes a changed session a 409.
-       */
-      update: async (input, options2 = {}) => request("/v1/me/profile", ownProfileSchema, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          ...options2.session ? { "X-Relay-Session": options2.session } : {}
-        },
-        body: JSON.stringify(profileUpdateSchema.parse(input))
-      }),
-      /**
-       * Uploads a JPEG, PNG or WebP of at most 5 MB as the member's avatar. The server crops it to
-       * a 512×512 WebP without metadata. Retrying with the same `uploadId` is idempotent.
-       */
-      uploadAvatar: async (file, options2 = {}) => {
-        if (!avatarUploadTypes.includes(file.type)) {
-          throw new RelayError("Use a JPEG, PNG or WebP image", 400);
-        }
-        if (file.size > AVATAR_UPLOAD_LIMIT) {
-          throw new RelayError("Use an image smaller than 5 MB", 413);
-        }
-        return request("/v1/me/profile/avatar", ownProfileSchema, {
-          method: "POST",
-          headers: {
-            "Content-Type": file.type,
-            "X-Relay-Upload-ID": identifier.parse(
-              options2.uploadId ?? crypto.randomUUID()
-            ),
-            ...options2.session ? { "X-Relay-Session": options2.session } : {}
-          },
-          body: file
-        });
-      },
-      /**
-       * A profile's name and avatar by its public ID (`profile.id` from a leaderboard row or
-       * `mine()`). A profile that is missing, hidden or not visible to this viewer is a 404.
-       */
-      get: (profile) => request(
-        `/v1/profiles/${identifier.parse(profile)}`,
-        profileSummarySchema
-      ),
-      /**
-       * A page of the profile's completions of quests that show on profiles, most recently
-       * completed first. Pass the page's `nextCursor` as `cursor` for the next one.
-       */
-      completions: (profile, options2 = {}) => request(
-        query(
-          `/v1/profiles/${identifier.parse(profile)}/completions`,
-          profileCompletionQuerySchema.parse(options2)
-        ),
-        profileCompletionPageSchema
-      ),
-      /**
-       * The profile's invited and qualified counts and milestones in one referral program. Needs
-       * a signed-in participant, as referral programs do.
-       */
-      referral: (profile, program) => request(
-        `/v1/profiles/${identifier.parse(profile)}/referrals/${identifier.parse(program)}`,
-        profileReferralSchema
-      )
-    },
-    quests: {
-      get: getQuest,
-      retry: async (view) => {
-        if (view.trigger.kind === "automatic") {
-          throw new Error(
-            "Automatic quests recover without participant retries."
-          );
-        }
-        if (!view.attempt || view.attempt.status !== "failed") {
-          throw new Error("There is no failed attempt to retry.");
-        }
-        const session = await request(
-          "/v1/auth/session",
-          sessionSchema.nullable()
-        );
-        if (session?.principal.kind !== "member") {
-          throw new Error("Sign in to retry verification.");
-        }
-        return request(`/v1/attempts/${view.attempt.id}/retry`, attemptSchema, {
-          ...json({}),
-          headers: {
-            "Content-Type": "application/json",
-            "X-Relay-Session": session.id
-          }
-        });
-      },
-      experience,
-      collection: async (id) => {
-        const collection = (await experience()).collections.find(
-          (c) => c.id === id || c.key === id
-        );
-        if (!collection) {
-          throw new RelayError("Collection not found", 404);
-        }
-        return collection;
-      },
-      open: questActions(submission, getQuest),
-      observe: (listener, options2) => {
-        const observer = observeProgress(
-          {
-            session: (signal) => request("/v1/auth/session", sessionSchema.nullable(), { signal }),
-            progress: (session, signal) => request("/v1/me/experience", questExperienceSchema, {
-              signal,
-              headers: { "X-Relay-Session": session }
-            })
-          },
-          listener,
-          options2,
-          () => observers.delete(observer)
-        );
-        observers.add(observer);
-        observer.clear();
-        void observer.refresh();
-        return { refresh: observer.refresh, dispose: observer.dispose };
-      }
-    },
-    /** The signed-in member's linked Solana, EVM and Cosmos wallets for this project. */
-    wallets: {
-      list: () => walletRequest(
-        "/v1/me/wallets",
-        z10.object({ wallets: z10.array(linkedWalletSchema) })
-      ).then((result) => result.wallets),
-      challenge: (input, session) => walletRequest(
-        "/v1/me/wallets/challenge",
-        walletMessageChallengeSchema,
-        {
-          ...json(walletAddressInputSchema.parse(input)),
-          headers: sessionHeaders(session)
-        }
-      ),
-      verify: (input, session) => walletRequest("/v1/me/wallets/verify", linkedWalletSchema, {
-        ...json(walletSignatureSchema.parse(input)),
-        headers: sessionHeaders(session)
-      }),
-      /** The address stays bound to this member: another member still cannot link it. */
-      unlink: (wallet) => request(
-        "/v1/me/wallets/unlink",
-        z10.object({ ok: z10.literal(true) }),
-        json(
-          walletUnlinkInputSchema.parse({
-            chain: wallet.chain,
-            address: wallet.address
-          })
-        )
-      ),
-      /** Asks the signer for its address, signs the returned challenge, and links the wallet. */
-      link: async (signer) => {
-        const session = await request(
-          "/v1/auth/session",
-          sessionSchema.nullable()
-        );
-        if (!session) {
-          throw new RelayError("Sign in to continue", 401);
-        }
-        const challenge = await walletRequest(
-          "/v1/me/wallets/challenge",
-          walletMessageChallengeSchema,
-          {
-            ...json(
-              walletAddressInputSchema.parse(await walletAddressInput(signer))
-            ),
-            headers: sessionHeaders(session.id)
-          }
-        );
-        const proof = await signer.sign(challenge.message, challenge.address);
-        return walletRequest("/v1/me/wallets/verify", linkedWalletSchema, {
-          ...json(
-            walletSignatureSchema.parse({ challenge: challenge.id, ...proof })
-          ),
-          headers: sessionHeaders(session.id)
-        });
-      }
-    },
-    /** @deprecated Use `wallets` (multi-chain). This reads and replaces the newest Solana wallet. */
-    wallet: {
-      connection: () => walletRequest("/v1/me/wallet", walletConnectionSchema.nullable()),
-      challenge: (input, session) => walletRequest("/v1/me/wallet/challenge", walletChallengeSchema, {
-        ...json(walletChallengeInputSchema.parse(input)),
-        headers: sessionHeaders(session)
-      }),
-      verify: (input, session) => walletRequest("/v1/me/wallet/verify", walletConnectionSchema, {
-        ...json(walletProofSchema.parse(input)),
-        headers: sessionHeaders(session)
-      })
-    },
-    auth: {
-      providers: () => request(
-        "/v1/auth/providers",
-        z10.object({
-          providers: z10.array(
-            z10.object({
-              provider: authProviderSchema,
-              configured: z10.boolean()
-            })
-          ),
-          email: z10.boolean(),
-          /** The wallet sign-in this project enabled; older servers omit it. */
-          wallets: walletSignInNetworksSchema.default([]),
-          demo: z10.boolean()
-        })
-      ),
-      start: (provider, mode) => request(
-        "/v1/auth/start",
-        z10.object({ url: z10.string() }),
-        json({ provider, mode })
-      ),
-      emailStart: (email) => request(
-        "/v1/auth/email/start",
-        z10.object({ challenge: z10.string() }),
-        json({ email })
-      ),
-      emailVerify: (challenge, code) => changeSession(
-        () => request(
-          "/v1/auth/email/verify",
-          sessionSchema,
-          json({ challenge, code })
-        )
-      ),
-      /**
-       * Sign in, or sign up, with a Solana, EVM or Cosmos wallet where the project enabled it
-       * (`providers().wallets`). A wallet the member linked while signed in cannot sign in.
-       */
-      wallet: {
-        /** A sign-in challenge for the wallet's address; binds the flow to this browser. */
-        start: (input) => request(
-          "/v1/auth/wallet/start",
-          walletMessageChallengeSchema,
-          json(walletAddressInputSchema.parse(input))
-        ),
-        /** Verifies the signed challenge and starts the session. Not retried: start again instead. */
-        verify: (proof) => changeSession(
-          () => request(
-            "/v1/auth/wallet/verify",
-            sessionSchema,
-            json(walletSignatureSchema.parse(proof))
-          )
-        ),
-        /**
-         * Asks the signer for its address, signs the challenge and starts the session. Throws a
-         * `RelayError` with status 403 when the project has not enabled this wallet family.
-         */
-        signIn: async (signer) => {
-          const challenge = await request(
-            "/v1/auth/wallet/start",
-            walletMessageChallengeSchema,
-            json(
-              walletAddressInputSchema.parse(await walletAddressInput(signer))
-            )
-          );
-          const proof = await signer.sign(challenge.message, challenge.address);
-          return changeSession(
-            () => request(
-              "/v1/auth/wallet/verify",
-              sessionSchema,
-              json(
-                walletSignatureSchema.parse({
-                  challenge: challenge.id,
-                  ...proof
-                })
-              )
-            )
-          );
-        }
-      },
-      accounts: () => request("/v1/auth/accounts", z10.array(accountConnectionSchema)),
-      disconnect: (provider) => request(
-        "/v1/auth/accounts/disconnect",
-        z10.object({ ok: z10.boolean() }),
-        json({ provider })
-      ),
-      connections: () => request(
-        "/v1/auth/connections",
-        z10.array(
-          z10.object({
-            provider: z10.string(),
-            subject: z10.string(),
-            signInEnabled: z10.boolean()
-          })
-        )
-      ),
-      session: () => request("/v1/auth/session", sessionSchema.nullable()),
-      signOut: () => changeSession(
-        () => request("/v1/auth/logout", z10.object({ ok: z10.boolean() }), json({}))
-      ),
-      /** Local development only. Existing hosted apps use createParticipantBackend from /portal-proxy. */
-      exchange: (input) => request("/v1/auth/exchange", exchangeResultSchema, json(input))
-    },
-    me: {
-      /** The signed-in member, and the seed of their generated avatar: `defaultAvatar(avatarSeed)`. */
-      get: () => request("/v1/me", memberSummarySchema),
-      observeProgress: (listener, options2) => {
-        const observer = observeProgress(
-          {
-            session: (signal) => request("/v1/auth/session", sessionSchema.nullable(), { signal }),
-            progress: (session, signal) => request("/v1/me/progress", memberProgressSchema, {
-              signal,
-              headers: { "X-Relay-Session": session }
-            })
-          },
-          listener,
-          options2,
-          () => observers.delete(observer)
-        );
-        observers.add(observer);
-        observer.clear();
-        void observer.refresh();
-        return { refresh: observer.refresh, dispose: observer.dispose };
-      },
-      submission,
-      collectionPass: (entitlement, session) => request("/v1/me/collection-pass", collectionPassSchema, {
-        ...json({ entitlement: identifier.parse(entitlement) }),
-        headers: {
-          "Content-Type": "application/json",
-          "X-Relay-Session": session
-        }
-      }),
-      /** @deprecated The participant API does not verify passes. Verify them on your server and call `POST /management/v1/passes/verify`. */
-      linkPass: (code) => request("/v1/me/pass", attemptSchema, json({ code })),
-      progress: () => request("/v1/me/progress", memberProgressSchema),
-      rewardDeliveries: () => request("/v1/reward-deliveries", rewardDeliveriesSchema),
-      claim: (input, options2) => request("/v1/me/attempts", attemptSchema, {
-        ...json(input),
-        headers: {
-          "Content-Type": "application/json",
-          ...options2 ? { "X-Relay-Session": options2.session } : {}
-        }
-      }),
-      upload: (file) => request("/v1/me/evidence", evidenceSchema, {
-        method: "POST",
-        headers: { "Content-Type": file.type },
-        body: file
-      })
-    },
-    evidence: {
-      async download(id, requestOptions) {
-        const response = await send(
-          `/v1/evidence/${identifier.parse(id)}`,
-          requestOptions
-        );
-        const type = response.headers.get("Content-Type");
-        if (type !== "image/jpeg" && type !== "image/png") {
-          throw new RelayError("Unexpected evidence content type", 502);
-        }
-        return response.blob();
-      }
-    },
-    /** @deprecated The participant API accepts only member sessions and rejects this staff call. Use the management API with a management key instead. */
-    lookupMember: (issuer, subject) => request(
-      "/v1/members/lookup",
-      z10.object({ member: z10.string() }),
-      json({ issuer, subject })
-    ),
-    /** @deprecated Removed from the participant API. Build quests with `domino` and `@domino-sdk/relay/build`. */
-    journeyTemplate: () => request("/v1/journey-template", z10.array(templateSchema)),
-    /** @deprecated Removed from the participant API. Build quests with `domino` and `@domino-sdk/relay/build`. */
-    template: () => request("/v1/template", templateSchema),
-    /** @deprecated The participant API accepts only member sessions and rejects this staff call. Use the management API with a management key instead. */
-    snapshot: () => request("/v1/snapshot", snapshotSchema),
-    /** @deprecated The participant API rejects publication. Publish with `domino deploy` or the management API. */
-    publish: (release) => request("/v1/releases", publishedReleaseSchema, json(release)),
-    /** @deprecated The participant API rejects publication. Publish with `domino deploy` or the management API. */
-    publishBatch: (releases) => request(
-      "/v1/releases/batch",
-      z10.array(publishedReleaseSchema),
-      json({ releases })
-    ),
-    progress: (member) => request(
-      `/v1/members/${encodeURIComponent(member)}/progress`,
-      memberProgressSchema
-    ),
-    /** @deprecated The participant API accepts only member sessions and rejects this staff call. Use the management API with a management key instead. */
-    beginHandover: (id, input) => request(`/v1/entitlements/${id}/begin`, entitlementSchema, json(input)),
-    /** @deprecated The participant API accepts only member sessions and rejects this staff call. Use the management API with a management key instead. */
-    confirmHandover: (id, input) => request(`/v1/entitlements/${id}/confirm`, entitlementSchema, json(input)),
-    upload: (member, file) => request(
-      `/v1/evidence?member=${encodeURIComponent(member)}`,
-      evidenceSchema,
-      {
-        method: "POST",
-        headers: { "Content-Type": file.type },
-        body: file
-      }
-    ),
-    engagement: {
-      boundaries: (input) => request(
-        "/v1/engagement/boundaries?" + new URLSearchParams(
-          Object.entries(engagementPageQuerySchema.parse(input)).flatMap(
-            ([key, value]) => value === void 0 ? [] : [[key, String(value)]]
-          )
-        ).toString(),
-        engagementBoundaryPageSchema
-      ),
-      page: (input) => request(
-        "/v1/engagement/history?" + new URLSearchParams(
-          Object.entries(engagementPageQuerySchema.parse(input)).flatMap(
-            ([key, value]) => value === void 0 ? [] : [[key, String(value)]]
-          )
-        ).toString(),
-        engagementPageSchema
-      )
-    },
-    content: {
-      performance: (input) => request(
-        "/v1/content/performance?" + new URLSearchParams(
-          Object.entries(
-            contentPerformanceQuerySchema.parse(input)
-          ).flatMap(
-            ([key, value]) => value === void 0 ? [] : [[key, String(value)]]
-          )
-        ).toString(),
-        contentPerformancePageSchema
-      ),
-      qualifications: (input) => request(
-        "/v1/content/qualifications?" + new URLSearchParams(
-          Object.entries(
-            contentQualificationQuerySchema.parse(input)
-          ).flatMap(
-            ([key, value]) => value === void 0 ? [] : [[key, String(value)]]
-          )
-        ).toString(),
-        contentQualificationPageSchema
-      ),
-      admissions: (input) => request(
-        "/v1/content/admissions?" + new URLSearchParams(
-          Object.entries(contentAdmissionQuerySchema.parse(input)).flatMap(
-            ([key, value]) => value === void 0 ? [] : [[key, value]]
-          )
-        ).toString(),
-        contentAdmissionPageSchema
-      ),
-      enroll: (input) => request(
-        "/v1/content/enrollments",
-        contentEnrollmentSchema,
-        json(contentEnrollmentInputSchema.parse(input))
-      ),
-      claim: (input) => request(
-        "/v1/content/claims",
-        contentAdmissionSchema,
-        json(contentReleaseInputSchema.parse(input))
-      )
-    },
-    submit: (input) => request("/v1/attempts", attemptSchema, json(input)),
-    retry: (id) => request(`/v1/attempts/${id}/retry`, attemptSchema, json({})),
-    /** @deprecated The participant API accepts only member sessions and rejects this staff call. Use the management API with a management key instead. */
-    decide: (id, input) => request(`/v1/attempts/${id}/review`, attemptSchema, json(input))
-  };
-}
-
-export {
-  pointLedgerPropertiesSchema,
-  createPointLedgerSchema,
-  pointLedgerSchema,
-  pointLedgerDeclarationSchema,
-  pointLedgerReferenceSchema,
-  rewardDeliverySchema,
-  rewardDeliveriesSchema,
-  interactionSchema,
-  questInteraction,
-  questTypeVersionSchema,
-  collectionSlotSchema,
-  collectionSlotDeclarationSchema,
-  questCollectionSchema,
-  questInstanceSchema,
-  questDraftChangesSchema,
-  questDraftSchema,
-  questCatalogSchema,
-  catalogDeploymentSchema,
-  catalogDeploymentPreviewSchema,
-  saveQuestDraftSchema,
-  publishQuestDraftSchema,
-  questRewardViewSchema,
-  questViewSchema,
-  collectionViewSchema,
-  questExperienceSchema,
-  questPublicationPreviewSchema,
-  allocateQuestSchema,
-  allocatedQuestSchema,
-  RelayError,
-  QuestUpdatedError,
-  reconcileQuestDraft,
-  questActions,
-  avatarSrc,
-  defaultAvatar,
-  defaultAvatarSvg,
-  walletAvatarSeed,
-  collectionCodeSchema,
-  collectionPassSchema,
-  collectionResolveSchema,
-  collectionBeginSchema,
-  collectionPreviewSchema,
-  questConfiguration,
-  xIdSchema,
-  xConnectionSchema,
-  xProfileSchema,
-  xPostSchema,
-  xRequestSchema,
-  imageReferenceSchema,
-  imageFieldSchema,
-  imageFieldsSchema,
-  imageRequestSchema,
-  imageInspectionSchema,
-  imageComparisonSchema,
-  imageExtractionSchema,
-  imageSightingsSchema,
-  imageAssetArtifactSchema,
-  imageUploadRequestSchema,
-  imageUploadsSchema,
-  publishedImageSchema,
-  parseImageExtraction,
-  parseImageResult,
-  projectCatalogArtifactSchema,
-  projectDeploymentSchema,
-  deploymentPreviewSchema,
-  publishDeploymentSchema,
-  deploymentResultSchema,
-  identityIntegrationInputSchema,
-  identityIntegrationSchema,
-  identityIntegrationSecretSchema,
-  participantExchangeSchema,
-  createRelayClient
-};