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

package/dist/chunk-YYD4QUBO.js

@@ -1,2348 +0,0 @@
-// src/accounts.ts
-import { z } from "zod";
-var authProviderSchema = z.enum(["google", "apple", "x", "discord"]);
-var accountConnectionSchema = z.object({
-  provider: authProviderSchema,
-  configured: z.boolean(),
-  status: z.enum(["disconnected", "connected", "reconnect"]),
-  subject: z.string().nullable(),
-  revision: z.number().int().nonnegative()
-});
-var discordMemberInputSchema = z.object({}).strict();
-var discordMessageInputSchema = z.object({
-  channelId: z.string().regex(/^[0-9]{1,20}$/),
-  messageId: z.string().regex(/^[0-9]{1,20}$/)
-}).strict();
-var discordMemberSchema = z.object({
-  userId: z.string().regex(/^[0-9]{1,20}$/).nullable().default(null),
-  nickname: z.string().nullable().default(null),
-  displayName: z.string().nullable().default(null),
-  boostingSince: z.string().datetime({ offset: true }).nullable().default(null),
-  roles: z.array(z.string().regex(/^[0-9]{1,20}$/)),
-  joinedAt: z.string().datetime({ offset: true }).nullable(),
-  pending: z.boolean()
-});
-
-// src/identifier.ts
-import { z as z2 } from "zod";
-var identifier = z2.string().min(1).max(100).regex(/^[a-zA-Z0-9_-]+$/);
-
-// src/pages.ts
-import { z as z3 } from "zod";
-var pageCursorSchema = z3.string().min(1).max(4096);
-var pageQuerySchema = z3.strictObject({
-  cursor: pageCursorSchema.optional()
-});
-
-// src/tracker-data.ts
-import { z as z4 } from "zod";
-var maxDepth = 16;
-var maxBytes = 32768;
-var trackerDataMaxBranches = 16;
-var trackerDataMaxEntries = 256;
-var scalar = z4.union([z4.string(), z4.number().finite(), z4.boolean(), z4.null()]);
-var size = z4.number().int().safe().nonnegative();
-var bound = z4.number().finite();
-var branches = () => z4.array(node).min(1).max(trackerDataMaxBranches);
-var node = z4.lazy(
-  () => z4.strictObject({
-    type: z4.enum([
-      "object",
-      "array",
-      "string",
-      "number",
-      "integer",
-      "boolean",
-      "null"
-    ]).optional(),
-    properties: z4.record(z4.string(), node).refine(
-      (properties) => Object.keys(properties).length <= trackerDataMaxEntries,
-      `An object schema lists at most ${trackerDataMaxEntries} properties`
-    ).optional(),
-    required: z4.array(z4.string()).max(trackerDataMaxEntries).optional(),
-    additionalProperties: z4.union([z4.boolean(), node]).optional(),
-    propertyNames: z4.strictObject({
-      type: z4.literal("string"),
-      enum: z4.array(z4.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: z4.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 = z4.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 = z4.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 = typeof reference === "object" ? reference.source : void 0;
-      const schema = source?.kind === "custom" ? source.data : void 0;
-      if (!schema) {
-        return page;
-      }
-      const issues = trackerDataIssues(
-        schema,
-        page.items.map((record) => record.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 z5 } from "zod";
-var timestamp = z5.number().int().safe().nonnegative().max(864e13);
-var count = z5.number().int().safe().nonnegative();
-var externalId = z5.string().min(1).max(256);
-var metric = count.nullable().default(null);
-var xTweetSchema = z5.looseObject({
-  id: externalId,
-  userId: externalId,
-  content: z5.string(),
-  createdAt: z5.iso.datetime({ offset: true }),
-  author: z5.looseObject({
-    id: externalId,
-    username: z5.string(),
-    name: z5.string(),
-    verified: z5.boolean().nullable().default(null)
-  }),
-  likeCount: metric,
-  replyCount: metric,
-  retweetCount: metric,
-  quoteCount: metric,
-  viewCount: metric,
-  bookmarkCount: metric,
-  isReply: z5.boolean(),
-  isRetweet: z5.boolean(),
-  isQuoteTweet: z5.boolean()
-});
-var xContentBodySchema = z5.strictObject({
-  version: z5.literal(1),
-  id: z5.string().min(1),
-  authorId: z5.string().min(1),
-  publishedAt: timestamp,
-  text: z5.string(),
-  isReply: z5.boolean(),
-  isRetweet: z5.boolean(),
-  isQuoteTweet: z5.boolean(),
-  media: z5.array(z5.strictObject({ type: z5.string(), url: z5.string() })).nullable(),
-  mentionedAuthorIds: z5.array(z5.string().min(1)).nullable(),
-  videoLengthSeconds: z5.number().nonnegative().nullable(),
-  references: z5.strictObject({
-    replyId: z5.string().nullable(),
-    replyAuthorId: z5.string().nullable(),
-    quoteId: z5.string().nullable(),
-    quoteAuthorId: z5.string().nullable(),
-    repostId: z5.string().nullable(),
-    repostAuthorId: z5.string().nullable()
-  })
-});
-var trackerContentQuerySchema = z5.strictObject({
-  id: externalId,
-  observation: z5.string().regex(/^observation_[a-f0-9]{64}$/)
-});
-var trackerContentReadSchema = trackerContentQuerySchema.extend({
-  member: identifier
-});
-var attributionContext = { member: identifier, capturedAt: timestamp };
-var trackerEvidenceSchema = z5.strictObject({
-  contentRevision: identifier,
-  observation: identifier
-});
-var trackerContentSchema = z5.strictObject({
-  tracker: identifier,
-  source: z5.literal("x"),
-  evidence: trackerEvidenceSchema,
-  content: xContentBodySchema,
-  observedAt: timestamp,
-  removed: z5.boolean(),
-  attribution: z5.discriminatedUnion("kind", [
-    z5.strictObject({
-      ...attributionContext,
-      kind: z5.literal("linked"),
-      account: z5.strictObject({
-        provider: z5.literal("x"),
-        issuer: z5.string().min(1),
-        subject: externalId,
-        revision: count,
-        linkedAt: timestamp.nullable()
-      })
-    }),
-    z5.strictObject({ ...attributionContext, kind: z5.literal("unlinked") }),
-    z5.strictObject({
-      ...attributionContext,
-      kind: z5.literal("different-author")
-    })
-  ])
-});
-var identityKindSchema = z5.enum(["wallet", "x", "discord", "member"]);
-var accountRoleSchema = z5.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 xSearchSourceSchema = z5.object({
-  kind: z5.literal("x-search"),
-  query: z5.string().trim().min(1).max(2e3)
-}).strict();
-var customSourceSchema = z5.object({
-  kind: z5.literal("custom"),
-  namespace: identifier,
-  /**
-   * The identity kinds a record's author and named accounts can be, attributed to members
-   * through verified links. Omitted when authors are opaque IDs, which no quest can pay.
-   */
-  identities: z5.array(identityKindSchema).min(1).max(4).refine(distinct, "List each identity kind once").optional(),
-  /** Roles of the named accounts records can carry besides their author, such as `recipient`. */
-  accounts: z5.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(),
-  /**
-   * How trackers published before identity kinds stored `identities: ["wallet"]`. Reads return
-   * those definitions as stored; write `identities` instead.
-   *
-   * @deprecated Use `identities: ["wallet"]`.
-   */
-  authors: z5.literal("wallet").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()
-}).strict().refine(
-  (source) => !(source.authors && source.identities),
-  "Use identities, not authors"
-).refine(
-  (source) => !source.accounts || source.identities,
-  "Named accounts need identities"
-);
-var trackerSourceSchema = z5.discriminatedUnion("kind", [
-  xSearchSourceSchema,
-  customSourceSchema
-]);
-function sourceIdentities(source) {
-  if (source.kind === "x-search") {
-    return ["x"];
-  }
-  return source.identities ?? (source.authors === "wallet" ? ["wallet"] : void 0);
-}
-var windowSchema = z5.object({ start: timestamp, end: timestamp.optional() }).strict().refine(
-  (w) => w.end === void 0 || w.end > w.start,
-  "End must follow start"
-);
-var trackerDefinitionSchema = z5.object({
-  key: identifier,
-  title: z5.string().trim().min(1).max(120),
-  source: trackerSourceSchema,
-  window: windowSchema,
-  refreshSeconds: z5.number().int().min(300).max(86400).default(21600),
-  maxPages: z5.number().int().min(1).max(1e3).default(60)
-}).strict();
-var trackerArtifactSchema = z5.union([
-  trackerDefinitionSchema,
-  z5.object({ code: z5.string().min(1).max(2e6) }).strict()
-]);
-var publishedTrackerSchema = z5.object({
-  id: identifier,
-  version: identifier,
-  definition: trackerDefinitionSchema,
-  publishedAt: timestamp,
-  actor: z5.string().nullable()
-});
-var trackerStatusSchema = z5.object({
-  published: publishedTrackerSchema,
-  paused: z5.boolean(),
-  state: z5.enum(["idle", "syncing", "error", "complete"]),
-  lastStartedAt: timestamp.nullable(),
-  lastCompletedAt: timestamp.nullable(),
-  nextSyncAt: timestamp.nullable(),
-  coverage: z5.enum(["unknown", "partial", "complete"]),
-  error: z5.string().nullable(),
-  records: count
-});
-var trackerControlSchema = z5.object({
-  actionId: identifier,
-  action: z5.enum(["pause", "resume", "refresh"])
-}).strict();
-var trackerAccountSchema = z5.strictObject({
-  kind: identityKindSchema.optional(),
-  id: externalId
-});
-var trackerRecordInputSchema = z5.object({
-  id: externalId,
-  occurredAt: timestamp,
-  observedAt: timestamp,
-  author: z5.object({
-    id: externalId,
-    verified: z5.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: z5.record(accountRoleSchema, trackerAccountSchema).refine(
-    (accounts) => Object.keys(accounts).length <= 10,
-    "At most 10 accounts"
-  ).optional(),
-  data: z5.record(z5.string(), z5.json()),
-  removed: z5.boolean().default(false)
-}).strict().refine(
-  (v) => new TextEncoder().encode(JSON.stringify(v.data)).byteLength <= 131072,
-  "Record exceeds 128 KB"
-);
-var trackerRecordSchema = trackerRecordInputSchema.safeExtend({
-  source: z5.string(),
-  firstSeenAt: timestamp,
-  /** Present only when includeEvidence is true; custom sources have no X evidence. */
-  evidence: trackerEvidenceSchema.nullable().optional()
-});
-var trackerIngestSchema = z5.object({
-  actionId: identifier,
-  records: z5.array(trackerRecordInputSchema).min(1).max(100)
-}).strict();
-var trackerIngestResultSchema = z5.object({
-  stored: count,
-  /** Tracker-trigger decisions this ingest caused. Absent from servers without tracker triggers. */
-  admissions: z5.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: z5.string().nullable(),
-  createdAt: timestamp,
-  updatedAt: timestamp,
-  /** Null for automatic decisions; the staff actor after a retry. */
-  actor: z5.string().nullable()
-};
-var trackerSkipCodes = [
-  /** The quest is paused or no longer active. */
-  "quest-paused",
-  /** The record occurred before the quest was published. */
-  "before-activation",
-  /** 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 X post 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. */
-  "unlinked-account",
-  /** More than one member has the beneficiary account. */
-  "ambiguous-account",
-  /** The attributed member has not joined the project. */
-  "not-joined",
-  /** The attributed member has not completed the quest's prerequisites. */
-  "prerequisites-incomplete"
-];
-var trackerOutcomeSchema = z5.discriminatedUnion("state", [
-  z5.strictObject({
-    ...trackerOutcomeFields,
-    state: z5.literal("admitted"),
-    code: z5.null(),
-    reason: z5.null(),
-    /** The attributed member. */
-    member: identifier,
-    /** The admitted attempt. Its evaluation, decision and rewards live on the attempt. */
-    attempt: identifier
-  }),
-  z5.strictObject({
-    ...trackerOutcomeFields,
-    state: z5.literal("skipped"),
-    /** Why the observation was skipped, as one of `trackerSkipCodes`. */
-    code: z5.string().min(1),
-    /** Why the observation was skipped, for people. */
-    reason: z5.string(),
-    /** The attributed member, when attribution got that far. */
-    member: identifier.nullable(),
-    attempt: identifier.nullable()
-  })
-]);
-var trackerOutcomeQuerySchema = z5.strictObject({
-  /** Quest key or ID. */
-  quest: identifier.optional(),
-  record: externalId.optional(),
-  member: identifier.optional(),
-  state: z5.enum(["admitted", "skipped"]).optional(),
-  /** Only skips with this code, such as `unlinked-account`. */
-  code: z5.string().min(1).max(100).optional(),
-  limit: z5.coerce.number().int().min(1).max(100).default(25),
-  /** Opaque cursor from `next`: older outcomes. */
-  before: z5.string().max(512).optional()
-});
-var trackerOutcomePageSchema = z5.strictObject({
-  /** Newest first. */
-  items: z5.array(trackerOutcomeSchema).max(100),
-  next: z5.string().nullable()
-});
-var trackerOutcomeRetrySchema = z5.strictObject({
-  actionId: identifier,
-  /** Quest key or ID. */
-  quest: identifier,
-  record: externalId,
-  observedAt: timestamp
-});
-var booleanQuery = z5.union([
-  z5.boolean(),
-  z5.enum(["true", "false"]).transform((v) => v === "true")
-]);
-var trackerQuerySchema = z5.object({
-  author: externalId.optional(),
-  member: identifier.optional(),
-  verified: booleanQuery.optional(),
-  since: z5.coerce.number().int().safe().nonnegative().optional(),
-  until: z5.coerce.number().int().safe().nonnegative().optional(),
-  removed: booleanQuery.default(false),
-  minLikes: z5.coerce.number().int().safe().nonnegative().optional(),
-  minViews: z5.coerce.number().int().safe().nonnegative().optional(),
-  limit: z5.coerce.number().int().min(1).max(100).default(25),
-  cursor: z5.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 = z5.object({
-  tracker: identifier,
-  items: z5.array(trackerRecordSchema),
-  nextCursor: z5.string().nullable(),
-  total: count,
-  status: trackerStatusSchema
-});
-var trackerSummarySchema = z5.object({
-  records: count,
-  authors: count,
-  metrics: z5.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 = z5.object({
-  query: xSearchSourceSchema.shape.query,
-  /** Start of the searched window. The window ends when the sample is fetched. */
-  since: timestamp
-}).strict();
-var trackerPreviewSchema = z5.object({
-  query: z5.string(),
-  since: timestamp,
-  fetchedAt: timestamp,
-  pages: count,
-  /** Every match in the sample, newest first, verified or not. */
-  posts: z5.array(xTweetSchema).max(trackerPreviewLimits.posts),
-  /** X had more matches than the sample holds. */
-  more: z5.boolean()
-});
-
-// src/content.ts
-import { z as z6 } from "zod";
-var timestamp2 = z6.number().int().safe().nonnegative().max(864e13);
-var contentPolicySchema = z6.strictObject({
-  tracker: identifier,
-  window: trackerDefinitionSchema.shape.window,
-  enrollment: z6.enum(["none", "required"]).default("none"),
-  posts: z6.enum(["after-enrollment", "since-start"]).default("after-enrollment"),
-  historical: z6.enum(["automatic", "claim", "staff"]).default("claim")
-});
-var admittedContentSchema = xContentBodySchema.extend({
-  tracker: identifier,
-  revision: identifier,
-  observation: identifier,
-  attribution: trackerContentSchema.shape.attribution.options[0],
-  enrolledAt: timestamp2.nullable(),
-  completionKey: z6.string().min(1).max(200)
-});
-var contentEnrollmentInputSchema = z6.strictObject({
-  actionId: identifier,
-  quest: identifier,
-  member: identifier
-});
-var contentEnrollmentSchema = z6.strictObject({
-  quest: identifier,
-  member: identifier,
-  enrolledAt: timestamp2
-});
-var contentReleaseInputSchema = contentEnrollmentInputSchema.extend({
-  content: z6.string().min(1).max(256)
-});
-var contentAdmissionSchema = z6.strictObject({
-  quest: identifier,
-  content: z6.string().min(1).max(256),
-  release: identifier,
-  state: z6.enum(["pending", "admitted", "excluded"]),
-  reason: z6.string().nullable(),
-  attempt: identifier.nullable()
-});
-var contentAdmissionQuerySchema = z6.strictObject({
-  quest: identifier,
-  member: identifier.optional(),
-  content: z6.string().min(1).max(256).optional(),
-  cursor: pageCursorSchema.optional()
-});
-var contentAdmissionPageSchema = z6.strictObject({
-  items: z6.array(contentAdmissionSchema),
-  nextCursor: pageCursorSchema.nullable()
-});
-var contentQualificationDecisionSchema = z6.strictObject({
-  kind: z6.enum(["accept", "reject", "review", "superseded"]),
-  reason: z6.string().nullable()
-});
-var contentQualificationQuerySchema = z6.strictObject({
-  quest: identifier,
-  member: identifier.optional(),
-  content: z6.string().min(1).max(256).optional(),
-  cursor: pageCursorSchema.optional()
-});
-var contentQualificationSchema = z6.strictObject({
-  quest: identifier,
-  content: z6.string(),
-  member: identifier,
-  release: identifier,
-  attempt: identifier,
-  revision: identifier,
-  observation: identifier,
-  current: z6.boolean(),
-  state: z6.enum([
-    "pending",
-    "qualified",
-    "unqualified",
-    "needs-review",
-    "failed",
-    "superseded",
-    "stale",
-    "blocked",
-    "unavailable"
-  ]),
-  reason: z6.string().nullable(),
-  reward: z6.strictObject({
-    attempt: identifier.nullable(),
-    completion: identifier.nullable(),
-    state: z6.enum(["unresolved", "awarded", "excluded"])
-  })
-});
-var contentQualificationPageSchema = z6.strictObject({
-  items: z6.array(contentQualificationSchema),
-  nextCursor: pageCursorSchema.nullable()
-});
-var contentMetricSchema = z6.enum([
-  "likes",
-  "replies",
-  "reposts",
-  "quotes",
-  "views",
-  "bookmarks"
-]);
-var contentMetricsSchema = z6.partialRecord(
-  contentMetricSchema,
-  z6.number().int().safe().nonnegative()
-);
-var contentPerformancePolicySchema = z6.strictObject({
-  metrics: z6.array(contentMetricSchema).min(1).max(6).refine(
-    (values) => new Set(values).size === values.length,
-    "Metrics must be unique"
-  ),
-  maxAgeMs: z6.number().int().positive().max(864e5).default(36e5)
-});
-
-// src/streaks.ts
-import { z as z7 } from "zod";
-var communityTimeZoneSchema = z7.string().min(1).max(100).refine((zone) => {
-  try {
-    if (/^[+-]/.test(zone)) {
-      return false;
-    }
-    new Intl.DateTimeFormat("en", { timeZone: zone });
-    return true;
-  } catch {
-    return false;
-  }
-}, "Use an IANA community timezone, such as Europe/Budapest");
-var streakPolicySchema = z7.object({
-  kind: z7.literal("streak"),
-  days: z7.number().int().min(1).max(3650),
-  timeZone: communityTimeZoneSchema
-}).strict();
-var streakProgressSchema = z7.object({
-  goal: z7.number().int().positive(),
-  current: z7.number().int().nonnegative(),
-  best: z7.number().int().nonnegative(),
-  today: z7.string(),
-  todayQualified: z7.boolean(),
-  timeZone: communityTimeZoneSchema,
-  nextBoundary: z7.number().int(),
-  pendingTimeZone: z7.object({
-    timeZone: communityTimeZoneSchema,
-    effectiveAt: z7.number().int()
-  }).nullable(),
-  days: z7.array(
-    z7.object({
-      day: z7.number().int(),
-      date: z7.string(),
-      timeZone: communityTimeZoneSchema,
-      occurredAt: z7.number().int()
-    })
-  ),
-  milestone: z7.discriminatedUnion("status", [
-    z7.object({ status: z7.literal("pending") }),
-    z7.object({
-      status: z7.literal("awarded"),
-      completion: z7.string(),
-      achievedAt: z7.number().int()
-    }),
-    z7.object({
-      status: z7.literal("budget-exhausted"),
-      budget: z7.string(),
-      achievedAt: z7.number().int()
-    })
-  ])
-});
-
-// src/tracker-triggers.ts
-import { z as z8 } from "zod";
-var timestamp3 = z8.number().int().safe().nonnegative().max(864e13);
-var count2 = z8.number().int().safe().nonnegative();
-var trackerTriggerModeSchema = z8.enum([
-  "new-record",
-  "new-observation",
-  "data-changed"
-]);
-function defaultTriggerMode(source) {
-  return source === "x-search" ? "new-record" : "new-observation";
-}
-var trackerBoundSchema = z8.union([
-  z8.number().finite(),
-  z8.strictObject({ setting: z8.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/) })
-]);
-var dataPath = z8.string().max(200).regex(
-  /^[^.\s]+(\.[^.\s]+)*$/,
-  "Use dot-separated keys, such as metrics.likes"
-);
-var trackerConditionSchema = z8.union([
-  z8.strictObject({
-    path: dataPath,
-    equals: z8.union([z8.string().max(1e3), z8.number().finite(), z8.boolean()])
-  }),
-  z8.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 = z8.union([
-  trackerConditionSchema,
-  z8.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 trackerTriggerPolicySchema = z8.strictObject({
-  /** The tracker's authoring key; publication binds it to the tracker's stable ID. */
-  tracker: identifier,
-  source: z8.enum(["x-search", "custom"]),
-  /** Which observations fire; absent means the source's default (`defaultTriggerMode`). */
-  on: trackerTriggerModeSchema.optional(),
-  where: trackerWhereSchema.optional(),
-  /**
-   * The record account the quest pays: `author`, `inReplyTo` for an X post, or a named account of
-   * a custom record. Relay attributes it through verified links; evaluators cannot redirect it.
-   * Releases published before account roles store `"replied-to"` for `inReplyTo`.
-   */
-  beneficiary: z8.union([accountRoleSchema, z8.literal("replied-to")])
-});
-function triggerMode(policy) {
-  return policy.on ?? defaultTriggerMode(policy.source);
-}
-function beneficiaryRole(policy) {
-  return policy.beneficiary === "replied-to" ? "inReplyTo" : policy.beneficiary;
-}
-var xLink = {
-  issuer: z8.string().min(1),
-  /** The account's stable user ID. */
-  subject: z8.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 = z8.strictObject({
-  member: identifier,
-  capturedAt: timestamp3,
-  account: z8.discriminatedUnion("provider", [
-    z8.strictObject({
-      provider: z8.literal("wallet"),
-      /** Canonical CAIP-10 account ID, as the record names it. */
-      id: z8.string().min(5).max(256),
-      /** The wallet link's revision. */
-      revision: count2,
-      /** When the member verified the wallet. */
-      linkedAt: timestamp3.nullable()
-    }),
-    z8.strictObject({ provider: z8.literal("x"), ...xLink }),
-    z8.strictObject({ provider: z8.literal("discord"), ...xLink }),
-    z8.strictObject({
-      provider: z8.literal("member"),
-      /** The member ID the record names. */
-      id: identifier
-    })
-  ])
-});
-var trackerTriggerRecordSchema = z8.strictObject({
-  id: z8.string().min(1).max(256),
-  source: z8.string(),
-  occurredAt: timestamp3,
-  observedAt: timestamp3,
-  firstSeenAt: timestamp3,
-  author: z8.strictObject({
-    id: z8.string().min(1).max(256),
-    verified: z8.boolean().nullable(),
-    kind: identityKindSchema.optional()
-  }).nullable(),
-  accounts: z8.record(accountRoleSchema, trackerAccountSchema).optional(),
-  data: z8.record(z8.string(), z8.json()),
-  removed: z8.boolean()
-});
-var trackerTriggerContextSchema = z8.strictObject({
-  /** 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. Releases published
-   * before account roles name `inReplyTo` `"replied-to"`, which their bundled evaluators expect.
-   */
-  beneficiary: z8.union([accountRoleSchema, z8.literal("replied-to")]),
-  record: trackerTriggerRecordSchema,
-  /** The captured X post of this observation; null for custom trackers. */
-  x: z8.strictObject({
-    evidence: trackerEvidenceSchema,
-    content: xContentBodySchema
-  }).nullable(),
-  attribution: trackerAttributionSchema
-});
-
-// src/observations.ts
-import { z as z9 } from "zod";
-var name = z9.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$/);
-var observationInputSchema = z9.object({
-  id: name,
-  source: name,
-  type: name,
-  member: identifier,
-  actor: z9.object({ provider: identifier, subject: z9.string().min(1).max(200) }).strict().optional(),
-  occurredAt: z9.number().int().nonnegative().max(864e13),
-  data: z9.record(z9.string(), z9.json())
-}).strict().refine(
-  (value) => JSON.stringify(value.data).length <= 32768,
-  "Observation data exceeds 32 KB"
-);
-var observationSchema = observationInputSchema.safeExtend({
-  receivedAt: z9.number().int().nonnegative()
-});
-var observationTriggerSchema = z9.object({ source: name, type: name }).strict();
-var completionPolicySchema = z9.discriminatedUnion("kind", [
-  streakPolicySchema,
-  z9.object({ kind: z9.literal("once") }).strict(),
-  z9.object({ kind: z9.literal("keyed") }).strict()
-]);
-var completionKeySchema = z9.string().min(1).max(500);
-var budgetSchema = z9.object({
-  id: name,
-  scope: z9.enum(["member", "project"]),
-  /**
-   * `"day"` buckets by UTC date and `"week"` by ISO week (UTC, weeks start on Monday), both of
-   * the attempt's eligibility time; `"lifetime"` never resets.
-   */
-  period: z9.enum(["lifetime", "day", "week"]),
-  limit: z9.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-  cost: z9.union([
-    z9.number().int().positive().max(Number.MAX_SAFE_INTEGER),
-    z9.object({ balance: name }).strict()
-  ])
-}).strict();
-var observationReceiptSchema = z9.object({
-  id: name,
-  source: name,
-  attempts: z9.array(z9.string()),
-  receivedAt: z9.number()
-});
-var discordReactionSchema = z9.object({
-  guildId: z9.string(),
-  channelId: z9.string(),
-  messageId: z9.string(),
-  userId: z9.string(),
-  messageAuthorId: z9.string().nullable().default(null),
-  actorRoles: z9.array(z9.string()).default([]),
-  emoji: z9.object({ id: z9.string().nullable(), name: z9.string() }),
-  messagePublishedAt: z9.number()
-}).strict();
-var discordMessageSchema = z9.object({
-  guildId: z9.string(),
-  channelId: z9.string(),
-  messageId: z9.string(),
-  userId: z9.string(),
-  content: z9.string().nullable(),
-  replyTo: z9.string().nullable(),
-  publishedAt: z9.number()
-}).strict();
-
-// src/integrations.ts
-import { z as z10 } from "zod";
-var integrationProviderSchema = z10.enum(["discord"]);
-var discordServerSchema = z10.object({
-  id: z10.string().regex(/^[0-9]{1,20}$/),
-  name: z10.string().min(1),
-  icon: z10.string().nullable()
-});
-var projectIntegrationSchema = z10.object({
-  provider: integrationProviderSchema,
-  configured: z10.boolean(),
-  status: z10.enum(["disconnected", "ready", "attention"]),
-  revision: z10.number().int().nonnegative(),
-  server: discordServerSchema.nullable(),
-  issue: z10.string().nullable(),
-  connectedAt: z10.number().default(0)
-});
-
-// src/submission-input.ts
-import { z as z11 } from "zod";
-var textOptionsSchema = z11.object({
-  required: z11.boolean().default(true),
-  minLength: z11.number().int().min(0).max(1e4).default(1),
-  maxLength: z11.number().int().min(1).max(1e4).default(1e4)
-}).strict().refine(
-  (v) => v.minLength <= v.maxLength,
-  "minLength must not exceed maxLength"
-);
-var hostSchema = z11.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 = z11.object({
-  required: z11.boolean().default(true),
-  allowedHosts: z11.array(hostSchema).min(1).max(100).optional()
-}).strict();
-var textEvidenceSchema = z11.object({ kind: z11.literal("text"), value: z11.string().max(1e4) }).strict();
-var urlEvidenceSchema = z11.object({ kind: z11.literal("url"), value: z11.string().max(2048) }).strict();
-var valueEvidenceSchema = z11.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 z12 } from "zod";
-var quizId = z12.string().regex(/^[a-zA-Z0-9_-]+$/).max(100);
-var quizChoiceSchema = z12.object({ id: quizId, label: z12.string().trim().min(1).max(500) }).strict();
-var quizQuestionSchema = z12.object({
-  id: quizId,
-  prompt: z12.string().trim().min(1).max(1e3),
-  choices: z12.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 = z12.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 = z12.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 z13 } from "zod";
-var channelSourceSchema = z13.object({
-  provider: z13.literal("discord"),
-  resource: z13.literal("channel"),
-  types: z13.array(z13.enum(["text", "announcement"])).min(1)
-}).strict();
-var resourceSourceSchema = z13.union([
-  z13.object({
-    provider: z13.literal("domino"),
-    resource: z13.literal("point-ledger")
-  }).strict(),
-  channelSourceSchema,
-  z13.object({
-    provider: z13.literal("discord"),
-    resource: z13.literal("role"),
-    assignable: z13.boolean().default(false)
-  }).strict()
-]);
-var resourceRequestSchema = z13.object({
-  source: resourceSourceSchema,
-  query: z13.string().max(100).optional(),
-  cursor: z13.string().regex(/^\d{1,6}$/).optional(),
-  ids: z13.array(z13.string().min(1).max(100)).max(50).optional()
-}).strict();
-var resourceOptionsSchema = z13.object({
-  revision: z13.number().int(),
-  options: z13.array(
-    z13.object({
-      id: z13.string(),
-      label: z13.string(),
-      description: z13.string().optional(),
-      group: z13.string().optional(),
-      disabledReason: z13.string().optional()
-    })
-  ),
-  cursor: z13.string().nullable()
-});
-
-// src/settings.ts
-import { z as z15 } from "zod";
-
-// src/setting-values.ts
-import { z as z14 } from "zod";
-var settingInstant = z14.iso.datetime({ offset: true }).transform((value) => new Date(value).toISOString());
-var settingResourceId = z14.union([
-  z14.literal(""),
-  z14.string().regex(/^\S{1,200}$/)
-]);
-
-// src/settings.ts
-var base = { label: z15.string().min(1), description: z15.string().optional() };
-var settingFieldSchema = z15.discriminatedUnion("kind", [
-  z15.object({ ...base, kind: z15.literal("point-ledger"), default: identifier }).strict(),
-  z15.object({ ...base, kind: z15.literal("datetime"), default: settingInstant }).strict(),
-  z15.object({
-    ...base,
-    kind: z15.literal("resource"),
-    default: settingResourceId,
-    source: resourceSourceSchema
-  }).strict(),
-  z15.object({ ...base, kind: z15.literal("quiz"), default: quizContentSchema }).strict(),
-  z15.object({
-    ...base,
-    kind: z15.literal("text"),
-    default: z15.string(),
-    minLength: z15.number().int().nonnegative(),
-    maxLength: z15.number().int().positive(),
-    multiline: z15.boolean()
-  }).strict(),
-  z15.object({
-    ...base,
-    kind: z15.literal("integer"),
-    default: z15.number().int(),
-    min: z15.number().int(),
-    max: z15.number().int()
-  }).strict(),
-  z15.object({ ...base, kind: z15.literal("boolean"), default: z15.boolean() }).strict(),
-  z15.object({
-    ...base,
-    kind: z15.literal("choice"),
-    default: z15.string(),
-    options: z15.array(z15.string().min(1)).min(1)
-  }).strict()
-]);
-var settingsFieldsSchema = z15.record(
-  z15.string().regex(/^[a-zA-Z][a-zA-Z0-9_]*$/),
-  settingFieldSchema
-);
-var settingsValuesSchema = z15.record(
-  z15.string(),
-  z15.union([z15.string(), z15.number().finite(), z15.boolean(), quizContentSchema])
-);
-function parseSettings(fields, input) {
-  const shape = {};
-  for (const [key, field] of Object.entries(fields)) {
-    switch (field.kind) {
-      case "point-ledger":
-        shape[key] = identifier.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] = z15.string().min(field.minLength).max(field.maxLength).default(field.default);
-        break;
-      case "integer":
-        shape[key] = z15.number().int().min(field.min).max(field.max).default(field.default);
-        break;
-      case "boolean":
-        shape[key] = z15.boolean().default(field.default);
-        break;
-      case "choice":
-        shape[key] = z15.enum(field.options).default(field.default);
-        break;
-    }
-  }
-  return settingsValuesSchema.parse(z15.object(shape).strict().parse(input));
-}
-function missingResourceSettings(fields, values) {
-  return Object.entries(fields).filter(([key, field]) => field.kind === "resource" && !values[key]).map(([key]) => key);
-}
-function compatibleSettingKinds(previous, next) {
-  return previous.kind === next.kind || previous.kind === "text" && (next.kind === "resource" || next.kind === "datetime" || next.kind === "point-ledger");
-}
-
-// src/schema.ts
-import { z as z16 } from "zod";
-var pointsRewardSchema = z16.object({
-  kind: z16.literal("points").default("points"),
-  balance: identifier,
-  amount: z16.number().int().min(0).max(1e4)
-}).strict();
-var tieredRewardDefinitionSchema = z16.object({
-  id: identifier,
-  title: z16.string().min(1).max(120),
-  tiers: z16.array(
-    z16.object({ id: identifier, title: z16.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: z16.object({ kind: z16.literal("untracked") }).strict(),
-  fulfillment: z16.object({ kind: z16.literal("staff-handover") }).strict()
-}).strict();
-var tieredRewardReferenceSchema = z16.object({
-  id: identifier,
-  key: identifier.nullable()
-});
-var tierRewardSchema = z16.object({
-  kind: z16.literal("tier"),
-  reward: tieredRewardDefinitionSchema,
-  tier: identifier
-}).strict().refine(
-  (value) => value.reward.tiers.some((t) => t.id === value.tier),
-  "Unknown reward tier"
-);
-var integrationRewardSchema = z16.object({
-  kind: z16.literal("integration"),
-  provider: z16.literal("discord"),
-  action: z16.literal("grant-role"),
-  roleId: z16.string().regex(/^[0-9]{1,20}$/)
-}).strict();
-var rewardSchema = z16.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 = z16.union([
-  z16.object({
-    kind: z16.literal("manual"),
-    input: z16.literal("text"),
-    constraints: textOptionsSchema,
-    actor: z16.enum(["member", "staff"]).optional()
-  }).strict(),
-  z16.object({
-    kind: z16.literal("manual"),
-    input: z16.literal("url"),
-    constraints: urlOptionsSchema,
-    actor: z16.enum(["member", "staff"]).optional()
-  }).strict(),
-  z16.object({
-    kind: z16.literal("manual"),
-    input: z16.enum(["photo", "quiz", "none"]),
-    actor: z16.enum(["member", "staff"]).optional()
-  }).strict(),
-  z16.object({
-    kind: z16.literal("automatic"),
-    observation: observationTriggerSchema.optional(),
-    content: contentPolicySchema.optional(),
-    tracker: trackerTriggerPolicySchema.optional()
-  }).strict().refine(
-    (value) => [value.observation, value.content, value.tracker].filter(Boolean).length <= 1,
-    "Choose one automatic trigger source"
-  )
-]);
-var prerequisiteSchema = z16.object({ quest: identifier });
-var photoResultSchema = z16.object({
-  kind: z16.enum(["pass", "fail", "unclear"]),
-  reason: z16.string().min(1).max(2e3)
-}).strict();
-var textReviewInputSchema = z16.object({
-  text: z16.string().min(1).max(16e3).refine((value) => value.trim().length > 0, "Text must not be blank"),
-  criteria: z16.string().trim().min(1).max(2e3)
-}).strict();
-var textResultSchema = photoResultSchema;
-var decisionSchema = z16.discriminatedUnion("kind", [
-  z16.object({
-    kind: z16.literal("accept"),
-    rewards: z16.array(rewardSchema).max(10),
-    completionKey: completionKeySchema.optional()
-  }).strict(),
-  z16.object({
-    kind: z16.literal("reject"),
-    reason: z16.string().min(1).max(2e3),
-    /** The evaluator asked for human review, but review is off for the quest, so this is a reject. */
-    requestedReview: z16.literal(true).optional()
-  }).strict(),
-  z16.object({
-    kind: z16.literal("review"),
-    reason: z16.string().min(1).max(2e3),
-    rewards: z16.array(rewardSchema).max(10).optional(),
-    completionKey: completionKeySchema.optional()
-  }).strict()
-]);
-var reviewModeSchema = z16.enum(["workers-ai"]);
-var storedReviewModeSchema = z16.enum([
-  "fixture-pass",
-  "fixture-fail",
-  "fixture-unclear",
-  "fixture-error",
-  "workers-ai"
-]);
-var rewardBundleSchema = z16.array(rewardSchema).max(10).refine(
-  (rewards) => new Set(rewards.map(rewardKey)).size === rewards.length,
-  "Use one entry per balance or shared reward"
-);
-var mediaUrlSchema = z16.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 = z16.object({
-  quiz: quizQuestionsSchema.optional(),
-  instructions: z16.string().max(4e3).optional(),
-  video: z16.object({
-    url: mediaUrlSchema,
-    poster: mediaUrlSchema.optional(),
-    captions: z16.object({
-      url: mediaUrlSchema,
-      language: z16.string().min(2).max(20),
-      label: z16.string().min(1).max(80)
-    }).strict().optional()
-  }).strict().optional()
-}).strict();
-var questProfileSchema = z16.object({ visible: z16.boolean() }).strict();
-var questDescriptionSchema = z16.object({
-  quest: identifier,
-  runtimeVersion: z16.union([z16.literal(1), z16.literal(2)]).default(1),
-  title: z16.string().min(1).max(120),
-  presentation: questPresentationSchema.default({}),
-  integrations: z16.array(integrationProviderSchema).max(10).default([]),
-  fields: settingsFieldsSchema,
-  values: settingsValuesSchema,
-  rewards: rewardBundleSchema,
-  humanReview: z16.boolean(),
-  trigger: triggerSchema,
-  performance: contentPerformancePolicySchema.optional(),
-  requires: z16.array(prerequisiteSchema).max(30).default([]),
-  completion: completionPolicySchema,
-  visibility: z16.enum(["visible", "hidden"]).default("visible"),
-  /**
-   * Whether completions show on participant profiles (`/v1/profiles/:id/completions`). Absent
-   * is hidden. Optional, not defaulted: releases carry the key only when the author sets it, so
-   * clients and pods that predate it (strict release schemas) still read every other release.
-   */
-  profile: questProfileSchema.optional(),
-  budgets: z16.array(budgetSchema).max(20).default([])
-}).strict();
-var artifactSchema = z16.object({ code: z16.string().min(1).max(1e6) }).strict();
-var releaseSchema = artifactSchema.extend({
-  settings: settingsValuesSchema,
-  provider: reviewModeSchema,
-  expectedRelease: identifier.nullable().optional(),
-  settingRenames: z16.record(z16.string(), z16.string()).optional()
-}).strict();
-var batchReleaseSchema = z16.object({ releases: z16.array(releaseSchema).min(1).max(50) }).strict();
-var questSettingsInputSchema = z16.object({
-  quest: identifier,
-  expectedRelease: identifier,
-  set: settingsValuesSchema,
-  reset: z16.array(z16.string())
-}).strict();
-var storedReleaseSchema = questDescriptionSchema.extend({
-  key: identifier.optional(),
-  code: z16.string(),
-  provider: storedReviewModeSchema,
-  id: identifier,
-  createdAt: z16.number(),
-  legacy: z16.boolean().default(false),
-  origin: z16.object({ typeVersion: identifier }).strict().optional(),
-  lifecycle: z16.enum(["active", "paused", "archived"]).default("active"),
-  configuration: z16.object({
-    defaults: settingsValuesSchema,
-    overrides: settingsValuesSchema,
-    preserved: z16.array(z16.string())
-  }).strict().optional()
-});
-var legacyReleaseSchema = z16.object({
-  quest: identifier,
-  title: z16.string(),
-  criteria: z16.string(),
-  humanReview: z16.boolean(),
-  rewards: rewardBundleSchema,
-  code: z16.string(),
-  provider: storedReviewModeSchema,
-  id: identifier,
-  createdAt: z16.number()
-}).transform((r) => {
-  const { criteria, ...stored } = r;
-  return storedReleaseSchema.parse({
-    ...stored,
-    fields: {},
-    values: { criteria, humanReview: r.humanReview },
-    trigger: { kind: "manual", input: "photo" },
-    completion: { kind: "once" },
-    legacy: true
-  });
-});
-var publishedReleaseSchema = z16.union([
-  storedReleaseSchema,
-  legacyReleaseSchema
-]);
-var templateSchema = z16.object({
-  code: z16.string(),
-  definition: questDescriptionSchema
-});
-var quizAnswersSchema = z16.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 = z16.object({
-  kind: z16.literal("quiz"),
-  release: identifier.optional(),
-  answers: quizAnswersSchema
-}).strict();
-var submissionEvidenceSchema = z16.union([
-  quizEvidenceSchema,
-  textEvidenceSchema,
-  urlEvidenceSchema
-]);
-var submitSchema = z16.object({
-  actionId: identifier,
-  quest: identifier,
-  member: identifier,
-  evidence: identifier.optional(),
-  input: submissionEvidenceSchema.optional(),
-  release: identifier.optional(),
-  faultAfterReview: z16.boolean().optional()
-}).strict();
-var attemptSchema = z16.object({
-  id: identifier,
-  release: identifier,
-  quest: identifier,
-  member: identifier,
-  evidence: identifier.nullable(),
-  input: submissionEvidenceSchema.optional(),
-  status: z16.enum([
-    "queued",
-    "evaluating",
-    "accepted",
-    "progressed",
-    "rejected",
-    "needs-review",
-    "failed"
-  ]),
-  reason: z16.string().nullable(),
-  retries: z16.number(),
-  generation: z16.number(),
-  completion: z16.string().nullable(),
-  reviewRewards: rewardBundleSchema.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: z16.boolean().default(false),
-  createdAt: z16.number()
-});
-var eventSchema = z16.object({
-  id: z16.number(),
-  attempt: z16.string().nullable(),
-  kind: z16.string(),
-  detail: z16.string(),
-  actor: z16.string().nullable().default(null),
-  at: z16.number()
-});
-var pickupSelectionSchema = z16.object({
-  item: identifier,
-  revision: z16.number().int().nonnegative()
-}).strict();
-var pickupAllocationSchema = z16.object({
-  item: identifier,
-  label: z16.string().min(1).max(80)
-}).strict();
-var pickupPolicySchema = z16.discriminatedUnion("kind", [
-  z16.object({ kind: z16.literal("untracked") }).strict(),
-  z16.object({
-    kind: z16.literal("at-pickup"),
-    tiers: z16.array(
-      z16.object({
-        tier: identifier,
-        variants: z16.array(pickupAllocationSchema).min(1).max(100)
-      }).strict()
-    ).min(1).max(100)
-  }).strict()
-]);
-var pickupCatalogSchema = z16.object({
-  reward: tieredRewardDefinitionSchema,
-  revision: z16.number().int().nonnegative(),
-  policy: pickupPolicySchema
-});
-var pickupAvailabilitySchema = z16.discriminatedUnion("kind", [
-  z16.object({ kind: z16.literal("untracked") }).strict(),
-  z16.object({
-    kind: z16.literal("at-pickup"),
-    revision: z16.number().int().nonnegative(),
-    variants: z16.array(
-      pickupAllocationSchema.extend({
-        available: z16.number().int().nonnegative()
-      })
-    )
-  }).strict()
-]);
-var configurePickupSchema = z16.object({
-  reward: identifier,
-  revision: z16.number().int().nonnegative(),
-  actionId: identifier,
-  policy: z16.discriminatedUnion("kind", [
-    z16.object({ kind: z16.literal("untracked") }).strict(),
-    z16.object({
-      kind: z16.literal("at-pickup"),
-      tiers: z16.array(
-        z16.object({
-          tier: identifier,
-          variants: z16.array(
-            pickupAllocationSchema.extend({
-              item: identifier.optional()
-            })
-          ).min(1).max(100)
-        }).strict()
-      ).min(1).max(100)
-    }).strict()
-  ])
-}).strict();
-var entitlementBase = {
-  id: identifier,
-  member: identifier,
-  reward: tieredRewardDefinitionSchema,
-  earnedTier: identifier,
-  tier: identifier,
-  revision: z16.number().int().positive()
-};
-var entitlementSchema = z16.discriminatedUnion("status", [
-  z16.object({ ...entitlementBase, status: z16.literal("available") }).strict(),
-  z16.object({
-    ...entitlementBase,
-    status: z16.literal("handing-over"),
-    handover: identifier,
-    startedAt: z16.number(),
-    allocation: pickupAllocationSchema.optional()
-  }).strict(),
-  z16.object({
-    ...entitlementBase,
-    status: z16.literal("collected"),
-    handover: identifier,
-    startedAt: z16.number(),
-    allocation: pickupAllocationSchema.optional(),
-    collectedAt: z16.number()
-  }).strict()
-]);
-var beginHandoverSchema = z16.object({
-  actionId: identifier,
-  revision: z16.number().int().positive(),
-  selection: pickupSelectionSchema.optional()
-}).strict();
-var confirmHandoverSchema = z16.object({ actionId: identifier, handover: identifier }).strict();
-var completionRecordSchema = z16.object({
-  key: z16.string().default("once"),
-  id: identifier,
-  quest: identifier,
-  member: identifier
-});
-var questAvailabilitySchema = z16.discriminatedUnion("kind", [
-  z16.object({
-    kind: z16.literal("available"),
-    input: z16.enum(["photo", "quiz", "none", "text", "url"])
-  }).strict(),
-  z16.object({ kind: z16.literal("completed") }).strict(),
-  z16.object({
-    kind: z16.literal("locked"),
-    missing: z16.array(z16.object({ quest: identifier, title: z16.string() })).min(1)
-  }).strict(),
-  z16.object({ kind: z16.literal("staff-required") }).strict(),
-  z16.object({
-    kind: z16.literal("automatic"),
-    observation: observationTriggerSchema.optional()
-  }).strict(),
-  z16.object({ kind: z16.literal("checking"), attempt: identifier }).strict(),
-  z16.object({ kind: z16.literal("needs-review"), attempt: identifier }).strict(),
-  z16.object({ kind: z16.literal("retryable"), attempt: identifier }).strict()
-]);
-var memberProgressSchema = z16.object({
-  member: identifier,
-  quests: z16.array(
-    z16.object({
-      quest: identifier,
-      key: identifier.optional(),
-      release: identifier.optional(),
-      title: z16.string(),
-      presentation: questPresentationSchema.default({}),
-      connections: z16.array(authProviderSchema).default([]),
-      trigger: triggerSchema,
-      availability: questAvailabilitySchema,
-      completed: z16.boolean(),
-      completion: completionPolicySchema.default({ kind: "once" }),
-      streak: streakProgressSchema.nullable().optional(),
-      completionCount: z16.number().int().nonnegative().default(0),
-      visibility: z16.enum(["visible", "hidden"]).default("visible"),
-      missing: z16.array(z16.object({ quest: identifier, title: z16.string() })),
-      attempt: attemptSchema.nullable()
-    })
-  ),
-  entitlements: z16.array(entitlementSchema)
-});
-var snapshotSchema = z16.object({
-  releases: z16.array(publishedReleaseSchema),
-  completions: z16.array(completionRecordSchema),
-  entitlements: z16.array(entitlementSchema),
-  attempts: z16.array(attemptSchema),
-  balances: z16.array(
-    z16.object({
-      member: z16.string(),
-      balance: z16.string(),
-      earned: z16.number(),
-      held: z16.number(),
-      available: z16.number()
-    })
-  ),
-  events: z16.array(eventSchema)
-});
-var evidenceSchema = z16.object({
-  id: identifier,
-  member: identifier,
-  type: z16.enum(["image/jpeg", "image/png"]),
-  size: z16.number()
-});
-var errorSchema = z16.object({
-  error: z16.string(),
-  code: z16.string().optional(),
-  missing: z16.array(z16.object({ quest: identifier, title: z16.string() })).optional()
-});
-var staffDecisionSchema = z16.object({
-  actionId: identifier,
-  generation: z16.number().int().nonnegative(),
-  decision: z16.enum(["accept", "reject"]),
-  reason: z16.string().trim().min(1).max(2e3)
-}).strict();
-var stockSchema = z16.object({ item: identifier, quantity: z16.number().int().min(0).max(1e4) }).strict();
-var reservationSchema = z16.object({
-  actionId: identifier,
-  member: identifier,
-  item: identifier,
-  balance: identifier,
-  price: z16.number().int().positive().max(1e4)
-}).strict();
-var pageOptions = {
-  limit: z16.number().int().min(1).max(100).default(25),
-  cursor: z16.string().min(1).max(4096).optional()
-};
-var reviewListSchema = z16.object({
-  ...pageOptions,
-  member: identifier.optional(),
-  quest: identifier.optional()
-}).strict();
-var memberListSchema = z16.object({
-  ...pageOptions,
-  prefix: identifier.optional()
-}).strict();
-var reviewItemSchema = z16.object({
-  attempt: attemptSchema,
-  title: z16.string(),
-  checks: z16.array(
-    z16.object({ criteria: z16.string(), result: photoResultSchema })
-  )
-});
-var reviewPageSchema = z16.object({
-  items: z16.array(reviewItemSchema).max(100),
-  nextCursor: z16.string().nullable()
-});
-var memberPageSchema = z16.object({
-  items: z16.array(z16.object({ member: identifier })).max(100),
-  nextCursor: z16.string().nullable()
-});
-var createStockItemSchema = z16.object({ actionId: identifier, name: z16.string().trim().min(1).max(80) }).strict();
-var stockItemSchema = z16.object({ id: identifier, name: z16.string() });
-var contentPerformanceSnapshotSchema = z16.strictObject({
-  contentAttempt: identifier,
-  observation: identifier,
-  observedAt: z16.number().int().safe().nonnegative(),
-  metrics: contentMetricsSchema,
-  rewards: rewardBundleSchema
-});
-var contentPerformanceQuerySchema = contentQualificationQuerySchema.extend({
-  content: z16.string().min(1).max(256)
-});
-var contentPerformancePageSchema = z16.strictObject({
-  current: z16.strictObject({
-    state: z16.enum([
-      "content-pending",
-      "content-unqualified",
-      "waiting",
-      "pending",
-      "qualified",
-      "unqualified",
-      "needs-review",
-      "failed",
-      "superseded"
-    ]),
-    reason: z16.string().nullable(),
-    contentAttempt: identifier,
-    attempt: identifier.nullable(),
-    reward: contentQualificationSchema.shape.reward
-  }),
-  items: z16.array(
-    z16.strictObject({
-      attempt: identifier,
-      contentAttempt: identifier,
-      observation: identifier,
-      observedAt: z16.number(),
-      metrics: contentMetricsSchema,
-      state: z16.enum([
-        "pending",
-        "qualified",
-        "unqualified",
-        "needs-review",
-        "failed",
-        "superseded"
-      ]),
-      reason: z16.string().nullable()
-    })
-  ),
-  nextCursor: pageCursorSchema.nullable()
-});
-
-export {
-  authProviderSchema,
-  accountConnectionSchema,
-  discordMemberInputSchema,
-  discordMessageInputSchema,
-  discordMemberSchema,
-  identifier,
-  pageCursorSchema,
-  pageQuerySchema,
-  trackerDataMaxBranches,
-  trackerDataMaxEntries,
-  trackerDataSchemaSchema,
-  trackerDataSchema,
-  trackerDataRecordSteps,
-  trackerDataBatchSteps,
-  trackerDataIssue,
-  trackerDataIssues,
-  trackerDataPathTypes,
-  schemaCheckedReader,
-  whereSchemaIssue,
-  xTweetSchema,
-  xContentBodySchema,
-  trackerContentQuerySchema,
-  trackerContentReadSchema,
-  trackerEvidenceSchema,
-  trackerContentSchema,
-  identityKindSchema,
-  accountRoleSchema,
-  xAccountRoles,
-  xSearchSourceSchema,
-  customSourceSchema,
-  trackerSourceSchema,
-  sourceIdentities,
-  trackerDefinitionSchema,
-  trackerArtifactSchema,
-  publishedTrackerSchema,
-  trackerStatusSchema,
-  trackerControlSchema,
-  trackerAccountSchema,
-  trackerRecordInputSchema,
-  trackerRecordSchema,
-  trackerIngestSchema,
-  trackerIngestResultSchema,
-  trackerSkipCodes,
-  trackerOutcomeSchema,
-  trackerOutcomeQuerySchema,
-  trackerOutcomePageSchema,
-  trackerOutcomeRetrySchema,
-  trackerQuerySchema,
-  trackerPageSchema,
-  trackerSummarySchema,
-  trackerPreviewLimits,
-  trackerPreviewInputSchema,
-  trackerPreviewSchema,
-  contentPolicySchema,
-  admittedContentSchema,
-  contentEnrollmentInputSchema,
-  contentEnrollmentSchema,
-  contentReleaseInputSchema,
-  contentAdmissionSchema,
-  contentAdmissionQuerySchema,
-  contentAdmissionPageSchema,
-  contentQualificationDecisionSchema,
-  contentQualificationQuerySchema,
-  contentQualificationSchema,
-  contentQualificationPageSchema,
-  contentMetricSchema,
-  contentMetricsSchema,
-  contentPerformancePolicySchema,
-  communityTimeZoneSchema,
-  streakPolicySchema,
-  streakProgressSchema,
-  trackerTriggerModeSchema,
-  defaultTriggerMode,
-  trackerBoundSchema,
-  trackerConditionSchema,
-  trackerWhereSchema,
-  whereConditions,
-  whereSettings,
-  trackerTriggerPolicySchema,
-  triggerMode,
-  beneficiaryRole,
-  trackerAttributionSchema,
-  trackerTriggerRecordSchema,
-  trackerTriggerContextSchema,
-  observationInputSchema,
-  observationSchema,
-  observationTriggerSchema,
-  completionPolicySchema,
-  completionKeySchema,
-  budgetSchema,
-  observationReceiptSchema,
-  discordReactionSchema,
-  discordMessageSchema,
-  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,
-  pointsRewardSchema,
-  tieredRewardDefinitionSchema,
-  tieredRewardReferenceSchema,
-  tierRewardSchema,
-  integrationRewardSchema,
-  rewardSchema,
-  rewardKey,
-  triggerSchema,
-  prerequisiteSchema,
-  photoResultSchema,
-  textReviewInputSchema,
-  textResultSchema,
-  decisionSchema,
-  reviewModeSchema,
-  storedReviewModeSchema,
-  rewardBundleSchema,
-  mediaUrlSchema,
-  questPresentationSchema,
-  questProfileSchema,
-  questDescriptionSchema,
-  artifactSchema,
-  releaseSchema,
-  batchReleaseSchema,
-  questSettingsInputSchema,
-  publishedReleaseSchema,
-  templateSchema,
-  quizAnswersSchema,
-  quizEvidenceSchema,
-  submissionEvidenceSchema,
-  submitSchema,
-  attemptSchema,
-  eventSchema,
-  pickupSelectionSchema,
-  pickupAllocationSchema,
-  pickupPolicySchema,
-  pickupCatalogSchema,
-  pickupAvailabilitySchema,
-  configurePickupSchema,
-  entitlementSchema,
-  beginHandoverSchema,
-  confirmHandoverSchema,
-  completionRecordSchema,
-  questAvailabilitySchema,
-  memberProgressSchema,
-  snapshotSchema,
-  evidenceSchema,
-  errorSchema,
-  staffDecisionSchema,
-  stockSchema,
-  reservationSchema,
-  reviewListSchema,
-  memberListSchema,
-  reviewItemSchema,
-  reviewPageSchema,
-  memberPageSchema,
-  createStockItemSchema,
-  stockItemSchema,
-  contentPerformanceSnapshotSchema,
-  contentPerformanceQuerySchema,
-  contentPerformancePageSchema
-};