@domino-sdk/relay 1.0.0-next.9 → 1.0.0

package/dist/chunk-JON5SESL.js

@@ -0,0 +1,2986 @@
+// src/pages.ts
+import { z } from "zod";
+var pageCursorSchema = z.string().min(1).max(4096);
+var pageQuerySchema = z.strictObject({
+  cursor: pageCursorSchema.optional()
+});
+
+// src/accounts.ts
+import { z as z2 } from "zod";
+var authProviderSchema = z2.enum(["google", "apple", "x", "discord"]);
+var accountConnectionSchema = z2.object({
+  provider: authProviderSchema,
+  configured: z2.boolean(),
+  status: z2.enum(["disconnected", "connected", "reconnect"]),
+  subject: z2.string().nullable(),
+  revision: z2.number().int().nonnegative()
+});
+var discordMemberInputSchema = z2.object({}).strict();
+var discordMessageInputSchema = z2.object({
+  channelId: z2.string().regex(/^[0-9]{1,20}$/),
+  messageId: z2.string().regex(/^[0-9]{1,20}$/)
+}).strict();
+var discordMemberSchema = z2.object({
+  userId: z2.string().regex(/^[0-9]{1,20}$/).nullable().default(null),
+  nickname: z2.string().nullable().default(null),
+  displayName: z2.string().nullable().default(null),
+  boostingSince: z2.string().datetime({ offset: true }).nullable().default(null),
+  roles: z2.array(z2.string().regex(/^[0-9]{1,20}$/)),
+  joinedAt: z2.string().datetime({ offset: true }).nullable(),
+  pending: z2.boolean()
+});
+
+// src/identifier.ts
+import { z as z3 } from "zod";
+var identifier = z3.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/);
+
+// src/discord.ts
+import { z as z4 } from "zod";
+var discordMessageSchema = z4.object({
+  guildId: z4.string(),
+  channelId: z4.string(),
+  messageId: z4.string(),
+  userId: z4.string(),
+  content: z4.string().nullable(),
+  replyTo: z4.string().nullable(),
+  publishedAt: z4.number()
+}).strict();
+var discordMessagesSourceSchema = z4.strictObject({
+  kind: z4.literal("discord-messages"),
+  /** Store each message's text in `data.text`. Off unless set. */
+  text: z4.boolean().optional()
+});
+var discordReactionsSourceSchema = z4.strictObject({
+  kind: z4.literal("discord-reactions")
+});
+var discordMessageDataSchema = z4.object({
+  guildId: z4.string(),
+  channelId: z4.string(),
+  messageId: z4.string(),
+  /** The ID of the message this one replies to, or null. */
+  replyTo: z4.string().nullable(),
+  /** When Discord says the message was posted, in epoch milliseconds. */
+  publishedAt: z4.number()
+});
+var discordMessageTextDataSchema = discordMessageDataSchema.extend({
+  text: z4.string().nullable()
+});
+var discordReactionDataSchema = z4.object({
+  guildId: z4.string(),
+  channelId: z4.string(),
+  /** The message reacted to. */
+  messageId: z4.string(),
+  /** A custom emoji's ID, or null for a Unicode emoji, whose `name` is the emoji itself. */
+  emoji: z4.object({ id: z4.string().nullable(), name: z4.string() }),
+  /** The role IDs the reactor held in the server when reacting. */
+  reactorRoles: z4.array(z4.string()),
+  /** When the reacted-to message was posted, in epoch milliseconds. */
+  messagePublishedAt: z4.number()
+});
+var discordRewardSchema = z4.strictObject({
+  kind: z4.literal("integration"),
+  provider: z4.literal("discord"),
+  action: z4.literal("grant-role"),
+  roleId: z4.string().regex(/^[0-9]{1,20}$/)
+});
+var discordResourceSourceSchema = z4.union([
+  z4.strictObject({
+    provider: z4.literal("discord"),
+    resource: z4.literal("channel"),
+    types: z4.array(z4.enum(["text", "announcement"])).min(1)
+  }),
+  z4.strictObject({
+    provider: z4.literal("discord"),
+    resource: z4.literal("role"),
+    assignable: z4.boolean().default(false)
+  })
+]);
+
+// src/tracker-data.ts
+import { z as z5 } from "zod";
+var maxDepth = 16;
+var maxBytes = 32768;
+var trackerDataMaxBranches = 16;
+var trackerDataMaxEntries = 256;
+var scalar = z5.union([z5.string(), z5.number().finite(), z5.boolean(), z5.null()]);
+var size = z5.number().int().safe().nonnegative();
+var bound = z5.number().finite();
+var branches = () => z5.array(node).min(1).max(trackerDataMaxBranches);
+var node = z5.lazy(
+  () => z5.strictObject({
+    type: z5.enum([
+      "object",
+      "array",
+      "string",
+      "number",
+      "integer",
+      "boolean",
+      "null"
+    ]).optional(),
+    properties: z5.record(z5.string(), node).refine(
+      (properties) => Object.keys(properties).length <= trackerDataMaxEntries,
+      `An object schema lists at most ${trackerDataMaxEntries} properties`
+    ).optional(),
+    required: z5.array(z5.string()).max(trackerDataMaxEntries).optional(),
+    additionalProperties: z5.union([z5.boolean(), node]).optional(),
+    propertyNames: z5.strictObject({
+      type: z5.literal("string"),
+      enum: z5.array(z5.string()).max(trackerDataMaxEntries).optional()
+    }).optional(),
+    items: node.optional(),
+    minItems: size.optional(),
+    maxItems: size.optional(),
+    minLength: size.optional(),
+    maxLength: size.optional(),
+    minimum: bound.optional(),
+    maximum: bound.optional(),
+    exclusiveMinimum: bound.optional(),
+    exclusiveMaximum: bound.optional(),
+    enum: z5.array(scalar).min(1).max(trackerDataMaxEntries).optional(),
+    const: scalar.optional(),
+    anyOf: branches().optional(),
+    oneOf: branches().optional(),
+    allOf: branches().optional()
+  })
+);
+function shapeIssue(value) {
+  const pending = [[value, 0]];
+  while (pending.length) {
+    const [current, level] = pending.pop();
+    if (typeof current !== "object" || current === null) {
+      continue;
+    }
+    if (level >= maxDepth) {
+      return "Tracker data schemas are at most 32 KB and 16 levels deep";
+    }
+    if (!Array.isArray(current) && Object.hasOwn(current, "__proto__")) {
+      return "Tracker data schemas cannot name a property __proto__";
+    }
+    for (const child of Object.values(current)) {
+      pending.push([child, level + 1]);
+    }
+  }
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength > maxBytes ? "Tracker data schemas are at most 32 KB and 16 levels deep" : null;
+}
+var unions = (s) => [
+  ...s.anyOf ?? [],
+  ...s.oneOf ?? [],
+  ...s.allOf ?? []
+];
+var compound = (s) => s.properties !== void 0 || s.items !== void 0 || typeof s.additionalProperties === "object" || unions(s).length > 0;
+function nestedUnionIssue(schema, path, insideUnion) {
+  const own = unions(schema);
+  if (insideUnion && own.filter(compound).length > 1) {
+    return path;
+  }
+  const children = [
+    ...Object.entries(schema.properties ?? {}).map(
+      ([key, child]) => [child, `${path}.${key}`]
+    )
+  ];
+  if (schema.items) {
+    children.push([schema.items, path]);
+  }
+  if (typeof schema.additionalProperties === "object") {
+    children.push([schema.additionalProperties, path]);
+  }
+  for (const [child, at] of children) {
+    const found = nestedUnionIssue(child, at, insideUnion);
+    if (found) {
+      return found;
+    }
+  }
+  for (const branch of own) {
+    const found = nestedUnionIssue(branch, path, true);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+var trackerDataSchemaSchema = z5.unknown().superRefine((value, ctx) => {
+  const issue = shapeIssue(value);
+  if (issue) {
+    ctx.addIssue({ code: "custom", message: issue, abort: true });
+  }
+}).pipe(node).refine(
+  (schema) => schema.type === "object",
+  "A tracker's record data is an object: declare it with z.object({ ... })"
+).superRefine((schema, ctx) => {
+  const at = nestedUnionIssue(schema, "data", false);
+  if (at) {
+    ctx.addIssue({
+      code: "custom",
+      message: `Tracker data schemas cannot nest a union with several object, array or union branches inside another union's branch (${at}): flatten it into one union`
+    });
+  }
+});
+var unsupported = {
+  pattern: "check string patterns in your evaluator",
+  format: "use z.string() and check the format in your evaluator",
+  prefixItems: "use an array or an object instead of a tuple",
+  multipleOf: "check divisibility in your evaluator",
+  not: "describe the allowed values instead",
+  $ref: "inline the schema instead of registering or reusing it by ID",
+  $defs: "inline the schema instead of registering or reusing it by ID",
+  definitions: "inline the schema instead of registering or reusing it by ID",
+  if: "use a union instead",
+  then: "use a union instead",
+  else: "use a union instead",
+  contains: "check array contents in your evaluator",
+  minContains: "check array contents in your evaluator",
+  maxContains: "check array contents in your evaluator",
+  uniqueItems: "check uniqueness in your evaluator",
+  minProperties: "check key counts in your evaluator",
+  maxProperties: "check key counts in your evaluator",
+  patternProperties: "use z.record(z.string(), value) instead",
+  dependentRequired: "use a union instead",
+  dependentSchemas: "use a union instead",
+  unevaluatedProperties: "use a strict object instead",
+  unevaluatedItems: "use an array instead"
+};
+var nested = /* @__PURE__ */ new Set(["additionalProperties", "items", "propertyNames"]);
+var listed = /* @__PURE__ */ new Set(["anyOf", "oneOf", "allOf"]);
+var supported = /* @__PURE__ */ new Set([
+  "type",
+  "properties",
+  "required",
+  "minItems",
+  "maxItems",
+  "minLength",
+  "maxLength",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "enum",
+  "const",
+  ...nested,
+  ...listed
+]);
+var annotations = /* @__PURE__ */ new Set([
+  "$schema",
+  "$id",
+  "$comment",
+  "title",
+  "description",
+  "default",
+  "examples",
+  "deprecated",
+  "readOnly",
+  "writeOnly"
+]);
+function subset(schema, path) {
+  if (typeof schema !== "object" || schema === null || Array.isArray(schema)) {
+    return schema;
+  }
+  const kept = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (Object.hasOwn(unsupported, key)) {
+      throw new Error(
+        `Tracker data schemas cannot use ${key} (${path}): ${unsupported[key]}`
+      );
+    }
+    if (annotations.has(key)) {
+      continue;
+    }
+    if (!supported.has(key)) {
+      throw new Error(
+        `Tracker data schemas cannot use the keyword ${key} (${path}): keep metadata to title, description, default and examples`
+      );
+    }
+    if (key === "properties" && Object.hasOwn(value, "__proto__") || key === "required" && value.includes("__proto__")) {
+      throw new Error(
+        `Tracker data schemas cannot name a property __proto__ (${path})`
+      );
+    }
+    kept[key] = key === "properties" ? Object.fromEntries(
+      Object.entries(value).map(
+        ([name2, child]) => [name2, subset(child, `${path}.${name2}`)]
+      )
+    ) : nested.has(key) ? subset(value, path) : listed.has(key) ? value.map((child) => subset(child, path)) : value;
+  }
+  return kept;
+}
+function trackerDataSchema(schema) {
+  let json;
+  try {
+    json = z5.toJSONSchema(schema, {
+      target: "draft-2020-12",
+      io: "input",
+      unrepresentable: "throw",
+      cycles: "throw",
+      reused: "inline",
+      override: ({ zodSchema, path }) => {
+        const def = zodSchema._zod.def;
+        const at = ["data", ...path].join(".");
+        if (def.type === "pipe" || def.type === "transform") {
+          throw new Error(
+            `Tracker data schemas cannot transform values (${at}): records are stored as sent`
+          );
+        }
+        if (def.checks?.some((check) => check._zod.def.check === "custom")) {
+          throw new Error(
+            `Tracker data schemas cannot use refinements (${at}): check the value in your evaluator`
+          );
+        }
+      }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      message.startsWith("Tracker data schemas") ? message : `Tracker data schemas describe JSON: ${message}. Use z.unknown() for any JSON value.`
+    );
+  }
+  const parsed = trackerDataSchemaSchema.safeParse(subset(json, "data"));
+  if (!parsed.success) {
+    throw new Error(
+      parsed.error.issues.map((issue) => issue.message).join("; ")
+    );
+  }
+  return parsed.data;
+}
+var trackerDataRecordSteps = 25e4;
+var trackerDataBatchSteps = 6e6;
+var BudgetSpent = class extends Error {
+};
+function charge(budget, steps) {
+  budget.steps -= steps;
+  if (budget.steps < 0) {
+    throw new BudgetSpent();
+  }
+}
+var maxKeyText = 64;
+var maxPathText = 256;
+function clip(text, limit) {
+  return text.length > limit ? text.slice(0, limit - 1) + "\u2026" : text;
+}
+function pathText(path) {
+  const keys = [];
+  for (let at = path; at; at = at.parent) {
+    keys.push(clip(String(at.key), maxKeyText));
+  }
+  return clip(["data", ...keys.reverse()].join("."), maxPathText);
+}
+var describe = (value) => value === null ? "null" : Array.isArray(value) ? "an array" : typeof value;
+var shownValues = 10;
+function oneOf(values) {
+  const shown = values.slice(0, shownValues).map((value) => JSON.stringify(value)).join(", ");
+  return values.length > shownValues ? `expected one of ${shown}, or ${values.length - shownValues} more` : `expected one of ${shown}`;
+}
+var enumSets = /* @__PURE__ */ new WeakMap();
+var literalLists = /* @__PURE__ */ new WeakMap();
+function setOf(owner, values) {
+  let found = enumSets.get(owner);
+  if (!found) {
+    found = new Set(values);
+    enumSets.set(owner, found);
+  }
+  return found;
+}
+function literalsOf(schema) {
+  let found = literalLists.get(schema);
+  if (!found) {
+    found = Object.entries(schema.properties ?? {}).filter(
+      ([, property]) => property.const !== void 0
+    );
+    literalLists.set(schema, found);
+  }
+  return found;
+}
+function matches(schema, value, at, budget) {
+  charge(budget, 1);
+  const issue = (reason) => ({ at, reason });
+  if (schema.const !== void 0 && value !== schema.const) {
+    return issue(() => `expected ${JSON.stringify(schema.const)}`);
+  }
+  if (schema.enum && !setOf(schema, schema.enum).has(value)) {
+    const values = schema.enum;
+    return issue(() => oneOf(values));
+  }
+  switch (schema.type) {
+    case "null":
+      if (value !== null) {
+        return issue(() => `expected null, got ${describe(value)}`);
+      }
+      break;
+    case "boolean":
+    case "string":
+      if (typeof value !== schema.type) {
+        const type = schema.type;
+        return issue(() => `expected a ${type}, got ${describe(value)}`);
+      }
+      break;
+    case "number":
+      if (typeof value !== "number") {
+        return issue(() => `expected a number, got ${describe(value)}`);
+      }
+      break;
+    case "integer":
+      if (!Number.isInteger(value)) {
+        return issue(
+          () => typeof value === "number" ? "expected an integer" : `expected an integer, got ${describe(value)}`
+        );
+      }
+      break;
+    case "array":
+      if (!Array.isArray(value)) {
+        return issue(() => `expected an array, got ${describe(value)}`);
+      }
+      break;
+    case "object":
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return issue(() => `expected an object, got ${describe(value)}`);
+      }
+      break;
+  }
+  if (typeof value === "string") {
+    const { minLength, maxLength } = schema;
+    if (minLength !== void 0 && value.length < minLength) {
+      return issue(() => `expected at least ${minLength} characters`);
+    }
+    if (maxLength !== void 0 && value.length > maxLength) {
+      return issue(() => `expected at most ${maxLength} characters`);
+    }
+  }
+  if (typeof value === "number") {
+    const limits = [
+      [schema.minimum, (limit) => value >= limit, "at least"],
+      [schema.exclusiveMinimum, (limit) => value > limit, "more than"],
+      [schema.maximum, (limit) => value <= limit, "at most"],
+      [schema.exclusiveMaximum, (limit) => value < limit, "less than"]
+    ];
+    for (const [limit, holds, label] of limits) {
+      if (limit !== void 0 && !holds(limit)) {
+        return issue(() => `expected ${label} ${limit}`);
+      }
+    }
+  }
+  if (Array.isArray(value)) {
+    const { minItems, maxItems } = schema;
+    if (minItems !== void 0 && value.length < minItems) {
+      return issue(() => `expected at least ${minItems} items`);
+    }
+    if (maxItems !== void 0 && value.length > maxItems) {
+      return issue(() => `expected at most ${maxItems} items`);
+    }
+    if (schema.items) {
+      for (let index = 0; index < value.length; index++) {
+        const found = matches(
+          schema.items,
+          value[index],
+          { parent: at, key: index },
+          budget
+        );
+        if (found) {
+          return found;
+        }
+      }
+    }
+  }
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    const object = value;
+    const properties = schema.properties ?? {};
+    const required = schema.required ?? [];
+    charge(budget, required.length);
+    for (const key of required) {
+      if (!Object.hasOwn(object, key)) {
+        return issue(() => `missing required key "${clip(key, maxKeyText)}"`);
+      }
+    }
+    const literals = literalsOf(schema);
+    charge(budget, literals.length);
+    for (const [key, property] of literals) {
+      if (Object.hasOwn(object, key) && object[key] !== property.const) {
+        return {
+          at: { parent: at, key },
+          reason: () => `expected ${JSON.stringify(property.const)}`
+        };
+      }
+    }
+    const keys = Object.keys(object);
+    charge(budget, keys.length);
+    const names = schema.propertyNames?.enum;
+    const allowed = names && setOf(schema.propertyNames, names);
+    for (const key of keys) {
+      if (allowed && !allowed.has(key)) {
+        return {
+          at: { parent: at, key },
+          reason: () => "is not an allowed key"
+        };
+      }
+      const property = Object.hasOwn(properties, key) ? properties[key] : schema.additionalProperties;
+      if (property === false) {
+        return {
+          at: { parent: at, key },
+          reason: () => "is not an allowed key"
+        };
+      }
+      if (property && property !== true) {
+        const found = matches(
+          property,
+          object[key],
+          { parent: at, key },
+          budget
+        );
+        if (found) {
+          return found;
+        }
+      }
+    }
+  }
+  for (const branch of schema.allOf ?? []) {
+    const found = matches(branch, value, at, budget);
+    if (found) {
+      return found;
+    }
+  }
+  if (schema.anyOf && !schema.anyOf.some((branch) => !matches(branch, value, at, budget))) {
+    return issue(() => "matches none of the allowed shapes");
+  }
+  if (schema.oneOf) {
+    let count3 = 0;
+    for (const branch of schema.oneOf) {
+      if (!matches(branch, value, at, budget) && ++count3 > 1) {
+        return issue(() => "matches more than one of the allowed shapes");
+      }
+    }
+    if (!count3) {
+      return issue(() => "matches none of the allowed shapes");
+    }
+  }
+  return null;
+}
+function trackerDataIssue(schema, data, budget = { steps: trackerDataRecordSteps }) {
+  try {
+    const found = matches(schema, data, null, budget);
+    return found && {
+      kind: "mismatch",
+      path: pathText(found.at),
+      reason: found.reason()
+    };
+  } catch (error) {
+    if (error instanceof BudgetSpent) {
+      return {
+        kind: "too-complex",
+        path: "data",
+        reason: "is too complex to validate against the tracker's schema"
+      };
+    }
+    throw error;
+  }
+}
+function trackerDataIssues(schema, records) {
+  const batch = { steps: trackerDataBatchSteps };
+  return records.map((data) => {
+    const budget = { steps: Math.min(trackerDataRecordSteps, batch.steps) };
+    const allowance = budget.steps;
+    const found = trackerDataIssue(schema, data, budget);
+    batch.steps -= allowance - Math.max(budget.steps, 0);
+    return found;
+  });
+}
+function alternatives(schemas) {
+  return schemas.flatMap(
+    (s) => s.anyOf || s.oneOf || s.allOf ? alternatives([
+      ...s.anyOf ?? [],
+      ...s.oneOf ?? [],
+      ...s.allOf ?? []
+    ]) : [s]
+  );
+}
+var unconstrained = (s) => s.type === void 0 && s.properties === void 0 && s.const === void 0 && s.enum === void 0;
+function trackerDataPathTypes(schema, path) {
+  const any = /* @__PURE__ */ new Set([
+    "string",
+    "number",
+    "boolean",
+    "null",
+    "object",
+    "array"
+  ]);
+  let current = [schema];
+  for (const key of path.split(".")) {
+    const next = [];
+    for (const s of alternatives(current)) {
+      if (unconstrained(s)) {
+        next.push({});
+      } else if (s.type !== "object") {
+        continue;
+      } else if (s.properties && Object.hasOwn(s.properties, key)) {
+        next.push(s.properties[key]);
+      } else if (s.additionalProperties === true) {
+        next.push({});
+      } else if (s.additionalProperties) {
+        next.push(s.additionalProperties);
+      }
+    }
+    if (!next.length) {
+      return null;
+    }
+    current = next;
+  }
+  const types = /* @__PURE__ */ new Set();
+  for (const s of alternatives(current)) {
+    if (unconstrained(s)) {
+      return any;
+    }
+    if (s.type) {
+      types.add(s.type === "integer" ? "number" : s.type);
+    }
+    for (const value of [
+      ...s.const !== void 0 ? [s.const] : [],
+      ...s.enum ?? []
+    ]) {
+      types.add(value === null ? "null" : typeof value);
+    }
+  }
+  return types;
+}
+function schemaCheckedReader(reader) {
+  return {
+    content: (reference, query) => reader.content(reference, query),
+    summary: (reference, query) => reader.summary(reference, query),
+    records: (async (reference, query) => {
+      const page = await reader.records(reference, query);
+      const source = reference.source;
+      const schema = source?.kind === "custom" ? source.data : void 0;
+      if (!schema) {
+        return page;
+      }
+      const issues = trackerDataIssues(
+        schema,
+        page.items.map((record2) => record2.data)
+      );
+      const items = page.items.filter((_, index) => !issues[index]);
+      return { ...page, items, excluded: page.items.length - items.length };
+    })
+  };
+}
+function whereSchemaIssue(schema, where) {
+  const conditions = where === void 0 ? [] : Array.isArray(where) ? where : [where];
+  for (const condition of conditions) {
+    const types = trackerDataPathTypes(schema, condition.path);
+    if (!types) {
+      return `The tracker filter reads data.${condition.path}, which the tracker's data schema does not declare`;
+    }
+    const wanted = "equals" in condition ? [typeof condition.equals] : ["number", "string"];
+    if (!wanted.some((type) => types.has(type))) {
+      return `The tracker filter compares data.${condition.path} with ${"equals" in condition ? JSON.stringify(condition.equals) : "a number"}, but the field holds ${[...types].join(" or ")}`;
+    }
+  }
+  return null;
+}
+
+// src/trackers.ts
+import { z as z6 } from "zod";
+var timestamp = z6.number().int().safe().nonnegative().max(864e13);
+var count = z6.number().int().safe().nonnegative();
+var externalId = z6.string().min(1).max(256);
+var metric = count.nullable().default(null);
+var xTweetSchema = z6.looseObject({
+  id: externalId,
+  userId: externalId,
+  content: z6.string(),
+  createdAt: z6.iso.datetime({ offset: true }),
+  author: z6.looseObject({
+    id: externalId,
+    username: z6.string(),
+    name: z6.string(),
+    verified: z6.boolean().nullable().default(null)
+  }),
+  likeCount: metric,
+  replyCount: metric,
+  retweetCount: metric,
+  quoteCount: metric,
+  viewCount: metric,
+  bookmarkCount: metric,
+  isReply: z6.boolean(),
+  isRetweet: z6.boolean(),
+  isQuoteTweet: z6.boolean()
+});
+var xContentBodySchema = z6.strictObject({
+  version: z6.literal(1),
+  id: z6.string().min(1),
+  authorId: z6.string().min(1),
+  publishedAt: timestamp,
+  text: z6.string(),
+  isReply: z6.boolean(),
+  isRetweet: z6.boolean(),
+  isQuoteTweet: z6.boolean(),
+  media: z6.array(z6.strictObject({ type: z6.string(), url: z6.string() })).nullable(),
+  mentionedAuthorIds: z6.array(z6.string().min(1)).nullable(),
+  videoLengthSeconds: z6.number().nonnegative().nullable(),
+  references: z6.strictObject({
+    replyId: z6.string().nullable(),
+    replyAuthorId: z6.string().nullable(),
+    quoteId: z6.string().nullable(),
+    quoteAuthorId: z6.string().nullable(),
+    repostId: z6.string().nullable(),
+    repostAuthorId: z6.string().nullable()
+  })
+});
+var trackerContentQuerySchema = z6.strictObject({
+  id: externalId,
+  observation: z6.string().regex(/^observation_[a-f0-9]{64}$/)
+});
+var trackerContentReadSchema = trackerContentQuerySchema.extend({
+  member: identifier
+});
+var attributionContext = { member: identifier, capturedAt: timestamp };
+var trackerEvidenceSchema = z6.strictObject({
+  contentRevision: identifier,
+  observation: identifier
+});
+var trackerContentSchema = z6.strictObject({
+  tracker: identifier,
+  source: z6.literal("x"),
+  evidence: trackerEvidenceSchema,
+  content: xContentBodySchema,
+  observedAt: timestamp,
+  removed: z6.boolean(),
+  attribution: z6.discriminatedUnion("kind", [
+    z6.strictObject({
+      ...attributionContext,
+      kind: z6.literal("linked"),
+      account: z6.strictObject({
+        provider: z6.literal("x"),
+        issuer: z6.string().min(1),
+        subject: externalId,
+        revision: count,
+        linkedAt: timestamp.nullable()
+      })
+    }),
+    z6.strictObject({ ...attributionContext, kind: z6.literal("unlinked") }),
+    z6.strictObject({
+      ...attributionContext,
+      kind: z6.literal("different-author")
+    })
+  ])
+});
+var knownIdentityKinds = ["wallet", "x", "discord", "member"];
+var appIdentityKindSchema = z6.templateLiteral([
+  "app:",
+  z6.string().regex(
+    /^[a-z0-9][a-z0-9_-]{0,39}$/,
+    "Name an app identity kind like app:telegram: lowercase letters, digits, _ or -, at most 40"
+  )
+]);
+var identityKindSchema = z6.union([
+  z6.enum(knownIdentityKinds),
+  appIdentityKindSchema
+]);
+var isAppIdentityKind = (kind) => kind.startsWith("app:");
+var openIdentityKindSchema = z6.string().min(1).max(64);
+var memberIdentitySchema = z6.object({
+  kind: openIdentityKindSchema,
+  /** The stable user ID for `x` and `discord`; the subject your app signed the member in with for `app:<name>`. */
+  subject: externalId,
+  /**
+   * The link's revision. It grows when the member selects another X or Discord account, or on
+   * each app identity unlink and relink. App identities never move between members.
+   */
+  revision: count,
+  /** The latest link time, refreshed on app identity relink; null when the link time is unknown. */
+  linkedAt: timestamp.nullable()
+});
+var accountRoleSchema = z6.string().regex(
+  /^[a-zA-Z][a-zA-Z0-9_]{0,39}$/,
+  "Name roles like author or recipient: a letter, then letters, digits or underscores"
+);
+var xAccountRoles = ["author", "inReplyTo"];
+var distinct = (values) => new Set(values).size === values.length;
+var contentMetricNameSchema = z6.string().regex(
+  /^[a-z][a-zA-Z0-9]{0,39}$/,
+  "Name metrics like likes or watchTime: a lowercase letter, then letters or digits"
+);
+var xContentMetrics = [
+  "likes",
+  "replies",
+  "reposts",
+  "quotes",
+  "views",
+  "bookmarks"
+];
+var customContentSchema = z6.strictObject({
+  metrics: z6.array(contentMetricNameSchema).max(10).refine(distinct, "List each metric once")
+});
+var xSearchSourceSchema = z6.object({
+  kind: z6.literal("x-search"),
+  query: z6.string().trim().min(1).max(2e3)
+}).strict();
+var customSourceSchema = z6.object({
+  kind: z6.literal("custom"),
+  namespace: identifier,
+  /**
+   * The identity kinds a record's author and named accounts can be, attributed to members
+   * through verified links: `wallet`, `x`, `discord`, `member`, or your app's own `app:<name>`.
+   * Omitted when authors are opaque IDs, which no quest can pay.
+   */
+  identities: z6.array(identityKindSchema).min(1).max(8).refine(distinct, "List each identity kind once").optional(),
+  /** Roles of the named accounts records can carry besides their author, such as `recipient`. */
+  accounts: z6.array(accountRoleSchema).min(1).max(10).refine(distinct, "List each account role once").refine(
+    (roles) => !roles.includes("author"),
+    "author is every record's own role; name other accounts"
+  ).optional(),
+  /**
+   * The schema every record's `data` matches, which ingestion enforces. `customSource()`
+   * requires it. Trackers published before typed data have none, and take no records until
+   * they are published with one.
+   */
+  data: trackerDataSchemaSchema.optional(),
+  /**
+   * The content its records carry: each record's `data` is `{ body, metrics? }`, and quests can
+   * use the tracker with `content()`. `customSource(namespace, { content })` sets it with the
+   * matching `data` schema.
+   */
+  content: customContentSchema.optional()
+}).strict().refine(
+  (source) => !source.content || source.data?.properties?.body?.type === "object" && (source.data.required ?? []).includes("body"),
+  "A content source's data schema has a required object body"
+).refine(
+  (source) => !source.accounts || source.identities,
+  "Named accounts need identities"
+);
+var trackerSourceSchema = z6.discriminatedUnion("kind", [
+  xSearchSourceSchema,
+  customSourceSchema,
+  discordMessagesSourceSchema,
+  discordReactionsSourceSchema
+]);
+var trackerSourceKinds = [
+  "x-search",
+  "custom",
+  "discord-messages",
+  "discord-reactions"
+];
+function sourceIdentities(source) {
+  if (!isKnownTrackerSource(source)) {
+    return void 0;
+  }
+  switch (source.kind) {
+    case "x-search":
+      return ["x"];
+    case "discord-messages":
+    case "discord-reactions":
+      return ["discord"];
+    case "custom":
+      return source.identities;
+  }
+}
+function sourceContent(source) {
+  switch (source.kind) {
+    case "x-search":
+      return { metrics: xContentMetrics };
+    case "custom":
+      return source.content;
+    case "discord-messages":
+    case "discord-reactions":
+      return void 0;
+  }
+}
+var windowSchema = z6.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
+  (w) => w.end === void 0 || w.end > w.start,
+  "End must follow start"
+);
+var trackerDefinitionSchema = z6.object({
+  key: identifier,
+  title: z6.string().trim().min(1).max(120),
+  source: trackerSourceSchema,
+  window: windowSchema,
+  refreshSeconds: z6.number().int().min(300).max(86400).default(21600),
+  maxPages: z6.number().int().min(1).max(1e3).default(60)
+}).strict();
+var trackerArtifactSchema = z6.union([
+  trackerDefinitionSchema,
+  z6.object({ code: z6.string().min(1).max(2e6) }).strict()
+]);
+var knownTrackerSourceResponseSchema = z6.discriminatedUnion("kind", [
+  z6.object(xSearchSourceSchema.shape),
+  z6.object({
+    ...customSourceSchema.shape,
+    identities: z6.array(openIdentityKindSchema).optional()
+  }),
+  z6.object(discordMessagesSourceSchema.shape),
+  z6.object(discordReactionsSourceSchema.shape)
+]);
+var trackerSourceResponseSchema = z6.union([
+  knownTrackerSourceResponseSchema,
+  z6.object({
+    kind: z6.string().min(1).refine(
+      (kind) => !trackerSourceKinds.some((known) => known === kind),
+      "Known source kinds must match their schema"
+    )
+  }).catchall(z6.json())
+]);
+function isKnownTrackerSource(source) {
+  return knownTrackerSourceResponseSchema.safeParse(source).success;
+}
+var trackerDefinitionResponseSchema = z6.object({
+  ...trackerDefinitionSchema.shape,
+  source: trackerSourceResponseSchema,
+  window: z6.object(windowSchema.shape)
+});
+var publishedTrackerSchema = z6.object({
+  id: identifier,
+  version: identifier,
+  definition: trackerDefinitionResponseSchema,
+  publishedAt: timestamp,
+  actor: z6.string().nullable()
+});
+var trackerStatusSchema = z6.object({
+  archivedAt: z6.number().int().nonnegative().nullable().optional(),
+  published: publishedTrackerSchema,
+  paused: z6.boolean(),
+  state: z6.enum(["idle", "syncing", "error", "complete"]),
+  lastStartedAt: timestamp.nullable(),
+  lastCompletedAt: timestamp.nullable(),
+  nextSyncAt: timestamp.nullable(),
+  coverage: z6.enum(["unknown", "partial", "complete"]),
+  error: z6.string().nullable(),
+  records: count
+});
+var trackerControlSchema = z6.object({
+  actionId: identifier,
+  action: z6.enum(["pause", "resume", "refresh"])
+}).strict();
+var trackerAccountSchema = z6.strictObject({
+  kind: identityKindSchema.optional(),
+  id: externalId
+});
+var trackerRecordInputSchema = z6.object({
+  id: externalId,
+  occurredAt: timestamp,
+  observedAt: timestamp,
+  author: z6.object({
+    id: externalId,
+    verified: z6.boolean().nullable().default(null),
+    /** The author's identity kind; needed when the source names more than one. */
+    kind: identityKindSchema.optional()
+  }).strict().nullable().default(null),
+  /** Named accounts besides the author, by the roles the custom source declares. */
+  accounts: z6.record(accountRoleSchema, trackerAccountSchema).refine(
+    (accounts) => Object.keys(accounts).length <= 10,
+    "At most 10 accounts"
+  ).optional(),
+  data: z6.record(z6.string(), z6.json()),
+  removed: z6.boolean().default(false)
+}).strict().refine(
+  (v) => new TextEncoder().encode(JSON.stringify(v.data)).byteLength <= 131072,
+  "Record exceeds 128 KB"
+);
+var trackerRecordAccountSchema = z6.object({
+  kind: openIdentityKindSchema.optional(),
+  id: z6.string()
+});
+var trackerRecordSchema = z6.object({
+  id: z6.string(),
+  occurredAt: timestamp,
+  observedAt: timestamp,
+  author: z6.object({
+    id: z6.string(),
+    verified: z6.boolean().nullable().default(null),
+    kind: openIdentityKindSchema.optional()
+  }).nullable().default(null),
+  accounts: z6.record(z6.string(), trackerRecordAccountSchema).optional(),
+  data: z6.record(z6.string(), z6.json()),
+  removed: z6.boolean().default(false),
+  source: z6.string(),
+  firstSeenAt: timestamp,
+  /** Present only when includeEvidence is true; custom sources have no X evidence. */
+  evidence: trackerEvidenceSchema.nullable().optional()
+});
+var trackerIngestSchema = z6.object({
+  actionId: identifier,
+  records: z6.array(trackerRecordInputSchema).min(1).max(100)
+}).strict();
+var trackerIngestResultSchema = z6.object({
+  stored: count,
+  /** Tracker-trigger decisions this ingest caused. Absent from servers without tracker triggers. */
+  admissions: z6.object({
+    admitted: count,
+    skipped: count,
+    /**
+     * Observations a quest's firing mode selected but its `where` filter did not match, counted
+     * per quest like `admitted` and `skipped`. They record no outcome. Present only when
+     * nonzero.
+     */
+    filtered: count.optional()
+  }).optional()
+});
+var trackerOutcomeFields = {
+  /** Stable quest ID. */
+  quest: identifier,
+  /** Stable tracker ID. */
+  tracker: identifier,
+  record: externalId,
+  observedAt: timestamp,
+  /** The release admitted, or the one active when the observation was skipped. */
+  release: identifier,
+  /** The account attribution resolved or failed to resolve, such as a CAIP-10 wallet ID. */
+  account: z6.string().nullable(),
+  createdAt: timestamp,
+  updatedAt: timestamp,
+  /** Null for automatic decisions; the staff actor after a retry. */
+  actor: z6.string().nullable()
+};
+var trackerSkipCodes = [
+  /** The quest is paused or no longer active. Catch-up after a pause is an operator decision. */
+  "quest-paused",
+  /** The record occurred before the quest was published, and the quest counts from activation. */
+  "before-activation",
+  /** The record occurred outside the tracker's window. */
+  "outside-window",
+  /** The record's occurrence time is later than the decision. */
+  "future-record",
+  /** The record is marked removed. */
+  "record-removed",
+  /**
+   * The record's data does not match the tracker's current data schema, such as a record stored
+   * before the schema changed. Staff can retry it once the schema accepts the data.
+   */
+  "invalid-record-data",
+  /** The captured body of this observation cannot be read. */
+  "content-unavailable",
+  /** The record has no account in the beneficiary role, such as a post that is not a reply. */
+  "no-account",
+  /**
+   * The beneficiary account is the record's author account, such as a reply to oneself, or both
+   * belong to the same member. A different account is judged once it resolves to a member, after
+   * `unlinked-account` and `ambiguous-account`.
+   */
+  "beneficiary-is-author",
+  /** No member has verified the beneficiary account. Decided again when a member links it. */
+  "unlinked-account",
+  /**
+   * More than one member has the beneficiary account. Decided again when a conflicting link is
+   * removed.
+   */
+  "ambiguous-account",
+  /** The attributed member has not joined the project. Decided again when the member joins. */
+  "not-joined",
+  /** The quest completes once, or pays one streak milestone, and the member already has it. */
+  "already-completed",
+  /**
+   * The quest requires enrollment and the member has not enrolled. Decided again when the member
+   * enrolls.
+   */
+  "not-enrolled",
+  /** The record occurred before the member enrolled, and the quest counts from enrollment. */
+  "before-enrollment",
+  /**
+   * The record occurred before the member linked the account it pays (an unknown link time counts
+   * as before) or before the member enrolled, and the quest's `historical` policy has not released
+   * it. A reviewer's retry releases it; under `historical: "claim"`, so does the member's claim.
+   */
+  "historical",
+  /** A prerequisite quest was not complete when the record occurred. */
+  "prerequisites-incomplete"
+];
+var trackerOutcomeSchema = z6.discriminatedUnion("state", [
+  z6.strictObject({
+    ...trackerOutcomeFields,
+    state: z6.literal("admitted"),
+    code: z6.null(),
+    reason: z6.null(),
+    /** The attributed member. */
+    member: identifier,
+    /** The admitted attempt. Its evaluation, decision and rewards live on the attempt. */
+    attempt: identifier
+  }),
+  z6.strictObject({
+    ...trackerOutcomeFields,
+    state: z6.literal("skipped"),
+    /** Why the observation was skipped, as one of `trackerSkipCodes`. */
+    code: z6.string().min(1),
+    /** Why the observation was skipped, for people. */
+    reason: z6.string(),
+    /** The attributed member, when attribution got that far. */
+    member: identifier.nullable(),
+    attempt: identifier.nullable()
+  })
+]);
+var trackerOutcomeQuerySchema = z6.strictObject({
+  /** Quest key or ID. */
+  quest: identifier.optional(),
+  record: externalId.optional(),
+  member: identifier.optional(),
+  state: z6.enum(["admitted", "skipped"]).optional(),
+  /** Only skips with this code, such as `unlinked-account`. */
+  code: z6.string().min(1).max(100).optional(),
+  limit: z6.coerce.number().int().min(1).max(100).default(25),
+  /** Opaque cursor from `next`: older outcomes. */
+  before: z6.string().max(512).optional()
+});
+var trackerOutcomePageSchema = z6.strictObject({
+  /** Newest first. */
+  items: z6.array(trackerOutcomeSchema).max(100),
+  next: z6.string().nullable()
+});
+var trackerOutcomeRetrySchema = z6.strictObject({
+  actionId: identifier,
+  /** Quest key or ID. */
+  quest: identifier,
+  record: externalId,
+  observedAt: timestamp
+});
+var booleanQuery = z6.union([
+  z6.boolean(),
+  z6.enum(["true", "false"]).transform((v) => v === "true")
+]);
+var trackerQuerySchema = z6.object({
+  author: externalId.optional(),
+  member: identifier.optional(),
+  verified: booleanQuery.optional(),
+  since: z6.coerce.number().int().safe().nonnegative().optional(),
+  until: z6.coerce.number().int().safe().nonnegative().optional(),
+  removed: booleanQuery.default(false),
+  minLikes: z6.coerce.number().int().safe().nonnegative().optional(),
+  minViews: z6.coerce.number().int().safe().nonnegative().optional(),
+  limit: z6.coerce.number().int().min(1).max(100).default(25),
+  cursor: z6.string().max(2048).optional(),
+  includeEvidence: booleanQuery.optional()
+}).strict().refine(
+  (q) => q.since === void 0 || q.until === void 0 || q.until > q.since,
+  "Until must follow since"
+);
+var trackerPageSchema = z6.object({
+  tracker: identifier,
+  items: z6.array(trackerRecordSchema),
+  nextCursor: z6.string().nullable(),
+  total: count,
+  status: trackerStatusSchema
+});
+var trackerSummarySchema = z6.object({
+  records: count,
+  authors: count,
+  metrics: z6.object({
+    likes: count,
+    replies: count,
+    reposts: count,
+    quotes: count,
+    views: count,
+    bookmarks: count
+  }),
+  missingMetrics: count,
+  status: trackerStatusSchema
+});
+var trackerPreviewLimits = {
+  pages: 3,
+  posts: 100,
+  days: 30
+};
+var trackerPreviewInputSchema = z6.object({
+  query: xSearchSourceSchema.shape.query,
+  /** Start of the searched window. The window ends when the sample is fetched. */
+  since: timestamp
+}).strict();
+var trackerPreviewSchema = z6.object({
+  query: z6.string(),
+  since: timestamp,
+  fetchedAt: timestamp,
+  pages: count,
+  /** Every match in the sample, newest first, verified or not. */
+  posts: z6.array(xTweetSchema).max(trackerPreviewLimits.posts),
+  /** X had more matches than the sample holds. */
+  more: z6.boolean()
+});
+
+// src/content.ts
+import { z as z7 } from "zod";
+var contentQualificationDecisionSchema = z7.strictObject({
+  kind: z7.enum([
+    "accept",
+    "reject",
+    "review",
+    "defer",
+    "progress",
+    "superseded"
+  ]),
+  reason: z7.string().nullable()
+});
+var contentQualificationQuerySchema = z7.strictObject({
+  quest: identifier,
+  member: identifier.optional(),
+  /** A content item's record ID in the quest's tracker. */
+  content: z7.string().min(1).max(256).optional(),
+  cursor: pageCursorSchema.optional()
+});
+var contentQualificationSchema = z7.strictObject({
+  quest: identifier,
+  /** The content item's record ID in the quest's tracker. */
+  content: z7.string(),
+  member: identifier,
+  release: identifier,
+  attempt: identifier,
+  revision: identifier,
+  observation: identifier,
+  current: z7.boolean(),
+  state: z7.enum([
+    "pending",
+    "qualified",
+    "unqualified",
+    "needs-review",
+    "failed",
+    "superseded",
+    "stale",
+    "blocked",
+    "unavailable"
+  ]),
+  reason: z7.string().nullable(),
+  reward: z7.strictObject({
+    attempt: identifier.nullable(),
+    completion: identifier.nullable(),
+    state: z7.enum(["unresolved", "awarded", "excluded"])
+  })
+});
+var contentQualificationPageSchema = z7.strictObject({
+  items: z7.array(contentQualificationSchema),
+  nextCursor: pageCursorSchema.nullable()
+});
+var contentMetricSchema = contentMetricNameSchema;
+var contentMetricsSchema = z7.record(
+  contentMetricSchema,
+  z7.number().int().safe().nonnegative()
+);
+var contentPerformancePolicySchema = z7.strictObject({
+  metrics: z7.array(contentMetricSchema).min(1).max(10).refine(
+    (values) => new Set(values).size === values.length,
+    "Metrics must be unique"
+  ),
+  maxAgeMs: z7.number().int().positive().max(864e5).default(36e5)
+});
+
+// src/counters.ts
+import { z as z8 } from "zod";
+var day = 864e5;
+var counterGoalSchema = z8.object({
+  kind: z8.literal("count"),
+  count: z8.number().int().min(1).max(1e4)
+}).strict();
+var counterWindowSchema = z8.discriminatedUnion("kind", [
+  z8.object({ kind: z8.literal("lifetime") }).strict(),
+  z8.object({
+    kind: z8.literal("calendar"),
+    period: z8.enum(["day", "week", "month"]),
+    latenessMs: z8.number().int().min(0).max(90 * day).default(7 * day)
+  }).strict(),
+  z8.object({
+    kind: z8.literal("rolling"),
+    durationMs: z8.number().int().min(1).max(365 * day)
+  }).strict()
+]);
+var counterPolicySchema = z8.object({
+  kind: z8.literal("progress"),
+  goal: counterGoalSchema,
+  window: counterWindowSchema,
+  repeat: z8.enum(["once", "repeat"]).default("once")
+}).strict();
+var achievementBase = z8.object({
+  id: identifier,
+  ordinal: z8.number().int().positive(),
+  achievedAt: z8.number().int(),
+  window: z8.string()
+});
+var counterAchievementSchema = z8.discriminatedUnion("status", [
+  achievementBase.extend({
+    status: z8.literal("revoked"),
+    completion: identifier,
+    revokedAt: z8.number().int()
+  }),
+  achievementBase.extend({
+    status: z8.literal("awarded"),
+    completion: identifier
+  }),
+  achievementBase.extend({
+    status: z8.literal("budget-exhausted"),
+    budget: identifier
+  })
+]);
+var counterProgressSchema = z8.object({
+  goal: z8.number().int().positive(),
+  current: z8.number().int().nonnegative(),
+  window: z8.object({
+    key: z8.string(),
+    start: z8.number().int().nullable(),
+    end: z8.number().int().nullable()
+  }),
+  repeat: z8.enum(["once", "repeat"]),
+  settled: z8.number().int().nonnegative(),
+  latest: counterAchievementSchema.nullable()
+});
+var counterContributionSchema = z8.object({
+  id: identifier,
+  distinct: z8.string(),
+  attempt: identifier,
+  occurredAt: z8.number().int(),
+  recordedAt: z8.number().int(),
+  window: z8.string(),
+  status: z8.enum(["counted", "late", "future", "excluded"]),
+  achievement: counterAchievementSchema.nullable(),
+  reason: z8.string().nullable()
+});
+var counterHistorySchema = z8.object({
+  items: z8.array(counterContributionSchema),
+  nextCursor: z8.string().nullable()
+});
+var counterModerationSchema = z8.object({
+  actionId: z8.uuid(),
+  excluded: z8.boolean(),
+  reason: z8.string().trim().min(1).max(2e3)
+}).strict();
+var counterHistoryQuerySchema = z8.object({
+  cursor: z8.string().max(2e3).optional(),
+  limit: z8.coerce.number().int().min(1).max(100).optional()
+}).strict();
+var counterModerationResultSchema = z8.object({ excluded: z8.boolean() });
+
+// src/calendar.ts
+import { z as z9 } from "zod";
+var timestamp2 = z9.number().int().safe();
+var fixedOffset = /^(?:[+-]|(?:Etc\/)?GMT[+-]\d|(?:EST|MST|HST)$)/i;
+function canonicalTimeZone(zone) {
+  let resolved;
+  try {
+    resolved = new Intl.DateTimeFormat("en", {
+      timeZone: zone
+    }).resolvedOptions().timeZone;
+  } catch {
+    return null;
+  }
+  if (resolved === "UTC") {
+    return "UTC";
+  }
+  return fixedOffset.test(zone) || fixedOffset.test(resolved) ? null : resolved;
+}
+var timeZoneSchema = z9.string().min(1).max(100).transform((zone, ctx) => {
+  const canonical = canonicalTimeZone(zone);
+  if (canonical === null) {
+    ctx.addIssue({
+      code: "custom",
+      message: fixedOffset.test(zone) ? "Use a named IANA timezone, such as Europe/Budapest or UTC. Fixed offsets have no daylight-saving rules." : "Use an IANA timezone name, such as Europe/Budapest or UTC"
+    });
+    return z9.NEVER;
+  }
+  return canonical;
+});
+var timeZoneNameSchema = z9.string().min(1).max(100);
+var movedTimeZone = (what) => `${what} no longer take a timeZone: they follow the project calendar. Set calendar.timeZone in relay.json or in Console settings.`;
+var record = (value) => typeof value === "object" && value !== null;
+function refuseStreakTimeZone(value, ctx) {
+  if (record(value) && value.kind === "streak" && "timeZone" in value) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["timeZone"],
+      message: movedTimeZone("Streaks")
+    });
+  }
+  return value;
+}
+function refuseWindowTimeZone(value, ctx) {
+  const window = record(value) ? value.window : void 0;
+  if (record(window) && window.kind === "calendar" && "timeZone" in window) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["window", "timeZone"],
+      message: movedTimeZone("Calendar leaderboard windows")
+    });
+  }
+  return value;
+}
+var calendarPeriodSchema = z9.enum(["lifetime", "day", "week", "month"]);
+var projectCalendarSchema = z9.object({
+  /** The timezone of the current calendar day. */
+  timeZone: timeZoneNameSchema,
+  /** The current calendar date, such as `2026-10-01`. */
+  today: z9.string(),
+  /** When the current calendar day ends, in epoch milliseconds. */
+  nextBoundary: timestamp2,
+  /** A change that takes effect at the next day boundary, or null. */
+  pending: z9.object({ timeZone: timeZoneNameSchema, effectiveAt: timestamp2 }).nullable(),
+  /** The `calendar.timeZone` the last deployment that declared one set, or null. */
+  declared: timeZoneNameSchema.nullable(),
+  /**
+   * A stored timezone the calendar no longer accepts, such as a fixed offset a streak named before
+   * v1. The calendar reads it as UTC until an operator chooses a timezone. Null otherwise.
+   */
+  unsupported: z9.string().nullable().default(null)
+});
+var projectCalendarInputSchema = z9.object({
+  actionId: identifier,
+  timeZone: timeZoneSchema,
+  reason: z9.string().trim().min(1).max(500)
+}).strict();
+var projectCalendarDeclarationSchema = z9.object({ timeZone: timeZoneSchema }).strict();
+
+// src/streaks.ts
+import { z as z10 } from "zod";
+var streakPolicySchema = z10.object({
+  kind: z10.literal("streak"),
+  days: z10.number().int().min(1).max(3650)
+});
+var streakProgressSchema = z10.object({
+  goal: z10.number().int().positive(),
+  current: z10.number().int().nonnegative(),
+  best: z10.number().int().nonnegative(),
+  today: z10.string(),
+  todayQualified: z10.boolean(),
+  timeZone: timeZoneNameSchema,
+  nextBoundary: z10.number().int(),
+  pendingTimeZone: z10.object({
+    timeZone: timeZoneNameSchema,
+    effectiveAt: z10.number().int()
+  }).nullable(),
+  days: z10.array(
+    z10.object({
+      day: z10.number().int(),
+      date: z10.string(),
+      // The zone the day was recorded in, as stored: days from before v1 can name a fixed offset.
+      timeZone: z10.string(),
+      occurredAt: z10.number().int()
+    })
+  ),
+  milestone: z10.discriminatedUnion("status", [
+    z10.object({ status: z10.literal("pending") }),
+    z10.object({
+      status: z10.literal("awarded"),
+      completion: z10.string(),
+      achievedAt: z10.number().int()
+    }),
+    z10.object({
+      status: z10.literal("budget-exhausted"),
+      budget: z10.string(),
+      achievedAt: z10.number().int()
+    })
+  ])
+});
+
+// src/tracker-triggers.ts
+import { z as z11 } from "zod";
+var timestamp3 = z11.number().int().safe().nonnegative().max(864e13);
+var count2 = z11.number().int().safe().nonnegative();
+var trackerTriggerModeSchema = z11.enum([
+  "new-record",
+  "new-observation",
+  "data-changed"
+]);
+function defaultTriggerMode(source) {
+  return source === "custom" ? "new-observation" : "new-record";
+}
+var trackerBoundSchema = z11.union([
+  z11.number().finite(),
+  z11.strictObject({ setting: z11.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
+]);
+var dataPath = z11.string().max(200).regex(
+  /^[^.\s]+(\.[^.\s]+)*$/,
+  "Use dot-separated keys, such as metrics.likes"
+);
+var trackerConditionSchema = z11.union([
+  z11.strictObject({
+    path: dataPath,
+    equals: z11.union([z11.string().max(1e3), z11.number().finite(), z11.boolean()])
+  }),
+  z11.strictObject({
+    path: dataPath,
+    gt: trackerBoundSchema.optional(),
+    gte: trackerBoundSchema.optional(),
+    lt: trackerBoundSchema.optional(),
+    lte: trackerBoundSchema.optional()
+  }).refine(
+    (where) => [where.gt, where.gte, where.lt, where.lte].some(
+      (bound2) => bound2 !== void 0
+    ),
+    "Compare with equals, gt, gte, lt or lte"
+  )
+]);
+var trackerWhereSchema = z11.union([
+  trackerConditionSchema,
+  z11.array(trackerConditionSchema).min(1).max(10)
+]);
+function whereConditions(where) {
+  return where === void 0 ? [] : Array.isArray(where) ? where : [where];
+}
+function whereSettings(where) {
+  return whereConditions(where).flatMap(
+    (condition) => "equals" in condition ? [] : [condition.gt, condition.gte, condition.lt, condition.lte].flatMap(
+      (bound2) => typeof bound2 === "object" ? [bound2.setting] : []
+    )
+  );
+}
+var triggerEnrollmentSchema = z11.enum(["none", "required"]);
+var triggerSinceSchema = z11.enum(["activation", "window", "enrollment"]);
+var triggerHistoricalSchema = z11.enum(["staff", "claim", "automatic"]);
+var trackerTriggerPolicySchema = z11.strictObject({
+  /** The tracker's authoring key; publication binds it to the tracker's stable ID. */
+  tracker: identifier,
+  /**
+   * The tracker's source kind, one of `trackerSourceKinds` today. An open string, so readers of
+   * releases keep parsing them when a later Relay adds a managed source.
+   */
+  source: z11.string().min(1).max(100),
+  /** Which observations fire. */
+  on: trackerTriggerModeSchema,
+  where: trackerWhereSchema.optional(),
+  /**
+   * The record account the quest pays: `author`, `inReplyTo` for an X post, `messageAuthor` for a
+   * Discord reaction, or a named account of a custom record. Relay attributes it through
+   * verified links; evaluators cannot redirect it.
+   */
+  beneficiary: accountRoleSchema,
+  /** Absent means `"none"`. */
+  enrollment: triggerEnrollmentSchema.optional(),
+  /** Absent means `"activation"`. */
+  since: triggerSinceSchema.optional(),
+  /** Absent means `"staff"`, or `"claim"` on a content quest. */
+  historical: triggerHistoricalSchema.optional(),
+  /**
+   * A content quest (`content({ tracker })`): one completion per content item, a content stage
+   * that re-evaluates edits and runs `performance`, firing on each new record and paying its
+   * author.
+   */
+  content: z11.literal(true).optional()
+}).refine(
+  (policy) => policy.since !== "enrollment" || policy.enrollment === "required",
+  'since: "enrollment" needs enrollment: "required"'
+);
+function triggerMode(policy) {
+  return policy.on;
+}
+function triggerAdmission(policy) {
+  return {
+    enrollment: policy.enrollment ?? "none",
+    since: policy.since ?? "activation",
+    historical: policy.historical ?? (policy.content ? "claim" : "staff")
+  };
+}
+function beneficiaryRole(policy) {
+  return policy.beneficiary;
+}
+var xLink = {
+  issuer: z11.string().min(1),
+  /** The account's stable user ID. */
+  subject: z11.string().min(1).max(256),
+  /** The member's account selection revision. */
+  revision: count2,
+  /** When the member linked the account; null when unknown. */
+  linkedAt: timestamp3.nullable()
+};
+var trackerAttributionSchema = z11.object({
+  member: identifier,
+  capturedAt: timestamp3,
+  account: z11.union([
+    z11.object({
+      provider: z11.literal("wallet"),
+      /** Canonical CAIP-10 account ID, as the record names it. */
+      id: z11.string().min(5).max(256),
+      /** The wallet link's revision. */
+      revision: count2,
+      /** When the member verified the wallet. */
+      linkedAt: timestamp3.nullable()
+    }),
+    z11.object({ provider: z11.literal("x"), ...xLink }),
+    z11.object({ provider: z11.literal("discord"), ...xLink }),
+    z11.object({
+      provider: z11.literal("member"),
+      /** The member ID the record names. */
+      id: identifier
+    }),
+    z11.object({
+      /** Your app's identity kind, such as `app:telegram`. */
+      provider: appIdentityKindSchema,
+      /** The subject your app signed the member in with, as the record names it. */
+      subject: z11.string().min(1).max(256),
+      /** The identity's revision in the project. */
+      revision: count2,
+      /** When the identity was linked to the member. */
+      linkedAt: timestamp3.nullable()
+    }),
+    /** A kind a later Relay adds. */
+    z11.object({ provider: z11.string().min(1) })
+  ])
+});
+var trackerTriggerRecordSchema = z11.object({
+  id: z11.string().min(1).max(256),
+  source: z11.string(),
+  occurredAt: timestamp3,
+  observedAt: timestamp3,
+  firstSeenAt: timestamp3,
+  author: z11.object({
+    id: z11.string().min(1).max(256),
+    verified: z11.boolean().nullable(),
+    kind: openIdentityKindSchema.optional()
+  }).nullable(),
+  accounts: z11.record(accountRoleSchema, trackerRecordAccountSchema).optional(),
+  data: z11.record(z11.string(), z11.json()),
+  removed: z11.boolean()
+});
+var trackerContentStageSchema = z11.object({
+  /** The body's revision: the hash of its canonical JSON. Edits make a new one. */
+  revision: identifier,
+  /** The captured observation that carried this body. */
+  observation: identifier,
+  /** The body: an X post's normalized body, or a custom record's `data.body`. */
+  body: z11.record(z11.string(), z11.json())
+});
+var trackerTriggerContextSchema = z11.object({
+  /** The tracker's stable ID. */
+  tracker: identifier,
+  /** The tracker's authoring key. */
+  key: identifier,
+  /** The record account the attempt pays, as the quest's release names it. */
+  beneficiary: accountRoleSchema,
+  record: trackerTriggerRecordSchema,
+  /**
+   * The content this observation carries, when the tracker's source declares content: its body,
+   * the body's revision, and the captured observation. On a content quest's stage attempts, the
+   * revision being evaluated.
+   */
+  content: trackerContentStageSchema.optional(),
+  attribution: trackerAttributionSchema,
+  /**
+   * When the member enrolled in the quest. Present only on quests that require enrollment.
+   */
+  enrolledAt: timestamp3.optional()
+});
+
+// src/completion.ts
+import { z as z12 } from "zod";
+var name = z12.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
+var completionPolicySchema = z12.discriminatedUnion("kind", [
+  streakPolicySchema,
+  counterPolicySchema,
+  z12.object({ kind: z12.literal("once") }).strict(),
+  z12.object({ kind: z12.literal("keyed") }).strict()
+]);
+var completionKeySchema = z12.string().min(1).max(500);
+var budgetSchema = z12.object({
+  id: name,
+  scope: z12.enum(["member", "project"]),
+  /**
+   * The project calendar period of the attempt's eligibility time that one bucket covers:
+   * `"day"`, `"week"` (ISO, starting on Monday) or `"month"` in the project timezone.
+   * `"lifetime"` never resets.
+   */
+  period: calendarPeriodSchema,
+  limit: z12.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+  cost: z12.union([
+    z12.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+    z12.object({ balance: name }).strict()
+  ])
+}).strict();
+
+// src/integrations.ts
+import { z as z13 } from "zod";
+var evaluatorIntegrationProviderSchema = z13.enum(["discord", "x"]);
+var integrationProviderSchema = z13.enum(["discord"]);
+var discordServerSchema = z13.object({
+  id: z13.string().regex(/^[0-9]{1,20}$/),
+  name: z13.string().min(1),
+  icon: z13.string().nullable()
+});
+var projectIntegrationSchema = z13.object({
+  provider: integrationProviderSchema,
+  configured: z13.boolean(),
+  status: z13.enum(["disconnected", "ready", "attention"]),
+  revision: z13.number().int().nonnegative(),
+  server: discordServerSchema.nullable(),
+  issue: z13.string().nullable(),
+  connectedAt: z13.number().default(0)
+});
+
+// src/submission-input.ts
+import { z as z14 } from "zod";
+var textOptionsSchema = z14.object({
+  required: z14.boolean().default(true),
+  minLength: z14.number().int().min(0).max(1e4).default(1),
+  maxLength: z14.number().int().min(1).max(1e4).default(1e4)
+}).strict().refine(
+  (v) => v.minLength <= v.maxLength,
+  "minLength must not exceed maxLength"
+);
+var hostSchema = z14.string().min(1).max(253).refine((host) => {
+  if (!/^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/i.test(host) || host.includes("..")) {
+    return false;
+  }
+  try {
+    const url = new URL(`https://${host}`);
+    return url.hostname === host.toLowerCase() && !url.port && !url.username && !url.password && url.pathname === "/" && !url.search && !url.hash;
+  } catch {
+    return false;
+  }
+}, "Use a hostname without a scheme, path, port, or wildcard");
+var urlOptionsSchema = z14.object({
+  required: z14.boolean().default(true),
+  allowedHosts: z14.array(hostSchema).min(1).max(100).optional()
+}).strict();
+var textEvidenceSchema = z14.object({ kind: z14.literal("text"), value: z14.string().max(1e4) }).strict();
+var urlEvidenceSchema = z14.object({ kind: z14.literal("url"), value: z14.string().max(2048) }).strict();
+var valueEvidenceSchema = z14.discriminatedUnion("kind", [
+  textEvidenceSchema,
+  urlEvidenceSchema
+]);
+function validateSubmissionValue(input, contract) {
+  const maximum = input.kind === "text" ? 1e4 : 2048;
+  if (input.value.length > maximum) {
+    return `Enter no more than ${maximum} characters`;
+  }
+  if (input.kind !== contract.input) {
+    return `This quest requires ${contract.input} input`;
+  }
+  if (!input.value.trim()) {
+    return contract.constraints.required ? "This field is required" : null;
+  }
+  if (contract.input === "text") {
+    if (input.value.length < contract.constraints.minLength) {
+      return `Enter at least ${contract.constraints.minLength} characters`;
+    }
+    if (input.value.length > contract.constraints.maxLength) {
+      return `Enter no more than ${contract.constraints.maxLength} characters`;
+    }
+    return null;
+  }
+  const url = parseHttpUrl(input.value);
+  if (!url) {
+    return "Enter a valid HTTP or HTTPS URL without credentials";
+  }
+  if (contract.constraints.allowedHosts && !contract.constraints.allowedHosts.some(
+    (host) => host.toLowerCase() === url.hostname.toLowerCase()
+  )) {
+    return `Use a URL hosted on: ${contract.constraints.allowedHosts.join(", ")}`;
+  }
+  return null;
+}
+function parseHttpUrl(value) {
+  if (value !== value.trim() || /[\\\s]/.test(value) || !/^https?:\/\//i.test(value)) {
+    return null;
+  }
+  try {
+    const url = new URL(value);
+    return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password ? url : null;
+  } catch {
+    return null;
+  }
+}
+function xPostId(value) {
+  const url = parseHttpUrl(value);
+  if (!url || url.port || ![
+    "x.com",
+    "www.x.com",
+    "twitter.com",
+    "www.twitter.com",
+    "mobile.twitter.com"
+  ].includes(url.hostname)) {
+    return null;
+  }
+  return /^\/(?:[A-Za-z0-9_]+|i\/web)\/status\/([0-9]{1,20})\/?$/.exec(
+    url.pathname
+  )?.[1] ?? null;
+}
+
+// src/quiz.ts
+import { z as z15 } from "zod";
+var quizId = z15.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
+var quizChoiceSchema = z15.object({ id: quizId, label: z15.string().trim().min(1).max(500) }).strict();
+var quizQuestionSchema = z15.object({
+  id: quizId,
+  prompt: z15.string().trim().min(1).max(1e3),
+  choices: z15.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 = z15.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 = z15.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/resources.ts
+import { z as z16 } from "zod";
+var resourceSourceSchema = z16.union([
+  z16.strictObject({
+    provider: z16.literal("domino"),
+    resource: z16.literal("point-ledger")
+  }),
+  discordResourceSourceSchema
+]);
+var resourceRequestSchema = z16.object({
+  source: resourceSourceSchema,
+  query: z16.string().max(100).optional(),
+  cursor: z16.string().regex(/^\d{1,6}$/).optional(),
+  ids: z16.array(z16.string().min(1).max(100)).max(50).optional()
+}).strict();
+var resourceOptionsSchema = z16.object({
+  revision: z16.number().int(),
+  options: z16.array(
+    z16.object({
+      id: z16.string(),
+      label: z16.string(),
+      description: z16.string().optional(),
+      group: z16.string().optional(),
+      disabledReason: z16.string().optional()
+    })
+  ),
+  cursor: z16.string().nullable()
+});
+
+// src/settings.ts
+import { z as z18 } from "zod";
+
+// src/setting-values.ts
+import { z as z17 } from "zod";
+var settingInstant = z17.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
+var settingResourceId = z17.union([
+  z17.literal(""),
+  z17.string().regex(/^\S{1,200}$/)
+]);
+
+// src/settings.ts
+var base = { label: z18.string().min(1), description: z18.string().optional() };
+var settingFieldSchema = z18.discriminatedUnion("kind", [
+  z18.object({
+    ...base,
+    kind: z18.literal("point-ledger"),
+    default: identifier.or(z18.literal(""))
+  }).strict(),
+  z18.object({ ...base, kind: z18.literal("datetime"), default: settingInstant }).strict(),
+  z18.object({
+    ...base,
+    kind: z18.literal("resource"),
+    default: settingResourceId,
+    source: resourceSourceSchema
+  }).strict(),
+  z18.object({ ...base, kind: z18.literal("quiz"), default: quizContentSchema }).strict(),
+  z18.object({
+    ...base,
+    kind: z18.literal("text"),
+    default: z18.string(),
+    minLength: z18.number().int().nonnegative(),
+    maxLength: z18.number().int().positive(),
+    multiline: z18.boolean()
+  }).strict(),
+  z18.object({
+    ...base,
+    kind: z18.literal("integer"),
+    default: z18.number().int(),
+    min: z18.number().int(),
+    max: z18.number().int()
+  }).strict(),
+  z18.object({ ...base, kind: z18.literal("boolean"), default: z18.boolean() }).strict(),
+  z18.object({
+    ...base,
+    kind: z18.literal("choice"),
+    default: z18.string(),
+    options: z18.array(z18.string().min(1)).min(1)
+  }).strict()
+]);
+var settingsFieldsSchema = z18.record(
+  z18.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
+  settingFieldSchema
+);
+var settingsValuesSchema = z18.record(
+  z18.string(),
+  z18.union([z18.string(), z18.number().finite(), z18.boolean(), quizContentSchema])
+);
+function parseSettings(fields, input) {
+  const shape = {};
+  for (const [key, field] of Object.entries(fields)) {
+    switch (field.kind) {
+      case "point-ledger":
+        shape[key] = settingResourceId.default(field.default);
+        break;
+      case "datetime":
+        shape[key] = settingInstant.default(field.default);
+        break;
+      case "resource":
+        shape[key] = settingResourceId.default(field.default);
+        break;
+      case "quiz":
+        shape[key] = quizContentSchema.default(field.default);
+        break;
+      case "text":
+        shape[key] = z18.string().min(field.minLength).max(field.maxLength).default(field.default);
+        break;
+      case "integer":
+        shape[key] = z18.number().int().min(field.min).max(field.max).default(field.default);
+        break;
+      case "boolean":
+        shape[key] = z18.boolean().default(field.default);
+        break;
+      case "choice":
+        shape[key] = z18.enum(field.options).default(field.default);
+        break;
+    }
+  }
+  return settingsValuesSchema.parse(z18.object(shape).strict().parse(input));
+}
+function missingResourceSettings(fields, values) {
+  return Object.entries(fields).filter(
+    ([key, field]) => (field.kind === "resource" || field.kind === "point-ledger") && !values[key]
+  ).map(([key]) => key);
+}
+function compatibleSettingKinds(previous, next) {
+  return previous.kind === next.kind || previous.kind === "resource" && previous.source.provider === "domino" && next.kind === "point-ledger" || next.kind === "resource" && next.source.provider === "domino" && previous.kind === "point-ledger" || previous.kind === "text" && (next.kind === "resource" || next.kind === "datetime" || next.kind === "point-ledger");
+}
+
+// src/authoring-identity.ts
+var authoringIdentityShape = { key: identifier };
+function authoringKey(input) {
+  if ("id" in input) {
+    throw new Error("Authoring definitions use key, not id");
+  }
+  return identifier.parse(input.key);
+}
+
+// src/campaigns.ts
+import { z as z19 } from "zod";
+var timestamp4 = z19.number().int().safe().nonnegative();
+var availabilityWindowSchema = z19.object({ from: timestamp4, until: timestamp4 }).strict().refine((window) => window.until > window.from, {
+  message: "Window end must follow its start",
+  path: ["until"]
+});
+var campaignDefinitionSchema = z19.object({
+  key: identifier,
+  title: z19.string().trim().min(1).max(120),
+  window: availabilityWindowSchema.optional(),
+  enrollment: z19.enum(["none", "required"]).default("none")
+}).strict();
+var campaignAuthoringSchema = campaignDefinitionSchema.omit({ key: true, title: true }).extend({
+  ...authoringIdentityShape,
+  title: z19.string().trim().min(1).max(120).optional()
+}).strict().transform((value) => {
+  const normalized = value;
+  return campaignDefinitionSchema.parse({
+    ...normalized,
+    title: value.title ?? normalized.key
+  });
+});
+function defineCampaign(input) {
+  return campaignAuthoringSchema.parse(input);
+}
+var campaignViewSchema = campaignDefinitionSchema.extend({
+  enrolledAt: timestamp4.nullable(),
+  withdrawnAt: timestamp4.nullable().default(null),
+  withdrawalReason: z19.string().nullable().default(null)
+});
+var campaignEnrollmentInputSchema = z19.object({ actionId: identifier, campaign: identifier }).strict();
+var memberCampaignEnrollmentInputSchema = campaignEnrollmentInputSchema.extend({ member: identifier });
+var campaignWithdrawalInputSchema = campaignEnrollmentInputSchema;
+var memberCampaignWithdrawalInputSchema = campaignWithdrawalInputSchema.extend({
+  member: identifier,
+  reason: z19.string().trim().min(1).max(500)
+});
+var campaignEnrollmentSchema = z19.object({
+  campaign: identifier,
+  member: identifier,
+  enrolledAt: timestamp4,
+  withdrawnAt: timestamp4.nullable().default(null),
+  withdrawalReason: z19.string().nullable().default(null)
+});
+
+// src/resource-handle.ts
+import { z as z20 } from "zod";
+function resourceHandle(_kind, definition) {
+  return definition;
+}
+var ledgerSettingSchema = identifier.or(z20.literal("")).brand();
+function ledgerKey(ledger) {
+  return typeof ledger === "string" ? ledger : ledger.key;
+}
+
+// src/groups.ts
+import { z as z21 } from "zod";
+var projectGroupSchema = z21.object({
+  key: identifier,
+  title: z21.string().trim().min(1).max(120)
+}).strict();
+var projectGroupAuthoringSchema = projectGroupSchema.omit({ key: true, title: true }).extend({
+  ...authoringIdentityShape,
+  title: z21.string().trim().min(1).max(120).optional()
+}).strict().transform((value) => {
+  return projectGroupSchema.parse({
+    ...value,
+    title: value.title ?? value.key
+  });
+});
+function defineGroup(input) {
+  return resourceHandle("group", projectGroupAuthoringSchema.parse(input));
+}
+function projectGroupKey(group) {
+  return identifier.parse(group.key);
+}
+
+// src/prerequisites.ts
+import { z as z22 } from "zod";
+var amount = z22.number().int().safe().nonnegative();
+var threshold = amount.positive();
+var completionPrerequisiteSchema = z22.discriminatedUnion("scope", [
+  z22.object({
+    kind: z22.literal("completion"),
+    quest: identifier,
+    scope: z22.literal("ever")
+  }).strict(),
+  z22.object({
+    kind: z22.literal("completion"),
+    quest: identifier,
+    scope: z22.literal("period"),
+    period: calendarPeriodSchema.exclude(["lifetime"])
+  }).strict()
+]);
+var balancePrerequisiteSchema = z22.object({
+  kind: z22.literal("balance"),
+  balance: identifier,
+  minimum: threshold
+}).strict();
+var groupPrerequisiteSchema = z22.object({ kind: z22.literal("group"), group: identifier, title: z22.string() }).strict();
+var prerequisiteSchema = z22.discriminatedUnion("kind", [
+  completionPrerequisiteSchema,
+  balancePrerequisiteSchema,
+  groupPrerequisiteSchema
+]);
+var missingPrerequisiteSchema = z22.union([
+  z22.object({
+    kind: z22.literal("completion"),
+    quest: identifier,
+    title: z22.string(),
+    scope: z22.literal("ever")
+  }),
+  z22.object({
+    kind: z22.literal("completion"),
+    quest: identifier,
+    title: z22.string(),
+    scope: z22.literal("period"),
+    period: calendarPeriodSchema.exclude(["lifetime"]),
+    resetsAt: z22.number().int().safe()
+  }),
+  z22.object({
+    kind: z22.literal("balance"),
+    balance: identifier,
+    title: z22.string(),
+    minimum: threshold,
+    current: amount
+  }),
+  z22.object({
+    kind: z22.literal("group"),
+    group: identifier,
+    title: z22.string()
+  })
+]);
+function completed(quest, options = {}) {
+  const reference = quest.key;
+  return completionPrerequisiteSchema.parse({
+    kind: "completion",
+    quest: reference,
+    scope: options.scope ?? "ever",
+    ..."period" in options ? { period: options.period } : {}
+  });
+}
+function balanceAtLeast(balance, minimum) {
+  return balancePrerequisiteSchema.parse({
+    kind: "balance",
+    balance: ledgerKey(balance),
+    minimum
+  });
+}
+function inGroup(group) {
+  return groupPrerequisiteSchema.parse({
+    kind: "group",
+    group: projectGroupKey(group),
+    title: group.title
+  });
+}
+
+// src/schema.ts
+import { z as z23 } from "zod";
+var pointsRewardSchema = z23.object({
+  kind: z23.literal("points").default("points"),
+  balance: identifier,
+  amount: z23.number().int().min(0).max(1e4)
+}).strict();
+var tieredRewardDefinitionSchema = z23.object({
+  id: identifier,
+  title: z23.string().min(1).max(120),
+  tiers: z23.array(
+    z23.object({ id: identifier, title: z23.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: z23.object({ kind: z23.literal("untracked") }).strict(),
+  fulfillment: z23.discriminatedUnion("kind", [
+    z23.object({ kind: z23.literal("staff-handover") }).strict(),
+    z23.object({ kind: z23.literal("automatic") }).strict()
+  ])
+}).strict();
+var tieredRewardReferenceSchema = z23.object({
+  id: identifier,
+  key: identifier.nullable()
+});
+var tierRewardSchema = z23.object({
+  kind: z23.literal("tier"),
+  reward: tieredRewardDefinitionSchema,
+  tier: identifier
+}).strict().refine(
+  (value) => value.reward.tiers.some((t) => t.id === value.tier),
+  "Unknown reward tier"
+);
+var integrationRewardSchema = discordRewardSchema;
+var rewardSchema = z23.union([
+  pointsRewardSchema,
+  tierRewardSchema,
+  integrationRewardSchema
+]);
+function rewardKey(reward) {
+  if (reward.kind === "integration") {
+    return `integration:${reward.provider}:${reward.action}:${reward.roleId}`;
+  }
+  return reward.kind === "points" ? "points:" + reward.balance : "tier:" + reward.reward.id;
+}
+var triggerSchema = z23.union([
+  z23.object({
+    kind: z23.literal("manual"),
+    input: z23.literal("text"),
+    constraints: textOptionsSchema,
+    actor: z23.enum(["member", "staff"]).optional()
+  }).strict(),
+  z23.object({
+    kind: z23.literal("manual"),
+    input: z23.literal("url"),
+    constraints: urlOptionsSchema,
+    actor: z23.enum(["member", "staff"]).optional()
+  }).strict(),
+  z23.object({
+    kind: z23.literal("manual"),
+    input: z23.enum(["photo", "quiz", "none"]),
+    actor: z23.enum(["member", "staff"]).optional()
+  }).strict(),
+  z23.object({
+    kind: z23.literal("automatic"),
+    tracker: trackerTriggerPolicySchema.optional()
+  }).strict()
+]);
+var triggerResponseSchema = z23.union(
+  triggerSchema.options.map((option) => option.strip())
+);
+var photoResultSchema = z23.object({
+  kind: z23.enum(["pass", "fail", "unclear"]),
+  reason: z23.string().min(1).max(2e3)
+}).strict();
+var textReviewInputSchema = z23.object({
+  text: z23.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
+  criteria: z23.string().trim().min(1).max(2e3)
+}).strict();
+var textResultSchema = photoResultSchema;
+var deferPolicy = {
+  minRetryAfterMs: 1e3,
+  maxRetryAfterMs: 36e5,
+  retryAfterMs: 6e4,
+  horizonMs: 864e5,
+  maxDefers: 100
+};
+var evaluatorProgressSchema = z23.object({
+  current: z23.number().finite().nonnegative(),
+  target: z23.number().finite().positive(),
+  reason: z23.string().min(1).max(2e3)
+}).refine((value) => value.current <= value.target, {
+  message: "Progress current must not exceed target"
+});
+var decisionSchema = z23.discriminatedUnion("kind", [
+  z23.strictObject({
+    kind: z23.literal("defer"),
+    reason: z23.string().min(1).max(2e3),
+    retryAfterMs: z23.number().int().min(deferPolicy.minRetryAfterMs).max(deferPolicy.maxRetryAfterMs).optional(),
+    /** Absolute Unix milliseconds; the platform can only shorten its existing deadline. */
+    until: z23.number().int().safe().nonnegative().optional()
+  }),
+  evaluatorProgressSchema.safeExtend({ kind: z23.literal("progress") }).strict(),
+  z23.object({
+    kind: z23.literal("accept"),
+    rewards: z23.array(rewardSchema).max(10),
+    completionKey: completionKeySchema.optional()
+  }).strict(),
+  z23.object({
+    kind: z23.literal("reject"),
+    reason: z23.string().min(1).max(2e3),
+    /** The evaluator asked for human review, but review is off for the quest, so this is a reject. */
+    requestedReview: z23.literal(true).optional()
+  }).strict(),
+  z23.object({
+    kind: z23.literal("review"),
+    reason: z23.string().min(1).max(2e3),
+    rewards: z23.array(rewardSchema).max(10).optional(),
+    completionKey: completionKeySchema.optional()
+  }).strict()
+]);
+var reviewModeSchema = z23.enum(["workers-ai"]);
+var storedReviewModeSchema = z23.enum([
+  "fixture-pass",
+  "fixture-fail",
+  "fixture-unclear",
+  "fixture-error",
+  "workers-ai"
+]);
+var rewardBundleSchema = z23.array(rewardSchema).max(10).refine(
+  (rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
+  "Use one entry per balance or shared reward"
+);
+var mediaUrlSchema = z23.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 = z23.object({
+  quiz: quizQuestionsSchema.optional(),
+  instructions: z23.string().max(4e3).optional(),
+  video: z23.object({
+    url: mediaUrlSchema,
+    poster: mediaUrlSchema.optional(),
+    captions: z23.object({
+      url: mediaUrlSchema,
+      language: z23.string().min(2).max(20),
+      label: z23.string().min(1).max(80)
+    }).strict().optional()
+  }).strict().optional()
+}).strict();
+var questProfileSchema = z23.object({ visible: z23.boolean() }).strict();
+var evaluatorProtocol = 2;
+var evaluatorProtocolSchema = z23.literal(evaluatorProtocol);
+var questDescriptionSchema = z23.object({
+  quest: identifier,
+  evaluatorProtocol: evaluatorProtocolSchema,
+  title: z23.string().min(1).max(120),
+  presentation: questPresentationSchema.default({}),
+  integrations: z23.array(evaluatorIntegrationProviderSchema).max(10).default([]),
+  fields: settingsFieldsSchema,
+  values: settingsValuesSchema,
+  rewards: rewardBundleSchema,
+  humanReview: z23.boolean(),
+  trigger: triggerSchema,
+  performance: contentPerformancePolicySchema.optional(),
+  requires: z23.array(prerequisiteSchema).max(30).default([]),
+  campaign: campaignDefinitionSchema.optional(),
+  availability: availabilityWindowSchema.optional(),
+  completion: z23.preprocess(refuseStreakTimeZone, completionPolicySchema),
+  visibility: z23.enum(["visible", "hidden"]).default("visible"),
+  /** Whether completions show on participant profiles (`/v1/profiles/:id/completions`). */
+  profile: questProfileSchema.default({ visible: false }),
+  budgets: z23.array(budgetSchema).max(20).default([])
+}).strict();
+var artifactSchema = z23.object({ code: z23.string().min(1).max(1e6) }).strict();
+var releaseSchema = artifactSchema.extend({
+  settings: settingsValuesSchema,
+  provider: reviewModeSchema,
+  expectedRelease: identifier.nullable().optional(),
+  settingRenames: z23.record(z23.string(), z23.string()).optional()
+}).strict();
+var batchReleaseSchema = z23.object({ releases: z23.array(releaseSchema).min(1).max(50) }).strict();
+var questSettingsInputSchema = z23.object({
+  quest: identifier,
+  expectedRelease: identifier,
+  set: settingsValuesSchema,
+  reset: z23.array(z23.string())
+}).strict();
+var storedQuestDescriptionSchema = questDescriptionSchema.extend({
+  completion: completionPolicySchema
+});
+var publishedReleaseSchema = storedQuestDescriptionSchema.extend({
+  key: identifier.optional(),
+  code: z23.string(),
+  provider: storedReviewModeSchema,
+  id: identifier,
+  createdAt: z23.number(),
+  origin: z23.object({ typeVersion: identifier }).strict().optional(),
+  lifecycle: z23.enum(["active", "paused", "archived"]).default("active"),
+  configuration: z23.object({
+    defaults: settingsValuesSchema,
+    overrides: settingsValuesSchema,
+    preserved: z23.array(z23.string())
+  }).strict().optional()
+});
+var templateSchema = z23.object({
+  code: z23.string(),
+  definition: questDescriptionSchema
+});
+var quizAnswersSchema = z23.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 = z23.object({
+  kind: z23.literal("quiz"),
+  release: identifier.optional(),
+  answers: quizAnswersSchema
+}).strict();
+var submissionEvidenceSchema = z23.union([
+  quizEvidenceSchema,
+  textEvidenceSchema,
+  urlEvidenceSchema
+]);
+var submitSchema = z23.object({
+  actionId: identifier,
+  quest: identifier,
+  member: identifier,
+  evidence: identifier.optional(),
+  input: submissionEvidenceSchema.optional(),
+  release: identifier.optional(),
+  faultAfterReview: z23.boolean().optional()
+}).strict();
+var AttemptStatus = {
+  Queued: "queued",
+  Evaluating: "evaluating",
+  Deferred: "deferred",
+  Accepted: "accepted",
+  Progressed: "progressed",
+  Rejected: "rejected",
+  NeedsReview: "needs-review",
+  Failed: "failed"
+};
+var attemptStatusSchema = z23.string();
+var attemptSchema = z23.object({
+  id: identifier,
+  release: identifier,
+  quest: identifier,
+  member: identifier,
+  evidence: identifier.nullable(),
+  input: submissionEvidenceSchema.optional(),
+  status: attemptStatusSchema,
+  reason: z23.string().nullable(),
+  retries: z23.number(),
+  generation: z23.number(),
+  completion: z23.string().nullable(),
+  reviewRewards: rewardBundleSchema.nullable().default(null),
+  /** Scheduled reruns advance this number; failure retries preserve it. */
+  evaluationRun: z23.number().int().nonnegative().default(0),
+  deferCount: z23.number().int().nonnegative().default(0),
+  deferUntil: z23.number().int().safe().nullable().default(null),
+  nextEvaluationAt: z23.number().int().safe().nullable().default(null),
+  /** Open code: consumers must tolerate new values. */
+  code: z23.string().nullable().default(null),
+  progress: evaluatorProgressSchema.nullable().default(null),
+  /**
+   * The evaluator asked for human review of a quest with review off, so Domino rejected the attempt
+   * with the evaluator's reason. Only set on a rejected attempt.
+   */
+  requestedReview: z23.boolean().default(false),
+  createdAt: z23.number()
+});
+var eventSchema = z23.object({
+  id: z23.number(),
+  attempt: z23.string().nullable(),
+  kind: z23.string(),
+  detail: z23.string(),
+  actor: z23.string().nullable().default(null),
+  at: z23.number()
+});
+var pickupSelectionSchema = z23.object({
+  item: identifier,
+  revision: z23.number().int().nonnegative()
+}).strict();
+var pickupAllocationSchema = z23.object({
+  item: identifier,
+  label: z23.string().min(1).max(80)
+}).strict();
+var pickupPolicySchema = z23.discriminatedUnion("kind", [
+  z23.object({ kind: z23.literal("untracked") }).strict(),
+  z23.object({
+    kind: z23.literal("at-pickup"),
+    tiers: z23.array(
+      z23.object({
+        tier: identifier,
+        variants: z23.array(pickupAllocationSchema).min(1).max(100)
+      }).strict()
+    ).min(1).max(100)
+  }).strict()
+]);
+var pickupCatalogSchema = z23.object({
+  reward: tieredRewardDefinitionSchema,
+  revision: z23.number().int().nonnegative(),
+  policy: pickupPolicySchema
+});
+var pickupAvailabilitySchema = z23.discriminatedUnion("kind", [
+  z23.object({ kind: z23.literal("untracked") }).strict(),
+  z23.object({
+    kind: z23.literal("at-pickup"),
+    revision: z23.number().int().nonnegative(),
+    variants: z23.array(
+      pickupAllocationSchema.extend({
+        available: z23.number().int().nonnegative()
+      })
+    )
+  }).strict()
+]);
+var configurePickupSchema = z23.object({
+  reward: identifier,
+  revision: z23.number().int().nonnegative(),
+  actionId: identifier,
+  policy: z23.discriminatedUnion("kind", [
+    z23.object({ kind: z23.literal("untracked") }).strict(),
+    z23.object({
+      kind: z23.literal("at-pickup"),
+      tiers: z23.array(
+        z23.object({
+          tier: identifier,
+          variants: z23.array(
+            pickupAllocationSchema.extend({
+              item: identifier.optional()
+            })
+          ).min(1).max(100)
+        }).strict()
+      ).min(1).max(100)
+    }).strict()
+  ])
+}).strict();
+var entitlementRecoverySchema = z23.object({
+  completion: identifier,
+  reason: z23.string(),
+  flaggedAt: z23.number(),
+  /** Null means no accepted completion currently earns this reward. */
+  remainingTier: identifier.nullable()
+});
+var entitlementBase = {
+  id: identifier,
+  member: identifier,
+  reward: tieredRewardDefinitionSchema,
+  earnedTier: identifier,
+  tier: identifier,
+  revision: z23.number().int().positive()
+};
+var entitlementStateSchema = z23.discriminatedUnion("status", [
+  z23.object({ ...entitlementBase, status: z23.literal("available") }).strict(),
+  z23.object({
+    ...entitlementBase,
+    status: z23.literal("handing-over"),
+    handover: identifier,
+    startedAt: z23.number(),
+    allocation: pickupAllocationSchema.optional()
+  }).strict(),
+  z23.object({
+    ...entitlementBase,
+    status: z23.literal("collected"),
+    handover: identifier,
+    startedAt: z23.number(),
+    allocation: pickupAllocationSchema.optional(),
+    collectedAt: z23.number(),
+    recovery: entitlementRecoverySchema.optional()
+  }).strict(),
+  // An operator voided it: it can no longer be handed over. A quest grant of the same reward to
+  // the member (the same grant key) makes it available again; a voided referral reward stays void.
+  z23.object({
+    ...entitlementBase,
+    status: z23.literal("void"),
+    voidedAt: z23.number()
+  }).strict()
+]);
+var tieredRewardReadSchema = z23.object({
+  id: identifier,
+  title: z23.string(),
+  tiers: z23.array(z23.object({ id: identifier, title: z23.string() }).loose()),
+  inventory: z23.object({ kind: z23.string() }).loose(),
+  fulfillment: z23.object({ kind: z23.string() }).loose()
+}).loose();
+var entitlementReadBase = {
+  id: identifier,
+  member: identifier,
+  reward: tieredRewardReadSchema,
+  earnedTier: identifier,
+  tier: identifier,
+  revision: z23.number().int()
+};
+var allocationReadSchema = z23.object({ item: identifier, label: z23.string() }).loose();
+var entitlementSchema = z23.union([
+  z23.discriminatedUnion("status", [
+    z23.object({ ...entitlementReadBase, status: z23.literal("available") }).loose(),
+    z23.object({
+      ...entitlementReadBase,
+      status: z23.literal("handing-over"),
+      handover: identifier,
+      startedAt: z23.number(),
+      allocation: allocationReadSchema.optional()
+    }).loose(),
+    z23.object({
+      ...entitlementReadBase,
+      status: z23.literal("collected"),
+      handover: identifier,
+      startedAt: z23.number(),
+      allocation: allocationReadSchema.optional(),
+      collectedAt: z23.number(),
+      recovery: entitlementRecoverySchema.optional()
+    }).loose(),
+    z23.object({
+      ...entitlementReadBase,
+      status: z23.literal("void"),
+      voidedAt: z23.number()
+    }).loose()
+  ]),
+  z23.object({ ...entitlementReadBase, status: z23.string() }).loose().transform(({ status, ...entitlement }) => ({
+    ...entitlement,
+    status: "unsupported",
+    reportedStatus: status
+  }))
+]);
+var beginHandoverSchema = z23.object({
+  actionId: identifier,
+  revision: z23.number().int().positive(),
+  selection: pickupSelectionSchema.optional()
+}).strict();
+var confirmHandoverSchema = z23.object({ actionId: identifier, handover: identifier }).strict();
+var entitlementCorrectionSchema = z23.object({
+  actionId: identifier,
+  revision: z23.number().int().positive(),
+  reason: z23.string().trim().min(1).max(500)
+}).strict();
+var completionRecordSchema = z23.object({
+  key: z23.string().default("once"),
+  id: identifier,
+  quest: identifier,
+  member: identifier
+});
+var questAvailabilitySchema = z23.discriminatedUnion("kind", [
+  z23.object({
+    kind: z23.literal("available"),
+    input: z23.enum(["photo", "quiz", "none", "text", "url"])
+  }).strict(),
+  z23.object({ kind: z23.literal("completed") }).strict(),
+  z23.object({
+    kind: z23.literal("locked"),
+    missing: z23.array(missingPrerequisiteSchema).min(1)
+  }).strict(),
+  z23.object({
+    kind: z23.literal("blocked"),
+    reason: z23.enum([
+      "budget-exhausted",
+      "connection-required",
+      "wallet-required",
+      "paused",
+      "outside-window",
+      "enrollment-required"
+    ]),
+    resetsAt: z23.number().int().safe().optional()
+  }).strict(),
+  z23.object({ kind: z23.literal("staff-required") }).strict(),
+  z23.object({ kind: z23.literal("automatic") }).strict(),
+  z23.object({ kind: z23.literal("checking"), attempt: identifier }).strict(),
+  z23.object({ kind: z23.literal("needs-review"), attempt: identifier }).strict(),
+  z23.object({ kind: z23.literal("retryable"), attempt: identifier }).strict()
+]);
+var questAvailabilityResponseSchema = z23.union(
+  questAvailabilitySchema.options.map((option) => option.strip())
+);
+var questBudgetViewSchema = z23.object({
+  id: identifier,
+  scope: z23.enum(["member", "project"]),
+  period: z23.enum(["day", "week", "month", "lifetime"]),
+  remaining: z23.number().int().safe().nonnegative(),
+  resetsAt: z23.number().int().safe().nullable()
+});
+var memberProgressSchema = z23.object({
+  member: identifier,
+  quests: z23.array(
+    z23.object({
+      quest: identifier,
+      key: identifier.optional(),
+      release: identifier.optional(),
+      title: z23.string(),
+      presentation: questPresentationSchema.default({}),
+      connections: z23.array(authProviderSchema).default([]),
+      trigger: triggerResponseSchema,
+      availability: questAvailabilityResponseSchema,
+      completed: z23.boolean(),
+      completion: completionPolicySchema.default({ kind: "once" }),
+      streak: streakProgressSchema.nullable().optional(),
+      counter: counterProgressSchema.nullable().optional(),
+      /** Latest attempt's committed evaluator progress, while it remains deferred/evaluating. */
+      progress: evaluatorProgressSchema.nullable().default(null),
+      completionCount: z23.number().int().nonnegative().default(0),
+      visibility: z23.enum(["visible", "hidden"]).default("visible"),
+      missing: z23.array(missingPrerequisiteSchema),
+      campaign: campaignViewSchema.nullable().default(null),
+      window: availabilityWindowSchema.nullable().default(null),
+      budgets: z23.array(questBudgetViewSchema).default([]),
+      attempt: attemptSchema.nullable()
+    })
+  ),
+  entitlements: z23.array(entitlementSchema)
+});
+var snapshotSchema = z23.object({
+  releases: z23.array(publishedReleaseSchema),
+  completions: z23.array(completionRecordSchema),
+  entitlements: z23.array(entitlementSchema),
+  attempts: z23.array(attemptSchema),
+  balances: z23.array(
+    z23.object({
+      member: z23.string(),
+      balance: z23.string(),
+      earned: z23.number(),
+      held: z23.number(),
+      available: z23.number()
+    })
+  ),
+  events: z23.array(eventSchema)
+});
+var evidenceSchema = z23.object({
+  id: identifier,
+  member: identifier,
+  type: z23.enum(["image/jpeg", "image/png"]),
+  size: z23.number()
+});
+var errorSchema = z23.object({
+  error: z23.string(),
+  code: z23.string().optional(),
+  missing: z23.array(missingPrerequisiteSchema).optional()
+});
+var staffDecisionSchema = z23.object({
+  actionId: identifier,
+  generation: z23.number().int().nonnegative(),
+  decision: z23.enum(["accept", "reject"]),
+  reason: z23.string().trim().min(1).max(2e3)
+}).strict();
+var stockSchema = z23.object({ item: identifier, quantity: z23.number().int().min(0).max(1e4) }).strict();
+var reservationSchema = z23.object({
+  actionId: identifier,
+  member: identifier,
+  item: identifier,
+  balance: identifier,
+  price: z23.number().int().positive().max(1e4)
+}).strict();
+var pageOptions = {
+  limit: z23.number().int().min(1).max(100).default(25),
+  cursor: z23.string().min(1).max(4096).optional()
+};
+var reviewListSchema = z23.object({
+  ...pageOptions,
+  member: identifier.optional(),
+  quest: identifier.optional()
+}).strict();
+var memberListSchema = z23.object({
+  ...pageOptions,
+  prefix: identifier.optional()
+}).strict();
+var reviewItemSchema = z23.object({
+  attempt: attemptSchema,
+  title: z23.string(),
+  checks: z23.array(
+    z23.object({ criteria: z23.string(), result: photoResultSchema })
+  )
+});
+var reviewPageSchema = z23.object({
+  items: z23.array(reviewItemSchema).max(100),
+  nextCursor: z23.string().nullable()
+});
+var memberPageSchema = z23.object({
+  items: z23.array(z23.object({ member: identifier })).max(100),
+  nextCursor: z23.string().nullable()
+});
+var createStockItemSchema = z23.object({ actionId: identifier, name: z23.string().trim().min(1).max(80) }).strict();
+var stockItemSchema = z23.object({ id: identifier, name: z23.string() });
+var contentPerformanceSnapshotSchema = z23.strictObject({
+  contentAttempt: identifier,
+  observation: identifier,
+  observedAt: z23.number().int().safe().nonnegative(),
+  metrics: contentMetricsSchema,
+  rewards: rewardBundleSchema
+});
+var contentPerformanceQuerySchema = contentQualificationQuerySchema.extend({
+  content: z23.string().min(1).max(256)
+});
+var contentPerformancePageSchema = z23.strictObject({
+  current: z23.strictObject({
+    state: z23.enum([
+      "content-pending",
+      "content-unqualified",
+      "waiting",
+      "pending",
+      "qualified",
+      "unqualified",
+      "needs-review",
+      "failed",
+      "superseded"
+    ]),
+    reason: z23.string().nullable(),
+    contentAttempt: identifier,
+    attempt: identifier.nullable(),
+    reward: contentQualificationSchema.shape.reward
+  }),
+  items: z23.array(
+    z23.strictObject({
+      attempt: identifier,
+      contentAttempt: identifier,
+      observation: identifier,
+      observedAt: z23.number(),
+      metrics: contentMetricsSchema,
+      state: z23.enum([
+        "pending",
+        "qualified",
+        "unqualified",
+        "needs-review",
+        "failed",
+        "superseded"
+      ]),
+      reason: z23.string().nullable()
+    })
+  ),
+  nextCursor: pageCursorSchema.nullable()
+});
+
+export {
+  pageCursorSchema,
+  pageQuerySchema,
+  authProviderSchema,
+  accountConnectionSchema,
+  discordMemberInputSchema,
+  discordMessageInputSchema,
+  discordMemberSchema,
+  identifier,
+  discordMessageSchema,
+  discordMessagesSourceSchema,
+  discordReactionsSourceSchema,
+  discordMessageDataSchema,
+  discordMessageTextDataSchema,
+  discordReactionDataSchema,
+  discordRewardSchema,
+  discordResourceSourceSchema,
+  trackerDataMaxBranches,
+  trackerDataMaxEntries,
+  trackerDataSchemaSchema,
+  trackerDataSchema,
+  trackerDataRecordSteps,
+  trackerDataBatchSteps,
+  trackerDataIssue,
+  trackerDataIssues,
+  trackerDataPathTypes,
+  schemaCheckedReader,
+  whereSchemaIssue,
+  xTweetSchema,
+  xContentBodySchema,
+  trackerContentQuerySchema,
+  trackerContentReadSchema,
+  trackerEvidenceSchema,
+  trackerContentSchema,
+  knownIdentityKinds,
+  appIdentityKindSchema,
+  identityKindSchema,
+  isAppIdentityKind,
+  openIdentityKindSchema,
+  memberIdentitySchema,
+  accountRoleSchema,
+  xAccountRoles,
+  contentMetricNameSchema,
+  xContentMetrics,
+  customContentSchema,
+  xSearchSourceSchema,
+  customSourceSchema,
+  trackerSourceSchema,
+  trackerSourceKinds,
+  sourceIdentities,
+  sourceContent,
+  trackerDefinitionSchema,
+  trackerArtifactSchema,
+  trackerSourceResponseSchema,
+  isKnownTrackerSource,
+  trackerDefinitionResponseSchema,
+  publishedTrackerSchema,
+  trackerStatusSchema,
+  trackerControlSchema,
+  trackerAccountSchema,
+  trackerRecordInputSchema,
+  trackerRecordAccountSchema,
+  trackerRecordSchema,
+  trackerIngestSchema,
+  trackerIngestResultSchema,
+  trackerSkipCodes,
+  trackerOutcomeSchema,
+  trackerOutcomeQuerySchema,
+  trackerOutcomePageSchema,
+  trackerOutcomeRetrySchema,
+  trackerQuerySchema,
+  trackerPageSchema,
+  trackerSummarySchema,
+  trackerPreviewLimits,
+  trackerPreviewInputSchema,
+  trackerPreviewSchema,
+  contentQualificationDecisionSchema,
+  contentQualificationQuerySchema,
+  contentQualificationSchema,
+  contentQualificationPageSchema,
+  contentMetricSchema,
+  contentMetricsSchema,
+  contentPerformancePolicySchema,
+  counterGoalSchema,
+  counterWindowSchema,
+  counterPolicySchema,
+  counterAchievementSchema,
+  counterProgressSchema,
+  counterContributionSchema,
+  counterHistorySchema,
+  counterModerationSchema,
+  counterHistoryQuerySchema,
+  counterModerationResultSchema,
+  canonicalTimeZone,
+  timeZoneSchema,
+  timeZoneNameSchema,
+  refuseStreakTimeZone,
+  refuseWindowTimeZone,
+  calendarPeriodSchema,
+  projectCalendarSchema,
+  projectCalendarInputSchema,
+  projectCalendarDeclarationSchema,
+  streakPolicySchema,
+  streakProgressSchema,
+  trackerTriggerModeSchema,
+  defaultTriggerMode,
+  trackerBoundSchema,
+  trackerConditionSchema,
+  trackerWhereSchema,
+  whereConditions,
+  whereSettings,
+  triggerEnrollmentSchema,
+  triggerSinceSchema,
+  triggerHistoricalSchema,
+  trackerTriggerPolicySchema,
+  triggerMode,
+  triggerAdmission,
+  beneficiaryRole,
+  trackerAttributionSchema,
+  trackerTriggerRecordSchema,
+  trackerContentStageSchema,
+  trackerTriggerContextSchema,
+  completionPolicySchema,
+  completionKeySchema,
+  budgetSchema,
+  evaluatorIntegrationProviderSchema,
+  integrationProviderSchema,
+  discordServerSchema,
+  projectIntegrationSchema,
+  textOptionsSchema,
+  urlOptionsSchema,
+  textEvidenceSchema,
+  urlEvidenceSchema,
+  valueEvidenceSchema,
+  validateSubmissionValue,
+  xPostId,
+  quizChoiceSchema,
+  quizQuestionSchema,
+  quizQuestionsSchema,
+  quizContentSchema,
+  resourceSourceSchema,
+  resourceRequestSchema,
+  resourceOptionsSchema,
+  settingInstant,
+  settingResourceId,
+  settingFieldSchema,
+  settingsFieldsSchema,
+  settingsValuesSchema,
+  parseSettings,
+  missingResourceSettings,
+  compatibleSettingKinds,
+  authoringIdentityShape,
+  authoringKey,
+  availabilityWindowSchema,
+  campaignDefinitionSchema,
+  defineCampaign,
+  campaignViewSchema,
+  campaignEnrollmentInputSchema,
+  memberCampaignEnrollmentInputSchema,
+  campaignWithdrawalInputSchema,
+  memberCampaignWithdrawalInputSchema,
+  campaignEnrollmentSchema,
+  resourceHandle,
+  ledgerSettingSchema,
+  ledgerKey,
+  projectGroupSchema,
+  defineGroup,
+  projectGroupKey,
+  completionPrerequisiteSchema,
+  balancePrerequisiteSchema,
+  groupPrerequisiteSchema,
+  prerequisiteSchema,
+  missingPrerequisiteSchema,
+  completed,
+  balanceAtLeast,
+  inGroup,
+  pointsRewardSchema,
+  tieredRewardDefinitionSchema,
+  tieredRewardReferenceSchema,
+  tierRewardSchema,
+  integrationRewardSchema,
+  rewardSchema,
+  rewardKey,
+  triggerSchema,
+  photoResultSchema,
+  textReviewInputSchema,
+  textResultSchema,
+  deferPolicy,
+  evaluatorProgressSchema,
+  decisionSchema,
+  reviewModeSchema,
+  storedReviewModeSchema,
+  rewardBundleSchema,
+  mediaUrlSchema,
+  questPresentationSchema,
+  questProfileSchema,
+  evaluatorProtocol,
+  evaluatorProtocolSchema,
+  questDescriptionSchema,
+  artifactSchema,
+  releaseSchema,
+  batchReleaseSchema,
+  questSettingsInputSchema,
+  storedQuestDescriptionSchema,
+  publishedReleaseSchema,
+  templateSchema,
+  quizAnswersSchema,
+  quizEvidenceSchema,
+  submissionEvidenceSchema,
+  submitSchema,
+  AttemptStatus,
+  attemptSchema,
+  eventSchema,
+  pickupSelectionSchema,
+  pickupAllocationSchema,
+  pickupPolicySchema,
+  pickupCatalogSchema,
+  pickupAvailabilitySchema,
+  configurePickupSchema,
+  entitlementRecoverySchema,
+  entitlementStateSchema,
+  entitlementSchema,
+  beginHandoverSchema,
+  confirmHandoverSchema,
+  entitlementCorrectionSchema,
+  completionRecordSchema,
+  questAvailabilitySchema,
+  questBudgetViewSchema,
+  memberProgressSchema,
+  snapshotSchema,
+  evidenceSchema,
+  errorSchema,
+  staffDecisionSchema,
+  stockSchema,
+  reservationSchema,
+  reviewListSchema,
+  memberListSchema,
+  reviewItemSchema,
+  reviewPageSchema,
+  memberPageSchema,
+  createStockItemSchema,
+  stockItemSchema,
+  contentPerformanceSnapshotSchema,
+  contentPerformanceQuerySchema,
+  contentPerformancePageSchema
+};