@@ -29,10 +29,11 @@ means adding it to `LibCopyArtifacts.contracts()` AND
 
 `foundry.toml`'s `ffi = true` and its filesystem permissions exist for
 `CopyArtifacts` and for `test/subgraph/`, which reads the built interface
-artifact with `jq`, the subgraph manifest and compose file with `yq`, and the
-git index with `git` — all over `vm.ffi`, so none of them needs an
-`fs_permissions` entry, and all three binaries have to be on `PATH` in the sol
-shell. Nothing else here shells out or touches the filesystem.
+artifact and `subgraph/schema.graphql` with `jq`, the subgraph manifest and
+compose file with `yq`, and the git index with `git` — all over `vm.ffi`, so
+none of them needs an `fs_permissions` entry, and all three binaries have to be
+on `PATH` in the sol shell. Nothing else here shells out or touches the
+filesystem.
 
 ## The subgraph is SOURCE only (#149)
 
@@ -61,7 +62,10 @@ cheatcodes at a path — not as text. A substring search answers a different
 question: a commented-out line satisfies a positive one, and a key respelled
 `address :` or `"address":` or moved into a flow mapping defeats a negative one.
 So new manifest assertions name the node they are about; do not add one that
-greps the file.
+greps the file. `schema.graphql` is the one file it does read by line, because
+no parser for it is in this lane — guarded by counting the `@entity` lines and
+asserting the types read against that count, so a shape it cannot read fails
+instead of under-reporting.
 
 ## Licensing
 
 
@@ -14,19 +14,20 @@ cbor_metadata = false
 # `script/CopyArtifacts.sol` and its freshness test shell out to `jq` via
 # `vm.ffi` to extract the deterministic subset of the forge artifact,
 # `test/subgraph/SubgraphManifest.t.sol` shells out to `jq` for that artifact's
-# event signatures and to `yq` to read `subgraph/subgraph.yaml` as parsed YAML
-# rather than as text, and `test/subgraph/SubgraphMatchstick.t.sol` shells out
-# to `git` for what the index tracks and to `yq` for the compose file. All
-# three are on `PATH` in the rainix sol shell.
+# event signatures and for `subgraph/schema.graphql`'s entity types and to `yq`
+# to read `subgraph/subgraph.yaml` as parsed YAML rather than as text, and
+# `test/subgraph/SubgraphMatchstick.t.sol` shells out to `git` for what the
+# index tracks and to `yq` for the compose file. All three are on `PATH` in the
+# rainix sol shell.
 ffi = true
 
 libs = ["dependencies"]
 
 # The filesystem access in this repo. `script/CopyArtifacts.sol` reads forge
 # build output and writes the stable subset for the rust bindings to consume;
 # `test/script/CopyArtifacts.t.sol` reads both back to assert the committed copy
-# is fresh. The `test/subgraph/` tests need no entry: they read through `yq` and
-# `git` over `vm.ffi`, which this list does not gate.
+# is fresh. The `test/subgraph/` tests need no entry: they read through `jq`,
+# `yq` and `git` over `vm.ffi`, which this list does not gate.
 fs_permissions = [
   { access = "read", path = "out/" },
   { access = "read", path = "test/fixtures/" },
 
@@ -14,6 +14,7 @@ dataSources:
       entities:
         - MetaBoard
         - MetaV1
+        - Transaction
       abis:
         - name: MetaBoard
           file: ../out/IMetaBoardV1_2.sol/IMetaBoardV1_2.json
 
@@ -41,6 +41,10 @@ contract SubgraphManifestTest is Test {
     /// The subgraph manifest, as a template: no deployment fact in it.
     string constant SUBGRAPH_YAML = "subgraph/subgraph.yaml";
 
+    /// The schema the mapping stores into, and the other side of the
+    /// `mapping.entities` check.
+    string constant SCHEMA_GRAPHQL = "subgraph/schema.graphql";
+
     /// The interface whose ABI the manifest decodes with. Named rather than
     /// read out of the manifest, so that the manifest is compared to an
     /// expectation instead of to itself.
@@ -277,6 +281,107 @@ contract SubgraphManifestTest is Test {
         );
     }
 
+    /// The schema's entity declarations, as JSON: `types` are the entity type
+    /// names, `declarations` is how many lines declare one.
+    ///
+    /// A LINE read, which every manifest check here is forbidden from being,
+    /// because there is no schema parser to reach for: this lane deliberately
+    /// has no node, and `yq` does not speak GraphQL. `declarations` is what
+    /// makes that safe. It counts every non-comment line carrying the entity
+    /// directive at all, and `schemaEntityTypes` holds `types` to that count,
+    /// so a schema written in a shape this cannot read — the directive on a
+    /// line of its own, a description carrying the word — fails loudly rather
+    /// than silently reporting fewer entities than the file declares. Comment
+    /// lines are dropped first, since a commented-out declaration is not one,
+    /// which is the same distinction reading the manifest as YAML gets for
+    /// free.
+    /// @return The `{declarations, types}` object as JSON.
+    function schemaEntityJson() internal returns (string memory) {
+        string[] memory cmd = new string[](4);
+        cmd[0] = "jq";
+        cmd[1] = "-Rn";
+        cmd[2] = "[inputs | select(test(\"^[[:space:]]*#\") | not) | select(test(\"@entity\"))]"
+            " | {declarations: length, types: [.[]"
+            " | scan(\"^type[[:space:]]+([A-Za-z_][A-Za-z0-9_]*)[[:space:]]+@entity\") | .[0]]}";
+        cmd[3] = SCHEMA_GRAPHQL;
+        return string(vm.ffi(cmd));
+    }
+
+    /// Every entity type the schema declares.
+    /// @return The entity type names.
+    function schemaEntityTypes() internal returns (string[] memory) {
+        string memory json = schemaEntityJson();
+        string[] memory types = vm.parseJsonStringArray(json, ".types");
+        assertEq(
+            types.length,
+            vm.parseJsonUint(json, ".declarations"),
+            "schema.graphql declares @entity on a line that is not a type declaration this can read"
+        );
+        return types;
+    }
+
+    /// The manifest MUST declare the entities the mapping stores.
+    ///
+    /// `mapping.entities` is the manifest's claim about which schema entities
+    /// the handler writes. Nothing downstream contradicts a stale one —
+    /// graph-node does not enforce the list at runtime and `graph codegen` does
+    /// not read it — which is how `Transaction`, stored by
+    /// `createTransactionEntity` on every event, sat unlisted
+    /// (rainlanguage/rain.metadata#151).
+    ///
+    /// The schema is the other side, rather than a list restated here, because
+    /// it is a separate file that codegen does read, and because
+    /// `dataSources` is pinned to one entry: there is exactly one mapping for
+    /// its entities to belong to, so an entity the schema declares is one that
+    /// mapping stores or dead schema. Both directions are asserted and neither
+    /// implies the other: a schema entity the manifest omits is #151 again, and
+    /// a manifest entity the schema does not declare is a name `graph build`
+    /// rejects.
+    function testManifestDeclaresTheEntitiesTheMappingStores() external {
+        string memory json = manifestJson();
+        string memory entitiesPath = string.concat(THE_DATA_SOURCE, ".mapping.entities");
+        assertTrue(vm.keyExistsJson(json, entitiesPath), "subgraph.yaml declares no mapping.entities");
+
+        string[] memory declared = vm.parseJsonStringArray(json, entitiesPath);
+        string[] memory schema = schemaEntityTypes();
+
+        for (uint256 i = 0; i < schema.length; i++) {
+            assertTrue(
+                _holds(declared, schema[i]),
+                string.concat(
+                    "subgraph.yaml's mapping.entities omits ", schema[i], ", which schema.graphql declares @entity"
+                )
+            );
+        }
+        for (uint256 i = 0; i < declared.length; i++) {
+            assertTrue(
+                _holds(schema, declared[i]),
+                string.concat(
+                    "subgraph.yaml's mapping.entities declares ",
+                    declared[i],
+                    ", which schema.graphql declares no @entity type for"
+                )
+            );
+        }
+        assertEq(
+            declared.length,
+            schema.length,
+            "subgraph.yaml's mapping.entities and schema.graphql name the same entities, one of them twice"
+        );
+    }
+
+    /// @param names The names to search.
+    /// @param name The name to find.
+    /// @return Whether the list holds the name.
+    function _holds(string[] memory names, string memory name) internal pure returns (bool) {
+        for (uint256 i = 0; i < names.length; i++) {
+            if (keccak256(bytes(names[i])) == keccak256(bytes(name))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     /// Every node in the document keyed `network` that is not the placeholder,
     /// by path.
     ///