@domino-sdk/relay 1.0.0-next.10 → 1.0.0-next.13

package/dist/{chunk-X2F2RAR3.js → chunk-EZWNGI5B.js}

@@ -1,9 +1,12 @@
 import {
   collectionPassSchema,
+  pointBalancesSchema,
+  pointHistoryPageSchema,
+  pointHistoryQuerySchema,
   pointLedgerReferenceSchema,
   questExperienceSchema,
   rewardDeliveriesSchema
-} from "./chunk-QR7ZA2BJ.js";
+} from "./chunk-M64XHC42.js";
 import {
   AVATAR_UPLOAD_LIMIT,
   RelayError,
@@ -35,14 +38,14 @@ import {
   walletSignInNetworksSchema,
   walletSignatureSchema,
   walletUnlinkInputSchema
-} from "./chunk-PHU5VDLR.js";
+} from "./chunk-OA2KMQVZ.js";
 import {
   exchangeResultSchema,
   exchangeSchema,
   memberSummarySchema,
   participantSessionSchema,
   sessionMember
-} from "./chunk-7Q4BGGT6.js";
+} from "./chunk-FXYJ4OMX.js";
 import {
   accountConnectionSchema,
   attemptSchema,
@@ -67,7 +70,7 @@ import {
   tieredRewardReferenceSchema,
   validateSubmissionValue,
   valueEvidenceSchema
-} from "./chunk-YYD4QUBO.js";
+} from "./chunk-CRNQP7NV.js";
 
 // src/submissions.ts
 import { z } from "zod";
@@ -1301,6 +1304,22 @@ function createRelayClient(options) {
       rewardDeliveries: (requestOptions) => request("/v1/reward-deliveries", rewardDeliveriesSchema, {
         options: requestOptions
       }),
+      /**
+       * `{ items }`: the member's balance in each of the project's point ledgers, in the project's
+       * ledger order, zero in a ledger they have no entries in.
+       */
+      balances: (requestOptions) => request("/v1/me/points", pointBalancesSchema, {
+        options: requestOptions
+      }),
+      /** The member's own entries in one ledger, by key or ID, most recently recorded first. */
+      pointHistory: async (query, requestOptions) => {
+        const { ledger, cursor } = parseInput(pointHistoryQuerySchema, query);
+        return request(
+          withQuery(`/v1/me/points/${ledger}/history`, { cursor }),
+          pointHistoryPageSchema,
+          { options: requestOptions }
+        );
+      },
       /** Claims a quest for the signed-in member. Quest controllers (`quests.open`) call this. */
       claim: async (value, requestOptions) => {
         const claim = parseInput(submitSchema.omit({ member: true }), value);

package/dist/{chunk-7Q4BGGT6.js → chunk-FXYJ4OMX.js}

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

package/dist/{chunk-4LBUTHD6.js → chunk-II7DRZSL.js}

@@ -1,7 +1,7 @@
 import {
   identifier,
   xTweetSchema
-} from "./chunk-YYD4QUBO.js";
+} from "./chunk-CRNQP7NV.js";
 
 // src/x.ts
 import { z } from "zod";

package/dist/chunk-KS33GOUL.js

@@ -0,0 +1,83 @@
+import {
+  imageAssetArtifactSchema,
+  publishedImageSchema
+} from "./chunk-II7DRZSL.js";
+import {
+  catalogDeploymentSchema,
+  interactionSchema,
+  pointLedgerDeclarationSchema,
+  pointLedgerSchema,
+  questCollectionSchema,
+  questTypeVersionSchema
+} from "./chunk-M64XHC42.js";
+import {
+  engagementArtifactSchema,
+  engagementDeploymentEntrySchema,
+  leaderboardArtifactSchema,
+  leaderboardPreviewSchema,
+  publishedReferralSchema,
+  referralArtifactSchema
+} from "./chunk-OA2KMQVZ.js";
+import {
+  identifier,
+  projectCalendarDeclarationSchema,
+  publishedReleaseSchema,
+  publishedTrackerSchema,
+  releaseSchema,
+  timeZoneNameSchema,
+  trackerArtifactSchema
+} from "./chunk-CRNQP7NV.js";
+
+// src/deployments.ts
+import { z } from "zod";
+var projectCatalogArtifactSchema = catalogDeploymentSchema.omit({ expectedRevision: true }).extend({
+  engagement: z.array(engagementArtifactSchema).max(50).default([]),
+  trackers: z.array(trackerArtifactSchema).max(50).default([]),
+  pointLedgers: z.array(pointLedgerDeclarationSchema).max(50).default([]),
+  referrals: z.array(referralArtifactSchema).max(50).default([]),
+  leaderboards: z.array(leaderboardArtifactSchema).max(50).default([]),
+  images: z.array(imageAssetArtifactSchema).max(10).default([]),
+  /** relay.json `calendar`: the project timezone. Omitted, the deployment leaves it unchanged. */
+  calendar: projectCalendarDeclarationSchema.optional()
+});
+var projectDeploymentSchema = projectCatalogArtifactSchema.extend({ releases: z.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 || value.calendar !== void 0,
+  "No resources configured. Add engagement, trackers, quests, questTypes, pointLedgers, leaderboards, referrals, images, collections, supportedInteractions, or calendar to relay.json."
+);
+var deploymentPreviewSchema = z.object({
+  id: identifier,
+  engagement: z.array(engagementDeploymentEntrySchema).default([]),
+  trackers: z.array(publishedTrackerSchema).default([]),
+  baseRevision: z.number().int().nonnegative(),
+  pointLedgers: z.array(pointLedgerSchema).default([]),
+  releases: z.array(publishedReleaseSchema),
+  types: z.array(questTypeVersionSchema),
+  collections: z.array(questCollectionSchema),
+  supportedInteractions: z.array(interactionSchema),
+  referrals: z.array(publishedReferralSchema).default([]),
+  leaderboards: z.array(leaderboardPreviewSchema).default([]),
+  images: z.array(publishedImageSchema).default([]),
+  /**
+   * The project timezone change this deployment makes, or null for none. A declared timezone
+   * applies only when relay.json changes it, so a change made in Console stays until relay.json
+   * changes. `effectiveAt` is when a scheduled change takes effect; null means the deployment keeps
+   * `timeZone` and cancels a pending change. Publishing makes exactly this change, or fails when the
+   * calendar moved since the preview (such as past a day boundary).
+   */
+  calendar: z.object({
+    timeZone: timeZoneNameSchema,
+    effectiveAt: z.number().int().nullable()
+  }).nullable().default(null)
+});
+var publishDeploymentSchema = z.object({ id: identifier }).strict();
+var deploymentResultSchema = deploymentPreviewSchema.extend({
+  revision: z.number().int().positive()
+});
+
+export {
+  projectCatalogArtifactSchema,
+  projectDeploymentSchema,
+  deploymentPreviewSchema,
+  publishDeploymentSchema,
+  deploymentResultSchema
+};

package/dist/{chunk-QR7ZA2BJ.js → chunk-M64XHC42.js}

@@ -2,20 +2,21 @@ import {
   authoringIdentityShape,
   normalizeAuthoringIdentity,
   validateAuthoringIdentity
-} from "./chunk-PHU5VDLR.js";
+} from "./chunk-OA2KMQVZ.js";
 import {
   entitlementSchema,
   identifier,
   memberProgressSchema,
+  pageCursorSchema,
   pickupAvailabilitySchema,
   pickupSelectionSchema,
   publishedReleaseSchema,
-  questDescriptionSchema,
   reviewModeSchema,
   settingsValuesSchema,
+  storedQuestDescriptionSchema,
   storedReviewModeSchema,
   tieredRewardReferenceSchema
-} from "./chunk-YYD4QUBO.js";
+} from "./chunk-CRNQP7NV.js";
 
 // src/point-ledgers.ts
 import { z } from "zod";
@@ -33,6 +34,43 @@ var pointLedgerReferenceSchema = z.object({
   key: identifier.nullable(),
   name: z.string()
 });
+var points = z.number().int().safe();
+var pointBalanceSchema = z.object({
+  ledger: pointLedgerReferenceSchema,
+  balance: points,
+  available: points
+});
+var pointBalancesSchema = z.object({
+  items: z.array(pointBalanceSchema)
+});
+var PointEntryKind = {
+  /** Points a quest completion, an engagement settlement or an operator awarded. */
+  Award: "award",
+  /** Points the member spent. */
+  Spend: "spend",
+  /** A correction in either direction, by an operator or a referral payout. */
+  Adjust: "adjust",
+  /** Undoes part or all of an award or a positive adjustment (`reverses`). */
+  Reverse: "reverse"
+};
+var pointEntryKindSchema = z.string().min(1).max(64);
+var pointEntrySchema = z.object({
+  id: identifier,
+  amount: points,
+  kind: pointEntryKindSchema,
+  /** When the entry took effect, in epoch milliseconds. A reversal keeps its source's. */
+  at: points.nonnegative(),
+  quest: identifier.nullable(),
+  reverses: identifier.nullable()
+});
+var pointHistoryQuerySchema = z.strictObject({
+  ledger: identifier,
+  cursor: pageCursorSchema.optional()
+});
+var pointHistoryPageSchema = z.object({
+  items: z.array(pointEntrySchema),
+  nextCursor: pageCursorSchema.nullable()
+});
 
 // src/catalog.ts
 import { z as z2 } from "zod";
@@ -53,7 +91,7 @@ var questTypeVersionSchema = z2.object({
   id: identifier,
   version: identifier,
   code: z2.string(),
-  definition: questDescriptionSchema,
+  definition: storedQuestDescriptionSchema,
   provider: storedReviewModeSchema,
   createdAt: z2.number()
 });
@@ -226,6 +264,12 @@ export {
   pointLedgerSchema,
   pointLedgerDeclarationSchema,
   pointLedgerReferenceSchema,
+  pointBalanceSchema,
+  pointBalancesSchema,
+  PointEntryKind,
+  pointEntrySchema,
+  pointHistoryQuerySchema,
+  pointHistoryPageSchema,
   interactionSchema,
   questInteraction,
   questTypeVersionSchema,

package/dist/chunk-MNQI35OG.js

@@ -0,0 +1,100 @@
+import {
+  imageComparisonSchema,
+  imageExtractionSchema,
+  imageFieldsSchema,
+  imageInspectionSchema,
+  imageSightingsSchema
+} from "./chunk-II7DRZSL.js";
+import {
+  authScopeSchema
+} from "./chunk-FXYJ4OMX.js";
+import {
+  photoResultSchema
+} from "./chunk-CRNQP7NV.js";
+
+// 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/identity-integration.ts
+import { z } from "zod";
+var identityIntegrationInputSchema = z.object({
+  name: z.string().trim().min(1).max(80),
+  origin: z.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: z.string().uuid(),
+  name: z.string(),
+  origin: z.string(),
+  expiresAt: z.number()
+});
+var identityIntegrationSecretSchema = identityIntegrationSchema.extend(
+  {
+    token: z.string()
+  }
+);
+var participantExchangeSchema = z.object({
+  subject: z.string().min(1).max(200),
+  previousToken: z.string().max(200).optional()
+}).strict();
+
+// src/image-results.ts
+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/sequence-cursor.ts
+import { z as z2 } from "zod";
+var sequenceCursorSchema = z2.string().regex(/^[1-9][0-9]{0,15}$/, "Invalid cursor").transform(Number).pipe(z2.number().int().positive().safe());
+
+export {
+  questConfiguration,
+  identityIntegrationInputSchema,
+  identityIntegrationSchema,
+  identityIntegrationSecretSchema,
+  participantExchangeSchema,
+  parseImageExtraction,
+  parseImageResult,
+  sequenceCursorSchema
+};

package/dist/{chunk-PHU5VDLR.js → chunk-OA2KMQVZ.js}

@@ -1,11 +1,13 @@
 import {
+  calendarPeriodSchema,
   contentMetricSchema,
   contentMetricsSchema,
   identifier,
   pageCursorSchema,
   pointsRewardSchema,
+  refuseWindowTimeZone,
   tierRewardSchema
-} from "./chunk-YYD4QUBO.js";
+} from "./chunk-CRNQP7NV.js";
 
 // src/authoring-identity.ts
 import { z } from "zod";
@@ -39,6 +41,11 @@ var authoringKey = (input) => identitySchema.parse(input).key;
 // src/engagement.ts
 import { z as z2 } from "zod";
 var amount = z2.number().int().safe().nonnegative();
+var engagementBudgetSchema = z2.strictObject({
+  scope: z2.enum(["member", "project"]),
+  period: calendarPeriodSchema,
+  limit: amount
+});
 var engagementDefinitionSchema = z2.strictObject({
   key: identifier,
   qualifiedBy: identifier,
@@ -49,11 +56,10 @@ var engagementDefinitionSchema = z2.strictObject({
   ),
   baseline: z2.literal("historical"),
   maxAgeMs: z2.number().int().positive().max(864e5).default(36e5),
-  budget: z2.strictObject({
-    projectDaily: amount.optional(),
-    memberDaily: amount.optional(),
-    projectLifetime: amount.optional()
-  }).default({})
+  budgets: z2.array(engagementBudgetSchema).max(8).default([]).refine(
+    (budgets) => new Set(budgets.map((b) => b.scope + ":" + b.period)).size === budgets.length,
+    "Give each scope and period one budget"
+  )
 });
 var engagementScoreInputSchema = z2.strictObject({
   metrics: contentMetricsSchema,
@@ -221,8 +227,13 @@ var RelayErrorCode = {
   NotFound: "not-found",
   /** The quest has no failed attempt the member can retry. */
   RetryUnavailable: "retry-unavailable",
-  /** Durable submission storage is missing, blocked or unreadable. */
+  /**
+   * Durable submission storage is missing, blocked or unreadable. Nothing was lost: call the
+   * handle's `status()` or `resume()` again once storage is available.
+   */
   SubmissionStorage: "submission-storage",
+  /** Browser storage is full, so submission progress was not saved. Free space, then resume. */
+  SubmissionStorageQuota: "submission-storage-quota",
   /** The saved submission is in a state that does not allow this action. */
   SubmissionConflict: "submission-conflict",
   /** The quest changed since the member saw it; review it before submitting again. */
@@ -233,6 +244,10 @@ var RelayErrorCode = {
   InvalidSubmission: "invalid-submission",
   /** A page cursor Relay cannot read; start again from the first page. */
   InvalidCursor: "invalid-cursor",
+  /** No point ledger in the project has the key or ID the call named. */
+  PointLedgerNotFound: "point-ledger-not-found",
+  /** The member has not joined this project, so it holds no points here. */
+  NotJoined: "not-joined",
   /** A wallet signer failed or the member refused to sign; `cause` is the wallet's own error. */
   WalletSigner: "wallet-signer"
 };
@@ -409,40 +424,39 @@ var leaderboardWindowSchema = z5.discriminatedUnion("kind", [
   z5.object({ kind: z5.literal("all-time") }).strict(),
   z5.object({ kind: z5.literal("fixed"), start: timestamp, end: timestamp }).strict().refine((w) => w.end > w.start, "Window end must follow its start"),
   z5.object({ kind: z5.literal("rolling"), days: integer.min(1).max(3660) }).strict(),
+  // Not strict: boards published while a calendar window named its own `timeZone` keep reading,
+  // and the field drops on parse. The authoring schema refuses it.
   z5.object({
     kind: z5.literal("calendar"),
-    period: z5.enum(["day", "week", "month"]),
-    timeZone: z5.string().min(1).max(100).refine((zone) => {
-      try {
-        new Intl.DateTimeFormat("en", { timeZone: zone });
-        return true;
-      } catch {
-        return false;
-      }
-    }, "Use an IANA timezone")
-  }).strict()
+    /** The current day, week (ISO, starting on Monday) or month of the project calendar. */
+    period: calendarPeriodSchema.exclude(["lifetime"])
+  })
 ]);
 var periodScore = {
   window: leaderboardWindowSchema.default({ kind: "all-time" }),
   quests: z5.array(identifier).min(1).max(100).optional()
 };
+var scoreSchema = z5.discriminatedUnion("kind", [
+  z5.object({ kind: z5.literal("balance") }).strict(),
+  z5.object({ kind: z5.literal("earned"), ...periodScore }).strict(),
+  z5.object({
+    kind: z5.literal("net"),
+    window: leaderboardWindowSchema.default({ kind: "all-time" })
+  }).strict()
+]).default({ kind: "balance" });
 var leaderboardDefinitionSchema = z5.object({
   id: identifier,
   key: identifier.optional(),
   title: z5.string().trim().min(1).max(120),
   balance: identifier,
-  score: z5.discriminatedUnion("kind", [
-    z5.object({ kind: z5.literal("balance") }).strict(),
-    z5.object({ kind: z5.literal("earned"), ...periodScore }).strict(),
-    z5.object({
-      kind: z5.literal("net"),
-      window: leaderboardWindowSchema.default({ kind: "all-time" })
-    }).strict()
-  ]).default({ kind: "balance" }),
+  score: scoreSchema,
   access: z5.enum(["participants", "public"]).default("participants"),
   group: identifier.optional()
 }).strict();
-var leaderboardAuthoringSchema = leaderboardDefinitionSchema.omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
+var leaderboardAuthoringSchema = leaderboardDefinitionSchema.omit({ id: true }).extend({
+  ...authoringIdentityShape,
+  score: z5.preprocess(refuseWindowTimeZone, scoreSchema)
+}).strict().superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
 var leaderboardArtifactSchema = z5.union([
   leaderboardAuthoringSchema,
   z5.object({ code: z5.string().min(1).max(2e6) }).strict()
@@ -903,6 +917,7 @@ export {
   validateAuthoringIdentity,
   normalizeAuthoringIdentity,
   authoringKey,
+  engagementBudgetSchema,
   engagementDefinitionSchema,
   engagementScoreInputSchema,
   engagementScoreSchema,