@inf-monkeys-tech/monkeys 1.1.22 → 1.1.24

package/lib/esm/runtime/index.mjs

@@ -12169,6 +12169,9 @@ var QueryBindingSchema = z13.object({
   draftRetention: z13.object({
     identityParameters: z13.array(ContractIdentifierSchema).min(1).max(32)
   }).strict().optional(),
+  queryRetention: z13.object({
+    identityParameters: z13.array(ContractIdentifierSchema).max(32)
+  }).strict().optional(),
   resultStateBindings: z13.array(QueryResultStateBindingSchema).max(32).optional(),
   execution: z13.enum(["server", "local-state"]).default("server"),
   pagination: z13.enum(["none", "cursor", "offset"]),
@@ -12192,6 +12195,18 @@ var QueryBindingSchema = z13.object({
       });
     }
   }
+  if (value.queryRetention) {
+    const names = value.queryRetention.identityParameters;
+    if (value.execution !== "server" || new Set(names).size !== names.length || names.some(
+      (name) => !Object.prototype.hasOwnProperty.call(value.parameters, name)
+    )) {
+      context.addIssue({
+        code: "custom",
+        path: ["queryRetention"],
+        message: "Query retention requires distinct declared Server query identity parameters."
+      });
+    }
+  }
   if (value.targetProjection) {
     if (value.targetProjection.schemaRevisionRef.kind !== "schema")
       context.addIssue({
@@ -25164,6 +25179,39 @@ var schemasCannotOverlap = (left, right) => {
   const property = (schema2, key) => schema2.properties?.[key] ?? (schema2.patternProperties ? true : schema2.additionalProperties ?? true);
   return [...a.required ?? [], ...b.required ?? []].some((key) => schemasCannotOverlap(property(a, key), property(b, key)));
 };
+var numericBound = (schema2, direction) => {
+  const inclusiveKey = direction === "lower" ? "minimum" : "maximum";
+  const exclusiveKey = direction === "lower" ? "exclusiveMinimum" : "exclusiveMaximum";
+  const inclusiveValue = schema2[inclusiveKey];
+  const exclusiveValue = schema2[exclusiveKey];
+  const candidates = [];
+  if (inclusiveValue !== void 0) {
+    if (typeof inclusiveValue !== "number" || !Number.isFinite(inclusiveValue)) return null;
+    candidates.push({ value: inclusiveValue, inclusive: true });
+  }
+  if (typeof exclusiveValue === "number") {
+    if (!Number.isFinite(exclusiveValue)) return null;
+    candidates.push({ value: exclusiveValue, inclusive: false });
+  } else if (exclusiveValue === true) {
+    if (typeof inclusiveValue !== "number" || !Number.isFinite(inclusiveValue)) return null;
+    candidates.push({ value: inclusiveValue, inclusive: false });
+  } else if (exclusiveValue !== void 0 && exclusiveValue !== false) {
+    return null;
+  }
+  if (!candidates.length) return void 0;
+  const compare = direction === "lower" ? Math.max : Math.min;
+  const value = compare(...candidates.map((candidate) => candidate.value));
+  return { value, inclusive: candidates.filter((candidate) => candidate.value === value).every((candidate) => candidate.inclusive) };
+};
+var boundAcceptsPrevious = (previous, next, direction) => {
+  if (previous === null || next === null) return false;
+  if (!next) return true;
+  if (!previous) return false;
+  if (direction === "lower" && previous.value < next.value) return false;
+  if (direction === "upper" && previous.value > next.value) return false;
+  return previous.value !== next.value || !previous.inclusive || next.inclusive;
+};
+var numericRangesAcceptPrevious = (previous, next) => boundAcceptsPrevious(numericBound(previous, "lower"), numericBound(next, "lower"), "lower") && boundAcceptsPrevious(numericBound(previous, "upper"), numericBound(next, "upper"), "upper");
 var acceptsPreviousSchema = (previous, next) => {
   if (canonicalContentHash(previous) === canonicalContentHash(next) || next === true) return true;
   if (previous === false) return true;
@@ -25182,6 +25230,10 @@ var acceptsPreviousSchema = (previous, next) => {
     additionalProperties: oldAdditional,
     enum: oldEnum,
     items: oldItems,
+    minimum: _oldMinimum,
+    maximum: _oldMaximum,
+    exclusiveMinimum: _oldExclusiveMinimum,
+    exclusiveMaximum: _oldExclusiveMaximum,
     ...oldFixed
   } = before;
   const {
@@ -25190,9 +25242,14 @@ var acceptsPreviousSchema = (previous, next) => {
     additionalProperties: newAdditional,
     enum: newEnum,
     items: newItems,
+    minimum: _newMinimum,
+    maximum: _newMaximum,
+    exclusiveMinimum: _newExclusiveMinimum,
+    exclusiveMaximum: _newExclusiveMaximum,
     ...newFixed
   } = after;
   if (canonicalContentHash(oldFixed) !== canonicalContentHash(newFixed)) return false;
+  if (!numericRangesAcceptPrevious(before, after)) return false;
   if (!acceptsPreviousSchema(oldItems ?? true, newItems ?? true)) return false;
   if (newEnum && (!oldEnum || oldEnum.some((value) => !newEnum.some((candidate) => canonicalContentHash(candidate) === canonicalContentHash(value))))) return false;
   if ((newRequired ?? []).some((key) => !(oldRequired ?? []).includes(key))) return false;