@plasius/schema 1.3.0 → 1.3.1

package/dist/feedback-diagnostics.cjs

@@ -0,0 +1,2696 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/feedback-diagnostics.ts
+var feedback_diagnostics_exports = {};
+__export(feedback_diagnostics_exports, {
+  FEEDBACK_BACKEND_BUCKETS: () => FEEDBACK_BACKEND_BUCKETS,
+  FEEDBACK_CONTRACT_VERSION: () => FEEDBACK_CONTRACT_VERSION,
+  FEEDBACK_FRAME_RATE_BUCKETS: () => FEEDBACK_FRAME_RATE_BUCKETS,
+  FEEDBACK_FRAME_TIME_BUCKETS: () => FEEDBACK_FRAME_TIME_BUCKETS,
+  FEEDBACK_GAME_COUNTER_CODES: () => FEEDBACK_GAME_COUNTER_CODES,
+  FEEDBACK_GAME_COUNTER_MAX_COUNT: () => FEEDBACK_GAME_COUNTER_MAX_COUNT,
+  FEEDBACK_GAME_COUNTER_MAX_ITEMS: () => FEEDBACK_GAME_COUNTER_MAX_ITEMS,
+  FEEDBACK_GAME_ERROR_CODES: () => FEEDBACK_GAME_ERROR_CODES,
+  FEEDBACK_GAME_FEATURE_IDS: () => FEEDBACK_GAME_FEATURE_IDS,
+  FEEDBACK_GAME_PROVENANCE_CONTRACTS: () => FEEDBACK_GAME_PROVENANCE_CONTRACTS,
+  FEEDBACK_GAME_PROVENANCE_CONTRACT_IDS: () => FEEDBACK_GAME_PROVENANCE_CONTRACT_IDS,
+  FEEDBACK_GAME_SURFACE_IDS: () => FEEDBACK_GAME_SURFACE_IDS,
+  FEEDBACK_RENDERER_BUCKETS: () => FEEDBACK_RENDERER_BUCKETS,
+  FEEDBACK_VIEWPORT_BUCKETS: () => FEEDBACK_VIEWPORT_BUCKETS,
+  FeedbackGameDiagnosticsSchema: () => FeedbackGameDiagnosticsSchema,
+  validateFeedbackGameDiagnostics: () => validateFeedbackGameDiagnostics
+});
+module.exports = __toCommonJS(feedback_diagnostics_exports);
+
+// 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());
+};
+
+// 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/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/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);
+}
+function isVariantSubtag(value) {
+  return /^([0-9][A-Za-z0-9]{3}|[A-Za-z0-9]{5,8})$/.test(value);
+}
+function isExtensionSingleton(value) {
+  return /^[0-9A-WY-Za-wy-z]$/.test(value);
+}
+function isExtensionSubtag(value) {
+  return /^[A-Za-z0-9]{2,8}$/.test(value);
+}
+function isPrivateUseSingleton(value) {
+  return value.toLowerCase() === "x";
+}
+function isPrivateUseSubtag(value) {
+  return /^[A-Za-z0-9]{1,8}$/.test(value);
+}
+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);
+  }
+  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;
+    }
+  }
+  if (i < parts.length && isScriptSubtag(parts[i])) {
+    i += 1;
+  }
+  if (i < parts.length && isRegionSubtag(parts[i].toUpperCase())) {
+    i += 1;
+  }
+  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;
+  }
+  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;
+    }
+  }
+  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;
+    }
+  }
+  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'"
+  )
+};
+
+// src/feedback-contract-version.ts
+var FEEDBACK_CONTRACT_VERSION = "1.0.0";
+
+// src/feedback-diagnostics-vocabulary.ts
+var FEEDBACK_RENDERER_BUCKETS = [
+  "webgl2",
+  "webgpu",
+  "canvas2d",
+  "unknown"
+];
+var FEEDBACK_BACKEND_BUCKETS = [
+  "browser",
+  "worker",
+  "unknown"
+];
+var FEEDBACK_GAME_SURFACE_IDS = [
+  "site.generator",
+  "site.gpu-demo"
+];
+var FEEDBACK_GAME_PROVENANCE_CONTRACTS = [
+  {
+    surfaceId: "site.generator",
+    contractId: "generator.renderer-diagnostics.v1"
+  },
+  {
+    surfaceId: "site.gpu-demo",
+    contractId: "gpu-demo.renderer-diagnostics.v1"
+  }
+];
+var FEEDBACK_GAME_PROVENANCE_CONTRACT_IDS = [
+  "generator.renderer-diagnostics.v1",
+  "gpu-demo.renderer-diagnostics.v1"
+];
+var FEEDBACK_GAME_FEATURE_IDS = [
+  "renderer.initialisation",
+  "renderer.frame-loop",
+  "renderer.asset-loading",
+  "renderer.input",
+  "renderer.scene-generation",
+  "renderer.post-processing"
+];
+var FEEDBACK_GAME_COUNTER_CODES = [
+  "frame-drop",
+  "device-loss",
+  "asset-load-failure",
+  "shader-failure",
+  "fallback-activation"
+];
+var FEEDBACK_GAME_COUNTER_MAX_ITEMS = 32;
+var FEEDBACK_GAME_COUNTER_MAX_COUNT = 1e4;
+var FEEDBACK_GAME_ERROR_CODES = [
+  "renderer.initialisation-failed",
+  "renderer.device-lost",
+  "renderer.asset-load-failed",
+  "renderer.frame-budget-exceeded",
+  "renderer.shader-failed",
+  "renderer.unknown"
+];
+var FEEDBACK_VIEWPORT_BUCKETS = [
+  "small-portrait",
+  "small-landscape",
+  "medium-portrait",
+  "medium-landscape",
+  "large-portrait",
+  "large-landscape",
+  "unknown"
+];
+var FEEDBACK_FRAME_RATE_BUCKETS = [
+  "under-15",
+  "15-29",
+  "30-59",
+  "60-plus",
+  "unknown"
+];
+var FEEDBACK_FRAME_TIME_BUCKETS = [
+  "under-17ms",
+  "17-33ms",
+  "34-66ms",
+  "over-66ms",
+  "unknown"
+];
+for (const vocabulary of [
+  FEEDBACK_RENDERER_BUCKETS,
+  FEEDBACK_BACKEND_BUCKETS,
+  FEEDBACK_GAME_SURFACE_IDS,
+  FEEDBACK_GAME_PROVENANCE_CONTRACTS,
+  FEEDBACK_GAME_PROVENANCE_CONTRACT_IDS,
+  FEEDBACK_GAME_FEATURE_IDS,
+  FEEDBACK_GAME_COUNTER_CODES,
+  FEEDBACK_GAME_ERROR_CODES,
+  FEEDBACK_VIEWPORT_BUCKETS,
+  FEEDBACK_FRAME_RATE_BUCKETS,
+  FEEDBACK_FRAME_TIME_BUCKETS
+]) {
+  Object.freeze(vocabulary);
+}
+for (const entry of FEEDBACK_GAME_PROVENANCE_CONTRACTS) {
+  Object.freeze(entry);
+}
+
+// src/types.ts
+var SCHEMA_UNKNOWN_FIELDS_POLICIES = Object.freeze([
+  "strip",
+  "reject"
+]);
+var SCHEMA_IDENTITY_POLICIES = Object.freeze([
+  "compatible",
+  "exact"
+]);
+
+// 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}`);
+      }
+    }
+  }
+  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 (isMissing && def.isRequired === false) {
+      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);
+  }
+  return result;
+}
+function prepareForRead(shape, stored, decryptFn) {
+  const readValue = (def, key, container, ctx = {}) => {
+    if (!def) return container?.[key];
+    const action = def._pii?.action;
+    const hasValue = container !== void 0 && container !== null && Object.prototype.hasOwnProperty.call(container, key);
+    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 (!hasValue && def.isRequired === false) {
+      return 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)) {
+        const child = readValue(childDef, childKey, source);
+        if (child !== void 0) {
+          obj[childKey] = child;
+        }
+      }
+      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)) {
+          const child = readValue(childDef, childKey, ref);
+          if (child !== void 0) {
+            ref[childKey] = child;
+          }
+        }
+      }
+      return ref;
+    }
+    return container?.[key];
+  };
+  const result = {};
+  for (const key in shape) {
+    const value = readValue(shape[key], key, stored);
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function sanitizeForLog(shape, data, pseudonymFn) {
+  const visit = (def, value, ctx = {}) => {
+    if (!def) return void 0;
+    if ((value === void 0 || value === null) && def.isRequired === false) {
+      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;
+    }
+    return value;
+  };
+  const output = {};
+  for (const key in shape) {
+    const child = visit(shape[key], data?.[key]);
+    if (child !== void 0) output[key] = child;
+  }
+  return output;
+}
+function getPiiAudit(shape) {
+  const piiFields = [];
+  const visit = (def, path) => {
+    if (!def) return;
+    if (def._pii && def._pii.classification !== "none") {
+      piiFields.push({
+        field: path,
+        classification: def._pii.classification,
+        action: def._pii.action,
+        logHandling: def._pii.logHandling,
+        purpose: def._pii.purpose
+      });
+    }
+    if ((def.type === "object" || def.type === "ref") && def._shape) {
+      for (const [childKey, childDef] of Object.entries(def._shape)) {
+        visit(childDef, `${path}.${childKey}`);
+      }
+    }
+    if (def.type === "array" && def.itemType) {
+      const itemPath = `${path}[]`;
+      if ((def.itemType.type === "object" || def.itemType.type === "ref") && def.itemType._shape) {
+        for (const [childKey, childDef] of Object.entries(
+          def.itemType._shape
+        )) {
+          visit(childDef, `${itemPath}.${childKey}`);
+        }
+      } else {
+        visit(def.itemType, itemPath);
+      }
+    }
+  };
+  for (const key in shape) {
+    visit(shape[key], key);
+  }
+  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 (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;
+    }
+    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;
+    }
+    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);
+        }
+      }
+    }
+  };
+  for (const key in shape) {
+    visit(shape[key], stored, [key], key);
+  }
+  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) {
+    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);
+  }
+}
+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;
+  }
+  return 0;
+}
+function applySchemaUpgrade(spec, input, ctx) {
+  if (typeof spec === "function") {
+    return spec(input, ctx);
+  }
+  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 { 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} must contain only: ${values.join(", ")}`;
+    }
+  } else {
+    if (!values.includes(value)) {
+      return `Field ${parentKey} must be one of: ${values.join(", ")}`;
+    }
+  }
+}
+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 };
+    }
+  }
+  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;
+}
+var MAX_STRICT_VALIDATION_NODES = 1e4;
+var MAX_STRICT_VALIDATION_DEPTH = 256;
+var MAX_STRICT_VALIDATION_OBJECTS = MAX_STRICT_VALIDATION_NODES;
+function strictInputIsWithinComplexityLimit(input) {
+  const pending = [
+    { value: input, depth: 0 }
+  ];
+  const seen = /* @__PURE__ */ new WeakSet();
+  let visitedNodes = 0;
+  try {
+    while (pending.length > 0) {
+      const current = pending.pop();
+      if (!current) {
+        continue;
+      }
+      visitedNodes += 1;
+      if (visitedNodes > MAX_STRICT_VALIDATION_NODES || current.depth > MAX_STRICT_VALIDATION_DEPTH) {
+        return false;
+      }
+      if (typeof current.value !== "object" || current.value === null) {
+        continue;
+      }
+      if (seen.has(current.value)) {
+        return false;
+      }
+      seen.add(current.value);
+      const keys = Object.keys(current.value);
+      if (visitedNodes + pending.length + keys.length > MAX_STRICT_VALIDATION_NODES) {
+        return false;
+      }
+      const record = current.value;
+      for (const key of keys) {
+        pending.push({
+          value: record[key],
+          depth: current.depth + 1
+        });
+      }
+    }
+  } catch {
+    return false;
+  }
+  return true;
+}
+function strictReferenceShape(def) {
+  return {
+    type: { type: "string" },
+    id: { type: "string" },
+    ...getShape(def) ?? {}
+  };
+}
+function unknownFieldLocations(value, shape, location = "root", state = {
+  remainingObjects: MAX_STRICT_VALIDATION_OBJECTS,
+  limitExceeded: false
+}) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return [];
+  }
+  if (state.remainingObjects <= 0) {
+    state.limitExceeded = true;
+    return [];
+  }
+  state.remainingObjects -= 1;
+  const record = value;
+  const knownKeys = new Set(Object.keys(shape));
+  const locations = /* @__PURE__ */ new Set();
+  if (Object.keys(record).some((key) => !knownKeys.has(key))) {
+    locations.add(location);
+  }
+  for (const [key, def] of Object.entries(shape)) {
+    const child = record[key];
+    if (child === void 0 || child === null) {
+      continue;
+    }
+    const childLocation = location === "root" ? key : `${location}.${key}`;
+    const childShape = getShape(def);
+    if (def?.type === "object" && childShape) {
+      for (const nestedLocation of unknownFieldLocations(
+        child,
+        childShape,
+        childLocation,
+        state
+      )) {
+        locations.add(nestedLocation);
+      }
+      continue;
+    }
+    const itemType = def?.itemType;
+    if (def?.type === "array" && (itemType?.type === "object" || itemType?.type === "ref") && Array.isArray(child)) {
+      const itemShape = itemType.type === "ref" ? strictReferenceShape(itemType) : getShape(itemType);
+      if (!itemShape) {
+        continue;
+      }
+      for (const [index, item] of child.entries()) {
+        if (state.limitExceeded) {
+          break;
+        }
+        for (const nestedLocation of unknownFieldLocations(
+          item,
+          itemShape,
+          `${childLocation}[${index}]`,
+          state
+        )) {
+          locations.add(nestedLocation);
+        }
+      }
+      continue;
+    }
+    if (def?.type === "ref") {
+      for (const nestedLocation of unknownFieldLocations(
+        child,
+        strictReferenceShape(def),
+        childLocation,
+        state
+      )) {
+        locations.add(nestedLocation);
+      }
+    }
+  }
+  return [...locations];
+}
+function normalizeValidationIssue(path, issue, defaultCode) {
+  if (typeof issue === "string") {
+    return {
+      path,
+      code: defaultCode,
+      message: issue
+    };
+  }
+  return {
+    path: issue.path ?? path,
+    code: issue.code || defaultCode,
+    message: issue.message
+  };
+}
+function normalizeValidatorIssues(path, result, defaultCode) {
+  if (result === true) {
+    return [];
+  }
+  if (result === false) {
+    return [
+      {
+        path,
+        code: defaultCode,
+        message: `Invalid value for field: ${path}`
+      }
+    ];
+  }
+  if (Array.isArray(result)) {
+    return result.map((issue) => normalizeValidationIssue(path, issue, defaultCode));
+  }
+  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 };
+  }
+  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 };
+  }
+  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);
+      }
+      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);
+    }
+  }
+}
+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);
+    }
+  }
+}
+function validateBooleanField(parentKey, key, value, _def, errors) {
+  const path = parentKey ? `${parentKey}.${key}` : key;
+  if (typeof value !== "boolean") {
+    errors.push(`Field ${path} must be boolean`);
+  }
+}
+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;
+    }
+    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;
+  }
+  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;
+  }
+  const enumValues = getEnumValues(itemDef);
+  if (Array.isArray(enumValues)) {
+    const enumError = validateEnum(path, arr, enumValues);
+    if (enumError) {
+      errors.push(enumError);
+    }
+  }
+  const validator = getValidator(itemDef);
+  if (validator) {
+    arr.forEach((v, idx) => {
+      if (!validator(v)) {
+        errors.push(`Invalid value for field: ${path}[${idx}]`);
+      }
+    });
+  }
+}
+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[]`);
+  }
+  const enumValues = getEnumValues(itemDef);
+  if (Array.isArray(enumValues)) {
+    const enumError = validateEnum(path, arr, enumValues);
+    if (enumError) {
+      errors.push(enumError);
+    }
+  }
+  const validator = getValidator(itemDef);
+  if (validator) {
+    arr.forEach((v, idx) => {
+      if (!validator(v)) {
+        errors.push(`Invalid value for field: ${path}[${idx}]`);
+      }
+    });
+  }
+}
+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}]`);
+      }
+    });
+  }
+}
+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;
+      }
+      const { missing } = checkMissingRequired(
+        itemParent,
+        childKey,
+        childValue,
+        childDef,
+        errors
+      );
+      if (missing) continue;
+      const { immutableViolation } = checkImmutable(
+        itemParent,
+        childKey,
+        childValue,
+        childDef,
+        existingItem,
+        errors
+      );
+      if (immutableViolation) continue;
+      const { shortCircuit } = enforcePIIField(
+        itemParent,
+        childKey,
+        childValue,
+        childDef,
+        piiEnforcement,
+        errors,
+        logger
+      );
+      if (shortCircuit) continue;
+      const { invalid } = runCustomValidator(
+        itemParent,
+        childKey,
+        childValue,
+        childDef,
+        errors,
+        issues
+      );
+      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}`
+        );
+      }
+    });
+    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
+      );
+    case "array":
+      return validateArrayField(
+        parentKey,
+        key,
+        value,
+        def,
+        errors,
+        issues,
+        existing,
+        piiEnforcement,
+        logger
+      );
+    case "ref":
+      return validateRefField(parentKey, key, value, def, errors, existing, piiEnforcement, logger);
+    default:
+      errors.push(`Unknown type for field ${path}: ${def.type}`);
+  }
+}
+function createSchema(_shape, entityType, options = {
+  version: "1.0.0",
+  table: "",
+  schemaValidator: () => true,
+  piiEnforcement: "none",
+  unknownFields: SCHEMA_UNKNOWN_FIELDS_POLICIES[0],
+  identity: SCHEMA_IDENTITY_POLICIES[0],
+  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"] };
+      }
+      if (options.unknownFields === "reject") {
+        if (!strictInputIsWithinComplexityLimit(input)) {
+          return {
+            valid: false,
+            errors: ["Strict validation complexity limit exceeded."],
+            issues: [
+              {
+                path: "root",
+                code: "validation_complexity_limit",
+                message: "Strict validation complexity limit exceeded."
+              }
+            ]
+          };
+        }
+        const scanState = {
+          remainingObjects: MAX_STRICT_VALIDATION_OBJECTS,
+          limitExceeded: false
+        };
+        const locations = unknownFieldLocations(
+          input,
+          schema._shape,
+          "root",
+          scanState
+        );
+        if (scanState.limitExceeded) {
+          return {
+            valid: false,
+            errors: ["Strict validation complexity limit exceeded."],
+            issues: [
+              {
+                path: "root",
+                code: "validation_complexity_limit",
+                message: "Strict validation complexity limit exceeded."
+              }
+            ]
+          };
+        }
+        if (locations.length > 0) {
+          return {
+            valid: false,
+            errors: locations.map(
+              (location) => `Unknown fields are not allowed at ${location}.`
+            ),
+            issues: locations.map((location) => ({
+              path: location,
+              code: "unknown_fields",
+              message: `Unknown fields are not allowed at ${location}.`
+            }))
+          };
+        }
+      }
+      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;
+      }
+      if (options.identity === "exact" && (working.type !== entityType || working.version !== version)) {
+        return {
+          valid: false,
+          errors: ["Schema type or version does not match the contract."],
+          issues: [
+            {
+              path: "root",
+              code: "schema_identity_mismatch",
+              message: "Schema type or version does not match the contract."
+            }
+          ]
+        };
+      }
+      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;
+        const source = input;
+        const validationContext = Object.freeze({
+          wasProvided: (fieldName) => Object.prototype.hasOwnProperty.call(source, fieldName)
+        });
+        if (!options.schemaValidator(castValue, validationContext)) {
+          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
+        }
+      );
+      if (res && res.ok && res.value) {
+        const out = { ...res.value, type: entityType, version: toVersion };
+        return { ok: true, value: out };
+      }
+      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 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;
+        }
+      }
+      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"
+        };
+      }
+      return {
+        entityType,
+        version,
+        hasSchemaUpgrade: !!schemaUpgrade,
+        shape: description
+      };
+    }
+  };
+  globalSchemaRegistry.set(entityType, schema);
+  return schema;
+}
+function getSchemaForType(type) {
+  return globalSchemaRegistry.get(type);
+}
+
+// src/feedback-diagnostics.contract.ts
+var positiveCountField = (maximum) => field.number().validator((value) => Number.isSafeInteger(value)).min(1).max(maximum);
+var nestedIdentityShape = () => ({
+  type: field.string().enum(["feedback-game-diagnostics"]),
+  version: field.string().enum([FEEDBACK_CONTRACT_VERSION])
+});
+var gameCounterShape = () => ({
+  code: field.string().enum(FEEDBACK_GAME_COUNTER_CODES),
+  count: positiveCountField(FEEDBACK_GAME_COUNTER_MAX_COUNT)
+});
+var feedbackGameDiagnosticsShape = (includeIdentity = false) => ({
+  ...includeIdentity ? nestedIdentityShape() : {},
+  surfaceId: field.string().enum(FEEDBACK_GAME_SURFACE_IDS),
+  consentConfirmed: field.boolean(),
+  provenanceContractId: field.string().enum(FEEDBACK_GAME_PROVENANCE_CONTRACT_IDS),
+  renderer: field.string().enum(FEEDBACK_RENDERER_BUCKETS),
+  backend: field.string().enum(FEEDBACK_BACKEND_BUCKETS),
+  viewportBucket: field.string().enum(FEEDBACK_VIEWPORT_BUCKETS),
+  frameRateBucket: field.string().enum(FEEDBACK_FRAME_RATE_BUCKETS),
+  frameTimeBucket: field.string().enum(FEEDBACK_FRAME_TIME_BUCKETS),
+  featureIds: field.array(field.string().enum(FEEDBACK_GAME_FEATURE_IDS)).max(FEEDBACK_GAME_FEATURE_IDS.length),
+  counters: field.array(field.object(gameCounterShape())).max(FEEDBACK_GAME_COUNTER_MAX_ITEMS),
+  errorCodes: field.array(field.string().enum(FEEDBACK_GAME_ERROR_CODES)).max(FEEDBACK_GAME_ERROR_CODES.length)
+});
+var isFeedbackGameDiagnosticsConsistent = (value) => {
+  const featureIds = Array.isArray(value.featureIds) ? value.featureIds : [];
+  const errorCodes = Array.isArray(value.errorCodes) ? value.errorCodes : [];
+  const counters = Array.isArray(value.counters) ? value.counters : [];
+  const provenance = FEEDBACK_GAME_PROVENANCE_CONTRACTS.find(
+    ({ surfaceId }) => surfaceId === value.surfaceId
+  );
+  return value.consentConfirmed === true && provenance !== void 0 && provenance.contractId === value.provenanceContractId && new Set(featureIds).size === featureIds.length && new Set(errorCodes).size === errorCodes.length && new Set(
+    counters.map(
+      (counter) => typeof counter === "object" && counter !== null ? counter.code : void 0
+    )
+  ).size === counters.length;
+};
+var FeedbackGameDiagnosticsSchema = createSchema(
+  feedbackGameDiagnosticsShape(),
+  "feedback-game-diagnostics",
+  {
+    version: FEEDBACK_CONTRACT_VERSION,
+    piiEnforcement: "strict",
+    unknownFields: "reject",
+    identity: "exact",
+    schemaValidator: isFeedbackGameDiagnosticsConsistent
+  }
+);
+var validateFeedbackGameDiagnostics = (input) => {
+  const result = FeedbackGameDiagnosticsSchema.validate(input);
+  if (!result.valid || result.value === void 0) {
+    return {
+      valid: false,
+      errors: result.errors ?? ["Game diagnostics validation failed."],
+      ...result.issues === void 0 ? {} : { issues: result.issues }
+    };
+  }
+  return {
+    valid: true,
+    value: result.value
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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,
+  FeedbackGameDiagnosticsSchema,
+  validateFeedbackGameDiagnostics
+});
+//# sourceMappingURL=feedback-diagnostics.cjs.map