@plasius/schema 1.2.18 → 1.3.1

package/dist/index.cjs

@@ -20,8 +20,68 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  FEEDBACK_ANALYSIS_MODEL_VERSIONS: () => FEEDBACK_ANALYSIS_MODEL_VERSIONS,
+  FEEDBACK_BACKEND_BUCKETS: () => FEEDBACK_BACKEND_BUCKETS,
+  FEEDBACK_BUG_COOLDOWN_SECONDS: () => FEEDBACK_BUG_COOLDOWN_SECONDS,
+  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_INTENT_IDS: () => FEEDBACK_INTENT_IDS,
+  FEEDBACK_ISSUE_TYPES: () => FEEDBACK_ISSUE_TYPES,
+  FEEDBACK_PERSISTABLE_ISSUE_TYPES: () => FEEDBACK_PERSISTABLE_ISSUE_TYPES,
+  FEEDBACK_PRIVACY_POLICY_VERSIONS: () => FEEDBACK_PRIVACY_POLICY_VERSIONS,
+  FEEDBACK_RENDERER_BUCKETS: () => FEEDBACK_RENDERER_BUCKETS,
+  FEEDBACK_REVIEW_COOLDOWN_SECONDS: () => FEEDBACK_REVIEW_COOLDOWN_SECONDS,
+  FEEDBACK_SATISFACTION_LEVELS: () => FEEDBACK_SATISFACTION_LEVELS,
+  FEEDBACK_SENTIMENT_BUCKETS: () => FEEDBACK_SENTIMENT_BUCKETS,
+  FEEDBACK_SEVERITY_LEVELS: () => FEEDBACK_SEVERITY_LEVELS,
+  FEEDBACK_STRUCTURED_ONLY_REASON_CODES: () => FEEDBACK_STRUCTURED_ONLY_REASON_CODES,
+  FEEDBACK_SURFACE_DEFINITIONS: () => FEEDBACK_SURFACE_DEFINITIONS,
+  FEEDBACK_SURFACE_IDS: () => FEEDBACK_SURFACE_IDS,
+  FEEDBACK_THEME_IDS: () => FEEDBACK_THEME_IDS,
+  FEEDBACK_UNICODE_NORMALIZATION_PROFILE: () => FEEDBACK_UNICODE_NORMALIZATION_PROFILE,
+  FEEDBACK_VIEWPORT_BUCKETS: () => FEEDBACK_VIEWPORT_BUCKETS,
+  FeedbackAcceptanceReceiptSchema: () => FeedbackAcceptanceReceiptSchema,
+  FeedbackAnalysisReceiptSchema: () => FeedbackAnalysisReceiptSchema,
+  FeedbackBugPacketSchema: () => FeedbackBugPacketSchema,
+  FeedbackBugSubmissionRequestSchema: () => FeedbackBugSubmissionRequestSchema,
+  FeedbackContextSchema: () => FeedbackContextSchema,
+  FeedbackDailySatisfactionReportSchema: () => FeedbackDailySatisfactionReportSchema,
+  FeedbackDerivedAnalysisSchema: () => FeedbackDerivedAnalysisSchema,
+  FeedbackDraftPacketSchema: () => FeedbackDraftPacketSchema,
+  FeedbackDraftReceiptSchema: () => FeedbackDraftReceiptSchema,
+  FeedbackDraftUpsertRequestSchema: () => FeedbackDraftUpsertRequestSchema,
+  FeedbackEncryptedNarrativeEnvelopeSchema: () => FeedbackEncryptedNarrativeEnvelopeSchema,
+  FeedbackGameDiagnosticsSchema: () => FeedbackGameDiagnosticsSchema,
+  FeedbackGameReconstructionManifestSchema: () => FeedbackGameReconstructionManifestSchema,
+  FeedbackHourlyBugReportSchema: () => FeedbackHourlyBugReportSchema,
+  FeedbackMaterializationManifestSchema: () => FeedbackMaterializationManifestSchema,
+  FeedbackProcessorCheckpointSchema: () => FeedbackProcessorCheckpointSchema,
+  FeedbackPublicSummarySchema: () => FeedbackPublicSummarySchema,
+  FeedbackReviewPacketSchema: () => FeedbackReviewPacketSchema,
+  FeedbackReviewSubmissionRequestSchema: () => FeedbackReviewSubmissionRequestSchema,
+  FeedbackRichTextAstSchema: () => FeedbackRichTextAstSchema,
+  FeedbackStructuredOnlyAnalysisResultSchema: () => FeedbackStructuredOnlyAnalysisResultSchema,
+  FeedbackSurfaceCatalogSchema: () => FeedbackSurfaceCatalogSchema,
+  FeedbackTransientAnalysisRequestSchema: () => FeedbackTransientAnalysisRequestSchema,
   FieldBuilder: () => FieldBuilder,
   IsoLanguageCode: () => IsoLanguageCode,
+  PLAYER_SYSTEM_ACHIEVEMENT_TIERS: () => PLAYER_SYSTEM_ACHIEVEMENT_TIERS,
+  PLAYER_SYSTEM_ACHIEVEMENT_TRACK_STATUSES: () => PLAYER_SYSTEM_ACHIEVEMENT_TRACK_STATUSES,
+  PLAYER_SYSTEM_EVENT_KINDS: () => PLAYER_SYSTEM_EVENT_KINDS,
+  PlayerSystemCuratedSnapshotSchema: () => PlayerSystemCuratedSnapshotSchema,
+  PlayerSystemNormalizedEventBatchSchema: () => PlayerSystemNormalizedEventBatchSchema,
+  PlayerSystemObservedEventBatchSchema: () => PlayerSystemObservedEventBatchSchema,
+  SCHEMA_IDENTITY_POLICIES: () => SCHEMA_IDENTITY_POLICIES,
+  SCHEMA_UNKNOWN_FIELDS_POLICIES: () => SCHEMA_UNKNOWN_FIELDS_POLICIES,
   createComponentSchema: () => createComponentSchema,
   createSchema: () => createSchema,
   field: () => field,
@@ -44,7 +104,10 @@ __export(index_exports, {
   validateCountryCode: () => validateCountryCode,
   validateCurrencyCode: () => validateCurrencyCode,
   validateDateTimeISO: () => validateDateTimeISO,
+  validateDisplayName: () => validateDisplayName,
   validateEmail: () => validateEmail,
+  validateFeedbackGameDiagnostics: () => validateFeedbackGameDiagnostics,
+  validateFeedbackTransientAnalysisRequest: () => validateFeedbackTransientAnalysisRequest,
   validateLanguage: () => validateLanguage,
   validateName: () => validateName,
   validatePercentage: () => validatePercentage,
@@ -812,7 +875,7 @@ function validateRichText(value) {
 }
 
 // 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;
@@ -821,10 +884,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) {
@@ -1216,6 +1284,16 @@ var field = {
   )
 };
 
+// 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;
@@ -1250,6 +1328,9 @@ function prepareForStorage(shape, input, encryptFn, hashFn) {
       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)) {
@@ -1295,6 +1376,7 @@ 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);
@@ -1305,11 +1387,17 @@ function prepareForRead(shape, stored, decryptFn) {
     }
     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)) {
-        obj[childKey] = readValue(childDef, childKey, source);
+        const child = readValue(childDef, childKey, source);
+        if (child !== void 0) {
+          obj[childKey] = child;
+        }
       }
       return obj;
     }
@@ -1325,7 +1413,10 @@ function prepareForRead(shape, stored, decryptFn) {
       const refShape = def._shape;
       if (refShape) {
         for (const [childKey, childDef] of Object.entries(refShape)) {
-          ref[childKey] = readValue(childDef, childKey, ref);
+          const child = readValue(childDef, childKey, ref);
+          if (child !== void 0) {
+            ref[childKey] = child;
+          }
         }
       }
       return ref;
@@ -1334,13 +1425,19 @@ function prepareForRead(shape, stored, decryptFn) {
   };
   const result = {};
   for (const key in shape) {
-    result[key] = readValue(shape[key], key, stored);
+    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]";
@@ -1385,18 +1482,37 @@ function sanitizeForLog(shape, data, pseudonymFn) {
 }
 function getPiiAudit(shape) {
   const piiFields = [];
-  for (const key in shape) {
-    const def = shape[key];
-    if (!def) continue;
+  const visit = (def, path) => {
+    if (!def) return;
     if (def._pii && def._pii.classification !== "none") {
       piiFields.push({
-        field: key,
+        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;
 }
@@ -1629,9 +1745,7 @@ function validateEnum(parentKey, value, 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(
-        ", "
-      )}`;
+      return `Field ${parentKey} must contain only: ${values.join(", ")}`;
     }
   } else {
     if (!values.includes(value)) {
@@ -1665,6 +1779,126 @@ function getValidator(def) {
 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 {
@@ -2125,6 +2359,8 @@ function createSchema(_shape, entityType, options = {
   table: "",
   schemaValidator: () => true,
   piiEnforcement: "none",
+  unknownFields: SCHEMA_UNKNOWN_FIELDS_POLICIES[0],
+  identity: SCHEMA_IDENTITY_POLICIES[0],
   schemaUpgrade: void 0
 }) {
   const systemFields = {
@@ -2151,6 +2387,57 @@ function createSchema(_shape, entityType, options = {
       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;
@@ -2173,6 +2460,19 @@ function createSchema(_shape, entityType, options = {
         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];
@@ -2255,7 +2555,11 @@ function createSchema(_shape, entityType, options = {
       }
       if (errors.length === 0 && options.schemaValidator) {
         const castValue = result;
-        if (!options.schemaValidator(castValue)) {
+        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.");
         }
       }
@@ -2559,10 +2863,1947 @@ function getComponentSchema(type) {
 function getAllComponentSchemas() {
   return Array.from(componentSchemaRegistry.entries());
 }
+
+// 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-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/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
+  };
+};
+
+// unicode/feedback-unicode-15.1.0-unassigned.json
+var feedback_unicode_15_1_0_unassigned_default = {
+  profileId: "unicode-15.1.0-nfkc-v1",
+  unicodeVersion: "15.1.0",
+  sourcePackage: "@unicode/unicode-15.1.0",
+  sourcePackageVersion: "1.6.17",
+  sourceProperty: "General_Category/Unassigned",
+  rangeEncoding: "flat-half-open-delta-uleb128-base64url-v1",
+  rangeCount: 707,
+  endpointCount: 1414,
+  codePointCount: 824718,
+  endpointSha256: "591e457524d6b4b988aa7c7687e76c95a78370fea38bbd1b09085be7fd935ef3",
+  payload: "-AYCBgQHAQEBFAGNAwEmAjICAwE3CBsEBguOAgE8AmUOOwIxAg8BHAIBAQsFHwECBuwBAQgCAgIWAQcBAQMEAgkCAgIECAEEAgEFAhkCAwEGBAICFgEHAQIBAgECAgEBBQQCAgMDAQcEAQEHEQoDAQkBAwEWAQcBAgEFAgoBAwEDAgEPBAIMBwcBAwEIAgICFgEHAQIBBQIJAgICAwcDBAIBBQISCgIBBgMDAQQDAgEBAQIDAgMDAwwEBQMDAQQCAQYBDhUFDQEDARcBEAIJAQMBBAcCAQMCAQIEAgoHFgEDARcBCgEFAgkBAwEEBwIGAgEEAgoBAwwNAQMBMwEDAQYEEAIaAQMBEgMYAQkBAQIHAwEEBgEBAQgGCgIDDDoEHSUCAQEBBQEYAQEBFwIFAQEBBwEKAgQgSAEkBCcBJAEPAQ0lxgEBAQUBAvkCAQQCBwEBAQQCKQEEAiEBBAIHAQEBBAIPATkBBAJDAiADGgZWAgYCnQUDWQcWCRgJFAwNAQMBAgxeAgoGCgYaBlkHKwVGCh8BDAQMBAEDKgIFCywEGgYLAz4CQQEdAgsGCgYOAh8xTQMvAXQIPAMPAzwHKwILCCsFlgQCBgImAgYCCAEBAQEBAQEfAjUBDwEOAgYBEwIDAQkBZQEMAhsBDQMhDyEPjAEElwUZCxWUDgIgAd0CBS0BAQUBAjgHAg4YCQcBBwEHAQcBBwEHAQcBBwF-IhoBWQzWARpQAVYCZwUrAV4BVAswAe3kAQM3CdwCFLgBCMsBBQIBAQEFGDsDCgY4CEYIDAZ0Cx4DTgELBCEBNwkOAgoCZxgcCgYCBgIGCQcBBwE8BH4CCgakVwwXBDEE7kQCaiYHDAUFGgEFAQEBAgECAX0QvQMCNgcBICoGMwETAQQEBQGHAQIBAb4BAwYCBgIGAgMDBwEHCgUCDAEaARMBAgEPAg4iewUDBC0DWAENAwEvLoIBHQMxDxwEJAkeBSsFHgElBA4qngECCgYkBCQEKAg0CwwBDwEHAQIBCwEPAQcBAkO3AgkWCggYBgEqAQlFBgIBASwBAgMBAhcBSAgJMBMBAgUhAxsFAUA4BBQCMgECBQgBAwEdAgMECgcJB0AgJwQMCTYDHQIbBRoHBAwHUEk3Mw0zBy4ICqYCHwEqAQMCAksrCCoWGiYcFBcJTgQkCUQKAQIZBwoGNQESCCcJYAEUCxIBLz4HAQEBBAEPAQsGOwUKBgQBCAICAhYBBwECAQUBCgICAgMCAQYBBQcCBwMFiwFcAQUeSAgKpgE2AiYiRQsKBg0TOgYKNhsCDwQXuQE8ZFMMCAIBAggBAgEeAQICDAkKRggCLgILG0gIUw1JBwr2AQkBLQEOCh0DIAIWAQ5JBwECASwDAQECAQkICgYGAQIBJQECAQYHCrYCGQcRASkDHFYBDzINmwdmbwEFC8QBzBRjDdYIqh_HBLlDuQQHHwEKBFEBCgYeAgYKRgoKAQcBFQUTsAVbZUsEOQcRQAULAg74LwjWCSoJ50UEAQcBAgGjAg8BHQMCAQ4ECIwDhBJrBQ0DCQcKAgjcJC4CFwl0PPYBCicCwgEVRnoUDBQMVwkZhwFVAUcBAgIBAgICBAEMAQEBBwFBAQQCCAEHARwBBAEFAQEDBwHUAgKkAgK-BQ8FAQ_QCB8GBtUBBwERAgcBAgEFBT4hAXAtAw4CCgQCwAIfEToFAdADKuYFBwEEAQIBDwHFAQIQKUwECgQCkQZETD3CAQQBGwECAQECAQEKAQQBAQEBBgEEAQEBAQEBAwECAQECAQEBAQEBAQEBAQIBAQIEAQcBBAEEAQEBCgERBQMBBQERNAKOAiwEZAwPAg8BDwElCq4BOB0NLAQJBwIOBpoB2AcEEQMNA3cEXwYMBAEPDAQ4CAoGKAgeAgJO1AIMDgINAwkHLgEHCA4ECQcJB5MBATclCoYI4M0CILogBt4BAoItDrE6D-4EohOeBOILyyYF4CDRuCsBHmCAAfABkPwD_v8DAv7_AwI"
+};
+
+// src/feedback-unicode-profile.codec.ts
+var BASE64URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var BASE64URL_PATTERN = /^[A-Za-z0-9_-]+$/;
+var MAX_UNICODE_ENDPOINT = 1114112;
+var MAX_ENCODED_PAYLOAD_CHARACTERS = 8192;
+var MAX_ULEB128_BYTES = 5;
+var MAX_PROFILE_RANGE_COUNT = 707;
+var MAX_PROFILE_ENDPOINT_COUNT = MAX_PROFILE_RANGE_COUNT * 2;
+var MAX_PROFILE_CODE_POINT_COUNT = MAX_UNICODE_ENDPOINT;
+var ARTIFACT_KEYS = /* @__PURE__ */ new Set([
+  "profileId",
+  "unicodeVersion",
+  "sourcePackage",
+  "sourcePackageVersion",
+  "sourceProperty",
+  "rangeEncoding",
+  "rangeCount",
+  "endpointCount",
+  "codePointCount",
+  "endpointSha256",
+  "payload"
+]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExpectedMetadata(artifact, expected) {
+  return Object.keys(artifact).length === ARTIFACT_KEYS.size && Object.keys(artifact).every((key) => ARTIFACT_KEYS.has(key)) && artifact.profileId === expected.profileId && artifact.unicodeVersion === expected.unicodeVersion && artifact.sourcePackage === expected.sourcePackage && artifact.sourcePackageVersion === expected.sourcePackageVersion && artifact.sourceProperty === expected.sourceProperty && artifact.rangeEncoding === expected.rangeEncoding && artifact.rangeCount === expected.rangeCount && artifact.endpointCount === expected.endpointCount && artifact.codePointCount === expected.codePointCount && artifact.endpointSha256 === expected.endpointSha256;
+}
+function isBoundedPositiveInteger(value, maximum) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= maximum;
+}
+function hasBoundedCounts(artifact, expected) {
+  return isBoundedPositiveInteger(
+    artifact.rangeCount,
+    MAX_PROFILE_RANGE_COUNT
+  ) && isBoundedPositiveInteger(
+    expected.rangeCount,
+    MAX_PROFILE_RANGE_COUNT
+  ) && isBoundedPositiveInteger(
+    artifact.endpointCount,
+    MAX_PROFILE_ENDPOINT_COUNT
+  ) && isBoundedPositiveInteger(
+    expected.endpointCount,
+    MAX_PROFILE_ENDPOINT_COUNT
+  ) && artifact.endpointCount === artifact.rangeCount * 2 && expected.endpointCount === expected.rangeCount * 2 && isBoundedPositiveInteger(
+    artifact.codePointCount,
+    MAX_PROFILE_CODE_POINT_COUNT
+  ) && isBoundedPositiveInteger(
+    expected.codePointCount,
+    MAX_PROFILE_CODE_POINT_COUNT
+  );
+}
+function decodeCanonicalBase64Url(value) {
+  if (value.length === 0 || value.length > MAX_ENCODED_PAYLOAD_CHARACTERS || value.length % 4 === 1 || !BASE64URL_PATTERN.test(value)) {
+    return void 0;
+  }
+  const finalSextet = BASE64URL_ALPHABET.indexOf(value.at(-1) ?? "");
+  if (finalSextet < 0 || value.length % 4 === 2 && (finalSextet & 15) !== 0 || value.length % 4 === 3 && (finalSextet & 3) !== 0) {
+    return void 0;
+  }
+  const expectedByteCount = Math.floor(value.length * 6 / 8);
+  const output = new Uint8Array(expectedByteCount);
+  let outputIndex = 0;
+  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[outputIndex] = accumulator >> bitCount & 255;
+      outputIndex += 1;
+      accumulator &= (1 << bitCount) - 1;
+    }
+  }
+  if (outputIndex !== expectedByteCount || bitCount > 0 && accumulator !== 0) {
+    return void 0;
+  }
+  return output;
+}
+function decodeCanonicalEndpointDeltas(bytes, endpointCount) {
+  if (!isBoundedPositiveInteger(
+    endpointCount,
+    MAX_PROFILE_ENDPOINT_COUNT
+  ) || endpointCount % 2 !== 0) {
+    return void 0;
+  }
+  const endpoints = new Uint32Array(endpointCount);
+  let byteOffset = 0;
+  let previousEndpoint = 0;
+  for (let endpointIndex = 0; endpointIndex < endpointCount; endpointIndex += 1) {
+    let delta = 0;
+    let multiplier = 1;
+    let byteCount = 0;
+    while (true) {
+      if (byteOffset >= bytes.length || byteCount >= MAX_ULEB128_BYTES) {
+        return void 0;
+      }
+      const byte = bytes[byteOffset];
+      if (byte === void 0) {
+        return void 0;
+      }
+      byteOffset += 1;
+      byteCount += 1;
+      const payload = byte & 127;
+      delta += payload * multiplier;
+      if (!Number.isSafeInteger(delta)) {
+        return void 0;
+      }
+      if ((byte & 128) === 0) {
+        if (byteCount > 1 && payload === 0) {
+          return void 0;
+        }
+        break;
+      }
+      multiplier *= 128;
+    }
+    const endpoint = previousEndpoint + delta;
+    if (delta <= 0 || !Number.isSafeInteger(endpoint) || endpoint > MAX_UNICODE_ENDPOINT) {
+      return void 0;
+    }
+    endpoints[endpointIndex] = endpoint;
+    previousEndpoint = endpoint;
+  }
+  if (byteOffset !== bytes.length) {
+    return void 0;
+  }
+  return endpoints;
+}
+function hasExpectedRanges(endpoints, expected) {
+  let previousEnd = -1;
+  let codePointCount = 0;
+  for (let index = 0; index < endpoints.length; index += 2) {
+    const start = endpoints[index];
+    const end = endpoints[index + 1];
+    if (start === void 0 || end === void 0 || start <= previousEnd || end <= start || end > MAX_UNICODE_ENDPOINT) {
+      return false;
+    }
+    codePointCount += end - start;
+    previousEnd = end;
+  }
+  return codePointCount === expected.codePointCount;
+}
+function decodeFeedbackUnicodeProfileArtifact(value, expected) {
+  if (!isRecord(value) || !hasBoundedCounts(value, expected) || !hasExpectedMetadata(value, expected) || typeof value.payload !== "string") {
+    return void 0;
+  }
+  const bytes = decodeCanonicalBase64Url(value.payload);
+  if (bytes === void 0) {
+    return void 0;
+  }
+  const endpoints = decodeCanonicalEndpointDeltas(
+    bytes,
+    expected.endpointCount
+  );
+  return endpoints !== void 0 && hasExpectedRanges(endpoints, expected) ? endpoints : void 0;
+}
+
+// src/feedback-unicode-profile.ts
+var FEEDBACK_UNICODE_PROFILE_ID = "unicode-15.1.0-nfkc-v1";
+var FEEDBACK_UNICODE_PROFILE_ENDPOINT_SHA256 = "591e457524d6b4b988aa7c7687e76c95a78370fea38bbd1b09085be7fd935ef3";
+var MAX_UNICODE_CODE_POINT = 1114111;
+var HIGH_SURROGATE_START = 55296;
+var HIGH_SURROGATE_END = 56319;
+var LOW_SURROGATE_START = 56320;
+var LOW_SURROGATE_END = 57343;
+var UNASSIGNED_RANGE_ENDPOINTS = decodeFeedbackUnicodeProfileArtifact(
+  feedback_unicode_15_1_0_unassigned_default,
+  {
+    profileId: FEEDBACK_UNICODE_PROFILE_ID,
+    unicodeVersion: "15.1.0",
+    sourcePackage: "@unicode/unicode-15.1.0",
+    sourcePackageVersion: "1.6.17",
+    sourceProperty: "General_Category/Unassigned",
+    rangeEncoding: "flat-half-open-delta-uleb128-base64url-v1",
+    rangeCount: 707,
+    endpointCount: 1414,
+    codePointCount: 824718,
+    endpointSha256: FEEDBACK_UNICODE_PROFILE_ENDPOINT_SHA256
+  }
+);
+function isFeedbackUnicodeProfileUnassigned(codePoint) {
+  if (UNASSIGNED_RANGE_ENDPOINTS === void 0 || !Number.isInteger(codePoint) || codePoint < 0 || codePoint > MAX_UNICODE_CODE_POINT || codePoint >= HIGH_SURROGATE_START && codePoint <= LOW_SURROGATE_END) {
+    return true;
+  }
+  let lowerRange = 0;
+  let upperRange = UNASSIGNED_RANGE_ENDPOINTS.length / 2 - 1;
+  while (lowerRange <= upperRange) {
+    const rangeIndex = Math.floor((lowerRange + upperRange) / 2);
+    const start = UNASSIGNED_RANGE_ENDPOINTS[rangeIndex * 2];
+    const end = UNASSIGNED_RANGE_ENDPOINTS[rangeIndex * 2 + 1];
+    if (start === void 0 || end === void 0) {
+      return true;
+    }
+    if (codePoint < start) {
+      upperRange = rangeIndex - 1;
+    } else if (codePoint >= end) {
+      lowerRange = rangeIndex + 1;
+    } else {
+      return true;
+    }
+  }
+  return false;
+}
+function containsFeedbackUnicodeProfileUnsupportedText(text) {
+  if (typeof text !== "string") {
+    return true;
+  }
+  for (let index = 0; index < text.length; index += 1) {
+    const first = text.charCodeAt(index);
+    let codePoint = first;
+    if (first >= HIGH_SURROGATE_START && first <= HIGH_SURROGATE_END) {
+      const second = text.charCodeAt(index + 1);
+      if (!Number.isInteger(second) || second < LOW_SURROGATE_START || second > LOW_SURROGATE_END) {
+        return true;
+      }
+      codePoint = 65536 + (first - HIGH_SURROGATE_START << 10) + (second - LOW_SURROGATE_START);
+      index += 1;
+    } else if (first >= LOW_SURROGATE_START && first <= LOW_SURROGATE_END) {
+      return true;
+    }
+    if (isFeedbackUnicodeProfileUnassigned(codePoint)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// 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);
+}
+for (const entry of [
+  ...FEEDBACK_SEVERITY_LEVELS,
+  ...FEEDBACK_SATISFACTION_LEVELS,
+  ...FEEDBACK_SURFACE_DEFINITIONS
+]) {
+  Object.freeze(entry);
+}
+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_PATTERN2 = /^[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_ALPHABET2 = "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 decodeCanonicalBase64Url2 = (value) => {
+  if (!BASE64URL_PATTERN2.test(value) || value.length % 4 === 1) {
+    return void 0;
+  }
+  const finalValue = BASE64URL_ALPHABET2.indexOf(value.at(-1) ?? "");
+  if (finalValue < 0 || value.length % 4 === 2 && (finalValue & 15) !== 0 || value.length % 4 === 3 && (finalValue & 3) !== 0) {
+    return void 0;
+  }
+  const output = [];
+  let accumulator = 0;
+  let bitCount = 0;
+  for (const character of value) {
+    const sextet = BASE64URL_ALPHABET2.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;
+    }
+  }
+  return Uint8Array.from(output);
+};
+var isCanonicalRsaModulus = (value) => {
+  const bytes = decodeCanonicalBase64Url2(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 = decodeCanonicalBase64Url2(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 positiveCountField2 = (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_PATTERN2).validator(
+  (value) => {
+    const decoded = decodeCanonicalBase64Url2(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 nestedIdentityShape2 = (type) => ({
+  type: field.string().enum([type]),
+  version: field.string().enum([FEEDBACK_CONTRACT_VERSION])
+});
+var envelopeShape = (includeIdentity = false) => ({
+  ...includeIdentity ? nestedIdentityShape2("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 ? nestedIdentityShape2("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 (new Set(intentIds).size !== intentIds.length || new Set(themeIds).size !== themeIds.length) {
+    return false;
+  }
+  if (status === "structured-only") {
+    return value.sentiment === void 0 && value.confidence === void 0 && intentIds.length === 0 && themeIds.length === 0;
+  }
+  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;
+  }
+  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;
+  }
+  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;
+};
+var isContextConsistent = (value) => {
+  if (!areSurfacesConsistent(value.surfaces)) {
+    return false;
+  }
+  if (value.selectedSurfaceId !== void 0 && !value.surfaces.some(
+    (surface) => surface.id === value.selectedSurfaceId
+  )) {
+    return false;
+  }
+  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;
+  }
+  const generatedAt = Date.parse(String(value.generatedAt));
+  if (!Number.isFinite(generatedAt)) {
+    return false;
+  }
+  const boundedFutureAvailabilityIsValid = (candidate, maximumSeconds) => {
+    if (candidate === void 0) {
+      return true;
+    }
+    const availableAt = Date.parse(String(candidate));
+    return Number.isFinite(availableAt) && availableAt > generatedAt && availableAt - generatedAt <= maximumSeconds * 1e3;
+  };
+  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;
+  }
+  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;
+  }
+  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: positiveCountField2(),
+  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;
+    }
+    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;
+    }
+    iso = `${windowKey}T00:00:00.000Z`;
+    expectedLength = 10;
+    duration = 24 * 60 * 60 * 1e3;
+  } else {
+    if (!RECONCILIATION_WINDOW_PATTERN.test(windowKey)) {
+      return void 0;
+    }
+    const minute = Number(windowKey.slice(-2));
+    if (minute % 5 !== 0) {
+      return void 0;
+    }
+    iso = `${windowKey}:00.000Z`;
+    expectedLength = 16;
+    duration = 5 * 60 * 1e3;
+  }
+  const start = Date.parse(iso);
+  if (!Number.isFinite(start) || new Date(start).toISOString().slice(0, expectedLength) !== windowKey) {
+    return void 0;
+  }
+  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;
+  }
+  const completedAt = Date.parse(
+    String(
+      artifact === "checkpoint" ? value.completedAt : value.generatedAt
+    )
+  );
+  if (!Number.isFinite(completedAt) || completedAt < window.start + window.duration) {
+    return false;
+  }
+  if (artifact === "checkpoint" && value.checkpointId !== `checkpoint:${processor}:${windowKey}`) {
+    return false;
+  }
+  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;
+  }
+  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;
+    }
+    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;
+    }
+  }
+);
+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;
+    }
+  }
+);
+var validateFeedbackTransientAnalysisRequest = (input) => {
+  const result = FeedbackTransientAnalysisRequestSchema.validate(input);
+  if (!result.valid || result.value === void 0) {
+    return {
+      valid: false,
+      errors: result.errors ?? ["Transient analysis validation failed."],
+      ...result.issues === void 0 ? {} : { issues: result.issues }
+    };
+  }
+  return {
+    valid: true,
+    value: result.value
+  };
+};
+var FeedbackAnalysisReceiptSchema = createSchema(
+  analysisReceiptShape(),
+  "feedback-analysis-receipt",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => value.status === "analyzed" && isAnalysisProjectionConsistent(value)
+  }
+);
+var FeedbackDerivedAnalysisSchema = createSchema(
+  analysisProjectionShape(),
+  "feedback-derived-analysis",
+  {
+    ...strictOptions,
+    schemaValidator: isAnalysisProjectionConsistent
+  }
+);
+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)
+  }
+);
+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: positiveCountField2().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_PATTERN2).validator(isCanonicalRsaModulus),
+        e: field.string().min(2).max(6).pattern(BASE64URL_PATTERN2).validator(isCanonicalRsaExponent),
+        ext: field.boolean().validator((value) => value === true)
+      }),
+      expiresAt: field.dateTimeISO()
+    }).optional()
+  },
+  "feedback-context",
+  {
+    ...strictOptions,
+    schemaValidator: isContextConsistent
+  }
+);
+var FeedbackDraftUpsertRequestSchema = createSchema(
+  {
+    draftId: draftIdField(),
+    kind: field.string().enum(["bug", "review"]),
+    revision: revisionField(),
+    ...optionalDraftFields()
+  },
+  "feedback-draft-upsert-request",
+  {
+    ...strictOptions,
+    schemaValidator: isDraftShapeConsistent
+  }
+);
+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;
+      }
+      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;
+    }
+  }
+);
+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;
+    }
+  }
+);
+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)
+  }
+);
+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
+      );
+    }
+  }
+);
+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)
+  }
+);
+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)
+  }
+);
+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;
+    }
+  }
+);
+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
+      );
+    }
+  }
+);
+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 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;
+      }
+    }
+    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;
+      }
+      if (value.acceptedReviewCount === 0 && (value.meanStars !== void 0 || value.medianStars !== void 0)) {
+        return false;
+      }
+      if (value.acceptedReviewCount > 0 && (value.meanStars === void 0 || value.medianStars === void 0)) {
+        return false;
+      }
+      const distributions = [
+        value.starDistribution,
+        value.sentimentDistribution,
+        value.intentDistribution
+      ];
+      const periods = value.rollingWindows.map(
+        (window) => window.period
+      );
+      const sevenDayWindow = value.rollingWindows.find(
+        (window) => window.period === "7-days"
+      );
+      const thirtyDayWindow = value.rollingWindows.find(
+        (window) => window.period === "30-days"
+      );
+      const ninetyDayWindow = value.rollingWindows.find(
+        (window) => window.period === "90-days"
+      );
+      if (sevenDayWindow === void 0 || thirtyDayWindow === void 0 || ninetyDayWindow === void 0) {
+        return false;
+      }
+      const statistics = satisfactionStatistics(
+        value.starDistribution,
+        value.acceptedReviewCount
+      );
+      const lagSeconds = Math.floor(
+        (Date.parse(String(value.generatedAt)) - Date.parse(String(value.windowEnd))) / 1e3
+      );
+      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;
+    }
+  }
+);
+var publicWeeklyPointShape = () => ({
+  weekStart: field.dateTimeISO(),
+  state: field.string().enum(["published", "suppressed"]),
+  acceptedReviewCount: positiveCountField2().optional(),
+  averageStars: field.number().min(1).max(5).optional()
+});
+var publicComparisonShape = () => ({
+  previousAcceptedReviewCount: positiveCountField2(),
+  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: positiveCountField2().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
+      );
+      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;
+      }
+      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 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;
+      }
+      if (value.processor === "commit-reconciliation") {
+        return value.status === "no-op" && value.revision >= 1 && value.outputReportId === void 0 && value.lateArrivalCount === 0;
+      }
+      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;
+    }
+  }
+);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  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,
@@ -2585,7 +4826,10 @@ function getAllComponentSchemas() {
   validateCountryCode,
   validateCurrencyCode,
   validateDateTimeISO,
+  validateDisplayName,
   validateEmail,
+  validateFeedbackGameDiagnostics,
+  validateFeedbackTransientAnalysisRequest,
   validateLanguage,
   validateName,
   validatePercentage,