@domino-sdk/relay 0.1.0

package/dist/browser.js

@@ -0,0 +1,60 @@
+import {
+  createRelayClient
+} from "./chunk-NC3UAP6T.js";
+import "./chunk-C2KOMNLG.js";
+
+// src/browser.ts
+function createBrowserRelayClient(options) {
+  return createRelayClient({
+    ...options,
+    submissionStore: options.submissionStore ?? browserSubmissionStore()
+  });
+}
+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."
+      );
+    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.onsuccess = () => resolve(request.result);
+      request.onblocked = () => reject(new Error("Close other Relay tabs and try again"));
+    });
+  }
+  async function transact(key, value) {
+    const db = await open();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction(
+        "submissions",
+        value === void 0 ? "readonly" : "readwrite",
+        { durability: "strict" }
+      );
+      const store = transaction.objectStore("submissions");
+      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."
+        )
+      );
+    });
+  }
+  return {
+    read: (key) => transact(key),
+    write: async (key, value) => {
+      await transact(key, value);
+    },
+    exclusive: async (key, task) => {
+      await open();
+      return navigator.locks.request(key, task);
+    }
+  };
+}
+export {
+  browserSubmissionStore,
+  createBrowserRelayClient
+};

package/dist/chunk-C2KOMNLG.js

@@ -0,0 +1,570 @@
+// src/quiz.ts
+import { z } from "zod";
+var quizId = z.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
+var quizChoiceSchema = z.object({ id: quizId, label: z.string().trim().min(1).max(500) }).strict();
+var quizQuestionSchema = z.object({
+  id: quizId,
+  prompt: z.string().trim().min(1).max(1e3),
+  choices: z.array(quizChoiceSchema).min(2).max(8).refine(
+    (choices) => new Set(choices.map((choice) => choice.id)).size === choices.length,
+    "Choice IDs must be unique"
+  )
+}).strict();
+var quizQuestionsSchema = z.array(quizQuestionSchema).min(1).max(20).refine(
+  (questions) => new Set(questions.map((question) => question.id)).size === questions.length,
+  "Question IDs must be unique"
+);
+var quizContentSchema = z.array(
+  quizQuestionSchema.extend({ correct: quizId }).refine(
+    (question) => question.choices.some((choice) => choice.id === question.correct),
+    "Choose a correct answer from the available choices"
+  )
+).min(1).max(20).refine(
+  (questions) => new Set(questions.map((question) => question.id)).size === questions.length,
+  "Question IDs must be unique"
+);
+
+// src/schema.ts
+import { z as z3 } from "zod";
+
+// src/settings.ts
+import { z as z2 } from "zod";
+var base = { label: z2.string().min(1), description: z2.string().optional() };
+var settingFieldSchema = z2.discriminatedUnion("kind", [
+  z2.object({ ...base, kind: z2.literal("quiz"), default: quizContentSchema }).strict(),
+  z2.object({
+    ...base,
+    kind: z2.literal("text"),
+    default: z2.string(),
+    minLength: z2.number().int().nonnegative(),
+    maxLength: z2.number().int().positive(),
+    multiline: z2.boolean()
+  }).strict(),
+  z2.object({
+    ...base,
+    kind: z2.literal("integer"),
+    default: z2.number().int(),
+    min: z2.number().int(),
+    max: z2.number().int()
+  }).strict(),
+  z2.object({ ...base, kind: z2.literal("boolean"), default: z2.boolean() }).strict(),
+  z2.object({
+    ...base,
+    kind: z2.literal("choice"),
+    default: z2.string(),
+    options: z2.array(z2.string().min(1)).min(1)
+  }).strict()
+]);
+var settingsFieldsSchema = z2.record(
+  z2.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
+  settingFieldSchema
+);
+var settingsValuesSchema = z2.record(
+  z2.string(),
+  z2.union([z2.string(), z2.number().finite(), z2.boolean(), quizContentSchema])
+);
+var settings = {
+  quiz(options) {
+    const value = quizContentSchema.parse(options.default);
+    return quizContentSchema.default(value).meta({ ...options, default: value, kind: "quiz" });
+  },
+  text(options) {
+    const field = {
+      ...options,
+      kind: "text",
+      minLength: options.minLength ?? 1,
+      maxLength: options.maxLength ?? 2e3,
+      multiline: options.multiline ?? false
+    };
+    return z2.string().min(field.minLength).max(field.maxLength).default(field.default).meta(field);
+  },
+  integer(options) {
+    return z2.number().int().min(options.min).max(options.max).default(options.default).meta({ ...options, kind: "integer" });
+  },
+  boolean(options) {
+    return z2.boolean().default(options.default).meta({ ...options, kind: "boolean" });
+  },
+  choice(options) {
+    return z2.enum(options.options).default(options.default).meta({ ...options, kind: "choice" });
+  },
+  object(shape) {
+    return z2.object(shape).strict();
+  }
+};
+function parseSettings(fields, input) {
+  const shape = {};
+  for (const [key, field] of Object.entries(fields)) {
+    switch (field.kind) {
+      case "quiz":
+        shape[key] = quizContentSchema.default(field.default);
+        break;
+      case "text":
+        shape[key] = z2.string().min(field.minLength).max(field.maxLength).default(field.default);
+        break;
+      case "integer":
+        shape[key] = z2.number().int().min(field.min).max(field.max).default(field.default);
+        break;
+      case "boolean":
+        shape[key] = z2.boolean().default(field.default);
+        break;
+      case "choice":
+        shape[key] = z2.enum(field.options).default(field.default);
+        break;
+    }
+  }
+  return settingsValuesSchema.parse(z2.object(shape).strict().parse(input));
+}
+
+// src/schema.ts
+var identifier = z3.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/);
+var pointsRewardSchema = z3.object({
+  kind: z3.literal("points").default("points"),
+  balance: identifier,
+  amount: z3.number().int().min(0).max(1e4)
+}).strict();
+var tieredRewardDefinitionSchema = z3.object({
+  id: identifier,
+  title: z3.string().min(1).max(120),
+  tiers: z3.array(
+    z3.object({ id: identifier, title: z3.string().min(1).max(120) }).strict()
+  ).min(1).max(20).refine(
+    (tiers) => new Set(tiers.map((t) => t.id)).size === tiers.length,
+    "Tier IDs must be unique"
+  ),
+  inventory: z3.object({ kind: z3.literal("untracked") }).strict(),
+  fulfillment: z3.object({ kind: z3.literal("staff-handover") }).strict()
+}).strict();
+var tierRewardSchema = z3.object({
+  kind: z3.literal("tier"),
+  reward: tieredRewardDefinitionSchema,
+  tier: identifier
+}).strict().refine(
+  (value) => value.reward.tiers.some((t) => t.id === value.tier),
+  "Unknown reward tier"
+);
+var rewardSchema = z3.union([pointsRewardSchema, tierRewardSchema]);
+function rewardKey(reward) {
+  return reward.kind === "points" ? "points:" + reward.balance : "tier:" + reward.reward.id;
+}
+var triggerSchema = z3.union([
+  z3.object({
+    kind: z3.literal("manual"),
+    input: z3.enum(["photo", "quiz", "none"]),
+    actor: z3.enum(["member", "staff"]).optional()
+  }).strict(),
+  z3.object({ kind: z3.literal("automatic") }).strict()
+]);
+var prerequisiteSchema = z3.object({ quest: identifier, scope: z3.literal("ever") }).strict();
+var photoResultSchema = z3.object({
+  kind: z3.enum(["pass", "fail", "unclear"]),
+  reason: z3.string().min(1).max(2e3)
+}).strict();
+var decisionSchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    kind: z3.literal("accept"),
+    rewards: z3.array(rewardSchema).max(10)
+  }).strict(),
+  z3.object({ kind: z3.literal("reject"), reason: z3.string().min(1).max(2e3) }).strict(),
+  z3.object({
+    kind: z3.literal("review"),
+    reason: z3.string().min(1).max(2e3),
+    rewards: z3.array(rewardSchema).max(10).optional()
+  }).strict()
+]);
+var reviewModeSchema = z3.enum([
+  "fixture-pass",
+  "fixture-fail",
+  "fixture-unclear",
+  "fixture-error",
+  "workers-ai"
+]);
+var rewardBundleSchema = z3.array(rewardSchema).max(10).refine(
+  (rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
+  "Use one entry per balance or shared reward"
+);
+var mediaUrlSchema = z3.string().max(2e3).refine((value) => {
+  if (/^\/(?!\/)[^\\\s]*$/.test(value)) return true;
+  try {
+    return new URL(value).protocol === "https:";
+  } catch {
+    return false;
+  }
+}, "Use an HTTPS URL or a same-site path beginning with /");
+var questPresentationSchema = z3.object({
+  quiz: quizQuestionsSchema.optional(),
+  instructions: z3.string().max(4e3).optional(),
+  video: z3.object({
+    url: mediaUrlSchema,
+    poster: mediaUrlSchema.optional(),
+    captions: z3.object({
+      url: mediaUrlSchema,
+      language: z3.string().min(2).max(20),
+      label: z3.string().min(1).max(80)
+    }).strict().optional()
+  }).strict().optional()
+}).strict();
+var questDescriptionSchema = z3.object({
+  quest: identifier,
+  runtimeVersion: z3.union([z3.literal(1), z3.literal(2)]).default(1),
+  title: z3.string().min(1).max(120),
+  presentation: questPresentationSchema.default({}),
+  fields: settingsFieldsSchema,
+  values: settingsValuesSchema,
+  rewards: rewardBundleSchema,
+  humanReview: z3.boolean(),
+  trigger: triggerSchema,
+  requires: z3.array(prerequisiteSchema).max(30).default([]),
+  completion: z3.object({ kind: z3.literal("once") }).strict()
+}).strict();
+var artifactSchema = z3.object({ code: z3.string().min(1).max(1e6) }).strict();
+var releaseSchema = artifactSchema.extend({
+  settings: settingsValuesSchema,
+  provider: reviewModeSchema,
+  expectedRelease: identifier.nullable().optional(),
+  settingRenames: z3.record(z3.string(), z3.string()).optional()
+}).strict();
+var batchReleaseSchema = z3.object({ releases: z3.array(releaseSchema).min(1).max(50) }).strict();
+var questSettingsInputSchema = z3.object({
+  quest: identifier,
+  expectedRelease: identifier,
+  set: settingsValuesSchema,
+  reset: z3.array(z3.string())
+}).strict();
+var storedReleaseSchema = questDescriptionSchema.extend({
+  code: z3.string(),
+  provider: reviewModeSchema,
+  id: identifier,
+  createdAt: z3.number(),
+  legacy: z3.boolean().default(false),
+  origin: z3.object({ typeVersion: identifier }).strict().optional(),
+  lifecycle: z3.enum(["active", "paused", "archived"]).default("active"),
+  configuration: z3.object({
+    defaults: settingsValuesSchema,
+    overrides: settingsValuesSchema,
+    preserved: z3.array(z3.string())
+  }).strict().optional()
+});
+var legacyReleaseSchema = z3.object({
+  quest: identifier,
+  title: z3.string(),
+  criteria: z3.string(),
+  humanReview: z3.boolean(),
+  rewards: rewardBundleSchema,
+  code: z3.string(),
+  provider: reviewModeSchema,
+  id: identifier,
+  createdAt: z3.number()
+}).transform((r) => {
+  const { criteria, ...stored } = r;
+  return storedReleaseSchema.parse({
+    ...stored,
+    fields: {},
+    values: { criteria, humanReview: r.humanReview },
+    trigger: { kind: "manual", input: "photo" },
+    completion: { kind: "once" },
+    legacy: true
+  });
+});
+var publishedReleaseSchema = z3.union([
+  storedReleaseSchema,
+  legacyReleaseSchema
+]);
+var templateSchema = z3.object({
+  code: z3.string(),
+  definition: questDescriptionSchema
+});
+var quizAnswersSchema = z3.record(identifier, identifier).refine(
+  (answers) => Object.keys(answers).length > 0 && Object.keys(answers).length <= 50,
+  "Provide between 1 and 50 answers"
+).transform(
+  (answers) => Object.fromEntries(
+    Object.entries(answers).sort(([a], [b]) => a.localeCompare(b))
+  )
+);
+var quizEvidenceSchema = z3.object({
+  kind: z3.literal("quiz"),
+  release: identifier.optional(),
+  answers: quizAnswersSchema
+}).strict();
+var submitSchema = z3.object({
+  actionId: identifier,
+  quest: identifier,
+  member: identifier,
+  evidence: identifier.optional(),
+  input: quizEvidenceSchema.optional(),
+  release: identifier.optional(),
+  faultAfterReview: z3.boolean().optional()
+}).strict();
+var attemptSchema = z3.object({
+  id: identifier,
+  release: identifier,
+  quest: identifier,
+  member: identifier,
+  evidence: identifier.nullable(),
+  input: quizEvidenceSchema.optional(),
+  status: z3.enum([
+    "queued",
+    "evaluating",
+    "accepted",
+    "rejected",
+    "needs-review",
+    "failed"
+  ]),
+  reason: z3.string().nullable(),
+  retries: z3.number(),
+  generation: z3.number(),
+  completion: z3.string().nullable(),
+  reviewRewards: rewardBundleSchema.nullable().default(null),
+  createdAt: z3.number()
+});
+var eventSchema = z3.object({
+  id: z3.number(),
+  attempt: z3.string().nullable(),
+  kind: z3.string(),
+  detail: z3.string(),
+  actor: z3.string().nullable().default(null),
+  at: z3.number()
+});
+var pickupSelectionSchema = z3.object({
+  item: identifier,
+  revision: z3.number().int().nonnegative()
+}).strict();
+var pickupAllocationSchema = z3.object({
+  item: identifier,
+  label: z3.string().min(1).max(80)
+}).strict();
+var pickupPolicySchema = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("untracked") }).strict(),
+  z3.object({
+    kind: z3.literal("at-pickup"),
+    tiers: z3.array(
+      z3.object({
+        tier: identifier,
+        variants: z3.array(pickupAllocationSchema).min(1).max(100)
+      }).strict()
+    ).min(1).max(100)
+  }).strict()
+]);
+var pickupCatalogSchema = z3.object({
+  reward: tieredRewardDefinitionSchema,
+  revision: z3.number().int().nonnegative(),
+  policy: pickupPolicySchema
+});
+var pickupAvailabilitySchema = z3.discriminatedUnion("kind", [
+  z3.object({ kind: z3.literal("untracked") }).strict(),
+  z3.object({
+    kind: z3.literal("at-pickup"),
+    revision: z3.number().int().nonnegative(),
+    variants: z3.array(
+      pickupAllocationSchema.extend({
+        available: z3.number().int().nonnegative()
+      })
+    )
+  }).strict()
+]);
+var configurePickupSchema = z3.object({
+  reward: identifier,
+  revision: z3.number().int().nonnegative(),
+  actionId: identifier,
+  policy: pickupPolicySchema
+}).strict();
+var entitlementBase = {
+  id: identifier,
+  member: identifier,
+  reward: tieredRewardDefinitionSchema,
+  earnedTier: identifier,
+  tier: identifier,
+  revision: z3.number().int().positive()
+};
+var entitlementSchema = z3.discriminatedUnion("status", [
+  z3.object({ ...entitlementBase, status: z3.literal("available") }).strict(),
+  z3.object({
+    ...entitlementBase,
+    status: z3.literal("handing-over"),
+    handover: identifier,
+    startedAt: z3.number(),
+    allocation: pickupAllocationSchema.optional()
+  }).strict(),
+  z3.object({
+    ...entitlementBase,
+    status: z3.literal("collected"),
+    handover: identifier,
+    startedAt: z3.number(),
+    allocation: pickupAllocationSchema.optional(),
+    collectedAt: z3.number()
+  }).strict()
+]);
+var beginHandoverSchema = z3.object({
+  actionId: identifier,
+  revision: z3.number().int().positive(),
+  selection: pickupSelectionSchema.optional()
+}).strict();
+var confirmHandoverSchema = z3.object({ actionId: identifier, handover: identifier }).strict();
+var completionRecordSchema = z3.object({
+  id: identifier,
+  quest: identifier,
+  member: identifier
+});
+var questAvailabilitySchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    kind: z3.literal("available"),
+    input: z3.enum(["photo", "quiz", "none"])
+  }).strict(),
+  z3.object({ kind: z3.literal("completed") }).strict(),
+  z3.object({
+    kind: z3.literal("locked"),
+    missing: z3.array(z3.object({ quest: identifier, title: z3.string() })).min(1)
+  }).strict(),
+  z3.object({ kind: z3.literal("staff-required") }).strict(),
+  z3.object({ kind: z3.literal("automatic") }).strict(),
+  z3.object({ kind: z3.literal("checking"), attempt: identifier }).strict(),
+  z3.object({ kind: z3.literal("needs-review"), attempt: identifier }).strict(),
+  z3.object({ kind: z3.literal("retryable"), attempt: identifier }).strict()
+]);
+var memberProgressSchema = z3.object({
+  member: identifier,
+  quests: z3.array(
+    z3.object({
+      quest: identifier,
+      release: identifier.optional(),
+      title: z3.string(),
+      presentation: questPresentationSchema.default({}),
+      trigger: triggerSchema,
+      availability: questAvailabilitySchema,
+      completed: z3.boolean(),
+      missing: z3.array(z3.object({ quest: identifier, title: z3.string() })),
+      attempt: attemptSchema.nullable()
+    })
+  ),
+  entitlements: z3.array(entitlementSchema)
+});
+var snapshotSchema = z3.object({
+  releases: z3.array(publishedReleaseSchema),
+  completions: z3.array(completionRecordSchema),
+  entitlements: z3.array(entitlementSchema),
+  attempts: z3.array(attemptSchema),
+  balances: z3.array(
+    z3.object({
+      member: z3.string(),
+      balance: z3.string(),
+      earned: z3.number(),
+      held: z3.number(),
+      available: z3.number()
+    })
+  ),
+  events: z3.array(eventSchema)
+});
+var evidenceSchema = z3.object({
+  id: identifier,
+  member: identifier,
+  type: z3.enum(["image/jpeg", "image/png"]),
+  size: z3.number()
+});
+var errorSchema = z3.object({
+  error: z3.string(),
+  code: z3.enum(["stale-quiz", "quest-updated"]).optional(),
+  missing: z3.array(z3.object({ quest: identifier, title: z3.string() })).optional()
+});
+var staffDecisionSchema = z3.object({
+  actionId: identifier,
+  generation: z3.number().int().nonnegative(),
+  decision: z3.enum(["accept", "reject"]),
+  reason: z3.string().trim().min(1).max(2e3)
+}).strict();
+var stockSchema = z3.object({ item: identifier, quantity: z3.number().int().min(0).max(1e4) }).strict();
+var reservationSchema = z3.object({
+  actionId: identifier,
+  member: identifier,
+  item: identifier,
+  balance: identifier,
+  price: z3.number().int().positive().max(1e4)
+}).strict();
+var pageOptions = {
+  limit: z3.number().int().min(1).max(100).default(25),
+  cursor: z3.string().min(1).max(4096).optional()
+};
+var reviewListSchema = z3.object({
+  ...pageOptions,
+  member: identifier.optional(),
+  quest: identifier.optional()
+}).strict();
+var memberListSchema = z3.object({
+  ...pageOptions,
+  prefix: identifier.optional()
+}).strict();
+var reviewItemSchema = z3.object({
+  attempt: attemptSchema,
+  title: z3.string(),
+  checks: z3.array(
+    z3.object({ criteria: z3.string(), result: photoResultSchema })
+  )
+});
+var reviewPageSchema = z3.object({
+  items: z3.array(reviewItemSchema).max(100),
+  nextCursor: z3.string().nullable()
+});
+var memberPageSchema = z3.object({
+  items: z3.array(z3.object({ member: identifier })).max(100),
+  nextCursor: z3.string().nullable()
+});
+
+export {
+  quizChoiceSchema,
+  quizQuestionSchema,
+  quizQuestionsSchema,
+  quizContentSchema,
+  settingFieldSchema,
+  settingsFieldsSchema,
+  settingsValuesSchema,
+  settings,
+  parseSettings,
+  identifier,
+  pointsRewardSchema,
+  tieredRewardDefinitionSchema,
+  tierRewardSchema,
+  rewardSchema,
+  rewardKey,
+  triggerSchema,
+  prerequisiteSchema,
+  photoResultSchema,
+  decisionSchema,
+  reviewModeSchema,
+  rewardBundleSchema,
+  mediaUrlSchema,
+  questPresentationSchema,
+  questDescriptionSchema,
+  artifactSchema,
+  releaseSchema,
+  batchReleaseSchema,
+  questSettingsInputSchema,
+  publishedReleaseSchema,
+  templateSchema,
+  quizAnswersSchema,
+  quizEvidenceSchema,
+  submitSchema,
+  attemptSchema,
+  eventSchema,
+  pickupSelectionSchema,
+  pickupAllocationSchema,
+  pickupPolicySchema,
+  pickupCatalogSchema,
+  pickupAvailabilitySchema,
+  configurePickupSchema,
+  entitlementSchema,
+  beginHandoverSchema,
+  confirmHandoverSchema,
+  completionRecordSchema,
+  questAvailabilitySchema,
+  memberProgressSchema,
+  snapshotSchema,
+  evidenceSchema,
+  errorSchema,
+  staffDecisionSchema,
+  stockSchema,
+  reservationSchema,
+  reviewListSchema,
+  memberListSchema,
+  reviewItemSchema,
+  reviewPageSchema,
+  memberPageSchema
+};