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

package/dist/chunk-DJZB5RY5.js

@@ -0,0 +1,901 @@
+import {
+  contentMetricSchema,
+  contentMetricsSchema,
+  identifier,
+  pointsRewardSchema,
+  tierRewardSchema
+} from "./chunk-UW6R2QGT.js";
+
+// src/authoring-identity.ts
+import { z } from "zod";
+var authoringIdentityShape = {
+  key: identifier.optional(),
+  id: identifier.optional()
+};
+function validateAuthoringIdentity(value, ctx) {
+  if (!value.key && !value.id) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["key"],
+      message: "Provide an authoring key. Legacy id is also accepted."
+    });
+  }
+  if (value.key && value.id && value.key !== value.id) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["key"],
+      message: "id and key must match. Keep the existing authoring name to preserve identity."
+    });
+  }
+}
+function normalizeAuthoringIdentity(value) {
+  const { id, key, ...properties } = value;
+  return { ...properties, key: identifier.parse(key ?? id) };
+}
+var identitySchema = z.object(authoringIdentityShape).superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
+var authoringKey = (input) => identitySchema.parse(input).key;
+
+// src/engagement.ts
+import { z as z2 } from "zod";
+var amount = z2.number().int().safe().nonnegative();
+var engagementDefinitionSchema = z2.strictObject({
+  key: identifier,
+  qualifiedBy: identifier,
+  balance: identifier,
+  metrics: z2.array(contentMetricSchema).min(1).max(6).refine(
+    (metrics) => new Set(metrics).size === metrics.length,
+    "Metrics must be unique"
+  ),
+  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({})
+});
+var engagementScoreInputSchema = z2.strictObject({
+  metrics: contentMetricsSchema,
+  baseline: contentMetricsSchema
+});
+var engagementScoreSchema = z2.strictObject({
+  target: amount,
+  baseline: amount
+});
+var engagementPublishSchema = z2.strictObject({
+  actionId: identifier,
+  code: z2.string().min(1).max(1e6)
+});
+var engagementRuleSchema = z2.strictObject({
+  version: identifier,
+  definition: engagementDefinitionSchema,
+  publishedAt: amount
+});
+var engagementPageQuerySchema = z2.strictObject({
+  rule: identifier,
+  content: z2.string().min(1).max(256),
+  member: identifier.optional(),
+  before: z2.coerce.number().int().positive().safe().optional()
+});
+var engagementSettlementSchema = z2.strictObject({
+  id: identifier,
+  day: z2.string(),
+  observation: identifier,
+  qualification: identifier,
+  earned: amount,
+  growth: amount,
+  paid: amount,
+  excluded: amount,
+  entry: identifier.nullable(),
+  createdAt: amount
+});
+var engagementPageSchema = z2.strictObject({
+  rule: engagementRuleSchema,
+  account: z2.strictObject({
+    member: identifier,
+    earned: amount,
+    accounted: amount,
+    paid: amount,
+    excluded: amount,
+    pending: amount,
+    counters: contentMetricsSchema,
+    baseline: contentMetricsSchema,
+    observation: identifier.nullable(),
+    nextSettlementAt: amount.nullable(),
+    reason: z2.string().nullable()
+  }).nullable(),
+  items: z2.array(engagementSettlementSchema),
+  next: amount.nullable()
+});
+var engagementChangePreviewInputSchema = z2.strictObject({
+  code: z2.string().min(1).max(1e6)
+});
+var engagementChangeSchema = engagementPublishSchema.extend({
+  expectedVersion: identifier,
+  previewHash: identifier
+});
+var total = z2.string().regex(/^(0|[1-9][0-9]*)$/);
+var engagementChangePreviewSchema = z2.strictObject({
+  rule: identifier,
+  fromVersion: identifier,
+  toVersion: identifier,
+  previewHash: identifier,
+  definition: engagementDefinitionSchema,
+  boundary: z2.literal("available-eligible-observation"),
+  settlement: z2.literal("deferred"),
+  summary: z2.strictObject({
+    knownAdmissions: amount,
+    accounts: amount,
+    uninitialized: amount,
+    pendingTransitions: amount,
+    earned: total,
+    paid: total,
+    excluded: total,
+    pending: total
+  })
+});
+var engagementVersionPageSchema = z2.strictObject({
+  items: z2.array(
+    engagementRuleSchema.extend({ previousVersion: identifier.nullable() })
+  ),
+  next: amount.nullable()
+});
+var engagementVersionQuerySchema = z2.strictObject({
+  rule: identifier,
+  before: z2.coerce.number().int().positive().safe().optional()
+});
+var engagementBoundaryPageSchema = z2.strictObject({
+  current: engagementRuleSchema.nullable(),
+  requested: engagementRuleSchema,
+  items: z2.array(
+    z2.strictObject({
+      from: identifier,
+      to: identifier,
+      baseline: contentMetricsSchema,
+      observedAt: amount,
+      settlement: engagementSettlementSchema
+    })
+  ),
+  next: amount.nullable()
+});
+var engagementArtifactSchema = engagementPublishSchema.omit({
+  actionId: true
+});
+var deploymentEntry = engagementArtifactSchema.extend({
+  rule: engagementRuleSchema
+});
+var engagementDeploymentEntrySchema = z2.discriminatedUnion("kind", [
+  deploymentEntry.extend({ kind: z2.literal("create") }),
+  deploymentEntry.extend({ kind: z2.literal("unchanged") }),
+  deploymentEntry.extend({
+    kind: z2.literal("change"),
+    change: engagementChangePreviewSchema
+  })
+]);
+
+// src/profiles.ts
+import { z as z3 } from "zod";
+var count = z3.number().int().nonnegative().safe();
+var profileVisibilitySchema = z3.enum([
+  "private",
+  "participants",
+  "public"
+]);
+var avatarProviderSchema = z3.enum(["x", "discord", "google"]);
+var profileDefaultProviderSchema = z3.enum(["x", "discord"]);
+var profileDefaultsSchema = z3.array(profileDefaultProviderSchema).max(profileDefaultProviderSchema.options.length).refine(
+  (providers) => new Set(providers).size === providers.length,
+  "List each provider once"
+);
+var avatarSeedSchema = z3.string().min(1).max(100);
+var profileAvatarSchema = z3.discriminatedUnion("source", [
+  z3.object({
+    source: z3.literal("upload"),
+    url: z3.string().url(),
+    seed: avatarSeedSchema
+  }),
+  z3.object({
+    source: z3.literal("account"),
+    provider: avatarProviderSchema,
+    url: z3.string().url(),
+    seed: avatarSeedSchema
+  }),
+  z3.object({ source: z3.literal("generated"), seed: avatarSeedSchema })
+]);
+var profileSummarySchema = z3.object({
+  id: identifier,
+  name: z3.string(),
+  avatar: profileAvatarSchema
+});
+var invisible = /[\p{Cc}؜᠎​-‏‪-‮⁠-⁤⁦-⁩]/u;
+var displayNameSchema = z3.string().max(200).transform((value) => value.normalize("NFC").replace(/\s+/g, " ").trim()).pipe(
+  z3.string().min(1, "Enter a name").max(40, "Use at most 40 characters").refine((value) => !invisible.test(value), "Use visible characters only")
+);
+var profileUpdateSchema = z3.object({
+  displayName: displayNameSchema.nullable().optional(),
+  avatar: z3.discriminatedUnion("source", [
+    z3.object({
+      source: z3.literal("account"),
+      provider: avatarProviderSchema
+    }).strict(),
+    z3.object({ source: z3.literal("generated") }).strict()
+  ]).nullable().optional(),
+  hidden: z3.boolean().optional()
+}).strict().refine(
+  (value) => Object.values(value).some((field) => field !== void 0),
+  "Change at least one field"
+);
+var ownProfileSchema = profileSummarySchema.extend({
+  /** The name the member chose, or null for the default. */
+  displayName: z3.string().nullable(),
+  /** The avatar the member chose: `default` follows the project's defaults. */
+  avatarChoice: z3.enum(["default", "upload", "account", "generated"]),
+  /** The account of an `account` choice. */
+  avatarProvider: avatarProviderSchema.nullable(),
+  hidden: z3.boolean(),
+  /** An operator locked the name and avatar; the member can still hide the profile. */
+  locked: z3.boolean(),
+  /** Who can see profiles in this project, so the app can explain it. */
+  visibility: profileVisibilitySchema,
+  /** The member's connected accounts a picture or name can come from. */
+  options: z3.array(
+    z3.object({
+      provider: avatarProviderSchema,
+      name: z3.string().nullable(),
+      imageUrl: z3.string().url().nullable()
+    })
+  )
+});
+var cursor = z3.string().min(1).max(512);
+var profileCompletionQuerySchema = z3.object({
+  limit: z3.coerce.number().int().min(1).max(100).default(20),
+  cursor: cursor.optional()
+}).strict();
+var profileCompletionSchema = z3.object({
+  quest: identifier,
+  key: identifier.optional(),
+  title: z3.string(),
+  completions: count.positive(),
+  /** Null for completions recorded before completion times were. */
+  lastCompletedAt: count.nullable()
+});
+var profileCompletionPageSchema = z3.object({
+  items: z3.array(profileCompletionSchema),
+  nextCursor: cursor.nullable()
+});
+var profileReferralSchema = z3.object({
+  program: identifier,
+  key: identifier.optional(),
+  title: z3.string(),
+  /** Members this member invited. Invitations are shared by every program. */
+  invited: count,
+  /** Invited members who qualified in this program. */
+  qualified: count,
+  milestones: z3.array(
+    z3.object({ id: identifier, count, reached: z3.boolean() })
+  )
+});
+var profileSettingsSchema = z3.object({
+  visibility: profileVisibilitySchema,
+  defaults: profileDefaultsSchema,
+  revision: count,
+  actor: z3.string().nullable(),
+  updatedAt: count.nullable()
+});
+var profileSettingsInputSchema = profileSettingsSchema.omit({ revision: true, actor: true, updatedAt: true }).extend({
+  actionId: identifier,
+  /** The revision the change was made against; a newer one is a 409. */
+  expectedRevision: count,
+  reason: z3.string().trim().min(1).max(500)
+}).strict();
+var profileModerationSchema = z3.object({
+  actionId: identifier,
+  resetName: z3.boolean().default(false),
+  removeAvatar: z3.boolean().default(false),
+  /** True locks the name and avatar, false unlocks them. */
+  lock: z3.boolean().optional(),
+  reason: z3.string().trim().min(1).max(1e3)
+}).strict().refine(
+  (value) => value.resetName || value.removeAvatar || value.lock !== void 0,
+  "Choose an action"
+);
+var managedProfileSchema = ownProfileSchema.omit({ options: true }).extend({
+  member: identifier,
+  lockedAt: count.nullable(),
+  lockedBy: z3.string().nullable(),
+  lockedReason: z3.string().nullable(),
+  updatedAt: count
+});
+var AVATAR_UPLOAD_LIMIT = 5 * 1024 * 1024;
+var avatarUploadTypes = ["image/jpeg", "image/png", "image/webp"];
+
+// src/leaderboards.ts
+import { z as z4 } from "zod";
+var integer = z4.number().int().safe();
+var timestamp = integer.nonnegative().max(864e13);
+var leaderboardWindowSchema = z4.discriminatedUnion("kind", [
+  z4.object({ kind: z4.literal("all-time") }).strict(),
+  z4.object({ kind: z4.literal("fixed"), start: timestamp, end: timestamp }).strict().refine((w) => w.end > w.start, "Window end must follow its start"),
+  z4.object({ kind: z4.literal("rolling"), days: integer.min(1).max(3660) }).strict(),
+  z4.object({
+    kind: z4.literal("calendar"),
+    period: z4.enum(["day", "week", "month"]),
+    timeZone: z4.string().min(1).max(100).refine((zone) => {
+      try {
+        new Intl.DateTimeFormat("en", { timeZone: zone });
+        return true;
+      } catch {
+        return false;
+      }
+    }, "Use an IANA timezone")
+  }).strict()
+]);
+var periodScore = {
+  window: leaderboardWindowSchema.default({ kind: "all-time" }),
+  quests: z4.array(identifier).min(1).max(100).optional()
+};
+var leaderboardDefinitionSchema = z4.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z4.string().trim().min(1).max(120),
+  balance: identifier,
+  score: z4.discriminatedUnion("kind", [
+    z4.object({ kind: z4.literal("balance") }).strict(),
+    z4.object({ kind: z4.literal("earned"), ...periodScore }).strict(),
+    z4.object({
+      kind: z4.literal("net"),
+      window: leaderboardWindowSchema.default({ kind: "all-time" })
+    }).strict()
+  ]).default({ kind: "balance" }),
+  access: z4.enum(["participants", "public"]).default("participants"),
+  group: identifier.optional()
+}).strict();
+var leaderboardAuthoringSchema = leaderboardDefinitionSchema.omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).transform(normalizeAuthoringIdentity);
+var leaderboardArtifactSchema = z4.union([
+  leaderboardAuthoringSchema,
+  z4.object({ code: z4.string().min(1).max(2e6) }).strict()
+]);
+var publishedLeaderboardSchema = z4.object({
+  version: identifier,
+  definition: leaderboardDefinitionSchema,
+  publishedAt: timestamp,
+  actor: z4.string().nullable()
+});
+var leaderboardQuerySchema = z4.object({
+  limit: z4.coerce.number().int().min(1).max(100).default(25),
+  cursor: z4.string().max(4096).optional()
+}).strict();
+var leaderboardRowSchema = z4.object({
+  /** The row's stable key: a pseudonym per board and member. */
+  participant: identifier,
+  member: identifier.optional(),
+  /** The profile's name where the viewer can see it, otherwise the pseudonym's. */
+  name: z4.string(),
+  score: integer,
+  rank: integer.positive(),
+  /**
+   * The member's profile, where the project shows profiles to this viewer and the member has not
+   * hidden theirs. Older servers omit it.
+   */
+  profile: profileSummarySchema.nullable().default(null)
+});
+var leaderboardPageSchema = z4.object({
+  leaderboard: identifier,
+  title: z4.string(),
+  version: identifier,
+  calculation: z4.enum(["balance", "earned", "net"]),
+  period: z4.object({ start: timestamp.nullable(), end: timestamp.nullable() }),
+  calculatedAt: timestamp,
+  lastEntryAt: timestamp.nullable(),
+  total: integer.nonnegative(),
+  items: z4.array(leaderboardRowSchema),
+  me: leaderboardRowSchema.nullable(),
+  nearby: z4.array(leaderboardRowSchema),
+  nextCursor: z4.string().nullable()
+});
+var leaderboardPlacementSchema = z4.object({
+  leaderboard: identifier,
+  key: identifier.optional(),
+  title: z4.string(),
+  profile: identifier,
+  rank: integer.positive().nullable(),
+  score: integer.nullable(),
+  /** Ranked participants on the board. */
+  total: integer.nonnegative()
+});
+var leaderboardPreviewSchema = z4.object({
+  published: publishedLeaderboardSchema,
+  before: leaderboardPageSchema.nullable(),
+  after: leaderboardPageSchema
+});
+var mutationBase = {
+  actionId: identifier,
+  member: identifier,
+  balance: identifier,
+  reason: z4.string().trim().min(1).max(1e3)
+};
+var datedMutation = { ...mutationBase, effectiveAt: timestamp.optional() };
+var pointsMutationSchema = z4.discriminatedUnion("kind", [
+  z4.object({
+    ...datedMutation,
+    kind: z4.literal("award"),
+    referralEligible: z4.boolean().optional(),
+    amount: integer.positive()
+  }).strict(),
+  z4.object({
+    ...datedMutation,
+    kind: z4.literal("spend"),
+    amount: integer.positive()
+  }).strict(),
+  z4.object({
+    ...datedMutation,
+    kind: z4.literal("adjust"),
+    amount: integer.refine((n) => n !== 0)
+  }).strict(),
+  z4.object({
+    ...datedMutation,
+    kind: z4.literal("set"),
+    total: integer.nonnegative(),
+    expectedTotal: integer.nonnegative(),
+    classification: z4.enum(["earned", "spend"])
+  }).strict(),
+  z4.object({
+    ...mutationBase,
+    kind: z4.literal("reverse"),
+    entry: identifier,
+    amount: integer.positive()
+  }).strict()
+]);
+var pointsEntrySchema = z4.object({
+  id: identifier,
+  completion: z4.string().nullable(),
+  member: identifier,
+  balance: identifier,
+  amount: integer,
+  kind: z4.enum(["award", "spend", "adjust", "reverse"]),
+  effectiveAt: timestamp,
+  receivedAt: timestamp,
+  quest: identifier.nullable(),
+  original: identifier.nullable(),
+  reason: z4.string(),
+  actor: z4.string().nullable()
+});
+var pointsResultSchema = z4.object({
+  entry: pointsEntrySchema,
+  total: integer.nonnegative()
+});
+var pointsAccountSchema = z4.object({
+  member: identifier,
+  balance: identifier,
+  total: integer.nonnegative(),
+  held: integer.nonnegative()
+});
+var leaderboardExclusionSchema = z4.object({
+  actionId: identifier,
+  member: identifier,
+  excluded: z4.boolean(),
+  reason: z4.string().trim().min(1).max(1e3)
+}).strict();
+var leaderboardGroupSchema = z4.object({
+  actionId: identifier,
+  member: identifier,
+  included: z4.boolean(),
+  reason: z4.string().trim().min(1).max(1e3)
+}).strict();
+
+// src/referrals.ts
+import { z as z5 } from "zod";
+var rewardSchema = z5.union([pointsRewardSchema, tierRewardSchema]);
+var amount2 = z5.number().int().safe().nonnegative();
+var reason = z5.string().trim().min(1).max(1e3);
+var referralDefinitionSchema = z5.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z5.string().trim().min(1).max(120),
+  enabled: z5.boolean().default(true),
+  qualification: z5.discriminatedUnion("kind", [
+    z5.object({ kind: z5.literal("signup") }).strict(),
+    z5.object({ kind: z5.literal("quest"), quest: identifier }).strict(),
+    z5.object({ kind: z5.literal("external") }).strict()
+  ]),
+  inviterGroup: identifier.optional(),
+  rewards: z5.object({
+    inviter: z5.array(rewardSchema).max(10).default([]),
+    invitee: z5.array(rewardSchema).max(10).default([])
+  }).strict().default({ inviter: [], invitee: [] }),
+  milestones: z5.array(
+    z5.object({
+      id: identifier,
+      count: amount2.min(1),
+      rewards: z5.array(rewardSchema).min(1).max(10)
+    }).strict()
+  ).max(30).default([]),
+  bonuses: z5.array(
+    z5.object({
+      id: identifier,
+      balance: identifier,
+      basisPoints: amount2.min(1).max(1e4),
+      quests: z5.array(identifier).min(1).max(100).optional(),
+      external: z5.boolean().default(false),
+      durationDays: amount2.min(1).max(36500).optional(),
+      maxPoints: amount2.min(1).optional()
+    }).strict()
+  ).max(20).default([])
+}).strict().superRefine((value, ctx) => {
+  for (const entries of [value.milestones, value.bonuses]) {
+    if (new Set(entries.map((e) => e.id)).size !== entries.length) {
+      ctx.addIssue({ code: "custom", message: "Rule IDs must be unique" });
+    }
+  }
+});
+var referralAuthoringSchema = z5.object(referralDefinitionSchema.shape).omit({ id: true }).extend(authoringIdentityShape).strict().superRefine(validateAuthoringIdentity).superRefine((value, ctx) => {
+  for (const entries of [value.milestones, value.bonuses]) {
+    if (new Set(entries.map((entry) => entry.id)).size !== entries.length) {
+      ctx.addIssue({ code: "custom", message: "Rule keys must be unique" });
+    }
+  }
+}).transform(normalizeAuthoringIdentity);
+var referralArtifactSchema = z5.union([
+  referralAuthoringSchema,
+  z5.object({ code: z5.string().min(1).max(2e6) }).strict()
+]);
+var publishedReferralSchema = z5.object({
+  version: identifier,
+  definition: referralDefinitionSchema,
+  publishedAt: amount2,
+  actor: z5.string().nullable()
+});
+var referralAcceptSchema = z5.object({ actionId: identifier, code: identifier }).strict();
+var referralControlSchema = z5.discriminatedUnion("kind", [
+  z5.object({
+    kind: z5.literal("suspend"),
+    actionId: identifier,
+    member: identifier,
+    suspended: z5.boolean(),
+    reason
+  }).strict(),
+  z5.object({
+    kind: z5.literal("qualify"),
+    actionId: identifier,
+    member: identifier,
+    program: identifier,
+    qualified: z5.boolean(),
+    reason
+  }).strict(),
+  z5.object({
+    kind: z5.literal("resolve-reward"),
+    actionId: identifier,
+    entitlement: identifier,
+    reason
+  }).strict()
+]);
+var referralRelationshipSchema = z5.object({
+  member: identifier,
+  inviter: identifier,
+  acceptedAt: amount2,
+  suspended: z5.boolean()
+});
+var referralAccountSchema = z5.object({
+  id: identifier,
+  program: identifier,
+  kind: z5.enum(["bonus", "fixed", "milestone"]),
+  balance: identifier,
+  earned: amount2,
+  settled: amount2,
+  outstanding: amount2
+});
+var referralSummarySchema = z5.object({
+  code: identifier,
+  attributed: amount2,
+  programs: z5.array(
+    z5.object({
+      definition: referralDefinitionSchema,
+      qualified: amount2,
+      milestones: z5.array(
+        z5.object({ id: identifier, count: amount2, reached: z5.boolean() })
+      )
+    })
+  ),
+  accounts: z5.array(referralAccountSchema)
+});
+var referralHistorySchema = z5.object({
+  items: z5.array(
+    z5.object({
+      id: amount2,
+      program: identifier,
+      balance: identifier,
+      amount: z5.number().int().safe(),
+      at: amount2,
+      reason: z5.string()
+    })
+  ),
+  next: amount2.nullable()
+});
+var referralManagementSchema = z5.object({
+  relationships: z5.array(referralRelationshipSchema),
+  qualifications: z5.array(
+    z5.object({
+      member: identifier,
+      program: identifier,
+      qualified: z5.boolean(),
+      qualifiedAt: amount2
+    })
+  ),
+  accounts: z5.array(
+    referralAccountSchema.extend({ member: identifier, invitee: z5.string() })
+  ),
+  reviews: z5.array(
+    z5.object({
+      entitlement: identifier,
+      member: identifier,
+      program: identifier,
+      reason: z5.string()
+    })
+  ),
+  next: amount2.nullable()
+});
+
+// src/wallet.ts
+import { z as z6 } from "zod";
+var solanaAddressSchema = z6.string().min(32).max(44).regex(/^[1-9A-HJ-NP-Za-km-z]+$/);
+var walletConnectionSchema = z6.object({
+  chain: z6.literal("solana"),
+  address: solanaAddressSchema,
+  verifiedAt: z6.number().int().nonnegative(),
+  revision: z6.number().int().positive()
+}).strict();
+var walletChallengeInputSchema = z6.object({
+  chain: z6.literal("solana"),
+  address: solanaAddressSchema
+}).strict();
+var walletChallengeSchema = walletChallengeInputSchema.extend({
+  id: z6.string().uuid(),
+  message: z6.string(),
+  expiresAt: z6.number()
+});
+var walletProofSchema = z6.object({
+  challenge: z6.string().uuid(),
+  signature: z6.string().min(64).max(88).regex(/^[1-9A-HJ-NP-Za-km-z]+$/)
+}).strict();
+var solanaBalanceSchema = z6.object({
+  address: solanaAddressSchema,
+  network: z6.literal("mainnet-beta"),
+  lamports: z6.string().regex(/^(0|[1-9][0-9]*)$/),
+  slot: z6.number().int().nonnegative().safe(),
+  observedAt: z6.number().int().nonnegative()
+}).strict();
+var walletChainSchema = z6.enum(["solana", "eip155", "cosmos"]);
+var cosmosNetworkPattern = /^cosmos:[-_a-zA-Z0-9]{1,32}$/;
+var cosmosNetworkSchema = z6.custom(
+  (value) => typeof value === "string" && cosmosNetworkPattern.test(value),
+  "Use a Cosmos network: cosmos:<chain ID>"
+);
+function cosmosChain(chain) {
+  if (typeof chain === "string" && !chain.startsWith("cosmos:")) {
+    throw new Error('Use a Cosmos network such as "cosmos:cosmoshub-4"');
+  }
+  const value = typeof chain === "string" ? { chainId: chain.slice("cosmos:".length) } : chain;
+  if (typeof value?.chainId !== "string") {
+    throw new Error(
+      'Pass a Cosmos chain as { chainId } or a network such as "cosmos:cosmoshub-4"'
+    );
+  }
+  const network = `cosmos:${value.chainId}`;
+  if (!cosmosNetworkPattern.test(network)) {
+    throw new Error(
+      "A Cosmos chain ID has 1 to 32 letters, digits, hyphens or underscores"
+    );
+  }
+  if (value.chainInfo && value.chainInfo.chainId !== value.chainId) {
+    throw new Error("The chain info describes another chain ID");
+  }
+  return { ...value, network };
+}
+var solanaMainnet = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+var evmAddressSchema = z6.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var cosmosAddressSchema = z6.string().min(8).max(90).regex(
+  /^(?:[a-z][a-z0-9]{0,82}1[02-9ac-hj-np-z]{38,}|[A-Z][A-Z0-9]{0,82}1[02-9AC-HJ-NP-Z]{38,})$/
+);
+var walletAddressInputSchema = z6.discriminatedUnion("chain", [
+  z6.object({ chain: z6.literal("solana"), address: solanaAddressSchema }).strict(),
+  z6.object({
+    chain: z6.literal("eip155"),
+    address: evmAddressSchema,
+    /** Shown in the sign-in message's Chain ID line only: links are chain-agnostic. Defaults to 1. */
+    chainId: z6.number().int().positive().safe().optional()
+  }).strict(),
+  z6.object({
+    chain: z6.literal("cosmos"),
+    network: cosmosNetworkSchema,
+    address: cosmosAddressSchema
+  }).strict()
+]);
+var walletMessageChallengeSchema = z6.object({
+  id: z6.string().min(1).max(200),
+  purpose: z6.enum(["link", "sign-in"]),
+  chain: walletChainSchema,
+  network: cosmosNetworkSchema.nullable(),
+  /** Canonical (base58, EIP-55 or lowercase bech32). The signer must sign with this address. */
+  address: z6.string(),
+  message: z6.string().max(4096),
+  expiresAt: z6.number().int()
+});
+var walletSignatureSchema = z6.object({
+  challenge: z6.string().min(1).max(200),
+  /** solana: base58, 64 bytes · eip155: 0x and 130 hex digits (65 bytes) · cosmos: base64, 64 bytes (r‖s) */
+  signature: z6.string().min(1).max(256),
+  /** cosmos only: the base64 33-byte compressed secp256k1 key from signArbitrary's pub_key.value */
+  publicKey: z6.string().max(128).optional()
+}).strict();
+var linkedWalletSchema = z6.object({
+  chain: walletChainSchema,
+  network: cosmosNetworkSchema.nullable(),
+  address: z6.string(),
+  verifiedAt: z6.number().int().nonnegative(),
+  revision: z6.number().int().positive(),
+  /** True when this wallet can sign in: it was first used through wallet sign-in. Linking never enables sign-in. */
+  signIn: z6.boolean()
+});
+var walletUnlinkInputSchema = z6.object({ chain: walletChainSchema, address: z6.string().min(1).max(100) }).strict();
+async function walletAddressInput(signer) {
+  const address = await signer.address();
+  switch (signer.chain) {
+    case "solana":
+      return { chain: "solana", address };
+    case "eip155":
+      return {
+        chain: "eip155",
+        address,
+        ...signer.chainId ? { chainId: await signer.chainId() } : {}
+      };
+    case "cosmos":
+      if (!signer.network) {
+        throw new Error("Choose the Cosmos chain for this wallet");
+      }
+      return { chain: "cosmos", network: signer.network, address };
+  }
+}
+var WALLETS_PER_CHAIN = 5;
+var walletSignInFamilies = ["solana", "eip155", "cosmos"];
+var walletSignInNetworkSchema = z6.union([z6.enum(walletSignInFamilies), z6.string().regex(cosmosNetworkPattern)]).transform(
+  (value) => value.startsWith("cosmos:") ? "cosmos" : value
+);
+var walletSignInNetworksSchema = z6.array(walletSignInNetworkSchema).transform(
+  (values) => walletSignInFamilies.filter((family) => values.includes(family))
+);
+function walletSignInNetwork(wallet) {
+  return wallet.chain;
+}
+function caip10(wallet, network) {
+  if (wallet.chain === "cosmos") {
+    if (!wallet.network || network && network !== wallet.network) {
+      throw new Error("A Cosmos wallet belongs to its own network");
+    }
+    return `${wallet.network}:${wallet.address}`;
+  }
+  const selected = network ?? (wallet.chain === "solana" ? solanaMainnet : "eip155:1");
+  const valid = wallet.chain === "solana" ? /^solana:[1-9A-HJ-NP-Za-km-z]{32}$/.test(selected) : isEvmChainId(selected);
+  if (!valid) {
+    throw new Error(`Use a ${wallet.chain} network for this wallet`);
+  }
+  return `${selected}:${wallet.address}`;
+}
+function isEvmChainId(value) {
+  return /^eip155:[1-9][0-9]{0,15}$/.test(value);
+}
+var evmChainIdSchema = z6.custom(
+  (value) => typeof value === "string" && isEvmChainId(value),
+  'Use an EVM chain ID such as "eip155:8453"'
+);
+var units = z6.string().regex(/^(0|[1-9][0-9]*)$/);
+var walletBalanceSchema = z6.object({
+  /** Canonical CAIP-2 ID: `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp` or `eip155:<chain ID>`. */
+  chain: z6.string(),
+  /** The canonical mint (base58) or EIP-55 contract address; null for the native coin. */
+  token: z6.string().nullable(),
+  /** Null only for an ERC-20 contract without `decimals()`. */
+  decimals: z6.number().int().min(0).max(255).nullable(),
+  /** The sum over `wallets`. */
+  total: units,
+  wallets: z6.array(z6.object({ address: z6.string(), amount: units }).strict()),
+  /** Solana: the lowest slot the reads saw. EVM: the latest block when the read started (approximate). */
+  at: z6.object({ kind: z6.enum(["slot", "block"]), number: units }).strict(),
+  observedAt: z6.number().int().nonnegative()
+}).strict();
+
+export {
+  authoringIdentityShape,
+  validateAuthoringIdentity,
+  normalizeAuthoringIdentity,
+  authoringKey,
+  engagementDefinitionSchema,
+  engagementScoreInputSchema,
+  engagementScoreSchema,
+  engagementPublishSchema,
+  engagementRuleSchema,
+  engagementPageQuerySchema,
+  engagementSettlementSchema,
+  engagementPageSchema,
+  engagementChangePreviewInputSchema,
+  engagementChangeSchema,
+  engagementChangePreviewSchema,
+  engagementVersionPageSchema,
+  engagementVersionQuerySchema,
+  engagementBoundaryPageSchema,
+  engagementArtifactSchema,
+  engagementDeploymentEntrySchema,
+  profileVisibilitySchema,
+  avatarProviderSchema,
+  profileDefaultProviderSchema,
+  profileDefaultsSchema,
+  avatarSeedSchema,
+  profileAvatarSchema,
+  profileSummarySchema,
+  displayNameSchema,
+  profileUpdateSchema,
+  ownProfileSchema,
+  profileCompletionQuerySchema,
+  profileCompletionSchema,
+  profileCompletionPageSchema,
+  profileReferralSchema,
+  profileSettingsSchema,
+  profileSettingsInputSchema,
+  profileModerationSchema,
+  managedProfileSchema,
+  AVATAR_UPLOAD_LIMIT,
+  avatarUploadTypes,
+  leaderboardWindowSchema,
+  leaderboardDefinitionSchema,
+  leaderboardAuthoringSchema,
+  leaderboardArtifactSchema,
+  publishedLeaderboardSchema,
+  leaderboardQuerySchema,
+  leaderboardRowSchema,
+  leaderboardPageSchema,
+  leaderboardPlacementSchema,
+  leaderboardPreviewSchema,
+  pointsMutationSchema,
+  pointsEntrySchema,
+  pointsResultSchema,
+  pointsAccountSchema,
+  leaderboardExclusionSchema,
+  leaderboardGroupSchema,
+  referralDefinitionSchema,
+  referralAuthoringSchema,
+  referralArtifactSchema,
+  publishedReferralSchema,
+  referralAcceptSchema,
+  referralControlSchema,
+  referralRelationshipSchema,
+  referralAccountSchema,
+  referralSummarySchema,
+  referralHistorySchema,
+  referralManagementSchema,
+  solanaAddressSchema,
+  walletConnectionSchema,
+  walletChallengeInputSchema,
+  walletChallengeSchema,
+  walletProofSchema,
+  solanaBalanceSchema,
+  walletChainSchema,
+  cosmosNetworkSchema,
+  cosmosChain,
+  solanaMainnet,
+  evmAddressSchema,
+  cosmosAddressSchema,
+  walletAddressInputSchema,
+  walletMessageChallengeSchema,
+  walletSignatureSchema,
+  linkedWalletSchema,
+  walletUnlinkInputSchema,
+  walletAddressInput,
+  WALLETS_PER_CHAIN,
+  walletSignInFamilies,
+  walletSignInNetworkSchema,
+  walletSignInNetworksSchema,
+  walletSignInNetwork,
+  caip10,
+  isEvmChainId,
+  evmChainIdSchema,
+  walletBalanceSchema
+};