katalyst-plugin-scaffolding 1.0.1a1__py3-none-any.whl

katalyst_plugin_scaffolding/__init__.py

@@ -0,0 +1,5 @@
+"""Scaffolding plugin — universal scaffold for node creation."""
+
+from .plugin import ScaffoldingPlugin
+
+__all__ = ["ScaffoldingPlugin"]

katalyst_plugin_scaffolding/linkml/__init__.py

@@ -0,0 +1,15 @@
+"""LinkML modules this package ships, on katalyst-core.
+
+Registered under the ``katalyst_core.modules`` entry point, so core loads them by name.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+__all__ = ["MODULES"]
+
+MODULES: dict[str, Path] = {
+    path.stem: path for path in sorted(Path(__file__).parent.glob("*.yaml"))
+}
+"""Module name (as an ``imports:`` line writes it) to its YAML file."""

katalyst_plugin_scaffolding/linkml/released/0.1.0/SHA256SUMS

@@ -0,0 +1 @@
+cb3f7942331947e4995dc5a067f51435bd59e2ea7292eabdf1be26eb2141340b  scaffolding.yaml

katalyst_plugin_scaffolding/linkml/released/0.1.0/scaffolding.yaml

@@ -0,0 +1,54 @@
+# Generated once from the Python definitions (LinkML rebuild, phase 4); edit here.
+id: https://w3id.org/katalyst/scaffolding/scaffolding
+name: scaffolding
+title: scaffolding scaffolding wing
+version: 0.1.0
+license: Proprietary
+prefixes:
+  scaffolding: https://w3id.org/katalyst/scaffolding/
+  kc: https://w3id.org/katalyst/core/
+  linkml: https://w3id.org/linkml/
+  dcterms: http://purl.org/dc/terms/
+default_prefix: scaffolding
+default_range: string
+imports:
+- linkml:types
+- katalyst_core
+description: The scaffolding wing.
+annotations:
+  wing: scaffolding
+  display_name: Scaffolding
+  describes_kind: wing
+classes:
+  NodeWiring:
+    is_a: Node
+    class_uri: scaffolding:NodeWiring
+    description: 'A node wiring: a node_wiring node of the scaffolding wing.'
+    attributes:
+      description:
+        description: What this wiring adds to scaffolded nodes
+        slot_uri: dcterms:description
+      extends:
+        description: 'The templates it extends: targetKind and targetNames (''*'' for all)'
+        slot_uri: scaffolding:extends
+        range: AnyValue
+      provides_template:
+        description: Template directory whose files are added, relative to this document
+        slot_uri: scaffolding:providesTemplate
+    annotations:
+      kind: node_wiring
+      wing: scaffolding
+      label: Node Wiring
+      label_plural: Node Wirings
+      display_order: 900
+      directory_name: node_wiring
+      root: true
+      leaf: true
+      storage:
+        tag: storage
+        value:
+          root: .global/taxonomy
+          container: file
+          filename: identity
+          nest_under_parent: false
+          scaffold: null

katalyst_plugin_scaffolding/linkml/scaffolding.yaml

@@ -0,0 +1,54 @@
+# Generated once from the Python definitions (LinkML rebuild, phase 4); edit here.
+id: https://w3id.org/katalyst/scaffolding/scaffolding
+name: scaffolding
+title: scaffolding scaffolding wing
+version: 0.1.0
+license: Proprietary
+prefixes:
+  scaffolding: https://w3id.org/katalyst/scaffolding/
+  kc: https://w3id.org/katalyst/core/
+  linkml: https://w3id.org/linkml/
+  dcterms: http://purl.org/dc/terms/
+default_prefix: scaffolding
+default_range: string
+imports:
+- linkml:types
+- katalyst_core
+description: The scaffolding wing.
+annotations:
+  wing: scaffolding
+  display_name: Scaffolding
+  describes_kind: wing
+classes:
+  NodeWiring:
+    is_a: Node
+    class_uri: scaffolding:NodeWiring
+    description: 'A node wiring: a node_wiring node of the scaffolding wing.'
+    attributes:
+      description:
+        description: What this wiring adds to scaffolded nodes
+        slot_uri: dcterms:description
+      extends:
+        description: 'The templates it extends: targetKind and targetNames (''*'' for all)'
+        slot_uri: scaffolding:extends
+        range: AnyValue
+      provides_template:
+        description: Template directory whose files are added, relative to this document
+        slot_uri: scaffolding:providesTemplate
+    annotations:
+      kind: node_wiring
+      wing: scaffolding
+      label: Node Wiring
+      label_plural: Node Wirings
+      display_order: 900
+      directory_name: node_wiring
+      root: true
+      leaf: true
+      storage:
+        tag: storage
+        value:
+          root: .global/taxonomy
+          container: file
+          filename: identity
+          nest_under_parent: false
+          scaffold: null

katalyst_plugin_scaffolding/plugin.py

@@ -0,0 +1,79 @@
+"""Scaffolding plugin — the template-bundle machinery scaffolding copies from.
+
+Registers how template bundles are installed into, removed from, listed in and described
+for a repository; how a fetched collection's bundle manifests are found; the probe
+``node_wiring`` documents check; the create hook that writes a scaffolded node's
+wiring file; and ``/ext/scaffolding/variants``, the installed variants a form offers
+(:mod:`katalyst_plugin_scaffolding.rest_routes`). ``kata tax add`` arrives over the ``katalyst_taxonomy.cli`` entry point.
+
+The scaffold copy itself is not here. The runtime's scaffolding hook
+(:mod:`katalyst_taxonomy.services.scaffolding_hook`) populates a new node's directory
+when a scaffold variant resolves and the kind's template root holds a directory for it
+(otherwise it is a no-op); the variants it copies are the templates this plugin
+installed. There is no engine-level ``scaffoldable`` flag: where a node records its
+variant is its kind's declaration (``ScaffoldPolicy.variant_annotation``, the field with
+the scaffold-variant role).
+"""
+
+from __future__ import annotations
+
+import importlib.metadata
+
+from katalyst_taxonomy.plugins.protocol import PluginContext, PluginManifest
+
+
+def _version() -> str:
+    """The installed distribution version, for :attr:`PluginManifest.version`.
+
+    No built-in plugin populated ``version`` before #219 — it was declared and
+    always empty, so ``kata config plugins`` could not tell you what you were
+    running. Read from installed metadata rather than a hardcoded literal so it
+    cannot drift from the package it describes.
+    """
+    try:
+        return importlib.metadata.version("katalyst-plugin-scaffolding")
+    except importlib.metadata.PackageNotFoundError:  # pragma: no cover - source checkout
+        return ""
+
+
+class ScaffoldingPlugin:
+    """The scaffolding plugin: template-bundle machinery and the node wiring create hook.
+
+    ``scaffold``: it installs the templates scaffolding copies; ``post_create``: its create
+    hook runs after a node is created.
+    """
+
+    @property
+    def name(self) -> str:
+        return "scaffolding"
+
+    @property
+    def manifest(self) -> PluginManifest:
+        return PluginManifest(
+            name="scaffolding",
+            capabilities=("scaffold", "post_create"),
+            description="Template bundles for scaffolding, and the node wiring create hook",
+            version=_version(),
+        )
+
+    def register(self, context: PluginContext) -> None:
+        """Register the template-bundle machinery and the create hook with *context*."""
+        from katalyst_plugin_scaffolding.rest_routes import ScaffoldingRestRoutes
+        from katalyst_plugin_scaffolding.templates.bundle_install import (
+            describe_bundle,
+            install_template_for_plugin,
+            installed_bundles,
+        )
+        from katalyst_plugin_scaffolding.templates.plugin import register_template_contributions
+        from katalyst_plugin_scaffolding.templates.template_remove import (
+            remove_template_for_plugin,
+        )
+
+        # No init hook: `kata tax init` installs what the user config declares
+        # (spec.templates), which a bundle's own init hook may add to.
+        register_template_contributions(context)
+        context.rest_routes.append(ScaffoldingRestRoutes())
+        context.template_installers.append(install_template_for_plugin)
+        context.template_removers.append(remove_template_for_plugin)
+        context.template_listers.append(installed_bundles)
+        context.template_describers.append(describe_bundle)

katalyst_plugin_scaffolding/rest_routes.py

@@ -0,0 +1,117 @@
+# pyright: reportUnusedFunction=false
+#
+# The routes are nested functions registered by their decorators and never referenced by
+# name; the REST app mounts the router this returns.
+"""``/ext/scaffolding`` — the installed scaffold variants, for a form that creates nodes.
+
+==================================  ======================================================
+Route                               Answers
+==================================  ======================================================
+``GET /ext/scaffolding/variants``   every scaffold variant installed in the repository
+                                    (``?kind=`` one kind's; ``?holds=ROLE`` those whose
+                                    nodes hold ROLE): its bundle and version, its
+                                    declaration, what its nodes hold, its files, its
+                                    expansions and every token it renders with where the
+                                    value comes from
+==================================  ======================================================
+
+A read: nothing is written. ``backend`` names the repository, as every REST route that
+reads one repository's files does. The answer is
+:mod:`katalyst_taxonomy.services.scaffold_catalog`'s.
+"""
+
+# No `from __future__ import annotations`: FastAPI reads the handlers' annotations.
+from pathlib import Path
+from typing import Any
+
+
+class ScaffoldingRestRoutes:
+    """Implements :class:`~katalyst_taxonomy.plugins.extensions.RestRoutes`."""
+
+    @property
+    def name(self) -> str:
+        return "scaffolding"
+
+    def router(self) -> Any:
+        from fastapi import APIRouter
+        from fastapi.responses import JSONResponse
+        from katalyst_taxonomy.config.installs import declared_config
+        from katalyst_taxonomy.services.scaffold_catalog import (
+            BundleFiles,
+            declared_tokens,
+            scaffold_variants,
+        )
+        from katalyst_taxonomy_mcp.response import ok
+        from katalyst_taxonomy_mcp.rest.repository import repository_or_refusal
+
+        from katalyst_plugin_scaffolding.templates.bundle_install import (
+            describe_bundle,
+            installed_bundles,
+        )
+
+        router = APIRouter()
+
+        def bundles(root: Path) -> list[BundleFiles]:
+            """The declared template bundles *root* has installed, with the files of each."""
+            config = declared_config()[0]
+            declared = config.spec.templates if config is not None else ()
+            have = set(installed_bundles(root, {t.name: t.source for t in declared}))
+            out: list[BundleFiles] = []
+            for template in declared:
+                if template.name not in have:
+                    continue
+                described = describe_bundle(root, template.name, template.source) or {}
+                files = [str(f) for f in described.get("files") or ()]
+                out.append(BundleFiles(template.name, str(template.version or ""), files))
+            return out
+
+        @router.get("/variants", response_model=None)
+        def variants(
+            kind: str | None = None, holds: str | None = None, backend: str | None = None
+        ) -> Any:
+            """The variants installed in *backend*'s repository: of *kind*, holding *holds*."""
+            repository = repository_or_refusal(backend)
+            if isinstance(repository, JSONResponse):
+                return repository
+            root = repository.root
+            found = scaffold_variants(
+                root,
+                filesystem=_Files(),
+                bundles=bundles(root),
+                kind=kind or None,
+                holds=holds or None,
+            )
+            return ok(
+                {
+                    "backend": repository.name,
+                    "kind": kind,
+                    "holds": holds,
+                    "variants": [variant.to_dict() for variant in found],
+                    # The kind's own scaffold tokens: fields only a template renders.
+                    "tokens": declared_tokens(kind) if kind else [],
+                }
+            )
+
+        return router
+
+
+class _Files:
+    """The repository's files, read — the ``FileReader`` the catalog reads through."""
+
+    def exists(self, path: Path) -> bool:
+        return path.exists()
+
+    def is_directory(self, path: Path) -> bool:
+        return path.is_dir()
+
+    def is_file(self, path: Path) -> bool:
+        return path.is_file()
+
+    def read_file(self, path: Path) -> str:
+        return path.read_text(encoding="utf-8")
+
+    def list_directory(self, path: Path) -> list[Path]:
+        return list(path.iterdir()) if path.is_dir() else []
+
+    def glob(self, path: Path, pattern: str) -> list[Path]:
+        return list(path.glob(pattern))

katalyst_plugin_scaffolding/schema.py

@@ -0,0 +1,75 @@
+"""Schema bundle for the scaffolding plugin: the ``node_wiring`` kind.
+
+A ``node_wiring`` document is ordinary taxonomy content. It lives in a repository,
+under ``.global/taxonomy/node_wiring/``, and adds files to scaffolded nodes: it names
+the templates it extends and the template directory it provides, and it activates only
+when the plugins it requires are installed.
+
+Declaring it (in the LinkML module ``linkml/scaffolding.yaml``) makes it a registered kind like any other, validated and listed. The
+runtime keeps no list of kinds to skip.
+"""
+
+from __future__ import annotations
+
+from functools import cache
+
+from katalyst_engine.bundle.protocol import BundleManifest
+from katalyst_engine.core.identity import Identity
+from katalyst_engine.core.version import Version
+from katalyst_engine.schema.definition import (
+    NodeDefinition,
+    SchemaDefinition,
+    WingDefinition,
+)
+from katalyst_engine.schema.manager import SchemaManager
+from katalyst_engine.toolkit.linkml import LinkMLDefinitions, installed_definitions
+
+#: The bundle's entry-point name, as a profile's ``schemas`` list names it.
+BUNDLE_NAME = "scaffolding-schema"
+WING = "scaffolding"
+KIND = "node_wiring"
+
+#: The LinkML module this bundle builds its definitions from (``linkml/scaffolding.yaml``).
+MODULES = ("scaffolding",)
+
+
+@cache
+def _definitions() -> LinkMLDefinitions:
+    return installed_definitions(MODULES)
+
+
+NODE_WIRING: NodeDefinition = next(n for n in _definitions().nodes if n.describes_kind == KIND)
+SCAFFOLDING_WING: WingDefinition = next(w for w in _definitions().wings if w.identity.name == WING)
+
+
+class ScaffoldingSchemaBundle:
+    """Contributes ``node_wiring``, and the wing it lives in."""
+
+    @property
+    def manifest(self) -> BundleManifest:
+        return BundleManifest(
+            identity=Identity(kind="bundle", name=BUNDLE_NAME),
+            version=Version(major=0, minor=1),
+            modules=MODULES,
+            provided_kinds=frozenset({KIND}),
+            wing_names=frozenset({WING}),
+            description="Schema for the documents the scaffolding plugin reads",
+        )
+
+    def node_definitions(self) -> list[NodeDefinition]:
+        return [NODE_WIRING]
+
+    def wing_definitions(self) -> list[WingDefinition]:
+        return [SCAFFOLDING_WING]
+
+    def schema_definition(self) -> SchemaDefinition:
+        return SchemaDefinition(
+            identity=Identity(kind="schema", name=BUNDLE_NAME),
+            describes_kind="taxonomy",
+            api_version="v2alpha",
+            schema_version=Version(major=0, minor=1),
+            node_definitions=(NODE_WIRING.identity,),
+        )
+
+    def register(self, manager: SchemaManager) -> None:
+        manager.register_schema(self.schema_definition(), node_definitions=self.node_definitions())

katalyst_plugin_scaffolding/templates/__init__.py

@@ -0,0 +1,6 @@
+"""Template bundles, as a taxonomy plugin.
+
+Installs, lists, describes and removes the template bundles a user config declares
+(``spec.templates``) — every bundle the same way, from its manifest in its declared
+source — and contributes the ``kata tax add`` command.
+"""

katalyst_plugin_scaffolding/templates/bundle_install.py

@@ -0,0 +1,238 @@
+"""Install forge template bundles into a taxonomy repository (the `kata tax add` engine).
+
+A collection declares its layout in ``templates/manifest.json`` (``layout:
+wing/kind/template``): a bundle is ``templates/_manifests/<name>.yaml`` listing the
+templates it is made of, each of which is installed where its kind declares (see
+:mod:`~katalyst_plugin_scaffolding.templates.composed_install`). The collection sits at
+the root of a git or local source, or one or two package levels down in a wheel.
+
+Every bundle is handled the same way, whatever kinds its templates are:
+
+* installed by copying its templates (:func:`install_template_bundle`);
+* installed *when* every path that copy writes is on disk (:func:`bundle_installed`);
+* described by those paths and its templates' kinds (:func:`describe_bundle`);
+* removed by deleting those paths (:mod:`~katalyst_plugin_scaffolding.templates.template_remove`).
+
+Each reads the bundle's manifest in its declared source (a ``spec.templates`` entry). It
+copies; it records nothing — the pinned source and version go on the template's
+``spec.templates`` entry in ``config.yaml`` (:mod:`katalyst_taxonomy.services.template_install`).
+"""
+
+from __future__ import annotations
+
+import subprocess
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any, cast
+
+import yaml
+from katalyst_taxonomy.sources.bundle_sources import fetch_source_tree
+
+from katalyst_plugin_scaffolding.templates.composed_install import (
+    BundleInstallResult,
+    bundle_targets,
+    composed_bundle_installed,
+    install_composed_bundle,
+    is_composed_manifest,
+    load_manifest,
+)
+from katalyst_plugin_scaffolding.templates.layout import LayoutSpec, TemplateRef, read_layout_spec
+
+
+def collection_root(checkout_root: Path) -> Path:
+    """The directory holding ``templates/``: the root, or a package one or two levels down.
+
+    A git or local source has it at the root. A wheel's top level is the installed
+    package(s) plus ``*.dist-info`` / ``*.data``, so the collection sits at
+    ``<package>/templates/`` or ``<package>/<subdir>/templates/`` (for instance
+    ``<package>/collection/templates/``). Below the root, a ``templates/`` that declares
+    a collection (``templates/manifest.json`` or ``templates/_manifests/``) wins over one
+    that does not: a package may have a ``templates`` subpackage of its own beside its
+    collection. Falls back to *checkout_root* so the caller reports "bundle not found"
+    rather than an internal error.
+    """
+    if (checkout_root / "templates").is_dir():
+        return checkout_root
+    if not checkout_root.is_dir():
+        return checkout_root
+    level = [
+        c
+        for c in sorted(checkout_root.iterdir())
+        if c.is_dir()
+        and not c.name.endswith((".dist-info", ".data"))
+        and not c.name.startswith(".")
+    ]
+    candidates = [
+        *level,
+        *(c for parent in level for c in sorted(parent.iterdir()) if c.is_dir()),
+    ]
+    for found in (_declares_collection, _has_templates):
+        for candidate in candidates:
+            if found(candidate):
+                return candidate
+    return checkout_root
+
+
+def _has_templates(directory: Path) -> bool:
+    return (directory / "templates").is_dir()
+
+
+def _declares_collection(directory: Path) -> bool:
+    templates = directory / "templates"
+    return (templates / "manifest.json").is_file() or (templates / "_manifests").is_dir()
+
+
+def install_template_bundle(
+    *,
+    repo_root: Path,
+    source_uri: str,
+    bundle_name: str,
+    ref: str = "",
+    checkout_root: Path | None = None,
+) -> BundleInstallResult:
+    """Fetch *source_uri* and install the named bundle into *repo_root*.
+
+    Returns a :class:`BundleInstallResult`; ``result.success`` is ``False`` with
+    a descriptive error if the bundle cannot be located.
+
+    *checkout_root*, when given, is an already-fetched tree for *source_uri* (see
+    :func:`~katalyst_taxonomy.sources.bundle_sources.fetch_bundle_collection`), so a
+    caller installing several bundles fetches — and clones — the source once.
+    """
+    # Issue #92: honour the documented contract — return an error result rather
+    # than letting raw exceptions from source fetching propagate.
+    if checkout_root is None:
+        try:
+            checkout_root = fetch_source_tree(source_uri, ref)
+        except (ValueError, OSError, RuntimeError, subprocess.CalledProcessError) as exc:
+            return _failed(bundle_name, f"Failed to fetch source {source_uri!r}: {exc}")
+    checkout_root = collection_root(checkout_root)
+    try:
+        layout = read_layout_spec(checkout_root)
+    except ValueError as exc:
+        return _failed(bundle_name, str(exc))
+    if layout is None:
+        return _failed(
+            bundle_name,
+            f"Source {source_uri} declares no template collection "
+            "(looked for templates/manifest.json with layout 'wing/kind/template')",
+        )
+    manifest = layout.manifest_for(bundle_name)
+    try:
+        doc = load_manifest(manifest) if manifest.is_file() else {}
+    except yaml.YAMLError as exc:
+        return _failed(bundle_name, f"{manifest} could not be parsed: {exc}")
+    if not is_composed_manifest(doc):
+        return _failed(
+            bundle_name,
+            f"Bundle '{bundle_name}' not found in source {source_uri} "
+            f"(looked for {manifest.relative_to(checkout_root)} listing spec.templates)",
+        )
+    return install_composed_bundle(manifest=manifest, doc=doc, layout=layout, repo_root=repo_root)
+
+
+def _failed(name: str, error: str) -> BundleInstallResult:
+    return BundleInstallResult(name=name, version="0.0.0", installed_targets=(), errors=(error,))
+
+
+def _source_tree(source: str, *, fetch: bool = False) -> Path | None:
+    """The tree *source* names: the local path, the source cache, or (with *fetch*) fetched."""
+    from katalyst_taxonomy.sources.bundle_sources import local_source_root, parse_bundle_uri
+    from katalyst_taxonomy.sources.cache import lookup
+
+    try:
+        if source.strip().startswith(("git:", "github:", "pypi:")):
+            found = lookup(source)
+            if found is not None:
+                return found.path
+            return fetch_source_tree(source) if fetch else None
+        return local_source_root(parse_bundle_uri(source))
+    except (OSError, ValueError, RuntimeError, subprocess.CalledProcessError):
+        return None
+
+
+def layout_for(
+    source: str, cache: dict[str, LayoutSpec | None] | None = None, *, fetch: bool = False
+) -> LayoutSpec | None:
+    """The collection layout *source* holds, read once per *cache*; None if not at hand."""
+    cache = {} if cache is None else cache
+    if source not in cache:
+        tree = _source_tree(source, fetch=fetch)
+        try:
+            cache[source] = read_layout_spec(collection_root(tree)) if tree is not None else None
+        except ValueError:
+            cache[source] = None
+    return cache[source]
+
+
+def bundle_installed(
+    repo_root: Path, name: str, source: str, cache: dict[str, LayoutSpec | None] | None = None
+) -> bool:
+    """Whether every path bundle *name* of *source* installs is on disk in *repo_root*."""
+    layout = layout_for(source, cache)
+    return layout is not None and composed_bundle_installed(
+        layout.manifest_for(name), layout, repo_root
+    )
+
+
+def installed_bundles(repo_root: Path, declared: Mapping[str, str]) -> list[str]:
+    """The bundles of *declared* (name → source) that *repo_root* has installed.
+
+    The ``PluginContext.template_listers`` entry: the one answer to "which template
+    bundles are installed". A source that is not at hand reports nothing, and installing
+    it again is harmless.
+    """
+    cache: dict[str, LayoutSpec | None] = {}
+    return sorted(n for n, s in declared.items() if bundle_installed(repo_root, n, s, cache))
+
+
+def describe_bundle(repo_root: Path, name: str, source: str) -> dict[str, Any] | None:
+    """What bundle *name* of *source* puts in *repo_root*: its node kinds and files.
+
+    A ``PluginContext.template_describers`` entry. None when the source is not at hand
+    or the manifest does not resolve.
+    """
+    layout = layout_for(source)
+    if layout is None:
+        return None
+    manifest = layout.manifest_for(name)
+    targets = bundle_targets(manifest, layout, repo_root)
+    if targets is None:
+        return None
+    kinds: dict[str, int] = {}
+    spec = cast(dict[str, Any], load_manifest(manifest).get("spec") or {})
+    for value in cast(list[object], spec.get("templates") or []):
+        kind = TemplateRef.parse(value).kind
+        kinds[kind] = kinds.get(kind, 0) + 1
+    files: list[str] = []
+    for target in targets:
+        try:
+            files.append(target.relative_to(repo_root).as_posix())
+        except ValueError:
+            files.append(str(target))
+    return {"kinds": kinds, "files": sorted(set(files))}
+
+
+def install_template_for_plugin(
+    repo_root: Path,
+    source: str,
+    bundle: str,
+    *,
+    ref: str = "",
+    checkout_root: Path | None = None,
+) -> dict[str, Any]:
+    """:func:`install_template_bundle` as a ``PluginContext.template_installers`` entry."""
+    result = install_template_bundle(
+        repo_root=repo_root,
+        source_uri=source,
+        bundle_name=bundle,
+        ref=ref,
+        checkout_root=checkout_root,
+    )
+    return {
+        "name": result.name,
+        "version": result.version,
+        "success": result.success,
+        "installed_targets": list(result.installed_targets),
+        "errors": list(result.errors),
+    }