@domino-sdk/relay 0.1.0

package/README.md

@@ -0,0 +1,11 @@
+# Domino Relay SDK
+
+Author quests and connect an application to Domino Relay.
+
+```sh
+pnpm add @domino-sdk/relay
+```
+
+Use `@domino-sdk/relay/authoring` for quest definitions, `/browser` for browser integrations, `/portal-proxy` for server proxies, and `/build` for bundling authored modules.
+
+Requires Node.js 24 for tooling. Proprietary software; `UNLICENSED`.

package/build.d.mts

@@ -0,0 +1,2 @@
+/** Bundle a default-exported quest module without executing it on the build host. */
+export declare function buildQuest(entry: string, options?: {exportName?: string}): Promise<{ code: string }>;

package/build.mjs

@@ -0,0 +1,30 @@
+import { resolve, dirname } from "node:path";
+import { build } from "esbuild";
+/** Bundle an authored quest without evaluating developer code in the build process. */
+export async function buildQuest(entry, options = {}) {
+  if (
+    options.exportName &&
+    !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(options.exportName)
+  )
+    throw new Error("Invalid quest export name");
+  const result = await build({
+    ...(options.exportName
+      ? {
+          stdin: {
+            contents: `export { ${options.exportName} as default } from ${JSON.stringify(resolve(entry))};`,
+            resolveDir: dirname(resolve(entry)),
+            loader: "ts",
+          },
+        }
+      : { entryPoints: [entry] }),
+    bundle: true,
+    write: false,
+    format: "esm",
+    platform: "neutral",
+    target: "es2022",
+    minify: true,
+  });
+  const file = result.outputFiles[0];
+  if (!file) throw new Error("Quest build produced no module");
+  return { code: file.text };
+}

package/dist/authoring.d.ts

@@ -0,0 +1,279 @@
+import { z } from 'zod';
+import { PhotoResult, rewardSchema, triggerSchema, QuestPresentation, QuizEvidence, Decision, TieredRewardDefinition } from './schema.js';
+import { W as WalletConnection, S as SolanaBalance } from './settings-BEbCiuhH.js';
+export { s as settings } from './settings-BEbCiuhH.js';
+
+type Reward = z.infer<typeof rewardSchema>;
+declare const points: (balance: string, amount: number) => {
+    kind: "points";
+    balance: string;
+    amount: number;
+};
+declare const evidence: {
+    photo: () => "photo";
+    quiz: () => "quiz";
+};
+declare function manual<const I extends "photo" | "quiz">(options: {
+    input: I;
+}): {
+    kind: "manual";
+    input: I;
+};
+declare function manual(): {
+    kind: "manual";
+    input: "none";
+};
+declare function manual(options: {
+    actor: "staff";
+}): {
+    kind: "manual";
+    input: "none";
+    actor: "staff";
+};
+declare const automatic: () => {
+    kind: "automatic";
+};
+declare const completed: (quest: {
+    id: string;
+} | string) => {
+    quest: string;
+    scope: "ever";
+};
+declare const untracked: () => {
+    kind: "untracked";
+};
+declare const staffHandover: () => {
+    kind: "staff-handover";
+};
+declare function defineTieredReward(input: TieredRewardDefinition): {
+    id: string;
+    tier: (tier: string) => {
+        kind: "tier";
+        reward: {
+            id: string;
+            title: string;
+            tiers: {
+                id: string;
+                title: string;
+            }[];
+            inventory: {
+                kind: "untracked";
+            };
+            fulfillment: {
+                kind: "staff-handover";
+            };
+        };
+        tier: string;
+    };
+};
+declare const once: () => {
+    kind: "once";
+};
+type Outcome = {
+    kind: "accept";
+    rewards?: Reward[];
+} | {
+    kind: "review";
+    reason: string;
+    rewards?: Reward[];
+} | {
+    kind: "reject";
+    reason: string;
+};
+declare const decision: {
+    accept: (options?: {
+        rewards?: Reward[];
+    }) => Outcome;
+    reject: (options: {
+        reason: string;
+    }) => Outcome;
+    review: (options: {
+        reason: string;
+        rewards?: Reward[];
+    }) => Outcome;
+};
+type EvaluationContext<T, I = {
+    photo: string;
+}> = {
+    settings: T;
+    member: {
+        id: string;
+    };
+    input: I;
+    review: {
+        photo(options: {
+            image: string;
+            criteria: string;
+        }): Promise<PhotoResult>;
+    };
+    wallet: {
+        connection(): Promise<WalletConnection | null>;
+        solanaBalance(): Promise<SolanaBalance | null>;
+    };
+};
+type Evaluator<T, I = {
+    photo: string;
+}> = (ctx: EvaluationContext<T, I>) => Promise<Outcome>;
+declare const evaluators: {
+    quiz(answerKey: QuizEvidence["answers"], options?: {
+        minimumCorrect?: number;
+    }): Evaluator<unknown, QuizEvidence>;
+    photo<T>(options: (ctx: {
+        settings: T;
+    }) => {
+        criteria: string;
+        unclear: "human-review" | "reject";
+    }): Evaluator<T>;
+};
+type Trigger = z.infer<typeof triggerSchema>;
+type QuestInput<T extends Trigger> = T extends {
+    input: "photo";
+} ? {
+    photo: string;
+} : T extends {
+    input: "quiz";
+} ? QuizEvidence : Record<string, never>;
+declare function defineQuest<T extends Record<string, z.ZodType>, const G extends Trigger>(definition: {
+    id: string;
+    title: string | ((ctx: {
+        settings: z.output<z.ZodObject<T>>;
+    }) => string);
+    settings: z.ZodObject<T>;
+    presentation?: (ctx: {
+        settings: z.output<z.ZodObject<T>>;
+    }) => QuestPresentation;
+    trigger: G;
+    requires?: ReturnType<typeof completed>[];
+    completion: ReturnType<typeof once>;
+    review?: (ctx: {
+        settings: z.output<z.ZodObject<T>>;
+    }) => {
+        enabled: boolean;
+    };
+    rewards: Reward[] | ((ctx: {
+        settings: z.output<z.ZodObject<T>>;
+    }) => Reward[]);
+    evaluate?: Evaluator<z.output<z.ZodObject<T>>, QuestInput<G>>;
+}): {
+    id: string;
+    describe: (input: unknown) => {
+        quest: string;
+        runtimeVersion: 1 | 2;
+        title: string;
+        presentation: {
+            quiz?: {
+                id: string;
+                prompt: string;
+                choices: {
+                    id: string;
+                    label: string;
+                }[];
+            }[] | undefined;
+            instructions?: string | undefined;
+            video?: {
+                url: string;
+                poster?: string | undefined;
+                captions?: {
+                    url: string;
+                    language: string;
+                    label: string;
+                } | undefined;
+            } | undefined;
+        };
+        fields: Record<string, {
+            kind: "quiz";
+            default: {
+                id: string;
+                prompt: string;
+                choices: {
+                    id: string;
+                    label: string;
+                }[];
+                correct: string;
+            }[];
+            label: string;
+            description?: string | undefined;
+        } | {
+            kind: "text";
+            default: string;
+            minLength: number;
+            maxLength: number;
+            multiline: boolean;
+            label: string;
+            description?: string | undefined;
+        } | {
+            kind: "integer";
+            default: number;
+            min: number;
+            max: number;
+            label: string;
+            description?: string | undefined;
+        } | {
+            kind: "boolean";
+            default: boolean;
+            label: string;
+            description?: string | undefined;
+        } | {
+            kind: "choice";
+            default: string;
+            options: string[];
+            label: string;
+            description?: string | undefined;
+        }>;
+        values: Record<string, string | number | boolean | {
+            id: string;
+            prompt: string;
+            choices: {
+                id: string;
+                label: string;
+            }[];
+            correct: string;
+        }[]>;
+        rewards: ({
+            kind: "tier";
+            reward: {
+                id: string;
+                title: string;
+                tiers: {
+                    id: string;
+                    title: string;
+                }[];
+                inventory: {
+                    kind: "untracked";
+                };
+                fulfillment: {
+                    kind: "staff-handover";
+                };
+            };
+            tier: string;
+        } | {
+            kind: "points";
+            balance: string;
+            amount: number;
+        })[];
+        humanReview: boolean;
+        trigger: {
+            kind: "manual";
+            input: "photo" | "quiz" | "none";
+            actor?: "member" | "staff" | undefined;
+        } | {
+            kind: "automatic";
+        };
+        requires: {
+            quest: string;
+            scope: "ever";
+        }[];
+        completion: {
+            kind: "once";
+        };
+    };
+    evaluate(ctx: EvaluationContext<unknown, QuestInput<G>> & {
+        rewards: Reward[];
+        humanReview: boolean;
+    }): Promise<Decision>;
+};
+/** Publish this artifact as a reusable type. Its id identifies the type;
+ * Console instances receive independent quest identities and pinned versions. */
+declare const defineQuestType: typeof defineQuest;
+
+export { type EvaluationContext, automatic, completed, decision, defineQuest, defineQuestType, defineTieredReward, evaluators, evidence, manual, once, points, staffHandover, untracked };

package/dist/authoring.js

@@ -0,0 +1,149 @@
+import {
+  decisionSchema,
+  parseSettings,
+  pointsRewardSchema,
+  questDescriptionSchema,
+  quizAnswersSchema,
+  rewardBundleSchema,
+  settingFieldSchema,
+  settings,
+  tierRewardSchema,
+  tieredRewardDefinitionSchema
+} from "./chunk-C2KOMNLG.js";
+
+// src/authoring.ts
+import { z } from "zod";
+var points = (balance, amount) => pointsRewardSchema.parse({ kind: "points", balance, amount });
+var evidence = {
+  photo: () => "photo",
+  quiz: () => "quiz"
+};
+function manual(options) {
+  return {
+    kind: "manual",
+    input: options?.input ?? "none",
+    ...options?.actor ? { actor: options.actor } : {}
+  };
+}
+var automatic = () => ({ kind: "automatic" });
+var completed = (quest) => ({
+  quest: typeof quest === "string" ? quest : quest.id,
+  scope: "ever"
+});
+var untracked = () => ({ kind: "untracked" });
+var staffHandover = () => ({ kind: "staff-handover" });
+function defineTieredReward(input) {
+  const reward = tieredRewardDefinitionSchema.parse(input);
+  return {
+    id: reward.id,
+    tier: (tier) => tierRewardSchema.parse({ kind: "tier", reward, tier })
+  };
+}
+var once = () => ({ kind: "once" });
+var decision = {
+  accept: (options = {}) => ({
+    kind: "accept",
+    ...options
+  }),
+  reject: (options) => ({
+    kind: "reject",
+    ...options
+  }),
+  review: (options) => ({
+    kind: "review",
+    ...options
+  })
+};
+var evaluators = {
+  quiz(answerKey, options = {}) {
+    const expected = quizAnswersSchema.parse(answerKey);
+    const questions = Object.keys(expected);
+    const minimum = z.number().int().min(1).max(questions.length).parse(options.minimumCorrect ?? questions.length);
+    return async ({ input }) => {
+      const complete = Object.keys(input.answers).length === questions.length && questions.every((question) => Object.hasOwn(input.answers, question));
+      const correct = questions.filter(
+        (question) => input.answers[question] === expected[question]
+      ).length;
+      return complete && correct >= minimum ? decision.accept() : decision.reject({ reason: "Review your answers and try again." });
+    };
+  },
+  photo(options) {
+    return async (ctx) => {
+      const config = options(ctx);
+      const result = await ctx.review.photo({
+        image: ctx.input.photo,
+        criteria: config.criteria
+      });
+      if (result.kind === "unclear")
+        return config.unclear === "human-review" ? decision.review({ reason: result.reason }) : decision.reject({ reason: result.reason });
+      return result.kind === "pass" ? decision.accept() : decision.reject({ reason: result.reason });
+    };
+  }
+};
+function defineQuest(definition) {
+  if (definition.trigger.kind === "manual" && definition.trigger.input !== "none" && !definition.evaluate)
+    throw new Error("Evidence quests require an evaluator");
+  const fields = Object.fromEntries(
+    Object.entries(definition.settings.shape).map(([key, schema]) => [
+      key,
+      settingFieldSchema.parse(schema.meta())
+    ])
+  );
+  function describe(input) {
+    const settings2 = definition.settings.parse(input);
+    const values = parseSettings(fields, settings2);
+    const rewards = rewardBundleSchema.parse(
+      typeof definition.rewards === "function" ? definition.rewards({ settings: settings2 }) : definition.rewards
+    );
+    return questDescriptionSchema.parse({
+      quest: definition.id,
+      runtimeVersion: 2,
+      title: typeof definition.title === "function" ? definition.title({ settings: settings2 }) : definition.title,
+      presentation: definition.presentation?.({ settings: settings2 }) ?? {},
+      fields,
+      values,
+      rewards,
+      humanReview: definition.review?.({ settings: settings2 })?.enabled ?? true,
+      trigger: definition.trigger,
+      completion: definition.completion,
+      requires: definition.requires ?? []
+    });
+  }
+  return {
+    id: definition.id,
+    describe,
+    async evaluate(ctx) {
+      const settings2 = definition.settings.parse(ctx.settings);
+      const result = definition.evaluate ? await definition.evaluate({
+        settings: settings2,
+        member: ctx.member,
+        input: ctx.input,
+        review: ctx.review,
+        wallet: ctx.wallet
+      }) : decision.accept();
+      if (!result) throw new Error("Evaluator returned no decision");
+      if (result.kind === "review" && !ctx.humanReview)
+        return decisionSchema.parse({ kind: "reject", reason: result.reason });
+      return decisionSchema.parse(
+        result.kind === "accept" || result.kind === "review" ? { ...result, rewards: result.rewards ?? ctx.rewards } : result
+      );
+    }
+  };
+}
+var defineQuestType = defineQuest;
+export {
+  automatic,
+  completed,
+  decision,
+  defineQuest,
+  defineQuestType,
+  defineTieredReward,
+  evaluators,
+  evidence,
+  manual,
+  once,
+  points,
+  settings,
+  staffHandover,
+  untracked
+};