@plasius/schema 1.2.18 → 1.3.1

package/dist/index.js

@@ -1,511 +1,57 @@
-// src/field.builder.ts
-function mergeValidatorResult(previousResult, nextValid) {
-  if (previousResult !== true) {
-    return previousResult;
-  }
-  return nextValid;
-}
-var FieldBuilder = class _FieldBuilder {
-  constructor(type, options = {}) {
-    this.type = type;
-    this._shape = options.shape;
-    this.itemType = options.itemType;
-    this.refType = options.refType;
-  }
-  type;
-  _type;
-  _storageType;
-  isSystem = false;
-  isImmutable = false;
-  isRequired = true;
-  _validator;
-  _description = "";
-  _version = "1.0.0";
-  _default;
-  _upgrade;
-  _shape;
-  itemType;
-  refType;
-  _pii = {
-    classification: "none",
-    action: "none",
-    logHandling: "plain",
-    purpose: "an ordinary value"
-  };
-  _exposure = "public";
-  enumValues;
-  immutable() {
-    this.isImmutable = true;
-    return this;
-  }
-  system() {
-    this.isSystem = true;
-    return this;
-  }
-  exposure(exposure) {
-    this._exposure = exposure;
-    return this;
-  }
-  internal() {
-    return this.exposure("internal");
-  }
-  public() {
-    return this.exposure("public");
-  }
-  required() {
-    this.isRequired = true;
-    return this;
-  }
-  optional() {
-    this.isRequired = false;
-    return this;
-  }
-  validator(fn) {
-    this._validator = fn;
-    return this;
-  }
-  description(desc) {
-    this._description = desc;
-    return this;
-  }
-  default(value) {
-    this._default = value;
-    this.isRequired = false;
-    return this;
-  }
-  /**
-   * Configure an upgrader used when validating older entities against a newer schema.
-   * The upgrader receives the current field value and version context, and should
-   * return { ok: true, value } with the upgraded value, or { ok: false, error }.
-   */
-  upgrade(fn) {
-    this._upgrade = fn;
-    return this;
-  }
-  getDefault() {
-    const v = this._default;
-    return typeof v === "function" ? v() : v;
-  }
-  version(ver) {
-    this._version = ver;
-    return this;
-  }
-  /// PID informs the schema PII handling of the manner in
-  /// which to handle data relating to this field.
-  PID(pii) {
-    this._pii = pii;
-    return this;
-  }
-  min(min) {
-    if (this.type === "number") {
-      const prevValidator = this._validator;
-      this._validator = (value) => {
-        const valid = typeof value === "number" && value >= min;
-        return prevValidator ? mergeValidatorResult(prevValidator(value), valid) : valid;
-      };
-    } else if (this.type === "string") {
-      const prevValidator = this._validator;
-      this._validator = (value) => {
-        const valid = typeof value === "string" && value.length >= min;
-        return prevValidator ? mergeValidatorResult(prevValidator(value), valid) : valid;
-      };
-    } else if (this.type === "array") {
-      const prevValidator = this._validator;
-      this._validator = (value) => {
-        const valid = Array.isArray(value) && value.length >= min;
-        return prevValidator ? mergeValidatorResult(prevValidator(value), valid) : valid;
-      };
-    } else {
-      throw new Error(
-        "Min is only supported on number, string, or array fields."
-      );
-    }
-    return this;
-  }
-  max(max) {
-    if (this.type === "number") {
-      const prevValidator = this._validator;
-      this._validator = (value) => {
-        const valid = typeof value === "number" && value <= max;
-        return prevValidator ? mergeValidatorResult(prevValidator(value), valid) : valid;
-      };
-    } else if (this.type === "string") {
-      const prevValidator = this._validator;
-      this._validator = (value) => {
-        const valid = typeof value === "string" && value.length <= max;
-        return prevValidator ? mergeValidatorResult(prevValidator(value), valid) : valid;
-      };
-    } else if (this.type === "array") {
-      const prevValidator = this._validator;
-      this._validator = (value) => {
-        const valid = Array.isArray(value) && value.length <= max;
-        return prevValidator ? mergeValidatorResult(prevValidator(value), valid) : valid;
-      };
-    } else {
-      throw new Error(
-        "Max is only supported on number, string, or array fields."
-      );
-    }
-    return this;
-  }
-  pattern(regex) {
-    if (this.type !== "string") {
-      throw new Error("Pattern is only supported on string fields.");
-    }
-    const prevValidator = this._validator;
-    this._validator = (value) => {
-      const valid = typeof value === "string" && regex.test(value);
-      return prevValidator ? mergeValidatorResult(prevValidator(value), valid) : valid;
-    };
-    return this;
-  }
-  enum(values) {
-    if (this.type !== "string" && this.type !== "number" && !(this.type === "array" && (this.itemType?.type === "string" || this.itemType?.type === "number"))) {
-      throw new Error(
-        "Enums are only supported on string or number fields or arrays of strings or numbers."
-      );
-    }
-    this.enumValues = values;
-    return this;
-  }
-  /**
-   * Create a shallow clone with a different external type parameter.
-   * Note: shape and itemType are passed by reference (shallow). If you need
-   * deep isolation of nested FieldBuilders, clone them explicitly.
-   */
-  as() {
-    const clone = new _FieldBuilder(this.type, {
-      shape: this._shape,
-      itemType: this.itemType,
-      refType: this.refType
-    });
-    clone.enumValues = this.enumValues;
-    clone.isImmutable = this.isImmutable;
-    clone.isSystem = this.isSystem;
-    clone.isRequired = this.isRequired;
-    clone._description = this._description;
-    clone._version = this._version;
-    clone._pii = this._pii;
-    clone._exposure = this._exposure;
-    clone._validator = this._validator;
-    clone._default = this._default;
-    clone._upgrade = this._upgrade;
-    return clone;
-  }
-};
-
-// src/validation/email.RFC5322.ts
-var validateEmail = (value) => {
-  if (typeof value !== "string") return false;
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  return emailRegex.test(value);
-};
-
-// src/validation/phone.E.164.ts
-var validatePhone = (value) => {
-  if (typeof value !== "string") return false;
-  const phoneRegex = /^\+[1-9]\d{1,14}$/;
-  return phoneRegex.test(value);
-};
-
-// src/validation/url.WHATWG.ts
-var validateUrl = (value) => {
-  if (typeof value !== "string") return false;
-  try {
-    const url = new URL(value);
-    if (url.protocol !== "http:" && url.protocol !== "https:") return false;
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-// src/validation/uuid.RFC4122.ts
-var validateUUID = (value) => {
-  if (typeof value !== "string") return false;
-  const standard = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-  return standard.test(value) || value.toLowerCase() === "00000000-0000-0000-0000-000000000000" || value.toLowerCase() === "ffffffff-ffff-ffff-ffff-ffffffffffff";
-};
-
-// src/validation/dateTime.ISO8601.ts
-var validateDateTimeISO = (value, options) => {
-  const mode = options?.mode ?? "datetime";
-  if (typeof value !== "string") return false;
-  if (mode === "datetime") {
-    const isoDateTimeRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?(?:Z|[+-]\d{2}:\d{2})$/;
-    if (!isoDateTimeRegex.test(value)) return false;
-    const date = new Date(value);
-    if (Number.isNaN(date.getTime())) return false;
-    return true;
-  }
-  if (mode === "date") {
-    const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
-    if (!dateRegex.test(value)) return false;
-    const date = new Date(value);
-    if (isNaN(date.getTime())) return false;
-    const [year, month, day] = value.split("-").map(Number);
-    return date.getUTCFullYear() === year && date.getUTCMonth() + 1 === month && date.getUTCDate() === day;
-  }
-  if (mode === "time") {
-    const timeRegex = /^([01]\d|2[0-3]):[0-5]\d:[0-5]\d(\.\d+)?Z?$/;
-    return timeRegex.test(value);
-  }
-  return false;
-};
-
-// src/validation/countryCode.ISO3166.ts
-var isoCountryCodes = /* @__PURE__ */ new Set([
-  "AD",
-  "AE",
-  "AF",
-  "AG",
-  "AI",
-  "AL",
-  "AM",
-  "AO",
-  "AQ",
-  "AR",
-  "AS",
-  "AT",
-  "AU",
-  "AW",
-  "AX",
-  "AZ",
-  "BA",
-  "BB",
-  "BD",
-  "BE",
-  "BF",
-  "BG",
-  "BH",
-  "BI",
-  "BJ",
-  "BL",
-  "BM",
-  "BN",
-  "BO",
-  "BQ",
-  "BR",
-  "BS",
-  "BT",
-  "BV",
-  "BW",
-  "BY",
-  "BZ",
-  "CA",
-  "CC",
-  "CD",
-  "CF",
-  "CG",
-  "CH",
-  "CI",
-  "CK",
-  "CL",
-  "CM",
-  "CN",
-  "CO",
-  "CR",
-  "CU",
-  "CV",
-  "CW",
-  "CX",
-  "CY",
-  "CZ",
-  "DE",
-  "DJ",
-  "DK",
-  "DM",
-  "DO",
-  "DZ",
-  "EC",
-  "EE",
-  "EG",
-  "EH",
-  "ER",
-  "ES",
-  "ET",
-  "FI",
-  "FJ",
-  "FM",
-  "FO",
-  "FR",
-  "GA",
-  "GB",
-  "GD",
-  "GE",
-  "GF",
-  "GG",
-  "GH",
-  "GI",
-  "GL",
-  "GM",
-  "GN",
-  "GP",
-  "GQ",
-  "GR",
-  "GT",
-  "GU",
-  "GW",
-  "GY",
-  "HK",
-  "HM",
-  "HN",
-  "HR",
-  "HT",
-  "HU",
-  "ID",
-  "IE",
-  "IL",
-  "IM",
-  "IN",
-  "IO",
-  "IQ",
-  "IR",
-  "IS",
-  "IT",
-  "JE",
-  "JM",
-  "JO",
-  "JP",
-  "KE",
-  "KG",
-  "KH",
-  "KI",
-  "KM",
-  "KN",
-  "KP",
-  "KR",
-  "KW",
-  "KY",
-  "KZ",
-  "LA",
-  "LB",
-  "LC",
-  "LI",
-  "LK",
-  "LR",
-  "LS",
-  "LT",
-  "LU",
-  "LV",
-  "LY",
-  "MA",
-  "MC",
-  "MD",
-  "ME",
-  "MF",
-  "MG",
-  "MH",
-  "MK",
-  "ML",
-  "MM",
-  "MN",
-  "MO",
-  "MP",
-  "MQ",
-  "MR",
-  "MS",
-  "MT",
-  "MU",
-  "MV",
-  "MW",
-  "MX",
-  "MY",
-  "MZ",
-  "NA",
-  "NC",
-  "NE",
-  "NF",
-  "NG",
-  "NI",
-  "NL",
-  "NO",
-  "NP",
-  "NR",
-  "NU",
-  "NZ",
-  "OM",
-  "PA",
-  "PE",
-  "PF",
-  "PG",
-  "PH",
-  "PK",
-  "PL",
-  "PM",
-  "PN",
-  "PR",
-  "PS",
-  "PT",
-  "PW",
-  "PY",
-  "QA",
-  "RE",
-  "RO",
-  "RS",
-  "RU",
-  "RW",
-  "SA",
-  "SB",
-  "SC",
-  "SD",
-  "SE",
-  "SG",
-  "SH",
-  "SI",
-  "SJ",
-  "SK",
-  "SL",
-  "SM",
-  "SN",
-  "SO",
-  "SR",
-  "SS",
-  "ST",
-  "SV",
-  "SX",
-  "SY",
-  "SZ",
-  "TC",
-  "TD",
-  "TF",
-  "TG",
-  "TH",
-  "TJ",
-  "TK",
-  "TL",
-  "TM",
-  "TN",
-  "TO",
-  "TR",
-  "TT",
-  "TV",
-  "TZ",
-  "UA",
-  "UG",
-  "UM",
-  "US",
-  "UY",
-  "UZ",
-  "VA",
-  "VC",
-  "VE",
-  "VG",
-  "VI",
-  "VN",
-  "VU",
-  "WF",
-  "WS",
-  "YE",
-  "YT",
-  "ZA",
-  "ZM",
-  "ZW"
-]);
-var validateCountryCode = (value) => {
-  if (typeof value !== "string") return false;
-  return isoCountryCodes.has(value.toUpperCase());
-};
+import {
+  FeedbackGameDiagnosticsSchema,
+  FieldBuilder,
+  IsoLanguageCode,
+  SCHEMA_IDENTITY_POLICIES,
+  SCHEMA_UNKNOWN_FIELDS_POLICIES,
+  createSchema,
+  feedbackGameDiagnosticsShape,
+  field,
+  getAllSchemas,
+  getSchemaForType,
+  isExtensionSingleton,
+  isExtensionSubtag,
+  isFeedbackGameDiagnosticsConsistent,
+  isIsoLanguageCode,
+  isPrivateUseSingleton,
+  isPrivateUseSubtag,
+  isRegionSubtag,
+  isScriptSubtag,
+  isVariantSubtag,
+  isoCountryCodes,
+  renderSchemaDescription,
+  validateCountryCode,
+  validateDateTimeISO,
+  validateEmail,
+  validateFeedbackGameDiagnostics,
+  validateLanguage,
+  validatePhone,
+  validateRichText,
+  validateSafeText,
+  validateSemVer,
+  validateUUID,
+  validateUrl
+} from "./chunk-UQHPDQZX.js";
+import {
+  FEEDBACK_BACKEND_BUCKETS,
+  FEEDBACK_CONTRACT_VERSION,
+  FEEDBACK_FRAME_RATE_BUCKETS,
+  FEEDBACK_FRAME_TIME_BUCKETS,
+  FEEDBACK_GAME_COUNTER_CODES,
+  FEEDBACK_GAME_COUNTER_MAX_COUNT,
+  FEEDBACK_GAME_COUNTER_MAX_ITEMS,
+  FEEDBACK_GAME_ERROR_CODES,
+  FEEDBACK_GAME_FEATURE_IDS,
+  FEEDBACK_GAME_PROVENANCE_CONTRACTS,
+  FEEDBACK_GAME_PROVENANCE_CONTRACT_IDS,
+  FEEDBACK_GAME_SURFACE_IDS,
+  FEEDBACK_RENDERER_BUCKETS,
+  FEEDBACK_VIEWPORT_BUCKETS
+} from "./chunk-AG2NAPDC.js";
+import {
+  FEEDBACK_UNICODE_PROFILE_ID,
+  containsFeedbackUnicodeProfileUnsupportedText
+} from "./chunk-6FE4FLKF.js";
 
 // src/validation/currencyCode.ISO4217.ts
 var isoCurrencyCodes = /* @__PURE__ */ new Set([
@@ -695,63 +241,14 @@ var validateCurrencyCode = (value) => {
   return isoCurrencyCodes.has(value.toUpperCase());
 };
 
-// src/validation/generalText.OWASP.ts
-function validateSafeText(value) {
-  if (typeof value !== "string") return false;
-  const trimmed = value.trim();
-  if (trimmed.length === 0) return false;
-  for (let i = 0; i < trimmed.length; i++) {
-    const code = trimmed.codePointAt(i);
-    if (code !== void 0 && (code >= 0 && code <= 31 || code === 127)) {
-      return false;
-    }
-  }
-  if (/['"<>\\{}();]/.test(trimmed)) return false;
-  if (/(--|\b(SELECT|UPDATE|DELETE|INSERT|DROP|ALTER|EXEC|UNION|GRANT|REVOKE)\b|\/\*|\*\/|@@)/i.test(
-    trimmed
-  ))
-    return false;
-  if (trimmed.includes("\0")) return false;
-  if (trimmed.length > 1024) return false;
-  return true;
-}
-
-// src/validation/version.SEMVER2.0.0.ts
-function validateSemVer(value) {
-  if (typeof value !== "string") return false;
-  return /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/.test(
-    value
-  );
-}
-
 // src/validation/percentage.ISO80000-1.ts
 function validatePercentage(value) {
   if (typeof value !== "number") return false;
   return value >= 0 && value <= 100;
 }
 
-// src/validation/richtext.OWASP.ts
-function validateRichText(value) {
-  if (typeof value !== "string") return false;
-  const trimmed = value.trim();
-  if (trimmed.length === 0) return true;
-  if (/<(script|iframe|object|embed|style|link|meta|base|form|input|button|textarea|select)\b/i.test(
-    trimmed
-  )) {
-    return false;
-  }
-  if (/javascript:/i.test(trimmed)) {
-    return false;
-  }
-  if (/on\w+=["']?/i.test(trimmed)) {
-    return false;
-  }
-  if (trimmed.length > 1e4) return false;
-  return true;
-}
-
 // src/validation/name.OWASP.ts
-function validateName(value) {
+function validateNameLike(value, pattern) {
   if (typeof value !== "string") return false;
   const trimmed = value.trim();
   if (trimmed.length === 0) return false;
@@ -760,10 +257,15 @@ function validateName(value) {
     const cp = ch.codePointAt(0);
     if (cp >= 0 && cp <= 31 || cp === 127) return false;
   }
-  const namePattern = /^[\p{L}\p{M}'\-. ]+$/u;
-  if (!namePattern.test(trimmed)) return false;
+  if (!pattern.test(trimmed)) return false;
   return true;
 }
+function validateName(value) {
+  return validateNameLike(value, /^[\p{L}\p{M}'\-. ]+$/u);
+}
+function validateDisplayName(value) {
+  return validateNameLike(value, /^[\p{L}\p{M}\p{Nd}'\-. ]+$/u);
+}
 
 // src/validation/user.MS-GOOGLE-APPLE.ts
 function validateUserId(value) {
@@ -780,1727 +282,1557 @@ function validateUserIdArray(value) {
   return value.every(validateUserId);
 }
 
-// src/validation/languageCode.BCP47.ts
-var IsoLanguageCode = /* @__PURE__ */ ((IsoLanguageCode2) => {
-  IsoLanguageCode2["Afar"] = "aa";
-  IsoLanguageCode2["Abkhazian"] = "ab";
-  IsoLanguageCode2["Afrikaans"] = "af";
-  IsoLanguageCode2["Akan"] = "ak";
-  IsoLanguageCode2["Albanian"] = "sq";
-  IsoLanguageCode2["Amharic"] = "am";
-  IsoLanguageCode2["Arabic"] = "ar";
-  IsoLanguageCode2["Aragonese"] = "an";
-  IsoLanguageCode2["Armenian"] = "hy";
-  IsoLanguageCode2["Assamese"] = "as";
-  IsoLanguageCode2["Avaric"] = "av";
-  IsoLanguageCode2["Aymara"] = "ay";
-  IsoLanguageCode2["Azerbaijani"] = "az";
-  IsoLanguageCode2["Bashkir"] = "ba";
-  IsoLanguageCode2["Bambara"] = "bm";
-  IsoLanguageCode2["Basque"] = "eu";
-  IsoLanguageCode2["Belarusian"] = "be";
-  IsoLanguageCode2["Bengali"] = "bn";
-  IsoLanguageCode2["Bislama"] = "bi";
-  IsoLanguageCode2["Bosnian"] = "bs";
-  IsoLanguageCode2["Breton"] = "br";
-  IsoLanguageCode2["Bulgarian"] = "bg";
-  IsoLanguageCode2["Burmese"] = "my";
-  IsoLanguageCode2["Catalan"] = "ca";
-  IsoLanguageCode2["Chamorro"] = "ch";
-  IsoLanguageCode2["Chechen"] = "ce";
-  IsoLanguageCode2["Chinese"] = "zh";
-  IsoLanguageCode2["ChurchSlavic"] = "cu";
-  IsoLanguageCode2["Chuvash"] = "cv";
-  IsoLanguageCode2["Cornish"] = "kw";
-  IsoLanguageCode2["Corsican"] = "co";
-  IsoLanguageCode2["Cree"] = "cr";
-  IsoLanguageCode2["Croatian"] = "hr";
-  IsoLanguageCode2["Czech"] = "cs";
-  IsoLanguageCode2["Danish"] = "da";
-  IsoLanguageCode2["Divehi"] = "dv";
-  IsoLanguageCode2["Dutch"] = "nl";
-  IsoLanguageCode2["Dzongkha"] = "dz";
-  IsoLanguageCode2["English"] = "en";
-  IsoLanguageCode2["Esperanto"] = "eo";
-  IsoLanguageCode2["Estonian"] = "et";
-  IsoLanguageCode2["Ewe"] = "ee";
-  IsoLanguageCode2["Faroese"] = "fo";
-  IsoLanguageCode2["Fijian"] = "fj";
-  IsoLanguageCode2["Finnish"] = "fi";
-  IsoLanguageCode2["French"] = "fr";
-  IsoLanguageCode2["WesternFrisian"] = "fy";
-  IsoLanguageCode2["Fulah"] = "ff";
-  IsoLanguageCode2["Gaelic"] = "gd";
-  IsoLanguageCode2["Galician"] = "gl";
-  IsoLanguageCode2["Ganda"] = "lg";
-  IsoLanguageCode2["Georgian"] = "ka";
-  IsoLanguageCode2["German"] = "de";
-  IsoLanguageCode2["Greek"] = "el";
-  IsoLanguageCode2["Kalaallisut"] = "kl";
-  IsoLanguageCode2["Guarani"] = "gn";
-  IsoLanguageCode2["Gujarati"] = "gu";
-  IsoLanguageCode2["Haitian"] = "ht";
-  IsoLanguageCode2["Hausa"] = "ha";
-  IsoLanguageCode2["Hebrew"] = "he";
-  IsoLanguageCode2["Herero"] = "hz";
-  IsoLanguageCode2["Hindi"] = "hi";
-  IsoLanguageCode2["HiriMotu"] = "ho";
-  IsoLanguageCode2["Hungarian"] = "hu";
-  IsoLanguageCode2["Icelandic"] = "is";
-  IsoLanguageCode2["Ido"] = "io";
-  IsoLanguageCode2["Igbo"] = "ig";
-  IsoLanguageCode2["Indonesian"] = "id";
-  IsoLanguageCode2["Interlingua"] = "ia";
-  IsoLanguageCode2["Interlingue"] = "ie";
-  IsoLanguageCode2["Inuktitut"] = "iu";
-  IsoLanguageCode2["Inupiaq"] = "ik";
-  IsoLanguageCode2["Irish"] = "ga";
-  IsoLanguageCode2["Italian"] = "it";
-  IsoLanguageCode2["Japanese"] = "ja";
-  IsoLanguageCode2["Javanese"] = "jv";
-  IsoLanguageCode2["Kannada"] = "kn";
-  IsoLanguageCode2["Kanuri"] = "kr";
-  IsoLanguageCode2["Kashmiri"] = "ks";
-  IsoLanguageCode2["Kazakh"] = "kk";
-  IsoLanguageCode2["CentralKhmer"] = "km";
-  IsoLanguageCode2["Kikuyu"] = "ki";
-  IsoLanguageCode2["Kinyarwanda"] = "rw";
-  IsoLanguageCode2["Kyrgyz"] = "ky";
-  IsoLanguageCode2["Komi"] = "kv";
-  IsoLanguageCode2["Kongo"] = "kg";
-  IsoLanguageCode2["Korean"] = "ko";
-  IsoLanguageCode2["Kuanyama"] = "kj";
-  IsoLanguageCode2["Kurdish"] = "ku";
-  IsoLanguageCode2["Lao"] = "lo";
-  IsoLanguageCode2["Latin"] = "la";
-  IsoLanguageCode2["Latvian"] = "lv";
-  IsoLanguageCode2["Limburgan"] = "li";
-  IsoLanguageCode2["Lingala"] = "ln";
-  IsoLanguageCode2["Lithuanian"] = "lt";
-  IsoLanguageCode2["LubaKatanga"] = "lu";
-  IsoLanguageCode2["Luxembourgish"] = "lb";
-  IsoLanguageCode2["Macedonian"] = "mk";
-  IsoLanguageCode2["Malagasy"] = "mg";
-  IsoLanguageCode2["Malay"] = "ms";
-  IsoLanguageCode2["Malayalam"] = "ml";
-  IsoLanguageCode2["Maltese"] = "mt";
-  IsoLanguageCode2["Manx"] = "gv";
-  IsoLanguageCode2["Maori"] = "mi";
-  IsoLanguageCode2["Marathi"] = "mr";
-  IsoLanguageCode2["Marshallese"] = "mh";
-  IsoLanguageCode2["Mongolian"] = "mn";
-  IsoLanguageCode2["Nauru"] = "na";
-  IsoLanguageCode2["Navajo"] = "nv";
-  IsoLanguageCode2["NorthNdebele"] = "nd";
-  IsoLanguageCode2["SouthNdebele"] = "nr";
-  IsoLanguageCode2["Ndonga"] = "ng";
-  IsoLanguageCode2["Nepali"] = "ne";
-  IsoLanguageCode2["Norwegian"] = "no";
-  IsoLanguageCode2["NorwegianBokmal"] = "nb";
-  IsoLanguageCode2["NorwegianNynorsk"] = "nn";
-  IsoLanguageCode2["SichuanYi"] = "ii";
-  IsoLanguageCode2["Occitan"] = "oc";
-  IsoLanguageCode2["Ojibwa"] = "oj";
-  IsoLanguageCode2["Oriya"] = "or";
-  IsoLanguageCode2["Oromo"] = "om";
-  IsoLanguageCode2["Ossetian"] = "os";
-  IsoLanguageCode2["Pali"] = "pi";
-  IsoLanguageCode2["Pashto"] = "ps";
-  IsoLanguageCode2["Persian"] = "fa";
-  IsoLanguageCode2["Polish"] = "pl";
-  IsoLanguageCode2["Portuguese"] = "pt";
-  IsoLanguageCode2["Punjabi"] = "pa";
-  IsoLanguageCode2["Quechua"] = "qu";
-  IsoLanguageCode2["Romansh"] = "rm";
-  IsoLanguageCode2["Romanian"] = "ro";
-  IsoLanguageCode2["Rundi"] = "rn";
-  IsoLanguageCode2["Russian"] = "ru";
-  IsoLanguageCode2["Samoan"] = "sm";
-  IsoLanguageCode2["Sango"] = "sg";
-  IsoLanguageCode2["Sanskrit"] = "sa";
-  IsoLanguageCode2["Sardinian"] = "sc";
-  IsoLanguageCode2["Serbian"] = "sr";
-  IsoLanguageCode2["Shona"] = "sn";
-  IsoLanguageCode2["Sindhi"] = "sd";
-  IsoLanguageCode2["Sinhala"] = "si";
-  IsoLanguageCode2["Slovak"] = "sk";
-  IsoLanguageCode2["Slovenian"] = "sl";
-  IsoLanguageCode2["Somali"] = "so";
-  IsoLanguageCode2["SouthernSotho"] = "st";
-  IsoLanguageCode2["Spanish"] = "es";
-  IsoLanguageCode2["Sundanese"] = "su";
-  IsoLanguageCode2["Swahili"] = "sw";
-  IsoLanguageCode2["Swati"] = "ss";
-  IsoLanguageCode2["Swedish"] = "sv";
-  IsoLanguageCode2["Tagalog"] = "tl";
-  IsoLanguageCode2["Tahitian"] = "ty";
-  IsoLanguageCode2["Tajik"] = "tg";
-  IsoLanguageCode2["Tamil"] = "ta";
-  IsoLanguageCode2["Tatar"] = "tt";
-  IsoLanguageCode2["Telugu"] = "te";
-  IsoLanguageCode2["Thai"] = "th";
-  IsoLanguageCode2["Tibetan"] = "bo";
-  IsoLanguageCode2["Tigrinya"] = "ti";
-  IsoLanguageCode2["Tonga"] = "to";
-  IsoLanguageCode2["Tsonga"] = "ts";
-  IsoLanguageCode2["Tswana"] = "tn";
-  IsoLanguageCode2["Turkish"] = "tr";
-  IsoLanguageCode2["Turkmen"] = "tk";
-  IsoLanguageCode2["Twi"] = "tw";
-  IsoLanguageCode2["Uighur"] = "ug";
-  IsoLanguageCode2["Ukrainian"] = "uk";
-  IsoLanguageCode2["Urdu"] = "ur";
-  IsoLanguageCode2["Uzbek"] = "uz";
-  IsoLanguageCode2["Venda"] = "ve";
-  IsoLanguageCode2["Vietnamese"] = "vi";
-  IsoLanguageCode2["Volapuk"] = "vo";
-  IsoLanguageCode2["Walloon"] = "wa";
-  IsoLanguageCode2["Welsh"] = "cy";
-  IsoLanguageCode2["Wolof"] = "wo";
-  IsoLanguageCode2["Xhosa"] = "xh";
-  IsoLanguageCode2["Yiddish"] = "yi";
-  IsoLanguageCode2["Yoruba"] = "yo";
-  IsoLanguageCode2["Zhuang"] = "za";
-  IsoLanguageCode2["Zulu"] = "zu";
-  return IsoLanguageCode2;
-})(IsoLanguageCode || {});
-var ISO_LANGUAGE_SET = new Set(
-  Object.values(IsoLanguageCode)
-);
-function isIsoLanguageCode(value) {
-  return typeof value === "string" && ISO_LANGUAGE_SET.has(value.toLowerCase());
-}
-function isRegionSubtag(value) {
-  return /^[A-Za-z]{2}$/.test(value) || /^\d{3}$/.test(value);
-}
-function isScriptSubtag(value) {
-  return /^[A-Za-z]{4}$/.test(value);
+// src/components.ts
+var componentSchemaRegistry = /* @__PURE__ */ new Map();
+function createComponentSchema(shape, name, version, tableName = "", schemaValidator = () => true) {
+  const schema = createSchema(shape, name, {
+    version,
+    piiEnforcement: "strict",
+    table: tableName,
+    schemaValidator
+  });
+  registerComponentSchema(name, schema);
+  return schema;
 }
-function isVariantSubtag(value) {
-  return /^([0-9][A-Za-z0-9]{3}|[A-Za-z0-9]{5,8})$/.test(value);
+function registerComponentSchema(type, schema) {
+  componentSchemaRegistry.set(type, schema);
 }
-function isExtensionSingleton(value) {
-  return /^[0-9A-WY-Za-wy-z]$/.test(value);
+function getComponentSchema(type) {
+  return componentSchemaRegistry.get(type);
 }
-function isExtensionSubtag(value) {
-  return /^[A-Za-z0-9]{2,8}$/.test(value);
+function getAllComponentSchemas() {
+  return Array.from(componentSchemaRegistry.entries());
 }
-function isPrivateUseSingleton(value) {
-  return value.toLowerCase() === "x";
+
+// src/player-system-events.ts
+var PLAYER_SYSTEM_EVENT_KINDS = [
+  "combat",
+  "social",
+  "mission",
+  "crafting",
+  "world"
+];
+var PLAYER_SYSTEM_ACHIEVEMENT_TIERS = [
+  "bronze",
+  "silver",
+  "gold"
+];
+var PLAYER_SYSTEM_ACHIEVEMENT_TRACK_STATUSES = [
+  "tracking",
+  "earned"
+];
+var playerIdField = () => field.string().min(1).max(128).PID({
+  classification: "low",
+  action: "none",
+  logHandling: "pseudonym",
+  purpose: "a stable player-scoped storage identifier"
+}).description(
+  "Stable player identifier; the only personal identifier retained in event projections"
+);
+var eventIdField = () => field.string().min(1).max(128);
+var eventKindField = () => field.string().enum(PLAYER_SYSTEM_EVENT_KINDS);
+var eventTitleField = () => field.generalText().min(1).max(120).description("Player-visible event title");
+var eventSummaryField = () => field.generalText().min(1).max(320).description("Player-visible event summary");
+var observedEventFields = (defaultHighlighted = true) => ({
+  id: eventIdField(),
+  playerId: playerIdField(),
+  occurredAt: field.dateTimeISO(),
+  kind: eventKindField(),
+  title: eventTitleField(),
+  summary: eventSummaryField(),
+  highlighted: defaultHighlighted ? field.boolean().default(false) : field.boolean()
+});
+var eventHighlightFields = () => ({
+  id: eventIdField(),
+  title: eventTitleField(),
+  summary: eventSummaryField(),
+  occurredAt: field.dateTimeISO(),
+  kind: eventKindField()
+});
+var eventEntryFields = () => ({
+  id: eventIdField(),
+  title: eventTitleField(),
+  summary: eventSummaryField(),
+  occurredAt: field.dateTimeISO(),
+  kind: eventKindField(),
+  highlighted: field.boolean()
+});
+var achievementFields = () => ({
+  id: eventIdField(),
+  title: eventTitleField(),
+  tier: field.string().enum(PLAYER_SYSTEM_ACHIEVEMENT_TIERS),
+  progressLabel: eventSummaryField(),
+  earnedAt: field.dateTimeISO().optional()
+});
+var achievementTrackFields = () => ({
+  id: eventIdField(),
+  title: eventTitleField(),
+  current: field.number().min(0).max(1e3),
+  target: field.number().min(1).max(1e3),
+  status: field.string().enum(PLAYER_SYSTEM_ACHIEVEMENT_TRACK_STATUSES)
+});
+var PlayerSystemObservedEventBatchSchema = createSchema(
+  {
+    source: field.string().min(1).max(120),
+    emittedAt: field.dateTimeISO(),
+    events: field.array(field.object(observedEventFields()))
+  },
+  "player-system-observed-event-batch",
+  {
+    version: "1.0.0",
+    piiEnforcement: "strict"
+  }
+);
+var PlayerSystemNormalizedEventBatchSchema = createSchema(
+  {
+    sourceBlobName: field.string().min(1).max(512),
+    processedAt: field.dateTimeISO(),
+    events: field.array(
+      field.object({
+        ...observedEventFields(false),
+        deterministicKey: field.string().min(1).max(256)
+      })
+    )
+  },
+  "player-system-normalized-event-batch",
+  {
+    version: "1.0.0",
+    piiEnforcement: "strict"
+  }
+);
+var PlayerSystemCuratedSnapshotSchema = createSchema(
+  {
+    playerId: playerIdField(),
+    projectedAt: field.dateTimeISO(),
+    lastObservedAt: field.dateTimeISO(),
+    highlights: field.array(field.object(eventHighlightFields())),
+    events: field.array(field.object(eventEntryFields())),
+    achievements: field.array(field.object(achievementFields())),
+    tracks: field.array(field.object(achievementTrackFields()))
+  },
+  "player-system-curated-snapshot",
+  {
+    version: "1.0.0",
+    piiEnforcement: "strict"
+  }
+);
+
+// src/feedback.ts
+var FEEDBACK_UNICODE_NORMALIZATION_PROFILE = FEEDBACK_UNICODE_PROFILE_ID;
+var FEEDBACK_BUG_COOLDOWN_SECONDS = Object.freeze([
+  5 * 60,
+  15 * 60,
+  60 * 60,
+  6 * 60 * 60,
+  24 * 60 * 60
+]);
+var FEEDBACK_REVIEW_COOLDOWN_SECONDS = 30 * 24 * 60 * 60;
+var FEEDBACK_ISSUE_TYPES = [
+  "visual-layout",
+  "functionality",
+  "gameplay",
+  "performance-stability",
+  "accessibility",
+  "content-localisation",
+  "account-access",
+  "privacy-security",
+  "other"
+];
+var FEEDBACK_PERSISTABLE_ISSUE_TYPES = FEEDBACK_ISSUE_TYPES.filter(
+  (issueType) => issueType !== "privacy-security"
+);
+var FEEDBACK_SEVERITY_LEVELS = [
+  { value: 1, id: "cosmetic", labelKey: "feedback.severity.cosmetic" },
+  { value: 2, id: "minor", labelKey: "feedback.severity.minor" },
+  { value: 3, id: "disruptive", labelKey: "feedback.severity.disruptive" },
+  { value: 4, id: "blocking", labelKey: "feedback.severity.blocking" },
+  { value: 5, id: "critical", labelKey: "feedback.severity.critical" }
+];
+var FEEDBACK_SATISFACTION_LEVELS = [
+  { value: 1, id: "very-poor", labelKey: "feedback.satisfaction.very-poor" },
+  { value: 2, id: "poor", labelKey: "feedback.satisfaction.poor" },
+  { value: 3, id: "fair", labelKey: "feedback.satisfaction.fair" },
+  { value: 4, id: "good", labelKey: "feedback.satisfaction.good" },
+  { value: 5, id: "excellent", labelKey: "feedback.satisfaction.excellent" }
+];
+var FEEDBACK_SENTIMENT_BUCKETS = [
+  "very-negative",
+  "negative",
+  "mixed",
+  "neutral",
+  "positive",
+  "very-positive",
+  "not-detected"
+];
+var FEEDBACK_INTENT_IDS = [
+  "visual-layout",
+  "functionality",
+  "gameplay",
+  "performance-stability",
+  "accessibility",
+  "content-localisation",
+  "account-access",
+  "other",
+  "praise",
+  "suggestion",
+  "confusion",
+  "frustration"
+];
+var FEEDBACK_THEME_IDS = [
+  "navigation",
+  "visual-design",
+  "game-controls",
+  "rendering",
+  "responsiveness",
+  "stability",
+  "accessibility",
+  "localisation",
+  "account-access",
+  "overall-experience",
+  "other"
+];
+var FEEDBACK_SURFACE_IDS = [
+  "site.about",
+  "admin.analytics",
+  "admin.capabilities",
+  "admin.feature-flags",
+  "admin.feedback",
+  "admin.moderation",
+  "admin.users",
+  "site.chatbot",
+  "site.generator",
+  "site.gpu-demo",
+  "site.home",
+  "game.player-system",
+  "account.profile",
+  "site.video"
+];
+var FEEDBACK_SURFACE_DEFINITIONS = [
+  {
+    id: "site.about",
+    labelKey: "feedback.surface.about",
+    kind: "public",
+    gameDiagnosticsEligible: false
+  },
+  {
+    id: "admin.analytics",
+    labelKey: "feedback.surface.adminAnalytics",
+    kind: "admin",
+    gameDiagnosticsEligible: false
+  },
+  {
+    id: "admin.capabilities",
+    labelKey: "feedback.surface.adminCapabilities",
+    kind: "admin",
+    gameDiagnosticsEligible: false
+  },
+  {
+    id: "admin.feature-flags",
+    labelKey: "feedback.surface.adminFeatureFlags",
+    kind: "admin",
+    gameDiagnosticsEligible: false
+  },
+  {
+    id: "admin.feedback",
+    labelKey: "feedback.surface.adminFeedback",
+    kind: "admin",
+    gameDiagnosticsEligible: false
+  },
+  {
+    id: "admin.moderation",
+    labelKey: "feedback.surface.adminModeration",
+    kind: "admin",
+    gameDiagnosticsEligible: false
+  },
+  {
+    id: "admin.users",
+    labelKey: "feedback.surface.adminUsers",
+    kind: "admin",
+    gameDiagnosticsEligible: false
+  },
+  {
+    id: "site.chatbot",
+    labelKey: "feedback.surface.chatbot",
+    kind: "public",
+    gameDiagnosticsEligible: false
+  },
+  {
+    id: "site.generator",
+    labelKey: "feedback.surface.generator",
+    kind: "game",
+    gameDiagnosticsEligible: true
+  },
+  {
+    id: "site.gpu-demo",
+    labelKey: "feedback.surface.gpuDemo",
+    kind: "game",
+    gameDiagnosticsEligible: true
+  },
+  {
+    id: "site.home",
+    labelKey: "feedback.surface.home",
+    kind: "public",
+    gameDiagnosticsEligible: false
+  },
+  {
+    id: "game.player-system",
+    labelKey: "feedback.surface.playerSystem",
+    kind: "game",
+    gameDiagnosticsEligible: false
+  },
+  {
+    id: "account.profile",
+    labelKey: "feedback.surface.profile",
+    kind: "authenticated",
+    gameDiagnosticsEligible: false
+  },
+  {
+    id: "site.video",
+    labelKey: "feedback.surface.video",
+    kind: "public",
+    gameDiagnosticsEligible: false
+  }
+];
+var FEEDBACK_STRUCTURED_ONLY_REASON_CODES = [
+  "analysis-unavailable",
+  "invalid-envelope",
+  "invalid-sensitive-payload",
+  "language-not-enabled",
+  "request-too-large",
+  "length-required"
+];
+var FEEDBACK_PRIVACY_POLICY_VERSIONS = [
+  "feedback-privacy-en-v1"
+];
+var FEEDBACK_ANALYSIS_MODEL_VERSIONS = [
+  "feedback-en-rules-v1"
+];
+for (const vocabulary of [
+  FEEDBACK_BUG_COOLDOWN_SECONDS,
+  FEEDBACK_ISSUE_TYPES,
+  FEEDBACK_PERSISTABLE_ISSUE_TYPES,
+  FEEDBACK_SEVERITY_LEVELS,
+  FEEDBACK_SATISFACTION_LEVELS,
+  FEEDBACK_SENTIMENT_BUCKETS,
+  FEEDBACK_INTENT_IDS,
+  FEEDBACK_THEME_IDS,
+  FEEDBACK_SURFACE_IDS,
+  FEEDBACK_SURFACE_DEFINITIONS,
+  FEEDBACK_STRUCTURED_ONLY_REASON_CODES,
+  FEEDBACK_PRIVACY_POLICY_VERSIONS,
+  FEEDBACK_ANALYSIS_MODEL_VERSIONS
+]) {
+  Object.freeze(vocabulary);
 }
-function isPrivateUseSubtag(value) {
-  return /^[A-Za-z0-9]{1,8}$/.test(value);
+for (const entry of [
+  ...FEEDBACK_SEVERITY_LEVELS,
+  ...FEEDBACK_SATISFACTION_LEVELS,
+  ...FEEDBACK_SURFACE_DEFINITIONS
+]) {
+  Object.freeze(entry);
 }
-function validateLanguage(value) {
-  if (typeof value !== "string" || value.length === 0) return false;
-  const parts = value.split("-");
-  if (parts.some((part) => part.length === 0)) return false;
-  const lowerTag = value.toLowerCase();
-  if (GRANDFATHERED_TAGS.has(lowerTag)) return true;
-  if (parts[0]?.toLowerCase() === "x") {
-    return parts.length > 1 && parts.slice(1).every(isPrivateUseSubtag);
+var SAFE_ID_PATTERN = /^[a-z0-9][a-z0-9._:-]*$/i;
+var INGESTION_KEY_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+var BASE64URL_PATTERN = /^[A-Za-z0-9_-]+$/;
+var OPAQUE_UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var DISALLOWED_NARRATIVE_SYNTAX_PATTERN = /<|>|(?:https?|ftp|mailto|javascript|data|blob|file):|\/\/|www\.|\]\s*\(/i;
+var DISALLOWED_UNICODE_FORMAT_PATTERN = /\p{Cf}/u;
+var MAX_NARRATIVE_CHARACTERS = 4e3;
+var MAX_NARRATIVE_UTF16_CODE_UNITS = 8e3;
+var MAX_COUNT = 1e9;
+var BASE64URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var BUG_HOUR_WINDOW_PATTERN = /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3])$/;
+var REVIEW_DAY_WINDOW_PATTERN = /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$/;
+var RECONCILIATION_WINDOW_PATTERN = /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):(?:[0-5]\d)$/;
+var strictOptions = {
+  version: FEEDBACK_CONTRACT_VERSION,
+  piiEnforcement: "strict",
+  unknownFields: "reject",
+  identity: "exact"
+};
+var uuidField = () => field.string().validator((value) => OPAQUE_UUID_V4_PATTERN.test(value)).description("Opaque UUID generated for the feedback workflow");
+var draftIdField = () => field.string().validator((value) => OPAQUE_UUID_V4_PATTERN.test(value)).description("Opaque identifier for one short-lived structured draft").PID({
+  classification: "low",
+  action: "none",
+  logHandling: "omit",
+  purpose: "short-lived feedback draft lookup that must never enter logs"
+});
+var safeIdField = (maximum = 128) => field.string().min(1).max(maximum).pattern(SAFE_ID_PATTERN);
+var ingestionKeyIdField = () => field.string().min(1).max(80).pattern(INGESTION_KEY_ID_PATTERN);
+var decodeCanonicalBase64Url = (value) => {
+  if (!BASE64URL_PATTERN.test(value) || value.length % 4 === 1) {
+    return void 0;
+  }
+  const finalValue = BASE64URL_ALPHABET.indexOf(value.at(-1) ?? "");
+  if (finalValue < 0 || value.length % 4 === 2 && (finalValue & 15) !== 0 || value.length % 4 === 3 && (finalValue & 3) !== 0) {
+    return void 0;
   }
-  let i = 0;
-  const lang = parts[i];
-  if (!lang || !/^[A-Za-z]{2,3}$/.test(lang)) return false;
-  if (lang.length === 2 && !isIsoLanguageCode(lang)) return false;
-  i += 1;
-  if (lang.length <= 3) {
-    let extlangCount = 0;
-    while (i < parts.length && extlangCount < 3 && /^[A-Za-z]{3}$/.test(parts[i])) {
-      i += 1;
-      extlangCount += 1;
+  const output = [];
+  let accumulator = 0;
+  let bitCount = 0;
+  for (const character of value) {
+    const sextet = BASE64URL_ALPHABET.indexOf(character);
+    if (sextet < 0) {
+      return void 0;
+    }
+    accumulator = accumulator << 6 | sextet;
+    bitCount += 6;
+    while (bitCount >= 8) {
+      bitCount -= 8;
+      output.push(accumulator >> bitCount & 255);
+      accumulator &= (1 << bitCount) - 1;
     }
   }
-  if (i < parts.length && isScriptSubtag(parts[i])) {
-    i += 1;
+  return Uint8Array.from(output);
+};
+var isCanonicalRsaModulus = (value) => {
+  const bytes = decodeCanonicalBase64Url(value);
+  return bytes !== void 0 && (bytes.length === 256 || bytes.length === 384 || bytes.length === 512) && (bytes[0] ?? 0) >= 128 && ((bytes.at(-1) ?? 0) & 1) === 1;
+};
+var isCanonicalRsaExponent = (value) => {
+  const bytes = decodeCanonicalBase64Url(value);
+  if (bytes === void 0 || bytes.length < 1 || bytes.length > 4 || bytes[0] === 0) {
+    return false;
+  }
+  const exponent = bytes.reduce(
+    (total, byte) => total * 256 + byte,
+    0
+  );
+  return exponent >= 3 && exponent % 2 === 1;
+};
+var surfaceIdField = () => field.string().enum(FEEDBACK_SURFACE_IDS);
+var countField = () => field.number().validator((value) => Number.isSafeInteger(value)).min(0).max(MAX_COUNT);
+var positiveCountField = (maximum = MAX_COUNT) => field.number().validator((value) => Number.isSafeInteger(value)).min(1).max(maximum);
+var redactionCountField = () => field.number().validator((value) => Number.isSafeInteger(value)).min(0).max(MAX_NARRATIVE_CHARACTERS);
+var revisionField = () => field.number().validator((value) => Number.isSafeInteger(value)).min(0).max(1e6);
+var ratingField = () => field.number().validator((value) => Number.isInteger(value)).min(1).max(5);
+var narrativeTextField = () => field.string().validator(
+  (value) => typeof value === "string" && value.length >= 1 && value.length <= MAX_NARRATIVE_UTF16_CODE_UNITS && !containsFeedbackUnicodeProfileUnsupportedText(value) && value.normalize("NFKC") === value && [...value].length <= MAX_NARRATIVE_CHARACTERS && !DISALLOWED_NARRATIVE_SYNTAX_PATTERN.test(value) && !DISALLOWED_UNICODE_FORMAT_PATTERN.test(value) && ![...value].some((character) => {
+    const codePoint = character.codePointAt(0);
+    return codePoint !== void 0 && (codePoint < 32 || codePoint === 127);
+  })
+).min(1).max(MAX_NARRATIVE_UTF16_CODE_UNITS).PID({
+  classification: "high",
+  action: "clear",
+  logHandling: "omit",
+  purpose: "transient feedback narrative that must be discarded after classification"
+});
+var transientCorrelationIdField = () => field.string().validator((value) => OPAQUE_UUID_V4_PATTERN.test(value)).PID({
+  classification: "low",
+  action: "clear",
+  logHandling: "omit",
+  purpose: "one-use transient feedback correlation"
+});
+var transientEncryptedField = (minimum, maximum, allowedLengths) => field.string().min(minimum).max(maximum).pattern(BASE64URL_PATTERN).validator(
+  (value) => {
+    const decoded = decodeCanonicalBase64Url(value);
+    return decoded !== void 0 && decoded.length > 0 && (allowedLengths === void 0 || allowedLengths.includes(value.length));
+  }
+).PID({
+  classification: "high",
+  action: "clear",
+  logHandling: "omit",
+  purpose: "encrypted transient feedback narrative material"
+});
+var richTextNodeShape = () => ({
+  type: field.string().enum(["text"]),
+  text: narrativeTextField(),
+  marks: field.array(
+    field.string().enum(["bold", "italic", "underline"])
+  ).max(3).optional()
+});
+var richTextBlockShape = () => ({
+  type: field.string().enum(["paragraph", "listItem"]),
+  depth: field.number().validator((value) => Number.isInteger(value)).min(0).max(4),
+  listType: field.string().enum(["bullet"]).optional(),
+  children: field.array(field.object(richTextNodeShape())).min(1).max(128)
+});
+var nestedIdentityShape = (type) => ({
+  type: field.string().enum([type]),
+  version: field.string().enum([FEEDBACK_CONTRACT_VERSION])
+});
+var envelopeShape = (includeIdentity = false) => ({
+  ...includeIdentity ? nestedIdentityShape("feedback-encrypted-narrative-envelope") : {},
+  schemaVersion: field.string().enum(["1"]),
+  keyId: ingestionKeyIdField(),
+  algorithm: field.string().enum(["RSA-OAEP-256+A256GCM"]),
+  wrappedKey: transientEncryptedField(342, 683, [342, 512, 683]),
+  iv: transientEncryptedField(16, 16, [16]),
+  ciphertext: transientEncryptedField(2, 49152),
+  authenticationTag: transientEncryptedField(22, 22, [22])
+});
+var analysisProjectionShape = (includeIdentity = false) => ({
+  ...includeIdentity ? nestedIdentityShape("feedback-derived-analysis") : {},
+  status: field.string().enum(["analyzed", "structured-only"]),
+  sentiment: field.string().enum(FEEDBACK_SENTIMENT_BUCKETS).optional(),
+  intentIds: field.array(field.string().enum(FEEDBACK_INTENT_IDS)).max(8),
+  themeIds: field.array(field.string().enum(FEEDBACK_THEME_IDS)).max(8),
+  confidence: field.string().enum(["low", "medium", "high"]).optional(),
+  policyVersion: field.string().enum(FEEDBACK_PRIVACY_POLICY_VERSIONS),
+  modelVersion: field.string().enum(FEEDBACK_ANALYSIS_MODEL_VERSIONS),
+  deterministicRedactionCount: redactionCountField(),
+  scannerRedactionCount: redactionCountField()
+});
+var analysisReceiptShape = () => ({
+  receiptId: transientCorrelationIdField(),
+  ...analysisProjectionShape(),
+  analyzedAt: field.dateTimeISO()
+});
+var isAnalysisProjectionConsistent = (value) => {
+  const status = value.status;
+  const intentIds = value.intentIds;
+  const themeIds = value.themeIds;
+  if (!Array.isArray(intentIds) || !Array.isArray(themeIds)) {
+    return false;
   }
-  if (i < parts.length && isRegionSubtag(parts[i].toUpperCase())) {
-    i += 1;
+  if (new Set(intentIds).size !== intentIds.length || new Set(themeIds).size !== themeIds.length) {
+    return false;
   }
-  const variants = /* @__PURE__ */ new Set();
-  while (i < parts.length && isVariantSubtag(parts[i])) {
-    const variant = parts[i].toLowerCase();
-    if (variants.has(variant)) return false;
-    variants.add(variant);
-    i += 1;
+  if (status === "structured-only") {
+    return value.sentiment === void 0 && value.confidence === void 0 && intentIds.length === 0 && themeIds.length === 0;
   }
-  const extensionSingletons = /* @__PURE__ */ new Set();
-  while (i < parts.length && isExtensionSingleton(parts[i])) {
-    const singleton = parts[i].toLowerCase();
-    if (extensionSingletons.has(singleton)) return false;
-    extensionSingletons.add(singleton);
-    i += 1;
-    if (!(i < parts.length && isExtensionSubtag(parts[i]))) return false;
-    while (i < parts.length && isExtensionSubtag(parts[i])) {
-      i += 1;
-    }
+  return status === "analyzed" && value.sentiment !== void 0 && value.confidence !== void 0;
+};
+var optionalDraftFields = () => ({
+  surfaceId: surfaceIdField().optional(),
+  issueType: field.string().enum(FEEDBACK_ISSUE_TYPES).optional(),
+  severity: ratingField().optional(),
+  satisfaction: ratingField().optional(),
+  analysisReceiptId: transientCorrelationIdField().optional()
+});
+var surfaceEntryShape = () => ({
+  id: surfaceIdField(),
+  labelKey: safeIdField(160),
+  kind: field.string().enum(["public", "authenticated", "admin", "game"]),
+  gameDiagnosticsEligible: field.boolean()
+});
+var areSurfacesConsistent = (surfaces) => {
+  if (!Array.isArray(surfaces)) {
+    return false;
   }
-  if (i < parts.length && isPrivateUseSingleton(parts[i])) {
-    i += 1;
-    if (!(i < parts.length && isPrivateUseSubtag(parts[i]))) return false;
-    while (i < parts.length && isPrivateUseSubtag(parts[i])) {
-      i += 1;
+  const surfaceIds = surfaces.map(
+    (surface) => surface.id
+  );
+  return new Set(surfaceIds).size === surfaceIds.length && surfaces.every(
+    (surface) => {
+      const definition = FEEDBACK_SURFACE_DEFINITIONS.find(
+        ({ id }) => id === surface.id
+      );
+      return definition !== void 0 && surface.labelKey === definition.labelKey && surface.kind === definition.kind && surface.gameDiagnosticsEligible === definition.gameDiagnosticsEligible;
     }
+  );
+};
+var isDraftShapeConsistent = (value) => {
+  const hasDirtyField = value.surfaceId !== void 0 || value.issueType !== void 0 || value.severity !== void 0 || value.satisfaction !== void 0 || value.analysisReceiptId !== void 0 || value.analysis !== void 0;
+  if (!hasDirtyField) {
+    return false;
   }
-  return i === parts.length;
-}
-var GRANDFATHERED_TAGS = /* @__PURE__ */ new Set([
-  "art-lojban",
-  "cel-gaulish",
-  "en-gb-oed",
-  "i-ami",
-  "i-bnn",
-  "i-default",
-  "i-enochian",
-  "i-hak",
-  "i-klingon",
-  "i-lux",
-  "i-mingo",
-  "i-navajo",
-  "i-pwn",
-  "i-tao",
-  "i-tay",
-  "i-tsu",
-  "no-bok",
-  "no-nyn",
-  "sgn-be-fr",
-  "sgn-be-nl",
-  "sgn-ch-de",
-  "zh-guoyu",
-  "zh-hakka",
-  "zh-min",
-  "zh-min-nan",
-  "zh-xiang"
-]);
-
-// src/field.ts
-var field = {
-  string: () => new FieldBuilder("string"),
-  number: () => new FieldBuilder("number"),
-  boolean: () => new FieldBuilder("boolean"),
-  object: (fields) => new FieldBuilder("object", { shape: fields }),
-  array: (itemType) => new FieldBuilder("array", { itemType }),
-  ref: (refType) => new FieldBuilder("ref", { refType }),
-  email: () => new FieldBuilder("string").validator(validateEmail).PID({
-    classification: "high",
-    action: "encrypt",
-    logHandling: "redact",
-    purpose: "an email address"
-  }).description("An email address"),
-  phone: () => new FieldBuilder("string").validator(validatePhone).PID({
-    classification: "high",
-    action: "encrypt",
-    logHandling: "redact",
-    purpose: "a phone number"
-  }).description("A phone number"),
-  url: () => new FieldBuilder("string").validator(validateUrl).PID({
-    classification: "low",
-    action: "hash",
-    logHandling: "pseudonym",
-    purpose: "a URL"
-  }).description("A URL"),
-  uuid: () => new FieldBuilder("string").PID({
-    classification: "low",
-    action: "hash",
-    logHandling: "pseudonym",
-    purpose: "a UUID"
-  }).validator(validateUUID).description("A UUID"),
-  dateTimeISO: () => new FieldBuilder("string").PID({
-    classification: "none",
-    action: "none",
-    logHandling: "plain",
-    purpose: "a date string"
-  }).validator(validateDateTimeISO).description("A date string in ISO 8601 format"),
-  dateISO: () => new FieldBuilder("string").PID({
-    classification: "none",
-    action: "none",
-    logHandling: "plain",
-    purpose: "a date string"
-  }).validator((s) => validateDateTimeISO(s, { mode: "date" })).description("A date string in ISO 8601 format (date only)"),
-  timeISO: () => new FieldBuilder("string").PID({
-    classification: "none",
-    action: "none",
-    logHandling: "plain",
-    purpose: "a time string"
-  }).validator((s) => validateDateTimeISO(s, { mode: "time" })).description("A time string in ISO 8601 format (time only)"),
-  richText: () => new FieldBuilder("string").PID({
-    classification: "low",
-    action: "clear",
-    logHandling: "omit",
-    purpose: "rich text content"
-  }).validator(validateRichText).description("Rich text content, may include basic HTML formatting"),
-  generalText: () => new FieldBuilder("string").PID({
-    classification: "none",
-    action: "none",
-    logHandling: "plain",
-    purpose: "Plain text content"
-  }).validator(validateSafeText).description("Standard text content, no HTML allowed"),
-  latitude: () => new FieldBuilder("number").PID({
-    classification: "low",
-    action: "clear",
-    logHandling: "omit",
-    purpose: "Latitude in decimal degrees, WGS 84 (ISO 6709)"
-  }).min(-90).max(90).description("Latitude in decimal degrees, WGS 84 (ISO 6709)"),
-  longitude: () => new FieldBuilder("number").PID({
-    classification: "low",
-    action: "clear",
-    logHandling: "omit",
-    purpose: "Longitude in decimal degrees, WGS 84 (ISO 6709)"
-  }).min(-180).max(180).description("Longitude in decimal degrees, WGS 84 (ISO 6709)"),
-  version: () => new FieldBuilder("string").validator(validateSemVer).description("A semantic version string, e.g. '1.0.0'"),
-  countryCode: () => new FieldBuilder("string").validator(validateCountryCode).description("An ISO 3166 country code, e.g. 'US', 'GB', 'FR'"),
-  languageCode: () => new FieldBuilder("string").validator(validateLanguage).description(
-    "An BCP 47 structured language code, primarily ISO 639-1 and optionally with ISO 3166-1 alpha-2 country code, e.g. 'en', 'en-US', 'fr', 'fr-FR'"
-  )
+  if (value.kind === "bug") {
+    return value.satisfaction === void 0;
+  }
+  if (value.kind === "review") {
+    return value.surfaceId === void 0 && value.issueType === void 0 && value.severity === void 0;
+  }
+  return false;
 };
-
-// src/pii.ts
-function enforcePIIField(parentKey, key, value, def, enforcement = "none", errors, logger) {
-  const path = parentKey ? `${parentKey}.${key}` : key;
-  if (def?._pii?.classification === "high" && (def?.isRequired ?? true)) {
-    const missing = value === void 0 || value === null || value === "";
-    if (missing) {
-      const msg = `High PII field must not be empty: ${path}`;
-      if (enforcement === "strict") {
-        errors?.push(msg);
-        return { shortCircuit: true };
-      }
-      if (enforcement === "warn") {
-        logger?.warn?.(`WARN (PII Enforcement): ${msg}`);
-      }
-    }
+var isContextConsistent = (value) => {
+  if (!areSurfacesConsistent(value.surfaces)) {
+    return false;
   }
-  return { shortCircuit: false };
-}
-function prepareForStorage(shape, input, encryptFn, hashFn) {
-  const build = (def, value, key, out, ctx = {}) => {
-    if (!def) return;
-    const isMissing = value === void 0 || value === null;
-    if (def._pii?.action === "encrypt") {
-      if (!isMissing) out[key + "Encrypted"] = encryptFn(value);
-      return;
-    }
-    if (def._pii?.action === "hash") {
-      if (!isMissing) out[key + "Hash"] = hashFn(value);
-      return;
-    }
-    if (def._pii?.action === "clear") {
-      if (!isMissing) out[key] = null;
-      return;
-    }
-    if (def.type === "object" && def._shape) {
-      const obj = {};
-      for (const [childKey, childDef] of Object.entries(def._shape)) {
-        build(childDef, value?.[childKey], childKey, obj, { parentKey: key });
-      }
-      out[key] = obj;
-      return;
-    }
-    if (def.type === "array" && def.itemType && Array.isArray(value)) {
-      out[key] = value.map((item) => {
-        const obj = {};
-        build(def.itemType, item, key, obj, {
-          parentKey: key,
-          isArrayItem: true
-        });
-        if (Object.prototype.hasOwnProperty.call(obj, key)) {
-          return obj[key];
-        }
-        return Object.keys(obj).length > 0 ? obj : item;
-      });
-      return;
-    }
-    if (def.type === "ref") {
-      const ref = { ...value };
-      const refShape = def._shape;
-      if (refShape && value) {
-        for (const [childKey, childDef] of Object.entries(refShape)) {
-          build(childDef, value[childKey], childKey, ref, { parentKey: key });
-        }
-      }
-      out[key] = ref;
-      return;
-    }
-    out[key] = value;
-  };
-  const result = {};
-  for (const key in shape) {
-    build(shape[key], input?.[key], key, result);
+  if (value.selectedSurfaceId !== void 0 && !value.surfaces.some(
+    (surface) => surface.id === value.selectedSurfaceId
+  )) {
+    return false;
   }
-  return result;
-}
-function prepareForRead(shape, stored, decryptFn) {
-  const readValue = (def, key, container, ctx = {}) => {
-    if (!def) return container?.[key];
-    const action = def._pii?.action;
-    if (action === "encrypt") {
-      const enc = container?.[key + "Encrypted"] ?? container?.[`${ctx.parentKey ?? key}Encrypted`];
-      return enc === void 0 ? void 0 : decryptFn(enc);
-    }
-    if (action === "hash") {
-      const h = container?.[key + "Hash"] ?? container?.[`${ctx.parentKey ?? key}Hash`];
-      return h === void 0 ? void 0 : h;
-    }
-    if (action === "clear")
-      return container?.hasOwnProperty(key) ? null : void 0;
-    if (def.type === "object" && def._shape) {
-      const obj = {};
-      const source = container && Object.prototype.hasOwnProperty.call(container, key) ? container[key] : container ?? {};
-      for (const [childKey, childDef] of Object.entries(def._shape)) {
-        obj[childKey] = readValue(childDef, childKey, source);
-      }
-      return obj;
-    }
-    if (def.type === "array" && def.itemType) {
-      const arr = container?.[key];
-      if (!Array.isArray(arr)) return arr;
-      return arr.map(
-        (item) => readValue(def.itemType, key, item, { parentKey: key, isArrayItem: true })
-      );
-    }
-    if (def.type === "ref") {
-      const ref = { ...container?.[key] ?? {} };
-      const refShape = def._shape;
-      if (refShape) {
-        for (const [childKey, childDef] of Object.entries(refShape)) {
-          ref[childKey] = readValue(childDef, childKey, ref);
-        }
-      }
-      return ref;
-    }
-    return container?.[key];
-  };
-  const result = {};
-  for (const key in shape) {
-    result[key] = readValue(shape[key], key, stored);
+  const hasProjectedSurface = value.surfaces.length > 0;
+  const hasDiagnosticsSurface = value.surfaces.some(
+    (surface) => surface.gameDiagnosticsEligible === true
+  );
+  if (value.eligibility.bugReport && !hasProjectedSurface || value.eligibility.gameDiagnostics && (!value.eligibility.bugReport || !hasDiagnosticsSurface)) {
+    return false;
   }
-  return result;
-}
-function sanitizeForLog(shape, data, pseudonymFn) {
-  const visit = (def, value, ctx = {}) => {
-    if (!def) return void 0;
-    const handling = def._pii?.logHandling;
-    if (handling === "omit") return void 0;
-    if (handling === "redact") return "[REDACTED]";
-    if (handling === "pseudonym") return pseudonymFn(value);
-    if (def.type === "object" && def._shape) {
-      const obj = {};
-      const src = value ?? {};
-      for (const [k, childDef] of Object.entries(def._shape)) {
-        const child = visit(childDef, src[k], { parentKey: k });
-        if (child !== void 0) obj[k] = child;
-      }
-      return obj;
-    }
-    if (def.type === "array" && def.itemType) {
-      if (!Array.isArray(value)) return void 0;
-      const arr = value.map((v) => visit(def.itemType, v, { parentKey: ctx.parentKey })).filter((v) => v !== void 0);
-      return arr;
-    }
-    if (def.type === "ref") {
-      const ref = value ? { type: value.type, id: value.id } : {};
-      const refShape = def._shape;
-      const src = value ?? {};
-      if (refShape) {
-        for (const [k, childDef] of Object.entries(refShape)) {
-          const child = visit(childDef, src[k]);
-          if (child !== void 0) ref[k] = child;
-        }
-      } else if (value) {
-        ref.type = value.type;
-        ref.id = value.id;
-      }
-      return ref;
+  const generatedAt = Date.parse(String(value.generatedAt));
+  if (!Number.isFinite(generatedAt)) {
+    return false;
+  }
+  const boundedFutureAvailabilityIsValid = (candidate, maximumSeconds) => {
+    if (candidate === void 0) {
+      return true;
     }
-    return value;
+    const availableAt = Date.parse(String(candidate));
+    return Number.isFinite(availableAt) && availableAt > generatedAt && availableAt - generatedAt <= maximumSeconds * 1e3;
   };
-  const output = {};
-  for (const key in shape) {
-    const child = visit(shape[key], data?.[key]);
-    if (child !== void 0) output[key] = child;
+  const maximumBugCooldownSeconds = FEEDBACK_BUG_COOLDOWN_SECONDS[FEEDBACK_BUG_COOLDOWN_SECONDS.length - 1] ?? 0;
+  if (!boundedFutureAvailabilityIsValid(
+    value.eligibility.bugAvailableAt,
+    maximumBugCooldownSeconds
+  ) || !boundedFutureAvailabilityIsValid(
+    value.eligibility.reviewAvailableAt,
+    FEEDBACK_REVIEW_COOLDOWN_SECONDS
+  )) {
+    return false;
   }
-  return output;
-}
-function getPiiAudit(shape) {
-  const piiFields = [];
-  for (const key in shape) {
-    const def = shape[key];
-    if (!def) continue;
-    if (def._pii && def._pii.classification !== "none") {
-      piiFields.push({
-        field: key,
-        classification: def._pii.classification,
-        action: def._pii.action,
-        logHandling: def._pii.logHandling,
-        purpose: def._pii.purpose
-      });
-    }
+  const bugAvailableAt = value.eligibility.bugAvailableAt === void 0 ? void 0 : Date.parse(String(value.eligibility.bugAvailableAt));
+  const bugRetryAfterSeconds = value.eligibility.bugRetryAfterSeconds;
+  const bugCooldownIsConsistent = bugAvailableAt === void 0 && bugRetryAfterSeconds === void 0 || bugAvailableAt !== void 0 && typeof bugRetryAfterSeconds === "number" && bugRetryAfterSeconds === Math.ceil((bugAvailableAt - generatedAt) / 1e3);
+  if (!bugCooldownIsConsistent || value.eligibility.bugReport && (value.eligibility.bugAvailableAt !== void 0 || value.eligibility.bugRetryAfterSeconds !== void 0) || value.eligibility.review && value.eligibility.reviewAvailableAt !== void 0 || value.eligibility.bugReport && !value.flags.bugReport || value.eligibility.review && !value.flags.review || value.eligibility.gameDiagnostics && !value.flags.gameDiagnostics) {
+    return false;
   }
-  return piiFields;
-}
-function scrubPiiForDelete(shape, stored) {
-  const result = Array.isArray(stored) ? [...stored] : { ...stored };
-  const setAtPath = (target, path, val) => {
-    let cur = target;
-    for (let i = 0; i < path.length - 1; i++) {
-      const p = path[i];
-      if (p === void 0) return;
-      if (cur[p] === void 0) {
-        const next = path[i + 1];
-        cur[p] = typeof next === "number" ? [] : {};
-      }
-      cur = cur[p];
-    }
-    const last = path[path.length - 1];
-    if (last === void 0) return;
-    cur[last] = val;
-  };
-  const visit = (def, host, path, keyName) => {
-    if (!def) return;
-    const applyPath = (targetKey) => {
-      const last = path[path.length - 1];
-      if (last === void 0) return;
-      if (typeof last === "number") {
-        setAtPath(result, [...path, targetKey], null);
-      } else {
-        setAtPath(result, [...path.slice(0, -1), targetKey], null);
-      }
-    };
-    if (def._pii?.action === "encrypt") {
-      const targetKey = `${keyName}Encrypted`;
-      if (host && Object.prototype.hasOwnProperty.call(host, targetKey)) {
-        applyPath(targetKey);
-      }
-      return;
-    }
-    if (def._pii?.action === "hash") {
-      const targetKey = `${keyName}Hash`;
-      if (host && Object.prototype.hasOwnProperty.call(host, targetKey)) {
-        applyPath(targetKey);
-      }
-      return;
-    }
-    if (def._pii?.action === "clear") {
-      if (host && Object.prototype.hasOwnProperty.call(host, keyName)) {
-        setAtPath(result, path, null);
-      }
-      return;
+  if (!value.flags.transientAnalysis) {
+    return value.ingestionKey === void 0;
+  }
+  if (value.ingestionKey === void 0) {
+    return false;
+  }
+  const expiresAt = Date.parse(String(value.ingestionKey.expiresAt));
+  return Number.isFinite(expiresAt) && expiresAt > generatedAt && expiresAt - generatedAt <= 10 * 60 * 1e3;
+};
+var distributionShape = (idField = () => safeIdField(128)) => ({
+  id: idField(),
+  count: countField()
+});
+var hasUniqueIds = (values) => Array.isArray(values) && new Set(
+  values.map(
+    (value) => typeof value === "object" && value !== null ? value.id : void 0
+  )
+).size === values.length;
+var distributionTotal = (values) => Array.isArray(values) ? values.reduce(
+  (total, value) => total + (typeof value === "object" && value !== null && typeof value.count === "number" ? value.count : 0),
+  0
+) : 0;
+var distributionCountsAtMost = (values, maximum) => Array.isArray(values) && values.every(
+  (value) => typeof value === "object" && value !== null && typeof value.count === "number" && value.count <= maximum
+);
+var advisoryShape = () => ({
+  code: field.string().enum(
+    [
+      "severity-five",
+      "critical-regression",
+      "satisfaction-drop",
+      "processor-stale"
+    ]
+  ),
+  level: field.string().enum(["advisory", "critical"]),
+  triggerCount: positiveCountField(),
+  recommendationIds: field.array(
+    field.string().enum(
+      [
+        "inspect-release",
+        "verify-renderer-health",
+        "review-top-intents",
+        "verify-processor-health"
+      ]
+    )
+  ).min(1).max(8)
+});
+var orderedWindow = (value, durationMilliseconds) => {
+  const start = Date.parse(String(value.windowStart));
+  const end = Date.parse(String(value.windowEnd));
+  const generatedAt = Date.parse(String(value.generatedAt));
+  return Number.isFinite(start) && Number.isFinite(end) && Number.isFinite(generatedAt) && new Date(start).toISOString() === value.windowStart && new Date(end).toISOString() === value.windowEnd && start % durationMilliseconds === 0 && end - start === durationMilliseconds && generatedAt >= end;
+};
+var processorWindow = (processor, windowKey) => {
+  let iso;
+  let expectedLength;
+  let duration;
+  if (processor === "bug-hourly") {
+    if (!BUG_HOUR_WINDOW_PATTERN.test(windowKey)) {
+      return void 0;
     }
-    if (def.type === "object" && def._shape) {
-      const obj = host && Object.prototype.hasOwnProperty.call(host, keyName) ? host[keyName] : host;
-      for (const [k, childDef] of Object.entries(def._shape)) {
-        visit(childDef, obj, [...path, k], k);
-      }
-      return;
+    iso = `${windowKey}:00:00.000Z`;
+    expectedLength = 13;
+    duration = 60 * 60 * 1e3;
+  } else if (processor === "review-daily") {
+    if (!REVIEW_DAY_WINDOW_PATTERN.test(windowKey)) {
+      return void 0;
     }
-    if (def.type === "array" && def.itemType) {
-      const arr = host?.[keyName];
-      if (Array.isArray(arr)) {
-        arr.forEach(
-          (item, idx) => visit(def.itemType, item, [...path, idx], keyName)
-        );
-      }
-      return;
+    iso = `${windowKey}T00:00:00.000Z`;
+    expectedLength = 10;
+    duration = 24 * 60 * 60 * 1e3;
+  } else {
+    if (!RECONCILIATION_WINDOW_PATTERN.test(windowKey)) {
+      return void 0;
     }
-    if (def.type === "ref") {
-      const refShape = def._shape;
-      const ref = host?.[keyName];
-      if (refShape && ref) {
-        for (const [k, childDef] of Object.entries(refShape)) {
-          visit(childDef, ref, [...path, k], k);
-        }
-      }
+    const minute = Number(windowKey.slice(-2));
+    if (minute % 5 !== 0) {
+      return void 0;
     }
-  };
-  for (const key in shape) {
-    visit(shape[key], stored, [key], key);
+    iso = `${windowKey}:00.000Z`;
+    expectedLength = 16;
+    duration = 5 * 60 * 1e3;
   }
-  return result;
-}
-
-// src/schema.ts
-var globalSchemaRegistry = /* @__PURE__ */ new Map();
-function deepClone(value) {
-  const seen = /* @__PURE__ */ new WeakMap();
-  const cloneAny = (val) => {
-    if (val === null || typeof val !== "object") return val;
-    if (seen.has(val)) throw new TypeError("Cannot clone circular structures");
-    if (val instanceof Date) return new Date(val.getTime());
-    if (Array.isArray(val)) {
-      const arr = [];
-      seen.set(val, arr);
-      val.forEach((item) => arr.push(cloneAny(item)));
-      return arr;
-    }
-    const out = {};
-    seen.set(val, out);
-    for (const [k, v] of Object.entries(val)) out[k] = cloneAny(v);
-    return out;
-  };
-  return cloneAny(value);
-}
-function shouldIncludeField(def, options) {
-  return options.includeInternal === true || (def?._exposure ?? "public") !== "internal";
-}
-function serializeFieldValue(def, value, options) {
-  if (value === void 0) {
+  const start = Date.parse(iso);
+  if (!Number.isFinite(start) || new Date(start).toISOString().slice(0, expectedLength) !== windowKey) {
     return void 0;
   }
-  if (value === null) {
-    return null;
-  }
-  switch (def?.type) {
-    case "string":
-    case "number":
-    case "boolean":
-      return deepClone(value);
-    case "ref": {
-      if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return deepClone(value);
-      }
-      const shape = getShape(def);
-      if (!shape || Object.keys(shape).length === 0) {
-        return deepClone(value);
-      }
-      const serializedRef = {};
-      if (typeof value.type === "string") {
-        serializedRef.type = value.type;
-      }
-      if (typeof value.id === "string") {
-        serializedRef.id = value.id;
-      }
-      for (const [childKey, childDef] of Object.entries(shape)) {
-        if (!shouldIncludeField(childDef, options)) {
-          continue;
-        }
-        if (!Object.prototype.hasOwnProperty.call(value, childKey)) {
-          continue;
-        }
-        const serializedChild = serializeFieldValue(
-          childDef,
-          value[childKey],
-          options
-        );
-        if (serializedChild !== void 0) {
-          serializedRef[childKey] = serializedChild;
-        }
-      }
-      return serializedRef;
-    }
-    case "object": {
-      if (typeof value !== "object" || value === null || Array.isArray(value)) {
-        return deepClone(value);
-      }
-      const shape = getShape(def);
-      if (!shape || Object.keys(shape).length === 0) {
-        return deepClone(value);
-      }
-      const serializedObject = {};
-      for (const [childKey, childDef] of Object.entries(shape)) {
-        if (!shouldIncludeField(childDef, options)) {
-          continue;
-        }
-        if (!Object.prototype.hasOwnProperty.call(value, childKey)) {
-          continue;
-        }
-        const serializedChild = serializeFieldValue(
-          childDef,
-          value[childKey],
-          options
-        );
-        if (serializedChild !== void 0) {
-          serializedObject[childKey] = serializedChild;
-        }
-      }
-      return serializedObject;
-    }
-    case "array": {
-      if (!Array.isArray(value)) {
-        return deepClone(value);
-      }
-      if (!def.itemType) {
-        return deepClone(value);
-      }
-      return value.map((item) => serializeFieldValue(def.itemType, item, options));
-    }
-    default:
-      return deepClone(value);
+  return { start, duration };
+};
+var isProcessorArtifactConsistent = (value, artifact) => {
+  const processor = value.processor;
+  const windowKey = String(value.windowKey);
+  const window = processorWindow(processor, windowKey);
+  if (window === void 0) {
+    return false;
   }
-}
-function cmpSemver(a, b) {
-  const pa = a.split(".").map((n) => parseInt(n, 10));
-  const pb = b.split(".").map((n) => parseInt(n, 10));
-  for (let i = 0; i < 3; i++) {
-    const ai = pa[i] ?? 0;
-    const bi = pb[i] ?? 0;
-    if (ai > bi) return 1;
-    if (ai < bi) return -1;
+  const completedAt = Date.parse(
+    String(
+      artifact === "checkpoint" ? value.completedAt : value.generatedAt
+    )
+  );
+  if (!Number.isFinite(completedAt) || completedAt < window.start + window.duration) {
+    return false;
   }
-  return 0;
-}
-function applySchemaUpgrade(spec, input, ctx) {
-  if (typeof spec === "function") {
-    return spec(input, ctx);
+  if (artifact === "checkpoint" && value.checkpointId !== `checkpoint:${processor}:${windowKey}`) {
+    return false;
   }
-  const steps = [...spec].sort((s1, s2) => cmpSemver(s1.to, s2.to));
-  let working = { ...input };
-  let fromVersion = ctx.from;
-  for (const step of steps) {
-    if (cmpSemver(fromVersion, step.to) < 0 && cmpSemver(step.to, ctx.to) <= 0) {
-      ctx.log?.(`Upgrading entity from v${fromVersion} \u2192 v${step.to}`);
-      const res = step.run(working, { ...ctx, from: fromVersion, to: step.to });
-      if (!res || res.ok !== true || !res.value) {
-        return {
-          ok: false,
-          errors: res?.errors?.length ? res.errors : [`Failed to upgrade entity from v${fromVersion} to v${step.to}`]
-        };
-      }
-      working = res.value;
-      fromVersion = step.to;
-    }
+  return true;
+};
+var roundRate = (value) => Math.round((value + Number.EPSILON) * 1e6) / 1e6;
+var rateMatches = (actual, expected) => typeof actual === "number" && actual === roundRate(expected);
+var distributionCountFor = (values, id) => {
+  if (!Array.isArray(values)) {
+    return 0;
+  }
+  const entry = values.find(
+    (value) => typeof value === "object" && value !== null && value.id === id
+  );
+  return typeof entry === "object" && entry !== null && typeof entry.count === "number" ? entry.count : 0;
+};
+var advisoryCodesAreConsistent = (advisories, expected) => {
+  if (!Array.isArray(advisories)) {
+    return false;
   }
-  return { ok: true, value: working };
-}
-function validateEnum(parentKey, value, enumValues) {
-  if (!enumValues) return;
-  const values = Array.isArray(enumValues) ? enumValues : Array.from(enumValues);
-  if (Array.isArray(value)) {
-    const invalid = value.filter((v) => !values.includes(v));
-    if (invalid.length > 0) {
-      return `Field ${parentKey} contains invalid enum values: ${invalid.join(
-        ", "
-      )}`;
+  const expectedCodes = Object.entries(expected).filter(
+    (entry) => entry[1] !== void 0
+  ).map(([code]) => code);
+  const codes = advisories.map(
+    (advisory) => advisory?.code
+  );
+  return new Set(codes).size === codes.length && codes.every(
+    (code) => typeof code === "string" && expectedCodes.includes(code)
+  ) && codes.length === expectedCodes.length && expectedCodes.every((code) => codes.includes(code)) && advisories.every((advisory) => {
+    const value = advisory;
+    const code = typeof value.code === "string" ? value.code : void 0;
+    const expectation = code === void 0 ? void 0 : expected[code];
+    if (expectation === void 0 || value.level !== expectation.level || value.triggerCount !== expectation.triggerCount || !Array.isArray(value.recommendationIds) || value.recommendationIds.length !== expectation.recommendationIds.length) {
+      return false;
     }
-  } else {
-    if (!values.includes(value)) {
-      return `Field ${parentKey} must be one of: ${values.join(", ")}`;
+    return value.recommendationIds.every(
+      (recommendation, index) => recommendation === expectation.recommendationIds[index]
+    );
+  });
+};
+var FeedbackRichTextAstSchema = createSchema(
+  {
+    schemaVersion: field.string().enum(["1"]),
+    children: field.array(field.object(richTextBlockShape())).min(1).max(128)
+  },
+  "doc",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => {
+      const blocks = Array.isArray(value.children) ? value.children : [];
+      const blocksAreConsistent = blocks.every(
+        (block) => {
+          const listShapeIsValid = block.type === "paragraph" && block.listType === void 0 || block.type === "listItem" && block.listType === "bullet";
+          const marksAreUnique = Array.isArray(block.children) && block.children.every(
+            (child) => child.marks === void 0 || Array.isArray(child.marks) && new Set(child.marks).size === child.marks.length
+          );
+          return listShapeIsValid && marksAreUnique;
+        }
+      );
+      const characterCount = blocks.reduce(
+        (blockTotal, block) => blockTotal + (Array.isArray(block.children) ? block.children.reduce(
+          (nodeTotal, node) => nodeTotal + (typeof node.text === "string" ? [...node.text].length : 0),
+          0
+        ) : 0),
+        0
+      );
+      const extractedCharacterCount = characterCount + Math.max(0, blocks.length - 1);
+      const nodeCount = blocks.reduce(
+        (total, block) => total + (Array.isArray(block.children) ? block.children.length : 0),
+        0
+      );
+      return value.type === "doc" && value.schemaVersion === "1" && blocksAreConsistent && nodeCount <= 256 && extractedCharacterCount > 0 && extractedCharacterCount <= MAX_NARRATIVE_CHARACTERS;
     }
   }
-}
-function getEnumValues(def) {
-  const src = Array.isArray(def?.enum) ? def.enum : Array.isArray(def?.enumValues) ? def.enumValues : Array.isArray(def?._enum) ? def._enum : Array.isArray(def?._enumValues) ? def._enumValues : def?._enumSet instanceof Set ? Array.from(def._enumSet) : void 0;
-  if (!src) return void 0;
-  const ok = src.every(
-    (v) => typeof v === "string" || typeof v === "number"
-  );
-  return ok ? src : void 0;
-}
-function applyDefault(def, current) {
-  if ((current === void 0 || current === null) && typeof def?.getDefault === "function") {
-    const next = def.getDefault();
-    if (next !== void 0) {
-      return { value: next, applied: true };
+);
+var FeedbackEncryptedNarrativeEnvelopeSchema = createSchema(
+  envelopeShape(),
+  "feedback-encrypted-narrative-envelope",
+  strictOptions
+);
+var FeedbackTransientAnalysisRequestSchema = createSchema(
+  {
+    schemaVersion: field.string().enum(["1"]),
+    requestId: transientCorrelationIdField(),
+    purpose: field.string().enum(["bug", "review"]),
+    surfaceId: surfaceIdField().optional(),
+    deterministicRedactionCount: redactionCountField(),
+    envelope: field.object(envelopeShape(true))
+  },
+  "feedback-transient-analysis-request",
+  {
+    ...strictOptions,
+    schemaValidator: (value, context) => {
+      const surfaceWasProvided = context?.wasProvided("surfaceId") ?? Object.prototype.hasOwnProperty.call(value, "surfaceId");
+      return value.purpose === "bug" && value.surfaceId !== void 0 || value.purpose === "review" && !surfaceWasProvided;
     }
   }
-  return { value: current, applied: false };
-}
-function isOptional(def) {
-  return def?.isRequired === false;
-}
-function getValidator(def) {
-  return def?._validator ?? void 0;
-}
-function getShape(def) {
-  return def?._shape ?? def?.shape ?? void 0;
-}
-function normalizeValidationIssue(path, issue, defaultCode) {
-  if (typeof issue === "string") {
+);
+var validateFeedbackTransientAnalysisRequest = (input) => {
+  const result = FeedbackTransientAnalysisRequestSchema.validate(input);
+  if (!result.valid || result.value === void 0) {
     return {
-      path,
-      code: defaultCode,
-      message: issue
+      valid: false,
+      errors: result.errors ?? ["Transient analysis validation failed."],
+      ...result.issues === void 0 ? {} : { issues: result.issues }
     };
   }
   return {
-    path: issue.path ?? path,
-    code: issue.code || defaultCode,
-    message: issue.message
+    valid: true,
+    value: result.value
   };
-}
-function normalizeValidatorIssues(path, result, defaultCode) {
-  if (result === true) {
-    return [];
+};
+var FeedbackAnalysisReceiptSchema = createSchema(
+  analysisReceiptShape(),
+  "feedback-analysis-receipt",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => value.status === "analyzed" && isAnalysisProjectionConsistent(value)
   }
-  if (result === false) {
-    return [
-      {
-        path,
-        code: defaultCode,
-        message: `Invalid value for field: ${path}`
-      }
-    ];
+);
+var FeedbackDerivedAnalysisSchema = createSchema(
+  analysisProjectionShape(),
+  "feedback-derived-analysis",
+  {
+    ...strictOptions,
+    schemaValidator: isAnalysisProjectionConsistent
   }
-  if (Array.isArray(result)) {
-    return result.map((issue) => normalizeValidationIssue(path, issue, defaultCode));
+);
+var FeedbackSurfaceCatalogSchema = createSchema(
+  {
+    generatedAt: field.dateTimeISO(),
+    catalogVersion: safeIdField(64),
+    surfaces: field.array(field.object(surfaceEntryShape())).max(256)
+  },
+  "feedback-surface-catalog",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => areSurfacesConsistent(value.surfaces)
   }
-  return [normalizeValidationIssue(path, result, defaultCode)];
-}
-function checkMissingRequired(parentKey, key, value, def, errors) {
-  if (value === void 0 || value === null) {
-    const path = parentKey ? `${parentKey}.${key}` : key;
-    if (!isOptional(def)) {
-      errors.push(`Missing required field: ${path}`);
-    }
-    return { missing: true };
+);
+var FeedbackContextSchema = createSchema(
+  {
+    generatedAt: field.dateTimeISO(),
+    catalogVersion: safeIdField(64),
+    surfaces: field.array(field.object(surfaceEntryShape())).max(256),
+    selectedSurfaceId: surfaceIdField().optional(),
+    flags: field.object({
+      bugReport: field.boolean(),
+      review: field.boolean(),
+      transientAnalysis: field.boolean(),
+      reporting: field.boolean(),
+      admin: field.boolean(),
+      mcp: field.boolean(),
+      publicHonesty: field.boolean(),
+      gameDiagnostics: field.boolean(),
+      anonymous: field.boolean()
+    }),
+    eligibility: field.object({
+      bugReport: field.boolean(),
+      review: field.boolean(),
+      gameDiagnostics: field.boolean(),
+      bugAvailableAt: field.dateTimeISO().optional(),
+      reviewAvailableAt: field.dateTimeISO().optional(),
+      bugRetryAfterSeconds: positiveCountField().optional()
+    }),
+    ingestionKey: field.object({
+      keyId: ingestionKeyIdField(),
+      algorithm: field.string().enum(["RSA-OAEP-256"]),
+      publicJwk: field.object({
+        kty: field.string().enum(["RSA"]),
+        alg: field.string().enum(["RSA-OAEP-256"]),
+        use: field.string().enum(["enc"]),
+        key_ops: field.array(field.string().enum(["wrapKey"])).min(1).max(1),
+        n: field.string().min(342).max(683).pattern(BASE64URL_PATTERN).validator(isCanonicalRsaModulus),
+        e: field.string().min(2).max(6).pattern(BASE64URL_PATTERN).validator(isCanonicalRsaExponent),
+        ext: field.boolean().validator((value) => value === true)
+      }),
+      expiresAt: field.dateTimeISO()
+    }).optional()
+  },
+  "feedback-context",
+  {
+    ...strictOptions,
+    schemaValidator: isContextConsistent
   }
-  return { missing: false };
-}
-function checkImmutable(parentKey, key, value, def, existing, errors) {
-  if (def.isImmutable && existing && existing[key] !== void 0 && value !== existing[key]) {
-    const path = parentKey ? `${parentKey}.${key}` : key;
-    errors.push(`Field is immutable: ${path}`);
-    return { immutableViolation: true };
+);
+var FeedbackDraftUpsertRequestSchema = createSchema(
+  {
+    draftId: draftIdField(),
+    kind: field.string().enum(["bug", "review"]),
+    revision: revisionField(),
+    ...optionalDraftFields()
+  },
+  "feedback-draft-upsert-request",
+  {
+    ...strictOptions,
+    schemaValidator: isDraftShapeConsistent
   }
-  return { immutableViolation: false };
-}
-function runCustomValidator(parentKey, key, value, def, errors, issues) {
-  const validator = getValidator(def);
-  if (validator && value !== void 0 && value !== null) {
-    const path = parentKey ? `${parentKey}.${key}` : key;
-    const normalizedIssues = normalizeValidatorIssues(path, validator(value), "invalid_value");
-    if (normalizedIssues.length > 0) {
-      errors.push(...normalizedIssues.map((issue) => issue.message));
-      if (issues) {
-        issues.push(...normalizedIssues);
+);
+var FeedbackDraftPacketSchema = createSchema(
+  {
+    draftId: draftIdField(),
+    kind: field.string().enum(["bug", "review"]),
+    revision: revisionField(),
+    surfaceId: surfaceIdField().optional(),
+    issueType: field.string().enum(FEEDBACK_ISSUE_TYPES).optional(),
+    severity: ratingField().optional(),
+    satisfaction: ratingField().optional(),
+    analysis: field.object(analysisProjectionShape(true)).optional(),
+    serverUpdatedAt: field.dateTimeISO(),
+    expiresAt: field.dateTimeISO()
+  },
+  "feedback-draft-packet",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => {
+      if (!isDraftShapeConsistent(value)) {
+        return false;
       }
-      return { invalid: true };
-    }
-  }
-  return { invalid: false };
-}
-function validateStringField(parentKey, key, value, def, errors) {
-  const path = parentKey ? `${parentKey}.${key}` : key;
-  if (typeof value !== "string") {
-    errors.push(`Field ${path} must be string`);
-    return;
-  }
-  const enumValues = getEnumValues(def);
-  if (Array.isArray(enumValues)) {
-    const enumError = validateEnum(path, value, enumValues);
-    if (enumError) {
-      errors.push(enumError);
+      if (value.analysis !== void 0 && !isAnalysisProjectionConsistent(value.analysis)) {
+        return false;
+      }
+      const updatedAt = Date.parse(String(value.serverUpdatedAt));
+      const expiresAt = Date.parse(String(value.expiresAt));
+      return Number.isFinite(updatedAt) && Number.isFinite(expiresAt) && expiresAt > updatedAt && expiresAt - updatedAt <= 24 * 60 * 60 * 1e3;
     }
   }
-}
-function validateNumberField(parentKey, key, value, def, errors) {
-  const path = parentKey ? `${parentKey}.${key}` : key;
-  if (typeof value !== "number") {
-    errors.push(`Field ${path} must be number`);
-    return;
-  }
-  const enumValues = getEnumValues(def);
-  if (Array.isArray(enumValues)) {
-    const enumError = validateEnum(path, value, enumValues);
-    if (enumError) {
-      errors.push(enumError);
+);
+var FeedbackDraftReceiptSchema = createSchema(
+  {
+    draftId: draftIdField(),
+    revision: revisionField(),
+    savedAt: field.dateTimeISO(),
+    expiresAt: field.dateTimeISO()
+  },
+  "feedback-draft-receipt",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => {
+      const savedAt = Date.parse(String(value.savedAt));
+      const expiresAt = Date.parse(String(value.expiresAt));
+      return Number.isFinite(savedAt) && Number.isFinite(expiresAt) && expiresAt > savedAt && expiresAt - savedAt <= 24 * 60 * 60 * 1e3;
     }
   }
-}
-function validateBooleanField(parentKey, key, value, _def, errors) {
-  const path = parentKey ? `${parentKey}.${key}` : key;
-  if (typeof value !== "boolean") {
-    errors.push(`Field ${path} must be boolean`);
+);
+var FeedbackBugSubmissionRequestSchema = createSchema(
+  {
+    draftId: draftIdField().optional(),
+    surfaceId: surfaceIdField(),
+    issueType: field.string().enum(FEEDBACK_ISSUE_TYPES),
+    severity: ratingField(),
+    analysisReceiptId: transientCorrelationIdField().optional(),
+    gameDiagnostics: field.object(feedbackGameDiagnosticsShape(true)).optional()
+  },
+  "feedback-bug-submission-request",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => value.issueType !== "privacy-security" && (value.gameDiagnostics === void 0 || isFeedbackGameDiagnosticsConsistent(value.gameDiagnostics) && value.gameDiagnostics.surfaceId === value.surfaceId)
   }
-}
-function validateObjectChildren(parentKey, obj, shape, errors, issues, existing, piiEnforcement, logger) {
-  for (const [childKey, childDef] of Object.entries(shape)) {
-    let childValue = obj[childKey];
-    const existingChild = existing && typeof existing === "object" ? existing[childKey] : void 0;
-    const { value: withDefault, applied } = applyDefault(childDef, childValue);
-    if (applied) {
-      obj[childKey] = withDefault;
-      childValue = withDefault;
+);
+var FeedbackReviewSubmissionRequestSchema = createSchema(
+  {
+    draftId: draftIdField().optional(),
+    satisfaction: ratingField(),
+    analysisReceiptId: transientCorrelationIdField().optional()
+  },
+  "feedback-review-submission-request",
+  strictOptions
+);
+var FeedbackAcceptanceReceiptSchema = createSchema(
+  {
+    packetId: uuidField(),
+    kind: field.string().enum(["bug", "review"]),
+    acceptedAt: field.dateTimeISO(),
+    nextEligibleAt: field.dateTimeISO()
+  },
+  "feedback-acceptance-receipt",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => {
+      const acceptedAt = Date.parse(String(value.acceptedAt));
+      const nextEligibleAt = Date.parse(String(value.nextEligibleAt));
+      const cooldownMilliseconds = nextEligibleAt - acceptedAt;
+      if (!Number.isFinite(acceptedAt) || !Number.isFinite(nextEligibleAt) || cooldownMilliseconds <= 0 || cooldownMilliseconds % 1e3 !== 0) {
+        return false;
+      }
+      const cooldownSeconds = cooldownMilliseconds / 1e3;
+      return value.kind === "review" ? cooldownSeconds === FEEDBACK_REVIEW_COOLDOWN_SECONDS : FEEDBACK_BUG_COOLDOWN_SECONDS.includes(
+        cooldownSeconds
+      );
     }
-    const { missing } = checkMissingRequired(
-      parentKey,
-      childKey,
-      childValue,
-      childDef,
-      errors
-    );
-    if (missing) continue;
-    const { immutableViolation } = checkImmutable(
-      parentKey,
-      childKey,
-      childValue,
-      childDef,
-      existing,
-      errors
-    );
-    if (immutableViolation) continue;
-    const { shortCircuit } = enforcePIIField(
-      parentKey,
-      childKey,
-      childValue,
-      childDef,
-      piiEnforcement,
-      errors,
-      logger
-    );
-    if (shortCircuit) continue;
-    const { invalid } = runCustomValidator(
-      parentKey,
-      childKey,
-      childValue,
-      childDef,
-      errors,
-      issues
-    );
-    if (invalid) continue;
-    validateByType(
-      parentKey,
-      childKey,
-      childValue,
-      childDef,
-      errors,
-      issues,
-      existingChild,
-      piiEnforcement,
-      logger
-    );
   }
-}
-function validateObjectField(parentKey, key, value, def, errors, issues, existing, piiEnforcement, logger) {
-  const path = parentKey ? `${parentKey}.${key}` : key;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    errors.push(`Field ${path} must be object`);
-    return;
+);
+var FeedbackStructuredOnlyAnalysisResultSchema = createSchema(
+  {
+    status: field.string().enum(["structured-only-required"]),
+    reasonCode: field.string().enum(FEEDBACK_STRUCTURED_ONLY_REASON_CODES)
+  },
+  "feedback-structured-only-analysis-result",
+  strictOptions
+);
+var FeedbackBugPacketSchema = createSchema(
+  {
+    packetId: uuidField(),
+    acceptedAt: field.dateTimeISO(),
+    surfaceId: surfaceIdField(),
+    issueType: field.string().enum(FEEDBACK_PERSISTABLE_ISSUE_TYPES),
+    severity: ratingField(),
+    releaseId: safeIdField(128),
+    buildId: safeIdField(128),
+    analysis: field.object(analysisProjectionShape(true)).optional(),
+    gameDiagnostics: field.object(feedbackGameDiagnosticsShape(true)).optional()
+  },
+  "feedback-bug-packet",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => (value.analysis === void 0 || isAnalysisProjectionConsistent(value.analysis)) && (value.gameDiagnostics === void 0 || isFeedbackGameDiagnosticsConsistent(value.gameDiagnostics) && value.gameDiagnostics.surfaceId === value.surfaceId)
   }
-  const objShape = getShape(def);
-  if (objShape)
-    validateObjectChildren(path, value, objShape, errors, issues, existing, piiEnforcement, logger);
-}
-function validateArrayOfStrings(parentKey, key, arr, itemDef, errors) {
-  const path = parentKey ? `${parentKey}.${key}` : key;
-  if (!arr.every((v) => typeof v === "string")) {
-    errors.push(`Field ${path} must be string[]`);
-    return;
+);
+var FeedbackReviewPacketSchema = createSchema(
+  {
+    packetId: uuidField(),
+    acceptedAt: field.dateTimeISO(),
+    satisfaction: ratingField(),
+    analysis: field.object(analysisProjectionShape(true)).optional()
+  },
+  "feedback-review-packet",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => value.analysis === void 0 || isAnalysisProjectionConsistent(value.analysis)
   }
-  const enumValues = getEnumValues(itemDef);
-  if (Array.isArray(enumValues)) {
-    const enumError = validateEnum(path, arr, enumValues);
-    if (enumError) {
-      errors.push(enumError);
+);
+var FeedbackGameReconstructionManifestSchema = createSchema(
+  {
+    reconstructionId: uuidField(),
+    bugPacketId: uuidField(),
+    createdAt: field.dateTimeISO(),
+    expiresAt: field.dateTimeISO(),
+    curatedAssetSetId: safeIdField(128),
+    noticeKey: safeIdField(160),
+    diagnostics: field.object(feedbackGameDiagnosticsShape(true))
+  },
+  "feedback-game-reconstruction-manifest",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => {
+      const createdAt = Date.parse(String(value.createdAt));
+      const expiresAt = Date.parse(String(value.expiresAt));
+      return isFeedbackGameDiagnosticsConsistent(value.diagnostics) && Number.isFinite(createdAt) && Number.isFinite(expiresAt) && expiresAt > createdAt && expiresAt - createdAt <= 30 * 24 * 60 * 60 * 1e3;
     }
   }
-  const validator = getValidator(itemDef);
-  if (validator) {
-    arr.forEach((v, idx) => {
-      if (!validator(v)) {
-        errors.push(`Invalid value for field: ${path}[${idx}]`);
-      }
-    });
+);
+var FeedbackHourlyBugReportSchema = createSchema(
+  {
+    reportId: uuidField(),
+    windowStart: field.dateTimeISO(),
+    windowEnd: field.dateTimeISO(),
+    revision: revisionField(),
+    generatedAt: field.dateTimeISO(),
+    acceptedCount: countField(),
+    rejectedCount: countField(),
+    diagnosticsAttachedCount: countField(),
+    deterministicRedactionCount: countField(),
+    scannerRedactionCount: countField(),
+    processorLagSeconds: countField(),
+    rates: field.object({
+      rejectionRate: field.number().min(0).max(1),
+      deterministicRedactionsPerAccepted: field.number().min(0).max(4e3),
+      scannerRedactionsPerAccepted: field.number().min(0).max(4e3)
+    }),
+    traffic: field.object({
+      denominator: countField(),
+      acceptedPerTenThousand: field.number().min(0).max(MAX_COUNT).optional()
+    }),
+    targetDistribution: field.array(field.object(distributionShape(surfaceIdField))).max(256),
+    issueTypeDistribution: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(FEEDBACK_PERSISTABLE_ISSUE_TYPES)
+        )
+      )
+    ).max(FEEDBACK_ISSUE_TYPES.length),
+    severityDistribution: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(["1", "2", "3", "4", "5"])
+        )
+      )
+    ).max(5),
+    intentDistribution: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(FEEDBACK_INTENT_IDS)
+        )
+      )
+    ).max(FEEDBACK_INTENT_IDS.length),
+    buildDistribution: field.array(field.object(distributionShape())).max(128),
+    rendererDistribution: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(FEEDBACK_RENDERER_BUCKETS)
+        )
+      )
+    ).max(FEEDBACK_RENDERER_BUCKETS.length),
+    backendDistribution: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(FEEDBACK_BACKEND_BUCKETS)
+        )
+      )
+    ).max(FEEDBACK_BACKEND_BUCKETS.length),
+    viewportDistribution: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(FEEDBACK_VIEWPORT_BUCKETS)
+        )
+      )
+    ).max(FEEDBACK_VIEWPORT_BUCKETS.length),
+    frameRateDistribution: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(FEEDBACK_FRAME_RATE_BUCKETS)
+        )
+      )
+    ).max(FEEDBACK_FRAME_RATE_BUCKETS.length),
+    frameTimeDistribution: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(FEEDBACK_FRAME_TIME_BUCKETS)
+        )
+      )
+    ).max(FEEDBACK_FRAME_TIME_BUCKETS.length),
+    diagnosticFeatureDistribution: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(FEEDBACK_GAME_FEATURE_IDS)
+        )
+      )
+    ).max(FEEDBACK_GAME_FEATURE_IDS.length),
+    diagnosticCounterDistribution: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(FEEDBACK_GAME_COUNTER_CODES)
+        )
+      )
+    ).max(FEEDBACK_GAME_COUNTER_CODES.length),
+    diagnosticErrorDistribution: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(FEEDBACK_GAME_ERROR_CODES)
+        )
+      )
+    ).max(FEEDBACK_GAME_ERROR_CODES.length),
+    abuseBlockBands: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(
+            [
+              "five-minutes",
+              "fifteen-minutes",
+              "one-hour",
+              "six-hours",
+              "twenty-four-hours",
+              "fail-closed",
+              "edge-blocked"
+            ]
+          )
+        )
+      )
+    ).max(16),
+    comparison: field.object({
+      previousHourRatio: field.number().min(0).max(1e3),
+      sevenDaySameHourRatio: field.number().min(0).max(1e3)
+    }),
+    advisories: field.array(field.object(advisoryShape())).max(32)
+  },
+  "feedback-hourly-bug-report",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => {
+      const distributions = [
+        value.targetDistribution,
+        value.issueTypeDistribution,
+        value.severityDistribution,
+        value.intentDistribution,
+        value.buildDistribution,
+        value.rendererDistribution,
+        value.backendDistribution,
+        value.viewportDistribution,
+        value.frameRateDistribution,
+        value.frameTimeDistribution,
+        value.diagnosticFeatureDistribution,
+        value.diagnosticCounterDistribution,
+        value.diagnosticErrorDistribution,
+        value.abuseBlockBands
+      ];
+      const submittedCount = value.acceptedCount + value.rejectedCount;
+      const expectedRejectionRate = submittedCount === 0 ? 0 : value.rejectedCount / submittedCount;
+      const expectedDeterministicRate = value.acceptedCount === 0 ? 0 : value.deterministicRedactionCount / value.acceptedCount;
+      const expectedScannerRate = value.acceptedCount === 0 ? 0 : value.scannerRedactionCount / value.acceptedCount;
+      const trafficIsConsistent = value.traffic.denominator === 0 && value.traffic.acceptedPerTenThousand === void 0 || value.traffic.denominator > 0 && rateMatches(
+        value.traffic.acceptedPerTenThousand,
+        value.acceptedCount * 1e4 / value.traffic.denominator
+      );
+      const severityFiveCount = distributionCountFor(
+        value.severityDistribution,
+        "5"
+      );
+      const criticalRegression = severityFiveCount >= 3 || value.acceptedCount >= 5 && value.comparison.sevenDaySameHourRatio >= 3;
+      const lagSeconds = Math.floor(
+        (Date.parse(String(value.generatedAt)) - Date.parse(String(value.windowEnd))) / 1e3
+      );
+      return orderedWindow(value, 60 * 60 * 1e3) && value.revision >= 1 && value.processorLagSeconds === lagSeconds && value.diagnosticsAttachedCount <= value.acceptedCount && (value.acceptedCount > 0 || value.deterministicRedactionCount === 0 && value.scannerRedactionCount === 0) && rateMatches(value.rates.rejectionRate, expectedRejectionRate) && rateMatches(
+        value.rates.deterministicRedactionsPerAccepted,
+        expectedDeterministicRate
+      ) && rateMatches(
+        value.rates.scannerRedactionsPerAccepted,
+        expectedScannerRate
+      ) && trafficIsConsistent && distributions.every(hasUniqueIds) && advisoryCodesAreConsistent(value.advisories, {
+        "severity-five": severityFiveCount > 0 ? {
+          level: "advisory",
+          triggerCount: severityFiveCount,
+          recommendationIds: ["inspect-release"]
+        } : void 0,
+        "critical-regression": criticalRegression ? {
+          level: "critical",
+          triggerCount: severityFiveCount >= 3 ? severityFiveCount : value.acceptedCount,
+          recommendationIds: [
+            "inspect-release",
+            "verify-renderer-health"
+          ]
+        } : void 0,
+        "processor-stale": lagSeconds > 10 * 60 ? {
+          level: "critical",
+          triggerCount: lagSeconds,
+          recommendationIds: ["verify-processor-health"]
+        } : void 0
+      }) && distributionTotal(value.targetDistribution) === value.acceptedCount && distributionTotal(value.issueTypeDistribution) === value.acceptedCount && distributionTotal(value.severityDistribution) === value.acceptedCount && distributionCountsAtMost(
+        value.intentDistribution,
+        value.acceptedCount
+      ) && distributionTotal(value.intentDistribution) <= value.acceptedCount * 8 && distributionTotal(value.buildDistribution) === value.acceptedCount && distributionTotal(value.rendererDistribution) === value.diagnosticsAttachedCount && distributionTotal(value.backendDistribution) === value.diagnosticsAttachedCount && distributionTotal(value.viewportDistribution) === value.diagnosticsAttachedCount && distributionTotal(value.frameRateDistribution) === value.diagnosticsAttachedCount && distributionTotal(value.frameTimeDistribution) === value.diagnosticsAttachedCount && distributionTotal(value.diagnosticFeatureDistribution) <= value.diagnosticsAttachedCount * FEEDBACK_GAME_FEATURE_IDS.length && distributionCountsAtMost(
+        value.diagnosticFeatureDistribution,
+        value.diagnosticsAttachedCount
+      ) && distributionTotal(value.diagnosticCounterDistribution) <= value.diagnosticsAttachedCount * FEEDBACK_GAME_COUNTER_CODES.length * 1e4 && distributionCountsAtMost(
+        value.diagnosticCounterDistribution,
+        value.diagnosticsAttachedCount * 1e4
+      ) && distributionTotal(value.diagnosticErrorDistribution) <= value.diagnosticsAttachedCount * FEEDBACK_GAME_ERROR_CODES.length && distributionCountsAtMost(
+        value.diagnosticErrorDistribution,
+        value.diagnosticsAttachedCount
+      );
+    }
   }
-}
-function validateArrayOfNumbers(parentKey, key, arr, itemDef, errors) {
-  const path = parentKey ? `${parentKey}.${key}` : key;
-  if (!arr.every((v) => typeof v === "number")) {
-    errors.push(`Field ${path} must be number[]`);
+);
+var rollingSatisfactionShape = () => ({
+  period: field.string().enum(["7-days", "30-days", "90-days"]),
+  reviewCount: countField(),
+  meanStars: field.number().min(1).max(5).optional()
+});
+var satisfactionStatistics = (distribution, total) => {
+  if (!Array.isArray(distribution) || total <= 0) {
+    return void 0;
   }
-  const enumValues = getEnumValues(itemDef);
-  if (Array.isArray(enumValues)) {
-    const enumError = validateEnum(path, arr, enumValues);
-    if (enumError) {
-      errors.push(enumError);
+  const counts = [1, 2, 3, 4, 5].map(
+    (star) => distributionCountFor(distribution, String(star))
+  );
+  const weightedTotal = counts.reduce(
+    (sum, count, index) => sum + count * (index + 1),
+    0
+  );
+  const valueAtPosition = (position) => {
+    let cumulative = 0;
+    for (let index = 0; index < counts.length; index += 1) {
+      cumulative += counts[index] ?? 0;
+      if (cumulative >= position) {
+        return index + 1;
+      }
     }
-  }
-  const validator = getValidator(itemDef);
-  if (validator) {
-    arr.forEach((v, idx) => {
-      if (!validator(v)) {
-        errors.push(`Invalid value for field: ${path}[${idx}]`);
+    return 5;
+  };
+  const lower = valueAtPosition(Math.ceil(total / 2));
+  const upper = valueAtPosition(Math.floor(total / 2) + 1);
+  return {
+    mean: Math.round(weightedTotal / total * 10) / 10,
+    median: (lower + upper) / 2
+  };
+};
+var FeedbackDailySatisfactionReportSchema = createSchema(
+  {
+    reportId: uuidField(),
+    windowStart: field.dateTimeISO(),
+    windowEnd: field.dateTimeISO(),
+    revision: revisionField(),
+    generatedAt: field.dateTimeISO(),
+    processorLagSeconds: countField(),
+    acceptedReviewCount: countField(),
+    meanStars: field.number().min(1).max(5).optional(),
+    medianStars: field.number().min(1).max(5).optional(),
+    starDistribution: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(["1", "2", "3", "4", "5"])
+        )
+      )
+    ).max(5),
+    sentimentDistribution: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(FEEDBACK_SENTIMENT_BUCKETS)
+        )
+      )
+    ).max(FEEDBACK_SENTIMENT_BUCKETS.length),
+    intentDistribution: field.array(
+      field.object(
+        distributionShape(
+          () => field.string().enum(FEEDBACK_INTENT_IDS)
+        )
+      )
+    ).max(FEEDBACK_INTENT_IDS.length),
+    rollingWindows: field.array(field.object(rollingSatisfactionShape())).max(3),
+    previousPeriodDeltaStars: field.number().min(-4).max(4).optional(),
+    advisories: field.array(field.object(advisoryShape())).max(32)
+  },
+  "feedback-daily-satisfaction-report",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => {
+      if (!orderedWindow(value, 24 * 60 * 60 * 1e3)) {
+        return false;
       }
-    });
-  }
-}
-function validateArrayOfBooleans(parentKey, key, arr, _itemDef, errors) {
-  const path = parentKey ? `${parentKey}.${key}` : key;
-  if (!arr.every((v) => typeof v === "boolean")) {
-    errors.push(`Field ${path} must be boolean[]`);
-  }
-  const validator = getValidator(_itemDef);
-  if (validator) {
-    arr.forEach((v, idx) => {
-      if (!validator(v)) {
-        errors.push(`Invalid value for field: ${path}[${idx}]`);
+      if (value.acceptedReviewCount === 0 && (value.meanStars !== void 0 || value.medianStars !== void 0)) {
+        return false;
       }
-    });
-  }
-}
-function validateArrayOfObjects(parentKey, key, arr, itemDef, errors, issues, existing, piiEnforcement, logger) {
-  const path = parentKey ? `${parentKey}.${key}` : key;
-  if (!Array.isArray(arr) || !arr.every((v) => typeof v === "object" && v !== null && !Array.isArray(v))) {
-    errors.push(`Field ${path} must be object[]`);
-    return;
-  }
-  const itemShape = getShape(itemDef);
-  if (!itemShape) return;
-  arr.forEach((item, idx) => {
-    const itemParent = `${path}[${idx}]`;
-    const existingItem = Array.isArray(existing) ? existing[idx] : void 0;
-    for (const [childKey, childDef] of Object.entries(itemShape)) {
-      let childValue = item[childKey];
-      const existingChild = existingItem && typeof existingItem === "object" ? existingItem[childKey] : void 0;
-      const { value: withDefault, applied } = applyDefault(
-        childDef,
-        childValue
-      );
-      if (applied) {
-        item[childKey] = withDefault;
-        childValue = withDefault;
+      if (value.acceptedReviewCount > 0 && (value.meanStars === void 0 || value.medianStars === void 0)) {
+        return false;
       }
-      const { missing } = checkMissingRequired(
-        itemParent,
-        childKey,
-        childValue,
-        childDef,
-        errors
+      const distributions = [
+        value.starDistribution,
+        value.sentimentDistribution,
+        value.intentDistribution
+      ];
+      const periods = value.rollingWindows.map(
+        (window) => window.period
       );
-      if (missing) continue;
-      const { immutableViolation } = checkImmutable(
-        itemParent,
-        childKey,
-        childValue,
-        childDef,
-        existingItem,
-        errors
+      const sevenDayWindow = value.rollingWindows.find(
+        (window) => window.period === "7-days"
       );
-      if (immutableViolation) continue;
-      const { shortCircuit } = enforcePIIField(
-        itemParent,
-        childKey,
-        childValue,
-        childDef,
-        piiEnforcement,
-        errors,
-        logger
+      const thirtyDayWindow = value.rollingWindows.find(
+        (window) => window.period === "30-days"
       );
-      if (shortCircuit) continue;
-      const { invalid } = runCustomValidator(
-        itemParent,
-        childKey,
-        childValue,
-        childDef,
-        errors,
-        issues
+      const ninetyDayWindow = value.rollingWindows.find(
+        (window) => window.period === "90-days"
       );
-      if (invalid) continue;
-      validateByType(
-        itemParent,
-        childKey,
-        childValue,
-        childDef,
-        errors,
-        issues,
-        existingChild,
-        piiEnforcement,
-        logger
-      );
-    }
-  });
-}
-function validateArrayField(parentKey, key, value, def, errors, issues, existing, piiEnforcement, logger) {
-  const path = parentKey ? `${parentKey}.${key}` : key;
-  if (!Array.isArray(value)) {
-    errors.push(`Field ${key} must be an array`);
-    return;
-  }
-  const itemType = def.itemType?.type;
-  if (itemType === "string")
-    return validateArrayOfStrings(parentKey, key, value, def.itemType, errors);
-  if (itemType === "number")
-    return validateArrayOfNumbers(parentKey, key, value, def.itemType, errors);
-  if (itemType === "boolean")
-    return validateArrayOfBooleans(parentKey, key, value, def.itemType, errors);
-  if (itemType === "object")
-    return validateArrayOfObjects(
-      parentKey,
-      key,
-      value,
-      def.itemType,
-      errors,
-      issues,
-      existing,
-      piiEnforcement,
-      logger
-    );
-  if (itemType === "ref") {
-    const expectedType = def.itemType.refType;
-    value.forEach((ref, idx) => {
-      if (!ref || typeof ref !== "object" || ref === null || typeof ref.type !== "string" || typeof ref.id !== "string" || expectedType && ref.type !== expectedType) {
-        errors.push(
-          `Field ${path}[${idx}] must be a reference object with type: ${expectedType}`
-        );
+      if (sevenDayWindow === void 0 || thirtyDayWindow === void 0 || ninetyDayWindow === void 0) {
+        return false;
       }
-    });
-    const refShape = getShape(def.itemType);
-    if (refShape) {
-      const existingRefs = Array.isArray(existing) ? existing : [];
-      value.forEach((ref, idx) => {
-        if (ref && typeof ref === "object" && ref !== null) {
-          const existingRef = existingRefs[idx];
-          for (const [childKey, childDef] of Object.entries(refShape)) {
-            const childPath = `${path}[${idx}].${childKey}`;
-            let childValue = ref[childKey];
-            const existingChild = existingRef && typeof existingRef === "object" ? existingRef[childKey] : void 0;
-            const { value: withDefault, applied } = applyDefault(
-              childDef,
-              childValue
-            );
-            if (applied) {
-              ref[childKey] = withDefault;
-              childValue = withDefault;
-            }
-            if ((childValue === void 0 || childValue === null) && !isOptional(childDef)) {
-              errors.push(`Missing required field: ${childPath}`);
-              continue;
-            }
-            const { immutableViolation } = checkImmutable(
-              `${path}[${idx}]`,
-              childKey,
-              childValue,
-              childDef,
-              existingRef,
-              errors
-            );
-            if (immutableViolation) continue;
-            const { shortCircuit } = enforcePIIField(
-              `${path}[${idx}]`,
-              childKey,
-              childValue,
-              childDef,
-              piiEnforcement,
-              errors,
-              logger
-            );
-            if (shortCircuit) continue;
-            const childValidator = getValidator(childDef);
-            if (childValidator && childValue !== void 0 && childValue !== null) {
-              const normalizedIssues = normalizeValidatorIssues(
-                childPath,
-                childValidator(childValue),
-                "invalid_value"
-              );
-              if (normalizedIssues.length > 0) {
-                errors.push(...normalizedIssues.map((issue) => issue.message));
-                issues.push(...normalizedIssues);
-                continue;
-              }
-            }
-            validateByType(
-              `${path}[${idx}]`,
-              childKey,
-              childValue,
-              childDef,
-              errors,
-              issues,
-              existingChild,
-              piiEnforcement,
-              logger
-            );
-          }
-        }
-      });
-    }
-    return;
-  }
-  errors.push(`Field ${path} has unsupported array item type`);
-}
-function validateRefField(parentKey, key, value, def, errors, _existing, _piiEnforcement, _logger) {
-  const path = parentKey ? `${parentKey}.${key}` : key;
-  if (typeof value !== "object" || value === null || typeof value.type !== "string" || typeof value.id !== "string") {
-    errors.push(`Field ${path} must be { type: string; id: string }`);
-    return;
-  }
-  const expectedType = def.refType;
-  if (expectedType && value.type !== expectedType) {
-    errors.push(
-      `Field ${path} must reference type: ${expectedType} (got ${value.type})`
-    );
-  }
-}
-function validateByType(parentKey, key, value, def, errors, issues, existing, piiEnforcement, logger) {
-  const path = parentKey ? `${parentKey}.${key}` : key;
-  switch (def.type) {
-    case "string":
-      return validateStringField(parentKey, key, value, def, errors);
-    case "number":
-      return validateNumberField(parentKey, key, value, def, errors);
-    case "boolean":
-      return validateBooleanField(parentKey, key, value, def, errors);
-    case "object":
-      return validateObjectField(
-        parentKey,
-        key,
-        value,
-        def,
-        errors,
-        issues,
-        existing,
-        piiEnforcement,
-        logger
+      const statistics = satisfactionStatistics(
+        value.starDistribution,
+        value.acceptedReviewCount
       );
-    case "array":
-      return validateArrayField(
-        parentKey,
-        key,
-        value,
-        def,
-        errors,
-        issues,
-        existing,
-        piiEnforcement,
-        logger
+      const lagSeconds = Math.floor(
+        (Date.parse(String(value.generatedAt)) - Date.parse(String(value.windowEnd))) / 1e3
       );
-    case "ref":
-      return validateRefField(parentKey, key, value, def, errors, existing, piiEnforcement, logger);
-    default:
-      errors.push(`Unknown type for field ${path}: ${def.type}`);
+      const satisfactionDrop = sevenDayWindow.reviewCount >= 20 && typeof value.previousPeriodDeltaStars === "number" && value.previousPeriodDeltaStars <= -0.3;
+      return value.revision >= 1 && value.processorLagSeconds === lagSeconds && distributions.every(hasUniqueIds) && distributionTotal(value.starDistribution) === value.acceptedReviewCount && distributionTotal(value.sentimentDistribution) <= value.acceptedReviewCount && distributionCountsAtMost(
+        value.sentimentDistribution,
+        value.acceptedReviewCount
+      ) && distributionTotal(value.intentDistribution) <= value.acceptedReviewCount * 8 && distributionCountsAtMost(
+        value.intentDistribution,
+        value.acceptedReviewCount
+      ) && periods.length === 3 && new Set(periods).size === 3 && (statistics === void 0 && value.meanStars === void 0 && value.medianStars === void 0 || statistics !== void 0 && value.meanStars === statistics.mean && value.medianStars === statistics.median) && advisoryCodesAreConsistent(value.advisories, {
+        "satisfaction-drop": satisfactionDrop ? {
+          level: "advisory",
+          triggerCount: sevenDayWindow.reviewCount,
+          recommendationIds: ["review-top-intents"]
+        } : void 0,
+        "processor-stale": lagSeconds > 2.5 * 60 * 60 ? {
+          level: "critical",
+          triggerCount: lagSeconds,
+          recommendationIds: ["verify-processor-health"]
+        } : void 0
+      }) && value.rollingWindows.every(
+        (window) => window.reviewCount === 0 && window.meanStars === void 0 || window.reviewCount > 0 && window.meanStars !== void 0
+      ) && value.acceptedReviewCount <= sevenDayWindow.reviewCount && sevenDayWindow.reviewCount <= thirtyDayWindow.reviewCount && thirtyDayWindow.reviewCount <= ninetyDayWindow.reviewCount;
+    }
   }
-}
-function createSchema(_shape, entityType, options = {
-  version: "1.0.0",
-  table: "",
-  schemaValidator: () => true,
-  piiEnforcement: "none",
-  schemaUpgrade: void 0
-}) {
-  const systemFields = {
-    type: field.string().immutable().system(),
-    version: field.string().immutable().system().validator(validateSemVer)
-  };
-  const version = options.version || "1.0.0";
-  const store = options.table || "";
-  const schemaUpgrade = options.schemaUpgrade;
-  const schema = {
-    // 🔗 Define the schema shape
-    _shape: {
-      ...systemFields,
-      ..._shape
-    },
-    // 🔗 Metadata about the schema
-    meta: { entityType, version },
-    // 🔗 Validate input against the schema
-    validate(input, existing) {
-      const errors = [];
-      const issues = [];
-      const result = {};
-      const piiMode = options.piiEnforcement ?? "none";
-      if (typeof input !== "object" || input === null) {
-        return { valid: false, errors: ["Input must be an object"] };
-      }
-      const working = typeof input === "object" && input !== null ? deepClone(input) : { ...input };
-      if (working.type == null) working.type = entityType;
-      if (working.version == null) working.version = version;
-      const fromVersion = String(working.version ?? "0.0.0");
-      const toVersion = String(version);
-      if (schemaUpgrade && cmpSemver(fromVersion, toVersion) < 0) {
-        const upgradeRes = applySchemaUpgrade(schemaUpgrade, { ...working }, {
-          from: fromVersion,
-          to: toVersion,
-          entityType,
-          describe: () => schema.describe()
-        });
-        if (!upgradeRes || upgradeRes.ok !== true || !upgradeRes.value) {
-          const errs = upgradeRes?.errors?.length ? upgradeRes.errors : [`Failed to upgrade entity from v${fromVersion} to v${toVersion}`];
-          errors.push(...errs);
-          return { valid: false, errors };
-        }
-        for (const k of Object.keys(working)) delete working[k];
-        Object.assign(working, upgradeRes.value);
-        working.type = entityType;
-        working.version = toVersion;
-      }
-      for (const key in schema._shape) {
-        const def = schema._shape[key];
-        let value = working[key];
-        const existingField = existing && typeof existing === "object" ? existing[key] : void 0;
-        if (!def) {
-          errors.push(`Field definition missing for: ${key}`);
-          continue;
-        }
-        const { value: withDefault, applied } = applyDefault(def, value);
-        if (applied) {
-          working[key] = withDefault;
-          value = withDefault;
-        }
-        const { missing } = checkMissingRequired("", key, value, def, errors);
-        if (missing) continue;
-        const { immutableViolation } = checkImmutable(
-          "",
-          key,
-          value,
-          def,
-          existing,
-          errors
-        );
-        if (immutableViolation) continue;
-        const { shortCircuit } = enforcePIIField(
-          "",
-          key,
-          value,
-          def,
-          piiMode,
-          errors,
-          console
-        );
-        if (shortCircuit) continue;
-        const validateField = (val) => {
-          const localErrors = [];
-          const localIssues = [];
-          const { invalid } = runCustomValidator(
-            "",
-            key,
-            val,
-            def,
-            localErrors,
-            localIssues
-          );
-          if (!invalid) {
-            validateByType("", key, val, def, localErrors, localIssues, existingField, piiMode, console);
-          }
-          issues.push(...localIssues);
-          return localErrors;
-        };
-        let fieldValue = value;
-        let fieldErrors = validateField(fieldValue);
-        const entityFrom = String(working.version ?? "0.0.0");
-        const entityTo = String(version);
-        const fieldTo = String(def._version ?? entityTo);
-        const hasUpgrader = typeof def._upgrade === "function";
-        if (fieldErrors.length > 0 && hasUpgrader && cmpSemver(entityFrom, entityTo) < 0) {
-          const up = def._upgrade;
-          const res = up(fieldValue, {
-            entityFrom,
-            entityTo,
-            fieldTo,
-            fieldName: key
-          });
-          if (res && res.ok) {
-            fieldValue = res.value;
-            fieldErrors = validateField(fieldValue);
-          } else {
-            fieldErrors.push(
-              res?.error || `Failed to upgrade field ${key} from v${entityFrom} to v${entityTo}`
-            );
-          }
-        }
-        result[key] = fieldValue;
-        if (fieldErrors.length !== 0) {
-          errors.push(...fieldErrors);
-          continue;
-        }
-      }
-      if (errors.length === 0 && options.schemaValidator) {
-        const castValue = result;
-        if (!options.schemaValidator(castValue)) {
-          errors.push("Schema-level validation failed.");
-        }
-      }
-      return {
-        valid: errors.length === 0,
-        value: result,
-        errors,
-        issues
-      };
-    },
-    // specific validator for a schema to allow conditional validation
-    schemaValidator: options.schemaValidator,
-    // <== expose it here!
-    /**
-     * Runs the optional schema-level upgrade function once, without validating.
-     * Useful for offline migrations or testing migration logic.
-     */
-    upgrade(input, log) {
-      const fromVersion = String(input?.version ?? "0.0.0");
-      const toVersion = String(version);
-      if (!schemaUpgrade || cmpSemver(fromVersion, toVersion) >= 0) {
-        return {
-          ok: true,
-          value: { ...input, type: entityType, version: toVersion }
-        };
-      }
-      const res = applySchemaUpgrade(
-        schemaUpgrade,
-        { ...input },
-        {
-          from: fromVersion,
-          to: toVersion,
-          entityType,
-          describe: () => schema.describe(),
-          log
-        }
+);
+var publicWeeklyPointShape = () => ({
+  weekStart: field.dateTimeISO(),
+  state: field.string().enum(["published", "suppressed"]),
+  acceptedReviewCount: positiveCountField().optional(),
+  averageStars: field.number().min(1).max(5).optional()
+});
+var publicComparisonShape = () => ({
+  previousAcceptedReviewCount: positiveCountField(),
+  previousAverageStars: field.number().min(1).max(5),
+  deltaStars: field.number().min(-4).max(4)
+});
+var FeedbackPublicSummarySchema = createSchema(
+  {
+    snapshotId: uuidField(),
+    generatedAt: field.dateTimeISO(),
+    asOf: field.dateTimeISO(),
+    freshness: field.string().enum(["fresh", "stale"]),
+    reportAgeSeconds: countField(),
+    rollingWindowDays: field.number().enum([90]),
+    state: field.string().enum(["published", "suppressed"]),
+    acceptedReviewCount: positiveCountField().optional(),
+    averageStars: field.number().min(1).max(5).optional(),
+    trend: field.string().enum(["up", "flat", "down"]).optional(),
+    comparison: field.object(publicComparisonShape()).optional(),
+    weeklyPoints: field.array(field.object(publicWeeklyPointShape())).min(13).max(13)
+  },
+  "feedback-public-summary",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => {
+      const summaryIsSuppressed = value.state === "suppressed" && value.acceptedReviewCount === void 0 && value.averageStars === void 0 && value.trend === void 0 && value.comparison === void 0;
+      const comparisonDelta = value.comparison === void 0 ? void 0 : roundRate(
+        value.averageStars - value.comparison.previousAverageStars
       );
-      if (res && res.ok && res.value) {
-        const out = { ...res.value, type: entityType, version: toVersion };
-        return { ok: true, value: out };
+      const expectedTrend = comparisonDelta === void 0 ? void 0 : comparisonDelta >= 0.1 ? "up" : comparisonDelta <= -0.1 ? "down" : "flat";
+      const comparisonIsConsistent = value.comparison === void 0 && value.trend === void 0 || value.comparison !== void 0 && value.comparison.previousAcceptedReviewCount >= 10 && value.comparison.deltaStars === comparisonDelta && value.trend === expectedTrend;
+      const summaryIsPublished = value.state === "published" && typeof value.acceptedReviewCount === "number" && value.acceptedReviewCount >= 10 && typeof value.averageStars === "number" && comparisonIsConsistent;
+      if (!summaryIsSuppressed && !summaryIsPublished) {
+        return false;
       }
-      return {
-        ok: false,
-        errors: res?.errors?.length ? res.errors : [`Failed to upgrade entity from v${fromVersion} to v${toVersion}`]
-      };
-    },
-    /**
-     * Recursively validates entity references defined in this schema.
-     *
-     * Traverses fields of type `ref` and arrays of `ref` and resolves each target
-     * entity using the provided `resolveEntity` function. When `autoValidate` is
-     * enabled (default) and the field's `refPolicy` is `eager`, the referenced
-     * entity's schema is fetched and validated via `validateComposition` up to
-     * `maxDepth` levels.
-     *
-     * Skips fields not listed in `onlyFields` when provided. Prevents cycles via
-     * a `visited` set in `validatorContext`.
-     *
-     * @param entity The root entity to validate (must include `type` and `id`).
-     * @param options Options controlling traversal and resolution behavior.
-     * @param options.resolveEntity Function to resolve a referenced entity by type and id.
-     * @param options.validatorContext Internal context (visited set) to prevent cycles.
-     * @param options.maxDepth Maximum depth for recursive validation (default: 5).
-     * @param options.onlyFields Optional whitelist of field names to validate.
-     * @param options.log Optional logger for traversal/debug output.
-     *
-     * @throws Error if a broken reference is encountered (target cannot be resolved).
-     */
-    async validateComposition(entity, options2) {
-      const {
-        resolveEntity,
-        validatorContext = { visited: /* @__PURE__ */ new Set() },
-        maxDepth = 5,
-        log
-      } = options2;
-      const entityKey = `${entity.type}:${entity.id}`;
-      if (validatorContext.visited.has(entityKey)) {
-        log?.(`Skipping already visited entity ${entityKey}`);
-        return;
-      }
-      validatorContext.visited.add(entityKey);
-      log?.(`Validating composition for entity ${entityKey}`);
-      for (const [key, def] of Object.entries(schema._shape)) {
-        if (options2.onlyFields && !options2.onlyFields.includes(key)) {
-          log?.(`Skipping field ${key} (not in onlyFields)`);
-          continue;
-        }
-        const autoValidate = def.autoValidate !== false;
-        const refPolicy = def.refPolicy ?? "eager";
-        const value = entity[key];
-        if (!value) continue;
-        if (def.type === "ref") {
-          const refType = def.refType;
-          if (!refType)
-            throw new Error(`Missing refType for reference field ${key}`);
-          const ref = value;
-          if (ref.type && ref.type !== refType) {
-            throw new Error(
-              `Reference type mismatch for field ${key}: expected ${refType}, got ${ref.type}`
-            );
-          }
-          const target = await options2.resolveEntity(refType, ref.id);
-          if (!target)
-            throw new Error(
-              `Broken reference: ${refType} ${ref.id} in field ${key}`
-            );
-          log?.(`Resolved ${refType} ${ref.id} from field ${key}`);
-          if (autoValidate && refPolicy === "eager") {
-            const targetSchema = getSchemaForType(refType);
-            if (options2.maxDepth > 0 && targetSchema) {
-              await targetSchema.validateComposition(target, {
-                ...options2,
-                maxDepth: options2.maxDepth - 1
-              });
-            }
-          }
-        } else if (def.type === "array" && def.itemType?.type === "ref") {
-          const refType = def.itemType.refType;
-          if (!refType)
-            throw new Error(`Missing refType for reference array field ${key}`);
-          const refs = value;
-          for (const ref of refs) {
-            if (ref.type && ref.type !== refType) {
-              throw new Error(
-                `Reference type mismatch for field ${key}: expected ${refType}, got ${ref.type}`
-              );
-            }
-            const target = await options2.resolveEntity(refType, ref.id);
-            if (!target)
-              throw new Error(
-                `Broken reference: ${refType} ${ref.id} in field ${key}`
-              );
-            log?.(`Resolved ${refType} ${ref.id} from field ${key}`);
-            if (autoValidate && refPolicy === "eager") {
-              const targetSchema = getSchemaForType(refType);
-              if (options2.maxDepth > 0 && targetSchema) {
-                await targetSchema.validateComposition(target, {
-                  ...options2,
-                  maxDepth: options2.maxDepth - 1
-                });
-              }
-            }
-          }
-        }
-      }
-    },
-    /**
-     * Returns the configured table name for this schema.
-     *
-     * @throws Error if no store/table name has been defined for this schema.
-     */
-    tableName() {
-      if (!store || store === "") {
-        throw new Error("Store is not defined for this schema");
-      }
-      return store;
-    },
-    serialize(input, options2 = {}) {
-      if (typeof input !== "object" || input === null) {
-        return {};
+      const weekStarts = value.weeklyPoints.map(
+        (point) => point.weekStart
+      );
+      const asOf = Date.parse(String(value.asOf));
+      const generatedAt = Date.parse(String(value.generatedAt));
+      if (!Number.isFinite(asOf) || !Number.isFinite(generatedAt) || new Date(asOf).toISOString() !== value.asOf || new Date(asOf).getUTCHours() !== 0 || new Date(asOf).getUTCMinutes() !== 0 || new Date(asOf).getUTCSeconds() !== 0 || new Date(asOf).getUTCMilliseconds() !== 0 || generatedAt < asOf || value.reportAgeSeconds !== Math.floor((generatedAt - asOf) / 1e3)) {
+        return false;
       }
-      const serialized = {};
-      for (const [key, def] of Object.entries(schema._shape)) {
-        if (!shouldIncludeField(def, options2)) {
-          continue;
-        }
-        if (!Object.prototype.hasOwnProperty.call(input, key)) {
-          continue;
-        }
-        const value = serializeFieldValue(def, input[key], options2);
-        if (value !== void 0) {
-          serialized[key] = value;
-        }
+      const daysSinceMonday = (new Date(asOf).getUTCDay() + 6) % 7;
+      const lastWeekStart = asOf - daysSinceMonday * 24 * 60 * 60 * 1e3;
+      const weeksAreCanonical = weekStarts.every(
+        (weekStart, index) => Date.parse(weekStart) === lastWeekStart - (12 - index) * 7 * 24 * 60 * 60 * 1e3
+      );
+      return new Set(weekStarts).size === weekStarts.length && weeksAreCanonical && (value.state !== "suppressed" || value.weeklyPoints.every(
+        (point) => point.state === "suppressed"
+      )) && value.weeklyPoints.every(
+        (point) => point.state === "suppressed" && point.acceptedReviewCount === void 0 && point.averageStars === void 0 || point.state === "published" && typeof point.acceptedReviewCount === "number" && point.acceptedReviewCount >= 10 && typeof point.averageStars === "number" && (value.state !== "published" || point.acceptedReviewCount <= value.acceptedReviewCount)
+      );
+    }
+  }
+);
+var FeedbackProcessorCheckpointSchema = createSchema(
+  {
+    checkpointId: safeIdField(160),
+    processor: field.string().enum(["bug-hourly", "review-daily", "commit-reconciliation"]),
+    windowKey: safeIdField(160),
+    revision: revisionField(),
+    completedAt: field.dateTimeISO(),
+    reportId: uuidField().optional()
+  },
+  "feedback-processor-checkpoint",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => isProcessorArtifactConsistent(value, "checkpoint") && value.revision >= 1 && (value.processor === "commit-reconciliation" && value.reportId === void 0 || value.processor !== "commit-reconciliation" && value.reportId !== void 0)
+  }
+);
+var FeedbackMaterializationManifestSchema = createSchema(
+  {
+    manifestId: uuidField(),
+    processor: field.string().enum(["bug-hourly", "review-daily", "commit-reconciliation"]),
+    windowKey: safeIdField(160),
+    revision: revisionField(),
+    generatedAt: field.dateTimeISO(),
+    sourcePacketCount: countField(),
+    lateArrivalCount: countField(),
+    outputReportId: uuidField().optional(),
+    status: field.string().enum(["published", "corrected", "no-op"])
+  },
+  "feedback-materialization-manifest",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => {
+      if (!isProcessorArtifactConsistent(value, "manifest") || value.lateArrivalCount > value.sourcePacketCount) {
+        return false;
       }
-      return serialized;
-    },
-    /**
-     * Transforms an input object for persistence by applying PII protection
-     * according to field annotations (e.g., encryption and hashing).
-     *
-     * @param input The raw entity data.
-     * @param encryptFn Function used to encrypt sensitive values.
-     * @param hashFn Function used to hash sensitive values.
-     * @returns A new object safe to store.
-     */
-    prepareForStorage(input, encryptFn, hashFn) {
-      return prepareForStorage(_shape, input, encryptFn, hashFn);
-    },
-    /**
-     * Reverses storage transformations for read paths (e.g., decrypts values)
-     * according to PII annotations, returning a consumer-friendly object.
-     *
-     * @param stored Data retrieved from storage.
-     * @param decryptFn Function used to decrypt values that were encrypted on write.
-     * @returns A new object suitable for application consumption.
-     */
-    prepareForRead(stored, decryptFn) {
-      return prepareForRead(_shape, stored, decryptFn);
-    },
-    /**
-     * Produces a log-safe copy of the provided data by redacting or pseudonymizing
-     * PII fields in accordance with field annotations.
-     *
-     * @param data Arbitrary data to sanitize for logging.
-     * @param pseudonymFn Function producing stable pseudonyms for sensitive values.
-     * @returns A copy safe to emit to logs.
-     */
-    sanitizeForLog(data, pseudonymFn) {
-      return sanitizeForLog(_shape, data, pseudonymFn);
-    },
-    /**
-     * Returns a list of fields annotated with PII metadata for auditing purposes.
-     * Each entry includes classification, required action, and optional log policy.
-     */
-    getPiiAudit() {
-      return getPiiAudit(_shape);
-    },
-    /**
-     * Produces a copy of stored data suitable for data deletion flows by scrubbing
-     * or blanking PII per field annotations.
-     *
-     * @param stored Data as persisted.
-     * @returns A copy with PII removed or neutralized for deletion.
-     */
-    scrubPiiForDelete(stored) {
-      return scrubPiiForDelete(_shape, stored);
-    },
-    /**
-     * Returns a normalized description of the schema suitable for documentation
-     * or UI rendering (type, optionality, enum values, PII flags, etc.).
-     */
-    describe() {
-      const description = {};
-      for (const [key, def] of Object.entries(schema._shape)) {
-        description[key] = {
-          type: def.type,
-          optional: isOptional(def),
-          immutable: !!def.isImmutable,
-          system: !!def.isSystem,
-          description: def._description ?? "",
-          version: def._version ?? "",
-          deprecated: def.deprecated ?? false,
-          deprecatedVersion: def.deprecatedVersion === void 0 ? null : def.deprecatedVersion,
-          enum: getEnumValues(def) ?? null,
-          refType: def.refType ?? null,
-          pii: !def._pii || def._pii.classification === "none" ? null : def._pii,
-          exposure: def._exposure ?? "public"
-        };
+      if (value.processor === "commit-reconciliation") {
+        return value.status === "no-op" && value.revision >= 1 && value.outputReportId === void 0 && value.lateArrivalCount === 0;
       }
-      return {
-        entityType,
-        version,
-        hasSchemaUpgrade: !!schemaUpgrade,
-        shape: description
-      };
+      return value.status === "published" && value.revision === 1 && value.lateArrivalCount === 0 && value.outputReportId !== void 0 || value.status === "corrected" && value.revision >= 2 && value.lateArrivalCount > 0 && value.outputReportId !== void 0;
     }
-  };
-  globalSchemaRegistry.set(entityType, schema);
-  return schema;
-}
-function getSchemaForType(type) {
-  return globalSchemaRegistry.get(type);
-}
-function getAllSchemas() {
-  return Array.from(globalSchemaRegistry.values());
-}
-function renderSchemaDescription(schema) {
-  const meta = schema.describe();
-  return {
-    title: `${meta.entityType} (v${meta.version})`,
-    fields: Object.entries(meta.shape).map(([name, def]) => ({
-      name,
-      type: def.type,
-      optional: def.optional,
-      description: def.description,
-      deprecated: def.deprecated,
-      pii: def.pii ? def.pii.classification : void 0,
-      exposure: def.exposure
-    }))
-  };
-}
-
-// src/components.ts
-var componentSchemaRegistry = /* @__PURE__ */ new Map();
-function createComponentSchema(shape, name, version, tableName = "", schemaValidator = () => true) {
-  const schema = createSchema(shape, name, {
-    version,
-    piiEnforcement: "strict",
-    table: tableName,
-    schemaValidator
-  });
-  registerComponentSchema(name, schema);
-  return schema;
-}
-function registerComponentSchema(type, schema) {
-  componentSchemaRegistry.set(type, schema);
-}
-function getComponentSchema(type) {
-  return componentSchemaRegistry.get(type);
-}
-function getAllComponentSchemas() {
-  return Array.from(componentSchemaRegistry.entries());
-}
+  }
+);
 export {
+  FEEDBACK_ANALYSIS_MODEL_VERSIONS,
+  FEEDBACK_BACKEND_BUCKETS,
+  FEEDBACK_BUG_COOLDOWN_SECONDS,
+  FEEDBACK_CONTRACT_VERSION,
+  FEEDBACK_FRAME_RATE_BUCKETS,
+  FEEDBACK_FRAME_TIME_BUCKETS,
+  FEEDBACK_GAME_COUNTER_CODES,
+  FEEDBACK_GAME_COUNTER_MAX_COUNT,
+  FEEDBACK_GAME_COUNTER_MAX_ITEMS,
+  FEEDBACK_GAME_ERROR_CODES,
+  FEEDBACK_GAME_FEATURE_IDS,
+  FEEDBACK_GAME_PROVENANCE_CONTRACTS,
+  FEEDBACK_GAME_PROVENANCE_CONTRACT_IDS,
+  FEEDBACK_GAME_SURFACE_IDS,
+  FEEDBACK_INTENT_IDS,
+  FEEDBACK_ISSUE_TYPES,
+  FEEDBACK_PERSISTABLE_ISSUE_TYPES,
+  FEEDBACK_PRIVACY_POLICY_VERSIONS,
+  FEEDBACK_RENDERER_BUCKETS,
+  FEEDBACK_REVIEW_COOLDOWN_SECONDS,
+  FEEDBACK_SATISFACTION_LEVELS,
+  FEEDBACK_SENTIMENT_BUCKETS,
+  FEEDBACK_SEVERITY_LEVELS,
+  FEEDBACK_STRUCTURED_ONLY_REASON_CODES,
+  FEEDBACK_SURFACE_DEFINITIONS,
+  FEEDBACK_SURFACE_IDS,
+  FEEDBACK_THEME_IDS,
+  FEEDBACK_UNICODE_NORMALIZATION_PROFILE,
+  FEEDBACK_VIEWPORT_BUCKETS,
+  FeedbackAcceptanceReceiptSchema,
+  FeedbackAnalysisReceiptSchema,
+  FeedbackBugPacketSchema,
+  FeedbackBugSubmissionRequestSchema,
+  FeedbackContextSchema,
+  FeedbackDailySatisfactionReportSchema,
+  FeedbackDerivedAnalysisSchema,
+  FeedbackDraftPacketSchema,
+  FeedbackDraftReceiptSchema,
+  FeedbackDraftUpsertRequestSchema,
+  FeedbackEncryptedNarrativeEnvelopeSchema,
+  FeedbackGameDiagnosticsSchema,
+  FeedbackGameReconstructionManifestSchema,
+  FeedbackHourlyBugReportSchema,
+  FeedbackMaterializationManifestSchema,
+  FeedbackProcessorCheckpointSchema,
+  FeedbackPublicSummarySchema,
+  FeedbackReviewPacketSchema,
+  FeedbackReviewSubmissionRequestSchema,
+  FeedbackRichTextAstSchema,
+  FeedbackStructuredOnlyAnalysisResultSchema,
+  FeedbackSurfaceCatalogSchema,
+  FeedbackTransientAnalysisRequestSchema,
   FieldBuilder,
   IsoLanguageCode,
+  PLAYER_SYSTEM_ACHIEVEMENT_TIERS,
+  PLAYER_SYSTEM_ACHIEVEMENT_TRACK_STATUSES,
+  PLAYER_SYSTEM_EVENT_KINDS,
+  PlayerSystemCuratedSnapshotSchema,
+  PlayerSystemNormalizedEventBatchSchema,
+  PlayerSystemObservedEventBatchSchema,
+  SCHEMA_IDENTITY_POLICIES,
+  SCHEMA_UNKNOWN_FIELDS_POLICIES,
   createComponentSchema,
   createSchema,
   field,
@@ -2523,7 +1855,10 @@ export {
   validateCountryCode,
   validateCurrencyCode,
   validateDateTimeISO,
+  validateDisplayName,
   validateEmail,
+  validateFeedbackGameDiagnostics,
+  validateFeedbackTransientAnalysisRequest,
   validateLanguage,
   validateName,
   validatePercentage,