@domino-sdk/relay 0.1.0

package/dist/chunk-NC3UAP6T.js

@@ -0,0 +1,1056 @@
+import {
+  attemptSchema,
+  entitlementSchema,
+  errorSchema,
+  evidenceSchema,
+  identifier,
+  memberListSchema,
+  memberPageSchema,
+  memberProgressSchema,
+  pickupAvailabilitySchema,
+  pickupSelectionSchema,
+  publishedReleaseSchema,
+  questDescriptionSchema,
+  quizEvidenceSchema,
+  releaseSchema,
+  reviewListSchema,
+  reviewModeSchema,
+  reviewPageSchema,
+  settingsValuesSchema,
+  snapshotSchema,
+  templateSchema
+} from "./chunk-C2KOMNLG.js";
+
+// src/catalog.ts
+import { z } from "zod";
+var interactionSchema = z.enum([
+  "photo",
+  "quiz",
+  "claim",
+  "staff",
+  "automatic"
+]);
+function questInteraction(trigger) {
+  return trigger.kind === "automatic" ? "automatic" : trigger.actor === "staff" ? "staff" : trigger.input === "none" ? "claim" : trigger.input;
+}
+var questTypeVersionSchema = z.object({
+  id: identifier,
+  version: identifier,
+  code: z.string(),
+  definition: questDescriptionSchema,
+  provider: reviewModeSchema,
+  createdAt: z.number()
+});
+var collectionSlotSchema = z.object({ id: identifier, title: z.string().trim().min(1).max(120) }).strict();
+var questCollectionSchema = collectionSlotSchema.extend({
+  quests: z.array(identifier).max(100).refine(
+    (v) => new Set(v).size === v.length,
+    "A collection can contain a quest only once"
+  )
+});
+var questInstanceSchema = z.object({
+  id: identifier,
+  title: z.string().trim().min(1).max(120),
+  typeVersion: identifier,
+  settings: settingsValuesSchema,
+  requires: z.array(identifier).max(30),
+  status: z.enum(["active", "paused", "archived"])
+}).strict();
+var questDraftChangesSchema = z.object({
+  quests: z.array(
+    questInstanceSchema.extend({ expectedRelease: identifier.nullable() })
+  ).max(50),
+  collections: z.array(questCollectionSchema).max(50)
+}).strict();
+var draftBase = z.object({
+  id: identifier,
+  revision: z.number().int().positive(),
+  baseRevision: z.number().int().nonnegative(),
+  changes: questDraftChangesSchema
+});
+var questDraftSchema = z.discriminatedUnion("status", [
+  draftBase.extend({ status: z.literal("draft") }),
+  draftBase.extend({
+    status: z.literal("published"),
+    releaseIds: z.array(identifier)
+  })
+]);
+var questCatalogSchema = z.object({
+  revision: z.number().int().nonnegative(),
+  types: z.array(questTypeVersionSchema),
+  collections: z.array(questCollectionSchema),
+  quests: z.array(questInstanceSchema),
+  drafts: z.array(questDraftSchema),
+  releases: z.array(publishedReleaseSchema).default([]),
+  supportedInteractions: z.array(interactionSchema)
+});
+var catalogDeploymentSchema = z.object({
+  expectedRevision: z.number().int().nonnegative(),
+  types: z.array(
+    z.object({
+      code: z.string().min(1).max(1e6),
+      provider: reviewModeSchema
+    })
+  ).max(50).default([]),
+  collections: z.array(collectionSlotSchema).max(50).default([]),
+  supportedInteractions: z.array(interactionSchema).min(1).optional()
+}).strict();
+var catalogDeploymentPreviewSchema = z.object({
+  revision: z.number().int().nonnegative(),
+  types: z.array(questTypeVersionSchema),
+  collections: z.array(collectionSlotSchema),
+  supportedInteractions: z.array(interactionSchema)
+});
+var saveQuestDraftSchema = z.object({
+  id: identifier,
+  expectedRevision: z.number().int().nonnegative(),
+  baseRevision: z.number().int().nonnegative(),
+  changes: questDraftChangesSchema
+}).strict();
+var publishQuestDraftSchema = z.object({ id: identifier, expectedRevision: z.number().int().positive() }).strict();
+var questViewSchema = memberProgressSchema.shape.quests.element.extend(
+  {
+    release: identifier,
+    interaction: interactionSchema,
+    lifecycle: z.enum(["active", "paused", "archived"]),
+    rewards: z.array(z.object({ label: z.string() }))
+  }
+);
+var collectionViewSchema = z.object({
+  id: identifier,
+  title: z.string(),
+  quests: z.array(questViewSchema)
+});
+var questExperienceSchema = z.object({
+  member: identifier,
+  quests: z.array(questViewSchema),
+  collections: z.array(collectionViewSchema)
+});
+var questPublicationPreviewSchema = z.object({
+  draft: questDraftSchema,
+  releases: z.array(publishedReleaseSchema),
+  affectedCollections: z.array(questCollectionSchema)
+});
+
+// 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 z2 } from "zod";
+var common = {
+  id: identifier,
+  quest: identifier,
+  release: identifier.optional()
+};
+var claimInputSchema = z2.union([
+  quizEvidenceSchema,
+  z2.object({ kind: z2.literal("none") }).strict()
+]);
+var draftSchema = z2.union([
+  claimInputSchema,
+  z2.object({ kind: z2.literal("photo"), file: z2.instanceof(Blob) })
+]);
+var recordSchema = z2.union([
+  z2.object({
+    ...common,
+    stage: z2.literal("review"),
+    draft: draftSchema.nullable()
+  }),
+  z2.object({ ...common, stage: z2.literal("upload"), file: z2.instanceof(Blob) }),
+  z2.object({
+    ...common,
+    stage: z2.literal("claim"),
+    evidence: identifier,
+    file: z2.instanceof(Blob).optional()
+  }),
+  z2.object({
+    ...common,
+    stage: z2.literal("submitted"),
+    evidence: identifier,
+    attempt: identifier
+  }),
+  z2.object({ ...common, stage: z2.literal("claim"), input: claimInputSchema }),
+  z2.object({
+    ...common,
+    stage: z2.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 === "quiz" ? { 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 === 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") return previous;
+        }
+        await store.write(key, record);
+        return resumeRecord(record);
+      });
+    }
+    const handle = {
+      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 === "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 === "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
+      });
+      return {
+        kind: "status",
+        view,
+        status: handle.status,
+        resume: () => run(handle.resume)
+      };
+    }
+    switch (view.interaction) {
+      case "photo": {
+        const handle = await submission(view.quest, {
+          input: "photo",
+          release: view.release,
+          recoverPrevious: true
+        });
+        return {
+          kind: "photo",
+          view,
+          status: handle.status,
+          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
+        });
+        return {
+          kind: "quiz",
+          view,
+          status: handle.status,
+          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
+        });
+        return {
+          kind: "claim",
+          view,
+          status: handle.status,
+          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 z7 } from "zod";
+
+// src/auth.ts
+import { z as z3 } from "zod";
+var authScopeSchema = z3.object({
+  organization: identifier,
+  project: identifier,
+  environment: z3.enum(["test", "live"])
+}).strict();
+var principalSchema = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("member"), member: identifier }).strict(),
+  z3.object({ kind: z3.literal("staff"), subject: identifier }).strict(),
+  z3.object({ kind: z3.literal("operator"), subject: identifier }).strict()
+]);
+var sessionSchema = authScopeSchema.extend({
+  id: identifier,
+  principal: principalSchema,
+  expiresAt: z3.number()
+});
+var exchangeSchema = authScopeSchema.extend({
+  identity: z3.object({ issuer: identifier, subject: z3.string().min(1).max(200) }).strict(),
+  role: z3.enum(["member", "staff", "operator"])
+}).strict();
+var exchangeResultSchema = z3.object({
+  token: z3.string(),
+  session: sessionSchema
+});
+
+// src/wallet.ts
+import { z as z4 } from "zod";
+var solanaAddressSchema = z4.string().min(32).max(44).regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
+var walletConnectionSchema = z4.object({
+  chain: z4.literal("solana"),
+  address: solanaAddressSchema,
+  verifiedAt: z4.number().int().nonnegative(),
+  revision: z4.number().int().positive()
+}).strict();
+var walletChallengeInputSchema = z4.object({
+  chain: z4.literal("solana"),
+  address: solanaAddressSchema
+}).strict();
+var walletChallengeSchema = walletChallengeInputSchema.extend({
+  id: z4.string().uuid(),
+  message: z4.string(),
+  expiresAt: z4.number()
+});
+var walletProofSchema = z4.object({
+  challenge: z4.string().uuid(),
+  signature: z4.string().min(64).max(88).regex(/^[1-9A-HJ-NP-Za-km-z]+$/)
+}).strict();
+var solanaBalanceSchema = z4.object({
+  address: solanaAddressSchema,
+  network: z4.literal("mainnet-beta"),
+  lamports: z4.string().regex(/^(0|[1-9][0-9]*)$/),
+  slot: z4.number().int().nonnegative().safe(),
+  observedAt: z4.number().int().nonnegative()
+}).strict();
+
+// 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 z6 } from "zod";
+var projectDeploymentSchema = catalogDeploymentSchema.omit({ expectedRevision: true }).extend({
+  releases: z6.array(releaseSchema).max(50).default([])
+}).refine(
+  (value) => value.releases.length > 0 || value.types.length > 0 || value.collections.length > 0 || value.supportedInteractions !== void 0,
+  "No resources configured. Add quests, questTypes, collections, or supportedInteractions to relay.json."
+);
+var deploymentPreviewSchema = z6.object({
+  id: identifier,
+  baseRevision: z6.number().int().nonnegative(),
+  releases: z6.array(publishedReleaseSchema),
+  types: z6.array(questTypeVersionSchema),
+  collections: z6.array(questCollectionSchema),
+  supportedInteractions: z6.array(interactionSchema)
+});
+var publishDeploymentSchema = z6.object({ id: identifier }).strict();
+var deploymentResultSchema = deploymentPreviewSchema.extend({
+  revision: z6.number().int().positive()
+});
+
+// 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)
+    };
+  }
+  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);
+    if (!quest) throw new RelayError("Quest not found", 404);
+    return quest;
+  }
+  return {
+    quests: {
+      get: getQuest,
+      retry: async (view) => {
+        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
+        );
+        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 };
+      }
+    },
+    wallet: {
+      connection: () => walletRequest("/v1/me/wallet", walletConnectionSchema.nullable()),
+      challenge: (input, session) => walletRequest("/v1/me/wallet/challenge", walletChallengeSchema, {
+        ...json(walletChallengeInputSchema.parse(input)),
+        headers: {
+          "Content-Type": "application/json",
+          "X-Relay-Session": session
+        }
+      }),
+      verify: (input, session) => walletRequest("/v1/me/wallet/verify", walletConnectionSchema, {
+        ...json(walletProofSchema.parse(input)),
+        headers: {
+          "Content-Type": "application/json",
+          "X-Relay-Session": session
+        }
+      })
+    },
+    auth: {
+      providers: () => request(
+        "/v1/auth/providers",
+        z7.object({
+          providers: z7.array(
+            z7.object({
+              provider: z7.enum(["google", "apple", "x", "discord"]),
+              configured: z7.boolean()
+            })
+          ),
+          email: z7.boolean(),
+          demo: z7.boolean()
+        })
+      ),
+      start: (provider, mode) => request(
+        "/v1/auth/start",
+        z7.object({ url: z7.string() }),
+        json({ provider, mode })
+      ),
+      emailStart: (email) => request(
+        "/v1/auth/email/start",
+        z7.object({ challenge: z7.string() }),
+        json({ email })
+      ),
+      emailVerify: (challenge, code) => changeSession(
+        () => request(
+          "/v1/auth/email/verify",
+          sessionSchema,
+          json({ challenge, code })
+        )
+      ),
+      connections: () => request(
+        "/v1/auth/connections",
+        z7.array(
+          z7.object({
+            provider: z7.string(),
+            subject: z7.string(),
+            signInEnabled: z7.boolean()
+          })
+        )
+      ),
+      session: () => request("/v1/auth/session", sessionSchema.nullable()),
+      demoSignIn: (code) => changeSession(
+        () => request("/v1/auth/demo", sessionSchema, json({ code }))
+      ),
+      signOut: () => changeSession(
+        () => request("/v1/auth/logout", z7.object({ ok: z7.boolean() }), json({}))
+      ),
+      exchange: (input) => request("/v1/auth/exchange", exchangeResultSchema, json(input))
+    },
+    me: {
+      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
+        }
+      }),
+      linkPass: (code) => request("/v1/me/pass", attemptSchema, json({ code })),
+      progress: () => request("/v1/me/progress", memberProgressSchema),
+      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
+      })
+    },
+    reviews: {
+      list: (options2 = {}, requestOptions) => request(
+        query("/v1/reviews", reviewListSchema.parse(options2)),
+        reviewPageSchema,
+        requestOptions
+      )
+    },
+    members: {
+      list: (options2 = {}, requestOptions) => request(
+        query("/v1/members", memberListSchema.parse(options2)),
+        memberPageSchema,
+        requestOptions
+      )
+    },
+    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();
+      }
+    },
+    lookupMember: (issuer, subject) => request(
+      "/v1/members/lookup",
+      z7.object({ member: z7.string() }),
+      json({ issuer, subject })
+    ),
+    journeyTemplate: () => request("/v1/journey-template", z7.array(templateSchema)),
+    template: () => request("/v1/template", templateSchema),
+    snapshot: () => request("/v1/snapshot", snapshotSchema),
+    publish: (release) => request("/v1/releases", publishedReleaseSchema, json(release)),
+    publishBatch: (releases) => request(
+      "/v1/releases/batch",
+      z7.array(publishedReleaseSchema),
+      json({ releases })
+    ),
+    progress: (member) => request(
+      `/v1/members/${encodeURIComponent(member)}/progress`,
+      memberProgressSchema
+    ),
+    beginHandover: (id, input) => request(`/v1/entitlements/${id}/begin`, entitlementSchema, json(input)),
+    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
+      }
+    ),
+    submit: (input) => request("/v1/attempts", attemptSchema, json(input)),
+    retry: (id) => request(`/v1/attempts/${id}/retry`, attemptSchema, json({})),
+    decide: (id, input) => request(`/v1/attempts/${id}/review`, attemptSchema, json(input))
+  };
+}
+
+export {
+  interactionSchema,
+  questInteraction,
+  questTypeVersionSchema,
+  collectionSlotSchema,
+  questCollectionSchema,
+  questInstanceSchema,
+  questDraftChangesSchema,
+  questDraftSchema,
+  questCatalogSchema,
+  catalogDeploymentSchema,
+  catalogDeploymentPreviewSchema,
+  saveQuestDraftSchema,
+  publishQuestDraftSchema,
+  questViewSchema,
+  collectionViewSchema,
+  questExperienceSchema,
+  questPublicationPreviewSchema,
+  RelayError,
+  QuestUpdatedError,
+  reconcileQuestDraft,
+  questActions,
+  authScopeSchema,
+  principalSchema,
+  sessionSchema,
+  exchangeSchema,
+  exchangeResultSchema,
+  solanaAddressSchema,
+  walletConnectionSchema,
+  walletChallengeInputSchema,
+  walletChallengeSchema,
+  walletProofSchema,
+  solanaBalanceSchema,
+  collectionCodeSchema,
+  collectionPassSchema,
+  collectionResolveSchema,
+  collectionBeginSchema,
+  collectionPreviewSchema,
+  questConfiguration,
+  projectDeploymentSchema,
+  deploymentPreviewSchema,
+  publishDeploymentSchema,
+  deploymentResultSchema,
+  createRelayClient
+};