@passioncode-ai/fabric-agent-adapter 0.72.0 → 0.73.0

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/check_service_channel_agent_schema.py

@@ -0,0 +1,496 @@
+"""The schema half of the probe's channel-agent rule (FAA-197, DEC-0150 FAC-SEM-162): the vendored
+`service-channel-agent-extension.schema.json` at the contract pin, a JSON Schema reader for exactly the keywords that
+file uses, giving Ajv's errors in Ajv's order (allErrors, verbose), and the contract's reading of those errors as
+places (`src/channel-agent.ts`: widths, oversize's names, placedToken, allowed, placed, messagePlaces, schemaErrors).
+
+No place carries a declared value: a member name the schema does not declare is written `*` (CA-5). Not a kit module:
+the probe has no Node twin and kit.json does not list it. Standard library only, Python 3.9+."""
+from __future__ import annotations
+
+import json
+import math
+import re
+import sys
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Set
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from fabric_jsvalue import double, is_number, js_keys, js_string, json_equal  # noqa: E402
+
+SCHEMA_FILE = Path(__file__).resolve().parent / "service-channel-agent-extension.schema.json"
+#: FAC-SEM-162's one answer when the schema itself cannot run on a value.
+TOO_LARGE = "the value is too large to check"
+#: A string value or a member name longer than this, in code points, is refused before the schema runs (CA-2).
+LONGEST_STRING = 4096
+#: The arrays the schema declares: a numeric token after one of them is an index a path may carry.
+ARRAYS = frozenset(("projects", "codes", "tiers", "channels", "sources", "declined_sources", "handoff_queues", "recorded_decisions"))
+ENUM_VALUES = 8
+PATTERN_CHARACTERS = 80
+_INDEX = re.compile(r"(?:0|[1-9][0-9]{0,8})\Z")
+_NONE_FORM_AT = re.compile(r"(?:^|/)projects/[0-9]+/(?:question_route|gap_registry|tickets/pd_check|channels/[0-9]+/texts/final)\Z")
+_TEXTS_AT = re.compile(r"(?:^|/)channels/[0-9]+/texts(?:/holding)?\Z")
+_CLOSED_TEXTS_AT = re.compile(r"/channels/[0-9]+/texts\Z")
+
+# Ajv's keyword groups in the order its generated code runs them (ajv 8, draft 2020-12): the untyped group first, then
+# one group per data type, each keyword in its vocabulary's order. Only what the vendored schema uses is read.
+_GROUPS = (
+    (None, ("$ref", "const", "enum", "not", "oneOf", "if")),
+    ("number", ("maximum", "minimum")),
+    ("string", ("maxLength", "minLength", "pattern", "format")),
+    ("array", ("maxItems", "minItems", "items")),
+    ("object", ("maxProperties", "minProperties", "required", "propertyNames", "additionalProperties", "properties")),
+)
+_GROUP_KEYS = {group: keys for group, keys in _GROUPS if group is not None}
+#: Members a schema node may carry that change nothing: metadata, and `then`/`else`, which `if` reads.
+_INERT = frozenset(("$schema", "$id", "title", "description", "$defs", "then", "else", "type"))
+SUPPORTED = frozenset(k for _, keys in _GROUPS for k in keys) | _INERT
+#: What Ajv counts as a rule beside a `$ref` (a `$ref` with none is read as the reference alone).
+_RULES = SUPPORTED - frozenset(("$schema", "$id", "title", "description", "$defs"))
+_FORMATS = ("date",)
+
+_schema: Optional[Dict[str, Any]] = None
+_names: Optional[Set[str]] = None
+_patterns: Dict[str, "re.Pattern[str]"] = {}
+
+
+def schema() -> Dict[str, Any]:
+    """The vendored schema, read once."""
+    global _schema
+    if _schema is None:
+        _schema = json.loads(SCHEMA_FILE.read_text(encoding="utf-8"))
+    return _schema
+
+
+def unsupported(node: Any = None) -> List[str]:
+    """The keywords and formats a schema node (default: the vendored schema) uses that this reader does not read."""
+    found: List[str] = []
+    stack = [schema() if node is None else node]
+    while stack:
+        item = stack.pop()
+        if isinstance(item, list):
+            stack.extend(item)
+        elif isinstance(item, dict):
+            for key, value in item.items():
+                if key not in SUPPORTED:
+                    found.append(key)
+                elif key == "format" and value not in _FORMATS:
+                    found.append("format %s" % value)
+                if key in ("properties", "$defs"):
+                    stack.extend(value.values())
+                elif key not in ("enum", "const", "required", "pattern", "description", "title"):
+                    stack.append(value)
+    return sorted(set(found))
+
+
+def _pattern(text: str) -> "re.Pattern[str]":
+    """An ECMAScript pattern (u flag) as Python reads it: `$` outside a class is the end of input only (\\Z)."""
+    if text not in _patterns:
+        out, i, in_class = [], 0, False
+        while i < len(text):
+            char = text[i]
+            if char == "\\":
+                out.append(text[i:i + 2])
+                i += 2
+                continue
+            if char == "[":
+                in_class = True
+            elif char == "]":
+                in_class = False
+            out.append("\\Z" if char == "$" and not in_class else char)
+            i += 1
+        _patterns[text] = re.compile("".join(out))
+    return _patterns[text]
+
+
+def _is(data: Any, kind: str) -> bool:
+    if kind == "object":
+        return isinstance(data, dict)
+    if kind == "array":
+        return isinstance(data, list)
+    if kind == "string":
+        return isinstance(data, str)
+    if kind == "boolean":
+        return isinstance(data, bool)
+    if kind == "null":
+        return data is None
+    if kind in ("number", "integer"):
+        if not is_number(data) or not math.isfinite(double(data)):
+            return False
+        return kind == "number" or double(data) % 1 == 0
+    return False
+
+
+_DAYS = (0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31)
+
+
+def _date(text: str) -> bool:
+    """ajv-formats' full `date`: YYYY-MM-DD with a real month and day, leap years counted."""
+    match = re.match(r"([0-9]{4})-([0-9]{2})-([0-9]{2})\Z", text)
+    if not match:
+        return False
+    year, month, day = (int(part) for part in match.groups())
+    leap = year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
+    return 1 <= month <= 12 and 1 <= day <= (29 if month == 2 and leap else _DAYS[month])
+
+
+def _pointer(key: str) -> str:
+    return key.replace("~", "~0").replace("/", "~1")
+
+
+def _has_ref(node: Any) -> bool:
+    if isinstance(node, dict):
+        return "$ref" in node or any(_has_ref(value) for key, value in node.items() if key not in ("enum", "const"))
+    return isinstance(node, list) and any(_has_ref(item) for item in node)
+
+
+class _Reader:
+    """Ajv's allErrors validation of one value, errors in its order with keyword, instancePath, schemaPath, params,
+    the keyword's schema (verbose) and, inside propertyNames, the member name. A definition that refers to no other is
+    inlined, so its errors' schemaPath starts `#/$defs/<name>`; one that does is its own function, whose paths start `#`."""
+
+    def __init__(self, root: Dict[str, Any]):
+        self.defs = root.get("$defs") or {}
+
+    def node(self, sch: Any, data: Any, ip: str, sp: str, errs: List[Dict[str, Any]], pn: Optional[str]) -> bool:
+        start = len(errs)
+        if sch is True:
+            return True
+        if sch is False or not isinstance(sch, dict):
+            errs.append(self.error("false schema", ip, sp, {}, False, pn))
+            return False
+        if "$ref" in sch and not any(key in _RULES for key in sch if key != "$ref"):
+            return self.ref(sch["$ref"], data, ip, errs, pn)
+        types = [sch["type"]] if isinstance(sch.get("type"), str) else list(sch.get("type") or [])
+        used = {group: any(key in sch for key in keys) for group, keys in _GROUP_KEYS.items()}
+        type_first = bool(types) and not (len(types) == 1 and used.get(types[0], False))
+        if type_first and not any(_is(data, kind) for kind in types):
+            errs.append(self.error("type", ip, sp + "/type", {"type": sch["type"]}, sch["type"], pn))
+        for group, keys in _GROUPS:
+            if group is not None and not used[group]:
+                continue
+            if group is not None and not _is(data, group):
+                if types == [group] and not type_first:
+                    errs.append(self.error("type", ip, sp + "/type", {"type": sch["type"]}, sch["type"], pn))
+                continue
+            for key in keys:
+                if key in sch:
+                    getattr(self, "k_" + key.lstrip("$"))(sch, sch[key], data, ip, sp, errs, pn)
+        return len(errs) == start
+
+    def error(self, keyword: str, ip: str, sp: str, params: Dict[str, Any], value: Any, pn: Optional[str]) -> Dict[str, Any]:
+        error = {"keyword": keyword, "instancePath": ip, "schemaPath": sp, "params": params, "schema": value}
+        if pn is not None:
+            error["propertyName"] = pn
+        return error
+
+    def ref(self, ref: str, data: Any, ip: str, errs: List[Dict[str, Any]], pn: Optional[str]) -> bool:
+        name = ref[len("#/$defs/"):]
+        target = self.defs[name]
+        return self.node(target, data, ip, "#" if _has_ref(target) else "#/$defs/" + name, errs, pn)
+
+    def k_ref(self, sch, value, data, ip, sp, errs, pn) -> None:
+        self.ref(value, data, ip, errs, pn)
+
+    def k_const(self, sch, value, data, ip, sp, errs, pn) -> None:
+        if not json_equal(data, value):
+            errs.append(self.error("const", ip, sp + "/const", {"allowedValue": value}, value, pn))
+
+    def k_enum(self, sch, value, data, ip, sp, errs, pn) -> None:
+        if not any(json_equal(data, item) for item in value):
+            errs.append(self.error("enum", ip, sp + "/enum", {"allowedValues": value}, value, pn))
+
+    def k_not(self, sch, value, data, ip, sp, errs, pn) -> None:
+        if self.node(value, data, ip, sp + "/not", [], pn):
+            errs.append(self.error("not", ip, sp + "/not", {}, value, pn))
+
+    def k_oneOf(self, sch, value, data, ip, sp, errs, pn) -> None:
+        start, passing = len(errs), []
+        for i, branch in enumerate(value):
+            if self.node(branch, data, ip, "%s/oneOf/%d" % (sp, i), errs, pn):
+                passing.append(i)
+        if len(passing) == 1:
+            del errs[start:]
+        else:
+            errs.append(self.error("oneOf", ip, sp + "/oneOf", {"passingSchemas": passing[:2] or None}, value, pn))
+
+    def k_if(self, sch, value, data, ip, sp, errs, pn) -> None:
+        branch = "then" if self.node(value, data, ip, sp + "/if", [], pn) else "else"
+        if branch in sch and not self.node(sch[branch], data, ip, "%s/%s" % (sp, branch), errs, pn):
+            errs.append(self.error("if", ip, sp + "/if", {"failingKeyword": branch}, value, pn))
+
+    def k_maximum(self, sch, value, data, ip, sp, errs, pn) -> None:
+        if double(data) > value:
+            errs.append(self.error("maximum", ip, sp + "/maximum", {"comparison": "<=", "limit": value}, value, pn))
+
+    def k_minimum(self, sch, value, data, ip, sp, errs, pn) -> None:
+        if double(data) < value:
+            errs.append(self.error("minimum", ip, sp + "/minimum", {"comparison": ">=", "limit": value}, value, pn))
+
+    def k_maxLength(self, sch, value, data, ip, sp, errs, pn) -> None:
+        if len(data) > value:  # code points, as Ajv's ucs2length counts them
+            errs.append(self.error("maxLength", ip, sp + "/maxLength", {"limit": value}, value, pn))
+
+    def k_minLength(self, sch, value, data, ip, sp, errs, pn) -> None:
+        if len(data) < value:
+            errs.append(self.error("minLength", ip, sp + "/minLength", {"limit": value}, value, pn))
+
+    def k_pattern(self, sch, value, data, ip, sp, errs, pn) -> None:
+        if not _pattern(value).search(data):
+            errs.append(self.error("pattern", ip, sp + "/pattern", {"pattern": value}, value, pn))
+
+    def k_format(self, sch, value, data, ip, sp, errs, pn) -> None:
+        if value == "date" and not _date(data):
+            errs.append(self.error("format", ip, sp + "/format", {"format": value}, value, pn))
+
+    def k_maxItems(self, sch, value, data, ip, sp, errs, pn) -> None:
+        if len(data) > value:
+            errs.append(self.error("maxItems", ip, sp + "/maxItems", {"limit": value}, value, pn))
+
+    def k_minItems(self, sch, value, data, ip, sp, errs, pn) -> None:
+        if len(data) < value:
+            errs.append(self.error("minItems", ip, sp + "/minItems", {"limit": value}, value, pn))
+
+    def k_items(self, sch, value, data, ip, sp, errs, pn) -> None:
+        for i, item in enumerate(data):
+            self.node(value, item, "%s/%d" % (ip, i), sp + "/items", errs, pn)
+
+    def k_maxProperties(self, sch, value, data, ip, sp, errs, pn) -> None:
+        if len(data) > value:
+            errs.append(self.error("maxProperties", ip, sp + "/maxProperties", {"limit": value}, value, pn))
+
+    def k_minProperties(self, sch, value, data, ip, sp, errs, pn) -> None:
+        if len(data) < value:
+            errs.append(self.error("minProperties", ip, sp + "/minProperties", {"limit": value}, value, pn))
+
+    def k_required(self, sch, value, data, ip, sp, errs, pn) -> None:
+        for name in value:
+            if name not in data:
+                errs.append(self.error("required", ip, sp + "/required", {"missingProperty": name}, value, pn))
+
+    def k_propertyNames(self, sch, value, data, ip, sp, errs, pn) -> None:
+        for key in js_keys(data):
+            if not self.node(value, key, ip, sp + "/propertyNames", errs, key):
+                errs.append(self.error("propertyNames", ip, sp + "/propertyNames", {"propertyName": key}, value, pn))
+
+    def k_additionalProperties(self, sch, value, data, ip, sp, errs, pn) -> None:
+        declared = sch.get("properties") or {}
+        for key in js_keys(data):
+            if key in declared:
+                continue
+            if value is False:
+                errs.append(self.error("additionalProperties", ip, sp + "/additionalProperties", {"additionalProperty": key}, value, pn))
+            elif value is not True:
+                self.node(value, data[key], ip + "/" + _pointer(key), sp + "/additionalProperties", errs, pn)
+
+    def k_properties(self, sch, value, data, ip, sp, errs, pn) -> None:
+        for name, sub in value.items():
+            if name in data:
+                self.node(sub, data[name], ip + "/" + _pointer(name), "%s/properties/%s" % (sp, name), errs, pn)
+
+
+def validate(value: Any) -> List[Dict[str, Any]]:
+    """The schema's errors on a value, as Ajv lists them; an empty list when it is valid."""
+    errs: List[Dict[str, Any]] = []
+    _Reader(schema()).node(schema(), value, "", "#", errs, None)
+    return errs
+
+
+def schema_names() -> Set[str]:
+    """Every member name the schema declares: a path token that is not one (a text's language, an unknown member) is `*`."""
+    global _names
+    if _names is None:
+        names: Set[str] = set()
+        stack: List[Any] = [schema()]
+        while stack:
+            node = stack.pop()
+            if isinstance(node, list):
+                stack.extend(node)
+            elif isinstance(node, dict):
+                if isinstance(node.get("properties"), dict):
+                    names.update(node["properties"])
+                stack.extend(node.values())
+        _names = names
+    return _names
+
+
+def is_none(value: Any) -> bool:
+    """The standard's form for a required member a project does not have: an object with a `none` member (CA-2)."""
+    return isinstance(value, dict) and "none" in value
+
+
+def placed_token(previous: Optional[str], before: Optional[str], token: str, index: bool, names: Set[str],
+                 none_form: bool = False) -> str:
+    """A member's token in a FAC-SEM-162 place: a declared name, or an index of a declared array, else `*`."""
+    if none_form and before == "texts" and previous == "final" and token in ("none", "until"):
+        return token
+    if before == "texts" and previous in ("holding", "final"):
+        return "*"
+    if index:
+        return token if previous is not None and previous in ARRAYS and _INDEX.match(token) else "*"
+    return token if token in names else "*"
+
+
+def resolved(node: Any, defs: Dict[str, Any], value: Any = None) -> Dict[str, Any]:
+    """A schema node with its `$ref` followed and a member that takes the none form resolved to the value's branch."""
+    at = node
+    while True:
+        if isinstance(at, dict) and isinstance(at.get("$ref"), str):
+            at = defs[at["$ref"][len("#/$defs/"):]]
+        elif isinstance(at, dict) and all(k in at for k in ("if", "then", "else")) and "properties" not in at:
+            at = at["then"] if is_none(value) else at["else"]
+        else:
+            return at if isinstance(at, dict) else {}
+
+
+def widths(value: Any) -> List[str]:
+    """The places of every array past its maxItems, map past its maxProperties and closed object with more members than
+    it declares, read before the schema runs so it never makes one error per member (CA-2)."""
+    root = schema()
+    defs = root["$defs"]
+    found: List[str] = []
+    stack: List[Any] = [(value, root, "")]
+    while stack:
+        item, node, at = stack.pop()
+        rule = resolved(node, defs, item)
+        if isinstance(item, list):
+            if is_number(rule.get("maxItems")) and len(item) > rule["maxItems"]:
+                found.append("maxItems at %s (at most %s items)" % (at, js_string(rule["maxItems"])))
+            elif "items" in rule:
+                for i in range(len(item) - 1, -1, -1):
+                    stack.append((item[i], rule["items"], "%s/%d" % (at, i)))
+        elif isinstance(item, dict):
+            count = len(item)
+            declared = rule.get("properties") if isinstance(rule.get("properties"), dict) else None
+            if declared is not None and rule.get("additionalProperties") is False and count > len(declared):
+                elsewhere = "; only texts.final takes the none form (Narrowings)" if _CLOSED_TEXTS_AT.search(at) and "none" in item else ""
+                found.append("maxProperties at %s (more members than the schema declares%s)" % (at or "/", elsewhere))
+            elif is_number(rule.get("maxProperties")) and count > rule["maxProperties"]:
+                found.append("maxProperties at %s (at most %s members)" % (at, js_string(rule["maxProperties"])))
+            elif declared is not None:
+                present = [name for name in declared if name in item]
+                for name in reversed(present):
+                    stack.append((item[name], declared[name], "%s/%s" % (at, name)))
+    return found
+
+
+def type_of(branch: Any) -> Optional[str]:
+    """A branch's type, through its `$ref`s into the schema's own `$defs`."""
+    if not isinstance(branch, dict):
+        return None
+    if isinstance(branch.get("type"), str):
+        return branch["type"]
+    if isinstance(branch.get("$ref"), str):
+        return type_of(schema()["$defs"].get(branch["$ref"][len("#/$defs/"):]))
+    return None
+
+
+def name_rule(rule: Dict[str, Any]) -> str:
+    """What a `propertyNames` schema takes, from the schema alone: its pattern, its length, the name it refuses."""
+    parts = []
+    if isinstance(rule.get("pattern"), str):
+        parts.append("matching %s" % rule["pattern"])
+    if is_number(rule.get("maxLength")):
+        parts.append("at most %s code points" % js_string(rule["maxLength"]))
+    if isinstance(rule.get("not"), dict) and "const" in rule["not"]:
+        parts.append("other than %s" % js_string(rule["not"]["const"]))
+    return "a member name %s" % ", ".join(parts) if parts else "a member name the schema takes"
+
+
+def allowed(error: Dict[str, Any], names: Set[str], at: str = "") -> str:
+    """What the schema allows at a failed place, from the schema alone, never the instance."""
+    params = error.get("params") or {}
+    keyword, rule = error["keyword"], error.get("schema")
+    texts = bool(_TEXTS_AT.search(at))
+    elsewhere = "; only texts.final takes the none form (Narrowings)" if texts and "none" in (params.get("additionalProperty"), params.get("propertyName")) else ""
+    if keyword == "required" and isinstance(params.get("missingProperty"), str) and params["missingProperty"] in names:
+        return " (%s)" % params["missingProperty"]
+    if keyword == "additionalProperties":
+        return " (only declared members are taken%s)" % elsewhere
+    if keyword == "propertyNames" and isinstance(rule, dict):
+        return " (%s%s)" % (name_rule(rule), elsewhere)
+    if keyword == "enum" and isinstance(params.get("allowedValues"), list):
+        values = [js_string(v) for v in params["allowedValues"]]
+        rest = " and %d more" % (len(values) - ENUM_VALUES) if len(values) > ENUM_VALUES else ""
+        return " (one of %s%s)" % (", ".join(values[:ENUM_VALUES]), rest)
+    if keyword == "const" and "allowedValue" in params:
+        return " (%s)" % js_string(params["allowedValue"])
+    if keyword == "pattern" and isinstance(params.get("pattern"), str):
+        pattern = params["pattern"]
+        return " (pattern %s)" % (pattern[:PATTERN_CHARACTERS] + "\u2026" if len(pattern) > PATTERN_CHARACTERS else pattern)
+    limit = params.get("limit") if is_number(params.get("limit")) else None
+    if limit is not None:
+        def count(word: str) -> str:
+            return "%s %s%s" % (js_string(limit), word, "" if limit == 1 else "s")
+        words = {"maxLength": "at most %s" % count("code point"), "minLength": "at least %s" % count("code point"),
+                 "maxItems": "at most %s" % count("item"), "minItems": "at least %s" % count("item"),
+                 "maxProperties": "at most %s" % count("member"), "minProperties": "at least %s" % count("member")}
+        if keyword in words:
+            return " (%s)" % words[keyword]
+        if keyword in ("minimum", "maximum"):
+            return " (%s %s)" % (js_string(params.get("comparison")), js_string(limit))
+    if keyword == "format" and isinstance(params.get("format"), str):
+        return " (format %s)" % params["format"]
+    if keyword == "not" and isinstance(rule, dict) and isinstance(rule.get("required"), list):
+        return " (%s only with not_yet)" % ", ".join(rule["required"])
+    if keyword == "not" and isinstance(rule, dict) and "const" in rule:
+        return " (a value other than %s)" % js_string(rule["const"])
+    if keyword == "type" and isinstance(params.get("type"), (str, list)):
+        form = ", or the none form {none: not_yet, until} / {none: not_used}" if _NONE_FORM_AT.search(at) else ""
+        kinds = params["type"] if isinstance(params["type"], list) else [params["type"]]
+        return " (%s%s)" % (" or ".join(kinds), form)
+    if keyword == "oneOf":
+        if isinstance(rule, list):
+            kinds = [type_of(branch) for branch in rule]
+            types = [kind for kind in kinds if kind is not None and kind != "null"]
+            if "null" in kinds and types:
+                return " (%s %s or null)" % ("an" if re.match(r"[aeiou]", types[0]) else "a", " or ".join(types))
+        return " (exactly one of its forms)"
+    return ""
+
+
+def placed(error: Dict[str, Any], or_null: bool = False) -> str:
+    """An error as its keyword and its place, every free member name replaced by `*`, never a declared value."""
+    names = schema_names()
+    tokens = [t.replace("~1", "/").replace("~0", "~") for t in error["instancePath"].split("/")[1:]]
+    none_form = isinstance(error.get("schemaPath"), str) and not error["schemaPath"].startswith("#/$defs/texts")
+    at = "/".join(placed_token(tokens[i - 1] if i >= 1 else None, tokens[i - 2] if i >= 2 else None, token,
+                               bool(_INDEX.match(token)), names, none_form) for i, token in enumerate(tokens))
+    return "%s at /%s%s%s" % (error["keyword"], at, allowed(error, names, at), ", or null" if or_null else "")
+
+
+def message_places(places: List[str]) -> List[str]:
+    """The places a message names, each distinct pattern spelled once; a later one reads `(pattern as above)`."""
+    seen: Set[str] = set()
+    out = []
+    for written in places:
+        or_null = ", or null" if written.endswith(", or null") else ""
+        place = written[:len(written) - len(or_null)]
+        at = place.find(" (pattern ")
+        if at < 0:
+            out.append(written)
+            continue
+        pattern = place[at:]
+        if pattern in seen:
+            out.append("%s (pattern as above)%s" % (place[:at], or_null))
+        else:
+            seen.add(pattern)
+            out.append(written)
+    return out
+
+
+def schema_errors(value: Any, validator: Callable[[Any], List[Dict[str, Any]]] = validate) -> List[str]:
+    """The schema's errors on a value as places: a nullable member fails in one line, its value branch's, ending
+    ", or null"; `if` lines and a member name's inner lines (its propertyNames line states them) are dropped."""
+    try:
+        errors = validator(value)
+    except RecursionError:
+        return [TOO_LARGE]
+    if not errors:
+        return []
+    nullable = {e["instancePath"] for e in errors
+                if e["keyword"] == "oneOf" and isinstance(e.get("schema"), list) and any(type_of(b) == "null" for b in e["schema"])}
+    kept = [e for e in errors if e["keyword"] != "if"
+            and not (e["keyword"] != "propertyNames" and e.get("propertyName") is not None)
+            and not (e["keyword"] == "type" and (e.get("params") or {}).get("type") == "null")
+            and not (e["keyword"] == "oneOf" and e["instancePath"] in nullable)]
+    return list(dict.fromkeys(placed(e, e["instancePath"] in nullable) for e in kept))

package/plugins/fabric-agent-adapter/skills/building-fabric-services/scripts/kit.json

@@ -1,6 +1,6 @@
 {
  "name": "fabric-service-kit",
- "version": "0.72.0",
+ "version": "0.73.0",
  "about": "The service kit's modules in dependency order: a module imports only modules listed before it. Written by fabric_kit.py build; edit the order and layers by hand, never the digests.",
  "python": [
   {
@@ -5766,6 +5766,96 @@
    "fabric-openrouter.mjs": "6041f3ab30f516658e1dbab4897a651cc8509b2136cfa8e769802c6b40ec2f35",
    "fabric-package.schema.json": "2ba799f576fad0f608029223c4ccccd122152f1c5dbfa8ce8b31cd63ac92ad44",
    "share-registration.schema.json": "34b3997eeaf936ebc861342a23045634a7c18c19f01d7ed4198310d81989f5b0"
+  },
+  "0.73.0": {
+   "fabric_jsvalue.py": "052f1b40bab18600b3731dbdca27cbff17588c21d9458fa6241efd1340d0e09a",
+   "fabric_time.py": "588f383da4ac6a243ea95b6ffc3a0aa99ca94245732dc4937734f190b7af4ae9",
+   "fabric_identifiers.py": "0fd814d521ac3aa39907458265870753046a73f48af3d8581ab864b93b211607",
+   "fabric_secrets.py": "53c5df8d6f2c87433c288853bfaad9a43f544789bdf1e39bda8d3ff14485c89d",
+   "fabric_crypto.py": "9c34aee20dbe4d6742e4fdbaab68ceb934bbe7dbd3a904c0010824ace16cdeaa",
+   "fabric_base.py": "f62bcc2ed9912660fa875d27a09f60867260cc4925f79873501fd9620be59611",
+   "fabric_platform.py": "a9350dff55ef0fb3a23cdb4d0320a15868b15a8deb10d2eb74d72c58740c284b",
+   "fabric_paths.py": "8a1ee742f80f436e9f28c61b4f049a9545de2a9e0d66bfc61faa6ee5d1ba3734",
+   "fabric_estate_rules.py": "8b36a7f4108d9c2b1fb38c8bff344778c807bed631a99b4a563ecb0a49c10b1c",
+   "fabric_estate.py": "0737ae1d1bb12586bae49de1f15ef1348bc207b5007cced9dad4c55bb5870874",
+   "fabric_mandate.py": "fb19ce5359606bd6e3352ab02b2a12f49605ec6e5c49b55cce1f79c831325044",
+   "fabric_delegation.py": "716f0ff7ac01095f54b24970beac1962128e8ff33026b243fc0467876142ab03",
+   "fabric_share.py": "da36a466426fc29dd7dd40013167f3959a18375f8fedd228bf64f298cec1040c",
+   "fabric_ceremonies.py": "a59e83cf4adb2669a9b98008e3d3a0cba991a35cbff97bc604fc82fe81cfd49f",
+   "fabric_package_schema.py": "e623f0408d38e3343ed66222fb812907c6c52e1a286eb1c1176ab2e64640c9ad",
+   "fabric_package.py": "1f2b9e73b2b32a7e1e887d4b69f87c6e21b4d1227ad924a235334223e6dd51ca",
+   "fabric_protocols.py": "077c6f03f3b887a2e22d9ce6b5bd3750199d71a29d4c82b1d5af8a615b509d93",
+   "fabric_actions.py": "ae21d1199614c4f74d1dcd1e0a87107a9d52434cd9e2d64aa24a7b1e196fb723",
+   "fabric_connections.py": "7de55cb7d808f756d650effabfaa12027d40a5bd5d2f6d448c32969d47529ecb",
+   "fabric_a2a.py": "8b01502131215bb4de1c01866187c56e99b791543923ed8577535573db33b919",
+   "fabric_page_links.py": "1b57ea573c550e2f90d1ec3edcc655917ceaa0db9dd1635fccf422ec3024d25e",
+   "fabric_lock.py": "dfaf92a7086cbb097d832a305869b7964e2d2a9da0e3365c8ec1685a7bb4fef9",
+   "fabric_usage.py": "5cc2e03ccc5b06e81987ed7bc3eead7a7e6cbf1a7cb8e05c6c64315eed9d91b6",
+   "fabric_backups.py": "1f3f0d7ecf361b29e9101e07f1c53e5dc304d598bf26fd59ec89f16b9fed2420",
+   "fabric_descriptor.py": "c08c91ca0960c694ed7677e7e9247d6307c7b63f37a7e614db022c080cd92ccc",
+   "fabric_context.py": "6ae311ddc7217a4aff915e7ce2646486931acd128462b7bebe4a52bbb5fbb6c7",
+   "fabric_auth.py": "74ccc10239b65a3567cec5213a7b344cbd88d6eee1fd1c5f7be1d6daf985993c",
+   "fabric_events.py": "cd94b186e2a8f8cb4ad2b6bd44d83ec5021933075e28c5d655f387f16dff42b8",
+   "fabric_logs.py": "86dc55bfafa2a57264722e2403510a249b95de0e4a722b2e4bc3948e3bd93da9",
+   "fabric_supervisors.py": "3c5b2e8c310738720b1c1b779be4710e90251013d9be4c68f9952edc0bf55d5f",
+   "fabric_service.py": "4b13f90aa26881fbfe0d9f3077fbb3552f3ce0a3c59279d6baa92df872867d8d",
+   "fabric_profiles.py": "26e21ec29c016000f8ca8053b7b489184854a73be1b7fdc0a18d12990203db9b",
+   "fabric_interop_rules.py": "9bdb7989e57b9d0b0d15eb9982d396499823a5e2c528230b71c67866c736e0f5",
+   "fabric_interop.py": "d27e31834611a37cf2a117746f2f60fc187ccc48718eb546ff923c5d0fce7dea",
+   "fabric_hub.py": "b9ac852e601b1d54cf61351677a628afc69faeed7d1fc74ebe541c1cf38e0c2a",
+   "fabric_board_shapes.py": "0a0e8d3d40e33dfd8c457aedb85330b2ff25f8c49a33eb6cbd5a5cc8a5007f7e",
+   "fabric_board_link.py": "052bc3c474ece835bb428c37ca864810d04e394d991ddb9c93989a7a825073a5",
+   "fabric_board_slots.py": "92b065e3df935547cf46653245f1129e4a1f8b59b0a41e8fa9ffdc41596ee592",
+   "fabric_board_session.py": "1fd3c3884f3044b56a40f78b33ff88dcac9272284f6681ea359c662879826f7e",
+   "fabric_board_fixture.py": "69761ce205ec640762ec9b591c6903e5a87f844e8d423b041681924027e39d1e",
+   "fabric_board.py": "f86c40b8291f8c818f6924910f4022b013d5fd107abaf8825dd0aa6c5e418638",
+   "fabric_http.py": "8b443477dc29d5a1fe908b9dccaf68f05fab837eae0670074051a1dd2dfb71ad",
+   "fabric_openrouter.py": "d06a40f83f2fb8bd441ab3485ae882f1fbdd9cd7a9c1ec175eb47cb8ae2cce81",
+   "fabric-jsvalue.mjs": "dfbdb8c41584972c9389750a41719374a1cfc5652ed438dd1623025190b0106e",
+   "fabric-time.mjs": "3ff932069038a720df1c68c6492976906737b2e67e5c12d9c81c418597f661de",
+   "fabric-identifiers.mjs": "a18c2a501a4aa170bfd3d99e571ad6b7662649b4d3b9d2a540c002ea42811bbf",
+   "fabric-secrets.mjs": "5822a7e25ecf2e87b5bab4f99c1074af7379d8b49e2784283b5d7d8c25022cde",
+   "fabric-crypto.mjs": "038e03689701e3c9721a1e7f8e0a4d02a52d6a5d1661b0dc84035edc3ebbfcf6",
+   "fabric-base.mjs": "7804b2df7715dbbf9702a9b61b6b8cef2110f9a52b04cabd8fb0a66458d87512",
+   "fabric-platform.mjs": "a8119d95ebba4d589a9e401f5d6fc8dda62d59d44e4c1ff811d97fac3771ac0c",
+   "fabric-paths.mjs": "aa630d611e748a899e7043480f4a4e46b444f2e15ff945f30c2fbef21c1ceea5",
+   "fabric-estate-rules.mjs": "7476be71174aa5b1026134f2b335abf647feaa55584e2f9de8618e3054aa8e1e",
+   "fabric-estate.mjs": "e8a2e62d2313121e6cb502f6e6abad94d1d546a44b4d9b3ce2be29e7808e8cf3",
+   "fabric-mandate.mjs": "b70f3de03a659e60bba7b5a0580b3582825cd7b8a8e30a28c79621919ec5b7bb",
+   "fabric-delegation.mjs": "8f63a63aab9a8746b7f664720b87e9398137d01b8d50880974d5070038e414a0",
+   "fabric-share.mjs": "bfb26581c21ad984c2a337da02429f9f3a165cc582f8ba48de4d3dfb7d163a59",
+   "fabric-ceremonies.mjs": "117d4374c9e95c930a38de7adbd4323774798f4fe6ec6f24afcd6f2c7298ca44",
+   "fabric-package-schema.mjs": "cd28092375db0fc21ffab1f0bb7794f7f8979ee08c64d3b9faf4b3845357caa6",
+   "fabric-package.mjs": "8cfb32eebbd4e1bcf28a6e4437344ae2dd54479b0e7c820f002e9f94ab9ecaad",
+   "fabric-protocols.mjs": "a560b7d6eb0d26204c5536711c3dda9daae90cc91e07cdc75412e75c86272767",
+   "fabric-actions.mjs": "06e42f5e24c96311d5417d0d1effa93479ef7128a7ab139903b2bcf59253f6be",
+   "fabric-connections.mjs": "303432e547ce563e90ca9ffcd827f5612f51d3582929834e1add0fdaf6485dcc",
+   "fabric-a2a.mjs": "51b72fe1d80649d659fcad3a8f96370db3476c4a7b30cbabd8522c138be69346",
+   "fabric-page-links.mjs": "a8834926e9d4bbf7c4857f551451d2ebf6ac8873bbccaaf89c5e30cf45b17ee6",
+   "fabric-lock.mjs": "02cf833c97a07a8b3c788f9c93f70c4b9c9066efa25318dccf0038e0fc79717f",
+   "fabric-usage.mjs": "1c4d18004639409624ac3516a02f2b60bbf55abdb612e9a96c37e83666eb87a7",
+   "fabric-backups.mjs": "cfd8c9085e3d597a783099c2bd2ffe2f3faa0daaadab46dedd30523894cfeb06",
+   "fabric-descriptor.mjs": "7c0ef7d245c037eb9e859ab481f6e66fb3e5ef2cf6d1e0a8d32b6d303097ca43",
+   "fabric-context.mjs": "1112d695e872f9825cbc94f08484974bff3880087bc29b8be59f885f03e8f7be",
+   "fabric-auth.mjs": "10ff37a39f9e3adb4d0f05db66c45f49b10eef582e9220c213907964109d7e52",
+   "fabric-events.mjs": "c463d6ffcae24229a5c608d8fcea4268d2ccc5024b19fa10e5a452284068fa71",
+   "fabric-logs.mjs": "58467e5719c16e099d05bbedec47a95712506ab03c33f3cd4be1252e8498a946",
+   "fabric-supervisors.mjs": "d45c38de0cb3ed85e083496c2d3c51dab004454accdd87f4762a512a6d442573",
+   "fabric-service.mjs": "297fef11ac76dc831d12d24c5581b7a93587c300c20664db703b3f924c0f9f1a",
+   "fabric-profiles.mjs": "314376cf2deb87f235fb18b11d3b532e211f585b9af0a9302b5f4cc39971b532",
+   "fabric-interop-rules.mjs": "b4e386c359a48e49ffff8a842215760c18a7c98a0af4754a808a35fb2820d458",
+   "fabric-interop.mjs": "989040aed33b2712a258244192bdf70e811a51076aa1b62f2adc2a6db051dbed",
+   "fabric-hub.mjs": "c005115a864cfd67daa4862097bb14acfe5a60bf653897e5bf8a570dd80f1070",
+   "fabric-board-shapes.mjs": "c1db7b7bd0d58d82bb6d8dfbc3cd1547a256a333052d367e82ff1b3edf2804d7",
+   "fabric-board-link.mjs": "6e7d51f4fd9730d93455f50dd30e97907b8b9e1ca65a1d69f036f2e8ec05cc0d",
+   "fabric-board-slots.mjs": "fc77a3c6e62aa18575568bef4f703cce2edaba8cef648813ebcdbb21bdc27a11",
+   "fabric-board-session.mjs": "18555962e5f6d18080a3e7971c4c6640452542f6042d07917e7ebc073721c415",
+   "fabric-board-fixture.mjs": "83c4b7e33ee47b68385faf2569d38d5c8a0c5cb0f8656090f41e1b0eed2f436e",
+   "fabric-board.mjs": "15fbb4441fcf7d2f285375b75de64ad6cffea129c515084c110245376b07775f",
+   "fabric-http.mjs": "317d7668c291570d4d93bc73295312f2853eb93940f4cf754a4a4619cb87ace9",
+   "fabric-openrouter.mjs": "6041f3ab30f516658e1dbab4897a651cc8509b2136cfa8e769802c6b40ec2f35",
+   "fabric-package.schema.json": "2ba799f576fad0f608029223c4ccccd122152f1c5dbfa8ce8b31cd63ac92ad44",
+   "share-registration.schema.json": "34b3997eeaf936ebc861342a23045634a7c18c19f01d7ed4198310d81989f5b0"
   }
  },
  "data": {