@reventlessdev/reventless-spec 3.0.0-alpha.85 → 3.0.0-alpha.86

package/CHANGELOG.md

@@ -3,6 +3,14 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.86 (2026-07-30)
+
+### Features
+
+* **spec,local:** resolve capability manifests beyond the example topology ([8bfadd5](https://github.com/ReventlessDev/reventless-core/commit/8bfadd5beef90c0c9f6f6f3fbb753c8b789469ed))
+* **spec:** semantic branded scalars — Email, Url, Phone, Percent, Color, Bytes, Duration ([2e64ff9](https://github.com/ReventlessDev/reventless-core/commit/2e64ff992e913c038a71659c731c25a104e3c5a9))
+
+
 # 3.0.0-alpha.85 (2026-07-30)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-spec",
-  "version": "3.0.0-alpha.85",
+  "version": "3.0.0-alpha.86",
   "description": "Specifications for Reventless",
   "license": "Apache-2.0",
   "bin": {

package/src/generator/PlatformGenerator.res

@@ -6,11 +6,10 @@
 // `PlatformCapabilities.res` (see PlatformCodegen). The platform root stays
 // hand-written and reads `PlatformCapabilities.capabilities`.
 //
-// A plugin path may be the composition package itself (its `src/` carries the
-// manifest) or an `-aws` deploy root that delegates to one. The delegation's
-// single existing record is the root's own `generate` script —
-// `generate-plugin --aws <Namespace> <srcDir>` — so the composition `src/` is
-// read from there rather than from a second, hand-typed spelling of the path.
+// A deploy manifest enumerates *deployables*, not plugins, and a plugin's
+// manifest can sit in any of three places. `PlatformManifests` owns both facts —
+// its head comment states the resolution order and why each arm exists; add a
+// fourth arm there, not here.
 
 @val external processExit: int => unit = "process.exit"
 @module("yaml") external parseYaml: string => JSON.t = "parse"
@@ -24,42 +23,6 @@ let asObject = (json: JSON.t): option<dict<JSON.t>> => json->JSON.Decode.object
 let stringAt = (obj: dict<JSON.t>, field: string): option<string> =>
   obj->Dict.get(field)->Option.flatMap(JSON.Decode.string)
 
-// Where a plugin keeps its capability manifest. The direct arm covers a plugin
-// path that is itself a composition package; the delegated arm follows the
-// `-aws` root's `generate-plugin --aws <Namespace> <srcDir>` script to the
-// composition `src/` it is generated from.
-let manifestPathFor = (~pluginDir: string): option<string> => {
-  let direct = Generator_Node.join([pluginDir, "src", "capabilities.json"])
-  if Generator_Node.existsSync(direct) {
-    Some(direct)
-  } else {
-    let packageJsonPath = Generator_Node.join([pluginDir, "package.json"])
-    if !Generator_Node.existsSync(packageJsonPath) {
-      None
-    } else {
-      let generateScript =
-        try Generator_Node.readFileSync(packageJsonPath)
-        ->JSON.parseOrThrow
-        ->asObject
-        ->Option.flatMap(pkg => pkg->Dict.get("scripts"))
-        ->Option.flatMap(asObject)
-        ->Option.flatMap(scripts => scripts->stringAt("generate")) catch {
-        | _ => None
-        }
-      generateScript
-      ->Option.flatMap(script => {
-        let tokens = script->String.split(" ")->Array.filter(t => t != "")
-        switch tokens {
-        | ["generate-plugin", "--aws", _namespace, srcDir] =>
-          Some(Generator_Node.resolve([pluginDir, srcDir, "capabilities.json"]))
-        | _ => None
-        }
-      })
-      ->Option.filter(Generator_Node.existsSync)
-    }
-  }
-}
-
 let () = {
   let manifestArg = Generator_Node.argv->Array.get(2)->Option.getOr("")
   if manifestArg == "" {
@@ -104,27 +67,43 @@ let () = {
 
     switch (platformPath, plugins) {
     | (Some(platformPath), Some(plugins)) => {
-        let pluginManifests = plugins->Array.map(((pluginName, pluginPath)) => {
+        let pluginManifests = plugins->Array.flatMap(((pluginName, pluginPath)) => {
           let pluginDir = Generator_Node.resolve([manifestDir, pluginPath])
-          switch manifestPathFor(~pluginDir) {
-          | None => {
+          if !Generator_Node.existsSync(pluginDir) {
+            fail(`plugin "${pluginName}" points at ${pluginDir}, which does not exist`)
+          }
+          switch PlatformManifests.resolve(~pluginDir) {
+          // A stack whose package graph holds no plugin composition — an
+          // SdkService, an SPA, a standalone Lambda — has no capabilities to
+          // contribute, which is not an error. Said out loud so a plugin
+          // skipped by mistake is visible in the generator's output.
+          | NotAPlugin => {
+              Console.log(`Skipped: ${pluginName} (${pluginDir}) — no plugin composition`)
+              []
+            }
+          | Unbuilt({evidence, expected}) => {
               fail(
                 `no capabilities.json found for plugin "${pluginName}" (${pluginDir}) — ` ++
-                `build the plugin first; its build emits src/capabilities.json beside Plugin.res`,
+                `build the plugin first; its build emits src/capabilities.json beside Plugin.res ` ++
+                `(${evidence}; expected ${expected})`,
               )
-              ({pluginName, manifest: {capabilities: []}}: PlatformCodegen.pluginManifest)
+              []
             }
-          | Some(capabilitiesPath) => {
-              let manifest = try Generator_Node.readFileSync(capabilitiesPath)
+          | Manifests(manifests) =>
+            manifests->Array.map(({path, via}) => {
+              Console.log(
+                `Read: ${pluginName} — ${path} (via ${PlatformManifests.describeVia(via)})`,
+              )
+              let manifest = try Generator_Node.readFileSync(path)
               ->JSON.parseOrThrow
               ->S.parseOrThrow(CapabilityManifest.schema) catch {
               | _ => {
-                  fail(`could not parse ${capabilitiesPath} as a capability manifest`)
+                  fail(`could not parse ${path} as a capability manifest`)
                   ({capabilities: []}: CapabilityManifest.t)
                 }
               }
               ({pluginName, manifest}: PlatformCodegen.pluginManifest)
-            }
+            })
           }
         })
 

package/src/generator/PlatformGenerator.res.mjs

@@ -8,6 +8,7 @@ import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as PlatformCodegen$Reventless from "./PlatformCodegen.res.mjs";
+import * as PlatformManifests$Reventless from "./PlatformManifests.res.mjs";
 import * as CapabilityManifest$Reventless from "../components/CapabilityManifest.res.mjs";
 
 function fail(message) {
@@ -23,39 +24,6 @@ function stringAt(obj, field) {
   return Stdlib_Option.flatMap(obj[field], Stdlib_JSON.Decode.string);
 }
 
-function manifestPathFor(pluginDir) {
-  let direct = Nodepath.join(pluginDir, "src", "capabilities.json");
-  if (Nodefs.existsSync(direct)) {
-    return direct;
-  }
-  let packageJsonPath = Nodepath.join(pluginDir, "package.json");
-  if (!Nodefs.existsSync(packageJsonPath)) {
-    return;
-  }
-  let generateScript;
-  try {
-    generateScript = Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(Nodefs.readFileSync(packageJsonPath, "utf8"))), pkg => pkg["scripts"]), asObject), scripts => stringAt(scripts, "generate"));
-  } catch (exn) {
-    generateScript = undefined;
-  }
-  return Stdlib_Option.filter(Stdlib_Option.flatMap(generateScript, script => {
-    let tokens = script.split(" ").filter(t => t !== "");
-    if (tokens.length !== 4) {
-      return;
-    }
-    let match = tokens[0];
-    if (match !== "generate-plugin") {
-      return;
-    }
-    let match$1 = tokens[1];
-    if (match$1 !== "--aws") {
-      return;
-    }
-    let srcDir = tokens[3];
-    return Nodepath.resolve(pluginDir, srcDir, "capabilities.json");
-  }), prim => Nodefs.existsSync(prim));
-}
-
 let manifestArg = Stdlib_Option.getOr(process.argv[2], "");
 
 if (manifestArg === "") {
@@ -88,32 +56,39 @@ if (manifestArg === "") {
   }));
   if (platformPath !== undefined) {
     if (plugins !== undefined) {
-      let pluginManifests = plugins.map(param => {
+      let pluginManifests = plugins.flatMap(param => {
         let pluginName = param[0];
         let pluginDir = Nodepath.resolve(manifestDir, param[1]);
-        let capabilitiesPath = manifestPathFor(pluginDir);
-        if (capabilitiesPath !== undefined) {
-          let manifest;
-          try {
-            manifest = S.parseOrThrow(JSON.parse(Nodefs.readFileSync(capabilitiesPath, "utf8")), CapabilityManifest$Reventless.schema);
-          } catch (exn) {
-            fail(`could not parse ` + capabilitiesPath + ` as a capability manifest`);
-            manifest = {
-              capabilities: []
+        if (!Nodefs.existsSync(pluginDir)) {
+          fail(`plugin "` + pluginName + `" points at ` + pluginDir + `, which does not exist`);
+        }
+        let manifests = PlatformManifests$Reventless.resolve(undefined, pluginDir);
+        if (typeof manifests !== "object") {
+          console.log(`Skipped: ` + pluginName + ` (` + pluginDir + `) — no plugin composition`);
+          return [];
+        }
+        if (manifests.TAG === "Manifests") {
+          return manifests._0.map(param => {
+            let path = param.path;
+            console.log(`Read: ` + pluginName + ` — ` + path + ` (via ` + PlatformManifests$Reventless.describeVia(param.via) + `)`);
+            let manifest;
+            try {
+              manifest = S.parseOrThrow(JSON.parse(Nodefs.readFileSync(path, "utf8")), CapabilityManifest$Reventless.schema);
+            } catch (exn) {
+              fail(`could not parse ` + path + ` as a capability manifest`);
+              manifest = {
+                capabilities: []
+              };
+            }
+            return {
+              pluginName: pluginName,
+              manifest: manifest
             };
-          }
-          return {
-            pluginName: pluginName,
-            manifest: manifest
-          };
+          });
         }
-        fail(`no capabilities.json found for plugin "` + pluginName + `" (` + pluginDir + `) — build the plugin first; its build emits src/capabilities.json beside Plugin.res`);
-        return {
-          pluginName: pluginName,
-          manifest: {
-            capabilities: []
-          }
-        };
+        let match = manifests._0;
+        fail(`no capabilities.json found for plugin "` + pluginName + `" (` + pluginDir + `) — build the plugin first; its build emits src/capabilities.json beside Plugin.res ` + (`(` + match.evidence + `; expected ` + match.expected + `)`));
+        return [];
       });
       let message = PlatformCodegen$Reventless.render(pluginManifests);
       if (message.TAG === "Ok") {
@@ -135,6 +110,5 @@ export {
   fail,
   asObject,
   stringAt,
-  manifestPathFor,
 }
 /* manifestArg Not a pure module */

package/src/generator/PlatformManifests.res

@@ -0,0 +1,203 @@
+// Where a deploy-manifest entry's capability manifests live — and, when it
+// contributes none, whether that is because the entry is not a plugin at all.
+//
+// A deploy manifest enumerates *deployables*, not plugins. An SdkService stack,
+// a static SPA, a standalone ingester Lambda are all legitimate entries with no
+// `pluginStructure` to derive capabilities from; contributing nothing is the
+// right answer for those. A plugin whose manifest is merely unbuilt is the
+// opposite case, and silently skipping it would deprovision the stores it
+// declared. The two are told apart by evidence — something in the package graph
+// that emits a capability manifest — never by falling through the arms below.
+//
+// Resolution order, first arm that yields manifests wins:
+//
+//   1. `<dir>/src/capabilities.json` — the entry is itself a composition
+//      package, so its manifest sits beside its composition root.
+//   2. `<dir>`'s own `generate: generate-plugin --aws <Namespace> <srcDir>`
+//      script — an `-aws` root generated from a composition `src/` elsewhere in
+//      the same repo. The script is the single existing record of that
+//      delegation, so no second hand-typed spelling of the path is introduced.
+//   3. `<dir>`'s dependencies — an `-aws` root that *installs* a published
+//      composition package, which is the shape the framework recommends and the
+//      one arms 1 and 2 both miss. Every plugin dependency contributes: a root
+//      deploying two plugins legitimately needs both manifests.
+//   4. Nothing in the package graph emits a manifest — not a plugin stack.
+//
+// I/O goes through `fileSystem` so the arms are testable without a fixture
+// tree; `nodeFileSystem` is what the generator passes.
+
+/** How a manifest was found — reported so the resolving arm never has to be
+    reconstructed from the output. */
+type via =
+  | Composition
+  | Generated(string)
+  | Dependency(string)
+
+type manifest = {path: string, via: via}
+
+/** Why the entry counted as a plugin, and where its manifest was looked for. */
+type unbuilt = {evidence: string, expected: string}
+
+type t =
+  | Manifests(array<manifest>)
+  /** Something here emits a capability manifest, but the manifest is not on
+      disk: a plugin that has not been built. */
+  | Unbuilt(unbuilt)
+  /** No plugin composition anywhere in the entry's package graph. */
+  | NotAPlugin
+
+type fileSystem = {
+  exists: string => bool,
+  readJson: string => option<JSON.t>,
+}
+
+let nodeFileSystem: fileSystem = {
+  exists: Generator_Node.existsSync,
+  readJson: path =>
+    try Some(Generator_Node.readFileSync(path)->JSON.parseOrThrow) catch {
+    | _ => None
+    },
+}
+
+let describeVia = (via: via): string =>
+  switch via {
+  | Composition => "its own src/"
+  | Generated(srcDir) => `its \`generate\` script's ${srcDir}`
+  | Dependency(name) => `dependency ${name}`
+  }
+
+let asObject = (json: JSON.t): option<dict<JSON.t>> => json->JSON.Decode.object
+
+let packageJsonAt = (~fs: fileSystem, ~dir: string): option<dict<JSON.t>> =>
+  fs.readJson(Generator_Node.join([dir, "package.json"]))->Option.flatMap(asObject)
+
+let scriptsOf = (pkg: dict<JSON.t>): array<string> =>
+  pkg
+  ->Dict.get("scripts")
+  ->Option.flatMap(asObject)
+  ->Option.mapOr([], scripts =>
+    scripts->Dict.valuesToArray->Array.filterMap(JSON.Decode.string)
+  )
+
+// The composition `src/` an `-aws` root is generated from, read off the script
+// that performs the generation.
+let generatedSrcDir = (pkg: dict<JSON.t>): option<string> =>
+  pkg
+  ->Dict.get("scripts")
+  ->Option.flatMap(asObject)
+  ->Option.flatMap(scripts => scripts->Dict.get("generate"))
+  ->Option.flatMap(JSON.Decode.string)
+  ->Option.flatMap(script => {
+    let tokens = script->String.split(" ")->Array.filter(t => t != "")
+    switch tokens {
+    | ["generate-plugin", "--aws", _namespace, srcDir] => Some(srcDir)
+    | _ => None
+    }
+  })
+
+// A package that runs `emit-capabilities` as part of its build is a plugin
+// composition package, whether or not it has been built yet. That is the whole
+// signal G1 needs: it is stated once, by the package that owns the fact, and it
+// is already there in every plugin package — unlike a `kind:` on the deploy
+// manifest, which would restate it a second time.
+//
+// `reventless-local` *provides* the bin under `bin`, and so is correctly not
+// matched here.
+let emitsCapabilities = (pkg: dict<JSON.t>): bool =>
+  pkg->scriptsOf->Array.some(script => script->String.includes("emit-capabilities"))
+
+let dependencyNames = (pkg: dict<JSON.t>): array<string> => {
+  let seen = Dict.make()
+  ["dependencies", "devDependencies"]
+  ->Array.flatMap(field =>
+    pkg->Dict.get(field)->Option.flatMap(asObject)->Option.mapOr([], Dict.keysToArray)
+  )
+  ->Array.filter(name =>
+    switch seen->Dict.get(name) {
+    | Some(_) => false
+    | None => {
+        seen->Dict.set(name, true)
+        true
+      }
+    }
+  )
+}
+
+/** Node's directory resolution: `<dir>/node_modules/<name>`, then each parent's,
+    up to the filesystem root. Walking it rather than binding `require.resolve`
+    keeps the lookup on the package directory itself — a package's entry point
+    may be anywhere, and it is `src/capabilities.json` that is wanted. */
+let resolvePackageDir = (~fs: fileSystem, ~fromDir: string, ~name: string): option<string> => {
+  let rec search = dir => {
+    let candidate = Generator_Node.join([dir, "node_modules", name])
+    if fs.exists(Generator_Node.join([candidate, "package.json"])) {
+      Some(candidate)
+    } else {
+      let parent = Generator_Node.dirname(dir)
+      parent == dir ? None : search(parent)
+    }
+  }
+  search(fromDir)
+}
+
+// Arm 3. Unbuilt wins over what was found: a root deploying two plugins needs
+// both manifests, so one of them missing is a failure even though the other
+// resolved.
+let fromDependencies = (~fs: fileSystem, ~pluginDir: string, ~pkg: dict<JSON.t>): t => {
+  let found = []
+  let unbuilt = ref(None)
+  pkg
+  ->dependencyNames
+  ->Array.forEach(name =>
+    switch resolvePackageDir(~fs, ~fromDir=pluginDir, ~name) {
+    | None => ()
+    | Some(packageDir) => {
+        let candidate = Generator_Node.join([packageDir, "src", "capabilities.json"])
+        if fs.exists(candidate) {
+          found->Array.push({path: candidate, via: Dependency(name)})
+        } else if packageJsonAt(~fs, ~dir=packageDir)->Option.mapOr(false, emitsCapabilities) {
+          switch unbuilt.contents {
+          | Some(_) => ()
+          | None =>
+            unbuilt :=
+              Some({
+                evidence: `dependency ${name} emits a capability manifest`,
+                expected: candidate,
+              })
+          }
+        }
+      }
+    }
+  )
+  switch (unbuilt.contents, found) {
+  | (Some({evidence, expected}), _) => Unbuilt({evidence, expected})
+  | (None, []) => NotAPlugin
+  | (None, manifests) => Manifests(manifests)
+  }
+}
+
+let resolve = (~fs: fileSystem=nodeFileSystem, ~pluginDir: string): t => {
+  let direct = Generator_Node.join([pluginDir, "src", "capabilities.json"])
+  if fs.exists(direct) {
+    Manifests([{path: direct, via: Composition}])
+  } else {
+    switch packageJsonAt(~fs, ~dir=pluginDir) {
+    | None => NotAPlugin
+    | Some(pkg) =>
+      switch generatedSrcDir(pkg) {
+      | Some(srcDir) => {
+          let expected = Generator_Node.resolve([pluginDir, srcDir, "capabilities.json"])
+          if fs.exists(expected) {
+            Manifests([{path: expected, via: Generated(srcDir)}])
+          } else {
+            Unbuilt({
+              evidence: `its \`generate\` script composes ${srcDir}`,
+              expected,
+            })
+          }
+        }
+      | None => fromDependencies(~fs, ~pluginDir, ~pkg)
+      }
+    }
+  }
+}

package/src/generator/PlatformManifests.res.mjs

@@ -0,0 +1,212 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodepath from "node:path";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+function nodeFileSystem_exists(prim) {
+  return Nodefs.existsSync(prim);
+}
+
+function nodeFileSystem_readJson(path) {
+  try {
+    return JSON.parse(Nodefs.readFileSync(path, "utf8"));
+  } catch (exn) {
+    return;
+  }
+}
+
+let nodeFileSystem = {
+  exists: nodeFileSystem_exists,
+  readJson: nodeFileSystem_readJson
+};
+
+function describeVia(via) {
+  if (typeof via !== "object") {
+    return "its own src/";
+  } else if (via.TAG === "Generated") {
+    return `its \`generate\` script's ` + via._0;
+  } else {
+    return `dependency ` + via._0;
+  }
+}
+
+function asObject(json) {
+  return Stdlib_JSON.Decode.object(json);
+}
+
+function packageJsonAt(fs, dir) {
+  return Stdlib_Option.flatMap(fs.readJson(Nodepath.join(dir, "package.json")), asObject);
+}
+
+function scriptsOf(pkg) {
+  return Stdlib_Option.mapOr(Stdlib_Option.flatMap(pkg["scripts"], asObject), [], scripts => Stdlib_Array.filterMap(Object.values(scripts), Stdlib_JSON.Decode.string));
+}
+
+function generatedSrcDir(pkg) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(pkg["scripts"], asObject), scripts => scripts["generate"]), Stdlib_JSON.Decode.string), script => {
+    let tokens = script.split(" ").filter(t => t !== "");
+    if (tokens.length !== 4) {
+      return;
+    }
+    let match = tokens[0];
+    if (match !== "generate-plugin") {
+      return;
+    }
+    let match$1 = tokens[1];
+    if (match$1 === "--aws") {
+      return tokens[3];
+    }
+  });
+}
+
+function emitsCapabilities(pkg) {
+  return scriptsOf(pkg).some(script => script.includes("emit-capabilities"));
+}
+
+function dependencyNames(pkg) {
+  let seen = {};
+  return [
+    "dependencies",
+    "devDependencies"
+  ].flatMap(field => Stdlib_Option.mapOr(Stdlib_Option.flatMap(pkg[field], asObject), [], prim => Object.keys(prim))).filter(name => {
+    let match = seen[name];
+    if (match !== undefined) {
+      return false;
+    } else {
+      seen[name] = true;
+      return true;
+    }
+  });
+}
+
+function resolvePackageDir(fs, fromDir, name) {
+  let _dir = fromDir;
+  while (true) {
+    let dir = _dir;
+    let candidate = Nodepath.join(dir, "node_modules", name);
+    if (fs.exists(Nodepath.join(candidate, "package.json"))) {
+      return candidate;
+    }
+    let parent = Nodepath.dirname(dir);
+    if (parent === dir) {
+      return;
+    }
+    _dir = parent;
+    continue;
+  };
+}
+
+function fromDependencies(fs, pluginDir, pkg) {
+  let found = [];
+  let unbuilt = {
+    contents: undefined
+  };
+  dependencyNames(pkg).forEach(name => {
+    let packageDir = resolvePackageDir(fs, pluginDir, name);
+    if (packageDir === undefined) {
+      return;
+    }
+    let candidate = Nodepath.join(packageDir, "src", "capabilities.json");
+    if (fs.exists(candidate)) {
+      found.push({
+        path: candidate,
+        via: {
+          TAG: "Dependency",
+          _0: name
+        }
+      });
+      return;
+    }
+    if (!Stdlib_Option.mapOr(packageJsonAt(fs, packageDir), false, emitsCapabilities)) {
+      return;
+    }
+    let match = unbuilt.contents;
+    if (match !== undefined) {
+      return;
+    } else {
+      unbuilt.contents = {
+        evidence: `dependency ` + name + ` emits a capability manifest`,
+        expected: candidate
+      };
+      return;
+    }
+  });
+  let match = unbuilt.contents;
+  if (match !== undefined) {
+    return {
+      TAG: "Unbuilt",
+      _0: {
+        evidence: match.evidence,
+        expected: match.expected
+      }
+    };
+  } else if (found.length !== 0) {
+    return {
+      TAG: "Manifests",
+      _0: found
+    };
+  } else {
+    return "NotAPlugin";
+  }
+}
+
+function resolve(fsOpt, pluginDir) {
+  let fs = fsOpt !== undefined ? fsOpt : nodeFileSystem;
+  let direct = Nodepath.join(pluginDir, "src", "capabilities.json");
+  if (fs.exists(direct)) {
+    return {
+      TAG: "Manifests",
+      _0: [{
+          path: direct,
+          via: "Composition"
+        }]
+    };
+  }
+  let pkg = packageJsonAt(fs, pluginDir);
+  if (pkg === undefined) {
+    return "NotAPlugin";
+  }
+  let srcDir = generatedSrcDir(pkg);
+  if (srcDir === undefined) {
+    return fromDependencies(fs, pluginDir, pkg);
+  }
+  let expected = Nodepath.resolve(pluginDir, srcDir, "capabilities.json");
+  if (fs.exists(expected)) {
+    return {
+      TAG: "Manifests",
+      _0: [{
+          path: expected,
+          via: {
+            TAG: "Generated",
+            _0: srcDir
+          }
+        }]
+    };
+  } else {
+    return {
+      TAG: "Unbuilt",
+      _0: {
+        evidence: `its \`generate\` script composes ` + srcDir,
+        expected: expected
+      }
+    };
+  }
+}
+
+export {
+  nodeFileSystem,
+  describeVia,
+  asObject,
+  packageJsonAt,
+  scriptsOf,
+  generatedSrcDir,
+  emitsCapabilities,
+  dependencyNames,
+  resolvePackageDir,
+  fromDependencies,
+  resolve,
+}
+/* node:fs Not a pure module */