@skill-harness/adapters 0.24.2 → 0.24.3

package/dist/closed-schema.js

@@ -31,10 +31,10 @@ const SUPPORTED_KEYWORDS = new Set([
     // value constraints
     "enum", "const", "minLength", "maxLength", "minimum", "pattern", "format",
 ]);
-/** Ledger v3 adds only closed composition/conditionals and property-name schemas. */
+/** Ledger v3/current record contracts add closed composition, conditionals, arrays and numeric bounds. */
 const V3_SUPPORTED_KEYWORDS = new Set([
     ...SUPPORTED_KEYWORDS,
-    "allOf", "anyOf", "if", "then", "propertyNames", "minItems", "maxItems",
+    "allOf", "anyOf", "if", "then", "not", "propertyNames", "minItems", "maxItems", "uniqueItems", "exclusiveMinimum",
 ]);
 /**
  * The shape each supported keyword must have. A keyword whose *name* is known but
@@ -49,6 +49,7 @@ const KEYWORD_SHAPES = {
     anyOf: { check: (value) => Array.isArray(value) && value.length > 0, expected: "a non-empty array" },
     if: { check: (value) => isSchemaObject(value), expected: "a schema object" },
     then: { check: (value) => isSchemaObject(value), expected: "a schema object" },
+    not: { check: (value) => isSchemaObject(value), expected: "a schema object" },
     propertyNames: { check: (value) => isSchemaObject(value), expected: "a schema object" },
     type: { check: (value) => typeof value === "string" || (Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string")), expected: "a string or array of strings" },
     properties: { check: (value) => isSchemaObject(value), expected: "an object" },
@@ -58,7 +59,9 @@ const KEYWORD_SHAPES = {
     enum: { check: (value) => Array.isArray(value) && value.length > 0, expected: "a non-empty array" },
     minLength: { check: (value) => typeof value === "number", expected: "a number" },
     maxLength: { check: (value) => typeof value === "number", expected: "a number" },
+    exclusiveMinimum: { check: (value) => typeof value === "number" && Number.isFinite(value), expected: "a finite number" },
     minimum: { check: (value) => typeof value === "number", expected: "a number" },
+    uniqueItems: { check: (value) => typeof value === "boolean", expected: "a boolean" },
     minItems: { check: (value) => Number.isInteger(value) && Number(value) >= 0, expected: "a non-negative integer" },
     maxItems: { check: (value) => Number.isInteger(value) && Number(value) >= 0, expected: "a non-negative integer" },
     pattern: { check: (value) => typeof value === "string", expected: "a string" },
@@ -122,7 +125,7 @@ function assertSchemaSupported(schema, label, path, v3) {
     }
     for (const [name, entry] of Object.entries(object(node.properties) ?? {}))
         assertSchemaSupported(entry, label, `${path}/properties/${name}`, v3);
-    for (const keyword of ["items", "propertyNames", "if", "then"]) {
+    for (const keyword of ["items", "propertyNames", "if", "then", "not"]) {
         if (node[keyword] !== undefined)
             assertSchemaSupported(node[keyword], label, `${path}/${keyword}`, v3);
     }
@@ -163,7 +166,7 @@ export function declaredPropertyNames(schema) {
             for (const entry of Array.isArray(current[keyword]) ? current[keyword] : [])
                 walk(entry);
         }
-        for (const keyword of ["items", "propertyNames", "if", "then"])
+        for (const keyword of ["items", "propertyNames", "if", "then", "not"])
             if (current[keyword] !== undefined)
                 walk(current[keyword]);
         if (current.additionalProperties && typeof current.additionalProperties === "object")
@@ -178,6 +181,9 @@ function validate(root, schema, value, path, known) {
         return validate(root, resolved, value, path, known);
     }
     const violations = [];
+    if (schema.not !== undefined && validate(root, schema.not, value, path, known).length === 0) {
+        violations.push({ path, message: "matches a forbidden schema shape" });
+    }
     if (Array.isArray(schema.allOf)) {
         for (const branch of schema.allOf)
             violations.push(...validate(root, branch, value, path, known));
@@ -220,6 +226,9 @@ function validate(root, schema, value, path, known) {
         if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
             violations.push({ path, message: `must contain at most ${schema.maxItems} item(s)` });
         }
+        if (schema.uniqueItems === true && new Set(value.map(canonicalItem)).size !== value.length) {
+            violations.push({ path, message: "must contain unique items" });
+        }
         if (schema.items !== undefined) {
             value.forEach((entry, index) => violations.push(...validate(root, schema.items, entry, `${path}[${index}]`, known)));
         }
@@ -280,6 +289,9 @@ function validateString(schema, value, path) {
     return violations;
 }
 function validateNumber(schema, value, path) {
+    if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum) {
+        return [{ path, message: `must be > ${schema.exclusiveMinimum}` }];
+    }
     if (typeof schema.minimum === "number" && value < schema.minimum) {
         return [{ path, message: `must be >= ${schema.minimum}` }];
     }
@@ -406,4 +418,12 @@ function object(value) {
 function isSchemaObject(value) {
     return object(value) !== undefined;
 }
+/** JSON structural identity for uniqueItems, independent of object key order. */
+function canonicalItem(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalItem).join(",")}]`;
+    return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${canonicalItem(item)}`).join(",")}}`;
+}
 //# sourceMappingURL=closed-schema.js.map