@domino-sdk/relay 1.0.0-next.6 → 1.0.0-next.8

package/dist/browser.js

@@ -11,12 +11,12 @@ import {
   signInOptions,
   solanaSigner,
   walletStandardSolanaSigner
-} from "./chunk-RTHN22KO.js";
-import "./chunk-ERBVT7GE.js";
-import "./chunk-ZKJBCQNI.js";
-import "./chunk-5IIWKDFX.js";
-import "./chunk-XEQDW7FM.js";
-import "./chunk-BRESOTKV.js";
+} from "./chunk-6A6K5RUD.js";
+import "./chunk-V5R2DMGY.js";
+import "./chunk-MRIURJE3.js";
+import "./chunk-V7EZUZ3Z.js";
+import "./chunk-QBOHLT7M.js";
+import "./chunk-VARGF4JS.js";
 export {
   browserSubmissionStore,
   cosmosChainList,

package/dist/{chunk-RTHN22KO.js → chunk-6A6K5RUD.js}

@@ -1,9 +1,11 @@
 import {
   createRelayClient
-} from "./chunk-ERBVT7GE.js";
+} from "./chunk-V5R2DMGY.js";
 import {
+  RelayErrorCode,
+  clientError,
   cosmosChain
-} from "./chunk-XEQDW7FM.js";
+} from "./chunk-V7EZUZ3Z.js";
 
 // src/base58.ts
 var alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
@@ -494,16 +496,27 @@ function browserSubmissionStore() {
   let database;
   function open() {
     if (!globalThis.indexedDB || !globalThis.navigator?.locks) {
-      throw new Error(
-        "This browser cannot safely save submissions. Use a browser with IndexedDB and Web Locks enabled."
+      throw clientError(
+        "This browser cannot safely save submissions. Use a browser with IndexedDB and Web Locks enabled.",
+        RelayErrorCode.SubmissionStorage
       );
     }
     return database ??= new Promise((resolve, reject) => {
       const request = indexedDB.open("domino-relay-submissions", 1);
       request.onupgradeneeded = () => request.result.createObjectStore("submissions");
-      request.onerror = () => reject(new Error("Could not open submission storage"));
+      request.onerror = () => reject(
+        clientError(
+          "Could not open submission storage",
+          RelayErrorCode.SubmissionStorage
+        )
+      );
       request.onsuccess = () => resolve(request.result);
-      request.onblocked = () => reject(new Error("Close other Relay tabs and try again"));
+      request.onblocked = () => reject(
+        clientError(
+          "Close other Relay tabs and try again",
+          RelayErrorCode.SubmissionStorage
+        )
+      );
     });
   }
   async function transact(key, value) {
@@ -518,8 +531,9 @@ function browserSubmissionStore() {
       const request = value === void 0 ? store.get(key) : store.put(value, key);
       transaction.oncomplete = () => resolve(request.result);
       transaction.onerror = transaction.onabort = () => reject(
-        new Error(
-          "Could not save submission progress. Resume the saved submission when browser storage is available."
+        clientError(
+          "Could not save submission progress. Resume the saved submission when browser storage is available.",
+          RelayErrorCode.SubmissionStorage
         )
       );
     });

package/dist/chunk-77H7APVD.js

@@ -0,0 +1,171 @@
+import {
+  identifier,
+  xTweetSchema
+} from "./chunk-VARGF4JS.js";
+
+// src/x.ts
+import { z } from "zod";
+var xIdSchema = z.string().regex(/^[0-9]{1,20}$/);
+var xConnectionSchema = z.object({ userId: xIdSchema });
+var xProfileSchema = z.object({
+  id: xIdSchema,
+  username: z.string(),
+  name: z.string(),
+  bio: z.string().nullable(),
+  profileImageUrl: z.string().url().nullable(),
+  followersCount: z.number().int().nonnegative().nullable(),
+  verified: z.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: z.unknown().transform(
+    (value) => z.array(z.object({ type: z.string(), url: z.string() })).safeParse(value).data ?? []
+  )
+});
+var xRequestSchema = z.discriminatedUnion("operation", [
+  z.object({ operation: z.literal("connection") }).strict(),
+  z.object({ operation: z.literal("profile") }).strict(),
+  z.object({ operation: z.literal("post"), postId: xIdSchema }).strict(),
+  z.object({ operation: z.literal("follows"), userId: xIdSchema }).strict(),
+  z.object({ operation: z.literal("reposted"), postId: xIdSchema }).strict()
+]);
+
+// src/images.ts
+import { z as z2 } from "zod";
+var imageReferenceSchema = z2.union([
+  z2.strictObject({ evidence: z2.string().min(1).max(256) }),
+  z2.strictObject({ x: z2.literal("profile") }),
+  z2.strictObject({
+    x: z2.literal("post"),
+    postId: xIdSchema,
+    index: z2.number().int().min(0).max(3).default(0)
+  }),
+  z2.strictObject({ asset: identifier })
+]);
+var criteria = z2.string().trim().min(1).max(2e3);
+var imageFieldSchema = z2.strictObject({
+  type: z2.enum(["string", "number", "boolean"]),
+  description: z2.string().trim().min(1).max(500)
+});
+var imageFieldsSchema = z2.record(z2.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 = z2.discriminatedUnion("operation", [
+  z2.strictObject({
+    operation: z2.literal("inspect"),
+    image: imageReferenceSchema
+  }),
+  z2.strictObject({
+    operation: z2.literal("compare"),
+    images: z2.tuple([imageReferenceSchema, imageReferenceSchema])
+  }),
+  z2.strictObject({
+    operation: z2.literal("review"),
+    images: z2.array(imageReferenceSchema).min(1).max(4),
+    criteria
+  }),
+  z2.strictObject({
+    operation: z2.literal("extract"),
+    image: imageReferenceSchema,
+    fields: imageFieldsSchema
+  }),
+  z2.strictObject({
+    operation: z2.literal("seen"),
+    image: imageReferenceSchema,
+    maxDistance: z2.number().int().min(0).max(8).default(8)
+  })
+]);
+var hash = z2.string().regex(/^[0-9a-f]{16}$/);
+var imageInspectionSchema = z2.strictObject({
+  width: z2.number().int().positive(),
+  height: z2.number().int().positive(),
+  format: z2.enum(["jpeg", "png", "webp", "gif", "avif"]),
+  bytes: z2.number().int().positive(),
+  sha256: z2.string().regex(/^[0-9a-f]{64}$/),
+  phash: hash,
+  dhash: hash
+});
+var distance = z2.number().int().min(0).max(64);
+var imageComparisonSchema = z2.strictObject({
+  identical: z2.boolean(),
+  phashDistance: distance,
+  dhashDistance: distance
+});
+var imageExtractionSchema = z2.strictObject({
+  values: z2.record(
+    z2.string(),
+    z2.union([z2.string().max(2e3), z2.number(), z2.boolean(), z2.null()])
+  ),
+  reason: z2.string().min(1).max(2e3)
+});
+var imageSightingsSchema = z2.strictObject({
+  matches: z2.number().int().nonnegative(),
+  closestDistance: distance.nullable(),
+  firstSeenAt: z2.number().int().nonnegative().nullable()
+});
+var sha256 = z2.string().regex(/^[0-9a-f]{64}$/);
+var imageSize = z2.number().int().positive().max(5 * 1024 * 1024);
+var imageAssetArtifactSchema = z2.strictObject({
+  key: identifier,
+  sha256,
+  size: imageSize,
+  path: z2.string().min(1).max(500).optional()
+});
+var imageUploadRequestSchema = z2.strictObject({
+  images: z2.array(
+    z2.strictObject({
+      sha256,
+      size: imageSize,
+      type: z2.enum(["image/jpeg", "image/png", "image/webp"])
+    })
+  ).min(1).max(10)
+});
+var imageUploadsSchema = z2.strictObject({
+  images: z2.array(
+    z2.strictObject({
+      sha256,
+      upload: z2.strictObject({
+        url: z2.string().url(),
+        headers: z2.record(z2.string(), z2.string()),
+        expiresAt: z2.number().int().positive()
+      }).nullable()
+    })
+  )
+});
+var publishedImageSchema = z2.strictObject({
+  key: identifier,
+  sha256,
+  type: z2.enum(["image/jpeg", "image/png", "image/webp"]),
+  size: imageSize,
+  width: z2.number().int().positive(),
+  height: z2.number().int().positive()
+});
+
+export {
+  xIdSchema,
+  xConnectionSchema,
+  xProfileSchema,
+  xPostSchema,
+  xRequestSchema,
+  imageReferenceSchema,
+  imageFieldSchema,
+  imageFieldsSchema,
+  imageRequestSchema,
+  imageInspectionSchema,
+  imageComparisonSchema,
+  imageExtractionSchema,
+  imageSightingsSchema,
+  imageAssetArtifactSchema,
+  imageUploadRequestSchema,
+  imageUploadsSchema,
+  publishedImageSchema
+};

package/dist/chunk-MRIURJE3.js

@@ -0,0 +1,257 @@
+import {
+  authoringIdentityShape,
+  normalizeAuthoringIdentity,
+  validateAuthoringIdentity
+} from "./chunk-V7EZUZ3Z.js";
+import {
+  entitlementSchema,
+  identifier,
+  memberProgressSchema,
+  pickupAvailabilitySchema,
+  pickupSelectionSchema,
+  publishedReleaseSchema,
+  questDescriptionSchema,
+  reviewModeSchema,
+  settingsValuesSchema,
+  storedReviewModeSchema,
+  tieredRewardReferenceSchema
+} from "./chunk-VARGF4JS.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/catalog.ts
+import { z as z2 } from "zod";
+var interactionSchema = z2.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 = z2.object({
+  key: identifier.optional(),
+  id: identifier,
+  version: identifier,
+  code: z2.string(),
+  definition: questDescriptionSchema,
+  provider: storedReviewModeSchema,
+  createdAt: z2.number()
+});
+var collectionSlotSchema = z2.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z2.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: z2.array(identifier).max(100).refine(
+    (v) => new Set(v).size === v.length,
+    "A collection can contain a quest only once"
+  )
+});
+var questInstanceSchema = z2.object({
+  id: identifier,
+  title: z2.string().trim().min(1).max(120),
+  typeVersion: identifier,
+  settings: settingsValuesSchema,
+  requires: z2.array(identifier).max(30),
+  status: z2.enum(["active", "paused", "archived"])
+}).strict();
+var questDraftChangesSchema = z2.object({
+  quests: z2.array(
+    questInstanceSchema.extend({ expectedRelease: identifier.nullable() })
+  ).max(50),
+  collections: z2.array(questCollectionSchema).max(50)
+}).strict();
+var draftBase = z2.object({
+  id: identifier,
+  revision: z2.number().int().positive(),
+  baseRevision: z2.number().int().nonnegative(),
+  changes: questDraftChangesSchema
+});
+var questDraftSchema = z2.discriminatedUnion("status", [
+  draftBase.extend({ status: z2.literal("draft") }),
+  draftBase.extend({
+    status: z2.literal("published"),
+    releaseIds: z2.array(identifier)
+  })
+]);
+var questCatalogSchema = z2.object({
+  revision: z2.number().int().nonnegative(),
+  types: z2.array(questTypeVersionSchema),
+  collections: z2.array(questCollectionSchema),
+  quests: z2.array(questInstanceSchema),
+  drafts: z2.array(questDraftSchema),
+  releases: z2.array(publishedReleaseSchema).default([]),
+  supportedInteractions: z2.array(interactionSchema)
+});
+var catalogDeploymentSchema = z2.object({
+  expectedRevision: z2.number().int().nonnegative(),
+  types: z2.array(
+    z2.object({
+      code: z2.string().min(1).max(1e6),
+      provider: reviewModeSchema
+    })
+  ).max(50).default([]),
+  collections: z2.array(collectionSlotDeclarationSchema).max(50).default([]),
+  supportedInteractions: z2.array(interactionSchema).min(1).optional()
+}).strict();
+var catalogDeploymentPreviewSchema = z2.object({
+  revision: z2.number().int().nonnegative(),
+  types: z2.array(questTypeVersionSchema),
+  collections: z2.array(collectionSlotSchema),
+  supportedInteractions: z2.array(interactionSchema)
+});
+var saveQuestDraftSchema = z2.object({
+  id: identifier.optional(),
+  actionId: identifier,
+  expectedRevision: z2.number().int().nonnegative(),
+  baseRevision: z2.number().int().nonnegative(),
+  changes: questDraftChangesSchema
+}).strict();
+var publishQuestDraftSchema = z2.object({ id: identifier, expectedRevision: z2.number().int().positive() }).strict();
+var questRewardViewSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("points"),
+    label: z2.string(),
+    amount: z2.number().int().nonnegative(),
+    ledger: pointLedgerReferenceSchema
+  }),
+  z2.object({
+    kind: z2.literal("tier"),
+    label: z2.string(),
+    reward: tieredRewardReferenceSchema.extend({ title: z2.string() }),
+    tier: identifier
+  }),
+  z2.object({ kind: z2.literal("integration"), label: z2.string() })
+]);
+var questViewSchema = memberProgressSchema.shape.quests.element.extend(
+  {
+    release: identifier,
+    interaction: interactionSchema,
+    lifecycle: z2.enum(["active", "paused", "archived"]),
+    rewards: z2.array(questRewardViewSchema)
+  }
+);
+var collectionViewSchema = z2.object({
+  key: identifier.optional(),
+  id: identifier,
+  title: z2.string(),
+  quests: z2.array(questViewSchema)
+});
+var questExperienceSchema = z2.object({
+  member: identifier,
+  quests: z2.array(questViewSchema),
+  collections: z2.array(collectionViewSchema)
+});
+var questPublicationPreviewSchema = z2.object({
+  draft: questDraftSchema,
+  releases: z2.array(publishedReleaseSchema),
+  affectedCollections: z2.array(questCollectionSchema)
+});
+var allocateQuestSchema = z2.object({ actionId: identifier }).strict();
+var allocatedQuestSchema = z2.object({ id: identifier });
+
+// src/collection.ts
+import { z as z3 } from "zod";
+var collectionCodeSchema = z3.string().regex(/^relay:collect:[a-f0-9]{64}$/);
+var collectionPassSchema = z3.object({
+  code: collectionCodeSchema,
+  expiresAt: z3.number(),
+  entitlement: identifier
+});
+var collectionResolveSchema = z3.object({ code: collectionCodeSchema }).strict();
+var collectionBeginSchema = collectionResolveSchema.extend({
+  actionId: identifier,
+  revision: z3.number().int().positive(),
+  selection: pickupSelectionSchema.optional()
+});
+var collectionPreviewSchema = z3.object({
+  entitlement: entitlementSchema,
+  inventory: pickupAvailabilitySchema,
+  expiresAt: z3.number()
+});
+
+// src/reward-deliveries.ts
+import { z as z4 } from "zod";
+var rewardDeliverySchema = z4.object({
+  id: z4.string(),
+  quest: z4.string(),
+  completion: z4.string(),
+  member: z4.string(),
+  provider: z4.literal("discord"),
+  action: z4.literal("grant-role"),
+  roleId: z4.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: z4.enum(["pending", "delivered", "failed"]),
+  /** Provider attempts in the current round; an operator retry starts a new round at zero. */
+  attempts: z4.number().int(),
+  /** While pending with a `lastError`, when the next attempt is scheduled. */
+  nextAt: z4.number(),
+  lastError: z4.string().nullable(),
+  createdAt: z4.number(),
+  deliveredAt: z4.number().nullable()
+});
+var rewardDeliveriesSchema = z4.object({
+  deliveries: z4.array(rewardDeliverySchema)
+});
+
+export {
+  pointLedgerPropertiesSchema,
+  createPointLedgerSchema,
+  pointLedgerSchema,
+  pointLedgerDeclarationSchema,
+  pointLedgerReferenceSchema,
+  interactionSchema,
+  questInteraction,
+  questTypeVersionSchema,
+  collectionSlotSchema,
+  collectionSlotDeclarationSchema,
+  questCollectionSchema,
+  questInstanceSchema,
+  questDraftChangesSchema,
+  questDraftSchema,
+  questCatalogSchema,
+  catalogDeploymentSchema,
+  catalogDeploymentPreviewSchema,
+  saveQuestDraftSchema,
+  publishQuestDraftSchema,
+  questRewardViewSchema,
+  questViewSchema,
+  collectionViewSchema,
+  questExperienceSchema,
+  questPublicationPreviewSchema,
+  allocateQuestSchema,
+  allocatedQuestSchema,
+  collectionCodeSchema,
+  collectionPassSchema,
+  collectionResolveSchema,
+  collectionBeginSchema,
+  collectionPreviewSchema,
+  rewardDeliverySchema,
+  rewardDeliveriesSchema
+};

package/dist/{chunk-5IIWKDFX.js → chunk-QBOHLT7M.js}

@@ -1,6 +1,6 @@
 import {
   identifier
-} from "./chunk-BRESOTKV.js";
+} from "./chunk-VARGF4JS.js";
 
 // src/auth.ts
 import { z } from "zod";
@@ -10,15 +10,33 @@ var authScopeSchema = z.object({
   environment: z.enum(["test", "live"])
 }).strict();
 var principalSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("member"), member: identifier }).strict(),
-  z.object({ kind: z.literal("staff"), subject: identifier }).strict(),
-  z.object({ kind: z.literal("operator"), subject: identifier }).strict()
+  z.object({ kind: z.literal("member"), member: identifier }),
+  z.object({ kind: z.literal("staff"), subject: identifier }),
+  z.object({ kind: z.literal("operator"), subject: identifier })
 ]);
-var sessionSchema = authScopeSchema.extend({
+var sessionSchema = z.object({
+  ...authScopeSchema.shape,
   id: identifier,
   principal: principalSchema,
   expiresAt: z.number()
 });
+var knownPrincipalKinds = principalSchema.options.map(
+  (option) => option.shape.kind.value
+);
+var participantPrincipalSchema = z.union([
+  principalSchema,
+  z.object({ kind: z.string().min(1) }).refine((principal) => !knownPrincipalKinds.includes(principal.kind))
+]);
+var participantSessionSchema = z.object({
+  ...authScopeSchema.shape,
+  id: identifier,
+  principal: participantPrincipalSchema,
+  expiresAt: z.number()
+});
+function sessionMember(session) {
+  const principal = session?.principal;
+  return principal?.kind === "member" && "member" in principal ? principal.member : null;
+}
 var memberSummarySchema = z.object({
   member: identifier,
   avatarSeed: z.string().min(1).max(100)
@@ -36,6 +54,9 @@ export {
   authScopeSchema,
   principalSchema,
   sessionSchema,
+  participantPrincipalSchema,
+  participantSessionSchema,
+  sessionMember,
   memberSummarySchema,
   exchangeSchema,
   exchangeResultSchema