@@ -0,0 +1,42 @@
+---
+'@objectstack/spec': minor
+---
+
+feat(spec)!: `defineStack` refuses two entries of one stack's `functions` array that author the same `name`, naming the name and every index (#22902)
+
+Clause-②: no (narrowing)
+
+<!-- adr-0087: registered stack-functions-array-duplicate-name-refused -->
+
+**BREAKING**: an accept-set narrowing on a published authoring surface, shipped as `minor` under the launch-window convention for breaking changes.
+
+Functions are one flat namespace resolved by name: a hook's `handler`, an action's `target` and a flow `script` node's `config.function` all look a function up by its name. The `functions` **array** form could author one name twice, and nothing refused it. Measured on `main` at this change's base with `functions: [{ name: 'kc_a', handler: first }, { name: 'kc_a', handler: second }]`:
+
+- `objectstack validate` exited 0 (`valid: true`);
+- `objectstack build` exited 0 and shipped `[{ name: 'kc_a' }, { name: 'kc_a__2' }]`: the second entry went out under a suffixed internal ref the author never wrote and nothing references, and `kc_a` ran `first`;
+- a source boot (`objectstack serve`, no build) registered `kc_a` as `second` and dropped `first`, with no notice.
+
+So the same stack ran different code under `kc_a` depending on whether it was built. `composeStacks` already refused one name defined by two stacks (`STACK_COMPOSE_FUNCTION_CONFLICT`); this is the one-stack case.
+
+**What is refused.** `defineStack`'s cross-reference pass refuses the stack with its existing envelope (`STACK_CROSS_REFERENCE_INVALID`, status 422, `defineStack cross-reference validation failed (N issues):`), one finding per colliding name, naming the name and every index:
+
+```text
+✗ Function 'kc_a' is declared twice in the `functions` array: stack.functions[0] and stack.functions[1]. …
+```
+
+It runs in an object-less stack too, and every entry counts, byte-identical twins included. `objectstack validate`, `objectstack build` and a source boot all load the config through `defineStack`, so all three refuse it at load, printing that line: `objectstack validate --json` answers `valid: false` with `code: 'STACK_CROSS_REFERENCE_INVALID'` (exit 1), `objectstack build` exits 2, and `objectstack serve` exits 1 before the kernel boots. Like every cross-reference check it is skipped under `defineStack(…, { strict: false })`.
+
+**Unchanged.** The map form, which cannot author one name twice; an array whose names are distinct; the suffixed refs a build emits for an internal slot (`kc_a__2` beside `kc_a` is two names); and the cross-stack refusal in `composeStacks`.
+
+## FROM → TO
+
+| you wrote | write instead |
+|:--|:--|
+| `functions: [{ name: 'sync', handler: a }, { name: 'sync', handler: b }]` | `functions: [{ name: 'sync', handler: a }, { name: 'sync_backup', handler: b }]`, and point each hook, action or script node that meant `b` at `sync_backup` |
+| two entries that are the same function under one name | one entry: delete the other |
+
+**The one-line fix: give each `functions` array entry its own `name`, or merge the duplicates into one entry.**
+
+No D2 conversion rewrites it: which entry keeps the name, and what every caller of the other one should name instead, is the author's call. Its D3 record is the semantic entry `stack-functions-array-duplicate-name-refused` (protocol 18).
+
+**Who is affected, measured.** On `main` at this change's base, no example app, fixture or test authors one name twice in a `functions` array: the four example apps author the map form or none, and every array-form fixture under `packages/` names distinct entries. `objectstack validate --json` on `examples/app-crm`, `app-todo`, `app-showcase` and `app-multi-package` answers byte-for-byte as it did without the check, apart from the `duration` value. Deployed metadata and other repositories were not measured.
@@ -0,0 +1,41 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+import type { SemanticMigration } from '../../types.js';
+
+// #22902. An accept-set narrowing of the stack aggregate: two entries of one
+// stack's `functions` ARRAY that author the same `name` are refused by the
+// cross-reference pass, the one-stack sibling of the duplicate action-key
+// refusal and of `composeStacks`' cross-stack function-name refusal. No D2
+// conversion: which entry should own the name, and what the other one is
+// renamed to (with every hook, action and script node that reads it), is the
+// author's call.
+export const entry: SemanticMigration = {
+  id: 'stack-functions-array-duplicate-name-refused',
+  // No backticks in `surface` — build-upgrade-guide renders it inside a code
+  // span already, and a nested backtick would close it.
+  surface:
+    'stack.functions in the ARRAY form — two or more entries that author the same name, e.g. '
+    + "functions: [{ name: 'sync', handler: a }, { name: 'sync', handler: b }]",
+  replacement:
+    'One entry per name. Rename one of the colliding entries (and every hook handler, action target '
+    + 'and flow script node that should call it), or merge them into a single entry and delete the '
+    + 'other. The map form, which cannot author one name twice, is unchanged, and so is an array whose '
+    + 'names are distinct.',
+  reason:
+    'Functions are one flat namespace resolved by name: a hook handler, an action target and a flow '
+    + 'script node all look a function up by its name, and the engine registers each under that name. '
+    + 'The array form could author one name twice and nothing refused it, so the two entries diverged '
+    + 'silently and differently on each path. objectstack build exited 0 and shipped the second entry '
+    + 'under a suffixed internal ref the author never wrote and nothing references, so the name ran the '
+    + 'FIRST entry; a source boot registered the name as the SECOND entry and dropped the first, with no '
+    + 'notice. The same stack therefore ran different code under one name depending on whether it was '
+    + 'built. composeStacks already refused the same name across two stacks; the stack aggregate now '
+    + 'refuses it inside one stack, in the same cross-reference envelope as a duplicate action key. '
+    + 'Not convertible: which entry keeps the name is a fact only the author holds.',
+  acceptanceCriteria:
+    'os validate and os build load the stack without a STACK_CROSS_REFERENCE_INVALID refusal. A stack '
+    + 'that still repeats a name is refused at load, with one finding per colliding name that names the '
+    + 'name and every index (stack.functions[i] and stack.functions[j]). After renaming, check that '
+    + 'each hook, action and script node that calls the renamed function now names the entry it '
+    + 'means, rather than assuming the old resolution was the intended one.',
+};
@@ -0,0 +1,193 @@
+/**
+ * `defineStack` refuses two entries of one stack's `functions` ARRAY that
+ * author the same `name` — and only those.
+ *
+ * Functions are one flat namespace resolved by name (a hook's `handler`, an
+ * action's `target`, a flow `script` node's `config.function`), so one name
+ * can own one handler. Measured on main `7dbb89dc5` before the check existed,
+ * with `[{ name: 'kc_a', handler: first }, { name: 'kc_a', handler: second }]`:
+ *
+ * ```
+ * os validate --json                   : exit 0  valid: true
+ * os build → loadArtifactBundle        : exit 0  [{ name: 'kc_a' }, { name: 'kc_a__2' }]  kc_a → first
+ * source boot (os serve, no build)     : boots   kc_a → second, first dropped, no notice
+ * ```
+ *
+ * The map form cannot author one name twice (an object key is unique) and is
+ * never visited; the cross-stack case is `composeStacks`' own refusal
+ * (`STACK_COMPOSE_FUNCTION_CONFLICT`). This is the one-stack sibling of the
+ * duplicate action-key check, raised in the same cross-reference aggregate.
+ *
+ * Refusals assert the ADR-0112 envelope (`code` + `status`) and the named
+ * subjects of each finding — the colliding name and every index — rather than
+ * a bare `toThrow()`, which a refusal for any other reason would also satisfy.
+ * Every refusal fixture differs from an accepted CONTROL by one name.
+ */
+import { describe, it, expect } from 'vitest';
+import { defineStack } from './stack.zod';
+
+const manifest = {
+  id: 'com.example.dupfn',
+  name: 'duplicate-function-name-test',
+  version: '1.0.0',
+  type: 'app' as const,
+};
+
+// `as const` on the field type is load-bearing (see stack.test.ts).
+const probeItem = { name: 'probe_item', label: 'Probe Item', fields: { title: { type: 'text' as const } } };
+
+const first = () => 'first';
+const second = () => 'second';
+const third = () => 'third';
+
+interface Refusal {
+  name?: string;
+  code?: string;
+  status?: number;
+  issues?: readonly string[];
+  message: string;
+}
+
+/** The thrown refusal, or `null` when the stack is accepted. */
+function refusal(config: Parameters<typeof defineStack>[0]): Refusal | null {
+  try {
+    defineStack(config);
+    return null;
+  } catch (e) {
+    return e as Refusal;
+  }
+}
+
+function expectCrossReferenceEnvelope(r: Refusal | null, issueCount: number): asserts r is Refusal {
+  expect(r).not.toBeNull();
+  expect(r!.code).toBe('STACK_CROSS_REFERENCE_INVALID');
+  expect(r!.status).toBe(422);
+  expect(r!.issues).toHaveLength(issueCount);
+  expect(r!.message).toContain(
+    `defineStack cross-reference validation failed (${issueCount} issue${issueCount === 1 ? '' : 's'}):`,
+  );
+}
+
+/** The one finding naming `name`, which must name exactly `indices`. */
+function findingFor(r: Refusal, name: string, indices: number[]): string {
+  const found = (r.issues ?? []).filter((issue) => issue.startsWith(`Function '${name}' `));
+  expect(found, `exactly one finding for '${name}'`).toHaveLength(1);
+  const finding = found[0];
+  for (const i of indices) expect(finding).toContain(`stack.functions[${i}]`);
+  const named = [...finding.matchAll(/stack\.functions\[(\d+)\]/g)].map((m) => Number(m[1]));
+  expect(named, `the indices '${name}' names`).toEqual(indices);
+  // The finding reaches the message too, as one `✗` line.
+  expect(r.message).toContain(`  ✗ ${finding}`);
+  return finding;
+}
+
+describe('defineStack - duplicate name in one stack\'s `functions` array', () => {
+  it('refuses two entries authoring one name, naming the name and both indices', () => {
+    const r = refusal({
+      manifest,
+      objects: [probeItem],
+      functions: [{ name: 'kc_a', handler: first }, { name: 'kc_a', handler: second }],
+    });
+    expectCrossReferenceEnvelope(r, 1);
+    expect(r.name).toBe('StackCrossReferenceError');
+    const finding = findingFor(r, 'kc_a', [0, 1]);
+    expect(finding).toContain('declared twice');
+  });
+
+  it('refuses one finding per colliding name, each listing every index, and leaves a unique name alone', () => {
+    const r = refusal({
+      manifest,
+      objects: [probeItem],
+      functions: [
+        { name: 'kc_a', handler: first },
+        { name: 'kc_b', handler: second },
+        { name: 'kc_a', handler: third },
+        { name: 'kc_b', handler: second },
+        { name: 'kc_a', handler: first },
+        { name: 'kc_c', handler: third },
+      ],
+    });
+    expectCrossReferenceEnvelope(r, 2);
+    expect(findingFor(r, 'kc_a', [0, 2, 4])).toContain('declared 3 times');
+    expect(findingFor(r, 'kc_b', [1, 3])).toContain('declared twice');
+    expect(r.issues!.some((issue) => issue.includes("'kc_c'"))).toBe(false);
+  });
+
+  it('refuses byte-identical twins — two registrations under one name whatever they hold', () => {
+    const entry = { name: 'kc_twin', handler: first, effect: 'writes' as const };
+    const r = refusal({ manifest, objects: [probeItem], functions: [entry, { ...entry }] });
+    expectCrossReferenceEnvelope(r, 1);
+    findingFor(r, 'kc_twin', [0, 1]);
+  });
+
+  it('refuses in an object-less stack — the check needs no object to resolve against', () => {
+    const r = refusal({
+      manifest,
+      functions: [{ name: 'kc_a', handler: first }, { name: 'kc_a', handler: second }],
+    });
+    expectCrossReferenceEnvelope(r, 1);
+    findingFor(r, 'kc_a', [0, 1]);
+  });
+
+  it('refuses the lowered (string-ref) array form too, when it repeats a name', () => {
+    const r = refusal({
+      manifest,
+      objects: [probeItem],
+      functions: [{ name: 'kc_a', handler: 'kc_a' }, { name: 'kc_a', handler: 'kc_a' }],
+    });
+    expectCrossReferenceEnvelope(r, 1);
+    findingFor(r, 'kc_a', [0, 1]);
+  });
+
+  it('joins the existing aggregate: one envelope with the duplicate action-key finding', () => {
+    const act = (name: string) => ({ name, label: name, type: 'script' as const, target: 'noop' });
+    const r = refusal({
+      manifest,
+      objects: [probeItem],
+      actions: [act('dup_r'), act('dup_r')],
+      functions: [{ name: 'kc_a', handler: first }, { name: 'kc_a', handler: second }],
+    });
+    expectCrossReferenceEnvelope(r, 2);
+    findingFor(r, 'kc_a', [0, 1]);
+    expect(r.issues!.some((issue) => issue.startsWith("Action key 'global:dup_r' is declared twice"))).toBe(true);
+  });
+
+  it('is skipped under `strict: false`, like every other cross-reference check', () => {
+    expect(() => defineStack(
+      { manifest, objects: [probeItem], functions: [{ name: 'kc_a', handler: first }, { name: 'kc_a', handler: second }] },
+      { strict: false },
+    )).not.toThrow();
+  });
+});
+
+describe('defineStack - CONTROL: distinct names and the map form are accepted unchanged', () => {
+  it('accepts two distinct names in the array form, in order, with what each entry declared', () => {
+    const out = defineStack({
+      manifest,
+      objects: [probeItem],
+      functions: [{ name: 'kc_a', handler: first }, { name: 'kc_b', handler: second, effect: 'writes' }],
+    });
+    const fns = out.functions as Array<{ name: string; handler: unknown; effect?: string }>;
+    expect(fns.map((e) => e.name)).toEqual(['kc_a', 'kc_b']);
+    expect(fns.map((e) => typeof e.handler)).toEqual(['function', 'function']);
+    expect(fns.map((e) => e.effect)).toEqual([undefined, 'writes']);
+  });
+
+  it('accepts the map form, keys unchanged', () => {
+    const out = defineStack({
+      manifest,
+      objects: [probeItem],
+      functions: { kc_a: first, kc_b: { handler: second, effect: 'writes' } },
+    });
+    expect(Object.keys(out.functions as Record<string, unknown>)).toEqual(['kc_a', 'kc_b']);
+  });
+
+  it('accepts the suffixed internal refs a build emits — distinct names, not a duplicate', () => {
+    const out = defineStack({
+      manifest,
+      objects: [probeItem],
+      functions: [{ name: 'kc_a', handler: 'kc_a' }, { name: 'kc_a__2', handler: 'kc_a__2' }],
+    });
+    expect((out.functions as Array<{ name: string }>).map((e) => e.name)).toEqual(['kc_a', 'kc_a__2']);
+  });
+});
@@ -2229,6 +2229,59 @@ function collectDuplicateActionKeyErrors(config: ObjectStackDefinition): string[
   return errors;
 }
 
+/**
+ * Same-stack duplicate `functions` names in the ARRAY form (#22902) — one
+ * refusal line per colliding name, naming the name and every index.
+ *
+ * Functions live in one flat namespace resolved by name: a hook's `handler`,
+ * an action's `target` and a flow `script` node's `config.function` all look a
+ * function up by its name, and the engine registers each under that name
+ * (`registerFunction` is a plain `Map.set`). The map form cannot author one
+ * name twice — an object key is unique — so it is never visited. The array
+ * form can, and nothing refused it, so the two entries diverged silently and
+ * differently on each path. Measured on main `7dbb89dc5` with
+ * `[{ name: 'kc_a', handler: first }, { name: 'kc_a', handler: second }]`:
+ *
+ * - `objectstack build` exited 0 and shipped
+ *   `[{ name: 'kc_a' }, { name: 'kc_a__2' }]`: `lowerCallables` mints refs in
+ *   one namespace, so the second entry took a suffixed internal ref the author
+ *   never wrote and nothing references — `kc_a` ran `first`;
+ * - a source boot (no build) registered `kc_a` as `second` and dropped
+ *   `first`, with no notice (`collectBundleFunctionEntries` keys by name, last
+ *   wins).
+ *
+ * So the same stack ran different code under `kc_a` depending on whether it
+ * was built. {@link composeStacks} already refuses the cross-stack case
+ * (`composeFunctions`, `STACK_COMPOSE_FUNCTION_CONFLICT`); this is its
+ * one-stack sibling, in the aggregate beside the action-key check. Every entry
+ * counts, byte-identical twins included: two entries are two registrations
+ * under one name whatever they hold, and only one can own it.
+ */
+function collectDuplicateFunctionNameErrors(config: ObjectStackDefinition): string[] {
+  const functions = config.functions;
+  if (!Array.isArray(functions)) return [];
+
+  const indicesByName = new Map<string, number[]>();
+  for (const [i, entry] of functions.entries()) {
+    const list = indicesByName.get(entry.name) ?? [];
+    list.push(i);
+    indicesByName.set(entry.name, list);
+  }
+
+  const errors: string[] = [];
+  for (const [name, indices] of indicesByName) {
+    if (indices.length < 2) continue;
+    errors.push(
+      `Function '${name}' is declared ${indices.length === 2 ? 'twice' : `${indices.length} times`} ` +
+        `in the \`functions\` array: ${joinDeclarationOrigins(indices.map((i) => `stack.functions[${i}]`))}. ` +
+        `Functions are registered and resolved by name, so only one of these entries can own ` +
+        `'${name}' and the others would be silently renamed or dropped. Rename one of them, or ` +
+        `merge them into a single entry.`,
+    );
+  }
+  return errors;
+}
+
 /**
  * [ADR-0112 · #15963] The envelope every refusal `defineStack` raises shares:
  * `status: 422` — an unprocessable authored entity, not a server fault, the
@@ -2303,8 +2356,8 @@ abstract class StackRefusalError<TIssue = string> extends Error {
  * machine-readable in {@link StackCrossReferenceError.issues}, one entry per
  * finding, which is the structured form of what was previously only
  * newline-joined prose. The family is also WIDER than "undefined object": the
- * same aggregate carries the duplicate-action-key, global-`update`-action and
- * mapping `javascript`-transform findings, so a
+ * same aggregate carries the duplicate-action-key, duplicate-function-name,
+ * global-`update`-action and mapping `javascript`-transform findings, so a
  * `…_UNDEFINED_OBJECT` spelling would be false for those.
  *
  * ⭐ There are TWO raise sites since #18202, one per PASS, and they share this
@@ -2945,6 +2998,9 @@ function validateCrossReferences(
   // stack that declares two globals under one name collides on exactly the
   // same runtime key, and this check needs no object to resolve against.
   errors.push(...collectDuplicateActionKeyErrors(config));
+  // Same placement, same reason: two `functions` array entries under one name
+  // collide in the one function namespace whether or not there are objects.
+  errors.push(...collectDuplicateFunctionNameErrors(config));
   // Same placement, same reason: a global `operation: 'update'` action is
   // wrong whether or not the stack declares any objects.
   errors.push(...collectGlobalUpdateActionErrors(config));