@@ -0,0 +1,21 @@
+---
+"@objectstack/spec": patch
+---
+
+`collectFlowGraphs` no longer hands out a `FlowGraph` whose `edges` can hold a non-record — the sibling list #16752's repair did not reach (#18102).
+
+`FlowGraph.edges` is declared `readonly FlowEdgeParsed[]`. The walk forwarded it untouched, four lines from the node-side member filter the same walk has carried since #16752, and a nested region's edge list is admitted on `Array.isArray` alone — which proves the LIST and never its MEMBERS. A YAML `edges:` list item left empty deserialises to `null`, and a region its own schema refused is left RAW for `validateControlFlow` to name, so the producer handed out an array holding a member its own declared element type excludes. Measured on `main`:
+
+```
+collectFlowGraphs({ nodes: [start, loop{ body: { nodes: [], edges: [null] } }], edges: [] })
+  graph[1] scope="loop 'lp' body"  edges=[null]     declared readonly FlowEdgeParsed[]
+```
+
+- **The junk member is DROPPED, per list**, through the same one predicate the node side uses (`isRegionDict`), so the two lists the walk hands out cannot drift from each other. Copy-on-write per list: a well-formed flow is handed back the very same arrays.
+- ⭐ **The real edge beside it is still HANDED OUT**, and so is the node list. "No non-record members" is half a contract — a filter that emptied `edges`, or reached into `nodes`, would satisfy it. Both are pinned.
+- **This is a drop in the producer, not a refusal.** No authoring door's accept set moves: `FlowSchema.safeParse` still returns an envelope rather than throwing, the region `safeParse` refusal in `validateControlFlow` still owns and still reports the malformed region, and `FlowGraph.path` still indexes the RAW node list so a Zod issue stays anchored where the author wrote it. ⛔ Not a looser signature either — the declared element type is unchanged and is now true.
+- **Latent, not live — measured, and not for the reason the filing gave.** There are THREE `graph.edges` consumers on the tree, not two. The two in `packages/lint` coerce through `recordsOf` (#16910). The third is `packages/services/service-automation`'s registration pass, which reads `.id` / `.source` / `.target` straight off each member with no guard, and is shielded only by call ORDER — `validateControlFlow` refuses the malformed region a few frames earlier in `registerFlow`. So no throw is reachable today, by one belt more than was counted. After this change the declared type carries it, and the next consumer needs neither a coercion nor a call-order argument.
+- **`analyzeRegion` is not one of those consumers.** It throws a `TypeError` on a `null` / `undefined` edge member (measured), but nothing routes producer output into it: its in-repo callers hand it post-`safeParse` region data. It reads an edge list, it does not read `FlowGraph.edges`.
+- **No behaviour changes on well-formed metadata.** The only input whose handling moves is input whose declared type already said it could not exist.
+
+Clause-②: no
@@ -500,9 +500,10 @@ export function findRegionEntry(region: { nodes: FlowNodeParsed[]; edges?: FlowE
 
 /**
  * A dict — region-shaped enough to reach its `nodes` / `edges`, and the same
- * test a member of a node list must pass to be a node at all. One spelling for
- * both, so what {@link collectFlowGraphs} walks cannot drift from what it hands
- * out.
+ * test a member of a node list or an EDGE list must pass to be a node or an
+ * edge at all. One spelling for all three, so what {@link collectFlowGraphs}
+ * walks cannot drift from what it hands out, and the two lists it hands out
+ * cannot drift from each other.
  */
 function isRegionDict(v: unknown): v is Record<string, unknown> {
   return typeof v === 'object' && v !== null && !Array.isArray(v);
@@ -722,11 +723,25 @@ export interface FlowGraph {
    * item deserialises to `null` — and a region its own schema refused is left
    * RAW for {@link validateControlFlow} to name. The walk therefore drops a
    * non-record member rather than hand out an array that does not match this
-   * declared type (#16752). Only this array is narrowed: the schema refusal
-   * that owns the malformed region still fires, and {@link path} still indexes
-   * the RAW list, so a finding stays anchored where the author wrote it.
+   * declared type (#16752). Only the two handed-out arrays are narrowed: the
+   * schema refusal that owns the malformed region still fires, and
+   * {@link path} still indexes the RAW list, so a finding stays anchored where
+   * the author wrote it.
    */
   readonly nodes: readonly FlowNodeParsed[];
+  /**
+   * Every member is a record, for the reason {@link FlowGraph.nodes} states and
+   * by the same drop in the same walk. A nested region's edge list is admitted
+   * on `Array.isArray` alone, and `Array.isArray` proves the LIST, never its
+   * MEMBERS: an empty YAML `edges:` item deserialises to `null`, and a region
+   * its own schema refused is left RAW for {@link validateControlFlow} to name.
+   * So this array was forwarded with the producer's word about its members
+   * rather than a check, while its declared element type said it could not hold
+   * one. The walk drops a non-record member here too. Only the handed-out array
+   * is narrowed: the schema refusal that owns the malformed region still fires,
+   * and no consumer indexes this list positionally — a dropped member changes
+   * the index, never whether an edge was judged.
+   */
   readonly edges: readonly FlowEdgeParsed[];
 }
 
@@ -759,24 +774,36 @@ export function collectFlowGraphs(
     // author typed — `null` included. What is HANDED OUT and what is WALKED both
     // drop it, through the one predicate above.
     //
-    // Handed out (#16752): `FlowGraph.nodes` is declared `readonly
-    // FlowNodeParsed[]`, and an array whose members every caller must re-check
-    // is not that array. This list is one the walk picked up out of an open
-    // `z.record` config ITSELF — no caller ever held it, so no coercion at a
-    // call site can reach it. Identity is preserved when nothing is dropped.
+    // Handed out (#16752 for `nodes`, #18102 for `edges`): both are declared
+    // arrays of parsed records, and an array whose members every caller must
+    // re-check is not that array. BOTH lists are ones the walk picked up out of
+    // an open `z.record` config ITSELF — no caller ever held them, so no
+    // coercion at a call site can reach them. The node side was repaired first
+    // and the edge side was forwarded untouched for one list's worth of time;
+    // one filter per list, side by side, is what keeps that from recurring.
+    // Identity is preserved per list when nothing is dropped.
     //
     // Walked (#16134): skip a non-record rather than read `.config` off it —
     // this walk runs inside `FlowSchema`'s parse, where a thrown TypeError would
     // escape `safeParse`, which is why this is a skip and not a throw. The schema
     // refusal that owns the malformed region still fires, reached now where the
     // throw used to pre-empt it.
     const kept = nodes.filter((node) => isRegionDict(node));
-    graphs.push({ scope, path, nodes: kept.length === nodes.length ? nodes : kept, edges });
+    const keptEdges = edges.filter((edge) => isRegionDict(edge));
+    graphs.push({
+      scope,
+      path,
+      nodes: kept.length === nodes.length ? nodes : kept,
+      edges: keptEdges.length === edges.length ? edges : keptEdges,
+    });
     if (depth >= MAX_REGION_DEPTH) return;
     // Indexed over the RAW list, never `kept`: `path` anchors a Zod issue where
     // the author wrote the node, so dropping a member must not renumber the
     // siblings that outlive it. `Array.isArray` on the inner list below proves
     // the LIST, never its MEMBERS — the sentence removed from four lint readers.
+    // It stays a list test on purpose: the member test for both lists is the
+    // pair of filters above, run by the next depth's own `visit` on the way
+    // out, so neither list can be handed out on an `Array.isArray` alone.
     nodes.forEach((node, index) => {
       if (!isRegionDict(node)) return;
       for (const slot of regionSlotsOf(node)) {
 
@@ -388,4 +388,135 @@ describe('#4347 — collectFlowGraphs', () => {
       expect(collectFlowGraphs({ nodes: nodes as never, edges: [] })[0]!.nodes).toBe(nodes);
     });
   });
+
+  /**
+   * #18102 — the SAME guarantee for the other list the walk hands out.
+   *
+   * `FlowGraph.edges` is declared `readonly FlowEdgeParsed[]` and was pushed
+   * through untouched, four lines from the node-side filter #16752 added. A
+   * nested region's edge list is admitted on `Array.isArray` alone, and
+   * `Array.isArray` proves the LIST and never its MEMBERS — so a
+   * `body: { edges: [null] }`, which is what a YAML `edges:` item left empty
+   * deserialises to, became a graph whose `edges` held a `null` its own
+   * declared element type excludes.
+   *
+   * ## Why this is a describe of its own and not a shape of the one above
+   *
+   * The two lists are read by the same walk out of the same open `z.record`
+   * config, so nothing about the node-side pin could say the edge side was
+   * unguarded: it addresses `nodes`. That is the whole lesson of this pair —
+   * the repair landed on one of the two lists and the sibling beside it kept
+   * the producer's word about its members for one list's worth of time. A
+   * separate describe is what makes the second list ADDRESSABLE, the same
+   * argument `non-record-object-entry.test.ts` makes for writing its sweep over
+   * a table.
+   *
+   * ⛔ Latent, not live — and the pin does not claim otherwise. On the tree this
+   * landed against, the two `graph.edges` readers in `packages/lint` coerce
+   * through `recordsOf` (#16910) and `packages/services/service-automation`'s
+   * registration pass reaches its unguarded `graph.edges` loop only AFTER
+   * `validateControlFlow` has refused the malformed region. Belt, not braces:
+   * what is pinned here is that the declared element type is now TRUE, so the
+   * next consumer to read this list needs neither coercion nor a call-order
+   * argument. ⛔ The repair is a drop, never a looser signature, and never a new
+   * refusal — the accept set of every authoring door is unchanged.
+   */
+  describe('#18102 — a non-record edge member never reaches a returned graph', () => {
+    /** The same five shapes the node-side pin sweeps; `null` is the authored one. */
+    const NON_EDGES: readonly (readonly [string, unknown])[] = [
+      ['null', null],
+      ['undefined', undefined],
+      ['a string', 'x'],
+      ['a number', 42],
+      ['an array', []],
+    ];
+
+    const isRecord = (v: unknown): boolean => typeof v === 'object' && v !== null && !Array.isArray(v);
+
+    /**
+     * `depth` nested loop bodies, the innermost holding `junk` in its EDGE list
+     * beside one real edge and the two real nodes that edge connects. Depth 0 is
+     * the flow's own list: a caller could coerce that one, but `FlowGraph.edges`
+     * draws no depth distinction, so neither does the filter or this pin.
+     */
+    const nestedJunkEdge = (depth: number, junk: unknown) => {
+      let region: Record<string, unknown> = {
+        nodes: [{ ...gate, id: 'gate_in' }, { ...write, id: 'write_in' }],
+        edges: [junk, { id: 'b_in', source: 'gate_in', target: 'write_in', type: 'default' }],
+      };
+      for (let i = depth; i > 0; i--) {
+        region = { nodes: [loopWith(region, `lp${i}`)], edges: [] };
+      }
+      return { nodes: region.nodes as never, edges: region.edges as never };
+    };
+
+    describe.each(NON_EDGES)('with %s in the innermost edge list', (_label, junk) => {
+      // 0 is the flow's own list, 1 the shape the card reproduced, and 32 the
+      // depth ceiling — where `visit` pushes a graph and returns without ever
+      // walking its members, so the junk was handed out with nothing having
+      // looked at it.
+      it.each([0, 1, 32])('hands out only records at nesting %i', (depth) => {
+        const graphs = collectFlowGraphs(nestedJunkEdge(depth, junk));
+        expect(graphs.flatMap(g => g.edges).filter(e => !isRecord(e))).toEqual([]);
+      });
+
+      it('lets an unguarded consumer dereference every edge it was handed', () => {
+        // The defect stated as the consumer's own operation: `analyzeRegion` and
+        // the engine's registration pass both read `.id` / `.source` / `.target`
+        // straight off a member, which is what a declared element type is FOR.
+        // This arm is what `null` and `undefined` fail before the filter; the
+        // shape assertion above is what the other three fail.
+        const graphs = collectFlowGraphs(nestedJunkEdge(1, junk));
+        expect(() => graphs.flatMap(g => g.edges).map(e => `${e.id}:${e.source}→${e.target}`)).not.toThrow();
+      });
+
+      it('still hands out the real edge, and the node list, standing beside it', () => {
+        // Anti-vacuity, twice: the drop takes what cannot be read, not the list
+        // — and it is per list, so a guard that emptied `edges` or reached into
+        // `nodes` would pass the assertions above.
+        const innermost = collectFlowGraphs(nestedJunkEdge(1, junk)).at(-1)!;
+        expect(innermost.edges.map(e => e.id)).toEqual(['b_in']);
+        expect(innermost.nodes.map(n => n.id)).toEqual(['gate_in', 'write_in']);
+      });
+
+      it('lets `FlowSchema.safeParse` return an envelope rather than throw (#16134)', () => {
+        // This walk runs inside the parse, so the repair has to stay a drop; a
+        // throw here escapes `safeParse` instead of becoming an issue.
+        const result = FlowSchema.safeParse({
+          name: 'repro', label: 'Repro', type: 'schedule',
+          nodes: [
+            { id: 'start', type: 'start', label: 'Start' },
+            loopWith({ nodes: [{ ...gate, id: 'gate_in' }, { ...write, id: 'write_in' }], edges: [junk] }),
+          ],
+          edges: [],
+        });
+        expect(typeof result.success).toBe('boolean');
+      });
+    });
+
+    it('hands out no non-record edge for the shape the card reproduced', () => {
+      // Verbatim from the filing, which is also the minimal repro: an empty
+      // `nodes` list still descends (`Array.isArray([])` holds), so the region
+      // graph exists and its `edges` is the array under test.
+      const graphs = collectFlowGraphs({
+        nodes: [
+          { id: 'start', type: 'start', config: {} },
+          { id: 'lp', type: LOOP_NODE_TYPE, config: { collection: 'x', body: { nodes: [], edges: [null] } } },
+        ] as never,
+        edges: [],
+      });
+      expect(graphs.map(g => g.path)).toEqual([[], ['nodes', 1, 'config', 'body']]);
+      expect(graphs[1]!.edges).toEqual([]);
+    });
+
+    it('hands back the very same arrays when there is nothing to drop', () => {
+      // Copy-on-write per list, as the node side already was: a well-formed flow
+      // pays nothing for either guard.
+      const nodes = [{ ...gate }, { ...write }];
+      const edges = [{ id: 'b1', source: 'gate', target: 'write', type: 'default' }];
+      const graph = collectFlowGraphs({ nodes: nodes as never, edges: edges as never })[0]!;
+      expect(graph.edges).toBe(edges);
+      expect(graph.nodes).toBe(nodes);
+    });
+  });
 });