@domino-sdk/relay 0.18.4 → 0.23.1

package/dist/browser.js

@@ -1,11 +1,11 @@
 import {
   browserSubmissionStore,
   createBrowserRelayClient
-} from "./chunk-MVDIVWR5.js";
-import "./chunk-TQUK4DIW.js";
-import "./chunk-FBOW2TLN.js";
-import "./chunk-6GH4NC2T.js";
-import "./chunk-23ZZTCDK.js";
+} from "./chunk-ND3CVNIW.js";
+import "./chunk-RTBIXGMH.js";
+import "./chunk-ZOL7RYHW.js";
+import "./chunk-57TGYC5Y.js";
+import "./chunk-UYS522ER.js";
 export {
   browserSubmissionStore,
   createBrowserRelayClient

package/dist/{chunk-6GH4NC2T.js → chunk-57TGYC5Y.js}

@@ -1,6 +1,6 @@
 import {
   identifier
-} from "./chunk-23ZZTCDK.js";
+} from "./chunk-UYS522ER.js";
 
 // src/auth.ts
 import { z } from "zod";

package/dist/{chunk-MVDIVWR5.js → chunk-ND3CVNIW.js}

@@ -1,6 +1,6 @@
 import {
   createRelayClient
-} from "./chunk-TQUK4DIW.js";
+} from "./chunk-RTBIXGMH.js";
 
 // src/browser.ts
 function createBrowserRelayClient(options) {

package/dist/{chunk-TQUK4DIW.js → chunk-RTBIXGMH.js}

@@ -18,12 +18,12 @@ import {
   referralHistorySchema,
   referralSummarySchema,
   validateAuthoringIdentity
-} from "./chunk-FBOW2TLN.js";
+} from "./chunk-ZOL7RYHW.js";
 import {
   authScopeSchema,
   exchangeResultSchema,
   sessionSchema
-} from "./chunk-6GH4NC2T.js";
+} from "./chunk-57TGYC5Y.js";
 import {
   accountConnectionSchema,
   attemptSchema,
@@ -42,9 +42,8 @@ import {
   errorSchema,
   evidenceSchema,
   identifier,
-  memberListSchema,
-  memberPageSchema,
   memberProgressSchema,
+  photoResultSchema,
   pickupAvailabilitySchema,
   pickupSelectionSchema,
   publishedReleaseSchema,
@@ -52,19 +51,18 @@ import {
   questDescriptionSchema,
   quizEvidenceSchema,
   releaseSchema,
-  reviewListSchema,
   reviewModeSchema,
-  reviewPageSchema,
   settingsValuesSchema,
   snapshotSchema,
   storedReviewModeSchema,
   submissionEvidenceSchema,
   templateSchema,
+  tieredRewardReferenceSchema,
   trackerArtifactSchema,
   validateSubmissionValue,
   valueEvidenceSchema,
   xTweetSchema
-} from "./chunk-23ZZTCDK.js";
+} from "./chunk-UYS522ER.js";
 
 // src/point-ledgers.ts
 import { z } from "zod";
@@ -77,6 +75,11 @@ 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";
@@ -202,12 +205,27 @@ var saveQuestDraftSchema = z3.object({
   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(z3.object({ label: z3.string() }))
+    rewards: z3.array(questRewardViewSchema)
   }
 );
 var collectionViewSchema = z3.object({
@@ -803,7 +821,7 @@ function observeProgress(transport, listener, options = {}, onDispose = () => {
 }
 
 // src/index.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/wallet.ts
 import { z as z5 } from "zod";
@@ -870,88 +888,245 @@ function questConfiguration(release) {
 }
 
 // src/deployments.ts
+import { z as z9 } from "zod";
+
+// src/images.ts
+import { z as z8 } from "zod";
+
+// src/x.ts
 import { z as z7 } from "zod";
+var xIdSchema = z7.string().regex(/^[0-9]{1,20}$/);
+var xConnectionSchema = z7.object({ userId: xIdSchema });
+var xProfileSchema = z7.object({
+  id: xIdSchema,
+  username: z7.string(),
+  name: z7.string(),
+  bio: z7.string().nullable(),
+  profileImageUrl: z7.string().url().nullable(),
+  followersCount: z7.number().int().nonnegative().nullable(),
+  verified: z7.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: z7.unknown().transform(
+    (value) => z7.array(z7.object({ type: z7.string(), url: z7.string() })).safeParse(value).data ?? []
+  )
+});
+var xRequestSchema = z7.discriminatedUnion("operation", [
+  z7.object({ operation: z7.literal("connection") }).strict(),
+  z7.object({ operation: z7.literal("profile") }).strict(),
+  z7.object({ operation: z7.literal("post"), postId: xIdSchema }).strict(),
+  z7.object({ operation: z7.literal("follows"), userId: xIdSchema }).strict(),
+  z7.object({ operation: z7.literal("reposted"), postId: xIdSchema }).strict()
+]);
+
+// src/images.ts
+var imageReferenceSchema = z8.union([
+  z8.strictObject({ evidence: z8.string().min(1).max(256) }),
+  z8.strictObject({ x: z8.literal("profile") }),
+  z8.strictObject({
+    x: z8.literal("post"),
+    postId: xIdSchema,
+    index: z8.number().int().min(0).max(3).default(0)
+  }),
+  z8.strictObject({ asset: identifier })
+]);
+var criteria = z8.string().trim().min(1).max(2e3);
+var imageFieldSchema = z8.strictObject({
+  type: z8.enum(["string", "number", "boolean"]),
+  description: z8.string().trim().min(1).max(500)
+});
+var imageFieldsSchema = z8.record(z8.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 = z8.discriminatedUnion("operation", [
+  z8.strictObject({
+    operation: z8.literal("inspect"),
+    image: imageReferenceSchema
+  }),
+  z8.strictObject({
+    operation: z8.literal("compare"),
+    images: z8.tuple([imageReferenceSchema, imageReferenceSchema])
+  }),
+  z8.strictObject({
+    operation: z8.literal("review"),
+    images: z8.array(imageReferenceSchema).min(1).max(4),
+    criteria
+  }),
+  z8.strictObject({
+    operation: z8.literal("extract"),
+    image: imageReferenceSchema,
+    fields: imageFieldsSchema
+  }),
+  z8.strictObject({
+    operation: z8.literal("seen"),
+    image: imageReferenceSchema,
+    maxDistance: z8.number().int().min(0).max(8).default(8)
+  })
+]);
+var hash = z8.string().regex(/^[0-9a-f]{16}$/);
+var imageInspectionSchema = z8.strictObject({
+  width: z8.number().int().positive(),
+  height: z8.number().int().positive(),
+  format: z8.enum(["jpeg", "png", "webp", "gif", "avif"]),
+  bytes: z8.number().int().positive(),
+  sha256: z8.string().regex(/^[0-9a-f]{64}$/),
+  phash: hash,
+  dhash: hash
+});
+var distance = z8.number().int().min(0).max(64);
+var imageComparisonSchema = z8.strictObject({
+  identical: z8.boolean(),
+  phashDistance: distance,
+  dhashDistance: distance
+});
+var imageExtractionSchema = z8.strictObject({
+  values: z8.record(
+    z8.string(),
+    z8.union([z8.string().max(2e3), z8.number(), z8.boolean(), z8.null()])
+  ),
+  reason: z8.string().min(1).max(2e3)
+});
+var imageSightingsSchema = z8.strictObject({
+  matches: z8.number().int().nonnegative(),
+  closestDistance: distance.nullable(),
+  firstSeenAt: z8.number().int().nonnegative().nullable()
+});
+var sha256 = z8.string().regex(/^[0-9a-f]{64}$/);
+var imageSize = z8.number().int().positive().max(5 * 1024 * 1024);
+var imageAssetArtifactSchema = z8.strictObject({
+  key: identifier,
+  sha256,
+  size: imageSize,
+  path: z8.string().min(1).max(500).optional()
+});
+var imageUploadRequestSchema = z8.strictObject({
+  images: z8.array(
+    z8.strictObject({
+      sha256,
+      size: imageSize,
+      type: z8.enum(["image/jpeg", "image/png", "image/webp"])
+    })
+  ).min(1).max(10)
+});
+var imageUploadsSchema = z8.strictObject({
+  images: z8.array(
+    z8.strictObject({
+      sha256,
+      upload: z8.strictObject({
+        url: z8.string().url(),
+        headers: z8.record(z8.string(), z8.string()),
+        expiresAt: z8.number().int().positive()
+      }).nullable()
+    })
+  )
+});
+var publishedImageSchema = z8.strictObject({
+  key: identifier,
+  sha256,
+  type: z8.enum(["image/jpeg", "image/png", "image/webp"]),
+  size: imageSize,
+  width: z8.number().int().positive(),
+  height: z8.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: z7.array(engagementArtifactSchema).max(50).default([]),
-  trackers: z7.array(trackerArtifactSchema).max(50).default([]),
-  pointLedgers: z7.array(pointLedgerDeclarationSchema).max(50).default([]),
-  referrals: z7.array(referralArtifactSchema).max(50).default([]),
-  leaderboards: z7.array(leaderboardArtifactSchema).max(50).default([])
+  engagement: z9.array(engagementArtifactSchema).max(50).default([]),
+  trackers: z9.array(trackerArtifactSchema).max(50).default([]),
+  pointLedgers: z9.array(pointLedgerDeclarationSchema).max(50).default([]),
+  referrals: z9.array(referralArtifactSchema).max(50).default([]),
+  leaderboards: z9.array(leaderboardArtifactSchema).max(50).default([]),
+  images: z9.array(imageAssetArtifactSchema).max(10).default([])
 });
-var projectDeploymentSchema = projectCatalogArtifactSchema.extend({ releases: z7.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.types.length > 0 || value.collections.length > 0 || value.supportedInteractions !== void 0,
-  "No resources configured. Add engagement, trackers, quests, questTypes, pointLedgers, leaderboards, referrals, collections, or supportedInteractions to relay.json."
+var projectDeploymentSchema = projectCatalogArtifactSchema.extend({ releases: z9.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 = z7.object({
+var deploymentPreviewSchema = z9.object({
   id: identifier,
-  engagement: z7.array(engagementDeploymentEntrySchema).default([]),
-  trackers: z7.array(publishedTrackerSchema).default([]),
-  baseRevision: z7.number().int().nonnegative(),
-  pointLedgers: z7.array(pointLedgerSchema).default([]),
-  releases: z7.array(publishedReleaseSchema),
-  types: z7.array(questTypeVersionSchema),
-  collections: z7.array(questCollectionSchema),
-  supportedInteractions: z7.array(interactionSchema),
-  referrals: z7.array(publishedReferralSchema).default([]),
-  leaderboards: z7.array(leaderboardPreviewSchema).default([])
+  engagement: z9.array(engagementDeploymentEntrySchema).default([]),
+  trackers: z9.array(publishedTrackerSchema).default([]),
+  baseRevision: z9.number().int().nonnegative(),
+  pointLedgers: z9.array(pointLedgerSchema).default([]),
+  releases: z9.array(publishedReleaseSchema),
+  types: z9.array(questTypeVersionSchema),
+  collections: z9.array(questCollectionSchema),
+  supportedInteractions: z9.array(interactionSchema),
+  referrals: z9.array(publishedReferralSchema).default([]),
+  leaderboards: z9.array(leaderboardPreviewSchema).default([]),
+  images: z9.array(publishedImageSchema).default([])
 });
-var publishDeploymentSchema = z7.object({ id: identifier }).strict();
+var publishDeploymentSchema = z9.object({ id: identifier }).strict();
 var deploymentResultSchema = deploymentPreviewSchema.extend({
-  revision: z7.number().int().positive()
+  revision: z9.number().int().positive()
 });
 
 // src/identity-integration.ts
-import { z as z8 } from "zod";
-var identityIntegrationInputSchema = z8.object({
-  name: z8.string().trim().min(1).max(80),
-  origin: z8.string().url().refine((value) => {
+import { z as z10 } from "zod";
+var identityIntegrationInputSchema = z10.object({
+  name: z10.string().trim().min(1).max(80),
+  origin: z10.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: z8.string().uuid(),
-  name: z8.string(),
-  origin: z8.string(),
-  expiresAt: z8.number()
+  id: z10.string().uuid(),
+  name: z10.string(),
+  origin: z10.string(),
+  expiresAt: z10.number()
 });
 var identityIntegrationSecretSchema = identityIntegrationSchema.extend(
   {
-    token: z8.string()
+    token: z10.string()
   }
 );
-var participantExchangeSchema = z8.object({
-  subject: z8.string().min(1).max(200),
-  previousToken: z8.string().max(200).optional()
+var participantExchangeSchema = z10.object({
+  subject: z10.string().min(1).max(200),
+  previousToken: z10.string().max(200).optional()
 }).strict();
 
-// src/x.ts
-import { z as z9 } from "zod";
-var xIdSchema = z9.string().regex(/^[0-9]{1,20}$/);
-var xConnectionSchema = z9.object({ userId: xIdSchema });
-var xProfileSchema = z9.object({
-  id: xIdSchema,
-  username: z9.string(),
-  name: z9.string(),
-  bio: z9.string().nullable(),
-  profileImageUrl: z9.string().url().nullable(),
-  followersCount: z9.number().int().nonnegative().nullable(),
-  verified: z9.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)
-});
-var xRequestSchema = z9.discriminatedUnion("operation", [
-  z9.object({ operation: z9.literal("connection") }).strict(),
-  z9.object({ operation: z9.literal("profile") }).strict(),
-  z9.object({ operation: z9.literal("post"), postId: xIdSchema }).strict(),
-  z9.object({ operation: z9.literal("follows"), userId: xIdSchema }).strict(),
-  z9.object({ operation: z9.literal("reposted"), postId: xIdSchema }).strict()
-]);
-
 // src/index.ts
 function createRelayClient(options) {
   async function send(path, init = {}) {
@@ -1083,19 +1258,33 @@ function createRelayClient(options) {
   }
   return {
     referrals: {
-      list: () => request("/v1/referrals", z10.array(referralDefinitionSchema)),
+      list: () => request("/v1/referrals", z11.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) }), {
+      accept: (input) => request("/v1/referrals/accept", z11.object({ ok: z11.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", z11.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", z11.array(pointLedgerReferenceSchema))
+    },
     leaderboards: {
-      list: () => request("/v1/leaderboards", z10.array(leaderboardDefinitionSchema)),
+      list: () => request("/v1/leaderboards", z11.array(leaderboardDefinitionSchema)),
       standings: (board, options2 = {}) => {
         const parsed = leaderboardQuerySchema.parse(options2);
         return request(
@@ -1180,25 +1369,25 @@ function createRelayClient(options) {
     auth: {
       providers: () => request(
         "/v1/auth/providers",
-        z10.object({
-          providers: z10.array(
-            z10.object({
+        z11.object({
+          providers: z11.array(
+            z11.object({
               provider: authProviderSchema,
-              configured: z10.boolean()
+              configured: z11.boolean()
             })
           ),
-          email: z10.boolean(),
-          demo: z10.boolean()
+          email: z11.boolean(),
+          demo: z11.boolean()
         })
       ),
       start: (provider, mode) => request(
         "/v1/auth/start",
-        z10.object({ url: z10.string() }),
+        z11.object({ url: z11.string() }),
         json({ provider, mode })
       ),
       emailStart: (email) => request(
         "/v1/auth/email/start",
-        z10.object({ challenge: z10.string() }),
+        z11.object({ challenge: z11.string() }),
         json({ email })
       ),
       emailVerify: (challenge, code) => changeSession(
@@ -1208,25 +1397,25 @@ function createRelayClient(options) {
           json({ challenge, code })
         )
       ),
-      accounts: () => request("/v1/auth/accounts", z10.array(accountConnectionSchema)),
+      accounts: () => request("/v1/auth/accounts", z11.array(accountConnectionSchema)),
       disconnect: (provider) => request(
         "/v1/auth/accounts/disconnect",
-        z10.object({ ok: z10.boolean() }),
+        z11.object({ ok: z11.boolean() }),
         json({ provider })
       ),
       connections: () => request(
         "/v1/auth/connections",
-        z10.array(
-          z10.object({
-            provider: z10.string(),
-            subject: z10.string(),
-            signInEnabled: z10.boolean()
+        z11.array(
+          z11.object({
+            provider: z11.string(),
+            subject: z11.string(),
+            signInEnabled: z11.boolean()
           })
         )
       ),
       session: () => request("/v1/auth/session", sessionSchema.nullable()),
       signOut: () => changeSession(
-        () => request("/v1/auth/logout", z10.object({ ok: z10.boolean() }), json({}))
+        () => request("/v1/auth/logout", z11.object({ ok: z11.boolean() }), json({}))
       ),
       /** Local development only. Existing hosted apps use createParticipantBackend from /portal-proxy. */
       exchange: (input) => request("/v1/auth/exchange", exchangeResultSchema, json(input))
@@ -1275,22 +1464,6 @@ function createRelayClient(options) {
         body: file
       })
     },
-    /** @deprecated The participant API accepts only member sessions and rejects this staff call. Use the management API with a management key instead. */
-    reviews: {
-      list: (options2 = {}, requestOptions) => request(
-        query("/v1/reviews", reviewListSchema.parse(options2)),
-        reviewPageSchema,
-        requestOptions
-      )
-    },
-    /** @deprecated The participant API accepts only member sessions and rejects this staff call. Use the management API with a management key instead. */
-    members: {
-      list: (options2 = {}, requestOptions) => request(
-        query("/v1/members", memberListSchema.parse(options2)),
-        memberPageSchema,
-        requestOptions
-      )
-    },
     evidence: {
       async download(id, requestOptions) {
         const response = await send(
@@ -1307,11 +1480,11 @@ function createRelayClient(options) {
     /** @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() }),
+      z11.object({ member: z11.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)),
+    journeyTemplate: () => request("/v1/journey-template", z11.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. */
@@ -1321,7 +1494,7 @@ function createRelayClient(options) {
     /** @deprecated The participant API rejects publication. Publish with `domino deploy` or the management API. */
     publishBatch: (releases) => request(
       "/v1/releases/batch",
-      z10.array(publishedReleaseSchema),
+      z11.array(publishedReleaseSchema),
       json({ releases })
     ),
     progress: (member) => request(
@@ -1411,6 +1584,7 @@ export {
   createPointLedgerSchema,
   pointLedgerSchema,
   pointLedgerDeclarationSchema,
+  pointLedgerReferenceSchema,
   rewardDeliverySchema,
   rewardDeliveriesSchema,
   interactionSchema,
@@ -1427,6 +1601,7 @@ export {
   catalogDeploymentPreviewSchema,
   saveQuestDraftSchema,
   publishQuestDraftSchema,
+  questRewardViewSchema,
   questViewSchema,
   collectionViewSchema,
   questExperienceSchema,
@@ -1449,6 +1624,25 @@ export {
   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,
@@ -1458,10 +1652,5 @@ export {
   identityIntegrationSchema,
   identityIntegrationSecretSchema,
   participantExchangeSchema,
-  xIdSchema,
-  xConnectionSchema,
-  xProfileSchema,
-  xPostSchema,
-  xRequestSchema,
   createRelayClient
 };

package/dist/{chunk-23ZZTCDK.js → chunk-UYS522ER.js}

@@ -860,6 +860,10 @@ var tieredRewardDefinitionSchema = z12.object({
   inventory: z12.object({ kind: z12.literal("untracked") }).strict(),
   fulfillment: z12.object({ kind: z12.literal("staff-handover") }).strict()
 }).strict();
+var tieredRewardReferenceSchema = z12.object({
+  id: identifier,
+  key: identifier.nullable()
+});
 var tierRewardSchema = z12.object({
   kind: z12.literal("tier"),
   reward: tieredRewardDefinitionSchema,
@@ -1452,6 +1456,7 @@ export {
   compatibleSettingKinds,
   pointsRewardSchema,
   tieredRewardDefinitionSchema,
+  tieredRewardReferenceSchema,
   tierRewardSchema,
   integrationRewardSchema,
   rewardSchema,

package/dist/{chunk-FBOW2TLN.js → chunk-ZOL7RYHW.js}

@@ -4,7 +4,7 @@ import {
   identifier,
   pointsRewardSchema,
   tierRewardSchema
-} from "./chunk-23ZZTCDK.js";
+} from "./chunk-UYS522ER.js";
 
 // src/engagement.ts
 import { z } from "zod";