@zanii/certify 0.0.0-stage → 0.6.0

package/dist/schema-dialect.js

@@ -0,0 +1,97 @@
+// Fail closed before the legacy value walker: this is a bounded Certify dialect, not general JSON Schema.
+import { isObj } from "./shared.js";
+import { withinVerificationBudget } from "./verification-bounds.js";
+const KEYWORDS = new Set("$schema $id title $defs $ref type const enum required properties additionalProperties items minItems maxItems uniqueItems minLength maxLength pattern minimum maximum anyOf".split(" "));
+const TYPES = new Set(["object", "array", "string", "integer", "boolean"]);
+const REF = /^#\/\$defs\/[A-Za-z][A-Za-z0-9_-]{0,127}$/;
+export function schemaDialectErrors(schema) {
+    if (!withinVerificationBudget(schema, { maxBytes: 1_048_576, maxNodes: 50_000, maxDepth: 32 }))
+        return ["schema $: exceeds the dialect JSON budget"];
+    const out = [], active = new Set(), visited = new Set();
+    const root = isObj(schema) ? schema : {};
+    const walk = (s, path) => {
+        const error = (message) => out.push(`schema ${path}: ${message}`);
+        if (!isObj(s)) {
+            error("a schema must be an object");
+            return;
+        }
+        if (active.has(s))
+            return;
+        if (visited.has(s))
+            return;
+        active.add(s);
+        for (const k of Object.keys(s).sort())
+            if (!KEYWORDS.has(k))
+                error(`unsupported keyword ${k}`);
+        if ("$schema" in s && s.$schema !== "https://json-schema.org/draft/2020-12/schema")
+            error("unsupported schema dialect");
+        for (const k of ["$id", "title"])
+            if (k in s && (typeof s[k] !== "string" || s[k].length > 2048))
+                error(`${k} must be a bounded string`);
+        if ("type" in s && (typeof s.type !== "string" || !TYPES.has(s.type)))
+            error("unsupported type");
+        for (const k of ["minLength", "maxLength", "minItems", "maxItems"])
+            if (k in s && !(Number.isSafeInteger(s[k]) && s[k] >= 0))
+                error(`${k} must be a nonnegative safe integer`);
+        for (const k of ["minimum", "maximum"])
+            if (k in s && !(typeof s[k] === "number" && Number.isFinite(s[k])))
+                error(`${k} must be finite`);
+        for (const k of ["additionalProperties", "uniqueItems"])
+            if (k in s && typeof s[k] !== "boolean")
+                error(`${k} must be boolean`);
+        if ("enum" in s && (!Array.isArray(s.enum) || s.enum.length < 1 || s.enum.length > 1000))
+            error("enum must contain 1 to 1000 values");
+        if ("required" in s && (!Array.isArray(s.required) || s.required.length > 1000 || !s.required.every((x) => typeof x === "string" && x.length <= 256) || new Set(s.required).size !== s.required.length))
+            error("required must contain distinct bounded names");
+        if ("pattern" in s) {
+            if (typeof s.pattern !== "string" || s.pattern.length > 512 || /[^\x00-\x7f]|\\[pPksS]|\(\?(?![:=!])|\\x(?![0-9a-fA-F]{2})|\\u(?![0-9a-fA-F]{4})/.test(s.pattern) || [...s.pattern.matchAll(/\\([A-Za-z0-9])/g)].some((m) => !"dDwWbBtnrfvux".includes(m[1])))
+                error("unsupported pattern syntax");
+            else
+                try {
+                    new RegExp(s.pattern);
+                }
+                catch {
+                    error("invalid pattern");
+                }
+        }
+        if ("$ref" in s) {
+            if (typeof s.$ref !== "string" || !REF.test(s.$ref) || !isObj(root.$defs) || !Object.hasOwn(root.$defs, s.$ref.slice(8)))
+                error("unresolved or unsupported reference");
+            else {
+                const chain = new Set([s]);
+                let next = root.$defs[s.$ref.slice(8)];
+                while (isObj(next) && typeof next.$ref === "string" && REF.test(next.$ref) && Object.hasOwn(root.$defs, next.$ref.slice(8))) {
+                    if (chain.has(next) || chain.size > 32) {
+                        error("non-consuming or excessive reference chain");
+                        break;
+                    }
+                    chain.add(next);
+                    next = root.$defs[next.$ref.slice(8)];
+                }
+            }
+            if (Object.keys(s).some((k) => !["$ref", "$defs", "$schema", "$id", "title"].includes(k)))
+                error("reference constraint siblings are unsupported");
+        }
+        for (const k of ["properties", "$defs"])
+            if (k in s) {
+                const map = s[k];
+                if (!isObj(map) || Object.keys(map).length > 1000 || Object.keys(map).some((name) => name.length > 256))
+                    error(`${k} must contain bounded schema names`);
+                else
+                    for (const [name, child] of Object.entries(map).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0))
+                        walk(child, `${path}.${k}.${name}`);
+            }
+        if ("items" in s)
+            walk(s.items, `${path}.items`);
+        if ("anyOf" in s) {
+            if (!Array.isArray(s.anyOf) || s.anyOf.length < 1 || s.anyOf.length > 32)
+                error("anyOf must contain 1 to 32 schemas");
+            else
+                s.anyOf.forEach((child, i) => walk(child, `${path}.anyOf[${i}]`));
+        }
+        active.delete(s);
+        visited.add(s);
+    };
+    walk(schema, "$");
+    return [...new Set(out)].sort();
+}

package/dist/schemas/clause-map.schema.json

@@ -0,0 +1,52 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://zanii.agency/certify/schemas/clause-map.schema.json",
+    "title": "Zanii Certify clause map (spec/profiles.md)",
+    "type": "object",
+    "required": ["v", "type", "slug", "version", "title", "source", "clauses"],
+    "additionalProperties": false,
+    "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "certify.clause-map" },
+        "slug": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]{0,63}$" },
+        "version": { "type": "integer", "minimum": 1 },
+        "title": { "$ref": "#/$defs/text" },
+        "source": {
+            "type": "object",
+            "required": ["publisher", "document", "url", "date"],
+            "additionalProperties": false,
+            "properties": {
+                "publisher": { "type": "string", "minLength": 1, "maxLength": 200 },
+                "document": { "type": "string", "minLength": 1, "maxLength": 500 },
+                "url": { "type": "string", "pattern": "^https://" },
+                "date": { "type": "string", "pattern": "^\\d{4}-\\d{2}(-\\d{2})?$" }
+            }
+        },
+        "clauses": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+                "type": "object",
+                "required": ["id", "title", "ref", "interpretation"],
+                "additionalProperties": false,
+                "properties": {
+                    "id": { "type": "string", "pattern": "^[A-Za-z0-9._-]{1,64}$" },
+                    "title": { "$ref": "#/$defs/text" },
+                    "ref": { "type": "string", "minLength": 1, "maxLength": 200 },
+                    "interpretation": { "type": "boolean" }
+                }
+            }
+        }
+    },
+    "$defs": {
+        "text": {
+            "type": "object",
+            "required": ["en", "ar"],
+            "additionalProperties": false,
+            "properties": {
+                "en": { "type": "string", "minLength": 1, "maxLength": 2000 },
+                "ar": { "type": "string", "minLength": 1, "maxLength": 2000 }
+            }
+        }
+    }
+}

package/dist/schemas/profile.schema.json

@@ -0,0 +1,81 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://zanii.agency/certify/schemas/profile.schema.json",
+    "title": "Zanii Certify sector profile (spec/profiles.md)",
+    "type": "object",
+    "required": ["v", "type", "slug", "version", "scheme", "title", "description", "levels", "clause_maps", "categories"],
+    "additionalProperties": false,
+    "properties": {
+        "v": { "const": 1 },
+        "type": { "const": "certify.profile" },
+        "slug": { "$ref": "#/$defs/slug" },
+        "version": { "type": "integer", "minimum": 1 },
+        "scheme": { "enum": ["zanii-certify/0.1", "zanii-certify/0.2", "zanii-certify/0.3", "zanii-certify/0.4"] },
+        "title": { "$ref": "#/$defs/text" },
+        "description": { "$ref": "#/$defs/text" },
+        "levels": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true,
+            "items": { "enum": [1, 2, 3] }
+        },
+        "live_evidence": { "$ref": "#/$defs/live_evidence" },
+        "scenarios": { "type": "boolean" },
+        "clause_maps": {
+            "type": "array",
+            "uniqueItems": true,
+            "items": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]{0,63}/[1-9][0-9]*$" }
+        },
+        "categories": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$ref": "#/$defs/category" }
+        }
+    },
+    "$defs": {
+        "live_evidence": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+                "max_guard_block_ppm": { "type": "integer", "minimum": 0, "maximum": 1000000 },
+                "max_contradicted_claim_ppm": { "type": "integer", "minimum": 0, "maximum": 1000000 },
+                "max_budget_breaches": { "type": "integer", "minimum": 0, "maximum": 1000000 }
+            }
+        },
+        "slug": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]{0,63}$" },
+        "text": {
+            "type": "object",
+            "required": ["en", "ar"],
+            "additionalProperties": false,
+            "properties": {
+                "en": { "type": "string", "minLength": 1, "maxLength": 2000 },
+                "ar": { "type": "string", "minLength": 1, "maxLength": 2000 }
+            }
+        },
+        "category": {
+            "type": "object",
+            "required": ["id", "title", "description", "required_levels", "min_trials", "threshold_ppm", "ci_rule", "clauses"],
+            "additionalProperties": false,
+            "properties": {
+                "id": { "type": "string", "pattern": "^[a-z][a-z0-9_]{0,63}$" },
+                "title": { "$ref": "#/$defs/text" },
+                "description": { "$ref": "#/$defs/text" },
+                "required_levels": {
+                    "type": "array",
+                    "minItems": 1,
+                    "uniqueItems": true,
+                    "items": { "enum": [1, 2, 3] }
+                },
+                "min_trials": { "type": "integer", "minimum": 1, "maximum": 1000000 },
+                "threshold_ppm": { "type": "integer", "minimum": 0, "maximum": 1000000 },
+                "ci_rule": { "const": "wilson95-low" },
+                "execution": { "enum": ["single_turn", "trajectory"] },
+                "clauses": {
+                    "type": "array",
+                    "uniqueItems": true,
+                    "items": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]{0,63}:[A-Za-z0-9._-]{1,64}$" }
+                }
+            }
+        }
+    }
+}