@plasius/schema 1.4.1 → 1.4.3

package/dist/feedback-diagnostics.js

@@ -1,7 +1,7 @@
 import {
   FeedbackGameDiagnosticsSchema,
   validateFeedbackGameDiagnostics
-} from "./chunk-UQHPDQZX.js";
+} from "./chunk-GNL2RBO5.js";
 import {
   FEEDBACK_BACKEND_BUCKETS,
   FEEDBACK_CONTRACT_VERSION,

package/dist/index.cjs

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  FEEDBACK_ABUSE_BLOCK_BANDS: () => FEEDBACK_ABUSE_BLOCK_BANDS,
   FEEDBACK_ANALYSIS_MODEL_VERSIONS: () => FEEDBACK_ANALYSIS_MODEL_VERSIONS,
   FEEDBACK_BACKEND_BUCKETS: () => FEEDBACK_BACKEND_BUCKETS,
   FEEDBACK_BUG_COOLDOWN_SECONDS: () => FEEDBACK_BUG_COOLDOWN_SECONDS,
@@ -51,6 +52,7 @@ __export(index_exports, {
   FEEDBACK_VIEWPORT_BUCKETS: () => FEEDBACK_VIEWPORT_BUCKETS,
   FeedbackAcceptanceReceiptSchema: () => FeedbackAcceptanceReceiptSchema,
   FeedbackAnalysisReceiptSchema: () => FeedbackAnalysisReceiptSchema,
+  FeedbackBugHealthMetricsProjectionSchema: () => FeedbackBugHealthMetricsProjectionSchema,
   FeedbackBugPacketSchema: () => FeedbackBugPacketSchema,
   FeedbackBugSubmissionRequestSchema: () => FeedbackBugSubmissionRequestSchema,
   FeedbackCommittedAcceptanceEvidenceSchema: () => FeedbackCommittedAcceptanceEvidenceSchema,
@@ -1783,45 +1785,113 @@ function getShape(def) {
 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 }
-  ];
+function snapshotStrictInput(input) {
+  const snapshot = Array.isArray(input) ? [] : {};
+  const pending = [{ source: input, target: snapshot, depth: 0 }];
   const seen = /* @__PURE__ */ new WeakSet();
-  let visitedNodes = 0;
+  let visitedNodes = 1;
   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;
+        return { valid: false };
       }
-      if (typeof current.value !== "object" || current.value === null) {
-        continue;
+      if (seen.has(current.source)) {
+        return { valid: false };
       }
-      if (seen.has(current.value)) {
-        return false;
+      seen.add(current.source);
+      const isArray = Array.isArray(current.source);
+      const prototype = Object.getPrototypeOf(current.source);
+      if (isArray && prototype !== Array.prototype || !isArray && prototype !== Object.prototype && prototype !== null) {
+        return { valid: false };
       }
-      seen.add(current.value);
-      const keys = Object.keys(current.value);
-      if (visitedNodes + pending.length + keys.length > MAX_STRICT_VALIDATION_NODES) {
-        return false;
+      const ownKeys = Reflect.ownKeys(current.source);
+      if (visitedNodes + ownKeys.length > MAX_STRICT_VALIDATION_NODES) {
+        return { valid: false };
       }
-      const record = current.value;
+      const descriptors = /* @__PURE__ */ new Map();
+      for (const key of ownKeys) {
+        const descriptor = Object.getOwnPropertyDescriptor(
+          current.source,
+          key
+        );
+        if (descriptor === void 0) {
+          return { valid: false };
+        }
+        descriptors.set(key, descriptor);
+      }
+      if (isArray) {
+        const lengthDescriptor = descriptors.get("length");
+        if (lengthDescriptor === void 0 || !("value" in lengthDescriptor) || !Number.isSafeInteger(lengthDescriptor.value) || lengthDescriptor.value < 0 || lengthDescriptor.value > MAX_STRICT_VALIDATION_NODES) {
+          return { valid: false };
+        }
+        let elementCount = 0;
+        for (const key of ownKeys) {
+          if (key === "length") {
+            continue;
+          }
+          if (typeof key !== "string" || !/^(?:0|[1-9]\d*)$/.test(key)) {
+            return { valid: false };
+          }
+          const descriptor = descriptors.get(key);
+          if (descriptor === void 0 || descriptor.enumerable !== true || Number(key) >= lengthDescriptor.value) {
+            return { valid: false };
+          }
+          elementCount += 1;
+        }
+        if (elementCount !== lengthDescriptor.value) {
+          return { valid: false };
+        }
+      }
+      visitedNodes += ownKeys.length;
+      const keys = ownKeys.filter(
+        (key) => descriptors.get(key)?.enumerable
+      );
       for (const key of keys) {
-        pending.push({
-          value: record[key],
-          depth: current.depth + 1
+        if (typeof key !== "string") {
+          return { valid: false };
+        }
+        if (isArray && !/^(?:0|[1-9]\d*)$/.test(key)) {
+          return { valid: false };
+        }
+        const descriptor = descriptors.get(key);
+        if (descriptor === void 0 || !("value" in descriptor) || descriptor.get !== void 0 || descriptor.set !== void 0) {
+          return { valid: false };
+        }
+        const child = descriptor.value;
+        if (typeof child === "function") {
+          return { valid: false };
+        }
+        if (typeof child === "object" && child !== null) {
+          const childSnapshot = Array.isArray(child) ? [] : {};
+          Object.defineProperty(current.target, key, {
+            value: childSnapshot,
+            enumerable: true,
+            configurable: true,
+            writable: true
+          });
+          pending.push({
+            source: child,
+            target: childSnapshot,
+            depth: current.depth + 1
+          });
+          continue;
+        }
+        Object.defineProperty(current.target, key, {
+          value: child,
+          enumerable: true,
+          configurable: true,
+          writable: true
         });
       }
     }
   } catch {
-    return false;
+    return { valid: false };
   }
-  return true;
+  return { valid: true, value: snapshot };
 }
 function strictReferenceShape(def) {
   return {
@@ -2388,8 +2458,10 @@ function createSchema(_shape, entityType, options = {
       if (typeof input !== "object" || input === null) {
         return { valid: false, errors: ["Input must be an object"] };
       }
+      let strictInputSnapshot;
       if (options.unknownFields === "reject") {
-        if (!strictInputIsWithinComplexityLimit(input)) {
+        const snapshot = snapshotStrictInput(input);
+        if (!snapshot.valid) {
           return {
             valid: false,
             errors: ["Strict validation complexity limit exceeded."],
@@ -2402,16 +2474,32 @@ function createSchema(_shape, entityType, options = {
             ]
           };
         }
+        strictInputSnapshot = snapshot.value;
         const scanState = {
           remainingObjects: MAX_STRICT_VALIDATION_OBJECTS,
           limitExceeded: false
         };
-        const locations = unknownFieldLocations(
-          input,
-          schema._shape,
-          "root",
-          scanState
-        );
+        let locations;
+        try {
+          locations = unknownFieldLocations(
+            strictInputSnapshot,
+            schema._shape,
+            "root",
+            scanState
+          );
+        } catch {
+          return {
+            valid: false,
+            errors: ["Strict validation complexity limit exceeded."],
+            issues: [
+              {
+                path: "root",
+                code: "validation_complexity_limit",
+                message: "Strict validation complexity limit exceeded."
+              }
+            ]
+          };
+        }
         if (scanState.limitExceeded) {
           return {
             valid: false,
@@ -2439,7 +2527,23 @@ function createSchema(_shape, entityType, options = {
           };
         }
       }
-      const working = typeof input === "object" && input !== null ? deepClone(input) : { ...input };
+      let working;
+      try {
+        working = strictInputSnapshot ?? (typeof input === "object" && input !== null ? deepClone(input) : { ...input });
+      } catch {
+        return {
+          valid: false,
+          errors: ["Input could not be safely cloned."],
+          issues: [
+            {
+              path: "root",
+              code: "unsafe_input",
+              message: "Input could not be safely cloned."
+            }
+          ]
+        };
+      }
+      const providedFieldNames = new Set(Object.keys(working));
       if (working.type == null) working.type = entityType;
       if (working.version == null) working.version = version;
       const fromVersion = String(working.version ?? "0.0.0");
@@ -2556,9 +2660,8 @@ function createSchema(_shape, entityType, options = {
       }
       if (errors.length === 0 && options.schemaValidator) {
         const castValue = result;
-        const source = input;
         const validationContext = Object.freeze({
-          wasProvided: (fieldName) => Object.prototype.hasOwnProperty.call(source, fieldName)
+          wasProvided: (fieldName) => providedFieldNames.has(fieldName)
         });
         if (!options.schemaValidator(castValue, validationContext)) {
           errors.push("Schema-level validation failed.");
@@ -3398,6 +3501,15 @@ var FEEDBACK_BUG_COOLDOWN_SECONDS = Object.freeze([
   24 * 60 * 60
 ]);
 var FEEDBACK_REVIEW_COOLDOWN_SECONDS = 30 * 24 * 60 * 60;
+var FEEDBACK_ABUSE_BLOCK_BANDS = Object.freeze([
+  "five-minutes",
+  "fifteen-minutes",
+  "one-hour",
+  "six-hours",
+  "twenty-four-hours",
+  "fail-closed",
+  "edge-blocked"
+]);
 var FEEDBACK_ISSUE_TYPES = [
   "visual-layout",
   "functionality",
@@ -4305,6 +4417,43 @@ var FeedbackCommittedAcceptanceEvidenceSchema = createSchema(
   "feedback-committed-acceptance-evidence",
   strictOptions
 );
+var FeedbackBugHealthMetricsProjectionSchema = createSchema(
+  {
+    projectionId: uuidField(),
+    windowStart: canonicalServerUtcField(),
+    windowEnd: canonicalServerUtcField(),
+    observedAt: canonicalServerUtcField(),
+    finalized: field.boolean().validator((value) => value === true),
+    rejectedCount: countField(),
+    trafficDenominator: countField(),
+    abuseBlockBands: field.array(
+      field.object({
+        id: field.string().enum(FEEDBACK_ABUSE_BLOCK_BANDS),
+        count: positiveCountField2()
+      })
+    ).max(FEEDBACK_ABUSE_BLOCK_BANDS.length)
+  },
+  "feedback-bug-health-metrics-projection",
+  {
+    ...strictOptions,
+    schemaValidator: (value) => {
+      const blockBands = value.abuseBlockBands;
+      let previousIndex = -1;
+      const canonicalBands = blockBands.every((bucket) => {
+        const index = FEEDBACK_ABUSE_BLOCK_BANDS.indexOf(bucket.id);
+        if (index <= previousIndex) {
+          return false;
+        }
+        previousIndex = index;
+        return true;
+      });
+      return orderedWindow(
+        { ...value, generatedAt: value.observedAt },
+        60 * 60 * 1e3
+      ) && Date.parse(String(value.observedAt)) >= Date.parse(String(value.windowEnd)) && canonicalBands;
+    }
+  }
+);
 var FeedbackGameReconstructionManifestSchema = createSchema(
   {
     reconstructionId: uuidField(),
@@ -4429,20 +4578,10 @@ var FeedbackHourlyBugReportSchema = createSchema(
     abuseBlockBands: field.array(
       field.object(
         distributionShape(
-          () => field.string().enum(
-            [
-              "five-minutes",
-              "fifteen-minutes",
-              "one-hour",
-              "six-hours",
-              "twenty-four-hours",
-              "fail-closed",
-              "edge-blocked"
-            ]
-          )
+          () => field.string().enum(FEEDBACK_ABUSE_BLOCK_BANDS)
         )
       )
-    ).max(16),
+    ).max(FEEDBACK_ABUSE_BLOCK_BANDS.length),
     comparison: field.object({
       previousHourRatio: field.number().min(0).max(1e3),
       sevenDaySameHourRatio: field.number().min(0).max(1e3)
@@ -4744,6 +4883,7 @@ var FeedbackMaterializationManifestSchema = createSchema(
     generatedAt: field.dateTimeISO(),
     sourcePacketCount: countField(),
     lateArrivalCount: countField(),
+    correctionReason: field.string().enum(["late-arrival", "metrics-source"]).optional(),
     outputReportId: uuidField().optional(),
     status: field.string().enum(["published", "corrected", "no-op"])
   },
@@ -4755,14 +4895,15 @@ var FeedbackMaterializationManifestSchema = createSchema(
         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 === "no-op" && value.revision >= 1 && value.outputReportId === void 0 && value.correctionReason === 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;
+      return value.status === "published" && value.revision === 1 && value.lateArrivalCount === 0 && value.correctionReason === void 0 && value.outputReportId !== void 0 || value.status === "corrected" && value.revision >= 2 && (value.correctionReason === "metrics-source" && value.lateArrivalCount === 0 || (value.correctionReason === void 0 || value.correctionReason === "late-arrival") && value.lateArrivalCount > 0) && value.outputReportId !== void 0;
     }
   }
 );
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  FEEDBACK_ABUSE_BLOCK_BANDS,
   FEEDBACK_ANALYSIS_MODEL_VERSIONS,
   FEEDBACK_BACKEND_BUCKETS,
   FEEDBACK_BUG_COOLDOWN_SECONDS,
@@ -4794,6 +4935,7 @@ var FeedbackMaterializationManifestSchema = createSchema(
   FEEDBACK_VIEWPORT_BUCKETS,
   FeedbackAcceptanceReceiptSchema,
   FeedbackAnalysisReceiptSchema,
+  FeedbackBugHealthMetricsProjectionSchema,
   FeedbackBugPacketSchema,
   FeedbackBugSubmissionRequestSchema,
   FeedbackCommittedAcceptanceEvidenceSchema,