@@ -0,0 +1,22 @@
+---
+'@objectstack/spec': patch
+---
+
+fix(spec): `composeStacks` refuses a malformed `actions` with the ADR-0112 envelope instead of crashing in its action-key collision pass
+
+`composeStacks` checks the composed stacks for cross-stack action-key collisions before it binds each standalone action to its object. That check read every input's top-level `actions` entries, and every composed object's own `actions`, with no shape guard. On a hand-built input stack it therefore crashed before the bound-action merge could refuse the same input. `defineStack` already refuses these shapes at its own door, with or without `strict: false`, so a stack it built never reached this crash. Measured before this change:
+
+| malformed input stack | before | after |
+| :--- | :--- | :--- |
+| top-level `actions: [null]` or `[undefined]` | bare `TypeError` reading `objectName`, `code` and `status` both `undefined` | refused, `STACK_SCHEMA_INVALID`, `status: 422`, issue at `['actions', index]` |
+| an object's `actions: 5` (or `'abc'`, `{}`, `true`) | bare `TypeError: (obj.actions ?? []).entries is not a function` | refused, `STACK_SCHEMA_INVALID`, `status: 422`, issue at `['objects', i, 'actions']` |
+| an object's `actions: [null]` or `[undefined]` | bare `TypeError` reading `name` | refused, `STACK_SCHEMA_INVALID`, `status: 422`, issue at `['objects', i, 'actions', index]` |
+| two stacks that each carry a non-object top-level entry (`['x']`) | refused as `STACK_COMPOSE_ACTION_KEY_COLLISION` on the key `global:undefined` | refused, `STACK_SCHEMA_INVALID`, `status: 422`, one issue per entry |
+
+The collision check now skips anything that declares no action key: a non-object entry, and an object's `actions` that is not an array. It does not word a refusal of its own. Every such input still reaches the bound-action merge, whose existing guard gives the one refusal for this condition. The index in each issue path is the entry's index in the composed artifact. Nothing that used to be accepted is refused now, and nothing that used to be refused is accepted. Well-formed stacks compose exactly as before, and a real cross-stack collision is still refused with `STACK_COMPOSE_ACTION_KEY_COLLISION`, including one that sits beside a skipped entry.
+
+Fix: author every `actions` as an array of action definitions, or run each stack through strict `defineStack` to have the shape refused where it is written.
+
+No code is added to the ADR-0112 ledger and no export changes: `STACK_SCHEMA_INVALID` is already registered under `@objectstack/spec`.
+
+Clause-②: no
@@ -0,0 +1,190 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * `composeStacks` refuses a malformed `actions` with the ADR-0112 envelope,
+ * never a bare `TypeError` out of its action-key collision pass (#19816).
+ *
+ * ## What was wrong
+ *
+ * Step 6 of `composeStacks` (`collectComposedActionKeyCollisions`) walked
+ * every input's top-level `actions` and every composed object's own `actions`
+ * with no element-shape guard, and it runs BEFORE step 7, the bound-action
+ * merge whose guard (#19799) refuses exactly these shapes. So on a hand-built
+ * input the collision pass crashed first, `code` and `status` both
+ * `undefined`:
+ *
+ * - top-level `actions: [null]` / `[undefined]`: reading `objectName`;
+ * - an object's `actions: 5` / `'abc'` / `{}` / `true`:
+ *   `(obj.actions ?? []).entries is not a function`;
+ * - an object's `actions: [null]` / `[undefined]`: reading `name`.
+ *
+ * A non-object entry it could read (`'x'`) was keyed `global:undefined`, so
+ * two stacks each carrying one were refused as a cross-stack ACTION KEY
+ * COLLISION — the wrong code for a schema defect.
+ *
+ * ## What is pinned
+ *
+ * The pass skips what declares no key, and every such input reaches step 7,
+ * which answers it with its one refusal: `STACK_SCHEMA_INVALID`, `status:
+ * 422`, the zod issue at the composed artifact's own path. The last block is
+ * the control: well-formed stacks still compose, and a real cross-stack
+ * collision — including one sitting beside a skipped entry — is still
+ * refused with the collision code at the declaring stack's own index.
+ */
+import { describe, it, expect } from 'vitest';
+import { composeStacks } from './stack.zod';
+
+type Envelope = Error & {
+  code?: string;
+  status?: number;
+  issues?: ReadonlyArray<{ code?: string; path?: readonly PropertyKey[]; expected?: string } | string>;
+};
+
+/** The thrown value, or `null` when the composition is accepted. */
+function refusal(fn: () => unknown): Envelope | null {
+  try {
+    fn();
+    return null;
+  } catch (e) {
+    return e as Envelope;
+  }
+}
+
+const mf = (id: string) => ({ id, name: id.split('.').pop()!, version: '1.0.0', type: 'app' as const });
+
+const act = (name: string, extra: Record<string, unknown> = {}) =>
+  ({ name, label: name, type: 'script' as const, target: 'noop', ...extra });
+
+const obj = (name: string, extra: Record<string, unknown> = {}) => ({
+  name,
+  label: name,
+  fields: { title: { type: 'text' as const } },
+  ...extra,
+});
+
+/** Stack A — well-formed, one object and one global action. */
+const valid = () => ({ manifest: mf('com.example.a'), objects: [obj('a_item')], actions: [act('a_home')] });
+/** Stack B, hand-built, with the given top-level `actions`. */
+const withTop = (actions: unknown) => ({ manifest: mf('com.example.b'), objects: [obj('b_item')], actions });
+/** Stack B, hand-built, whose object `b_item` carries the given `actions`. */
+const withOwn = (actions: unknown) => ({ manifest: mf('com.example.b'), objects: [obj('b_item', { actions })] });
+
+const compose = (stacks: unknown[], options?: Record<string, unknown>) =>
+  composeStacks(stacks as never, options as never);
+
+function expectSchemaEnvelope(refused: Envelope | null, paths: PropertyKey[][], expected: 'array' | 'object'): void {
+  expect(refused).toBeInstanceOf(Error);
+  expect(refused).not.toBeInstanceOf(TypeError);
+  expect(refused?.code).toBe('STACK_SCHEMA_INVALID');
+  expect(refused?.status).toBe(422);
+  const issues = (refused?.issues ?? []) as ReadonlyArray<{ code?: string; path?: readonly PropertyKey[]; expected?: string }>;
+  expect(issues.map((issue) => issue.path)).toEqual(paths);
+  expect(issues.every((issue) => issue.code === 'invalid_type' && issue.expected === expected)).toBe(true);
+}
+
+// Stack A contributes one top-level action, so stack B's first entry sits at
+// composed index 1 — the index the artifact carries and the refusal names.
+const topEntries: Array<{ label: string; value: unknown }> = [
+  { label: 'null', value: null },
+  { label: 'undefined', value: undefined },
+  { label: 'a string', value: 'x' },
+  { label: 'a number', value: 5 },
+  { label: 'an array', value: [] },
+];
+
+describe('#19816 — a non-object top-level `actions` entry is refused with the envelope, not a TypeError', () => {
+  for (const row of topEntries) {
+    it(`entry ${row.label} is refused at ['actions', 1]`, () => {
+      const refused = refusal(() => compose([valid(), withTop([row.value])]));
+      expectSchemaEnvelope(refused, [['actions', 1]], 'object');
+      expect(refused?.message).toContain("'actions'");
+      expect(refused?.message).toContain('#1 (');
+    });
+  }
+
+  it('a malformed entry beside a well-formed one is refused at its own composed index', () => {
+    const refused = refusal(() => compose([valid(), withTop([act('b_home'), null])]));
+    expectSchemaEnvelope(refused, [['actions', 2]], 'object');
+  });
+
+  it("two stacks each carrying a non-object entry are a schema defect, NOT a 'global:undefined' key collision", () => {
+    const refused = refusal(() => compose([{ ...valid(), actions: ['x'] }, withTop(['x'])]));
+    expectSchemaEnvelope(refused, [['actions', 0], ['actions', 1]], 'object');
+    expect(refused?.message).not.toContain('global:undefined');
+  });
+});
+
+describe("#19816 — a malformed object's own `actions` is refused with the envelope, not a TypeError", () => {
+  const nonArrays: Array<{ label: string; value: unknown }> = [
+    { label: 'a number', value: 5 },
+    { label: 'a string', value: 'abc' },
+    { label: 'a plain object', value: {} },
+    { label: 'a boolean', value: true },
+  ];
+  for (const row of nonArrays) {
+    it(`\`actions\` as ${row.label} is refused at ['objects', 1, 'actions']`, () => {
+      const refused = refusal(() => compose([valid(), withOwn(row.value)]));
+      expectSchemaEnvelope(refused, [['objects', 1, 'actions']], 'array');
+      expect(refused?.message).toContain("object 'b_item'");
+    });
+  }
+
+  const entries: Array<{ label: string; value: unknown }> = [
+    { label: 'null', value: null },
+    { label: 'undefined', value: undefined },
+    { label: 'a string', value: 'x' },
+  ];
+  for (const row of entries) {
+    it(`entry ${row.label} is refused at ['objects', 1, 'actions', 0]`, () => {
+      const refused = refusal(() => compose([valid(), withOwn([row.value])]));
+      expectSchemaEnvelope(refused, [['objects', 1, 'actions', 0]], 'object');
+      expect(refused?.message).toContain("object 'b_item'");
+    });
+  }
+
+  it("under objectConflict 'override' and 'merge' the answer is the same envelope", () => {
+    expectSchemaEnvelope(
+      refusal(() => compose([valid(), withOwn(5)], { objectConflict: 'override' })),
+      [['objects', 1, 'actions']],
+      'array',
+    );
+    expectSchemaEnvelope(
+      refusal(() => compose([valid(), withOwn([null])], { objectConflict: 'merge' })),
+      [['objects', 1, 'actions', 0]],
+      'object',
+    );
+  });
+});
+
+describe('#19816 — the controls: well-formed stacks compose, and a real collision is still refused', () => {
+  it('a valid pair composes, every action carried', () => {
+    const composed = compose([valid(), withTop([act('b_home')])]);
+    expect(composed.actions?.map((a) => a.name)).toEqual(['a_home', 'b_home']);
+  });
+
+  it('a real cross-stack collision is still refused with the collision code', () => {
+    const refused = refusal(() => compose([valid(), withTop([act('a_home')])]));
+    expect(refused?.code).toBe('STACK_COMPOSE_ACTION_KEY_COLLISION');
+    expect(refused?.status).toBe(422);
+    expect(refused?.issues).toHaveLength(1);
+    expect(String(refused?.issues?.[0])).toContain("'global:a_home'");
+  });
+
+  it("the walk goes on past a skipped top-level entry — the collision names the declaring stack's own index", () => {
+    const refused = refusal(() => compose([valid(), withTop([null, act('a_home')])]));
+    expect(refused?.code).toBe('STACK_COMPOSE_ACTION_KEY_COLLISION');
+    expect(String(refused?.issues?.[0])).toContain('stack.actions[1]');
+  });
+
+  it("the walk goes on past a skipped embedded entry — an object's own collision is still found", () => {
+    const refused = refusal(() =>
+      compose([
+        { ...valid(), actions: [act('b_go', { objectName: 'b_item' })] },
+        withOwn([null, act('b_go')]),
+      ]),
+    );
+    expect(refused?.code).toBe('STACK_COMPOSE_ACTION_KEY_COLLISION');
+    expect(String(refused?.issues?.[0])).toContain("'b_item:b_go'");
+    expect(String(refused?.issues?.[0])).toContain("objects['b_item'].actions[1]");
+  });
+});
@@ -4381,6 +4381,16 @@ function mergeObjects(
  *
  * Runs BEFORE `mergeActionsIntoObjects` so the composed output's own echo is
  * not counted either. Returns one line per colliding key, in first-seen order.
+ *
+ * [ADR-0112 · #19816] Reads only what is shaped like an action. A non-object
+ * entry (`null`, `undefined`, a string, …) and an object's non-array `actions`
+ * declare no key, so they are SKIPPED here, never dereferenced into a bare
+ * `TypeError` and never keyed `global:undefined` (two such entries used to be
+ * reported as a cross-stack collision). Skipping loses nothing: the entry is
+ * still in the composed `actions` step 3 concatenated, and the object is the
+ * same composed object, so step 7's guard in `mergeActionsIntoObjects` refuses
+ * every one of them with its `STACK_SCHEMA_INVALID` / 422 envelope. That guard
+ * holds the one refusal for this condition; this pass does not word a second.
  * @internal
  */
 function collectComposedActionKeyCollisions(
@@ -4401,11 +4411,13 @@ function collectComposedActionKeyCollisions(
   };
 
   for (const [i, stack] of stacks.entries()) {
-    // A non-array `actions` never reaches the output: the concat pass drops it
-    // (and warns), so it declares nothing here either.
+    // An absent `actions` declares nothing. A present non-array one never
+    // reaches this pass: step 3 refuses it (`STACK_SCHEMA_INVALID`).
     const declared = (stack as Record<string, unknown>).actions;
     if (!Array.isArray(declared)) continue;
     for (const [j, action] of (declared as Action[]).entries()) {
+      // A non-object entry declares no key; step 7 refuses it (see above).
+      if (!isRecord(action)) continue;
       // Truthiness, not nullish: an empty-string `objectName` (type-legal;
       // refused by ActionSchema's regex only under strict parse) keys as
       // global here exactly as `collectDuplicateActionKeyErrors`,
@@ -4422,7 +4434,12 @@ function collectComposedActionKeyCollisions(
       // and skipping would hide exactly the collisions this walk exists for.
       throw new Error(`composeStacks internal error: no source stack recorded for composed object '${obj.name}'.`);
     }
-    for (const [j, action] of (obj.actions ?? []).entries()) {
+    // An absent `actions` declares nothing; a non-array one and a non-object
+    // entry declare no key either, and step 7 refuses both (see above).
+    const embedded: unknown = obj.actions;
+    if (!Array.isArray(embedded)) continue;
+    for (const [j, action] of (embedded as Action[]).entries()) {
+      if (!isRecord(action)) continue;
       note(obj.name, action.name, owner, `objects['${obj.name}'].actions[${j}]`);
     }
   }